@solidjs/signals 0.5.0 → 0.6.0

package/dist/prod.js

@@ -45,7 +45,7 @@ function schedule() {
   if (scheduled)
     return;
   scheduled = true;
-  if (!globalQueue.A)
+  if (!globalQueue.B)
     queueMicrotask(flush);
 }
 function notifyUnobserved() {
@@ -59,7 +59,7 @@ function notifyUnobserved() {
 var pureQueue = [];
 var Queue = class {
   k = null;
-  A = false;
+  B = false;
   g = [[], []];
   f = [];
   created = clock;
@@ -86,9 +86,9 @@ var Queue = class {
     }
   }
   flush() {
-    if (this.A)
+    if (this.B)
       return;
-    this.A = true;
+    this.B = true;
     try {
       this.run(EFFECT_PURE);
       incrementClock();
@@ -96,7 +96,7 @@ var Queue = class {
       this.run(EFFECT_RENDER);
       this.run(EFFECT_USER);
     } finally {
-      this.A = false;
+      this.B = false;
       Unobserved.length && notifyUnobserved();
     }
   }
@@ -162,15 +162,15 @@ function runQueue(queue, type) {
 var Transition = class _Transition {
   a = /* @__PURE__ */ new Map();
   t = /* @__PURE__ */ new Set();
-  Q = /* @__PURE__ */ new Set();
+  G = /* @__PURE__ */ new Set();
   W = /* @__PURE__ */ new Set();
-  I = false;
+  w = false;
   g = [[], []];
   p = /* @__PURE__ */ new Map();
-  E = [];
+  H = [];
   f = [];
   k = null;
-  A = false;
+  B = false;
   X = false;
   e = globalQueue;
   created = clock;
@@ -181,15 +181,15 @@ var Transition = class _Transition {
     }
   }
   enqueue(type, fn) {
-    this.E.push(fn);
+    this.H.push(fn);
     if (type)
       this.g[type - 1].push(fn);
     this.schedule();
   }
   run(type) {
     if (type === EFFECT_PURE) {
-      this.E.length && runQueue(this.E, type);
-      this.E = [];
+      this.H.length && runQueue(this.H, type);
+      this.H = [];
       return;
     } else if (this.g[type - 1].length) {
       const effects = this.g[type - 1];
@@ -201,9 +201,9 @@ var Transition = class _Transition {
     }
   }
   flush() {
-    if (this.A)
+    if (this.B)
       return;
-    this.A = true;
+    this.B = true;
     let currentTransition = ActiveTransition;
     ActiveTransition = this;
     try {
@@ -213,7 +213,7 @@ var Transition = class _Transition {
       ActiveTransition = currentTransition;
       finishTransition(this);
     } finally {
-      this.A = false;
+      this.B = false;
       ActiveTransition = currentTransition;
     }
   }
@@ -239,7 +239,7 @@ var Transition = class _Transition {
   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.E.push.apply(this.E, queue.E);
+    this.H.push.apply(this.H, queue.H);
     for (let i = 0; i < queue.f.length; i++) {
       const og = this.f.find((c) => c.e === queue.f[i].e);
       if (og)
@@ -252,13 +252,13 @@ var Transition = class _Transition {
     if (this.X)
       return;
     this.X = true;
-    if (!this.A)
+    if (!this.B)
       queueMicrotask(() => this.flush());
   }
   runTransition(fn, force = false) {
-    if (this.I) {
-      if (this.I instanceof _Transition)
-        return this.I.runTransition(fn, force);
+    if (this.w) {
+      if (this.w instanceof _Transition)
+        return this.w.runTransition(fn, force);
       if (!force)
         throw new Error("Transition already completed");
       fn();
@@ -266,12 +266,34 @@ var Transition = class _Transition {
     }
     ActiveTransition = this;
     try {
-      const result = fn();
-      const transition2 = ActiveTransition;
+      let result = fn();
+      let transition2 = ActiveTransition;
+      if (result?.next) {
+        (async function() {
+          let temp, value;
+          while (!(temp = result.next(value)).done) {
+            if (temp.value instanceof Promise) {
+              transition2.G.add(temp.value);
+              try {
+                value = await temp.value;
+              } finally {
+                while (transition2.w instanceof _Transition)
+                  transition2 = transition2.w;
+                transition2.G.delete(temp.value);
+              }
+              ActiveTransition = transition2;
+            } else
+              value = temp.value;
+          }
+          finishTransition(transition2);
+        })();
+      }
       if (result instanceof Promise) {
-        transition2.Q.add(result);
+        transition2.G.add(result);
         result.finally(() => {
-          transition2.Q.delete(result);
+          while (transition2.w instanceof _Transition)
+            transition2 = transition2.w;
+          transition2.G.delete(result);
           finishTransition(transition2);
         });
       }
@@ -348,7 +370,7 @@ function cloneQueue(queue, parent, clonedQueues) {
     },
     notify(node, type, flags) {
       node = node.e || node;
-      if (!clone.F || type & LOADING_BIT) {
+      if (!clone.I || type & LOADING_BIT) {
         type &= ~LOADING_BIT;
         ActiveTransition?.notify(node, LOADING_BIT, flags);
         if (!type)
@@ -389,10 +411,10 @@ function mergeTransitions(t1, t2) {
     c.j = t1;
     t1.W.add(c);
   });
-  t2.Q.forEach((p) => t1.Q.add(p));
+  t2.G.forEach((p) => t1.G.add(p));
   t2.t.forEach((n) => t1.t.add(n));
   t1.merge(t2);
-  t2.I = t1;
+  t2.w = t1;
 }
 function getTransitionSource(input) {
   return ActiveTransition && ActiveTransition.a.get(input) || input;
@@ -408,7 +430,7 @@ function initialDispose(node) {
   }
 }
 function finishTransition(transition2) {
-  if (transition2.I || transition2.X || transition2.Q.size || transition2.t.size)
+  if (transition2.w || transition2.X || transition2.G.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]);
@@ -431,15 +453,15 @@ function finishTransition(transition2) {
     Object.assign(source, clone);
     delete source.e;
     let current = clone.n;
-    if (current?.w === clone)
-      current.w = source;
+    if (current?.x === clone)
+      current.x = source;
     while (current?.k === clone) {
       current.k = source;
       current = current.n;
     }
     delete source.j;
   }
-  transition2.I = true;
+  transition2.w = true;
   for (const reset of transition2.W) {
     delete reset.j;
     reset();
@@ -464,10 +486,10 @@ var Owner = class {
   // See comment at the top of the file for an example of the _nextSibling traversal
   k = null;
   n = null;
-  w = null;
+  x = null;
   c = STATE_CLEAN;
   o = null;
-  x = defaultContext;
+  y = defaultContext;
   m = globalQueue;
   fa = 0;
   id = null;
@@ -479,15 +501,15 @@ var Owner = class {
   }
   append(child) {
     child.k = this;
-    child.w = this;
+    child.x = this;
     if (this.n)
-      this.n.w = child;
+      this.n.x = child;
     child.n = this.n;
     this.n = child;
     if (this.id != null && child.id == null)
       child.id = this.getNextChildId();
-    if (child.x !== this.x) {
-      child.x = { ...this.x, ...child.x };
+    if (child.y !== this.y) {
+      child.y = { ...this.y, ...child.y };
     }
     if (this.m)
       child.m = this.m;
@@ -495,7 +517,7 @@ var Owner = class {
   dispose(self = true) {
     if (this.c === STATE_DISPOSED)
       return;
-    let head = self ? this.w || this.k : this, current = this.n, next = null;
+    let head = self ? this.x || this.k : this, current = this.n, next = null;
     while (current && current.k === this) {
       current.dispose(true);
       next = current.n;
@@ -506,16 +528,16 @@ var Owner = class {
     if (self)
       this.R();
     if (current)
-      current.w = !self ? this : this.w;
+      current.x = !self ? this : this.x;
     if (head)
       head.n = current;
   }
   R() {
-    if (this.w)
-      this.w.n = null;
+    if (this.x)
+      this.x.n = null;
     this.k = null;
-    this.w = null;
-    this.x = defaultContext;
+    this.x = null;
+    this.y = defaultContext;
     this.c = STATE_DISPOSED;
     this.emptyDisposal();
   }
@@ -545,7 +567,7 @@ function getContext(context, owner = currentOwner) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  const value = hasContext(context, owner) ? owner.x[context.id] : context.defaultValue;
+  const value = hasContext(context, owner) ? owner.y[context.id] : context.defaultValue;
   if (isUndefined(value)) {
     throw new ContextNotFoundError();
   }
@@ -555,13 +577,13 @@ function setContext(context, value, owner = currentOwner) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  owner.x = {
-    ...owner.x,
+  owner.y = {
+    ...owner.y,
     [context.id]: isUndefined(value) ? context.defaultValue : value
   };
 }
 function hasContext(context, owner = currentOwner) {
-  return !isUndefined(owner?.x[context.id]);
+  return !isUndefined(owner?.y[context.id]);
 }
 function onCleanup(fn) {
   if (!currentOwner)
@@ -601,8 +623,8 @@ var Computation = class extends Owner {
   a = null;
   b = null;
   l;
-  J;
-  K;
+  L;
+  M;
   // Used in __DEV__ mode, hopefully removed in production
   la;
   // Using false is an optimization as an alternative to _equals: () => false
@@ -614,13 +636,13 @@ var Computation = class extends Owner {
   h = 0;
   /** Which flags raised by sources are handled, vs. being passed through. */
   ba = DEFAULT_FLAGS;
-  L = -1;
-  G = false;
+  N = -1;
+  J = false;
   j;
   e;
   constructor(initialValue, compute2, options) {
     super(options?.id, compute2 === null);
-    this.K = compute2;
+    this.M = compute2;
     this.c = compute2 ? STATE_DIRTY : STATE_CLEAN;
     this.h = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
     this.l = initialValue;
@@ -639,7 +661,7 @@ var Computation = class extends Owner {
     track(this);
     newFlags |= this.h & ~currentMask;
     if (this.h & ERROR_BIT) {
-      throw this.J;
+      throw this.L;
     } else {
       return this.l;
     }
@@ -654,11 +676,11 @@ var Computation = class extends Owner {
       if (clone !== this)
         return clone.read();
     }
-    if (this.K) {
-      if (this.h & ERROR_BIT && this.L <= clock)
+    if (this.M) {
+      if (this.h & ERROR_BIT && this.N <= clock)
         update(this);
       else
-        this.H();
+        this.K();
     }
     return this.ga();
   }
@@ -675,11 +697,11 @@ var Computation = class extends Owner {
       if (clone !== this)
         return clone.wait();
     }
-    if (this.K) {
-      if (this.h & ERROR_BIT && this.L <= clock)
+    if (this.M) {
+      if (this.h & ERROR_BIT && this.N <= clock)
         update(this);
       else
-        this.H();
+        this.K();
     }
     if ((notStale || this.h & UNINITIALIZED_BIT) && this.h & LOADING_BIT) {
       track(this);
@@ -702,15 +724,15 @@ var Computation = class extends Owner {
     this.aa === false || !this.aa(this.l, newValue));
     if (valueChanged) {
       this.l = newValue;
-      this.J = void 0;
+      this.L = void 0;
     }
     const changedFlagsMask = this.h ^ flags, changedFlags = changedFlagsMask & flags;
     this.h = flags;
-    this.L = clock + 1;
+    this.N = clock + 1;
     if (this.b) {
       for (let i = 0; i < this.b.length; i++) {
         if (valueChanged) {
-          this.b[i].y(STATE_DIRTY);
+          this.b[i].z(STATE_DIRTY);
         } else if (changedFlagsMask) {
           this.b[i].Z(changedFlagsMask, changedFlags);
         }
@@ -721,14 +743,14 @@ var Computation = class extends Owner {
   /**
    * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
    */
-  y(state, skipQueue) {
-    if (this.c >= state && !this.G)
+  z(state, skipQueue) {
+    if (this.c >= state && !this.J)
       return;
-    this.G = !!skipQueue;
+    this.J = !!skipQueue;
     this.c = state;
     if (this.b) {
       for (let i = 0; i < this.b.length; i++) {
-        this.b[i].y(STATE_CHECK, skipQueue);
+        this.b[i].z(STATE_CHECK, skipQueue);
       }
     }
   }
@@ -742,7 +764,7 @@ var Computation = class extends Owner {
     if (this.c >= STATE_DIRTY)
       return;
     if (mask & this.ba) {
-      this.y(STATE_DIRTY);
+      this.z(STATE_DIRTY);
       return;
     }
     if (this.c >= STATE_CHECK)
@@ -750,7 +772,7 @@ var Computation = class extends Owner {
     const prevFlags = this.h & mask;
     const deltaFlags = prevFlags ^ newFlags2;
     if (newFlags2 === prevFlags) ; else if (deltaFlags & prevFlags & mask) {
-      this.y(STATE_CHECK);
+      this.z(STATE_CHECK);
     } else {
       this.h ^= deltaFlags;
       if (this.b) {
@@ -760,13 +782,13 @@ var Computation = class extends Owner {
       }
     }
   }
-  M(error) {
+  D(error) {
     if (ActiveTransition && !this.e) {
       const clone = cloneGraph(this);
       if (clone !== this)
-        return clone.M(error);
+        return clone.D(error);
     }
-    this.J = error;
+    this.L = error;
     this.write(UNCHANGED, this.h & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
   }
   /**
@@ -776,8 +798,8 @@ var Computation = class extends Owner {
    *
    * This function will ensure that the value and states we read from the computation are up to date
    */
-  H() {
-    if (!this.K) {
+  K() {
+    if (!this.M) {
       return;
     }
     if (this.c === STATE_DISPOSED) {
@@ -790,7 +812,7 @@ var Computation = class extends Owner {
     if (this.c === STATE_CHECK) {
       for (let i = 0; i < this.a.length; i++) {
         const source = getTransitionSource(this.a[i]);
-        source.H();
+        source.K();
         observerFlags |= source.h & ~UNINITIALIZED_BIT;
         if (this.c === STATE_DIRTY) {
           break;
@@ -827,7 +849,7 @@ function track(computation) {
       newSources.push(computation);
     }
     if (updateCheck) {
-      updateCheck.l = computation.L > currentObserver.L;
+      updateCheck.l = computation.N > currentObserver.N;
     }
   }
 }
@@ -843,13 +865,13 @@ function update(node) {
     }
     node.dispose(false);
     node.emptyDisposal();
-    const result = compute(node, node.K, node);
+    const result = compute(node, node.M, node);
     node.write(result, newFlags, true);
   } catch (error) {
     if (error instanceof NotReadyError) {
       node.write(UNCHANGED, newFlags | LOADING_BIT | node.h & UNINITIALIZED_BIT);
     } else {
-      node.M(error);
+      node.D(error);
     }
   } finally {
     if (newSources) {
@@ -878,7 +900,7 @@ function update(node) {
     newSources = prevSources;
     newSourcesIndex = prevSourcesIndex;
     newFlags = prevFlags;
-    node.L = clock + 1;
+    node.N = clock + 1;
     node.c = STATE_CLEAN;
   }
 }
@@ -953,7 +975,7 @@ function runWithObserver(observer, run) {
         newFlags | LOADING_BIT | observer.h & UNINITIALIZED_BIT
       );
     } else {
-      observer.M(error);
+      observer.D(error);
     }
   } finally {
     if (newSources) {
@@ -998,28 +1020,28 @@ function compute(owner, fn, observer) {
 var Effect = class extends Computation {
   ca;
   _;
-  N;
+  O;
   da = false;
   $;
-  B;
+  C;
   constructor(initialValue, compute2, effect, error, options) {
     super(initialValue, compute2, options);
     this.ca = effect;
     this._ = error;
     this.$ = initialValue;
-    this.B = options?.render ? EFFECT_RENDER : EFFECT_USER;
-    if (this.B === EFFECT_RENDER) {
-      this.K = function(p) {
+    this.C = options?.render ? EFFECT_RENDER : EFFECT_USER;
+    if (this.C === EFFECT_RENDER) {
+      this.M = function(p) {
         return !this.e && clock > this.m.created && !(this.h & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
       };
     }
-    this.H();
-    !options?.defer && (this.B === EFFECT_USER ? this.m.enqueue(this.B, this.C.bind(this)) : this.C(this.B));
+    this.K();
+    !options?.defer && (this.C === EFFECT_USER ? this.m.enqueue(this.C, this.E.bind(this)) : this.E(this.C));
   }
   write(value, flags = 0) {
     if (this.c == STATE_DIRTY) {
       this.h = flags;
-      if (this.B === EFFECT_RENDER) {
+      if (this.C === EFFECT_RENDER) {
         this.m.notify(this, LOADING_BIT | ERROR_BIT, this.h);
       }
     }
@@ -1027,14 +1049,14 @@ var Effect = class extends Computation {
       return this.l;
     this.l = value;
     this.da = true;
-    this.J = void 0;
+    this.L = void 0;
     return value;
   }
-  y(state, skipQueue) {
+  z(state, skipQueue) {
     if (this.c >= state || skipQueue)
       return;
     if (this.c === STATE_CLEAN)
-      this.m.enqueue(this.B, this.C.bind(this));
+      this.m.enqueue(this.C, this.E.bind(this));
     this.c = state;
   }
   Z(mask, newFlags2) {
@@ -1042,21 +1064,21 @@ var Effect = class extends Computation {
       if (this.c >= STATE_DIRTY)
         return;
       if (mask & 3) {
-        this.y(STATE_DIRTY);
+        this.z(STATE_DIRTY);
         return;
       }
     }
     super.Z(mask, newFlags2);
   }
-  M(error) {
-    this.J = error;
+  D(error) {
+    this.L = error;
     this.m.notify(this, LOADING_BIT, 0);
     this.h = ERROR_BIT;
-    if (this.B === EFFECT_USER) {
+    if (this.C === EFFECT_USER) {
       try {
         return this._ ? this._(error, () => {
-          this.N?.();
-          this.N = void 0;
+          this.O?.();
+          this.O = void 0;
         }) : console.error(error);
       } catch (e) {
         error = e;
@@ -1071,18 +1093,18 @@ var Effect = class extends Computation {
     this.ca = void 0;
     this.$ = void 0;
     this._ = void 0;
-    this.N?.();
-    this.N = void 0;
+    this.O?.();
+    this.O = void 0;
     this.m.notify(this, ERROR_BIT | LOADING_BIT, 0);
     super.R();
   }
-  C(type) {
+  E(type) {
     if (type) {
       const effect = this.e || this;
       if (effect.da && effect.c !== STATE_DISPOSED) {
-        effect.N?.();
+        effect.O?.();
         try {
-          effect.N = effect.ca(effect.l, effect.$);
+          effect.O = effect.ca(effect.l, effect.$);
         } catch (e) {
           if (!effect.m.notify(effect, ERROR_BIT, ERROR_BIT))
             throw e;
@@ -1098,16 +1120,16 @@ var Effect = class extends Computation {
 var EagerComputation = class extends Computation {
   constructor(initialValue, compute2, options) {
     super(initialValue, compute2, options);
-    !options?.defer && this.H();
+    !options?.defer && this.K();
   }
-  y(state, skipQueue) {
-    if (this.c >= state && !this.G)
+  z(state, skipQueue) {
+    if (this.c >= state && !this.J)
       return;
-    if (!skipQueue && (this.c === STATE_CLEAN || this.c === STATE_CHECK && this.G))
-      this.m.enqueue(EFFECT_PURE, this.C.bind(this));
-    super.y(state, skipQueue);
+    if (!skipQueue && (this.c === STATE_CLEAN || this.c === STATE_CHECK && this.J))
+      this.m.enqueue(EFFECT_PURE, this.E.bind(this));
+    super.z(state, skipQueue);
   }
-  C() {
+  E() {
     this.c !== STATE_CLEAN && runTop(this);
   }
 };
@@ -1116,15 +1138,15 @@ var FirewallComputation = class extends Computation {
   constructor(compute2) {
     super(void 0, compute2);
   }
-  y(state, skipQueue) {
-    if (this.c >= state && !this.G)
+  z(state, skipQueue) {
+    if (this.c >= state && !this.J)
       return;
-    if (!skipQueue && (this.c === STATE_CLEAN || this.c === STATE_CHECK && this.G))
-      this.m.enqueue(EFFECT_PURE, this.C.bind(this));
-    super.y(state, true);
-    this.G = !!skipQueue;
+    if (!skipQueue && (this.c === STATE_CLEAN || this.c === STATE_CHECK && this.J))
+      this.m.enqueue(EFFECT_PURE, this.E.bind(this));
+    super.z(state, true);
+    this.J = !!skipQueue;
   }
-  C() {
+  E() {
     this.c !== STATE_CLEAN && runTop(this);
   }
 };
@@ -1139,22 +1161,156 @@ function runTop(node) {
   }
   for (let i = ancestors.length - 1; i >= 0; i--) {
     if (ancestors[i].c !== STATE_DISPOSED)
-      ancestors[i].H();
+      ancestors[i].K();
   }
 }
 
+// src/store/reconcile.ts
+function unwrap(value) {
+  return value?.[$TARGET]?.[STORE_NODE] ?? value;
+}
+function getOverrideValue(value, override, key) {
+  return override && key in override ? override[key] : value[key];
+}
+function getAllKeys(value, override, next) {
+  const keys = getKeys(value, override);
+  const nextKeys = Object.keys(next);
+  return Array.from(/* @__PURE__ */ new Set([...keys, ...nextKeys]));
+}
+function applyState(next, state, keyFn, all) {
+  const target = state?.[$TARGET];
+  if (!target)
+    return;
+  const previous = target[STORE_VALUE];
+  const override = target[STORE_OVERRIDE];
+  if (next === previous && !override)
+    return;
+  (target[STORE_LOOKUP] || storeLookup).set(next, target[$PROXY]);
+  target[STORE_VALUE] = next;
+  target[STORE_OVERRIDE] = void 0;
+  if (Array.isArray(previous)) {
+    let changed = false;
+    const prevLength = getOverrideValue(previous, override, "length");
+    if (next.length && prevLength && next[0] && keyFn(next[0]) != null) {
+      let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
+      for (start = 0, end = Math.min(prevLength, next.length); start < end && ((item = getOverrideValue(previous, override, start)) === next[start] || item && next[start] && keyFn(item) === keyFn(next[start])); start++) {
+        applyState(next[start], wrap(item, target), keyFn, all);
+      }
+      const temp = new Array(next.length), newIndices = /* @__PURE__ */ new Map();
+      for (end = prevLength - 1, newEnd = next.length - 1; end >= start && newEnd >= start && ((item = getOverrideValue(previous, override, end)) === next[newEnd] || item && next[newEnd] && keyFn(item) === keyFn(next[newEnd])); end--, newEnd--) {
+        temp[newEnd] = item;
+      }
+      if (start > newEnd || start > end) {
+        for (j = start; j <= newEnd; j++) {
+          changed = true;
+          target[STORE_NODE][j]?.write(wrap(next[j], target));
+        }
+        for (; j < next.length; j++) {
+          changed = true;
+          const wrapped = wrap(temp[j], target);
+          target[STORE_NODE][j]?.write(wrapped);
+          applyState(next[j], wrapped, keyFn, all);
+        }
+        changed && target[STORE_NODE][$TRACK]?.write(void 0);
+        prevLength !== next.length && target[STORE_NODE].length?.write(next.length);
+        return;
+      }
+      newIndicesNext = new Array(newEnd + 1);
+      for (j = newEnd; j >= start; j--) {
+        item = next[j];
+        keyVal = item ? keyFn(item) : item;
+        i = newIndices.get(keyVal);
+        newIndicesNext[j] = i === void 0 ? -1 : i;
+        newIndices.set(keyVal, j);
+      }
+      for (i = start; i <= end; i++) {
+        item = getOverrideValue(previous, override, i);
+        keyVal = item ? keyFn(item) : item;
+        j = newIndices.get(keyVal);
+        if (j !== void 0 && j !== -1) {
+          temp[j] = item;
+          j = newIndicesNext[j];
+          newIndices.set(keyVal, j);
+        }
+      }
+      for (j = start; j < next.length; j++) {
+        if (j in temp) {
+          const wrapped = wrap(temp[j], target);
+          target[STORE_NODE][j]?.write(wrapped);
+          applyState(next[j], wrapped, keyFn, all);
+        } else
+          target[STORE_NODE][j]?.write(wrap(next[j], target));
+      }
+      if (start < next.length)
+        changed = true;
+    } else if (prevLength && next.length) {
+      for (let i = 0, len = next.length; i < len; i++) {
+        const item = getOverrideValue(previous, override, i);
+        isWrappable(item) && applyState(next[i], wrap(item, target), keyFn, all);
+      }
+    }
+    if (prevLength !== next.length) {
+      changed = true;
+      target[STORE_NODE].length?.write(next.length);
+    }
+    changed && target[STORE_NODE][$TRACK]?.write(void 0);
+    return;
+  }
+  let nodes = target[STORE_NODE];
+  if (nodes) {
+    const tracked = nodes[$TRACK];
+    const keys = tracked || all ? getAllKeys(previous, override, next) : Object.keys(nodes);
+    for (let i = 0, len = keys.length; i < len; i++) {
+      const key = keys[i];
+      const node = nodes[key];
+      const previousValue = unwrap(getOverrideValue(previous, override, key));
+      let nextValue = unwrap(next[key]);
+      if (previousValue === nextValue)
+        continue;
+      if (!previousValue || !isWrappable(previousValue) || keyFn(previousValue) != null && keyFn(previousValue) !== keyFn(nextValue)) {
+        tracked?.write(void 0);
+        node?.write(isWrappable(nextValue) ? wrap(nextValue, target) : nextValue);
+      } else
+        applyState(nextValue, wrap(previousValue, target), keyFn, all);
+    }
+  }
+  if (nodes = target[STORE_HAS]) {
+    const keys = Object.keys(nodes);
+    for (let i = 0, len = keys.length; i < len; i++) {
+      nodes[keys[i]].write(keys[i] in next);
+    }
+  }
+}
+function reconcile(value, key, all = false) {
+  return (state) => {
+    if (state == null)
+      throw new Error("Cannot reconcile null or undefined state");
+    const keyFn = typeof key === "string" ? (item) => item[key] : key;
+    const eq = keyFn(state);
+    if (eq !== void 0 && keyFn(value) !== keyFn(state))
+      throw new Error("Cannot reconcile states with different identity");
+    applyState(value, state, keyFn, all);
+  };
+}
+
 // src/store/projection.ts
-function createProjection(fn, initialValue = {}) {
+function createProjection(fn, initialValue = {}, options) {
   let wrappedStore;
   const node = new FirewallComputation(() => {
-    storeSetter(wrappedStore, fn);
+    storeSetter(wrappedStore, (s) => {
+      const value = fn(s);
+      if (value !== s && value !== void 0) {
+        reconcile(value, options?.key || "id", options?.all)(s);
+      }
+    });
   });
   const wrappedMap = /* @__PURE__ */ new WeakMap();
   const traps = {
     ...storeTraps,
     get(target, property, receiver) {
       const o = getOwner();
-      (!o || o !== node) && node.wait();
+      const n = getTransitionSource(node);
+      (!o || o !== n) && n.wait();
       return storeTraps.get(target, property, receiver);
     }
   };
@@ -1396,8 +1552,8 @@ function storeSetter(store, fn) {
     Writing = prevWriting;
   }
 }
-function createStore(first, second) {
-  const derived = typeof first === "function", wrappedStore = derived ? createProjection(first, second) : wrap(first);
+function createStore(first, second, options) {
+  const derived = typeof first === "function", wrappedStore = derived ? createProjection(first, second, options) : wrap(first);
   return [wrappedStore, (fn) => storeSetter(wrappedStore, fn)];
 }
 function recursivelyNotify(state, lookup) {
@@ -1461,134 +1617,6 @@ function deep(store) {
   return store[$DEEP];
 }
 
-// src/store/reconcile.ts
-function unwrap(value) {
-  return value?.[$TARGET]?.[STORE_NODE] ?? value;
-}
-function getOverrideValue(value, override, key) {
-  return override && key in override ? override[key] : value[key];
-}
-function getAllKeys(value, override, next) {
-  const keys = getKeys(value, override);
-  const nextKeys = Object.keys(next);
-  return Array.from(/* @__PURE__ */ new Set([...keys, ...nextKeys]));
-}
-function applyState(next, state, keyFn, all) {
-  const target = state?.[$TARGET];
-  if (!target)
-    return;
-  const previous = target[STORE_VALUE];
-  const override = target[STORE_OVERRIDE];
-  if (next === previous && !override)
-    return;
-  (target[STORE_LOOKUP] || storeLookup).set(next, target[$PROXY]);
-  target[STORE_VALUE] = next;
-  target[STORE_OVERRIDE] = void 0;
-  if (Array.isArray(previous)) {
-    let changed = false;
-    const prevLength = getOverrideValue(previous, override, "length");
-    if (next.length && prevLength && next[0] && keyFn(next[0]) != null) {
-      let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
-      for (start = 0, end = Math.min(prevLength, next.length); start < end && ((item = getOverrideValue(previous, override, start)) === next[start] || item && next[start] && keyFn(item) === keyFn(next[start])); start++) {
-        applyState(next[start], wrap(item, target), keyFn, all);
-      }
-      const temp = new Array(next.length), newIndices = /* @__PURE__ */ new Map();
-      for (end = prevLength - 1, newEnd = next.length - 1; end >= start && newEnd >= start && ((item = getOverrideValue(previous, override, end)) === next[newEnd] || item && next[newEnd] && keyFn(item) === keyFn(next[newEnd])); end--, newEnd--) {
-        temp[newEnd] = item;
-      }
-      if (start > newEnd || start > end) {
-        for (j = start; j <= newEnd; j++) {
-          changed = true;
-          target[STORE_NODE][j]?.write(wrap(next[j], target));
-        }
-        for (; j < next.length; j++) {
-          changed = true;
-          const wrapped = wrap(temp[j], target);
-          target[STORE_NODE][j]?.write(wrapped);
-          applyState(next[j], wrapped, keyFn, all);
-        }
-        changed && target[STORE_NODE][$TRACK]?.write(void 0);
-        prevLength !== next.length && target[STORE_NODE].length?.write(next.length);
-        return;
-      }
-      newIndicesNext = new Array(newEnd + 1);
-      for (j = newEnd; j >= start; j--) {
-        item = next[j];
-        keyVal = item ? keyFn(item) : item;
-        i = newIndices.get(keyVal);
-        newIndicesNext[j] = i === void 0 ? -1 : i;
-        newIndices.set(keyVal, j);
-      }
-      for (i = start; i <= end; i++) {
-        item = getOverrideValue(previous, override, i);
-        keyVal = item ? keyFn(item) : item;
-        j = newIndices.get(keyVal);
-        if (j !== void 0 && j !== -1) {
-          temp[j] = item;
-          j = newIndicesNext[j];
-          newIndices.set(keyVal, j);
-        }
-      }
-      for (j = start; j < next.length; j++) {
-        if (j in temp) {
-          const wrapped = wrap(temp[j], target);
-          target[STORE_NODE][j]?.write(wrapped);
-          applyState(next[j], wrapped, keyFn, all);
-        } else
-          target[STORE_NODE][j]?.write(wrap(next[j], target));
-      }
-      if (start < next.length)
-        changed = true;
-    } else if (prevLength && next.length) {
-      for (let i = 0, len = next.length; i < len; i++) {
-        const item = getOverrideValue(previous, override, i);
-        isWrappable(item) && applyState(next[i], wrap(item, target), keyFn, all);
-      }
-    }
-    if (prevLength !== next.length) {
-      changed = true;
-      target[STORE_NODE].length?.write(next.length);
-    }
-    changed && target[STORE_NODE][$TRACK]?.write(void 0);
-    return;
-  }
-  let nodes = target[STORE_NODE];
-  if (nodes) {
-    const tracked = nodes[$TRACK];
-    const keys = tracked || all ? getAllKeys(previous, override, next) : Object.keys(nodes);
-    for (let i = 0, len = keys.length; i < len; i++) {
-      const key = keys[i];
-      const node = nodes[key];
-      const previousValue = unwrap(getOverrideValue(previous, override, key));
-      let nextValue = unwrap(next[key]);
-      if (previousValue === nextValue)
-        continue;
-      if (!previousValue || !isWrappable(previousValue) || keyFn(previousValue) != null && keyFn(previousValue) !== keyFn(nextValue)) {
-        tracked?.write(void 0);
-        node?.write(isWrappable(nextValue) ? wrap(nextValue, target) : nextValue);
-      } else
-        applyState(nextValue, wrap(previousValue, target), keyFn, all);
-    }
-  }
-  if (nodes = target[STORE_HAS]) {
-    const keys = Object.keys(nodes);
-    for (let i = 0, len = keys.length; i < len; i++) {
-      nodes[keys[i]].write(keys[i] in next);
-    }
-  }
-}
-function reconcile(value, key, all = false) {
-  return (state) => {
-    if (state == null)
-      throw new Error("Cannot reconcile null or undefined state");
-    const keyFn = typeof key === "string" ? (item) => item[key] : key;
-    const eq = keyFn(state);
-    if (eq !== void 0 && keyFn(value) !== keyFn(state))
-      throw new Error("Cannot reconcile states with different identity");
-    applyState(value, state, keyFn, all);
-  };
-}
-
 // src/store/utils.ts
 function snapshot(item, map, lookup) {
   let target, isArray, override, result, unwrapped, v;
@@ -1847,22 +1875,24 @@ function createAsync(compute2, value, options) {
       }
       let abort = false;
       onCleanup(() => abort = true);
-      const transition2 = ActiveTransition;
+      let transition2 = ActiveTransition;
       if (isPromise) {
         source.then(
           (value3) => {
             if (abort)
               return;
             if (transition2)
-              return transition2.runTransition(() => node.write(value3, 0, true), true);
+              return transition2.runTransition(() => {
+                node.write(value3, 0, true);
+              }, true);
             node.write(value3, 0, true);
           },
           (error) => {
             if (abort)
               return;
             if (transition2)
-              return transition2.runTransition(() => node.M(error), true);
-            node.M(error);
+              return transition2.runTransition(() => node.D(error), true);
+            node.D(error);
           }
         );
       } else {
@@ -1871,12 +1901,22 @@ function createAsync(compute2, value, options) {
             for await (let value3 of source) {
               if (abort)
                 return;
+              if (transition2)
+                return transition2.runTransition(() => {
+                  node.write(value3, 0, true);
+                  transition2 = null;
+                }, true);
               node.write(value3, 0, true);
             }
           } catch (error) {
             if (abort)
               return;
-            node.write(error, ERROR_BIT);
+            if (transition2)
+              return transition2.runTransition(() => {
+                node.D(error);
+                transition2 = null;
+              }, true);
+            node.D(error);
           }
         })();
       }
@@ -1892,7 +1932,7 @@ function createAsync(compute2, value, options) {
     }
     n.c = STATE_DIRTY;
     refreshing = true;
-    n.H();
+    n.K();
   };
   return read;
 }
@@ -1934,55 +1974,56 @@ function resolve(fn) {
     });
   });
 }
-function tryCatch(fn) {
-  try {
-    const v = fn();
-    if (v instanceof Promise) {
-      return v.then(
-        (v2) => [void 0, v2],
-        (e) => {
-          if (e instanceof NotReadyError)
-            throw e;
-          return [e];
-        }
-      );
-    }
-    return [void 0, v];
-  } catch (e) {
-    if (e instanceof NotReadyError)
-      throw e;
-    return [e];
-  }
-}
-function createOptimistic(initial) {
-  const node = new Computation(initial, null);
-  const reset = () => node.write(initial);
+function createPending() {
+  const node = new Computation(false, null);
+  const reset = () => node.write(false);
   function write(v) {
     if (!ActiveTransition)
-      throw new Error("createOptimistic can only be updated inside a transition");
+      return v;
     ActiveTransition.addOptimistic(reset);
     queueMicrotask(() => reset.j && node.write(v));
   }
-  return [node.read.bind(node), write];
+  function read() {
+    node.read();
+    return !ActiveTransition;
+  }
+  return [read, write];
 }
-function createOptimisticStore(first, second) {
+function useTransition() {
+  const [pending, setPending] = createPending();
+  function start(fn) {
+    transition((resume) => {
+      setPending(true);
+      return fn(resume);
+    });
+  }
+  return [pending, start];
+}
+function createOptimistic(first, second, options) {
   let store, setStore;
   if (typeof first === "function") {
     [store, setStore] = createStore((s) => {
       const value = first(s);
       if (!ActiveTransition)
         return value;
+      ActiveTransition.addOptimistic(reset);
     }, {});
   } else
     [store, setStore] = createStore(first);
-  const reset = () => setStore(() => typeof first === "function" ? first(second) : first);
+  const reset = () => setStore(
+    (s) => reconcile(
+      { value: typeof first === "function" ? first(second) : first },
+      options?.key || "id",
+      options?.all
+    )(s)
+  );
   function write(v) {
     if (!ActiveTransition)
       throw new Error("createOptimistic can only be updated inside a transition");
     ActiveTransition.addOptimistic(reset);
     queueMicrotask(() => reset.j && setStore(v));
   }
-  return [() => store.value, write];
+  return [store, write];
 }
 
 // src/map.ts
@@ -1992,11 +2033,11 @@ function mapArray(list, map, options) {
     S: new Owner(),
     q: 0,
     ia: list,
-    D: [],
-    O: map,
+    F: [],
+    P: map,
     i: [],
     d: [],
-    P: keyFn,
+    Q: keyFn,
     r: keyFn || options?.keyed === false ? [] : void 0,
     s: map.length > 1 ? [] : void 0,
     T: options?.fallback
@@ -2010,23 +2051,23 @@ function updateKeyedMap() {
     let i, j, mapper = this.r ? () => {
       this.r[j] = new Computation(newItems[j], null, pureOptions);
       this.s && (this.s[j] = new Computation(j, null, pureOptions));
-      return this.O(
+      return this.P(
         Computation.prototype.read.bind(this.r[j]),
         this.s ? Computation.prototype.read.bind(this.s[j]) : void 0
       );
     } : this.s ? () => {
       const item = newItems[j];
       this.s[j] = new Computation(j, null, pureOptions);
-      return this.O(() => item, Computation.prototype.read.bind(this.s[j]));
+      return this.P(() => item, Computation.prototype.read.bind(this.s[j]));
     } : () => {
       const item = newItems[j];
-      return this.O(() => item);
+      return this.P(() => item);
     };
     if (newLen === 0) {
       if (this.q !== 0) {
         this.S.dispose(false);
         this.d = [];
-        this.D = [];
+        this.F = [];
         this.i = [];
         this.q = 0;
         this.r && (this.r = []);
@@ -2044,17 +2085,17 @@ function updateKeyedMap() {
         this.d[0].dispose();
       this.i = new Array(newLen);
       for (j = 0; j < newLen; j++) {
-        this.D[j] = newItems[j];
+        this.F[j] = newItems[j];
         this.i[j] = compute(this.d[j] = new Owner(), mapper, null);
       }
       this.q = newLen;
     } else {
       let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.r ? new Array(newLen) : void 0, tempIndexes = this.s ? new Array(newLen) : void 0;
-      for (start = 0, end = Math.min(this.q, newLen); start < end && (this.D[start] === newItems[start] || this.r && compare(this.P, this.D[start], newItems[start])); start++) {
+      for (start = 0, end = Math.min(this.q, newLen); start < end && (this.F[start] === newItems[start] || this.r && compare(this.Q, this.F[start], newItems[start])); start++) {
         if (this.r)
           this.r[start].write(newItems[start]);
       }
-      for (end = this.q - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.D[end] === newItems[newEnd] || this.r && compare(this.P, this.D[end], newItems[newEnd])); end--, newEnd--) {
+      for (end = this.q - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.F[end] === newItems[newEnd] || this.r && compare(this.Q, this.F[end], newItems[newEnd])); end--, newEnd--) {
         temp[newEnd] = this.i[end];
         tempNodes[newEnd] = this.d[end];
         tempRows && (tempRows[newEnd] = this.r[end]);
@@ -2064,14 +2105,14 @@ function updateKeyedMap() {
       newIndicesNext = new Array(newEnd + 1);
       for (j = newEnd; j >= start; j--) {
         item = newItems[j];
-        key = this.P ? this.P(item) : item;
+        key = this.Q ? this.Q(item) : item;
         i = newIndices.get(key);
         newIndicesNext[j] = i === void 0 ? -1 : i;
         newIndices.set(key, j);
       }
       for (i = start; i <= end; i++) {
-        item = this.D[i];
-        key = this.P ? this.P(item) : item;
+        item = this.F[i];
+        key = this.Q ? this.Q(item) : item;
         j = newIndices.get(key);
         if (j !== void 0 && j !== -1) {
           temp[j] = this.i[i];
@@ -2100,7 +2141,7 @@ function updateKeyedMap() {
         }
       }
       this.i = this.i.slice(0, this.q = newLen);
-      this.D = newItems.slice(0);
+      this.F = newItems.slice(0);
     }
   });
   return this.i;
@@ -2109,9 +2150,9 @@ function repeat(count, map, options) {
   return updateRepeat.bind({
     S: new Owner(),
     q: 0,
-    z: 0,
+    A: 0,
     ja: count,
-    O: map,
+    P: map,
     d: [],
     i: [],
     ka: options?.from,
@@ -2139,20 +2180,20 @@ function updateRepeat() {
       return;
     }
     const to = from + newLen;
-    const prevTo = this.z + this.q;
+    const prevTo = this.A + this.q;
     if (this.q === 0 && this.d[0])
       this.d[0].dispose();
     for (let i = to; i < prevTo; i++)
-      this.d[i - this.z].dispose();
-    if (this.z < from) {
-      let i = this.z;
+      this.d[i - this.A].dispose();
+    if (this.A < from) {
+      let i = this.A;
       while (i < from && i < this.q)
         this.d[i++].dispose();
-      this.d.splice(0, from - this.z);
-      this.i.splice(0, from - this.z);
-    } else if (this.z > from) {
-      let i = prevTo - this.z - 1;
-      let difference = this.z - from;
+      this.d.splice(0, from - this.A);
+      this.i.splice(0, from - this.A);
+    } else if (this.A > from) {
+      let i = prevTo - this.A - 1;
+      let difference = this.A - from;
       this.d.length = this.i.length = newLen;
       while (i >= difference) {
         this.d[i] = this.d[i - difference];
@@ -2162,7 +2203,7 @@ function updateRepeat() {
       for (let i2 = 0; i2 < difference; i2++) {
         this.i[i2] = compute(
           this.d[i2] = new Owner(),
-          () => this.O(i2 + from),
+          () => this.P(i2 + from),
           null
         );
       }
@@ -2170,12 +2211,12 @@ function updateRepeat() {
     for (let i = prevTo; i < to; i++) {
       this.i[i - from] = compute(
         this.d[i - from] = new Owner(),
-        () => this.O(i),
+        () => this.P(i),
         null
       );
     }
     this.i = this.i.slice(0, newLen);
-    this.z = from;
+    this.A = from;
     this.q = newLen;
   });
   return this.i;
@@ -2254,12 +2295,12 @@ var ConditionalQueue = class extends Queue {
   }
 };
 var CollectionQueue = class extends Queue {
-  F;
+  I;
   d = /* @__PURE__ */ new Set();
   u = new Computation(false, null, { pureWrite: true });
   constructor(type) {
     super();
-    this.F = type;
+    this.I = type;
   }
   run(type) {
     if (!type || this.u.read())
@@ -2269,9 +2310,9 @@ var CollectionQueue = class extends Queue {
   notify(node, type, flags) {
     if (ActiveTransition && ActiveTransition.p.has(this))
       return ActiveTransition.p.get(this).notify(node, type, flags);
-    if (!(type & this.F))
+    if (!(type & this.I))
       return super.notify(node, type, flags);
-    if (flags & this.F) {
+    if (flags & this.I) {
       this.d.add(node);
       if (this.d.size === 1)
         this.u.write(true);
@@ -2280,11 +2321,11 @@ var CollectionQueue = class extends Queue {
       if (this.d.size === 0)
         this.u.write(false);
     }
-    type &= ~this.F;
+    type &= ~this.I;
     return type ? super.notify(node, type, flags) : true;
   }
   merge(queue) {
-    queue.d.forEach((n) => this.notify(n, this.F, this.F));
+    queue.d.forEach((n) => this.notify(n, this.I, this.I));
     super.merge(queue);
   }
 };
@@ -2326,13 +2367,13 @@ function createSuspense(fn, fallback) {
 function createErrorBoundary(fn, fallback) {
   return createCollectionBoundary(ERROR_BIT, fn, (queue) => {
     let node = getTransitionSource(queue.d.values().next().value);
-    return fallback(node.J, () => {
+    return fallback(node.L, () => {
       incrementClock();
       for (let node2 of queue.d) {
         if (ActiveTransition && !node2.e)
           node2 = cloneGraph(node2);
         node2.c = STATE_DIRTY;
-        node2.m?.enqueue(node2.B, node2.C.bind(node2));
+        node2.m?.enqueue(node2.C, node2.E.bind(node2));
       }
     });
   });
@@ -2392,4 +2433,4 @@ function flattenArray(children, results = [], options) {
   return needsUnwrap;
 }
 
-export { $PROXY, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, SUPPORTS_PROXY, createAsync, createBoundary, createContext, createEffect, createErrorBoundary, createMemo, createOptimistic, createOptimisticStore, createProjection, createRenderEffect, createRoot, createSignal, createStore, createSuspense, deep, flatten, flush, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, runWithObserver, runWithOwner, setContext, snapshot, transition, tryCatch, untrack };
+export { $PROXY, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, SUPPORTS_PROXY, createAsync, createBoundary, createContext, createEffect, createErrorBoundary, createMemo, createOptimistic, createProjection, createRenderEffect, createRoot, createSignal, createStore, createSuspense, deep, flatten, flush, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, runWithObserver, runWithOwner, setContext, snapshot, transition, untrack, useTransition };