@but212/atom-effect 0.1.2 → 0.1.4

package/dist/index.mjs

@@ -1,14 +1,14 @@
-const S = {
+const b = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
   REJECTED: "rejected"
-}, y = {
+}, D = {
   DISPOSED: 1,
   // 0001 - Effect has been disposed
   EXECUTING: 2
   // 0010 - Effect is currently executing
-}, u = {
+}, r = {
   DIRTY: 1,
   // 0001 - Needs recomputation
   IDLE: 2,
@@ -23,17 +23,17 @@ const S = {
   // 100000 - Currently recomputing
   HAS_ERROR: 64
   // 1000000 - Has error state
-}, j = {
+}, L = {
   /** 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
-}, U = {
+}, A = {
   /** Maximum effect executions per second to detect infinite loops */
   MAX_EXECUTIONS_PER_SECOND: 100,
   /** Threshold for cleaning up old execution timestamps */
   CLEANUP_THRESHOLD: 100
-}, m = {
+}, R = {
   /** Maximum dependencies before warning about large dependency graphs */
   MAX_DEPENDENCIES: 1e3,
   /** Enable infinite loop detection warnings */
@@ -50,7 +50,7 @@ class a extends Error {
     super(e), this.name = "AtomError", this.cause = t, this.recoverable = s, this.timestamp = /* @__PURE__ */ new Date();
   }
 }
-class d extends a {
+class _ extends a {
   /**
    * Creates a new ComputedError
    * @param message - Error message
@@ -60,7 +60,7 @@ class d extends a {
     super(e, t, !0), this.name = "ComputedError";
   }
 }
-class b extends a {
+class d extends a {
   /**
    * Creates a new EffectError
    * @param message - Error message
@@ -70,7 +70,7 @@ class b extends a {
     super(e, t, !1), this.name = "EffectError";
   }
 }
-class g extends a {
+class p extends a {
   /**
    * Creates a new SchedulerError
    * @param message - Error message
@@ -80,20 +80,20 @@ class g extends a {
     super(e, t, !1), this.name = "SchedulerError";
   }
 }
-function E(i, e, t) {
+function l(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 a)
     return i;
-  const s = i instanceof Error ? i.message : String(i), r = i instanceof Error ? i : null;
-  return new e(`Unexpected error (${t}): ${s}`, r);
+  const s = i instanceof Error ? i.message : String(i), n = i instanceof Error ? i : null;
+  return new e(`Unexpected error (${t}): ${s}`, n);
 }
-function A(i) {
+function m(i) {
   return i != null && typeof i.then == "function";
 }
-const o = {
+const h = {
   // ─────────────────────────────────────────────────────────────────
   // Computed errors
   // ─────────────────────────────────────────────────────────────────
@@ -178,9 +178,9 @@ const o = {
    */
   CALLBACK_ERROR_IN_ERROR_HANDLER: "Error occurred during onError callback execution"
 };
-class x {
+class M {
   constructor() {
-    this.queue = /* @__PURE__ */ new Set(), this.isProcessing = !1, this.isBatching = !1, this.batchDepth = 0, this.batchQueue = [], this.batchQueueSize = 0, this.isFlushingSync = !1, this.maxFlushIterations = 1e3;
+    this.queueA = /* @__PURE__ */ new Set(), this.queueB = /* @__PURE__ */ new Set(), this.queue = this.queueA, this.isProcessing = !1, this.isBatching = !1, this.batchDepth = 0, this.batchQueue = [], this.batchQueueSize = 0, this.isFlushingSync = !1, this.maxFlushIterations = 1e3;
   }
   /**
    * Schedules a callback for execution.
@@ -202,7 +202,7 @@ class x {
    */
   schedule(e) {
     if (typeof e != "function")
-      throw new g("Scheduler callback must be a function");
+      throw new p("Scheduler callback must be a function");
     this.isBatching || this.isFlushingSync ? this.batchQueue[this.batchQueueSize++] = e : (this.queue.add(e), this.isProcessing || this.flush());
   }
   /**
@@ -220,17 +220,17 @@ class x {
   flush() {
     if (this.isProcessing || this.queue.size === 0) return;
     this.isProcessing = !0;
-    const e = Array.from(this.queue);
-    this.queue.clear(), queueMicrotask(() => {
-      for (let t = 0; t < e.length; t++)
+    const e = this.queue;
+    this.queue = this.queue === this.queueA ? this.queueB : this.queueA, queueMicrotask(() => {
+      for (const t of e)
         try {
-          e[t]?.();
+          t?.();
         } catch (s) {
           console.error(
-            new g("Error occurred during scheduler execution", s)
+            new p("Error occurred during scheduler execution", s)
           );
         }
-      this.isProcessing = !1, this.queue.size > 0 && !this.isBatching && this.flush();
+      e.clear(), this.isProcessing = !1, this.queue.size > 0 && !this.isBatching && this.flush();
     });
   }
   /**
@@ -258,23 +258,23 @@ class x {
       for (; this.queue.size > 0; ) {
         if (++e > this.maxFlushIterations) {
           console.error(
-            new g(
+            new p(
               `Maximum flush iterations (${this.maxFlushIterations}) exceeded. Possible infinite loop in reactive dependencies. Consider increasing the limit with scheduler.setMaxFlushIterations()`
             )
           ), this.queue.clear(), this.batchQueueSize = 0;
           break;
         }
-        const t = Array.from(this.queue);
-        this.queue.clear();
-        for (let s = 0; s < t.length; s++)
+        const t = this.queue;
+        this.queue = this.queue === this.queueA ? this.queueB : this.queueA;
+        for (const s of t)
           try {
-            t[s]?.();
-          } catch (r) {
+            s?.();
+          } catch (n) {
             console.error(
-              new g("Error occurred during batch execution", r)
+              new p("Error occurred during batch execution", n)
             );
           }
-        if (this.batchQueueSize > 0) {
+        if (t.clear(), this.batchQueueSize > 0) {
           for (let s = 0; s < this.batchQueueSize; s++)
             this.queue.add(this.batchQueue[s]);
           this.batchQueueSize = 0;
@@ -345,24 +345,24 @@ class x {
    */
   setMaxFlushIterations(e) {
     if (e < 10)
-      throw new g("Max flush iterations must be at least 10");
+      throw new p("Max flush iterations must be at least 10");
     this.maxFlushIterations = e;
   }
 }
-const D = new x();
-function G(i) {
+const E = new M();
+function B(i) {
   if (typeof i != "function")
     throw new a("Batch callback must be a function");
-  D.startBatch();
+  E.startBatch();
   try {
     return i();
   } catch (e) {
     throw new a("Error occurred during batch execution", e);
   } finally {
-    D.endBatch();
+    E.endBatch();
   }
 }
-const p = {
+const f = {
   /** @inheritdoc */
   current: null,
   /**
@@ -383,9 +383,9 @@ const p = {
     return this.current;
   }
 };
-class F {
+class N {
   constructor() {
-    this.depMap = /* @__PURE__ */ new WeakMap(), this.depRefs = [], this.cleanupThreshold = 100, this.addCount = 0;
+    this.cleanupThreshold = 100, this.addCount = 0, this.depRefs = [], this.depMap = /* @__PURE__ */ new WeakMap(), this.count = 0;
   }
   /**
    * Adds a dependency with its associated unsubscribe callback.
@@ -394,7 +394,7 @@ class F {
    * immediately called to prevent duplicate subscriptions.
    *
    * @param dep - The dependency to track (atom, computed, etc.)
-   * @param unsubscribe - Callback to invoke when removing the dependency
+   * @param cleanup - Callback to invoke when removing the dependency
    *
    * @remarks
    * - Duplicate dependencies are rejected with immediate unsubscribe
@@ -412,7 +412,8 @@ class F {
       t();
       return;
     }
-    this.depMap.set(e, t), this.depRefs.push(new WeakRef(e)), ++this.addCount >= this.cleanupThreshold && (this.cleanup(), this.addCount = 0);
+    const s = this.count++;
+    this.depRefs[s] = e, this.depMap.set(e, t), ++this.addCount >= this.cleanupThreshold && (this.cleanup(), this.addCount = 0);
   }
   /**
    * Removes a dependency and calls its unsubscribe callback.
@@ -438,8 +439,19 @@ class F {
     if (t) {
       try {
         t();
-      } catch (s) {
-        console.warn("[DependencyManager] Error during unsubscribe:", s);
+      } catch (u) {
+        console.warn("[DependencyManager] Error during unsubscribe:", u);
+      }
+      const s = this.depRefs, n = this.count;
+      let c = -1;
+      for (let u = 0; u < n; u++)
+        if (s[u] === e) {
+          c = u;
+          break;
+        }
+      if (c !== -1) {
+        const u = n - 1;
+        s[c] = s[u], s[u] = void 0, this.count = u;
       }
       return this.depMap.delete(e), !0;
     }
@@ -482,32 +494,33 @@ class F {
    * ```
    */
   unsubscribeAll() {
-    for (let e = 0; e < this.depRefs.length; e++) {
-      const t = this.depRefs[e].deref();
+    for (let e = 0; e < this.count; e++) {
+      const t = this.depRefs[e];
       if (t) {
         const s = this.depMap.get(t);
         if (s) {
           try {
             s();
-          } catch (r) {
-            console.warn("[DependencyManager] Error during unsubscribe:", r);
+          } catch (n) {
+            console.warn("[DependencyManager] Error during unsubscribe:", n);
           }
           this.depMap.delete(t);
         }
       }
     }
-    this.depRefs.length = 0, this.addCount = 0;
+    this.depRefs.length = 0, this.count = 0, this.addCount = 0;
   }
   /**
-   * Removes stale WeakRefs from the internal array.
+   * Removes stale references from the internal array.
    *
-   * WeakRefs whose targets have been garbage collected are filtered out
-   * to prevent unbounded growth of the depRefs array.
+   * This method iterates through the `depRefs` array and removes any dependencies
+   * that are no longer present in the `depMap` (meaning their unsubscribe
+   * callback has been garbage collected or explicitly deleted).
    *
    * @remarks
    * - Called automatically every `cleanupThreshold` additions
    * - Can be called manually for immediate cleanup
-   * - Time complexity: O(n) where n is the number of WeakRefs
+   * - Time complexity: O(n) where n is the number of dependencies
    *
    * @example
    * ```typescript
@@ -516,7 +529,15 @@ class F {
    * ```
    */
   cleanup() {
-    this.depRefs = this.depRefs.filter((e) => e.deref() !== void 0);
+    let e = 0;
+    const t = this.depRefs, s = this.count;
+    for (let n = 0; n < s; n++) {
+      const c = t[n];
+      c && this.depMap.has(c) && (e !== n && (t[e] = c), e++);
+    }
+    for (let n = e; n < s; n++)
+      t[n] = void 0;
+    this.count = e, t.length = e;
   }
   /**
    * Gets the current number of live dependencies.
@@ -532,8 +553,8 @@ class F {
    * console.log(`Tracking ${manager.count} dependencies`);
    * ```
    */
-  get count() {
-    return this.cleanup(), this.depRefs.length;
+  get liveCount() {
+    return this.count;
   }
   /**
    * Gets an array of all live dependencies.
@@ -553,8 +574,8 @@ class F {
    */
   getDependencies() {
     const e = [];
-    for (let t = 0; t < this.depRefs.length; t++) {
-      const s = this.depRefs[t].deref();
+    for (let t = 0; t < this.count; t++) {
+      const s = this.depRefs[t];
       s !== void 0 && e.push(s);
     }
     return e;
@@ -601,24 +622,24 @@ class F {
     this.cleanupThreshold = Math.max(1, e);
   }
 }
-function V(i) {
+function k(i) {
   if (typeof i != "function")
     throw new a("Untracked callback must be a function");
-  const e = p.current;
-  p.current = null;
+  const e = f.current;
+  f.current = null;
   try {
     return i();
   } catch (t) {
     throw new a("Error occurred during untracked execution", t);
   } finally {
-    p.current = e;
+    f.current = e;
   }
 }
-const C = /* @__PURE__ */ Symbol("debugName"), P = /* @__PURE__ */ Symbol("id"), R = /* @__PURE__ */ Symbol("type"), T = /* @__PURE__ */ Symbol("noDefaultValue");
-function w(i) {
+const S = /* @__PURE__ */ Symbol("debugName"), O = /* @__PURE__ */ Symbol("id"), I = /* @__PURE__ */ Symbol("type"), C = /* @__PURE__ */ Symbol("noDefaultValue");
+function F(i) {
   return i !== null && typeof i == "object" && "dependencies" in i && i.dependencies instanceof Set;
 }
-const h = {
+const o = {
   /**
    * Whether debug mode is enabled.
    *
@@ -632,13 +653,13 @@ const h = {
    *
    * @see {@link DEBUG_CONFIG.MAX_DEPENDENCIES}
    */
-  maxDependencies: m.MAX_DEPENDENCIES,
+  maxDependencies: R.MAX_DEPENDENCIES,
   /**
    * Whether to warn about potential infinite loops.
    *
    * @see {@link DEBUG_CONFIG.WARN_INFINITE_LOOP}
    */
-  warnInfiniteLoop: m.WARN_INFINITE_LOOP,
+  warnInfiniteLoop: R.WARN_INFINITE_LOOP,
   /**
    * Logs a warning message when condition is true and debug is enabled.
    *
@@ -683,11 +704,11 @@ const h = {
    */
   checkCircular(i, e, t = /* @__PURE__ */ new Set()) {
     if (i === e)
-      throw new d("Direct circular dependency detected");
+      throw new _("Direct circular dependency detected");
     if (this.enabled) {
       if (t.has(i))
-        throw new d("Indirect circular dependency detected");
-      if (t.add(i), w(i))
+        throw new _("Indirect circular dependency detected");
+      if (t.add(i), F(i))
         for (const s of i.dependencies)
           this.checkCircular(s, e, t);
     }
@@ -716,7 +737,7 @@ const h = {
     if (!this.enabled)
       return;
     const s = i;
-    s[C] = `${e}_${t}`, s[P] = t, s[R] = e;
+    s[S] = `${e}_${t}`, s[O] = t, s[I] = e;
   },
   /**
    * Retrieves the debug display name from a reactive object.
@@ -731,8 +752,8 @@ const h = {
    * ```
    */
   getDebugName(i) {
-    if (i !== null && typeof i == "object" && C in i)
-      return i[C];
+    if (i !== null && typeof i == "object" && S in i)
+      return i[S];
   },
   /**
    * Retrieves the debug type from a reactive object.
@@ -749,230 +770,13 @@ const h = {
    * ```
    */
   getDebugType(i) {
-    if (i !== null && typeof i == "object" && R in i)
-      return i[R];
+    if (i !== null && typeof i == "object" && I in i)
+      return i[I];
   }
 };
-let v = 1;
-const I = () => v++;
-class L {
-  /**
-   * Creates a new AtomImpl instance.
-   *
-   * @param initialValue - The initial value of the atom
-   * @param sync - Whether to notify subscribers synchronously
-   */
-  constructor(e, t) {
-    this._value = e, this._version = 0, this._fnSubs = [], this._fnSubCount = 0, this._objSubs = [], this._objSubCount = 0, this._sync = t, this._id = I().toString(), h.attachDebugInfo(this, "atom", I());
-  }
-  /**
-   * Gets the current value and registers the atom as a dependency
-   * in the current tracking context.
-   *
-   * @returns The current value
-   *
-   * @remarks
-   * This getter automatically tracks dependencies when accessed within
-   * a computed or effect context.
-   */
-  get value() {
-    const e = p.getCurrent();
-    return e != null && this._track(e), this._value;
-  }
-  /**
-   * Sets a new value and notifies all subscribers if the value changed.
-   *
-   * @param newValue - The new value to set
-   *
-   * @remarks
-   * Uses Object.is for equality comparison. If the value is unchanged,
-   * no notifications are sent. Notifications may be batched unless
-   * sync mode is enabled.
-   */
-  set value(e) {
-    if (Object.is(this._value, e)) return;
-    const t = this._value, s = ++this._version;
-    this._value = e, (this._fnSubCount | this._objSubCount) !== 0 && this._notify(e, t, s);
-  }
-  /**
-   * Tracks the current context as a dependency of this atom.
-   *
-   * @param current - The current tracking context (function or object)
-   *
-   * @remarks
-   * Handles both function-based trackers (with optional addDependency method)
-   * and object-based trackers (with execute or addDependency methods).
-   */
-  _track(e) {
-    if (typeof e == "function") {
-      const t = e;
-      t.addDependency !== void 0 ? t.addDependency(this) : this._addFnSub(e);
-    } else {
-      const t = e;
-      t.addDependency !== void 0 ? t.addDependency(this) : t.execute !== void 0 && this._addObjSub(t);
-    }
-  }
-  /**
-   * Adds a function-based subscriber.
-   *
-   * @param sub - The subscriber function to add
-   * @returns An unsubscribe function
-   *
-   * @remarks
-   * Prevents duplicate subscriptions by checking existing subscribers.
-   */
-  _addFnSub(e) {
-    const t = this._fnSubs, s = this._fnSubCount;
-    for (let r = 0; r < s; r++)
-      if (t[r] === e) return this._createUnsub(r, !0);
-    return t[s] = e, this._fnSubCount = s + 1, this._createUnsub(s, !0);
-  }
-  /**
-   * Adds an object-based subscriber.
-   *
-   * @param sub - The subscriber object with an execute method
-   *
-   * @remarks
-   * Prevents duplicate subscriptions by checking existing subscribers.
-   */
-  _addObjSub(e) {
-    const t = this._objSubs, s = this._objSubCount;
-    for (let r = 0; r < s; r++)
-      if (t[r] === e) return;
-    t[s] = e, this._objSubCount = s + 1;
-  }
-  /**
-   * Creates an unsubscribe function for a subscriber at the given index.
-   *
-   * @param idx - The index of the subscriber
-   * @param isFn - Whether this is a function subscriber (true) or object subscriber (false)
-   * @returns An unsubscribe function
-   */
-  _createUnsub(e, t) {
-    return () => {
-      t ? this._removeFnSub(e) : this._removeObjSub(e);
-    };
-  }
-  /**
-   * Removes a function subscriber at the given index.
-   *
-   * @param idx - The index of the subscriber to remove
-   *
-   * @remarks
-   * Uses swap-and-pop removal for O(1) performance.
-   */
-  _removeFnSub(e) {
-    const t = this._fnSubCount;
-    if (e >= t) return;
-    const s = t - 1, r = this._fnSubs;
-    r[e] = r[s], r[s] = void 0, this._fnSubCount = s;
-  }
-  /**
-   * Removes an object subscriber at the given index.
-   *
-   * @param idx - The index of the subscriber to remove
-   *
-   * @remarks
-   * Uses swap-and-pop removal for O(1) performance.
-   */
-  _removeObjSub(e) {
-    const t = this._objSubCount;
-    if (e >= t) return;
-    const s = t - 1, r = this._objSubs;
-    r[e] = r[s], r[s] = void 0, this._objSubCount = s;
-  }
-  /**
-   * Notifies all subscribers of a value change.
-   *
-   * @param newValue - The new value
-   * @param oldValue - The previous value
-   * @param currentVersion - The version at the time of change
-   *
-   * @remarks
-   * Notifications are skipped if the version has changed (stale update).
-   * Errors from individual subscribers are caught and logged without
-   * interrupting other subscribers.
-   */
-  _notify(e, t, s) {
-    const r = () => {
-      if (this._version !== s) return;
-      const c = this._fnSubs, n = this._fnSubCount, _ = this._objSubs, M = this._objSubCount;
-      for (let f = 0; f < n; f++)
-        try {
-          const l = c[f];
-          l && l(e, t);
-        } catch (l) {
-          console.error(
-            new a(o.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, l)
-          );
-        }
-      for (let f = 0; f < M; f++)
-        try {
-          const l = _[f];
-          l && l.execute();
-        } catch (l) {
-          console.error(
-            new a(o.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, l)
-          );
-        }
-    };
-    this._sync && !D.isBatching ? r() : D.schedule(r);
-  }
-  /**
-   * Subscribes a listener function to value changes.
-   *
-   * @param listener - Function to call when the value changes
-   * @returns An unsubscribe function
-   * @throws {AtomError} If listener is not a function
-   *
-   * @example
-   * ```ts
-   * const unsub = myAtom.subscribe((newVal, oldVal) => {
-   *   console.log(`Changed from ${oldVal} to ${newVal}`);
-   * });
-   * // Later: unsub();
-   * ```
-   */
-  subscribe(e) {
-    if (typeof e != "function")
-      throw new a(o.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
-    return this._addFnSub(e);
-  }
-  /**
-   * Gets the current value without registering as a dependency.
-   *
-   * @returns The current value
-   *
-   * @remarks
-   * Use this method when you need to read the value without
-   * creating a reactive dependency (e.g., in event handlers).
-   */
-  peek() {
-    return this._value;
-  }
-  /**
-   * Disposes the atom, clearing all subscribers and releasing resources.
-   *
-   * @remarks
-   * After disposal, the atom should not be used. The value is set to
-   * undefined to help with garbage collection.
-   */
-  dispose() {
-    this._fnSubs.length = 0, this._objSubs.length = 0, this._fnSubCount = 0, this._objSubCount = 0, this._value = void 0;
-  }
-  /**
-   * Gets the total number of active subscribers.
-   *
-   * @returns The count of function and object subscribers combined
-   */
-  subscriberCount() {
-    return this._fnSubCount + this._objSubCount;
-  }
-}
-function X(i, e = {}) {
-  return new L(i, e.sync ?? !1);
-}
-class N {
+let x = 1;
+const g = () => x++;
+class y {
   constructor() {
     this.subscribers = null, this.subscriberIndex = null;
   }
@@ -1022,8 +826,8 @@ class N {
       return !1;
     const s = this.subscribers.length - 1;
     if (t !== s) {
-      const r = this.subscribers[s];
-      this.subscribers[t] = r, this.subscriberIndex.set(r, t);
+      const n = this.subscribers[s];
+      this.subscribers[t] = n, this.subscriberIndex.set(n, t);
     }
     return this.subscribers.pop(), this.subscriberIndex.delete(e), !0;
   }
@@ -1070,8 +874,8 @@ class N {
       for (let s = 0; s < this.subscribers.length; s++)
         try {
           e(this.subscribers[s], s);
-        } catch (r) {
-          t ? t(r) : console.error("[SubscriberManager] Error in subscriber callback:", r);
+        } catch (n) {
+          t ? t(n) : console.error("[SubscriberManager] Error in subscriber callback:", n);
         }
   }
   /**
@@ -1111,22 +915,163 @@ class N {
     return this.subscribers ? [...this.subscribers] : [];
   }
 }
-class k {
+class U {
+  /**
+   * Creates a new AtomImpl instance.
+   *
+   * @param initialValue - The initial value of the atom
+   * @param sync - Whether to notify subscribers synchronously
+   */
+  constructor(e, t) {
+    this._isNotificationScheduled = !1, this._value = e, this._version = 0, this._functionSubscribers = new y(), this._objectSubscribers = new y(), this._sync = t, this._id = g().toString(), this._notifyTask = this._flushNotifications.bind(this), o.attachDebugInfo(this, "atom", g());
+  }
+  /**
+   * Gets the current value and registers the atom as a dependency
+   * in the current tracking context.
+   *
+   * @returns The current value
+   *
+   * @remarks
+   * This getter automatically tracks dependencies when accessed within
+   * a computed or effect context.
+   */
+  get value() {
+    const e = f.getCurrent();
+    return e != null && this._track(e), this._value;
+  }
+  /**
+   * Sets a new value and notifies all subscribers if the value changed.
+   *
+   * @param newValue - The new value to set
+   *
+   * @remarks
+   * Uses Object.is for equality comparison. If the value is unchanged,
+   * no notifications are sent. Notifications may be batched unless
+   * sync mode is enabled.
+   */
+  set value(e) {
+    if (Object.is(this._value, e)) return;
+    const t = this._value, s = ++this._version;
+    this._value = e, !(!this._functionSubscribers.hasSubscribers && !this._objectSubscribers.hasSubscribers) && this._notify(e, t, s);
+  }
+  /**
+   * Tracks the current context as a dependency of this atom.
+   *
+   * @param current - The current tracking context (function or object)
+   *
+   * @remarks
+   * Handles both function-based trackers (with optional addDependency method)
+   * and object-based trackers (with execute or addDependency methods).
+   */
+  _track(e) {
+    if (typeof e == "function") {
+      const t = e;
+      t.addDependency !== void 0 ? t.addDependency(this) : this._functionSubscribers.add(e);
+    } else {
+      const t = e;
+      t.addDependency !== void 0 ? t.addDependency(this) : t.execute !== void 0 && this._objectSubscribers.add(t);
+    }
+  }
+  /**
+   * Notifies all subscribers of a value change.
+   *
+   * @param newValue - The new value
+   * @param oldValue - The previous value
+   * @param currentVersion - The version at the time of change
+   *
+   * @remarks
+   * Notifications are skipped if the version has changed (stale update).
+   * Errors from individual subscribers are caught and logged without
+   * interrupting other subscribers.
+   */
+  /**
+   * Schedules a notification.
+   * Uses coalescing: if a notification is already scheduled, we update the state
+   * 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 && !E.isBatching ? this._flushNotifications() : E.schedule(this._notifyTask);
+  }
+  /**
+   * Executes the pending notifications.
+   * Bound to 'this' in constructor to avoid closure allocation.
+   */
+  _flushNotifications() {
+    if (!this._isNotificationScheduled) return;
+    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 a(h.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, s))
+    ), this._objectSubscribers.forEachSafe(
+      (s) => s.execute(),
+      (s) => console.error(new a(h.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, s))
+    );
+  }
+  /**
+   * Subscribes a listener function to value changes.
+   *
+   * @param listener - Function to call when the value changes
+   * @returns An unsubscribe function
+   * @throws {AtomError} If listener is not a function
+   *
+   * @example
+   * ```ts
+   * const unsub = myAtom.subscribe((newVal, oldVal) => {
+   *   console.log(`Changed from ${oldVal} to ${newVal}`);
+   * });
+   * // Later: unsub();
+   * ```
+   */
+  subscribe(e) {
+    if (typeof e != "function")
+      throw new a(h.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
+    return this._functionSubscribers.add(e);
+  }
+  /**
+   * Gets the current value without registering as a dependency.
+   *
+   * @returns The current value
+   *
+   * @remarks
+   * Use this method when you need to read the value without
+   * creating a reactive dependency (e.g., in event handlers).
+   */
+  peek() {
+    return this._value;
+  }
+  /**
+   * Disposes the atom, clearing all subscribers and releasing resources.
+   *
+   * @remarks
+   * After disposal, the atom should not be used. The value is set to
+   * undefined to help with garbage collection.
+   */
+  dispose() {
+    this._functionSubscribers.clear(), this._objectSubscribers.clear(), this._value = void 0;
+  }
+  /**
+   * Gets the total number of active subscribers.
+   *
+   * @returns The count of function and object subscribers combined
+   */
+  subscriberCount() {
+    return this._functionSubscribers.size + this._objectSubscribers.size;
+  }
+}
+function G(i, e = {}) {
+  return new U(i, e.sync ?? !1);
+}
+class T {
   constructor(e, t = {}) {
-    if (this._error = null, this._promiseId = 0, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, typeof e != "function")
-      throw new d(o.COMPUTED_MUST_BE_FUNCTION);
-    this._fn = e, this._stateFlags = u.DIRTY | u.IDLE, this._value = void 0;
-    const {
-      equal: s = Object.is,
-      defaultValue: r = T,
-      lazy: c = !0,
-      onError: n = null
-    } = t;
-    if (this._equal = s, this._defaultValue = r, this._hasDefaultValue = r !== T, this._onError = n, this._functionSubscribers = new N(), this._objectSubscribers = new N(), this._dependencyManager = new F(), this._id = I(), h.attachDebugInfo(this, "computed", this._id), h.enabled) {
-      const _ = this;
-      _.subscriberCount = () => this._functionSubscribers.size + this._objectSubscribers.size, _.isDirty = () => this._isDirty(), _.dependencies = this._dependencyManager.getDependencies(), _.stateFlags = this._getFlagsAsString();
+    if (typeof e != "function")
+      throw new _(h.COMPUTED_MUST_BE_FUNCTION);
+    if (this._value = void 0, this._stateFlags = r.DIRTY | r.IDLE, this._error = null, this._promiseId = 0, this._equal = t.equal ?? Object.is, this._fn = e, this._defaultValue = "defaultValue" in t ? t.defaultValue : C, this._hasDefaultValue = this._defaultValue !== C, this._onError = t.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._functionSubscribers = new y(), this._objectSubscribers = new y(), this._dependencyManager = new N(), this._dependencyBuffer = /* @__PURE__ */ new Set(), this._trackable = Object.assign(() => this._markDirty(), {
+      addDependency: (s) => this._dependencyBuffer.add(s)
+    }), this._id = g(), o.attachDebugInfo(this, "computed", this._id), o.enabled) {
+      const s = this;
+      s.subscriberCount = () => this._functionSubscribers.size + this._objectSubscribers.size, s.isDirty = () => this._isDirty(), s.dependencies = this._dependencyManager.getDependencies(), s.stateFlags = this._getFlagsAsString();
     }
-    if (!c)
+    if (t.lazy === !1)
       try {
         this._recompute();
       } catch {
@@ -1134,14 +1079,14 @@ class k {
   }
   // === PUBLIC API ===
   get value() {
-    if ((this._stateFlags & (u.RESOLVED | u.DIRTY)) === u.RESOLVED)
+    if ((this._stateFlags & (r.RESOLVED | r.DIRTY)) === r.RESOLVED)
       return this._registerTracking(), this._value;
     const t = this._computeValue();
     return this._registerTracking(), t;
   }
   subscribe(e) {
     if (typeof e != "function")
-      throw new d(o.COMPUTED_SUBSCRIBER_MUST_BE_FUNCTION);
+      throw new _(h.COMPUTED_SUBSCRIBER_MUST_BE_FUNCTION);
     return this._functionSubscribers.add(e);
   }
   peek() {
@@ -1166,50 +1111,50 @@ class k {
     this._markDirty();
   }
   dispose() {
-    this._dependencyManager.unsubscribeAll(), this._functionSubscribers.clear(), this._objectSubscribers.clear(), this._stateFlags = u.DIRTY | u.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID;
+    this._dependencyManager.unsubscribeAll(), this._functionSubscribers.clear(), this._objectSubscribers.clear(), this._stateFlags = r.DIRTY | r.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 & u.DIRTY) !== 0;
+    return (this._stateFlags & r.DIRTY) !== 0;
   }
   _setDirty() {
-    this._stateFlags |= u.DIRTY;
+    this._stateFlags |= r.DIRTY;
   }
   _clearDirty() {
     this._stateFlags &= -2;
   }
   _isIdle() {
-    return (this._stateFlags & u.IDLE) !== 0;
+    return (this._stateFlags & r.IDLE) !== 0;
   }
   _setIdle() {
-    this._stateFlags |= u.IDLE, this._stateFlags &= -29;
+    this._stateFlags |= r.IDLE, this._stateFlags &= -29;
   }
   _isPending() {
-    return (this._stateFlags & u.PENDING) !== 0;
+    return (this._stateFlags & r.PENDING) !== 0;
   }
   _setPending() {
-    this._stateFlags |= u.PENDING, this._stateFlags &= -27;
+    this._stateFlags |= r.PENDING, this._stateFlags &= -27;
   }
   _isResolved() {
-    return (this._stateFlags & u.RESOLVED) !== 0;
+    return (this._stateFlags & r.RESOLVED) !== 0;
   }
   _setResolved() {
-    this._stateFlags |= u.RESOLVED, this._stateFlags &= -87;
+    this._stateFlags |= r.RESOLVED, this._stateFlags &= -87;
   }
   _isRejected() {
-    return (this._stateFlags & u.REJECTED) !== 0;
+    return (this._stateFlags & r.REJECTED) !== 0;
   }
   _setRejected() {
-    this._stateFlags |= u.REJECTED | u.HAS_ERROR, this._stateFlags &= -15;
+    this._stateFlags |= r.REJECTED | r.HAS_ERROR, this._stateFlags &= -15;
   }
   _isRecomputing() {
-    return (this._stateFlags & u.RECOMPUTING) !== 0;
+    return (this._stateFlags & r.RECOMPUTING) !== 0;
   }
   _setRecomputing(e) {
-    e ? this._stateFlags |= u.RECOMPUTING : this._stateFlags &= -33;
+    e ? this._stateFlags |= r.RECOMPUTING : this._stateFlags &= -33;
   }
   _getAsyncState() {
-    return this._isPending() ? S.PENDING : this._isResolved() ? S.RESOLVED : this._isRejected() ? S.REJECTED : S.IDLE;
+    return this._isPending() ? b.PENDING : this._isResolved() ? b.RESOLVED : this._isRejected() ? b.REJECTED : b.IDLE;
   }
   _getFlagsAsString() {
     const e = [];
@@ -1222,19 +1167,17 @@ class k {
   _recompute() {
     if (!this._isDirty() && this._isResolved())
       return;
-    this._setRecomputing(!0);
-    const e = /* @__PURE__ */ new Set(), t = Object.assign(() => this._markDirty(), {
-      addDependency: (s) => e.add(s)
-    });
+    this._setRecomputing(!0), this._dependencyBuffer.clear();
+    const e = this._dependencyBuffer;
     try {
-      const s = p.run(t, this._fn);
-      if (A(s)) {
-        this._updateDependencies(e), this._handleAsyncComputation(s), this._setRecomputing(!1);
+      const t = f.run(this._trackable, this._fn);
+      if (m(t)) {
+        this._updateDependencies(e), this._handleAsyncComputation(t), this._setRecomputing(!1);
         return;
       }
-      this._updateDependencies(e), this._handleSyncResult(s);
-    } catch (s) {
-      this._updateDependencies(e), this._handleComputationError(s);
+      this._updateDependencies(e), this._handleSyncResult(t);
+    } catch (t) {
+      this._updateDependencies(e), this._handleComputationError(t);
     }
   }
   _handleSyncResult(e) {
@@ -1255,29 +1198,29 @@ class k {
     this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), t && this._notifySubscribers();
   }
   _handleAsyncRejection(e) {
-    const t = E(e, d, o.COMPUTED_ASYNC_COMPUTATION_FAILED);
+    const t = l(e, _, 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 = E(e, d, o.COMPUTED_COMPUTATION_FAILED);
+    const t = l(e, _, 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 d(o.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    throw new _(h.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
   }
   _handleRejected() {
     if (this._error?.recoverable && this._hasDefaultValue)
@@ -1298,36 +1241,29 @@ class k {
     return !0;
   }
   _performDeltaSync(e, t) {
-    const s = new Set(e), r = [], c = [];
-    for (let n = 0; n < e.length; n++) {
-      const _ = e[n];
-      t.has(_) || r.push(_);
+    for (let s = 0; s < e.length; s++) {
+      const n = e[s];
+      t.has(n) || this._dependencyManager.removeDependency(n);
     }
-    t.forEach((n) => {
-      s.has(n) || c.push(n);
-    });
-    for (let n = 0; n < r.length; n++)
-      this._dependencyManager.removeDependency(r[n]);
-    for (let n = 0; n < c.length; n++)
-      this._addDependency(c[n]);
-    e.length = 0, t.forEach((n) => {
-      e.push(n);
+    t.forEach((s) => {
+      const n = s;
+      this._dependencyManager.hasDependency(n) || this._addDependency(n);
     });
   }
   _addDependency(e) {
-    h.checkCircular(e, this);
-    const t = this._dependencyManager.count;
-    h.warn(t > h.maxDependencies, o.LARGE_DEPENDENCY_GRAPH(t));
+    o.checkCircular(e, this);
+    const t = this._dependencyManager.liveCount;
+    o.warn(t > o.maxDependencies, h.LARGE_DEPENDENCY_GRAPH(t));
     try {
       const s = e.subscribe(() => this._markDirty());
       this._dependencyManager.addDependency(e, s);
     } catch (s) {
-      throw E(s, d, "dependency subscription");
+      throw l(s, _, "dependency subscription");
     }
   }
   // === PRIVATE: Subscriber Management ===
   _markDirty() {
-    this._isRecomputing() || this._isDirty() || (this._setDirty(), this._setIdle(), (this._functionSubscribers.hasSubscribers || this._objectSubscribers.hasSubscribers) && D.schedule(() => {
+    this._isRecomputing() || this._isDirty() || (this._setDirty(), this._setIdle(), (this._functionSubscribers.hasSubscribers || this._objectSubscribers.hasSubscribers) && E.schedule(() => {
       if (this._isDirty())
         try {
           this._recompute();
@@ -1336,7 +1272,7 @@ class k {
     }));
   }
   _notifySubscribers() {
-    !this._functionSubscribers.hasSubscribers && !this._objectSubscribers.hasSubscribers || D.schedule(() => {
+    !this._functionSubscribers.hasSubscribers && !this._objectSubscribers.hasSubscribers || E.schedule(() => {
       this._functionSubscribers.forEachSafe(
         (e) => e(),
         (e) => console.error(e)
@@ -1347,28 +1283,21 @@ class k {
     });
   }
   _registerTracking() {
-    const e = p.getCurrent();
-    e && (typeof e == "function" ? this._functionSubscribers.add(e) : e.addDependency ? e.addDependency(this) : e.execute && this._objectSubscribers.add(e));
-  }
-}
-function z(i, e = {}) {
-  return new k(i, e);
-}
-function O(i) {
-  return i !== null && typeof i == "object" && "value" in i && "subscribe" in i && typeof i.subscribe == "function";
-}
-function q(i) {
-  if (h.enabled) {
-    const e = h.getDebugType(i);
+    const e = f.getCurrent();
     if (e)
-      return e === "computed";
+      if (typeof e == "object" && e !== null && e.addDependency)
+        e.addDependency(this);
+      else if (typeof e == "function") {
+        const t = e;
+        t.addDependency ? t.addDependency(this) : this._functionSubscribers.add(e);
+      } else e.execute && this._objectSubscribers.add(e);
   }
-  return O(i) && "invalidate" in i && typeof i.invalidate == "function";
 }
-function Y(i) {
-  return i !== null && typeof i == "object" && "dispose" in i && "run" in i && typeof i.dispose == "function" && typeof i.run == "function";
+Object.freeze(T.prototype);
+function V(i, e = {}) {
+  return new T(i, e);
 }
-class B {
+class w {
   /**
    * Creates a new EffectImpl instance.
    *
@@ -1397,44 +1326,48 @@ class B {
   constructor(e, t = {}) {
     this.run = () => {
       if (this.isDisposed)
-        throw new b(o.EFFECT_MUST_BE_FUNCTION);
+        throw new d(h.EFFECT_MUST_BE_FUNCTION);
       this.execute();
     }, this.dispose = () => {
-      this.isDisposed || (this._setDisposed(), this._safeCleanup(), this._depManager.unsubscribeAll(), this._trackedDeps.size > 0 && (this._trackedDeps.forEach((s) => {
-        const r = this._originalDescriptors.get(s);
-        if (r)
-          try {
-            Object.defineProperty(s, "value", r);
-          } catch {
-            h.warn(!0, "Failed to restore original descriptor");
-          }
-      }), this._trackedDeps.clear()));
+      this.isDisposed || (this._setDisposed(), this._safeCleanup(), this._depManager.unsubscribeAll());
     }, this.addDependency = (s) => {
-      try {
-        const r = s.subscribe(() => {
-          this._sync ? this.execute() : D.schedule(this.execute);
-        });
-        this._depManager.addDependency(s, r), this._trackModifications && O(s) && this._trackModificationsForDep(s);
-      } catch (r) {
-        throw E(r, b, o.EFFECT_EXECUTION_FAILED);
-      }
+      this.isExecuting && (this._dependencyBuffer.add(s), this._depManager.hasDependency(s) || this._subscribeTo(s));
     }, this.execute = () => {
       if (this.isDisposed || this.isExecuting) return;
       const s = Date.now();
-      this._recordExecution(s), this._setExecuting(!0), this._safeCleanup(), this._depManager.unsubscribeAll(), this._modifiedDeps.clear();
+      this._recordExecution(s), this._setExecuting(!0), this._safeCleanup(), this._dependencyBuffer.clear(), this._modifiedDeps.clear();
       try {
-        const r = p.run(this, this._fn);
-        this._checkLoopWarnings(), A(r) ? r.then((c) => {
+        const n = f.run(this, this._fn);
+        this._syncDependencies(), this._checkLoopWarnings(), m(n) ? n.then((c) => {
           !this.isDisposed && typeof c == "function" && (this._cleanup = c);
         }).catch((c) => {
-          console.error(E(c, b, o.EFFECT_EXECUTION_FAILED));
-        }) : this._cleanup = typeof r == "function" ? r : null;
-      } catch (r) {
-        console.error(E(r, b, o.EFFECT_EXECUTION_FAILED)), this._cleanup = null;
+          console.error(l(c, d, h.EFFECT_EXECUTION_FAILED));
+        }) : this._cleanup = typeof n == "function" ? n : null;
+      } catch (n) {
+        console.error(l(n, d, h.EFFECT_EXECUTION_FAILED)), this._cleanup = null;
       } finally {
         this._setExecuting(!1);
       }
-    }, this._fn = e, this._sync = t.sync ?? !1, this._maxExecutions = t.maxExecutionsPerSecond ?? U.MAX_EXECUTIONS_PER_SECOND, this._trackModifications = t.trackModifications ?? !1, this._id = I(), this._flags = 0, this._cleanup = null, this._depManager = new F(), this._modifiedDeps = /* @__PURE__ */ new Set(), this._originalDescriptors = /* @__PURE__ */ new WeakMap(), this._trackedDeps = /* @__PURE__ */ new Set(), this._historyCapacity = this._maxExecutions + 5, this._history = new Float64Array(this._historyCapacity), this._historyIdx = 0, this._historyCount = 0, this._executionCount = 0, h.attachDebugInfo(this, "effect", this._id);
+    }, this._fn = e, this._sync = t.sync ?? !1, this._maxExecutions = t.maxExecutionsPerSecond ?? A.MAX_EXECUTIONS_PER_SECOND, this._trackModifications = t.trackModifications ?? !1, this._id = g(), this._flags = 0, this._cleanup = null, this._depManager = new N(), this._modifiedDeps = /* @__PURE__ */ new Set(), this._dependencyBuffer = /* @__PURE__ */ new Set(), this._historyCapacity = this._maxExecutions + 5, this._history = new Float64Array(this._historyCapacity), this._historyIdx = 0, this._historyCount = 0, this._executionCount = 0, o.attachDebugInfo(this, "effect", this._id);
+  }
+  _syncDependencies() {
+    const e = this._dependencyBuffer, t = this._depManager.getDependencies();
+    for (let s = 0; s < t.length; s++) {
+      const n = t[s];
+      e.has(n) || this._depManager.removeDependency(n);
+    }
+    for (const s of e)
+      this._depManager.hasDependency(s) || this._subscribeTo(s);
+  }
+  _subscribeTo(e) {
+    try {
+      const t = e.subscribe(() => {
+        this._trackModifications && this.isExecuting && this._modifiedDeps.add(e), this._sync ? this.execute() : E.schedule(this.execute);
+      });
+      this._depManager.addDependency(e, t);
+    } catch (t) {
+      console.error(l(t, d, h.EFFECT_EXECUTION_FAILED));
+    }
   }
   /**
    * Indicates whether this effect has been disposed.
@@ -1455,7 +1388,7 @@ class B {
    * ```
    */
   get isDisposed() {
-    return (this._flags & y.DISPOSED) !== 0;
+    return (this._flags & D.DISPOSED) !== 0;
   }
   /**
    * Returns the total number of times this effect has been executed.
@@ -1497,7 +1430,7 @@ class B {
    * ```
    */
   get isExecuting() {
-    return (this._flags & y.EXECUTING) !== 0;
+    return (this._flags & D.EXECUTING) !== 0;
   }
   /**
    * Sets the disposed flag on this effect.
@@ -1509,7 +1442,7 @@ class B {
    * @internal
    */
   _setDisposed() {
-    this._flags |= y.DISPOSED;
+    this._flags |= D.DISPOSED;
   }
   /**
    * Sets or clears the executing flag on this effect.
@@ -1523,7 +1456,7 @@ class B {
    * @internal
    */
   _setExecuting(e) {
-    e ? this._flags |= y.EXECUTING : this._flags &= -3;
+    e ? this._flags |= D.EXECUTING : this._flags &= -3;
   }
   /**
    * Safely executes the cleanup function if one exists.
@@ -1543,7 +1476,7 @@ class B {
       try {
         this._cleanup();
       } catch (e) {
-        console.error(E(e, b, o.EFFECT_CLEANUP_FAILED));
+        console.error(l(e, d, h.EFFECT_CLEANUP_FAILED));
       }
       this._cleanup = null;
     }
@@ -1570,45 +1503,13 @@ class B {
     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, r = (this._historyIdx - 1 + this._historyCapacity) % this._historyCapacity;
-    for (let c = 0; c < this._historyCount && !(this._history[r] < t); c++)
-      s++, r = (r - 1 + this._historyCapacity) % this._historyCapacity;
+    let s = 0, n = (this._historyIdx - 1 + this._historyCapacity) % this._historyCapacity;
+    for (let c = 0; c < this._historyCount && !(this._history[n] < t); c++)
+      s++, n = (n - 1 + this._historyCapacity) % this._historyCapacity;
     if (s > this._maxExecutions) {
-      const c = `Effect executed ${s} times within 1 second. Infinite loop suspected`, n = new b(c);
-      if (this.dispose(), console.error(n), h.enabled)
-        throw n;
-    }
-  }
-  /**
-   * Sets up modification tracking for a dependency.
-   *
-   * @param dep - The dependency (atom) to track modifications on
-   *
-   * @remarks
-   * This method intercepts the `value` setter on the dependency to detect
-   * when the effect modifies a dependency it also reads. This pattern
-   * (read-after-write within the same effect) often indicates an infinite loop.
-   *
-   * The original property descriptor is preserved and can be restored
-   * when the effect is disposed.
-   *
-   * @internal
-   */
-  _trackModificationsForDep(e) {
-    const t = Object.getPrototypeOf(e), s = Object.getOwnPropertyDescriptor(t, "value");
-    if (s?.set && !this._originalDescriptors.has(e)) {
-      this._originalDescriptors.set(e, s), this._trackedDeps.add(e);
-      const r = this;
-      Object.defineProperty(e, "value", {
-        set(c) {
-          r._modifiedDeps.add(e), s.set?.call(e, c);
-        },
-        get() {
-          return e.peek();
-        },
-        configurable: !0,
-        enumerable: !0
-      });
+      const c = `Effect executed ${s} times within 1 second. Infinite loop suspected`, u = new d(c);
+      if (this.dispose(), console.error(u), o.enabled)
+        throw u;
     }
   }
   /**
@@ -1625,42 +1526,56 @@ class B {
    * @internal
    */
   _checkLoopWarnings() {
-    if (this._trackModifications && h.enabled) {
+    if (this._trackModifications && o.enabled) {
       const e = this._depManager.getDependencies();
       for (let t = 0; t < e.length; t++) {
         const s = e[t];
-        this._modifiedDeps.has(s) && h.warn(
+        this._modifiedDeps.has(s) && o.warn(
           !0,
-          `Effect is reading a dependency (${h.getDebugName(s) || "unknown"}) that it just modified. Infinite loop may occur`
+          `Effect is reading a dependency (${o.getDebugName(s) || "unknown"}) that it just modified. Infinite loop may occur`
         );
       }
     }
   }
 }
-function Q(i, e = {}) {
+function q(i, e = {}) {
   if (typeof i != "function")
-    throw new b(o.EFFECT_MUST_BE_FUNCTION);
-  const t = new B(i, e);
+    throw new d(h.EFFECT_MUST_BE_FUNCTION);
+  const t = new w(i, e);
   return t.execute(), t;
 }
+function P(i) {
+  return i !== null && typeof i == "object" && "value" in i && "subscribe" in i && typeof i.subscribe == "function";
+}
+function z(i) {
+  if (o.enabled) {
+    const e = o.getDebugType(i);
+    if (e)
+      return e === "computed";
+  }
+  return P(i) && "invalidate" in i && typeof i.invalidate == "function";
+}
+function j(i) {
+  return i !== null && typeof i == "object" && "dispose" in i && "run" in i && typeof i.dispose == "function" && typeof i.run == "function";
+}
 export {
-  S as AsyncState,
+  b as AsyncState,
   a as AtomError,
-  d as ComputedError,
-  m as DEBUG_CONFIG,
-  h as DEBUG_RUNTIME,
-  b as EffectError,
-  j as POOL_CONFIG,
-  U as SCHEDULER_CONFIG,
-  g as SchedulerError,
-  X as atom,
-  G as batch,
-  z as computed,
-  Q as effect,
-  O as isAtom,
-  q as isComputed,
-  Y as isEffect,
-  D as scheduler,
-  V as untracked
+  _ as ComputedError,
+  R as DEBUG_CONFIG,
+  o as DEBUG_RUNTIME,
+  d as EffectError,
+  L as POOL_CONFIG,
+  A as SCHEDULER_CONFIG,
+  p as SchedulerError,
+  G as atom,
+  B as batch,
+  V as computed,
+  q as effect,
+  P as isAtom,
+  z as isComputed,
+  j as isEffect,
+  E as scheduler,
+  k as untracked
 };
 //# sourceMappingURL=index.mjs.map