@solidjs/signals 0.6.3 → 0.7.0

package/dist/prod.js

@@ -45,13 +45,13 @@ function schedule() {
   if (scheduled)
     return;
   scheduled = true;
-  if (!globalQueue.A)
+  if (!globalQueue.B)
     queueMicrotask(flush);
 }
 function notifyUnobserved() {
   for (let i = 0; i < Unobserved.length; i++) {
     const source = Unobserved[i];
-    if (!source.b || !source.b.length)
+    if (!source.c || !source.c.length)
       Unobserved[i].ea?.();
   }
   Unobserved = [];
@@ -59,7 +59,7 @@ function notifyUnobserved() {
 var pureQueue = [];
 var Queue = class {
   k = null;
-  A = false;
+  B = false;
   g = [[], []];
   f = [];
   created = clock;
@@ -84,9 +84,9 @@ var Queue = class {
     }
   }
   flush() {
-    if (this.A)
+    if (this.B)
       return;
-    this.A = true;
+    this.B = true;
     try {
       this.run(EFFECT_PURE);
       incrementClock();
@@ -94,19 +94,19 @@ var Queue = class {
       this.run(EFFECT_RENDER);
       this.run(EFFECT_USER);
     } finally {
-      this.A = false;
+      this.B = false;
       Unobserved.length && notifyUnobserved();
     }
   }
   addChild(child) {
-    if (ActiveTransition && ActiveTransition.r.has(this))
-      return ActiveTransition.r.get(this).addChild(child);
+    if (ActiveTransition && ActiveTransition.G.has(this))
+      return ActiveTransition.G.get(this).addChild(child);
     this.f.push(child);
     child.k = this;
   }
   removeChild(child) {
-    if (ActiveTransition && ActiveTransition.r.has(this))
-      return ActiveTransition.r.get(this).removeChild(child);
+    if (ActiveTransition && ActiveTransition.G.has(this))
+      return ActiveTransition.G.get(this).removeChild(child);
     const index = this.f.indexOf(child);
     if (index >= 0) {
       this.f.splice(index, 1);
@@ -122,7 +122,7 @@ var Queue = class {
     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.e === queue.f[i].e);
+      const og = this.f.find((c) => c.d === queue.f[i].d);
       if (og)
         og.merge(queue.f[i]);
       else
@@ -141,12 +141,12 @@ function removeSourceObservers(node, index) {
   let swap;
   for (let i = index; i < node.a.length; i++) {
     source = getTransitionSource(node.a[i]);
-    if (source.b) {
-      if ((swap = source.b.indexOf(node)) !== -1) {
-        source.b[swap] = source.b[source.b.length - 1];
-        source.b.pop();
+    if (source.c) {
+      if ((swap = source.c.indexOf(node)) !== -1) {
+        source.c[swap] = source.c[source.c.length - 1];
+        source.c.pop();
       }
-      if (!source.b.length)
+      if (!source.c.length)
         Unobserved.push(source);
     }
   }
@@ -159,33 +159,33 @@ var Transition = class _Transition {
   a = /* @__PURE__ */ new Map();
   s = /* @__PURE__ */ new Set();
   H = /* @__PURE__ */ new Set();
-  W = /* @__PURE__ */ new Set();
-  u = false;
+  I = /* @__PURE__ */ new Set();
+  D = false;
   g = [[], []];
-  r = /* @__PURE__ */ new Map();
-  I = [];
+  G = /* @__PURE__ */ new Map();
+  J = [];
   f = [];
   k = null;
-  A = false;
-  X = false;
-  e = globalQueue;
+  B = false;
+  Y = false;
+  d = globalQueue;
   created = clock;
   constructor() {
-    this.r.set(globalQueue, this);
+    this.G.set(globalQueue, this);
     for (const child of globalQueue.f) {
-      cloneQueue(child, this, this.r);
+      cloneQueue(child, this, this);
     }
   }
   enqueue(type, fn) {
-    this.I.push(fn);
+    this.J.push(fn);
     if (type)
       this.g[type - 1].push(fn);
     this.schedule();
   }
   run(type) {
     if (type === EFFECT_PURE) {
-      this.I.length && runQueue(this.I, type);
-      this.I = [];
+      this.J.length && runQueue(this.J, type);
+      this.J = [];
       return;
     } else if (this.g[type - 1].length) {
       const effects = this.g[type - 1];
@@ -197,19 +197,19 @@ var Transition = class _Transition {
     }
   }
   flush() {
-    if (this.A)
+    if (this.B)
       return;
-    this.A = true;
+    this.B = true;
     let currentTransition = ActiveTransition;
     ActiveTransition = this;
     try {
       this.run(EFFECT_PURE);
       incrementClock();
-      this.X = false;
+      this.Y = false;
       ActiveTransition = currentTransition;
       finishTransition(this);
     } finally {
-      this.A = false;
+      this.B = false;
       ActiveTransition = currentTransition;
     }
   }
@@ -235,9 +235,9 @@ 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.I.push.apply(this.I, queue.I);
+    this.J.push.apply(this.J, queue.J);
     for (let i = 0; i < queue.f.length; i++) {
-      const og = this.f.find((c) => c.e === queue.f[i].e);
+      const og = this.f.find((c) => c.d === queue.f[i].d);
       if (og)
         og.merge(queue.f[i]);
       else
@@ -245,16 +245,16 @@ var Transition = class _Transition {
     }
   }
   schedule() {
-    if (this.X)
+    if (this.Y)
       return;
-    this.X = true;
-    if (!this.A)
+    this.Y = true;
+    if (!this.B)
       queueMicrotask(() => this.flush());
   }
   runTransition(fn, force = false) {
-    if (this.u) {
-      if (this.u instanceof _Transition)
-        return this.u.runTransition(fn, force);
+    if (this.D) {
+      if (this.D instanceof _Transition)
+        return this.D.runTransition(fn, force);
       if (!force)
         throw new Error("Transition already completed");
       fn();
@@ -273,8 +273,7 @@ var Transition = class _Transition {
               try {
                 value = await temp.value;
               } finally {
-                while (transition2.u instanceof _Transition)
-                  transition2 = transition2.u;
+                transition2 = latestTransition(transition2);
                 transition2.H.delete(temp.value);
               }
               ActiveTransition = transition2;
@@ -288,8 +287,7 @@ var Transition = class _Transition {
       if (result instanceof Promise) {
         transition2.H.add(result);
         result.finally(() => {
-          while (transition2.u instanceof _Transition)
-            transition2 = transition2.u;
+          transition2 = latestTransition(transition2);
           transition2.H.delete(result);
           ActiveTransition = null;
           finishTransition(transition2);
@@ -308,14 +306,14 @@ var Transition = class _Transition {
       return;
     }
     fn.j = this;
-    this.W.add(fn);
+    this.I.add(fn);
   }
 };
 function transition(fn) {
   let t = new Transition();
   queueMicrotask(() => t.runTransition(() => fn((fn2) => t.runTransition(fn2))));
 }
-function cloneGraph(node) {
+function cloneGraph(node, optimistic) {
   if (node.j) {
     if (node.j !== ActiveTransition) {
       mergeTransitions(node.j, ActiveTransition);
@@ -327,50 +325,60 @@ function cloneGraph(node) {
   Object.assign(clone, node, {
     n: null,
     m: null,
-    b: null,
+    c: null,
     a: node.a ? [...node.a] : null,
-    e: node
+    d: node,
+    I: !!optimistic
   });
+  delete clone.T;
   ActiveTransition.a.set(node, clone);
   node.j = ActiveTransition;
-  if (node.a) {
+  if (!optimistic && node.a) {
     for (let i = 0; i < node.a.length; i++)
-      node.a[i].b.push(clone);
+      node.a[i].c.push(clone);
   }
-  if (node.b) {
-    clone.b = [];
-    for (let i = 0, length = node.b.length; i < length; i++) {
-      !node.b[i].e && clone.b.push(cloneGraph(node.b[i]));
+  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));
     }
   }
   return clone;
 }
+function latestTransition(t) {
+  while (t.D instanceof Transition)
+    t = t.D;
+  return t;
+}
 function replaceSourceObservers(node, transition2) {
   let source;
+  let transitionSource;
   let swap;
   for (let i = 0; i < node.a.length; i++) {
-    source = transition2.a.get(node.a[i]) || node.a[i];
-    if (source.b && (swap = source.b.indexOf(node)) !== -1) {
-      const remove = source.b.indexOf(node.e) > -1;
-      source.b[swap] = !remove ? node.e : source.b[source.b.length - 1];
-      remove && source.b.pop();
+    transitionSource = transition2.a.get(node.a[i]);
+    source = transitionSource || node.a[i];
+    if (source.c && (swap = source.c.indexOf(node)) !== -1) {
+      source.c[swap] = transitionSource ? node.d : source.c[source.c.length - 1];
+      !transitionSource && source.c.pop();
     }
   }
 }
-function cloneQueue(queue, parent, clonedQueues) {
+function cloneQueue(queue, parent, transition2) {
   const clone = Object.create(Object.getPrototypeOf(queue));
   Object.assign(clone, queue, {
-    e: queue,
+    d: queue,
     k: parent,
     f: [],
     enqueue(type, fn) {
-      ActiveTransition?.enqueue(type, fn);
+      transition2 = latestTransition(transition2);
+      transition2.enqueue(type, fn);
     },
     notify(node, type, flags) {
-      node = node.e || node;
-      if (!clone.J || type & LOADING_BIT) {
+      node = node.d || node;
+      if (!clone.K || type & LOADING_BIT) {
         type &= ~LOADING_BIT;
-        ActiveTransition?.notify(node, LOADING_BIT, flags);
+        transition2 = latestTransition(transition2);
+        transition2.notify(node, LOADING_BIT, flags);
         if (!type)
           return true;
       }
@@ -378,14 +386,14 @@ function cloneQueue(queue, parent, clonedQueues) {
     }
   });
   parent.f.push(clone);
-  clonedQueues.set(queue, clone);
+  transition2.G.set(queue, clone);
   for (const child of queue.f) {
-    cloneQueue(child, clone, clonedQueues);
+    cloneQueue(child, clone, transition2);
   }
 }
 function resolveQueues(children) {
   for (const child of children) {
-    const og = child.e;
+    const og = child.d;
     if (og) {
       const clonedChildren = child.f;
       delete child.enqueue;
@@ -393,10 +401,10 @@ function resolveQueues(children) {
       delete child.k;
       delete child.f;
       Object.assign(og, child);
-      delete og.e;
+      delete og.d;
       resolveQueues(clonedChildren);
-    } else if (child.k.e) {
-      child.k.e.addChild(child);
+    } else if (child.k.d) {
+      child.k.d.addChild(child);
     }
   }
 }
@@ -405,34 +413,34 @@ function mergeTransitions(t1, t2) {
     key.j = t1;
     t1.a.set(key, value);
   });
-  t2.W.forEach((c) => {
+  t2.I.forEach((c) => {
     c.j = t1;
-    t1.W.add(c);
+    t1.I.add(c);
   });
   t2.H.forEach((p) => t1.H.add(p));
   t2.s.forEach((n) => t1.s.add(n));
   t1.merge(t2);
-  t2.u = t1;
+  t2.D = t1;
 }
 function getTransitionSource(input) {
   return ActiveTransition && ActiveTransition.a.get(input) || input;
 }
 function getQueue(node) {
-  const transition2 = ActiveTransition || node.e?.j;
-  return transition2 && transition2.r.get(node.B) || node.B;
+  const transition2 = ActiveTransition || node.d?.j;
+  return transition2 && transition2.G.get(node.C) || node.C;
 }
 function initialDispose(node) {
   let current = node.m;
   while (current !== null && current.k === node) {
     initialDispose(current);
     const clone = ActiveTransition.a.get(current);
-    if (clone && !clone.Y)
+    if (clone && !clone.Z)
       clone.dispose(true);
     current = current.m;
   }
 }
 function finishTransition(transition2) {
-  if (transition2.u || transition2.X || transition2.H.size || transition2.s.size)
+  if (transition2.D || transition2.Y || transition2.H.size || transition2.s.size)
     return;
   globalQueue.g[0].push.apply(globalQueue.g[0], transition2.g[0]);
   globalQueue.g[1].push.apply(globalQueue.g[1], transition2.g[1]);
@@ -444,27 +452,33 @@ function finishTransition(transition2) {
     }
     if (clone.a)
       replaceSourceObservers(clone, transition2);
-    if (clone.Y || clone.c === STATE_DISPOSED) {
-      source.dispose(clone.c === STATE_DISPOSED);
+    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();
-      delete clone.Y;
+      delete clone.Z;
     } else {
       delete clone.m;
       delete clone.n;
     }
     Object.assign(source, clone);
-    delete source.e;
+    delete source.d;
     let current = clone.m;
-    if (current?.w === clone)
-      current.w = source;
+    if (current?.y === clone)
+      current.y = source;
     while (current?.k === clone) {
       current.k = source;
       current = current.m;
     }
     delete source.j;
   }
-  transition2.u = true;
-  for (const reset of transition2.W) {
+  transition2.D = true;
+  for (const reset of transition2.I) {
     delete reset.j;
     reset();
   }
@@ -488,11 +502,11 @@ var Owner = class {
   // See comment at the top of the file for an example of the _nextSibling traversal
   k = null;
   m = null;
-  w = null;
-  c = STATE_CLEAN;
+  y = null;
+  b = STATE_CLEAN;
   n = null;
-  x = defaultContext;
-  B = globalQueue;
+  z = defaultContext;
+  C = globalQueue;
   fa = 0;
   id = null;
   constructor(id = null, skipAppend = false) {
@@ -503,23 +517,23 @@ var Owner = class {
   }
   append(child) {
     child.k = this;
-    child.w = this;
+    child.y = this;
     if (this.m)
-      this.m.w = child;
+      this.m.y = child;
     child.m = this.m;
     this.m = 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.z !== this.z) {
+      child.z = { ...this.z, ...child.z };
     }
-    if (this.B)
-      child.B = this.B;
+    if (this.C)
+      child.C = this.C;
   }
   dispose(self = true) {
-    if (this.c === STATE_DISPOSED)
+    if (this.b === STATE_DISPOSED)
       return;
-    let head = self ? this.w || this.k : this, current = this.m, next = null;
+    let head = self ? this.y || this.k : this, current = this.m, next = null;
     while (current && current.k === this) {
       current.dispose(true);
       next = current.m;
@@ -528,19 +542,19 @@ var Owner = class {
     }
     this.fa = 0;
     if (self)
-      this.R();
+      this.L();
     if (current)
-      current.w = !self ? this : this.w;
+      current.y = !self ? this : this.y;
     if (head)
       head.m = current;
   }
-  R() {
-    if (this.w)
-      this.w.m = null;
+  L() {
+    if (this.y)
+      this.y.m = null;
     this.k = null;
-    this.w = null;
-    this.x = defaultContext;
-    this.c = STATE_DISPOSED;
+    this.y = null;
+    this.z = defaultContext;
+    this.b = STATE_DISPOSED;
     this.emptyDisposal();
   }
   emptyDisposal() {
@@ -569,7 +583,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.z[context.id] : context.defaultValue;
   if (isUndefined(value)) {
     throw new ContextNotFoundError();
   }
@@ -579,13 +593,13 @@ function setContext(context, value, owner = currentOwner) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  owner.x = {
-    ...owner.x,
+  owner.z = {
+    ...owner.z,
     [context.id]: isUndefined(value) ? context.defaultValue : value
   };
 }
 function hasContext(context, owner = currentOwner) {
-  return !isUndefined(owner?.x[context.id]);
+  return !isUndefined(owner?.z[context.id]);
 }
 function onCleanup(fn) {
   if (!currentOwner)
@@ -623,10 +637,10 @@ function getObserver() {
 var UNCHANGED = Symbol(0);
 var Computation = class extends Owner {
   a = null;
-  b = null;
+  c = null;
   l;
-  L;
-  M;
+  O;
+  P;
   // Used in __DEV__ mode, hopefully removed in production
   la;
   // Using false is an optimization as an alternative to _equals: () => false
@@ -635,25 +649,24 @@ var Computation = class extends Owner {
   ea;
   ha = false;
   /** Whether the computation is an error or has ancestors that are unresolved */
-  h = 0;
+  i = 0;
   /** Which flags raised by sources are handled, vs. being passed through. */
   ba = DEFAULT_FLAGS;
-  N = -1;
-  D = false;
+  Q = -1;
+  E = false;
   j;
-  e;
+  d;
+  I = false;
   constructor(initialValue, compute2, options) {
     super(options?.id, compute2 === null);
-    this.M = compute2;
-    this.c = compute2 ? STATE_DIRTY : STATE_CLEAN;
-    this.h = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
+    this.P = compute2;
+    this.b = compute2 ? STATE_DIRTY : STATE_CLEAN;
+    this.i = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
     this.l = initialValue;
     if (options?.equals !== void 0)
       this.aa = options.equals;
-    if (options?.pureWrite)
-      this.ha = true;
-    if (options?.unobserved)
-      this.ea = options?.unobserved;
+    this.ha = !!options?.pureWrite;
+    this.ea = options?.unobserved;
     if (ActiveTransition) {
       this.j = ActiveTransition;
       ActiveTransition.a.set(this, this);
@@ -661,9 +674,9 @@ var Computation = class extends Owner {
   }
   ga() {
     track(this);
-    newFlags |= this.h & ~currentMask;
-    if (this.h & ERROR_BIT) {
-      throw this.L;
+    newFlags |= this.i & ~currentMask;
+    if (this.i & ERROR_BIT) {
+      throw this.O;
     } else {
       return this.l;
     }
@@ -673,16 +686,16 @@ var Computation = class extends Owner {
    * Automatically re-executes the surrounding computation when the value changes
    */
   read() {
-    if (ActiveTransition && (ActiveTransition.a.has(this) || !this.e && this.h & (UNINITIALIZED_BIT | ERROR_BIT))) {
+    if (ActiveTransition && (ActiveTransition.a.has(this) || !this.d && this.i & (UNINITIALIZED_BIT | ERROR_BIT))) {
       const clone = ActiveTransition.a.get(this) || cloneGraph(this);
       if (clone !== this)
         return clone.read();
     }
-    if (this.M) {
-      if (this.h & ERROR_BIT && this.N <= clock)
+    if (this.P) {
+      if (this.i & ERROR_BIT && this.Q <= clock)
         update(this);
       else
-        this.K();
+        this.M();
     }
     return this.ga();
   }
@@ -694,49 +707,49 @@ var Computation = class extends Owner {
    * before continuing
    */
   wait() {
-    if (ActiveTransition && (ActiveTransition.a.has(this) || !this.e && this.h & (UNINITIALIZED_BIT | ERROR_BIT))) {
+    if (ActiveTransition && (ActiveTransition.a.has(this) || !this.d && this.i & (UNINITIALIZED_BIT | ERROR_BIT))) {
       const clone = ActiveTransition.a.get(this) || cloneGraph(this);
       if (clone !== this)
         return clone.wait();
     }
-    if (this.M) {
-      if (this.h & ERROR_BIT && this.N <= clock)
+    if (this.P) {
+      if (this.i & ERROR_BIT && this.Q <= clock)
         update(this);
       else
-        this.K();
+        this.M();
     }
-    if ((notStale || this.h & UNINITIALIZED_BIT) && this.h & LOADING_BIT) {
+    if ((notStale || this.i & UNINITIALIZED_BIT) && this.i & LOADING_BIT) {
       track(this);
       throw new NotReadyError();
     }
-    if (staleCheck && this.h & LOADING_BIT) {
+    if (staleCheck && this.i & LOADING_BIT) {
       staleCheck.l = true;
     }
     return this.ga();
   }
   /** Update the computation with a new value. */
   write(value, flags = 0, raw = false) {
-    if (ActiveTransition && !this.e) {
+    if (ActiveTransition && !this.d) {
       const clone = cloneGraph(this);
       if (clone !== this)
         return clone.write(value, flags, raw);
     }
     const newValue = !raw && typeof value === "function" ? value(this.l) : value;
-    const valueChanged = newValue !== UNCHANGED && (!!(this.h & UNINITIALIZED_BIT) || // this._stateFlags & LOADING_BIT & ~flags ||
+    const valueChanged = newValue !== UNCHANGED && (!!(this.i & UNINITIALIZED_BIT) || // this._stateFlags & LOADING_BIT & ~flags ||
     this.aa === false || !this.aa(this.l, newValue));
     if (valueChanged) {
       this.l = newValue;
-      this.L = void 0;
+      this.O = void 0;
     }
-    const changedFlagsMask = this.h ^ flags, changedFlags = changedFlagsMask & flags;
-    this.h = flags;
-    this.N = clock + 1;
-    if (this.b) {
-      for (let i = 0; i < this.b.length; i++) {
+    const changedFlagsMask = this.i ^ flags, changedFlags = changedFlagsMask & flags;
+    this.i = flags;
+    this.Q = clock + 1;
+    if (this.c) {
+      for (let i = 0; i < this.c.length; i++) {
         if (valueChanged) {
-          this.b[i].y(STATE_DIRTY);
+          this.c[i].t(STATE_DIRTY);
         } else if (changedFlagsMask) {
-          this.b[i].Z(changedFlagsMask, changedFlags);
+          this.c[i]._(changedFlagsMask, changedFlags);
         }
       }
     }
@@ -745,14 +758,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.D)
+  t(state, skipQueue) {
+    if (this.b >= state && !this.E)
       return;
-    this.D = !!skipQueue;
-    this.c = state;
-    if (this.b) {
-      for (let i = 0; i < this.b.length; i++) {
-        this.b[i].y(STATE_CHECK, skipQueue);
+    this.E = !!skipQueue;
+    this.b = state;
+    if (this.c) {
+      for (let i = 0; i < this.c.length; i++) {
+        this.c[i].t(STATE_CHECK, skipQueue);
       }
     }
   }
@@ -762,36 +775,36 @@ var Computation = class extends Owner {
    * @param mask A bitmask for which flag(s) were changed.
    * @param newFlags The source's new flags, masked to just the changed ones.
    */
-  Z(mask, newFlags2) {
-    if (this.c >= STATE_DIRTY)
+  _(mask, newFlags2) {
+    if (this.b >= STATE_DIRTY)
       return;
     if (mask & this.ba) {
-      this.y(STATE_DIRTY);
+      this.t(STATE_DIRTY);
       return;
     }
-    if (this.c >= STATE_CHECK && !this.D)
+    if (this.b >= STATE_CHECK && !this.E)
       return;
-    const prevFlags = this.h & mask;
+    const prevFlags = this.i & mask;
     const deltaFlags = prevFlags ^ newFlags2;
     if (newFlags2 === prevFlags) ; else if (deltaFlags & prevFlags & mask) {
-      this.y(STATE_CHECK);
+      this.t(STATE_CHECK);
     } else {
-      this.h ^= deltaFlags;
-      if (this.b) {
-        for (let i = 0; i < this.b.length; i++) {
-          this.b[i].Z(mask, newFlags2);
+      this.i ^= deltaFlags;
+      if (this.c) {
+        for (let i = 0; i < this.c.length; i++) {
+          this.c[i]._(mask, newFlags2);
         }
       }
     }
   }
-  E(error) {
-    if (ActiveTransition && !this.e) {
+  N(error) {
+    if (ActiveTransition && !this.d) {
       const clone = cloneGraph(this);
       if (clone !== this)
-        return clone.E(error);
+        return clone.N(error);
     }
-    this.L = error;
-    this.write(UNCHANGED, this.h & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
+    this.O = error;
+    this.write(UNCHANGED, this.i & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
   }
   /**
    * This is the core part of the reactivity system, which makes sure that the values are updated
@@ -800,48 +813,48 @@ var Computation = class extends Owner {
    *
    * This function will ensure that the value and states we read from the computation are up to date
    */
-  K() {
-    if (!this.M) {
+  M() {
+    if (!this.P) {
       return;
     }
-    if (this.c === STATE_DISPOSED) {
+    if (this.b === STATE_DISPOSED) {
       return;
     }
-    if (this.c === STATE_CLEAN) {
+    if (this.b === STATE_CLEAN) {
       return;
     }
     let observerFlags = 0;
-    if (this.c === STATE_CHECK) {
+    if (this.b === STATE_CHECK) {
       for (let i = 0; i < this.a.length; i++) {
         const source = getTransitionSource(this.a[i]);
-        source.K();
-        observerFlags |= source.h & ~UNINITIALIZED_BIT;
-        if (this.c === STATE_DIRTY) {
+        source.M();
+        observerFlags |= source.i & ~UNINITIALIZED_BIT;
+        if (this.b === STATE_DIRTY) {
           break;
         }
       }
     }
-    if (this.c === STATE_DIRTY) {
+    if (this.b === STATE_DIRTY) {
       update(this);
     } else {
       this.write(UNCHANGED, observerFlags);
-      this.c = STATE_CLEAN;
+      this.b = STATE_CLEAN;
     }
   }
   /**
    * Remove ourselves from the owner graph and the computation graph
    */
-  R() {
-    if (this.c === STATE_DISPOSED)
+  L() {
+    if (this.b === STATE_DISPOSED)
       return;
     if (this.a)
       removeSourceObservers(this, 0);
-    super.R();
+    super.L();
   }
 };
 function track(computation) {
-  if (ActiveTransition && computation.e)
-    computation = computation.e;
+  if (ActiveTransition && computation.d)
+    computation = computation.d;
   if (currentObserver) {
     if (!newSources && currentObserver.a && currentObserver.a[newSourcesIndex] === computation) {
       newSourcesIndex++;
@@ -851,7 +864,7 @@ function track(computation) {
       newSources.push(computation);
     }
     if (updateCheck) {
-      updateCheck.l = computation.N > currentObserver.N;
+      updateCheck.l = computation.Q > currentObserver.Q;
     }
   }
 }
@@ -861,19 +874,19 @@ function update(node) {
   newSourcesIndex = 0;
   newFlags = 0;
   try {
-    if (ActiveTransition && node.e && !node.Y) {
-      initialDispose(node.e);
-      node.Y = true;
+    if (ActiveTransition && node.d && !node.Z) {
+      initialDispose(node.d);
+      node.Z = true;
     }
     node.dispose(false);
     node.emptyDisposal();
-    const result = compute(node, node.M, node);
+    const result = compute(node, node.P, node);
     node.write(result, newFlags, true);
   } catch (error) {
     if (error instanceof NotReadyError) {
-      node.write(UNCHANGED, newFlags | LOADING_BIT | node.h & UNINITIALIZED_BIT);
+      node.write(UNCHANGED, newFlags | LOADING_BIT | node.i & UNINITIALIZED_BIT);
     } else {
-      node.E(error);
+      node.N(error);
     }
   } finally {
     if (newSources) {
@@ -890,10 +903,10 @@ function update(node) {
       let source;
       for (let i = newSourcesIndex; i < node.a.length; i++) {
         source = getTransitionSource(node.a[i]);
-        if (!source.b)
-          source.b = [node];
+        if (!source.c)
+          source.c = [node];
         else
-          source.b.push(node);
+          source.c.push(node);
       }
     } else if (node.a && newSourcesIndex < node.a.length) {
       removeSourceObservers(node, newSourcesIndex);
@@ -902,8 +915,8 @@ function update(node) {
     newSources = prevSources;
     newSourcesIndex = prevSourcesIndex;
     newFlags = prevFlags;
-    node.N = clock + 1;
-    node.c = STATE_CLEAN;
+    node.Q = clock + 1;
+    node.b = STATE_CLEAN;
   }
 }
 function isEqual(a, b) {
@@ -963,46 +976,6 @@ function latest(fn, fallback) {
     notStale = prevNotStale;
   }
 }
-function runWithObserver(observer, run) {
-  const prevSources = newSources, prevSourcesIndex = newSourcesIndex, prevFlags = newFlags;
-  newSources = null;
-  newSourcesIndex = observer.a ? observer.a.length : 0;
-  newFlags = 0;
-  try {
-    return compute(observer, run, observer);
-  } catch (error) {
-    if (error instanceof NotReadyError) {
-      observer.write(
-        UNCHANGED,
-        newFlags | LOADING_BIT | observer.h & UNINITIALIZED_BIT
-      );
-    } else {
-      observer.E(error);
-    }
-  } finally {
-    if (newSources) {
-      if (newSourcesIndex > 0) {
-        observer.a.length = newSourcesIndex + newSources.length;
-        for (let i = 0; i < newSources.length; i++) {
-          observer.a[newSourcesIndex + i] = newSources[i];
-        }
-      } else {
-        observer.a = newSources;
-      }
-      let source;
-      for (let i = newSourcesIndex; i < observer.a.length; i++) {
-        source = observer.a[i];
-        if (!source.b)
-          source.b = [observer];
-        else
-          source.b.push(observer);
-      }
-    }
-    newSources = prevSources;
-    newSourcesIndex = prevSourcesIndex;
-    newFlags = prevFlags;
-  }
-}
 function compute(owner, fn, observer) {
   const prevOwner = setOwner(owner), prevObserver = currentObserver, prevMask = currentMask, prevNotStale = notStale;
   currentObserver = observer;
@@ -1021,66 +994,66 @@ function compute(owner, fn, observer) {
 // src/core/effect.ts
 var Effect = class extends Computation {
   ca;
-  _;
-  O;
-  da = false;
   $;
-  C;
+  u;
+  da = false;
+  T;
+  r;
   constructor(initialValue, compute2, effect, error, options) {
     super(initialValue, compute2, options);
     this.ca = effect;
-    this._ = error;
-    this.$ = initialValue;
-    this.C = options?.render ? EFFECT_RENDER : EFFECT_USER;
-    if (this.C === EFFECT_RENDER) {
-      this.M = function(p) {
-        return !this.e && clock > this.B.created && !(this.h & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
+    this.$ = error;
+    this.T = initialValue;
+    this.r = options?.render ? EFFECT_RENDER : EFFECT_USER;
+    if (this.r === EFFECT_RENDER) {
+      this.P = function(p) {
+        return !this.d && clock > this.C.created && !(this.i & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
       };
     }
-    this.K();
-    !options?.defer && (this.C === EFFECT_USER ? getQueue(this).enqueue(this.C, this.F.bind(this)) : this.F(this.C));
+    this.M();
+    !options?.defer && (this.r === EFFECT_USER ? getQueue(this).enqueue(this.r, this.w.bind(this)) : this.w(this.r));
   }
   write(value, flags = 0) {
-    if (this.c == STATE_DIRTY) {
-      this.h = flags;
-      if (this.C === EFFECT_RENDER) {
-        getQueue(this).notify(this, LOADING_BIT | ERROR_BIT, this.h);
+    if (this.b == STATE_DIRTY) {
+      this.i = flags;
+      if (this.r === EFFECT_RENDER) {
+        getQueue(this).notify(this, LOADING_BIT | ERROR_BIT, this.i);
       }
     }
     if (value === UNCHANGED)
       return this.l;
     this.l = value;
     this.da = true;
-    this.L = void 0;
+    this.O = void 0;
     return value;
   }
-  y(state, skipQueue) {
-    if (this.c >= state || skipQueue)
+  t(state, skipQueue) {
+    if (this.b >= state || skipQueue)
       return;
-    if (this.c === STATE_CLEAN)
-      getQueue(this).enqueue(this.C, this.F.bind(this));
-    this.c = state;
+    if (this.b === STATE_CLEAN || this.d && !ActiveTransition)
+      getQueue(this).enqueue(this.r, this.w.bind(this));
+    this.b = state;
   }
-  Z(mask, newFlags2) {
-    if (this.e) {
-      if (this.c >= STATE_DIRTY)
+  _(mask, newFlags2) {
+    if (this.d) {
+      if (this.b >= STATE_DIRTY)
         return;
       if (mask & 3) {
-        this.y(STATE_DIRTY);
+        this.t(STATE_DIRTY);
         return;
       }
     }
-    super.Z(mask, newFlags2);
+    super._(mask, newFlags2);
   }
-  E(error) {
-    this.L = error;
+  N(error) {
+    this.O = error;
     getQueue(this).notify(this, LOADING_BIT, 0);
-    this.h = ERROR_BIT;
-    if (this.C === EFFECT_USER) {
+    this.i = ERROR_BIT;
+    if (this.r === EFFECT_USER) {
       try {
-        return this._ ? this._(error, () => {
-          this.O?.();
-          this.O = void 0;
+        return this.$ ? this.$(error, () => {
+          this.u?.();
+          this.u = void 0;
         }) : console.error(error);
       } catch (e) {
         error = e;
@@ -1089,50 +1062,81 @@ var Effect = class extends Computation {
     if (!getQueue(this).notify(this, ERROR_BIT, ERROR_BIT))
       throw error;
   }
-  R() {
-    if (this.c === STATE_DISPOSED)
+  L() {
+    if (this.b === STATE_DISPOSED)
       return;
     this.ca = void 0;
+    this.T = void 0;
     this.$ = void 0;
-    this._ = void 0;
-    this.O?.();
-    this.O = void 0;
+    this.u?.();
+    this.u = void 0;
     getQueue(this).notify(this, ERROR_BIT | LOADING_BIT, 0);
-    super.R();
+    super.L();
   }
-  F(type) {
+  w(type) {
     if (type) {
-      const effect = this.e || this;
-      if (effect.da && effect.c !== STATE_DISPOSED) {
-        effect.O?.();
+      const effect = this.d || this;
+      if (effect.da && effect.b !== STATE_DISPOSED) {
+        effect.u?.();
         try {
-          effect.O = effect.ca(effect.l, effect.$);
+          effect.u = effect.ca(effect.l, effect.T);
         } catch (e) {
           if (!getQueue(effect).notify(effect, ERROR_BIT, ERROR_BIT))
             throw e;
         } finally {
-          effect.$ = effect.l;
+          effect.T = effect.l;
           effect.da = false;
         }
       }
     } else
-      this.c !== STATE_CLEAN && runTop(this);
+      this.b !== STATE_CLEAN && runTop(this);
+  }
+};
+var TrackedEffect = class extends Computation {
+  r = EFFECT_USER;
+  u;
+  constructor(compute2, options) {
+    super(void 0, () => {
+      this.u?.();
+      this.u = latest(compute2);
+      return void 0;
+    }, options);
+    getQueue(this).enqueue(this.r, this.w.bind(this));
+  }
+  t(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));
+    this.b = state;
+  }
+  L() {
+    if (this.b === STATE_DISPOSED)
+      return;
+    this.u?.();
+    this.u = void 0;
+    getQueue(this).notify(this, ERROR_BIT | LOADING_BIT, 0);
+    super.L();
+  }
+  w(type) {
+    if (type)
+      this.b !== STATE_CLEAN && runTop(this);
   }
 };
 var EagerComputation = class extends Computation {
   constructor(initialValue, compute2, options) {
     super(initialValue, compute2, options);
-    !options?.defer && this.K();
+    !options?.defer && this.M();
   }
-  y(state, skipQueue) {
-    if (this.c >= state && !this.D)
+  t(state, skipQueue) {
+    if (this.b >= state && !this.E)
       return;
-    if (!skipQueue && (this.c === STATE_CLEAN || this.c === STATE_CHECK && this.D))
-      getQueue(this).enqueue(EFFECT_PURE, this.F.bind(this));
-    super.y(state, skipQueue);
+    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);
   }
-  F() {
-    this.c !== STATE_CLEAN && runTop(this);
+  w() {
+    this.b !== STATE_CLEAN && runTop(this);
   }
 };
 var FirewallComputation = class extends Computation {
@@ -1140,16 +1144,16 @@ var FirewallComputation = class extends Computation {
   constructor(compute2) {
     super(void 0, compute2);
   }
-  y(state, skipQueue) {
-    if (this.c >= state && !this.D)
+  t(state, skipQueue) {
+    if (this.b >= state && !this.E)
       return;
-    if (!skipQueue && (this.c === STATE_CLEAN || this.c === STATE_CHECK && this.D))
-      getQueue(this).enqueue(EFFECT_PURE, this.F.bind(this));
-    super.y(state, true);
-    this.D = !!skipQueue;
+    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;
   }
-  F() {
-    this.c !== STATE_CLEAN && runTop(this);
+  w() {
+    this.b !== STATE_CLEAN && runTop(this);
   }
 };
 function runTop(node) {
@@ -1157,22 +1161,218 @@ function runTop(node) {
   for (let current = node; current !== null; current = current.k) {
     if (ActiveTransition && current.j)
       current = ActiveTransition.a.get(current);
-    if (current.c !== STATE_CLEAN) {
+    if (current.b !== STATE_CLEAN) {
       ancestors.push(current);
     }
   }
   for (let i = ancestors.length - 1; i >= 0; i--) {
-    if (ancestors[i].c !== STATE_DISPOSED)
-      ancestors[i].K();
+    if (ancestors[i].b !== STATE_DISPOSED)
+      ancestors[i].M();
   }
 }
 
+// src/signals.ts
+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)];
+  }
+  const o = getOwner();
+  const needsId = o?.id != null;
+  const node = new Computation(
+    first,
+    null,
+    needsId ? { id: o.getNextChildId(), ...second } : second
+  );
+  return [node.read.bind(node), node.write.bind(node)];
+}
+function createMemo(compute2, value, options) {
+  let node = new Computation(
+    value,
+    compute2,
+    options
+  );
+  let resolvedValue;
+  return () => {
+    if (node) {
+      if (node.b === STATE_DISPOSED) {
+        node = void 0;
+        return resolvedValue;
+      }
+      resolvedValue = node.wait();
+      if (!node.a?.length && node.m?.k !== node && !(node.i & UNINITIALIZED_BIT)) {
+        node.dispose();
+        node = void 0;
+      }
+    }
+    return resolvedValue;
+  };
+}
+function createAsync(compute2, value, options) {
+  let refreshing = false;
+  const node = new EagerComputation(
+    value,
+    (p) => {
+      const source = compute2(p, refreshing);
+      refreshing = false;
+      const isPromise = source instanceof Promise;
+      const iterator = source[Symbol.asyncIterator];
+      if (!isPromise && !iterator) {
+        return source;
+      }
+      let abort = false;
+      onCleanup(() => abort = true);
+      let transition2 = ActiveTransition;
+      if (isPromise) {
+        source.then(
+          (value3) => {
+            if (abort)
+              return;
+            if (transition2)
+              return transition2.runTransition(() => {
+                node.write(value3, 0, true);
+              }, true);
+            node.write(value3, 0, true);
+          },
+          (error) => {
+            if (abort)
+              return;
+            if (transition2)
+              return transition2.runTransition(() => node.N(error), true);
+            node.N(error);
+          }
+        );
+      } else {
+        (async () => {
+          try {
+            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;
+            if (transition2)
+              return transition2.runTransition(() => {
+                node.N(error);
+                transition2 = null;
+              }, true);
+            node.N(error);
+          }
+        })();
+      }
+      throw new NotReadyError();
+    },
+    options
+  );
+  const read = node.wait.bind(node);
+  read.refresh = () => {
+    let n = node;
+    if (ActiveTransition && !node.d) {
+      n = cloneGraph(node);
+    }
+    n.b = STATE_DIRTY;
+    refreshing = true;
+    n.M();
+  };
+  return read;
+}
+function createEffect(compute2, effect, value, options) {
+  void new Effect(
+    value,
+    compute2,
+    effect.effect || effect,
+    effect.error,
+    options
+  );
+}
+function createRenderEffect(compute2, effect, value, options) {
+  void new Effect(value, compute2, effect, void 0, {
+    render: true,
+    ...options
+  });
+}
+function createTrackedEffect(compute2, options) {
+  void new TrackedEffect(compute2, options);
+}
+function createReaction(effect, options) {
+  let cleanup = void 0;
+  onCleanup(() => cleanup?.());
+  return (tracking) => {
+    const node = new Effect(
+      void 0,
+      tracking,
+      () => {
+        cleanup?.();
+        cleanup = (effect.effect || effect)?.();
+        node.dispose(true);
+      },
+      effect.error,
+      {
+        defer: true,
+        ...options
+      }
+    );
+  };
+}
+function createRoot(init, options) {
+  const owner = new Owner(options?.id);
+  return compute(owner, !init.length ? init : () => init(() => owner.dispose()), null);
+}
+function runWithOwner(owner, run) {
+  return compute(owner, run, null);
+}
+function resolve(fn) {
+  return new Promise((res, rej) => {
+    createRoot((dispose) => {
+      new EagerComputation(void 0, () => {
+        try {
+          res(fn());
+        } catch (err) {
+          if (err instanceof NotReadyError)
+            throw err;
+          rej(err);
+        }
+        dispose();
+      });
+    });
+  });
+}
+function createOptimistic(first, second, third) {
+  const node = typeof first === "function" ? new Computation(second, first, third) : new Computation(first, null, second);
+  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));
+  }
+  return [node.read.bind(node), write];
+}
+function useTransition() {
+  const [pending, setPending] = createOptimistic(false);
+  function start(fn) {
+    transition((resume) => {
+      setPending(true);
+      return fn(resume);
+    });
+  }
+  return [pending, start];
+}
+
 // 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 getOverrideValue(value, override, nodes, key) {
+  return nodes && key in nodes ? nodes[key].read() : override && key in override ? override[key] : value[key];
 }
 function getAllKeys(value, override, next) {
   const keys = getKeys(value, override);
@@ -1185,6 +1385,7 @@ function applyState(next, state, keyFn, all) {
     return;
   const previous = target[STORE_VALUE];
   const override = target[STORE_OVERRIDE];
+  let nodes = target[STORE_NODE];
   if (next === previous && !override)
     return;
   (target[STORE_LOOKUP] || storeLookup).set(next, target[$PROXY]);
@@ -1192,14 +1393,14 @@ function applyState(next, state, keyFn, all) {
   target[STORE_OVERRIDE] = void 0;
   if (Array.isArray(previous)) {
     let changed = false;
-    const prevLength = getOverrideValue(previous, override, "length");
+    const prevLength = getOverrideValue(previous, override, nodes, "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++) {
+      for (start = 0, end = Math.min(prevLength, next.length); start < end && ((item = getOverrideValue(previous, override, nodes, 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--) {
+      for (end = prevLength - 1, newEnd = next.length - 1; end >= start && newEnd >= start && ((item = getOverrideValue(previous, override, nodes, end)) === next[newEnd] || item && next[newEnd] && keyFn(item) === keyFn(next[newEnd])); end--, newEnd--) {
         temp[newEnd] = item;
       }
       if (start > newEnd || start > end) {
@@ -1226,7 +1427,7 @@ function applyState(next, state, keyFn, all) {
         newIndices.set(keyVal, j);
       }
       for (i = start; i <= end; i++) {
-        item = getOverrideValue(previous, override, i);
+        item = getOverrideValue(previous, override, nodes, i);
         keyVal = item ? keyFn(item) : item;
         j = newIndices.get(keyVal);
         if (j !== void 0 && j !== -1) {
@@ -1247,7 +1448,7 @@ function applyState(next, state, keyFn, all) {
         changed = true;
     } else if (prevLength && next.length) {
       for (let i = 0, len = next.length; i < len; i++) {
-        const item = getOverrideValue(previous, override, i);
+        const item = getOverrideValue(previous, override, nodes, i);
         isWrappable(item) && applyState(next[i], wrap(item, target), keyFn, all);
       }
     }
@@ -1258,14 +1459,13 @@ function applyState(next, state, keyFn, all) {
     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));
+      const previousValue = unwrap(getOverrideValue(previous, override, nodes, key));
       let nextValue = unwrap(next[key]);
       if (previousValue === nextValue)
         continue;
@@ -1296,16 +1496,7 @@ function reconcile(value, key, all = false) {
 }
 
 // src/store/projection.ts
-function createProjection(fn, initialValue = {}, options) {
-  let wrappedStore;
-  const node = new FirewallComputation(() => {
-    storeSetter(wrappedStore, (s) => {
-      const value = fn(s);
-      if (value !== s && value !== void 0) {
-        reconcile(value, options?.key || "id", options?.all)(s);
-      }
-    });
-  });
+function createProjectionInternal(fn, initialValue = {}, options) {
   const wrappedMap = /* @__PURE__ */ new WeakMap();
   const traps = {
     ...storeTraps,
@@ -1316,7 +1507,7 @@ function createProjection(fn, initialValue = {}, options) {
       return storeTraps.get(target, property, receiver);
     }
   };
-  function wrapProjection(source) {
+  const wrapProjection = (source) => {
     if (wrappedMap.has(source))
       return wrappedMap.get(source);
     if (source[$TARGET]?.[STORE_WRAP] === wrapProjection)
@@ -1327,8 +1518,20 @@ function createProjection(fn, initialValue = {}, options) {
     });
     wrappedMap.set(source, wrapped);
     return wrapped;
-  }
-  return wrappedStore = wrapProjection(initialValue);
+  };
+  const wrappedStore = wrapProjection(initialValue);
+  const node = new FirewallComputation(() => {
+    storeSetter(wrappedStore, (s) => {
+      const value = fn(s);
+      if (value !== s && value !== void 0) {
+        reconcile(value, options?.key || "id", options?.all)(s);
+      }
+    });
+  });
+  return { store: wrappedStore, node };
+}
+function createProjection(fn, initialValue = {}, options) {
+  return createProjectionInternal(fn, initialValue, options).store;
 }
 
 // src/store/store.ts
@@ -1464,7 +1667,7 @@ var storeTraps = {
       untrack(() => {
         const state = target[STORE_VALUE];
         const base = state[property];
-        const prev = target[STORE_OVERRIDE]?.[property] || base;
+        const prev = target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE] ? target[STORE_OVERRIDE][property] : base;
         const value = rawValue?.[$TARGET]?.[STORE_VALUE] ?? rawValue;
         if (prev === value)
           return true;
@@ -1496,7 +1699,7 @@ var storeTraps = {
   deleteProperty(target, property) {
     if (Writing?.has(target[$PROXY]) && target[STORE_OVERRIDE]?.[property] !== $DELETED) {
       untrack(() => {
-        const prev = target[STORE_OVERRIDE]?.[property] || target[STORE_VALUE][property];
+        const prev = target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE] ? target[STORE_OVERRIDE][property] : target[STORE_VALUE][property];
         if (property in target[STORE_VALUE]) {
           (target[STORE_OVERRIDE] || (target[STORE_OVERRIDE] = /* @__PURE__ */ Object.create(null)))[property] = $DELETED;
         } else if (target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]) {
@@ -1555,7 +1758,7 @@ function storeSetter(store, fn) {
   }
 }
 function createStore(first, second, options) {
-  const derived = typeof first === "function", wrappedStore = derived ? createProjection(first, second, options) : wrap(first);
+  const derived = typeof first === "function", wrappedStore = derived ? createProjectionInternal(first, second, options).store : wrap(first);
   return [wrappedStore, (fn) => storeSetter(wrappedStore, fn)];
 }
 function recursivelyNotify(state, lookup) {
@@ -1619,6 +1822,29 @@ function deep(store) {
   return store[$DEEP];
 }
 
+// src/store/optimistic.ts
+function createOptimisticStore(first, second, options) {
+  const derived = typeof first === "function";
+  const { store, node } = derived ? createProjectionInternal(first, second, options) : createProjectionInternal(() => {
+  }, first);
+  const reset = () => storeSetter(
+    store,
+    reconcile(
+      derived ? first(store) || store : first,
+      options?.key || "id",
+      options?.all
+    )
+  );
+  const write = (v) => {
+    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];
+}
+
 // src/store/utils.ts
 function snapshot(item, map, lookup) {
   let target, isArray, override, result, unwrapped, v;
@@ -1819,287 +2045,78 @@ function omit(props, ...keys) {
   return result;
 }
 
-// src/signals.ts
-function createSignal(first, second, third) {
-  if (typeof first === "function") {
-    const memo = createMemo((p) => {
-      const node2 = new Computation(
-        first(p ? untrack(p[0]) : second),
-        null,
-        third
-      );
-      return [node2.read.bind(node2), node2.write.bind(node2)];
-    });
-    return [() => memo()[0](), (value) => memo()[1](value)];
-  }
-  const o = getOwner();
-  const needsId = o?.id != null;
-  const node = new Computation(
-    first,
-    null,
-    needsId ? { id: o.getNextChildId(), ...second } : second
-  );
-  return [node.read.bind(node), node.write.bind(node)];
-}
-function createMemo(compute2, value, options) {
-  let node = new Computation(
-    value,
-    compute2,
-    options
-  );
-  let resolvedValue;
-  return () => {
-    if (node) {
-      if (node.c === STATE_DISPOSED) {
-        node = void 0;
-        return resolvedValue;
-      }
-      resolvedValue = node.wait();
-      if (!node.a?.length && node.m?.k !== node && !(node.h & UNINITIALIZED_BIT)) {
-        node.dispose();
-        node = void 0;
-      }
-    }
-    return resolvedValue;
-  };
-}
-function createAsync(compute2, value, options) {
-  let refreshing = false;
-  const node = new EagerComputation(
-    value,
-    (p) => {
-      const source = compute2(p, refreshing);
-      refreshing = false;
-      const isPromise = source instanceof Promise;
-      const iterator = source[Symbol.asyncIterator];
-      if (!isPromise && !iterator) {
-        return source;
-      }
-      let abort = false;
-      onCleanup(() => abort = true);
-      let transition2 = ActiveTransition;
-      if (isPromise) {
-        source.then(
-          (value3) => {
-            if (abort)
-              return;
-            if (transition2)
-              return transition2.runTransition(() => {
-                node.write(value3, 0, true);
-              }, true);
-            node.write(value3, 0, true);
-          },
-          (error) => {
-            if (abort)
-              return;
-            if (transition2)
-              return transition2.runTransition(() => node.E(error), true);
-            node.E(error);
-          }
-        );
-      } else {
-        (async () => {
-          try {
-            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;
-            if (transition2)
-              return transition2.runTransition(() => {
-                node.E(error);
-                transition2 = null;
-              }, true);
-            node.E(error);
-          }
-        })();
-      }
-      throw new NotReadyError();
-    },
-    options
-  );
-  const read = node.wait.bind(node);
-  read.refresh = () => {
-    let n = node;
-    if (ActiveTransition && !node.e) {
-      n = cloneGraph(node);
-    }
-    n.c = STATE_DIRTY;
-    refreshing = true;
-    n.K();
-  };
-  return read;
-}
-function createEffect(compute2, effect, value, options) {
-  void new Effect(
-    value,
-    compute2,
-    effect.effect ? effect.effect : effect,
-    effect.error,
-    options
-  );
-}
-function createRenderEffect(compute2, effect, value, options) {
-  void new Effect(value, compute2, effect, void 0, {
-    render: true,
-    ...options
-  });
-}
-function createRoot(init, options) {
-  const owner = new Owner(options?.id);
-  return compute(owner, !init.length ? init : () => init(() => owner.dispose()), null);
-}
-function runWithOwner(owner, run) {
-  return compute(owner, run, null);
-}
-function resolve(fn) {
-  return new Promise((res, rej) => {
-    createRoot((dispose) => {
-      new EagerComputation(void 0, () => {
-        try {
-          res(fn());
-        } catch (err) {
-          if (err instanceof NotReadyError)
-            throw err;
-          rej(err);
-        }
-        dispose();
-      });
-    });
-  });
-}
-function createPending() {
-  const node = new Computation(false, null);
-  const reset = () => node.write(false);
-  function write() {
-    if (!ActiveTransition)
-      return false;
-    ActiveTransition.addOptimistic(reset);
-    queueMicrotask(() => reset.j && node.write(true));
-  }
-  function read() {
-    const v = node.read();
-    return ActiveTransition ? false : v;
-  }
-  return [read, write];
-}
-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(
-    reconcile(
-      typeof first === "function" ? first(second) : first,
-      options?.key || "id",
-      options?.all
-    )
-  );
-  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, write];
-}
-
 // src/map.ts
 function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
   return updateKeyedMap.bind({
-    S: new Owner(),
+    U: new Owner(),
     o: 0,
     ia: list,
-    G: [],
-    P: map,
-    i: [],
-    d: [],
-    Q: keyFn,
+    F: [],
+    R: map,
+    h: [],
+    e: [],
+    S: keyFn,
     p: keyFn || options?.keyed === false ? [] : void 0,
     q: map.length > 1 ? [] : void 0,
-    T: options?.fallback
+    V: options?.fallback
   });
 }
 var pureOptions = { pureWrite: true };
 function updateKeyedMap() {
   const newItems = this.ia() || [], newLen = newItems.length;
   newItems[$TRACK];
-  runWithOwner(this.S, () => {
+  runWithOwner(this.U, () => {
     let i, j, mapper = this.p ? () => {
       this.p[j] = new Computation(newItems[j], null, pureOptions);
       this.q && (this.q[j] = new Computation(j, null, pureOptions));
-      return this.P(
+      return this.R(
         Computation.prototype.read.bind(this.p[j]),
         this.q ? Computation.prototype.read.bind(this.q[j]) : void 0
       );
     } : this.q ? () => {
       const item = newItems[j];
       this.q[j] = new Computation(j, null, pureOptions);
-      return this.P(() => item, Computation.prototype.read.bind(this.q[j]));
+      return this.R(() => item, Computation.prototype.read.bind(this.q[j]));
     } : () => {
       const item = newItems[j];
-      return this.P(() => item);
+      return this.R(() => item);
     };
     if (newLen === 0) {
       if (this.o !== 0) {
-        this.S.dispose(false);
-        this.d = [];
-        this.G = [];
-        this.i = [];
+        this.U.dispose(false);
+        this.e = [];
+        this.F = [];
+        this.h = [];
         this.o = 0;
         this.p && (this.p = []);
         this.q && (this.q = []);
       }
-      if (this.T && !this.i[0]) {
-        this.i[0] = compute(
-          this.d[0] = new Owner(),
-          this.T,
+      if (this.V && !this.h[0]) {
+        this.h[0] = compute(
+          this.e[0] = new Owner(),
+          this.V,
           null
         );
       }
     } else if (this.o === 0) {
-      if (this.d[0])
-        this.d[0].dispose();
-      this.i = new Array(newLen);
+      if (this.e[0])
+        this.e[0].dispose();
+      this.h = new Array(newLen);
       for (j = 0; j < newLen; j++) {
-        this.G[j] = newItems[j];
-        this.i[j] = compute(this.d[j] = new Owner(), mapper, null);
+        this.F[j] = newItems[j];
+        this.h[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.G[start] === newItems[start] || this.p && compare(this.Q, this.G[start], newItems[start])); start++) {
+      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++) {
         if (this.p)
           this.p[start].write(newItems[start]);
       }
-      for (end = this.o - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.G[end] === newItems[newEnd] || this.p && compare(this.Q, this.G[end], newItems[newEnd])); end--, newEnd--) {
-        temp[newEnd] = this.i[end];
-        tempNodes[newEnd] = this.d[end];
+      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];
+        tempNodes[newEnd] = this.e[end];
         tempRows && (tempRows[newEnd] = this.p[end]);
         tempIndexes && (tempIndexes[newEnd] = this.q[end]);
       }
@@ -2107,29 +2124,29 @@ function updateKeyedMap() {
       newIndicesNext = new Array(newEnd + 1);
       for (j = newEnd; j >= start; j--) {
         item = newItems[j];
-        key = this.Q ? this.Q(item) : item;
+        key = this.S ? this.S(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.G[i];
-        key = this.Q ? this.Q(item) : item;
+        item = this.F[i];
+        key = this.S ? this.S(item) : item;
         j = newIndices.get(key);
         if (j !== void 0 && j !== -1) {
-          temp[j] = this.i[i];
-          tempNodes[j] = this.d[i];
+          temp[j] = this.h[i];
+          tempNodes[j] = this.e[i];
           tempRows && (tempRows[j] = this.p[i]);
           tempIndexes && (tempIndexes[j] = this.q[i]);
           j = newIndicesNext[j];
           newIndices.set(key, j);
         } else
-          this.d[i].dispose();
+          this.e[i].dispose();
       }
       for (j = start; j < newLen; j++) {
         if (j in temp) {
-          this.i[j] = temp[j];
-          this.d[j] = tempNodes[j];
+          this.h[j] = temp[j];
+          this.e[j] = tempNodes[j];
           if (tempRows) {
             this.p[j] = tempRows[j];
             this.p[j].write(newItems[j]);
@@ -2139,89 +2156,89 @@ function updateKeyedMap() {
             this.q[j].write(j);
           }
         } else {
-          this.i[j] = compute(this.d[j] = new Owner(), mapper, null);
+          this.h[j] = compute(this.e[j] = new Owner(), mapper, null);
         }
       }
-      this.i = this.i.slice(0, this.o = newLen);
-      this.G = newItems.slice(0);
+      this.h = this.h.slice(0, this.o = newLen);
+      this.F = newItems.slice(0);
     }
   });
-  return this.i;
+  return this.h;
 }
 function repeat(count, map, options) {
   return updateRepeat.bind({
-    S: new Owner(),
+    U: new Owner(),
     o: 0,
-    z: 0,
+    A: 0,
     ja: count,
-    P: map,
-    d: [],
-    i: [],
+    R: map,
+    e: [],
+    h: [],
     ka: options?.from,
-    T: options?.fallback
+    V: options?.fallback
   });
 }
 function updateRepeat() {
   const newLen = this.ja();
   const from = this.ka?.() || 0;
-  runWithOwner(this.S, () => {
+  runWithOwner(this.U, () => {
     if (newLen === 0) {
       if (this.o !== 0) {
-        this.S.dispose(false);
-        this.d = [];
-        this.i = [];
+        this.U.dispose(false);
+        this.e = [];
+        this.h = [];
         this.o = 0;
       }
-      if (this.T && !this.i[0]) {
-        this.i[0] = compute(
-          this.d[0] = new Owner(),
-          this.T,
+      if (this.V && !this.h[0]) {
+        this.h[0] = compute(
+          this.e[0] = new Owner(),
+          this.V,
           null
         );
       }
       return;
     }
     const to = from + newLen;
-    const prevTo = this.z + this.o;
-    if (this.o === 0 && this.d[0])
-      this.d[0].dispose();
+    const prevTo = this.A + this.o;
+    if (this.o === 0 && this.e[0])
+      this.e[0].dispose();
     for (let i = to; i < prevTo; i++)
-      this.d[i - this.z].dispose();
-    if (this.z < from) {
-      let i = this.z;
+      this.e[i - this.A].dispose();
+    if (this.A < from) {
+      let i = this.A;
       while (i < from && i < this.o)
-        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.length = this.i.length = newLen;
+        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;
       while (i >= difference) {
-        this.d[i] = this.d[i - difference];
-        this.i[i] = this.i[i - difference];
+        this.e[i] = this.e[i - difference];
+        this.h[i] = this.h[i - difference];
         i--;
       }
       for (let i2 = 0; i2 < difference; i2++) {
-        this.i[i2] = compute(
-          this.d[i2] = new Owner(),
-          () => this.P(i2 + from),
+        this.h[i2] = compute(
+          this.e[i2] = new Owner(),
+          () => this.R(i2 + from),
           null
         );
       }
     }
     for (let i = prevTo; i < to; i++) {
-      this.i[i - from] = compute(
-        this.d[i - from] = new Owner(),
-        () => this.P(i),
+      this.h[i - from] = compute(
+        this.e[i - from] = new Owner(),
+        () => this.R(i),
         null
       );
     }
-    this.i = this.i.slice(0, newLen);
-    this.z = from;
+    this.h = this.h.slice(0, newLen);
+    this.A = from;
     this.o = newLen;
   });
-  return this.i;
+  return this.h;
 }
 function compare(key, a, b) {
   return key ? key(a) === key(b) : true;
@@ -2229,24 +2246,24 @@ function compare(key, a, b) {
 
 // src/boundaries.ts
 var BoundaryComputation = class extends EagerComputation {
-  U;
+  W;
   constructor(compute2, propagationMask) {
     super(void 0, compute2, { defer: true });
-    this.U = propagationMask;
+    this.W = propagationMask;
   }
   write(value, flags) {
-    super.write(value, flags & ~this.U);
-    if (this.U & LOADING_BIT && !(this.h & UNINITIALIZED_BIT || ActiveTransition)) {
+    super.write(value, flags & ~this.W);
+    if (this.W & LOADING_BIT && !(this.i & UNINITIALIZED_BIT || ActiveTransition)) {
       flags &= ~LOADING_BIT;
     }
-    getQueue(this).notify(this, this.U, flags);
+    getQueue(this).notify(this, this.W, flags);
     return this.l;
   }
 };
 function createBoundChildren(owner, fn, queue, mask) {
-  const parentQueue = owner.B;
-  parentQueue.addChild(owner.B = queue);
-  onCleanup(() => parentQueue.removeChild(owner.B));
+  const parentQueue = owner.C;
+  parentQueue.addChild(owner.C = queue);
+  onCleanup(() => parentQueue.removeChild(owner.C));
   return compute(
     owner,
     () => {
@@ -2257,22 +2274,20 @@ function createBoundChildren(owner, fn, queue, mask) {
   );
 }
 var ConditionalQueue = class extends Queue {
-  t;
-  V = /* @__PURE__ */ new Set();
+  x;
+  X = /* @__PURE__ */ new Set();
   s = /* @__PURE__ */ new Set();
   constructor(disabled) {
     super();
-    this.t = disabled;
+    this.x = disabled;
   }
   run(type) {
-    if (!type || this.t.read())
+    if (!type || this.x.read())
       return;
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (ActiveTransition && ActiveTransition.r.has(this))
-      return ActiveTransition.r.get(this).notify(node, type, flags);
-    if (this.t.read()) {
+    if (this.x.read()) {
       if (type & LOADING_BIT) {
         if (flags & LOADING_BIT) {
           this.s.add(node);
@@ -2282,9 +2297,9 @@ var ConditionalQueue = class extends Queue {
       }
       if (type & ERROR_BIT) {
         if (flags & ERROR_BIT) {
-          this.V.add(node);
+          this.X.add(node);
           type &= ~ERROR_BIT;
-        } else if (this.V.delete(node))
+        } else if (this.X.delete(node))
           type &= ~ERROR_BIT;
       }
     }
@@ -2292,42 +2307,40 @@ var ConditionalQueue = class extends Queue {
   }
   merge(queue) {
     queue.s.forEach((n) => this.notify(n, LOADING_BIT, LOADING_BIT));
-    queue.V.forEach((n) => this.notify(n, ERROR_BIT, ERROR_BIT));
+    queue.X.forEach((n) => this.notify(n, ERROR_BIT, ERROR_BIT));
     super.merge(queue);
   }
 };
 var CollectionQueue = class extends Queue {
-  J;
-  d = /* @__PURE__ */ new Set();
-  t = new Computation(false, null, { pureWrite: true });
+  K;
+  e = /* @__PURE__ */ new Set();
+  x = new Computation(false, null, { pureWrite: true });
   constructor(type) {
     super();
-    this.J = type;
+    this.K = type;
   }
   run(type) {
-    if (!type || this.t.read())
+    if (!type || this.x.read())
       return;
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (ActiveTransition && ActiveTransition.r.has(this))
-      return ActiveTransition.r.get(this).notify(node, type, flags);
-    if (!(type & this.J))
+    if (!(type & this.K))
       return super.notify(node, type, flags);
-    if (flags & this.J) {
-      this.d.add(node);
-      if (this.d.size === 1)
-        this.t.write(true);
-    } else if (this.d.size > 0) {
-      this.d.delete(node);
-      if (this.d.size === 0)
-        this.t.write(false);
-    }
-    type &= ~this.J;
+    if (flags & this.K) {
+      this.e.add(node);
+      if (this.e.size === 1)
+        this.x.write(true);
+    } else if (this.e.size > 0) {
+      this.e.delete(node);
+      if (this.e.size === 0)
+        this.x.write(false);
+    }
+    type &= ~this.K;
     return type ? super.notify(node, type, flags) : true;
   }
   merge(queue) {
-    queue.d.forEach((n) => this.notify(n, this.J, this.J));
+    queue.e.forEach((n) => this.notify(n, this.K, this.K));
     super.merge(queue);
   }
 };
@@ -2338,25 +2351,25 @@ function createBoundary(fn, condition) {
   );
   const tree = createBoundChildren(owner, fn, queue, 0);
   new EagerComputation(void 0, () => {
-    const disabled = queue.t.read();
-    tree.U = disabled ? ERROR_BIT | LOADING_BIT : 0;
+    const disabled = queue.x.read();
+    tree.W = disabled ? ERROR_BIT | LOADING_BIT : 0;
     if (!disabled) {
       queue.s.forEach((node) => queue.notify(node, LOADING_BIT, LOADING_BIT));
-      queue.V.forEach((node) => queue.notify(node, ERROR_BIT, ERROR_BIT));
+      queue.X.forEach((node) => queue.notify(node, ERROR_BIT, ERROR_BIT));
       queue.s.clear();
-      queue.V.clear();
+      queue.X.clear();
     }
   });
-  return () => queue.t.read() ? void 0 : tree.read();
+  return () => queue.x.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.t.read()) {
+    if (!queue.x.read()) {
       const resolved = tree.read();
-      if (!untrack(() => queue.t.read()))
+      if (!untrack(() => queue.x.read()))
         return resolved;
     }
     return fallback(queue);
@@ -2368,14 +2381,14 @@ 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.L, () => {
+    let node = getTransitionSource(queue.e.values().next().value);
+    return fallback(node.O, () => {
       incrementClock();
-      for (let node2 of queue.d) {
-        if (ActiveTransition && !node2.e)
+      for (let node2 of queue.e) {
+        if (ActiveTransition && !node2.d)
           node2 = cloneGraph(node2);
-        node2.c = STATE_DIRTY;
-        getQueue(node2).enqueue(node2.C, node2.F.bind(node2));
+        node2.b = STATE_DIRTY;
+        getQueue(node2).enqueue(node2.r, node2.w.bind(node2));
       }
     });
   });
@@ -2435,4 +2448,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, 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 };
+export { $PROXY, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, SUPPORTS_PROXY, createAsync, createBoundary, createContext, createEffect, createErrorBoundary, createMemo, createOptimistic, createOptimisticStore, createProjection, createReaction, createRenderEffect, createRoot, createSignal, createStore, createSuspense, createTrackedEffect, deep, flatten, flush, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, runWithOwner, setContext, snapshot, transition, untrack, useTransition };