@but212/atom-effect 0.10.0 → 0.11.0

package/dist/index.mjs

@@ -1,17 +1,17 @@
-const Z = {
+const te = {
   /** One second in milliseconds */
   ONE_SECOND_MS: 1e3
-}, P = {
+}, M = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
   REJECTED: "rejected"
-}, A = {
+}, O = {
   DISPOSED: 1,
   // 0001 - Effect has been disposed
   EXECUTING: 2
   // 0010 - Effect is currently executing
-}, c = {
+}, u = {
   DIRTY: 1,
   // 0001 - Needs recomputation
   IDLE: 2,
@@ -26,12 +26,15 @@ const Z = {
   // 100000 - Currently recomputing
   HAS_ERROR: 64
   // 1000000 - Has error state
-}, Se = {
+}, A = {
+  SYNC: 1,
+  NOTIFICATION_SCHEDULED: 2
+}, ye = {
   /** 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 */
@@ -55,7 +58,7 @@ const Z = {
   MAX_DEPENDENCIES: 1e3,
   /** Enable infinite loop detection warnings */
   WARN_INFINITE_LOOP: !0
-}, I = 1073741823, l = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", ee = Object.freeze([]);
+}, S = 1073741823, z = 1 << 19, l = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", se = Object.freeze([]);
 class b extends Error {
   /**
    * Creates a new AtomError
@@ -67,7 +70,7 @@ class b extends Error {
     super(e), this.name = "AtomError", this.cause = t, this.recoverable = s, this.timestamp = /* @__PURE__ */ new Date();
   }
 }
