@but212/atom-effect 0.21.0 → 0.21.2

package/dist/index.mjs

@@ -1,4 +1,4 @@
-const k = {
+const A = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
@@ -6,7 +6,7 @@ const k = {
 }, l = {
   DISPOSED: 1,
   EXECUTING: 8
-}, st = {
+}, K = {
   DISPOSED: 1,
   /** Marker bit: identifies this node as a computed. */
   IS_COMPUTED: 2,
@@ -17,15 +17,15 @@ const k = {
   REJECTED: 128,
   RECOMPUTING: 256,
   HAS_ERROR: 512
-}, E = {
+}, a = {
   DISPOSED: 1,
   SYNC: 8,
   NOTIFICATION_SCHEDULED: 16
-}, kt = {
+}, Ct = {
   MAX_SIZE: 1e3,
   WARMUP_SIZE: 100,
   ENABLE_STATS: !1
-}, S = {
+}, p = {
   // Infinite loop protection
   MAX_EXECUTIONS_PER_SECOND: 1e3,
   MAX_EXECUTIONS_PER_EFFECT: 100,
@@ -34,68 +34,52 @@ const k = {
   MAX_FLUSH_ITERATIONS: 1e3,
   MIN_FLUSH_ITERATIONS: 10,
   // Memory management
-  CLEANUP_THRESHOLD: 1e3,
   BATCH_QUEUE_SHRINK_THRESHOLD: 1e3
-}, _t = {
-  WARN_INFINITE_LOOP: !0
-}, z = 1073741823, u = typeof process < "u" && process.env && process.env.NODE_ENV !== "production" || typeof __DEV__ < "u" && !!__DEV__, at = Object.freeze([]);
-class O extends Error {
+}, ot = {
+  WARN_INFINITE_LOOP: !0,
+  EFFECT_FREQUENCY_WINDOW: 1e3
+}, X = {
+  MAX_ASYNC_RETRIES: 3,
+  MAX_PROMISE_ID: Number.MAX_SAFE_INTEGER - 1
+}, B = 1073741823, J = typeof process < "u" && process.env && !1 || !1, ht = Object.freeze([]);
+class C extends Error {
   constructor(t, e = null, s = !0) {
     super(t), this.cause = e, this.recoverable = s, this.name = "AtomError";
   }
 }
-class d extends O {
+class E extends C {
   constructor(t, e = null) {
     super(t, e, !0), this.name = "ComputedError";
   }
 }
-class I extends O {
+class g extends C {
   constructor(t, e = null) {
     super(t, e, !1), this.name = "EffectError";
   }
 }
-class m extends O {
+class m extends C {
   constructor(t, e = null) {
     super(t, e, !1), this.name = "SchedulerError";
   }
 }
-const G = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), ft = /* @__PURE__ */ Symbol("AtomEffect.Id"), Q = /* @__PURE__ */ Symbol("AtomEffect.Type"), v = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), Et = (i) => "dependencies" in i && Array.isArray(i.dependencies);
-function it(i, t, e) {
-  if (i === t)
-    throw new d(
-      "Circular dependency detected: The computation refers to itself explicitly or implicitly."
-    );
-  if (!e.has(i.id) && (e.add(i.id), Et(i))) {
-    const s = i.dependencies;
-    for (let n = 0; n < s.length; n++) {
-      const r = s[n];
-      r && it(r, t, e);
-    }
-  }
-}
-const D = {
+const ct = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), ut = /* @__PURE__ */ Symbol("AtomEffect.Type"), U = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), L = {
   // Dev mode flag
-  enabled: u,
-  warnInfiniteLoop: _t.WARN_INFINITE_LOOP,
+  enabled: J,
+  warnInfiniteLoop: ot.WARN_INFINITE_LOOP,
   warn(i, t) {
-    u && this.enabled && i && console.warn(`[Atom Effect] ${t}`);
   },
   checkCircular(i, t) {
     if (i === t)
-      throw new d("Direct circular dependency detected");
-    u && this.enabled && it(i, t, /* @__PURE__ */ new Set());
+      throw new E("Direct circular dependency detected");
   },
   attachDebugInfo(i, t, e) {
-    if (!u || !this.enabled) return;
-    const s = i;
-    s[G] = `${t}_${e}`, s[ft] = e, s[Q] = t;
   },
-  getDebugName: (i) => i?.[G],
-  getDebugType: (i) => i?.[Q]
+  getDebugName: (i) => i?.[ct],
+  getDebugType: (i) => i?.[ut]
 };
-let dt = 1;
-const pt = () => dt++;
-function nt(i, t, e) {
+let lt = 1;
+const _t = () => lt++;
+function Z(i, t, e) {
   if (typeof t == "function") {
     const n = t;
     for (let r = 0, o = e.length; r < o; r++) {
@@ -116,7 +100,7 @@ function nt(i, t, e) {
   }
   e.push(new M(void 0, s));
 }
-function j(i, t, e) {
+function G(i, t, e) {
   const s = /* @__PURE__ */ new Map();
   for (let n = 0, r = t.length; n < r; n++) {
     const o = t[n];
@@ -125,13 +109,13 @@ function j(i, t, e) {
   for (let n = 0, r = i.length; n < r; n++) {
     const o = i[n];
     if (!o) continue;
-    const h = o.node, f = s.get(h);
-    f !== void 0 ? (o.unsub = f, s.delete(h)) : (D.checkCircular(h, e), o.unsub = h.subscribe(e));
+    const h = o.node, I = s.get(h);
+    I !== void 0 ? (o.unsub = I, s.delete(h)) : (L.checkCircular(h, e), o.unsub = h.subscribe(e));
   }
   for (const n of s.values())
     n();
 }
-class R {
+class v {
   constructor(t, e, s = void 0) {
     this.node = t, this.version = e, this.unsub = s;
   }
@@ -162,36 +146,38 @@ const c = {
   // System / Debug
   CALLBACK_ERROR_IN_ERROR_HANDLER: "Exception encountered in onError handler",
   // Effect frequency
-  EFFECT_FREQUENCY_LIMIT_EXCEEDED: "Effect executed too frequently within 1 second. Suspected infinite loop."
+  EFFECT_FREQUENCY_LIMIT_EXCEEDED: "Effect executed too frequently within 1 second. Suspected infinite loop.",
+  SCHEDULER_CALLBACK_MUST_BE_FUNCTION: "Scheduler callback must be a function",
+  SCHEDULER_END_BATCH_WITHOUT_START: "endBatch() called without matching startBatch(). Ignoring."
 };
-function T(i, t, e) {
-  if (i instanceof O)
+function D(i, t, e) {
+  if (i instanceof C)
     return i;
   const s = i instanceof Error, n = s ? i.message : String(i), r = s ? i : void 0, h = `${s ? i.constructor.name : "Unexpected error"} (${e}): ${n}`;
   return new t(h, r);
 }
-class rt {
+class tt {
   constructor() {
-    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this.id = pt() & z;
+    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this.id = _t() & B;
   }
 }
-class ot extends rt {
+class et extends tt {
   /**
    * Adds subscriber.
    */
   subscribe(t) {
     const e = typeof t == "function";
     if (!e && (!t || typeof t.execute != "function"))
-      throw T(
+      throw D(
         new TypeError("Invalid subscriber"),
-        O,
+        C,
         c.ATOM_SUBSCRIBER_MUST_BE_FUNCTION
       );
     const s = this._subscribers;
     for (let r = 0, o = s.length; r < o; r++) {
       const h = s[r];
       if (h && (e ? h.fn === t : h.sub === t))
-        return u && console.warn("Duplicate subscription ignored."), () => {
+        return () => {
         };
     }
     const n = new M(
@@ -223,22 +209,22 @@ class ot extends rt {
     }
   }
   _handleNotifyError(t) {
-    console.error(T(t, O, c.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
+    console.error(D(t, C, c.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
   }
 }
-let w = 0;
-const V = () => (w = w + 1 & z || 1, w), B = (i) => i + 1 & z;
-let H = 0, U = !1, ht = 0;
-const It = () => ht;
-function Y() {
-  return U ? (u && console.warn("startFlush() called during flush - ignored"), !1) : (U = !0, ht = V(), H = 0, !0);
+let x = 0;
+const z = () => (x = x + 1 & B || 1, x), w = (i) => i + 1 & B;
+let H = 0, k = !1, st = 0;
+const at = () => st;
+function Q() {
+  return k ? !1 : (k = !0, st = z(), H = 0, !0);
 }
-const $ = () => {
-  U = !1;
-}, gt = () => U ? ++H : 0;
-class St {
+const Y = () => {
+  k = !1;
+}, ft = () => k ? ++H : 0;
+class Et {
   constructor() {
-    this._queueBuffer = [[], []], this._bufferIndex = 0, this._size = 0, this._epoch = 0, this._isProcessing = !1, this._isBatching = !1, this._isFlushingSync = !1, this._batchDepth = 0, this._batchQueue = [], this._batchQueueSize = 0, this._maxFlushIterations = S.MAX_FLUSH_ITERATIONS, this.onOverflow = null, this._boundRunLoop = this._runLoop.bind(this);
+    this._queueBuffer = [[], []], this._bufferIndex = 0, this._size = 0, this._epoch = 0, this._isProcessing = !1, this._isBatching = !1, this._isFlushingSync = !1, this._batchDepth = 0, this._batchQueue = [], this._batchQueueSize = 0, this._maxFlushIterations = p.MAX_FLUSH_ITERATIONS, this.onOverflow = null, this._boundRunLoop = this._runLoop.bind(this);
   }
   get phase() {
     return this._isProcessing || this._isFlushingSync ? 2 : this._isBatching ? 1 : 0;
@@ -253,8 +239,6 @@ class St {
    * Schedules job.
    */
   schedule(t) {
-    if (u && typeof t != "function")
-      throw new m("Scheduler callback must be a function");
     if (t._nextEpoch !== this._epoch) {
       if (t._nextEpoch = this._epoch, this._isBatching || this._isFlushingSync) {
         this._batchQueue[this._batchQueueSize++] = t;
@@ -275,19 +259,19 @@ class St {
   _runLoop() {
     try {
       if (this._size === 0) return;
-      const t = Y();
-      this._drainQueue(), t && $();
+      const t = Q();
+      this._drainQueue(), t && Y();
     } finally {
       this._isProcessing = !1, this._size > 0 && !this._isBatching && this._flush();
     }
   }
   _flushSync() {
     this._isFlushingSync = !0;
-    const t = Y();
+    const t = Q();
     try {
       this._mergeBatchQueue(), this._drainQueue();
     } finally {
-      this._isFlushingSync = !1, t && $();
+      this._isFlushingSync = !1, t && Y();
     }
   }
   _mergeBatchQueue() {
@@ -298,7 +282,7 @@ class St {
       const o = e[r];
       o._nextEpoch !== t && (o._nextEpoch = t, s[n++] = o);
     }
-    this._size = n, this._batchQueueSize = 0, e.length > S.BATCH_QUEUE_SHRINK_THRESHOLD && (e.length = 0);
+    this._size = n, this._batchQueueSize = 0, e.length > p.BATCH_QUEUE_SHRINK_THRESHOLD && (e.length = 0);
   }
   _drainQueue() {
     let t = 0;
@@ -337,21 +321,17 @@ class St {
     this._batchDepth++, this._isBatching = !0;
   }
   endBatch() {
-    if (this._batchDepth === 0) {
-      u && console.warn("endBatch() called without matching startBatch(). Ignoring.");
-      return;
-    }
-    --this._batchDepth === 0 && (this._flushSync(), this._isBatching = !1);
+    this._batchDepth !== 0 && --this._batchDepth === 0 && (this._flushSync(), this._isBatching = !1);
   }
   setMaxFlushIterations(t) {
-    if (t < S.MIN_FLUSH_ITERATIONS)
+    if (t < p.MIN_FLUSH_ITERATIONS)
       throw new m(
-        `Max flush iterations must be at least ${S.MIN_FLUSH_ITERATIONS}`
+        `Max flush iterations must be at least ${p.MIN_FLUSH_ITERATIONS}`
       );
     this._maxFlushIterations = t;
   }
 }
-const N = new St(), X = /* @__PURE__ */ Symbol.for("atom-effect/atom"), ct = /* @__PURE__ */ Symbol.for("atom-effect/computed"), ut = /* @__PURE__ */ Symbol.for("atom-effect/effect"), a = {
+const b = new Et(), V = /* @__PURE__ */ Symbol.for("atom-effect/atom"), it = /* @__PURE__ */ Symbol.for("atom-effect/computed"), nt = /* @__PURE__ */ Symbol.for("atom-effect/effect"), _ = {
   /** Active listener. */
   current: null,
   /**
@@ -371,36 +351,36 @@ const N = new St(), X = /* @__PURE__ */ Symbol.for("atom-effect/atom"), ct = /*
     }
   }
 };
-function mt(i) {
-  const t = a.current;
+function Tt(i) {
+  const t = _.current;
   if (t === null) return i();
-  a.current = null;
+  _.current = null;
   try {
     return i();
   } finally {
-    a.current = t;
+    _.current = t;
   }
 }
-var q, K;
-class Dt extends (K = ot, q = X, K) {
+var j;
+class dt extends et {
   constructor(t, e) {
-    super(), this._pendingOldValue = void 0, this._notifyTask = void 0, this._subscribers = [], this[q] = !0, this._value = t, e && (this.flags |= E.SYNC), D.attachDebugInfo(this, "atom", this.id);
+    super(), this._pendingOldValue = void 0, this._notifyTask = () => this._flushNotifications(), this._subscribers = [], this[j] = !0, this._value = t, e && (this.flags |= a.SYNC), L.attachDebugInfo(this, "atom", this.id);
   }
   get value() {
-    const t = a.current;
-    return t && nt(this, t, this._subscribers), this._value;
+    const t = _.current;
+    return t && Z(this, t, this._subscribers), this._value;
   }
   set value(t) {
     const e = this._value;
     if (Object.is(e, t)) return;
-    this._value = t, this.version = B(this.version);
+    this._value = t, this.version = w(this.version);
     const s = this.flags;
-    if (!(this._subscribers.length === 0 || s & E.NOTIFICATION_SCHEDULED)) {
-      if (this._pendingOldValue = e, this.flags = s | E.NOTIFICATION_SCHEDULED, s & E.SYNC && !N.isBatching) {
+    if (!(this._subscribers.length === 0 || s & a.NOTIFICATION_SCHEDULED)) {
+      if (this._pendingOldValue = e, this.flags = s | a.NOTIFICATION_SCHEDULED, s & a.SYNC && !b.isBatching) {
         this._flushNotifications();
         return;
       }
-      this._notifyTask || (this._notifyTask = () => this._flushNotifications()), N.schedule(this._notifyTask);
+      b.schedule(this._notifyTask);
     }
   }
   /**
@@ -408,7 +388,7 @@ class Dt extends (K = ot, q = X, K) {
    */
   _flushNotifications() {
     const t = this.flags;
-    if (!(t & E.NOTIFICATION_SCHEDULED) || t & E.DISPOSED)
+    if (!(t & a.NOTIFICATION_SCHEDULED) || t & a.DISPOSED)
       return;
     const e = this._pendingOldValue;
     this._pendingOldValue = void 0, this.flags &= -17, this._notifySubscribers(this._value, e);
@@ -417,20 +397,23 @@ class Dt extends (K = ot, q = X, K) {
     return this._value;
   }
   dispose() {
-    this.flags & E.DISPOSED || (this._subscribers.length = 0, this.flags |= E.DISPOSED, this._value = void 0, this._pendingOldValue = void 0, this._notifyTask = void 0);
+    this.flags & a.DISPOSED || (this._subscribers.length = 0, this.flags |= a.DISPOSED, this._value = void 0, this._pendingOldValue = void 0);
+  }
+  [(j = V, Symbol.dispose)]() {
+    this.dispose();
   }
 }
-function Lt(i, t = {}) {
-  return new Dt(i, t.sync ?? !1);
+function Ot(i, t = {}) {
+  return new dt(i, t.sync ?? !1);
 }
-class Ct {
+class pt {
   /**
    * @param limit - Max unique arrays to hold (default: 50). Prevents the pool itself from consuming too much memory.
    * @param capacity - Max length of an array to accept (default: 256).
    * @param enableStats - Force-enable stats even in production (default: false).
    */
   constructor(t = 50, e = 256, s = !1) {
-    this.limit = t, this.capacity = e, this.pool = [], this.stats = null, this.stats = u || s ? {
+    this.limit = t, this.capacity = e, this.pool = [], this.stats = null, this.stats = s ? {
       acquired: 0,
       released: 0,
       rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
@@ -490,61 +473,61 @@ class Ct {
     });
   }
 }
-const _ = Object.freeze(
+const u = Object.freeze(
   []
-), p = new Ct();
-function Ft(i) {
-  return i !== null && typeof i == "object" && X in i;
+), f = new pt();
+function bt(i) {
+  return i !== null && typeof i == "object" && V in i;
 }
-function Rt(i) {
-  return i !== null && typeof i == "object" && ct in i;
+function At(i) {
+  return i !== null && typeof i == "object" && it in i;
 }
-function xt(i) {
-  return i !== null && typeof i == "object" && ut in i;
+function Nt(i) {
+  return i !== null && typeof i == "object" && nt in i;
 }
-function lt(i) {
+function rt(i) {
   return i !== null && typeof i == "object" && typeof i.then == "function";
 }
-var W, J, Z;
-const bt = 3, Tt = Number.MAX_SAFE_INTEGER - 1, { IDLE: L, DIRTY: b, PENDING: x, RESOLVED: g, REJECTED: A, HAS_ERROR: F, RECOMPUTING: y, DISPOSED: P, IS_COMPUTED: Ot } = st;
-function yt(i) {
-  return i & g ? k.RESOLVED : i & x ? k.PENDING : i & A ? k.REJECTED : k.IDLE;
+var q, $;
+const { IDLE: N, DIRTY: S, PENDING: R, RESOLVED: d, REJECTED: O, HAS_ERROR: y, RECOMPUTING: T, DISPOSED: P, IS_COMPUTED: It } = K;
+function St(i) {
+  return i & d ? A.RESOLVED : i & R ? A.PENDING : i & O ? A.REJECTED : A.IDLE;
 }
-class At extends (Z = ot, J = X, W = ct, Z) {
+class gt extends et {
   constructor(t, e = {}) {
-    if (typeof t != "function") throw new d(c.COMPUTED_MUST_BE_FUNCTION);
-    super(), this[J] = !0, this[W] = !0, this._error = null, this._promiseId = 0, this._subscribers = [], this._links = _, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this._trackEpoch = -1, this._trackLinks = _, this._trackCount = 0, this._value = void 0, this.flags = Ot | b | L, this._equal = e.equal ?? Object.is, this._fn = t, this._defaultValue = "defaultValue" in e ? e.defaultValue : v, this._onError = e.onError ?? null;
+    if (typeof t != "function") throw new E(c.COMPUTED_MUST_BE_FUNCTION);
+    super(), this[$] = !0, this[q] = !0, this._error = null, this._promiseId = 0, this._subscribers = [], this._links = u, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this._trackEpoch = -1, this._trackLinks = u, this._trackCount = 0, this._value = void 0, this.flags = It | S | N, this._equal = e.equal ?? Object.is, this._fn = t, this._defaultValue = "defaultValue" in e ? e.defaultValue : U, this._onError = e.onError ?? null;
     const s = e.maxAsyncRetries;
-    if (this._maxAsyncRetries = s != null && s >= 0 ? s : bt, D.attachDebugInfo(this, "computed", this.id), e.lazy === !1)
+    if (this._maxAsyncRetries = s != null && s >= 0 ? s : X.MAX_ASYNC_RETRIES, L.attachDebugInfo(this, "computed", this.id), e.lazy === !1)
       try {
         this._recompute();
       } catch {
       }
   }
   _track() {
-    const t = a.current;
-    t && nt(this, t, this._subscribers);
+    const t = _.current;
+    t && Z(this, t, this._subscribers);
   }
   get value() {
     this._track();
     const t = this.flags;
-    if ((t & (g | b | L)) === g)
+    if ((t & (d | S | N)) === d)
       return this._value;
     if (t & P)
-      throw new d(c.COMPUTED_DISPOSED);
-    if (t & y) {
-      if (this._defaultValue !== v) return this._defaultValue;
-      throw new d(c.COMPUTED_CIRCULAR_DEPENDENCY);
+      throw new E(c.COMPUTED_DISPOSED);
+    if (t & T) {
+      if (this._defaultValue !== U) return this._defaultValue;
+      throw new E(c.COMPUTED_CIRCULAR_DEPENDENCY);
     }
-    if (t & (b | L) && (this._recompute(), this.flags & g))
+    if (t & (S | N) && (this._recompute(), this.flags & d))
       return this._value;
-    const e = this._defaultValue, s = e !== v;
-    if (this.flags & x) {
+    const e = this._defaultValue, s = e !== U;
+    if (this.flags & R) {
       if (s) return e;
-      throw new d(c.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+      throw new E(c.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
     }
-    if (this.flags & A) {
-      if (this._error?.recoverable && s) return e;
+    if (this.flags & O) {
+      if (s) return e;
       throw this._error;
     }
     return this._value;
@@ -553,14 +536,14 @@ class At extends (Z = ot, J = X, W = ct, Z) {
     return this._value;
   }
   get state() {
-    return this._track(), yt(this.flags);
+    return this._track(), St(this.flags);
   }
   get hasError() {
-    if (this._track(), this.flags & (A | F)) return !0;
+    if (this._track(), this.flags & (O | y)) return !0;
     const t = this._links;
     for (let e = 0, s = t.length; e < s; e++) {
       const n = t[e]?.node;
-      if (n && n.flags & F) return !0;
+      if (n && n.flags & y) return !0;
     }
     return !1;
   }
@@ -568,21 +551,19 @@ class At extends (Z = ot, J = X, W = ct, Z) {
     return !this.hasError;
   }
   get errors() {
-    if (this._track(), !this.hasError) return at;
+    if (this._track(), !this.hasError) return ht;
     const t = [];
     this._error && t.push(this._error);
     const e = this._links;
     for (let s = 0, n = e.length; s < n; s++) {
       const r = e[s].node;
-      if (r.flags & F) {
-        const o = r;
-        if (o.errors) {
-          const h = o.errors;
-          for (let f = 0; f < h.length; f++) {
-            const C = h[f];
-            C && t.indexOf(C) === -1 && t.push(C);
+      if (r.flags & y) {
+        const h = r.errors;
+        if (h.length > 0)
+          for (let I = 0; I < h.length; I++) {
+            const F = h[I];
+            F && t.indexOf(F) === -1 && t.push(F);
           }
-        }
       }
     }
     return Object.freeze(t);
@@ -591,10 +572,10 @@ class At extends (Z = ot, J = X, W = ct, Z) {
     return this._track(), this._error;
   }
   get isPending() {
-    return this._track(), (this.flags & x) !== 0;
+    return this._track(), (this.flags & R) !== 0;
   }
   get isResolved() {
-    return this._track(), (this.flags & g) !== 0;
+    return this._track(), (this.flags & d) !== 0;
   }
   invalidate() {
     this._markDirty();
@@ -602,12 +583,15 @@ class At extends (Z = ot, J = X, W = ct, Z) {
   dispose() {
     if (this.flags & P) return;
     const t = this._links;
-    if (t !== _) {
+    if (t !== u) {
       for (let e = 0, s = t.length; e < s; e++)
         t[e].unsub?.();
-      p.release(t), this._links = _;
+      f.release(t), this._links = u;
     }
-    this._subscribers.length = 0, this.flags = P | b | L, this._error = null, this._value = void 0;
+    this._subscribers.length = 0, this.flags = P | S | N, this._error = null, this._value = void 0;
+  }
+  [($ = V, q = it, Symbol.dispose)]() {
+    this.dispose();
   }
   addDependency(t) {
     if (t._lastSeenEpoch !== this._trackEpoch) {
@@ -615,40 +599,39 @@ class At extends (Z = ot, J = X, W = ct, Z) {
         const e = this._trackLinks[this._trackCount];
         e.node = t, e.version = t.version;
       } else
-        this._trackLinks.push(new R(t, t.version));
+        this._trackLinks.push(new v(t, t.version));
       this._trackCount++;
     }
   }
   _recompute() {
-    if (this.flags & y) return;
-    this.flags |= y;
+    if (this.flags & T) return;
+    this.flags |= T;
     const t = this._links;
-    this._trackEpoch = V(), this._trackLinks = p.acquire(), this._trackCount = 0;
+    this._trackEpoch = z(), this._trackLinks = f.acquire(), this._trackCount = 0;
     let e = !1;
     try {
-      const s = a.run(this, this._fn);
-      this._trackLinks.length = this._trackCount, j(this._trackLinks, t, this), this._links = this._trackLinks, e = !0, lt(s) ? this._handleAsyncComputation(s) : this._finalizeResolution(s);
+      const s = _.run(this, this._fn);
+      this._trackLinks.length = this._trackCount, G(this._trackLinks, t, this), this._links = this._trackLinks, e = !0, rt(s) ? this._handleAsyncComputation(s) : this._finalizeResolution(s);
     } catch (s) {
       if (!e)
         try {
-          this._trackLinks.length = this._trackCount, j(this._trackLinks, t, this), this._links = this._trackLinks, e = !0;
-        } catch (n) {
-          u && console.warn("[atom-effect] _commitDeps failed during error recovery:", n);
+          this._trackLinks.length = this._trackCount, G(this._trackLinks, t, this), this._links = this._trackLinks, e = !0;
+        } catch {
         }
       this._handleError(s, c.COMPUTED_COMPUTATION_FAILED, !0);
     } finally {
-      e && t !== _ ? p.release(t) : e || p.release(this._trackLinks), this._trackEpoch = -1, this._trackLinks = _, this._trackCount = 0, this.flags &= ~y;
+      e && t !== u ? f.release(t) : e || f.release(this._trackLinks), this._trackEpoch = -1, this._trackLinks = u, this._trackCount = 0, this.flags &= ~T;
     }
   }
   _handleAsyncComputation(t) {
-    this.flags = (this.flags | x) & -217, this._notifySubscribers(void 0, void 0), this._asyncStartAggregateVersion = this._captureVersionSnapshot(), this._asyncRetryCount = 0, this._promiseId = (this._promiseId + 1) % Tt;
+    this.flags = (this.flags | R) & -217, this._notifySubscribers(void 0, void 0), this._asyncStartAggregateVersion = this._captureVersionSnapshot(), this._asyncRetryCount = 0, this._promiseId = (this._promiseId + 1) % X.MAX_PROMISE_ID;
     const e = this._promiseId;
     t.then(
       (s) => {
         if (e === this._promiseId) {
           if (this._captureVersionSnapshot() !== this._asyncStartAggregateVersion)
             return this._asyncRetryCount++ < this._maxAsyncRetries ? this._markDirty() : this._handleError(
-              new d(
+              new E(
                 `Async drift threshold exceeded after ${this._maxAsyncRetries} retries.`
               ),
               c.COMPUTED_ASYNC_COMPUTATION_FAILED
@@ -667,8 +650,8 @@ class At extends (Z = ot, J = X, W = ct, Z) {
     return t;
   }
   _handleError(t, e, s = !1) {
-    const n = T(t, d, e);
-    if (!s && !(this.flags & A) && (this.version = B(this.version)), this._error = n, this.flags = this.flags & -121 | A | F, this._onError)
+    const n = D(t, E, e);
+    if (!s && !(this.flags & O) && (this.version = w(this.version)), this._error = n, this.flags = this.flags & -121 | O | y, this._onError)
       try {
         this._onError(n);
       } catch (r) {
@@ -678,58 +661,59 @@ class At extends (Z = ot, J = X, W = ct, Z) {
     this._notifySubscribers(void 0, void 0);
   }
   _finalizeResolution(t) {
-    (!(this.flags & g) || !this._equal(this._value, t)) && (this.version = B(this.version)), this._value = t, this._error = null, this.flags = (this.flags | g) & -697;
+    (!(this.flags & d) || !this._equal(this._value, t)) && (this.version = w(this.version)), this._value = t, this._error = null, this.flags = (this.flags | d) & -697;
   }
   execute() {
     this._markDirty();
   }
   /** @internal */
   _markDirty() {
-    this.flags & (y | b) || (this.flags |= b, this._notifySubscribers(void 0, void 0));
+    this.flags & (T | S) || (this.flags |= S, this._notifySubscribers(void 0, void 0));
   }
 }
-function Ut(i, t = {}) {
-  return new At(i, t);
+function yt(i, t = {}) {
+  return new gt(i, t);
 }
-var tt, et;
-class Nt extends (et = rt, tt = ut, et) {
+var W;
+class Dt extends tt {
   constructor(t, e = {}) {
-    super(), this[tt] = !0, this._cleanup = null, this._links = _, this._nextLinks = null, this._prevLinks = null, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._executionCount = 0, this._windowStart = 0, this._windowCount = 0, this._execId = 0, this._fn = t, this._onError = e.onError ?? null, this._sync = e.sync ?? !1, this._maxExecutions = e.maxExecutionsPerSecond ?? S.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = e.maxExecutionsPerFlush ?? S.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = e.trackModifications ?? !1, D.attachDebugInfo(this, "effect", this.id);
+    super(), this[W] = !0, this._cleanup = null, this._links = u, this._nextLinks = null, this._prevLinks = u, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._executionCount = 0, this._windowStart = 0, this._windowCount = 0, this._execId = 0, this._fn = t, this._onError = e.onError ?? null, this._sync = e.sync ?? !1, this._maxExecutions = e.maxExecutionsPerSecond ?? p.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = e.maxExecutionsPerFlush ?? p.MAX_EXECUTIONS_PER_EFFECT, this._sync ? (this._executeTask = void 0, this._notifyCallback = () => this.execute()) : (this._executeTask = () => this.execute(), this._notifyCallback = () => b.schedule(this._executeTask)), L.attachDebugInfo(this, "effect", this.id);
   }
   run() {
     if (this.flags & l.DISPOSED)
-      throw new I(c.EFFECT_DISPOSED);
+      throw new g(c.EFFECT_DISPOSED);
     this.execute(!0);
   }
   dispose() {
-    this.flags & l.DISPOSED || (this.flags |= l.DISPOSED, this._execCleanup(), this._unsubLinks(this._links), this._links !== _ && p.release(this._links), this._links = _, this._executeTask = void 0);
+    this.flags & l.DISPOSED || (this.flags |= l.DISPOSED, this._execCleanup(), this._unsubLinks(this._links), this._links !== u && f.release(this._links), this._links = u, this._prevLinks = u);
+  }
+  [(W = nt, Symbol.dispose)]() {
+    this.dispose();
   }
   addDependency(t) {
-    if (!(this.flags & l.EXECUTING) || t._lastSeenEpoch === this._currentEpoch) return;
-    t._lastSeenEpoch = this._currentEpoch;
-    const e = this._nextLinks, s = this._prevLinks;
-    if (s)
-      for (let n = 0, r = s.length; n < r; n++) {
-        const o = s[n];
-        if (o && o.node === t && o.unsub) {
-          e.push(new R(t, t.version, o.unsub)), o.unsub = void 0;
-          return;
-        }
+    if (!(this.flags & l.EXECUTING)) return;
+    const e = this._currentEpoch;
+    if (t._lastSeenEpoch === e) return;
+    t._lastSeenEpoch = e;
+    const s = this._nextLinks, n = this._prevLinks;
+    for (let r = 0, o = n.length; r < o; r++) {
+      const h = n[r];
+      if (h && h.node === t && h.unsub) {
+        h.version = t.version, s.push(h), n[r] = null;
+        return;
       }
+    }
     try {
-      const n = t.subscribe(() => {
-        if (this._trackModifications && this.flags & l.EXECUTING && (t._modifiedAtEpoch = this._currentEpoch), this._sync) return this.execute();
-        this._executeTask ??= () => this.execute(), N.schedule(this._executeTask);
-      });
-      e.push(new R(t, t.version, n));
-    } catch (n) {
-      const r = T(n, I, c.EFFECT_EXECUTION_FAILED);
-      if (console.error(r), this._onError)
+      const r = t.subscribe(this._notifyCallback);
+      s.push(new v(t, t.version, r));
+    } catch (r) {
+      const o = D(r, g, c.EFFECT_EXECUTION_FAILED);
+      if (console.error(o), this._onError)
         try {
-          this._onError(r);
+          this._onError(o);
         } catch {
         }
-      e.push(new R(t, t.version, void 0));
+      s.push(new v(t, t.version, void 0));
     }
   }
   /**
@@ -737,29 +721,17 @@ class Nt extends (et = rt, tt = ut, et) {
    */
   execute(t = !1) {
     if (this.flags & (l.DISPOSED | l.EXECUTING) || !t && this._links.length > 0 && !this._isDirty()) return;
-    this._checkInfiniteLoops(), this.flags |= l.EXECUTING, this._execCleanup();
-    const e = this._links;
-    this._prevLinks = e !== _ ? e : null;
-    const s = p.acquire();
-    this._nextLinks = s, this._currentEpoch = V();
-    let n = !1;
+    this._checkInfiniteLoops(), this.flags |= l.EXECUTING, this._execCleanup(), this._prevLinks = this._links;
+    const e = f.acquire();
+    this._nextLinks = e, this._currentEpoch = z();
+    let s = !1;
     try {
-      const r = a.run(this, this._fn);
-      if (this._links = s, n = !0, this._trackModifications && D.enabled) {
-        const o = this._currentEpoch;
-        for (let h = 0, f = s.length; h < f; h++) {
-          const C = s[h].node;
-          C._modifiedAtEpoch === o && D.warn(
-            !0,
-            `Effect is reading a dependency (${D.getDebugName(C) || "unknown"}) that it just modified. Infinite loop may occur`
-          );
-        }
-      }
-      lt(r) ? this._handleAsyncResult(r) : this._cleanup = typeof r == "function" ? r : null;
-    } catch (r) {
-      n = !0, this._handleExecutionError(r), this._cleanup = null;
+      const n = _.run(this, this._fn);
+      this._links = e, s = !0, rt(n) ? this._handleAsyncResult(n) : this._cleanup = typeof n == "function" ? n : null;
+    } catch (n) {
+      this._links = e, s = !0, this._handleExecutionError(n), this._cleanup = null;
     } finally {
-      this._finalizeDependencies(n, e, s), this.flags &= -9;
+      this._finalizeDependencies(s, this._prevLinks, e), this.flags &= -9;
     }
   }
   _handleAsyncResult(t) {
@@ -781,37 +753,36 @@ class Nt extends (et = rt, tt = ut, et) {
     );
   }
   _finalizeDependencies(t, e, s) {
-    if (this._nextLinks = null, t) {
-      const n = this._prevLinks;
-      if (n)
-        for (let r = 0, o = n.length; r < o; r++)
-          n[r]?.unsub?.();
-      e !== _ && p.release(e);
+    if (this._nextLinks = null, this._prevLinks = u, t) {
+      for (let n = 0, r = e.length; n < r; n++) {
+        const o = e[n];
+        o && o.unsub?.();
+      }
+      e !== u && f.release(e);
     } else
-      this._unsubLinks(s), p.release(s);
-    this._prevLinks = null;
+      this._unsubLinks(s), f.release(s);
   }
   _unsubLinks(t) {
     for (let e = 0, s = t.length; e < s; e++)
       t[e]?.unsub?.();
   }
   _isDirty() {
-    const t = this._links, e = a.current;
-    a.current = null;
+    const t = this._links, e = _.current;
+    _.current = null;
     try {
       for (let s = 0, n = t.length; s < n; s++) {
         const r = t[s], o = r.node;
-        if (o.flags & st.IS_COMPUTED)
+        if (o.flags & K.IS_COMPUTED)
           try {
             o.value;
           } catch {
-            return u && console.warn(`[atom-effect] Dependency #${o.id} threw during dirty check`), !0;
+            return !0;
           }
         if (o.version !== r.version) return !0;
       }
       return !1;
     } finally {
-      a.current = e;
+      _.current = e;
     }
   }
   _execCleanup() {
@@ -825,16 +796,8 @@ class Nt extends (et = rt, tt = ut, et) {
     }
   }
   _checkInfiniteLoops() {
-    const t = It();
-    if (this._lastFlushEpoch !== t && (this._lastFlushEpoch = t, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), gt() > S.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, u && Number.isFinite(this._maxExecutions)) {
-      const e = Date.now();
-      if (e - this._windowStart >= 1e3)
-        this._windowStart = e, this._windowCount = 1;
-      else if (++this._windowCount > this._maxExecutions) {
-        const s = new I(c.EFFECT_FREQUENCY_LIMIT_EXCEEDED);
-        throw this.dispose(), this._handleExecutionError(s), s;
-      }
-    }
+    const t = at();
+    this._lastFlushEpoch !== t && (this._lastFlushEpoch = t, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), ft() > p.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++;
   }
   get isDisposed() {
     return (this.flags & l.DISPOSED) !== 0;
@@ -846,58 +809,58 @@ class Nt extends (et = rt, tt = ut, et) {
     return (this.flags & l.EXECUTING) !== 0;
   }
   _throwInfiniteLoopError(t) {
-    const e = new I(
+    const e = new g(
       `Infinite loop detected (${t}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${H}`
     );
     throw this.dispose(), console.error(e), e;
   }
   _handleExecutionError(t, e = c.EFFECT_EXECUTION_FAILED) {
-    const s = T(t, I, e);
+    const s = D(t, g, e);
     if (console.error(s), this._onError)
       try {
         this._onError(s);
       } catch (n) {
-        console.error(T(n, I, c.CALLBACK_ERROR_IN_ERROR_HANDLER));
+        console.error(D(n, g, c.CALLBACK_ERROR_IN_ERROR_HANDLER));
       }
   }
 }
-function vt(i, t = {}) {
+function Rt(i, t = {}) {
   if (typeof i != "function")
-    throw new I(c.EFFECT_MUST_BE_FUNCTION);
-  const e = new Nt(i, t);
+    throw new g(c.EFFECT_MUST_BE_FUNCTION);
+  const e = new Dt(i, t);
   return e.execute(), e;
 }
-function wt(i) {
+function kt(i) {
   if (typeof i != "function")
     throw new TypeError("Batch callback must be a function");
-  N.startBatch();
+  b.startBatch();
   try {
     return i();
   } finally {
-    N.endBatch();
+    b.endBatch();
   }
 }
 export {
-  X as ATOM_BRAND,
-  k as AsyncState,
-  O as AtomError,
-  ct as COMPUTED_BRAND,
-  d as ComputedError,
-  _t as DEBUG_CONFIG,
-  D as DEBUG_RUNTIME,
-  ut as EFFECT_BRAND,
-  I as EffectError,
-  kt as POOL_CONFIG,
-  S as SCHEDULER_CONFIG,
+  V as ATOM_BRAND,
+  A as AsyncState,
+  C as AtomError,
+  it as COMPUTED_BRAND,
+  E as ComputedError,
+  ot as DEBUG_CONFIG,
+  L as DEBUG_RUNTIME,
+  nt as EFFECT_BRAND,
+  g as EffectError,
+  Ct as POOL_CONFIG,
+  p as SCHEDULER_CONFIG,
   m as SchedulerError,
-  Lt as atom,
-  wt as batch,
-  Ut as computed,
-  vt as effect,
-  Ft as isAtom,
-  Rt as isComputed,
-  xt as isEffect,
-  N as scheduler,
-  mt as untracked
+  Ot as atom,
+  kt as batch,
+  yt as computed,
+  Rt as effect,
+  bt as isAtom,
+  At as isComputed,
+  Nt as isEffect,
+  b as scheduler,
+  Tt as untracked
 };
 //# sourceMappingURL=index.mjs.map