@but212/atom-effect 0.3.2 → 0.4.0

package/dist/index.mjs

@@ -1,14 +1,17 @@
-const T = {
+const ie = {
+  /** One second in milliseconds */
+  ONE_SECOND_MS: 1e3
+}, F = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
   REJECTED: "rejected"
-}, F = {
+}, P = {
   DISPOSED: 1,
   // 0001 - Effect has been disposed
   EXECUTING: 2
   // 0010 - Effect is currently executing
-}, h = {
+}, o = {
   DIRTY: 1,
   // 0001 - Needs recomputation
   IDLE: 2,
@@ -23,12 +26,12 @@ const T = {
   // 100000 - Currently recomputing
   HAS_ERROR: 64
   // 1000000 - Has error state
-}, ie = {
+}, Ee = {
   /** 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 = {
+}, y = {
   /** Maximum effect executions per second to detect infinite loops (Legacy/Fallback) */
   MAX_EXECUTIONS_PER_SECOND: 100,
   /** Threshold for cleaning up old execution timestamps */
@@ -42,25 +45,29 @@ const T = {
    * Maximum total executions across all effects in a single flush cycle
    * Increased from 1000 to 5000 based on evaluation report
    */
-  MAX_EXECUTIONS_PER_FLUSH: 5e3
-}, k = {
+  MAX_EXECUTIONS_PER_FLUSH: 5e3,
+  /** Maximum iterations for synchronous flush loop to prevent infinite loops */
+  MAX_FLUSH_ITERATIONS: 1e3,
+  /** Minimum allowed value for max flush iterations */
+  MIN_FLUSH_ITERATIONS: 10
+}, z = {
   /** 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 {
+}, A = 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
    * @param cause - Original error that caused this error
    * @param recoverable - Whether the operation can be retried
    */
-  constructor(e, t = null, s = !0) {
-    super(e), this.name = "AtomError", this.cause = t, this.recoverable = s, this.timestamp = /* @__PURE__ */ new Date();
+  constructor(e, t = null, i = !0) {
+    super(e), this.name = "AtomError", this.cause = t, this.recoverable = i, this.timestamp = /* @__PURE__ */ new Date();
   }
 }
-class I extends d {
+class T extends E {
   /**
    * Creates a new ComputedError
    * @param message - Error message
@@ -70,7 +77,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 +87,7 @@ class g extends d {
     super(e, t, !1), this.name = "EffectError";
   }
 }
-class C extends d {
+class x extends E {
   /**
    * Creates a new SchedulerError
    * @param message - Error message
@@ -90,20 +97,20 @@ class C extends d {
     super(e, t, !1), this.name = "SchedulerError";
   }
 }
-function R(i, e, t) {
-  if (i instanceof TypeError)
-    return new e(`Type error (${t}): ${i.message}`, i);
-  if (i instanceof ReferenceError)
-    return new e(`Reference error (${t}): ${i.message}`, i);
-  if (i instanceof d)
-    return i;
-  const s = i instanceof Error ? i.message : String(i), n = i instanceof Error ? i : null;
-  return new e(`Unexpected error (${t}): ${s}`, n);
+function C(s, e, t) {
+  if (s instanceof TypeError)
+    return new e(`Type error (${t}): ${s.message}`, s);
+  if (s instanceof ReferenceError)
+    return new e(`Reference error (${t}): ${s.message}`, s);
+  if (s instanceof E)
+    return s;
+  const i = s instanceof Error ? s.message : String(s), n = s instanceof Error ? s : null;
+  return new e(`Unexpected error (${t}): ${i}`, n);
 }
-function X(i) {
-  return i != null && typeof i.then == "function";
+function Y(s) {
+  return s != null && typeof s.then == "function";
 }
-const a = {
+const l = {
   // ─────────────────────────────────────────────────────────────────
   // Computed errors
   // ─────────────────────────────────────────────────────────────────
@@ -177,7 +184,7 @@ const a = {
    * // Output: "Large dependency graph detected: 150 dependencies"
    * ```
    */
-  LARGE_DEPENDENCY_GRAPH: (i) => `Large dependency graph detected: ${i} dependencies`,
+  LARGE_DEPENDENCY_GRAPH: (s) => `Large dependency graph detected: ${s} dependencies`,
   /**
    * Warning logged when attempting to unsubscribe a non-existent listener.
    */
@@ -187,105 +194,155 @@ const a = {
    * @remarks This prevents cascading failures from masking the original error.
    */
   CALLBACK_ERROR_IN_ERROR_HANDLER: "Error occurred during onError callback execution"
-};
-let P = 0;
-function G() {
-  return P = (P + 1 | 0) & D, P;
-}
-let U = 0, w = 0, O = !1;
-function q() {
-  return O ? (M && console.warn(
-    "Warning: startFlush() called during flush - ignored to prevent infinite loop detection bypass"
-  ), !1) : (O = !0, U = U + 1 & D, w = 0, !0);
-}
-function z() {
-  O = !1;
+}, w = /* @__PURE__ */ Symbol("debugName"), ne = /* @__PURE__ */ Symbol("id"), V = /* @__PURE__ */ Symbol("type"), X = /* @__PURE__ */ Symbol("noDefaultValue");
+function re(s) {
+  return "dependencies" in s && Array.isArray(s.dependencies);
 }
-function H() {
-  return O ? ++w : 0;
+let G = 0;
+function Q(s, e, t) {
+  if (s._visitedEpoch !== t) {
+    if (s._visitedEpoch = t, s === e)
+      throw new T("Indirect circular dependency detected");
+    if (re(s)) {
+      const i = s.dependencies;
+      for (let n = 0; n < i.length; n++) {
+        const r = i[n];
+        r && Q(r, e, t);
+      }
+    }
+  }
 }
+const S = {
+  enabled: typeof process < "u" && process.env?.NODE_ENV === "development",
+  maxDependencies: z.MAX_DEPENDENCIES,
+  warnInfiniteLoop: z.WARN_INFINITE_LOOP,
+  warn(s, e) {
+    this.enabled && s && 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(s, e) {
+    if (s === e)
+      throw new T("Direct circular dependency detected");
+    this.enabled && (G++, Q(s, e, G));
+  },
+  attachDebugInfo(s, e, t) {
+    if (!this.enabled)
+      return;
+    const i = s;
+    i[w] = `${e}_${t}`, i[ne] = t, i[V] = e;
+  },
+  getDebugName(s) {
+    if (s != null && w in s)
+      return s[w];
+  },
+  getDebugType(s) {
+    if (s != null && V in s)
+      return s[V];
+  }
+};
+let ce = 1;
+const ue = () => ce++;
 class J {
   constructor() {
-    this.queueA = [], this.queueB = [], this.queue = this.queueA, this.queueSize = 0, this._epoch = 0, this.isProcessing = !1, this.isBatching = !1, this.batchDepth = 0, this.batchQueue = [], this.batchQueueSize = 0, this.isFlushingSync = !1, this.maxFlushIterations = 1e3;
+    this.id = ue() & A, this.flags = 0;
+  }
+}
+class W extends J {
+  constructor() {
+    super(), this.version = 0, this._lastSeenEpoch = -1;
   }
   /**
-   * Gets the current phase of the scheduler.
+   * 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
    */
-  get phase() {
-    return this.isProcessing || this.isFlushingSync ? 2 : this.isBatching ? 1 : 0;
+  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);
   }
   /**
-   * 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
+   * Gets the total number of active subscribers.
+   */
+  subscriberCount() {
+    return this._functionSubscribers.size + this._objectSubscribers.size;
+  }
+  /**
+   * Notifies all subscribers of a change.
    *
-   * @example
-   * ```typescript
-   * scheduler.schedule(() => {
-   *   // This runs in the next microtask (or sync if batching)
-   *   updateUI();
-   * });
-   * ```
+   * @param newValue - The new value
+   * @param oldValue - The old value
    */
+  _notifySubscribers(e, t) {
+    this._functionSubscribers.forEachSafe(
+      (i) => i(e, t),
+      (i) => console.error(new E(l.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, i))
+    ), this._objectSubscribers.forEachSafe(
+      (i) => i.execute(),
+      (i) => console.error(new E(l.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, i))
+    );
+  }
+}
+let B = 0;
+function K() {
+  return B = (B + 1 | 0) & A, B;
+}
+let M = 0, k = 0, L = !1;
+function $() {
+  return L ? (d && console.warn(
+    "Warning: startFlush() called during flush - ignored to prevent infinite loop detection bypass"
+  ), !1) : (L = !0, M = M + 1 & A, k = 0, !0);
+}
+function H() {
+  L = !1;
+}
+function oe() {
+  return L ? ++k : 0;
+}
+class he {
+  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 = y.MAX_FLUSH_ITERATIONS;
+  }
+  get phase() {
+    return this.isProcessing || this.isFlushingSync ? 2 : this.isBatching ? 1 : 0;
+  }
   schedule(e) {
     if (typeof e != "function")
-      throw new C("Scheduler callback must be a function");
+      throw new x("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 i = $();
       for (let n = 0; n < t; n++)
         try {
           e[n]?.();
         } catch (r) {
           console.error(
-            new C("Error occurred during scheduler execution", r)
+            new x("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, i && H(), 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 = $();
     try {
       if (this._epoch++, this.batchQueueSize > 0) {
-        for (let s = 0; s < this.batchQueueSize; s++) {
-          const n = this.batchQueue[s];
+        for (let i = 0; i < this.batchQueueSize; i++) {
+          const n = this.batchQueue[i];
           n._nextEpoch !== this._epoch && (n._nextEpoch = this._epoch, this.queue[this.queueSize++] = n);
         }
         this.batchQueueSize = 0;
@@ -294,312 +351,104 @@ 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 x(
+              `Maximum flush iterations (${this.maxFlushIterations}) exceeded. Possible infinite loop.`
             )
           ), this.queueSize = 0, this.queue.length = 0, this.batchQueueSize = 0;
           break;
         }
-        const s = this.queue, n = this.queueSize;
+        const i = this.queue, n = this.queueSize;
         this.queue = this.queue === this.queueA ? this.queueB : this.queueA, this.queueSize = 0, this._epoch++;
         for (let r = 0; r < n; r++)
           try {
-            s[r]?.();
+            i[r]?.();
           } catch (c) {
             console.error(
-              new C("Error occurred during batch execution", c)
+              new x("Error occurred during batch execution", c)
             );
           }
-        if (s.length = 0, this.batchQueueSize > 0) {
+        if (i.length = 0, this.batchQueueSize > 0) {
           for (let r = 0; r < this.batchQueueSize; r++)
             this.queue[this.queueSize++] = this.batchQueue[r];
           this.batchQueueSize = 0;
         }
       }
     } finally {
-      this.isFlushingSync = !1, e && z();
+      this.isFlushingSync = !1, e && H();
     }
   }
-  /**
-   * 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");
+    if (e < y.MIN_FLUSH_ITERATIONS)
+      throw new x(
+        `Max flush iterations must be at least ${y.MIN_FLUSH_ITERATIONS}`
+      );
     this.maxFlushIterations = e;
   }
 }
-const N = new J();
-function ne(i) {
-  if (typeof i != "function")
-    throw new d("Batch callback must be a function");
-  N.startBatch();
+const U = new he();
+function be(s) {
+  if (typeof s != "function")
+    throw new E("Batch callback must be a function");
+  U.startBatch();
   try {
-    return i();
+    return s();
   } 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 */
+const N = {
   current: null,
-  /**
-   * @inheritdoc
-   * @throws Re-throws any error from the executed function after restoring context
-   */
-  run(i, e) {
+  run(s, e) {
     const t = this.current;
-    this.current = i;
+    this.current = s;
     try {
       return e();
     } finally {
       this.current = t;
     }
   },
-  /** @inheritdoc */
   getCurrent() {
     return this.current;
   }
 };
-function re(i) {
-  if (typeof i != "function")
-    throw new d("Untracked callback must be a function");
-  const e = m.current;
-  m.current = null;
+function le(s) {
+  return typeof s == "object" && s !== null;
+}
+function Z(s) {
+  return (typeof s == "object" || typeof s == "function") && s !== null && typeof s.addDependency == "function";
+}
+function ee(s) {
+  return typeof s == "function" && typeof s.addDependency != "function";
+}
+function te(s) {
+  return le(s) && typeof s.execute == "function";
+}
+function _e(s) {
+  if (typeof s != "function")
+    throw new E("Untracked callback must be a function");
+  const e = N.current;
+  N.current = null;
   try {
-    return i();
+    return s();
   } 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);
-    }
+    N.current = e;
   }
 }
-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 v {
   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,322 +459,180 @@ 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;
     const t = this.subscribers.indexOf(e);
     if (t === -1)
       return !1;
-    const s = this.subscribers.length - 1;
-    return t !== s && (this.subscribers[t] = this.subscribers[s]), this.subscribers.pop(), !0;
+    const i = this.subscribers.length - 1;
+    return t !== i && (this.subscribers[t] = this.subscribers[i]), 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++)
+      for (let i = 0; i < this.subscribers.length; i++)
         try {
-          e(this.subscribers[s], s);
+          e(this.subscribers[i], i);
         } catch (n) {
           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;
+    return this.subscribers !== null && this.subscribers.length > 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 ae 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 v(), this._objectSubscribersStore = new v(), 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;
+    const e = N.getCurrent();
+    return e && 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;
-    const s = this.version;
-    this._value = e, !(!this._functionSubscribers.hasSubscribers && !this._objectSubscribers.hasSubscribers) && this._notify(e, t, s);
+    this.version = this.version + 1 & A, this._value = e, !(!this._functionSubscribersStore.hasSubscribers && !this._objectSubscribersStore.hasSubscribers) && this._scheduleNotification(t);
   }
-  /**
-   * 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);
+    if (Z(e)) {
+      e.addDependency(this);
+      return;
+    }
+    if (ee(e)) {
+      this._functionSubscribersStore.add(e);
+      return;
     }
+    te(e) && this._objectSubscribersStore.add(e);
   }
-  /**
-   * 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);
+  _scheduleNotification(e) {
+    this._isNotificationScheduled || (this._pendingOldValue = e, 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))
-    );
+    this._pendingOldValue = void 0, this._isNotificationScheduled = !1, this._notifySubscribers(t, e);
   }
-  /**
-   * 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);
-  }
-  /**
-   * 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 pe(s, e = {}) {
+  return new ae(s, e.sync ?? !1);
 }
-const p = process.env.NODE_ENV !== "production", f = Object.freeze([]), E = Object.freeze([]);
-class $ {
+const a = Object.freeze([]), b = Object.freeze([]), f = Object.freeze([]);
+class j {
   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;
-    const { acquired: e, released: t, rejected: s } = this.stats, n = s.frozen + s.tooLarge + s.poolFull;
+    if (!d || !this.stats) return null;
+    const { acquired: e, released: t, rejected: i } = this.stats, n = i.frozen + i.tooLarge + i.poolFull;
     return {
       acquired: e,
       released: t,
-      rejected: s,
+      rejected: i,
       leaked: e - t - n,
       poolSize: this.pool.length
     };
   }
   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 I = new j(), m = new j(), p = new j();
+function q(s, e, t, i) {
+  if (e !== a && t !== b)
+    for (let r = 0; r < e.length; r++) {
+      const c = e[r];
+      c && (c._tempUnsub = t[r]);
+    }
+  const n = m.acquire();
+  n.length = s.length;
+  for (let r = 0; r < s.length; r++) {
+    const c = s[r];
+    c && (c._tempUnsub ? (n[r] = c._tempUnsub, c._tempUnsub = void 0) : (S.checkCircular(c, i), n[r] = c.subscribe(i)));
+  }
+  if (e !== a)
+    for (let r = 0; r < e.length; r++) {
+      const c = e[r];
+      c?._tempUnsub && (c._tempUnsub(), c._tempUnsub = void 0);
+    }
+  return t !== b && m.release(t), n;
+}
+class se 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(
-        (s) => s(),
-        (s) => console.error(s)
-      ), this._objectSubscribers.forEachSafe(
-        (s) => s.execute(),
-        (s) => console.error(s)
+      throw new T(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 v(), this._objectSubscribersStore = new v(), this._dependencies = a, this._dependencyVersions = f, this._unsubscribes = b, this._notifyJob = () => {
+      this._functionSubscribersStore.forEachSafe(
+        (i) => i(),
+        (i) => console.error(i)
+      ), this._objectSubscribersStore.forEachSafe(
+        (i) => i.execute(),
+        (i) => console.error(i)
       );
     }, this._trackable = Object.assign(() => this._markDirty(), {
-      addDependency: (s) => {
+      addDependency: (i) => {
       }
-    }), b.attachDebugInfo(this, "computed", this.id), b.enabled) {
-      const s = this;
-      s.subscriberCount = () => this._functionSubscribers.size + this._objectSubscribers.size, s.isDirty = () => this._isDirty(), s.dependencies = this._dependencies, s.stateFlags = this._getFlagsAsString();
+    }), S.attachDebugInfo(this, "computed", this.id), S.enabled) {
+      const i = this;
+      i.subscriberCount = () => this._functionSubscribersStore.size + this._objectSubscribersStore.size, i.isDirty = () => this._isDirty(), i.dependencies = this._dependencies, i.stateFlags = this._getFlagsAsString();
     }
     if (t.lazy === !1)
       try {
@@ -933,19 +640,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,508 +669,362 @@ 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;
+      m.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 !== a && (I.release(this._dependencies), this._dependencies = a), 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._isResolved() ? F.RESOLVED : this._isPending() ? F.PENDING : this._isRejected() ? F.REJECTED : F.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, i = I.acquire(), n = p.acquire(), r = K();
+    let c = 0;
+    const O = (h) => {
+      h._lastSeenEpoch !== r && (h._lastSeenEpoch = r, c < i.length ? (i[c] = h, n[c] = h.version) : (i.push(h), n.push(h.version)), c++);
+    }, D = this._trackable.addDependency;
+    this._trackable.addDependency = O;
+    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 = N.run(this._trackable, this._fn);
+      if (i.length = c, n.length = c, Y(h)) {
+        this._unsubscribes = q(i, e, this._unsubscribes, this), this._dependencies = i, 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(i, e, this._unsubscribes, this), this._dependencies = i, this._dependencyVersions = n, R = !0, this._handleSyncResult(h);
+    } catch (h) {
+      i.length = c, n.length = c, this._unsubscribes = q(i, e, this._unsubscribes, this), this._dependencies = i, this._dependencyVersions = n, R = !0, this._handleComputationError(h);
     } finally {
-      this._trackable.addDependency = c, o ? e !== f && S.release(e) : S.release(t);
+      this._trackable.addDependency = D, R ? (e !== a && I.release(e), t !== f && p.release(t)) : (I.release(i), p.release(n));
     }
   }
-  /**
-   * 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)));
-    }
-    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 & A), 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);
-    }).catch((s) => {
-      t === this._promiseId && this._handleAsyncRejection(s);
+    e.then((i) => {
+      t === this._promiseId && this._handleAsyncResolution(i);
+    }).catch((i) => {
+      t === this._promiseId && this._handleAsyncRejection(i);
     });
   }
   _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 & A), 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);
-    if (this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError && typeof this._onError == "function")
+    const t = C(e, T, l.COMPUTED_ASYNC_COMPUTATION_FAILED);
+    if (this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
       try {
         this._onError(t);
-      } catch (s) {
-        console.error(a.CALLBACK_ERROR_IN_ERROR_HANDLER, s);
+      } catch (i) {
+        console.error(l.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
       }
-    this._notifySubscribers();
+    this._notifySubscribers(void 0, void 0);
   }
   _handleComputationError(e) {
-    const t = R(e, I, a.COMPUTED_COMPUTATION_FAILED);
-    if (this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError && typeof this._onError == "function")
+    const t = C(e, T, l.COMPUTED_COMPUTATION_FAILED);
+    if (this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
       try {
         this._onError(t);
-      } catch (s) {
-        console.error(a.CALLBACK_ERROR_IN_ERROR_HANDLER, s);
+      } catch (i) {
+        console.error(l.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
       }
     throw t;
   }
   _handlePending() {
     if (this._hasDefaultValue)
       return this._defaultValue;
-    throw new I(a.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    throw new T(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();
-    if (e)
-      if (typeof e == "object" && e !== null && e.addDependency)
+    const e = N.getCurrent();
+    if (e) {
+      if (Z(e)) {
         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;
+      }
+      if (ee(e)) {
+        this._functionSubscribersStore.add(e);
+        return;
+      }
+      te(e) && this._objectSubscribersStore.add(e);
+    }
   }
 }
-Object.freeze(Q.prototype);
-function ue(i, e = {}) {
-  return new Q(i, e);
+Object.freeze(se.prototype);
+function Se(s, e = {}) {
+  return new se(s, e);
 }
-class te {
+class fe 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) {
-          for (let s = 0; s < this._unsubscribes.length; s++) {
-            const n = this._unsubscribes[s];
+        if (this._setDisposed(), this._safeCleanup(), this._unsubscribes !== b) {
+          for (let i = 0; i < this._unsubscribes.length; i++) {
+            const n = this._unsubscribes[i];
             n && n();
           }
-          y.release(this._unsubscribes), this._unsubscribes = E;
+          m.release(this._unsubscribes), this._unsubscribes = b;
         }
-        this._dependencies !== f && (S.release(this._dependencies), this._dependencies = f);
+        this._dependencies !== a && (I.release(this._dependencies), this._dependencies = a), this._dependencyVersions !== f && (p.release(this._dependencyVersions), this._dependencyVersions = f);
       }
-    }, this.addDependency = (s) => {
-      if (this.isExecuting && this._nextDeps && this._nextUnsubs) {
-        const n = s, r = this._currentEpoch;
-        if (n._lastSeenEpoch === r) return;
-        n._lastSeenEpoch = r, this._nextDeps.push(n), n._tempUnsub ? (this._nextUnsubs.push(n._tempUnsub), n._tempUnsub = void 0) : this._subscribeTo(n);
+    }, this.addDependency = (i) => {
+      if (this.isExecuting && this._nextDeps && this._nextUnsubs && this._nextVersions) {
+        const n = this._currentEpoch;
+        if (i._lastSeenEpoch === n) return;
+        i._lastSeenEpoch = n, this._nextDeps.push(i), this._nextVersions.push(i.version), i._tempUnsub ? (this._nextUnsubs.push(i._tempUnsub), i._tempUnsub = void 0) : this._subscribeTo(i);
       }
     }, 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)
-        for (let u = 0; u < s.length; u++) {
-          const l = s[u];
-          l && (l._tempUnsub = n[u]);
+      const i = this._dependencies, n = this._dependencyVersions, r = this._unsubscribes, c = I.acquire(), O = p.acquire(), D = m.acquire(), R = K();
+      if (i !== a && r !== b)
+        for (let u = 0; u < i.length; u++) {
+          const _ = i[u];
+          _ && (_._tempUnsub = r[u]);
         }
-      this._nextDeps = r, this._nextUnsubs = c, this._currentEpoch = o;
-      let _ = !1;
+      this._nextDeps = c, this._nextVersions = O, 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));
+        const u = N.run(this, this._fn);
+        this._dependencies = c, this._dependencyVersions = O, this._unsubscribes = D, h = !0, this._checkLoopWarnings(), Y(u) ? u.then((_) => {
+          !this.isDisposed && typeof _ == "function" && (this._cleanup = _);
+        }).catch((_) => {
+          console.error(C(_, 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(C(u, g, l.EFFECT_EXECUTION_FAILED)), this._cleanup = null;
       } finally {
-        if (this._setExecuting(!1), this._nextDeps = null, this._nextUnsubs = null, _) {
-          if (s !== f) {
-            for (let u = 0; u < s.length; u++) {
-              const l = s[u];
-              l?._tempUnsub && (l._tempUnsub(), l._tempUnsub = void 0);
+        if (this._setExecuting(!1), this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, h) {
+          if (i !== a) {
+            for (let u = 0; u < i.length; u++) {
+              const _ = i[u];
+              _?._tempUnsub && (_._tempUnsub(), _._tempUnsub = void 0);
             }
-            S.release(s);
+            I.release(i);
           }
-          n !== E && y.release(n);
+          r !== b && m.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)
-            for (let u = 0; u < s.length; u++) {
-              const l = s[u];
-              l && (l._tempUnsub = void 0);
+          I.release(c), p.release(O);
+          for (let u = 0; u < D.length; u++)
+            D[u]?.();
+          if (m.release(D), i !== a)
+            for (let u = 0; u < i.length; u++) {
+              const _ = i[u];
+              _ && (_._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 ?? y.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = t.maxExecutionsPerFlush ?? y.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = t.trackModifications ?? !1, this._cleanup = null, this._dependencies = a, 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(C(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 & P.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 & P.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 |= P.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;
+    const t = P.EXECUTING;
+    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") {
+    if (this._cleanup) {
       try {
         this._cleanup();
       } catch (e) {
-        console.error(R(e, g, a.EFFECT_CLEANUP_FAILED));
+        console.error(C(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 !== M && (this._lastFlushEpoch = M, this._executionsInEpoch = 0), this._executionsInEpoch++, this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), oe() > y.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 > y.MAX_EXECUTIONS_PER_SECOND + 10 && this._history.shift(), this._checkTimestampLoop(e);
     }
   }
   _checkTimestampLoop(e) {
     const t = this._history;
     if (!t || this._maxExecutions <= 0) return;
-    const s = e - 1e3;
+    const i = e - ie.ONE_SECOND_MS;
     let n = 0;
-    for (let r = t.length - 1; r >= 0 && !(t[r] < s); r--)
+    for (let r = t.length - 1; r >= 0 && !(t[r] < i); r--)
       n++;
     if (n > this._maxExecutions) {
       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 === a || 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 {
+            _e(() => 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(
+        const i = e[t];
+        i && i._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(i) || "unknown"}) that it just modified. Infinite loop may occur`
         );
       }
     }
   }
 }
-function he(i, e = {}) {
-  if (typeof i != "function")
-    throw new g(a.EFFECT_MUST_BE_FUNCTION);
-  const t = new te(i, e);
+function ge(s, e = {}) {
+  if (typeof s != "function")
+    throw new g(l.EFFECT_MUST_BE_FUNCTION);
+  const t = new fe(s, e);
   return t.execute(), t;
 }
-function se(i) {
-  return i !== null && typeof i == "object" && "value" in i && "subscribe" in i && typeof i.subscribe == "function";
+function de(s) {
+  return s !== null && typeof s == "object" && "value" in s && "subscribe" in s && typeof s.subscribe == "function";
 }
-function oe(i) {
-  if (b.enabled) {
-    const e = b.getDebugType(i);
+function Ie(s) {
+  if (S.enabled && (s == null || typeof s == "object")) {
+    const e = S.getDebugType(s);
     if (e)
       return e === "computed";
   }
-  return se(i) && "invalidate" in i && typeof i.invalidate == "function";
+  return de(s) && "invalidate" in s && typeof s.invalidate == "function";
 }
-function ae(i) {
-  return i !== null && typeof i == "object" && "dispose" in i && "run" in i && typeof i.dispose == "function" && typeof i.run == "function";
+function De(s) {
+  return s !== null && typeof s == "object" && "dispose" in s && "run" in s && typeof s.dispose == "function" && typeof s.run == "function";
 }
 export {
-  T as AsyncState,
-  d as AtomError,
-  I as ComputedError,
-  k as DEBUG_CONFIG,
-  b as DEBUG_RUNTIME,
+  F as AsyncState,
+  E as AtomError,
+  T as ComputedError,
+  z 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
+  Ee as POOL_CONFIG,
+  y as SCHEDULER_CONFIG,
+  x as SchedulerError,
+  pe as atom,
+  be as batch,
+  Se as computed,
+  ge as effect,
+  de as isAtom,
+  Ie as isComputed,
+  De as isEffect,
+  U as scheduler,
+  _e as untracked
 };
 //# sourceMappingURL=index.mjs.map