-class N extends b {
+class D extends b {
   /**
    * Creates a new ComputedError
    * @param message - Error message
@@ -77,7 +80,7 @@ class N extends b {
     super(e, t, !0), this.name = "ComputedError";
   }
 }
-class g extends b {
+class y extends b {
   /**
    * Creates a new EffectError
    * @param message - Error message
@@ -87,7 +90,7 @@ class g extends b {
     super(e, t, !1), this.name = "EffectError";
   }
 }
-class O extends b {
+class U extends b {
   /**
    * Creates a new SchedulerError
    * @param message - Error message
@@ -149,20 +152,20 @@ const h = {
    * @remarks This prevents cascading failures from masking the original error.
    */
   CALLBACK_ERROR_IN_ERROR_HANDLER: "Error occurred during onError callback execution"
-}, L = /* @__PURE__ */ Symbol("debugName"), te = /* @__PURE__ */ Symbol("id"), V = /* @__PURE__ */ Symbol("type"), j = /* @__PURE__ */ Symbol("noDefaultValue");
-function se(i) {
+}, V = /* @__PURE__ */ Symbol("debugName"), ie = /* @__PURE__ */ Symbol("id"), w = /* @__PURE__ */ Symbol("type"), Q = /* @__PURE__ */ Symbol("noDefaultValue");
+function re(i) {
   return "dependencies" in i && Array.isArray(i.dependencies);
 }
 let q = 0;
-function G(i, e, t) {
+function Y(i, e, t) {
   if (i._visitedEpoch !== t) {
     if (i._visitedEpoch = t, i === e)
-      throw new N("Indirect circular dependency detected");
-    if (se(i)) {
+      throw new D("Indirect circular dependency detected");
+    if (re(i)) {
       const s = i.dependencies;
-      for (let n = 0; n < s.length; n++) {
-        const r = s[n];
-        r && G(r, e, t);
+      for (let r = 0; r < s.length; r++) {
+        const n = s[r];
+        n && Y(n, e, t);
       }
     }
   }
@@ -181,34 +184,73 @@ const E = {
    */
   checkCircular(i, e) {
     if (i === e)
-      throw new N("Direct circular dependency detected");
-    this.enabled && (q++, G(i, e, q));
+      throw new D("Direct circular dependency detected");
+    this.enabled && (q++, Y(i, e, q));
   },
   attachDebugInfo(i, e, t) {
     if (!this.enabled)
       return;
     const s = i;
-    s[L] = `${e}_${t}`, s[te] = t, s[V] = e;
+    s[V] = `${e}_${t}`, s[ie] = t, s[w] = e;
   },
   getDebugName(i) {
-    if (i != null && L in i)
-      return i[L];
-  },
-  getDebugType(i) {
     if (i != null && V in i)
       return i[V];
+  },
+  getDebugType(i) {
+    if (i != null && w in i)
+      return i[w];
   }
 };
-let ie = 1;
-const ne = () => ie++;
-class Y {
+let ne = 1;
+const oe = () => ne++;
+class H {
   constructor() {
-    this.id = ne() & I, this.flags = 0;
+    this.id = oe() & S, this.flags = 0, this.version = 0;
+  }
+  /**
+   * 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 & S, 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 & S;
   }
 }
-class Q extends Y {
+class $ extends H {
   constructor() {
-    super(), this.version = 0, this._lastSeenEpoch = -1;
+    super(), this._lastSeenEpoch = -1;
   }
   /**
    * Subscribes a listener function or Subscriber object to value changes.
@@ -247,60 +289,90 @@ class Q extends Y {
   }
 }
 let x = 0;
-function $() {
-  return x = x + 1 & I || 1, x;
+function J() {
+  return x = x + 1 & S || 1, x;
 }
-function re() {
+function ue() {
   return x;
 }
-let U = 0, w = 0, F = !1;
-function z() {
-  return F ? (l && console.warn(
+let F = 0, j = 0, P = !1;
+function X() {
+  return P ? (l && console.warn(
     "Warning: startFlush() called during flush - ignored to prevent infinite loop detection bypass"
-  ), !1) : (F = !0, U = U + 1 & I, w = 0, !0);
+  ), !1) : (P = !0, F = F + 1 & S, j = 0, !0);
 }
-function X() {
-  F = !1;
+function G() {
+  P = !1;
 }
-function oe() {
-  return F ? ++w : 0;
+function he() {
+  return P ? ++j : 0;
 }
 class ce {
   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 O("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()));
+      throw new U("Scheduler callback must be a function");
+    if (e._nextEpoch !== this._epoch)
+      if (e._nextEpoch = this._epoch, this.isBatching || this.isFlushingSync)
+        this.batchQueue[this.batchQueueSize++] = e;
+      else {
+        const s = this._calculateUrgency(e, t);
+        this.urgentQueue[this.urgentQueueSize] = e, this.queue[this.queueSize] = e, this.urgentQueueSize += s, this.queueSize += s ^ 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 s = t.getShift(e._cachedVersion);
+    return z - 1 - s >>> 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 = z();
-        this._drainQueue(), e && X();
+        if (this.queueSize === 0 && this.urgentQueueSize === 0) return;
+        const e = X();
+        this._drainQueue(), e && G();
       } 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 = z();
+    const e = X();
     try {
       this._mergeBatchQueue(), this._drainQueue();
     } finally {
-      this.isFlushingSync = !1, e && X();
+      this.isFlushingSync = !1, e && G();
     }
   }
   _mergeBatchQueue() {
@@ -312,34 +384,52 @@ class ce {
       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;
       }
-      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);
   }
   _handleFlushOverflow() {
     console.error(
-      new O(
+      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 (n) {
+      } catch (r) {
         console.error(
-          new O("Error occurred during scheduler execution", n)
+          new U("Error occurred during scheduler execution", r)
         );
       }
     e.length = 0;
@@ -360,25 +450,25 @@ class ce {
    * @param max - Maximum iterations count.
    */
   setMaxFlushIterations(e) {
-    if (e < D.MIN_FLUSH_ITERATIONS)
-      throw new O(
-        `Max flush iterations must be at least ${D.MIN_FLUSH_ITERATIONS}`
+    if (e < I.MIN_FLUSH_ITERATIONS)
+      throw new U(
+        `Max flush iterations must be at least ${I.MIN_FLUSH_ITERATIONS}`
       );
     this.maxFlushIterations = e;
   }
 }
-const T = new ce();
-function ge(i) {
+const N = new ce();
+function De(i) {
   if (typeof i != "function")
     throw new b("Batch callback must be a function");
-  T.startBatch();
+  N.startBatch();
   try {
     return i();
   } finally {
-    T.endBatch();
+    N.endBatch();
   }
 }
-class he {
+class ae {
   constructor() {
     this.current = null;
   }
@@ -405,8 +495,8 @@ class he {
     return this.current;
   }
 }
-const m = new he();
-function ue(i) {
+const m = new ae();
+function _e(i) {
   if (typeof i != "function")
     throw new b("Untracked callback must be a function");
   const e = m.current;
@@ -456,8 +546,8 @@ class v {
       for (let s = 0; s < this.subscribers.length; s++)
         try {
           e(this.subscribers[s], s);
-        } catch (n) {
-          t ? t(n) : console.error("[SubscriberManager] Error in subscriber callback:", n);
+        } catch (r) {
+          t ? t(r) : console.error("[SubscriberManager] Error in subscriber callback:", r);
         }
   }
   get size() {
@@ -511,12 +601,12 @@ class k {
   /** 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, n = s.frozen + s.tooLarge + s.poolFull;
+    const { acquired: e, released: t, rejected: s } = this.stats, r = s.frozen + s.tooLarge + s.poolFull;
     return {
       acquired: e,
       released: t,
       rejected: s,
-      leaked: e - t - n,
+      leaked: e - t - r,
       poolSize: this.pool.length
     };
   }
@@ -525,142 +615,145 @@ class k {
     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 k(), y = new k(), d = new k();
-function ae(i) {
+const a = Object.freeze([]), f = Object.freeze([]), _ = Object.freeze([]), g = new k(), C = new k(), d = new k();
+function le(i) {
   return i !== null && typeof i == "object" && "value" in i && "subscribe" in i && typeof i.subscribe == "function";
 }
-function De(i) {
+function Ie(i) {
   if (E.enabled && (i == null || typeof i == "object")) {
     const e = E.getDebugType(i);
     if (e)
       return e === "computed";
   }
-  return ae(i) && "invalidate" in i && typeof i.invalidate == "function";
+  return le(i) && "invalidate" in i && typeof i.invalidate == "function";
 }
-function ye(i) {
+function Ce(i) {
   return i !== null && typeof i == "object" && "dispose" in i && "run" in i && typeof i.dispose == "function" && typeof i.run == "function";
 }
-function H(i) {
+function W(i) {
   return i != null && typeof i.then == "function";
 }
-function _e(i) {
+function fe(i) {
   return typeof i == "object" && i !== null;
 }
-function le(i) {
+function de(i) {
   return (typeof i == "object" || typeof i == "function") && i !== null && typeof i.addDependency == "function";
 }
-function fe(i) {
+function Ee(i) {
   return typeof i == "function" && typeof i.addDependency != "function";
 }
-function de(i) {
-  return _e(i) && typeof i.execute == "function";
+function pe(i) {
+  return fe(i) && typeof i.execute == "function";
 }
-function J(i, e, t, s) {
+function K(i, e, t, s) {
   if (e) {
-    if (le(e)) {
+    if (de(e)) {
       e.addDependency(i);
       return;
     }
-    if (fe(e)) {
+    if (Ee(e)) {
       t.add(e);
       return;
     }
-    de(e) && s.add(e);
+    pe(e) && s.add(e);
   }
 }
-function Ee(i, e, t, s) {
-  if (e !== u && t !== f)
-    for (let r = 0; r < e.length; r++) {
-      const o = e[r];
-      o && (o._tempUnsub = t[r]);
+function be(i, e, t, s) {
+  if (e !== a && t !== f)
+    for (let n = 0; n < e.length; n++) {
+      const o = e[n];
+      o && (o._tempUnsub = t[n]);
     }
-  const n = y.acquire();
-  n.length = i.length;
-  for (let r = 0; r < i.length; r++) {
-    const o = i[r];
-    o && (o._tempUnsub ? (n[r] = o._tempUnsub, o._tempUnsub = void 0) : (E.checkCircular(o, s), n[r] = o.subscribe(s)));
-  }
-  if (e !== u)
-    for (let r = 0; r < e.length; r++) {
-      const o = e[r];
+  const r = C.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 !== a)
+    for (let n = 0; n < e.length; n++) {
+      const o = e[n];
       o?._tempUnsub && (o._tempUnsub(), o._tempUnsub = void 0);
     }
-  return t !== f && y.release(t), n;
+  return t !== f && C.release(t), r;
 }
-class pe extends Q {
+class ge extends $ {
   constructor(e, t) {
-    super(), this._isNotificationScheduled = !1, this._value = e, this._functionSubscribersStore = new v(), this._objectSubscribersStore = new v(), this._sync = t, this._notifyTask = this._flushNotifications.bind(this), E.attachDebugInfo(this, "atom", this.id);
+    super(), this._functionSubscribersStore = null, this._objectSubscribersStore = null, this._value = e, t && (this.flags |= A.SYNC), E.attachDebugInfo(this, "atom", this.id);
   }
-  /** Gets the manager for function-based subscribers. */
   get _functionSubscribers() {
-    return this._functionSubscribersStore;
+    return this._functionSubscribersStore || (this._functionSubscribersStore = new v()), this._functionSubscribersStore;
   }
-  /** Gets the manager for object-based subscribers. */
   get _objectSubscribers() {
-    return this._objectSubscribersStore;
+    return this._objectSubscribersStore || (this._objectSubscribersStore = new v()), this._objectSubscribersStore;
   }
   /**
-   * Returns the current value and registers the atom as a dependency in the current tracking context.
+   * Returns the current value and registers the atom as a dependency if in a tracking context.
    */
   get value() {
-    const e = m.getCurrent();
-    return e && this._track(e), this._value;
+    const e = m.current;
+    return e && K(this, e, this._functionSubscribers, this._objectSubscribers), this._value;
   }
   /**
    * Sets a new value and schedules notifications if the value has changed.
-   * Uses `Object.is` for comparison.
    */
   set value(e) {
     if (Object.is(this._value, e)) return;
     const t = this._value;
-    this.version = this.version + 1 & I, this._value = e, !(!this._functionSubscribersStore.hasSubscribers && !this._objectSubscribersStore.hasSubscribers) && this._scheduleNotification(t);
-  }
-  _track(e) {
-    J(this, e, this._functionSubscribersStore, this._objectSubscribersStore);
+    this._value = e, this.rotatePhase();
+    const s = this._functionSubscribersStore?.hasSubscribers, r = this._objectSubscribersStore?.hasSubscribers;
+    (s || r) && this._scheduleNotification(t);
   }
+  /**
+   * Schedules or flushes notifications based on sync mode and batching state.
+   */
   _scheduleNotification(e) {
-    this._isNotificationScheduled || (this._pendingOldValue = e, this._isNotificationScheduled = !0), this._sync && !T.isBatching ? this._flushNotifications() : T.schedule(this._notifyTask);
+    if (this.flags & A.NOTIFICATION_SCHEDULED || (this._pendingOldValue = e, this.flags |= A.NOTIFICATION_SCHEDULED), this.flags & A.SYNC && !N.isBatching) {
+      this._flushNotifications();
+      return;
+    }
+    this._notifyTask || (this._notifyTask = () => this._flushNotifications()), N.schedule(this._notifyTask);
   }
   _flushNotifications() {
-    if (!this._isNotificationScheduled) return;
+    if (!(this.flags & A.NOTIFICATION_SCHEDULED)) return;
     const e = this._pendingOldValue, t = this._value;
-    this._pendingOldValue = void 0, this._isNotificationScheduled = !1, this._notifySubscribers(t, e);
+    this._pendingOldValue = void 0, this.flags &= -3, this._notifySubscribers(t, e);
   }
   /**
-   * Returns the current value without registering as a dependency in the tracking context.
+   * 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;
   }
-  /**
-   * Disposes of the atom, clearing all subscribers and resetting the value.
-   */
   dispose() {
-    this._functionSubscribersStore.clear(), this._objectSubscribersStore.clear(), this._value = void 0;
+    this._functionSubscribersStore?.clear(), this._objectSubscribersStore?.clear(), this._value = void 0, this._notifyTask = void 0;
   }
 }
-function Ie(i, e = {}) {
-  return new pe(i, e.sync ?? !1);
+function me(i, e = {}) {
+  return new ge(i, e.sync ?? !1);
 }
-function R(i, e, t) {
+function T(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), n = i instanceof Error ? i : null;
-  return new e(`Unexpected error (${t}): ${s}`, n);
+  const s = i instanceof Error ? i.message : String(i), r = i instanceof Error ? i : null;
+  return new e(`Unexpected error (${t}): ${s}`, r);
 }
-const W = c.RESOLVED | c.PENDING | c.REJECTED, M = Array(W + 1).fill(P.IDLE);
-M[c.RESOLVED] = P.RESOLVED;
-M[c.PENDING] = P.PENDING;
-M[c.REJECTED] = P.REJECTED;
-class K extends Q {
+const Z = u.RESOLVED | u.PENDING | u.REJECTED, L = Array(Z + 1).fill(M.IDLE);
+L[u.RESOLVED] = M.RESOLVED;
+L[u.PENDING] = M.PENDING;
+L[u.REJECTED] = M.REJECTED;
+class ee extends $ {
   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 : j, this._hasDefaultValue = this._defaultValue !== j, this._onError = t.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._functionSubscribersStore = new v(), this._objectSubscribersStore = new v(), this._dependencies = u, this._dependencyVersions = a, this._unsubscribes = f, this._notifyJob = () => {
+      throw new D(h.COMPUTED_MUST_BE_FUNCTION);
+    if (super(), this._cachedErrors = null, this._errorCacheEpoch = -1, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this.MAX_ASYNC_RETRIES = 3, this._value = void 0, this.flags = u.DIRTY | u.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 v(), this._objectSubscribersStore = new v(), this._dependencies = a, this._dependencyVersions = _, this._unsubscribes = f, this._notifyJob = () => {
       this._functionSubscribersStore.forEachSafe(
         (s) => s(),
         (s) => console.error(s)
@@ -711,19 +804,19 @@ class K extends Q {
   }
   get errors() {
     if (this._registerTracking(), !this.hasError)
-      return ee;
-    const e = re();
+      return se;
+    const e = ue();
     if (this._errorCacheEpoch === e && this._cachedErrors !== null)
       return this._cachedErrors;
     const t = /* @__PURE__ */ new Set();
     this._error && t.add(this._error);
     for (let s = 0; s < this._dependencies.length; s++) {
-      const n = this._dependencies[s];
-      if (n && "errors" in n) {
-        const r = n.errors;
-        for (let o = 0; o < r.length; o++) {
-          const _ = r[o];
-          _ && t.add(_);
+      const r = this._dependencies[s];
+      if (r && "errors" in r) {
+        const n = r.errors;
+        for (let o = 0; o < n.length; o++) {
+          const c = n[o];
+          c && t.add(c);
         }
       }
     }
@@ -739,7 +832,7 @@ class K extends Q {
     return this._registerTracking(), this._isResolved();
   }
   invalidate() {
-    this._markDirty(), this._dependencyVersions !== a && (d.release(this._dependencyVersions), this._dependencyVersions = a), this._errorCacheEpoch = -1, this._cachedErrors = null;
+    this._markDirty(), this._dependencyVersions !== _ && (d.release(this._dependencyVersions), this._dependencyVersions = _), this._errorCacheEpoch = -1, this._cachedErrors = null;
   }
   dispose() {
     if (this._unsubscribes !== f) {
@@ -747,53 +840,53 @@ class K extends Q {
         const t = this._unsubscribes[e];
         t && t();
       }
-      y.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 !== a && (g.release(this._dependencies), this._dependencies = a), this._dependencyVersions !== _ && (d.release(this._dependencyVersions), this._dependencyVersions = _), this._functionSubscribersStore.clear(), this._objectSubscribersStore.clear(), this.flags = u.DIRTY | u.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 & u.DIRTY) !== 0;
   }
   _setDirty() {
-    this.flags |= c.DIRTY;
+    this.flags |= u.DIRTY;
   }
   _clearDirty() {
     this.flags &= -2;
   }
   _isIdle() {
-    return (this.flags & c.IDLE) !== 0;
+    return (this.flags & u.IDLE) !== 0;
   }
   _setIdle() {
-    this.flags |= c.IDLE, this.flags &= -29;
+    this.flags |= u.IDLE, this.flags &= -29;
   }
   _isPending() {
-    return (this.flags & c.PENDING) !== 0;
+    return (this.flags & u.PENDING) !== 0;
   }
   _setPending() {
-    this.flags |= c.PENDING, this.flags &= -27;
+    this.flags |= u.PENDING, this.flags &= -27;
   }
   _isResolved() {
-    return (this.flags & c.RESOLVED) !== 0;
+    return (this.flags & u.RESOLVED) !== 0;
   }
   _setResolved() {
-    this.flags |= c.RESOLVED, this.flags &= -87;
+    this.flags |= u.RESOLVED, this.flags &= -87;
   }
   _isRejected() {
-    return (this.flags & c.REJECTED) !== 0;
+    return (this.flags & u.REJECTED) !== 0;
   }
   _setRejected() {
-    this.flags |= c.REJECTED | c.HAS_ERROR, this.flags &= -15;
+    this.flags |= u.REJECTED | u.HAS_ERROR, this.flags &= -15;
   }
   _isRecomputing() {
-    return (this.flags & c.RECOMPUTING) !== 0;
+    return (this.flags & u.RECOMPUTING) !== 0;
   }
   _setRecomputing(e) {
-    const t = c.RECOMPUTING;
+    const t = u.RECOMPUTING;
     this.flags = this.flags & ~t | -Number(e) & t;
   }
   _getAsyncState() {
-    return M[this.flags & W];
+    return L[this.flags & Z];
   }
   _getFlagsAsString() {
     const e = [];
@@ -809,13 +902,13 @@ class K extends Q {
     let t = !1;
     try {
       const s = m.run(this._trackable, this._fn);
-      this._commitDependencies(e), t = !0, H(s) ? this._handleAsyncComputation(s) : this._handleSyncResult(s);
+      this._commitDependencies(e), t = !0, W(s) ? this._handleAsyncComputation(s) : this._handleSyncResult(s);
     } catch (s) {
       if (!t)
         try {
           this._commitDependencies(e), t = !0;
-        } catch (n) {
-          this._handleComputationError(n);
+        } catch (r) {
+          this._handleComputationError(r);
         }
       this._handleComputationError(s);
     } finally {
@@ -823,47 +916,100 @@ class K extends Q {
     }
   }
   _prepareComputationContext() {
-    const e = this._dependencies, t = this._dependencyVersions, s = S.acquire(), n = d.acquire(), r = $(), o = { depCount: 0 }, _ = (p) => {
-      p._lastSeenEpoch !== r && (p._lastSeenEpoch = r, o.depCount < s.length ? (s[o.depCount] = p, n[o.depCount] = p.version) : (s.push(p), n.push(p.version)), o.depCount++);
-    }, C = this._trackable.addDependency;
-    return this._trackable.addDependency = _, { prevDeps: e, prevVersions: t, nextDeps: s, nextVersions: n, originalAdd: C, state: o };
+    const e = this._dependencies, t = this._dependencyVersions, s = g.acquire(), r = d.acquire(), n = J(), o = { depCount: 0 }, c = (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++);
+    }, R = this._trackable.addDependency;
+    return this._trackable.addDependency = c, { prevDeps: e, prevVersions: t, nextDeps: s, nextVersions: r, originalAdd: R, state: o };
   }
   _commitDependencies(e) {
-    const { nextDeps: t, nextVersions: s, state: n, prevDeps: r } = e;
-    t.length = n.depCount, s.length = n.depCount, this._unsubscribes = Ee(t, r, this._unsubscribes, this), this._dependencies = t, this._dependencyVersions = s;
+    const { nextDeps: t, nextVersions: s, state: r, prevDeps: n } = e;
+    t.length = r.depCount, s.length = r.depCount, this._unsubscribes = be(t, n, this._unsubscribes, this), this._dependencies = t, this._dependencyVersions = s;
   }
   _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 !== a && g.release(e.prevDeps), e.prevVersions !== _ && d.release(e.prevVersions)) : (g.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, s = this._dependencyVersions;
+    for (let r = 0; r < t.length; r++) {
+      const n = t[r], o = s[r];
+      n && o !== void 0 && (e = e + n.getShift(o) & S);
+    }
+    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() >= z;
   }
   _handleSyncResult(e) {
-    const t = !this._isResolved() || !this._equal(this._value, e);
-    this.version = this.version + Number(t) & I, this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), this._cachedErrors = null, this._errorCacheEpoch = -1;
+    (!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;
   }
   _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);
+      if (t !== this._promiseId) return;
+      const n = this._captureVersionSnapshot() - this._asyncStartAggregateVersion & S;
+      if (z - 1 - n >>> 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(s);
     }).catch((s) => {
       t === this._promiseId && this._handleAsyncRejection(s);
     });
   }
+  /**
+   * 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 s = 0; s < t.length; s++) {
+      const r = t[s];
+      r && (e = e + r.version & S);
+    }
+    return e;
+  }
   _handleAsyncResolution(e) {
-    const t = !this._isResolved() || !this._equal(this._value, e);
-    this.version = this.version + Number(t) & I, this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), this._cachedErrors = null, this._errorCacheEpoch = -1, this._notifyJob();
+    (!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, this._notifyJob();
   }
   _handleAsyncRejection(e) {
-    const t = R(e, N, h.COMPUTED_ASYNC_COMPUTATION_FAILED), s = !this._isRejected();
-    if (this.version = this.version + Number(s) & I, this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
+    const t = T(e, D, h.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 (n) {
-        console.error(h.CALLBACK_ERROR_IN_ERROR_HANDLER, n);
+      } catch (r) {
+        console.error(h.CALLBACK_ERROR_IN_ERROR_HANDLER, r);
       }
     this._notifyJob();
   }
   _handleComputationError(e) {
-    const t = R(e, N, h.COMPUTED_COMPUTATION_FAILED);
+    const t = T(e, D, h.COMPUTED_COMPUTATION_FAILED);
     if (this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
       try {
         this._onError(t);
@@ -875,7 +1021,7 @@ class K extends Q {
   _handlePending() {
     if (this._hasDefaultValue)
       return this._defaultValue;
-    throw new N(h.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    throw new D(h.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
   }
   _handleRejected() {
     if (this._error?.recoverable && this._hasDefaultValue)
@@ -890,7 +1036,7 @@ class K extends Q {
     this._isRecomputing() || this._isDirty() || (this._setDirty(), this._notifyJob());
   }
   _registerTracking() {
-    J(
+    K(
       this,
       m.getCurrent(),
       this._functionSubscribersStore,
@@ -898,11 +1044,11 @@ class K extends Q {
     );
   }
 }
-Object.freeze(K.prototype);
-function me(i, e = {}) {
-  return new K(i, e);
+Object.freeze(ee.prototype);
+function Re(i, e = {}) {
+  return new ee(i, e);
 }
-class be extends Y {
+class Se extends H {
   /**
    * Creates a new EffectImpl instance.
    * @param fn - The effect function to run.
@@ -911,58 +1057,58 @@ class be extends Y {
   constructor(e, t = {}) {
     super(), this.run = () => {
       if (this.isDisposed)
-        throw new g(h.EFFECT_MUST_BE_FUNCTION);
-      this._dependencyVersions !== a && (d.release(this._dependencyVersions), this._dependencyVersions = a), this.execute();
+        throw new y(h.EFFECT_MUST_BE_FUNCTION);
+      this._dependencyVersions !== _ && (d.release(this._dependencyVersions), this._dependencyVersions = _), this.execute();
     }, this.dispose = () => {
       if (!this.isDisposed) {
         if (this._setDisposed(), this._safeCleanup(), this._unsubscribes !== f) {
-          for (let n = 0; n < this._unsubscribes.length; n++) {
-            const r = this._unsubscribes[n];
-            r && r();
+          for (let r = 0; r < this._unsubscribes.length; r++) {
+            const n = this._unsubscribes[r];
+            n && n();
           }
-          y.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 !== a && (g.release(this._dependencies), this._dependencies = a), this._dependencyVersions !== _ && (d.release(this._dependencyVersions), this._dependencyVersions = _);
       }
-    }, this.addDependency = (n) => {
+    }, this.addDependency = (r) => {
       if (this.isExecuting && this._nextDeps && this._nextUnsubs && this._nextVersions) {
-        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);
+        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);
       }
     }, this.execute = () => {
       if (this.isDisposed || this.isExecuting || !this._shouldExecute()) return;
       this._checkInfiniteLoop(), this._setExecuting(!0), this._safeCleanup();
-      const n = this._prepareEffectContext();
-      let r = !1;
+      const r = this._prepareEffectContext();
+      let n = !1;
       try {
         const o = m.run(this, this._fn);
-        this._commitEffect(n), r = !0, this._checkLoopWarnings(), H(o) ? o.then((_) => {
-          !this.isDisposed && typeof _ == "function" && (this._cleanup = _);
-        }).catch((_) => {
-          this._handleExecutionError(_);
+        this._commitEffect(r), n = !0, this._checkLoopWarnings(), W(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) {
-        r = !0, this._handleExecutionError(o), this._cleanup = null;
+        n = !0, this._handleExecutionError(o), this._cleanup = null;
       } finally {
-        this._cleanupEffect(n, r), this._setExecuting(!1);
+        this._cleanupEffect(r, n), 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;
+    }, 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._cleanup = null, this._dependencies = a, this._dependencyVersions = _, 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._historyCapacity = s ? Math.min(this._maxExecutions + 1, I.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);
   }
   /**
    * Prepares the execution context by acquiring pools and setting up epoch.
    * @returns The prepared EffectContext.
    */
   _prepareEffectContext() {
-    const e = this._dependencies, t = this._dependencyVersions, s = this._unsubscribes, n = S.acquire(), r = d.acquire(), o = y.acquire(), _ = $();
-    if (e !== u && s !== f)
-      for (let C = 0; C < e.length; C++) {
-        const p = e[C];
-        p && (p._tempUnsub = s[C]);
+    const e = this._dependencies, t = this._dependencyVersions, s = this._unsubscribes, r = g.acquire(), n = d.acquire(), o = C.acquire(), c = J();
+    if (e !== a && s !== f)
+      for (let R = 0; R < e.length; R++) {
+        const p = e[R];
+        p && (p._tempUnsub = s[R]);
       }
-    return this._nextDeps = n, this._nextVersions = r, this._nextUnsubs = o, this._currentEpoch = _, { prevDeps: e, prevVersions: t, prevUnsubs: s, nextDeps: n, nextVersions: r, nextUnsubs: o };
+    return this._nextDeps = r, this._nextVersions = n, this._nextUnsubs = o, this._currentEpoch = c, { prevDeps: e, prevVersions: t, prevUnsubs: s, nextDeps: r, nextVersions: n, nextUnsubs: o };
   }
   /**
    * Commits the tracked dependencies as the current active dependencies.
@@ -979,22 +1125,22 @@ class be extends Y {
    */
   _cleanupEffect(e, t) {
     if (this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, t) {
-      if (e.prevDeps !== u) {
+      if (e.prevDeps !== a) {
         for (let s = 0; s < e.prevDeps.length; s++) {
-          const n = e.prevDeps[s];
-          n?._tempUnsub && (n._tempUnsub(), n._tempUnsub = void 0);
+          const r = e.prevDeps[s];
+          r?._tempUnsub && (r._tempUnsub(), r._tempUnsub = void 0);
         }
-        S.release(e.prevDeps);
+        g.release(e.prevDeps);
       }
-      e.prevUnsubs !== f && y.release(e.prevUnsubs), e.prevVersions !== a && d.release(e.prevVersions);
+      e.prevUnsubs !== f && C.release(e.prevUnsubs), e.prevVersions !== _ && d.release(e.prevVersions);
     } else {
-      S.release(e.nextDeps), d.release(e.nextVersions);
+      g.release(e.nextDeps), d.release(e.nextVersions);
       for (let s = 0; s < e.nextUnsubs.length; s++)
         e.nextUnsubs[s]?.();
-      if (y.release(e.nextUnsubs), e.prevDeps !== u)
+      if (C.release(e.nextUnsubs), e.prevDeps !== a)
         for (let s = 0; s < e.prevDeps.length; s++) {
-          const n = e.prevDeps[s];
-          n && (n._tempUnsub = void 0);
+          const r = e.prevDeps[s];
+          r && (r._tempUnsub = void 0);
         }
     }
   }
@@ -1005,11 +1151,11 @@ class be extends Y {
   _subscribeTo(e) {
     try {
       const t = e.subscribe(() => {
-        this._trackModifications && this.isExecuting && (e._modifiedAtEpoch = this._currentEpoch), this._sync ? this.execute() : T.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(T(t, y, h.EFFECT_EXECUTION_FAILED)), this._nextUnsubs && this._nextUnsubs.push(() => {
       });
     }
   }
@@ -1017,7 +1163,7 @@ class be extends Y {
    * Whether the effect has been disposed.
    */
   get isDisposed() {
-    return (this.flags & A.DISPOSED) !== 0;
+    return (this.flags & O.DISPOSED) !== 0;
   }
   /**
    * Total number of times this effect has executed.
@@ -1029,13 +1175,13 @@ class be extends Y {
    * Whether the effect is currently executing.
    */
   get isExecuting() {
-    return (this.flags & A.EXECUTING) !== 0;
+    return (this.flags & O.EXECUTING) !== 0;
   }
   _setDisposed() {
-    this.flags |= A.DISPOSED;
+    this.flags |= O.DISPOSED;
   }
   _setExecuting(e) {
-    const t = A.EXECUTING;
+    const t = O.EXECUTING;
     this.flags = this.flags & ~t | -Number(e) & t;
   }
   /**
@@ -1046,7 +1192,7 @@ class be extends Y {
       try {
         this._cleanup();
       } catch (e) {
-        console.error(R(e, g, h.EFFECT_CLEANUP_FAILED));
+        console.error(T(e, y, h.EFFECT_CLEANUP_FAILED));
       }
       this._cleanup = null;
     }
@@ -1056,12 +1202,12 @@ class be extends Y {
    * @throws {EffectError} If an infinite loop is detected.
    */
   _checkInfiniteLoop() {
-    if (this._lastFlushEpoch !== U && (this._lastFlushEpoch = U, this._executionsInEpoch = 0), this._executionsInEpoch++, this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), oe() > D.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history && this._maxExecutions > 0) {
+    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, s = this._historyCapacity;
       this._history[t] = e;
-      const n = (t + 1) % s, r = this._history[n] ?? 0;
-      if (this._historyPtr = n, r > 0 && e - r < Z.ONE_SECOND_MS) {
-        const o = new g(
+      const r = (t + 1) % s, n = this._history[r] ?? 0;
+      if (this._historyPtr = r, n > 0 && e - n < te.ONE_SECOND_MS) {
+        const o = new y(
           `Effect executed ${s} times within 1 second. Infinite loop suspected`
         );
         if (this.dispose(), console.error(o), this._onError && this._onError(o), l)
@@ -1070,8 +1216,8 @@ class be extends Y {
     }
   }
   _throwInfiniteLoopError(e) {
-    const t = new g(
-      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${w}`
+    const t = new y(
+      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${j}`
     );
     throw this.dispose(), console.error(t), t;
   }
@@ -1080,14 +1226,14 @@ class be extends Y {
    * @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 === a || this._dependencyVersions === _)
       return !0;
     for (let e = 0; e < this._dependencies.length; e++) {
       const t = this._dependencies[e];
       if (t) {
         if ("value" in t)
           try {
-            ue(() => t.value);
+            _e(() => t.value);
           } catch {
             return !0;
           }
@@ -1102,7 +1248,7 @@ class be extends Y {
    * 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 = T(e, y, h.EFFECT_EXECUTION_FAILED);
     console.error(t), this._onError && this._onError(t);
   }
   /**
@@ -1122,30 +1268,30 @@ class be extends Y {
     }
   }
 }
-function Ce(i, e = {}) {
+function Ae(i, e = {}) {
   if (typeof i != "function")
-    throw new g(h.EFFECT_MUST_BE_FUNCTION);
-  const t = new be(i, e);
+    throw new y(h.EFFECT_MUST_BE_FUNCTION);
+  const t = new Se(i, e);
   return t.execute(), t;
 }
 export {
-  P as AsyncState,
+  M as AsyncState,
   b as AtomError,
-  N as ComputedError,
+  D as ComputedError,
   B as DEBUG_CONFIG,
   E as DEBUG_RUNTIME,
-  g as EffectError,
-  Se as POOL_CONFIG,
-  D as SCHEDULER_CONFIG,
-  O as SchedulerError,
-  Ie as atom,
-  ge as batch,
-  me as computed,
-  Ce as effect,
-  ae as isAtom,
-  De as isComputed,
-  ye as isEffect,
-  T as scheduler,
-  ue as untracked
+  y as EffectError,
+  ye as POOL_CONFIG,
+  I as SCHEDULER_CONFIG,
+  U as SchedulerError,
+  me as atom,
+  De as batch,
+  Re as computed,
+  Ae as effect,
+  le as isAtom,
+  Ie as isComputed,
+  Ce as isEffect,
+  N as scheduler,
+  _e as untracked
 };
 //# sourceMappingURL=index.mjs.map