@but212/atom-effect 0.3.3 → 0.4.0

package/dist/index.mjs

@@ -1,9 +1,12 @@
-const O = {
+const ie = {
+  /** One second in milliseconds */
+  ONE_SECOND_MS: 1e3
+}, F = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
   REJECTED: "rejected"
-}, F = {
+}, P = {
   DISPOSED: 1,
   // 0001 - Effect has been disposed
   EXECUTING: 2
@@ -23,12 +26,12 @@ const O = {
   // 100000 - Currently recomputing
   HAS_ERROR: 64
   // 1000000 - Has error state
-}, le = {
+}, Ee = {
   /** 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
-}, P = {
+}, y = {
   /** Maximum effect executions per second to detect infinite loops (Legacy/Fallback) */
   MAX_EXECUTIONS_PER_SECOND: 100,
   /** Threshold for cleaning up old execution timestamps */
@@ -42,13 +45,17 @@ const O = {
    * Maximum total executions across all effects in a single flush cycle
    * Increased from 1000 to 5000 based on evaluation report
    */
-  MAX_EXECUTIONS_PER_FLUSH: 5e3
-}, j = {
+  MAX_EXECUTIONS_PER_FLUSH: 5e3,
+  /** Maximum iterations for synchronous flush loop to prevent infinite loops */
+  MAX_FLUSH_ITERATIONS: 1e3,
+  /** Minimum allowed value for max flush iterations */
+  MIN_FLUSH_ITERATIONS: 10
+}, z = {
   /** Maximum dependencies before warning about large dependency graphs */
   MAX_DEPENDENCIES: 1e3,
   /** Enable infinite loop detection warnings */
   WARN_INFINITE_LOOP: !0
-}, T = 1073741823, d = typeof process < "u" && process.env && process.env.NODE_ENV !== "production";
+}, A = 1073741823, d = typeof process < "u" && process.env && process.env.NODE_ENV !== "production";
 class E extends Error {
   /**
    * Creates a new AtomError
@@ -56,11 +63,11 @@ class E extends Error {
    * @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 C extends E {
+class T extends E {
   /**
    * Creates a new ComputedError
    * @param message - Error message
@@ -80,7 +87,7 @@ class g extends E {
     super(e, t, !1), this.name = "EffectError";
   }
 }
-class A extends E {
+class x extends E {
   /**
    * Creates a new SchedulerError
    * @param message - Error message
@@ -90,18 +97,18 @@ class A extends E {
     super(e, t, !1), this.name = "SchedulerError";
   }
 }
-function N(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)
-    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 C(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 E)
+    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);
 }
-function Q(i) {
-  return i != null && typeof i.then == "function";
+function Y(s) {
+  return s != null && typeof s.then == "function";
 }
 const l = {
   // ─────────────────────────────────────────────────────────────────
@@ -177,7 +184,7 @@ const l = {
    * // Output: "Large dependency graph detected: 150 dependencies"
    * ```
    */
-  LARGE_DEPENDENCY_GRAPH: (i) => `Large dependency graph detected: ${i} dependencies`,
+  LARGE_DEPENDENCY_GRAPH: (s) => `Large dependency graph detected: ${s} dependencies`,
   /**
    * Warning logged when attempting to unsubscribe a non-existent listener.
    */
@@ -187,60 +194,61 @@ const l = {
    * @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"), ee = /* @__PURE__ */ Symbol("id"), V = /* @__PURE__ */ Symbol("type"), X = /* @__PURE__ */ Symbol("noDefaultValue");
-function te(i) {
-  return i !== null && typeof i == "object" && "dependencies" in i && Array.isArray(i.dependencies);
+}, w = /* @__PURE__ */ Symbol("debugName"), ne = /* @__PURE__ */ Symbol("id"), V = /* @__PURE__ */ Symbol("type"), X = /* @__PURE__ */ Symbol("noDefaultValue");
+function re(s) {
+  return "dependencies" in s && Array.isArray(s.dependencies);
 }
 let G = 0;
-function H(i, e, t) {
-  const s = i;
+function Q(s, e, t) {
   if (s._visitedEpoch !== t) {
-    if (s._visitedEpoch = t, i === e)
-      throw new C("Indirect circular dependency detected");
-    if (te(i)) {
-      const n = i.dependencies;
-      for (let r = 0; r < n.length; r++)
-        H(n[r], e, t);
+    if (s._visitedEpoch = t, s === e)
+      throw new T("Indirect circular dependency detected");
+    if (re(s)) {
+      const i = s.dependencies;
+      for (let n = 0; n < i.length; n++) {
+        const r = i[n];
+        r && Q(r, e, t);
+      }
     }
   }
 }
 const S = {
   enabled: typeof process < "u" && process.env?.NODE_ENV === "development",
-  maxDependencies: j.MAX_DEPENDENCIES,
-  warnInfiniteLoop: j.WARN_INFINITE_LOOP,
-  warn(i, e) {
-    this.enabled && i && console.warn(`[Atom Effect] ${e}`);
+  maxDependencies: z.MAX_DEPENDENCIES,
+  warnInfiniteLoop: z.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, t) {
-    if (i === e)
-      throw new C("Direct circular dependency detected");
-    this.enabled && (G++, H(i, e, G));
+  checkCircular(s, e) {
+    if (s === e)
+      throw new T("Direct circular dependency detected");
+    this.enabled && (G++, Q(s, e, G));
   },
-  attachDebugInfo(i, e, t) {
+  attachDebugInfo(s, e, t) {
     if (!this.enabled)
       return;
-    const s = i;
-    s[w] = `${e}_${t}`, s[ee] = t, s[V] = e;
+    const i = s;
+    i[w] = `${e}_${t}`, i[ne] = t, i[V] = e;
   },
-  getDebugName(i) {
-    if (i !== null && typeof i == "object" && w in i)
-      return i[w];
+  getDebugName(s) {
+    if (s != null && w in s)
+      return s[w];
   },
-  getDebugType(i) {
-    if (i !== null && typeof i == "object" && V in i)
-      return i[V];
+  getDebugType(s) {
+    if (s != null && V in s)
+      return s[V];
   }
 };
-let se = 1;
-const ie = () => se++;
+let ce = 1;
+const ue = () => ce++;
 class J {
   constructor() {
-    this.id = ie() & T, this.flags = 0;
+    this.id = ue() & A, this.flags = 0;
   }
 }
 class W extends J {
@@ -275,40 +283,40 @@ class W extends J {
    */
   _notifySubscribers(e, t) {
     this._functionSubscribers.forEachSafe(
-      (s) => s(e, t),
-      (s) => console.error(new E(l.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, s))
+      (i) => i(e, t),
+      (i) => console.error(new E(l.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, i))
     ), this._objectSubscribers.forEachSafe(
-      (s) => s.execute(),
-      (s) => console.error(new E(l.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, s))
+      (i) => i.execute(),
+      (i) => console.error(new E(l.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, i))
     );
   }
 }
 let B = 0;
 function K() {
-  return B = (B + 1 | 0) & T, B;
+  return B = (B + 1 | 0) & A, B;
 }
-let v = 0, k = 0, L = !1;
-function Y() {
+let M = 0, k = 0, L = !1;
+function $() {
   return L ? (d && console.warn(
     "Warning: startFlush() called during flush - ignored to prevent infinite loop detection bypass"
-  ), !1) : (L = !0, v = v + 1 & T, k = 0, !0);
+  ), !1) : (L = !0, M = M + 1 & A, k = 0, !0);
 }
-function $() {
+function H() {
   L = !1;
 }
-function ne() {
+function oe() {
   return L ? ++k : 0;
 }
-class re {
+class he {
   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 = 1e3;
+    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 = y.MAX_FLUSH_ITERATIONS;
   }
   get phase() {
     return this.isProcessing || this.isFlushingSync ? 2 : this.isBatching ? 1 : 0;
   }
   schedule(e) {
     if (typeof e != "function")
-      throw new A("Scheduler callback must be a function");
+      throw new x("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() {
@@ -316,25 +324,25 @@ 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 = Y();
+      const i = $();
       for (let n = 0; n < t; n++)
         try {
           e[n]?.();
         } catch (r) {
           console.error(
-            new A("Error occurred during scheduler execution", r)
+            new x("Error occurred during scheduler execution", r)
           );
         }
-      e.length = 0, this.isProcessing = !1, s && $(), this.queueSize > 0 && !this.isBatching && this.flush();
+      e.length = 0, this.isProcessing = !1, i && H(), this.queueSize > 0 && !this.isBatching && this.flush();
     });
   }
   flushSync() {
     this.isFlushingSync = !0;
-    const e = Y();
+    const e = $();
     try {
       if (this._epoch++, this.batchQueueSize > 0) {
-        for (let s = 0; s < this.batchQueueSize; s++) {
-          const n = this.batchQueue[s];
+        for (let i = 0; i < this.batchQueueSize; i++) {
+          const n = this.batchQueue[i];
           n._nextEpoch !== this._epoch && (n._nextEpoch = this._epoch, this.queue[this.queueSize++] = n);
         }
         this.batchQueueSize = 0;
@@ -343,30 +351,30 @@ class re {
       for (; this.queueSize > 0; ) {
         if (++t > this.maxFlushIterations) {
           console.error(
-            new A(
+            new x(
               `Maximum flush iterations (${this.maxFlushIterations}) exceeded. Possible infinite loop.`
             )
           ), this.queueSize = 0, this.queue.length = 0, this.batchQueueSize = 0;
           break;
         }
-        const s = this.queue, n = this.queueSize;
+        const i = this.queue, n = this.queueSize;
         this.queue = this.queue === this.queueA ? this.queueB : this.queueA, this.queueSize = 0, this._epoch++;
         for (let r = 0; r < n; r++)
           try {
-            s[r]?.();
+            i[r]?.();
           } catch (c) {
             console.error(
-              new A("Error occurred during batch execution", c)
+              new x("Error occurred during batch execution", c)
             );
           }
-        if (s.length = 0, this.batchQueueSize > 0) {
+        if (i.length = 0, this.batchQueueSize > 0) {
           for (let r = 0; r < this.batchQueueSize; r++)
             this.queue[this.queueSize++] = this.batchQueue[r];
           this.batchQueueSize = 0;
         }
       }
     } finally {
-      this.isFlushingSync = !1, e && $();
+      this.isFlushingSync = !1, e && H();
     }
   }
   startBatch() {
@@ -376,29 +384,31 @@ class re {
     this.batchDepth = Math.max(0, this.batchDepth - 1), this.batchDepth === 0 && (this.flushSync(), this.isBatching = !1);
   }
   setMaxFlushIterations(e) {
-    if (e < 10)
-      throw new A("Max flush iterations must be at least 10");
+    if (e < y.MIN_FLUSH_ITERATIONS)
+      throw new x(
+        `Max flush iterations must be at least ${y.MIN_FLUSH_ITERATIONS}`
+      );
     this.maxFlushIterations = e;
   }
 }
-const U = new re();
-function ae(i) {
-  if (typeof i != "function")
+const U = new he();
+function be(s) {
+  if (typeof s != "function")
     throw new E("Batch callback must be a function");
   U.startBatch();
   try {
-    return i();
+    return s();
   } catch (e) {
     throw new E("Error occurred during batch execution", e);
   } finally {
     U.endBatch();
   }
 }
-const m = {
+const N = {
   current: null,
-  run(i, e) {
+  run(s, e) {
     const t = this.current;
-    this.current = i;
+    this.current = s;
     try {
       return e();
     } finally {
@@ -409,20 +419,32 @@ const m = {
     return this.current;
   }
 };
-function ce(i) {
-  if (typeof i != "function")
+function le(s) {
+  return typeof s == "object" && s !== null;
+}
+function Z(s) {
+  return (typeof s == "object" || typeof s == "function") && s !== null && typeof s.addDependency == "function";
+}
+function ee(s) {
+  return typeof s == "function" && typeof s.addDependency != "function";
+}
+function te(s) {
+  return le(s) && typeof s.execute == "function";
+}
+function _e(s) {
+  if (typeof s != "function")
     throw new E("Untracked callback must be a function");
-  const e = m.current;
-  m.current = null;
+  const e = N.current;
+  N.current = null;
   try {
-    return i();
+    return s();
   } catch (t) {
     throw new E("Error occurred during untracked execution", t);
   } finally {
-    m.current = e;
+    N.current = e;
   }
 }
-class M {
+class v {
   constructor() {
     this.subscribers = null;
   }
@@ -444,8 +466,8 @@ class M {
     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;
@@ -458,9 +480,9 @@ class M {
   /** 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);
         }
@@ -469,7 +491,7 @@ class M {
     return this.subscribers?.length ?? 0;
   }
   get hasSubscribers() {
-    return this.size > 0;
+    return this.subscribers !== null && this.subscribers.length > 0;
   }
   clear() {
     this.subscribers = null;
@@ -478,9 +500,9 @@ class M {
     return this.subscribers ? [...this.subscribers] : [];
   }
 }
-class ue extends W {
+class ae extends W {
   constructor(e, t) {
-    super(), this._isNotificationScheduled = !1, this._value = e, this._functionSubscribersStore = new M(), this._objectSubscribersStore = new M(), this._sync = t, this._notifyTask = this._flushNotifications.bind(this), S.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), S.attachDebugInfo(this, "atom", this.id);
   }
   get _functionSubscribers() {
     return this._functionSubscribersStore;
@@ -490,28 +512,28 @@ class ue extends W {
   }
   /** Gets value and registers as dependency in current tracking context */
   get value() {
-    const e = m.getCurrent();
-    return e != null && this._track(e), this._value;
+    const e = N.getCurrent();
+    return e && this._track(e), this._value;
   }
   /** Sets value and notifies subscribers if changed (uses Object.is) */
   set value(e) {
     if (Object.is(this._value, e)) return;
     const t = this._value;
-    this.version = this.version + 1 & T;
-    const s = this.version;
-    this._value = e, !(!this._functionSubscribersStore.hasSubscribers && !this._objectSubscribersStore.hasSubscribers) && this._notify(e, t, s);
+    this.version = this.version + 1 & A, this._value = e, !(!this._functionSubscribersStore.hasSubscribers && !this._objectSubscribersStore.hasSubscribers) && this._scheduleNotification(t);
   }
   _track(e) {
-    if (typeof e == "function") {
-      const t = e;
-      t.addDependency !== void 0 ? t.addDependency(this) : this._functionSubscribersStore.add(e);
-    } else {
-      const t = e;
-      t.addDependency !== void 0 ? t.addDependency(this) : t.execute !== void 0 && this._objectSubscribersStore.add(t);
+    if (Z(e)) {
+      e.addDependency(this);
+      return;
     }
+    if (ee(e)) {
+      this._functionSubscribersStore.add(e);
+      return;
+    }
+    te(e) && this._objectSubscribersStore.add(e);
   }
-  _notify(e, t, s) {
-    this._isNotificationScheduled || (this._pendingOldValue = t, this._isNotificationScheduled = !0), this._sync && !U.isBatching ? this._flushNotifications() : U.schedule(this._notifyTask);
+  _scheduleNotification(e) {
+    this._isNotificationScheduled || (this._pendingOldValue = e, this._isNotificationScheduled = !0), this._sync && !U.isBatching ? this._flushNotifications() : U.schedule(this._notifyTask);
   }
   _flushNotifications() {
     if (!this._isNotificationScheduled) return;
@@ -526,11 +548,11 @@ class ue extends W {
     this._functionSubscribersStore.clear(), this._objectSubscribersStore.clear(), this._value = void 0;
   }
 }
-function _e(i, e = {}) {
-  return new ue(i, e.sync ?? !1);
+function pe(s, e = {}) {
+  return new ae(s, e.sync ?? !1);
 }
-const _ = Object.freeze([]), b = Object.freeze([]), f = Object.freeze([]);
-class z {
+const a = Object.freeze([]), b = Object.freeze([]), f = Object.freeze([]);
+class j {
   constructor() {
     this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = d ? {
       acquired: 0,
@@ -560,11 +582,11 @@ class z {
   }
   getStats() {
     if (!d || !this.stats) return null;
-    const { acquired: e, released: t, rejected: s } = this.stats, n = s.frozen + s.tooLarge + s.poolFull;
+    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
     };
@@ -573,44 +595,44 @@ class z {
     this.pool.length = 0, d && this.stats && (this.stats.acquired = 0, this.stats.released = 0, this.stats.rejected = { frozen: 0, tooLarge: 0, poolFull: 0 });
   }
 }
-const y = new z(), I = new z(), p = new z();
-function q(i, e, t, s) {
-  if (e !== _ && t !== b)
+const I = new j(), m = new j(), p = new j();
+function q(s, e, t, i) {
+  if (e !== a && t !== b)
     for (let r = 0; r < e.length; r++) {
       const c = e[r];
       c && (c._tempUnsub = t[r]);
     }
-  const n = I.acquire();
-  n.length = i.length;
-  for (let r = 0; r < i.length; r++) {
-    const c = i[r];
-    c && (c._tempUnsub ? (n[r] = c._tempUnsub, c._tempUnsub = void 0) : (S.checkCircular(c, s), n[r] = c.subscribe(s)));
+  const n = m.acquire();
+  n.length = s.length;
+  for (let r = 0; r < s.length; r++) {
+    const c = s[r];
+    c && (c._tempUnsub ? (n[r] = c._tempUnsub, c._tempUnsub = void 0) : (S.checkCircular(c, i), n[r] = c.subscribe(i)));
   }
-  if (e !== _)
+  if (e !== a)
     for (let r = 0; r < e.length; r++) {
       const c = e[r];
       c?._tempUnsub && (c._tempUnsub(), c._tempUnsub = void 0);
     }
-  return t !== b && I.release(t), n;
+  return t !== b && m.release(t), n;
 }
-class Z extends W {
+class se extends W {
   constructor(e, t = {}) {
     if (typeof e != "function")
-      throw new C(l.COMPUTED_MUST_BE_FUNCTION);
-    if (super(), this._value = void 0, this.flags = o.DIRTY | o.IDLE, this._error = null, this._promiseId = 0, this._equal = t.equal ?? Object.is, this._fn = e, this._defaultValue = "defaultValue" in t ? t.defaultValue : X, this._hasDefaultValue = this._defaultValue !== X, this._onError = t.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._functionSubscribersStore = new M(), this._objectSubscribersStore = new M(), this._dependencies = _, this._dependencyVersions = f, this._unsubscribes = b, this._notifyJob = () => {
+      throw new T(l.COMPUTED_MUST_BE_FUNCTION);
+    if (super(), this._value = void 0, this.flags = o.DIRTY | o.IDLE, this._error = null, this._promiseId = 0, this._equal = t.equal ?? Object.is, this._fn = e, this._defaultValue = "defaultValue" in t ? t.defaultValue : X, this._hasDefaultValue = this._defaultValue !== X, this._onError = t.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._functionSubscribersStore = new v(), this._objectSubscribersStore = new v(), this._dependencies = a, this._dependencyVersions = f, this._unsubscribes = b, 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) => {
       }
     }), S.attachDebugInfo(this, "computed", this.id), S.enabled) {
-      const s = this;
-      s.subscriberCount = () => this._functionSubscribersStore.size + this._objectSubscribersStore.size, s.isDirty = () => this._isDirty(), s.dependencies = this._dependencies, s.stateFlags = this._getFlagsAsString();
+      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 {
@@ -655,9 +677,9 @@ class Z extends W {
         const t = this._unsubscribes[e];
         t && t();
       }
-      I.release(this._unsubscribes), this._unsubscribes = b;
+      m.release(this._unsubscribes), this._unsubscribes = b;
     }
-    this._dependencies !== _ && (y.release(this._dependencies), this._dependencies = _), this._dependencyVersions !== f && (p.release(this._dependencyVersions), this._dependencyVersions = f), this._functionSubscribersStore.clear(), this._objectSubscribersStore.clear(), this.flags = o.DIRTY | o.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID;
+    this._dependencies !== a && (I.release(this._dependencies), this._dependencies = a), this._dependencyVersions !== f && (p.release(this._dependencyVersions), this._dependencyVersions = f), this._functionSubscribersStore.clear(), this._objectSubscribersStore.clear(), this.flags = o.DIRTY | o.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID;
   }
   // State flag operations
   _isDirty() {
@@ -701,7 +723,7 @@ class Z extends W {
     this.flags = this.flags & ~t | -Number(e) & t;
   }
   _getAsyncState() {
-    return this._isPending() ? O.PENDING : this._isResolved() ? O.RESOLVED : this._isRejected() ? O.REJECTED : O.IDLE;
+    return this._isResolved() ? F.RESOLVED : this._isPending() ? F.PENDING : this._isRejected() ? F.REJECTED : F.IDLE;
   }
   _getFlagsAsString() {
     const e = [];
@@ -713,65 +735,65 @@ class Z extends W {
   _recompute() {
     if (this._isRecomputing()) return;
     this._setRecomputing(!0);
-    const e = this._dependencies, t = this._dependencyVersions, s = y.acquire(), n = p.acquire(), r = K();
+    const e = this._dependencies, t = this._dependencyVersions, i = I.acquire(), n = p.acquire(), r = K();
     let c = 0;
-    const x = (h) => {
-      h._lastSeenEpoch !== r && (h._lastSeenEpoch = r, c < s.length ? (s[c] = h, n[c] = h.version) : (s.push(h), n.push(h.version)), c++);
+    const O = (h) => {
+      h._lastSeenEpoch !== r && (h._lastSeenEpoch = r, c < i.length ? (i[c] = h, n[c] = h.version) : (i.push(h), n.push(h.version)), c++);
     }, D = this._trackable.addDependency;
-    this._trackable.addDependency = x;
+    this._trackable.addDependency = O;
     let R = !1;
     try {
-      const h = m.run(this._trackable, this._fn);
-      if (s.length = c, n.length = c, Q(h)) {
-        this._unsubscribes = q(s, e, this._unsubscribes, this), this._dependencies = s, this._dependencyVersions = n, R = !0, this._handleAsyncComputation(h), this._setRecomputing(!1);
+      const h = N.run(this._trackable, this._fn);
+      if (i.length = c, n.length = c, Y(h)) {
+        this._unsubscribes = q(i, e, this._unsubscribes, this), this._dependencies = i, this._dependencyVersions = n, R = !0, this._handleAsyncComputation(h), this._setRecomputing(!1);
         return;
       }
-      this._unsubscribes = q(s, e, this._unsubscribes, this), this._dependencies = s, this._dependencyVersions = n, R = !0, this._handleSyncResult(h);
+      this._unsubscribes = q(i, e, this._unsubscribes, this), this._dependencies = i, this._dependencyVersions = n, R = !0, this._handleSyncResult(h);
     } catch (h) {
-      s.length = c, n.length = c, this._unsubscribes = q(s, e, this._unsubscribes, this), this._dependencies = s, this._dependencyVersions = n, R = !0, this._handleComputationError(h);
+      i.length = c, n.length = c, this._unsubscribes = q(i, e, this._unsubscribes, this), this._dependencies = i, this._dependencyVersions = n, R = !0, this._handleComputationError(h);
     } finally {
-      this._trackable.addDependency = D, R ? (e !== _ && y.release(e), t !== f && p.release(t)) : (y.release(s), p.release(n));
+      this._trackable.addDependency = D, R ? (e !== a && I.release(e), t !== f && p.release(t)) : (I.release(i), p.release(n));
     }
   }
   _handleSyncResult(e) {
-    (!this._isResolved() || !this._equal(this._value, e)) && (this.version = this.version + 1 & T), this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1);
+    (!this._isResolved() || !this._equal(this._value, e)) && (this.version = this.version + 1 & A), this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1);
   }
   _handleAsyncComputation(e) {
     this._setPending(), this._clearDirty(), 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) {
-    (!this._isResolved() || !this._equal(this._value, e)) && (this.version = this.version + 1 & T), this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1);
+    (!this._isResolved() || !this._equal(this._value, e)) && (this.version = this.version + 1 & A), this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1);
   }
   _handleAsyncRejection(e) {
-    const t = N(e, C, l.COMPUTED_ASYNC_COMPUTATION_FAILED);
-    if (this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError && typeof this._onError == "function")
+    const t = C(e, T, l.COMPUTED_ASYNC_COMPUTATION_FAILED);
+    if (this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
       try {
         this._onError(t);
-      } catch (s) {
-        console.error(l.CALLBACK_ERROR_IN_ERROR_HANDLER, s);
+      } catch (i) {
+        console.error(l.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
       }
     this._notifySubscribers(void 0, void 0);
   }
   _handleComputationError(e) {
-    const t = N(e, C, l.COMPUTED_COMPUTATION_FAILED);
-    if (this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError && typeof this._onError == "function")
+    const t = C(e, T, l.COMPUTED_COMPUTATION_FAILED);
+    if (this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
       try {
         this._onError(t);
-      } catch (s) {
-        console.error(l.CALLBACK_ERROR_IN_ERROR_HANDLER, s);
+      } catch (i) {
+        console.error(l.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
       }
     throw t;
   }
   _handlePending() {
     if (this._hasDefaultValue)
       return this._defaultValue;
-    throw new C(l.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    throw new T(l.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
   }
   _handleRejected() {
     if (this._error?.recoverable && this._hasDefaultValue)
@@ -786,21 +808,25 @@ class Z extends W {
     this._isRecomputing() || this._isDirty() || (this._setDirty(), this._notifyJob());
   }
   _registerTracking() {
-    const e = m.getCurrent();
-    if (e)
-      if (typeof e == "object" && e !== null && e.addDependency)
+    const e = N.getCurrent();
+    if (e) {
+      if (Z(e)) {
         e.addDependency(this);
-      else if (typeof e == "function") {
-        const t = e;
-        t.addDependency ? t.addDependency(this) : this._functionSubscribersStore.add(e);
-      } else e.execute && this._objectSubscribersStore.add(e);
+        return;
+      }
+      if (ee(e)) {
+        this._functionSubscribersStore.add(e);
+        return;
+      }
+      te(e) && this._objectSubscribersStore.add(e);
+    }
   }
 }
-Object.freeze(Z.prototype);
-function fe(i, e = {}) {
-  return new Z(i, e);
+Object.freeze(se.prototype);
+function Se(s, e = {}) {
+  return new se(s, e);
 }
-class oe extends J {
+class fe extends J {
   constructor(e, t = {}) {
     super(), this.run = () => {
       if (this.isDisposed)
@@ -809,62 +835,62 @@ class oe extends J {
     }, this.dispose = () => {
       if (!this.isDisposed) {
         if (this._setDisposed(), this._safeCleanup(), this._unsubscribes !== b) {
-          for (let s = 0; s < this._unsubscribes.length; s++) {
-            const n = this._unsubscribes[s];
+          for (let i = 0; i < this._unsubscribes.length; i++) {
+            const n = this._unsubscribes[i];
             n && n();
           }
-          I.release(this._unsubscribes), this._unsubscribes = b;
+          m.release(this._unsubscribes), this._unsubscribes = b;
         }
-        this._dependencies !== _ && (y.release(this._dependencies), this._dependencies = _), this._dependencyVersions !== f && (p.release(this._dependencyVersions), this._dependencyVersions = f);
+        this._dependencies !== a && (I.release(this._dependencies), this._dependencies = a), this._dependencyVersions !== f && (p.release(this._dependencyVersions), this._dependencyVersions = f);
       }
-    }, this.addDependency = (s) => {
+    }, this.addDependency = (i) => {
       if (this.isExecuting && this._nextDeps && this._nextUnsubs && this._nextVersions) {
-        const n = s, 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);
+        const n = this._currentEpoch;
+        if (i._lastSeenEpoch === n) return;
+        i._lastSeenEpoch = n, this._nextDeps.push(i), this._nextVersions.push(i.version), i._tempUnsub ? (this._nextUnsubs.push(i._tempUnsub), i._tempUnsub = void 0) : this._subscribeTo(i);
       }
     }, this.execute = () => {
       if (this.isDisposed || this.isExecuting || !this._shouldExecute()) return;
       this._checkInfiniteLoop(), this._setExecuting(!0), this._safeCleanup();
-      const s = this._dependencies, n = this._dependencyVersions, r = this._unsubscribes, c = y.acquire(), x = p.acquire(), D = I.acquire(), R = K();
-      if (s !== _ && r !== b)
-        for (let u = 0; u < s.length; u++) {
-          const a = s[u];
-          a && (a._tempUnsub = r[u]);
+      const i = this._dependencies, n = this._dependencyVersions, r = this._unsubscribes, c = I.acquire(), O = p.acquire(), D = m.acquire(), R = K();
+      if (i !== a && r !== b)
+        for (let u = 0; u < i.length; u++) {
+          const _ = i[u];
+          _ && (_._tempUnsub = r[u]);
         }
-      this._nextDeps = c, this._nextVersions = x, this._nextUnsubs = D, this._currentEpoch = R;
+      this._nextDeps = c, this._nextVersions = O, this._nextUnsubs = D, this._currentEpoch = R;
       let h = !1;
       try {
-        const u = m.run(this, this._fn);
-        this._dependencies = c, this._dependencyVersions = x, this._unsubscribes = D, h = !0, this._checkLoopWarnings(), Q(u) ? u.then((a) => {
-          !this.isDisposed && typeof a == "function" && (this._cleanup = a);
-        }).catch((a) => {
-          console.error(N(a, g, l.EFFECT_EXECUTION_FAILED));
+        const u = N.run(this, this._fn);
+        this._dependencies = c, this._dependencyVersions = O, this._unsubscribes = D, h = !0, this._checkLoopWarnings(), Y(u) ? u.then((_) => {
+          !this.isDisposed && typeof _ == "function" && (this._cleanup = _);
+        }).catch((_) => {
+          console.error(C(_, g, l.EFFECT_EXECUTION_FAILED));
         }) : this._cleanup = typeof u == "function" ? u : null;
       } catch (u) {
-        h = !0, console.error(N(u, g, l.EFFECT_EXECUTION_FAILED)), this._cleanup = null;
+        h = !0, console.error(C(u, g, l.EFFECT_EXECUTION_FAILED)), this._cleanup = null;
       } finally {
         if (this._setExecuting(!1), this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, h) {
-          if (s !== _) {
-            for (let u = 0; u < s.length; u++) {
-              const a = s[u];
-              a?._tempUnsub && (a._tempUnsub(), a._tempUnsub = void 0);
+          if (i !== a) {
+            for (let u = 0; u < i.length; u++) {
+              const _ = i[u];
+              _?._tempUnsub && (_._tempUnsub(), _._tempUnsub = void 0);
             }
-            y.release(s);
+            I.release(i);
           }
-          r !== b && I.release(r), n !== f && p.release(n);
+          r !== b && m.release(r), n !== f && p.release(n);
         } else {
-          y.release(c), p.release(x);
+          I.release(c), p.release(O);
           for (let u = 0; u < D.length; u++)
             D[u]?.();
-          if (I.release(D), s !== _)
-            for (let u = 0; u < s.length; u++) {
-              const a = s[u];
-              a && (a._tempUnsub = void 0);
+          if (m.release(D), i !== a)
+            for (let u = 0; u < i.length; u++) {
+              const _ = i[u];
+              _ && (_._tempUnsub = void 0);
             }
         }
       }
-    }, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._fn = e, this._sync = t.sync ?? !1, this._maxExecutions = t.maxExecutionsPerSecond ?? P.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = t.maxExecutionsPerFlush ?? P.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = t.trackModifications ?? !1, this._cleanup = null, this._dependencies = _, this._dependencyVersions = f, this._unsubscribes = b, this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, this._history = d ? [] : null, this._executionCount = 0, S.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 ?? y.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = t.maxExecutionsPerFlush ?? y.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = t.trackModifications ?? !1, this._cleanup = null, this._dependencies = a, this._dependencyVersions = f, this._unsubscribes = b, this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, this._history = d ? [] : null, this._executionCount = 0, S.attachDebugInfo(this, "effect", this.id);
   }
   _subscribeTo(e) {
     try {
@@ -873,48 +899,48 @@ class oe extends J {
       });
       this._nextUnsubs && this._nextUnsubs.push(t);
     } catch (t) {
-      console.error(N(t, g, l.EFFECT_EXECUTION_FAILED)), this._nextUnsubs && this._nextUnsubs.push(() => {
+      console.error(C(t, g, l.EFFECT_EXECUTION_FAILED)), this._nextUnsubs && this._nextUnsubs.push(() => {
       });
     }
   }
   get isDisposed() {
-    return (this.flags & F.DISPOSED) !== 0;
+    return (this.flags & P.DISPOSED) !== 0;
   }
   get executionCount() {
     return this._executionCount;
   }
   get isExecuting() {
-    return (this.flags & F.EXECUTING) !== 0;
+    return (this.flags & P.EXECUTING) !== 0;
   }
   _setDisposed() {
-    this.flags |= F.DISPOSED;
+    this.flags |= P.DISPOSED;
   }
   _setExecuting(e) {
-    const t = F.EXECUTING;
+    const t = P.EXECUTING;
     this.flags = this.flags & ~t | -Number(e) & t;
   }
   _safeCleanup() {
-    if (this._cleanup && typeof this._cleanup == "function") {
+    if (this._cleanup) {
       try {
         this._cleanup();
       } catch (e) {
-        console.error(N(e, g, l.EFFECT_CLEANUP_FAILED));
+        console.error(C(e, g, l.EFFECT_CLEANUP_FAILED));
       }
       this._cleanup = null;
     }
   }
   _checkInfiniteLoop() {
-    if (this._lastFlushEpoch !== v && (this._lastFlushEpoch = v, this._executionsInEpoch = 0), this._executionsInEpoch++, this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), ne() > P.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history) {
+    if (this._lastFlushEpoch !== M && (this._lastFlushEpoch = M, this._executionsInEpoch = 0), this._executionsInEpoch++, this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), oe() > y.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history) {
       const e = Date.now();
-      this._history.push(e), this._history.length > P.MAX_EXECUTIONS_PER_SECOND + 10 && this._history.shift(), this._checkTimestampLoop(e);
+      this._history.push(e), this._history.length > y.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 - 1e3;
+    const i = e - ie.ONE_SECOND_MS;
     let n = 0;
-    for (let r = t.length - 1; r >= 0 && !(t[r] < s); r--)
+    for (let r = t.length - 1; r >= 0 && !(t[r] < i); r--)
       n++;
     if (n > this._maxExecutions) {
       const r = new g(
@@ -931,13 +957,14 @@ class oe extends J {
     throw this.dispose(), console.error(t), t;
   }
   _shouldExecute() {
-    if (this._dependencies === _ || this._dependencyVersions === f) return !0;
+    if (this._dependencies === a || this._dependencyVersions === f)
+      return !0;
     for (let e = 0; e < this._dependencies.length; e++) {
       const t = this._dependencies[e];
       if (t) {
         if ("value" in t)
           try {
-            ce(() => t.value);
+            _e(() => t.value);
           } catch {
             return !0;
           }
@@ -951,53 +978,53 @@ class oe extends J {
     if (this._trackModifications && S.enabled) {
       const e = this._dependencies;
       for (let t = 0; t < e.length; t++) {
-        const s = e[t];
-        s && s._modifiedAtEpoch === this._currentEpoch && S.warn(
+        const i = e[t];
+        i && i._modifiedAtEpoch === this._currentEpoch && S.warn(
           !0,
-          `Effect is reading a dependency (${S.getDebugName(s) || "unknown"}) that it just modified. Infinite loop may occur`
+          `Effect is reading a dependency (${S.getDebugName(i) || "unknown"}) that it just modified. Infinite loop may occur`
         );
       }
     }
   }
 }
-function de(i, e = {}) {
-  if (typeof i != "function")
+function ge(s, e = {}) {
+  if (typeof s != "function")
     throw new g(l.EFFECT_MUST_BE_FUNCTION);
-  const t = new oe(i, e);
+  const t = new fe(s, e);
   return t.execute(), t;
 }
-function he(i) {
-  return i !== null && typeof i == "object" && "value" in i && "subscribe" in i && typeof i.subscribe == "function";
+function de(s) {
+  return s !== null && typeof s == "object" && "value" in s && "subscribe" in s && typeof s.subscribe == "function";
 }
-function Ee(i) {
-  if (S.enabled) {
-    const e = S.getDebugType(i);
+function Ie(s) {
+  if (S.enabled && (s == null || typeof s == "object")) {
+    const e = S.getDebugType(s);
     if (e)
       return e === "computed";
   }
-  return he(i) && "invalidate" in i && typeof i.invalidate == "function";
+  return de(s) && "invalidate" in s && typeof s.invalidate == "function";
 }
-function be(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";
 }
 export {
-  O as AsyncState,
+  F as AsyncState,
   E as AtomError,
-  C as ComputedError,
-  j as DEBUG_CONFIG,
+  T as ComputedError,
+  z as DEBUG_CONFIG,
   S as DEBUG_RUNTIME,
   g as EffectError,
-  le as POOL_CONFIG,
-  P as SCHEDULER_CONFIG,
-  A as SchedulerError,
-  _e as atom,
-  ae as batch,
-  fe as computed,
-  de as effect,
-  he as isAtom,
-  Ee as isComputed,
-  be as isEffect,
+  Ee as POOL_CONFIG,
+  y as SCHEDULER_CONFIG,
+  x as SchedulerError,
+  pe as atom,
+  be as batch,
+  Se as computed,
+  ge as effect,
+  de as isAtom,
+  Ie as isComputed,
+  De as isEffect,
   U as scheduler,
-  ce as untracked
+  _e as untracked
 };
 //# sourceMappingURL=index.mjs.map