@but212/atom-effect 0.10.1 → 0.12.0

package/dist/index.mjs

@@ -1,7 +1,7 @@
 const ee = {
   /** One second in milliseconds */
   ONE_SECOND_MS: 1e3
-}, L = {
+}, v = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
@@ -11,7 +11,7 @@ const ee = {
   // 0001 - Effect has been disposed
   EXECUTING: 2
   // 0010 - Effect is currently executing
-}, c = {
+}, h = {
   DIRTY: 1,
   // 0001 - Needs recomputation
   IDLE: 2,
@@ -29,12 +29,12 @@ const ee = {
 }, T = {
   SYNC: 1,
   NOTIFICATION_SCHEDULED: 2
-}, ge = {
+}, be = {
   /** 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
-}, D = {
+}, I = {
   /** Maximum effect executions per second to detect infinite loops (Legacy/Fallback) */
   MAX_EXECUTIONS_PER_SECOND: 1e3,
   /** Threshold for cleaning up old execution timestamps */
@@ -58,19 +58,19 @@ const ee = {
   MAX_DEPENDENCIES: 1e3,
   /** Enable infinite loop detection warnings */
   WARN_INFINITE_LOOP: !0
-}, y = 1073741823, l = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", te = Object.freeze([]);
-class b extends Error {
+}, b = 1073741823, w = 1 << 19, l = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", te = Object.freeze([]);
+class g 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 N extends b {
+class D extends g {
   /**
    * Creates a new ComputedError
    * @param message - Error message
@@ -80,7 +80,7 @@ class N extends b {
     super(e, t, !0), this.name = "ComputedError";
   }
 }
-class g extends b {
+class y extends g {
   /**
    * Creates a new EffectError
    * @param message - Error message
@@ -90,7 +90,7 @@ class g extends b {
     super(e, t, !1), this.name = "EffectError";
   }
 }
-class U extends b {
+class U extends g {
   /**
    * Creates a new SchedulerError
    * @param message - Error message
@@ -100,7 +100,7 @@ class U extends b {
     super(e, t, !1), this.name = "SchedulerError";
   }
 }
-const h = {
+const u = {
   // ─────────────────────────────────────────────────────────────────
   // Computed errors
   // ─────────────────────────────────────────────────────────────────
@@ -152,67 +152,103 @@ const h = {
    * @remarks This prevents cascading failures from masking the original error.
    */
   CALLBACK_ERROR_IN_ERROR_HANDLER: "Error occurred during onError callback execution"
-}, V = /* @__PURE__ */ Symbol("debugName"), se = /* @__PURE__ */ Symbol("id"), w = /* @__PURE__ */ Symbol("type"), q = /* @__PURE__ */ Symbol("noDefaultValue");
-function ie(i) {
-  return "dependencies" in i && Array.isArray(i.dependencies);
+}, M = /* @__PURE__ */ Symbol("debugName"), se = /* @__PURE__ */ Symbol("id"), V = /* @__PURE__ */ Symbol("type"), k = /* @__PURE__ */ Symbol("noDefaultValue");
+function ie(s) {
+  return "dependencies" in s && Array.isArray(s.dependencies);
 }
-let z = 0;
-function Y(i, e, t) {
-  if (i._visitedEpoch !== t) {
-    if (i._visitedEpoch = t, i === e)
-      throw new N("Indirect circular dependency detected");
-    if (ie(i)) {
-      const s = i.dependencies;
-      for (let r = 0; r < s.length; r++) {
-        const n = s[r];
-        n && Y(n, e, t);
+let Q = 0;
+function G(s, e, t) {
+  if (s._visitedEpoch !== t) {
+    if (s._visitedEpoch = t, s === e)
+      throw new D("Indirect circular dependency detected");
+    if (ie(s)) {
+      const i = s.dependencies;
+      for (let n = 0; n < i.length; n++) {
+        const r = i[n];
+        r && G(r, e, t);
       }
     }
   }
 }
-const E = {
+const p = {
   enabled: typeof process < "u" && process.env?.NODE_ENV === "development",
   maxDependencies: B.MAX_DEPENDENCIES,
   warnInfiniteLoop: B.WARN_INFINITE_LOOP,
-  warn(i, e) {
-    this.enabled && i && console.warn(`[Atom Effect] ${e}`);
+  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(i, e) {
-    if (i === e)
-      throw new N("Direct circular dependency detected");
-    this.enabled && (z++, Y(i, e, z));
+  checkCircular(s, e) {
+    if (s === e)
+      throw new D("Direct circular dependency detected");
+    this.enabled && (Q++, G(s, e, Q));
   },
-  attachDebugInfo(i, e, t) {
+  attachDebugInfo(s, e, t) {
     if (!this.enabled)
       return;
-    const s = i;
-    s[V] = `${e}_${t}`, s[se] = t, s[w] = e;
+    const i = s;
+    i[M] = `${e}_${t}`, i[se] = t, i[V] = e;
   },
-  getDebugName(i) {
-    if (i != null && V in i)
-      return i[V];
+  getDebugName(s) {
+    if (s != null && M in s)
+      return s[M];
   },
-  getDebugType(i) {
-    if (i != null && w in i)
-      return i[w];
+  getDebugType(s) {
+    if (s != null && V in s)
+      return s[V];
   }
 };
-let re = 1;
-const ne = () => re++;
-class H {
+let ne = 1;
+const re = () => ne++;
+class Y {
   constructor() {
-    this.id = ne() & y, this.flags = 0;
+    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this.id = re() & b;
   }
-}
-class Q extends H {
-  constructor() {
-    super(), this.version = 0, this._lastSeenEpoch = -1;
+  /**
+   * Rotates the phase by 1, automatically incrementing cycle on overflow.
+   *
+   * Performance Benefits:
+   * - Branchless: No conditional statements
+   * - O(1): Single bitwise AND operation
+   * - Smi-safe: Result always within 30-bit range (0x3fffffff)
+   *
+   * When Phase reaches 0xfffff (1,048,575), the next increment:
+   * - Overflows into Cycle bits
+   * - Phase resets to 0
+   * - Cycle increments by 1
+   *
+   * @returns The new version after phase rotation
+   */
+  rotatePhase() {
+    return this.version = this.version + 1 & b, this.version;
   }
+  /**
+   * Calculates the logical distance (shift) between current and cached version.
+   *
+   * Uses modular arithmetic to handle cycle wraparound correctly.
+   * The result represents how many phase rotations have occurred since
+   * the cached version was recorded.
+   *
+   * Performance Benefits:
+   * - Branchless: Single subtraction with mask
+   * - Handles wraparound: Works correctly even when version overflows
+   *
+   * Use Cases:
+   * - Scheduler priority: Large shifts indicate stale updates
+   * - Dependency staleness: Detect how outdated a cached value is
+   *
+   * @param cachedVersion - The previously cached version to compare against
+   * @returns Non-negative shift distance (0 to 0x3fffffff)
+   */
+  getShift(e) {
+    return this.version - e & b;
+  }
+}
+class H extends Y {
   /**
    * Subscribes a listener function or Subscriber object to value changes.
    *
@@ -222,16 +258,31 @@ class Q extends H {
    */
   subscribe(e) {
     if (typeof e == "object" && e !== null && "execute" in e)
-      return this._objectSubscribers.add(e);
+      return this._addSubscriber(this._getObjSubs(), e);
     if (typeof e != "function")
-      throw new b(h.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
-    return this._functionSubscribers.add(e);
+      throw new g(u.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
+    return this._addSubscriber(this._getFnSubs(), e);
   }
   /**
    * Gets the total number of active subscribers.
    */
   subscriberCount() {
-    return this._functionSubscribers.size + this._objectSubscribers.size;
+    return (this._fnSubs?.length ?? 0) + (this._objSubs?.length ?? 0);
+  }
+  _addSubscriber(e, t) {
+    if (e.indexOf(t) !== -1) return () => {
+    };
+    e.push(t);
+    let i = !1;
+    return () => {
+      if (i) return;
+      i = !0;
+      const n = e.indexOf(t);
+      if (n !== -1) {
+        const r = e.length - 1;
+        n !== r && (e[n] = e[r]), e.pop();
+      }
+    };
   }
   /**
    * Notifies all subscribers of a change.
@@ -240,66 +291,111 @@ class Q extends H {
    * @param oldValue - The old value
    */
   _notifySubscribers(e, t) {
-    this._functionSubscribers.forEachSafe(
-      (s) => s(e, t),
-      (s) => console.error(new b(h.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, s))
-    ), this._objectSubscribers.forEachSafe(
-      (s) => s.execute(),
-      (s) => console.error(new b(h.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, s))
-    );
+    const i = this._fnSubs;
+    if (i)
+      for (let r = i.length - 1; r >= 0; r--)
+        try {
+          const o = i[r];
+          o && o(e, t);
+        } catch (o) {
+          console.error(
+            new g(u.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, o)
+          );
+        }
+    const n = this._objSubs;
+    if (n)
+      for (let r = n.length - 1; r >= 0; r--)
+        try {
+          const o = n[r];
+          o && o.execute();
+        } catch (o) {
+          console.error(
+            new g(u.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, o)
+          );
+        }
   }
 }
 let x = 0;
 function $() {
-  return x = x + 1 & y || 1, x;
+  return x = x + 1 & b || 1, x;
 }
 function oe() {
   return x;
 }
-let F = 0, k = 0, v = !1;
-function G() {
-  return v ? (l && console.warn(
+let F = 0, z = 0, P = !1;
+function q() {
+  return P ? (l && console.warn(
     "Warning: startFlush() called during flush - ignored to prevent infinite loop detection bypass"
-  ), !1) : (v = !0, F = F + 1 & y, k = 0, !0);
+  ), !1) : (P = !0, F = F + 1 & b, z = 0, !0);
 }
 function X() {
-  v = !1;
+  P = !1;
 }
-function ce() {
-  return v ? ++k : 0;
+function he() {
+  return P ? ++z : 0;
 }
-class he {
+class ue {
   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 = D.MAX_FLUSH_ITERATIONS;
+    this.queueA = [], this.queueB = [], this.queue = this.queueA, this.queueSize = 0, this.urgentQueueA = [], this.urgentQueueB = [], this.urgentQueue = this.urgentQueueA, this.urgentQueueSize = 0, this._epoch = 0, this.isProcessing = !1, this.isBatching = !1, this.batchDepth = 0, this.batchQueue = [], this.batchQueueSize = 0, this.isFlushingSync = !1, this.maxFlushIterations = I.MAX_FLUSH_ITERATIONS;
   }
   get phase() {
     return this.isProcessing || this.isFlushingSync ? 2 : this.isBatching ? 1 : 0;
   }
   /**
-   * Schedules a task for execution.
-   * Tasks are deduplicated within the same flush cycle using epoch tracking.
-   * @param callback - The function to execute.
-   * @throws {SchedulerError} If the callback is not a function.
+   * Schedules a task for execution with optional priority based on phase shift.
+   *
+   * Priority Calculation (Branchless):
+   * - If sourceNode and cachedVersion are provided, calculates shift
+   * - Jobs with shift >= PHASE_THRESHOLD go to urgentQueue
+   * - Uses branchless bit manipulation: ((shift - THRESHOLD) >>> 31) ^ 1
+   *
+   * @param callback - The function to execute
+   * @param sourceNode - Optional reactive node for shift calculation
+   * @throws {SchedulerError} If the callback is not a function
    */
-  schedule(e) {
+  schedule(e, t) {
     if (typeof e != "function")
       throw new U("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()));
+    if (e._nextEpoch !== this._epoch)
+      if (e._nextEpoch = this._epoch, this.isBatching || this.isFlushingSync)
+        this.batchQueue[this.batchQueueSize++] = e;
+      else {
+        const i = this._calculateUrgency(e, t);
+        this.urgentQueue[this.urgentQueueSize] = e, this.queue[this.queueSize] = e, this.urgentQueueSize += i, this.queueSize += i ^ 1, this.isProcessing || this.flush();
+      }
+  }
+  /**
+   * Calculates urgency flag using branchless bit manipulation.
+   *
+   * Formula: ((shift - PHASE_THRESHOLD) >>> 31) ^ 1
+   * - If shift >= THRESHOLD: (negative >>> 31) = 0, XOR 1 = 1 (urgent)
+   * - If shift < THRESHOLD: (positive >>> 31) = 0... wait, that's wrong
+   *
+   * Correct formula: (shift >= THRESHOLD) ? 1 : 0
+   * Branchless: ((PHASE_THRESHOLD - 1 - shift) >>> 31)
+   *
+   * @returns 1 if urgent, 0 if normal
+   */
+  _calculateUrgency(e, t) {
+    if (!t || e._cachedVersion === void 0)
+      return 0;
+    const i = t.getShift(e._cachedVersion);
+    return w - 1 - i >>> 31 & 1;
   }
   flush() {
-    this.isProcessing || this.queueSize === 0 || (this.isProcessing = !0, queueMicrotask(() => {
+    this.isProcessing || this.queueSize === 0 && this.urgentQueueSize === 0 || (this.isProcessing = !0, queueMicrotask(() => {
       try {
-        if (this.queueSize === 0) return;
-        const e = G();
+        if (this.queueSize === 0 && this.urgentQueueSize === 0) return;
+        const e = q();
         this._drainQueue(), e && X();
       } finally {
-        this.isProcessing = !1, this.queueSize > 0 && !this.isBatching && this.flush();
+        this.isProcessing = !1, (this.queueSize > 0 || this.urgentQueueSize > 0) && !this.isBatching && this.flush();
       }
     }));
   }
   flushSync() {
     this.isFlushingSync = !0;
-    const e = G();
+    const e = q();
     try {
       this._mergeBatchQueue(), this._drainQueue();
     } finally {
@@ -315,16 +411,34 @@ class he {
       this.batchQueueSize = 0;
     }
   }
+  /**
+   * Drains all queues, processing urgent queue completely first.
+   *
+   * Processing Order:
+   * 1. Process all urgent jobs (high phase shift = stale updates)
+   * 2. Process normal jobs
+   * 3. Repeat until both queues are empty
+   *
+   * This ordering reduces glitches by ensuring that the most
+   * impactful state changes are propagated first.
+   */
   _drainQueue() {
     let e = 0;
-    for (; this.queueSize > 0; ) {
+    for (; this.urgentQueueSize > 0 || this.queueSize > 0; ) {
       if (++e > this.maxFlushIterations) {
         this._handleFlushOverflow();
-        break;
+        return;
       }
-      this._processCurrentQueue(), this._mergeBatchQueue();
+      this.urgentQueueSize > 0 && this._processUrgentQueue(), this.queueSize > 0 && this._processCurrentQueue(), this._mergeBatchQueue();
     }
   }
+  /**
+   * Processes the urgent queue using double-buffering.
+   */
+  _processUrgentQueue() {
+    const e = this.urgentQueue, t = this.urgentQueueSize;
+    this.urgentQueue = this.urgentQueue === this.urgentQueueA ? this.urgentQueueB : this.urgentQueueA, this.urgentQueueSize = 0, this._epoch++, this._processJobs(e, t);
+  }
   _processCurrentQueue() {
     const e = this.queue, t = this.queueSize;
     this.queue = this.queue === this.queueA ? this.queueB : this.queueA, this.queueSize = 0, this._epoch++, this._processJobs(e, t);
@@ -334,17 +448,20 @@ class he {
       new U(
         `Maximum flush iterations (${this.maxFlushIterations}) exceeded. Possible infinite loop.`
       )
-    ), this.queueSize = 0, this.queue.length = 0, this.batchQueueSize = 0;
+    ), this.queueSize = 0, this.queue.length = 0, this.urgentQueueSize = 0, this.urgentQueue.length = 0, this.batchQueueSize = 0;
   }
   _processJobs(e, t) {
-    for (let s = 0; s < t; s++)
-      try {
-        e[s]?.();
-      } catch (r) {
-        console.error(
-          new U("Error occurred during scheduler execution", r)
-        );
-      }
+    for (let i = 0; i < t; i++) {
+      const n = e[i];
+      if (n)
+        try {
+          n();
+        } catch (r) {
+          console.error(
+            new U("Error occurred during scheduler execution", r)
+          );
+        }
+    }
     e.length = 0;
   }
   /** Starts a new batch of updates. Updates will be deferred until endBatch is called. */
@@ -363,25 +480,25 @@ class he {
    * @param max - Maximum iterations count.
    */
   setMaxFlushIterations(e) {
-    if (e < D.MIN_FLUSH_ITERATIONS)
+    if (e < I.MIN_FLUSH_ITERATIONS)
       throw new U(
-        `Max flush iterations must be at least ${D.MIN_FLUSH_ITERATIONS}`
+        `Max flush iterations must be at least ${I.MIN_FLUSH_ITERATIONS}`
       );
     this.maxFlushIterations = e;
   }
 }
-const A = new he();
-function De(i) {
-  if (typeof i != "function")
-    throw new b("Batch callback must be a function");
-  A.startBatch();
+const N = new ue();
+function ye(s) {
+  if (typeof s != "function")
+    throw new g("Batch callback must be a function");
+  N.startBatch();
   try {
-    return i();
+    return s();
   } finally {
-    A.endBatch();
+    N.endBatch();
   }
 }
-class ue {
+class ce {
   constructor() {
     this.current = null;
   }
@@ -393,12 +510,12 @@ class ue {
    * @param fn - The function to execute.
    */
   run(e, t) {
-    const s = this.current;
+    const i = this.current;
     this.current = e;
     try {
       return t();
     } finally {
-      this.current = s;
+      this.current = i;
     }
   }
   /**
@@ -408,74 +525,18 @@ class ue {
     return this.current;
   }
 }
-const m = new ue();
-function ae(i) {
-  if (typeof i != "function")
-    throw new b("Untracked callback must be a function");
+const m = new ce();
+function _e(s) {
+  if (typeof s != "function")
+    throw new g("Untracked callback must be a function");
   const e = m.current;
   m.current = null;
   try {
-    return i();
+    return s();
   } finally {
     m.current = e;
   }
 }
-class P {
-  constructor() {
-    this.subscribers = null;
-  }
-  /** Adds subscriber and returns unsubscribe function (idempotent) */
-  add(e) {
-    if (this.subscribers || (this.subscribers = []), this.subscribers.indexOf(e) !== -1)
-      return () => {
-      };
-    this.subscribers.push(e);
-    let t = !1;
-    return () => {
-      t || (t = !0, this.remove(e));
-    };
-  }
-  /** 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;
-  }
-  has(e) {
-    return this.subscribers ? this.subscribers.indexOf(e) !== -1 : !1;
-  }
-  forEach(e) {
-    if (this.subscribers)
-      for (let t = 0; t < this.subscribers.length; t++)
-        e(this.subscribers[t], t);
-  }
-  /** 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++)
-        try {
-          e(this.subscribers[s], s);
-        } catch (r) {
-          t ? t(r) : console.error("[SubscriberManager] Error in subscriber callback:", r);
-        }
-  }
-  get size() {
-    return this.subscribers?.length ?? 0;
-  }
-  get hasSubscribers() {
-    return this.subscribers !== null && this.subscribers.length > 0;
-  }
-  clear() {
-    this.subscribers = null;
-  }
-  toArray() {
-    return this.subscribers ? [...this.subscribers] : [];
-  }
-}
 class j {
   constructor() {
     this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = l ? {
@@ -514,12 +575,12 @@ class j {
   /** Returns current stats for the pool (dev mode only). */
   getStats() {
     if (!l || !this.stats) return null;
-    const { acquired: e, released: t, rejected: s } = this.stats, r = s.frozen + s.tooLarge + s.poolFull;
+    const { acquired: e, released: t, rejected: i } = this.stats, n = i.frozen + i.tooLarge + i.poolFull;
     return {
       acquired: e,
       released: t,
-      rejected: s,
-      leaked: e - t - r,
+      rejected: i,
+      leaked: e - t - n,
       poolSize: this.pool.length
     };
   }
@@ -528,84 +589,85 @@ class j {
     this.pool.length = 0, l && this.stats && (this.stats.acquired = 0, this.stats.released = 0, this.stats.rejected = { frozen: 0, tooLarge: 0, poolFull: 0 });
   }
 }
-const u = Object.freeze([]), f = Object.freeze([]), a = Object.freeze([]), S = new j(), I = new j(), d = new j();
-function _e(i) {
-  return i !== null && typeof i == "object" && "value" in i && "subscribe" in i && typeof i.subscribe == "function";
+const _ = Object.freeze([]), f = Object.freeze([]), a = Object.freeze([]), S = new j(), C = new j(), d = new j();
+function ae(s) {
+  return s !== null && typeof s == "object" && "value" in s && "subscribe" in s && typeof s.subscribe == "function";
 }
-function Ie(i) {
-  if (E.enabled && (i == null || typeof i == "object")) {
-    const e = E.getDebugType(i);
+function De(s) {
+  if (p.enabled && (s == null || typeof s == "object")) {
+    const e = p.getDebugType(s);
     if (e)
       return e === "computed";
   }
-  return _e(i) && "invalidate" in i && typeof i.invalidate == "function";
+  return ae(s) && "invalidate" in s && typeof s.invalidate == "function";
 }
-function ye(i) {
-  return i !== null && typeof i == "object" && "dispose" in i && "run" in i && typeof i.dispose == "function" && typeof i.run == "function";
+function Ie(s) {
+  return s !== null && typeof s == "object" && "dispose" in s && "run" in s && typeof s.dispose == "function" && typeof s.run == "function";
 }
-function J(i) {
-  return i != null && typeof i.then == "function";
+function J(s) {
+  return s != null && typeof s.then == "function";
 }
-function le(i) {
-  return typeof i == "object" && i !== null;
+function le(s) {
+  return typeof s == "object" && s !== null;
 }
-function fe(i) {
-  return (typeof i == "object" || typeof i == "function") && i !== null && typeof i.addDependency == "function";
+function fe(s) {
+  return (typeof s == "object" || typeof s == "function") && s !== null && typeof s.addDependency == "function";
 }
-function de(i) {
-  return typeof i == "function" && typeof i.addDependency != "function";
+function de(s) {
+  return typeof s == "function" && typeof s.addDependency != "function";
 }
-function Ee(i) {
-  return le(i) && typeof i.execute == "function";
+function pe(s) {
+  return le(s) && typeof s.execute == "function";
 }
-function W(i, e, t, s) {
+function W(s, e, t, i) {
   if (e) {
     if (fe(e)) {
-      e.addDependency(i);
+      e.addDependency(s);
       return;
     }
     if (de(e)) {
-      t.add(e);
+      const n = e;
+      t.indexOf(n) === -1 && t.push(n);
       return;
     }
-    Ee(e) && s.add(e);
+    pe(e) && i.indexOf(e) === -1 && i.push(e);
   }
 }
-function pe(i, e, t, s) {
-  if (e !== u && t !== f)
-    for (let n = 0; n < e.length; n++) {
-      const o = e[n];
-      o && (o._tempUnsub = t[n]);
+function Ee(s, e, t, i) {
+  if (e !== _ && t !== f)
+    for (let r = 0; r < e.length; r++) {
+      const o = e[r];
+      o && (o._tempUnsub = t[r]);
     }
-  const r = I.acquire();
-  r.length = i.length;
-  for (let n = 0; n < i.length; n++) {
-    const o = i[n];
-    o && (o._tempUnsub ? (r[n] = o._tempUnsub, o._tempUnsub = void 0) : (E.checkCircular(o, s), r[n] = o.subscribe(s)));
-  }
-  if (e !== u)
-    for (let n = 0; n < e.length; n++) {
-      const o = e[n];
+  const n = C.acquire();
+  n.length = s.length;
+  for (let r = 0; r < s.length; r++) {
+    const o = s[r];
+    o && (o._tempUnsub ? (n[r] = o._tempUnsub, o._tempUnsub = void 0) : (p.checkCircular(o, i), n[r] = o.subscribe(i)));
+  }
+  if (e !== _)
+    for (let r = 0; r < e.length; r++) {
+      const o = e[r];
       o?._tempUnsub && (o._tempUnsub(), o._tempUnsub = void 0);
     }
-  return t !== f && I.release(t), r;
+  return t !== f && C.release(t), n;
 }
-class be extends Q {
+class ge extends H {
   constructor(e, t) {
-    super(), this._functionSubscribersStore = null, this._objectSubscribersStore = null, this._value = e, t && (this.flags |= T.SYNC), E.attachDebugInfo(this, "atom", this.id);
+    super(), this._fnSubs = null, this._objSubs = null, this._value = e, t && (this.flags |= T.SYNC), p.attachDebugInfo(this, "atom", this.id);
   }
-  get _functionSubscribers() {
-    return this._functionSubscribersStore || (this._functionSubscribersStore = new P()), this._functionSubscribersStore;
+  _getFnSubs() {
+    return this._fnSubs ??= [], this._fnSubs;
   }
-  get _objectSubscribers() {
-    return this._objectSubscribersStore || (this._objectSubscribersStore = new P()), this._objectSubscribersStore;
+  _getObjSubs() {
+    return this._objSubs ??= [], this._objSubs;
   }
   /**
    * Returns the current value and registers the atom as a dependency if in a tracking context.
    */
   get value() {
     const e = m.current;
-    return e && W(this, e, this._functionSubscribers, this._objectSubscribers), this._value;
+    return e && W(this, e, this._getFnSubs(), this._getObjSubs()), this._value;
   }
   /**
    * Sets a new value and schedules notifications if the value has changed.
@@ -613,73 +675,76 @@ class be extends Q {
   set value(e) {
     if (Object.is(this._value, e)) return;
     const t = this._value;
-    this._value = e, this.version = this.version + 1 & y;
-    const s = this._functionSubscribersStore?.hasSubscribers, r = this._objectSubscribersStore?.hasSubscribers;
-    (s || r) && this._scheduleNotification(t);
+    this._value = e, this.rotatePhase(), ((this._fnSubs?.length ?? 0) > 0 || (this._objSubs?.length ?? 0) > 0) && this._scheduleNotification(t);
   }
   /**
    * Schedules or flushes notifications based on sync mode and batching state.
    */
   _scheduleNotification(e) {
-    if (this.flags & T.NOTIFICATION_SCHEDULED || (this._pendingOldValue = e, this.flags |= T.NOTIFICATION_SCHEDULED), this.flags & T.SYNC && !A.isBatching) {
+    if (this.flags & T.NOTIFICATION_SCHEDULED || (this._pendingOldValue = e, this.flags |= T.NOTIFICATION_SCHEDULED), this.flags & T.SYNC && !N.isBatching) {
       this._flushNotifications();
       return;
     }
-    this._notifyTask || (this._notifyTask = () => this._flushNotifications()), A.schedule(this._notifyTask);
+    this._notifyTask || (this._notifyTask = () => this._flushNotifications()), N.schedule(this._notifyTask);
   }
   _flushNotifications() {
     if (!(this.flags & T.NOTIFICATION_SCHEDULED)) return;
     const e = this._pendingOldValue, t = this._value;
     this._pendingOldValue = void 0, this.flags &= -3, this._notifySubscribers(t, e);
   }
-  /**
-   * Overridden to avoid unnecessary manager creation during notification loop.
-   */
-  _notifySubscribers(e, t) {
-    this._functionSubscribersStore && this._functionSubscribersStore.forEachSafe((s) => s(e, t)), this._objectSubscribersStore && this._objectSubscribersStore.forEachSafe((s) => s.execute());
-  }
   peek() {
     return this._value;
   }
   dispose() {
-    this._functionSubscribersStore?.clear(), this._objectSubscribersStore?.clear(), this._value = void 0, this._notifyTask = void 0;
+    this._fnSubs = null, this._objSubs = null, this._value = void 0, this._notifyTask = void 0;
   }
 }
-function me(i, e = {}) {
-  return new be(i, e.sync ?? !1);
+function Ce(s, e = {}) {
+  return new ge(s, e.sync ?? !1);
 }
-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 b)
-    return i;
-  const s = i instanceof Error ? i.message : String(i), r = i instanceof Error ? i : null;
-  return new e(`Unexpected error (${t}): ${s}`, r);
+function A(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 g)
+    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);
 }
-const K = c.RESOLVED | c.PENDING | c.REJECTED, M = Array(K + 1).fill(L.IDLE);
-M[c.RESOLVED] = L.RESOLVED;
-M[c.PENDING] = L.PENDING;
-M[c.REJECTED] = L.REJECTED;
-class Z extends Q {
+const K = h.RESOLVED | h.PENDING | h.REJECTED, L = Array(K + 1).fill(v.IDLE);
+L[h.RESOLVED] = v.RESOLVED;
+L[h.PENDING] = v.PENDING;
+L[h.REJECTED] = v.REJECTED;
+class Z extends H {
   constructor(e, t = {}) {
     if (typeof e != "function")
-      throw new N(h.COMPUTED_MUST_BE_FUNCTION);
-    if (super(), this._cachedErrors = null, this._errorCacheEpoch = -1, this._value = void 0, this.flags = 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 : q, this._hasDefaultValue = this._defaultValue !== q, this._onError = t.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._functionSubscribersStore = new P(), this._objectSubscribersStore = new P(), this._dependencies = u, this._dependencyVersions = a, this._unsubscribes = f, this._notifyJob = () => {
-      this._functionSubscribersStore.forEachSafe(
-        (s) => s(),
-        (s) => console.error(s)
-      ), this._objectSubscribersStore.forEachSafe(
-        (s) => s.execute(),
-        (s) => console.error(s)
-      );
+      throw new D(u.COMPUTED_MUST_BE_FUNCTION);
+    if (super(), this._fnSubs = null, this._objSubs = null, this._cachedErrors = null, this._errorCacheEpoch = -1, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this.MAX_ASYNC_RETRIES = 3, this._value = void 0, this.flags = 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 : k, this._hasDefaultValue = this._defaultValue !== k, this._onError = t.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._dependencies = _, this._dependencyVersions = a, this._unsubscribes = f, this._notifyJob = () => {
+      const i = this._fnSubs;
+      if (i)
+        for (let r = i.length - 1; r >= 0; r--)
+          try {
+            const o = i[r];
+            o && o(void 0, void 0);
+          } catch (o) {
+            console.error(o);
+          }
+      const n = this._objSubs;
+      if (n)
+        for (let r = n.length - 1; r >= 0; r--)
+          try {
+            const o = n[r];
+            o && o.execute();
+          } catch (o) {
+            console.error(o);
+          }
     }, this._trackable = Object.assign(() => this._markDirty(), {
-      addDependency: (s) => {
+      addDependency: (i) => {
       }
-    }), E.attachDebugInfo(this, "computed", this.id), E.enabled) {
-      const s = this;
-      s.subscriberCount = () => this._functionSubscribersStore.size + this._objectSubscribersStore.size, s.isDirty = () => this._isDirty(), s.dependencies = this._dependencies, s.stateFlags = this._getFlagsAsString();
+    }), p.attachDebugInfo(this, "computed", this.id), p.enabled) {
+      const i = this;
+      i.subscriberCount = this.subscriberCount.bind(this), i.isDirty = () => this._isDirty(), i.dependencies = this._dependencies, i.stateFlags = this._getFlagsAsString();
     }
     if (t.lazy === !1)
       try {
@@ -687,11 +752,11 @@ class Z extends Q {
       } catch {
       }
   }
-  get _functionSubscribers() {
-    return this._functionSubscribersStore;
+  _getFnSubs() {
+    return this._fnSubs ??= [], this._fnSubs;
   }
-  get _objectSubscribers() {
-    return this._objectSubscribersStore;
+  _getObjSubs() {
+    return this._objSubs ??= [], this._objSubs;
   }
   get value() {
     return this._registerTracking(), this._computeValue();
@@ -723,13 +788,13 @@ class Z extends Q {
       return this._cachedErrors;
     const t = /* @__PURE__ */ new Set();
     this._error && t.add(this._error);
-    for (let s = 0; s < this._dependencies.length; s++) {
-      const r = this._dependencies[s];
-      if (r && "errors" in r) {
-        const n = r.errors;
-        for (let o = 0; o < n.length; o++) {
-          const _ = n[o];
-          _ && t.add(_);
+    for (let i = 0; i < this._dependencies.length; i++) {
+      const n = this._dependencies[i];
+      if (n && "errors" in n) {
+        const r = n.errors;
+        for (let o = 0; o < r.length; o++) {
+          const c = r[o];
+          c && t.add(c);
         }
       }
     }
@@ -753,53 +818,53 @@ class Z extends Q {
         const t = this._unsubscribes[e];
         t && t();
       }
-      I.release(this._unsubscribes), this._unsubscribes = f;
+      C.release(this._unsubscribes), this._unsubscribes = f;
     }
-    this._dependencies !== u && (S.release(this._dependencies), this._dependencies = u), this._dependencyVersions !== a && (d.release(this._dependencyVersions), this._dependencyVersions = a), this._functionSubscribersStore.clear(), this._objectSubscribersStore.clear(), this.flags = c.DIRTY | c.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID, this._cachedErrors = null, this._errorCacheEpoch = -1;
+    this._dependencies !== _ && (S.release(this._dependencies), this._dependencies = _), this._dependencyVersions !== a && (d.release(this._dependencyVersions), this._dependencyVersions = a), this._fnSubs = null, this._objSubs = null, this.flags = h.DIRTY | h.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID, this._cachedErrors = null, this._errorCacheEpoch = -1;
   }
   // State flag operations
   _isDirty() {
-    return (this.flags & c.DIRTY) !== 0;
+    return (this.flags & h.DIRTY) !== 0;
   }
   _setDirty() {
-    this.flags |= c.DIRTY;
+    this.flags |= h.DIRTY;
   }
   _clearDirty() {
     this.flags &= -2;
   }
   _isIdle() {
-    return (this.flags & c.IDLE) !== 0;
+    return (this.flags & h.IDLE) !== 0;
   }
   _setIdle() {
-    this.flags |= c.IDLE, this.flags &= -29;
+    this.flags |= h.IDLE, this.flags &= -29;
   }
   _isPending() {
-    return (this.flags & c.PENDING) !== 0;
+    return (this.flags & h.PENDING) !== 0;
   }
   _setPending() {
-    this.flags |= c.PENDING, this.flags &= -27;
+    this.flags |= h.PENDING, this.flags &= -27;
   }
   _isResolved() {
-    return (this.flags & c.RESOLVED) !== 0;
+    return (this.flags & h.RESOLVED) !== 0;
   }
   _setResolved() {
-    this.flags |= c.RESOLVED, this.flags &= -87;
+    this.flags |= h.RESOLVED, this.flags &= -87;
   }
   _isRejected() {
-    return (this.flags & c.REJECTED) !== 0;
+    return (this.flags & h.REJECTED) !== 0;
   }
   _setRejected() {
-    this.flags |= c.REJECTED | c.HAS_ERROR, this.flags &= -15;
+    this.flags |= h.REJECTED | h.HAS_ERROR, this.flags &= -15;
   }
   _isRecomputing() {
-    return (this.flags & c.RECOMPUTING) !== 0;
+    return (this.flags & h.RECOMPUTING) !== 0;
   }
   _setRecomputing(e) {
-    const t = c.RECOMPUTING;
+    const t = h.RECOMPUTING;
     this.flags = this.flags & ~t | -Number(e) & t;
   }
   _getAsyncState() {
-    return M[this.flags & K];
+    return L[this.flags & K];
   }
   _getFlagsAsString() {
     const e = [];
@@ -814,74 +879,134 @@ class Z extends Q {
     const e = this._prepareComputationContext();
     let t = !1;
     try {
-      const s = m.run(this._trackable, this._fn);
-      this._commitDependencies(e), t = !0, J(s) ? this._handleAsyncComputation(s) : this._handleSyncResult(s);
-    } catch (s) {
+      const i = m.run(this._trackable, this._fn);
+      this._commitDependencies(e), t = !0, J(i) ? this._handleAsyncComputation(i) : this._handleSyncResult(i);
+    } catch (i) {
       if (!t)
         try {
           this._commitDependencies(e), t = !0;
-        } catch (r) {
-          this._handleComputationError(r);
+        } catch (n) {
+          this._handleComputationError(n);
         }
-      this._handleComputationError(s);
+      this._handleComputationError(i);
     } finally {
       this._cleanupContext(e, t), this._setRecomputing(!1);
     }
   }
   _prepareComputationContext() {
-    const e = this._dependencies, t = this._dependencyVersions, s = S.acquire(), r = d.acquire(), n = $(), o = { depCount: 0 }, _ = (p) => {
-      p._lastSeenEpoch !== n && (p._lastSeenEpoch = n, o.depCount < s.length ? (s[o.depCount] = p, r[o.depCount] = p.version) : (s.push(p), r.push(p.version)), o.depCount++);
-    }, C = this._trackable.addDependency;
-    return this._trackable.addDependency = _, { prevDeps: e, prevVersions: t, nextDeps: s, nextVersions: r, originalAdd: C, state: o };
+    const e = this._dependencies, t = this._dependencyVersions, i = S.acquire(), n = d.acquire(), r = $(), o = { depCount: 0 }, c = (E) => {
+      E._lastSeenEpoch !== r && (E._lastSeenEpoch = r, o.depCount < i.length ? (i[o.depCount] = E, n[o.depCount] = E.version) : (i.push(E), n.push(E.version)), o.depCount++);
+    }, R = this._trackable.addDependency;
+    return this._trackable.addDependency = c, { prevDeps: e, prevVersions: t, nextDeps: i, nextVersions: n, originalAdd: R, state: o };
   }
   _commitDependencies(e) {
-    const { nextDeps: t, nextVersions: s, state: r, prevDeps: n } = e;
-    t.length = r.depCount, s.length = r.depCount, this._unsubscribes = pe(t, n, this._unsubscribes, this), this._dependencies = t, this._dependencyVersions = s;
+    const { nextDeps: t, nextVersions: i, state: n, prevDeps: r } = e;
+    t.length = n.depCount, i.length = n.depCount, this._unsubscribes = Ee(t, r, this._unsubscribes, this), this._dependencies = t, this._dependencyVersions = i;
   }
   _cleanupContext(e, t) {
-    this._trackable.addDependency = e.originalAdd, t ? (e.prevDeps !== u && S.release(e.prevDeps), e.prevVersions !== a && d.release(e.prevVersions)) : (S.release(e.nextDeps), d.release(e.nextVersions));
+    this._trackable.addDependency = e.originalAdd, t ? (e.prevDeps !== _ && S.release(e.prevDeps), e.prevVersions !== a && d.release(e.prevVersions)) : (S.release(e.nextDeps), d.release(e.nextVersions));
+  }
+  /**
+   * Calculates aggregate shift from all dependencies.
+   * Used for scheduling priority in computed chains.
+   *
+   * Performance: O(N) where N = dependency count
+   * Branchless: Each dep.getShift uses modular arithmetic
+   *
+   * @returns Sum of all dependency shifts (capped at SMI_MAX)
+   */
+  _getAggregateShift() {
+    let e = 0;
+    const t = this._dependencies, i = this._dependencyVersions;
+    for (let n = 0; n < t.length; n++) {
+      const r = t[n], o = i[n];
+      r && o !== void 0 && (e = e + r.getShift(o) & b);
+    }
+    return e;
+  }
+  /**
+   * Checks if this computed should be scheduled with urgent priority.
+   * Based on aggregate shift from all dependencies.
+   *
+   * @returns true if aggregate shift exceeds PHASE_THRESHOLD
+   */
+  isUrgent() {
+    return this._getAggregateShift() >= w;
   }
   _handleSyncResult(e) {
-    const t = !this._isResolved() || !this._equal(this._value, e);
-    this.version = this.version + Number(t) & y, this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), this._cachedErrors = null, this._errorCacheEpoch = -1;
+    this._finalizeResolution(e);
   }
   _handleAsyncComputation(e) {
-    this._setPending(), this._clearDirty(), this._notifyJob(), this._promiseId = this._promiseId >= this.MAX_PROMISE_ID ? 1 : this._promiseId + 1;
+    this._setPending(), this._clearDirty(), this._notifyJob(), this._asyncStartAggregateVersion = this._captureVersionSnapshot(), this._asyncRetryCount = 0, 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) => {
+      if (t !== this._promiseId) return;
+      const r = this._captureVersionSnapshot() - this._asyncStartAggregateVersion & b;
+      if (w - 1 - r >>> 31 & 1) {
+        if (this._asyncRetryCount < this.MAX_ASYNC_RETRIES) {
+          this._asyncRetryCount++, this._markDirty();
+          return;
+        }
+        const c = new D(
+          `Async drift exceeded threshold after ${this.MAX_ASYNC_RETRIES} retries. Dependencies changed too rapidly for stable computation.`
+        );
+        this._handleAsyncRejection(c);
+        return;
+      }
+      this._handleAsyncResolution(i);
+    }).catch((i) => {
+      t === this._promiseId && this._handleAsyncRejection(i);
     });
   }
+  /**
+   * Captures the aggregate version of all dependencies.
+   * Used for phase drift validation in async computations.
+   *
+   * @returns Sum of all dependency versions (capped at SMI_MAX)
+   */
+  _captureVersionSnapshot() {
+    let e = 0;
+    const t = this._dependencies;
+    for (let i = 0; i < t.length; i++) {
+      const n = t[i];
+      n && (e = e + n.version & b);
+    }
+    return e;
+  }
   _handleAsyncResolution(e) {
-    const t = !this._isResolved() || !this._equal(this._value, e);
-    this.version = this.version + Number(t) & y, this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), this._cachedErrors = null, this._errorCacheEpoch = -1, this._notifyJob();
+    this._finalizeResolution(e), this._notifyJob();
+  }
+  /**
+   * Unified success finalization for sync and async results.
+   * Handles phase rotation, state transition, and error cache clearing.
+   */
+  _finalizeResolution(e) {
+    (!this._isResolved() || !this._equal(this._value, e)) && this.rotatePhase(), this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), this._cachedErrors = null, this._errorCacheEpoch = -1;
   }
   _handleAsyncRejection(e) {
-    const t = R(e, N, h.COMPUTED_ASYNC_COMPUTATION_FAILED), s = !this._isRejected();
-    if (this.version = this.version + Number(s) & y, this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
+    const t = A(e, D, u.COMPUTED_ASYNC_COMPUTATION_FAILED);
+    if (!this._isRejected() && this.rotatePhase(), this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
       try {
         this._onError(t);
-      } catch (r) {
-        console.error(h.CALLBACK_ERROR_IN_ERROR_HANDLER, r);
+      } catch (n) {
+        console.error(u.CALLBACK_ERROR_IN_ERROR_HANDLER, n);
       }
     this._notifyJob();
   }
   _handleComputationError(e) {
-    const t = R(e, N, h.COMPUTED_COMPUTATION_FAILED);
+    const t = A(e, D, u.COMPUTED_COMPUTATION_FAILED);
     if (this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
       try {
         this._onError(t);
-      } catch (s) {
-        console.error(h.CALLBACK_ERROR_IN_ERROR_HANDLER, s);
+      } catch (i) {
+        console.error(u.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
       }
     throw t;
   }
   _handlePending() {
     if (this._hasDefaultValue)
       return this._defaultValue;
-    throw new N(h.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    throw new D(u.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
   }
   _handleRejected() {
     if (this._error?.recoverable && this._hasDefaultValue)
@@ -896,19 +1021,14 @@ class Z extends Q {
     this._isRecomputing() || this._isDirty() || (this._setDirty(), this._notifyJob());
   }
   _registerTracking() {
-    W(
-      this,
-      m.getCurrent(),
-      this._functionSubscribersStore,
-      this._objectSubscribersStore
-    );
+    W(this, m.getCurrent(), this._getFnSubs(), this._getObjSubs());
   }
 }
 Object.freeze(Z.prototype);
-function Ce(i, e = {}) {
-  return new Z(i, e);
+function me(s, e = {}) {
+  return new Z(s, e);
 }
-class Se extends H {
+class Se extends Y {
   /**
    * Creates a new EffectImpl instance.
    * @param fn - The effect function to run.
@@ -917,58 +1037,58 @@ class Se extends H {
   constructor(e, t = {}) {
     super(), this.run = () => {
       if (this.isDisposed)
-        throw new g(h.EFFECT_MUST_BE_FUNCTION);
+        throw new y(u.EFFECT_MUST_BE_FUNCTION);
       this._dependencyVersions !== a && (d.release(this._dependencyVersions), this._dependencyVersions = a), this.execute();
     }, this.dispose = () => {
       if (!this.isDisposed) {
         if (this._setDisposed(), this._safeCleanup(), this._unsubscribes !== f) {
-          for (let r = 0; r < this._unsubscribes.length; r++) {
-            const n = this._unsubscribes[r];
-            n && n();
+          for (let n = 0; n < this._unsubscribes.length; n++) {
+            const r = this._unsubscribes[n];
+            r && r();
           }
-          I.release(this._unsubscribes), this._unsubscribes = f;
+          C.release(this._unsubscribes), this._unsubscribes = f;
         }
-        this._dependencies !== u && (S.release(this._dependencies), this._dependencies = u), this._dependencyVersions !== a && (d.release(this._dependencyVersions), this._dependencyVersions = a);
+        this._dependencies !== _ && (S.release(this._dependencies), this._dependencies = _), this._dependencyVersions !== a && (d.release(this._dependencyVersions), this._dependencyVersions = a);
       }
-    }, this.addDependency = (r) => {
+    }, this.addDependency = (n) => {
       if (this.isExecuting && this._nextDeps && this._nextUnsubs && this._nextVersions) {
-        const n = this._currentEpoch;
-        if (r._lastSeenEpoch === n) return;
-        r._lastSeenEpoch = n, this._nextDeps.push(r), this._nextVersions.push(r.version), r._tempUnsub ? (this._nextUnsubs.push(r._tempUnsub), r._tempUnsub = void 0) : this._subscribeTo(r);
+        const r = this._currentEpoch;
+        if (n._lastSeenEpoch === r) return;
+        n._lastSeenEpoch = r, this._nextDeps.push(n), this._nextVersions.push(n.version), n._tempUnsub ? (this._nextUnsubs.push(n._tempUnsub), n._tempUnsub = void 0) : this._subscribeTo(n);
       }
     }, this.execute = () => {
       if (this.isDisposed || this.isExecuting || !this._shouldExecute()) return;
       this._checkInfiniteLoop(), this._setExecuting(!0), this._safeCleanup();
-      const r = this._prepareEffectContext();
-      let n = !1;
+      const n = this._prepareEffectExecutionContext();
+      let r = !1;
       try {
         const o = m.run(this, this._fn);
-        this._commitEffect(r), n = !0, this._checkLoopWarnings(), J(o) ? o.then((_) => {
-          !this.isDisposed && typeof _ == "function" && (this._cleanup = _);
-        }).catch((_) => {
-          this._handleExecutionError(_);
+        this._commitEffect(n), r = !0, this._checkLoopWarnings(), J(o) ? o.then((c) => {
+          !this.isDisposed && typeof c == "function" && (this._cleanup = c);
+        }).catch((c) => {
+          this._handleExecutionError(c);
         }) : this._cleanup = typeof o == "function" ? o : null;
       } catch (o) {
-        n = !0, this._handleExecutionError(o), this._cleanup = null;
+        r = !0, this._handleExecutionError(o), this._cleanup = null;
       } finally {
-        this._cleanupEffect(r, n), this._setExecuting(!1);
+        this._cleanupEffect(n, r), this._setExecuting(!1);
       }
-    }, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._fn = e, this._sync = t.sync ?? !1, this._maxExecutions = t.maxExecutionsPerSecond ?? D.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = t.maxExecutionsPerFlush ?? D.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = t.trackModifications ?? !1, this._cleanup = null, this._dependencies = u, this._dependencyVersions = a, this._unsubscribes = f, this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, this._onError = t.onError ?? null, this._historyPtr = 0;
-    const s = Number.isFinite(this._maxExecutions);
-    this._historyCapacity = s ? Math.min(this._maxExecutions + 1, D.MAX_EXECUTIONS_PER_SECOND + 1) : 0, this._history = l && s && this._historyCapacity > 0 ? new Array(this._historyCapacity).fill(0) : null, this._executionCount = 0, E.attachDebugInfo(this, "effect", this.id);
+    }, this._cleanup = null, this._dependencies = _, this._dependencyVersions = a, this._unsubscribes = f, this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, this._onError = t.onError ?? null, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._fn = e, this._sync = t.sync ?? !1, this._maxExecutions = t.maxExecutionsPerSecond ?? I.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = t.maxExecutionsPerFlush ?? I.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = t.trackModifications ?? !1, this._historyPtr = 0;
+    const i = Number.isFinite(this._maxExecutions);
+    this._historyCapacity = i ? Math.min(this._maxExecutions + 1, I.MAX_EXECUTIONS_PER_SECOND + 1) : 0, this._history = l && i && this._historyCapacity > 0 ? new Array(this._historyCapacity).fill(0) : null, this._executionCount = 0, p.attachDebugInfo(this, "effect", this.id);
   }
   /**
    * Prepares the execution context by acquiring pools and setting up epoch.
-   * @returns The prepared EffectContext.
+   * @returns The prepared EffectExecutionContext.
    */
-  _prepareEffectContext() {
-    const e = this._dependencies, t = this._dependencyVersions, s = this._unsubscribes, r = S.acquire(), n = d.acquire(), o = I.acquire(), _ = $();
-    if (e !== u && s !== f)
-      for (let C = 0; C < e.length; C++) {
-        const p = e[C];
-        p && (p._tempUnsub = s[C]);
+  _prepareEffectExecutionContext() {
+    const e = this._dependencies, t = this._dependencyVersions, i = this._unsubscribes, n = S.acquire(), r = d.acquire(), o = C.acquire(), c = $();
+    if (e !== _ && i !== f)
+      for (let R = 0; R < e.length; R++) {
+        const E = e[R];
+        E && (E._tempUnsub = i[R]);
       }
-    return this._nextDeps = r, this._nextVersions = n, this._nextUnsubs = o, this._currentEpoch = _, { prevDeps: e, prevVersions: t, prevUnsubs: s, nextDeps: r, nextVersions: n, nextUnsubs: o };
+    return this._nextDeps = n, this._nextVersions = r, this._nextUnsubs = o, this._currentEpoch = c, { prevDeps: e, prevVersions: t, prevUnsubs: i, nextDeps: n, nextVersions: r, nextUnsubs: o };
   }
   /**
    * Commits the tracked dependencies as the current active dependencies.
@@ -985,22 +1105,22 @@ class Se extends H {
    */
   _cleanupEffect(e, t) {
     if (this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, t) {
-      if (e.prevDeps !== u) {
-        for (let s = 0; s < e.prevDeps.length; s++) {
-          const r = e.prevDeps[s];
-          r?._tempUnsub && (r._tempUnsub(), r._tempUnsub = void 0);
+      if (e.prevDeps !== _) {
+        for (let i = 0; i < e.prevDeps.length; i++) {
+          const n = e.prevDeps[i];
+          n?._tempUnsub && (n._tempUnsub(), n._tempUnsub = void 0);
         }
         S.release(e.prevDeps);
       }
-      e.prevUnsubs !== f && I.release(e.prevUnsubs), e.prevVersions !== a && d.release(e.prevVersions);
+      e.prevUnsubs !== f && C.release(e.prevUnsubs), e.prevVersions !== a && d.release(e.prevVersions);
     } else {
       S.release(e.nextDeps), d.release(e.nextVersions);
-      for (let s = 0; s < e.nextUnsubs.length; s++)
-        e.nextUnsubs[s]?.();
-      if (I.release(e.nextUnsubs), e.prevDeps !== u)
-        for (let s = 0; s < e.prevDeps.length; s++) {
-          const r = e.prevDeps[s];
-          r && (r._tempUnsub = void 0);
+      for (let i = 0; i < e.nextUnsubs.length; i++)
+        e.nextUnsubs[i]?.();
+      if (C.release(e.nextUnsubs), e.prevDeps !== _)
+        for (let i = 0; i < e.prevDeps.length; i++) {
+          const n = e.prevDeps[i];
+          n && (n._tempUnsub = void 0);
         }
     }
   }
@@ -1011,11 +1131,11 @@ class Se extends H {
   _subscribeTo(e) {
     try {
       const t = e.subscribe(() => {
-        this._trackModifications && this.isExecuting && (e._modifiedAtEpoch = this._currentEpoch), this._sync ? this.execute() : A.schedule(this.execute);
+        this._trackModifications && this.isExecuting && (e._modifiedAtEpoch = this._currentEpoch), this._sync ? this.execute() : N.schedule(this.execute);
       });
       this._nextUnsubs && this._nextUnsubs.push(t);
     } catch (t) {
-      console.error(R(t, g, h.EFFECT_EXECUTION_FAILED)), this._nextUnsubs && this._nextUnsubs.push(() => {
+      console.error(A(t, y, u.EFFECT_EXECUTION_FAILED)), this._nextUnsubs && this._nextUnsubs.push(() => {
       });
     }
   }
@@ -1052,7 +1172,7 @@ class Se extends H {
       try {
         this._cleanup();
       } catch (e) {
-        console.error(R(e, g, h.EFFECT_CLEANUP_FAILED));
+        console.error(A(e, y, u.EFFECT_CLEANUP_FAILED));
       }
       this._cleanup = null;
     }
@@ -1062,13 +1182,13 @@ class Se extends H {
    * @throws {EffectError} If an infinite loop is detected.
    */
   _checkInfiniteLoop() {
-    if (this._lastFlushEpoch !== F && (this._lastFlushEpoch = F, this._executionsInEpoch = 0), this._executionsInEpoch++, this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), ce() > D.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history && this._maxExecutions > 0) {
-      const e = Date.now(), t = this._historyPtr, s = this._historyCapacity;
+    if (this._lastFlushEpoch !== F && (this._lastFlushEpoch = F, this._executionsInEpoch = 0), this._executionsInEpoch++, this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), he() > I.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history && this._maxExecutions > 0) {
+      const e = Date.now(), t = this._historyPtr, i = this._historyCapacity;
       this._history[t] = e;
-      const r = (t + 1) % s, n = this._history[r] ?? 0;
-      if (this._historyPtr = r, n > 0 && e - n < ee.ONE_SECOND_MS) {
-        const o = new g(
-          `Effect executed ${s} times within 1 second. Infinite loop suspected`
+      const n = (t + 1) % i, r = this._history[n] ?? 0;
+      if (this._historyPtr = n, r > 0 && e - r < ee.ONE_SECOND_MS) {
+        const o = new y(
+          `Effect executed ${i} times within 1 second. Infinite loop suspected`
         );
         if (this.dispose(), console.error(o), this._onError && this._onError(o), l)
           throw o;
@@ -1076,8 +1196,8 @@ class Se extends H {
     }
   }
   _throwInfiniteLoopError(e) {
-    const t = new g(
-      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${k}`
+    const t = new y(
+      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${z}`
     );
     throw this.dispose(), console.error(t), t;
   }
@@ -1086,14 +1206,14 @@ class Se extends H {
    * @returns true if any dependency has changed or if it's the first run.
    */
   _shouldExecute() {
-    if (this._dependencies === u || this._dependencyVersions === a)
+    if (this._dependencies === _ || this._dependencyVersions === a)
       return !0;
     for (let e = 0; e < this._dependencies.length; e++) {
       const t = this._dependencies[e];
       if (t) {
         if ("value" in t)
           try {
-            ae(() => t.value);
+            _e(() => t.value);
           } catch {
             return !0;
           }
@@ -1108,7 +1228,7 @@ class Se extends H {
    * Wraps the error, logs it to console, and calls onError callback if provided.
    */
   _handleExecutionError(e) {
-    const t = R(e, g, h.EFFECT_EXECUTION_FAILED);
+    const t = A(e, y, u.EFFECT_EXECUTION_FAILED);
     console.error(t), this._onError && this._onError(t);
   }
   /**
@@ -1116,42 +1236,42 @@ class Se extends H {
    * Only active if trackModifications is enabled and debug is on.
    */
   _checkLoopWarnings() {
-    if (this._trackModifications && E.enabled) {
+    if (this._trackModifications && p.enabled) {
       const e = this._dependencies;
       for (let t = 0; t < e.length; t++) {
-        const s = e[t];
-        s && s._modifiedAtEpoch === this._currentEpoch && E.warn(
+        const i = e[t];
+        i && i._modifiedAtEpoch === this._currentEpoch && p.warn(
           !0,
-          `Effect is reading a dependency (${E.getDebugName(s) || "unknown"}) that it just modified. Infinite loop may occur`
+          `Effect is reading a dependency (${p.getDebugName(i) || "unknown"}) that it just modified. Infinite loop may occur`
         );
       }
     }
   }
 }
-function Ne(i, e = {}) {
-  if (typeof i != "function")
-    throw new g(h.EFFECT_MUST_BE_FUNCTION);
-  const t = new Se(i, e);
+function Re(s, e = {}) {
+  if (typeof s != "function")
+    throw new y(u.EFFECT_MUST_BE_FUNCTION);
+  const t = new Se(s, e);
   return t.execute(), t;
 }
 export {
-  L as AsyncState,
-  b as AtomError,
-  N as ComputedError,
+  v as AsyncState,
+  g as AtomError,
+  D as ComputedError,
   B as DEBUG_CONFIG,
-  E as DEBUG_RUNTIME,
-  g as EffectError,
-  ge as POOL_CONFIG,
-  D as SCHEDULER_CONFIG,
+  p as DEBUG_RUNTIME,
+  y as EffectError,
+  be as POOL_CONFIG,
+  I as SCHEDULER_CONFIG,
   U as SchedulerError,
-  me as atom,
-  De as batch,
-  Ce as computed,
-  Ne as effect,
-  _e as isAtom,
-  Ie as isComputed,
-  ye as isEffect,
-  A as scheduler,
-  ae as untracked
+  Ce as atom,
+  ye as batch,
+  me as computed,
+  Re as effect,
+  ae as isAtom,
+  De as isComputed,
+  Ie as isEffect,
+  N as scheduler,
+  _e as untracked
 };
 //# sourceMappingURL=index.mjs.map