@but212/atom-effect 0.5.1 → 0.7.0

package/dist/index.mjs

@@ -1,7 +1,7 @@
-const Z = {
+const te = {
   /** One second in milliseconds */
   ONE_SECOND_MS: 1e3
-}, T = {
+}, v = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
@@ -11,7 +11,7 @@ const Z = {
   // 0001 - Effect has been disposed
   EXECUTING: 2
   // 0010 - Effect is currently executing
-}, u = {
+}, c = {
   DIRTY: 1,
   // 0001 - Needs recomputation
   IDLE: 2,
@@ -26,7 +26,7 @@ const Z = {
   // 100000 - Currently recomputing
   HAS_ERROR: 64
   // 1000000 - Has error state
-}, ae = {
+}, pe = {
   /** Maximum number of pooled objects to prevent memory bloat */
   MAX_SIZE: 1e3,
   /** Number of objects to pre-allocate for performance-critical paths */
@@ -50,13 +50,13 @@ const Z = {
   MAX_FLUSH_ITERATIONS: 1e3,
   /** Minimum allowed value for max flush iterations */
   MIN_FLUSH_ITERATIONS: 10
-}, B = {
+}, k = {
   /** Maximum dependencies before warning about large dependency graphs */
   MAX_DEPENDENCIES: 1e3,
   /** Enable infinite loop detection warnings */
   WARN_INFINITE_LOOP: !0
-}, N = 1073741823, l = typeof process < "u" && process.env && process.env.NODE_ENV !== "production";
-class E extends Error {
+}, I = 1073741823, a = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", se = Object.freeze([]);
+class p extends Error {
   /**
    * Creates a new AtomError
    * @param message - Error message describing what went wrong
@@ -67,7 +67,7 @@ class E extends Error {
     super(e), this.name = "AtomError", this.cause = t, this.recoverable = s, this.timestamp = /* @__PURE__ */ new Date();
   }
 }
-class m extends E {
+class N extends p {
   /**
    * Creates a new ComputedError
    * @param message - Error message
@@ -77,7 +77,7 @@ class m extends E {
     super(e, t, !0), this.name = "ComputedError";
   }
 }
-class b extends E {
+class b extends p {
   /**
    * Creates a new EffectError
    * @param message - Error message
@@ -87,7 +87,7 @@ class b extends E {
     super(e, t, !1), this.name = "EffectError";
   }
 }
-class U extends E {
+class O extends p {
   /**
    * Creates a new SchedulerError
    * @param message - Error message
@@ -97,7 +97,7 @@ class U extends E {
     super(e, t, !1), this.name = "SchedulerError";
   }
 }
-const c = {
+const h = {
   // ─────────────────────────────────────────────────────────────────
   // Computed errors
   // ─────────────────────────────────────────────────────────────────
@@ -181,28 +181,28 @@ const c = {
    * @remarks This prevents cascading failures from masking the original error.
    */
   CALLBACK_ERROR_IN_ERROR_HANDLER: "Error occurred during onError callback execution"
-}, P = /* @__PURE__ */ Symbol("debugName"), ee = /* @__PURE__ */ Symbol("id"), M = /* @__PURE__ */ Symbol("type"), q = /* @__PURE__ */ Symbol("noDefaultValue");
-function te(i) {
+}, L = /* @__PURE__ */ Symbol("debugName"), ie = /* @__PURE__ */ Symbol("id"), V = /* @__PURE__ */ Symbol("type"), q = /* @__PURE__ */ Symbol("noDefaultValue");
+function ne(i) {
   return "dependencies" in i && Array.isArray(i.dependencies);
 }
-let k = 0;
-function X(i, e, t) {
+let j = 0;
+function G(i, e, t) {
   if (i._visitedEpoch !== t) {
     if (i._visitedEpoch = t, i === e)
-      throw new m("Indirect circular dependency detected");
-    if (te(i)) {
+      throw new N("Indirect circular dependency detected");
+    if (ne(i)) {
       const s = i.dependencies;
       for (let n = 0; n < s.length; n++) {
         const r = s[n];
-        r && X(r, e, t);
+        r && G(r, e, t);
       }
     }
   }
 }
 const d = {
   enabled: typeof process < "u" && process.env?.NODE_ENV === "development",
-  maxDependencies: B.MAX_DEPENDENCIES,
-  warnInfiniteLoop: B.WARN_INFINITE_LOOP,
+  maxDependencies: k.MAX_DEPENDENCIES,
+  warnInfiniteLoop: k.WARN_INFINITE_LOOP,
   warn(i, e) {
     this.enabled && i && console.warn(`[Atom Effect] ${e}`);
   },
@@ -213,32 +213,32 @@ const d = {
    */
   checkCircular(i, e) {
     if (i === e)
-      throw new m("Direct circular dependency detected");
-    this.enabled && (k++, X(i, e, k));
+      throw new N("Direct circular dependency detected");
+    this.enabled && (j++, G(i, e, j));
   },
   attachDebugInfo(i, e, t) {
     if (!this.enabled)
       return;
     const s = i;
-    s[P] = `${e}_${t}`, s[ee] = t, s[M] = e;
+    s[L] = `${e}_${t}`, s[ie] = t, s[V] = e;
   },
   getDebugName(i) {
-    if (i != null && P in i)
-      return i[P];
+    if (i != null && L in i)
+      return i[L];
   },
   getDebugType(i) {
-    if (i != null && M in i)
-      return i[M];
+    if (i != null && V in i)
+      return i[V];
   }
 };
-let se = 1;
-const ie = () => se++;
-class G {
+let re = 1;
+const oe = () => re++;
+class Y {
   constructor() {
-    this.id = ie() & N, this.flags = 0;
+    this.id = oe() & I, this.flags = 0;
   }
 }
-class $ extends G {
+class $ extends Y {
   constructor() {
     super(), this.version = 0, this._lastSeenEpoch = -1;
   }
@@ -253,7 +253,7 @@ class $ extends G {
     if (typeof e == "object" && e !== null && "execute" in e)
       return this._objectSubscribers.add(e);
     if (typeof e != "function")
-      throw new E(c.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
+      throw new p(h.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
     return this._functionSubscribers.add(e);
   }
   /**
@@ -271,30 +271,33 @@ class $ extends G {
   _notifySubscribers(e, t) {
     this._functionSubscribers.forEachSafe(
       (s) => s(e, t),
-      (s) => console.error(new E(c.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, s))
+      (s) => console.error(new p(h.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, s))
     ), this._objectSubscribers.forEachSafe(
       (s) => s.execute(),
-      (s) => console.error(new E(c.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, s))
+      (s) => console.error(new p(h.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, s))
     );
   }
 }
-let L = 0;
+let U = 0;
 function H() {
-  return L = (L + 1 | 0) & N, L;
+  return U = (U + 1 | 0) & I, U;
 }
-let O = 0, V = 0, x = !1;
-function j() {
-  return x ? (l && console.warn(
-    "Warning: startFlush() called during flush - ignored to prevent infinite loop detection bypass"
-  ), !1) : (x = !0, O = O + 1 & N, V = 0, !0);
+function ce() {
+  return U;
 }
+let x = 0, w = 0, F = !1;
 function z() {
-  x = !1;
+  return F ? (a && console.warn(
+    "Warning: startFlush() called during flush - ignored to prevent infinite loop detection bypass"
+  ), !1) : (F = !0, x = x + 1 & I, w = 0, !0);
+}
+function X() {
+  F = !1;
 }
-function ne() {
-  return x ? ++V : 0;
+function he() {
+  return F ? ++w : 0;
 }
-class re {
+class ue {
   constructor() {
     this.queueA = [], this.queueB = [], this.queue = this.queueA, this.queueSize = 0, this._epoch = 0, this.isProcessing = !1, this.isBatching = !1, this.batchDepth = 0, this.batchQueue = [], this.batchQueueSize = 0, this.isFlushingSync = !1, this.maxFlushIterations = g.MAX_FLUSH_ITERATIONS;
   }
@@ -309,7 +312,7 @@ class re {
    */
   schedule(e) {
     if (typeof e != "function")
-      throw new U("Scheduler callback must be a function");
+      throw new O("Scheduler callback must be a function");
     e._nextEpoch !== this._epoch && (e._nextEpoch = this._epoch, this.isBatching || this.isFlushingSync ? this.batchQueue[this.batchQueueSize++] = e : (this.queue[this.queueSize++] = e, this.isProcessing || this.flush()));
   }
   flush() {
@@ -317,17 +320,17 @@ class re {
     this.isProcessing = !0;
     const e = this.queue, t = this.queueSize;
     this.queue = this.queue === this.queueA ? this.queueB : this.queueA, this.queueSize = 0, this._epoch++, queueMicrotask(() => {
-      const s = j();
-      this._processJobs(e, t), this.isProcessing = !1, s && z(), this.queueSize > 0 && !this.isBatching && this.flush();
+      const s = z();
+      this._processJobs(e, t), this.isProcessing = !1, s && X(), this.queueSize > 0 && !this.isBatching && this.flush();
     });
   }
   flushSync() {
     this.isFlushingSync = !0;
-    const e = j();
+    const e = z();
     try {
       this._mergeBatchQueue(), this._drainQueue();
     } finally {
-      this.isFlushingSync = !1, e && z();
+      this.isFlushingSync = !1, e && X();
     }
   }
   _mergeBatchQueue() {
@@ -355,7 +358,7 @@ class re {
   }
   _handleFlushOverflow() {
     console.error(
-      new U(
+      new O(
         `Maximum flush iterations (${this.maxFlushIterations}) exceeded. Possible infinite loop.`
       )
     ), this.queueSize = 0, this.queue.length = 0, this.batchQueueSize = 0;
@@ -366,7 +369,7 @@ class re {
         e[s]?.();
       } catch (n) {
         console.error(
-          new U("Error occurred during scheduler execution", n)
+          new O("Error occurred during scheduler execution", n)
         );
       }
     e.length = 0;
@@ -388,24 +391,24 @@ class re {
    */
   setMaxFlushIterations(e) {
     if (e < g.MIN_FLUSH_ITERATIONS)
-      throw new U(
+      throw new O(
         `Max flush iterations must be at least ${g.MIN_FLUSH_ITERATIONS}`
       );
     this.maxFlushIterations = e;
   }
 }
-const R = new re();
-function fe(i) {
+const T = new ue();
+function be(i) {
   if (typeof i != "function")
-    throw new E("Batch callback must be a function");
-  R.startBatch();
+    throw new p("Batch callback must be a function");
+  T.startBatch();
   try {
     return i();
   } finally {
-    R.endBatch();
+    T.endBatch();
   }
 }
-const I = {
+const y = {
   current: null,
   run(i, e) {
     const t = this.current;
@@ -420,18 +423,18 @@ const I = {
     return this.current;
   }
 };
-function oe(i) {
+function _e(i) {
   if (typeof i != "function")
-    throw new E("Untracked callback must be a function");
-  const e = I.current;
-  I.current = null;
+    throw new p("Untracked callback must be a function");
+  const e = y.current;
+  y.current = null;
   try {
     return i();
   } finally {
-    I.current = e;
+    y.current = e;
   }
 }
-class F {
+class P {
   constructor() {
     this.subscribers = null;
   }
@@ -487,38 +490,38 @@ class F {
     return this.subscribers ? [...this.subscribers] : [];
   }
 }
-function ue(i) {
+function ae(i) {
   return i !== null && typeof i == "object" && "value" in i && "subscribe" in i && typeof i.subscribe == "function";
 }
-function de(i) {
+function Se(i) {
   if (d.enabled && (i == null || typeof i == "object")) {
     const e = d.getDebugType(i);
     if (e)
       return e === "computed";
   }
-  return ue(i) && "invalidate" in i && typeof i.invalidate == "function";
+  return ae(i) && "invalidate" in i && typeof i.invalidate == "function";
 }
-function pe(i) {
+function ge(i) {
   return i !== null && typeof i == "object" && "dispose" in i && "run" in i && typeof i.dispose == "function" && typeof i.run == "function";
 }
-function Q(i) {
+function J(i) {
   return i != null && typeof i.then == "function";
 }
-function ce(i) {
+function le(i) {
   return typeof i == "object" && i !== null;
 }
-function Y(i) {
+function Q(i) {
   return (typeof i == "object" || typeof i == "function") && i !== null && typeof i.addDependency == "function";
 }
-function J(i) {
+function W(i) {
   return typeof i == "function" && typeof i.addDependency != "function";
 }
-function W(i) {
-  return ce(i) && typeof i.execute == "function";
+function K(i) {
+  return le(i) && typeof i.execute == "function";
 }
-class he extends $ {
+class fe extends $ {
   constructor(e, t) {
-    super(), this._isNotificationScheduled = !1, this._value = e, this._functionSubscribersStore = new F(), this._objectSubscribersStore = new F(), this._sync = t, this._notifyTask = this._flushNotifications.bind(this), d.attachDebugInfo(this, "atom", this.id);
+    super(), this._isNotificationScheduled = !1, this._value = e, this._functionSubscribersStore = new P(), this._objectSubscribersStore = new P(), this._sync = t, this._notifyTask = this._flushNotifications.bind(this), d.attachDebugInfo(this, "atom", this.id);
   }
   /** Gets the manager for function-based subscribers. */
   get _functionSubscribers() {
@@ -532,7 +535,7 @@ class he extends $ {
    * Returns the current value and registers the atom as a dependency in the current tracking context.
    */
   get value() {
-    const e = I.getCurrent();
+    const e = y.getCurrent();
     return e && this._track(e), this._value;
   }
   /**
@@ -542,21 +545,21 @@ class he extends $ {
   set value(e) {
     if (Object.is(this._value, e)) return;
     const t = this._value;
-    this.version = this.version + 1 & N, this._value = e, !(!this._functionSubscribersStore.hasSubscribers && !this._objectSubscribersStore.hasSubscribers) && this._scheduleNotification(t);
+    this.version = this.version + 1 & I, this._value = e, !(!this._functionSubscribersStore.hasSubscribers && !this._objectSubscribersStore.hasSubscribers) && this._scheduleNotification(t);
   }
   _track(e) {
-    if (Y(e)) {
+    if (Q(e)) {
       e.addDependency(this);
       return;
     }
-    if (J(e)) {
+    if (W(e)) {
       this._functionSubscribersStore.add(e);
       return;
     }
-    W(e) && this._objectSubscribersStore.add(e);
+    K(e) && this._objectSubscribersStore.add(e);
   }
   _scheduleNotification(e) {
-    this._isNotificationScheduled || (this._pendingOldValue = e, this._isNotificationScheduled = !0), this._sync && !R.isBatching ? this._flushNotifications() : R.schedule(this._notifyTask);
+    this._isNotificationScheduled || (this._pendingOldValue = e, this._isNotificationScheduled = !0), this._sync && !T.isBatching ? this._flushNotifications() : T.schedule(this._notifyTask);
   }
   _flushNotifications() {
     if (!this._isNotificationScheduled) return;
@@ -576,12 +579,12 @@ class he extends $ {
     this._functionSubscribersStore.clear(), this._objectSubscribersStore.clear(), this._value = void 0;
   }
 }
-function Ee(i, e = {}) {
-  return new he(i, e.sync ?? !1);
+function De(i, e = {}) {
+  return new fe(i, e.sync ?? !1);
 }
-class w {
+class B {
   constructor() {
-    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = l ? {
+    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = a ? {
       acquired: 0,
       released: 0,
       rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
@@ -589,7 +592,7 @@ class w {
   }
   /** Acquires an array from the pool or creates a new one if the pool is empty. */
   acquire() {
-    return l && this.stats && this.stats.acquired++, this.pool.pop() ?? [];
+    return a && this.stats && this.stats.acquired++, this.pool.pop() ?? [];
   }
   /**
    * Releases an array back to the pool.
@@ -600,23 +603,23 @@ class w {
   release(e, t) {
     if (!(t && e === t)) {
       if (Object.isFrozen(e)) {
-        l && this.stats && this.stats.rejected.frozen++;
+        a && this.stats && this.stats.rejected.frozen++;
         return;
       }
       if (e.length > this.maxReusableCapacity) {
-        l && this.stats && this.stats.rejected.tooLarge++;
+        a && this.stats && this.stats.rejected.tooLarge++;
         return;
       }
       if (this.pool.length >= this.maxPoolSize) {
-        l && this.stats && this.stats.rejected.poolFull++;
+        a && this.stats && this.stats.rejected.poolFull++;
         return;
       }
-      e.length = 0, this.pool.push(e), l && this.stats && this.stats.released++;
+      e.length = 0, this.pool.push(e), a && this.stats && this.stats.released++;
     }
   }
   /** Returns current stats for the pool (dev mode only). */
   getStats() {
-    if (!l || !this.stats) return null;
+    if (!a || !this.stats) return null;
     const { acquired: e, released: t, rejected: s } = this.stats, n = s.frozen + s.tooLarge + s.poolFull;
     return {
       acquired: e,
@@ -628,12 +631,12 @@ class w {
   }
   /** Resets the pool and its stats. */
   reset() {
-    this.pool.length = 0, l && this.stats && (this.stats.acquired = 0, this.stats.released = 0, this.stats.rejected = { frozen: 0, tooLarge: 0, poolFull: 0 });
+    this.pool.length = 0, a && this.stats && (this.stats.acquired = 0, this.stats.released = 0, this.stats.rejected = { frozen: 0, tooLarge: 0, poolFull: 0 });
   }
 }
-const h = Object.freeze([]), a = Object.freeze([]), _ = Object.freeze([]), S = new w(), D = new w(), f = new w();
-function _e(i, e, t, s) {
-  if (e !== h && t !== a)
+const u = Object.freeze([]), l = Object.freeze([]), _ = Object.freeze([]), S = new B(), D = new B(), f = new B();
+function de(i, e, t, s) {
+  if (e !== u && t !== l)
     for (let r = 0; r < e.length; r++) {
       const o = e[r];
       o && (o._tempUnsub = t[r]);
@@ -644,28 +647,32 @@ function _e(i, e, t, s) {
     const o = i[r];
     o && (o._tempUnsub ? (n[r] = o._tempUnsub, o._tempUnsub = void 0) : (d.checkCircular(o, s), n[r] = o.subscribe(s)));
   }
-  if (e !== h)
+  if (e !== u)
     for (let r = 0; r < e.length; r++) {
       const o = e[r];
       o?._tempUnsub && (o._tempUnsub(), o._tempUnsub = void 0);
     }
-  return t !== a && D.release(t), n;
+  return t !== l && D.release(t), n;
 }
-function C(i, e, t) {
+function R(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 E)
+  if (i instanceof p)
     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);
 }
-class K extends $ {
+const Z = c.RESOLVED | c.PENDING | c.REJECTED, M = Array(Z + 1).fill(v.IDLE);
+M[c.RESOLVED] = v.RESOLVED;
+M[c.PENDING] = v.PENDING;
+M[c.REJECTED] = v.REJECTED;
+class ee extends $ {
   constructor(e, t = {}) {
     if (typeof e != "function")
-      throw new m(c.COMPUTED_MUST_BE_FUNCTION);
-    if (super(), 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._functionSubscribersStore = new F(), this._objectSubscribersStore = new F(), this._dependencies = h, this._dependencyVersions = _, this._unsubscribes = a, this._notifyJob = () => {
+      throw new N(h.COMPUTED_MUST_BE_FUNCTION);
+    if (super(), this._cachedErrors = null, this._errorCacheEpoch = -1, this._value = void 0, this.flags = c.DIRTY | c.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._functionSubscribersStore = new P(), this._objectSubscribersStore = new P(), this._dependencies = u, this._dependencyVersions = _, this._unsubscribes = l, this._notifyJob = () => {
       this._functionSubscribersStore.forEachSafe(
         (s) => s(),
         (s) => console.error(s)
@@ -693,83 +700,112 @@ class K extends $ {
     return this._objectSubscribersStore;
   }
   get value() {
-    const e = this._computeValue();
-    return this._registerTracking(), e;
+    return this._registerTracking(), this._computeValue();
   }
   peek() {
     return this._value;
   }
   get state() {
-    return this._getAsyncState();
+    return this._registerTracking(), this._getAsyncState();
   }
   get hasError() {
-    return this._isRejected();
+    if (this._registerTracking(), this._isRejected())
+      return !0;
+    for (let e = 0; e < this._dependencies.length; e++) {
+      const t = this._dependencies[e];
+      if (t && "hasError" in t && t.hasError)
+        return !0;
+    }
+    return !1;
+  }
+  get isValid() {
+    return !this.hasError;
+  }
+  get errors() {
+    if (this._registerTracking(), !this.hasError)
+      return se;
+    const e = ce();
+    if (this._errorCacheEpoch === e && this._cachedErrors !== null)
+      return this._cachedErrors;
+    const t = /* @__PURE__ */ new Set();
+    this._error && t.add(this._error);
+    for (let s = 0; s < this._dependencies.length; s++) {
+      const n = this._dependencies[s];
+      if (n && "errors" in n) {
+        const r = n.errors;
+        for (let o = 0; o < r.length; o++) {
+          const m = r[o];
+          m && t.add(m);
+        }
+      }
+    }
+    return this._cachedErrors = Object.freeze([...t]), this._errorCacheEpoch = e, this._cachedErrors;
   }
   get lastError() {
-    return this._error;
+    return this._registerTracking(), this._error;
   }
   get isPending() {
-    return this._isPending();
+    return this._registerTracking(), this._isPending();
   }
   get isResolved() {
-    return this._isResolved();
+    return this._registerTracking(), this._isResolved();
   }
   invalidate() {
-    this._markDirty(), this._dependencyVersions !== _ && (f.release(this._dependencyVersions), this._dependencyVersions = _);
+    this._markDirty(), this._dependencyVersions !== _ && (f.release(this._dependencyVersions), this._dependencyVersions = _), this._errorCacheEpoch = -1, this._cachedErrors = null;
   }
   dispose() {
-    if (this._unsubscribes !== a) {
+    if (this._unsubscribes !== l) {
       for (let e = 0; e < this._unsubscribes.length; e++) {
         const t = this._unsubscribes[e];
         t && t();
       }
-      D.release(this._unsubscribes), this._unsubscribes = a;
+      D.release(this._unsubscribes), this._unsubscribes = l;
     }
-    this._dependencies !== h && (S.release(this._dependencies), this._dependencies = h), this._dependencyVersions !== _ && (f.release(this._dependencyVersions), this._dependencyVersions = _), this._functionSubscribersStore.clear(), this._objectSubscribersStore.clear(), this.flags = u.DIRTY | u.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID;
+    this._dependencies !== u && (S.release(this._dependencies), this._dependencies = u), this._dependencyVersions !== _ && (f.release(this._dependencyVersions), this._dependencyVersions = _), this._functionSubscribersStore.clear(), this._objectSubscribersStore.clear(), this.flags = c.DIRTY | c.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID, this._cachedErrors = null, this._errorCacheEpoch = -1;
   }
   // State flag operations
   _isDirty() {
-    return (this.flags & u.DIRTY) !== 0;
+    return (this.flags & c.DIRTY) !== 0;
   }
   _setDirty() {
-    this.flags |= u.DIRTY;
+    this.flags |= c.DIRTY;
   }
   _clearDirty() {
     this.flags &= -2;
   }
   _isIdle() {
-    return (this.flags & u.IDLE) !== 0;
+    return (this.flags & c.IDLE) !== 0;
   }
   _setIdle() {
-    this.flags |= u.IDLE, this.flags &= -29;
+    this.flags |= c.IDLE, this.flags &= -29;
   }
   _isPending() {
-    return (this.flags & u.PENDING) !== 0;
+    return (this.flags & c.PENDING) !== 0;
   }
   _setPending() {
-    this.flags |= u.PENDING, this.flags &= -27;
+    this.flags |= c.PENDING, this.flags &= -27;
   }
   _isResolved() {
-    return (this.flags & u.RESOLVED) !== 0;
+    return (this.flags & c.RESOLVED) !== 0;
   }
   _setResolved() {
-    this.flags |= u.RESOLVED, this.flags &= -87;
+    this.flags |= c.RESOLVED, this.flags &= -87;
   }
   _isRejected() {
-    return (this.flags & u.REJECTED) !== 0;
+    return (this.flags & c.REJECTED) !== 0;
   }
   _setRejected() {
-    this.flags |= u.REJECTED | u.HAS_ERROR, this.flags &= -15;
+    this.flags |= c.REJECTED | c.HAS_ERROR, this.flags &= -15;
   }
   _isRecomputing() {
-    return (this.flags & u.RECOMPUTING) !== 0;
+    return (this.flags & c.RECOMPUTING) !== 0;
   }
   _setRecomputing(e) {
-    const t = u.RECOMPUTING;
+    const t = c.RECOMPUTING;
     this.flags = this.flags & ~t | -Number(e) & t;
   }
   _getAsyncState() {
-    return this._isResolved() ? T.RESOLVED : this._isPending() ? T.PENDING : this._isRejected() ? T.REJECTED : T.IDLE;
+    return M[this.flags & Z];
   }
   _getFlagsAsString() {
     const e = [];
@@ -784,32 +820,39 @@ class K extends $ {
     const e = this._prepareComputationContext();
     let t = !1;
     try {
-      const s = I.run(this._trackable, this._fn);
-      Q(s) ? (this._commitDependencies(e), t = !0, this._handleAsyncComputation(s)) : (this._commitDependencies(e), t = !0, this._handleSyncResult(s));
+      const s = y.run(this._trackable, this._fn);
+      this._commitDependencies(e), t = !0, J(s) ? this._handleAsyncComputation(s) : this._handleSyncResult(s);
     } catch (s) {
-      this._commitDependencies(e), t = !0, this._handleComputationError(s);
+      if (!t)
+        try {
+          this._commitDependencies(e), t = !0;
+        } catch (n) {
+          this._handleComputationError(n);
+        }
+      this._handleComputationError(s);
     } finally {
       this._cleanupContext(e, t), this._setRecomputing(!1);
     }
   }
   _prepareComputationContext() {
-    const e = this._dependencies, t = this._dependencyVersions, s = S.acquire(), n = f.acquire(), r = H(), o = { depCount: 0 }, v = (p) => {
-      p._lastSeenEpoch !== r && (p._lastSeenEpoch = r, o.depCount < s.length ? (s[o.depCount] = p, n[o.depCount] = p.version) : (s.push(p), n.push(p.version)), o.depCount++);
-    }, y = this._trackable.addDependency;
-    return this._trackable.addDependency = v, { prevDeps: e, prevVersions: t, nextDeps: s, nextVersions: n, originalAdd: y, state: o };
+    const e = this._dependencies, t = this._dependencyVersions, s = S.acquire(), n = f.acquire(), r = H(), o = { depCount: 0 }, m = (E) => {
+      E._lastSeenEpoch !== r && (E._lastSeenEpoch = r, o.depCount < s.length ? (s[o.depCount] = E, n[o.depCount] = E.version) : (s.push(E), n.push(E.version)), o.depCount++);
+    }, C = this._trackable.addDependency;
+    return this._trackable.addDependency = m, { prevDeps: e, prevVersions: t, nextDeps: s, nextVersions: n, originalAdd: C, state: o };
   }
   _commitDependencies(e) {
     const { nextDeps: t, nextVersions: s, state: n, prevDeps: r } = e;
-    t.length = n.depCount, s.length = n.depCount, this._unsubscribes = _e(t, r, this._unsubscribes, this), this._dependencies = t, this._dependencyVersions = s;
+    t.length = n.depCount, s.length = n.depCount, this._unsubscribes = de(t, r, this._unsubscribes, this), this._dependencies = t, this._dependencyVersions = s;
   }
   _cleanupContext(e, t) {
-    this._trackable.addDependency = e.originalAdd, t ? (e.prevDeps !== h && S.release(e.prevDeps), e.prevVersions !== _ && f.release(e.prevVersions)) : (S.release(e.nextDeps), f.release(e.nextVersions));
+    this._trackable.addDependency = e.originalAdd, t ? (e.prevDeps !== u && S.release(e.prevDeps), e.prevVersions !== _ && f.release(e.prevVersions)) : (S.release(e.nextDeps), f.release(e.nextVersions));
   }
   _handleSyncResult(e) {
-    (!this._isResolved() || !this._equal(this._value, e)) && (this.version = this.version + 1 & N), this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1);
+    const t = !this._isResolved() || !this._equal(this._value, e);
+    this.version = this.version + Number(t) & I, this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), this._cachedErrors = null, this._errorCacheEpoch = -1;
   }
   _handleAsyncComputation(e) {
-    this._setPending(), this._clearDirty(), this._promiseId = this._promiseId >= this.MAX_PROMISE_ID ? 1 : this._promiseId + 1;
+    this._setPending(), this._clearDirty(), this._notifyJob(), this._promiseId = this._promiseId >= this.MAX_PROMISE_ID ? 1 : this._promiseId + 1;
     const t = this._promiseId;
     e.then((s) => {
       t === this._promiseId && this._handleAsyncResolution(s);
@@ -818,32 +861,33 @@ class K extends $ {
     });
   }
   _handleAsyncResolution(e) {
-    (!this._isResolved() || !this._equal(this._value, e)) && (this.version = this.version + 1 & N), this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1);
+    const t = !this._isResolved() || !this._equal(this._value, e);
+    this.version = this.version + Number(t) & I, this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), this._cachedErrors = null, this._errorCacheEpoch = -1, this._notifyJob();
   }
   _handleAsyncRejection(e) {
-    const t = C(e, m, c.COMPUTED_ASYNC_COMPUTATION_FAILED);
-    if (this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
+    const t = R(e, N, h.COMPUTED_ASYNC_COMPUTATION_FAILED), s = !this._isRejected();
+    if (this.version = this.version + Number(s) & I, this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
       try {
         this._onError(t);
-      } catch (s) {
-        console.error(c.CALLBACK_ERROR_IN_ERROR_HANDLER, s);
+      } catch (n) {
+        console.error(h.CALLBACK_ERROR_IN_ERROR_HANDLER, n);
       }
-    this._notifySubscribers(void 0, void 0);
+    this._notifyJob();
   }
   _handleComputationError(e) {
-    const t = C(e, m, c.COMPUTED_COMPUTATION_FAILED);
+    const t = R(e, N, h.COMPUTED_COMPUTATION_FAILED);
     if (this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
       try {
         this._onError(t);
       } catch (s) {
-        console.error(c.CALLBACK_ERROR_IN_ERROR_HANDLER, s);
+        console.error(h.CALLBACK_ERROR_IN_ERROR_HANDLER, s);
       }
     throw t;
   }
   _handlePending() {
     if (this._hasDefaultValue)
       return this._defaultValue;
-    throw new m(c.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    throw new N(h.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
   }
   _handleRejected() {
     if (this._error?.recoverable && this._hasDefaultValue)
@@ -858,25 +902,25 @@ class K extends $ {
     this._isRecomputing() || this._isDirty() || (this._setDirty(), this._notifyJob());
   }
   _registerTracking() {
-    const e = I.getCurrent();
+    const e = y.getCurrent();
     if (e) {
-      if (Y(e)) {
+      if (Q(e)) {
         e.addDependency(this);
         return;
       }
-      if (J(e)) {
+      if (W(e)) {
         this._functionSubscribersStore.add(e);
         return;
       }
-      W(e) && this._objectSubscribersStore.add(e);
+      K(e) && this._objectSubscribersStore.add(e);
     }
   }
 }
-Object.freeze(K.prototype);
-function be(i, e = {}) {
-  return new K(i, e);
+Object.freeze(ee.prototype);
+function Ie(i, e = {}) {
+  return new ee(i, e);
 }
-class le extends G {
+class Ee extends Y {
   /**
    * Creates a new EffectImpl instance.
    * @param fn - The effect function to run.
@@ -885,18 +929,18 @@ class le extends G {
   constructor(e, t = {}) {
     super(), this.run = () => {
       if (this.isDisposed)
-        throw new b(c.EFFECT_MUST_BE_FUNCTION);
+        throw new b(h.EFFECT_MUST_BE_FUNCTION);
       this._dependencyVersions !== _ && (f.release(this._dependencyVersions), this._dependencyVersions = _), this.execute();
     }, this.dispose = () => {
       if (!this.isDisposed) {
-        if (this._setDisposed(), this._safeCleanup(), this._unsubscribes !== a) {
+        if (this._setDisposed(), this._safeCleanup(), this._unsubscribes !== l) {
           for (let s = 0; s < this._unsubscribes.length; s++) {
             const n = this._unsubscribes[s];
             n && n();
           }
-          D.release(this._unsubscribes), this._unsubscribes = a;
+          D.release(this._unsubscribes), this._unsubscribes = l;
         }
-        this._dependencies !== h && (S.release(this._dependencies), this._dependencies = h), this._dependencyVersions !== _ && (f.release(this._dependencyVersions), this._dependencyVersions = _);
+        this._dependencies !== u && (S.release(this._dependencies), this._dependencies = u), this._dependencyVersions !== _ && (f.release(this._dependencyVersions), this._dependencyVersions = _);
       }
     }, this.addDependency = (s) => {
       if (this.isExecuting && this._nextDeps && this._nextUnsubs && this._nextVersions) {
@@ -910,31 +954,31 @@ class le extends G {
       const s = this._prepareEffectContext();
       let n = !1;
       try {
-        const r = I.run(this, this._fn);
-        this._commitEffect(s), n = !0, this._checkLoopWarnings(), Q(r) ? r.then((o) => {
+        const r = y.run(this, this._fn);
+        this._commitEffect(s), n = !0, this._checkLoopWarnings(), J(r) ? r.then((o) => {
           !this.isDisposed && typeof o == "function" && (this._cleanup = o);
         }).catch((o) => {
-          console.error(C(o, b, c.EFFECT_EXECUTION_FAILED));
+          console.error(R(o, b, h.EFFECT_EXECUTION_FAILED));
         }) : this._cleanup = typeof r == "function" ? r : null;
       } catch (r) {
-        n = !0, console.error(C(r, b, c.EFFECT_EXECUTION_FAILED)), this._cleanup = null;
+        n = !0, console.error(R(r, b, h.EFFECT_EXECUTION_FAILED)), this._cleanup = null;
       } finally {
         this._cleanupEffect(s, n), this._setExecuting(!1);
       }
-    }, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._fn = e, this._sync = t.sync ?? !1, this._maxExecutions = t.maxExecutionsPerSecond ?? g.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = t.maxExecutionsPerFlush ?? g.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = t.trackModifications ?? !1, this._cleanup = null, this._dependencies = h, this._dependencyVersions = _, this._unsubscribes = a, this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, this._history = l ? [] : null, this._executionCount = 0, d.attachDebugInfo(this, "effect", this.id);
+    }, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._fn = e, this._sync = t.sync ?? !1, this._maxExecutions = t.maxExecutionsPerSecond ?? g.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = t.maxExecutionsPerFlush ?? g.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = t.trackModifications ?? !1, this._cleanup = null, this._dependencies = u, this._dependencyVersions = _, this._unsubscribes = l, this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, this._history = a ? [] : null, this._executionCount = 0, d.attachDebugInfo(this, "effect", this.id);
   }
   /**
    * Prepares the execution context by acquiring pools and setting up epoch.
    * @returns The prepared EffectContext.
    */
   _prepareEffectContext() {
-    const e = this._dependencies, t = this._dependencyVersions, s = this._unsubscribes, n = S.acquire(), r = f.acquire(), o = D.acquire(), v = H();
-    if (e !== h && s !== a)
-      for (let y = 0; y < e.length; y++) {
-        const p = e[y];
-        p && (p._tempUnsub = s[y]);
+    const e = this._dependencies, t = this._dependencyVersions, s = this._unsubscribes, n = S.acquire(), r = f.acquire(), o = D.acquire(), m = H();
+    if (e !== u && s !== l)
+      for (let C = 0; C < e.length; C++) {
+        const E = e[C];
+        E && (E._tempUnsub = s[C]);
       }
-    return this._nextDeps = n, this._nextVersions = r, this._nextUnsubs = o, this._currentEpoch = v, { prevDeps: e, prevVersions: t, prevUnsubs: s, nextDeps: n, nextVersions: r, nextUnsubs: o };
+    return this._nextDeps = n, this._nextVersions = r, this._nextUnsubs = o, this._currentEpoch = m, { prevDeps: e, prevVersions: t, prevUnsubs: s, nextDeps: n, nextVersions: r, nextUnsubs: o };
   }
   /**
    * Commits the tracked dependencies as the current active dependencies.
@@ -951,19 +995,19 @@ class le extends G {
    */
   _cleanupEffect(e, t) {
     if (this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, t) {
-      if (e.prevDeps !== h) {
+      if (e.prevDeps !== u) {
         for (let s = 0; s < e.prevDeps.length; s++) {
           const n = e.prevDeps[s];
           n?._tempUnsub && (n._tempUnsub(), n._tempUnsub = void 0);
         }
         S.release(e.prevDeps);
       }
-      e.prevUnsubs !== a && D.release(e.prevUnsubs), e.prevVersions !== _ && f.release(e.prevVersions);
+      e.prevUnsubs !== l && D.release(e.prevUnsubs), e.prevVersions !== _ && f.release(e.prevVersions);
     } else {
       S.release(e.nextDeps), f.release(e.nextVersions);
       for (let s = 0; s < e.nextUnsubs.length; s++)
         e.nextUnsubs[s]?.();
-      if (D.release(e.nextUnsubs), e.prevDeps !== h)
+      if (D.release(e.nextUnsubs), e.prevDeps !== u)
         for (let s = 0; s < e.prevDeps.length; s++) {
           const n = e.prevDeps[s];
           n && (n._tempUnsub = void 0);
@@ -977,11 +1021,11 @@ class le extends G {
   _subscribeTo(e) {
     try {
       const t = e.subscribe(() => {
-        this._trackModifications && this.isExecuting && (e._modifiedAtEpoch = this._currentEpoch), this._sync ? this.execute() : R.schedule(this.execute);
+        this._trackModifications && this.isExecuting && (e._modifiedAtEpoch = this._currentEpoch), this._sync ? this.execute() : T.schedule(this.execute);
       });
       this._nextUnsubs && this._nextUnsubs.push(t);
     } catch (t) {
-      console.error(C(t, b, c.EFFECT_EXECUTION_FAILED)), this._nextUnsubs && this._nextUnsubs.push(() => {
+      console.error(R(t, b, h.EFFECT_EXECUTION_FAILED)), this._nextUnsubs && this._nextUnsubs.push(() => {
       });
     }
   }
@@ -1018,7 +1062,7 @@ class le extends G {
       try {
         this._cleanup();
       } catch (e) {
-        console.error(C(e, b, c.EFFECT_CLEANUP_FAILED));
+        console.error(R(e, b, h.EFFECT_CLEANUP_FAILED));
       }
       this._cleanup = null;
     }
@@ -1028,7 +1072,7 @@ class le extends G {
    * @throws {EffectError} If an infinite loop is detected.
    */
   _checkInfiniteLoop() {
-    if (this._lastFlushEpoch !== O && (this._lastFlushEpoch = O, this._executionsInEpoch = 0), this._executionsInEpoch++, this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), ne() > g.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history) {
+    if (this._lastFlushEpoch !== x && (this._lastFlushEpoch = x, this._executionsInEpoch = 0), this._executionsInEpoch++, this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), he() > g.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history) {
       const e = Date.now();
       this._history.push(e), this._history.length > g.MAX_EXECUTIONS_PER_SECOND + 10 && this._history.shift(), this._checkTimestampLoop(e);
     }
@@ -1036,7 +1080,7 @@ class le extends G {
   _checkTimestampLoop(e) {
     const t = this._history;
     if (!t || this._maxExecutions <= 0) return;
-    const s = e - Z.ONE_SECOND_MS;
+    const s = e - te.ONE_SECOND_MS;
     let n = 0;
     for (let r = t.length - 1; r >= 0 && !(t[r] < s); r--)
       n++;
@@ -1044,13 +1088,13 @@ class le extends G {
       const r = new b(
         `Effect executed ${n} times within 1 second. Infinite loop suspected`
       );
-      if (this.dispose(), console.error(r), l)
+      if (this.dispose(), console.error(r), a)
         throw r;
     }
   }
   _throwInfiniteLoopError(e) {
     const t = new b(
-      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${V}`
+      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${w}`
     );
     throw this.dispose(), console.error(t), t;
   }
@@ -1059,14 +1103,14 @@ class le extends G {
    * @returns true if any dependency has changed or if it's the first run.
    */
   _shouldExecute() {
-    if (this._dependencies === h || this._dependencyVersions === _)
+    if (this._dependencies === u || this._dependencyVersions === _)
       return !0;
     for (let e = 0; e < this._dependencies.length; e++) {
       const t = this._dependencies[e];
       if (t) {
         if ("value" in t)
           try {
-            oe(() => t.value);
+            _e(() => t.value);
           } catch {
             return !0;
           }
@@ -1093,30 +1137,30 @@ class le extends G {
     }
   }
 }
-function Se(i, e = {}) {
+function ye(i, e = {}) {
   if (typeof i != "function")
-    throw new b(c.EFFECT_MUST_BE_FUNCTION);
-  const t = new le(i, e);
+    throw new b(h.EFFECT_MUST_BE_FUNCTION);
+  const t = new Ee(i, e);
   return t.execute(), t;
 }
 export {
-  T as AsyncState,
-  E as AtomError,
-  m as ComputedError,
-  B as DEBUG_CONFIG,
+  v as AsyncState,
+  p as AtomError,
+  N as ComputedError,
+  k as DEBUG_CONFIG,
   d as DEBUG_RUNTIME,
   b as EffectError,
-  ae as POOL_CONFIG,
+  pe as POOL_CONFIG,
   g as SCHEDULER_CONFIG,
-  U as SchedulerError,
-  Ee as atom,
-  fe as batch,
-  be as computed,
-  Se as effect,
-  ue as isAtom,
-  de as isComputed,
-  pe as isEffect,
-  R as scheduler,
-  oe as untracked
+  O as SchedulerError,
+  De as atom,
+  be as batch,
+  Ie as computed,
+  ye as effect,
+  ae as isAtom,
+  Se as isComputed,
+  ge as isEffect,
+  T as scheduler,
+  _e as untracked
 };
 //# sourceMappingURL=index.mjs.map