@but212/atom-effect 0.2.2 → 0.3.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-const C = {
+const R = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
@@ -23,22 +23,32 @@ const C = {
   // 100000 - Currently recomputing
   HAS_ERROR: 64
   // 1000000 - Has error state
-}, X = {
+}, W = {
   /** 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
-}, L = {
-  /** Maximum effect executions per second to detect infinite loops */
+}, N = {
+  /** Maximum effect executions per second to detect infinite loops (Legacy/Fallback) */
   MAX_EXECUTIONS_PER_SECOND: 100,
   /** Threshold for cleaning up old execution timestamps */
-  CLEANUP_THRESHOLD: 100
-}, x = {
+  CLEANUP_THRESHOLD: 100,
+  /**
+   * Maximum executions per effect within a single flush cycle
+   * Increased from 10 to 50 based on evaluation report
+   */
+  MAX_EXECUTIONS_PER_EFFECT: 50,
+  /**
+   * 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
+}, M = {
   /** Maximum dependencies before warning about large dependency graphs */
   MAX_DEPENDENCIES: 1e3,
   /** Enable infinite loop detection warnings */
   WARN_INFINITE_LOOP: !0
-}, I = 1073741823;
+}, I = 1073741823, U = typeof process < "u" && process.env && process.env.NODE_ENV !== "production";
 class _ extends Error {
   /**
    * Creates a new AtomError
@@ -60,7 +70,7 @@ class b extends _ {
     super(e, t, !0), this.name = "ComputedError";
   }
 }
-class p extends _ {
+class E extends _ {
   /**
    * Creates a new EffectError
    * @param message - Error message
@@ -80,7 +90,7 @@ class y extends _ {
     super(e, t, !1), this.name = "SchedulerError";
   }
 }
-function g(i, e, t) {
+function D(i, e, t) {
   if (i instanceof TypeError)
     return new e(`Type error (${t}): ${i.message}`, i);
   if (i instanceof ReferenceError)
@@ -90,10 +100,10 @@ function g(i, e, t) {
   const s = i instanceof Error ? i.message : String(i), n = i instanceof Error ? i : null;
   return new e(`Unexpected error (${t}): ${s}`, n);
 }
-function P(i) {
+function k(i) {
   return i != null && typeof i.then == "function";
 }
-const o = {
+const h = {
   // ─────────────────────────────────────────────────────────────────
   // Computed errors
   // ─────────────────────────────────────────────────────────────────
@@ -178,7 +188,23 @@ const o = {
    */
   CALLBACK_ERROR_IN_ERROR_HANDLER: "Error occurred during onError callback execution"
 };
