@but212/atom-effect 0.2.2 → 0.3.1

package/dist/index.mjs

@@ -1,14 +1,14 @@
-const C = {
+const T = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
   REJECTED: "rejected"
-}, m = {
+}, F = {
   DISPOSED: 1,
   // 0001 - Effect has been disposed
   EXECUTING: 2
   // 0010 - Effect is currently executing
-}, c = {
+}, h = {
   DIRTY: 1,
   // 0001 - Needs recomputation
   IDLE: 2,
@@ -23,23 +23,33 @@ const C = {
   // 100000 - Currently recomputing
   HAS_ERROR: 64
   // 1000000 - Has error state
-}, X = {
+}, ie = {
   /** 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 */
+}, U = {
+  /** 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
+}, k = {
   /** Maximum dependencies before warning about large dependency graphs */
   MAX_DEPENDENCIES: 1e3,
   /** Enable infinite loop detection warnings */
   WARN_INFINITE_LOOP: !0
-}, I = 1073741823;
-class _ extends Error {
+}, N = 1073741823, w = typeof process < "u" && process.env && process.env.NODE_ENV !== "production";
+class d extends Error {
   /**
    * Creates a new AtomError
    * @param message - Error message describing what went wrong
@@ -50,7 +60,7 @@ class _ extends Error {
     super(e), this.name = "AtomError", this.cause = t, this.recoverable = s, this.timestamp = /* @__PURE__ */ new Date();
   }
 }
