@solidjs/signals 0.8.0 → 0.8.2

package/dist/prod.js

@@ -24,21 +24,21 @@ var SUPPORTS_PROXY = typeof Proxy === "function";
 
 // src/core/heap.ts
 function actualInsertIntoHeap(n, heap) {
-  const parentHeight = (n.s?.Z ? n.s._?.e : n.s?.e) ?? -1;
-  if (parentHeight >= n.e)
-    n.e = parentHeight + 1;
-  const height = n.e;
-  const heapAtHeight = heap.o[height];
+  const parentHeight = (n.w?._ ? n.w.$?.c : n.w?.c) ?? -1;
+  if (parentHeight >= n.c)
+    n.c = parentHeight + 1;
+  const height = n.c;
+  const heapAtHeight = heap.r[height];
   if (heapAtHeight === void 0) {
-    heap.o[height] = n;
+    heap.r[height] = n;
   } else {
-    const tail = heapAtHeight.x;
-    tail.O = n;
-    n.x = tail;
-    heapAtHeight.x = n;
+    const tail = heapAtHeight.z;
+    tail.Q = n;
+    n.z = tail;
+    heapAtHeight.z = n;
   }
-  if (height > heap.J) {
-    heap.J = height;
+  if (height > heap.L) {
+    heap.L = height;
   }
 }
 function insertIntoHeap(n, heap) {
@@ -65,29 +65,29 @@ function deleteFromHeap(n, heap) {
   if (!(flags & (8 /* InHeap */ | 16 /* InHeapHeight */)))
     return;
   n.b = flags & ~(8 /* InHeap */ | 16 /* InHeapHeight */);
-  const height = n.e;
-  if (n.x === n) {
-    heap.o[height] = void 0;
+  const height = n.c;
+  if (n.z === n) {
+    heap.r[height] = void 0;
   } else {
-    const next = n.O;
-    const dhh = heap.o[height];
+    const next = n.Q;
+    const dhh = heap.r[height];
     const end = next ?? dhh;
     if (n === dhh) {
-      heap.o[height] = next;
+      heap.r[height] = next;
     } else {
-      n.x.O = next;
+      n.z.Q = next;
     }
-    end.x = n.x;
+    end.z = n.z;
   }
-  n.x = n;
-  n.O = void 0;
+  n.z = n;
+  n.Q = void 0;
 }
 function markHeap(heap) {
-  if (heap.$)
+  if (heap.aa)
     return;
-  heap.$ = true;
-  for (let i = 0; i <= heap.J; i++) {
-    for (let el = heap.o[i]; el !== void 0; el = el.O) {
+  heap.aa = true;
+  for (let i = 0; i <= heap.L; i++) {
+    for (let el = heap.r[i]; el !== void 0; el = el.Q) {
       if (el.b & 8 /* InHeap */)
         markNode(el);
     }
@@ -98,48 +98,48 @@ function markNode(el, newState = 2 /* Dirty */) {
   if ((flags & (1 /* Check */ | 2 /* Dirty */)) >= newState)
     return;
   el.b = flags & ~(1 /* Check */ | 2 /* Dirty */) | newState;
-  for (let link2 = el.p; link2 !== null; link2 = link2.y) {
-    markNode(link2.m, 1 /* Check */);
+  for (let link2 = el.s; link2 !== null; link2 = link2.A) {
+    markNode(link2.j, 1 /* Check */);
   }
-  if (el.aa !== null) {
-    for (let child = el.aa; child !== null; child = child.qa) {
-      for (let link2 = child.p; link2 !== null; link2 = link2.y) {
-        markNode(link2.m, 1 /* Check */);
+  if (el.ba !== null) {
+    for (let child = el.ba; child !== null; child = child.ra) {
+      for (let link2 = child.s; link2 !== null; link2 = link2.A) {
+        markNode(link2.j, 1 /* Check */);
       }
     }
   }
 }
 function runHeap(heap, recompute2) {
-  heap.$ = false;
-  for (heap.t = 0; heap.t <= heap.J; heap.t++) {
-    let el = heap.o[heap.t];
+  heap.aa = false;
+  for (heap.p = 0; heap.p <= heap.L; heap.p++) {
+    let el = heap.r[heap.p];
     while (el !== void 0) {
       if (el.b & 8 /* InHeap */)
         recompute2(el);
       else {
         adjustHeight(el, heap);
       }
-      el = heap.o[heap.t];
+      el = heap.r[heap.p];
     }
   }
-  heap.J = 0;
+  heap.L = 0;
 }
 function adjustHeight(el, heap) {
   deleteFromHeap(el, heap);
-  let newHeight = el.e;
-  for (let d = el.u; d; d = d.E) {
-    const dep1 = d.P;
-    const dep = "_owner" in dep1 ? dep1.z : dep1;
+  let newHeight = el.c;
+  for (let d = el.x; d; d = d.F) {
+    const dep1 = d.R;
+    const dep = "_owner" in dep1 ? dep1.B : dep1;
     if ("_fn" in dep) {
-      if (dep.e >= newHeight) {
-        newHeight = dep.e + 1;
+      if (dep.c >= newHeight) {
+        newHeight = dep.c + 1;
       }
     }
   }
-  if (el.e !== newHeight) {
-    el.e = newHeight;
-    for (let s = el.p; s !== null; s = s.y) {
-      insertIntoHeapHeight(s.m, heap);
+  if (el.c !== newHeight) {
+    el.c = newHeight;
+    for (let s = el.s; s !== null; s = s.A) {
+      insertIntoHeapHeight(s.j, heap);
     }
   }
 }
@@ -154,76 +154,98 @@ function schedule() {
   if (scheduled)
     return;
   scheduled = true;
-  if (!globalQueue.ba)
+  if (!globalQueue.ca)
     queueMicrotask(flush);
 }
 var dirtyQueue = {
-  o: new Array(2e3).fill(void 0),
-  $: false,
-  t: 0,
-  J: 0
+  r: new Array(2e3).fill(void 0),
+  aa: false,
+  p: 0,
+  L: 0
 };
 var zombieQueue = {
-  o: new Array(2e3).fill(void 0),
-  $: false,
-  t: 0,
-  J: 0
+  r: new Array(2e3).fill(void 0),
+  aa: false,
+  p: 0,
+  L: 0
 };
 var Queue = class {
-  s = null;
-  A = [[], []];
-  Q = [];
+  w = null;
+  k = [[], []];
+  l = [];
   created = clock;
   addChild(child) {
-    this.Q.push(child);
-    child.s = this;
+    this.l.push(child);
+    child.w = this;
   }
   removeChild(child) {
-    const index = this.Q.indexOf(child);
+    const index = this.l.indexOf(child);
     if (index >= 0) {
-      this.Q.splice(index, 1);
-      child.s = null;
+      this.l.splice(index, 1);
+      child.w = null;
     }
   }
   notify(node, mask, flags) {
-    if (this.s)
-      return this.s.notify(node, mask, flags);
+    if (this.w)
+      return this.w.notify(node, mask, flags);
     return false;
   }
   run(type) {
-    if (this.A[type - 1].length) {
-      const effects = this.A[type - 1];
-      this.A[type - 1] = [];
+    if (this.k[type - 1].length) {
+      const effects = this.k[type - 1];
+      this.k[type - 1] = [];
       runQueue(effects, type);
     }
-    for (let i = 0; i < this.Q.length; i++) {
-      this.Q[i].run(type);
+    for (let i = 0; i < this.l.length; i++) {
+      this.l[i].run(type);
     }
   }
   enqueue(type, fn) {
     if (type)
-      this.A[type - 1].push(fn);
+      this.k[type - 1].push(fn);
     schedule();
   }
+  stashQueues(stub) {
+    stub.k[0].push(...this.k[0]);
+    stub.k[1].push(...this.k[1]);
+    this.k = [[], []];
+    for (let i = 0; i < this.l.length; i++) {
+      let child = this.l[i];
+      let childStub = stub.l[i];
+      if (!childStub) {
+        childStub = { k: [[], []], l: [] };
+        stub.l[i] = childStub;
+      }
+      child.stashQueues(childStub);
+    }
+  }
+  restoreQueues(stub) {
+    this.k[0].push(...stub.k[0]);
+    this.k[1].push(...stub.k[1]);
+    for (let i = 0; i < stub.l.length; i++) {
+      const childStub = stub.l[i];
+      let child = this.l[i];
+      if (child)
+        child.restoreQueues(childStub);
+    }
+  }
 };
 var GlobalQueue = class _GlobalQueue extends Queue {
-  ba = false;
+  ca = false;
   h = [];
-  static R;
+  static S;
   static ka;
   flush() {
-    if (this.ba)
+    if (this.ca)
       return;
-    this.ba = true;
+    this.ca = true;
     try {
-      runHeap(dirtyQueue, _GlobalQueue.R);
+      runHeap(dirtyQueue, _GlobalQueue.S);
       if (activeTransition) {
         if (!transitionComplete(activeTransition)) {
-          runHeap(zombieQueue, _GlobalQueue.R);
+          runHeap(zombieQueue, _GlobalQueue.S);
           globalQueue.h = [];
-          activeTransition.queues[0].push(...globalQueue.A[0]);
-          activeTransition.queues[1].push(...globalQueue.A[1]);
-          globalQueue.A = [[], []];
+          globalQueue.stashQueues(activeTransition.queueStash);
           clock++;
           scheduled = false;
           runPending(activeTransition.pendingNodes, true);
@@ -231,19 +253,18 @@ var GlobalQueue = class _GlobalQueue extends Queue {
           return;
         }
         globalQueue.h.push(...activeTransition.pendingNodes);
-        globalQueue.A[0].push(...activeTransition.queues[0]);
-        globalQueue.A[1].push(...activeTransition.queues[1]);
+        globalQueue.restoreQueues(activeTransition.queueStash);
         transitions.delete(activeTransition);
         activeTransition = null;
         if (runPending(globalQueue.h, false))
-          runHeap(dirtyQueue, _GlobalQueue.R);
+          runHeap(dirtyQueue, _GlobalQueue.S);
       } else if (transitions.size)
-        runHeap(zombieQueue, _GlobalQueue.R);
+        runHeap(zombieQueue, _GlobalQueue.S);
       for (let i = 0; i < globalQueue.h.length; i++) {
         const n = globalQueue.h[i];
-        if (n.d !== NOT_PENDING) {
-          n.g = n.d;
-          n.d = NOT_PENDING;
+        if (n.e !== NOT_PENDING) {
+          n.g = n.e;
+          n.e = NOT_PENDING;
         }
         if (n.ha)
           _GlobalQueue.ka(n, false, true);
@@ -254,15 +275,15 @@ var GlobalQueue = class _GlobalQueue extends Queue {
       this.run(1 /* Render */);
       this.run(2 /* User */);
     } finally {
-      this.ba = false;
+      this.ca = false;
       unobserved.length && notifyUnobserved();
     }
   }
   notify(node, mask, flags) {
     if (mask & 1 /* Pending */) {
       if (flags & 1 /* Pending */) {
-        if (activeTransition && !activeTransition.asyncNodes.includes(node.B.cause))
-          activeTransition.asyncNodes.push(node.B.cause);
+        if (activeTransition && !activeTransition.asyncNodes.includes(node.C.cause))
+          activeTransition.asyncNodes.push(node.C.cause);
       }
       return true;
     }
@@ -272,18 +293,18 @@ var GlobalQueue = class _GlobalQueue extends Queue {
     if (activeTransition && activeTransition.time === clock)
       return;
     if (!activeTransition) {
-      activeTransition = node.S ?? {
+      activeTransition = node.T ?? {
         time: clock,
         pendingNodes: [],
         asyncNodes: [],
-        queues: [[], []]
+        queueStash: { k: [[], []], l: [] }
       };
     }
     transitions.add(activeTransition);
     activeTransition.time = clock;
     for (let i = 0; i < globalQueue.h.length; i++) {
       const n = globalQueue.h[i];
-      n.S = activeTransition;
+      n.T = activeTransition;
       activeTransition.pendingNodes.push(n);
     }
     globalQueue.h = activeTransition.pendingNodes;
@@ -294,9 +315,9 @@ function runPending(pendingNodes, value) {
   const p = pendingNodes.slice();
   for (let i = 0; i < p.length; i++) {
     const n = p[i];
-    n.S = activeTransition;
-    if (n.G) {
-      n.G.ca(value);
+    n.T = activeTransition;
+    if (n.H) {
+      n.H.da(value);
       needsReset = true;
     }
   }
@@ -325,14 +346,14 @@ function transitionComplete(transition) {
 function notifyUnobserved() {
   for (let i = 0; i < unobserved.length; i++) {
     const source = unobserved[i];
-    if (!source.p)
-      unobserved[i].ra?.();
+    if (!source.s)
+      unobserved[i].sa?.();
   }
   unobserved = [];
 }
 
 // src/core/core.ts
-GlobalQueue.R = recompute;
+GlobalQueue.S = recompute;
 GlobalQueue.ka = disposeChildren;
 var tracking = false;
 var stale = false;
@@ -340,27 +361,35 @@ var pendingValueCheck = false;
 var pendingCheck = null;
 var context = null;
 var defaultContext = {};
+function notifySubs(node) {
+  for (let s = node.s; s !== null; s = s.A) {
+    const queue = s.j.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue;
+    if (queue.p > s.j.c)
+      queue.p = s.j.c;
+    insertIntoHeap(s.j, queue);
+  }
+}
 function recompute(el, create = false) {
   deleteFromHeap(el, el.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
-  if (el.d !== NOT_PENDING || el.T || el.U)
+  if (el.e !== NOT_PENDING || el.U || el.V)
     disposeChildren(el);
   else {
     markDisposal(el);
     globalQueue.h.push(el);
+    el.V = el.t;
     el.U = el.q;
-    el.T = el.n;
+    el.t = null;
     el.q = null;
-    el.n = null;
   }
   const oldcontext = context;
   context = el;
-  el.H = null;
+  el.I = null;
   el.b = 4 /* RecomputingDeps */;
-  el.V = clock;
-  let value = el.d === NOT_PENDING ? el.g : el.d;
-  let oldHeight = el.e;
+  el.J = clock;
+  let value = el.e === NOT_PENDING ? el.g : el.e;
+  let oldHeight = el.c;
   let prevStatusFlags = el.f;
-  let prevError = el.B;
+  let prevError = el.C;
   let prevTracking = tracking;
   clearStatusFlags(el);
   tracking = true;
@@ -379,50 +408,50 @@ function recompute(el, create = false) {
   }
   el.b = 0 /* None */;
   context = oldcontext;
-  const depsTail = el.H;
-  let toRemove = depsTail !== null ? depsTail.E : el.u;
+  const depsTail = el.I;
+  let toRemove = depsTail !== null ? depsTail.F : el.x;
   if (toRemove !== null) {
     do {
       toRemove = unlinkSubs(toRemove);
     } while (toRemove !== null);
     if (depsTail !== null) {
-      depsTail.E = null;
+      depsTail.F = null;
     } else {
-      el.u = null;
+      el.x = null;
     }
   }
-  const valueChanged = !el.da || !el.da(el.d === NOT_PENDING ? el.g : el.d, value);
-  const statusFlagsChanged = el.f !== prevStatusFlags || el.B !== prevError;
+  const valueChanged = !el.ea || !el.ea(el.e === NOT_PENDING ? el.g : el.e, value);
+  const statusFlagsChanged = el.f !== prevStatusFlags || el.C !== prevError;
   el.la?.(statusFlagsChanged, prevStatusFlags);
   if (valueChanged || statusFlagsChanged) {
     if (valueChanged) {
-      if (create || el.ia || el.I)
+      if (create || el.ia || el.K)
         el.g = value;
       else {
-        if (el.d === NOT_PENDING)
+        if (el.e === NOT_PENDING)
           globalQueue.h.push(el);
-        el.d = value;
+        el.e = value;
       }
-      if (el.C)
-        el.C.ca(value);
+      if (el.D)
+        el.D.da(value);
     }
-    for (let s = el.p; s !== null; s = s.y) {
-      const queue = s.m.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue;
-      if (s.m.e < el.e && queue.t > s.m.e)
-        queue.t = s.m.e;
-      insertIntoHeap(s.m, queue);
+    for (let s = el.s; s !== null; s = s.A) {
+      const queue = s.j.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue;
+      if (s.j.c < el.c && queue.p > s.j.c)
+        queue.p = s.j.c;
+      insertIntoHeap(s.j, queue);
     }
-  } else if (el.e != oldHeight) {
-    for (let s = el.p; s !== null; s = s.y) {
-      insertIntoHeapHeight(s.m, s.m.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
+  } else if (el.c != oldHeight) {
+    for (let s = el.s; s !== null; s = s.A) {
+      insertIntoHeapHeight(s.j, s.j.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
     }
   }
 }
 function updateIfNecessary(el) {
   if (el.b & 1 /* Check */) {
-    for (let d = el.u; d; d = d.E) {
-      const dep1 = d.P;
-      const dep = "_owner" in dep1 ? dep1.z : dep1;
+    for (let d = el.x; d; d = d.F) {
+      const dep1 = d.R;
+      const dep = "_owner" in dep1 ? dep1.B : dep1;
       if ("_fn" in dep) {
         updateIfNecessary(dep);
       }
@@ -437,9 +466,9 @@ function updateIfNecessary(el) {
   el.b = 0 /* None */;
 }
 function unlinkSubs(link2) {
-  const dep = link2.P;
-  const nextDep = link2.E;
-  const nextSub = link2.y;
+  const dep = link2.R;
+  const nextDep = link2.F;
+  const nextSub = link2.A;
   const prevSub = link2.ma;
   if (nextSub !== null) {
     nextSub.ma = prevSub;
@@ -447,52 +476,52 @@ function unlinkSubs(link2) {
     dep.W = prevSub;
   }
   if (prevSub !== null) {
-    prevSub.y = nextSub;
+    prevSub.A = nextSub;
   } else {
-    dep.p = nextSub;
+    dep.s = nextSub;
   }
   return nextDep;
 }
 function link(dep, sub) {
-  const prevDep = sub.H;
-  if (prevDep !== null && prevDep.P === dep) {
+  const prevDep = sub.I;
+  if (prevDep !== null && prevDep.R === dep) {
     return;
   }
   let nextDep = null;
   const isRecomputing = sub.b & 4 /* RecomputingDeps */;
   if (isRecomputing) {
-    nextDep = prevDep !== null ? prevDep.E : sub.u;
-    if (nextDep !== null && nextDep.P === dep) {
-      sub.H = nextDep;
+    nextDep = prevDep !== null ? prevDep.F : sub.x;
+    if (nextDep !== null && nextDep.R === dep) {
+      sub.I = nextDep;
       return;
     }
   }
   const prevSub = dep.W;
-  if (prevSub !== null && prevSub.m === sub && (!isRecomputing || isValidLink(prevSub, sub))) {
+  if (prevSub !== null && prevSub.j === sub && (!isRecomputing || isValidLink(prevSub, sub))) {
     return;
   }
-  const newLink = sub.H = dep.W = {
-    P: dep,
-    m: sub,
-    E: nextDep,
+  const newLink = sub.I = dep.W = {
+    R: dep,
+    j: sub,
+    F: nextDep,
     ma: prevSub,
-    y: null
+    A: null
   };
   if (prevDep !== null) {
-    prevDep.E = newLink;
+    prevDep.F = newLink;
   } else {
-    sub.u = newLink;
+    sub.x = newLink;
   }
   if (prevSub !== null) {
-    prevSub.y = newLink;
+    prevSub.A = newLink;
   } else {
-    dep.p = newLink;
+    dep.s = newLink;
   }
 }
 function isValidLink(checkLink, sub) {
-  const depsTail = sub.H;
+  const depsTail = sub.I;
   if (depsTail !== null) {
-    let link2 = sub.u;
+    let link2 = sub.x;
     do {
       if (link2 === checkLink) {
         return true;
@@ -500,23 +529,23 @@ function isValidLink(checkLink, sub) {
       if (link2 === depsTail) {
         break;
       }
-      link2 = link2.E;
+      link2 = link2.F;
     } while (link2 !== null);
   }
   return false;
 }
 function setStatusFlags(signal2, flags, error = null) {
   signal2.f = flags;
-  signal2.B = error;
+  signal2.C = error;
 }
 function setError(signal2, error) {
-  setStatusFlags(signal2, 2 /* Error */ | 4 /* Uninitialized */, error);
+  setStatusFlags(signal2, 2 /* Error */, error);
 }
 function clearStatusFlags(signal2) {
   setStatusFlags(signal2, 0 /* None */);
 }
 function markDisposal(el) {
-  let child = el.n;
+  let child = el.q;
   while (child) {
     child.b |= 32 /* Zombie */;
     const inHeap = child.b & 8 /* InHeap */;
@@ -525,7 +554,7 @@ function markDisposal(el) {
       insertIntoHeap(child, zombieQueue);
     }
     markDisposal(child);
-    child = child.K;
+    child = child.M;
   }
 }
 function disposeChildren(node, self = false, zombie) {
@@ -533,32 +562,32 @@ function disposeChildren(node, self = false, zombie) {
     return;
   if (self)
     node.b = 64 /* Disposed */;
-  let child = zombie ? node.T : node.n;
+  let child = zombie ? node.U : node.q;
   while (child) {
-    const nextChild = child.K;
-    if (child.u) {
+    const nextChild = child.M;
+    if (child.x) {
       const n = child;
       deleteFromHeap(n, n.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
-      let toRemove = n.u;
+      let toRemove = n.x;
       do {
         toRemove = unlinkSubs(toRemove);
       } while (toRemove !== null);
-      n.u = null;
-      n.H = null;
+      n.x = null;
+      n.I = null;
     }
     disposeChildren(child, true);
     child = nextChild;
   }
   if (zombie) {
-    node.T = null;
+    node.U = null;
   } else {
-    node.n = null;
-    node.K = null;
+    node.q = null;
+    node.M = null;
   }
   runDisposal(node, zombie);
 }
 function runDisposal(node, zombie) {
-  let disposal = zombie ? node.U : node.q;
+  let disposal = zombie ? node.V : node.t;
   if (!disposal)
     return;
   if (Array.isArray(disposal)) {
@@ -569,13 +598,13 @@ function runDisposal(node, zombie) {
   } else {
     disposal.call(disposal);
   }
-  zombie ? node.U = null : node.q = null;
+  zombie ? node.V = null : node.t = null;
 }
 function withOptions(obj, options) {
   obj.id = options?.id ?? (context?.id != null ? getNextChildId(context) : void 0);
-  obj.da = options?.equals != null ? options.equals : isEqual;
-  obj.xa = !!options?.pureWrite;
-  obj.ra = options?.unobserved;
+  obj.ea = options?.equals != null ? options.equals : isEqual;
+  obj.ya = !!options?.pureWrite;
+  obj.sa = options?.unobserved;
   if (options?.ja)
     Object.assign(obj, options.ja);
   return obj;
@@ -592,47 +621,47 @@ function formatId(prefix, id) {
 function computed(fn, initialValue, options) {
   const self = withOptions(
     {
-      q: null,
+      t: null,
       i: globalQueue,
-      D: defaultContext,
+      E: defaultContext,
       na: 0,
       ha: fn,
       g: initialValue,
-      e: 0,
-      aa: null,
-      O: void 0,
+      c: 0,
+      ba: null,
+      Q: void 0,
+      z: null,
       x: null,
-      u: null,
-      H: null,
-      p: null,
+      I: null,
+      s: null,
       W: null,
-      s: context,
-      K: null,
-      n: null,
+      w: context,
+      M: null,
+      q: null,
       b: 0 /* None */,
       f: 4 /* Uninitialized */,
-      V: clock,
-      d: NOT_PENDING,
-      U: null,
-      T: null
+      J: clock,
+      e: NOT_PENDING,
+      V: null,
+      U: null
     },
     options
   );
-  self.x = self;
-  const parent = context?.Z ? context._ : context;
+  self.z = self;
+  const parent = context?._ ? context.$ : context;
   if (context) {
     context.i && (self.i = context.i);
-    context.D && (self.D = context.D);
-    const lastChild = context.n;
+    context.E && (self.E = context.E);
+    const lastChild = context.q;
     if (lastChild === null) {
-      context.n = self;
+      context.q = self;
     } else {
-      self.K = lastChild;
-      context.n = self;
+      self.M = lastChild;
+      context.q = self;
     }
   }
   if (parent)
-    self.e = parent.e + 1;
+    self.c = parent.c + 1;
   recompute(self, true);
   return self;
 }
@@ -660,6 +689,9 @@ function asyncComputed(asyncFn, initialValue, options) {
           return;
         globalQueue.initTransition(self);
         setError(self, e);
+        self.J = clock;
+        notifySubs(self);
+        schedule();
         flush();
       });
     } else {
@@ -677,6 +709,9 @@ function asyncComputed(asyncFn, initialValue, options) {
             return;
           globalQueue.initTransition(self);
           setError(self, error);
+          self.J = clock;
+          notifySubs(self);
+          schedule();
           flush();
         }
       })();
@@ -685,7 +720,7 @@ function asyncComputed(asyncFn, initialValue, options) {
     throw new NotReadyError(context);
   };
   const self = computed(fn, initialValue, options);
-  self.sa = () => {
+  self.ta = () => {
     refreshing = true;
     recompute(self);
     flush();
@@ -694,16 +729,16 @@ function asyncComputed(asyncFn, initialValue, options) {
 }
 function signal(v, options, firewall = null) {
   if (firewall !== null) {
-    return firewall.aa = withOptions(
+    return firewall.ba = withOptions(
       {
         g: v,
-        p: null,
+        s: null,
         W: null,
-        z: firewall,
-        qa: firewall.aa,
+        B: firewall,
+        ra: firewall.ba,
         f: 0 /* None */,
-        V: clock,
-        d: NOT_PENDING
+        J: clock,
+        e: NOT_PENDING
       },
       options
     );
@@ -711,11 +746,11 @@ function signal(v, options, firewall = null) {
     return withOptions(
       {
         g: v,
-        p: null,
+        s: null,
         W: null,
         f: 0 /* None */,
-        V: clock,
-        d: NOT_PENDING
+        J: clock,
+        e: NOT_PENDING
       },
       options
     );
@@ -736,98 +771,96 @@ function untrack(fn) {
 }
 function read(el) {
   let c = context;
-  if (c?.Z)
-    c = c._;
+  if (c?._)
+    c = c.$;
   if (c && tracking) {
     link(el, c);
-    const owner = "_owner" in el ? el.z : el;
+    const owner = "_owner" in el ? el.B : el;
     if ("_fn" in owner) {
       const isZombie = el.b & 32 /* Zombie */;
-      if (owner.e >= (isZombie ? zombieQueue.t : dirtyQueue.t)) {
+      if (owner.c >= (isZombie ? zombieQueue.p : dirtyQueue.p)) {
         markNode(c);
         markHeap(isZombie ? zombieQueue : dirtyQueue);
         updateIfNecessary(owner);
       }
-      const height = owner.e;
-      if (height >= c.e && el.s !== c) {
-        c.e = height + 1;
+      const height = owner.c;
+      if (height >= c.c && el.w !== c) {
+        c.c = height + 1;
       }
     }
   }
   if (pendingCheck) {
-    const pendingResult = (el.f & 1 /* Pending */) !== 0 || !!el.S || false;
-    if (!el.G) {
-      el.G = signal(pendingResult);
-      el.G.ia = true;
-      el.G.ca = (v) => setSignal(el.G, v);
+    const pendingResult = (el.f & 1 /* Pending */) !== 0 || !!el.T || false;
+    if (!el.H) {
+      el.H = signal(pendingResult);
+      el.H.ia = true;
+      el.H.da = (v) => setSignal(el.H, v);
     }
     const prev = pendingCheck;
     pendingCheck = null;
-    read(el.G);
+    read(el.H);
     pendingCheck = prev;
     prev.g = pendingResult || prev.g;
   }
   if (pendingValueCheck) {
-    if (!el.C) {
-      el.C = signal(
-        el.d === NOT_PENDING ? el.g : el.d
+    if (!el.D) {
+      el.D = signal(
+        el.e === NOT_PENDING ? el.g : el.e
       );
-      el.C.ia = true;
-      el.C.ca = (v) => queueMicrotask(() => queueMicrotask(() => setSignal(el.C, v)));
+      el.D.ia = true;
+      el.D.da = (v) => queueMicrotask(() => queueMicrotask(() => setSignal(el.D, v)));
     }
     pendingValueCheck = false;
     try {
-      return read(el.C);
+      return read(el.D);
     } finally {
       pendingValueCheck = true;
     }
   }
   if (el.f & 1 /* Pending */) {
     if (c && !stale || el.f & 4 /* Uninitialized */)
-      throw el.B;
+      throw el.C;
     else if (c && stale && !pendingCheck) {
       setStatusFlags(
         c,
         c.f | 1,
-        el.B
+        el.C
       );
     }
   }
   if (el.f & 2 /* Error */) {
-    if (el.V < clock) {
+    if (el.J < clock) {
       recompute(el, true);
       return read(el);
     } else {
-      throw el.B;
+      throw el.C;
     }
   }
-  return !c || el.d === NOT_PENDING || stale && !pendingCheck && el.S && activeTransition !== el.S ? el.g : el.d;
+  return !c || el.e === NOT_PENDING || stale && !pendingCheck && el.T && activeTransition !== el.T ? el.g : el.e;
 }
 function setSignal(el, v) {
   if (typeof v === "function") {
     v = v(
-      el.d === NOT_PENDING ? el.g : el.d
+      el.e === NOT_PENDING ? el.g : el.e
     );
   }
-  const valueChanged = !el.da || !el.da(el.d === NOT_PENDING ? el.g : el.d, v);
+  const valueChanged = !el.ea || !el.ea(el.e === NOT_PENDING ? el.g : el.e, v);
   if (!valueChanged && !el.f)
     return v;
   if (valueChanged) {
     if (el.ia)
       el.g = v;
     else {
-      if (el.d === NOT_PENDING)
+      if (el.e === NOT_PENDING)
         globalQueue.h.push(el);
-      el.d = v;
+      el.e = v;
     }
-    if (el.C)
-      el.C.ca(v);
+    if (el.D)
+      el.D.da(v);
   }
   clearStatusFlags(el);
-  el.V = clock;
-  for (let link2 = el.p; link2 !== null; link2 = link2.y) {
-    insertIntoHeap(link2.m, link2.m.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
-  }
+  el.J = clock;
+  notifySubs(el);
   schedule();
   return v;
 }
@@ -841,41 +874,41 @@ function onCleanup(fn) {
   if (!context)
     return fn;
   const node = context;
-  if (!node.q) {
-    node.q = fn;
-  } else if (Array.isArray(node.q)) {
-    node.q.push(fn);
+  if (!node.t) {
+    node.t = fn;
+  } else if (Array.isArray(node.t)) {
+    node.t.push(fn);
   } else {
-    node.q = [node.q, fn];
+    node.t = [node.t, fn];
   }
   return fn;
 }
 function createOwner(options) {
   const parent = context;
   const owner = {
-    Z: true,
-    _: parent?.Z ? parent._ : parent,
-    n: null,
-    K: null,
+    _: true,
+    $: parent?._ ? parent.$ : parent,
     q: null,
+    M: null,
+    t: null,
     id: options?.id ?? (parent?.id != null ? getNextChildId(parent) : void 0),
     i: parent?.i ?? globalQueue,
-    D: parent?.D || defaultContext,
+    E: parent?.E || defaultContext,
     na: 0,
+    V: null,
     U: null,
-    T: null,
-    s: parent,
+    w: parent,
     dispose(self = true) {
       disposeChildren(owner, self);
     }
   };
   if (parent) {
-    const lastChild = parent.n;
+    const lastChild = parent.q;
     if (lastChild === null) {
-      parent.n = owner;
+      parent.q = owner;
     } else {
-      owner.K = lastChild;
-      parent.n = owner;
+      owner.M = lastChild;
+      parent.q = owner;
     }
   }
   return owner;
@@ -936,7 +969,7 @@ function getContext(context2, owner = getOwner()) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  const value = hasContext(context2, owner) ? owner.D[context2.id] : context2.defaultValue;
+  const value = hasContext(context2, owner) ? owner.E[context2.id] : context2.defaultValue;
   if (isUndefined(value)) {
     throw new ContextNotFoundError();
   }
@@ -946,13 +979,13 @@ function setContext(context2, value, owner = getOwner()) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  owner.D = {
-    ...owner.D,
+  owner.E = {
+    ...owner.E,
     [context2.id]: isUndefined(value) ? context2.defaultValue : value
   };
 }
 function hasContext(context2, owner) {
-  return !isUndefined(owner?.D[context2.id]);
+  return !isUndefined(owner?.E[context2.id]);
 }
 function isUndefined(value) {
   return typeof value === "undefined";
@@ -964,28 +997,28 @@ function effect(compute, effect2, error, initialValue, options) {
   const node = computed(compute, initialValue, {
     ...options,
     ja: {
-      ea: true,
+      fa: true,
       oa: initialValue,
-      ta: effect2,
+      ua: effect2,
       pa: error,
-      L: void 0,
+      N: void 0,
       i: getOwner()?.i ?? globalQueue,
-      I: options?.render ? 1 /* Render */ : 2 /* User */,
+      K: options?.render ? 1 /* Render */ : 2 /* User */,
       la(statusFlagsChanged, prevStatusFlags) {
         if (initialized) {
           const errorChanged = this.f && this.f === prevStatusFlags && statusFlagsChanged;
-          this.ea = !(this.f & 2 /* Error */) && !(this.f & 1 /* Pending */ & ~prevStatusFlags) && !errorChanged;
-          if (this.ea)
-            this.i.enqueue(this.I, runEffect.bind(this));
+          this.fa = !(this.f & 2 /* Error */) && !(this.f & 1 /* Pending */ & ~prevStatusFlags) && !errorChanged;
+          if (this.fa)
+            this.i.enqueue(this.K, runEffect.bind(this));
         }
         if (this.f & 2 /* Error */) {
-          let error2 = this.B;
+          let error2 = this.C;
           this.i.notify(this, 1 /* Pending */, 0);
-          if (this.I === 2 /* User */) {
+          if (this.K === 2 /* User */) {
             try {
               return this.pa ? this.pa(error2, () => {
-                this.L?.();
-                this.L = void 0;
+                this.N?.();
+                this.N = void 0;
               }) : console.error(error2);
             } catch (e) {
               error2 = e;
@@ -993,7 +1026,7 @@ function effect(compute, effect2, error, initialValue, options) {
           }
           if (!this.i.notify(this, 2 /* Error */, 2 /* Error */))
             throw error2;
-        } else if (this.I === 1 /* Render */) {
+        } else if (this.K === 1 /* Render */) {
           this.i.notify(
             this,
             1 /* Pending */ | 2 /* Error */,
@@ -1004,25 +1037,24 @@ function effect(compute, effect2, error, initialValue, options) {
     }
   });
   initialized = true;
-  if (node.I === 1 /* Render */) {
-    node.ha = (p) => !(node.f & 2 /* Error */) ? staleValues(() => compute(p)) : compute(p);
-  }
-  !options?.defer && !(node.f & (2 /* Error */ | 1 /* Pending */)) && (node.I === 2 /* User */ ? node.i.enqueue(node.I, runEffect.bind(node)) : runEffect.call(node));
-  onCleanup(() => node.L?.());
+  if (node.K === 1 /* Render */)
+    node.ha = (p) => staleValues(() => compute(p));
+  !options?.defer && !(node.f & (2 /* Error */ | 1 /* Pending */)) && (node.K === 2 /* User */ ? node.i.enqueue(node.K, runEffect.bind(node)) : runEffect.call(node));
+  onCleanup(() => node.N?.());
 }
 function runEffect() {
-  if (!this.ea || this.b & 64 /* Disposed */)
+  if (!this.fa || this.b & 64 /* Disposed */)
     return;
-  this.L?.();
-  this.L = void 0;
+  this.N?.();
+  this.N = void 0;
   try {
-    this.L = this.ta(this.g, this.oa);
+    this.N = this.ua(this.g, this.oa);
   } catch (error) {
     if (!this.i.notify(this, 2 /* Error */, 2 /* Error */))
       throw error;
   } finally {
     this.oa = this.g;
-    this.ea = false;
+    this.fa = false;
   }
 }
 
@@ -1053,7 +1085,7 @@ function createMemo(compute, value, options) {
 function createAsync(compute, value, options) {
   const node = asyncComputed(compute, value, options);
   const ret = read.bind(null, node);
-  ret.refresh = node.sa;
+  ret.refresh = node.ta;
   return ret;
 }
 function createEffect(compute, effectFn, value, options) {
@@ -1366,7 +1398,7 @@ var storeTraps = {
         return desc.get.call(receiver);
     }
     if (Writing?.has(receiver)) {
-      let value2 = tracked && (overridden || !proxySource) ? tracked.d !== NOT_PENDING ? tracked.d : tracked.g : storeValue[property];
+      let value2 = tracked && (overridden || !proxySource) ? tracked.e !== NOT_PENDING ? tracked.e : tracked.g : storeValue[property];
       value2 === $DELETED && (value2 = void 0);
       if (!isWrappable(value2))
         return value2;
@@ -1765,98 +1797,98 @@ function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
   return createMemo(
     updateKeyedMap.bind({
-      z: createOwner(),
-      j: 0,
-      ua: list,
-      F: [],
-      M: map,
-      c: [],
+      B: createOwner(),
+      m: 0,
+      va: list,
+      G: [],
+      O: map,
+      d: [],
       a: [],
-      N: keyFn,
-      k: keyFn || options?.keyed === false ? [] : void 0,
-      l: map.length > 1 ? [] : void 0,
+      P: keyFn,
+      n: keyFn || options?.keyed === false ? [] : void 0,
+      o: map.length > 1 ? [] : void 0,
       X: options?.fallback
     })
   );
 }
 var pureOptions = { pureWrite: true };
 function updateKeyedMap() {
-  const newItems = this.ua() || [], newLen = newItems.length;
+  const newItems = this.va() || [], newLen = newItems.length;
   newItems[$TRACK];
-  runWithOwner(this.z, () => {
-    let i, j, mapper = this.k ? () => {
-      this.k[j] = signal(newItems[j], pureOptions);
-      this.l && (this.l[j] = signal(j, pureOptions));
-      return this.M(
-        read.bind(null, this.k[j]),
-        this.l ? read.bind(null, this.l[j]) : void 0
+  runWithOwner(this.B, () => {
+    let i, j, mapper = this.n ? () => {
+      this.n[j] = signal(newItems[j], pureOptions);
+      this.o && (this.o[j] = signal(j, pureOptions));
+      return this.O(
+        read.bind(null, this.n[j]),
+        this.o ? read.bind(null, this.o[j]) : void 0
       );
-    } : this.l ? () => {
+    } : this.o ? () => {
       const item = newItems[j];
-      this.l[j] = signal(j, pureOptions);
-      return this.M(
+      this.o[j] = signal(j, pureOptions);
+      return this.O(
         () => item,
-        read.bind(null, this.l[j])
+        read.bind(null, this.o[j])
       );
     } : () => {
       const item = newItems[j];
-      return this.M(() => item);
+      return this.O(() => item);
     };
     if (newLen === 0) {
-      if (this.j !== 0) {
-        this.z.dispose(false);
+      if (this.m !== 0) {
+        this.B.dispose(false);
         this.a = [];
-        this.F = [];
-        this.c = [];
-        this.j = 0;
-        this.k && (this.k = []);
-        this.l && (this.l = []);
+        this.G = [];
+        this.d = [];
+        this.m = 0;
+        this.n && (this.n = []);
+        this.o && (this.o = []);
       }
-      if (this.X && !this.c[0]) {
-        this.c[0] = runWithOwner(
+      if (this.X && !this.d[0]) {
+        this.d[0] = runWithOwner(
           this.a[0] = createOwner(),
           this.X
         );
       }
-    } else if (this.j === 0) {
+    } else if (this.m === 0) {
       if (this.a[0])
         this.a[0].dispose();
-      this.c = new Array(newLen);
+      this.d = new Array(newLen);
       for (j = 0; j < newLen; j++) {
-        this.F[j] = newItems[j];
-        this.c[j] = runWithOwner(this.a[j] = createOwner(), mapper);
+        this.G[j] = newItems[j];
+        this.d[j] = runWithOwner(this.a[j] = createOwner(), mapper);
       }
-      this.j = newLen;
+      this.m = newLen;
     } else {
-      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.k ? new Array(newLen) : void 0, tempIndexes = this.l ? new Array(newLen) : void 0;
-      for (start = 0, end = Math.min(this.j, newLen); start < end && (this.F[start] === newItems[start] || this.k && compare(this.N, this.F[start], newItems[start])); start++) {
-        if (this.k)
-          setSignal(this.k[start], newItems[start]);
+      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.n ? new Array(newLen) : void 0, tempIndexes = this.o ? new Array(newLen) : void 0;
+      for (start = 0, end = Math.min(this.m, newLen); start < end && (this.G[start] === newItems[start] || this.n && compare(this.P, this.G[start], newItems[start])); start++) {
+        if (this.n)
+          setSignal(this.n[start], newItems[start]);
       }
-      for (end = this.j - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.F[end] === newItems[newEnd] || this.k && compare(this.N, this.F[end], newItems[newEnd])); end--, newEnd--) {
-        temp[newEnd] = this.c[end];
+      for (end = this.m - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.G[end] === newItems[newEnd] || this.n && compare(this.P, this.G[end], newItems[newEnd])); end--, newEnd--) {
+        temp[newEnd] = this.d[end];
         tempNodes[newEnd] = this.a[end];
-        tempRows && (tempRows[newEnd] = this.k[end]);
-        tempIndexes && (tempIndexes[newEnd] = this.l[end]);
+        tempRows && (tempRows[newEnd] = this.n[end]);
+        tempIndexes && (tempIndexes[newEnd] = this.o[end]);
       }
       newIndices = /* @__PURE__ */ new Map();
       newIndicesNext = new Array(newEnd + 1);
       for (j = newEnd; j >= start; j--) {
         item = newItems[j];
-        key = this.N ? this.N(item) : item;
+        key = this.P ? this.P(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.F[i];
-        key = this.N ? this.N(item) : item;
+        item = this.G[i];
+        key = this.P ? this.P(item) : item;
         j = newIndices.get(key);
         if (j !== void 0 && j !== -1) {
-          temp[j] = this.c[i];
+          temp[j] = this.d[i];
           tempNodes[j] = this.a[i];
-          tempRows && (tempRows[j] = this.k[i]);
-          tempIndexes && (tempIndexes[j] = this.l[i]);
+          tempRows && (tempRows[j] = this.n[i]);
+          tempIndexes && (tempIndexes[j] = this.o[i]);
           j = newIndicesNext[j];
           newIndices.set(key, j);
         } else
@@ -1864,52 +1896,52 @@ function updateKeyedMap() {
       }
       for (j = start; j < newLen; j++) {
         if (j in temp) {
-          this.c[j] = temp[j];
+          this.d[j] = temp[j];
           this.a[j] = tempNodes[j];
           if (tempRows) {
-            this.k[j] = tempRows[j];
-            setSignal(this.k[j], newItems[j]);
+            this.n[j] = tempRows[j];
+            setSignal(this.n[j], newItems[j]);
           }
           if (tempIndexes) {
-            this.l[j] = tempIndexes[j];
-            setSignal(this.l[j], j);
+            this.o[j] = tempIndexes[j];
+            setSignal(this.o[j], j);
           }
         } else {
-          this.c[j] = runWithOwner(this.a[j] = createOwner(), mapper);
+          this.d[j] = runWithOwner(this.a[j] = createOwner(), mapper);
         }
       }
-      this.c = this.c.slice(0, this.j = newLen);
-      this.F = newItems.slice(0);
+      this.d = this.d.slice(0, this.m = newLen);
+      this.G = newItems.slice(0);
     }
   });
-  return this.c;
+  return this.d;
 }
 function repeat(count, map, options) {
   return updateRepeat.bind({
-    z: createOwner(),
-    j: 0,
-    w: 0,
-    va: count,
-    M: map,
+    B: createOwner(),
+    m: 0,
+    y: 0,
+    wa: count,
+    O: map,
     a: [],
-    c: [],
-    wa: options?.from,
+    d: [],
+    xa: options?.from,
     X: options?.fallback
   });
 }
 function updateRepeat() {
-  const newLen = this.va();
-  const from = this.wa?.() || 0;
-  runWithOwner(this.z, () => {
+  const newLen = this.wa();
+  const from = this.xa?.() || 0;
+  runWithOwner(this.B, () => {
     if (newLen === 0) {
-      if (this.j !== 0) {
-        this.z.dispose(false);
+      if (this.m !== 0) {
+        this.B.dispose(false);
         this.a = [];
-        this.c = [];
-        this.j = 0;
+        this.d = [];
+        this.m = 0;
       }
-      if (this.X && !this.c[0]) {
-        this.c[0] = runWithOwner(
+      if (this.X && !this.d[0]) {
+        this.d[0] = runWithOwner(
           this.a[0] = createOwner(),
           this.X
         );
@@ -1917,44 +1949,44 @@ function updateRepeat() {
       return;
     }
     const to = from + newLen;
-    const prevTo = this.w + this.j;
-    if (this.j === 0 && this.a[0])
+    const prevTo = this.y + this.m;
+    if (this.m === 0 && this.a[0])
       this.a[0].dispose();
     for (let i = to; i < prevTo; i++)
-      this.a[i - this.w].dispose();
-    if (this.w < from) {
-      let i = this.w;
-      while (i < from && i < this.j)
+      this.a[i - this.y].dispose();
+    if (this.y < from) {
+      let i = this.y;
+      while (i < from && i < this.m)
         this.a[i++].dispose();
-      this.a.splice(0, from - this.w);
-      this.c.splice(0, from - this.w);
-    } else if (this.w > from) {
-      let i = prevTo - this.w - 1;
-      let difference = this.w - from;
-      this.a.length = this.c.length = newLen;
+      this.a.splice(0, from - this.y);
+      this.d.splice(0, from - this.y);
+    } else if (this.y > from) {
+      let i = prevTo - this.y - 1;
+      let difference = this.y - from;
+      this.a.length = this.d.length = newLen;
       while (i >= difference) {
         this.a[i] = this.a[i - difference];
-        this.c[i] = this.c[i - difference];
+        this.d[i] = this.d[i - difference];
         i--;
       }
       for (let i2 = 0; i2 < difference; i2++) {
-        this.c[i2] = runWithOwner(
+        this.d[i2] = runWithOwner(
           this.a[i2] = createOwner(),
-          () => this.M(i2 + from)
+          () => this.O(i2 + from)
         );
       }
     }
     for (let i = prevTo; i < to; i++) {
-      this.c[i - from] = runWithOwner(
+      this.d[i - from] = runWithOwner(
         this.a[i - from] = createOwner(),
-        () => this.M(i)
+        () => this.O(i)
       );
     }
-    this.c = this.c.slice(0, newLen);
-    this.w = from;
-    this.j = newLen;
+    this.d = this.d.slice(0, newLen);
+    this.y = from;
+    this.m = newLen;
   });
-  return this.c;
+  return this.d;
 }
 function compare(key, a, b) {
   return key ? key(a) === key(b) : true;
@@ -1988,20 +2020,20 @@ function createBoundChildren(owner, fn, queue, mask) {
   });
 }
 var ConditionalQueue = class extends Queue {
-  r;
-  fa = /* @__PURE__ */ new Set();
+  u;
+  ga = /* @__PURE__ */ new Set();
   h = /* @__PURE__ */ new Set();
   constructor(disabled) {
     super();
-    this.r = disabled;
+    this.u = disabled;
   }
   run(type) {
-    if (!type || read(this.r))
+    if (!type || read(this.u))
       return;
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (read(this.r)) {
+    if (read(this.u)) {
       if (type & 1 /* Pending */) {
         if (flags & 1 /* Pending */) {
           this.h.add(node);
@@ -2011,9 +2043,9 @@ var ConditionalQueue = class extends Queue {
       }
       if (type & 2 /* Error */) {
         if (flags & 2 /* Error */) {
-          this.fa.add(node);
+          this.ga.add(node);
           type &= ~2 /* Error */;
-        } else if (this.fa.delete(node))
+        } else if (this.ga.delete(node))
           type &= ~2 /* Error */;
       }
     }
@@ -2021,31 +2053,32 @@ var ConditionalQueue = class extends Queue {
   }
 };
 var CollectionQueue = class extends Queue {
-  ga;
+  Z;
   a = /* @__PURE__ */ new Set();
-  r = signal(false, { pureWrite: true });
+  u = signal(false, { pureWrite: true });
+  qa = false;
   constructor(type) {
     super();
-    this.ga = type;
+    this.Z = type;
   }
   run(type) {
-    if (!type || read(this.r))
+    if (!type || read(this.u))
       return;
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (!(type & this.ga))
+    if (!(type & this.Z) || this.Z & 1 /* Pending */ && this.qa)
       return super.notify(node, type, flags);
-    if (flags & this.ga) {
+    if (flags & this.Z) {
       this.a.add(node);
       if (this.a.size === 1)
-        setSignal(this.r, true);
+        setSignal(this.u, true);
     } else if (this.a.size > 0) {
       this.a.delete(node);
       if (this.a.size === 0)
-        setSignal(this.r, false);
+        setSignal(this.u, false);
     }
-    type &= ~this.ga;
+    type &= ~this.Z;
     return type ? super.notify(node, type, flags) : true;
   }
 };
@@ -2054,28 +2087,29 @@ function createBoundary(fn, condition) {
   const queue = new ConditionalQueue(computed(() => condition() === "hidden" /* HIDDEN */));
   const tree = createBoundChildren(owner, fn, queue, 0);
   computed(() => {
-    const disabled = read(queue.r);
+    const disabled = read(queue.u);
     tree.Y = disabled ? 2 /* Error */ | 1 /* Pending */ : 0;
     if (!disabled) {
       queue.h.forEach(
         (node) => queue.notify(node, 1 /* Pending */, 1 /* Pending */)
       );
-      queue.fa.forEach((node) => queue.notify(node, 2 /* Error */, 2 /* Error */));
+      queue.ga.forEach((node) => queue.notify(node, 2 /* Error */, 2 /* Error */));
       queue.h.clear();
-      queue.fa.clear();
+      queue.ga.clear();
     }
   });
-  return () => read(queue.r) ? void 0 : read(tree);
+  return () => read(queue.u) ? void 0 : read(tree);
 }
 function createCollectionBoundary(type, fn, fallback) {
   const owner = createOwner();
   const queue = new CollectionQueue(type);
   const tree = createBoundChildren(owner, fn, queue, type);
   const decision = computed(() => {
-    if (!read(queue.r)) {
+    if (!read(queue.u)) {
       const resolved = read(tree);
-      if (!untrack(() => read(queue.r)))
-        return resolved;
+      if (!untrack(() => read(queue.u)))
+        queue.qa = true;
+      return resolved;
     }
     return fallback(queue);
   });
@@ -2087,7 +2121,7 @@ function createLoadBoundary(fn, fallback) {
 function createErrorBoundary(fn, fallback) {
   return createCollectionBoundary(2 /* Error */, fn, (queue) => {
     let node = queue.a.values().next().value;
-    return fallback(node.B, () => {
+    return fallback(node.C, () => {
       for (let node2 of queue.a) {
         recompute(node2, true);
       }