@solidjs/signals 0.8.1 → 0.8.3

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.q?._ ? n.q.$?.c : n.q?.c) ?? -1;
+  const parentHeight = (n.w?.$ ? n.w.aa?.c : n.w?.c) ?? -1;
   if (parentHeight >= n.c)
     n.c = parentHeight + 1;
   const height = n.c;
-  const heapAtHeight = heap.p[height];
+  const heapAtHeight = heap.s[height];
   if (heapAtHeight === void 0) {
-    heap.p[height] = n;
+    heap.s[height] = n;
   } else {
-    const tail = heapAtHeight.x;
-    tail.P = 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) {
@@ -66,28 +66,28 @@ function deleteFromHeap(n, heap) {
     return;
   n.b = flags & ~(8 /* InHeap */ | 16 /* InHeapHeight */);
   const height = n.c;
-  if (n.x === n) {
-    heap.p[height] = void 0;
+  if (n.z === n) {
+    heap.s[height] = void 0;
   } else {
-    const next = n.P;
-    const dhh = heap.p[height];
+    const next = n.Q;
+    const dhh = heap.s[height];
     const end = next ?? dhh;
     if (n === dhh) {
-      heap.p[height] = next;
+      heap.s[height] = next;
     } else {
-      n.x.P = next;
+      n.z.Q = next;
     }
-    end.x = n.x;
+    end.z = n.z;
   }
-  n.x = n;
-  n.P = void 0;
+  n.z = n;
+  n.Q = void 0;
 }
 function markHeap(heap) {
-  if (heap.aa)
+  if (heap.ba)
     return;
-  heap.aa = true;
-  for (let i = 0; i <= heap.J; i++) {
-    for (let el = heap.p[i]; el !== void 0; el = el.P) {
+  heap.ba = true;
+  for (let i = 0; i <= heap.L; i++) {
+    for (let el = heap.s[i]; el !== void 0; el = el.Q) {
       if (el.b & 8 /* InHeap */)
         markNode(el);
     }
@@ -98,39 +98,39 @@ 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.r; link2 !== null; link2 = link2.y) {
+  for (let link2 = el.x; link2 !== null; link2 = link2.A) {
     markNode(link2.j, 1 /* Check */);
   }
-  if (el.ba !== null) {
-    for (let child = el.ba; child !== null; child = child.ra) {
-      for (let link2 = child.r; link2 !== null; link2 = link2.y) {
+  if (el.ca !== null) {
+    for (let child = el.ca; child !== null; child = child.sa) {
+      for (let link2 = child.x; link2 !== null; link2 = link2.A) {
         markNode(link2.j, 1 /* Check */);
       }
     }
   }
 }
 function runHeap(heap, recompute2) {
-  heap.aa = false;
-  for (heap.n = 0; heap.n <= heap.J; heap.n++) {
-    let el = heap.p[heap.n];
+  heap.ba = false;
+  for (heap.q = 0; heap.q <= heap.L; heap.q++) {
+    let el = heap.s[heap.q];
     while (el !== void 0) {
       if (el.b & 8 /* InHeap */)
         recompute2(el);
       else {
         adjustHeight(el, heap);
       }
-      el = heap.p[heap.n];
+      el = heap.s[heap.q];
     }
   }
-  heap.J = 0;
+  heap.L = 0;
 }
 function adjustHeight(el, heap) {
   deleteFromHeap(el, heap);
   let newHeight = el.c;
-  for (let d = el.u; d; d = d.E) {
-    const dep1 = d.Q;
-    const dep = "_owner" in dep1 ? dep1.z : dep1;
-    if ("_fn" in dep) {
+  for (let d = el.l; d; d = d.E) {
+    const dep1 = d.R;
+    const dep = dep1.ia || dep1;
+    if (dep.H) {
       if (dep.c >= newHeight) {
         newHeight = dep.c + 1;
       }
@@ -138,7 +138,7 @@ function adjustHeight(el, heap) {
   }
   if (el.c !== newHeight) {
     el.c = newHeight;
-    for (let s = el.r; s !== null; s = s.y) {
+    for (let s = el.x; s !== null; s = s.A) {
       insertIntoHeapHeight(s.j, heap);
     }
   }
@@ -147,83 +147,104 @@ function adjustHeight(el, heap) {
 // src/core/scheduler.ts
 var clock = 0;
 var activeTransition = null;
-var unobserved = [];
 var transitions = /* @__PURE__ */ new Set();
 var scheduled = false;
 function schedule() {
   if (scheduled)
     return;
   scheduled = true;
-  if (!globalQueue.ca)
+  if (!globalQueue.da)
     queueMicrotask(flush);
 }
 var dirtyQueue = {
-  p: new Array(2e3).fill(void 0),
-  aa: false,
-  n: 0,
-  J: 0
+  s: new Array(2e3).fill(void 0),
+  ba: false,
+  q: 0,
+  L: 0
 };
 var zombieQueue = {
-  p: new Array(2e3).fill(void 0),
-  aa: false,
-  n: 0,
-  J: 0
+  s: new Array(2e3).fill(void 0),
+  ba: false,
+  q: 0,
+  L: 0
 };
 var Queue = class {
-  q = null;
-  A = [[], []];
-  R = [];
+  w = null;
+  k = [[], []];
+  m = [];
   created = clock;
   addChild(child) {
-    this.R.push(child);
-    child.q = this;
+    this.m.push(child);
+    child.w = this;
   }
   removeChild(child) {
-    const index = this.R.indexOf(child);
+    const index = this.m.indexOf(child);
     if (index >= 0) {
-      this.R.splice(index, 1);
-      child.q = null;
+      this.m.splice(index, 1);
+      child.w = null;
     }
   }
   notify(node, mask, flags) {
-    if (this.q)
-      return this.q.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.R.length; i++) {
-      this.R[i].run(type);
+    for (let i = 0; i < this.m.length; i++) {
+      this.m[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.m.length; i++) {
+      let child = this.m[i];
+      let childStub = stub.m[i];
+      if (!childStub) {
+        childStub = { k: [[], []], m: [] };
+        stub.m[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.m.length; i++) {
+      const childStub = stub.m[i];
+      let child = this.m[i];
+      if (child)
+        child.restoreQueues(childStub);
+    }
+  }
 };
 var GlobalQueue = class _GlobalQueue extends Queue {
-  ca = false;
+  da = false;
   h = [];
   static S;
   static la;
   flush() {
-    if (this.ca)
+    if (this.da)
       return;
-    this.ca = true;
+    this.da = true;
     try {
       runHeap(dirtyQueue, _GlobalQueue.S);
       if (activeTransition) {
         if (!transitionComplete(activeTransition)) {
           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,8 +252,7 @@ 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))
@@ -245,7 +265,7 @@ var GlobalQueue = class _GlobalQueue extends Queue {
           n.g = n.e;
           n.e = NOT_PENDING;
         }
-        if (n.ha)
+        if (n.H)
           _GlobalQueue.la(n, false, true);
       }
       globalQueue.h.length = 0;
@@ -254,8 +274,7 @@ var GlobalQueue = class _GlobalQueue extends Queue {
       this.run(1 /* Render */);
       this.run(2 /* User */);
     } finally {
-      this.ca = false;
-      unobserved.length && notifyUnobserved();
+      this.da = false;
     }
   }
   notify(node, mask, flags) {
@@ -276,7 +295,7 @@ var GlobalQueue = class _GlobalQueue extends Queue {
         time: clock,
         pendingNodes: [],
         asyncNodes: [],
-        queues: [[], []]
+        queueStash: { k: [[], []], m: [] }
       };
     }
     transitions.add(activeTransition);
@@ -295,8 +314,8 @@ function runPending(pendingNodes, value) {
   for (let i = 0; i < p.length; i++) {
     const n = p[i];
     n.T = activeTransition;
-    if (n.G) {
-      n.G.da(value);
+    if (n.I) {
+      n.I.ea(value);
       needsReset = true;
     }
   }
@@ -322,14 +341,6 @@ function transitionComplete(transition) {
   }
   return done;
 }
-function notifyUnobserved() {
-  for (let i = 0; i < unobserved.length; i++) {
-    const source = unobserved[i];
-    if (!source.r)
-      unobserved[i].sa?.();
-  }
-  unobserved = [];
-}
 
 // src/core/core.ts
 GlobalQueue.S = recompute;
@@ -340,6 +351,14 @@ var pendingValueCheck = false;
 var pendingCheck = null;
 var context = null;
 var defaultContext = {};
+function notifySubs(node) {
+  for (let s = node.x; s !== null; s = s.A) {
+    const queue = s.j.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue;
+    if (queue.q > s.j.c)
+      queue.q = s.j.c;
+    insertIntoHeap(s.j, queue);
+  }
+}
 function recompute(el, create = false) {
   deleteFromHeap(el, el.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
   if (el.e !== NOT_PENDING || el.U || el.V)
@@ -347,16 +366,16 @@ function recompute(el, create = false) {
   else {
     markDisposal(el);
     globalQueue.h.push(el);
-    el.V = el.s;
-    el.U = el.o;
-    el.s = null;
-    el.o = null;
+    el.V = el.t;
+    el.U = el.r;
+    el.t = null;
+    el.r = null;
   }
   const oldcontext = context;
   context = el;
-  el.H = null;
+  el.F = null;
   el.b = 4 /* RecomputingDeps */;
-  el.W = clock;
+  el.J = clock;
   let value = el.e === NOT_PENDING ? el.g : el.e;
   let oldHeight = el.c;
   let prevStatusFlags = el.f;
@@ -365,7 +384,7 @@ function recompute(el, create = false) {
   clearStatusFlags(el);
   tracking = true;
   try {
-    value = el.ha(value);
+    value = el.H(value);
   } catch (e) {
     if (e instanceof NotReadyError) {
       if (e.cause !== el)
@@ -379,8 +398,8 @@ 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.F;
+  let toRemove = depsTail !== null ? depsTail.E : el.l;
   if (toRemove !== null) {
     do {
       toRemove = unlinkSubs(toRemove);
@@ -388,15 +407,15 @@ function recompute(el, create = false) {
     if (depsTail !== null) {
       depsTail.E = null;
     } else {
-      el.u = null;
+      el.l = null;
     }
   }
-  const valueChanged = !el.ea || !el.ea(el.e === NOT_PENDING ? el.g : el.e, value);
+  const valueChanged = !el.fa || !el.fa(el.e === NOT_PENDING ? el.g : el.e, value);
   const statusFlagsChanged = el.f !== prevStatusFlags || el.B !== prevError;
   el.ma?.(statusFlagsChanged, prevStatusFlags);
   if (valueChanged || statusFlagsChanged) {
     if (valueChanged) {
-      if (create || el.ia || el.I)
+      if (create || el.ja || el.K)
         el.g = value;
       else {
         if (el.e === NOT_PENDING)
@@ -404,26 +423,26 @@ function recompute(el, create = false) {
         el.e = value;
       }
       if (el.C)
-        el.C.da(value);
+        el.C.ea(value);
     }
-    for (let s = el.r; s !== null; s = s.y) {
+    for (let s = el.x; s !== null; s = s.A) {
       const queue = s.j.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue;
-      if (s.j.c < el.c && queue.n > s.j.c)
-        queue.n = s.j.c;
+      if (s.j.c < el.c && queue.q > s.j.c)
+        queue.q = s.j.c;
       insertIntoHeap(s.j, queue);
     }
   } else if (el.c != oldHeight) {
-    for (let s = el.r; s !== null; s = s.y) {
+    for (let s = el.x; 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.Q;
-      const dep = "_owner" in dep1 ? dep1.z : dep1;
-      if ("_fn" in dep) {
+    for (let d = el.l; d; d = d.E) {
+      const dep1 = d.R;
+      const dep = dep1.ia || dep1;
+      if (dep.H) {
         updateIfNecessary(dep);
       }
       if (el.b & 2 /* Dirty */) {
@@ -437,62 +456,75 @@ function updateIfNecessary(el) {
   el.b = 0 /* None */;
 }
 function unlinkSubs(link2) {
-  const dep = link2.Q;
+  const dep = link2.R;
   const nextDep = link2.E;
-  const nextSub = link2.y;
+  const nextSub = link2.A;
   const prevSub = link2.na;
   if (nextSub !== null) {
     nextSub.na = prevSub;
   } else {
-    dep.X = prevSub;
+    dep.W = prevSub;
   }
   if (prevSub !== null) {
-    prevSub.y = nextSub;
+    prevSub.A = nextSub;
   } else {
-    dep.r = nextSub;
+    dep.x = nextSub;
+    if (nextSub === null) {
+      dep.ta?.();
+      dep.H && unobserved(dep);
+    }
   }
   return nextDep;
 }
+function unobserved(el) {
+  deleteFromHeap(el, el.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
+  let dep = el.l;
+  while (dep !== null) {
+    dep = unlinkSubs(dep);
+  }
+  el.l = null;
+  runDisposal(el);
+}
 function link(dep, sub) {
-  const prevDep = sub.H;
-  if (prevDep !== null && prevDep.Q === dep) {
+  const prevDep = sub.F;
+  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.Q === dep) {
-      sub.H = nextDep;
+    nextDep = prevDep !== null ? prevDep.E : sub.l;
+    if (nextDep !== null && nextDep.R === dep) {
+      sub.F = nextDep;
       return;
     }
   }
-  const prevSub = dep.X;
+  const prevSub = dep.W;
   if (prevSub !== null && prevSub.j === sub && (!isRecomputing || isValidLink(prevSub, sub))) {
     return;
   }
-  const newLink = sub.H = dep.X = {
-    Q: dep,
+  const newLink = sub.F = dep.W = {
+    R: dep,
     j: sub,
     E: nextDep,
     na: prevSub,
-    y: null
+    A: null
   };
   if (prevDep !== null) {
     prevDep.E = newLink;
   } else {
-    sub.u = newLink;
+    sub.l = newLink;
   }
   if (prevSub !== null) {
-    prevSub.y = newLink;
+    prevSub.A = newLink;
   } else {
-    dep.r = newLink;
+    dep.x = newLink;
   }
 }
 function isValidLink(checkLink, sub) {
-  const depsTail = sub.H;
+  const depsTail = sub.F;
   if (depsTail !== null) {
-    let link2 = sub.u;
+    let link2 = sub.l;
     do {
       if (link2 === checkLink) {
         return true;
@@ -510,13 +542,13 @@ function setStatusFlags(signal2, flags, error = null) {
   signal2.B = 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.o;
+  let child = el.r;
   while (child) {
     child.b |= 32 /* Zombie */;
     const inHeap = child.b & 8 /* InHeap */;
@@ -525,26 +557,35 @@ function markDisposal(el) {
       insertIntoHeap(child, zombieQueue);
     }
     markDisposal(child);
-    child = child.K;
+    child = child.M;
   }
 }
+function dispose(node) {
+  let toRemove = node.l || null;
+  do {
+    toRemove = unlinkSubs(toRemove);
+  } while (toRemove !== null);
+  node.l = null;
+  node.F = null;
+  disposeChildren(node, true);
+}
 function disposeChildren(node, self = false, zombie) {
   if (node.b & 64 /* Disposed */)
     return;
   if (self)
     node.b = 64 /* Disposed */;
-  let child = zombie ? node.U : node.o;
+  let child = zombie ? node.U : node.r;
   while (child) {
-    const nextChild = child.K;
-    if (child.u) {
+    const nextChild = child.M;
+    if (child.l) {
       const n = child;
       deleteFromHeap(n, n.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
-      let toRemove = n.u;
+      let toRemove = n.l;
       do {
         toRemove = unlinkSubs(toRemove);
       } while (toRemove !== null);
-      n.u = null;
-      n.H = null;
+      n.l = null;
+      n.F = null;
     }
     disposeChildren(child, true);
     child = nextChild;
@@ -552,13 +593,13 @@ function disposeChildren(node, self = false, zombie) {
   if (zombie) {
     node.U = null;
   } else {
-    node.o = null;
-    node.K = null;
+    node.r = null;
+    node.M = null;
   }
   runDisposal(node, zombie);
 }
 function runDisposal(node, zombie) {
-  let disposal = zombie ? node.V : node.s;
+  let disposal = zombie ? node.V : node.t;
   if (!disposal)
     return;
   if (Array.isArray(disposal)) {
@@ -569,15 +610,15 @@ function runDisposal(node, zombie) {
   } else {
     disposal.call(disposal);
   }
-  zombie ? node.V = null : node.s = null;
+  zombie ? node.V = null : node.t = null;
 }
 function withOptions(obj, options) {
   obj.id = options?.id ?? (context?.id != null ? getNextChildId(context) : void 0);
-  obj.ea = options?.equals != null ? options.equals : isEqual;
-  obj.ya = !!options?.pureWrite;
-  obj.sa = options?.unobserved;
-  if (options?.ja)
-    Object.assign(obj, options.ja);
+  obj.fa = options?.equals != null ? options.equals : isEqual;
+  obj.za = !!options?.pureWrite;
+  obj.ta = options?.unobserved;
+  if (options?.ka)
+    Object.assign(obj, options.ka);
   return obj;
 }
 function getNextChildId(owner) {
@@ -592,43 +633,43 @@ function formatId(prefix, id) {
 function computed(fn, initialValue, options) {
   const self = withOptions(
     {
-      s: null,
+      t: null,
       i: globalQueue,
       D: defaultContext,
       oa: 0,
-      ha: fn,
+      H: fn,
       g: initialValue,
       c: 0,
-      ba: null,
-      P: void 0,
+      ca: null,
+      Q: void 0,
+      z: null,
+      l: null,
+      F: null,
       x: null,
-      u: null,
-      H: null,
+      W: null,
+      w: context,
+      M: null,
       r: null,
-      X: null,
-      q: context,
-      K: null,
-      o: null,
       b: 0 /* None */,
       f: 4 /* Uninitialized */,
-      W: clock,
+      J: clock,
       e: NOT_PENDING,
       V: null,
       U: null
     },
     options
   );
-  self.x = self;
-  const parent = context?._ ? context.$ : context;
+  self.z = self;
+  const parent = context?.$ ? context.aa : context;
   if (context) {
     context.i && (self.i = context.i);
     context.D && (self.D = context.D);
-    const lastChild = context.o;
+    const lastChild = context.r;
     if (lastChild === null) {
-      context.o = self;
+      context.r = self;
     } else {
-      self.K = lastChild;
-      context.o = self;
+      self.M = lastChild;
+      context.r = self;
     }
   }
   if (parent)
@@ -660,6 +701,9 @@ function asyncComputed(asyncFn, initialValue, options) {
           return;
         globalQueue.initTransition(self);
         setError(self, e);
+        self.J = clock;
+        notifySubs(self);
+        schedule();
         flush();
       });
     } else {
@@ -677,6 +721,9 @@ function asyncComputed(asyncFn, initialValue, options) {
             return;
           globalQueue.initTransition(self);
           setError(self, error);
+          self.J = clock;
+          notifySubs(self);
+          schedule();
           flush();
         }
       })();
@@ -685,7 +732,7 @@ function asyncComputed(asyncFn, initialValue, options) {
     throw new NotReadyError(context);
   };
   const self = computed(fn, initialValue, options);
-  self.ta = () => {
+  self.ua = () => {
     refreshing = true;
     recompute(self);
     flush();
@@ -694,15 +741,15 @@ function asyncComputed(asyncFn, initialValue, options) {
 }
 function signal(v, options, firewall = null) {
   if (firewall !== null) {
-    return firewall.ba = withOptions(
+    return firewall.ca = withOptions(
       {
         g: v,
-        r: null,
-        X: null,
-        z: firewall,
-        ra: firewall.ba,
+        x: null,
+        W: null,
+        ia: firewall,
+        sa: firewall.ca,
         f: 0 /* None */,
-        W: clock,
+        J: clock,
         e: NOT_PENDING
       },
       options
@@ -711,10 +758,10 @@ function signal(v, options, firewall = null) {
     return withOptions(
       {
         g: v,
-        r: null,
-        X: null,
+        x: null,
+        W: null,
         f: 0 /* None */,
-        W: clock,
+        J: clock,
         e: NOT_PENDING
       },
       options
@@ -736,34 +783,34 @@ function untrack(fn) {
 }
 function read(el) {
   let c = context;
-  if (c?._)
-    c = c.$;
+  if (c?.$)
+    c = c.aa;
   if (c && tracking) {
     link(el, c);
-    const owner = "_owner" in el ? el.z : el;
-    if ("_fn" in owner) {
+    const owner = el.ia || el;
+    if (owner.H) {
       const isZombie = el.b & 32 /* Zombie */;
-      if (owner.c >= (isZombie ? zombieQueue.n : dirtyQueue.n)) {
+      if (owner.c >= (isZombie ? zombieQueue.q : dirtyQueue.q)) {
         markNode(c);
         markHeap(isZombie ? zombieQueue : dirtyQueue);
         updateIfNecessary(owner);
       }
       const height = owner.c;
-      if (height >= c.c && el.q !== c) {
+      if (height >= c.c && el.w !== c) {
         c.c = height + 1;
       }
     }
   }
   if (pendingCheck) {
     const pendingResult = (el.f & 1 /* Pending */) !== 0 || !!el.T || false;
-    if (!el.G) {
-      el.G = signal(pendingResult);
-      el.G.ia = true;
-      el.G.da = (v) => setSignal(el.G, v);
+    if (!el.I) {
+      el.I = signal(pendingResult);
+      el.I.ja = true;
+      el.I.ea = (v) => setSignal(el.I, v);
     }
     const prev = pendingCheck;
     pendingCheck = null;
-    read(el.G);
+    read(el.I);
     pendingCheck = prev;
     prev.g = pendingResult || prev.g;
   }
@@ -772,8 +819,8 @@ function read(el) {
       el.C = signal(
         el.e === NOT_PENDING ? el.g : el.e
       );
-      el.C.ia = true;
-      el.C.da = (v) => queueMicrotask(() => queueMicrotask(() => setSignal(el.C, v)));
+      el.C.ja = true;
+      el.C.ea = (v) => queueMicrotask(() => queueMicrotask(() => setSignal(el.C, v)));
     }
     pendingValueCheck = false;
     try {
@@ -794,7 +841,7 @@ function read(el) {
     }
   }
   if (el.f & 2 /* Error */) {
-    if (el.W < clock) {
+    if (el.J < clock) {
       recompute(el, true);
       return read(el);
     } else {
@@ -809,11 +856,11 @@ function setSignal(el, v) {
       el.e === NOT_PENDING ? el.g : el.e
     );
   }
-  const valueChanged = !el.ea || !el.ea(el.e === NOT_PENDING ? el.g : el.e, v);
+  const valueChanged = !el.fa || !el.fa(el.e === NOT_PENDING ? el.g : el.e, v);
   if (!valueChanged && !el.f)
     return v;
   if (valueChanged) {
-    if (el.ia)
+    if (el.ja)
       el.g = v;
     else {
       if (el.e === NOT_PENDING)
@@ -821,16 +868,11 @@ function setSignal(el, v) {
       el.e = v;
     }
     if (el.C)
-      el.C.da(v);
+      el.C.ea(v);
   }
   clearStatusFlags(el);
-  el.W = clock;
-  for (let s = el.r; s !== null; s = s.y) {
-    const queue = s.j.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue;
-    if (queue.n > s.j.c)
-      queue.n = s.j.c;
-    insertIntoHeap(s.j, queue);
-  }
+  el.J = clock;
+  notifySubs(el);
   schedule();
   return v;
 }
@@ -844,41 +886,41 @@ function onCleanup(fn) {
   if (!context)
     return fn;
   const node = context;
-  if (!node.s) {
-    node.s = fn;
-  } else if (Array.isArray(node.s)) {
-    node.s.push(fn);
+  if (!node.t) {
+    node.t = fn;
+  } else if (Array.isArray(node.t)) {
+    node.t.push(fn);
   } else {
-    node.s = [node.s, fn];
+    node.t = [node.t, fn];
   }
   return fn;
 }
 function createOwner(options) {
   const parent = context;
   const owner = {
-    _: true,
-    $: parent?._ ? parent.$ : parent,
-    o: null,
-    K: null,
-    s: null,
+    $: true,
+    aa: parent?.$ ? parent.aa : parent,
+    r: null,
+    M: null,
+    t: null,
     id: options?.id ?? (parent?.id != null ? getNextChildId(parent) : void 0),
     i: parent?.i ?? globalQueue,
     D: parent?.D || defaultContext,
     oa: 0,
     V: null,
     U: null,
-    q: parent,
+    w: parent,
     dispose(self = true) {
       disposeChildren(owner, self);
     }
   };
   if (parent) {
-    const lastChild = parent.o;
+    const lastChild = parent.r;
     if (lastChild === null) {
-      parent.o = owner;
+      parent.r = owner;
     } else {
-      owner.K = lastChild;
-      parent.o = owner;
+      owner.M = lastChild;
+      parent.r = owner;
     }
   }
   return owner;
@@ -966,29 +1008,29 @@ function effect(compute, effect2, error, initialValue, options) {
   let initialized = false;
   const node = computed(compute, initialValue, {
     ...options,
-    ja: {
-      fa: true,
+    ka: {
+      ga: true,
       pa: initialValue,
-      ua: effect2,
+      va: effect2,
       qa: 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 */,
       ma(statusFlagsChanged, prevStatusFlags) {
         if (initialized) {
           const errorChanged = this.f && this.f === prevStatusFlags && statusFlagsChanged;
-          this.fa = !(this.f & 2 /* Error */) && !(this.f & 1 /* Pending */ & ~prevStatusFlags) && !errorChanged;
-          if (this.fa)
-            this.i.enqueue(this.I, runEffect.bind(this));
+          this.ga = !(this.f & 2 /* Error */) && !(this.f & 1 /* Pending */ & ~prevStatusFlags) && !errorChanged;
+          if (this.ga)
+            this.i.enqueue(this.K, runEffect.bind(this));
         }
         if (this.f & 2 /* Error */) {
           let error2 = this.B;
           this.i.notify(this, 1 /* Pending */, 0);
-          if (this.I === 2 /* User */) {
+          if (this.K === 2 /* User */) {
             try {
               return this.qa ? this.qa(error2, () => {
-                this.L?.();
-                this.L = void 0;
+                this.N?.();
+                this.N = void 0;
               }) : console.error(error2);
             } catch (e) {
               error2 = e;
@@ -996,7 +1038,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 */,
@@ -1007,25 +1049,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.H = (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.fa || this.b & 64 /* Disposed */)
+  if (!this.ga || this.b & 64 /* Disposed */)
     return;
-  this.L?.();
-  this.L = void 0;
+  this.N?.();
+  this.N = void 0;
   try {
-    this.L = this.ua(this.g, this.pa);
+    this.N = this.va(this.g, this.pa);
   } catch (error) {
     if (!this.i.notify(this, 2 /* Error */, 2 /* Error */))
       throw error;
   } finally {
     this.pa = this.g;
-    this.fa = false;
+    this.ga = false;
   }
 }
 
@@ -1056,7 +1097,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.ta;
+  ret.refresh = node.ua;
   return ret;
 }
 function createEffect(compute, effectFn, value, options) {
@@ -1076,11 +1117,29 @@ function createRenderEffect(compute, effectFn, value, options) {
 }
 function createTrackedEffect(compute, options) {
 }
-function createReaction(effect2, options) {
+function createReaction(effectFn, options) {
+  let cleanup = void 0;
+  onCleanup(() => cleanup?.());
+  return (tracking2) => {
+    effect(
+      () => (tracking2(), getOwner()),
+      (node) => {
+        cleanup?.();
+        cleanup = (effectFn.effect || effectFn)?.();
+        dispose(node);
+      },
+      effectFn.error,
+      void 0,
+      {
+        defer: true,
+        ...options
+      }
+    );
+  };
 }
 function resolve(fn) {
   return new Promise((res, rej) => {
-    createRoot((dispose) => {
+    createRoot((dispose2) => {
       computed(() => {
         try {
           res(fn());
@@ -1089,7 +1148,7 @@ function resolve(fn) {
             throw err;
           rej(err);
         }
-        dispose();
+        dispose2();
       });
     });
   });
@@ -1098,6 +1157,14 @@ function createOptimistic(first, second, third) {
   return {};
 }
 function onSettled(callback) {
+  let cleanup;
+  const o = getOwner();
+  if (o)
+    onCleanup(() => cleanup?.());
+  globalQueue.enqueue(2 /* User */, () => {
+    cleanup = callback();
+    !o && cleanup?.();
+  });
 }
 
 // src/store/reconcile.ts
@@ -1233,23 +1300,17 @@ function reconcile(value, key, all = false) {
 function createProjectionInternal(fn, initialValue = {}, options) {
   let node;
   const wrappedMap = /* @__PURE__ */ new WeakMap();
-  const traps = {
-    ...storeTraps,
-    get(target, property, receiver) {
-      const o = getOwner();
-      const n = node;
-      (!o || o !== n) && n && read(n);
-      return storeTraps.get(target, property, receiver);
-    }
-  };
   const wrapProjection = (source) => {
     if (wrappedMap.has(source))
       return wrappedMap.get(source);
     if (source[$TARGET]?.[STORE_WRAP] === wrapProjection)
       return source;
-    const wrapped = createStoreProxy(source, traps, {
+    const wrapped = createStoreProxy(source, storeTraps, {
       [STORE_WRAP]: wrapProjection,
-      [STORE_LOOKUP]: wrappedMap
+      [STORE_LOOKUP]: wrappedMap,
+      [STORE_FIREWALL]() {
+        return node;
+      }
     });
     wrappedMap.set(source, wrapped);
     return wrapped;
@@ -1282,6 +1343,7 @@ var STORE_NODE = "n";
 var STORE_HAS = "h";
 var STORE_WRAP = "w";
 var STORE_LOOKUP = "l";
+var STORE_FIREWALL = "f";
 function createStoreProxy(value, traps = storeTraps, extend) {
   let newTarget;
   if (Array.isArray(value)) {
@@ -1310,18 +1372,24 @@ function getNodes(target, type) {
     target[type] = nodes = /* @__PURE__ */ Object.create(null);
   return nodes;
 }
-function getNode(nodes, property, value, equals = isEqual) {
+function getNode(nodes, property, value, firewall, equals = isEqual) {
   if (nodes[property])
     return nodes[property];
-  return nodes[property] = signal(value, {
-    equals,
-    unobserved() {
-      delete nodes[property];
-    }
-  });
+  return nodes[property] = signal(
+    value,
+    {
+      equals,
+      unobserved() {
+        delete nodes[property];
+      }
+    },
+    firewall
+  );
 }
 function trackSelf(target, symbol = $TRACK) {
-  getObserver() && read(getNode(getNodes(target, STORE_NODE), symbol, void 0, false));
+  getObserver() && read(
+    getNode(getNodes(target, STORE_NODE), symbol, void 0, target[STORE_FIREWALL]?.(), false)
+  );
 }
 function getKeys(source, override, enumerable = true) {
   const baseKeys = untrack(() => enumerable ? Object.keys(source) : Reflect.ownKeys(source));
@@ -1384,7 +1452,14 @@ var storeTraps = {
         let proto;
         return !Array.isArray(target[STORE_VALUE]) && (proto = Object.getPrototypeOf(target[STORE_VALUE])) && proto !== Object.prototype ? value.bind(storeValue) : value;
       } else if (getObserver()) {
-        return read(getNode(nodes, property, isWrappable(value) ? wrap(value, target) : value));
+        return read(
+          getNode(
+            nodes,
+            property,
+            isWrappable(value) ? wrap(value, target) : value,
+            target[STORE_FIREWALL]?.()
+          )
+        );
       }
     }
     return isWrappable(value) ? wrap(value, target) : value;
@@ -1393,7 +1468,7 @@ var storeTraps = {
     if (property === $PROXY || property === $TRACK || property === "__proto__")
       return true;
     const has = target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE] ? target[STORE_OVERRIDE][property] !== $DELETED : property in target[STORE_VALUE];
-    getObserver() && read(getNode(getNodes(target, STORE_HAS), property, has));
+    getObserver() && read(getNode(getNodes(target, STORE_HAS), property, has, target[STORE_FIREWALL]?.()));
     return has;
   },
   set(target, property, rawValue) {
@@ -1768,52 +1843,52 @@ function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
   return createMemo(
     updateKeyedMap.bind({
-      z: createOwner(),
-      k: 0,
-      va: list,
-      F: [],
-      M: map,
+      X: createOwner(),
+      n: 0,
+      wa: list,
+      G: [],
+      O: map,
       d: [],
       a: [],
-      N: keyFn,
-      l: keyFn || options?.keyed === false ? [] : void 0,
-      m: map.length > 1 ? [] : void 0,
+      P: keyFn,
+      o: keyFn || options?.keyed === false ? [] : void 0,
+      p: map.length > 1 ? [] : void 0,
       Y: options?.fallback
     })
   );
 }
 var pureOptions = { pureWrite: true };
 function updateKeyedMap() {
-  const newItems = this.va() || [], newLen = newItems.length;
+  const newItems = this.wa() || [], newLen = newItems.length;
   newItems[$TRACK];
-  runWithOwner(this.z, () => {
-    let i, j, mapper = this.l ? () => {
-      this.l[j] = signal(newItems[j], pureOptions);
-      this.m && (this.m[j] = signal(j, pureOptions));
-      return this.M(
-        read.bind(null, this.l[j]),
-        this.m ? read.bind(null, this.m[j]) : void 0
+  runWithOwner(this.X, () => {
+    let i, j, mapper = this.o ? () => {
+      this.o[j] = signal(newItems[j], pureOptions);
+      this.p && (this.p[j] = signal(j, pureOptions));
+      return this.O(
+        read.bind(null, this.o[j]),
+        this.p ? read.bind(null, this.p[j]) : void 0
       );
-    } : this.m ? () => {
+    } : this.p ? () => {
       const item = newItems[j];
-      this.m[j] = signal(j, pureOptions);
-      return this.M(
+      this.p[j] = signal(j, pureOptions);
+      return this.O(
         () => item,
-        read.bind(null, this.m[j])
+        read.bind(null, this.p[j])
       );
     } : () => {
       const item = newItems[j];
-      return this.M(() => item);
+      return this.O(() => item);
     };
     if (newLen === 0) {
-      if (this.k !== 0) {
-        this.z.dispose(false);
+      if (this.n !== 0) {
+        this.X.dispose(false);
         this.a = [];
-        this.F = [];
+        this.G = [];
         this.d = [];
-        this.k = 0;
-        this.l && (this.l = []);
-        this.m && (this.m = []);
+        this.n = 0;
+        this.o && (this.o = []);
+        this.p && (this.p = []);
       }
       if (this.Y && !this.d[0]) {
         this.d[0] = runWithOwner(
@@ -1821,45 +1896,45 @@ function updateKeyedMap() {
           this.Y
         );
       }
-    } else if (this.k === 0) {
+    } else if (this.n === 0) {
       if (this.a[0])
         this.a[0].dispose();
       this.d = new Array(newLen);
       for (j = 0; j < newLen; j++) {
-        this.F[j] = newItems[j];
+        this.G[j] = newItems[j];
         this.d[j] = runWithOwner(this.a[j] = createOwner(), mapper);
       }
-      this.k = newLen;
+      this.n = newLen;
     } else {
-      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.l ? new Array(newLen) : void 0, tempIndexes = this.m ? new Array(newLen) : void 0;
-      for (start = 0, end = Math.min(this.k, newLen); start < end && (this.F[start] === newItems[start] || this.l && compare(this.N, this.F[start], newItems[start])); start++) {
-        if (this.l)
-          setSignal(this.l[start], newItems[start]);
+      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.o ? new Array(newLen) : void 0, tempIndexes = this.p ? new Array(newLen) : void 0;
+      for (start = 0, end = Math.min(this.n, newLen); start < end && (this.G[start] === newItems[start] || this.o && compare(this.P, this.G[start], newItems[start])); start++) {
+        if (this.o)
+          setSignal(this.o[start], newItems[start]);
       }
-      for (end = this.k - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.F[end] === newItems[newEnd] || this.l && compare(this.N, this.F[end], newItems[newEnd])); end--, newEnd--) {
+      for (end = this.n - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.G[end] === newItems[newEnd] || this.o && compare(this.P, this.G[end], newItems[newEnd])); end--, newEnd--) {
         temp[newEnd] = this.d[end];
         tempNodes[newEnd] = this.a[end];
-        tempRows && (tempRows[newEnd] = this.l[end]);
-        tempIndexes && (tempIndexes[newEnd] = this.m[end]);
+        tempRows && (tempRows[newEnd] = this.o[end]);
+        tempIndexes && (tempIndexes[newEnd] = this.p[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.d[i];
           tempNodes[j] = this.a[i];
-          tempRows && (tempRows[j] = this.l[i]);
-          tempIndexes && (tempIndexes[j] = this.m[i]);
+          tempRows && (tempRows[j] = this.o[i]);
+          tempIndexes && (tempIndexes[j] = this.p[i]);
           j = newIndicesNext[j];
           newIndices.set(key, j);
         } else
@@ -1870,46 +1945,46 @@ function updateKeyedMap() {
           this.d[j] = temp[j];
           this.a[j] = tempNodes[j];
           if (tempRows) {
-            this.l[j] = tempRows[j];
-            setSignal(this.l[j], newItems[j]);
+            this.o[j] = tempRows[j];
+            setSignal(this.o[j], newItems[j]);
           }
           if (tempIndexes) {
-            this.m[j] = tempIndexes[j];
-            setSignal(this.m[j], j);
+            this.p[j] = tempIndexes[j];
+            setSignal(this.p[j], j);
           }
         } else {
           this.d[j] = runWithOwner(this.a[j] = createOwner(), mapper);
         }
       }
-      this.d = this.d.slice(0, this.k = newLen);
-      this.F = newItems.slice(0);
+      this.d = this.d.slice(0, this.n = newLen);
+      this.G = newItems.slice(0);
     }
   });
   return this.d;
 }
 function repeat(count, map, options) {
   return updateRepeat.bind({
-    z: createOwner(),
-    k: 0,
-    w: 0,
-    wa: count,
-    M: map,
+    X: createOwner(),
+    n: 0,
+    y: 0,
+    xa: count,
+    O: map,
     a: [],
     d: [],
-    xa: options?.from,
+    ya: options?.from,
     Y: options?.fallback
   });
 }
 function updateRepeat() {
-  const newLen = this.wa();
-  const from = this.xa?.() || 0;
-  runWithOwner(this.z, () => {
+  const newLen = this.xa();
+  const from = this.ya?.() || 0;
+  runWithOwner(this.X, () => {
     if (newLen === 0) {
-      if (this.k !== 0) {
-        this.z.dispose(false);
+      if (this.n !== 0) {
+        this.X.dispose(false);
         this.a = [];
         this.d = [];
-        this.k = 0;
+        this.n = 0;
       }
       if (this.Y && !this.d[0]) {
         this.d[0] = runWithOwner(
@@ -1920,20 +1995,20 @@ function updateRepeat() {
       return;
     }
     const to = from + newLen;
-    const prevTo = this.w + this.k;
-    if (this.k === 0 && this.a[0])
+    const prevTo = this.y + this.n;
+    if (this.n === 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.k)
+      this.a[i - this.y].dispose();
+    if (this.y < from) {
+      let i = this.y;
+      while (i < from && i < this.n)
         this.a[i++].dispose();
-      this.a.splice(0, from - this.w);
-      this.d.splice(0, from - this.w);
-    } else if (this.w > from) {
-      let i = prevTo - this.w - 1;
-      let difference = this.w - from;
+      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];
@@ -1943,19 +2018,19 @@ function updateRepeat() {
       for (let i2 = 0; i2 < difference; i2++) {
         this.d[i2] = runWithOwner(
           this.a[i2] = createOwner(),
-          () => this.M(i2 + from)
+          () => this.O(i2 + from)
         );
       }
     }
     for (let i = prevTo; i < to; i++) {
       this.d[i - from] = runWithOwner(
         this.a[i - from] = createOwner(),
-        () => this.M(i)
+        () => this.O(i)
       );
     }
     this.d = this.d.slice(0, newLen);
-    this.w = from;
-    this.k = newLen;
+    this.y = from;
+    this.n = newLen;
   });
   return this.d;
 }
@@ -1966,7 +2041,7 @@ function compare(key, a, b) {
 // src/boundaries.ts
 function boundaryComputed(fn, propagationMask) {
   const node = computed(fn, void 0, {
-    ja: {
+    ka: {
       ma() {
         let flags = this.f;
         this.f &= ~this.Z;
@@ -1991,20 +2066,20 @@ function createBoundChildren(owner, fn, queue, mask) {
   });
 }
 var ConditionalQueue = class extends Queue {
-  t;
-  ga = /* @__PURE__ */ new Set();
+  u;
+  ha = /* @__PURE__ */ new Set();
   h = /* @__PURE__ */ new Set();
   constructor(disabled) {
     super();
-    this.t = disabled;
+    this.u = disabled;
   }
   run(type) {
-    if (!type || read(this.t))
+    if (!type || read(this.u))
       return;
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (read(this.t)) {
+    if (read(this.u)) {
       if (type & 1 /* Pending */) {
         if (flags & 1 /* Pending */) {
           this.h.add(node);
@@ -2014,9 +2089,9 @@ var ConditionalQueue = class extends Queue {
       }
       if (type & 2 /* Error */) {
         if (flags & 2 /* Error */) {
-          this.ga.add(node);
+          this.ha.add(node);
           type &= ~2 /* Error */;
-        } else if (this.ga.delete(node))
+        } else if (this.ha.delete(node))
           type &= ~2 /* Error */;
       }
     }
@@ -2024,38 +2099,32 @@ var ConditionalQueue = class extends Queue {
   }
 };
 var CollectionQueue = class extends Queue {
-  O;
+  _;
   a = /* @__PURE__ */ new Set();
-  t = signal(false, { pureWrite: true });
-  ka = false;
+  u = signal(false, { pureWrite: true });
+  ra = false;
   constructor(type) {
     super();
-    this.O = type;
+    this._ = type;
   }
   run(type) {
-    if (!type || read(this.t))
+    if (!type || read(this.u))
       return;
     return super.run(type);
   }
-  enqueue(type, fn) {
-    if (this.O & 1 /* Pending */ && this.ka) {
-      return this.q?.enqueue(type, fn);
-    }
-    return super.enqueue(type, fn);
-  }
   notify(node, type, flags) {
-    if (!(type & this.O) || this.O & 1 /* Pending */ && this.ka)
+    if (!(type & this._) || this._ & 1 /* Pending */ && this.ra)
       return super.notify(node, type, flags);
-    if (flags & this.O) {
+    if (flags & this._) {
       this.a.add(node);
       if (this.a.size === 1)
-        setSignal(this.t, true);
+        setSignal(this.u, true);
     } else if (this.a.size > 0) {
       this.a.delete(node);
       if (this.a.size === 0)
-        setSignal(this.t, false);
+        setSignal(this.u, false);
     }
-    type &= ~this.O;
+    type &= ~this._;
     return type ? super.notify(node, type, flags) : true;
   }
 };
@@ -2064,28 +2133,28 @@ function createBoundary(fn, condition) {
   const queue = new ConditionalQueue(computed(() => condition() === "hidden" /* HIDDEN */));
   const tree = createBoundChildren(owner, fn, queue, 0);
   computed(() => {
-    const disabled = read(queue.t);
+    const disabled = read(queue.u);
     tree.Z = disabled ? 2 /* Error */ | 1 /* Pending */ : 0;
     if (!disabled) {
       queue.h.forEach(
         (node) => queue.notify(node, 1 /* Pending */, 1 /* Pending */)
       );
-      queue.ga.forEach((node) => queue.notify(node, 2 /* Error */, 2 /* Error */));
+      queue.ha.forEach((node) => queue.notify(node, 2 /* Error */, 2 /* Error */));
       queue.h.clear();
-      queue.ga.clear();
+      queue.ha.clear();
     }
   });
-  return () => read(queue.t) ? 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.t)) {
+    if (!read(queue.u)) {
       const resolved = read(tree);
-      if (!untrack(() => read(queue.t)))
-        queue.ka = true;
+      if (!untrack(() => read(queue.u)))
+        queue.ra = true;
       return resolved;
     }
     return fallback(queue);