-class v {
+let A = 0;
+function q() {
+  return A = (A + 1 | 0) & I, A;
+}
+let C = 0, P = 0, T = !1;
+function w() {
+  return T ? (U && console.warn(
+    "Warning: startFlush() called during flush - ignored to prevent infinite loop detection bypass"
+  ), !1) : (T = !0, C = C + 1 & I, P = 0, !0);
+}
+function v() {
+  T = !1;
+}
+function V() {
+  return T ? ++P : 0;
+}
+class X {
   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;
   }
@@ -228,15 +254,16 @@ class v {
     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(() => {
-      for (let s = 0; s < t; s++)
+      const s = w();
+      for (let n = 0; n < t; n++)
         try {
-          e[s]?.();
-        } catch (n) {
+          e[n]?.();
+        } catch (r) {
           console.error(
-            new y("Error occurred during scheduler execution", n)
+            new y("Error occurred during scheduler execution", r)
           );
         }
-      e.length = 0, this.isProcessing = !1, this.queueSize > 0 && !this.isBatching && this.flush();
+      e.length = 0, this.isProcessing = !1, s && v(), this.queueSize > 0 && !this.isBatching && this.flush();
     });
   }
   /**
@@ -254,17 +281,18 @@ class v {
    */
   flushSync() {
     this.isFlushingSync = !0;
+    const e = w();
     try {
       if (this._epoch++, this.batchQueueSize > 0) {
-        for (let t = 0; t < this.batchQueueSize; t++) {
-          const s = this.batchQueue[t];
-          s._nextEpoch !== this._epoch && (s._nextEpoch = this._epoch, this.queue[this.queueSize++] = s);
+        for (let s = 0; s < this.batchQueueSize; s++) {
+          const n = this.batchQueue[s];
+          n._nextEpoch !== this._epoch && (n._nextEpoch = this._epoch, this.queue[this.queueSize++] = n);
         }
         this.batchQueueSize = 0;
       }
-      let e = 0;
+      let t = 0;
       for (; this.queueSize > 0; ) {
-        if (++e > this.maxFlushIterations) {
+        if (++t > this.maxFlushIterations) {
           console.error(
             new y(
               `Maximum flush iterations (${this.maxFlushIterations}) exceeded. Possible infinite loop in reactive dependencies. Consider increasing the limit with scheduler.setMaxFlushIterations()`
@@ -272,24 +300,24 @@ class v {
           ), this.queueSize = 0, this.queue.length = 0, this.batchQueueSize = 0;
           break;
         }
-        const t = this.queue, s = this.queueSize;
+        const s = this.queue, n = this.queueSize;
         this.queue = this.queue === this.queueA ? this.queueB : this.queueA, this.queueSize = 0, this._epoch++;
-        for (let n = 0; n < s; n++)
+        for (let r = 0; r < n; r++)
           try {
-            t[n]?.();
-          } catch (r) {
+            s[r]?.();
+          } catch (u) {
             console.error(
-              new y("Error occurred during batch execution", r)
+              new y("Error occurred during batch execution", u)
             );
           }
-        if (t.length = 0, this.batchQueueSize > 0) {
-          for (let n = 0; n < this.batchQueueSize; n++)
-            this.queue[this.queueSize++] = this.batchQueue[n];
+        if (s.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;
+      this.isFlushingSync = !1, e && v();
     }
   }
   /**
@@ -357,17 +385,17 @@ class v {
     this.maxFlushIterations = e;
   }
 }
-const D = new v();
-function Y(i) {
+const g = new X();
+function K(i) {
   if (typeof i != "function")
     throw new _("Batch callback must be a function");
-  D.startBatch();
+  g.startBatch();
   try {
     return i();
   } catch (e) {
     throw new _("Error occurred during batch execution", e);
   } finally {
-    D.endBatch();
+    g.endBatch();
   }
 }
 const S = {
@@ -391,7 +419,7 @@ const S = {
     return this.current;
   }
 };
-function Q(i) {
+function Z(i) {
   if (typeof i != "function")
     throw new _("Untracked callback must be a function");
   const e = S.current;
@@ -404,11 +432,11 @@ function Q(i) {
     S.current = e;
   }
 }
-const T = /* @__PURE__ */ Symbol("debugName"), B = /* @__PURE__ */ Symbol("id"), A = /* @__PURE__ */ Symbol("type"), U = /* @__PURE__ */ Symbol("noDefaultValue");
-function q(i) {
+const O = /* @__PURE__ */ Symbol("debugName"), j = /* @__PURE__ */ Symbol("id"), x = /* @__PURE__ */ Symbol("type"), B = /* @__PURE__ */ Symbol("noDefaultValue");
+function G(i) {
   return i !== null && typeof i == "object" && "dependencies" in i && i.dependencies instanceof Set;
 }
-const a = {
+const f = {
   /**
    * Whether debug mode is enabled.
    *
@@ -422,13 +450,13 @@ const a = {
    *
    * @see {@link DEBUG_CONFIG.MAX_DEPENDENCIES}
    */
-  maxDependencies: x.MAX_DEPENDENCIES,
+  maxDependencies: M.MAX_DEPENDENCIES,
   /**
    * Whether to warn about potential infinite loops.
    *
    * @see {@link DEBUG_CONFIG.WARN_INFINITE_LOOP}
    */
-  warnInfiniteLoop: x.WARN_INFINITE_LOOP,
+  warnInfiniteLoop: M.WARN_INFINITE_LOOP,
   /**
    * Logs a warning message when condition is true and debug is enabled.
    *
@@ -477,7 +505,7 @@ const a = {
     if (this.enabled) {
       if (t.has(i))
         throw new b("Indirect circular dependency detected");
-      if (t.add(i), q(i))
+      if (t.add(i), G(i))
         for (const s of i.dependencies)
           this.checkCircular(s, e, t);
     }
@@ -506,7 +534,7 @@ const a = {
     if (!this.enabled)
       return;
     const s = i;
-    s[T] = `${e}_${t}`, s[B] = t, s[A] = e;
+    s[O] = `${e}_${t}`, s[j] = t, s[x] = e;
   },
   /**
    * Retrieves the debug display name from a reactive object.
@@ -521,8 +549,8 @@ const a = {
    * ```
    */
   getDebugName(i) {
-    if (i !== null && typeof i == "object" && T in i)
-      return i[T];
+    if (i !== null && typeof i == "object" && O in i)
+      return i[O];
   },
   /**
    * Retrieves the debug type from a reactive object.
@@ -539,13 +567,13 @@ const a = {
    * ```
    */
   getDebugType(i) {
-    if (i !== null && typeof i == "object" && A in i)
-      return i[A];
+    if (i !== null && typeof i == "object" && x in i)
+      return i[x];
   }
 };
-let k = 1;
-const F = () => k++;
-class N {
+let $ = 1;
+const L = () => $++;
+class F {
   constructor() {
     this.subscribers = null;
   }
@@ -678,7 +706,7 @@ class N {
     return this.subscribers ? [...this.subscribers] : [];
   }
 }
-class z {
+class Y {
   /**
    * Creates a new AtomImpl instance.
    *
@@ -686,7 +714,7 @@ class z {
    * @param sync - Whether to notify subscribers synchronously
    */
   constructor(e, t) {
-    this._isNotificationScheduled = !1, this.id = F() & I, this.version = 0, this.flags = 0, this._lastSeenEpoch = -1, this._value = e, this._functionSubscribers = new N(), this._objectSubscribers = new N(), this._sync = t, this._notifyTask = this._flushNotifications.bind(this), a.attachDebugInfo(this, "atom", this.id);
+    this._isNotificationScheduled = !1, this.id = L() & I, this.version = 0, this.flags = 0, this._lastSeenEpoch = -1, this._value = e, this._functionSubscribers = new F(), this._objectSubscribers = new F(), this._sync = t, this._notifyTask = this._flushNotifications.bind(this), f.attachDebugInfo(this, "atom", this.id);
   }
   /**
    * Gets the current value and registers the atom as a dependency
@@ -755,7 +783,7 @@ class z {
    * but don't schedule a new task. The pending task will see the latest value.
    */
   _notify(e, t, s) {
-    this._isNotificationScheduled || (this._pendingOldValue = t, this._isNotificationScheduled = !0), this._sync && !D.isBatching ? this._flushNotifications() : D.schedule(this._notifyTask);
+    this._isNotificationScheduled || (this._pendingOldValue = t, this._isNotificationScheduled = !0), this._sync && !g.isBatching ? this._flushNotifications() : g.schedule(this._notifyTask);
   }
   /**
    * Executes the pending notifications.
@@ -766,10 +794,10 @@ class z {
     const e = this._pendingOldValue, t = this._value;
     this._pendingOldValue = void 0, this._isNotificationScheduled = !1, this._functionSubscribers.forEachSafe(
       (s) => s(t, e),
-      (s) => console.error(new _(o.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, s))
+      (s) => console.error(new _(h.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, s))
     ), this._objectSubscribers.forEachSafe(
       (s) => s.execute(),
-      (s) => console.error(new _(o.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, s))
+      (s) => console.error(new _(h.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, s))
     );
   }
   /**
@@ -789,7 +817,7 @@ class z {
    */
   subscribe(e) {
     if (typeof e != "function")
-      throw new _(o.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
+      throw new _(h.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
     return this._functionSubscribers.add(e);
   }
   /**
@@ -823,44 +851,40 @@ class z {
     return this._functionSubscribers.size + this._objectSubscribers.size;
   }
 }
-function $(i, e = {}) {
-  return new z(i, e.sync ?? !1);
-}
-let O = 0;
-function M() {
-  return O = (O + 1 | 0) & I, O;
+function ee(i, e = {}) {
+  return new Y(i, e.sync ?? !1);
 }
-const f = process.env.NODE_ENV !== "production", l = Object.freeze([]);
-class V {
+const d = process.env.NODE_ENV !== "production", l = Object.freeze([]);
+class Q {
   constructor() {
-    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = f ? {
+    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = d ? {
       acquired: 0,
       released: 0,
       rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
     } : null;
   }
   acquire() {
-    return f && this.stats && this.stats.acquired++, this.pool.pop() ?? [];
+    return d && this.stats && this.stats.acquired++, this.pool.pop() ?? [];
   }
   release(e, t) {
     if (!(t && e === t)) {
       if (Object.isFrozen(e)) {
-        f && this.stats && this.stats.rejected.frozen++;
+        d && this.stats && this.stats.rejected.frozen++;
         return;
       }
       if (e.length > this.maxReusableCapacity) {
-        f && this.stats && this.stats.rejected.tooLarge++;
+        d && this.stats && this.stats.rejected.tooLarge++;
         return;
       }
       if (this.pool.length >= this.maxPoolSize) {
-        f && this.stats && this.stats.rejected.poolFull++;
+        d && this.stats && this.stats.rejected.poolFull++;
         return;
       }
-      e.length = 0, this.pool.push(e), f && this.stats && this.stats.released++;
+      e.length = 0, this.pool.push(e), d && this.stats && this.stats.released++;
     }
   }
   getStats() {
-    if (!f || !this.stats) return null;
+    if (!d || !this.stats) return null;
     const { acquired: e, released: t, rejected: s } = this.stats, n = s.frozen + s.tooLarge + s.poolFull;
     return {
       acquired: e,
@@ -871,15 +895,15 @@ class V {
     };
   }
   reset() {
-    this.pool.length = 0, f && this.stats && (this.stats.acquired = 0, this.stats.released = 0, this.stats.rejected = { frozen: 0, tooLarge: 0, poolFull: 0 });
+    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 E = new V();
-class w {
+const p = new Q();
+class z {
   constructor(e, t = {}) {
     if (typeof e != "function")
-      throw new b(o.COMPUTED_MUST_BE_FUNCTION);
-    if (this.id = F() & I, this.version = 0, this.flags = 0, this._lastSeenEpoch = -1, this._value = void 0, this._stateFlags = 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 : U, this._hasDefaultValue = this._defaultValue !== U, this._onError = t.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._functionSubscribers = new N(), this._objectSubscribers = new N(), this._dependencies = l, this._subscriptions = /* @__PURE__ */ new Map(), this._recomputeJob = () => {
+      throw new b(h.COMPUTED_MUST_BE_FUNCTION);
+    if (this.id = L() & I, this.version = 0, this.flags = 0, this._lastSeenEpoch = -1, this._value = void 0, this._stateFlags = 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 : B, this._hasDefaultValue = this._defaultValue !== B, this._onError = t.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._functionSubscribers = new F(), this._objectSubscribers = new F(), this._dependencies = l, this._subscriptions = /* @__PURE__ */ new Map(), this._recomputeJob = () => {
       if (this._isDirty())
         try {
           this._recompute();
@@ -896,7 +920,7 @@ class w {
     }, this._trackable = Object.assign(() => this._markDirty(), {
       addDependency: (s) => {
       }
-    }), a.attachDebugInfo(this, "computed", this.id), a.enabled) {
+    }), f.attachDebugInfo(this, "computed", this.id), f.enabled) {
       const s = this;
       s.subscriberCount = () => this._functionSubscribers.size + this._objectSubscribers.size, s.isDirty = () => this._isDirty(), s.dependencies = this._dependencies, s.stateFlags = this._getFlagsAsString();
     }
@@ -915,7 +939,7 @@ class w {
   }
   subscribe(e) {
     if (typeof e != "function")
-      throw new b(o.COMPUTED_SUBSCRIBER_MUST_BE_FUNCTION);
+      throw new b(h.COMPUTED_SUBSCRIBER_MUST_BE_FUNCTION);
     return this._functionSubscribers.add(e);
   }
   peek() {
@@ -945,7 +969,7 @@ class w {
         const t = this._subscriptions.get(e.id);
         t && t(), this._subscriptions.delete(e.id);
       }
-      E.release(this._dependencies);
+      p.release(this._dependencies);
     }
     this._dependencies = l, this._functionSubscribers.clear(), this._objectSubscribers.clear(), this._stateFlags = c.DIRTY | c.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID;
   }
@@ -987,10 +1011,11 @@ class w {
     return (this._stateFlags & c.RECOMPUTING) !== 0;
   }
   _setRecomputing(e) {
-    e ? this._stateFlags |= c.RECOMPUTING : this._stateFlags &= -33;
+    const t = c.RECOMPUTING;
+    this._stateFlags = this._stateFlags & ~t | -Number(e) & t;
   }
   _getAsyncState() {
-    return this._isPending() ? C.PENDING : this._isResolved() ? C.RESOLVED : this._isRejected() ? C.REJECTED : C.IDLE;
+    return this._isPending() ? R.PENDING : this._isResolved() ? R.RESOLVED : this._isRejected() ? R.REJECTED : R.IDLE;
   }
   _getFlagsAsString() {
     const e = [];
@@ -1004,24 +1029,24 @@ class w {
     if (!this._isDirty() && this._isResolved())
       return;
     this._setRecomputing(!0);
-    const e = this._dependencies, t = E.acquire(), s = M();
+    const e = this._dependencies, t = p.acquire(), s = q();
     let n = 0;
-    const r = (h) => {
-      h._lastSeenEpoch !== s && (h._lastSeenEpoch = s, n < t.length ? t[n] = h : t.push(h), n++);
+    const r = (o) => {
+      o._lastSeenEpoch !== s && (o._lastSeenEpoch = s, n < t.length ? t[n] = o : t.push(o), n++);
     }, u = this._trackable.addDependency;
     this._trackable.addDependency = r;
-    let d = !1;
+    let a = !1;
     try {
-      const h = S.run(this._trackable, this._fn);
-      if (t.length = n, P(h)) {
-        this._syncDependencies(e, t, s), this._dependencies = t, d = !0, this._handleAsyncComputation(h), this._setRecomputing(!1);
+      const o = S.run(this._trackable, this._fn);
+      if (t.length = n, k(o)) {
+        this._syncDependencies(e, t, s), this._dependencies = t, a = !0, this._handleAsyncComputation(o), this._setRecomputing(!1);
         return;
       }
-      this._syncDependencies(e, t, s), this._dependencies = t, d = !0, this._handleSyncResult(h);
-    } catch (h) {
-      t.length = n, this._syncDependencies(e, t, s), this._dependencies = t, d = !0, this._handleComputationError(h);
+      this._syncDependencies(e, t, s), this._dependencies = t, a = !0, this._handleSyncResult(o);
+    } catch (o) {
+      t.length = n, this._syncDependencies(e, t, s), this._dependencies = t, a = !0, this._handleComputationError(o);
     } finally {
-      this._trackable.addDependency = u, d ? e !== l && E.release(e) : E.release(t);
+      this._trackable.addDependency = u, a ? e !== l && p.release(e) : p.release(t);
     }
   }
   /**
@@ -1040,7 +1065,7 @@ class w {
     for (let n = 0; n < t.length; n++) {
       const r = t[n];
       if (r && !this._subscriptions.has(r.id)) {
-        a.checkCircular(r, this);
+        f.checkCircular(r, this);
         const u = r.subscribe(() => this._markDirty());
         this._subscriptions.set(r.id, u);
       }
@@ -1064,29 +1089,29 @@ class w {
     this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), t && this._notifySubscribers();
   }
   _handleAsyncRejection(e) {
-    const t = g(e, b, o.COMPUTED_ASYNC_COMPUTATION_FAILED);
+    const t = D(e, b, h.COMPUTED_ASYNC_COMPUTATION_FAILED);
     if (this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError && typeof this._onError == "function")
       try {
         this._onError(t);
       } catch (s) {
-        console.error(o.CALLBACK_ERROR_IN_ERROR_HANDLER, s);
+        console.error(h.CALLBACK_ERROR_IN_ERROR_HANDLER, s);
       }
     this._notifySubscribers();
   }
   _handleComputationError(e) {
-    const t = g(e, b, o.COMPUTED_COMPUTATION_FAILED);
+    const t = D(e, b, h.COMPUTED_COMPUTATION_FAILED);
     if (this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError && typeof this._onError == "function")
       try {
         this._onError(t);
       } catch (s) {
-        console.error(o.CALLBACK_ERROR_IN_ERROR_HANDLER, s);
+        console.error(h.CALLBACK_ERROR_IN_ERROR_HANDLER, s);
       }
     throw t;
   }
   _handlePending() {
     if (this._hasDefaultValue)
       return this._defaultValue;
-    throw new b(o.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    throw new b(h.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
   }
   _handleRejected() {
     if (this._error?.recoverable && this._hasDefaultValue)
@@ -1097,10 +1122,10 @@ class w {
   // (Replaced by _syncDependencies and inline pool logic)
   // === PRIVATE: Subscriber Management ===
   _markDirty() {
-    this._isRecomputing() || this._isDirty() || (this._setDirty(), this._setIdle(), (this._functionSubscribers.hasSubscribers || this._objectSubscribers.hasSubscribers) && D.schedule(this._recomputeJob));
+    this._isRecomputing() || this._isDirty() || (this._setDirty(), this._setIdle(), (this._functionSubscribers.hasSubscribers || this._objectSubscribers.hasSubscribers) && g.schedule(this._recomputeJob));
   }
   _notifySubscribers() {
-    !this._functionSubscribers.hasSubscribers && !this._objectSubscribers.hasSubscribers || D.schedule(this._notifyJob);
+    !this._functionSubscribers.hasSubscribers && !this._objectSubscribers.hasSubscribers || g.schedule(this._notifyJob);
   }
   _registerTracking() {
     const e = S.getCurrent();
@@ -1113,15 +1138,15 @@ class w {
       } else e.execute && this._objectSubscribers.add(e);
   }
 }
-Object.freeze(w.prototype);
-function J(i, e = {}) {
-  return new w(i, e);
+Object.freeze(z.prototype);
+function te(i, e = {}) {
+  return new z(i, e);
 }
-class j {
+class H {
   constructor(e, t = {}) {
     this.run = () => {
       if (this.isDisposed)
-        throw new p(o.EFFECT_MUST_BE_FUNCTION);
+        throw new E(h.EFFECT_MUST_BE_FUNCTION);
       this.execute();
     }, this.dispose = () => {
       if (!this.isDisposed && (this._setDisposed(), this._safeCleanup(), this._dependencies !== l)) {
@@ -1129,7 +1154,7 @@ class j {
           const n = this._subscriptions.get(s.id);
           n && n(), this._subscriptions.delete(s.id);
         }
-        E.release(this._dependencies), this._dependencies = l;
+        p.release(this._dependencies), this._dependencies = l;
       }
     }, this.addDependency = (s) => {
       if (this.isExecuting && this._nextDeps) {
@@ -1139,24 +1164,23 @@ class j {
       }
     }, this.execute = () => {
       if (this.isDisposed || this.isExecuting) return;
-      const s = Date.now();
-      this._recordExecution(s), this._setExecuting(!0), this._safeCleanup(), this._modifiedDeps.clear();
-      const n = this._dependencies, r = E.acquire(), u = M();
-      this._nextDeps = r, this._currentEpoch = u;
-      let d = !1;
+      this._checkInfiniteLoop(), this._setExecuting(!0), this._safeCleanup(), this._modifiedDeps.clear();
+      const s = this._dependencies, n = p.acquire(), r = q();
+      this._nextDeps = n, this._currentEpoch = r;
+      let u = !1;
       try {
-        const h = S.run(this, this._fn);
-        this._syncDependencies(n, u), this._dependencies = r, d = !0, this._checkLoopWarnings(), P(h) ? h.then((R) => {
-          !this.isDisposed && typeof R == "function" && (this._cleanup = R);
-        }).catch((R) => {
-          console.error(g(R, p, o.EFFECT_EXECUTION_FAILED));
-        }) : this._cleanup = typeof h == "function" ? h : null;
-      } catch (h) {
-        this._syncDependencies(n, u), this._dependencies = r, d = !0, console.error(g(h, p, o.EFFECT_EXECUTION_FAILED)), this._cleanup = null;
+        const a = S.run(this, this._fn);
+        this._syncDependencies(s, r), this._dependencies = n, u = !0, this._checkLoopWarnings(), k(a) ? a.then((o) => {
+          !this.isDisposed && typeof o == "function" && (this._cleanup = o);
+        }).catch((o) => {
+          console.error(D(o, E, h.EFFECT_EXECUTION_FAILED));
+        }) : this._cleanup = typeof a == "function" ? a : null;
+      } catch (a) {
+        this._syncDependencies(s, r), this._dependencies = n, u = !0, console.error(D(a, E, h.EFFECT_EXECUTION_FAILED)), this._cleanup = null;
       } finally {
-        this._setExecuting(!1), this._nextDeps = null, d ? n !== l && E.release(n) : E.release(r);
+        this._setExecuting(!1), this._nextDeps = null, u ? s !== l && p.release(s) : p.release(n);
       }
-    }, this._id = F() & I, this._flags = 0, this._currentEpoch = -1, this._fn = e, this._sync = t.sync ?? !1, this._maxExecutions = t.maxExecutionsPerSecond ?? L.MAX_EXECUTIONS_PER_SECOND, this._trackModifications = t.trackModifications ?? !1, this._cleanup = null, this._dependencies = l, this._subscriptions = /* @__PURE__ */ new Map(), this._nextDeps = null, this._modifiedDeps = /* @__PURE__ */ new Set(), this._historyCapacity = this._maxExecutions + 5, this._history = new Float64Array(this._historyCapacity), this._historyIdx = 0, this._historyCount = 0, this._executionCount = 0, a.attachDebugInfo(this, "effect", this._id);
+    }, this._id = L() & I, this._flags = 0, this._currentEpoch = -1, this._fn = e, this._sync = t.sync ?? !1, this._maxExecutions = t.maxExecutionsPerSecond ?? N.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = t.maxExecutionsPerFlush ?? N.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = t.trackModifications ?? !1, this._cleanup = null, this._dependencies = l, this._subscriptions = /* @__PURE__ */ new Map(), this._nextDeps = null, this._modifiedDeps = /* @__PURE__ */ new Set(), this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._history = U ? [] : null, this._executionCount = 0, f.attachDebugInfo(this, "effect", this._id);
   }
   /**
    * Synchronizes subscriptions by unsubscribing from removed dependencies.
@@ -1178,11 +1202,11 @@ class j {
   _subscribeTo(e) {
     try {
       const t = e.subscribe(() => {
-        this._trackModifications && this.isExecuting && this._modifiedDeps.add(e), this._sync ? this.execute() : D.schedule(this.execute);
+        this._trackModifications && this.isExecuting && this._modifiedDeps.add(e), this._sync ? this.execute() : g.schedule(this.execute);
       });
       this._subscriptions.set(e.id, t);
     } catch (t) {
-      console.error(g(t, p, o.EFFECT_EXECUTION_FAILED));
+      console.error(D(t, E, h.EFFECT_EXECUTION_FAILED));
     }
   }
   /**
@@ -1272,7 +1296,8 @@ class j {
    * @internal
    */
   _setExecuting(e) {
-    e ? this._flags |= m.EXECUTING : this._flags &= -3;
+    const t = m.EXECUTING;
+    this._flags = this._flags & ~t | -Number(e) & t;
   }
   /**
    * Safely executes the cleanup function if one exists.
@@ -1292,42 +1317,45 @@ class j {
       try {
         this._cleanup();
       } catch (e) {
-        console.error(g(e, p, o.EFFECT_CLEANUP_FAILED));
+        console.error(D(e, E, h.EFFECT_CLEANUP_FAILED));
       }
       this._cleanup = null;
     }
   }
   /**
-   * Records an execution timestamp and checks for infinite loop conditions.
-   *
-   * @param now - The current timestamp in milliseconds (from `Date.now()`)
-   *
-   * @remarks
-   * This method implements a circular buffer to track recent execution
-   * timestamps. If the number of executions within the last second exceeds
-   * `_maxExecutions`, the effect is disposed and an error is thrown (in debug mode)
-   * or logged (in production mode).
-   *
-   * The circular buffer approach provides O(1) insertion and efficient
-   * memory usage for tracking execution history.
-   *
-   * @throws {EffectError} In debug mode, throws when infinite loop is detected
+   * Checks for infinite loop conditions using epoch-based detection.
+   * Falls back to timestamp-based detection in development mode.
    *
+   * @throws {EffectError} When infinite loop is detected
    * @internal
    */
-  _recordExecution(e) {
-    if (this._maxExecutions <= 0) return;
-    const t = e - 1e3;
-    this._history[this._historyIdx] = e, this._historyIdx = (this._historyIdx + 1) % this._historyCapacity, this._historyCount < this._historyCapacity && this._historyCount++, this._executionCount++;
-    let s = 0, n = (this._historyIdx - 1 + this._historyCapacity) % this._historyCapacity;
-    for (let r = 0; r < this._historyCount && !(this._history[n] < t); r++)
-      s++, n = (n - 1 + this._historyCapacity) % this._historyCapacity;
-    if (s > this._maxExecutions) {
-      const r = `Effect executed ${s} times within 1 second. Infinite loop suspected`, u = new p(r);
-      if (this.dispose(), console.error(u), a.enabled)
-        throw u;
+  _checkInfiniteLoop() {
+    if (this._lastFlushEpoch !== C && (this._lastFlushEpoch = C, this._executionsInEpoch = 0), this._executionsInEpoch++, this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), V() > N.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history) {
+      const e = Date.now();
+      this._history.push(e), this._history.length > N.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;
+    let n = 0;
+    for (let r = t.length - 1; r >= 0 && !(t[r] < s); r--)
+      n++;
+    if (n > this._maxExecutions) {
+      const r = new E(
+        `Effect executed ${n} times within 1 second. Infinite loop suspected`
+      );
+      if (this.dispose(), console.error(r), U)
+        throw r;
+    }
+  }
+  _throwInfiniteLoopError(e) {
+    const t = new E(
+      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${P}`
+    );
+    throw this.dispose(), console.error(t), t;
+  }
   /**
    * Checks for and warns about potential infinite loop patterns.
    *
@@ -1342,56 +1370,56 @@ class j {
    * @internal
    */
   _checkLoopWarnings() {
-    if (this._trackModifications && a.enabled) {
+    if (this._trackModifications && f.enabled) {
       const e = this._dependencies;
       for (let t = 0; t < e.length; t++) {
         const s = e[t];
-        s && this._modifiedDeps.has(s) && a.warn(
+        s && this._modifiedDeps.has(s) && f.warn(
           !0,
-          `Effect is reading a dependency (${a.getDebugName(s) || "unknown"}) that it just modified. Infinite loop may occur`
+          `Effect is reading a dependency (${f.getDebugName(s) || "unknown"}) that it just modified. Infinite loop may occur`
         );
       }
     }
   }
 }
-function H(i, e = {}) {
+function se(i, e = {}) {
   if (typeof i != "function")
-    throw new p(o.EFFECT_MUST_BE_FUNCTION);
-  const t = new j(i, e);
+    throw new E(h.EFFECT_MUST_BE_FUNCTION);
+  const t = new H(i, e);
   return t.execute(), t;
 }
-function G(i) {
+function J(i) {
   return i !== null && typeof i == "object" && "value" in i && "subscribe" in i && typeof i.subscribe == "function";
 }
-function W(i) {
-  if (a.enabled) {
-    const e = a.getDebugType(i);
+function ie(i) {
+  if (f.enabled) {
+    const e = f.getDebugType(i);
     if (e)
       return e === "computed";
   }
-  return G(i) && "invalidate" in i && typeof i.invalidate == "function";
+  return J(i) && "invalidate" in i && typeof i.invalidate == "function";
 }
-function K(i) {
+function ne(i) {
   return i !== null && typeof i == "object" && "dispose" in i && "run" in i && typeof i.dispose == "function" && typeof i.run == "function";
 }
 export {
-  C as AsyncState,
+  R as AsyncState,
   _ as AtomError,
   b as ComputedError,
-  x as DEBUG_CONFIG,
-  a as DEBUG_RUNTIME,
-  p as EffectError,
-  X as POOL_CONFIG,
-  L as SCHEDULER_CONFIG,
+  M as DEBUG_CONFIG,
+  f as DEBUG_RUNTIME,
+  E as EffectError,
+  W as POOL_CONFIG,
+  N as SCHEDULER_CONFIG,
   y as SchedulerError,
-  $ as atom,
-  Y as batch,
-  J as computed,
-  H as effect,
-  G as isAtom,
-  W as isComputed,
-  K as isEffect,
-  D as scheduler,
-  Q as untracked
+  ee as atom,
+  K as batch,
+  te as computed,
+  se as effect,
+  J as isAtom,
+  ie as isComputed,
+  ne as isEffect,
+  g as scheduler,
+  Z as untracked
 };
 //# sourceMappingURL=index.mjs.map