@but212/atom-effect 0.3.2 → 0.3.3

package/dist/index.mjs

@@ -1,4 +1,4 @@
-const T = {
+const O = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
@@ -8,7 +8,7 @@ const T = {
   // 0001 - Effect has been disposed
   EXECUTING: 2
   // 0010 - Effect is currently executing
-}, h = {
+}, o = {
   DIRTY: 1,
   // 0001 - Needs recomputation
   IDLE: 2,
@@ -23,12 +23,12 @@ const T = {
   // 100000 - Currently recomputing
   HAS_ERROR: 64
   // 1000000 - Has error state
-}, ie = {
+}, le = {
   /** 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
-}, A = {
+}, P = {
   /** Maximum effect executions per second to detect infinite loops (Legacy/Fallback) */
   MAX_EXECUTIONS_PER_SECOND: 100,
   /** Threshold for cleaning up old execution timestamps */
@@ -43,13 +43,13 @@ const T = {
    * Increased from 1000 to 5000 based on evaluation report
    */
   MAX_EXECUTIONS_PER_FLUSH: 5e3
-}, k = {
+}, j = {
   /** Maximum dependencies before warning about large dependency graphs */
   MAX_DEPENDENCIES: 1e3,
   /** Enable infinite loop detection warnings */
   WARN_INFINITE_LOOP: !0
-}, D = 1073741823, M = typeof process < "u" && process.env && process.env.NODE_ENV !== "production";
-class d extends Error {
+}, T = 1073741823, d = typeof process < "u" && process.env && process.env.NODE_ENV !== "production";
+class E extends Error {
   /**
    * Creates a new AtomError
    * @param message - Error message describing what went wrong
@@ -60,7 +60,7 @@ class d extends Error {
     super(e), this.name = "AtomError", this.cause = t, this.recoverable = s, this.timestamp = /* @__PURE__ */ new Date();
   }
 }
-class I extends d {
+class C extends E {
   /**
    * Creates a new ComputedError
    * @param message - Error message
@@ -70,7 +70,7 @@ class I extends d {
     super(e, t, !0), this.name = "ComputedError";
   }
 }
-class g extends d {
+class g extends E {
   /**
    * Creates a new EffectError
    * @param message - Error message
@@ -80,7 +80,7 @@ class g extends d {
     super(e, t, !1), this.name = "EffectError";
   }
 }
-class C extends d {
+class A extends E {
   /**
    * Creates a new SchedulerError
    * @param message - Error message
@@ -90,20 +90,20 @@ class C extends d {
     super(e, t, !1), this.name = "SchedulerError";
   }
 }
-function R(i, e, t) {
+function N(i, e, t) {
   if (i instanceof TypeError)
     return new e(`Type error (${t}): ${i.message}`, i);
   if (i instanceof ReferenceError)
     return new e(`Reference error (${t}): ${i.message}`, i);
-  if (i instanceof d)
+  if (i instanceof E)
     return i;
   const s = i instanceof Error ? i.message : String(i), n = i instanceof Error ? i : null;
   return new e(`Unexpected error (${t}): ${s}`, n);
 }
-function X(i) {
+function Q(i) {
   return i != null && typeof i.then == "function";
 }
-const a = {
+const l = {
   // ─────────────────────────────────────────────────────────────────
   // Computed errors
   // ─────────────────────────────────────────────────────────────────
@@ -187,101 +187,150 @@ const a = {
    * @remarks This prevents cascading failures from masking the original error.
    */
   CALLBACK_ERROR_IN_ERROR_HANDLER: "Error occurred during onError callback execution"
+}, w = /* @__PURE__ */ Symbol("debugName"), ee = /* @__PURE__ */ Symbol("id"), V = /* @__PURE__ */ Symbol("type"), X = /* @__PURE__ */ Symbol("noDefaultValue");
+function te(i) {
+  return i !== null && typeof i == "object" && "dependencies" in i && Array.isArray(i.dependencies);
+}
+let G = 0;
+function H(i, e, t) {
+  const s = i;
+  if (s._visitedEpoch !== t) {
+    if (s._visitedEpoch = t, i === e)
+      throw new C("Indirect circular dependency detected");
+    if (te(i)) {
+      const n = i.dependencies;
+      for (let r = 0; r < n.length; r++)
+        H(n[r], e, t);
+    }
+  }
+}
+const S = {
+  enabled: typeof process < "u" && process.env?.NODE_ENV === "development",
+  maxDependencies: j.MAX_DEPENDENCIES,
+  warnInfiniteLoop: j.WARN_INFINITE_LOOP,
+  warn(i, e) {
+    this.enabled && i && console.warn(`[Atom Effect] ${e}`);
+  },
+  /**
+   * Checks for circular dependencies.
+   * Direct check runs always; indirect check only in dev mode.
+   * @throws {ComputedError} When circular dependency detected
+   */
+  checkCircular(i, e, t) {
+    if (i === e)
+      throw new C("Direct circular dependency detected");
+    this.enabled && (G++, H(i, e, G));
+  },
+  attachDebugInfo(i, e, t) {
+    if (!this.enabled)
+      return;
+    const s = i;
+    s[w] = `${e}_${t}`, s[ee] = t, s[V] = e;
+  },
+  getDebugName(i) {
+    if (i !== null && typeof i == "object" && w in i)
+      return i[w];
+  },
+  getDebugType(i) {
+    if (i !== null && typeof i == "object" && V in i)
+      return i[V];
+  }
 };
-let P = 0;
-function G() {
-  return P = (P + 1 | 0) & D, P;
+let se = 1;
+const ie = () => se++;
+class J {
+  constructor() {
+    this.id = ie() & T, this.flags = 0;
+  }
 }
-let U = 0, w = 0, O = !1;
-function q() {
-  return O ? (M && console.warn(
+class W extends J {
+  constructor() {
+    super(), this.version = 0, this._lastSeenEpoch = -1;
+  }
+  /**
+   * Subscribes a listener function or Subscriber object to 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 or Subscriber
+   */
+  subscribe(e) {
+    if (typeof e == "object" && e !== null && "execute" in e)
+      return this._objectSubscribers.add(e);
+    if (typeof e != "function")
+      throw new E(l.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
+    return this._functionSubscribers.add(e);
+  }
+  /**
+   * Gets the total number of active subscribers.
+   */
+  subscriberCount() {
+    return this._functionSubscribers.size + this._objectSubscribers.size;
+  }
+  /**
+   * Notifies all subscribers of a change.
+   *
+   * @param newValue - The new value
+   * @param oldValue - The old value
+   */
+  _notifySubscribers(e, t) {
+    this._functionSubscribers.forEachSafe(
+      (s) => s(e, t),
+      (s) => console.error(new E(l.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, s))
+    ), this._objectSubscribers.forEachSafe(
+      (s) => s.execute(),
+      (s) => console.error(new E(l.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, s))
+    );
+  }
+}
+let B = 0;
+function K() {
+  return B = (B + 1 | 0) & T, B;
+}
+let v = 0, k = 0, L = !1;
+function Y() {
+  return L ? (d && console.warn(
     "Warning: startFlush() called during flush - ignored to prevent infinite loop detection bypass"
-  ), !1) : (O = !0, U = U + 1 & D, w = 0, !0);
+  ), !1) : (L = !0, v = v + 1 & T, k = 0, !0);
 }
-function z() {
-  O = !1;
+function $() {
+  L = !1;
 }
-function H() {
-  return O ? ++w : 0;
+function ne() {
+  return L ? ++k : 0;
 }
-class J {
+class re {
   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;
   }
-  /**
-   * Gets the current phase of the scheduler.
-   */
   get phase() {
     return this.isProcessing || this.isFlushingSync ? 2 : this.isBatching ? 1 : 0;
   }
-  /**
-   * Schedules a callback for execution.
-   *
-   * If batching is active or a sync flush is in progress, the callback
-   * is added to the batch queue. Otherwise, it's added to the main queue
-   * and a flush is triggered via microtask.
-   *
-   * @param callback - The function to schedule for execution
-   * @throws {SchedulerError} If callback is not a function
-   *
-   * @example
-   * ```typescript
-   * scheduler.schedule(() => {
-   *   // This runs in the next microtask (or sync if batching)
-   *   updateUI();
-   * });
-   * ```
-   */
   schedule(e) {
     if (typeof e != "function")
-      throw new C("Scheduler callback must be a function");
+      throw new A("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()));
   }
-  /**
-   * Flushes the queue asynchronously via microtask.
-   *
-   * Executes all queued callbacks in a microtask, allowing the current
-   * synchronous execution to complete first. Errors in individual
-   * callbacks are caught and logged without interrupting others.
-   *
-   * @private
-   * @remarks
-   * This method is idempotent - calling it multiple times while
-   * processing is active has no effect.
-   */
   flush() {
     if (this.isProcessing || this.queueSize === 0) return;
     this.isProcessing = !0;
     const e = this.queue, t = this.queueSize;
     this.queue = this.queue === this.queueA ? this.queueB : this.queueA, this.queueSize = 0, this._epoch++, queueMicrotask(() => {
-      const s = q();
+      const s = Y();
       for (let n = 0; n < t; n++)
         try {
           e[n]?.();
         } catch (r) {
           console.error(
-            new C("Error occurred during scheduler execution", r)
+            new A("Error occurred during scheduler execution", r)
           );
         }
-      e.length = 0, this.isProcessing = !1, s && z(), this.queueSize > 0 && !this.isBatching && this.flush();
+      e.length = 0, this.isProcessing = !1, s && $(), this.queueSize > 0 && !this.isBatching && this.flush();
     });
   }
-  /**
-   * Flushes all queued callbacks synchronously.
-   *
-   * This method is called when a batch ends. It processes all callbacks
-   * in the batch queue and main queue synchronously, allowing callbacks
-   * to schedule additional callbacks that are processed in the same flush.
-   *
-   * @private
-   * @remarks
-   * - Includes infinite loop protection via maxFlushIterations
-   * - Errors in callbacks are caught and logged individually
-   * - The isFlushingSync flag prevents re-entrancy issues
-   */
   flushSync() {
     this.isFlushingSync = !0;
-    const e = q();
+    const e = Y();
     try {
       if (this._epoch++, this.batchQueueSize > 0) {
         for (let s = 0; s < this.batchQueueSize; s++) {
@@ -294,8 +343,8 @@ class J {
       for (; this.queueSize > 0; ) {
         if (++t > this.maxFlushIterations) {
           console.error(
-            new C(
-              `Maximum flush iterations (${this.maxFlushIterations}) exceeded. Possible infinite loop in reactive dependencies. Consider increasing the limit with scheduler.setMaxFlushIterations()`
+            new A(
+              `Maximum flush iterations (${this.maxFlushIterations}) exceeded. Possible infinite loop.`
             )
           ), this.queueSize = 0, this.queue.length = 0, this.batchQueueSize = 0;
           break;
@@ -307,7 +356,7 @@ class J {
             s[r]?.();
           } catch (c) {
             console.error(
-              new C("Error occurred during batch execution", c)
+              new A("Error occurred during batch execution", c)
             );
           }
         if (s.length = 0, this.batchQueueSize > 0) {
@@ -317,94 +366,36 @@ class J {
         }
       }
     } finally {
-      this.isFlushingSync = !1, e && z();
+      this.isFlushingSync = !1, e && $();
     }
   }
-  /**
-   * Starts a new batch operation.
-   *
-   * While batching is active, all scheduled callbacks are deferred
-   * until endBatch() is called. Batches can be nested - only the
-   * outermost endBatch() triggers execution.
-   *
-   * @example
-   * ```typescript
-   * scheduler.startBatch();
-   * // All updates here are deferred
-   * atom1.value = 'a';
-   * atom2.value = 'b';
-   * scheduler.endBatch(); // Both updates processed together
-   * ```
-   */
   startBatch() {
     this.batchDepth++, this.isBatching = !0;
   }
-  /**
-   * Ends a batch operation.
-   *
-   * Decrements the batch depth counter. When depth reaches zero,
-   * all queued callbacks are flushed synchronously and batching
-   * is disabled.
-   *
-   * @remarks
-   * Safe to call even if startBatch() wasn't called - depth is
-   * clamped to zero minimum.
-   *
-   * @example
-   * ```typescript
-   * scheduler.startBatch();
-   * try {
-   *   // ... batched operations
-   * } finally {
-   *   scheduler.endBatch(); // Always end batch, even on error
-   * }
-   * ```
-   */
   endBatch() {
     this.batchDepth = Math.max(0, this.batchDepth - 1), this.batchDepth === 0 && (this.flushSync(), this.isBatching = !1);
   }
-  /**
-   * Sets the maximum number of flush iterations allowed.
-   *
-   * This limit prevents infinite loops when reactive dependencies
-   * form cycles. If exceeded, the queue is cleared and an error
-   * is logged.
-   *
-   * @param max - Maximum iterations (must be at least 10)
-   * @throws {SchedulerError} If max is less than 10
-   *
-   * @example
-   * ```typescript
-   * // Increase limit for complex dependency graphs
-   * scheduler.setMaxFlushIterations(5000);
-   * ```
-   */
   setMaxFlushIterations(e) {
     if (e < 10)
-      throw new C("Max flush iterations must be at least 10");
+      throw new A("Max flush iterations must be at least 10");
     this.maxFlushIterations = e;
   }
 }
-const N = new J();
-function ne(i) {
+const U = new re();
+function ae(i) {
   if (typeof i != "function")
-    throw new d("Batch callback must be a function");
-  N.startBatch();
+    throw new E("Batch callback must be a function");
+  U.startBatch();
   try {
     return i();
   } catch (e) {
-    throw new d("Error occurred during batch execution", e);
+    throw new E("Error occurred during batch execution", e);
   } finally {
-    N.endBatch();
+    U.endBatch();
   }
 }
 const m = {
-  /** @inheritdoc */
   current: null,
-  /**
-   * @inheritdoc
-   * @throws Re-throws any error from the executed function after restoring context
-   */
   run(i, e) {
     const t = this.current;
     this.current = i;
@@ -414,192 +405,28 @@ const m = {
       this.current = t;
     }
   },
-  /** @inheritdoc */
   getCurrent() {
     return this.current;
   }
 };
-function re(i) {
+function ce(i) {
   if (typeof i != "function")
-    throw new d("Untracked callback must be a function");
+    throw new E("Untracked callback must be a function");
   const e = m.current;
   m.current = null;
   try {
     return i();
   } catch (t) {
-    throw new d("Error occurred during untracked execution", t);
+    throw new E("Error occurred during untracked execution", t);
   } finally {
     m.current = e;
   }
 }
-const v = /* @__PURE__ */ Symbol("debugName"), W = /* @__PURE__ */ Symbol("id"), L = /* @__PURE__ */ Symbol("type"), V = /* @__PURE__ */ Symbol("noDefaultValue");
-function K(i) {
-  return i !== null && typeof i == "object" && "dependencies" in i && Array.isArray(i.dependencies);
-}
-let j = 0;
-function Y(i, e, t) {
-  const s = i;
-  if (s._visitedEpoch !== t) {
-    if (s._visitedEpoch = t, i === e)
-      throw new I("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.
-   *
-   * @remarks
-   * Automatically set based on `NODE_ENV` environment variable.
-   * Only `'development'` enables debug features.
-   */
-  enabled: typeof process < "u" && process.env?.NODE_ENV === "development",
-  /**
-   * Maximum number of dependencies before warning.
-   *
-   * @see {@link DEBUG_CONFIG.MAX_DEPENDENCIES}
-   */
-  maxDependencies: k.MAX_DEPENDENCIES,
-  /**
-   * Whether to warn about potential infinite loops.
-   *
-   * @see {@link DEBUG_CONFIG.WARN_INFINITE_LOOP}
-   */
-  warnInfiniteLoop: k.WARN_INFINITE_LOOP,
-  /**
-   * Logs a warning message when condition is true and debug is enabled.
-   *
-   * @param condition - When true, the warning is logged
-   * @param message - The warning message to display
-   *
-   * @example
-   * ```typescript
-   * debug.warn(deps.length > 100, 'Large dependency graph detected');
-   * ```
-   */
-  warn(i, e) {
-    this.enabled && i && console.warn(`[Atom Effect] ${e}`);
-  },
-  /**
-   * Checks for circular dependencies in the dependency graph.
-   *
-   * Detects two types of circular references:
-   * 1. **Direct**: A depends on itself (A → A)
-   * 2. **Indirect**: A depends on B which depends on A (A → B → A)
-   *
-   * @param dep - The dependency being added
-   * @param current - The current reactive object adding the dependency
-   * @param visited - Set of already visited nodes (for recursion)
-   *
-   * @throws {ComputedError} When a circular dependency is detected
-   *
-   * @remarks
-   * - Direct circular detection runs in all environments
-   * - Indirect circular detection only runs in development mode
-   * - Uses depth-first traversal with O(n) time complexity
-   *
-   * @example
-   * ```typescript
-   * // This will throw for direct circular reference
-   * debug.checkCircular(computedA, computedA);
-   *
-   * // This will throw for indirect circular reference (dev only)
-   * // Given: A → B → C → A
-   * debug.checkCircular(computedC, computedA);
-   * ```
-   */
-  checkCircular(i, e, t) {
-    if (i === e)
-      throw new I("Direct circular dependency detected");
-    this.enabled && (j++, Y(i, e, j));
-  },
-  /**
-   * Attaches debug metadata to a reactive object.
-   *
-   * @param obj - The object to attach metadata to
-   * @param type - The type of reactive object ('atom' | 'computed' | 'effect')
-   * @param id - The unique identifier for this object
-   *
-   * @remarks
-   * Only attaches metadata when debug mode is enabled.
-   * Uses symbol keys to avoid property name collisions.
-   *
-   * @example
-   * ```typescript
-   * const atom = createAtomInternal(0);
-   * debug.attachDebugInfo(atom, 'atom', 1);
-   * // atom[DEBUG_NAME] === 'atom_1'
-   * // atom[DEBUG_ID] === 1
-   * // atom[DEBUG_TYPE] === 'atom'
-   * ```
-   */
-  attachDebugInfo(i, e, t) {
-    if (!this.enabled)
-      return;
-    const s = i;
-    s[v] = `${e}_${t}`, s[W] = t, s[L] = e;
-  },
-  /**
-   * Retrieves the debug display name from a reactive object.
-   *
-   * @param obj - The object to get the name from
-   * @returns The debug name (e.g., 'atom_1') or undefined if not set
-   *
-   * @example
-   * ```typescript
-   * const name = debug.getDebugName(myAtom);
-   * console.log(`Updating ${name ?? 'unknown'}`);
-   * ```
-   */
-  getDebugName(i) {
-    if (i !== null && typeof i == "object" && v in i)
-      return i[v];
-  },
-  /**
-   * Retrieves the debug type from a reactive object.
-   *
-   * @param obj - The object to get the type from
-   * @returns The type ('atom' | 'computed' | 'effect') or undefined if not set
-   *
-   * @example
-   * ```typescript
-   * const type = debug.getDebugType(reactiveObj);
-   * if (type === 'computed') {
-   *   // Handle computed-specific logic
-   * }
-   * ```
-   */
-  getDebugType(i) {
-    if (i !== null && typeof i == "object" && L in i)
-      return i[L];
-  }
-};
-let Z = 1;
-const B = () => Z++;
-class x {
+class M {
   constructor() {
     this.subscribers = null;
   }
-  /**
-   * Adds a subscriber and returns an unsubscribe function
-   *
-   * Performs lazy initialization on first subscriber.
-   * Duplicate subscribers are ignored (idempotent).
-   *
-   * @param subscriber - Function to add as subscriber
-   * @returns Unsubscribe function
-   *
-   * @example
-   * ```ts
-   * const unsub = manager.add((value) => console.log(value));
-   * // Later...
-   * unsub(); // Remove this subscriber
-   * ```
-   */
+  /** Adds subscriber and returns unsubscribe function (idempotent) */
   add(e) {
     if (this.subscribers || (this.subscribers = []), this.subscribers.indexOf(e) !== -1)
       return () => {
@@ -610,16 +437,7 @@ class x {
       t || (t = !0, this.remove(e));
     };
   }
-  /**
-   * Removes a subscriber using swap-and-pop optimization
-   *
-   * Linear search + O(1) swap-and-pop removal.
-   * For small arrays, this is faster than hash-based approaches
-   * due to cache locality.
-   *
-   * @param subscriber - Subscriber to remove
-   * @returns True if removed, false if not found
-   */
+  /** Removes subscriber using swap-and-pop */
   remove(e) {
     if (!this.subscribers)
       return !1;
@@ -629,44 +447,15 @@ class x {
     const s = this.subscribers.length - 1;
     return t !== s && (this.subscribers[t] = this.subscribers[s]), this.subscribers.pop(), !0;
   }
-  /**
-   * Checks if a subscriber is registered
-   *
-   * @param subscriber - Subscriber to check
-   * @returns True if registered
-   */
   has(e) {
     return this.subscribers ? this.subscribers.indexOf(e) !== -1 : !1;
   }
-  /**
-   * Iterates over all subscribers with a callback
-   *
-   * Optimized for cache-friendly sequential access.
-   * Errors in callbacks are propagated to the caller.
-   *
-   * @param fn - Callback to execute for each subscriber
-   *
-   * @example
-   * ```ts
-   * manager.forEach((subscriber) => {
-   *   subscriber(newValue, oldValue);
-   * });
-   * ```
-   */
   forEach(e) {
     if (this.subscribers)
       for (let t = 0; t < this.subscribers.length; t++)
         e(this.subscribers[t], t);
   }
-  /**
-   * Safely iterates over subscribers with error handling
-   *
-   * Catches and logs errors from individual callbacks to prevent
-   * one failing subscriber from breaking the entire notification chain.
-   *
-   * @param fn - Callback to execute for each subscriber
-   * @param onError - Optional error handler for each callback error
-   */
+  /** Iterates with error handling to prevent one failure from breaking the chain */
   forEachSafe(e, t) {
     if (this.subscribers)
       for (let s = 0; s < this.subscribers.length; s++)
@@ -676,224 +465,101 @@ class x {
           t ? t(n) : console.error("[SubscriberManager] Error in subscriber callback:", n);
         }
   }
-  /**
-   * Gets the current number of subscribers
-   *
-   * @returns Number of active subscribers
-   */
   get size() {
     return this.subscribers?.length ?? 0;
   }
-  /**
-   * Checks if there are any subscribers
-   *
-   * @returns True if at least one subscriber exists
-   */
   get hasSubscribers() {
     return this.size > 0;
   }
-  /**
-   * Clears all subscribers
-   *
-   * Removes all subscribers and releases memory.
-   * Subsequent operations will re-initialize lazily.
-   */
   clear() {
     this.subscribers = null;
   }
-  /**
-   * Gets a copy of all subscribers as an array
-   *
-   * Useful for debugging or manual iteration.
-   * Returns empty array if no subscribers.
-   *
-   * @returns Array of all subscribers
-   */
   toArray() {
     return this.subscribers ? [...this.subscribers] : [];
   }
 }
-class ee {
-  /**
-   * Creates a new AtomImpl instance.
-   *
-   * @param initialValue - The initial value of the atom
-   * @param sync - Whether to notify subscribers synchronously
-   */
+class ue extends W {
   constructor(e, t) {
-    this._isNotificationScheduled = !1, this.id = B() & D, 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);
+    super(), this._isNotificationScheduled = !1, this._value = e, this._functionSubscribersStore = new M(), this._objectSubscribersStore = new M(), this._sync = t, this._notifyTask = this._flushNotifications.bind(this), S.attachDebugInfo(this, "atom", this.id);
   }
-  /**
-   * 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 _functionSubscribers() {
+    return this._functionSubscribersStore;
+  }
+  get _objectSubscribers() {
+    return this._objectSubscribersStore;
+  }
+  /** Gets value and registers as dependency in current tracking context */
   get value() {
     const e = m.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.
-   */
+  /** Sets value and notifies subscribers if changed (uses Object.is) */
   set value(e) {
     if (Object.is(this._value, e)) return;
     const t = this._value;
-    this.version = this.version + 1 & D;
+    this.version = this.version + 1 & T;
     const s = this.version;
-    this._value = e, !(!this._functionSubscribers.hasSubscribers && !this._objectSubscribers.hasSubscribers) && this._notify(e, t, s);
+    this._value = e, !(!this._functionSubscribersStore.hasSubscribers && !this._objectSubscribersStore.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);
+      t.addDependency !== void 0 ? t.addDependency(this) : this._functionSubscribersStore.add(e);
     } else {
       const t = e;
-      t.addDependency !== void 0 ? t.addDependency(this) : t.execute !== void 0 && this._objectSubscribers.add(t);
+      t.addDependency !== void 0 ? t.addDependency(this) : t.execute !== void 0 && this._objectSubscribersStore.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 && !N.isBatching ? this._flushNotifications() : N.schedule(this._notifyTask);
+    this._isNotificationScheduled || (this._pendingOldValue = t, this._isNotificationScheduled = !0), this._sync && !U.isBatching ? this._flushNotifications() : U.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 d(a.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, s))
-    ), this._objectSubscribers.forEachSafe(
-      (s) => s.execute(),
-      (s) => console.error(new d(a.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, s))
-    );
-  }
-  /**
-   * Subscribes a listener function or Subscriber object to 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 or Subscriber
-   *
-   * @example
-   * ```ts
-   * const unsub = myAtom.subscribe((newVal, oldVal) => {
-   *   console.log(`Changed from ${oldVal} to ${newVal}`);
-   * });
-   * // Later: unsub();
-   * ```
-   */
-  subscribe(e) {
-    if (typeof e == "object" && e !== null && "execute" in e)
-      return this._objectSubscribers.add(e);
-    if (typeof e != "function")
-      throw new d(a.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
-    return this._functionSubscribers.add(e);
+    this._pendingOldValue = void 0, this._isNotificationScheduled = !1, this._notifySubscribers(t, 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).
-   */
+  /** Gets value without registering as dependency */
   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;
+    this._functionSubscribersStore.clear(), this._objectSubscribersStore.clear(), this._value = void 0;
   }
 }
-function ce(i, e = {}) {
-  return new ee(i, e.sync ?? !1);
+function _e(i, e = {}) {
+  return new ue(i, e.sync ?? !1);
 }
-const p = process.env.NODE_ENV !== "production", f = Object.freeze([]), E = Object.freeze([]);
-class $ {
+const _ = Object.freeze([]), b = Object.freeze([]), f = Object.freeze([]);
+class z {
   constructor() {
-    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = p ? {
+    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = d ? {
       acquired: 0,
       released: 0,
       rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
     } : null;
   }
   acquire() {
-    return p && this.stats && this.stats.acquired++, this.pool.pop() ?? [];
+    return d && this.stats && this.stats.acquired++, this.pool.pop() ?? [];
   }
   release(e, t) {
     if (!(t && e === t)) {
       if (Object.isFrozen(e)) {
-        p && this.stats && this.stats.rejected.frozen++;
+        d && this.stats && this.stats.rejected.frozen++;
         return;
       }
       if (e.length > this.maxReusableCapacity) {
-        p && this.stats && this.stats.rejected.tooLarge++;
+        d && this.stats && this.stats.rejected.tooLarge++;
         return;
       }
       if (this.pool.length >= this.maxPoolSize) {
-        p && this.stats && this.stats.rejected.poolFull++;
+        d && this.stats && this.stats.rejected.poolFull++;
         return;
       }
-      e.length = 0, this.pool.push(e), p && this.stats && this.stats.released++;
+      e.length = 0, this.pool.push(e), d && this.stats && this.stats.released++;
     }
   }
   getStats() {
-    if (!p || !this.stats) return null;
+    if (!d || !this.stats) return null;
     const { acquired: e, released: t, rejected: s } = this.stats, n = s.frozen + s.tooLarge + s.poolFull;
     return {
       acquired: e,
@@ -904,28 +570,47 @@ class $ {
     };
   }
   reset() {
-    this.pool.length = 0, p && this.stats && (this.stats.acquired = 0, this.stats.released = 0, this.stats.rejected = { frozen: 0, tooLarge: 0, poolFull: 0 });
+    this.pool.length = 0, d && this.stats && (this.stats.acquired = 0, this.stats.released = 0, this.stats.rejected = { frozen: 0, tooLarge: 0, poolFull: 0 });
   }
 }
-const S = new $(), y = new $();
-class Q {
+const y = new z(), I = new z(), p = new z();
+function q(i, e, t, s) {
+  if (e !== _ && t !== b)
+    for (let r = 0; r < e.length; r++) {
+      const c = e[r];
+      c && (c._tempUnsub = t[r]);
+    }
+  const n = I.acquire();
+  n.length = i.length;
+  for (let r = 0; r < i.length; r++) {
+    const c = i[r];
+    c && (c._tempUnsub ? (n[r] = c._tempUnsub, c._tempUnsub = void 0) : (S.checkCircular(c, s), n[r] = c.subscribe(s)));
+  }
+  if (e !== _)
+    for (let r = 0; r < e.length; r++) {
+      const c = e[r];
+      c?._tempUnsub && (c._tempUnsub(), c._tempUnsub = void 0);
+    }
+  return t !== b && I.release(t), n;
+}
+class Z extends W {
   constructor(e, t = {}) {
     if (typeof e != "function")
-      throw new I(a.COMPUTED_MUST_BE_FUNCTION);
-    if (this.id = B() & D, 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 : V, this._hasDefaultValue = this._defaultValue !== V, 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._notifyJob = () => {
-      this._functionSubscribers.forEachSafe(
+      throw new C(l.COMPUTED_MUST_BE_FUNCTION);
+    if (super(), this._value = void 0, this.flags = o.DIRTY | o.IDLE, this._error = null, this._promiseId = 0, this._equal = t.equal ?? Object.is, this._fn = e, this._defaultValue = "defaultValue" in t ? t.defaultValue : X, this._hasDefaultValue = this._defaultValue !== X, this._onError = t.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._functionSubscribersStore = new M(), this._objectSubscribersStore = new M(), this._dependencies = _, this._dependencyVersions = f, this._unsubscribes = b, this._notifyJob = () => {
+      this._functionSubscribersStore.forEachSafe(
         (s) => s(),
         (s) => console.error(s)
-      ), this._objectSubscribers.forEachSafe(
+      ), this._objectSubscribersStore.forEachSafe(
         (s) => s.execute(),
         (s) => console.error(s)
       );
     }, this._trackable = Object.assign(() => this._markDirty(), {
       addDependency: (s) => {
       }
-    }), b.attachDebugInfo(this, "computed", this.id), b.enabled) {
+    }), S.attachDebugInfo(this, "computed", this.id), S.enabled) {
       const s = this;
-      s.subscriberCount = () => this._functionSubscribers.size + this._objectSubscribers.size, s.isDirty = () => this._isDirty(), s.dependencies = this._dependencies, s.stateFlags = this._getFlagsAsString();
+      s.subscriberCount = () => this._functionSubscribersStore.size + this._objectSubscribersStore.size, s.isDirty = () => this._isDirty(), s.dependencies = this._dependencies, s.stateFlags = this._getFlagsAsString();
     }
     if (t.lazy === !1)
       try {
@@ -933,19 +618,15 @@ class Q {
       } catch {
       }
   }
-  // === PUBLIC API ===
-  get value() {
-    if ((this._stateFlags & (h.RESOLVED | h.DIRTY)) === h.RESOLVED)
-      return this._registerTracking(), this._value;
-    const t = this._computeValue();
-    return this._registerTracking(), t;
+  get _functionSubscribers() {
+    return this._functionSubscribersStore;
   }
-  subscribe(e) {
-    if (typeof e == "object" && e !== null && "execute" in e)
-      return this._objectSubscribers.add(e);
-    if (typeof e != "function")
-      throw new I(a.COMPUTED_SUBSCRIBER_MUST_BE_FUNCTION);
-    return this._functionSubscribers.add(e);
+  get _objectSubscribers() {
+    return this._objectSubscribersStore;
+  }
+  get value() {
+    const e = this._computeValue();
+    return this._registerTracking(), e;
   }
   peek() {
     return this._value;
@@ -966,126 +647,97 @@ class Q {
     return this._isResolved();
   }
   invalidate() {
-    this._markDirty();
+    this._markDirty(), this._dependencyVersions !== f && (p.release(this._dependencyVersions), this._dependencyVersions = f);
   }
   dispose() {
-    if (this._unsubscribes !== E) {
+    if (this._unsubscribes !== b) {
       for (let e = 0; e < this._unsubscribes.length; e++) {
         const t = this._unsubscribes[e];
         t && t();
       }
-      y.release(this._unsubscribes), this._unsubscribes = E;
+      I.release(this._unsubscribes), this._unsubscribes = b;
     }
-    this._dependencies !== f && (S.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;
+    this._dependencies !== _ && (y.release(this._dependencies), this._dependencies = _), this._dependencyVersions !== f && (p.release(this._dependencyVersions), this._dependencyVersions = f), this._functionSubscribersStore.clear(), this._objectSubscribersStore.clear(), this.flags = o.DIRTY | o.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID;
   }
-  // === PRIVATE: State Flag Operations (inlined for performance) ===
+  // State flag operations
   _isDirty() {
-    return (this._stateFlags & h.DIRTY) !== 0;
+    return (this.flags & o.DIRTY) !== 0;
   }
   _setDirty() {
-    this._stateFlags |= h.DIRTY;
+    this.flags |= o.DIRTY;
   }
   _clearDirty() {
-    this._stateFlags &= -2;
+    this.flags &= -2;
   }
   _isIdle() {
-    return (this._stateFlags & h.IDLE) !== 0;
+    return (this.flags & o.IDLE) !== 0;
   }
   _setIdle() {
-    this._stateFlags |= h.IDLE, this._stateFlags &= -29;
+    this.flags |= o.IDLE, this.flags &= -29;
   }
   _isPending() {
-    return (this._stateFlags & h.PENDING) !== 0;
+    return (this.flags & o.PENDING) !== 0;
   }
   _setPending() {
-    this._stateFlags |= h.PENDING, this._stateFlags &= -27;
+    this.flags |= o.PENDING, this.flags &= -27;
   }
   _isResolved() {
-    return (this._stateFlags & h.RESOLVED) !== 0;
+    return (this.flags & o.RESOLVED) !== 0;
   }
   _setResolved() {
-    this._stateFlags |= h.RESOLVED, this._stateFlags &= -87;
+    this.flags |= o.RESOLVED, this.flags &= -87;
   }
   _isRejected() {
-    return (this._stateFlags & h.REJECTED) !== 0;
+    return (this.flags & o.REJECTED) !== 0;
   }
   _setRejected() {
-    this._stateFlags |= h.REJECTED | h.HAS_ERROR, this._stateFlags &= -15;
+    this.flags |= o.REJECTED | o.HAS_ERROR, this.flags &= -15;
   }
   _isRecomputing() {
-    return (this._stateFlags & h.RECOMPUTING) !== 0;
+    return (this.flags & o.RECOMPUTING) !== 0;
   }
   _setRecomputing(e) {
-    const t = h.RECOMPUTING;
-    this._stateFlags = this._stateFlags & ~t | -Number(e) & t;
+    const t = o.RECOMPUTING;
+    this.flags = this.flags & ~t | -Number(e) & t;
   }
   _getAsyncState() {
-    return this._isPending() ? T.PENDING : this._isResolved() ? T.RESOLVED : this._isRejected() ? T.REJECTED : T.IDLE;
+    return this._isPending() ? O.PENDING : this._isResolved() ? O.RESOLVED : this._isRejected() ? O.REJECTED : O.IDLE;
   }
   _getFlagsAsString() {
     const e = [];
     return this._isDirty() && e.push("DIRTY"), this._isIdle() && e.push("IDLE"), this._isPending() && e.push("PENDING"), this._isResolved() && e.push("RESOLVED"), this._isRejected() && e.push("REJECTED"), this._isRecomputing() && e.push("RECOMPUTING"), e.join(" | ");
   }
-  // === PRIVATE: Core Computation Logic ===
   _computeValue() {
-    return this._isRecomputing() ? this._value : this._isPending() ? this._handlePending() : this._isRejected() ? this._handleRejected() : (this._isDirty() || this._isIdle()) && (this._recompute(), this._isPending()) ? this._handlePending() : this._value;
+    return this._isRecomputing() ? this._value : ((this._isDirty() || this._isIdle()) && this._recompute(), this._isPending() ? this._handlePending() : this._isRejected() ? this._handleRejected() : this._value);
   }
   _recompute() {
-    if (!this._isDirty() && this._isResolved())
-      return;
+    if (this._isRecomputing()) return;
     this._setRecomputing(!0);
-    const e = this._dependencies, t = S.acquire(), s = G();
-    let n = 0;
-    const r = (_) => {
-      _._lastSeenEpoch !== s && (_._lastSeenEpoch = s, n < t.length ? t[n] = _ : t.push(_), n++);
-    }, c = this._trackable.addDependency;
-    this._trackable.addDependency = r;
-    let o = !1;
+    const e = this._dependencies, t = this._dependencyVersions, s = y.acquire(), n = p.acquire(), r = K();
+    let c = 0;
+    const x = (h) => {
+      h._lastSeenEpoch !== r && (h._lastSeenEpoch = r, c < s.length ? (s[c] = h, n[c] = h.version) : (s.push(h), n.push(h.version)), c++);
+    }, D = this._trackable.addDependency;
+    this._trackable.addDependency = x;
+    let R = !1;
     try {
-      const _ = m.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);
+      const h = m.run(this._trackable, this._fn);
+      if (s.length = c, n.length = c, Q(h)) {
+        this._unsubscribes = q(s, e, this._unsubscribes, this), this._dependencies = s, this._dependencyVersions = n, R = !0, this._handleAsyncComputation(h), this._setRecomputing(!1);
         return;
       }
-      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(_);
+      this._unsubscribes = q(s, e, this._unsubscribes, this), this._dependencies = s, this._dependencyVersions = n, R = !0, this._handleSyncResult(h);
+    } catch (h) {
+      s.length = c, n.length = c, this._unsubscribes = q(s, e, this._unsubscribes, this), this._dependencies = s, this._dependencyVersions = n, R = !0, this._handleComputationError(h);
     } finally {
-      this._trackable.addDependency = c, o ? e !== f && S.release(e) : S.release(t);
-    }
-  }
-  /**
-   * Synchronizes subscriptions based on dependency changes.
-   * O(N) Diff using Epoch.
-   */
-  /**
-   * 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 = y.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)));
+      this._trackable.addDependency = D, R ? (e !== _ && y.release(e), t !== f && p.release(t)) : (y.release(s), p.release(n));
     }
-    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 && y.release(s), this._unsubscribes = r;
   }
   _handleSyncResult(e) {
-    (!this._isResolved() || !this._equal(this._value, e)) && (this.version = this.version + 1 & D), this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1);
+    (!this._isResolved() || !this._equal(this._value, e)) && (this.version = this.version + 1 & T), this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1);
   }
   _handleAsyncComputation(e) {
-    this._setPending(), this._promiseId = this._promiseId >= this.MAX_PROMISE_ID ? 1 : this._promiseId + 1;
+    this._setPending(), this._clearDirty(), this._promiseId = this._promiseId >= this.MAX_PROMISE_ID ? 1 : this._promiseId + 1;
     const t = this._promiseId;
     e.then((s) => {
       t === this._promiseId && this._handleAsyncResolution(s);
@@ -1094,68 +746,44 @@ class Q {
     });
   }
   _handleAsyncResolution(e) {
-    (!this._isResolved() || !this._equal(this._value, e)) && (this.version = this.version + 1 & D), this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1);
+    (!this._isResolved() || !this._equal(this._value, e)) && (this.version = this.version + 1 & T), this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1);
   }
   _handleAsyncRejection(e) {
-    const t = R(e, I, a.COMPUTED_ASYNC_COMPUTATION_FAILED);
+    const t = N(e, C, l.COMPUTED_ASYNC_COMPUTATION_FAILED);
     if (this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError && typeof this._onError == "function")
       try {
         this._onError(t);
       } catch (s) {
-        console.error(a.CALLBACK_ERROR_IN_ERROR_HANDLER, s);
+        console.error(l.CALLBACK_ERROR_IN_ERROR_HANDLER, s);
       }
-    this._notifySubscribers();
+    this._notifySubscribers(void 0, void 0);
   }
   _handleComputationError(e) {
-    const t = R(e, I, a.COMPUTED_COMPUTATION_FAILED);
+    const t = N(e, C, l.COMPUTED_COMPUTATION_FAILED);
     if (this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError && typeof this._onError == "function")
       try {
         this._onError(t);
       } catch (s) {
-        console.error(a.CALLBACK_ERROR_IN_ERROR_HANDLER, s);
+        console.error(l.CALLBACK_ERROR_IN_ERROR_HANDLER, s);
       }
     throw t;
   }
   _handlePending() {
     if (this._hasDefaultValue)
       return this._defaultValue;
-    throw new I(a.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    throw new C(l.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
   }
   _handleRejected() {
     if (this._error?.recoverable && this._hasDefaultValue)
       return this._defaultValue;
     throw this._error;
   }
-  // === 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
-   */
+  /** Subscriber interface - marks dirty on dependency change */
   execute() {
     this._markDirty();
   }
-  /**
-   * Push-State, Pull-Value pattern:
-   * Marks this computed as dirty and propagates to all subscribers.
-   * - Object subscribers (Computed atoms): will mark themselves dirty
-   * - Function subscribers (Effects): will schedule their execution
-   * Actual recomputation happens lazily when .value is accessed (Pull).
-   */
   _markDirty() {
-    this._isRecomputing() || this._isDirty() || (this._setDirty(), this._setIdle(), this._notifyJob());
-  }
-  /**
-   * Notifies function subscribers (Effects) of state changes.
-   * Currently only called from _handleAsyncRejection to notify Effects of errors.
-   * In normal operation, Effects are notified via _markDirty during dirty propagation.
-   */
-  _notifySubscribers() {
-    this._functionSubscribers.hasSubscribers && this._functionSubscribers.forEachSafe(
-      (e) => e(),
-      (e) => console.error(e)
-    );
+    this._isRecomputing() || this._isDirty() || (this._setDirty(), this._notifyJob());
   }
   _registerTracking() {
     const e = m.getCurrent();
@@ -1164,223 +792,121 @@ class Q {
         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);
+        t.addDependency ? t.addDependency(this) : this._functionSubscribersStore.add(e);
+      } else e.execute && this._objectSubscribersStore.add(e);
   }
 }
-Object.freeze(Q.prototype);
-function ue(i, e = {}) {
-  return new Q(i, e);
+Object.freeze(Z.prototype);
+function fe(i, e = {}) {
+  return new Z(i, e);
 }
-class te {
+class oe extends J {
   constructor(e, t = {}) {
-    this.run = () => {
+    super(), this.run = () => {
       if (this.isDisposed)
-        throw new g(a.EFFECT_MUST_BE_FUNCTION);
-      this.execute();
+        throw new g(l.EFFECT_MUST_BE_FUNCTION);
+      this._dependencyVersions !== f && (p.release(this._dependencyVersions), this._dependencyVersions = f), this.execute();
     }, this.dispose = () => {
       if (!this.isDisposed) {
-        if (this._setDisposed(), this._safeCleanup(), this._unsubscribes !== E) {
+        if (this._setDisposed(), this._safeCleanup(), this._unsubscribes !== b) {
           for (let s = 0; s < this._unsubscribes.length; s++) {
             const n = this._unsubscribes[s];
             n && n();
           }
-          y.release(this._unsubscribes), this._unsubscribes = E;
+          I.release(this._unsubscribes), this._unsubscribes = b;
         }
-        this._dependencies !== f && (S.release(this._dependencies), this._dependencies = f);
+        this._dependencies !== _ && (y.release(this._dependencies), this._dependencies = _), this._dependencyVersions !== f && (p.release(this._dependencyVersions), this._dependencyVersions = f);
       }
     }, this.addDependency = (s) => {
-      if (this.isExecuting && this._nextDeps && this._nextUnsubs) {
+      if (this.isExecuting && this._nextDeps && this._nextUnsubs && this._nextVersions) {
         const n = s, r = this._currentEpoch;
         if (n._lastSeenEpoch === r) return;
-        n._lastSeenEpoch = r, this._nextDeps.push(n), n._tempUnsub ? (this._nextUnsubs.push(n._tempUnsub), n._tempUnsub = void 0) : this._subscribeTo(n);
+        n._lastSeenEpoch = r, this._nextDeps.push(n), this._nextVersions.push(n.version), n._tempUnsub ? (this._nextUnsubs.push(n._tempUnsub), n._tempUnsub = void 0) : this._subscribeTo(n);
       }
     }, this.execute = () => {
-      if (this.isDisposed || this.isExecuting) return;
+      if (this.isDisposed || this.isExecuting || !this._shouldExecute()) return;
       this._checkInfiniteLoop(), this._setExecuting(!0), this._safeCleanup();
-      const s = this._dependencies, n = this._unsubscribes, r = S.acquire(), c = y.acquire(), o = G();
-      if (s !== f && n !== E)
+      const s = this._dependencies, n = this._dependencyVersions, r = this._unsubscribes, c = y.acquire(), x = p.acquire(), D = I.acquire(), R = K();
+      if (s !== _ && r !== b)
         for (let u = 0; u < s.length; u++) {
-          const l = s[u];
-          l && (l._tempUnsub = n[u]);
+          const a = s[u];
+          a && (a._tempUnsub = r[u]);
         }
-      this._nextDeps = r, this._nextUnsubs = c, this._currentEpoch = o;
-      let _ = !1;
+      this._nextDeps = c, this._nextVersions = x, this._nextUnsubs = D, this._currentEpoch = R;
+      let h = !1;
       try {
         const u = m.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, g, a.EFFECT_EXECUTION_FAILED));
+        this._dependencies = c, this._dependencyVersions = x, this._unsubscribes = D, h = !0, this._checkLoopWarnings(), Q(u) ? u.then((a) => {
+          !this.isDisposed && typeof a == "function" && (this._cleanup = a);
+        }).catch((a) => {
+          console.error(N(a, g, l.EFFECT_EXECUTION_FAILED));
         }) : this._cleanup = typeof u == "function" ? u : null;
       } catch (u) {
-        _ = !0, console.error(R(u, g, a.EFFECT_EXECUTION_FAILED)), this._cleanup = null;
+        h = !0, console.error(N(u, g, l.EFFECT_EXECUTION_FAILED)), this._cleanup = null;
       } finally {
-        if (this._setExecuting(!1), this._nextDeps = null, this._nextUnsubs = null, _) {
-          if (s !== f) {
+        if (this._setExecuting(!1), this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, h) {
+          if (s !== _) {
             for (let u = 0; u < s.length; u++) {
-              const l = s[u];
-              l?._tempUnsub && (l._tempUnsub(), l._tempUnsub = void 0);
+              const a = s[u];
+              a?._tempUnsub && (a._tempUnsub(), a._tempUnsub = void 0);
             }
-            S.release(s);
+            y.release(s);
           }
-          n !== E && y.release(n);
+          r !== b && I.release(r), n !== f && p.release(n);
         } else {
-          S.release(r);
-          for (let u = 0; u < c.length; u++)
-            c[u]?.();
-          if (y.release(c), s !== f)
+          y.release(c), p.release(x);
+          for (let u = 0; u < D.length; u++)
+            D[u]?.();
+          if (I.release(D), s !== _)
             for (let u = 0; u < s.length; u++) {
-              const l = s[u];
-              l && (l._tempUnsub = void 0);
+              const a = s[u];
+              a && (a._tempUnsub = void 0);
             }
         }
       }
-    }, this._id = B() & D, this._flags = 0, this._currentEpoch = -1, this._fn = e, this._sync = t.sync ?? !1, this._maxExecutions = t.maxExecutionsPerSecond ?? A.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = t.maxExecutionsPerFlush ?? A.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 = M ? [] : null, this._executionCount = 0, b.attachDebugInfo(this, "effect", this._id);
+    }, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._fn = e, this._sync = t.sync ?? !1, this._maxExecutions = t.maxExecutionsPerSecond ?? P.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = t.maxExecutionsPerFlush ?? P.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = t.trackModifications ?? !1, this._cleanup = null, this._dependencies = _, this._dependencyVersions = f, this._unsubscribes = b, this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, this._history = d ? [] : null, this._executionCount = 0, S.attachDebugInfo(this, "effect", this.id);
   }
-  /**
-   * Synchronizes subscriptions by unsubscribing from removed dependencies.
-   * Uses epoch-based O(N) diff to identify stale dependencies.
-   *
-   * @param prevDeps - Previous dependency array
-   * @param epoch - Current execution epoch for staleness detection
-   */
-  // _syncDependencies removed (inline logic in execute)
   _subscribeTo(e) {
     try {
       const t = e.subscribe(() => {
-        this._trackModifications && this.isExecuting && (e._modifiedAtEpoch = this._currentEpoch), this._sync ? this.execute() : N.schedule(this.execute);
+        this._trackModifications && this.isExecuting && (e._modifiedAtEpoch = this._currentEpoch), this._sync ? this.execute() : U.schedule(this.execute);
       });
       this._nextUnsubs && this._nextUnsubs.push(t);
     } catch (t) {
-      console.error(R(t, g, a.EFFECT_EXECUTION_FAILED)), this._nextUnsubs && this._nextUnsubs.push(() => {
+      console.error(N(t, g, l.EFFECT_EXECUTION_FAILED)), this._nextUnsubs && this._nextUnsubs.push(() => {
       });
     }
   }
-  /**
-   * Indicates whether this effect has been disposed.
-   *
-   * @returns `true` if the effect has been disposed, `false` otherwise
-   *
-   * @remarks
-   * A disposed effect will not execute and cannot be reactivated.
-   * Use this property to check if the effect is still active before
-   * performing operations that depend on it.
-   *
-   * @example
-   * ```typescript
-   * const fx = effect(() => console.log(counter.value));
-   * console.log(fx.isDisposed); // false
-   * fx.dispose();
-   * console.log(fx.isDisposed); // true
-   * ```
-   */
   get isDisposed() {
-    return (this._flags & F.DISPOSED) !== 0;
+    return (this.flags & F.DISPOSED) !== 0;
   }
-  /**
-   * Returns the total number of times this effect has been executed.
-   *
-   * @returns The cumulative execution count since the effect was created
-   *
-   * @remarks
-   * This counter is useful for debugging, testing, and monitoring
-   * effect behavior. It increments on every execution, regardless
-   * of whether the execution succeeds or fails.
-   *
-   * @example
-   * ```typescript
-   * const fx = effect(() => console.log(counter.value));
-   * console.log(fx.executionCount); // 1 (initial execution)
-   * counter.value = 10;
-   * console.log(fx.executionCount); // 2
-   * ```
-   */
   get executionCount() {
     return this._executionCount;
   }
-  /**
-   * Indicates whether this effect is currently executing.
-   *
-   * @returns `true` if the effect is mid-execution, `false` otherwise
-   *
-   * @remarks
-   * This property is used internally to prevent re-entrant execution
-   * (an effect triggering itself during its own execution). It can
-   * also be useful for debugging to understand the effect's state.
-   *
-   * @example
-   * ```typescript
-   * const fx = effect(() => {
-   *   console.log('executing:', fx.isExecuting); // true
-   * });
-   * console.log(fx.isExecuting); // false (after execution completes)
-   * ```
-   */
   get isExecuting() {
-    return (this._flags & F.EXECUTING) !== 0;
+    return (this.flags & F.EXECUTING) !== 0;
   }
-  /**
-   * Sets the disposed flag on this effect.
-   *
-   * @remarks
-   * This is a low-level method that only sets the bit flag.
-   * Use the public `dispose()` method for proper cleanup.
-   *
-   * @internal
-   */
   _setDisposed() {
-    this._flags |= F.DISPOSED;
+    this.flags |= F.DISPOSED;
   }
-  /**
-   * Sets or clears the executing flag on this effect.
-   *
-   * @param value - `true` to mark as executing, `false` to clear
-   *
-   * @remarks
-   * Uses bitwise operations for efficient flag manipulation.
-   * This flag prevents re-entrant execution of the effect.
-   *
-   * @internal
-   */
   _setExecuting(e) {
     const t = F.EXECUTING;
-    this._flags = this._flags & ~t | -Number(e) & t;
+    this.flags = this.flags & ~t | -Number(e) & t;
   }
-  /**
-   * Safely executes the cleanup function if one exists.
-   *
-   * @remarks
-   * This method:
-   * - Checks if a cleanup function exists and is callable
-   * - Wraps the cleanup call in a try-catch to prevent cleanup errors
-   *   from breaking the effect lifecycle
-   * - Logs any cleanup errors to the console
-   * - Clears the cleanup reference after execution
-   *
-   * @internal
-   */
   _safeCleanup() {
     if (this._cleanup && typeof this._cleanup == "function") {
       try {
         this._cleanup();
       } catch (e) {
-        console.error(R(e, g, a.EFFECT_CLEANUP_FAILED));
+        console.error(N(e, g, l.EFFECT_CLEANUP_FAILED));
       }
       this._cleanup = null;
     }
   }
-  /**
-   * 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
-   */
   _checkInfiniteLoop() {
-    if (this._lastFlushEpoch !== U && (this._lastFlushEpoch = U, this._executionsInEpoch = 0), this._executionsInEpoch++, this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), H() > A.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history) {
+    if (this._lastFlushEpoch !== v && (this._lastFlushEpoch = v, this._executionsInEpoch = 0), this._executionsInEpoch++, this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), ne() > P.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history) {
       const e = Date.now();
-      this._history.push(e), this._history.length > A.MAX_EXECUTIONS_PER_SECOND + 10 && this._history.shift(), this._checkTimestampLoop(e);
+      this._history.push(e), this._history.length > P.MAX_EXECUTIONS_PER_SECOND + 10 && this._history.shift(), this._checkTimestampLoop(e);
     }
   }
   _checkTimestampLoop(e) {
@@ -1394,80 +920,84 @@ class te {
       const r = new g(
         `Effect executed ${n} times within 1 second. Infinite loop suspected`
       );
-      if (this.dispose(), console.error(r), M)
+      if (this.dispose(), console.error(r), d)
         throw r;
     }
   }
   _throwInfiniteLoopError(e) {
     const t = new g(
-      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${w}`
+      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${k}`
     );
     throw this.dispose(), console.error(t), t;
   }
-  /**
-   * Checks for and warns about potential infinite loop patterns.
-   *
-   * @remarks
-   * When modification tracking is enabled and debug mode is active,
-   * this method checks if any dependencies were both read and modified
-   * during the effect execution. Such patterns often lead to infinite loops.
-   *
-   * Warnings are only emitted in debug mode to avoid performance overhead
-   * in production.
-   *
-   * @internal
-   */
+  _shouldExecute() {
+    if (this._dependencies === _ || this._dependencyVersions === f) return !0;
+    for (let e = 0; e < this._dependencies.length; e++) {
+      const t = this._dependencies[e];
+      if (t) {
+        if ("value" in t)
+          try {
+            ce(() => t.value);
+          } catch {
+            return !0;
+          }
+        if (t.version !== this._dependencyVersions[e])
+          return !0;
+      }
+    }
+    return !1;
+  }
   _checkLoopWarnings() {
-    if (this._trackModifications && b.enabled) {
+    if (this._trackModifications && S.enabled) {
       const e = this._dependencies;
       for (let t = 0; t < e.length; t++) {
         const s = e[t];
-        s && s._modifiedAtEpoch === this._currentEpoch && b.warn(
+        s && s._modifiedAtEpoch === this._currentEpoch && S.warn(
           !0,
-          `Effect is reading a dependency (${b.getDebugName(s) || "unknown"}) that it just modified. Infinite loop may occur`
+          `Effect is reading a dependency (${S.getDebugName(s) || "unknown"}) that it just modified. Infinite loop may occur`
         );
       }
     }
   }
 }
-function he(i, e = {}) {
+function de(i, e = {}) {
   if (typeof i != "function")
-    throw new g(a.EFFECT_MUST_BE_FUNCTION);
-  const t = new te(i, e);
+    throw new g(l.EFFECT_MUST_BE_FUNCTION);
+  const t = new oe(i, e);
   return t.execute(), t;
 }
-function se(i) {
+function he(i) {
   return i !== null && typeof i == "object" && "value" in i && "subscribe" in i && typeof i.subscribe == "function";
 }
-function oe(i) {
-  if (b.enabled) {
-    const e = b.getDebugType(i);
+function Ee(i) {
+  if (S.enabled) {
+    const e = S.getDebugType(i);
     if (e)
       return e === "computed";
   }
-  return se(i) && "invalidate" in i && typeof i.invalidate == "function";
+  return he(i) && "invalidate" in i && typeof i.invalidate == "function";
 }
-function ae(i) {
+function be(i) {
   return i !== null && typeof i == "object" && "dispose" in i && "run" in i && typeof i.dispose == "function" && typeof i.run == "function";
 }
 export {
-  T as AsyncState,
-  d as AtomError,
-  I as ComputedError,
-  k as DEBUG_CONFIG,
-  b as DEBUG_RUNTIME,
+  O as AsyncState,
+  E as AtomError,
+  C as ComputedError,
+  j as DEBUG_CONFIG,
+  S as DEBUG_RUNTIME,
   g as EffectError,
-  ie as POOL_CONFIG,
-  A 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,
-  N as scheduler,
-  re as untracked
+  le as POOL_CONFIG,
+  P as SCHEDULER_CONFIG,
+  A as SchedulerError,
+  _e as atom,
+  ae as batch,
+  fe as computed,
+  de as effect,
+  he as isAtom,
+  Ee as isComputed,
+  be as isEffect,
+  U as scheduler,
+  ce as untracked
 };
 //# sourceMappingURL=index.mjs.map