@solidjs/signals 0.4.0 → 0.4.1

package/dist/prod.js

@@ -37,20 +37,20 @@ function schedule() {
   if (scheduled)
     return;
   scheduled = true;
-  if (!globalQueue.J)
+  if (!globalQueue.K)
     queueMicrotask(flush);
 }
 var pureQueue = [];
 var Queue = class {
   o = null;
-  J = false;
-  K = [[], []];
-  E = [];
+  K = false;
+  L = [[], []];
+  F = [];
   created = clock;
   enqueue(type, fn) {
     pureQueue.push(fn);
     if (type)
-      this.K[type - 1].push(fn);
+      this.L[type - 1].push(fn);
     schedule();
   }
   run(type) {
@@ -58,19 +58,19 @@ var Queue = class {
       pureQueue.length && runQueue(pureQueue, type);
       pureQueue = [];
       return;
-    } else if (this.K[type - 1].length) {
-      const effects = this.K[type - 1];
-      this.K[type - 1] = [];
+    } else if (this.L[type - 1].length) {
+      const effects = this.L[type - 1];
+      this.L[type - 1] = [];
       runQueue(effects, type);
     }
-    for (let i = 0; i < this.E.length; i++) {
-      this.E[i].run(type);
+    for (let i = 0; i < this.F.length; i++) {
+      this.F[i].run(type);
     }
   }
   flush() {
-    if (this.J)
+    if (this.K)
       return;
-    this.J = true;
+    this.K = true;
     try {
       this.run(EFFECT_PURE);
       incrementClock();
@@ -78,17 +78,17 @@ var Queue = class {
       this.run(EFFECT_RENDER);
       this.run(EFFECT_USER);
     } finally {
-      this.J = false;
+      this.K = false;
     }
   }
   addChild(child) {
-    this.E.push(child);
+    this.F.push(child);
     child.o = this;
   }
   removeChild(child) {
-    const index = this.E.indexOf(child);
+    const index = this.F.indexOf(child);
     if (index >= 0)
-      this.E.splice(index, 1);
+      this.F.splice(index, 1);
   }
   notify(...args) {
     if (this.o)
@@ -158,20 +158,20 @@ var Owner = class {
     let head = self ? this.t || this.o : this, current = this.m, next = null;
     while (current && current.o === this) {
       current.dispose(true);
-      current.y();
+      current.z();
       next = current.m;
       current.m = null;
       current = next;
     }
     this.W = 0;
     if (self)
-      this.y();
+      this.z();
     if (current)
       current.t = !self ? this : this.t;
     if (head)
       head.m = current;
   }
-  y() {
+  z() {
     if (this.t)
       this.t.m = null;
     this.o = null;
@@ -272,45 +272,45 @@ var Computation = class extends Owner {
   c = null;
   d = null;
   g;
-  F;
-  z;
+  G;
+  A;
   // Used in __DEV__ mode, hopefully removed in production
   ca;
   // Using false is an optimization as an alternative to _equals: () => false
   // which could enable more efficient DIRTY notification
-  R = isEqual;
+  S = isEqual;
   X;
   _ = false;
   /** Whether the computation is an error or has ancestors that are unresolved */
   f = 0;
   /** Which flags raised by sources are handled, vs. being passed through. */
-  S = DEFAULT_FLAGS;
-  A = -1;
-  w = false;
+  T = DEFAULT_FLAGS;
+  B = -1;
+  x = false;
   constructor(initialValue, compute2, options) {
     super(options?.id, compute2 === null);
-    this.z = compute2;
+    this.A = compute2;
     this.a = compute2 ? STATE_DIRTY : STATE_CLEAN;
     this.f = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
     this.g = initialValue;
     if (options?.equals !== void 0)
-      this.R = options.equals;
+      this.S = options.equals;
     if (options?.pureWrite)
       this._ = true;
     if (options?.unobserved)
       this.X = options?.unobserved;
   }
   Y() {
-    if (this.z) {
-      if (this.f & ERROR_BIT && this.A <= getClock())
+    if (this.A) {
+      if (this.f & ERROR_BIT && this.B <= getClock())
         update(this);
       else
-        this.x();
+        this.y();
     }
     track(this);
     newFlags |= this.f & ~currentMask;
     if (this.f & ERROR_BIT) {
-      throw this.F;
+      throw this.G;
     } else {
       return this.g;
     }
@@ -330,10 +330,10 @@ var Computation = class extends Owner {
    * before continuing
    */
   wait() {
-    if (this.z && this.f & ERROR_BIT && this.A <= getClock()) {
+    if (this.A && this.f & ERROR_BIT && this.B <= getClock()) {
       update(this);
     } else {
-      this.x();
+      this.y();
     }
     track(this);
     if ((notStale || this.f & UNINITIALIZED_BIT) && this.f & LOADING_BIT) {
@@ -348,14 +348,14 @@ var Computation = class extends Owner {
   write(value, flags = 0, raw = false) {
     const newValue = !raw && typeof value === "function" ? value(this.g) : value;
     const valueChanged = newValue !== UNCHANGED && (!!(this.f & UNINITIALIZED_BIT) || // this._stateFlags & LOADING_BIT & ~flags ||
-    this.R === false || !this.R(this.g, newValue));
+    this.S === false || !this.S(this.g, newValue));
     if (valueChanged) {
       this.g = newValue;
-      this.F = void 0;
+      this.G = void 0;
     }
     const changedFlagsMask = this.f ^ flags, changedFlags = changedFlagsMask & flags;
     this.f = flags;
-    this.A = getClock() + 1;
+    this.B = getClock() + 1;
     if (this.d) {
       for (let i = 0; i < this.d.length; i++) {
         if (valueChanged) {
@@ -371,9 +371,9 @@ var Computation = class extends Owner {
    * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
    */
   r(state, skipQueue) {
-    if (this.a >= state && !this.w)
+    if (this.a >= state && !this.x)
       return;
-    this.w = !!skipQueue;
+    this.x = !!skipQueue;
     this.a = state;
     if (this.d) {
       for (let i = 0; i < this.d.length; i++) {
@@ -390,7 +390,7 @@ var Computation = class extends Owner {
   Z(mask, newFlags2) {
     if (this.a >= STATE_DIRTY)
       return;
-    if (mask & this.S) {
+    if (mask & this.T) {
       this.r(STATE_DIRTY);
       return;
     }
@@ -409,8 +409,8 @@ var Computation = class extends Owner {
       }
     }
   }
-  L(error) {
-    this.F = error;
+  M(error) {
+    this.G = error;
     this.write(UNCHANGED, this.f & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
   }
   /**
@@ -420,8 +420,8 @@ var Computation = class extends Owner {
    *
    * This function will ensure that the value and states we read from the computation are up to date
    */
-  x() {
-    if (!this.z) {
+  y() {
+    if (!this.A) {
       return;
     }
     if (this.a === STATE_DISPOSED) {
@@ -433,7 +433,7 @@ var Computation = class extends Owner {
     let observerFlags = 0;
     if (this.a === STATE_CHECK) {
       for (let i = 0; i < this.c.length; i++) {
-        this.c[i].x();
+        this.c[i].y();
         observerFlags |= this.c[i].f;
         if (this.a === STATE_DIRTY) {
           break;
@@ -450,12 +450,12 @@ var Computation = class extends Owner {
   /**
    * Remove ourselves from the owner graph and the computation graph
    */
-  y() {
+  z() {
     if (this.a === STATE_DISPOSED)
       return;
     if (this.c)
       removeSourceObservers(this, 0);
-    super.y();
+    super.z();
   }
 };
 function track(computation) {
@@ -468,7 +468,7 @@ function track(computation) {
       newSources.push(computation);
     }
     if (updateCheck) {
-      updateCheck.g = computation.A > currentObserver.A;
+      updateCheck.g = computation.B > currentObserver.B;
     }
   }
 }
@@ -480,13 +480,13 @@ function update(node) {
   try {
     node.dispose(false);
     node.emptyDisposal();
-    const result = compute(node, node.z, node);
+    const result = compute(node, node.A, node);
     node.write(result, newFlags, true);
   } catch (error) {
     if (error instanceof NotReadyError) {
       node.write(UNCHANGED, newFlags | LOADING_BIT | node.f & UNINITIALIZED_BIT);
     } else {
-      node.L(error);
+      node.M(error);
     }
   } finally {
     if (newSources) {
@@ -516,7 +516,7 @@ function update(node) {
     newSources = prevSources;
     newSourcesIndex = prevSourcesIndex;
     newFlags = prevFlags;
-    node.A = getClock() + 1;
+    node.B = getClock() + 1;
     node.a = STATE_CLEAN;
   }
 }
@@ -580,7 +580,7 @@ function isPending(fn, loadingValue) {
   if (!currentObserver)
     return pendingCheck(fn, loadingValue);
   const c = new Computation(void 0, () => pendingCheck(fn, loadingValue));
-  c.S |= LOADING_BIT;
+  c.T |= LOADING_BIT;
   return c.read();
 }
 function latest(fn, fallback) {
@@ -613,7 +613,7 @@ function runWithObserver(observer, run) {
         newFlags | LOADING_BIT | observer.f & UNINITIALIZED_BIT
       );
     } else {
-      observer.L(error);
+      observer.M(error);
     }
   } finally {
     if (newSources) {
@@ -642,7 +642,7 @@ function runWithObserver(observer, run) {
 function compute(owner, fn, observer) {
   const prevOwner = setOwner(owner), prevObserver = currentObserver, prevMask = currentMask, prevNotStale = notStale;
   currentObserver = observer;
-  currentMask = observer?.S ?? DEFAULT_FLAGS;
+  currentMask = observer?.T ?? DEFAULT_FLAGS;
   notStale = true;
   try {
     return fn(observer ? observer.g : void 0);
@@ -656,23 +656,23 @@ function compute(owner, fn, observer) {
 
 // src/core/effect.ts
 var Effect = class extends Computation {
-  T;
-  M;
-  B;
-  U = false;
+  U;
   N;
+  C;
+  V = false;
+  O;
   s;
   constructor(initialValue, compute2, effect, error, options) {
     super(initialValue, compute2, options);
-    this.T = effect;
-    this.M = error;
-    this.N = initialValue;
+    this.U = effect;
+    this.N = error;
+    this.O = initialValue;
     this.s = options?.render ? EFFECT_RENDER : EFFECT_USER;
     if (this.s === EFFECT_RENDER) {
-      this.z = (p) => getClock() > this.h.created && !(this.f & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
+      this.A = (p) => getClock() > this.h.created && !(this.f & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
     }
-    this.x();
-    !options?.defer && (this.s === EFFECT_USER ? this.h.enqueue(this.s, this.V.bind(this)) : this.V(this.s));
+    this.y();
+    !options?.defer && (this.s === EFFECT_USER ? this.h.enqueue(this.s, this.u.bind(this)) : this.u(this.s));
   }
   write(value, flags = 0) {
     if (this.a == STATE_DIRTY) {
@@ -685,25 +685,25 @@ var Effect = class extends Computation {
     if (value === UNCHANGED)
       return this.g;
     this.g = value;
-    this.U = true;
+    this.V = true;
     return value;
   }
   r(state, skipQueue) {
     if (this.a >= state || skipQueue)
       return;
     if (this.a === STATE_CLEAN)
-      this.h.enqueue(this.s, this.V.bind(this));
+      this.h.enqueue(this.s, this.u.bind(this));
     this.a = state;
   }
-  L(error) {
-    this.F = error;
+  M(error) {
+    this.G = error;
     this.h.notify(this, LOADING_BIT, 0);
     this.f = ERROR_BIT;
     if (this.s === EFFECT_USER) {
       try {
-        return this.M ? this.M(error, () => {
-          this.B?.();
-          this.B = void 0;
+        return this.N ? this.N(error, () => {
+          this.C?.();
+          this.C = void 0;
         }) : console.error(error);
       } catch (e) {
         error = e;
@@ -712,49 +712,49 @@ var Effect = class extends Computation {
     if (!this.h.notify(this, ERROR_BIT, ERROR_BIT))
       throw error;
   }
-  y() {
+  z() {
     if (this.a === STATE_DISPOSED)
       return;
-    this.T = void 0;
+    this.U = void 0;
+    this.O = void 0;
     this.N = void 0;
-    this.M = void 0;
-    this.B?.();
-    this.B = void 0;
-    super.y();
+    this.C?.();
+    this.C = void 0;
+    super.z();
   }
-  V(type) {
+  u(type) {
     if (type) {
-      if (this.U && this.a !== STATE_DISPOSED) {
-        this.B?.();
+      if (this.V && this.a !== STATE_DISPOSED) {
+        this.C?.();
         try {
-          this.B = this.T(this.g, this.N);
+          this.C = this.U(this.g, this.O);
         } catch (e) {
           if (!this.h.notify(this, ERROR_BIT, ERROR_BIT))
             throw e;
         } finally {
-          this.N = this.g;
-          this.U = false;
+          this.O = this.g;
+          this.V = false;
         }
       }
     } else
       this.a !== STATE_CLEAN && runTop(this);
   }
 };
-function runComputation() {
-  this.a !== STATE_CLEAN && runTop(this);
-}
 var EagerComputation = class extends Computation {
   constructor(initialValue, compute2, options) {
     super(initialValue, compute2, options);
-    !options?.defer && this.x();
+    !options?.defer && this.y();
   }
   r(state, skipQueue) {
-    if (this.a >= state && !this.w)
+    if (this.a >= state && !this.x)
       return;
-    if (!skipQueue && (this.a === STATE_CLEAN || this.a === STATE_CHECK && this.w))
-      this.h.enqueue(EFFECT_PURE, runComputation.bind(this));
+    if (!skipQueue && (this.a === STATE_CLEAN || this.a === STATE_CHECK && this.x))
+      this.h.enqueue(EFFECT_PURE, this.u.bind(this));
     super.r(state, skipQueue);
   }
+  u() {
+    this.a !== STATE_CLEAN && runTop(this);
+  }
 };
 var FirewallComputation = class extends Computation {
   firewall = true;
@@ -762,12 +762,15 @@ var FirewallComputation = class extends Computation {
     super(void 0, compute2);
   }
   r(state, skipQueue) {
-    if (this.a >= state && !this.w)
+    if (this.a >= state && !this.x)
       return;
-    if (!skipQueue && (this.a === STATE_CLEAN || this.a === STATE_CHECK && this.w))
-      this.h.enqueue(EFFECT_PURE, runComputation.bind(this));
+    if (!skipQueue && (this.a === STATE_CLEAN || this.a === STATE_CHECK && this.x))
+      this.h.enqueue(EFFECT_PURE, this.u.bind(this));
     super.r(state, true);
-    this.w = !!skipQueue;
+    this.x = !!skipQueue;
+  }
+  u() {
+    this.a !== STATE_CLEAN && runTop(this);
   }
 };
 function runTop(node) {
@@ -779,7 +782,7 @@ function runTop(node) {
   }
   for (let i = ancestors.length - 1; i >= 0; i--) {
     if (ancestors[i].a !== STATE_DISPOSED)
-      ancestors[i].x();
+      ancestors[i].y();
   }
 }
 
@@ -851,7 +854,7 @@ function createAsync(compute2, value, options) {
           (error) => {
             if (abort)
               return;
-            node.L(error);
+            node.M(error);
           }
         );
       } else {
@@ -877,7 +880,7 @@ function createAsync(compute2, value, options) {
   read.refresh = () => {
     node.a = STATE_DIRTY;
     refreshing = true;
-    node.x();
+    node.y();
   };
   return read;
 }
@@ -1578,53 +1581,53 @@ function omit(props, ...keys) {
 function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
   return updateKeyedMap.bind({
-    G: new Owner(),
+    H: new Owner(),
     i: 0,
     $: list,
-    u: [],
-    C: map,
+    w: [],
+    D: map,
     e: [],
     b: [],
-    D: keyFn,
+    E: keyFn,
     j: keyFn || options?.keyed === false ? [] : void 0,
     k: map.length > 1 ? [] : void 0,
-    H: options?.fallback
+    I: options?.fallback
   });
 }
 var pureOptions = { pureWrite: true };
 function updateKeyedMap() {
   const newItems = this.$() || [], newLen = newItems.length;
   newItems[$TRACK];
-  runWithOwner(this.G, () => {
+  runWithOwner(this.H, () => {
     let i, j, mapper = this.j ? () => {
       this.j[j] = new Computation(newItems[j], null, pureOptions);
       this.k && (this.k[j] = new Computation(j, null, pureOptions));
-      return this.C(
+      return this.D(
         Computation.prototype.read.bind(this.j[j]),
         this.k ? Computation.prototype.read.bind(this.k[j]) : void 0
       );
     } : this.k ? () => {
       const item = newItems[j];
       this.k[j] = new Computation(j, null, pureOptions);
-      return this.C(() => item, Computation.prototype.read.bind(this.k[j]));
+      return this.D(() => item, Computation.prototype.read.bind(this.k[j]));
     } : () => {
       const item = newItems[j];
-      return this.C(() => item);
+      return this.D(() => item);
     };
     if (newLen === 0) {
       if (this.i !== 0) {
-        this.G.dispose(false);
+        this.H.dispose(false);
         this.b = [];
-        this.u = [];
+        this.w = [];
         this.e = [];
         this.i = 0;
         this.j && (this.j = []);
         this.k && (this.k = []);
       }
-      if (this.H && !this.e[0]) {
+      if (this.I && !this.e[0]) {
         this.e[0] = compute(
           this.b[0] = new Owner(),
-          this.H,
+          this.I,
           null
         );
       }
@@ -1633,17 +1636,17 @@ function updateKeyedMap() {
         this.b[0].dispose();
       this.e = new Array(newLen);
       for (j = 0; j < newLen; j++) {
-        this.u[j] = newItems[j];
+        this.w[j] = newItems[j];
         this.e[j] = compute(this.b[j] = new Owner(), mapper, null);
       }
       this.i = newLen;
     } else {
       let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.j ? new Array(newLen) : void 0, tempIndexes = this.k ? new Array(newLen) : void 0;
-      for (start = 0, end = Math.min(this.i, newLen); start < end && (this.u[start] === newItems[start] || this.j && compare(this.D, this.u[start], newItems[start])); start++) {
+      for (start = 0, end = Math.min(this.i, newLen); start < end && (this.w[start] === newItems[start] || this.j && compare(this.E, this.w[start], newItems[start])); start++) {
         if (this.j)
           this.j[start].write(newItems[start]);
       }
-      for (end = this.i - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.u[end] === newItems[newEnd] || this.j && compare(this.D, this.u[end], newItems[newEnd])); end--, newEnd--) {
+      for (end = this.i - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.w[end] === newItems[newEnd] || this.j && compare(this.E, this.w[end], newItems[newEnd])); end--, newEnd--) {
         temp[newEnd] = this.e[end];
         tempNodes[newEnd] = this.b[end];
         tempRows && (tempRows[newEnd] = this.j[end]);
@@ -1653,14 +1656,14 @@ function updateKeyedMap() {
       newIndicesNext = new Array(newEnd + 1);
       for (j = newEnd; j >= start; j--) {
         item = newItems[j];
-        key = this.D ? this.D(item) : item;
+        key = this.E ? this.E(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.u[i];
-        key = this.D ? this.D(item) : item;
+        item = this.w[i];
+        key = this.E ? this.E(item) : item;
         j = newIndices.get(key);
         if (j !== void 0 && j !== -1) {
           temp[j] = this.e[i];
@@ -1689,39 +1692,39 @@ function updateKeyedMap() {
         }
       }
       this.e = this.e.slice(0, this.i = newLen);
-      this.u = newItems.slice(0);
+      this.w = newItems.slice(0);
     }
   });
   return this.e;
 }
 function repeat(count, map, options) {
   return updateRepeat.bind({
-    G: new Owner(),
+    H: new Owner(),
     i: 0,
     q: 0,
     aa: count,
-    C: map,
+    D: map,
     b: [],
     e: [],
     ba: options?.from,
-    H: options?.fallback
+    I: options?.fallback
   });
 }
 function updateRepeat() {
   const newLen = this.aa();
   const from = this.ba?.() || 0;
-  runWithOwner(this.G, () => {
+  runWithOwner(this.H, () => {
     if (newLen === 0) {
       if (this.i !== 0) {
-        this.G.dispose(false);
+        this.H.dispose(false);
         this.b = [];
         this.e = [];
         this.i = 0;
       }
-      if (this.H && !this.e[0]) {
+      if (this.I && !this.e[0]) {
         this.e[0] = compute(
           this.b[0] = new Owner(),
-          this.H,
+          this.I,
           null
         );
       }
@@ -1751,7 +1754,7 @@ function updateRepeat() {
       for (let i2 = 0; i2 < difference; i2++) {
         this.e[i2] = compute(
           this.b[i2] = new Owner(),
-          () => this.C(i2 + from),
+          () => this.D(i2 + from),
           null
         );
       }
@@ -1759,7 +1762,7 @@ function updateRepeat() {
     for (let i = prevTo; i < to; i++) {
       this.e[i - from] = compute(
         this.b[i - from] = new Owner(),
-        () => this.C(i),
+        () => this.D(i),
         null
       );
     }
@@ -1775,17 +1778,17 @@ function compare(key, a, b) {
 
 // src/boundaries.ts
 var BoundaryComputation = class extends EagerComputation {
-  I;
+  J;
   constructor(compute2, propagationMask) {
     super(void 0, compute2, { defer: true });
-    this.I = propagationMask;
+    this.J = propagationMask;
   }
   write(value, flags) {
-    super.write(value, flags & ~this.I);
-    if (this.I & LOADING_BIT && !(this.f & UNINITIALIZED_BIT)) {
+    super.write(value, flags & ~this.J);
+    if (this.J & LOADING_BIT && !(this.f & UNINITIALIZED_BIT)) {
       flags &= ~LOADING_BIT;
     }
-    this.h.notify(this, this.I, flags);
+    this.h.notify(this, this.J, flags);
     return this.g;
   }
 };
@@ -1804,8 +1807,8 @@ function createBoundChildren(owner, fn, queue, mask) {
 }
 var ConditionalQueue = class extends Queue {
   n;
-  O = /* @__PURE__ */ new Set();
   P = /* @__PURE__ */ new Set();
+  Q = /* @__PURE__ */ new Set();
   constructor(disabled) {
     super();
     this.n = disabled;
@@ -1819,16 +1822,16 @@ var ConditionalQueue = class extends Queue {
     if (this.n.read()) {
       if (type & LOADING_BIT) {
         if (flags & LOADING_BIT) {
-          this.P.add(node);
+          this.Q.add(node);
           type &= ~LOADING_BIT;
-        } else if (this.P.delete(node))
+        } else if (this.Q.delete(node))
           type &= ~LOADING_BIT;
       }
       if (type & ERROR_BIT) {
         if (flags & ERROR_BIT) {
-          this.O.add(node);
+          this.P.add(node);
           type &= ~ERROR_BIT;
-        } else if (this.O.delete(node))
+        } else if (this.P.delete(node))
           type &= ~ERROR_BIT;
       }
     }
@@ -1836,12 +1839,12 @@ var ConditionalQueue = class extends Queue {
   }
 };
 var CollectionQueue = class extends Queue {
-  Q;
+  R;
   b = /* @__PURE__ */ new Set();
   n = new Computation(false, null, { pureWrite: true });
   constructor(type) {
     super();
-    this.Q = type;
+    this.R = type;
   }
   run(type) {
     if (!type || this.n.read())
@@ -1849,9 +1852,9 @@ var CollectionQueue = class extends Queue {
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (!(type & this.Q))
+    if (!(type & this.R))
       return super.notify(node, type, flags);
-    if (flags & this.Q) {
+    if (flags & this.R) {
       this.b.add(node);
       if (this.b.size === 1)
         this.n.write(true);
@@ -1860,7 +1863,7 @@ var CollectionQueue = class extends Queue {
       if (this.b.size === 0)
         this.n.write(false);
     }
-    type &= ~this.Q;
+    type &= ~this.R;
     return type ? super.notify(node, type, flags) : true;
   }
 };
@@ -1872,12 +1875,12 @@ function createBoundary(fn, condition) {
   const tree = createBoundChildren(owner, fn, queue, 0);
   new EagerComputation(void 0, () => {
     const disabled = queue.n.read();
-    tree.I = disabled ? ERROR_BIT | LOADING_BIT : 0;
+    tree.J = disabled ? ERROR_BIT | LOADING_BIT : 0;
     if (!disabled) {
-      queue.P.forEach((node) => queue.notify(node, LOADING_BIT, LOADING_BIT));
-      queue.O.forEach((node) => queue.notify(node, ERROR_BIT, ERROR_BIT));
+      queue.Q.forEach((node) => queue.notify(node, LOADING_BIT, LOADING_BIT));
+      queue.P.forEach((node) => queue.notify(node, ERROR_BIT, ERROR_BIT));
+      queue.Q.clear();
       queue.P.clear();
-      queue.O.clear();
     }
   });
   return () => queue.n.read() ? void 0 : tree.read();
@@ -1903,11 +1906,11 @@ function createErrorBoundary(fn, fallback) {
   return createCollectionBoundary(
     ERROR_BIT,
     fn,
-    (queue) => fallback(queue.b.values().next().value.F, () => {
+    (queue) => fallback(queue.b.values().next().value.G, () => {
       incrementClock();
       for (let node of queue.b) {
         node.a = STATE_DIRTY;
-        node.h?.enqueue(node.s, node);
+        node.h?.enqueue(node.s, node.u.bind(node));
       }
     })
   );