@but212/atom-effect 0.3.0 → 0.3.1

package/dist/index.mjs

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