@solidjs/signals 0.4.1 → 0.4.2

package/dist/prod.js

@@ -24,33 +24,51 @@ var EFFECT_RENDER = 1;
 var EFFECT_USER = 2;
 var SUPPORTS_PROXY = typeof Proxy === "function";
 
+// src/core/flags.ts
+var ERROR_OFFSET = 0;
+var ERROR_BIT = 1 << ERROR_OFFSET;
+var LOADING_OFFSET = 1;
+var LOADING_BIT = 1 << LOADING_OFFSET;
+var UNINITIALIZED_OFFSET = 2;
+var UNINITIALIZED_BIT = 1 << UNINITIALIZED_OFFSET;
+var DEFAULT_FLAGS = ERROR_BIT;
+
 // src/core/scheduler.ts
 var clock = 0;
-function getClock() {
-  return clock;
-}
 function incrementClock() {
   clock++;
 }
+var ActiveTransition = null;
+var unobserved = [];
 var scheduled = false;
 function schedule() {
   if (scheduled)
     return;
   scheduled = true;
-  if (!globalQueue.K)
+  if (!globalQueue.x)
     queueMicrotask(flush);
 }
+function notifyUnobserved() {
+  for (let i = 0; i < unobserved.length; i++) {
+    const source = unobserved[i];
+    if (!source.d || !source.d.length)
+      unobserved[i].ca?.();
+  }
+  unobserved = [];
+}
 var pureQueue = [];
 var Queue = class {
-  o = null;
-  K = false;
-  L = [[], []];
-  F = [];
+  p = null;
+  x = false;
+  o = [[], []];
+  q = [];
   created = clock;
   enqueue(type, fn) {
+    if (ActiveTransition)
+      return ActiveTransition.enqueue(type, fn);
     pureQueue.push(fn);
     if (type)
-      this.L[type - 1].push(fn);
+      this.o[type - 1].push(fn);
     schedule();
   }
   run(type) {
@@ -58,19 +76,19 @@ var Queue = class {
       pureQueue.length && runQueue(pureQueue, type);
       pureQueue = [];
       return;
-    } else if (this.L[type - 1].length) {
-      const effects = this.L[type - 1];
-      this.L[type - 1] = [];
+    } else if (this.o[type - 1].length) {
+      const effects = this.o[type - 1];
+      this.o[type - 1] = [];
       runQueue(effects, type);
     }
-    for (let i = 0; i < this.F.length; i++) {
-      this.F[i].run(type);
+    for (let i = 0; i < this.q.length; i++) {
+      this.q[i].run(type);
     }
   }
   flush() {
-    if (this.K)
+    if (this.x)
       return;
-    this.K = true;
+    this.x = true;
     try {
       this.run(EFFECT_PURE);
       incrementClock();
@@ -78,21 +96,22 @@ var Queue = class {
       this.run(EFFECT_RENDER);
       this.run(EFFECT_USER);
     } finally {
-      this.K = false;
+      this.x = false;
+      unobserved.length && notifyUnobserved();
     }
   }
   addChild(child) {
-    this.F.push(child);
-    child.o = this;
+    this.q.push(child);
+    child.p = this;
   }
   removeChild(child) {
-    const index = this.F.indexOf(child);
+    const index = this.q.indexOf(child);
     if (index >= 0)
-      this.F.splice(index, 1);
+      this.q.splice(index, 1);
   }
   notify(...args) {
-    if (this.o)
-      return this.o.notify(...args);
+    if (this.p)
+      return this.p.notify(...args);
     return false;
   }
 };
@@ -106,6 +125,200 @@ function runQueue(queue, type) {
   for (let i = 0; i < queue.length; i++)
     queue[i](type);
 }
+var Transition = class _Transition {
+  a = /* @__PURE__ */ new Map();
+  t = /* @__PURE__ */ new Set();
+  M = /* @__PURE__ */ new Set();
+  T = /* @__PURE__ */ new Set();
+  E = false;
+  o = [[], []];
+  F = [];
+  q = [];
+  p = null;
+  x = false;
+  U = false;
+  created = clock;
+  enqueue(type, fn) {
+    this.F.push(fn);
+    if (type)
+      this.o[type - 1].push(fn);
+    this.schedule();
+  }
+  run(type) {
+    if (type === EFFECT_PURE) {
+      this.F.length && runQueue(this.F, type);
+      this.F = [];
+      return;
+    } else if (this.o[type - 1].length) {
+      const effects = this.o[type - 1];
+      this.o[type - 1] = [];
+      runQueue(effects, type);
+    }
+    for (let i = 0; i < this.q.length; i++) {
+      this.q[i].run(type);
+    }
+  }
+  flush() {
+    if (this.x)
+      return;
+    this.x = true;
+    let currentTransition = ActiveTransition;
+    ActiveTransition = this;
+    try {
+      this.run(EFFECT_PURE);
+      incrementClock();
+      this.U = false;
+      ActiveTransition = currentTransition;
+      finishTransition(this);
+    } finally {
+      this.x = false;
+      ActiveTransition = currentTransition;
+    }
+  }
+  addChild(child) {
+    this.q.push(child);
+    child.p = this;
+  }
+  removeChild(child) {
+    const index = this.q.indexOf(child);
+    if (index >= 0)
+      this.q.splice(index, 1);
+  }
+  notify(node, type, flags) {
+    if (!(type & LOADING_BIT))
+      return false;
+    if (flags & LOADING_BIT) {
+      this.t.add(node);
+    } else {
+      this.t.delete(node);
+    }
+    return true;
+  }
+  schedule() {
+    if (this.U)
+      return;
+    this.U = true;
+    if (!this.x)
+      queueMicrotask(() => this.flush());
+  }
+  runTransition(fn, force = false) {
+    if (this.E) {
+      if (this.E instanceof _Transition)
+        return this.E.runTransition(fn, force);
+      if (!force)
+        throw new Error("Transition already completed");
+      fn();
+      return;
+    }
+    ActiveTransition = this;
+    try {
+      const result = fn();
+      const transition2 = ActiveTransition;
+      if (result instanceof Promise) {
+        transition2.M.add(result);
+        result.finally(() => {
+          transition2.M.delete(result);
+          finishTransition(transition2);
+        });
+      }
+    } finally {
+      const transition2 = ActiveTransition;
+      ActiveTransition = null;
+      finishTransition(transition2);
+    }
+  }
+  addOptimistic(fn) {
+    if (fn.h && fn.h !== this) {
+      mergeTransitions(fn.h, this);
+      ActiveTransition = fn.h;
+      return;
+    }
+    fn.h = this;
+    this.T.add(fn);
+  }
+};
+var Transitions = /* @__PURE__ */ new Set();
+function transition(fn) {
+  let t = new Transition();
+  Transitions.add(t);
+  queueMicrotask(() => t.runTransition(() => fn((fn2) => t.runTransition(fn2))));
+}
+function cloneGraph(node) {
+  if (node.h) {
+    if (node.h !== ActiveTransition) {
+      mergeTransitions(node.h, ActiveTransition);
+      ActiveTransition = node.h;
+    }
+    return node.h.a.get(node);
+  }
+  const clone = Object.create(Object.getPrototypeOf(node));
+  Object.assign(clone, node, { j: null, r: null, N: node });
+  ActiveTransition.a.set(node, clone);
+  node.h = ActiveTransition;
+  if (node.d) {
+    for (let i = 0, length = node.d.length; i < length; i++) {
+      const o = node.d[i];
+      node.d.push(cloneGraph(o));
+    }
+  }
+  return clone;
+}
+function removeSourceObservers(node, index) {
+  let source;
+  let swap;
+  for (let i = index; i < node.a.length; i++) {
+    source = ActiveTransition && ActiveTransition.a.get(node.a[i]) || node.a[i];
+    if (source.d) {
+      if ((swap = source.d.indexOf(node)) !== -1) {
+        source.d[swap] = source.d[source.d.length - 1];
+        source.d.pop();
+      }
+      if (!source.d.length)
+        unobserved.push(source);
+    }
+  }
+}
+function mergeTransitions(t1, t2) {
+  t2.a.forEach((value, key) => {
+    key.h = t1;
+    t1.a.set(key, value);
+  });
+  t2.T.forEach((c) => {
+    c.h = t1;
+    t1.T.add(c);
+  });
+  t2.M.forEach((p) => t1.M.add(p));
+  t2.t.forEach((n) => t1.t.add(n));
+  t2.o[0].forEach((f) => t1.o[0].push(f));
+  t2.o[1].forEach((f) => t1.o[1].push(f));
+  t2.F.forEach((f) => t1.F.push(f));
+  t2.q.forEach((c) => t1.addChild(c));
+  t2.E = t1;
+  Transitions.delete(t2);
+}
+function finishTransition(transition2) {
+  if (transition2.E || transition2.U || transition2.M.size || transition2.t.size)
+    return;
+  for (const [source, clone] of transition2.a) {
+    if (source === clone || source.h !== transition2)
+      continue;
+    if (clone.a)
+      removeSourceObservers(clone, 0);
+    source.dispose(false);
+    source.emptyDisposal();
+    Object.assign(source, clone);
+    delete source.N;
+    delete source.h;
+  }
+  transition2.E = true;
+  Transitions.delete(transition2);
+  transition2.run(EFFECT_RENDER);
+  transition2.run(EFFECT_USER);
+  for (const reset of transition2.T) {
+    delete reset.h;
+    reset();
+  }
+}
 
 // src/core/owner.ts
 var currentOwner = null;
@@ -122,14 +335,14 @@ var Owner = class {
   // We flatten the owner tree into a linked list so that we don't need a pointer to .firstChild
   // However, the children are actually added in reverse creation order
   // See comment at the top of the file for an example of the _nextSibling traversal
-  o = null;
-  m = null;
-  t = null;
-  a = STATE_CLEAN;
-  l = null;
-  p = defaultContext;
-  h = globalQueue;
-  W = 0;
+  p = null;
+  r = null;
+  z = null;
+  b = STATE_CLEAN;
+  j = null;
+  u = defaultContext;
+  i = globalQueue;
+  da = 0;
   id = null;
   constructor(id = null, skipAppend = false) {
     this.id = id;
@@ -138,64 +351,64 @@ var Owner = class {
     }
   }
   append(child) {
-    child.o = this;
-    child.t = this;
-    if (this.m)
-      this.m.t = child;
-    child.m = this.m;
-    this.m = child;
+    child.p = this;
+    child.z = this;
+    if (this.r)
+      this.r.z = child;
+    child.r = this.r;
+    this.r = child;
     if (this.id != null && child.id == null)
       child.id = this.getNextChildId();
-    if (child.p !== this.p) {
-      child.p = { ...this.p, ...child.p };
+    if (child.u !== this.u) {
+      child.u = { ...this.u, ...child.u };
     }
-    if (this.h)
-      child.h = this.h;
+    if (this.i)
+      child.i = this.i;
   }
   dispose(self = true) {
-    if (this.a === STATE_DISPOSED)
+    if (this.b === STATE_DISPOSED)
       return;
-    let head = self ? this.t || this.o : this, current = this.m, next = null;
-    while (current && current.o === this) {
+    let head = self ? this.z || this.p : this, current = this.r, next = null;
+    while (current && current.p === this) {
       current.dispose(true);
-      current.z();
-      next = current.m;
-      current.m = null;
+      current.G();
+      next = current.r;
+      current.r = null;
       current = next;
     }
-    this.W = 0;
+    this.da = 0;
     if (self)
-      this.z();
+      this.G();
     if (current)
-      current.t = !self ? this : this.t;
+      current.z = !self ? this : this.z;
     if (head)
-      head.m = current;
-  }
-  z() {
-    if (this.t)
-      this.t.m = null;
-    this.o = null;
-    this.t = null;
-    this.p = defaultContext;
-    this.a = STATE_DISPOSED;
+      head.r = current;
+  }
+  G() {
+    if (this.z)
+      this.z.r = null;
+    this.p = null;
+    this.z = null;
+    this.u = defaultContext;
+    this.b = STATE_DISPOSED;
     this.emptyDisposal();
   }
   emptyDisposal() {
-    if (!this.l)
+    if (!this.j)
       return;
-    if (Array.isArray(this.l)) {
-      for (let i = 0; i < this.l.length; i++) {
-        const callable = this.l[i];
+    if (Array.isArray(this.j)) {
+      for (let i = 0; i < this.j.length; i++) {
+        const callable = this.j[i];
         callable.call(callable);
       }
     } else {
-      this.l.call(this.l);
+      this.j.call(this.j);
     }
-    this.l = null;
+    this.j = null;
   }
   getNextChildId() {
     if (this.id != null)
-      return formatId(this.id, this.W++);
+      return formatId(this.id, this.da++);
     throw new Error("Cannot get child id from owner without an id");
   }
 };
@@ -206,7 +419,7 @@ function getContext(context, owner = currentOwner) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  const value = hasContext(context, owner) ? owner.p[context.id] : context.defaultValue;
+  const value = hasContext(context, owner) ? owner.u[context.id] : context.defaultValue;
   if (isUndefined(value)) {
     throw new ContextNotFoundError();
   }
@@ -216,24 +429,24 @@ function setContext(context, value, owner = currentOwner) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  owner.p = {
-    ...owner.p,
+  owner.u = {
+    ...owner.u,
     [context.id]: isUndefined(value) ? context.defaultValue : value
   };
 }
 function hasContext(context, owner = currentOwner) {
-  return !isUndefined(owner?.p[context.id]);
+  return !isUndefined(owner?.u[context.id]);
 }
 function onCleanup(fn) {
   if (!currentOwner)
     return fn;
   const node = currentOwner;
-  if (!node.l) {
-    node.l = fn;
-  } else if (Array.isArray(node.l)) {
-    node.l.push(fn);
+  if (!node.j) {
+    node.j = fn;
+  } else if (Array.isArray(node.j)) {
+    node.j.push(fn);
   } else {
-    node.l = [node.l, fn];
+    node.j = [node.j, fn];
   }
   return fn;
 }
@@ -245,22 +458,12 @@ function isUndefined(value) {
   return typeof value === "undefined";
 }
 
-// src/core/flags.ts
-var ERROR_OFFSET = 0;
-var ERROR_BIT = 1 << ERROR_OFFSET;
-var LOADING_OFFSET = 1;
-var LOADING_BIT = 1 << LOADING_OFFSET;
-var UNINITIALIZED_OFFSET = 2;
-var UNINITIALIZED_BIT = 1 << UNINITIALIZED_OFFSET;
-var DEFAULT_FLAGS = ERROR_BIT;
-
 // src/core/core.ts
 var currentObserver = null;
 var currentMask = DEFAULT_FLAGS;
 var newSources = null;
 var newSourcesIndex = 0;
 var newFlags = 0;
-var unobserved = [];
 var notStale = false;
 var updateCheck = null;
 var staleCheck = null;
@@ -269,48 +472,48 @@ function getObserver() {
 }
 var UNCHANGED = Symbol(0);
 var Computation = class extends Owner {
-  c = null;
+  a = null;
   d = null;
   g;
-  G;
-  A;
+  O;
+  H;
   // Used in __DEV__ mode, hopefully removed in production
-  ca;
+  ja;
   // Using false is an optimization as an alternative to _equals: () => false
   // which could enable more efficient DIRTY notification
-  S = isEqual;
-  X;
-  _ = false;
+  _ = isEqual;
+  ca;
+  fa = false;
   /** Whether the computation is an error or has ancestors that are unresolved */
   f = 0;
   /** Which flags raised by sources are handled, vs. being passed through. */
-  T = DEFAULT_FLAGS;
-  B = -1;
-  x = false;
+  $ = DEFAULT_FLAGS;
+  I = -1;
+  C = false;
+  h;
+  N;
   constructor(initialValue, compute2, options) {
     super(options?.id, compute2 === null);
-    this.A = compute2;
-    this.a = compute2 ? STATE_DIRTY : STATE_CLEAN;
+    this.H = compute2;
+    this.b = compute2 ? STATE_DIRTY : STATE_CLEAN;
     this.f = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
     this.g = initialValue;
     if (options?.equals !== void 0)
-      this.S = options.equals;
+      this._ = options.equals;
     if (options?.pureWrite)
-      this._ = true;
+      this.fa = true;
     if (options?.unobserved)
-      this.X = options?.unobserved;
-  }
-  Y() {
-    if (this.A) {
-      if (this.f & ERROR_BIT && this.B <= getClock())
-        update(this);
-      else
-        this.y();
+      this.ca = options?.unobserved;
+    if (ActiveTransition) {
+      this.h = ActiveTransition;
+      ActiveTransition.a.set(this, this);
     }
+  }
+  ea() {
     track(this);
     newFlags |= this.f & ~currentMask;
     if (this.f & ERROR_BIT) {
-      throw this.G;
+      throw this.O;
     } else {
       return this.g;
     }
@@ -320,7 +523,18 @@ var Computation = class extends Owner {
    * Automatically re-executes the surrounding computation when the value changes
    */
   read() {
-    return this.Y();
+    if (ActiveTransition && ActiveTransition.a.has(this)) {
+      const clone = ActiveTransition.a.get(this);
+      if (clone !== this)
+        return clone.read();
+    }
+    if (this.H) {
+      if (this.f & ERROR_BIT && this.I <= clock)
+        update(this);
+      else
+        this.D();
+    }
+    return this.ea();
   }
   /**
    * Return the current value of this computation
@@ -330,38 +544,48 @@ var Computation = class extends Owner {
    * before continuing
    */
   wait() {
-    if (this.A && this.f & ERROR_BIT && this.B <= getClock()) {
-      update(this);
-    } else {
-      this.y();
+    if (ActiveTransition && ActiveTransition.a.has(this)) {
+      const clone = ActiveTransition.a.get(this);
+      if (clone !== this)
+        return clone.wait();
+    }
+    if (this.H) {
+      if (this.f & ERROR_BIT && this.I <= clock)
+        update(this);
+      else
+        this.D();
     }
-    track(this);
     if ((notStale || this.f & UNINITIALIZED_BIT) && this.f & LOADING_BIT) {
+      track(this);
       throw new NotReadyError();
     }
     if (staleCheck && this.f & LOADING_BIT) {
       staleCheck.g = true;
     }
-    return this.Y();
+    return this.ea();
   }
   /** Update the computation with a new value. */
   write(value, flags = 0, raw = false) {
+    if (ActiveTransition && !this.N) {
+      const clone = cloneGraph(this);
+      return clone.write(value, flags, raw);
+    }
     const newValue = !raw && typeof value === "function" ? value(this.g) : value;
     const valueChanged = newValue !== UNCHANGED && (!!(this.f & UNINITIALIZED_BIT) || // this._stateFlags & LOADING_BIT & ~flags ||
-    this.S === false || !this.S(this.g, newValue));
+    this._ === false || !this._(this.g, newValue));
     if (valueChanged) {
       this.g = newValue;
-      this.G = void 0;
+      this.O = void 0;
     }
     const changedFlagsMask = this.f ^ flags, changedFlags = changedFlagsMask & flags;
     this.f = flags;
-    this.B = getClock() + 1;
+    this.I = clock + 1;
     if (this.d) {
       for (let i = 0; i < this.d.length; i++) {
         if (valueChanged) {
-          this.d[i].r(STATE_DIRTY);
+          this.d[i].k(STATE_DIRTY);
         } else if (changedFlagsMask) {
-          this.d[i].Z(changedFlagsMask, changedFlags);
+          this.d[i].V(changedFlagsMask, changedFlags);
         }
       }
     }
@@ -370,14 +594,19 @@ var Computation = class extends Owner {
   /**
    * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
    */
-  r(state, skipQueue) {
-    if (this.a >= state && !this.x)
+  k(state, skipQueue) {
+    if (ActiveTransition && ActiveTransition.a.has(this)) {
+      const clone = ActiveTransition.a.get(this);
+      if (clone !== this)
+        return clone.k(state, skipQueue);
+    }
+    if (this.b >= state && !this.C)
       return;
-    this.x = !!skipQueue;
-    this.a = state;
+    this.C = !!skipQueue;
+    this.b = state;
     if (this.d) {
       for (let i = 0; i < this.d.length; i++) {
-        this.d[i].r(STATE_CHECK, skipQueue);
+        this.d[i].k(STATE_CHECK, skipQueue);
       }
     }
   }
@@ -387,30 +616,30 @@ 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.a >= STATE_DIRTY)
+  V(mask, newFlags2) {
+    if (this.b >= STATE_DIRTY)
       return;
-    if (mask & this.T) {
-      this.r(STATE_DIRTY);
+    if (mask & this.$) {
+      this.k(STATE_DIRTY);
       return;
     }
-    if (this.a >= STATE_CHECK)
+    if (this.b >= STATE_CHECK)
       return;
     const prevFlags = this.f & mask;
     const deltaFlags = prevFlags ^ newFlags2;
     if (newFlags2 === prevFlags) ; else if (deltaFlags & prevFlags & mask) {
-      this.r(STATE_CHECK);
+      this.k(STATE_CHECK);
     } else {
       this.f ^= deltaFlags;
       if (this.d) {
         for (let i = 0; i < this.d.length; i++) {
-          this.d[i].Z(mask, newFlags2);
+          this.d[i].V(mask, newFlags2);
         }
       }
     }
   }
-  M(error) {
-    this.G = error;
+  P(error) {
+    this.O = error;
     this.write(UNCHANGED, this.f & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
   }
   /**
@@ -420,47 +649,50 @@ var Computation = class extends Owner {
    *
    * This function will ensure that the value and states we read from the computation are up to date
    */
-  y() {
-    if (!this.A) {
+  D() {
+    if (!this.H) {
       return;
     }
-    if (this.a === STATE_DISPOSED) {
+    if (this.b === STATE_DISPOSED) {
       return;
     }
-    if (this.a === STATE_CLEAN) {
+    if (this.b === STATE_CLEAN) {
       return;
     }
     let observerFlags = 0;
-    if (this.a === STATE_CHECK) {
-      for (let i = 0; i < this.c.length; i++) {
-        this.c[i].y();
-        observerFlags |= this.c[i].f;
-        if (this.a === STATE_DIRTY) {
+    if (this.b === STATE_CHECK) {
+      for (let i = 0; i < this.a.length; i++) {
+        const source = ActiveTransition && ActiveTransition.a.get(this.a[i]) || this.a[i];
+        source.D();
+        observerFlags |= source.f;
+        if (this.b === STATE_DIRTY) {
           break;
         }
       }
     }
-    if (this.a === STATE_DIRTY) {
+    if (this.b === STATE_DIRTY) {
       update(this);
     } else {
       this.write(UNCHANGED, observerFlags);
-      this.a = STATE_CLEAN;
+      this.b = STATE_CLEAN;
     }
   }
   /**
    * Remove ourselves from the owner graph and the computation graph
    */
-  z() {
-    if (this.a === STATE_DISPOSED)
+  G() {
+    if (this.b === STATE_DISPOSED)
       return;
-    if (this.c)
+    if (this.a)
       removeSourceObservers(this, 0);
-    super.z();
+    super.G();
   }
 };
 function track(computation) {
+  if (ActiveTransition && computation.N)
+    computation = computation.N;
   if (currentObserver) {
-    if (!newSources && currentObserver.c && currentObserver.c[newSourcesIndex] === computation) {
+    if (!newSources && currentObserver.a && currentObserver.a[newSourcesIndex] === computation) {
       newSourcesIndex++;
     } else if (!newSources)
       newSources = [computation];
@@ -468,7 +700,7 @@ function track(computation) {
       newSources.push(computation);
     }
     if (updateCheck) {
-      updateCheck.g = computation.B > currentObserver.B;
+      updateCheck.g = computation.I > currentObserver.I;
     }
   }
 }
@@ -480,68 +712,45 @@ function update(node) {
   try {
     node.dispose(false);
     node.emptyDisposal();
-    const result = compute(node, node.A, node);
+    const result = compute(node, node.H, node);
     node.write(result, newFlags, true);
   } catch (error) {
     if (error instanceof NotReadyError) {
       node.write(UNCHANGED, newFlags | LOADING_BIT | node.f & UNINITIALIZED_BIT);
     } else {
-      node.M(error);
+      node.P(error);
     }
   } finally {
     if (newSources) {
-      if (node.c)
+      if (node.a)
         removeSourceObservers(node, newSourcesIndex);
-      if (node.c && newSourcesIndex > 0) {
-        node.c.length = newSourcesIndex + newSources.length;
+      if (node.a && newSourcesIndex > 0) {
+        node.a.length = newSourcesIndex + newSources.length;
         for (let i = 0; i < newSources.length; i++) {
-          node.c[newSourcesIndex + i] = newSources[i];
+          node.a[newSourcesIndex + i] = newSources[i];
         }
       } else {
-        node.c = newSources;
+        node.a = newSources;
       }
       let source;
-      for (let i = newSourcesIndex; i < node.c.length; i++) {
-        source = node.c[i];
+      for (let i = newSourcesIndex; i < node.a.length; i++) {
+        source = node.a[i];
         if (!source.d)
           source.d = [node];
         else
           source.d.push(node);
       }
-    } else if (node.c && newSourcesIndex < node.c.length) {
+    } else if (node.a && newSourcesIndex < node.a.length) {
       removeSourceObservers(node, newSourcesIndex);
-      node.c.length = newSourcesIndex;
+      node.a.length = newSourcesIndex;
     }
-    unobserved.length && notifyUnobserved();
     newSources = prevSources;
     newSourcesIndex = prevSourcesIndex;
     newFlags = prevFlags;
-    node.B = getClock() + 1;
-    node.a = STATE_CLEAN;
+    node.I = clock + 1;
+    node.b = STATE_CLEAN;
   }
 }
-function removeSourceObservers(node, index) {
-  let source;
-  let swap;
-  for (let i = index; i < node.c.length; i++) {
-    source = node.c[i];
-    if (source.d) {
-      swap = source.d.indexOf(node);
-      source.d[swap] = source.d[source.d.length - 1];
-      source.d.pop();
-      if (!source.d.length)
-        unobserved.push(source);
-    }
-  }
-}
-function notifyUnobserved() {
-  for (let i = 0; i < unobserved.length; i++) {
-    const source = unobserved[i];
-    if (!source.d || !source.d.length)
-      unobserved[i].X?.();
-  }
-  unobserved = [];
-}
 function isEqual(a, b) {
   return a === b;
 }
@@ -580,7 +789,7 @@ function isPending(fn, loadingValue) {
   if (!currentObserver)
     return pendingCheck(fn, loadingValue);
   const c = new Computation(void 0, () => pendingCheck(fn, loadingValue));
-  c.T |= LOADING_BIT;
+  c.$ |= LOADING_BIT;
   return c.read();
 }
 function latest(fn, fallback) {
@@ -602,7 +811,7 @@ function latest(fn, fallback) {
 function runWithObserver(observer, run) {
   const prevSources = newSources, prevSourcesIndex = newSourcesIndex, prevFlags = newFlags;
   newSources = null;
-  newSourcesIndex = observer.c ? observer.c.length : 0;
+  newSourcesIndex = observer.a ? observer.a.length : 0;
   newFlags = 0;
   try {
     return compute(observer, run, observer);
@@ -613,21 +822,21 @@ function runWithObserver(observer, run) {
         newFlags | LOADING_BIT | observer.f & UNINITIALIZED_BIT
       );
     } else {
-      observer.M(error);
+      observer.P(error);
     }
   } finally {
     if (newSources) {
       if (newSourcesIndex > 0) {
-        observer.c.length = newSourcesIndex + newSources.length;
+        observer.a.length = newSourcesIndex + newSources.length;
         for (let i = 0; i < newSources.length; i++) {
-          observer.c[newSourcesIndex + i] = newSources[i];
+          observer.a[newSourcesIndex + i] = newSources[i];
         }
       } else {
-        observer.c = newSources;
+        observer.a = newSources;
       }
       let source;
-      for (let i = newSourcesIndex; i < observer.c.length; i++) {
-        source = observer.c[i];
+      for (let i = newSourcesIndex; i < observer.a.length; i++) {
+        source = observer.a[i];
         if (!source.d)
           source.d = [observer];
         else
@@ -642,7 +851,7 @@ function runWithObserver(observer, run) {
 function compute(owner, fn, observer) {
   const prevOwner = setOwner(owner), prevObserver = currentObserver, prevMask = currentMask, prevNotStale = notStale;
   currentObserver = observer;
-  currentMask = observer?.T ?? DEFAULT_FLAGS;
+  currentMask = observer?.$ ?? DEFAULT_FLAGS;
   notStale = true;
   try {
     return fn(observer ? observer.g : void 0);
@@ -656,104 +865,120 @@ function compute(owner, fn, observer) {
 
 // src/core/effect.ts
 var Effect = class extends Computation {
-  U;
-  N;
-  C;
-  V = false;
-  O;
-  s;
+  aa;
+  W;
+  J;
+  ba = false;
+  X;
+  y;
   constructor(initialValue, compute2, effect, error, options) {
     super(initialValue, compute2, options);
-    this.U = effect;
-    this.N = error;
-    this.O = initialValue;
-    this.s = options?.render ? EFFECT_RENDER : EFFECT_USER;
-    if (this.s === EFFECT_RENDER) {
-      this.A = (p) => getClock() > this.h.created && !(this.f & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
+    this.aa = effect;
+    this.W = error;
+    this.X = initialValue;
+    this.y = options?.render ? EFFECT_RENDER : EFFECT_USER;
+    if (this.y === EFFECT_RENDER) {
+      this.H = (p) => !ActiveTransition && clock > this.i.created && !(this.f & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
     }
-    this.y();
-    !options?.defer && (this.s === EFFECT_USER ? this.h.enqueue(this.s, this.u.bind(this)) : this.u(this.s));
+    this.D();
+    !options?.defer && (this.y === EFFECT_USER ? (ActiveTransition || this.i).enqueue(this.y, this.A.bind(this)) : this.A(this.y));
   }
   write(value, flags = 0) {
-    if (this.a == STATE_DIRTY) {
-      this.f;
+    if (this.b == STATE_DIRTY || flags !== this.f) {
       this.f = flags;
-      if (this.s === EFFECT_RENDER) {
-        this.h.notify(this, LOADING_BIT | ERROR_BIT, flags);
+      if (this.y === EFFECT_RENDER) {
+        (ActiveTransition || this.i).notify(this, LOADING_BIT | ERROR_BIT, flags);
       }
     }
     if (value === UNCHANGED)
       return this.g;
     this.g = value;
-    this.V = true;
+    this.ba = true;
     return value;
   }
-  r(state, skipQueue) {
-    if (this.a >= state || skipQueue)
+  k(state, skipQueue) {
+    if (ActiveTransition && ActiveTransition.a.has(this)) {
+      return ActiveTransition.a.get(this).k(state, skipQueue);
+    }
+    if (this.b >= state || skipQueue)
       return;
-    if (this.a === STATE_CLEAN)
-      this.h.enqueue(this.s, this.u.bind(this));
-    this.a = state;
+    if (this.b === STATE_CLEAN)
+      (ActiveTransition || this.i).enqueue(this.y, this.A.bind(this));
+    this.b = state;
+  }
+  V(mask, newFlags2) {
+    if (ActiveTransition && ActiveTransition.a.has(this)) {
+      if (this.b >= STATE_CHECK)
+        return;
+      if (mask & 3) {
+        this.k(STATE_DIRTY);
+        return;
+      }
+    }
+    super.V(mask, newFlags2);
   }
-  M(error) {
-    this.G = error;
-    this.h.notify(this, LOADING_BIT, 0);
+  P(error) {
+    this.O = error;
+    (ActiveTransition || this.i).notify(this, LOADING_BIT, 0);
     this.f = ERROR_BIT;
-    if (this.s === EFFECT_USER) {
+    if (this.y === EFFECT_USER) {
       try {
-        return this.N ? this.N(error, () => {
-          this.C?.();
-          this.C = void 0;
+        return this.W ? this.W(error, () => {
+          this.J?.();
+          this.J = void 0;
         }) : console.error(error);
       } catch (e) {
         error = e;
       }
     }
-    if (!this.h.notify(this, ERROR_BIT, ERROR_BIT))
+    if (!(ActiveTransition || this.i).notify(this, ERROR_BIT, ERROR_BIT))
       throw error;
   }
-  z() {
-    if (this.a === STATE_DISPOSED)
+  G() {
+    if (this.b === STATE_DISPOSED)
       return;
-    this.U = void 0;
-    this.O = void 0;
-    this.N = void 0;
-    this.C?.();
-    this.C = void 0;
-    super.z();
-  }
-  u(type) {
+    this.aa = void 0;
+    this.X = void 0;
+    this.W = void 0;
+    this.J?.();
+    this.J = void 0;
+    super.G();
+  }
+  A(type) {
     if (type) {
-      if (this.V && this.a !== STATE_DISPOSED) {
-        this.C?.();
+      if (this.ba && this.b !== STATE_DISPOSED) {
+        this.J?.();
         try {
-          this.C = this.U(this.g, this.O);
+          this.J = this.aa(this.g, this.X);
         } catch (e) {
-          if (!this.h.notify(this, ERROR_BIT, ERROR_BIT))
+          if (!(ActiveTransition || this.i).notify(this, ERROR_BIT, ERROR_BIT))
             throw e;
         } finally {
-          this.O = this.g;
-          this.V = false;
+          this.X = this.g;
+          this.ba = false;
         }
       }
     } else
-      this.a !== STATE_CLEAN && runTop(this);
+      this.b !== STATE_CLEAN && runTop(this);
   }
 };
 var EagerComputation = class extends Computation {
   constructor(initialValue, compute2, options) {
     super(initialValue, compute2, options);
-    !options?.defer && this.y();
+    !options?.defer && this.D();
   }
-  r(state, skipQueue) {
-    if (this.a >= state && !this.x)
+  k(state, skipQueue) {
+    if (ActiveTransition && ActiveTransition.a.has(this)) {
+      return ActiveTransition.a.get(this).k(state, skipQueue);
+    }
+    if (this.b >= state && !this.C)
       return;
-    if (!skipQueue && (this.a === STATE_CLEAN || this.a === STATE_CHECK && this.x))
-      this.h.enqueue(EFFECT_PURE, this.u.bind(this));
-    super.r(state, skipQueue);
+    if (!skipQueue && (this.b === STATE_CLEAN || this.b === STATE_CHECK && this.C))
+      (ActiveTransition || this.i).enqueue(EFFECT_PURE, this.A.bind(this));
+    super.k(state, skipQueue);
   }
-  u() {
-    this.a !== STATE_CLEAN && runTop(this);
+  A() {
+    this.b !== STATE_CLEAN && runTop(this);
   }
 };
 var FirewallComputation = class extends Computation {
@@ -761,193 +986,34 @@ var FirewallComputation = class extends Computation {
   constructor(compute2) {
     super(void 0, compute2);
   }
-  r(state, skipQueue) {
-    if (this.a >= state && !this.x)
+  k(state, skipQueue) {
+    if (ActiveTransition && ActiveTransition.a.has(this)) {
+      return ActiveTransition.a.get(this).k(state, skipQueue);
+    }
+    if (this.b >= state && !this.C)
       return;
-    if (!skipQueue && (this.a === STATE_CLEAN || this.a === STATE_CHECK && this.x))
-      this.h.enqueue(EFFECT_PURE, this.u.bind(this));
-    super.r(state, true);
-    this.x = !!skipQueue;
+    if (!skipQueue && (this.b === STATE_CLEAN || this.b === STATE_CHECK && this.C))
+      (ActiveTransition || this.i).enqueue(EFFECT_PURE, this.A.bind(this));
+    super.k(state, true);
+    this.C = !!skipQueue;
   }
-  u() {
-    this.a !== STATE_CLEAN && runTop(this);
+  A() {
+    this.b !== STATE_CLEAN && runTop(this);
   }
 };
 function runTop(node) {
   const ancestors = [];
-  for (let current = node; current !== null; current = current.o) {
-    if (current.a !== STATE_CLEAN) {
+  for (let current = node; current !== null; current = current.p) {
+    if (current.b !== STATE_CLEAN) {
       ancestors.push(current);
     }
   }
   for (let i = ancestors.length - 1; i >= 0; i--) {
-    if (ancestors[i].a !== STATE_DISPOSED)
-      ancestors[i].y();
+    if (ancestors[i].b !== STATE_DISPOSED)
+      ancestors[i].D();
   }
 }
 
-// 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.a === STATE_DISPOSED) {
-        node = void 0;
-        return resolvedValue;
-      }
-      resolvedValue = node.wait();
-      if (!node.c?.length && node.m?.o !== node) {
-        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);
-      if (isPromise) {
-        source.then(
-          (value3) => {
-            if (abort)
-              return;
-            node.write(value3, 0, true);
-          },
-          (error) => {
-            if (abort)
-              return;
-            node.M(error);
-          }
-        );
-      } else {
-        (async () => {
-          try {
-            for await (let value3 of source) {
-              if (abort)
-                return;
-              node.write(value3, 0, true);
-            }
-          } catch (error) {
-            if (abort)
-              return;
-            node.write(error, ERROR_BIT);
-          }
-        })();
-      }
-      throw new NotReadyError();
-    },
-    options
-  );
-  const read = node.wait.bind(node);
-  read.refresh = () => {
-    node.a = STATE_DIRTY;
-    refreshing = true;
-    node.y();
-  };
-  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 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 transition(fn) {
-}
-function createOptimistic(initial, compute2, options) {
-  return [];
-}
-
 // src/store/projection.ts
 function createProjection(fn, initialValue = {}) {
   let wrappedStore;
@@ -1577,198 +1643,405 @@ 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.b === STATE_DISPOSED) {
+        node = void 0;
+        return resolvedValue;
+      }
+      resolvedValue = node.wait();
+      if (!node.a?.length && node.r?.p !== node) {
+        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);
+      const 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.P(error), true);
+            node.P(error);
+          }
+        );
+      } else {
+        (async () => {
+          try {
+            for await (let value3 of source) {
+              if (abort)
+                return;
+              node.write(value3, 0, true);
+            }
+          } catch (error) {
+            if (abort)
+              return;
+            node.write(error, ERROR_BIT);
+          }
+        })();
+      }
+      throw new NotReadyError();
+    },
+    options
+  );
+  const read = node.wait.bind(node);
+  read.refresh = () => {
+    node.b = STATE_DIRTY;
+    refreshing = true;
+    node.D();
+  };
+  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 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, compute2, key) {
+  if (!compute2) {
+    let write2 = function(v) {
+      if (!ActiveTransition)
+        throw new Error("createOptimistic can only be updated inside a transition");
+      ActiveTransition.addOptimistic(reset2);
+      queueMicrotask(() => node.write(v));
+    };
+    var write = write2;
+    const node = new Computation(initial, null);
+    const reset2 = () => node.write(initial);
+    return [node.read.bind(node), write2];
+  }
+  let store, setStore;
+  if (typeof initial === "function") {
+    [store, setStore] = createStore(
+      (s) => {
+        const value = initial();
+        if (!ActiveTransition)
+          s.value = value;
+      },
+      { value: void 0 }
+    );
+  } else
+    [store, setStore] = createStore({ value: initial });
+  const reset = () => setStore(
+    (s) => reconcile(
+      typeof initial === "function" ? initial() : initial,
+      key
+    )(s.value)
+  );
+  let lastChange = void 0;
+  function write(v) {
+    if (!ActiveTransition)
+      throw new Error("createOptimistic can only be updated inside a transition");
+    ActiveTransition.addOptimistic(reset);
+    queueMicrotask(
+      () => setStore((s) => {
+        lastChange = typeof v === "function" ? v(lastChange) : v;
+        compute2(s.value, lastChange);
+      })
+    );
+  }
+  return [() => store.value, write];
+}
+
 // src/map.ts
 function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
   return updateKeyedMap.bind({
-    H: new Owner(),
-    i: 0,
-    $: list,
-    w: [],
-    D: map,
+    Q: new Owner(),
+    l: 0,
+    ga: list,
+    B: [],
+    K: map,
     e: [],
-    b: [],
-    E: keyFn,
-    j: keyFn || options?.keyed === false ? [] : void 0,
-    k: map.length > 1 ? [] : void 0,
-    I: options?.fallback
+    c: [],
+    L: keyFn,
+    m: keyFn || options?.keyed === false ? [] : void 0,
+    n: map.length > 1 ? [] : void 0,
+    R: options?.fallback
   });
 }
 var pureOptions = { pureWrite: true };
 function updateKeyedMap() {
-  const newItems = this.$() || [], newLen = newItems.length;
+  const newItems = this.ga() || [], newLen = newItems.length;
   newItems[$TRACK];
-  runWithOwner(this.H, () => {
-    let i, j, mapper = this.j ? () => {
-      this.j[j] = new Computation(newItems[j], null, pureOptions);
-      this.k && (this.k[j] = new Computation(j, null, pureOptions));
-      return this.D(
-        Computation.prototype.read.bind(this.j[j]),
-        this.k ? Computation.prototype.read.bind(this.k[j]) : void 0
+  runWithOwner(this.Q, () => {
+    let i, j, mapper = this.m ? () => {
+      this.m[j] = new Computation(newItems[j], null, pureOptions);
+      this.n && (this.n[j] = new Computation(j, null, pureOptions));
+      return this.K(
+        Computation.prototype.read.bind(this.m[j]),
+        this.n ? Computation.prototype.read.bind(this.n[j]) : void 0
       );
-    } : this.k ? () => {
+    } : this.n ? () => {
       const item = newItems[j];
-      this.k[j] = new Computation(j, null, pureOptions);
-      return this.D(() => item, Computation.prototype.read.bind(this.k[j]));
+      this.n[j] = new Computation(j, null, pureOptions);
+      return this.K(() => item, Computation.prototype.read.bind(this.n[j]));
     } : () => {
       const item = newItems[j];
-      return this.D(() => item);
+      return this.K(() => item);
     };
     if (newLen === 0) {
-      if (this.i !== 0) {
-        this.H.dispose(false);
-        this.b = [];
-        this.w = [];
+      if (this.l !== 0) {
+        this.Q.dispose(false);
+        this.c = [];
+        this.B = [];
         this.e = [];
-        this.i = 0;
-        this.j && (this.j = []);
-        this.k && (this.k = []);
+        this.l = 0;
+        this.m && (this.m = []);
+        this.n && (this.n = []);
       }
-      if (this.I && !this.e[0]) {
+      if (this.R && !this.e[0]) {
         this.e[0] = compute(
-          this.b[0] = new Owner(),
-          this.I,
+          this.c[0] = new Owner(),
+          this.R,
           null
         );
       }
-    } else if (this.i === 0) {
-      if (this.b[0])
-        this.b[0].dispose();
+    } else if (this.l === 0) {
+      if (this.c[0])
+        this.c[0].dispose();
       this.e = new Array(newLen);
       for (j = 0; j < newLen; j++) {
-        this.w[j] = newItems[j];
-        this.e[j] = compute(this.b[j] = new Owner(), mapper, null);
+        this.B[j] = newItems[j];
+        this.e[j] = compute(this.c[j] = new Owner(), mapper, null);
       }
-      this.i = newLen;
+      this.l = newLen;
     } else {
-      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.j ? new Array(newLen) : void 0, tempIndexes = this.k ? new Array(newLen) : void 0;
-      for (start = 0, end = Math.min(this.i, newLen); start < end && (this.w[start] === newItems[start] || this.j && compare(this.E, this.w[start], newItems[start])); start++) {
-        if (this.j)
-          this.j[start].write(newItems[start]);
+      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.m ? new Array(newLen) : void 0, tempIndexes = this.n ? new Array(newLen) : void 0;
+      for (start = 0, end = Math.min(this.l, newLen); start < end && (this.B[start] === newItems[start] || this.m && compare(this.L, this.B[start], newItems[start])); start++) {
+        if (this.m)
+          this.m[start].write(newItems[start]);
       }
-      for (end = this.i - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.w[end] === newItems[newEnd] || this.j && compare(this.E, this.w[end], newItems[newEnd])); end--, newEnd--) {
+      for (end = this.l - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.B[end] === newItems[newEnd] || this.m && compare(this.L, this.B[end], newItems[newEnd])); end--, newEnd--) {
         temp[newEnd] = this.e[end];
-        tempNodes[newEnd] = this.b[end];
-        tempRows && (tempRows[newEnd] = this.j[end]);
-        tempIndexes && (tempIndexes[newEnd] = this.k[end]);
+        tempNodes[newEnd] = this.c[end];
+        tempRows && (tempRows[newEnd] = this.m[end]);
+        tempIndexes && (tempIndexes[newEnd] = this.n[end]);
       }
       newIndices = /* @__PURE__ */ new Map();
       newIndicesNext = new Array(newEnd + 1);
       for (j = newEnd; j >= start; j--) {
         item = newItems[j];
-        key = this.E ? this.E(item) : item;
+        key = this.L ? this.L(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.w[i];
-        key = this.E ? this.E(item) : item;
+        item = this.B[i];
+        key = this.L ? this.L(item) : item;
         j = newIndices.get(key);
         if (j !== void 0 && j !== -1) {
           temp[j] = this.e[i];
-          tempNodes[j] = this.b[i];
-          tempRows && (tempRows[j] = this.j[i]);
-          tempIndexes && (tempIndexes[j] = this.k[i]);
+          tempNodes[j] = this.c[i];
+          tempRows && (tempRows[j] = this.m[i]);
+          tempIndexes && (tempIndexes[j] = this.n[i]);
           j = newIndicesNext[j];
           newIndices.set(key, j);
         } else
-          this.b[i].dispose();
+          this.c[i].dispose();
       }
       for (j = start; j < newLen; j++) {
         if (j in temp) {
           this.e[j] = temp[j];
-          this.b[j] = tempNodes[j];
+          this.c[j] = tempNodes[j];
           if (tempRows) {
-            this.j[j] = tempRows[j];
-            this.j[j].write(newItems[j]);
+            this.m[j] = tempRows[j];
+            this.m[j].write(newItems[j]);
           }
           if (tempIndexes) {
-            this.k[j] = tempIndexes[j];
-            this.k[j].write(j);
+            this.n[j] = tempIndexes[j];
+            this.n[j].write(j);
           }
         } else {
-          this.e[j] = compute(this.b[j] = new Owner(), mapper, null);
+          this.e[j] = compute(this.c[j] = new Owner(), mapper, null);
         }
       }
-      this.e = this.e.slice(0, this.i = newLen);
-      this.w = newItems.slice(0);
+      this.e = this.e.slice(0, this.l = newLen);
+      this.B = newItems.slice(0);
     }
   });
   return this.e;
 }
 function repeat(count, map, options) {
   return updateRepeat.bind({
-    H: new Owner(),
-    i: 0,
-    q: 0,
-    aa: count,
-    D: map,
-    b: [],
+    Q: new Owner(),
+    l: 0,
+    w: 0,
+    ha: count,
+    K: map,
+    c: [],
     e: [],
-    ba: options?.from,
-    I: options?.fallback
+    ia: options?.from,
+    R: options?.fallback
   });
 }
 function updateRepeat() {
-  const newLen = this.aa();
-  const from = this.ba?.() || 0;
-  runWithOwner(this.H, () => {
+  const newLen = this.ha();
+  const from = this.ia?.() || 0;
+  runWithOwner(this.Q, () => {
     if (newLen === 0) {
-      if (this.i !== 0) {
-        this.H.dispose(false);
-        this.b = [];
+      if (this.l !== 0) {
+        this.Q.dispose(false);
+        this.c = [];
         this.e = [];
-        this.i = 0;
+        this.l = 0;
       }
-      if (this.I && !this.e[0]) {
+      if (this.R && !this.e[0]) {
         this.e[0] = compute(
-          this.b[0] = new Owner(),
-          this.I,
+          this.c[0] = new Owner(),
+          this.R,
           null
         );
       }
       return;
     }
     const to = from + newLen;
-    const prevTo = this.q + this.i;
-    if (this.i === 0 && this.b[0])
-      this.b[0].dispose();
+    const prevTo = this.w + this.l;
+    if (this.l === 0 && this.c[0])
+      this.c[0].dispose();
     for (let i = to; i < prevTo; i++)
-      this.b[i - this.q].dispose();
-    if (this.q < from) {
-      let i = this.q;
-      while (i < from && i < this.i)
-        this.b[i++].dispose();
-      this.b.splice(0, from - this.q);
-      this.e.splice(0, from - this.q);
-    } else if (this.q > from) {
-      let i = prevTo - this.q - 1;
-      let difference = this.q - from;
-      this.b.length = this.e.length = newLen;
+      this.c[i - this.w].dispose();
+    if (this.w < from) {
+      let i = this.w;
+      while (i < from && i < this.l)
+        this.c[i++].dispose();
+      this.c.splice(0, from - this.w);
+      this.e.splice(0, from - this.w);
+    } else if (this.w > from) {
+      let i = prevTo - this.w - 1;
+      let difference = this.w - from;
+      this.c.length = this.e.length = newLen;
       while (i >= difference) {
-        this.b[i] = this.b[i - difference];
+        this.c[i] = this.c[i - difference];
         this.e[i] = this.e[i - difference];
         i--;
       }
       for (let i2 = 0; i2 < difference; i2++) {
         this.e[i2] = compute(
-          this.b[i2] = new Owner(),
-          () => this.D(i2 + from),
+          this.c[i2] = new Owner(),
+          () => this.K(i2 + from),
           null
         );
       }
     }
     for (let i = prevTo; i < to; i++) {
       this.e[i - from] = compute(
-        this.b[i - from] = new Owner(),
-        () => this.D(i),
+        this.c[i - from] = new Owner(),
+        () => this.K(i),
         null
       );
     }
     this.e = this.e.slice(0, newLen);
-    this.q = from;
-    this.i = newLen;
+    this.w = from;
+    this.l = newLen;
   });
   return this.e;
 }
@@ -1778,24 +2051,24 @@ function compare(key, a, b) {
 
 // src/boundaries.ts
 var BoundaryComputation = class extends EagerComputation {
-  J;
+  S;
   constructor(compute2, propagationMask) {
     super(void 0, compute2, { defer: true });
-    this.J = propagationMask;
+    this.S = propagationMask;
   }
   write(value, flags) {
-    super.write(value, flags & ~this.J);
-    if (this.J & LOADING_BIT && !(this.f & UNINITIALIZED_BIT)) {
+    super.write(value, flags & ~this.S);
+    if (this.S & LOADING_BIT && !(this.f & UNINITIALIZED_BIT)) {
       flags &= ~LOADING_BIT;
     }
-    this.h.notify(this, this.J, flags);
+    this.i.notify(this, this.S, flags);
     return this.g;
   }
 };
 function createBoundChildren(owner, fn, queue, mask) {
-  const parentQueue = owner.h;
-  parentQueue.addChild(owner.h = queue);
-  onCleanup(() => parentQueue.removeChild(owner.h));
+  const parentQueue = owner.i;
+  parentQueue.addChild(owner.i = queue);
+  onCleanup(() => parentQueue.removeChild(owner.i));
   return compute(
     owner,
     () => {
@@ -1806,32 +2079,32 @@ function createBoundChildren(owner, fn, queue, mask) {
   );
 }
 var ConditionalQueue = class extends Queue {
-  n;
-  P = /* @__PURE__ */ new Set();
-  Q = /* @__PURE__ */ new Set();
+  s;
+  Y = /* @__PURE__ */ new Set();
+  t = /* @__PURE__ */ new Set();
   constructor(disabled) {
     super();
-    this.n = disabled;
+    this.s = disabled;
   }
   run(type) {
-    if (!type || this.n.read())
+    if (!type || this.s.read())
       return;
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (this.n.read()) {
+    if (this.s.read()) {
       if (type & LOADING_BIT) {
         if (flags & LOADING_BIT) {
-          this.Q.add(node);
+          this.t.add(node);
           type &= ~LOADING_BIT;
-        } else if (this.Q.delete(node))
+        } else if (this.t.delete(node))
           type &= ~LOADING_BIT;
       }
       if (type & ERROR_BIT) {
         if (flags & ERROR_BIT) {
-          this.P.add(node);
+          this.Y.add(node);
           type &= ~ERROR_BIT;
-        } else if (this.P.delete(node))
+        } else if (this.Y.delete(node))
           type &= ~ERROR_BIT;
       }
     }
@@ -1839,31 +2112,31 @@ var ConditionalQueue = class extends Queue {
   }
 };
 var CollectionQueue = class extends Queue {
-  R;
-  b = /* @__PURE__ */ new Set();
-  n = new Computation(false, null, { pureWrite: true });
+  Z;
+  c = /* @__PURE__ */ new Set();
+  s = new Computation(false, null, { pureWrite: true });
   constructor(type) {
     super();
-    this.R = type;
+    this.Z = type;
   }
   run(type) {
-    if (!type || this.n.read())
+    if (!type || this.s.read())
       return;
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (!(type & this.R))
+    if (!(type & this.Z))
       return super.notify(node, type, flags);
-    if (flags & this.R) {
-      this.b.add(node);
-      if (this.b.size === 1)
-        this.n.write(true);
+    if (flags & this.Z) {
+      this.c.add(node);
+      if (this.c.size === 1)
+        this.s.write(true);
     } else {
-      this.b.delete(node);
-      if (this.b.size === 0)
-        this.n.write(false);
+      this.c.delete(node);
+      if (this.c.size === 0)
+        this.s.write(false);
     }
-    type &= ~this.R;
+    type &= ~this.Z;
     return type ? super.notify(node, type, flags) : true;
   }
 };
@@ -1874,25 +2147,25 @@ function createBoundary(fn, condition) {
   );
   const tree = createBoundChildren(owner, fn, queue, 0);
   new EagerComputation(void 0, () => {
-    const disabled = queue.n.read();
-    tree.J = disabled ? ERROR_BIT | LOADING_BIT : 0;
+    const disabled = queue.s.read();
+    tree.S = disabled ? ERROR_BIT | LOADING_BIT : 0;
     if (!disabled) {
-      queue.Q.forEach((node) => queue.notify(node, LOADING_BIT, LOADING_BIT));
-      queue.P.forEach((node) => queue.notify(node, ERROR_BIT, ERROR_BIT));
-      queue.Q.clear();
-      queue.P.clear();
+      queue.t.forEach((node) => queue.notify(node, LOADING_BIT, LOADING_BIT));
+      queue.Y.forEach((node) => queue.notify(node, ERROR_BIT, ERROR_BIT));
+      queue.t.clear();
+      queue.Y.clear();
     }
   });
-  return () => queue.n.read() ? void 0 : tree.read();
+  return () => queue.s.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.n.read()) {
+    if (!queue.s.read()) {
       const resolved = tree.read();
-      if (!queue.n.read())
+      if (!queue.s.read())
         return resolved;
     }
     return fallback(queue);
@@ -1906,11 +2179,11 @@ function createErrorBoundary(fn, fallback) {
   return createCollectionBoundary(
     ERROR_BIT,
     fn,
-    (queue) => fallback(queue.b.values().next().value.G, () => {
+    (queue) => fallback(queue.c.values().next().value.O, () => {
       incrementClock();
-      for (let node of queue.b) {
-        node.a = STATE_DIRTY;
-        node.h?.enqueue(node.s, node.u.bind(node));
+      for (let node of queue.c) {
+        node.b = STATE_DIRTY;
+        node.i?.enqueue(node.y, node.A.bind(node));
       }
     })
   );