@but212/atom-effect 0.14.0 → 0.15.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-const re = {
+const ne = {
   /** One second in milliseconds */
   ONE_SECOND_MS: 1e3
 }, M = {
@@ -6,15 +6,15 @@ const re = {
   PENDING: "pending",
   RESOLVED: "resolved",
   REJECTED: "rejected"
-}, S = {
+}, g = {
   DISPOSED: 1,
   HAS_FN_SUBS: 2,
   HAS_OBJ_SUBS: 4
-}, d = {
-  ...S,
+}, S = {
+  ...g,
   EXECUTING: 8
 }, u = {
-  ...S,
+  ...g,
   DIRTY: 8,
   IDLE: 16,
   PENDING: 32,
@@ -22,16 +22,16 @@ const re = {
   REJECTED: 128,
   RECOMPUTING: 256,
   HAS_ERROR: 512
-}, D = {
-  ...S,
+}, b = {
+  ...g,
   SYNC: 8,
   NOTIFICATION_SCHEDULED: 16
-}, Te = {
+}, De = {
   /** Maximum number of pooled objects to prevent memory bloat */
   MAX_SIZE: 1e3,
   /** Number of objects to pre-allocate for performance-critical paths */
   WARMUP_SIZE: 100
-}, A = {
+}, T = {
   /** Maximum effect executions per second to detect infinite loops (Legacy/Fallback) */
   MAX_EXECUTIONS_PER_SECOND: 1e3,
   /** Threshold for cleaning up old execution timestamps */
@@ -57,8 +57,8 @@ const re = {
   MAX_DEPENDENCIES: 1e3,
   /** Enable infinite loop detection warnings */
   WARN_INFINITE_LOOP: !0
-}, b = 1073741823, oe = 20, z = 1 << oe - 1, g = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", ce = Object.freeze([]);
-class T extends Error {
+}, A = 1073741823, E = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", re = Object.freeze([]);
+class C extends Error {
   /**
    * Creates a new AtomError
    * @param message - Error message describing what went wrong
@@ -69,7 +69,7 @@ class T extends Error {
     super(e), this.name = "AtomError", this.cause = t, this.recoverable = s, this.timestamp = /* @__PURE__ */ new Date();
   }
 }
-class x extends T {
+class R extends C {
   /**
    * Creates a new ComputedError
    * @param message - Error message
@@ -79,7 +79,7 @@ class x extends T {
     super(e, t, !0), this.name = "ComputedError";
   }
 }
-class R extends T {
+class y extends C {
   /**
    * Creates a new EffectError
    * @param message - Error message
@@ -89,7 +89,7 @@ class R extends T {
     super(e, t, !1), this.name = "EffectError";
   }
 }
-class F extends T {
+class P extends C {
   /**
    * Creates a new SchedulerError
    * @param message - Error message
@@ -107,6 +107,10 @@ const l = {
    * Error thrown when computed() receives a non-function argument.
    */
   COMPUTED_MUST_BE_FUNCTION: "Computed function must be a function",
+  /**
+   * Error thrown when subscribe() receives an invalid listener.
+   */
+  COMPUTED_SUBSCRIBER_MUST_BE_FUNCTION: "Subscriber listener must be a function or Subscriber object",
   /**
    * Error thrown when accessing a pending async computed without a default value.
    */
@@ -119,6 +123,14 @@ const l = {
    * Error thrown when an asynchronous computed computation fails.
    */
   COMPUTED_ASYNC_COMPUTATION_FAILED: "Async computed computation failed",
+  /**
+   * Error thrown when a circular dependency is detected during computation.
+   */
+  COMPUTED_CIRCULAR_DEPENDENCY: "Circular dependency detected during computation",
+  /**
+   * Error thrown when subscribing to a dependency fails.
+   */
+  COMPUTED_DEPENDENCY_SUBSCRIPTION_FAILED: "Failed to subscribe to dependency",
   // ─────────────────────────────────────────────────────────────────
   // Atom errors
   // ─────────────────────────────────────────────────────────────────
@@ -126,6 +138,10 @@ const l = {
    * Error thrown when atom.subscribe() receives an invalid listener.
    */
   ATOM_SUBSCRIBER_MUST_BE_FUNCTION: "Subscription listener must be a function or Subscriber object",
+  /**
+   * Error thrown when the atom subscriber notification process fails.
+   */
+  ATOM_SUBSCRIBER_EXECUTION_FAILED: "Error occurred while executing atom subscribers",
   /**
    * Error logged when an individual subscriber throws during notification.
    * @remarks This error is caught and logged to prevent cascading failures.
@@ -146,24 +162,48 @@ const l = {
    * Error thrown when an effect's cleanup function fails.
    */
   EFFECT_CLEANUP_FAILED: "Effect cleanup function execution failed",
+  /**
+   * Error thrown when attempting to run a disposed effect.
+   */
+  EFFECT_DISPOSED: "Cannot run a disposed effect",
+  // ─────────────────────────────────────────────────────────────────
+  // Debug warnings
+  // ─────────────────────────────────────────────────────────────────
+  /**
+   * Warning message for large dependency graphs.
+   *
+   * @param count - The number of dependencies detected
+   * @returns Formatted warning message with dependency count
+   *
+   * @example
+   * ```ts
+   * console.warn(ERROR_MESSAGES.LARGE_DEPENDENCY_GRAPH(150));
+   * // Output: "Large dependency graph detected: 150 dependencies"
+   * ```
+   */
+  LARGE_DEPENDENCY_GRAPH: (i) => `Large dependency graph detected: ${i} dependencies`,
+  /**
+   * Warning logged when attempting to unsubscribe a non-existent listener.
+   */
+  UNSUBSCRIBE_NON_EXISTENT: "Attempted to unsubscribe a non-existent listener",
   /**
    * Error logged when the onError callback itself throws an error.
    * @remarks This prevents cascading failures from masking the original error.
    */
   CALLBACK_ERROR_IN_ERROR_HANDLER: "Error occurred during onError callback execution"
-}, w = /* @__PURE__ */ Symbol("debugName"), he = /* @__PURE__ */ Symbol("id"), B = /* @__PURE__ */ Symbol("type"), Q = /* @__PURE__ */ Symbol("noDefaultValue");
-function ue(n) {
-  return "dependencies" in n && Array.isArray(n.dependencies);
+}, w = /* @__PURE__ */ Symbol("debugName"), oe = /* @__PURE__ */ Symbol("id"), k = /* @__PURE__ */ Symbol("type"), Y = /* @__PURE__ */ Symbol("noDefaultValue");
+function ce(i) {
+  return "dependencies" in i && Array.isArray(i.dependencies);
 }
-let Y = 0;
-function K(n, e, t) {
-  if (n._visitedEpoch !== t) {
-    if (n._visitedEpoch = t, n === e)
-      throw new x("Indirect circular dependency detected");
-    if (ue(n)) {
-      const s = n.dependencies;
-      for (let i = 0; i < s.length; i++) {
-        const r = s[i];
+let q = 0;
+function K(i, e, t) {
+  if (i._visitedEpoch !== t) {
+    if (i._visitedEpoch = t, i === e)
+      throw new R("Indirect circular dependency detected");
+    if (ce(i)) {
+      const s = i.dependencies;
+      for (let n = 0; n < s.length; n++) {
+        const r = s[n];
         r && K(r, e, t);
       }
     }
@@ -173,45 +213,45 @@ const I = {
   enabled: typeof process < "u" && process.env?.NODE_ENV === "development",
   maxDependencies: G.MAX_DEPENDENCIES,
   warnInfiniteLoop: G.WARN_INFINITE_LOOP,
-  warn(n, e) {
-    this.enabled && n && console.warn(`[Atom Effect] ${e}`);
+  warn(i, e) {
+    this.enabled && i && console.warn(`[Atom Effect] ${e}`);
   },
   /**
    * Checks for circular dependencies.
    * Direct check runs always; indirect check only in dev mode.
    * @throws {ComputedError} When circular dependency detected
    */
-  checkCircular(n, e) {
-    if (n === e)
-      throw new x("Direct circular dependency detected");
-    this.enabled && (Y++, K(n, e, Y));
+  checkCircular(i, e) {
+    if (i === e)
+      throw new R("Direct circular dependency detected");
+    this.enabled && (q++, K(i, e, q));
   },
-  attachDebugInfo(n, e, t) {
+  attachDebugInfo(i, e, t) {
     if (!this.enabled)
       return;
-    const s = n;
-    s[w] = `${e}_${t}`, s[he] = t, s[B] = e;
+    const s = i;
+    s[w] = `${e}_${t}`, s[oe] = t, s[k] = e;
   },
-  getDebugName(n) {
-    if (n != null && w in n)
-      return n[w];
+  getDebugName(i) {
+    if (i != null && w in i)
+      return i[w];
   },
-  getDebugType(n) {
-    if (n != null && B in n)
-      return n[B];
+  getDebugType(i) {
+    if (i != null && k in i)
+      return i[k];
   }
 };
-let _e = 1;
-const le = () => _e++;
+let he = 1;
+const ue = () => he++;
 class W {
   constructor() {
-    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this._modifiedAtEpoch = -1, this._visitedEpoch = -1, this.id = le() & b, this._tempUnsub = void 0;
+    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this._modifiedAtEpoch = -1, this._visitedEpoch = -1, this.id = ue() & A, this._tempUnsub = void 0;
   }
   /**
    * Calculates the logical distance (shift) between current and cached version.
    */
   getShift(e) {
-    return this.version - e & b;
+    return this.version - e & A;
   }
 }
 class Z extends W {
@@ -223,11 +263,11 @@ class Z extends W {
       return this._addSubscriber(
         this._fnSubs,
         e,
-        S.HAS_FN_SUBS
+        g.HAS_FN_SUBS
       );
     if (e !== null && typeof e == "object" && "execute" in e)
-      return this._addSubscriber(this._objSubs, e, S.HAS_OBJ_SUBS);
-    throw new T(l.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
+      return this._addSubscriber(this._objSubs, e, g.HAS_OBJ_SUBS);
+    throw new C(l.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
   }
   /**
    * Gets the total number of active subscribers.
@@ -240,8 +280,11 @@ class Z extends W {
    * Uses swap-and-pop for efficient removals.
    */
   _addSubscriber(e, t, s) {
-    if (e.indexOf(t) !== -1) return () => {
-    };
+    if (e.indexOf(t) !== -1)
+      return E && console.warn(
+        "Attempted to subscribe the same listener twice. Ignoring duplicate subscription."
+      ), () => {
+      };
     e.push(t), this.flags |= s;
     let r = !1;
     return () => {
@@ -258,9 +301,9 @@ class Z extends W {
    * Notifies all subscribers of a change.
    */
   _notifySubscribers(e, t) {
-    const s = this.flags, i = S.HAS_FN_SUBS | S.HAS_OBJ_SUBS;
-    if (s & i) {
-      if (s & S.HAS_FN_SUBS) {
+    const s = this.flags, n = g.HAS_FN_SUBS | g.HAS_OBJ_SUBS;
+    if (s & n) {
+      if (s & g.HAS_FN_SUBS) {
         const r = this._fnSubs;
         for (let o = 0, c = r.length; o < c; o++) {
           const h = r[o];
@@ -269,12 +312,12 @@ class Z extends W {
               h(e, t);
             } catch (_) {
               console.error(
-                new T(l.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, _)
+                new C(l.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, _)
               );
             }
         }
       }
-      if (s & S.HAS_OBJ_SUBS) {
+      if (s & g.HAS_OBJ_SUBS) {
         const r = this._objSubs;
         for (let o = 0, c = r.length; o < c; o++) {
           const h = r[o];
@@ -283,7 +326,7 @@ class Z extends W {
               h.execute();
             } catch (_) {
               console.error(
-                new T(l.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, _)
+                new C(l.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, _)
               );
             }
         }
@@ -291,24 +334,24 @@ class Z extends W {
     }
   }
 }
-class ae {
+class _e {
   constructor() {
-    this.acquired = 0, this.released = 0, this.rejected = new fe();
+    this.acquired = 0, this.released = 0, this.rejected = new le();
   }
 }
-class fe {
+class le {
   constructor() {
     this.frozen = 0, this.tooLarge = 0, this.poolFull = 0;
   }
 }
-class k {
+class z {
   constructor() {
-    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = g ? new ae() : null;
+    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = E ? new _e() : null;
   }
   /** Acquires an array from the pool or creates a new one if the pool is empty. */
   acquire() {
     const e = this.stats;
-    return g && e && e.acquired++, this.pool.pop() ?? [];
+    return E && e && e.acquired++, this.pool.pop() ?? [];
   }
   /**
    * Releases an array back to the pool.
@@ -317,31 +360,31 @@ class k {
   release(e, t) {
     if (t && e === t || Object.isFrozen(e)) {
       const c = this.stats;
-      g && c && e !== t && c.rejected.frozen++;
+      E && c && e !== t && c.rejected.frozen++;
       return;
     }
-    const s = e.length, i = this.pool, r = i.length;
+    const s = e.length, n = this.pool, r = n.length;
     if (s > this.maxReusableCapacity || r >= this.maxPoolSize) {
       const c = this.stats;
-      g && c && (s > this.maxReusableCapacity ? c.rejected.tooLarge++ : c.rejected.poolFull++);
+      E && c && (s > this.maxReusableCapacity ? c.rejected.tooLarge++ : c.rejected.poolFull++);
       return;
     }
-    e.length = 0, i.push(e);
+    e.length = 0, n.push(e);
     const o = this.stats;
-    g && o && o.released++;
+    E && o && o.released++;
   }
   /** Returns current stats for the pool (dev mode only). */
   getStats() {
     const e = this.stats;
-    if (!g || !e) return null;
-    const { acquired: t, released: s, rejected: i } = e, r = i.frozen + i.tooLarge + i.poolFull;
+    if (!E || !e) return null;
+    const { acquired: t, released: s, rejected: n } = e, r = n.frozen + n.tooLarge + n.poolFull;
     return {
       acquired: t,
       released: s,
       rejected: {
-        frozen: i.frozen,
-        tooLarge: i.tooLarge,
-        poolFull: i.poolFull
+        frozen: n.frozen,
+        tooLarge: n.tooLarge,
+        poolFull: n.poolFull
       },
       leaked: t - s - r,
       poolSize: this.pool.length
@@ -351,76 +394,71 @@ class k {
   reset() {
     this.pool.length = 0;
     const e = this.stats;
-    g && e && (e.acquired = 0, e.released = 0, e.rejected.frozen = 0, e.rejected.tooLarge = 0, e.rejected.poolFull = 0);
+    E && e && (e.acquired = 0, e.released = 0, e.rejected.frozen = 0, e.rejected.tooLarge = 0, e.rejected.poolFull = 0);
   }
 }
-const f = Object.freeze([]), N = Object.freeze([]), p = Object.freeze([]), O = new k(), U = new k(), C = new k();
-function y(n, e, t, s) {
+const d = Object.freeze([]), O = Object.freeze([]), p = Object.freeze([]), x = new z(), U = new z(), D = new z();
+function N(i, e, t, s) {
   if (e != null) {
     if ((typeof e == "object" || typeof e == "function") && typeof e.addDependency == "function") {
-      e.addDependency(n);
+      e.addDependency(i);
       return;
     }
     if (typeof e == "function") {
-      const i = e;
-      t.indexOf(i) === -1 && (t.push(i), n.flags |= S.HAS_FN_SUBS);
+      const n = e;
+      t.indexOf(n) === -1 && (t.push(n), i.flags |= g.HAS_FN_SUBS);
       return;
     }
-    typeof e == "object" && typeof e.execute == "function" && s.indexOf(e) === -1 && (s.push(e), n.flags |= S.HAS_OBJ_SUBS);
+    typeof e == "object" && typeof e.execute == "function" && s.indexOf(e) === -1 && (s.push(e), i.flags |= g.HAS_OBJ_SUBS);
   }
 }
-function q(n, e, t, s) {
-  const i = n.length, r = e.length, o = e !== f && r > 0;
+function Q(i, e, t, s) {
+  const n = i.length, r = e.length, o = e !== d && r > 0;
   if (o)
     for (let h = 0; h < r; h++) {
       const _ = e[h];
       _ && (_._tempUnsub = t[h]);
     }
   const c = U.acquire();
-  c.length = i;
-  for (let h = 0; h < i; h++) {
-    const _ = n[h];
+  c.length = n;
+  for (let h = 0; h < n; h++) {
+    const _ = i[h];
     if (!_) continue;
-    const E = _._tempUnsub;
-    E ? (c[h] = E, _._tempUnsub = void 0) : (I.checkCircular(_, s), c[h] = _.subscribe(s));
+    const a = _._tempUnsub;
+    a ? (c[h] = a, _._tempUnsub = void 0) : (I.checkCircular(_, s), c[h] = _.subscribe(s));
   }
   if (o)
     for (let h = 0; h < r; h++) {
       const _ = e[h];
       if (_) {
-        const E = _._tempUnsub;
-        E && (E(), _._tempUnsub = void 0);
+        const a = _._tempUnsub;
+        a && (a(), _._tempUnsub = void 0);
       }
     }
-  return t !== N && U.release(t), c;
+  return t !== O && U.release(t), c;
 }
-let P = 0;
+let v = 0;
 function ee() {
-  return P = P + 1 & b || 1, P;
+  return v = v + 1 & A || 1, v;
 }
-function Ee() {
-  return P;
+function ae() {
+  return v;
 }
 let H = 0, j = 0, L = !1;
 function J() {
-  return L ? (g && console.warn(
+  return L ? (E && console.warn(
     "Warning: startFlush() called during flush - ignored to prevent infinite loop detection bypass"
-  ), !1) : (L = !0, H = H + 1 & b, j = 0, !0);
+  ), !1) : (L = !0, H = H + 1 & A || 1, j = 0, !0);
 }
 function $() {
   L = !1;
 }
-function de() {
+function fe() {
   return L ? ++j : 0;
 }
-class pe {
+class Ee {
   constructor() {
-    this._queueBuffers = [
-      [[], []],
-      // Normal [0][0], [0][1]
-      [[], []]
-      // Urgent [1][0], [1][1]
-    ], this._bufferIndices = new Uint8Array(2), this._sizes = new Uint32Array(2), this._activeQueues = [this._queueBuffers[0][0], this._queueBuffers[1][0]], this._epoch = 0, this.isProcessing = !1, this.isBatching = !1, this.batchDepth = 0, this.batchQueue = [], this.batchQueueSize = 0, this.isFlushingSync = !1, this.maxFlushIterations = A.MAX_FLUSH_ITERATIONS;
+    this._queueBuffer = [[], []], this._bufferIndex = 0, this._size = 0, this._epoch = 0, this.isProcessing = !1, this.isBatching = !1, this.batchDepth = 0, this.batchQueue = [], this.batchQueueSize = 0, this.isFlushingSync = !1, this.maxFlushIterations = T.MAX_FLUSH_ITERATIONS;
   }
   /**
    * Returns the current operational phase of the scheduler.
@@ -428,57 +466,37 @@ class pe {
   get phase() {
     return this.isProcessing || this.isFlushingSync ? 2 : this.isBatching ? 1 : 0;
   }
-  /** Current number of pending normal jobs. */
+  /** Current number of pending jobs. */
   get queueSize() {
-    return this._sizes[0];
-  }
-  /** Current number of pending urgent jobs. */
-  get urgentQueueSize() {
-    return this._sizes[1];
+    return this._size;
   }
   /**
-   * Schedules a task for execution with optional priority based on phase shift.
+   * Schedules a task for execution.
    */
-  schedule(e, t) {
-    if (typeof e != "function")
-      throw new F("Scheduler callback must be a function");
-    const s = this._epoch;
-    if (e._nextEpoch === s) return;
-    if (e._nextEpoch = s, this.isBatching || this.isFlushingSync) {
-      this.batchQueue[this.batchQueueSize++] = e;
-      return;
+  schedule(e) {
+    if (E && typeof e != "function")
+      throw new P("Scheduler callback must be a function");
+    const t = this._epoch;
+    if (e._nextEpoch !== t) {
+      if (e._nextEpoch = t, this.isBatching || this.isFlushingSync) {
+        this.batchQueue[this.batchQueueSize++] = e;
+        return;
+      }
+      this._queueBuffer[this._bufferIndex][this._size++] = e, this.isProcessing || this.flush();
     }
-    const i = this._calculateUrgency(e, t);
-    this._activeQueues[i][this._sizes[i]++] = e, this.isProcessing || this.flush();
   }
   /**
-   * Calculates urgency flag using branchless bit manipulation.
-   *
-   * Logic:
-   * 1. Calculate the 'shift' (rotation distance) from the cached version.
-   * 2. Compare against PHASE_THRESHOLD (180° rotation equivalent).
-   * 3. Use (N >>> 31) to extract the sign bit in O(1) time.
-   *
-   * @returns 1 if urgent (shift >= PHASE_THRESHOLD), 0 otherwise.
-   */
-  _calculateUrgency(e, t) {
-    if (!t || e._cachedVersion === void 0)
-      return 0;
-    const s = t.getShift(e._cachedVersion);
-    return z - 1 - s >>> 31 & 1;
-  }
-  /**
-   * Schedules a microtask-based flush of the queues.
+   * Schedules a microtask-based flush of the queue.
    * Coalesces multiple schedule calls into a single microtask execution.
    */
   flush() {
-    this.isProcessing || this._sizes[0] === 0 && this._sizes[1] === 0 || (this.isProcessing = !0, queueMicrotask(() => {
+    this.isProcessing || this._size === 0 || (this.isProcessing = !0, queueMicrotask(() => {
       try {
-        if (this._sizes[0] === 0 && this._sizes[1] === 0) return;
+        if (this._size === 0) return;
         const e = J();
         this._drainQueue(), e && $();
       } finally {
-        this.isProcessing = !1, (this._sizes[0] > 0 || this._sizes[1] > 0) && !this.isBatching && this.flush();
+        this.isProcessing = !1, this._size > 0 && !this.isBatching && this.flush();
       }
     }));
   }
@@ -496,49 +514,49 @@ class pe {
     }
   }
   /**
-   * Merges jobs from the batching queue into the primary normal queue.
-   * Increments the epoch/uses provided epoch to ensure deduplication.
+   * Merges jobs from the batching queue into the primary queue.
+   * Increments the epoch to ensure deduplication.
    */
   _mergeBatchQueue() {
     const e = this.batchQueueSize;
     if (e === 0) return;
-    const t = ++this._epoch, s = this.batchQueue, i = this._activeQueues[0];
-    let r = this._sizes[0];
+    const t = ++this._epoch, s = this.batchQueue, n = this._queueBuffer[this._bufferIndex];
+    let r = this._size;
     for (let o = 0; o < e; o++) {
       const c = s[o];
-      c._nextEpoch !== t && (c._nextEpoch = t, i[r++] = c);
+      c._nextEpoch !== t && (c._nextEpoch = t, n[r++] = c);
     }
-    this._sizes[0] = r, this.batchQueueSize = 0, s.length > A.BATCH_QUEUE_SHRINK_THRESHOLD && (s.length = 0);
+    this._size = r, this.batchQueueSize = 0, s.length > T.BATCH_QUEUE_SHRINK_THRESHOLD && (s.length = 0);
   }
   _drainQueue() {
     let e = 0;
     const t = this.maxFlushIterations;
-    for (; this._sizes[1] > 0 || this._sizes[0] > 0; ) {
+    for (; this._size > 0; ) {
       if (++e > t) {
         this._handleFlushOverflow();
         return;
       }
-      this._sizes[1] > 0 && this._processQueue(1), this._sizes[0] > 0 && this._processQueue(0), this._mergeBatchQueue();
+      this._processQueue(), this._mergeBatchQueue();
     }
   }
-  _processQueue(e) {
-    const t = this._queueBuffers[e], s = this._bufferIndices[e], i = t[s], r = this._sizes[e], o = s ^ 1;
-    this._bufferIndices[e] = o, this._activeQueues[e] = t[o], this._sizes[e] = 0, this._epoch++, this._processJobs(i, r);
+  _processQueue() {
+    const e = this._bufferIndex, t = this._queueBuffer[e], s = this._size, n = e ^ 1;
+    this._bufferIndex = n, this._size = 0, this._epoch++, this._processJobs(t, s);
   }
   _handleFlushOverflow() {
     console.error(
-      new F(
+      new P(
         `Maximum flush iterations (${this.maxFlushIterations}) exceeded. Possible infinite loop.`
       )
-    ), this._sizes[0] = 0, this._activeQueues[0].length = 0, this._sizes[1] = 0, this._activeQueues[1].length = 0, this.batchQueueSize = 0;
+    ), this._size = 0, this._queueBuffer[this._bufferIndex].length = 0, this.batchQueueSize = 0;
   }
   _processJobs(e, t) {
     for (let s = 0; s < t; s++)
       try {
         e[s]();
-      } catch (i) {
+      } catch (n) {
         console.error(
-          new F("Error occurred during scheduler execution", i)
+          new P("Error occurred during scheduler execution", n)
         );
       }
     e.length = 0;
@@ -547,18 +565,22 @@ class pe {
     this.batchDepth++, this.isBatching = !0;
   }
   endBatch() {
-    this.batchDepth = Math.max(0, this.batchDepth - 1), this.batchDepth === 0 && (this.flushSync(), this.isBatching = !1);
+    if (this.batchDepth === 0) {
+      E && console.warn("endBatch() called without matching startBatch(). Ignoring.");
+      return;
+    }
+    this.batchDepth--, this.batchDepth === 0 && (this.flushSync(), this.isBatching = !1);
   }
   setMaxFlushIterations(e) {
-    if (e < A.MIN_FLUSH_ITERATIONS)
-      throw new F(
-        `Max flush iterations must be at least ${A.MIN_FLUSH_ITERATIONS}`
+    if (e < T.MIN_FLUSH_ITERATIONS)
+      throw new P(
+        `Max flush iterations must be at least ${T.MIN_FLUSH_ITERATIONS}`
       );
     this.maxFlushIterations = e;
   }
 }
-const v = new pe();
-class Se {
+const F = new Ee();
+class de {
   constructor() {
     this.current = null;
   }
@@ -585,28 +607,28 @@ class Se {
     return this.current;
   }
 }
-const a = new Se();
-function ge(n) {
-  if (typeof n != "function")
-    throw new T("Untracked callback must be a function");
-  const e = a.current;
-  a.current = null;
+const f = new de();
+function pe(i) {
+  if (typeof i != "function")
+    throw new C("Untracked callback must be a function");
+  const e = f.current;
+  f.current = null;
   try {
-    return n();
+    return i();
   } finally {
-    a.current = e;
+    f.current = e;
   }
 }
-class be extends Z {
+class Se extends Z {
   constructor(e, t) {
-    super(), this._value = e, this._pendingOldValue = void 0, this._notifyTask = void 0, this._fnSubs = [], this._objSubs = [], t && (this.flags |= D.SYNC), I.attachDebugInfo(this, "atom", this.id);
+    super(), this._value = e, this._pendingOldValue = void 0, this._notifyTask = void 0, this._fnSubs = [], this._objSubs = [], t && (this.flags |= b.SYNC), I.attachDebugInfo(this, "atom", this.id);
   }
   /**
    * Returns the current value and registers the atom as a dependency if in a tracking context.
    */
   get value() {
-    const e = a.current;
-    return e && y(this, e, this._fnSubs, this._objSubs), this._value;
+    const e = f.current;
+    return e && N(this, e, this._fnSubs, this._objSubs), this._value;
   }
   /**
    * Sets a new value and schedules notifications if the value has changed.
@@ -614,30 +636,31 @@ class be extends Z {
   set value(e) {
     const t = this._value;
     if (Object.is(t, e)) return;
-    this._value = e, this.version = this.version + 1 & b;
-    const s = this.flags, i = D.HAS_FN_SUBS | D.HAS_OBJ_SUBS;
-    s & i && this._scheduleNotification(t);
+    this._value = e, this.version = this.version + 1 & A;
+    const s = this.flags, n = b.HAS_FN_SUBS | b.HAS_OBJ_SUBS;
+    s & n && this._scheduleNotification(t);
   }
   /**
    * Schedules or flushes notifications based on sync mode and batching state.
    */
   _scheduleNotification(e) {
     let t = this.flags;
-    if (t & D.NOTIFICATION_SCHEDULED || (this._pendingOldValue = e, this.flags = t |= D.NOTIFICATION_SCHEDULED), t & D.SYNC && !v.isBatching) {
+    if (t & b.NOTIFICATION_SCHEDULED || (this._pendingOldValue = e, this.flags = t |= b.NOTIFICATION_SCHEDULED), t & b.SYNC && !F.isBatching) {
       this._flushNotifications();
       return;
     }
     let s = this._notifyTask;
-    s || (s = this._notifyTask = () => this._flushNotifications()), v.schedule(s);
+    s || (s = this._notifyTask = () => this._flushNotifications()), F.schedule(s);
   }
   /**
    * Flushes scheduled notifications and resets state for the next cycle.
    */
   _flushNotifications() {
-    if (!(this.flags & D.NOTIFICATION_SCHEDULED))
+    const e = this.flags;
+    if (!(e & b.NOTIFICATION_SCHEDULED) || e & b.DISPOSED)
       return;
-    const e = this._pendingOldValue, t = this._value;
-    this._pendingOldValue = void 0, this.flags &= -17, this._notifySubscribers(t, e);
+    const t = this._pendingOldValue, s = this._value;
+    this._pendingOldValue = void 0, this.flags &= -17, this._notifySubscribers(s, t);
   }
   /**
    * Returns the current value without registering it as a dependency.
@@ -649,46 +672,46 @@ class be extends Z {
    * Disposes of the atom and releases all subscribers and tasks.
    */
   dispose() {
-    this.flags & D.DISPOSED || (this._fnSubs = [], this._objSubs = [], this.flags |= D.DISPOSED, this._value = void 0, this._pendingOldValue = void 0, this._notifyTask = void 0);
+    this.flags & b.DISPOSED || (this._fnSubs = [], this._objSubs = [], this.flags |= b.DISPOSED, this._value = void 0, this._pendingOldValue = void 0, this._notifyTask = void 0);
   }
 }
-function ye(n, e = {}) {
-  return new be(n, e.sync ?? !1);
+function Ce(i, e = {}) {
+  return new Se(i, e.sync ?? !1);
 }
-function m(n, e, t) {
-  if (n instanceof TypeError)
-    return new e(`Type error (${t}): ${n.message}`, n);
-  if (n instanceof ReferenceError)
-    return new e(`Reference error (${t}): ${n.message}`, n);
-  if (n instanceof T)
-    return n;
-  const s = n instanceof Error ? n.message : String(n), i = n instanceof Error ? n : null;
-  return new e(`Unexpected error (${t}): ${s}`, i);
+function m(i, e, t) {
+  if (i instanceof TypeError)
+    return new e(`Type error (${t}): ${i.message}`, i);
+  if (i instanceof ReferenceError)
+    return new e(`Reference error (${t}): ${i.message}`, i);
+  if (i instanceof C)
+    return i;
+  const s = i instanceof Error ? i.message : String(i), n = i instanceof Error ? i : null;
+  return new e(`Unexpected error (${t}): ${s}`, n);
 }
-function Ie(n) {
-  return n !== null && typeof n == "object" && "value" in n && "subscribe" in n && typeof n.subscribe == "function";
+function ge(i) {
+  return i !== null && typeof i == "object" && "value" in i && "subscribe" in i && typeof i.subscribe == "function";
 }
-function Ae(n) {
-  if (I.enabled && (n == null || typeof n == "object")) {
-    const e = I.getDebugType(n);
+function Ne(i) {
+  if (I.enabled && i != null && typeof i == "object") {
+    const e = I.getDebugType(i);
     if (e)
       return e === "computed";
   }
-  return Ie(n) && "invalidate" in n && typeof n.invalidate == "function";
+  return ge(i) && "invalidate" in i && typeof i.invalidate == "function";
 }
-function Ne(n) {
-  return n !== null && typeof n == "object" && "dispose" in n && "run" in n && typeof n.dispose == "function" && typeof n.run == "function";
+function Re(i) {
+  return i !== null && typeof i == "object" && "dispose" in i && "run" in i && typeof i.dispose == "function" && typeof i.run == "function";
 }
-function te(n) {
-  return n != null && typeof n.then == "function";
+function te(i) {
+  return i != null && typeof i.then == "function";
 }
 const se = u.RESOLVED | u.PENDING | u.REJECTED, V = Array(se + 1).fill(M.IDLE);
 V[u.RESOLVED] = M.RESOLVED;
 V[u.PENDING] = M.PENDING;
 V[u.REJECTED] = M.REJECTED;
-class De {
+class be {
   constructor(e) {
-    this._owner = e, this._epoch = -1, this._nextDeps = f, this._nextVersions = p, this._depCount = 0;
+    this._owner = e, this._epoch = -1, this._nextDeps = d, this._nextVersions = p, this._depCount = 0;
   }
   execute() {
     this._owner._markDirty();
@@ -697,18 +720,18 @@ class De {
     if (e._lastSeenEpoch === this._epoch)
       return;
     e._lastSeenEpoch = this._epoch;
-    const t = this._depCount, s = this._nextDeps, i = this._nextVersions;
-    t < s.length ? (s[t] = e, i[t] = e.version) : (s.push(e), i.push(e.version)), this._depCount = t + 1;
+    const t = this._depCount, s = this._nextDeps, n = this._nextVersions;
+    t < s.length ? (s[t] = e, n[t] = e.version) : (s.push(e), n.push(e.version)), this._depCount = t + 1;
   }
   reset() {
-    this._epoch = -1, this._nextDeps = f, this._nextVersions = p, this._depCount = 0;
+    this._epoch = -1, this._nextDeps = d, this._nextVersions = p, this._depCount = 0;
   }
 }
 class ie extends Z {
   constructor(e, t = {}) {
     if (typeof e != "function")
-      throw new x(l.COMPUTED_MUST_BE_FUNCTION);
-    if (super(), this.MAX_ASYNC_RETRIES = 3, this._value = void 0, this.flags = u.DIRTY | u.IDLE, this._error = null, this._promiseId = 0, this._equal = t.equal ?? Object.is, this._fn = e, this._defaultValue = "defaultValue" in t ? t.defaultValue : Q, this._hasDefaultValue = this._defaultValue !== Q, this._onError = t.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._fnSubs = [], this._objSubs = [], this._dependencies = f, this._dependencyVersions = p, this._unsubscribes = N, this._cachedErrors = null, this._errorCacheEpoch = -1, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this._trackable = new De(this), I.attachDebugInfo(this, "computed", this.id), I.enabled) {
+      throw new R(l.COMPUTED_MUST_BE_FUNCTION);
+    if (super(), this.MAX_ASYNC_RETRIES = 3, this._value = void 0, this.flags = u.DIRTY | u.IDLE, this._error = null, this._promiseId = 0, this._equal = t.equal ?? Object.is, this._fn = e, this._defaultValue = "defaultValue" in t ? t.defaultValue : Y, this._hasDefaultValue = this._defaultValue !== Y, this._onError = t.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._fnSubs = [], this._objSubs = [], this._dependencies = d, this._dependencyVersions = p, this._unsubscribes = O, this._cachedErrors = null, this._errorCacheEpoch = -1, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this._trackable = new be(this), I.attachDebugInfo(this, "computed", this.id), I.enabled) {
       const s = this;
       s.subscriberCount = this.subscriberCount.bind(this), s.isDirty = () => (this.flags & u.DIRTY) !== 0, s.dependencies = this._dependencies, s.stateFlags = "";
     }
@@ -719,10 +742,13 @@ class ie extends Z {
       }
   }
   get value() {
-    const e = a.current;
-    e && y(this, e, this._fnSubs, this._objSubs);
+    const e = f.current;
+    e && N(this, e, this._fnSubs, this._objSubs);
     const t = this.flags;
-    if (t & u.RECOMPUTING) return this._value;
+    if (t & u.RECOMPUTING) {
+      if (this._hasDefaultValue) return this._defaultValue;
+      throw new R(l.COMPUTED_CIRCULAR_DEPENDENCY);
+    }
     t & (u.DIRTY | u.IDLE) && this._recompute();
     const s = this.flags;
     return s & u.PENDING ? this._handlePending() : s & u.REJECTED ? this._handleRejected() : this._value;
@@ -731,15 +757,15 @@ class ie extends Z {
     return this._value;
   }
   get state() {
-    const e = a.current;
-    return e && y(this, e, this._fnSubs, this._objSubs), V[this.flags & se];
+    const e = f.current;
+    return e && N(this, e, this._fnSubs, this._objSubs), V[this.flags & se];
   }
   get hasError() {
-    const e = a.current;
-    if (e && y(this, e, this._fnSubs, this._objSubs), this.flags & (u.REJECTED | u.HAS_ERROR)) return !0;
+    const e = f.current;
+    if (e && N(this, e, this._fnSubs, this._objSubs), this.flags & (u.REJECTED | u.HAS_ERROR)) return !0;
     const s = this._dependencies;
-    for (let i = 0, r = s.length; i < r; i++) {
-      const o = s[i];
+    for (let n = 0, r = s.length; n < r; n++) {
+      const o = s[n];
       if (o && o.flags & u.HAS_ERROR) return !0;
     }
     return !1;
@@ -748,20 +774,20 @@ class ie extends Z {
     return !this.hasError;
   }
   get errors() {
-    const e = a.current;
-    if (e && y(this, e, this._fnSubs, this._objSubs), !this.hasError) return ce;
-    const t = Ee();
+    const e = f.current;
+    if (e && N(this, e, this._fnSubs, this._objSubs), !this.hasError) return re;
+    const t = ae();
     if (this._errorCacheEpoch === t && this._cachedErrors !== null)
       return this._cachedErrors;
     const s = /* @__PURE__ */ new Set();
     this._error && s.add(this._error);
-    const i = this._dependencies;
-    for (let o = 0, c = i.length; o < c; o++) {
-      const h = i[o];
+    const n = this._dependencies;
+    for (let o = 0, c = n.length; o < c; o++) {
+      const h = n[o];
       if (h && "errors" in h) {
         const _ = h.errors;
-        for (let E = 0, ne = _.length; E < ne; E++) {
-          const X = _[E];
+        for (let a = 0, B = _.length; a < B; a++) {
+          const X = _[a];
           X && s.add(X);
         }
       }
@@ -770,35 +796,35 @@ class ie extends Z {
     return this._cachedErrors = r, this._errorCacheEpoch = t, r;
   }
   get lastError() {
-    const e = a.current;
-    return e && y(this, e, this._fnSubs, this._objSubs), this._error;
+    const e = f.current;
+    return e && N(this, e, this._fnSubs, this._objSubs), this._error;
   }
   get isPending() {
-    const e = a.current;
-    return e && y(this, e, this._fnSubs, this._objSubs), (this.flags & u.PENDING) !== 0;
+    const e = f.current;
+    return e && N(this, e, this._fnSubs, this._objSubs), (this.flags & u.PENDING) !== 0;
   }
   get isResolved() {
-    const e = a.current;
-    return e && y(this, e, this._fnSubs, this._objSubs), (this.flags & u.RESOLVED) !== 0;
+    const e = f.current;
+    return e && N(this, e, this._fnSubs, this._objSubs), (this.flags & u.RESOLVED) !== 0;
   }
   invalidate() {
     this._markDirty();
     const e = this._dependencyVersions;
-    e !== p && (C.release(e), this._dependencyVersions = p), this._errorCacheEpoch = -1, this._cachedErrors = null;
+    e !== p && (D.release(e), this._dependencyVersions = p), this._errorCacheEpoch = -1, this._cachedErrors = null;
   }
   dispose() {
     const e = this._unsubscribes;
-    if (e !== N) {
-      for (let i = 0, r = e.length; i < r; i++) {
-        const o = e[i];
+    if (e !== O) {
+      for (let n = 0, r = e.length; n < r; n++) {
+        const o = e[n];
         o && o();
       }
-      U.release(e), this._unsubscribes = N;
+      U.release(e), this._unsubscribes = O;
     }
     const t = this._dependencies;
-    t !== f && (O.release(t), this._dependencies = f);
+    t !== d && (x.release(t), this._dependencies = d);
     const s = this._dependencyVersions;
-    s !== p && (C.release(s), this._dependencyVersions = p), this._fnSubs = [], this._objSubs = [], this.flags = u.DISPOSED | u.DIRTY | u.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID, this._cachedErrors = null, this._errorCacheEpoch = -1;
+    s !== p && (D.release(s), this._dependencyVersions = p), this._fnSubs = [], this._objSubs = [], this.flags = u.DISPOSED | u.DIRTY | u.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID, this._cachedErrors = null, this._errorCacheEpoch = -1;
   }
   _clearDirty() {
     this.flags &= -9;
@@ -827,52 +853,39 @@ class ie extends Z {
       return;
     this._setRecomputing(!0);
     const e = this._trackable, t = this._dependencies, s = this._dependencyVersions;
-    e._epoch = ee(), e._nextDeps = O.acquire(), e._nextVersions = C.acquire(), e._depCount = 0;
-    let i = !1;
+    e._epoch = ee(), e._nextDeps = x.acquire(), e._nextVersions = D.acquire(), e._depCount = 0;
+    let n = !1;
     try {
-      const r = a.run(e, this._fn), o = e._nextDeps, c = e._nextVersions, h = e._depCount;
-      o.length = h, c.length = h, this._unsubscribes = q(o, t, this._unsubscribes, this), this._dependencies = o, this._dependencyVersions = c, i = !0, te(r) ? this._handleAsyncComputation(r) : this._finalizeResolution(r);
+      const r = f.run(e, this._fn), o = e._nextDeps, c = e._nextVersions, h = e._depCount;
+      o.length = h, c.length = h, this._unsubscribes = Q(o, t, this._unsubscribes, this), this._dependencies = o, this._dependencyVersions = c, n = !0, te(r) ? this._handleAsyncComputation(r) : this._finalizeResolution(r);
     } catch (r) {
       let o = r;
-      if (!i)
+      if (!n)
         try {
           const c = e._nextDeps, h = e._nextVersions, _ = e._depCount;
-          c.length = _, h.length = _, this._unsubscribes = q(c, t, this._unsubscribes, this), this._dependencies = c, this._dependencyVersions = h, i = !0;
+          c.length = _, h.length = _, this._unsubscribes = Q(c, t, this._unsubscribes, this), this._dependencies = c, this._dependencyVersions = h, n = !0;
         } catch (c) {
           o = c;
         }
       this._handleComputationError(o);
     } finally {
-      i ? (t !== f && O.release(t), s !== p && C.release(s)) : (O.release(e._nextDeps), C.release(e._nextVersions)), e.reset(), this._setRecomputing(!1);
-    }
-  }
-  _getAggregateShift() {
-    let e = 0;
-    const t = this._dependencies, s = this._dependencyVersions;
-    for (let i = 0, r = t.length; i < r; i++) {
-      const o = t[i], c = s[i];
-      o && c !== void 0 && (e = e + o.getShift(c) & b);
+      n ? (t !== d && x.release(t), s !== p && D.release(s)) : (x.release(e._nextDeps), D.release(e._nextVersions)), e.reset(), this._setRecomputing(!1);
     }
-    return e;
-  }
-  isUrgent() {
-    return this._getAggregateShift() >= z;
   }
   _handleAsyncComputation(e) {
     this._setPending(), this._clearDirty(), this._notifySubscribers(void 0, void 0), this._asyncStartAggregateVersion = this._captureVersionSnapshot(), this._asyncRetryCount = 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID;
     const t = this._promiseId;
     e.then((s) => {
       if (t !== this._promiseId) return;
-      const r = this._captureVersionSnapshot() - this._asyncStartAggregateVersion & b;
-      if (z - 1 - r >>> 31 & 1) {
+      if (this._captureVersionSnapshot() !== this._asyncStartAggregateVersion) {
         if (this._asyncRetryCount < this.MAX_ASYNC_RETRIES) {
           this._asyncRetryCount++, this._markDirty();
           return;
         }
-        const c = new x(
+        const o = new R(
           `Async drift exceeded threshold after ${this.MAX_ASYNC_RETRIES} retries.`
         );
-        this._handleAsyncRejection(c);
+        this._handleAsyncRejection(o);
         return;
       }
       this._finalizeResolution(s), this._notifySubscribers(s, void 0);
@@ -883,43 +896,46 @@ class ie extends Z {
   _captureVersionSnapshot() {
     let e = 0;
     const t = this._dependencies;
-    for (let s = 0, i = t.length; s < i; s++) {
+    for (let s = 0, n = t.length; s < n; s++) {
       const r = t[s];
-      r && (e = e + r.version & b);
+      if (r) {
+        const o = r.version;
+        e = ((e << 5) - e | 0) + o & A;
+      }
     }
     return e;
   }
   _handleAsyncRejection(e) {
-    const t = m(e, x, l.COMPUTED_ASYNC_COMPUTATION_FAILED);
-    this.flags & u.REJECTED || (this.version = this.version + 1 & b), this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1);
+    const t = m(e, R, l.COMPUTED_ASYNC_COMPUTATION_FAILED);
+    this.flags & u.REJECTED || (this.version = this.version + 1 & A), this._error = t, this._setRejected(), this._clearDirty();
     const s = this._onError;
     if (s)
       try {
         s(t);
-      } catch (i) {
-        console.error(l.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
+      } catch (n) {
+        console.error(l.CALLBACK_ERROR_IN_ERROR_HANDLER, n);
       }
     this._notifySubscribers(void 0, void 0);
   }
   _finalizeResolution(e) {
-    (!(this.flags & u.RESOLVED) || !this._equal(this._value, e)) && (this.version = this.version + 1 & b), this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), this._cachedErrors = null, this._errorCacheEpoch = -1;
+    (!(this.flags & u.RESOLVED) || !this._equal(this._value, e)) && (this.version = this.version + 1 & A), this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), this._cachedErrors = null, this._errorCacheEpoch = -1;
   }
   _handleComputationError(e) {
-    const t = m(e, x, l.COMPUTED_COMPUTATION_FAILED);
+    const t = m(e, R, l.COMPUTED_COMPUTATION_FAILED);
     this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1);
     const s = this._onError;
     if (s)
       try {
         s(t);
-      } catch (i) {
-        console.error(l.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
+      } catch (n) {
+        console.error(l.CALLBACK_ERROR_IN_ERROR_HANDLER, n);
       }
     throw t;
   }
   _handlePending() {
     if (this._hasDefaultValue)
       return this._defaultValue;
-    throw new x(l.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    throw new R(l.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
   }
   _handleRejected() {
     const e = this._error;
@@ -937,91 +953,105 @@ class ie extends Z {
   }
 }
 Object.freeze(ie.prototype);
-function Oe(n, e = {}) {
-  return new ie(n, e);
+function Te(i, e = {}) {
+  return new ie(i, e);
 }
-class Ce extends W {
+class Ie extends W {
   constructor(e, t = {}) {
-    super(), this._cleanup = null, this._dependencies = f, this._dependencyVersions = p, this._unsubscribes = N, this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, this._executeTask = void 0, this._onError = t.onError ?? null, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._fn = e, this._sync = t.sync ?? !1, this._maxExecutions = t.maxExecutionsPerSecond ?? A.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = t.maxExecutionsPerFlush ?? A.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = t.trackModifications ?? !1, this._executionCount = 0, this._historyPtr = 0;
-    const s = Number.isFinite(this._maxExecutions), i = s ? Math.min(this._maxExecutions + 1, A.MAX_EXECUTIONS_PER_SECOND + 1) : 0;
-    this._historyCapacity = i, this._history = g && s && i > 0 ? new Array(i).fill(0) : null, I.attachDebugInfo(this, "effect", this.id);
+    super(), this._cleanup = null, this._dependencies = d, this._dependencyVersions = p, this._unsubscribes = O, this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, this._executeTask = void 0, this._onError = t.onError ?? null, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._fn = e, this._sync = t.sync ?? !1, this._maxExecutions = t.maxExecutionsPerSecond ?? T.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = t.maxExecutionsPerFlush ?? T.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = t.trackModifications ?? !1, this._executionCount = 0, this._historyPtr = 0;
+    const s = Number.isFinite(this._maxExecutions), n = s ? Math.min(this._maxExecutions + 1, T.MAX_EXECUTIONS_PER_SECOND + 1) : 0;
+    this._historyCapacity = n, this._history = E && s && n > 0 ? new Array(n).fill(0) : null, this._execId = 0, I.attachDebugInfo(this, "effect", this.id);
   }
   run() {
-    if (this.flags & d.DISPOSED)
-      throw new R(l.EFFECT_MUST_BE_FUNCTION);
+    if (this.flags & S.DISPOSED)
+      throw new y(l.EFFECT_DISPOSED);
     this.execute(!0);
   }
   dispose() {
     const e = this.flags;
-    if (e & d.DISPOSED) return;
-    this.flags = e | d.DISPOSED, this._safeCleanup();
+    if (e & S.DISPOSED) return;
+    this.flags = e | S.DISPOSED, this._safeCleanup();
     const t = this._unsubscribes;
-    if (t !== N) {
+    if (t !== O) {
       for (let r = 0, o = t.length; r < o; r++) {
         const c = t[r];
         c && c();
       }
-      U.release(t), this._unsubscribes = N;
+      U.release(t), this._unsubscribes = O;
     }
     const s = this._dependencies;
-    s !== f && (O.release(s), this._dependencies = f);
-    const i = this._dependencyVersions;
-    i !== p && (C.release(i), this._dependencyVersions = p), this._executeTask = void 0;
+    s !== d && (x.release(s), this._dependencies = d);
+    const n = this._dependencyVersions;
+    n !== p && (D.release(n), this._dependencyVersions = p), this._executeTask = void 0;
   }
   addDependency(e) {
-    if (!(this.flags & d.EXECUTING)) return;
+    if (!(this.flags & S.EXECUTING)) return;
     const s = this._currentEpoch;
     if (e._lastSeenEpoch === s) return;
     e._lastSeenEpoch = s;
-    const i = this._nextDeps, r = this._nextVersions, o = this._nextUnsubs;
-    if (!i || !r || !o) return;
-    i.push(e), r.push(e.version);
+    const n = this._nextDeps, r = this._nextVersions, o = this._nextUnsubs;
+    if (!n || !r || !o) return;
+    n.push(e), r.push(e.version);
     const c = e._tempUnsub;
     c ? (o.push(c), e._tempUnsub = void 0) : this._subscribeTo(e);
   }
   execute(e = !1) {
-    if (this.flags & (d.DISPOSED | d.EXECUTING) || !e && !this._shouldExecute()) return;
+    if (this.flags & (S.DISPOSED | S.EXECUTING) || !e && !this._shouldExecute()) return;
     this._checkInfiniteLoop(), this._setExecuting(!0), this._safeCleanup();
     const s = this._prepareEffectExecutionContext();
-    let i = !1;
+    let n = !1;
     try {
-      const r = a.run(this, this._fn), o = s.nextDeps.length;
-      s.nextDeps.length = o, s.nextVersions.length = o, this._dependencies = s.nextDeps, this._dependencyVersions = s.nextVersions, this._unsubscribes = s.nextUnsubs, i = !0, this._checkLoopWarnings(), te(r) ? r.then((c) => {
-        !(this.flags & d.DISPOSED) && typeof c == "function" && (this._cleanup = c);
-      }).catch((c) => this._handleExecutionError(c)) : this._cleanup = typeof r == "function" ? r : null;
+      const r = f.run(this, this._fn), o = s.nextDeps.length;
+      s.nextDeps.length = o, s.nextVersions.length = o, this._dependencies = s.nextDeps, this._dependencyVersions = s.nextVersions, this._unsubscribes = s.nextUnsubs, n = !0, this._checkLoopWarnings();
+      const c = ++this._execId;
+      te(r) ? r.then((h) => {
+        const _ = c !== this._execId, a = this.flags & S.DISPOSED;
+        if (_ || a) {
+          if (typeof h == "function")
+            try {
+              h();
+            } catch (B) {
+              this._handleExecutionError(B, l.EFFECT_CLEANUP_FAILED);
+            }
+          return;
+        }
+        typeof h == "function" && (this._cleanup = h);
+      }).catch((h) => {
+        c === this._execId && this._handleExecutionError(h);
+      }) : this._cleanup = typeof r == "function" ? r : null;
     } catch (r) {
-      i = !0, this._handleExecutionError(r), this._cleanup = null;
+      n = !0, this._handleExecutionError(r), this._cleanup = null;
     } finally {
-      this._cleanupEffect(s, i), this._setExecuting(!1);
+      this._cleanupEffect(s, n), this._setExecuting(!1);
     }
   }
   _prepareEffectExecutionContext() {
-    const e = this._dependencies, t = this._dependencyVersions, s = this._unsubscribes, i = O.acquire(), r = C.acquire(), o = U.acquire(), c = ee();
-    if (e !== f)
+    const e = this._dependencies, t = this._dependencyVersions, s = this._unsubscribes, n = x.acquire(), r = D.acquire(), o = U.acquire(), c = ee();
+    if (e !== d)
       for (let h = 0, _ = e.length; h < _; h++) {
-        const E = e[h];
-        E && (E._tempUnsub = s[h]);
+        const a = e[h];
+        a && (a._tempUnsub = s[h]);
       }
-    return this._nextDeps = i, this._nextVersions = r, this._nextUnsubs = o, this._currentEpoch = c, { prevDeps: e, prevVersions: t, prevUnsubs: s, nextDeps: i, nextVersions: r, nextUnsubs: o };
+    return this._nextDeps = n, this._nextVersions = r, this._nextUnsubs = o, this._currentEpoch = c, { prevDeps: e, prevVersions: t, prevUnsubs: s, nextDeps: n, nextVersions: r, nextUnsubs: o };
   }
   _cleanupEffect(e, t) {
     this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null;
     const s = e.prevDeps;
     if (t) {
-      if (s !== f) {
-        for (let i = 0, r = s.length; i < r; i++) {
-          const o = s[i], c = o ? o._tempUnsub : void 0;
+      if (s !== d) {
+        for (let n = 0, r = s.length; n < r; n++) {
+          const o = s[n], c = o ? o._tempUnsub : void 0;
           c && (c(), o && (o._tempUnsub = void 0));
         }
-        O.release(s);
+        x.release(s);
       }
-      e.prevUnsubs !== N && U.release(e.prevUnsubs), e.prevVersions !== p && C.release(e.prevVersions);
+      e.prevUnsubs !== O && U.release(e.prevUnsubs), e.prevVersions !== p && D.release(e.prevVersions);
     } else {
-      O.release(e.nextDeps), C.release(e.nextVersions);
-      const i = e.nextUnsubs;
-      for (let r = 0, o = i.length; r < o; r++)
-        i[r]?.();
-      if (U.release(i), s !== f)
+      x.release(e.nextDeps), D.release(e.nextVersions);
+      const n = e.nextUnsubs;
+      for (let r = 0, o = n.length; r < o; r++)
+        n[r]?.();
+      if (U.release(n), s !== d)
         for (let r = 0, o = s.length; r < o; r++) {
           const c = s[r];
           c && (c._tempUnsub = void 0);
@@ -1031,35 +1061,32 @@ class Ce extends W {
   _subscribeTo(e) {
     try {
       const t = e.subscribe(() => {
-        if (this._trackModifications && this.flags & d.EXECUTING && (e._modifiedAtEpoch = this._currentEpoch), this._sync) {
+        if (this._trackModifications && this.flags & S.EXECUTING && (e._modifiedAtEpoch = this._currentEpoch), this._sync) {
           this.execute();
           return;
         }
-        let i = this._executeTask;
-        i || (i = this._executeTask = () => this.execute()), v.schedule(i);
+        let n = this._executeTask;
+        n || (n = this._executeTask = () => this.execute()), F.schedule(n);
       }), s = this._nextUnsubs;
       s && s.push(t);
     } catch (t) {
-      console.error(m(t, R, l.EFFECT_EXECUTION_FAILED));
+      console.error(m(t, y, l.EFFECT_EXECUTION_FAILED));
       const s = this._nextUnsubs;
       s && s.push(() => {
       });
     }
   }
   get isDisposed() {
-    return (this.flags & d.DISPOSED) !== 0;
+    return (this.flags & S.DISPOSED) !== 0;
   }
   get executionCount() {
     return this._executionCount;
   }
   get isExecuting() {
-    return (this.flags & d.EXECUTING) !== 0;
-  }
-  _setDisposed() {
-    this.flags |= d.DISPOSED;
+    return (this.flags & S.EXECUTING) !== 0;
   }
   _setExecuting(e) {
-    const t = d.EXECUTING;
+    const t = S.EXECUTING;
     this.flags = this.flags & ~t | (e ? -1 : 0) & t;
   }
   _safeCleanup() {
@@ -1068,31 +1095,32 @@ class Ce extends W {
       try {
         e();
       } catch (t) {
-        console.error(m(t, R, l.EFFECT_CLEANUP_FAILED));
+        this._handleExecutionError(t, l.EFFECT_CLEANUP_FAILED);
       }
       this._cleanup = null;
     }
   }
   _checkInfiniteLoop() {
     const e = H;
-    this._lastFlushEpoch !== e && (this._lastFlushEpoch = e, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), de() > A.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++;
+    this._lastFlushEpoch !== e && (this._lastFlushEpoch = e, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), fe() > T.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++;
     const s = this._history;
     if (s) {
-      const i = Date.now(), r = this._historyPtr, o = this._historyCapacity;
-      s[r] = i;
+      const n = Date.now(), r = this._historyPtr, o = this._historyCapacity;
+      s[r] = n;
       const c = (r + 1) % o;
       this._historyPtr = c;
       const h = s[c] ?? 0;
-      if (h > 0 && i - h < re.ONE_SECOND_MS) {
-        const _ = new R(
+      if (h > 0 && n - h < ne.ONE_SECOND_MS) {
+        const _ = new y(
           `Effect executed ${o} times within 1 second. Infinite loop suspected`
         );
-        if (this.dispose(), console.error(_), this._onError && this._onError(_), g) throw _;
+        if (this.dispose(), console.error(_), this._onError && this._onError(_), E) throw _;
+        return;
       }
     }
   }
   _throwInfiniteLoopError(e) {
-    const t = new R(
+    const t = new y(
       `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${j}`
     );
     throw this.dispose(), console.error(t), t;
@@ -1101,13 +1129,13 @@ class Ce extends W {
     const e = this._dependencies;
     if (e.length === 0) return !0;
     const t = this._dependencyVersions;
-    for (let s = 0, i = e.length; s < i; s++) {
+    for (let s = 0, n = e.length; s < n; s++) {
       const r = e[s];
       if (r) {
         if (r.version !== t[s]) return !0;
         if ("value" in r)
           try {
-            ge(() => r.value);
+            pe(() => r.value);
           } catch {
             return !0;
           }
@@ -1115,16 +1143,21 @@ class Ce extends W {
     }
     return !1;
   }
-  _handleExecutionError(e) {
-    const t = m(e, R, l.EFFECT_EXECUTION_FAILED);
-    console.error(t);
-    const s = this._onError;
-    s && s(t);
+  _handleExecutionError(e, t = l.EFFECT_EXECUTION_FAILED) {
+    const s = m(e, y, t);
+    console.error(s);
+    const n = this._onError;
+    if (n)
+      try {
+        n(s);
+      } catch (r) {
+        console.error(m(r, y, l.CALLBACK_ERROR_IN_ERROR_HANDLER));
+      }
   }
   _checkLoopWarnings() {
     if (this._trackModifications && I.enabled) {
       const e = this._dependencies, t = this._currentEpoch;
-      for (let s = 0, i = e.length; s < i; s++) {
+      for (let s = 0, n = e.length; s < n; s++) {
         const r = e[s];
         r && r._modifiedAtEpoch === t && I.warn(
           !0,
@@ -1134,40 +1167,40 @@ class Ce extends W {
     }
   }
 }
-function Re(n, e = {}) {
-  if (typeof n != "function")
-    throw new R(l.EFFECT_MUST_BE_FUNCTION);
-  const t = new Ce(n, e);
+function Oe(i, e = {}) {
+  if (typeof i != "function")
+    throw new y(l.EFFECT_MUST_BE_FUNCTION);
+  const t = new Ie(i, e);
   return t.execute(), t;
 }
-function xe(n) {
-  if (typeof n != "function")
-    throw new T("Batch callback must be a function");
-  v.startBatch();
+function xe(i) {
+  if (typeof i != "function")
+    throw new C("Batch callback must be a function");
+  F.startBatch();
   try {
-    return n();
+    return i();
   } finally {
-    v.endBatch();
+    F.endBatch();
   }
 }
 export {
   M as AsyncState,
-  T as AtomError,
-  x as ComputedError,
+  C as AtomError,
+  R as ComputedError,
   G as DEBUG_CONFIG,
   I as DEBUG_RUNTIME,
-  R as EffectError,
-  Te as POOL_CONFIG,
-  A as SCHEDULER_CONFIG,
-  F as SchedulerError,
-  ye as atom,
+  y as EffectError,
+  De as POOL_CONFIG,
+  T as SCHEDULER_CONFIG,
+  P as SchedulerError,
+  Ce as atom,
   xe as batch,
-  Oe as computed,
-  Re as effect,
-  Ie as isAtom,
-  Ae as isComputed,
-  Ne as isEffect,
-  v as scheduler,
-  ge as untracked
+  Te as computed,
+  Oe as effect,
+  ge as isAtom,
+  Ne as isComputed,
+  Re as isEffect,
+  F as scheduler,
+  pe as untracked
 };
 //# sourceMappingURL=index.mjs.map