-class b extends _ {
+class D extends d {
   /**
    * Creates a new ComputedError
    * @param message - Error message
@@ -60,7 +70,7 @@ class b extends _ {
     super(e, t, !0), this.name = "ComputedError";
   }
 }
-class p extends _ {
+class S extends d {
   /**
    * Creates a new EffectError
    * @param message - Error message
@@ -70,7 +80,7 @@ class p extends _ {
     super(e, t, !1), this.name = "EffectError";
   }
 }
-class y extends _ {
+class C extends d {
   /**
    * Creates a new SchedulerError
    * @param message - Error message
@@ -80,20 +90,20 @@ class y extends _ {
     super(e, t, !1), this.name = "SchedulerError";
   }
 }
-function g(i, e, t) {
+function R(i, e, t) {
   if (i instanceof TypeError)
     return new e(`Type error (${t}): ${i.message}`, i);
   if (i instanceof ReferenceError)
     return new e(`Reference error (${t}): ${i.message}`, i);
-  if (i instanceof _)
+  if (i instanceof d)
     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 P(i) {
+function X(i) {
   return i != null && typeof i.then == "function";
 }
-const o = {
+const a = {
   // ─────────────────────────────────────────────────────────────────
   // Computed errors
   // ─────────────────────────────────────────────────────────────────
@@ -102,9 +112,9 @@ const o = {
    */
   COMPUTED_MUST_BE_FUNCTION: "Computed function must be a function",
   /**
-   * Error thrown when subscribe() receives a non-function listener.
+   * Error thrown when subscribe() receives an invalid listener.
    */
-  COMPUTED_SUBSCRIBER_MUST_BE_FUNCTION: "Subscriber listener must be a function",
+  COMPUTED_SUBSCRIBER_MUST_BE_FUNCTION: "Subscriber listener must be a function or Subscriber object",
   /**
    * Error thrown when accessing a pending async computed without a default value.
    */
@@ -125,9 +135,9 @@ const o = {
   // Atom errors
   // ─────────────────────────────────────────────────────────────────
   /**
-   * Error thrown when atom.subscribe() receives a non-function listener.
+   * Error thrown when atom.subscribe() receives an invalid listener.
    */
-  ATOM_SUBSCRIBER_MUST_BE_FUNCTION: "Subscription listener must be a function",
+  ATOM_SUBSCRIBER_MUST_BE_FUNCTION: "Subscription listener must be a function or Subscriber object",
   /**
    * Error thrown when the atom subscriber notification process fails.
    */
@@ -178,7 +188,23 @@ const o = {
    */
   CALLBACK_ERROR_IN_ERROR_HANDLER: "Error occurred during onError callback execution"
 };
-class v {
+let P = 0;
+function G() {
+  return P = (P + 1 | 0) & N, P;
+}
+let A = 0, v = 0, O = !1;
+function q() {
+  return O ? (w && console.warn(
+    "Warning: startFlush() called during flush - ignored to prevent infinite loop detection bypass"
+  ), !1) : (O = !0, A = A + 1 & N, v = 0, !0);
+}
+function z() {
+  O = !1;
+}
+function H() {
+  return O ? ++v : 0;
+}
+class J {
   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;
   }
@@ -208,7 +234,7 @@ class v {
    */
   schedule(e) {
     if (typeof e != "function")
-      throw new y("Scheduler callback must be a function");
+      throw new C("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()));
   }
   /**
@@ -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 = q();
+      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 C("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 && z(), this.queueSize > 0 && !this.isBatching && this.flush();
     });
   }
   /**
@@ -254,42 +281,43 @@ class v {
    */
   flushSync() {
     this.isFlushingSync = !0;
+    const e = q();
     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(
+            new C(
               `Maximum flush iterations (${this.maxFlushIterations}) exceeded. Possible infinite loop in reactive dependencies. Consider increasing the limit with scheduler.setMaxFlushIterations()`
             )
           ), 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 (c) {
             console.error(
-              new y("Error occurred during batch execution", r)
+              new C("Error occurred during batch execution", c)
             );
           }
-        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 && z();
     }
   }
   /**
@@ -353,24 +381,24 @@ class v {
    */
   setMaxFlushIterations(e) {
     if (e < 10)
-      throw new y("Max flush iterations must be at least 10");
+      throw new C("Max flush iterations must be at least 10");
     this.maxFlushIterations = e;
   }
 }
-const D = new v();
-function Y(i) {
+const m = new J();
+function ne(i) {
   if (typeof i != "function")
-    throw new _("Batch callback must be a function");
-  D.startBatch();
+    throw new d("Batch callback must be a function");
+  m.startBatch();
   try {
     return i();
   } catch (e) {
-    throw new _("Error occurred during batch execution", e);
+    throw new d("Error occurred during batch execution", e);
   } finally {
-    D.endBatch();
+    m.endBatch();
   }
 }
-const S = {
+const y = {
   /** @inheritdoc */
   current: null,
   /**
@@ -391,24 +419,37 @@ const S = {
     return this.current;
   }
 };
-function Q(i) {
+function re(i) {
   if (typeof i != "function")
-    throw new _("Untracked callback must be a function");
-  const e = S.current;
-  S.current = null;
+    throw new d("Untracked callback must be a function");
+  const e = y.current;
+  y.current = null;
   try {
     return i();
   } catch (t) {
-    throw new _("Error occurred during untracked execution", t);
+    throw new d("Error occurred during untracked execution", t);
   } finally {
-    S.current = e;
+    y.current = e;
   }
 }
-const T = /* @__PURE__ */ Symbol("debugName"), B = /* @__PURE__ */ Symbol("id"), A = /* @__PURE__ */ Symbol("type"), U = /* @__PURE__ */ Symbol("noDefaultValue");
-function q(i) {
-  return i !== null && typeof i == "object" && "dependencies" in i && i.dependencies instanceof Set;
+const L = /* @__PURE__ */ Symbol("debugName"), W = /* @__PURE__ */ Symbol("id"), M = /* @__PURE__ */ Symbol("type"), j = /* @__PURE__ */ Symbol("noDefaultValue");
+function K(i) {
+  return i !== null && typeof i == "object" && "dependencies" in i && Array.isArray(i.dependencies);
 }
-const a = {
+let V = 0;
+function Y(i, e, t) {
+  const s = i;
+  if (s._visitedEpoch !== t) {
+    if (s._visitedEpoch = t, i === e)
+      throw new D("Indirect circular dependency detected");
+    if (K(i)) {
+      const n = i.dependencies;
+      for (let r = 0; r < n.length; r++)
+        Y(n[r], e, t);
+    }
+  }
+}
+const b = {
   /**
    * Whether debug mode is enabled.
    *
@@ -422,13 +463,13 @@ const a = {
    *
    * @see {@link DEBUG_CONFIG.MAX_DEPENDENCIES}
    */
-  maxDependencies: x.MAX_DEPENDENCIES,
+  maxDependencies: k.MAX_DEPENDENCIES,
   /**
    * Whether to warn about potential infinite loops.
    *
    * @see {@link DEBUG_CONFIG.WARN_INFINITE_LOOP}
    */
-  warnInfiniteLoop: x.WARN_INFINITE_LOOP,
+  warnInfiniteLoop: k.WARN_INFINITE_LOOP,
   /**
    * Logs a warning message when condition is true and debug is enabled.
    *
@@ -471,16 +512,10 @@ const a = {
    * debug.checkCircular(computedC, computedA);
    * ```
    */
-  checkCircular(i, e, t = /* @__PURE__ */ new Set()) {
+  checkCircular(i, e, t) {
     if (i === e)
-      throw new b("Direct circular dependency detected");
-    if (this.enabled) {
-      if (t.has(i))
-        throw new b("Indirect circular dependency detected");
-      if (t.add(i), q(i))
-        for (const s of i.dependencies)
-          this.checkCircular(s, e, t);
-    }
+      throw new D("Direct circular dependency detected");
+    this.enabled && (V++, Y(i, e, V));
   },
   /**
    * Attaches debug metadata to a reactive object.
@@ -506,7 +541,7 @@ const a = {
     if (!this.enabled)
       return;
     const s = i;
-    s[T] = `${e}_${t}`, s[B] = t, s[A] = e;
+    s[L] = `${e}_${t}`, s[W] = t, s[M] = e;
   },
   /**
    * Retrieves the debug display name from a reactive object.
@@ -521,8 +556,8 @@ const a = {
    * ```
    */
   getDebugName(i) {
-    if (i !== null && typeof i == "object" && T in i)
-      return i[T];
+    if (i !== null && typeof i == "object" && L in i)
+      return i[L];
   },
   /**
    * Retrieves the debug type from a reactive object.
@@ -539,13 +574,13 @@ const a = {
    * ```
    */
   getDebugType(i) {
-    if (i !== null && typeof i == "object" && A in i)
-      return i[A];
+    if (i !== null && typeof i == "object" && M in i)
+      return i[M];
   }
 };
-let k = 1;
-const F = () => k++;
-class N {
+let Z = 1;
+const B = () => Z++;
+class x {
   constructor() {
     this.subscribers = null;
   }
@@ -678,7 +713,7 @@ class N {
     return this.subscribers ? [...this.subscribers] : [];
   }
 }
-class z {
+class ee {
   /**
    * Creates a new AtomImpl instance.
    *
@@ -686,7 +721,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 = B() & N, this.version = 0, this.flags = 0, this._lastSeenEpoch = -1, this._value = e, this._functionSubscribers = new x(), this._objectSubscribers = new x(), this._sync = t, this._notifyTask = this._flushNotifications.bind(this), b.attachDebugInfo(this, "atom", this.id);
   }
   /**
    * Gets the current value and registers the atom as a dependency
@@ -699,7 +734,7 @@ class z {
    * a computed or effect context.
    */
   get value() {
-    const e = S.getCurrent();
+    const e = y.getCurrent();
     return e != null && this._track(e), this._value;
   }
   /**
@@ -715,7 +750,7 @@ class z {
   set value(e) {
     if (Object.is(this._value, e)) return;
     const t = this._value;
-    this.version = this.version + 1 & I;
+    this.version = this.version + 1 & N;
     const s = this.version;
     this._value = e, !(!this._functionSubscribers.hasSubscribers && !this._objectSubscribers.hasSubscribers) && this._notify(e, t, s);
   }
@@ -755,7 +790,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 && !m.isBatching ? this._flushNotifications() : m.schedule(this._notifyTask);
   }
   /**
    * Executes the pending notifications.
@@ -766,18 +801,18 @@ 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 d(a.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 d(a.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, s))
     );
   }
   /**
-   * Subscribes a listener function to value changes.
+   * Subscribes a listener function or Subscriber object to value changes.
    *
-   * @param listener - Function to call when the value changes
+   * @param listener - Function or Subscriber object to call when the value changes
    * @returns An unsubscribe function
-   * @throws {AtomError} If listener is not a function
+   * @throws {AtomError} If listener is not a function or Subscriber
    *
    * @example
    * ```ts
@@ -788,8 +823,10 @@ class z {
    * ```
    */
   subscribe(e) {
+    if (typeof e == "object" && e !== null && "execute" in e)
+      return this._objectSubscribers.add(e);
     if (typeof e != "function")
-      throw new _(o.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
+      throw new d(a.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
     return this._functionSubscribers.add(e);
   }
   /**
@@ -823,44 +860,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 ce(i, e = {}) {
+  return new ee(i, e.sync ?? !1);
 }
-const f = process.env.NODE_ENV !== "production", l = Object.freeze([]);
-class V {
+const p = process.env.NODE_ENV !== "production", f = Object.freeze([]), E = Object.freeze([]);
+class $ {
   constructor() {
-    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = f ? {
+    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = p ? {
       acquired: 0,
       released: 0,
       rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
     } : null;
   }
   acquire() {
-    return f && this.stats && this.stats.acquired++, this.pool.pop() ?? [];
+    return p && 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++;
+        p && this.stats && this.stats.rejected.frozen++;
         return;
       }
       if (e.length > this.maxReusableCapacity) {
-        f && this.stats && this.stats.rejected.tooLarge++;
+        p && this.stats && this.stats.rejected.tooLarge++;
         return;
       }
       if (this.pool.length >= this.maxPoolSize) {
-        f && this.stats && this.stats.rejected.poolFull++;
+        p && 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), p && this.stats && this.stats.released++;
     }
   }
   getStats() {
-    if (!f || !this.stats) return null;
+    if (!p || !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 +904,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, p && 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 g = new $(), I = new $();
+class Q {
   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 D(a.COMPUTED_MUST_BE_FUNCTION);
+    if (this.id = B() & N, this.version = 0, this.flags = 0, this._lastSeenEpoch = -1, this._value = void 0, this._stateFlags = h.DIRTY | h.IDLE, this._error = null, this._promiseId = 0, this._equal = t.equal ?? Object.is, this._fn = e, this._defaultValue = "defaultValue" in t ? t.defaultValue : j, this._hasDefaultValue = this._defaultValue !== j, this._onError = t.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._functionSubscribers = new x(), this._objectSubscribers = new x(), this._dependencies = f, this._unsubscribes = E, this._recomputeJob = () => {
       if (this._isDirty())
         try {
           this._recompute();
@@ -896,7 +929,7 @@ class w {
     }, this._trackable = Object.assign(() => this._markDirty(), {
       addDependency: (s) => {
       }
-    }), a.attachDebugInfo(this, "computed", this.id), a.enabled) {
+    }), b.attachDebugInfo(this, "computed", this.id), b.enabled) {
       const s = this;
       s.subscriberCount = () => this._functionSubscribers.size + this._objectSubscribers.size, s.isDirty = () => this._isDirty(), s.dependencies = this._dependencies, s.stateFlags = this._getFlagsAsString();
     }
@@ -908,14 +941,16 @@ class w {
   }
   // === PUBLIC API ===
   get value() {
-    if ((this._stateFlags & (c.RESOLVED | c.DIRTY)) === c.RESOLVED)
+    if ((this._stateFlags & (h.RESOLVED | h.DIRTY)) === h.RESOLVED)
       return this._registerTracking(), this._value;
     const t = this._computeValue();
     return this._registerTracking(), t;
   }
   subscribe(e) {
+    if (typeof e == "object" && e !== null && "execute" in e)
+      return this._objectSubscribers.add(e);
     if (typeof e != "function")
-      throw new b(o.COMPUTED_SUBSCRIBER_MUST_BE_FUNCTION);
+      throw new D(a.COMPUTED_SUBSCRIBER_MUST_BE_FUNCTION);
     return this._functionSubscribers.add(e);
   }
   peek() {
@@ -940,57 +975,58 @@ class w {
     this._markDirty();
   }
   dispose() {
-    if (this._dependencies !== l) {
-      for (const e of this._dependencies) {
-        const t = this._subscriptions.get(e.id);
-        t && t(), this._subscriptions.delete(e.id);
+    if (this._unsubscribes !== E) {
+      for (let e = 0; e < this._unsubscribes.length; e++) {
+        const t = this._unsubscribes[e];
+        t && t();
       }
-      E.release(this._dependencies);
+      I.release(this._unsubscribes), this._unsubscribes = E;
     }
-    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;
+    this._dependencies !== f && (g.release(this._dependencies), this._dependencies = f), this._functionSubscribers.clear(), this._objectSubscribers.clear(), this._stateFlags = h.DIRTY | h.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID;
   }
   // === PRIVATE: State Flag Operations (inlined for performance) ===
   _isDirty() {
-    return (this._stateFlags & c.DIRTY) !== 0;
+    return (this._stateFlags & h.DIRTY) !== 0;
   }
   _setDirty() {
-    this._stateFlags |= c.DIRTY;
+    this._stateFlags |= h.DIRTY;
   }
   _clearDirty() {
     this._stateFlags &= -2;
   }
   _isIdle() {
-    return (this._stateFlags & c.IDLE) !== 0;
+    return (this._stateFlags & h.IDLE) !== 0;
   }
   _setIdle() {
-    this._stateFlags |= c.IDLE, this._stateFlags &= -29;
+    this._stateFlags |= h.IDLE, this._stateFlags &= -29;
   }
   _isPending() {
-    return (this._stateFlags & c.PENDING) !== 0;
+    return (this._stateFlags & h.PENDING) !== 0;
   }
   _setPending() {
-    this._stateFlags |= c.PENDING, this._stateFlags &= -27;
+    this._stateFlags |= h.PENDING, this._stateFlags &= -27;
   }
   _isResolved() {
-    return (this._stateFlags & c.RESOLVED) !== 0;
+    return (this._stateFlags & h.RESOLVED) !== 0;
   }
   _setResolved() {
-    this._stateFlags |= c.RESOLVED, this._stateFlags &= -87;
+    this._stateFlags |= h.RESOLVED, this._stateFlags &= -87;
   }
   _isRejected() {
-    return (this._stateFlags & c.REJECTED) !== 0;
+    return (this._stateFlags & h.REJECTED) !== 0;
   }
   _setRejected() {
-    this._stateFlags |= c.REJECTED | c.HAS_ERROR, this._stateFlags &= -15;
+    this._stateFlags |= h.REJECTED | h.HAS_ERROR, this._stateFlags &= -15;
   }
   _isRecomputing() {
-    return (this._stateFlags & c.RECOMPUTING) !== 0;
+    return (this._stateFlags & h.RECOMPUTING) !== 0;
   }
   _setRecomputing(e) {
-    e ? this._stateFlags |= c.RECOMPUTING : this._stateFlags &= -33;
+    const t = h.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() ? T.PENDING : this._isResolved() ? T.RESOLVED : this._isRejected() ? T.REJECTED : T.IDLE;
   }
   _getFlagsAsString() {
     const e = [];
@@ -1004,47 +1040,52 @@ 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 = g.acquire(), s = G();
     let n = 0;
-    const r = (h) => {
-      h._lastSeenEpoch !== s && (h._lastSeenEpoch = s, n < t.length ? t[n] = h : t.push(h), n++);
-    }, u = this._trackable.addDependency;
+    const r = (_) => {
+      _._lastSeenEpoch !== s && (_._lastSeenEpoch = s, n < t.length ? t[n] = _ : t.push(_), n++);
+    }, c = this._trackable.addDependency;
     this._trackable.addDependency = r;
-    let d = !1;
+    let o = !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 _ = y.run(this._trackable, this._fn);
+      if (t.length = n, X(_)) {
+        this._syncDependencies(e, t, this._unsubscribes, s), this._dependencies = t, o = !0, this._handleAsyncComputation(_), 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, this._unsubscribes, s), this._dependencies = t, o = !0, this._handleSyncResult(_);
+    } catch (_) {
+      t.length = n, this._syncDependencies(e, t, this._unsubscribes, s), this._dependencies = t, this._handleComputationError(_);
     } finally {
-      this._trackable.addDependency = u, d ? e !== l && E.release(e) : E.release(t);
+      this._trackable.addDependency = c, o ? e !== f && g.release(e) : g.release(t);
     }
   }
   /**
    * Synchronizes subscriptions based on dependency changes.
    * O(N) Diff using Epoch.
    */
-  _syncDependencies(e, t, s) {
-    if (e !== l)
-      for (let n = 0; n < e.length; n++) {
-        const r = e[n];
-        if (r && r._lastSeenEpoch !== s) {
-          const u = this._subscriptions.get(r.id);
-          u && (u(), this._subscriptions.delete(r.id));
-        }
-      }
-    for (let n = 0; n < t.length; n++) {
-      const r = t[n];
-      if (r && !this._subscriptions.has(r.id)) {
-        a.checkCircular(r, this);
-        const u = r.subscribe(() => this._markDirty());
-        this._subscriptions.set(r.id, u);
+  /**
+   * Synchronizes subscriptions based on dependency changes using O(N) strategy.
+   * Maps unsubs 1:1 with dependencies array.
+   */
+  _syncDependencies(e, t, s, n) {
+    if (e !== f && s !== E)
+      for (let c = 0; c < e.length; c++) {
+        const o = e[c];
+        o && (o._tempUnsub = s[c]);
       }
+    const r = I.acquire();
+    r.length = t.length;
+    for (let c = 0; c < t.length; c++) {
+      const o = t[c];
+      o && (o._tempUnsub ? (r[c] = o._tempUnsub, o._tempUnsub = void 0) : (b.checkCircular(o, this), r[c] = o.subscribe(this)));
     }
+    if (e !== f)
+      for (let c = 0; c < e.length; c++) {
+        const o = e[c];
+        o?._tempUnsub && (o._tempUnsub(), o._tempUnsub = void 0);
+      }
+    s !== E && I.release(s), this._unsubscribes = r;
   }
   _handleSyncResult(e) {
     const t = !this._isResolved() || !this._equal(this._value, e);
@@ -1064,29 +1105,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 = R(e, D, a.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(a.CALLBACK_ERROR_IN_ERROR_HANDLER, s);
       }
     this._notifySubscribers();
   }
   _handleComputationError(e) {
-    const t = g(e, b, o.COMPUTED_COMPUTATION_FAILED);
+    const t = R(e, D, a.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(a.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 D(a.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
   }
   _handleRejected() {
     if (this._error?.recoverable && this._hasDefaultValue)
@@ -1096,14 +1137,21 @@ class w {
   // === PRIVATE: Dependency Management ===
   // (Replaced by _syncDependencies and inline pool logic)
   // === PRIVATE: Subscriber Management ===
+  /**
+   * Subscriber interface implementation (Zero-Allocation pattern)
+   * Called by dependencies when they change - delegates to _markDirty
+   */
+  execute() {
+    this._markDirty();
+  }
   _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) && m.schedule(this._recomputeJob));
   }
   _notifySubscribers() {
-    !this._functionSubscribers.hasSubscribers && !this._objectSubscribers.hasSubscribers || D.schedule(this._notifyJob);
+    !this._functionSubscribers.hasSubscribers && !this._objectSubscribers.hasSubscribers || m.schedule(this._notifyJob);
   }
   _registerTracking() {
-    const e = S.getCurrent();
+    const e = y.getCurrent();
     if (e)
       if (typeof e == "object" && e !== null && e.addDependency)
         e.addDependency(this);
@@ -1113,50 +1161,75 @@ class w {
       } else e.execute && this._objectSubscribers.add(e);
   }
 }
-Object.freeze(w.prototype);
-function J(i, e = {}) {
-  return new w(i, e);
+Object.freeze(Q.prototype);
+function ue(i, e = {}) {
+  return new Q(i, e);
 }
-class j {
+class te {
   constructor(e, t = {}) {
     this.run = () => {
       if (this.isDisposed)
-        throw new p(o.EFFECT_MUST_BE_FUNCTION);
+        throw new S(a.EFFECT_MUST_BE_FUNCTION);
       this.execute();
     }, this.dispose = () => {
-      if (!this.isDisposed && (this._setDisposed(), this._safeCleanup(), this._dependencies !== l)) {
-        for (const s of this._dependencies) {
-          const n = this._subscriptions.get(s.id);
-          n && n(), this._subscriptions.delete(s.id);
+      if (!this.isDisposed) {
+        if (this._setDisposed(), this._safeCleanup(), this._unsubscribes !== E) {
+          for (let s = 0; s < this._unsubscribes.length; s++) {
+            const n = this._unsubscribes[s];
+            n && n();
+          }
+          I.release(this._unsubscribes), this._unsubscribes = E;
         }
-        E.release(this._dependencies), this._dependencies = l;
+        this._dependencies !== f && (g.release(this._dependencies), this._dependencies = f);
       }
     }, this.addDependency = (s) => {
-      if (this.isExecuting && this._nextDeps) {
+      if (this.isExecuting && this._nextDeps && this._nextUnsubs) {
         const n = s, r = this._currentEpoch;
         if (n._lastSeenEpoch === r) return;
-        n._lastSeenEpoch = r, this._nextDeps.push(n), this._subscriptions.has(n.id) || this._subscribeTo(n);
+        n._lastSeenEpoch = r, this._nextDeps.push(n), n._tempUnsub ? (this._nextUnsubs.push(n._tempUnsub), n._tempUnsub = void 0) : this._subscribeTo(n);
       }
     }, 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();
+      const s = this._dependencies, n = this._unsubscribes, r = g.acquire(), c = I.acquire(), o = G();
+      if (s !== f && n !== E)
+        for (let u = 0; u < s.length; u++) {
+          const l = s[u];
+          l && (l._tempUnsub = n[u]);
+        }
+      this._nextDeps = r, this._nextUnsubs = c, this._currentEpoch = o;
+      let _ = !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 u = y.run(this, this._fn);
+        this._dependencies = r, this._unsubscribes = c, _ = !0, this._checkLoopWarnings(), X(u) ? u.then((l) => {
+          !this.isDisposed && typeof l == "function" && (this._cleanup = l);
+        }).catch((l) => {
+          console.error(R(l, S, a.EFFECT_EXECUTION_FAILED));
+        }) : this._cleanup = typeof u == "function" ? u : null;
+      } catch (u) {
+        _ = !0, console.error(R(u, S, a.EFFECT_EXECUTION_FAILED)), this._cleanup = null;
       } finally {
-        this._setExecuting(!1), this._nextDeps = null, d ? n !== l && E.release(n) : E.release(r);
+        if (this._setExecuting(!1), this._nextDeps = null, this._nextUnsubs = null, _) {
+          if (s !== f) {
+            for (let u = 0; u < s.length; u++) {
+              const l = s[u];
+              l?._tempUnsub && (l._tempUnsub(), l._tempUnsub = void 0);
+            }
+            g.release(s);
+          }
+          n !== E && I.release(n);
+        } else {
+          g.release(r);
+          for (let u = 0; u < c.length; u++)
+            c[u]?.();
+          if (I.release(c), s !== f)
+            for (let u = 0; u < s.length; u++) {
+              const l = s[u];
+              l && (l._tempUnsub = void 0);
+            }
+        }
       }
-    }, 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 = B() & N, this._flags = 0, this._currentEpoch = -1, this._fn = e, this._sync = t.sync ?? !1, this._maxExecutions = t.maxExecutionsPerSecond ?? U.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = t.maxExecutionsPerFlush ?? U.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = t.trackModifications ?? !1, this._cleanup = null, this._dependencies = f, this._unsubscribes = E, this._nextDeps = null, this._nextUnsubs = null, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._history = w ? [] : null, this._executionCount = 0, b.attachDebugInfo(this, "effect", this._id);
   }
   /**
    * Synchronizes subscriptions by unsubscribing from removed dependencies.
@@ -1165,24 +1238,16 @@ class j {
    * @param prevDeps - Previous dependency array
    * @param epoch - Current execution epoch for staleness detection
    */
-  _syncDependencies(e, t) {
-    if (e !== l)
-      for (let s = 0; s < e.length; s++) {
-        const n = e[s];
-        if (n && n._lastSeenEpoch !== t) {
-          const r = this._subscriptions.get(n.id);
-          r && (r(), this._subscriptions.delete(n.id));
-        }
-      }
-  }
+  // _syncDependencies removed (inline logic in execute)
   _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 && (e._modifiedAtEpoch = this._currentEpoch), this._sync ? this.execute() : m.schedule(this.execute);
       });
-      this._subscriptions.set(e.id, t);
+      this._nextUnsubs && this._nextUnsubs.push(t);
     } catch (t) {
-      console.error(g(t, p, o.EFFECT_EXECUTION_FAILED));
+      console.error(R(t, S, a.EFFECT_EXECUTION_FAILED)), this._nextUnsubs && this._nextUnsubs.push(() => {
+      });
     }
   }
   /**
@@ -1204,7 +1269,7 @@ class j {
    * ```
    */
   get isDisposed() {
-    return (this._flags & m.DISPOSED) !== 0;
+    return (this._flags & F.DISPOSED) !== 0;
   }
   /**
    * Returns the total number of times this effect has been executed.
@@ -1246,7 +1311,7 @@ class j {
    * ```
    */
   get isExecuting() {
-    return (this._flags & m.EXECUTING) !== 0;
+    return (this._flags & F.EXECUTING) !== 0;
   }
   /**
    * Sets the disposed flag on this effect.
@@ -1258,7 +1323,7 @@ class j {
    * @internal
    */
   _setDisposed() {
-    this._flags |= m.DISPOSED;
+    this._flags |= F.DISPOSED;
   }
   /**
    * Sets or clears the executing flag on this effect.
@@ -1272,7 +1337,8 @@ class j {
    * @internal
    */
   _setExecuting(e) {
-    e ? this._flags |= m.EXECUTING : this._flags &= -3;
+    const t = F.EXECUTING;
+    this._flags = this._flags & ~t | -Number(e) & t;
   }
   /**
    * Safely executes the cleanup function if one exists.
@@ -1292,42 +1358,45 @@ class j {
       try {
         this._cleanup();
       } catch (e) {
-        console.error(g(e, p, o.EFFECT_CLEANUP_FAILED));
+        console.error(R(e, S, a.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 !== A && (this._lastFlushEpoch = A, this._executionsInEpoch = 0), this._executionsInEpoch++, this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), H() > U.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history) {
+      const e = Date.now();
+      this._history.push(e), this._history.length > U.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 S(
+        `Effect executed ${n} times within 1 second. Infinite loop suspected`
+      );
+      if (this.dispose(), console.error(r), w)
+        throw r;
+    }
+  }
+  _throwInfiniteLoopError(e) {
+    const t = new S(
+      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${v}`
+    );
+    throw this.dispose(), console.error(t), t;
+  }
   /**
    * Checks for and warns about potential infinite loop patterns.
    *
@@ -1342,56 +1411,56 @@ class j {
    * @internal
    */
   _checkLoopWarnings() {
-    if (this._trackModifications && a.enabled) {
+    if (this._trackModifications && b.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 && s._modifiedAtEpoch === this._currentEpoch && b.warn(
           !0,
-          `Effect is reading a dependency (${a.getDebugName(s) || "unknown"}) that it just modified. Infinite loop may occur`
+          `Effect is reading a dependency (${b.getDebugName(s) || "unknown"}) that it just modified. Infinite loop may occur`
         );
       }
     }
   }
 }
-function H(i, e = {}) {
+function he(i, e = {}) {
   if (typeof i != "function")
-    throw new p(o.EFFECT_MUST_BE_FUNCTION);
-  const t = new j(i, e);
+    throw new S(a.EFFECT_MUST_BE_FUNCTION);
+  const t = new te(i, e);
   return t.execute(), t;
 }
-function G(i) {
+function se(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 oe(i) {
+  if (b.enabled) {
+    const e = b.getDebugType(i);
     if (e)
       return e === "computed";
   }
-  return G(i) && "invalidate" in i && typeof i.invalidate == "function";
+  return se(i) && "invalidate" in i && typeof i.invalidate == "function";
 }
-function K(i) {
+function ae(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,
-  _ as AtomError,
-  b as ComputedError,
-  x as DEBUG_CONFIG,
-  a as DEBUG_RUNTIME,
-  p as EffectError,
-  X as POOL_CONFIG,
-  L 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
+  T as AsyncState,
+  d as AtomError,
+  D as ComputedError,
+  k as DEBUG_CONFIG,
+  b as DEBUG_RUNTIME,
+  S as EffectError,
+  ie as POOL_CONFIG,
+  U as SCHEDULER_CONFIG,
+  C as SchedulerError,
+  ce as atom,
+  ne as batch,
+  ue as computed,
+  he as effect,
+  se as isAtom,
+  oe as isComputed,
+  ae as isEffect,
+  m as scheduler,
+  re as untracked
 };
 //# sourceMappingURL=index.mjs.map