@but212/atom-effect 0.8.4 → 0.9.1

package/dist/index.mjs

@@ -1,7 +1,7 @@
 const Z = {
   /** One second in milliseconds */
   ONE_SECOND_MS: 1e3
-}, v = {
+}, P = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
@@ -31,7 +31,7 @@ const Z = {
   MAX_SIZE: 1e3,
   /** Number of objects to pre-allocate for performance-critical paths */
   WARMUP_SIZE: 100
-}, g = {
+}, D = {
   /** Maximum effect executions per second to detect infinite loops (Legacy/Fallback) */
   MAX_EXECUTIONS_PER_SECOND: 1e3,
   /** Threshold for cleaning up old execution timestamps */
@@ -50,24 +50,24 @@ const Z = {
   MAX_FLUSH_ITERATIONS: 1e3,
   /** Minimum allowed value for max flush iterations */
   MIN_FLUSH_ITERATIONS: 10
-}, k = {
+}, B = {
   /** Maximum dependencies before warning about large dependency graphs */
   MAX_DEPENDENCIES: 1e3,
   /** Enable infinite loop detection warnings */
   WARN_INFINITE_LOOP: !0
-}, I = 1073741823, a = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", ee = Object.freeze([]);
-class p extends Error {
+}, I = 1073741823, l = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", ee = Object.freeze([]);
+class b extends Error {
   /**
    * Creates a new AtomError
    * @param message - Error message describing what went wrong
    * @param cause - Original error that caused this error
    * @param recoverable - Whether the operation can be retried
    */
-  constructor(e, t = null, s = !0) {
-    super(e), this.name = "AtomError", this.cause = t, this.recoverable = s, this.timestamp = /* @__PURE__ */ new Date();
+  constructor(e, t = null, i = !0) {
+    super(e), this.name = "AtomError", this.cause = t, this.recoverable = i, this.timestamp = /* @__PURE__ */ new Date();
   }
 }
-class N extends p {
+class N extends b {
   /**
    * Creates a new ComputedError
    * @param message - Error message
@@ -77,7 +77,7 @@ class N extends p {
     super(e, t, !0), this.name = "ComputedError";
   }
 }
-class b extends p {
+class g extends b {
   /**
    * Creates a new EffectError
    * @param message - Error message
@@ -87,7 +87,7 @@ class b extends p {
     super(e, t, !1), this.name = "EffectError";
   }
 }
-class O extends p {
+class O extends b {
   /**
    * Creates a new SchedulerError
    * @param message - Error message
@@ -105,10 +105,6 @@ const h = {
    * 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.
    */
@@ -121,10 +117,6 @@ const h = {
    * Error thrown when an asynchronous computed computation fails.
    */
   COMPUTED_ASYNC_COMPUTATION_FAILED: "Async computed computation failed",
-  /**
-   * Error thrown when subscribing to a dependency fails.
-   */
-  COMPUTED_DEPENDENCY_SUBSCRIPTION_FAILED: "Failed to subscribe to dependency",
   // ─────────────────────────────────────────────────────────────────
   // Atom errors
   // ─────────────────────────────────────────────────────────────────
@@ -132,10 +124,6 @@ const h = {
    * 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.
@@ -156,79 +144,59 @@ const h = {
    * Error thrown when an effect's cleanup function fails.
    */
   EFFECT_CLEANUP_FAILED: "Effect cleanup function execution failed",
-  // ─────────────────────────────────────────────────────────────────
-  // 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"
-}, L = /* @__PURE__ */ Symbol("debugName"), te = /* @__PURE__ */ Symbol("id"), V = /* @__PURE__ */ Symbol("type"), q = /* @__PURE__ */ Symbol("noDefaultValue");
-function se(i) {
-  return "dependencies" in i && Array.isArray(i.dependencies);
+}, L = /* @__PURE__ */ Symbol("debugName"), te = /* @__PURE__ */ Symbol("id"), V = /* @__PURE__ */ Symbol("type"), j = /* @__PURE__ */ Symbol("noDefaultValue");
+function se(s) {
+  return "dependencies" in s && Array.isArray(s.dependencies);
 }
-let j = 0;
-function G(i, e, t) {
-  if (i._visitedEpoch !== t) {
-    if (i._visitedEpoch = t, i === e)
+let q = 0;
+function G(s, e, t) {
+  if (s._visitedEpoch !== t) {
+    if (s._visitedEpoch = t, s === e)
       throw new N("Indirect circular dependency detected");
-    if (se(i)) {
-      const s = i.dependencies;
-      for (let n = 0; n < s.length; n++) {
-        const r = s[n];
+    if (se(s)) {
+      const i = s.dependencies;
+      for (let n = 0; n < i.length; n++) {
+        const r = i[n];
         r && G(r, e, t);
       }
     }
   }
 }
-const d = {
+const E = {
   enabled: typeof process < "u" && process.env?.NODE_ENV === "development",
-  maxDependencies: k.MAX_DEPENDENCIES,
-  warnInfiniteLoop: k.WARN_INFINITE_LOOP,
-  warn(i, e) {
-    this.enabled && i && console.warn(`[Atom Effect] ${e}`);
+  maxDependencies: B.MAX_DEPENDENCIES,
+  warnInfiniteLoop: B.WARN_INFINITE_LOOP,
+  warn(s, e) {
+    this.enabled && s && 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(i, e) {
-    if (i === e)
+  checkCircular(s, e) {
+    if (s === e)
       throw new N("Direct circular dependency detected");
-    this.enabled && (j++, G(i, e, j));
+    this.enabled && (q++, G(s, e, q));
   },
-  attachDebugInfo(i, e, t) {
+  attachDebugInfo(s, e, t) {
     if (!this.enabled)
       return;
-    const s = i;
-    s[L] = `${e}_${t}`, s[te] = t, s[V] = e;
+    const i = s;
+    i[L] = `${e}_${t}`, i[te] = t, i[V] = e;
   },
-  getDebugName(i) {
-    if (i != null && L in i)
-      return i[L];
+  getDebugName(s) {
+    if (s != null && L in s)
+      return s[L];
   },
-  getDebugType(i) {
-    if (i != null && V in i)
-      return i[V];
+  getDebugType(s) {
+    if (s != null && V in s)
+      return s[V];
   }
 };
 let ie = 1;
@@ -238,7 +206,7 @@ class Y {
     this.id = ne() & I, this.flags = 0;
   }
 }
-class $ extends Y {
+class Q extends Y {
   constructor() {
     super(), this.version = 0, this._lastSeenEpoch = -1;
   }
@@ -253,7 +221,7 @@ class $ extends Y {
     if (typeof e == "object" && e !== null && "execute" in e)
       return this._objectSubscribers.add(e);
     if (typeof e != "function")
-      throw new p(h.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
+      throw new b(h.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
     return this._functionSubscribers.add(e);
   }
   /**
@@ -270,26 +238,26 @@ class $ extends Y {
    */
   _notifySubscribers(e, t) {
     this._functionSubscribers.forEachSafe(
-      (s) => s(e, t),
-      (s) => console.error(new p(h.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, s))
+      (i) => i(e, t),
+      (i) => console.error(new b(h.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, i))
     ), this._objectSubscribers.forEachSafe(
-      (s) => s.execute(),
-      (s) => console.error(new p(h.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, s))
+      (i) => i.execute(),
+      (i) => console.error(new b(h.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, i))
     );
   }
 }
-let U = 0;
-function H() {
-  return U = (U + 1 | 0) & I, U;
+let x = 0;
+function $() {
+  return x = x + 1 & I || 1, x;
 }
 function re() {
-  return U;
+  return x;
 }
-let x = 0, w = 0, F = !1;
+let U = 0, w = 0, F = !1;
 function z() {
-  return F ? (a && console.warn(
+  return F ? (l && console.warn(
     "Warning: startFlush() called during flush - ignored to prevent infinite loop detection bypass"
-  ), !1) : (F = !0, x = x + 1 & I, w = 0, !0);
+  ), !1) : (F = !0, U = U + 1 & I, w = 0, !0);
 }
 function X() {
   F = !1;
@@ -299,7 +267,7 @@ function oe() {
 }
 class ce {
   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;
+    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 = D.MAX_FLUSH_ITERATIONS;
   }
   get phase() {
     return this.isProcessing || this.isFlushingSync ? 2 : this.isBatching ? 1 : 0;
@@ -316,13 +284,15 @@ class ce {
     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() {
-    if (this.isProcessing || this.queueSize === 0) return;
-    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 = z();
-      this._processJobs(e, t), this.isProcessing = !1, s && X(), this.queueSize > 0 && !this.isBatching && this.flush();
-    });
+    this.isProcessing || this.queueSize === 0 || (this.isProcessing = !0, queueMicrotask(() => {
+      try {
+        if (this.queueSize === 0) return;
+        const e = z();
+        this._drainQueue(), e && X();
+      } finally {
+        this.isProcessing = !1, this.queueSize > 0 && !this.isBatching && this.flush();
+      }
+    }));
   }
   flushSync() {
     this.isFlushingSync = !0;
@@ -364,9 +334,9 @@ class ce {
     ), this.queueSize = 0, this.queue.length = 0, this.batchQueueSize = 0;
   }
   _processJobs(e, t) {
-    for (let s = 0; s < t; s++)
+    for (let i = 0; i < t; i++)
       try {
-        e[s]?.();
+        e[i]?.();
       } catch (n) {
         console.error(
           new O("Error occurred during scheduler execution", n)
@@ -390,29 +360,29 @@ class ce {
    * @param max - Maximum iterations count.
    */
   setMaxFlushIterations(e) {
-    if (e < g.MIN_FLUSH_ITERATIONS)
+    if (e < D.MIN_FLUSH_ITERATIONS)
       throw new O(
-        `Max flush iterations must be at least ${g.MIN_FLUSH_ITERATIONS}`
+        `Max flush iterations must be at least ${D.MIN_FLUSH_ITERATIONS}`
       );
     this.maxFlushIterations = e;
   }
 }
 const T = new ce();
-function Se(i) {
-  if (typeof i != "function")
-    throw new p("Batch callback must be a function");
+function Se(s) {
+  if (typeof s != "function")
+    throw new b("Batch callback must be a function");
   T.startBatch();
   try {
-    return i();
+    return s();
   } finally {
     T.endBatch();
   }
 }
-const y = {
+const m = {
   current: null,
-  run(i, e) {
+  run(s, e) {
     const t = this.current;
-    this.current = i;
+    this.current = s;
     try {
       return e();
     } finally {
@@ -423,18 +393,18 @@ const y = {
     return this.current;
   }
 };
-function he(i) {
-  if (typeof i != "function")
-    throw new p("Untracked callback must be a function");
-  const e = y.current;
-  y.current = null;
+function he(s) {
+  if (typeof s != "function")
+    throw new b("Untracked callback must be a function");
+  const e = m.current;
+  m.current = null;
   try {
-    return i();
+    return s();
   } finally {
-    y.current = e;
+    m.current = e;
   }
 }
-class P {
+class v {
   constructor() {
     this.subscribers = null;
   }
@@ -456,8 +426,8 @@ class P {
     const t = this.subscribers.indexOf(e);
     if (t === -1)
       return !1;
-    const s = this.subscribers.length - 1;
-    return t !== s && (this.subscribers[t] = this.subscribers[s]), this.subscribers.pop(), !0;
+    const i = this.subscribers.length - 1;
+    return t !== i && (this.subscribers[t] = this.subscribers[i]), this.subscribers.pop(), !0;
   }
   has(e) {
     return this.subscribers ? this.subscribers.indexOf(e) !== -1 : !1;
@@ -470,9 +440,9 @@ class P {
   /** Iterates with error handling to prevent one failure from breaking the chain */
   forEachSafe(e, t) {
     if (this.subscribers)
-      for (let s = 0; s < this.subscribers.length; s++)
+      for (let i = 0; i < this.subscribers.length; i++)
         try {
-          e(this.subscribers[s], s);
+          e(this.subscribers[i], i);
         } catch (n) {
           t ? t(n) : console.error("[SubscriberManager] Error in subscriber callback:", n);
         }
@@ -490,9 +460,9 @@ class P {
     return this.subscribers ? [...this.subscribers] : [];
   }
 }
-class B {
+class k {
   constructor() {
-    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = a ? {
+    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = l ? {
       acquired: 0,
       released: 0,
       rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
@@ -500,7 +470,7 @@ class B {
   }
   /** Acquires an array from the pool or creates a new one if the pool is empty. */
   acquire() {
-    return a && this.stats && this.stats.acquired++, this.pool.pop() ?? [];
+    return l && this.stats && this.stats.acquired++, this.pool.pop() ?? [];
   }
   /**
    * Releases an array back to the pool.
@@ -511,102 +481,102 @@ class B {
   release(e, t) {
     if (!(t && e === t)) {
       if (Object.isFrozen(e)) {
-        a && this.stats && this.stats.rejected.frozen++;
+        l && this.stats && this.stats.rejected.frozen++;
         return;
       }
       if (e.length > this.maxReusableCapacity) {
-        a && this.stats && this.stats.rejected.tooLarge++;
+        l && this.stats && this.stats.rejected.tooLarge++;
         return;
       }
       if (this.pool.length >= this.maxPoolSize) {
-        a && this.stats && this.stats.rejected.poolFull++;
+        l && this.stats && this.stats.rejected.poolFull++;
         return;
       }
-      e.length = 0, this.pool.push(e), a && this.stats && this.stats.released++;
+      e.length = 0, this.pool.push(e), l && this.stats && this.stats.released++;
     }
   }
   /** Returns current stats for the pool (dev mode only). */
   getStats() {
-    if (!a || !this.stats) return null;
-    const { acquired: e, released: t, rejected: s } = this.stats, n = s.frozen + s.tooLarge + s.poolFull;
+    if (!l || !this.stats) return null;
+    const { acquired: e, released: t, rejected: i } = this.stats, n = i.frozen + i.tooLarge + i.poolFull;
     return {
       acquired: e,
       released: t,
-      rejected: s,
+      rejected: i,
       leaked: e - t - n,
       poolSize: this.pool.length
     };
   }
   /** Resets the pool and its stats. */
   reset() {
-    this.pool.length = 0, a && this.stats && (this.stats.acquired = 0, this.stats.released = 0, this.stats.rejected = { frozen: 0, tooLarge: 0, poolFull: 0 });
+    this.pool.length = 0, l && this.stats && (this.stats.acquired = 0, this.stats.released = 0, this.stats.rejected = { frozen: 0, tooLarge: 0, poolFull: 0 });
   }
 }
-const u = Object.freeze([]), l = Object.freeze([]), _ = Object.freeze([]), S = new B(), D = new B(), f = new B();
-function ue(i) {
-  return i !== null && typeof i == "object" && "value" in i && "subscribe" in i && typeof i.subscribe == "function";
+const u = Object.freeze([]), f = Object.freeze([]), a = Object.freeze([]), S = new k(), y = new k(), d = new k();
+function ue(s) {
+  return s !== null && typeof s == "object" && "value" in s && "subscribe" in s && typeof s.subscribe == "function";
 }
-function ge(i) {
-  if (d.enabled && (i == null || typeof i == "object")) {
-    const e = d.getDebugType(i);
+function ge(s) {
+  if (E.enabled && (s == null || typeof s == "object")) {
+    const e = E.getDebugType(s);
     if (e)
       return e === "computed";
   }
-  return ue(i) && "invalidate" in i && typeof i.invalidate == "function";
+  return ue(s) && "invalidate" in s && typeof s.invalidate == "function";
 }
-function De(i) {
-  return i !== null && typeof i == "object" && "dispose" in i && "run" in i && typeof i.dispose == "function" && typeof i.run == "function";
+function De(s) {
+  return s !== null && typeof s == "object" && "dispose" in s && "run" in s && typeof s.dispose == "function" && typeof s.run == "function";
 }
-function J(i) {
-  return i != null && typeof i.then == "function";
+function H(s) {
+  return s != null && typeof s.then == "function";
 }
-function _e(i) {
-  return typeof i == "object" && i !== null;
+function ae(s) {
+  return typeof s == "object" && s !== null;
 }
-function ae(i) {
-  return (typeof i == "object" || typeof i == "function") && i !== null && typeof i.addDependency == "function";
+function _e(s) {
+  return (typeof s == "object" || typeof s == "function") && s !== null && typeof s.addDependency == "function";
 }
-function le(i) {
-  return typeof i == "function" && typeof i.addDependency != "function";
+function le(s) {
+  return typeof s == "function" && typeof s.addDependency != "function";
 }
-function fe(i) {
-  return _e(i) && typeof i.execute == "function";
+function fe(s) {
+  return ae(s) && typeof s.execute == "function";
 }
-function Q(i, e, t, s) {
+function J(s, e, t, i) {
   if (e) {
-    if (ae(e)) {
-      e.addDependency(i);
+    if (_e(e)) {
+      e.addDependency(s);
       return;
     }
     if (le(e)) {
       t.add(e);
       return;
     }
-    fe(e) && s.add(e);
+    fe(e) && i.add(e);
   }
 }
-function de(i, e, t, s) {
-  if (e !== u && t !== l)
+function de(s, e, t, i) {
+  if (e !== u && t !== f)
     for (let r = 0; r < e.length; r++) {
       const o = e[r];
       o && (o._tempUnsub = t[r]);
     }
-  const n = D.acquire();
-  n.length = i.length;
-  for (let r = 0; r < i.length; r++) {
-    const o = i[r];
-    o && (o._tempUnsub ? (n[r] = o._tempUnsub, o._tempUnsub = void 0) : (d.checkCircular(o, s), n[r] = o.subscribe(s)));
+  const n = y.acquire();
+  n.length = s.length;
+  for (let r = 0; r < s.length; r++) {
+    const o = s[r];
+    o && (o._tempUnsub ? (n[r] = o._tempUnsub, o._tempUnsub = void 0) : (E.checkCircular(o, i), n[r] = o.subscribe(i)));
   }
   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 !== l && D.release(t), n;
+  return t !== f && y.release(t), n;
 }
-class Ee extends $ {
+class Ee extends Q {
   constructor(e, t) {
-    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);
+    super(), this._isNotificationScheduled = !1, this._value = e, this._functionSubscribersStore = new v(), this._objectSubscribersStore = new v(), this._sync = t, this._notifyTask = this._flushNotifications.bind(this), E.attachDebugInfo(this, "atom", this.id);
   }
   /** Gets the manager for function-based subscribers. */
   get _functionSubscribers() {
@@ -620,7 +590,7 @@ class Ee extends $ {
    * Returns the current value and registers the atom as a dependency in the current tracking context.
    */
   get value() {
-    const e = y.getCurrent();
+    const e = m.getCurrent();
     return e && this._track(e), this._value;
   }
   /**
@@ -633,7 +603,7 @@ class Ee extends $ {
     this.version = this.version + 1 & I, this._value = e, !(!this._functionSubscribersStore.hasSubscribers && !this._objectSubscribersStore.hasSubscribers) && this._scheduleNotification(t);
   }
   _track(e) {
-    Q(this, e, this._functionSubscribersStore, this._objectSubscribersStore);
+    J(this, e, this._functionSubscribersStore, this._objectSubscribersStore);
   }
   _scheduleNotification(e) {
     this._isNotificationScheduled || (this._pendingOldValue = e, this._isNotificationScheduled = !0), this._sync && !T.isBatching ? this._flushNotifications() : T.schedule(this._notifyTask);
@@ -656,41 +626,41 @@ class Ee extends $ {
     this._functionSubscribersStore.clear(), this._objectSubscribersStore.clear(), this._value = void 0;
   }
 }
-function Ie(i, e = {}) {
-  return new Ee(i, e.sync ?? !1);
+function ye(s, e = {}) {
+  return new Ee(s, e.sync ?? !1);
 }
-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 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);
+function R(s, e, t) {
+  if (s instanceof TypeError)
+    return new e(`Type error (${t}): ${s.message}`, s);
+  if (s instanceof ReferenceError)
+    return new e(`Reference error (${t}): ${s.message}`, s);
+  if (s instanceof b)
+    return s;
+  const i = s instanceof Error ? s.message : String(s), n = s instanceof Error ? s : null;
+  return new e(`Unexpected error (${t}): ${i}`, n);
 }
-const W = c.RESOLVED | c.PENDING | c.REJECTED, M = Array(W + 1).fill(v.IDLE);
-M[c.RESOLVED] = v.RESOLVED;
-M[c.PENDING] = v.PENDING;
-M[c.REJECTED] = v.REJECTED;
-class K extends $ {
+const W = c.RESOLVED | c.PENDING | c.REJECTED, M = Array(W + 1).fill(P.IDLE);
+M[c.RESOLVED] = P.RESOLVED;
+M[c.PENDING] = P.PENDING;
+M[c.REJECTED] = P.REJECTED;
+class K extends Q {
   constructor(e, t = {}) {
     if (typeof e != "function")
       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 = () => {
+    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 : j, this._hasDefaultValue = this._defaultValue !== j, this._onError = t.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._functionSubscribersStore = new v(), this._objectSubscribersStore = new v(), this._dependencies = u, this._dependencyVersions = a, this._unsubscribes = f, this._notifyJob = () => {
       this._functionSubscribersStore.forEachSafe(
-        (s) => s(),
-        (s) => console.error(s)
+        (i) => i(),
+        (i) => console.error(i)
       ), this._objectSubscribersStore.forEachSafe(
-        (s) => s.execute(),
-        (s) => console.error(s)
+        (i) => i.execute(),
+        (i) => console.error(i)
       );
     }, this._trackable = Object.assign(() => this._markDirty(), {
-      addDependency: (s) => {
+      addDependency: (i) => {
       }
-    }), d.attachDebugInfo(this, "computed", this.id), d.enabled) {
-      const s = this;
-      s.subscriberCount = () => this._functionSubscribersStore.size + this._objectSubscribersStore.size, s.isDirty = () => this._isDirty(), s.dependencies = this._dependencies, s.stateFlags = this._getFlagsAsString();
+    }), E.attachDebugInfo(this, "computed", this.id), E.enabled) {
+      const i = this;
+      i.subscriberCount = () => this._functionSubscribersStore.size + this._objectSubscribersStore.size, i.isDirty = () => this._isDirty(), i.dependencies = this._dependencies, i.stateFlags = this._getFlagsAsString();
     }
     if (t.lazy === !1)
       try {
@@ -734,13 +704,13 @@ class K extends $ {
       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];
+    for (let i = 0; i < this._dependencies.length; i++) {
+      const n = this._dependencies[i];
       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);
+          const _ = r[o];
+          _ && t.add(_);
         }
       }
     }
@@ -756,17 +726,17 @@ class K extends $ {
     return this._registerTracking(), this._isResolved();
   }
   invalidate() {
-    this._markDirty(), this._dependencyVersions !== _ && (f.release(this._dependencyVersions), this._dependencyVersions = _), this._errorCacheEpoch = -1, this._cachedErrors = null;
+    this._markDirty(), this._dependencyVersions !== a && (d.release(this._dependencyVersions), this._dependencyVersions = a), this._errorCacheEpoch = -1, this._cachedErrors = null;
   }
   dispose() {
-    if (this._unsubscribes !== l) {
+    if (this._unsubscribes !== f) {
       for (let e = 0; e < this._unsubscribes.length; e++) {
         const t = this._unsubscribes[e];
         t && t();
       }
-      D.release(this._unsubscribes), this._unsubscribes = l;
+      y.release(this._unsubscribes), this._unsubscribes = f;
     }
-    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;
+    this._dependencies !== u && (S.release(this._dependencies), this._dependencies = u), this._dependencyVersions !== a && (d.release(this._dependencyVersions), this._dependencyVersions = a), 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() {
@@ -825,32 +795,32 @@ class K extends $ {
     const e = this._prepareComputationContext();
     let t = !1;
     try {
-      const s = y.run(this._trackable, this._fn);
-      this._commitDependencies(e), t = !0, J(s) ? this._handleAsyncComputation(s) : this._handleSyncResult(s);
-    } catch (s) {
+      const i = m.run(this._trackable, this._fn);
+      this._commitDependencies(e), t = !0, H(i) ? this._handleAsyncComputation(i) : this._handleSyncResult(i);
+    } catch (i) {
       if (!t)
         try {
           this._commitDependencies(e), t = !0;
         } catch (n) {
           this._handleComputationError(n);
         }
-      this._handleComputationError(s);
+      this._handleComputationError(i);
     } 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 }, 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++);
+    const e = this._dependencies, t = this._dependencyVersions, i = S.acquire(), n = d.acquire(), r = $(), o = { depCount: 0 }, _ = (p) => {
+      p._lastSeenEpoch !== r && (p._lastSeenEpoch = r, o.depCount < i.length ? (i[o.depCount] = p, n[o.depCount] = p.version) : (i.push(p), n.push(p.version)), o.depCount++);
     }, C = this._trackable.addDependency;
-    return this._trackable.addDependency = m, { prevDeps: e, prevVersions: t, nextDeps: s, nextVersions: n, originalAdd: C, state: o };
+    return this._trackable.addDependency = _, { prevDeps: e, prevVersions: t, nextDeps: i, 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 = de(t, r, this._unsubscribes, this), this._dependencies = t, this._dependencyVersions = s;
+    const { nextDeps: t, nextVersions: i, state: n, prevDeps: r } = e;
+    t.length = n.depCount, i.length = n.depCount, this._unsubscribes = de(t, r, this._unsubscribes, this), this._dependencies = t, this._dependencyVersions = i;
   }
   _cleanupContext(e, t) {
-    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));
+    this._trackable.addDependency = e.originalAdd, t ? (e.prevDeps !== u && S.release(e.prevDeps), e.prevVersions !== a && d.release(e.prevVersions)) : (S.release(e.nextDeps), d.release(e.nextVersions));
   }
   _handleSyncResult(e) {
     const t = !this._isResolved() || !this._equal(this._value, e);
@@ -859,10 +829,10 @@ class K extends $ {
   _handleAsyncComputation(e) {
     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);
-    }).catch((s) => {
-      t === this._promiseId && this._handleAsyncRejection(s);
+    e.then((i) => {
+      t === this._promiseId && this._handleAsyncResolution(i);
+    }).catch((i) => {
+      t === this._promiseId && this._handleAsyncRejection(i);
     });
   }
   _handleAsyncResolution(e) {
@@ -870,8 +840,8 @@ class K extends $ {
     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 = 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)
+    const t = R(e, N, h.COMPUTED_ASYNC_COMPUTATION_FAILED), i = !this._isRejected();
+    if (this.version = this.version + Number(i) & I, this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
       try {
         this._onError(t);
       } catch (n) {
@@ -884,8 +854,8 @@ class K extends $ {
     if (this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
       try {
         this._onError(t);
-      } catch (s) {
-        console.error(h.CALLBACK_ERROR_IN_ERROR_HANDLER, s);
+      } catch (i) {
+        console.error(h.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
       }
     throw t;
   }
@@ -907,17 +877,17 @@ class K extends $ {
     this._isRecomputing() || this._isDirty() || (this._setDirty(), this._notifyJob());
   }
   _registerTracking() {
-    Q(
+    J(
       this,
-      y.getCurrent(),
+      m.getCurrent(),
       this._functionSubscribersStore,
       this._objectSubscribersStore
     );
   }
 }
 Object.freeze(K.prototype);
-function ye(i, e = {}) {
-  return new K(i, e);
+function Ie(s, e = {}) {
+  return new K(s, e);
 }
 class pe extends Y {
   /**
@@ -928,56 +898,58 @@ class pe extends Y {
   constructor(e, t = {}) {
     super(), this.run = () => {
       if (this.isDisposed)
-        throw new b(h.EFFECT_MUST_BE_FUNCTION);
-      this._dependencyVersions !== _ && (f.release(this._dependencyVersions), this._dependencyVersions = _), this.execute();
+        throw new g(h.EFFECT_MUST_BE_FUNCTION);
+      this._dependencyVersions !== a && (d.release(this._dependencyVersions), this._dependencyVersions = a), this.execute();
     }, this.dispose = () => {
       if (!this.isDisposed) {
-        if (this._setDisposed(), this._safeCleanup(), this._unsubscribes !== l) {
-          for (let s = 0; s < this._unsubscribes.length; s++) {
-            const n = this._unsubscribes[s];
-            n && n();
+        if (this._setDisposed(), this._safeCleanup(), this._unsubscribes !== f) {
+          for (let n = 0; n < this._unsubscribes.length; n++) {
+            const r = this._unsubscribes[n];
+            r && r();
           }
-          D.release(this._unsubscribes), this._unsubscribes = l;
+          y.release(this._unsubscribes), this._unsubscribes = f;
         }
-        this._dependencies !== u && (S.release(this._dependencies), this._dependencies = u), this._dependencyVersions !== _ && (f.release(this._dependencyVersions), this._dependencyVersions = _);
+        this._dependencies !== u && (S.release(this._dependencies), this._dependencies = u), this._dependencyVersions !== a && (d.release(this._dependencyVersions), this._dependencyVersions = a);
       }
-    }, this.addDependency = (s) => {
+    }, this.addDependency = (n) => {
       if (this.isExecuting && this._nextDeps && this._nextUnsubs && this._nextVersions) {
-        const n = this._currentEpoch;
-        if (s._lastSeenEpoch === n) return;
-        s._lastSeenEpoch = n, this._nextDeps.push(s), this._nextVersions.push(s.version), s._tempUnsub ? (this._nextUnsubs.push(s._tempUnsub), s._tempUnsub = void 0) : this._subscribeTo(s);
+        const r = this._currentEpoch;
+        if (n._lastSeenEpoch === r) return;
+        n._lastSeenEpoch = r, this._nextDeps.push(n), this._nextVersions.push(n.version), n._tempUnsub ? (this._nextUnsubs.push(n._tempUnsub), n._tempUnsub = void 0) : this._subscribeTo(n);
       }
     }, this.execute = () => {
       if (this.isDisposed || this.isExecuting || !this._shouldExecute()) return;
       this._checkInfiniteLoop(), this._setExecuting(!0), this._safeCleanup();
-      const s = this._prepareEffectContext();
-      let n = !1;
+      const n = this._prepareEffectContext();
+      let r = !1;
       try {
-        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(R(o, b, h.EFFECT_EXECUTION_FAILED));
-        }) : this._cleanup = typeof r == "function" ? r : null;
-      } catch (r) {
-        n = !0, console.error(R(r, b, h.EFFECT_EXECUTION_FAILED)), this._cleanup = null;
+        const o = m.run(this, this._fn);
+        this._commitEffect(n), r = !0, this._checkLoopWarnings(), H(o) ? o.then((_) => {
+          !this.isDisposed && typeof _ == "function" && (this._cleanup = _);
+        }).catch((_) => {
+          this._handleExecutionError(_);
+        }) : this._cleanup = typeof o == "function" ? o : null;
+      } catch (o) {
+        r = !0, this._handleExecutionError(o), this._cleanup = null;
       } finally {
-        this._cleanupEffect(s, n), this._setExecuting(!1);
+        this._cleanupEffect(n, r), 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 = 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);
+    }, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._fn = e, this._sync = t.sync ?? !1, this._maxExecutions = t.maxExecutionsPerSecond ?? D.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = t.maxExecutionsPerFlush ?? D.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = t.trackModifications ?? !1, this._cleanup = null, this._dependencies = u, this._dependencyVersions = a, this._unsubscribes = f, this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, this._onError = t.onError ?? null, this._historyPtr = 0;
+    const i = Number.isFinite(this._maxExecutions);
+    this._historyCapacity = i ? Math.min(this._maxExecutions + 1, D.MAX_EXECUTIONS_PER_SECOND + 1) : 0, this._history = l && i && this._historyCapacity > 0 ? new Array(this._historyCapacity).fill(0) : null, this._executionCount = 0, E.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(), m = H();
-    if (e !== u && s !== l)
+    const e = this._dependencies, t = this._dependencyVersions, i = this._unsubscribes, n = S.acquire(), r = d.acquire(), o = y.acquire(), _ = $();
+    if (e !== u && i !== f)
       for (let C = 0; C < e.length; C++) {
-        const E = e[C];
-        E && (E._tempUnsub = s[C]);
+        const p = e[C];
+        p && (p._tempUnsub = i[C]);
       }
-    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 };
+    return this._nextDeps = n, this._nextVersions = r, this._nextUnsubs = o, this._currentEpoch = _, { prevDeps: e, prevVersions: t, prevUnsubs: i, nextDeps: n, nextVersions: r, nextUnsubs: o };
   }
   /**
    * Commits the tracked dependencies as the current active dependencies.
@@ -995,20 +967,20 @@ class pe extends Y {
   _cleanupEffect(e, t) {
     if (this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, t) {
       if (e.prevDeps !== u) {
-        for (let s = 0; s < e.prevDeps.length; s++) {
-          const n = e.prevDeps[s];
+        for (let i = 0; i < e.prevDeps.length; i++) {
+          const n = e.prevDeps[i];
           n?._tempUnsub && (n._tempUnsub(), n._tempUnsub = void 0);
         }
         S.release(e.prevDeps);
       }
-      e.prevUnsubs !== l && D.release(e.prevUnsubs), e.prevVersions !== _ && f.release(e.prevVersions);
+      e.prevUnsubs !== f && y.release(e.prevUnsubs), e.prevVersions !== a && d.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 !== u)
-        for (let s = 0; s < e.prevDeps.length; s++) {
-          const n = e.prevDeps[s];
+      S.release(e.nextDeps), d.release(e.nextVersions);
+      for (let i = 0; i < e.nextUnsubs.length; i++)
+        e.nextUnsubs[i]?.();
+      if (y.release(e.nextUnsubs), e.prevDeps !== u)
+        for (let i = 0; i < e.prevDeps.length; i++) {
+          const n = e.prevDeps[i];
           n && (n._tempUnsub = void 0);
         }
     }
@@ -1024,7 +996,7 @@ class pe extends Y {
       });
       this._nextUnsubs && this._nextUnsubs.push(t);
     } catch (t) {
-      console.error(R(t, b, h.EFFECT_EXECUTION_FAILED)), this._nextUnsubs && this._nextUnsubs.push(() => {
+      console.error(R(t, g, h.EFFECT_EXECUTION_FAILED)), this._nextUnsubs && this._nextUnsubs.push(() => {
       });
     }
   }
@@ -1061,7 +1033,7 @@ class pe extends Y {
       try {
         this._cleanup();
       } catch (e) {
-        console.error(R(e, b, h.EFFECT_CLEANUP_FAILED));
+        console.error(R(e, g, h.EFFECT_CLEANUP_FAILED));
       }
       this._cleanup = null;
     }
@@ -1071,28 +1043,21 @@ class pe extends Y {
    * @throws {EffectError} If an infinite loop is detected.
    */
   _checkInfiniteLoop() {
-    if (this._lastFlushEpoch !== x && (this._lastFlushEpoch = x, this._executionsInEpoch = 0), this._executionsInEpoch++, this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), oe() > 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);
-    }
-  }
-  _checkTimestampLoop(e) {
-    const t = this._history;
-    if (!t || this._maxExecutions <= 0) return;
-    const s = e - Z.ONE_SECOND_MS;
-    let n = 0;
-    for (let r = t.length - 1; r >= 0 && !(t[r] < s); r--)
-      n++;
-    if (n > this._maxExecutions) {
-      const r = new b(
-        `Effect executed ${n} times within 1 second. Infinite loop suspected`
-      );
-      if (this.dispose(), console.error(r), a)
-        throw r;
+    if (this._lastFlushEpoch !== U && (this._lastFlushEpoch = U, this._executionsInEpoch = 0), this._executionsInEpoch++, this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), oe() > D.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history && this._maxExecutions > 0) {
+      const e = Date.now(), t = this._historyPtr, i = this._historyCapacity;
+      this._history[t] = e;
+      const n = (t + 1) % i, r = this._history[n] ?? 0;
+      if (this._historyPtr = n, r > 0 && e - r < Z.ONE_SECOND_MS) {
+        const o = new g(
+          `Effect executed ${i} times within 1 second. Infinite loop suspected`
+        );
+        if (this.dispose(), console.error(o), this._onError && this._onError(o), l)
+          throw o;
+      }
     }
   }
   _throwInfiniteLoopError(e) {
-    const t = new b(
+    const t = new g(
       `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${w}`
     );
     throw this.dispose(), console.error(t), t;
@@ -1102,7 +1067,7 @@ class pe extends Y {
    * @returns true if any dependency has changed or if it's the first run.
    */
   _shouldExecute() {
-    if (this._dependencies === u || this._dependencyVersions === _)
+    if (this._dependencies === u || this._dependencyVersions === a)
       return !0;
     for (let e = 0; e < this._dependencies.length; e++) {
       const t = this._dependencies[e];
@@ -1119,42 +1084,50 @@ class pe extends Y {
     }
     return !1;
   }
+  /**
+   * Handles errors occurring during effect execution.
+   * Wraps the error, logs it to console, and calls onError callback if provided.
+   */
+  _handleExecutionError(e) {
+    const t = R(e, g, h.EFFECT_EXECUTION_FAILED);
+    console.error(t), this._onError && this._onError(t);
+  }
   /**
    * Checks for potential infinite loops where an effect modifies its own dependencies.
    * Only active if trackModifications is enabled and debug is on.
    */
   _checkLoopWarnings() {
-    if (this._trackModifications && d.enabled) {
+    if (this._trackModifications && E.enabled) {
       const e = this._dependencies;
       for (let t = 0; t < e.length; t++) {
-        const s = e[t];
-        s && s._modifiedAtEpoch === this._currentEpoch && d.warn(
+        const i = e[t];
+        i && i._modifiedAtEpoch === this._currentEpoch && E.warn(
           !0,
-          `Effect is reading a dependency (${d.getDebugName(s) || "unknown"}) that it just modified. Infinite loop may occur`
+          `Effect is reading a dependency (${E.getDebugName(i) || "unknown"}) that it just modified. Infinite loop may occur`
         );
       }
     }
   }
 }
-function me(i, e = {}) {
-  if (typeof i != "function")
-    throw new b(h.EFFECT_MUST_BE_FUNCTION);
-  const t = new pe(i, e);
+function me(s, e = {}) {
+  if (typeof s != "function")
+    throw new g(h.EFFECT_MUST_BE_FUNCTION);
+  const t = new pe(s, e);
   return t.execute(), t;
 }
 export {
-  v as AsyncState,
-  p as AtomError,
+  P as AsyncState,
+  b as AtomError,
   N as ComputedError,
-  k as DEBUG_CONFIG,
-  d as DEBUG_RUNTIME,
-  b as EffectError,
+  B as DEBUG_CONFIG,
+  E as DEBUG_RUNTIME,
+  g as EffectError,
   be as POOL_CONFIG,
-  g as SCHEDULER_CONFIG,
+  D as SCHEDULER_CONFIG,
   O as SchedulerError,
-  Ie as atom,
+  ye as atom,
   Se as batch,
-  ye as computed,
+  Ie as computed,
   me as effect,
   ue as isAtom,
   ge as isComputed,