@solidjs/signals 0.7.2 → 0.7.4

package/dist/prod.js

@@ -1,5 +1,9 @@
 // src/core/error.ts
 var NotReadyError = class extends Error {
+  constructor(node) {
+    super();
+    this.cause = node;
+  }
 };
 var NoOwnerError = class extends Error {
   constructor() {
@@ -52,21 +56,21 @@ function notifyUnobserved() {
   for (let i = 0; i < Unobserved.length; i++) {
     const source = Unobserved[i];
     if (!source.c || !source.c.length)
-      Unobserved[i].ea?.();
+      Unobserved[i].fa?.();
   }
   Unobserved = [];
 }
 var pureQueue = [];
 var Queue = class {
-  k = null;
+  l = null;
   C = false;
-  f = [[], []];
-  g = [];
+  h = [[], []];
+  i = [];
   created = clock;
   enqueue(type, fn) {
     pureQueue.push(fn);
     if (type)
-      this.f[type - 1].push(fn);
+      this.h[type - 1].push(fn);
     schedule();
   }
   run(type) {
@@ -74,13 +78,13 @@ var Queue = class {
       pureQueue.length && runQueue(pureQueue, type);
       pureQueue = [];
       return;
-    } else if (this.f[type - 1].length) {
-      const effects = this.f[type - 1];
-      this.f[type - 1] = [];
+    } else if (this.h[type - 1].length) {
+      const effects = this.h[type - 1];
+      this.h[type - 1] = [];
       runQueue(effects, type);
     }
-    for (let i = 0; i < this.g.length; i++) {
-      this.g[i].run(type);
+    for (let i = 0; i < this.i.length; i++) {
+      this.i[i].run(type);
     }
   }
   flush() {
@@ -101,32 +105,32 @@ var Queue = class {
   addChild(child) {
     if (ActiveTransition && ActiveTransition.J.has(this))
       return ActiveTransition.J.get(this).addChild(child);
-    this.g.push(child);
-    child.k = this;
+    this.i.push(child);
+    child.l = this;
   }
   removeChild(child) {
     if (ActiveTransition && ActiveTransition.J.has(this))
       return ActiveTransition.J.get(this).removeChild(child);
-    const index = this.g.indexOf(child);
+    const index = this.i.indexOf(child);
     if (index >= 0) {
-      this.g.splice(index, 1);
-      child.k = null;
+      this.i.splice(index, 1);
+      child.l = null;
     }
   }
   notify(...args) {
-    if (this.k)
-      return this.k.notify(...args);
+    if (this.l)
+      return this.l.notify(...args);
     return false;
   }
   merge(queue) {
-    this.f[0].push.apply(this.f[0], queue.f[0]);
-    this.f[1].push.apply(this.f[1], queue.f[1]);
-    for (let i = 0; i < queue.g.length; i++) {
-      const og = this.g.find((c) => c.d === queue.g[i].d);
+    this.h[0].push.apply(this.h[0], queue.h[0]);
+    this.h[1].push.apply(this.h[1], queue.h[1]);
+    for (let i = 0; i < queue.i.length; i++) {
+      const og = this.i.find((c) => c.d === queue.i[i].d);
       if (og)
-        og.merge(queue.g[i]);
+        og.merge(queue.i[i]);
       else
-        this.addChild(queue.g[i]);
+        this.addChild(queue.i[i]);
     }
   }
 };
@@ -139,8 +143,8 @@ function flush() {
 function removeSourceObservers(node, index) {
   let source;
   let swap;
-  for (let i = index; i < node.a.length; i++) {
-    source = getTransitionSource(node.a[i]);
+  for (let i = index; i < node.b.length; i++) {
+    source = getTransitionSource(node.b[i]);
     if (source.c) {
       if ((swap = source.c.indexOf(node)) !== -1) {
         source.c[swap] = source.c[source.c.length - 1];
@@ -156,30 +160,32 @@ function runQueue(queue, type) {
     queue[i](type);
 }
 var Transition = class _Transition {
-  a = /* @__PURE__ */ new Map();
+  b = /* @__PURE__ */ new Map();
   t = /* @__PURE__ */ new Set();
   K = /* @__PURE__ */ new Set();
-  r = /* @__PURE__ */ new Set();
+  j = /* @__PURE__ */ new Set();
   D = false;
-  f = [[], []];
+  h = [[], []];
   J = /* @__PURE__ */ new Map();
   G = [];
-  g = [];
-  k = null;
+  i = [];
+  l = null;
   C = false;
   Y = false;
   d = globalQueue;
+  aa;
   created = clock;
-  constructor() {
+  constructor(signal) {
+    this.aa = signal;
     this.J.set(globalQueue, this);
-    for (const child of globalQueue.g) {
+    for (const child of globalQueue.i) {
       cloneQueue(child, this, this);
     }
   }
   enqueue(type, fn) {
     this.G.push(fn);
     if (type)
-      this.f[type - 1].push(fn);
+      this.h[type - 1].push(fn);
     this.schedule();
   }
   run(type) {
@@ -187,18 +193,19 @@ var Transition = class _Transition {
       this.G.length && runQueue(this.G, type);
       this.G = [];
       return;
-    } else if (this.f[type - 1].length) {
-      const effects = this.f[type - 1];
-      this.f[type - 1] = [];
+    } else if (this.h[type - 1].length) {
+      const effects = this.h[type - 1];
+      this.h[type - 1] = [];
       runQueue(effects, type);
     }
-    for (let i = 0; i < this.g.length; i++) {
-      this.g[i].run(type);
+    for (let i = 0; i < this.i.length; i++) {
+      this.i[i].run(type);
     }
   }
   flush() {
     if (this.C || this.D)
       return;
+    globalQueue.flush();
     this.C = true;
     let currentTransition = ActiveTransition;
     ActiveTransition = this;
@@ -214,13 +221,13 @@ var Transition = class _Transition {
     }
   }
   addChild(child) {
-    this.g.push(child);
-    child.k = this;
+    this.i.push(child);
+    child.l = this;
   }
   removeChild(child) {
-    const index = this.g.indexOf(child);
+    const index = this.i.indexOf(child);
     if (index >= 0)
-      this.g.splice(index, 1);
+      this.i.splice(index, 1);
   }
   notify(node, type, flags) {
     if (!(type & LOADING_BIT))
@@ -233,18 +240,18 @@ var Transition = class _Transition {
     return true;
   }
   merge(queue) {
-    this.f[0].push.apply(this.f[0], queue.f[0]);
-    this.f[1].push.apply(this.f[1], queue.f[1]);
+    this.h[0].push.apply(this.h[0], queue.h[0]);
+    this.h[1].push.apply(this.h[1], queue.h[1]);
     this.G.push.apply(this.G, queue.G);
-    queue.f[0].length = 0;
-    queue.f[1].length = 0;
+    queue.h[0].length = 0;
+    queue.h[1].length = 0;
     queue.G.length = 0;
-    for (let i = 0; i < queue.g.length; i++) {
-      const og = this.g.find((c) => c.d === queue.g[i].d);
+    for (let i = 0; i < queue.i.length; i++) {
+      const og = this.i.find((c) => c.d === queue.i[i].d);
       if (og)
-        og.merge(queue.g[i]);
+        og.merge(queue.i[i]);
       else
-        this.addChild(queue.g[i]);
+        this.addChild(queue.i[i]);
     }
   }
   schedule() {
@@ -304,43 +311,44 @@ var Transition = class _Transition {
     }
   }
   addOptimistic(fn) {
-    if (fn.j && fn.j !== this) {
-      mergeTransitions(fn.j, this);
-      ActiveTransition = fn.j;
+    if (fn.f && fn.f !== this) {
+      mergeTransitions(fn.f, this);
+      ActiveTransition = fn.f;
       return;
     }
-    fn.j = this;
-    this.r.add(fn);
+    fn.f = this;
+    this.j.add(fn);
   }
 };
-function transition(fn) {
-  let t = new Transition();
-  queueMicrotask(() => t.runTransition(() => fn((fn2) => t.runTransition(fn2))));
-}
 function cloneGraph(node) {
-  if (node.r)
-    return node;
   if (node.j) {
-    if (node.j !== ActiveTransition) {
-      mergeTransitions(node.j, ActiveTransition);
-      ActiveTransition = node.j;
+    if (node.a !== STATE_DISPOSED) {
+      node.j.ia?.();
+      ActiveTransition.addOptimistic(node.j);
+    }
+    return node;
+  }
+  if (node.f) {
+    if (node.f !== ActiveTransition) {
+      mergeTransitions(node.f, ActiveTransition);
+      ActiveTransition = node.f;
     }
-    return node.j.a.get(node);
+    return node.f.b.get(node);
   }
   const clone = Object.create(Object.getPrototypeOf(node));
   Object.assign(clone, node, {
+    o: null,
     n: null,
-    m: null,
     c: null,
-    a: node.a ? [...node.a] : null,
+    b: node.b ? [...node.b] : null,
     d: node
   });
   delete clone.T;
-  ActiveTransition.a.set(node, clone);
-  node.j = ActiveTransition;
-  if (node.a) {
-    for (let i = 0; i < node.a.length; i++)
-      node.a[i].c.push(clone);
+  ActiveTransition.b.set(node, clone);
+  node.f = ActiveTransition;
+  if (node.b) {
+    for (let i = 0; i < node.b.length; i++)
+      node.b[i].c.push(clone);
   }
   if (node.c) {
     clone.c = [];
@@ -359,9 +367,9 @@ function replaceSourceObservers(node, transition2) {
   let source;
   let transitionSource;
   let swap;
-  for (let i = 0; i < node.a.length; i++) {
-    transitionSource = transition2.a.get(node.a[i]);
-    source = transitionSource || node.a[i];
+  for (let i = 0; i < node.b.length; i++) {
+    transitionSource = transition2.b.get(node.b[i]);
+    source = transitionSource || node.b[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();
@@ -372,8 +380,8 @@ function cloneQueue(queue, parent, transition2) {
   const clone = Object.create(Object.getPrototypeOf(queue));
   Object.assign(clone, queue, {
     d: queue,
-    k: parent,
-    g: [],
+    l: parent,
+    i: [],
     enqueue(type, fn) {
       transition2 = latestTransition(transition2);
       transition2.enqueue(type, fn);
@@ -390,9 +398,9 @@ function cloneQueue(queue, parent, transition2) {
       return queue.notify.call(this, node, type, flags);
     }
   });
-  parent.g.push(clone);
+  parent.i.push(clone);
   transition2.J.set(queue, clone);
-  for (const child of queue.g) {
+  for (const child of queue.i) {
     cloneQueue(child, clone, transition2);
   }
 }
@@ -400,27 +408,27 @@ function resolveQueues(children) {
   for (const child of children) {
     const og = child.d;
     if (og) {
-      const clonedChildren = child.g;
+      const clonedChildren = child.i;
       delete child.enqueue;
       delete child.notify;
-      delete child.k;
-      delete child.g;
+      delete child.l;
+      delete child.i;
       Object.assign(og, child);
       delete og.d;
       resolveQueues(clonedChildren);
-    } else if (child.k.d) {
-      child.k.d.addChild(child);
+    } else if (child.l.d) {
+      child.l.d.addChild(child);
     }
   }
 }
 function mergeTransitions(t1, t2) {
-  t2.a.forEach((value, key) => {
-    key.j = t1;
-    t1.a.set(key, value);
+  t2.b.forEach((value, key) => {
+    key.f = t1;
+    t1.b.set(key, value);
   });
-  t2.r.forEach((c) => {
-    c.j = t1;
-    t1.r.add(c);
+  t2.j.forEach((c) => {
+    c.f = t1;
+    t1.j.add(c);
   });
   t2.K.forEach((p) => t1.K.add(p));
   t2.t.forEach((n) => t1.t.add(n));
@@ -428,59 +436,60 @@ function mergeTransitions(t1, t2) {
   t2.D = t1;
 }
 function getTransitionSource(input) {
-  return ActiveTransition && ActiveTransition.a.get(input) || input;
+  return ActiveTransition && ActiveTransition.b.get(input) || input;
 }
 function getQueue(node) {
-  const transition2 = ActiveTransition || node.d?.j;
+  const transition2 = ActiveTransition || node.d?.f;
   return transition2 && transition2.J.get(node.E) || node.E;
 }
 function initialDispose(node) {
-  let current = node.m;
-  while (current !== null && current.k === node) {
+  let current = node.n;
+  while (current !== null && current.l === node) {
     initialDispose(current);
-    const clone = ActiveTransition.a.get(current);
+    const clone = ActiveTransition.b.get(current);
     if (clone && !clone.Z)
       clone.dispose(true);
-    current = current.m;
+    current = current.n;
   }
 }
 function finishTransition(transition2) {
   if (transition2.D || transition2.Y || transition2.K.size || transition2.t.size)
     return;
-  globalQueue.f[0].push.apply(globalQueue.f[0], transition2.f[0]);
-  globalQueue.f[1].push.apply(globalQueue.f[1], transition2.f[1]);
-  resolveQueues(transition2.g);
-  for (const [source, clone] of transition2.a) {
-    if (source === clone || source.j !== transition2) {
-      delete source.j;
+  globalQueue.h[0].push.apply(globalQueue.h[0], transition2.h[0]);
+  globalQueue.h[1].push.apply(globalQueue.h[1], transition2.h[1]);
+  resolveQueues(transition2.i);
+  for (const [source, clone] of transition2.b) {
+    if (source === clone || source.f !== transition2) {
+      delete source.f;
       continue;
     }
-    if (clone.a)
+    if (clone.b)
       replaceSourceObservers(clone, transition2);
-    if (clone.Z || clone.b === STATE_DISPOSED) {
-      source.dispose(clone.b === STATE_DISPOSED);
+    if (clone.Z || clone.a === STATE_DISPOSED) {
+      source.dispose(clone.a === STATE_DISPOSED);
       source.emptyDisposal();
       delete clone.Z;
     } else {
-      delete clone.m;
       delete clone.n;
+      delete clone.o;
     }
     Object.assign(source, clone);
     delete source.d;
-    let current = clone.m;
+    let current = clone.n;
     if (current?.z === clone)
       current.z = source;
-    while (current?.k === clone) {
-      current.k = source;
-      current = current.m;
+    while (current?.l === clone) {
+      current.l = source;
+      current = current.n;
     }
-    delete source.j;
+    delete source.f;
   }
   transition2.D = true;
-  for (const reset of transition2.r) {
-    delete reset.j;
+  for (const reset of transition2.j) {
+    delete reset.f;
     reset();
   }
+  transition2.aa.write(true);
   globalQueue.flush();
 }
 
@@ -499,14 +508,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
-  k = null;
-  m = null;
-  z = null;
-  b = STATE_CLEAN;
+  l = null;
   n = null;
+  z = null;
+  a = STATE_CLEAN;
+  o = null;
   A = defaultContext;
   E = globalQueue;
-  fa = 0;
+  ga = 0;
   id = null;
   constructor(id = null, skipAppend = false) {
     this.id = id;
@@ -515,12 +524,12 @@ var Owner = class {
     }
   }
   append(child) {
-    child.k = this;
+    child.l = this;
     child.z = this;
-    if (this.m)
-      this.m.z = child;
-    child.m = this.m;
-    this.m = child;
+    if (this.n)
+      this.n.z = child;
+    child.n = this.n;
+    this.n = child;
     if (this.id != null && child.id == null)
       child.id = this.getNextChildId();
     if (child.A !== this.A) {
@@ -530,48 +539,48 @@ var Owner = class {
       child.E = this.E;
   }
   dispose(self = true) {
-    if (this.b === STATE_DISPOSED)
+    if (this.a === STATE_DISPOSED)
       return;
-    let head = self ? this.z || this.k : this, current = this.m, next = null;
-    while (current && current.k === this) {
+    let head = self ? this.z || this.l : this, current = this.n, next = null;
+    while (current && current.l === this) {
       current.dispose(true);
-      next = current.m;
-      current.m = null;
+      next = current.n;
+      current.n = null;
       current = next;
     }
-    this.fa = 0;
+    this.ga = 0;
     if (self)
       this.M();
     if (current)
       current.z = !self ? this : this.z;
     if (head)
-      head.m = current;
+      head.n = current;
   }
   M() {
     if (this.z)
-      this.z.m = null;
-    this.k = null;
+      this.z.n = null;
+    this.l = null;
     this.z = null;
     this.A = defaultContext;
-    this.b = STATE_DISPOSED;
+    this.a = STATE_DISPOSED;
     this.emptyDisposal();
   }
   emptyDisposal() {
-    if (!this.n)
+    if (!this.o)
       return;
-    if (Array.isArray(this.n)) {
-      for (let i = 0; i < this.n.length; i++) {
-        const callable = this.n[i];
+    if (Array.isArray(this.o)) {
+      for (let i = 0; i < this.o.length; i++) {
+        const callable = this.o[i];
         callable.call(callable);
       }
     } else {
-      this.n.call(this.n);
+      this.o.call(this.o);
     }
-    this.n = null;
+    this.o = null;
   }
   getNextChildId() {
     if (this.id != null)
-      return formatId(this.id, this.fa++);
+      return formatId(this.id, this.ga++);
     throw new Error("Cannot get child id from owner without an id");
   }
 };
@@ -604,12 +613,12 @@ function onCleanup(fn) {
   if (!currentOwner)
     return fn;
   const node = currentOwner;
-  if (!node.n) {
-    node.n = fn;
-  } else if (Array.isArray(node.n)) {
-    node.n.push(fn);
+  if (!node.o) {
+    node.o = fn;
+  } else if (Array.isArray(node.o)) {
+    node.o.push(fn);
   } else {
-    node.n = [node.n, fn];
+    node.o = [node.o, fn];
   }
   return fn;
 }
@@ -635,49 +644,49 @@ function getObserver() {
 }
 var UNCHANGED = Symbol(0);
 var Computation = class extends Owner {
-  a = null;
+  b = null;
   c = null;
-  l;
+  m;
   O;
   P;
   // Used in __DEV__ mode, hopefully removed in production
-  la;
+  na;
   // Using false is an optimization as an alternative to _equals: () => false
   // which could enable more efficient DIRTY notification
-  aa = isEqual;
-  ea;
-  ha = false;
+  ba = isEqual;
+  fa;
+  ja = false;
   /** Whether the computation is an error or has ancestors that are unresolved */
-  h = 0;
+  g = 0;
   /** Which flags raised by sources are handled, vs. being passed through. */
-  ba = DEFAULT_FLAGS;
+  ca = DEFAULT_FLAGS;
   Q = -1;
   H = false;
-  j;
+  f;
   d;
-  r = false;
+  j;
   constructor(initialValue, compute2, options) {
     super(options?.id, compute2 === null);
     this.P = compute2;
-    this.b = compute2 ? STATE_DIRTY : STATE_CLEAN;
-    this.h = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
-    this.l = initialValue;
+    this.a = compute2 ? STATE_DIRTY : STATE_CLEAN;
+    this.g = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
+    this.m = initialValue;
     if (options?.equals !== void 0)
-      this.aa = options.equals;
-    this.ha = !!options?.pureWrite;
-    this.ea = options?.unobserved;
+      this.ba = options.equals;
+    this.ja = !!options?.pureWrite;
+    this.fa = options?.unobserved;
     if (ActiveTransition) {
-      this.j = ActiveTransition;
-      ActiveTransition.a.set(this, this);
+      this.f = ActiveTransition;
+      ActiveTransition.b.set(this, this);
     }
   }
-  ga() {
+  ha() {
     track(this);
-    newFlags |= this.h & ~currentMask;
-    if (this.h & ERROR_BIT) {
+    newFlags |= this.g & ~currentMask;
+    if (this.g & ERROR_BIT) {
       throw this.O;
     } else {
-      return this.l;
+      return this.m;
     }
   }
   /**
@@ -685,18 +694,18 @@ var Computation = class extends Owner {
    * Automatically re-executes the surrounding computation when the value changes
    */
   read() {
-    if (ActiveTransition && (ActiveTransition.a.has(this) || !this.d && this.h & (UNINITIALIZED_BIT | ERROR_BIT))) {
-      const clone = ActiveTransition.a.get(this) || cloneGraph(this);
+    if (ActiveTransition && (ActiveTransition.b.has(this) || !this.d && this.g & (UNINITIALIZED_BIT | ERROR_BIT))) {
+      const clone = ActiveTransition.b.get(this) || cloneGraph(this);
       if (clone !== this)
         return clone.read();
     }
     if (this.P) {
-      if (this.h & ERROR_BIT && this.Q <= clock)
+      if (this.g & ERROR_BIT && this.Q <= clock)
         update(this);
       else
         this.F();
     }
-    return this.ga();
+    return this.ha();
   }
   /**
    * Return the current value of this computation
@@ -706,25 +715,25 @@ var Computation = class extends Owner {
    * before continuing
    */
   wait() {
-    if (ActiveTransition && (ActiveTransition.a.has(this) || !this.d && this.h & (UNINITIALIZED_BIT | ERROR_BIT))) {
-      const clone = ActiveTransition.a.get(this) || cloneGraph(this);
+    if (ActiveTransition && (ActiveTransition.b.has(this) || !this.d && this.g & (UNINITIALIZED_BIT | ERROR_BIT))) {
+      const clone = ActiveTransition.b.get(this) || cloneGraph(this);
       if (clone !== this)
         return clone.wait();
     }
     if (this.P) {
-      if (this.h & ERROR_BIT && this.Q <= clock)
+      if (this.g & ERROR_BIT && this.Q <= clock)
         update(this);
       else
         this.F();
     }
-    if ((notStale || this.h & UNINITIALIZED_BIT) && this.h & LOADING_BIT) {
-      track(this);
-      throw new NotReadyError();
+    if ((notStale || this.g & UNINITIALIZED_BIT) && this.g & LOADING_BIT) {
+      throw new NotReadyError(this);
     }
-    if (staleCheck && this.h & LOADING_BIT) {
-      staleCheck.l = true;
+    if (staleCheck && (this.g & LOADING_BIT || this.f)) {
+      staleCheck.m = true;
+      this.f?.aa.read();
     }
-    return this.ga();
+    return this.ha();
   }
   /** Update the computation with a new value. */
   write(value, flags = 0, raw = false) {
@@ -733,17 +742,17 @@ var Computation = class extends Owner {
       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 ||
-    this.aa === false || !this.aa(this.l, newValue));
+    const newValue = !raw && typeof value === "function" ? value(this.m) : value;
+    const valueChanged = newValue !== UNCHANGED && (!!(this.g & UNINITIALIZED_BIT) || // this._stateFlags & LOADING_BIT & ~flags ||
+    this.ba === false || !this.ba(this.m, newValue));
     if (valueChanged) {
-      this.l = newValue;
+      this.m = newValue;
       this.O = void 0;
     }
-    const changedFlagsMask = this.h ^ flags, changedFlags = changedFlagsMask & flags;
-    this.h = flags;
+    const changedFlagsMask = this.g ^ flags, changedFlags = changedFlagsMask & flags;
+    this.g = flags;
     this.Q = clock + 1;
-    if (this.c && !(this.r && ActiveTransition)) {
+    if (this.c && !(this.j && ActiveTransition)) {
       for (let i = 0; i < this.c.length; i++) {
         if (valueChanged) {
           this.c[i].u(STATE_DIRTY);
@@ -752,17 +761,17 @@ var Computation = class extends Owner {
         }
       }
     }
-    return this.l;
+    return this.m;
   }
   /**
    * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
    */
   u(state, skipQueue) {
-    if (this.b >= state && !this.H)
+    if (this.a >= state && !this.H)
       return;
     this.H = !!skipQueue;
-    this.b = state;
-    if (this.c && !(this.r && ActiveTransition)) {
+    this.a = state;
+    if (this.c && !(this.j && ActiveTransition)) {
       for (let i = 0; i < this.c.length; i++) {
         this.c[i].u(STATE_CHECK, skipQueue);
       }
@@ -775,20 +784,20 @@ var Computation = class extends Owner {
    * @param newFlags The source's new flags, masked to just the changed ones.
    */
   _(mask, newFlags2) {
-    if (this.b >= STATE_DIRTY)
+    if (this.a >= STATE_DIRTY)
       return;
-    if (mask & this.ba || this.r && ActiveTransition) {
+    if (mask & this.ca || this.j && ActiveTransition) {
       this.u(STATE_DIRTY);
       return;
     }
-    if (this.b >= STATE_CHECK && !this.H)
+    if (this.a >= STATE_CHECK && !this.H)
       return;
-    const prevFlags = this.h & mask;
+    const prevFlags = this.g & mask;
     const deltaFlags = prevFlags ^ newFlags2;
     if (newFlags2 === prevFlags) ; else if (deltaFlags & prevFlags & mask) {
       this.u(STATE_CHECK);
     } else {
-      this.h ^= deltaFlags;
+      this.g ^= deltaFlags;
       if (this.c) {
         for (let i = 0; i < this.c.length; i++) {
           this.c[i]._(mask, newFlags2);
@@ -803,7 +812,7 @@ var Computation = class extends Owner {
         return clone.N(error);
     }
     this.O = error;
-    this.write(UNCHANGED, this.h & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
+    this.write(UNCHANGED, this.g & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
   }
   /**
    * This is the core part of the reactivity system, which makes sure that the values are updated
@@ -816,37 +825,37 @@ var Computation = class extends Owner {
     if (!this.P) {
       return;
     }
-    if (this.b === STATE_DISPOSED) {
+    if (this.a === STATE_DISPOSED) {
       return;
     }
-    if (this.b === STATE_CLEAN) {
+    if (this.a === STATE_CLEAN) {
       return;
     }
     let observerFlags = 0;
-    if (this.b === STATE_CHECK) {
-      for (let i = 0; i < this.a.length; i++) {
-        const source = getTransitionSource(this.a[i]);
+    if (this.a === STATE_CHECK) {
+      for (let i = 0; i < this.b.length; i++) {
+        const source = getTransitionSource(this.b[i]);
         source.F();
-        observerFlags |= source.h & ~UNINITIALIZED_BIT;
-        if (this.b === STATE_DIRTY) {
+        observerFlags |= source.g & ~UNINITIALIZED_BIT;
+        if (this.a === STATE_DIRTY) {
           break;
         }
       }
     }
-    if (this.b === STATE_DIRTY) {
+    if (this.a === STATE_DIRTY) {
       update(this);
     } else {
       this.write(UNCHANGED, observerFlags);
-      this.b = STATE_CLEAN;
+      this.a = STATE_CLEAN;
     }
   }
   /**
    * Remove ourselves from the owner graph and the computation graph
    */
   M() {
-    if (this.b === STATE_DISPOSED)
+    if (this.a === STATE_DISPOSED)
       return;
-    if (this.a)
+    if (this.b)
       removeSourceObservers(this, 0);
     super.M();
   }
@@ -855,7 +864,7 @@ function track(computation) {
   if (ActiveTransition && computation.d)
     computation = computation.d;
   if (currentObserver) {
-    if (!newSources && currentObserver.a && currentObserver.a[newSourcesIndex] === computation) {
+    if (!newSources && currentObserver.b && currentObserver.b[newSourcesIndex] === computation) {
       newSourcesIndex++;
     } else if (!newSources)
       newSources = [computation];
@@ -863,7 +872,7 @@ function track(computation) {
       newSources.push(computation);
     }
     if (updateCheck) {
-      updateCheck.l = computation.Q > currentObserver.Q;
+      updateCheck.m = computation.Q > currentObserver.Q;
     }
   }
 }
@@ -883,39 +892,45 @@ function update(node) {
     node.write(result, newFlags, true);
   } catch (error) {
     if (error instanceof NotReadyError) {
-      node.write(UNCHANGED, newFlags | LOADING_BIT | node.h & UNINITIALIZED_BIT);
+      if (error.cause !== node)
+        compute(
+          node,
+          () => track(error.cause),
+          node
+        );
+      node.write(UNCHANGED, newFlags | LOADING_BIT | node.g & UNINITIALIZED_BIT);
     } else {
       node.N(error);
     }
   } finally {
     if (newSources) {
-      if (node.a)
+      if (node.b)
         removeSourceObservers(node, newSourcesIndex);
-      if (node.a && newSourcesIndex > 0) {
-        node.a.length = newSourcesIndex + newSources.length;
+      if (node.b && newSourcesIndex > 0) {
+        node.b.length = newSourcesIndex + newSources.length;
         for (let i = 0; i < newSources.length; i++) {
-          node.a[newSourcesIndex + i] = newSources[i];
+          node.b[newSourcesIndex + i] = newSources[i];
         }
       } else {
-        node.a = newSources;
+        node.b = newSources;
       }
       let source;
-      for (let i = newSourcesIndex; i < node.a.length; i++) {
-        source = getTransitionSource(node.a[i]);
+      for (let i = newSourcesIndex; i < node.b.length; i++) {
+        source = getTransitionSource(node.b[i]);
         if (!source.c)
           source.c = [node];
         else
           source.c.push(node);
       }
-    } else if (node.a && newSourcesIndex < node.a.length) {
+    } else if (node.b && newSourcesIndex < node.b.length) {
       removeSourceObservers(node, newSourcesIndex);
-      node.a.length = newSourcesIndex;
+      node.b.length = newSourcesIndex;
     }
     newSources = prevSources;
     newSourcesIndex = prevSourcesIndex;
     newFlags = prevFlags;
     node.Q = clock + 1;
-    node.b = STATE_CLEAN;
+    node.a = STATE_CLEAN;
   }
 }
 function isEqual(a, b) {
@@ -928,20 +943,20 @@ function untrack(fn) {
 }
 function hasUpdated(fn) {
   const current = updateCheck;
-  updateCheck = { l: false };
+  updateCheck = { m: false };
   try {
     fn();
-    return updateCheck.l;
+    return updateCheck.m;
   } finally {
     updateCheck = current;
   }
 }
 function pendingCheck(fn, loadingValue) {
   const current = staleCheck;
-  staleCheck = { l: false };
+  staleCheck = { m: false };
   try {
     latest(fn);
-    return staleCheck.l;
+    return staleCheck.m;
   } catch (err) {
     if (!(err instanceof NotReadyError))
       return false;
@@ -956,8 +971,17 @@ function isPending(fn, loadingValue) {
   if (!currentObserver)
     return pendingCheck(fn, loadingValue);
   const c = new Computation(void 0, () => pendingCheck(fn, loadingValue));
-  c.ba |= LOADING_BIT;
-  return c.read();
+  c.j = () => c.write(false);
+  c.j.ia = () => globalQueue.enqueue(0, () => c.j.f && c.write(true));
+  c.ca |= LOADING_BIT;
+  const res = c.wait();
+  c.o = () => {
+    if (c.j.f) {
+      c.j.f.j.delete(c.j);
+      delete c.j.f;
+    }
+  };
+  return res;
 }
 function latest(fn, fallback) {
   const argLength = arguments.length;
@@ -978,10 +1002,10 @@ function latest(fn, fallback) {
 function compute(owner, fn, observer) {
   const prevOwner = setOwner(owner), prevObserver = currentObserver, prevMask = currentMask, prevNotStale = notStale;
   currentObserver = observer;
-  currentMask = observer?.ba ?? DEFAULT_FLAGS;
+  currentMask = observer?.ca ?? DEFAULT_FLAGS;
   notStale = true;
   try {
-    return fn.call(observer, observer ? observer.l : void 0);
+    return fn.call(observer, observer ? observer.m : void 0);
   } finally {
     setOwner(prevOwner);
     currentObserver = prevObserver;
@@ -992,50 +1016,50 @@ function compute(owner, fn, observer) {
 
 // src/core/effect.ts
 var Effect = class extends Computation {
-  ca;
+  da;
   $;
   w;
-  da = false;
+  ea = false;
   T;
   s;
   constructor(initialValue, compute2, effect, error, options) {
     super(initialValue, compute2, options);
-    this.ca = effect;
+    this.da = effect;
     this.$ = error;
     this.T = initialValue;
     this.s = options?.render ? EFFECT_RENDER : EFFECT_USER;
     if (this.s === EFFECT_RENDER) {
       this.P = function(p) {
-        return !this.d && clock > this.E.created && !(this.h & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
+        return !this.d && clock > this.E.created && !(this.g & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
       };
     }
     this.F();
     !options?.defer && (this.s === EFFECT_USER ? getQueue(this).enqueue(this.s, this.x.bind(this)) : this.x(this.s));
   }
   write(value, flags = 0) {
-    if (this.b == STATE_DIRTY) {
-      this.h = flags;
+    if (this.a == STATE_DIRTY) {
+      this.g = flags;
       if (this.s === EFFECT_RENDER) {
-        getQueue(this).notify(this, LOADING_BIT | ERROR_BIT, this.h);
+        getQueue(this).notify(this, LOADING_BIT | ERROR_BIT, this.g);
       }
     }
     if (value === UNCHANGED)
-      return this.l;
-    this.l = value;
-    this.da = true;
+      return this.m;
+    this.m = value;
+    this.ea = true;
     this.O = void 0;
     return value;
   }
   u(state, skipQueue) {
-    if (this.b >= state || skipQueue)
+    if (this.a >= state || skipQueue)
       return;
-    if (this.b === STATE_CLEAN || this.d && !ActiveTransition)
+    if (this.a === STATE_CLEAN || this.d && !ActiveTransition)
       getQueue(this).enqueue(this.s, this.x.bind(this));
-    this.b = state;
+    this.a = state;
   }
   _(mask, newFlags2) {
     if (this.d) {
-      if (this.b >= STATE_DIRTY)
+      if (this.a >= STATE_DIRTY)
         return;
       if (mask & 3) {
         this.u(STATE_DIRTY);
@@ -1047,7 +1071,7 @@ var Effect = class extends Computation {
   N(error) {
     this.O = error;
     getQueue(this).notify(this, LOADING_BIT, 0);
-    this.h = ERROR_BIT;
+    this.g = ERROR_BIT;
     if (this.s === EFFECT_USER) {
       try {
         return this.$ ? this.$(error, () => {
@@ -1062,9 +1086,9 @@ var Effect = class extends Computation {
       throw error;
   }
   M() {
-    if (this.b === STATE_DISPOSED)
+    if (this.a === STATE_DISPOSED)
       return;
-    this.ca = void 0;
+    this.da = void 0;
     this.T = void 0;
     this.$ = void 0;
     this.w?.();
@@ -1075,42 +1099,46 @@ var Effect = class extends Computation {
   x(type) {
     if (type) {
       const effect = this.d || this;
-      if (effect.da && effect.b !== STATE_DISPOSED) {
+      if (effect.ea && effect.a !== STATE_DISPOSED) {
         effect.w?.();
         try {
-          effect.w = effect.ca(effect.l, effect.T);
+          effect.w = effect.da(effect.m, effect.T);
         } catch (e) {
           if (!getQueue(effect).notify(effect, ERROR_BIT, ERROR_BIT))
             throw e;
         } finally {
-          effect.T = effect.l;
-          effect.da = false;
+          effect.T = effect.m;
+          effect.ea = false;
         }
       }
     } else
-      this.b !== STATE_CLEAN && runTop(this);
+      this.a !== STATE_CLEAN && runTop(this);
   }
 };
 var TrackedEffect = class extends Computation {
   s = EFFECT_USER;
   w;
   constructor(compute2, options) {
-    super(void 0, () => {
-      this.w?.();
-      this.w = latest(compute2);
-      return void 0;
-    }, options);
+    super(
+      void 0,
+      () => {
+        this.w?.();
+        this.w = latest(compute2);
+        return void 0;
+      },
+      options
+    );
     getQueue(this).enqueue(this.s, this.x.bind(this));
   }
   u(state, skipQueue) {
-    if (this.b >= state || skipQueue)
+    if (this.a >= state || skipQueue)
       return;
-    if (this.b === STATE_CLEAN || this.d && !ActiveTransition)
+    if (this.a === STATE_CLEAN || this.d && !ActiveTransition)
       getQueue(this).enqueue(this.s, this.x.bind(this));
-    this.b = state;
+    this.a = state;
   }
   M() {
-    if (this.b === STATE_DISPOSED)
+    if (this.a === STATE_DISPOSED)
       return;
     this.w?.();
     this.w = void 0;
@@ -1119,7 +1147,7 @@ var TrackedEffect = class extends Computation {
   }
   x(type) {
     if (type)
-      this.b !== STATE_CLEAN && runTop(this);
+      this.a !== STATE_CLEAN && runTop(this);
   }
 };
 var EagerComputation = class extends Computation {
@@ -1128,14 +1156,14 @@ var EagerComputation = class extends Computation {
     !options?.defer && this.F();
   }
   u(state, skipQueue) {
-    if (this.b >= state && !this.H)
+    if (this.a >= state && !this.H)
       return;
-    if (!skipQueue && (this.b === STATE_CLEAN || this.b === STATE_CHECK && this.H))
+    if (!skipQueue && (this.a === STATE_CLEAN || this.a === STATE_CHECK && this.H))
       getQueue(this).enqueue(EFFECT_PURE, this.x.bind(this));
     super.u(state, skipQueue);
   }
   x() {
-    this.b !== STATE_CLEAN && runTop(this);
+    this.a !== STATE_CLEAN && runTop(this);
   }
 };
 var FirewallComputation = class extends Computation {
@@ -1144,31 +1172,34 @@ var FirewallComputation = class extends Computation {
     super(void 0, compute2);
   }
   u(state, skipQueue) {
-    if (this.b >= state && !this.H)
+    if (this.a >= state && !this.H)
       return;
-    if (!skipQueue && (this.b === STATE_CLEAN || this.b === STATE_CHECK && this.H))
+    if (!skipQueue && (this.a === STATE_CLEAN || this.a === STATE_CHECK && this.H))
       getQueue(this).enqueue(EFFECT_PURE, this.x.bind(this));
     super.u(state, true);
     this.H = !!skipQueue;
   }
   x() {
-    const prevFlags = this.h;
-    this.b !== STATE_CLEAN && runTop(this);
-    if (ActiveTransition && this.r && this.h !== prevFlags)
-      getQueue(this).notify(this, LOADING_BIT | ERROR_BIT, this.h);
+    const prevFlags = this.g;
+    this.a !== STATE_CLEAN && runTop(this);
+    if (ActiveTransition && this.j && (this.g !== prevFlags || this.g !== this.j.flags)) {
+      getQueue(this).notify(this, LOADING_BIT | ERROR_BIT, this.g);
+      this.j.flags = this.g;
+      this.g = prevFlags;
+    }
   }
 };
 function runTop(node) {
   const ancestors = [];
-  for (let current = node; current !== null; current = current.k) {
-    if (ActiveTransition && current.j)
-      current = ActiveTransition.a.get(current);
-    if (current.b !== STATE_CLEAN) {
+  for (let current = node; current !== null; current = current.l) {
+    if (ActiveTransition && current.f)
+      current = ActiveTransition.b.get(current);
+    if (current.a !== STATE_CLEAN) {
       ancestors.push(current);
     }
   }
   for (let i = ancestors.length - 1; i >= 0; i--) {
-    if (ancestors[i].b !== STATE_DISPOSED)
+    if (ancestors[i].a !== STATE_DISPOSED)
       ancestors[i].F();
   }
 }
@@ -1177,10 +1208,13 @@ function runTop(node) {
 function createSignal(first, second, third) {
   if (typeof first === "function") {
     const node2 = new Computation(second, first, third);
-    return [node2.read.bind(node2), (v) => {
-      node2.F();
-      return node2.write(v);
-    }];
+    return [
+      node2.wait.bind(node2),
+      (v) => {
+        node2.F();
+        return node2.write(v);
+      }
+    ];
   }
   const o = getOwner();
   const needsId = o?.id != null;
@@ -1200,12 +1234,12 @@ function createMemo(compute2, value, options) {
   let resolvedValue;
   return () => {
     if (node) {
-      if (node.b === STATE_DISPOSED) {
+      if (node.a === STATE_DISPOSED) {
         node = void 0;
         return resolvedValue;
       }
       resolvedValue = node.wait();
-      if (!node.a?.length && node.m?.k !== node && !(node.h & UNINITIALIZED_BIT)) {
+      if (!node.b?.length && node.n?.l !== node && !(node.g & UNINITIALIZED_BIT)) {
         node.dispose();
         node = void 0;
       }
@@ -1272,7 +1306,7 @@ function createAsync(compute2, value, options) {
           }
         })();
       }
-      throw new NotReadyError();
+      throw new NotReadyError(getOwner());
     },
     options
   );
@@ -1282,7 +1316,7 @@ function createAsync(compute2, value, options) {
     if (ActiveTransition && !node.d) {
       n = cloneGraph(node);
     }
-    n.b = STATE_DIRTY;
+    n.a = STATE_DIRTY;
     refreshing = true;
     n.F();
   };
@@ -1350,26 +1384,33 @@ function resolve(fn) {
   });
 }
 function createOptimistic(first, second, third) {
-  const node = typeof first === "function" ? new Computation(second, (prev) => {
-    const res = first(prev);
-    if (reset.j)
-      return prev;
-    return res;
-  }, third) : new Computation(first, null, second);
-  node.r = true;
-  const reset = () => node.write(first);
+  const node = typeof first === "function" ? new Computation(
+    second,
+    (prev) => {
+      const res = first(prev);
+      if (node.j.f)
+        return prev;
+      return res;
+    },
+    third
+  ) : new Computation(first, null, second);
+  node.j = () => node.write(first);
   function write(v) {
     if (!ActiveTransition)
       throw new Error("createOptimistic can only be updated inside a transition");
-    ActiveTransition.addOptimistic(reset);
+    ActiveTransition.addOptimistic(node.j);
     queueMicrotask(() => {
-      if (reset.j) {
+      if (node.j.f) {
         node.F();
         node.write(v);
       }
     });
   }
-  return [node.read.bind(node), write];
+  return [node.wait.bind(node), write];
+}
+function transition(fn) {
+  let t = new Transition(new Computation(void 0, null));
+  queueMicrotask(() => t.runTransition(() => fn((fn2) => t.runTransition(fn2))));
 }
 function useTransition() {
   const [pending, setPending] = createOptimistic(false);
@@ -1649,7 +1690,7 @@ var storeTraps = {
         return desc.get.call(receiver);
     }
     if (Writing?.has(receiver)) {
-      let value2 = tracked && (overridden || !proxySource) ? tracked.l : storeValue[property];
+      let value2 = tracked && (overridden || !proxySource) ? tracked.m : storeValue[property];
       value2 === $DELETED && (value2 = void 0);
       if (!isWrappable(value2))
         return value2;
@@ -1840,28 +1881,28 @@ function deep(store) {
 // src/store/optimistic.ts
 function createOptimisticStore(first, second, options) {
   const derived = typeof first === "function";
-  const { store, node } = derived ? createProjectionInternal((draft) => {
-    const res = first(draft);
-    if (reset.j)
-      return draft;
-    return res;
-  }, second, options) : createProjectionInternal(() => {
+  const { store, node } = derived ? createProjectionInternal(
+    (draft) => {
+      const res = first(draft);
+      if (reset.f)
+        return draft;
+      return res;
+    },
+    second,
+    options
+  ) : createProjectionInternal(() => {
   }, first);
-  node.r = true;
   const reset = () => storeSetter(
     store,
-    reconcile(
-      derived ? first(store) || store : first,
-      options?.key || "id",
-      options?.all
-    )
+    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);
-    queueMicrotask(() => reset.j && storeSetter(store, v));
+    queueMicrotask(() => reset.f && storeSetter(store, v));
   };
+  node.j = reset;
   return [store, write];
 }
 
@@ -2070,75 +2111,75 @@ function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
   return updateKeyedMap.bind({
     U: new Owner(),
-    o: 0,
-    ia: list,
+    p: 0,
+    ka: list,
     I: [],
     R: map,
-    i: [],
+    k: [],
     e: [],
     S: keyFn,
-    p: keyFn || options?.keyed === false ? [] : void 0,
-    q: map.length > 1 ? [] : void 0,
+    q: keyFn || options?.keyed === false ? [] : void 0,
+    r: map.length > 1 ? [] : void 0,
     V: options?.fallback
   });
 }
 var pureOptions = { pureWrite: true };
 function updateKeyedMap() {
-  const newItems = this.ia() || [], newLen = newItems.length;
+  const newItems = this.ka() || [], newLen = newItems.length;
   newItems[$TRACK];
   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));
+    let i, j, mapper = this.q ? () => {
+      this.q[j] = new Computation(newItems[j], null, pureOptions);
+      this.r && (this.r[j] = new Computation(j, null, pureOptions));
       return this.R(
-        Computation.prototype.read.bind(this.p[j]),
-        this.q ? Computation.prototype.read.bind(this.q[j]) : void 0
+        Computation.prototype.read.bind(this.q[j]),
+        this.r ? Computation.prototype.read.bind(this.r[j]) : void 0
       );
-    } : this.q ? () => {
+    } : this.r ? () => {
       const item = newItems[j];
-      this.q[j] = new Computation(j, null, pureOptions);
-      return this.R(() => item, Computation.prototype.read.bind(this.q[j]));
+      this.r[j] = new Computation(j, null, pureOptions);
+      return this.R(() => item, Computation.prototype.read.bind(this.r[j]));
     } : () => {
       const item = newItems[j];
       return this.R(() => item);
     };
     if (newLen === 0) {
-      if (this.o !== 0) {
+      if (this.p !== 0) {
         this.U.dispose(false);
         this.e = [];
         this.I = [];
-        this.i = [];
-        this.o = 0;
-        this.p && (this.p = []);
+        this.k = [];
+        this.p = 0;
         this.q && (this.q = []);
+        this.r && (this.r = []);
       }
-      if (this.V && !this.i[0]) {
-        this.i[0] = compute(
+      if (this.V && !this.k[0]) {
+        this.k[0] = compute(
           this.e[0] = new Owner(),
           this.V,
           null
         );
       }
-    } else if (this.o === 0) {
+    } else if (this.p === 0) {
       if (this.e[0])
         this.e[0].dispose();
-      this.i = new Array(newLen);
+      this.k = new Array(newLen);
       for (j = 0; j < newLen; j++) {
         this.I[j] = newItems[j];
-        this.i[j] = compute(this.e[j] = new Owner(), mapper, null);
+        this.k[j] = compute(this.e[j] = new Owner(), mapper, null);
       }
-      this.o = newLen;
+      this.p = 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.I[start] === newItems[start] || this.p && compare(this.S, this.I[start], newItems[start])); start++) {
-        if (this.p)
-          this.p[start].write(newItems[start]);
+      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.q ? new Array(newLen) : void 0, tempIndexes = this.r ? new Array(newLen) : void 0;
+      for (start = 0, end = Math.min(this.p, newLen); start < end && (this.I[start] === newItems[start] || this.q && compare(this.S, this.I[start], newItems[start])); start++) {
+        if (this.q)
+          this.q[start].write(newItems[start]);
       }
-      for (end = this.o - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.I[end] === newItems[newEnd] || this.p && compare(this.S, this.I[end], newItems[newEnd])); end--, newEnd--) {
-        temp[newEnd] = this.i[end];
+      for (end = this.p - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.I[end] === newItems[newEnd] || this.q && compare(this.S, this.I[end], newItems[newEnd])); end--, newEnd--) {
+        temp[newEnd] = this.k[end];
         tempNodes[newEnd] = this.e[end];
-        tempRows && (tempRows[newEnd] = this.p[end]);
-        tempIndexes && (tempIndexes[newEnd] = this.q[end]);
+        tempRows && (tempRows[newEnd] = this.q[end]);
+        tempIndexes && (tempIndexes[newEnd] = this.r[end]);
       }
       newIndices = /* @__PURE__ */ new Map();
       newIndicesNext = new Array(newEnd + 1);
@@ -2154,10 +2195,10 @@ function updateKeyedMap() {
         key = this.S ? this.S(item) : item;
         j = newIndices.get(key);
         if (j !== void 0 && j !== -1) {
-          temp[j] = this.i[i];
+          temp[j] = this.k[i];
           tempNodes[j] = this.e[i];
-          tempRows && (tempRows[j] = this.p[i]);
-          tempIndexes && (tempIndexes[j] = this.q[i]);
+          tempRows && (tempRows[j] = this.q[i]);
+          tempIndexes && (tempIndexes[j] = this.r[i]);
           j = newIndicesNext[j];
           newIndices.set(key, j);
         } else
@@ -2165,52 +2206,52 @@ function updateKeyedMap() {
       }
       for (j = start; j < newLen; j++) {
         if (j in temp) {
-          this.i[j] = temp[j];
+          this.k[j] = temp[j];
           this.e[j] = tempNodes[j];
           if (tempRows) {
-            this.p[j] = tempRows[j];
-            this.p[j].write(newItems[j]);
+            this.q[j] = tempRows[j];
+            this.q[j].write(newItems[j]);
           }
           if (tempIndexes) {
-            this.q[j] = tempIndexes[j];
-            this.q[j].write(j);
+            this.r[j] = tempIndexes[j];
+            this.r[j].write(j);
           }
         } else {
-          this.i[j] = compute(this.e[j] = new Owner(), mapper, null);
+          this.k[j] = compute(this.e[j] = new Owner(), mapper, null);
         }
       }
-      this.i = this.i.slice(0, this.o = newLen);
+      this.k = this.k.slice(0, this.p = newLen);
       this.I = newItems.slice(0);
     }
   });
-  return this.i;
+  return this.k;
 }
 function repeat(count, map, options) {
   return updateRepeat.bind({
     U: new Owner(),
-    o: 0,
+    p: 0,
     B: 0,
-    ja: count,
+    la: count,
     R: map,
     e: [],
-    i: [],
-    ka: options?.from,
+    k: [],
+    ma: options?.from,
     V: options?.fallback
   });
 }
 function updateRepeat() {
-  const newLen = this.ja();
-  const from = this.ka?.() || 0;
+  const newLen = this.la();
+  const from = this.ma?.() || 0;
   runWithOwner(this.U, () => {
     if (newLen === 0) {
-      if (this.o !== 0) {
+      if (this.p !== 0) {
         this.U.dispose(false);
         this.e = [];
-        this.i = [];
-        this.o = 0;
+        this.k = [];
+        this.p = 0;
       }
-      if (this.V && !this.i[0]) {
-        this.i[0] = compute(
+      if (this.V && !this.k[0]) {
+        this.k[0] = compute(
           this.e[0] = new Owner(),
           this.V,
           null
@@ -2219,28 +2260,28 @@ function updateRepeat() {
       return;
     }
     const to = from + newLen;
-    const prevTo = this.B + this.o;
-    if (this.o === 0 && this.e[0])
+    const prevTo = this.B + this.p;
+    if (this.p === 0 && this.e[0])
       this.e[0].dispose();
     for (let i = to; i < prevTo; i++)
       this.e[i - this.B].dispose();
     if (this.B < from) {
       let i = this.B;
-      while (i < from && i < this.o)
+      while (i < from && i < this.p)
         this.e[i++].dispose();
       this.e.splice(0, from - this.B);
-      this.i.splice(0, from - this.B);
+      this.k.splice(0, from - this.B);
     } else if (this.B > from) {
       let i = prevTo - this.B - 1;
       let difference = this.B - from;
-      this.e.length = this.i.length = newLen;
+      this.e.length = this.k.length = newLen;
       while (i >= difference) {
         this.e[i] = this.e[i - difference];
-        this.i[i] = this.i[i - difference];
+        this.k[i] = this.k[i - difference];
         i--;
       }
       for (let i2 = 0; i2 < difference; i2++) {
-        this.i[i2] = compute(
+        this.k[i2] = compute(
           this.e[i2] = new Owner(),
           () => this.R(i2 + from),
           null
@@ -2248,17 +2289,17 @@ function updateRepeat() {
       }
     }
     for (let i = prevTo; i < to; i++) {
-      this.i[i - from] = compute(
+      this.k[i - from] = compute(
         this.e[i - from] = new Owner(),
         () => this.R(i),
         null
       );
     }
-    this.i = this.i.slice(0, newLen);
+    this.k = this.k.slice(0, newLen);
     this.B = from;
-    this.o = newLen;
+    this.p = newLen;
   });
-  return this.i;
+  return this.k;
 }
 function compare(key, a, b) {
   return key ? key(a) === key(b) : true;
@@ -2273,11 +2314,11 @@ var BoundaryComputation = class extends EagerComputation {
   }
   write(value, flags) {
     super.write(value, flags & ~this.W);
-    if (this.W & LOADING_BIT && !(this.h & UNINITIALIZED_BIT || ActiveTransition)) {
+    if (this.W & LOADING_BIT && !(this.g & UNINITIALIZED_BIT || ActiveTransition)) {
       flags &= ~LOADING_BIT;
     }
     getQueue(this).notify(this, this.W, flags);
-    return this.l;
+    return this.m;
   }
 };
 function createBoundChildren(owner, fn, queue, mask) {
@@ -2288,7 +2329,7 @@ function createBoundChildren(owner, fn, queue, mask) {
     owner,
     () => {
       const c = new Computation(void 0, fn);
-      return new BoundaryComputation(() => flatten(c.wait()), mask);
+      return new BoundaryComputation(() => latest(() => flatten(c.wait())), mask);
     },
     null
   );
@@ -2407,7 +2448,7 @@ function createErrorBoundary(fn, fallback) {
       for (let node2 of queue.e) {
         if (ActiveTransition && !node2.d)
           node2 = cloneGraph(node2);
-        node2.b = STATE_DIRTY;
+        node2.a = STATE_DIRTY;
         getQueue(node2).enqueue(node2.s, node2.x.bind(node2));
       }
     });