@but212/atom-effect 0.23.0 → 0.24.1

package/dist/index.mjs

@@ -1,14 +1,13 @@
-const N = {
+var b = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
   REJECTED: "rejected"
-}, _ = {
+}, f = {
   DISPOSED: 1,
   EXECUTING: 8
-}, W = {
+}, x = {
   DISPOSED: 1,
-  /** Marker bit: identifies this node as a computed. */
   IS_COMPUTED: 2,
   DIRTY: 8,
   IDLE: 16,
@@ -16,233 +15,362 @@ const N = {
   RESOLVED: 64,
   REJECTED: 128,
   RECOMPUTING: 256,
-  HAS_ERROR: 512
-}, a = {
+  HAS_ERROR: 512,
+  FORCE_COMPUTE: 1024
+}, d = {
   DISPOSED: 1,
   SYNC: 8,
   NOTIFICATION_SCHEDULED: 16
-}, d = {
-  // Infinite loop protection
+}, m = {
   MAX_EXECUTIONS_PER_SECOND: 1e3,
   MAX_EXECUTIONS_PER_EFFECT: 100,
-  // Batch processing limits to prevent blocking the main thread for too long
   MAX_EXECUTIONS_PER_FLUSH: 1e4,
   MAX_FLUSH_ITERATIONS: 1e3,
   MIN_FLUSH_ITERATIONS: 10,
-  // Memory management
   BATCH_QUEUE_SHRINK_THRESHOLD: 1e3
-}, ht = {
+}, st = {
   WARN_INFINITE_LOOP: !0,
   EFFECT_FREQUENCY_WINDOW: 1e3
-}, V = {
+}, j = {
   MAX_ASYNC_RETRIES: 3,
   MAX_PROMISE_ID: Number.MAX_SAFE_INTEGER - 1
-}, g = {
-  /** Uninitialized epoch marker. Used as initial value before any flush has occurred. */
-  UNINITIALIZED: -1
-}, F = 1073741823, Z = typeof process < "u" && process.env && !1 || !1, ot = Object.freeze([]);
-function X(n, t, s) {
-  const e = /* @__PURE__ */ new Map();
-  for (let i = 0; i < t.length; i++) {
-    const r = t[i];
-    r?.unsub && e.set(r.node, r.unsub);
-  }
-  for (let i = 0; i < n.length; i++) {
-    const r = n[i];
-    if (!r) continue;
-    const h = r.node, o = e.get(h);
-    o !== void 0 ? (r.unsub = o, e.delete(h)) : r.unsub || (r.unsub = h.subscribe(s));
-  }
-  for (const i of e.values())
-    i();
-}
-class y {
+}, I = {
+  UNINITIALIZED: -1,
+  MIN: 1
+}, G = 1073741823, q = { VERSION_BITS: 16 }, Ct = (typeof process < "u" && process.env, !1), W = Object.freeze([]), H = class {
   constructor(t, s, e = void 0) {
     this.node = t, this.version = s, this.unsub = e;
   }
-}
-class ct {
+}, ut = class {
   constructor(t, s) {
     this.fn = t, this.sub = s;
   }
   notify(t, s) {
     this.fn ? this.fn(t, s) : this.sub && this.sub.execute();
   }
-}
-class k extends Error {
+}, N = class extends Error {
   constructor(t, s = null, e = !0) {
     super(t), this.cause = s, this.recoverable = e, this.name = "AtomError";
   }
-}
-class I extends k {
+}, S = class extends N {
   constructor(t, s = null) {
     super(t, s, !0), this.name = "ComputedError";
   }
-}
-class C extends k {
+}, D = class extends N {
   constructor(t, s = null) {
     super(t, s, !1), this.name = "EffectError";
   }
-}
-class m extends k {
+}, R = class extends N {
   constructor(t, s = null) {
     super(t, s, !1), this.name = "SchedulerError";
   }
-}
-const c = {
-  // Computed Errors
+}, l = {
   COMPUTED_MUST_BE_FUNCTION: "Computed target must be a function",
   COMPUTED_ASYNC_PENDING_NO_DEFAULT: "Async computation pending with no default value",
   COMPUTED_COMPUTATION_FAILED: "Computation execution failed",
   COMPUTED_ASYNC_COMPUTATION_FAILED: "Async computation execution failed",
   COMPUTED_CIRCULAR_DEPENDENCY: "Circular dependency detected",
   COMPUTED_DISPOSED: "Attempted to access disposed computed",
-  // Atom Errors
   ATOM_SUBSCRIBER_MUST_BE_FUNCTION: "Subscriber must be a function or Subscriber object",
   ATOM_INDIVIDUAL_SUBSCRIBER_FAILED: "Subscriber execution failed",
-  // Effect Errors
   EFFECT_MUST_BE_FUNCTION: "Effect target must be a function",
   EFFECT_EXECUTION_FAILED: "Effect execution failed",
   EFFECT_CLEANUP_FAILED: "Effect cleanup failed",
   EFFECT_DISPOSED: "Attempted to run disposed effect",
-  // Scheduler Errors
-  SCHEDULER_FLUSH_OVERFLOW: (n, t) => `Maximum flush iterations (${n}) exceeded. ${t} jobs dropped. Possible infinite loop.`,
-  // System / Debug
+  SCHEDULER_FLUSH_OVERFLOW: (t, s) => `Maximum flush iterations (${t}) exceeded. ${s} jobs dropped. Possible infinite loop.`,
   CALLBACK_ERROR_IN_ERROR_HANDLER: "Exception encountered in onError handler",
-  // Effect frequency
   EFFECT_FREQUENCY_LIMIT_EXCEEDED: "Effect executed too frequently within 1 second. Suspected infinite loop.",
   SCHEDULER_CALLBACK_MUST_BE_FUNCTION: "Scheduler callback must be a function",
   SCHEDULER_END_BATCH_WITHOUT_START: "endBatch() called without matching startBatch(). Ignoring.",
   BATCH_CALLBACK_MUST_BE_FUNCTION: "Batch callback must be a function"
-}, ut = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), _t = /* @__PURE__ */ Symbol("AtomEffect.Type"), x = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), B = {
-  // Dev mode flag
-  enabled: Z,
-  warnInfiniteLoop: ht.WARN_INFINITE_LOOP,
-  warn(n, t) {
-  },
-  attachDebugInfo(n, t, s) {
-  },
-  getDebugName: (n) => n?.[ut],
-  getDebugType: (n) => n?.[_t]
-};
-let lt = 1;
-const at = () => lt++;
-function S(n, t, s) {
-  if (n instanceof k)
-    return n;
-  const e = n instanceof Error, i = e ? n.message : String(n), r = e ? n : void 0, o = `${e ? n.constructor.name : "Unexpected error"} (${s}): ${i}`;
-  return new t(o, r);
-}
-class J {
+}, et = class {
   constructor() {
-    this.flags = 0, this.version = 0, this._lastSeenEpoch = g.UNINITIALIZED, this.id = at() & F;
+    this._s0 = null, this._s1 = null, this._s2 = null, this._s3 = null, this._count = 0, this._epoch = I.UNINITIALIZED, this._overflow = null;
+  }
+  get size() {
+    return this._count;
+  }
+  getAt(t) {
+    switch (t) {
+      case 0:
+        return this._s0;
+      case 1:
+        return this._s1;
+      case 2:
+        return this._s2;
+      case 3:
+        return this._s3;
+      default: {
+        const s = this._overflow;
+        if (s !== null && t >= 4) {
+          const e = t - 4;
+          if (e < s.length) return s[e] ?? null;
+        }
+        return null;
+      }
+    }
+  }
+  setAt(t, s) {
+    switch (t) {
+      case 0:
+        this._s0 = s;
+        break;
+      case 1:
+        this._s1 = s;
+        break;
+      case 2:
+        this._s2 = s;
+        break;
+      case 3:
+        this._s3 = s;
+        break;
+      default: {
+        this._overflow ??= [];
+        const e = this._overflow;
+        e[t - 4] = s;
+      }
+    }
+    t >= this._count && (this._count = t + 1);
+  }
+  truncateFrom(t) {
+    const s = this._count;
+    if (t >= s) return;
+    if (t <= 3) switch (t) {
+      case 0: {
+        const i = this._s0;
+        i != null && (this._onItemRemoved(i), this._s0 = null);
+      }
+      case 1: {
+        const i = this._s1;
+        i != null && (this._onItemRemoved(i), this._s1 = null);
+      }
+      case 2: {
+        const i = this._s2;
+        i != null && (this._onItemRemoved(i), this._s2 = null);
+      }
+      case 3: {
+        const i = this._s3;
+        i != null && (this._onItemRemoved(i), this._s3 = null);
+      }
+    }
+    const e = this._overflow;
+    if (e !== null && s > 4) {
+      const i = t > 4 ? t - 4 : 0, n = e.length;
+      for (let r = i; r < n; r++) {
+        const o = e[r];
+        o != null && (this._onItemRemoved(o), e[r] = null);
+      }
+      t <= 4 ? (e.length = 0, this._overflow = null) : e.length = t - 4;
+    }
+    this._count = t;
+  }
+  _onItemRemoved(t) {
+  }
+  add(t) {
+    if (this._s0 === null) {
+      this._s0 = t, this._count++;
+      return;
+    }
+    if (this._s1 === null) {
+      this._s1 = t, this._count++;
+      return;
+    }
+    if (this._s2 === null) {
+      this._s2 = t, this._count++;
+      return;
+    }
+    if (this._s3 === null) {
+      this._s3 = t, this._count++;
+      return;
+    }
+    if (this._overflow === null) this._overflow = [t];
+    else {
+      const s = this._overflow;
+      for (let e = 0, i = s.length; e < i; e++) if (s[e] === null) {
+        s[e] = t, this._count++;
+        return;
+      }
+      s.push(t);
+    }
+    this._count++;
+  }
+  remove(t) {
+    if (this._s0 === t)
+      return this._s0 = null, this._count--, !0;
+    if (this._s1 === t)
+      return this._s1 = null, this._count--, !0;
+    if (this._s2 === t)
+      return this._s2 = null, this._count--, !0;
+    if (this._s3 === t)
+      return this._s3 = null, this._count--, !0;
+    const s = this._overflow;
+    if (s == null) return !1;
+    for (let e = 0, i = s.length; e < i; e++) if (s[e] === t)
+      return s[e] = null, this._count--, !0;
+    return !1;
+  }
+  has(t) {
+    const s = this._count;
+    if (s === 0) return !1;
+    if (this._s0 === t || this._s1 === t || this._s2 === t || this._s3 === t) return !0;
+    if (s <= 4) return !1;
+    const e = this._overflow;
+    if (e != null) {
+      let i = 0;
+      this._s0 != null && i++, this._s1 != null && i++, this._s2 != null && i++, this._s3 != null && i++;
+      for (let n = 0, r = e.length; n < r; n++) {
+        const o = e[n];
+        if (o != null) {
+          if (o === t) return !0;
+          if (++i === s) break;
+        }
+      }
+    }
+    return !1;
+  }
+  forEach(t) {
+    const s = this._count;
+    if (s === 0) return;
+    const e = this._s0;
+    e != null && t(e);
+    const i = this._s1;
+    i != null && t(i);
+    const n = this._s2;
+    n != null && t(n);
+    const r = this._s3;
+    if (r != null && t(r), s <= 4) return;
+    const o = this._overflow;
+    if (o != null) {
+      let h = 0;
+      e != null && h++, i != null && h++, n != null && h++, r != null && h++;
+      for (let u = 0, a = o.length; u < a; u++) {
+        const c = o[u];
+        if (c != null && (t(c), ++h === s))
+          return;
+      }
+    }
+  }
+  forEachIndexed(t) {
+    const s = this._count;
+    if (s === 0) return 0;
+    let e = 0;
+    const i = this._s0;
+    i != null && (t(i), e++);
+    const n = this._s1;
+    n != null && (t(n), e++);
+    const r = this._s2;
+    r != null && (t(r), e++);
+    const o = this._s3;
+    if (o != null && (t(o), e++), s <= 4 || e === s) return e;
+    const h = this._overflow;
+    if (h != null) for (let u = 0, a = h.length; u < a; u++) {
+      const c = h[u];
+      if (c != null && (t(c), ++e === s))
+        break;
+    }
+    return e;
+  }
+  compact() {
+    const t = this._overflow;
+    if (t === null || t.length === 0) return;
+    let s = 0;
+    for (; s < t.length; ) if (t[s] === null) {
+      const e = t.pop();
+      s < t.length && e != null && (t[s] = e);
+    } else s++;
+    t.length === 0 && (this._overflow = null);
   }
+  clear() {
+    this._s0 = null, this._s1 = null, this._s2 = null, this._s3 = null, this._count = 0, this._overflow !== null && (this._overflow.length = 0, this._overflow = null);
+  }
+  dispose() {
+    this.clear();
+  }
+}, Z = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), lt = /* @__PURE__ */ Symbol("AtomEffect.Id"), K = /* @__PURE__ */ Symbol("AtomEffect.Type"), U = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), X = {
+  enabled: !1,
+  warnInfiniteLoop: st.WARN_INFINITE_LOOP,
+  warn(t, s) {
+  },
+  attachDebugInfo(t, s, e) {
+  },
+  getDebugName: (t) => t?.[Z],
+  getDebugType: (t) => t?.[K]
+}, _t = 1, ct = () => _t++;
+function T(t, s, e) {
+  if (t instanceof N) return t;
+  const i = t instanceof Error, n = i ? t.message : String(t), r = i ? t : void 0;
+  return new s(`${i ? t.constructor.name : "Unexpected error"} (${e}): ${n}`, r);
 }
-class tt extends J {
+var V = class {
   constructor() {
-    super(...arguments), this._notifying = 0;
+    this.flags = 0, this.version = 0, this._lastSeenEpoch = I.UNINITIALIZED, this._notifying = 0, this._hotIndex = -1, this._slots = null, this._deps = null, this.id = ct() & G;
   }
-  /**
-   * Adds subscriber.
-   */
   subscribe(t) {
     const s = typeof t == "function";
-    if (!s && (!t || typeof t.execute != "function"))
-      throw S(
-        new TypeError("Invalid subscriber"),
-        k,
-        c.ATOM_SUBSCRIBER_MUST_BE_FUNCTION
-      );
-    const e = this._subscribers, i = e.length;
-    let r = !1;
-    for (let o = 0; o < i; o++) {
-      const U = e[o];
-      if (U != null && (s ? U.fn === t : U.sub === t)) {
-        r = !0;
-        break;
-      }
-    }
-    if (r)
+    if (!s && (!t || typeof t.execute != "function")) throw T(/* @__PURE__ */ new TypeError("Invalid subscriber"), N, l.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
+    let e = this._slots;
+    e || (e = new et(), this._slots = e);
+    let i = !1;
+    if (e.forEach((r) => {
+      (s ? r.fn === t : r.sub === t) && (i = !0);
+    }), i)
       return () => {
       };
-    const h = new ct(
-      s ? t : void 0,
-      s ? void 0 : t
-    );
-    return e.push(h), () => this._unsubscribe(h);
+    const n = new ut(s ? t : void 0, s ? void 0 : t);
+    return e.add(n), () => this._unsubscribe(n);
   }
   _unsubscribe(t) {
-    const s = this._subscribers;
-    let e = -1;
-    for (let r = 0; r < s.length; r++)
-      if (s[r] === t) {
-        e = r;
-        break;
+    if (this._slots) {
+      if (this._notifying > 0) {
+        this._slots.remove(t);
+        return;
       }
-    if (e === -1) return;
-    if (this._notifying > 0) {
-      s[e] = null;
-      return;
+      this._slots.remove(t), this._slots.compact();
     }
-    const i = s.pop();
-    e < s.length && i !== void 0 && (s[e] = i);
   }
   subscriberCount() {
-    let t = 0;
-    const s = this._subscribers;
-    for (let e = 0; e < s.length; e++)
-      s[e] != null && t++;
-    return t;
+    return this._slots ? this._slots.size : 0;
   }
   _notifySubscribers(t, s) {
-    const e = this._subscribers, i = e.length;
-    if (i !== 0) {
+    const e = this._slots;
+    if (!(!e || e.size === 0)) {
       this._notifying++;
       try {
-        for (let r = 0; r < i; r++) {
-          const h = e[r];
-          if (h != null)
-            try {
-              h.notify(t, s);
-            } catch (o) {
-              this._handleNotifyError(o);
-            }
-        }
+        e.forEach((i) => {
+          try {
+            i.notify(t, s);
+          } catch (n) {
+            console.error(T(n, N, l.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
+          }
+        });
       } finally {
-        this._notifying--, this._notifying === 0 && this._cleanupTombstones();
+        this._notifying--, this._notifying === 0 && e.compact();
       }
     }
   }
-  _cleanupTombstones() {
-    const t = this._subscribers;
-    let s = 0;
-    for (; s < t.length; )
-      if (t[s] === null) {
-        const e = t.pop();
-        s < t.length && e !== void 0 && (t[s] = e);
-      } else
-        s++;
-  }
-  _handleNotifyError(t) {
-    console.error(S(t, k, c.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
+  _isDirty() {
+    const t = this._deps;
+    if (!t || t.size === 0) return !1;
+    if (this._hotIndex !== -1) {
+      const s = t.getAt(this._hotIndex);
+      if (s != null && s.node.version !== s.version) return !0;
+    }
+    return !t.hasComputeds && !t.isDirtyFast() ? !1 : this._deepDirtyCheck();
   }
+}, w = 0, Q = () => (w = w + 1 & 1073741823 || 1, w), z = (t) => t + 1 & G, Y = 0, F = !1, it = 0, nt = () => it;
+function J() {
+  return F ? !1 : (F = !0, it = Q(), Y = 0, !0);
 }
-let v = 0;
-const w = () => (v = v + 1 & F || 1, v), M = (n) => n + 1 & F;
-let z = 0, R = !1, st = 0;
-const et = () => st;
-function G() {
-  return R ? !1 : (R = !0, st = w(), z = 0, !0);
-}
-const Q = () => {
-  R = !1;
-}, ft = () => R ? ++z : 0;
-class Et {
+var tt = () => {
+  F = !1;
+}, ft = () => F ? ++Y : 0, L = /* @__PURE__ */ (function(t) {
+  return t[t.IDLE = 0] = "IDLE", t[t.BATCHING = 1] = "BATCHING", t[t.FLUSHING = 2] = "FLUSHING", t;
+})({}), at = class {
   constructor() {
-    this._queueBuffer = [[], []], this._bufferIndex = 0, this._size = 0, this._epoch = 0, this._isProcessing = !1, this._isBatching = !1, this._isFlushingSync = !1, this._batchDepth = 0, this._batchQueue = [], this._batchQueueSize = 0, this._maxFlushIterations = d.MAX_FLUSH_ITERATIONS, this.onOverflow = null, this._boundRunLoop = this._runLoop.bind(this);
+    this._queueBuffer = [[], []], this._bufferIndex = 0, this._size = 0, this._epoch = 0, this._isProcessing = !1, this._isBatching = !1, this._isFlushingSync = !1, this._batchDepth = 0, this._batchQueue = [], this._batchQueueSize = 0, this._maxFlushIterations = m.MAX_FLUSH_ITERATIONS, this.onOverflow = null, this._boundRunLoop = this._runLoop.bind(this);
   }
   get phase() {
-    return this._isProcessing || this._isFlushingSync ? 2 : this._isBatching ? 1 : 0;
+    return this._isProcessing || this._isFlushingSync ? L.FLUSHING : this._isBatching ? L.BATCHING : L.IDLE;
   }
   get queueSize() {
     return this._size;
@@ -250,9 +378,6 @@ class Et {
   get isBatching() {
     return this._isBatching;
   }
-  /**
-   * Schedules job.
-   */
   schedule(t) {
     if (t._nextEpoch !== this._epoch) {
       if (t._nextEpoch = this._epoch, this._isBatching || this._isFlushingSync) {
@@ -262,40 +387,36 @@ class Et {
       this._queueBuffer[this._bufferIndex][this._size++] = t, this._isProcessing || this._flush();
     }
   }
-  /**
-   * Triggers flush.
-   */
   _flush() {
     this._isProcessing || this._size === 0 || (this._isProcessing = !0, queueMicrotask(this._boundRunLoop));
   }
-  /**
-   * Scheduler loop.
-   */
   _runLoop() {
     try {
       if (this._size === 0) return;
-      const t = G();
-      this._drainQueue(), t && Q();
+      const t = J();
+      this._drainQueue(), t && tt();
     } finally {
       this._isProcessing = !1, this._size > 0 && !this._isBatching && this._flush();
     }
   }
   _flushSync() {
     this._isFlushingSync = !0;
-    const t = G();
+    const t = J();
     try {
       this._mergeBatchQueue(), this._drainQueue();
     } finally {
-      this._isFlushingSync = !1, t && Q();
+      this._isFlushingSync = !1, t && tt();
     }
   }
   _mergeBatchQueue() {
     if (this._batchQueueSize === 0) return;
     const t = ++this._epoch, s = this._batchQueue, e = this._queueBuffer[this._bufferIndex];
     let i = this._size;
-    s.slice(0, this._batchQueueSize).forEach((r) => {
+    for (let n = 0; n < this._batchQueueSize; n++) {
+      const r = s[n];
       r._nextEpoch !== t && (r._nextEpoch = t, e[i++] = r);
-    }), this._size = i, this._batchQueueSize = 0, s.length > d.BATCH_QUEUE_SHRINK_THRESHOLD && (s.length = 0);
+    }
+    this._size = i, this._batchQueueSize = 0, s.length = 0;
   }
   _drainQueue() {
     let t = 0;
@@ -310,26 +431,20 @@ class Et {
   _processQueue() {
     const t = this._bufferIndex, s = this._queueBuffer[t], e = this._size;
     this._bufferIndex = t ^ 1, this._size = 0, this._epoch++;
-    for (let i = 0; i < e; i++)
-      try {
-        const r = s[i];
-        typeof r == "function" ? r() : r.execute();
-      } catch (r) {
-        console.error(new m("Error occurred during scheduler execution", r));
-      }
+    for (let i = 0; i < e; i++) try {
+      const n = s[i];
+      typeof n == "function" ? n() : n.execute();
+    } catch (n) {
+      console.error(new R("Error occurred during scheduler execution", n));
+    }
     s.length = 0;
   }
   _handleFlushOverflow() {
     const t = this._size + this._batchQueueSize;
-    if (console.error(
-      new m(
-        c.SCHEDULER_FLUSH_OVERFLOW(this._maxFlushIterations, t)
-      )
-    ), this._size = 0, this._queueBuffer[this._bufferIndex].length = 0, this._batchQueueSize = 0, this.onOverflow)
-      try {
-        this.onOverflow(t);
-      } catch {
-      }
+    if (console.error(new R(l.SCHEDULER_FLUSH_OVERFLOW(this._maxFlushIterations, t))), this._size = 0, this._queueBuffer[this._bufferIndex].length = 0, this._batchQueueSize = 0, this.onOverflow) try {
+      this.onOverflow(t);
+    } catch {
+    }
   }
   startBatch() {
     this._batchDepth++, this._isBatching = !0;
@@ -338,214 +453,314 @@ class Et {
     this._batchDepth !== 0 && --this._batchDepth === 0 && (this._flushSync(), this._isBatching = !1);
   }
   setMaxFlushIterations(t) {
-    if (t < d.MIN_FLUSH_ITERATIONS)
-      throw new m(
-        `Max flush iterations must be at least ${d.MIN_FLUSH_ITERATIONS}`
-      );
+    if (t < m.MIN_FLUSH_ITERATIONS) throw new R(`Max flush iterations must be at least ${m.MIN_FLUSH_ITERATIONS}`);
     this._maxFlushIterations = t;
   }
-}
-const T = new Et(), H = /* @__PURE__ */ Symbol.for("atom-effect/atom"), it = /* @__PURE__ */ Symbol.for("atom-effect/computed"), nt = /* @__PURE__ */ Symbol.for("atom-effect/effect"), dt = /* @__PURE__ */ Symbol.for("atom-effect/writable"), l = {
-  /** Active listener. */
+}, y = new at(), $ = /* @__PURE__ */ Symbol.for("atom-effect/atom"), rt = /* @__PURE__ */ Symbol.for("atom-effect/computed"), ot = /* @__PURE__ */ Symbol.for("atom-effect/effect"), Et = /* @__PURE__ */ Symbol.for("atom-effect/writable"), _ = {
   current: null,
-  /**
-   * Executes in context.
-   *
-   * @param listener - The subscriber.
-   * @param fn - The logic to execute.
-   * @returns The result of `fn`.
-   */
-  run(n, t) {
-    const s = this.current;
-    this.current = n;
+  run(t, s) {
+    const e = this.current;
+    this.current = t;
     try {
-      return t();
+      return s();
     } finally {
-      this.current = s;
+      this.current = e;
     }
   }
 };
-function Dt(n) {
-  const t = l.current;
-  if (t === null) return n();
-  l.current = null;
+function vt(t) {
+  const s = _.current;
+  if (s === null) return t();
+  _.current = null;
   try {
-    return n();
+    return t();
   } finally {
-    l.current = t;
+    _.current = s;
   }
 }
-var Y, q;
-class It extends tt {
+var dt = class extends V {
   constructor(t, s) {
-    super(), this._pendingOldValue = void 0, this._subscribers = [], this[q] = !0, this[Y] = !0, this._value = t, s && (this.flags |= a.SYNC), B.attachDebugInfo(this, "atom", this.id);
+    super(), this[$] = !0, this[Et] = !0, this._value = t, this._pendingOldValue = void 0, s && (this.flags |= d.SYNC), X.attachDebugInfo(this, "atom", this.id);
   }
   get value() {
-    return l.current?.addDependency(this), this._value;
+    const t = _.current;
+    return t?.addDependency(this), this._value;
   }
   set value(t) {
     const s = this._value;
     if (Object.is(s, t)) return;
-    this._value = t, this.version = M(this.version);
-    const e = this.flags;
-    if (!(this._subscribers.length === 0 || e & a.NOTIFICATION_SCHEDULED)) {
-      if (this._pendingOldValue = s, this.flags = e | a.NOTIFICATION_SCHEDULED, e & a.SYNC && !T.isBatching) {
-        this._flushNotifications();
-        return;
-      }
-      T.schedule(this);
+    this._value = t, this.version = z(this.version);
+    const e = this._slots, i = this.flags;
+    if (e == null || e.size === 0 || i & d.NOTIFICATION_SCHEDULED) return;
+    this._pendingOldValue = s;
+    const n = i | d.NOTIFICATION_SCHEDULED;
+    if (this.flags = n, (n & d.SYNC) !== 0 && !y.isBatching) {
+      this._flushNotifications();
+      return;
     }
+    y.schedule(this);
   }
-  /**
-   * Executes scheduled notification.
-   * @internal
-   */
   execute() {
     this._flushNotifications();
   }
-  /**
-   * Triggers subscribers.
-   */
   _flushNotifications() {
     const t = this.flags;
-    if (!(t & a.NOTIFICATION_SCHEDULED) || t & a.DISPOSED)
-      return;
+    if (!(t & d.NOTIFICATION_SCHEDULED) || t & d.DISPOSED) return;
     const s = this._pendingOldValue;
-    this._pendingOldValue = void 0, this.flags &= -17, this._notifySubscribers(this._value, s);
+    this._pendingOldValue = void 0, this.flags &= ~d.NOTIFICATION_SCHEDULED, this._notifySubscribers(this._value, s);
   }
   peek() {
     return this._value;
   }
   dispose() {
-    this.flags & a.DISPOSED || (this._subscribers.length = 0, this.flags |= a.DISPOSED, this._value = void 0, this._pendingOldValue = void 0);
+    this.flags & d.DISPOSED || (this._slots?.clear(), this.flags |= d.DISPOSED, this._value = void 0, this._pendingOldValue = void 0);
   }
-  [(q = H, Y = dt, Symbol.dispose)]() {
+  _deepDirtyCheck() {
+    return !1;
+  }
+  [Symbol.dispose]() {
     this.dispose();
   }
+};
+function Dt(t, s = {}) {
+  return new dt(t, s.sync ?? !1);
 }
-function bt(n, t = {}) {
-  return new It(n, t.sync ?? !1);
-}
-class pt {
-  /**
-   * @param limit - Max unique arrays to hold (default: 50). Prevents the pool itself from consuming too much memory.
-   * @param capacity - Max length of an array to accept (default: 256).
-   * @param enableStats - Force-enable stats even in production (default: false).
-   */
-  constructor(t = 50, s = 256, e = !1) {
-    this.limit = t, this.capacity = s, this.pool = [], this.stats = null, this.stats = e ? {
-      acquired: 0,
-      released: 0,
-      rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
-    } : null;
-  }
-  /**
-   * Acquires array.
-   */
-  acquire() {
-    return this.stats && this.stats.acquired++, this.pool.pop() ?? [];
-  }
-  /**
-   * Releases array.
-   *
-   * @param arr - Array to release.
-   * @param emptyConst - Optional empty constant.
-   */
-  release(t, s) {
-    if (!(s && t === s)) {
-      if (t.length > this.capacity) {
-        this.stats && this.stats.rejected.tooLarge++;
-        return;
+var k = class extends et {
+  constructor() {
+    super(), this._map = null, this._SCAN_THRESHOLD = 32, this.hasComputeds = !1, this._depsHash = 0, this._map = null, this.hasComputeds = !1, this._depsHash = 0;
+  }
+  prepareTracking() {
+    this.hasComputeds = !1;
+  }
+  _onItemRemoved(t) {
+    const s = t.unsub;
+    s && s();
+  }
+  claimExisting(t, s) {
+    const e = this._count;
+    if (s >= e) return !1;
+    const i = e - s;
+    if (this._map !== null || i > this._SCAN_THRESHOLD) return this._claimViaMap(t, s);
+    if (s < 4) switch (s) {
+      case 0: {
+        const o = this._s0;
+        if (o && o.node === t && o.unsub)
+          return o.version = t.version, !0;
       }
-      if (this.pool.length >= this.limit) {
-        this.stats && this.stats.rejected.poolFull++;
-        return;
+      case 1:
+        if (e > 1) {
+          const o = this._s1;
+          if (o && o.node === t && o.unsub)
+            return o.version = t.version, s !== 1 && (this._s1 = this._s0, this._s0 = o), !0;
+        }
+      case 2:
+        if (e > 2) {
+          const o = this._s2;
+          if (o && o.node === t && o.unsub) {
+            if (o.version = t.version, s !== 2) {
+              const h = s === 0 ? this._s0 : this._s1;
+              s === 0 ? this._s0 = o : this._s1 = o, this._s2 = h;
+            }
+            return !0;
+          }
+        }
+      case 3:
+        if (e > 3) {
+          const o = this._s3;
+          if (o && o.node === t && o.unsub) {
+            if (o.version = t.version, s !== 3) {
+              let h;
+              s === 0 ? (h = this._s0, this._s0 = o) : s === 1 ? (h = this._s1, this._s1 = o) : (h = this._s2, this._s2 = o), this._s3 = h;
+            }
+            return !0;
+          }
+        }
+    }
+    const n = s > 4 ? s : 4, r = this._overflow;
+    if (r) for (let o = n - 4, h = r.length; o < h; o++) {
+      const u = r[o];
+      if (u && u.node === t && u.unsub)
+        return u.version = t.version, this._swapGeneral(o + 4, s, u), !0;
+    }
+    return !1;
+  }
+  _claimViaMap(t, s) {
+    if (this._map === null) {
+      this._map = /* @__PURE__ */ new Map();
+      const n = this._count;
+      s < 4 && (s <= 0 && this._s0?.unsub && this._map.set(this._s0.node, 0), s <= 1 && this._s1?.unsub && this._map.set(this._s1.node, 1), s <= 2 && this._s2?.unsub && this._map.set(this._s2.node, 2), s <= 3 && this._s3?.unsub && this._map.set(this._s3.node, 3));
+      const r = this._overflow;
+      if (r && n > 4) {
+        const o = s > 4 ? s : 4;
+        for (let h = o - 4, u = r.length; h < u; h++) {
+          const a = r[h];
+          a?.unsub && this._map.set(a.node, h + 4);
+        }
       }
-      if (Object.isFrozen(t)) {
-        this.stats && this.stats.rejected.frozen++;
+    }
+    const e = this._map.get(t);
+    if (e === void 0 || e < s) return !1;
+    const i = this.getAt(e);
+    if (i == null || !i.unsub) return !1;
+    if (i.version = t.version, e !== s) {
+      const n = this.getAt(s);
+      this.setAt(s, i), this.setAt(e, n), n?.unsub && this._map.set(n.node, e), this._map.set(t, s);
+    }
+    return !0;
+  }
+  _swapInline(t, s, e) {
+    const i = this.getAt(s);
+    this.setAt(s, e), this.setAt(t, i);
+  }
+  _swapGeneral(t, s, e) {
+    if (t === s) return;
+    const i = this.getAt(s);
+    if (this.setAt(s, e), t === 0) this._s0 = i;
+    else if (t === 1) this._s1 = i;
+    else if (t === 2) this._s2 = i;
+    else if (t === 3) this._s3 = i;
+    else {
+      const n = this._overflow;
+      n[t - 4] = i;
+    }
+  }
+  insertNew(t, s) {
+    const e = this._count;
+    if (t < e) {
+      const i = this.getAt(t);
+      i != null && (this.add(i), this._map !== null && i.unsub && this._map.set(i.node, this._count - 1));
+    }
+    if (t === 0) this._s0 = s;
+    else if (t === 1) this._s1 = s;
+    else if (t === 2) this._s2 = s;
+    else if (t === 3) this._s3 = s;
+    else {
+      let i = this._overflow;
+      i || (i = [], this._overflow = i), i[t - 4] = s;
+    }
+    t >= e && (this._count = t + 1);
+  }
+  truncateFrom(t) {
+    t >= this._count || (super.truncateFrom(t), this._map !== null && (this._map.clear(), this._map = null));
+  }
+  seal() {
+    const t = this._count, s = q.VERSION_BITS;
+    let e = 0;
+    switch (t) {
+      case 0:
+        this._depsHash = 0;
         return;
+      case 1: {
+        const i = this._s0;
+        e = e + (i.version << s) + i.node.id | 0;
+        break;
+      }
+      case 2: {
+        const i = this._s0, n = this._s1;
+        e = e + (i.version << s) + i.node.id | 0, e = e + (n.version << s) + n.node.id | 0;
+        break;
+      }
+      case 3: {
+        const i = this._s0, n = this._s1, r = this._s2;
+        e = e + (i.version << s) + i.node.id | 0, e = e + (n.version << s) + n.node.id | 0, e = e + (r.version << s) + r.node.id | 0;
+        break;
+      }
+      default: {
+        const i = this._s0, n = this._s1, r = this._s2, o = this._s3;
+        if (e = e + (i.version << s) + i.node.id | 0, e = e + (n.version << s) + n.node.id | 0, e = e + (r.version << s) + r.node.id | 0, e = e + (o.version << s) + o.node.id | 0, t > 4) {
+          const h = this._overflow;
+          for (let u = 0, a = h.length; u < a; u++) {
+            const c = h[u];
+            e = e + (c.version << s) + c.node.id | 0;
+          }
+        }
       }
-      t.length = 0, this.pool.push(t), this.stats && this.stats.released++;
-    }
-  }
-  /**
-   * Pool stats.
-   */
-  getStats() {
-    if (!this.stats) return null;
-    const { acquired: t, released: s, rejected: e } = this.stats, i = t - s - (e.frozen + e.tooLarge + e.poolFull);
-    return {
-      acquired: t,
-      released: s,
-      rejected: { ...e },
-      leaked: i,
-      poolSize: this.pool.length
-    };
-  }
-  /**
-   * Resets pool.
-   */
-  reset() {
-    this.pool.length = 0, this.stats && (this.stats = {
-      acquired: 0,
-      released: 0,
-      rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
-    });
+    }
+    this._depsHash = e;
+  }
+  isDirtyFast() {
+    const t = this._count, s = q.VERSION_BITS;
+    let e = 0;
+    switch (t) {
+      case 0:
+        return !1;
+      case 1: {
+        const i = this._s0.node;
+        e = e + (i.version << s) + i.id | 0;
+        break;
+      }
+      case 2: {
+        const i = this._s0.node, n = this._s1.node;
+        e = e + (i.version << s) + i.id | 0, e = e + (n.version << s) + n.id | 0;
+        break;
+      }
+      case 3: {
+        const i = this._s0.node, n = this._s1.node, r = this._s2.node;
+        e = e + (i.version << s) + i.id | 0, e = e + (n.version << s) + n.id | 0, e = e + (r.version << s) + r.id | 0;
+        break;
+      }
+      default: {
+        const i = this._s0.node, n = this._s1.node, r = this._s2.node, o = this._s3.node;
+        if (e = e + (i.version << s) + i.id | 0, e = e + (n.version << s) + n.id | 0, e = e + (r.version << s) + r.id | 0, e = e + (o.version << s) + o.id | 0, t > 4) {
+          const h = this._overflow;
+          for (let u = 0, a = h.length; u < a; u++) {
+            const c = h[u].node;
+            e = e + (c.version << s) + c.id | 0;
+          }
+        }
+      }
+    }
+    return e !== this._depsHash;
   }
+  disposeAll() {
+    this._count > 0 && this.truncateFrom(0), this.hasComputeds = !1, this._map !== null && (this._map.clear(), this._map = null);
+  }
+  remove(t) {
+    throw new Error("remove() is strictly prohibited in DepSlotBuffer to preserve sequential cache paths.");
+  }
+  compact() {
+  }
+};
+function St(t) {
+  return t !== null && typeof t == "object" && $ in t;
 }
-const u = Object.freeze(
-  []
-), f = new pt();
-function Tt(n) {
-  return n !== null && typeof n == "object" && H in n;
-}
-function Nt(n) {
-  return n !== null && typeof n == "object" && it in n;
-}
-function Lt(n) {
-  return n !== null && typeof n == "object" && nt in n;
+function gt(t) {
+  return t !== null && typeof t == "object" && rt in t;
 }
-function rt(n) {
-  return n !== null && typeof n == "object" && typeof n.then == "function";
+function mt(t) {
+  return t !== null && typeof t == "object" && ot in t;
 }
-var j, $;
-const { IDLE: L, DIRTY: p, PENDING: O, RESOLVED: E, REJECTED: b, HAS_ERROR: A, RECOMPUTING: D, DISPOSED: P, IS_COMPUTED: Ct } = W;
-function gt(n) {
-  return n & E ? N.RESOLVED : n & O ? N.PENDING : n & b ? N.REJECTED : N.IDLE;
+function ht(t) {
+  return t !== null && typeof t == "object" && typeof t.then == "function";
 }
-class St extends tt {
+var { IDLE: C, DIRTY: E, PENDING: g, RESOLVED: p, REJECTED: v, HAS_ERROR: A, RECOMPUTING: O, DISPOSED: M, IS_COMPUTED: P, FORCE_COMPUTE: B } = x, pt = class extends V {
   constructor(t, s = {}) {
-    if (typeof t != "function") throw new I(c.COMPUTED_MUST_BE_FUNCTION);
-    super(), this[$] = !0, this[j] = !0, this._error = null, this._promiseId = 0, this._subscribers = [], this._links = u, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this._lastDriftEpoch = g.UNINITIALIZED, this._trackEpoch = g.UNINITIALIZED, this._trackLinks = u, this._trackCount = 0, this._value = void 0, this.flags = Ct | p | L, this._equal = s.equal ?? Object.is, this._fn = t, this._defaultValue = "defaultValue" in s ? s.defaultValue : x, this._onError = s.onError ?? null;
-    const e = s.maxAsyncRetries;
-    if (this._maxAsyncRetries = (e ?? V.MAX_ASYNC_RETRIES) & F, B.attachDebugInfo(this, "computed", this.id), s.lazy === !1)
-      try {
-        this._recompute();
-      } catch {
-      }
+    if (typeof t != "function") throw new S(l.COMPUTED_MUST_BE_FUNCTION);
+    if (super(), this[$] = !0, this[rt] = !0, this._error = null, this._promiseId = 0, this._deps = new k(), this._asyncRetryCount = 0, this._lastDriftEpoch = I.UNINITIALIZED, this._trackEpoch = I.UNINITIALIZED, this._trackCount = 0, this._value = void 0, this.flags = P | E | C, this._equal = s.equal ?? Object.is, this._fn = t, this._defaultValue = "defaultValue" in s ? s.defaultValue : U, this._onError = s.onError ?? null, this._maxAsyncRetries = (s.maxAsyncRetries ?? j.MAX_ASYNC_RETRIES) & G, X.attachDebugInfo(this, "computed", this.id), s.lazy === !1) try {
+      this._recompute();
+    } catch {
+    }
   }
   _track() {
-    l.current?.addDependency(this);
+    _.current?.addDependency(this);
   }
   get value() {
     this._track();
     const t = this.flags;
-    if ((t & (E | p | L)) === E)
-      return this._value;
-    if (t & P)
-      throw new I(c.COMPUTED_DISPOSED);
-    if (t & D) {
-      if (this._defaultValue !== x) return this._defaultValue;
-      throw new I(c.COMPUTED_CIRCULAR_DEPENDENCY);
+    if ((t & (p | E | C)) === p) return this._value;
+    if (t & M) throw new S(l.COMPUTED_DISPOSED);
+    if (t & O) {
+      if (this._defaultValue !== U) return this._defaultValue;
+      throw new S(l.COMPUTED_CIRCULAR_DEPENDENCY);
     }
-    if (t & (p | L) && (this._recompute(), this.flags & E))
+    if (t & (E | C) && ((t & C) === 0 && (t & B) === 0 && this._deps.size > 0 && !this._isDirty() ? this.flags &= ~E : this._recompute(), this.flags & p))
       return this._value;
-    const s = this._defaultValue, e = s !== x;
-    if (this.flags & O) {
+    const s = this._defaultValue, e = s !== U;
+    if (this.flags & g) {
       if (e) return s;
-      throw new I(c.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+      throw new S(l.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
     }
-    if (this.flags & b) {
+    if (this.flags & v) {
       if (e) return s;
       throw this._error;
     }
@@ -555,279 +770,250 @@ class St extends tt {
     return this._value;
   }
   get state() {
-    return this._track(), gt(this.flags);
+    this._track();
+    const t = this.flags;
+    return t & p ? b.RESOLVED : t & g ? b.PENDING : t & v ? b.REJECTED : b.IDLE;
   }
   get hasError() {
-    return this._track(), this.flags & (b | A) ? !0 : this._links.some((t) => t?.node?.flags & A);
+    if (this._track(), this.flags & (v | A)) return !0;
+    const t = this._deps;
+    if (!t.hasComputeds) return !1;
+    const s = t.size;
+    for (let e = 0; e < s; e++) {
+      const i = t.getAt(e);
+      if (i != null && i.node.flags & A) return !0;
+    }
+    return !1;
   }
   get isValid() {
     return !this.hasError;
   }
   get errors() {
-    if (this._track(), !this.hasError) return ot;
+    this._track();
     const t = [];
-    return this._error && t.push(this._error), this._links.forEach((e) => {
-      const i = e.node;
-      i.flags & A && i.errors.forEach((h) => {
-        h && !t.includes(h) && t.push(h);
-      });
-    }), Object.freeze(t);
+    this._error && t.push(this._error);
+    const s = this._deps;
+    if (!s.hasComputeds) return t.length === 0 ? W : Object.freeze(t);
+    const e = s.size;
+    for (let i = 0; i < e; i++) {
+      const n = s.getAt(i);
+      if (n == null) continue;
+      const r = n.node;
+      r.flags & A && this._collectErrorsFromDep(r, t);
+    }
+    return t.length === 0 ? W : Object.freeze(t);
+  }
+  _collectErrorsFromDep(t, s) {
+    const e = t.errors, i = e.length;
+    for (let n = 0; n < i; n++) {
+      const r = e[n];
+      r != null && !s.includes(r) && s.push(r);
+    }
   }
   get lastError() {
     return this._track(), this._error;
   }
   get isPending() {
-    return this._track(), (this.flags & O) !== 0;
+    return this._track(), (this.flags & g) !== 0;
   }
   get isResolved() {
-    return this._track(), (this.flags & E) !== 0;
+    return this._track(), (this.flags & p) !== 0;
   }
   invalidate() {
-    this._markDirty();
+    this.flags |= B, this._markDirty();
   }
   dispose() {
-    if (this.flags & P) return;
-    const t = this._links;
-    t !== u && (t.forEach((s) => s.unsub?.()), f.release(t), this._links = u), this._subscribers.length = 0, this.flags = P | p | L, this._error = null, this._value = void 0;
+    this.flags & M || (this._deps.disposeAll(), this._slots?.clear(), this.flags = M | E | C, this._error = null, this._value = void 0, this._hotIndex = -1);
   }
-  [($ = H, j = it, Symbol.dispose)]() {
+  [Symbol.dispose]() {
     this.dispose();
   }
   addDependency(t) {
-    if (t._lastSeenEpoch !== this._trackEpoch) {
-      if (t._lastSeenEpoch = this._trackEpoch, this._trackLinks === this._links && this._trackCount < this._links.length && this._links[this._trackCount].node === t) {
-        this._links[this._trackCount].version = t.version, this._trackCount++;
-        return;
-      }
-      if (this._trackLinks === this._links) {
-        const s = f.acquire();
-        for (let e = 0; e < this._trackCount; e++)
-          s[e] = this._links[e];
-        this._trackLinks = s;
-      }
-      this._trackCount < this._trackLinks.length ? this._trackLinks[this._trackCount] = new y(t, t.version) : this._trackLinks.push(new y(t, t.version)), this._trackCount++;
+    if (t._lastSeenEpoch === this._trackEpoch) return;
+    t._lastSeenEpoch = this._trackEpoch;
+    const s = this._trackCount, e = this._deps.getAt(s);
+    if (e != null && e.node === t) e.version = t.version;
+    else if (!this._deps.claimExisting(t, s)) {
+      const i = new H(t, t.version, t.subscribe(this));
+      this._deps.insertNew(s, i);
     }
+    t.flags & P && (this._deps.hasComputeds = !0), this._trackCount = s + 1;
   }
   _recompute() {
-    if (this.flags & D) return;
-    this.flags |= D;
-    const t = this._links;
-    this._trackEpoch = w(), this._trackLinks = t, this._trackCount = 0;
-    let s = !1;
+    if (this.flags & O) return;
+    this.flags = (this.flags | O) & ~B, this._trackEpoch = Q(), this._trackCount = 0, this._deps.prepareTracking(), this._hotIndex = -1;
+    let t = !1;
     try {
-      const e = l.run(this, this._fn);
-      if (this._trackLinks === t)
-        if (this._trackCount === t.length)
-          s = !0;
-        else {
-          for (let i = this._trackCount; i < t.length; i++)
-            t[i].unsub?.();
-          t.length = this._trackCount, s = !0;
-        }
-      else
-        this._trackLinks.length = this._trackCount, X(this._trackLinks, t, this), this._links = this._trackLinks, s = !0;
-      rt(e) ? this._handleAsyncComputation(e) : this._finalizeResolution(e);
-    } catch (e) {
-      if (!s)
-        try {
-          if (this._trackLinks === t) {
-            for (let i = this._trackCount; i < t.length; i++)
-              t[i].unsub?.();
-            t.length = this._trackCount, s = !0;
-          } else
-            this._trackLinks.length = this._trackCount, X(this._trackLinks, t, this), this._links = this._trackLinks, s = !0;
-        } catch {
-        }
-      this._handleError(e, c.COMPUTED_COMPUTATION_FAILED, !0);
+      const s = _.run(this, this._fn);
+      this._deps.truncateFrom(this._trackCount), this._deps.seal(), t = !0, ht(s) ? this._handleAsyncComputation(s) : this._finalizeResolution(s);
+    } catch (s) {
+      if (!t) try {
+        this._deps.truncateFrom(this._trackCount);
+      } catch {
+      }
+      this._handleError(s, l.COMPUTED_COMPUTATION_FAILED, !0);
     } finally {
-      s ? this._links !== t && t !== u && f.release(t) : this._trackLinks !== t && this._trackLinks !== u && f.release(this._trackLinks), this._trackEpoch = g.UNINITIALIZED, this._trackLinks = u, this._trackCount = 0, this.flags &= ~D;
+      this._trackEpoch = I.UNINITIALIZED, this._trackCount = 0, this.flags &= ~O;
     }
   }
   _handleAsyncComputation(t) {
-    this.flags = (this.flags | O) & -217, this._notifySubscribers(void 0, void 0), this._asyncStartAggregateVersion = this._captureVersionSnapshot(), this._asyncRetryCount = 0, this._promiseId = (this._promiseId + 1) % V.MAX_PROMISE_ID;
+    this.flags = (this.flags | g) & ~(C | E | p | v), this._notifySubscribers(void 0, void 0), this._asyncRetryCount = 0, this._promiseId = (this._promiseId + 1) % j.MAX_PROMISE_ID;
     const s = this._promiseId;
-    t.then(
-      (e) => {
-        if (s === this._promiseId) {
-          if (this._captureVersionSnapshot() !== this._asyncStartAggregateVersion) {
-            const i = et();
-            return this._lastDriftEpoch !== i && (this._lastDriftEpoch = i, this._asyncRetryCount = 0), this._asyncRetryCount++ < this._maxAsyncRetries ? this._markDirty() : this._handleError(
-              new I(
-                `Async drift threshold exceeded after ${this._maxAsyncRetries} retries.`
-              ),
-              c.COMPUTED_ASYNC_COMPUTATION_FAILED
-            );
-          }
-          this._finalizeResolution(e), this._notifySubscribers(e, void 0);
+    t.then((e) => {
+      if (s === this._promiseId) {
+        if (this._isDirty()) {
+          const i = nt();
+          return this._lastDriftEpoch !== i && (this._lastDriftEpoch = i, this._asyncRetryCount = 0), this._asyncRetryCount++ < this._maxAsyncRetries ? this._markDirty() : this._handleError(new S(`Async drift threshold exceeded after ${this._maxAsyncRetries} retries.`), l.COMPUTED_ASYNC_COMPUTATION_FAILED);
         }
-      },
-      (e) => s === this._promiseId && this._handleError(e, c.COMPUTED_ASYNC_COMPUTATION_FAILED)
-    );
-  }
-  _captureVersionSnapshot() {
-    let t = 0;
-    const s = this._links;
-    for (let e = 0, i = s.length; e < i; e++)
-      t = (t << 5) - t + s[e].node.version | 0;
-    return t;
+        this._finalizeResolution(e), this._notifySubscribers(e, void 0);
+      }
+    }, (e) => s === this._promiseId && this._handleError(e, l.COMPUTED_ASYNC_COMPUTATION_FAILED));
   }
   _handleError(t, s, e = !1) {
-    const i = S(t, I, s);
-    if (!e && !(this.flags & b) && (this.version = M(this.version)), this._error = i, this.flags = this.flags & -121 | b | A, this._onError)
-      try {
-        this._onError(i);
-      } catch (r) {
-        console.error(c.CALLBACK_ERROR_IN_ERROR_HANDLER, r);
-      }
+    const i = T(t, S, s);
+    if (!e && !(this.flags & v) && (this.version = z(this.version)), this._error = i, this.flags = this.flags & ~(C | E | g | p) | v | A, this._onError) try {
+      this._onError(i);
+    } catch (n) {
+      console.error(l.CALLBACK_ERROR_IN_ERROR_HANDLER, n);
+    }
     if (e) throw i;
     this._notifySubscribers(void 0, void 0);
   }
   _finalizeResolution(t) {
-    (!(this.flags & E) || !this._equal(this._value, t)) && (this.version = M(this.version)), this._value = t, this._error = null, this.flags = (this.flags | E) & -697;
+    (!(this.flags & p) || !this._equal(this._value, t)) && (this.version = z(this.version)), this._value = t, this._error = null, this.flags = (this.flags | p) & ~(C | E | g | v | A);
   }
   execute() {
     this._markDirty();
   }
-  /** @internal */
   _markDirty() {
-    this.flags & (D | p) || (this.flags |= p, this._notifySubscribers(void 0, void 0));
+    this.flags & (O | E) || (this.flags |= E, this._notifySubscribers(void 0, void 0));
   }
+  _isDirty() {
+    const t = this._deps;
+    return t.hasComputeds ? this._deepDirtyCheck() : t.isDirtyFast();
+  }
+  _deepDirtyCheck() {
+    const t = this._deps, s = _.current;
+    _.current = null;
+    try {
+      const e = t.size;
+      for (let i = 0; i < e; i++) {
+        const n = t.getAt(i);
+        if (n == null) continue;
+        const r = n.node;
+        if (r.flags & P) try {
+          r.value;
+        } catch {
+        }
+        if (r.version !== n.version)
+          return this._hotIndex = i, !0;
+      }
+      return this._hotIndex = -1, !1;
+    } finally {
+      _.current = s;
+    }
+  }
+};
+function Tt(t, s = {}) {
+  return new pt(t, s);
 }
-function At(n, t = {}) {
-  return new St(n, t);
-}
-var K;
-class kt extends J {
+var It = class extends V {
   constructor(t, s = {}) {
-    super(), this[K] = !0, this._cleanup = null, this._links = u, this._nextLinks = null, this._prevLinks = u, this._currentEpoch = g.UNINITIALIZED, this._lastFlushEpoch = g.UNINITIALIZED, this._executionsInEpoch = 0, this._executionCount = 0, this._windowStart = 0, this._windowCount = 0, this._execId = 0, this._trackCount = 0, this._fn = t, this._onError = s.onError ?? null, this._sync = s.sync ?? !1, this._maxExecutions = s.maxExecutionsPerSecond ?? d.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = s.maxExecutionsPerFlush ?? d.MAX_EXECUTIONS_PER_EFFECT, this._sync ? this._notifyCallback = () => this.execute() : this._notifyCallback = () => T.schedule(this), B.attachDebugInfo(this, "effect", this.id);
+    super(), this[ot] = !0, this._cleanup = null, this._deps = new k(), this._currentEpoch = I.UNINITIALIZED, this._lastFlushEpoch = I.UNINITIALIZED, this._fn = t, this._onError = s.onError ?? null, this._sync = s.sync ?? !1, this._maxExecutions = s.maxExecutionsPerSecond ?? m.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = s.maxExecutionsPerFlush ?? m.MAX_EXECUTIONS_PER_EFFECT, this._cleanup = null, this._deps = new k(), this._currentEpoch = I.UNINITIALIZED, this._lastFlushEpoch = I.UNINITIALIZED, this._executionsInEpoch = 0, this._executionCount = 0, this._windowStart = 0, this._windowCount = 0, this._execId = 0, this._trackCount = 0, this._sync ? this._notifyCallback = () => this.execute() : this._notifyCallback = () => y.schedule(this), X.attachDebugInfo(this, "effect", this.id);
   }
   run() {
-    if (this.flags & _.DISPOSED)
-      throw new C(c.EFFECT_DISPOSED);
+    if (this.flags & f.DISPOSED) throw new D(l.EFFECT_DISPOSED);
     this.execute(!0);
   }
   dispose() {
-    this.flags & _.DISPOSED || (this.flags |= _.DISPOSED, this._execCleanup(), this._unsubLinks(this._links), this._links !== u && f.release(this._links), this._links = u, this._prevLinks = u);
+    this.flags & f.DISPOSED || (this.flags |= f.DISPOSED, this._execCleanup(), this._deps?.disposeAll());
   }
-  [(K = nt, Symbol.dispose)]() {
+  [Symbol.dispose]() {
     this.dispose();
   }
   addDependency(t) {
-    if (!(this.flags & _.EXECUTING)) return;
+    if (!(this.flags & f.EXECUTING)) return;
     const s = this._currentEpoch;
     if (t._lastSeenEpoch === s) return;
     t._lastSeenEpoch = s;
-    const e = this._prevLinks;
-    if (this._nextLinks === e && this._trackCount < e.length && e[this._trackCount].node === t) {
-      e[this._trackCount].version = t.version, this._trackCount++;
-      return;
-    }
-    if (this._nextLinks === e) {
-      const h = f.acquire();
-      for (let o = 0; o < this._trackCount; o++)
-        h[o] = e[o];
-      this._nextLinks = h;
-    }
-    const i = this._nextLinks;
-    let r = -1;
-    for (let h = this._trackCount; h < e.length; h++) {
-      const o = e[h];
-      if (o && o.node === t && o.unsub) {
-        r = h;
-        break;
+    const e = this._trackCount, i = this._deps;
+    let n;
+    e === 0 ? n = i._s0 : e === 1 ? n = i._s1 : e === 2 ? n = i._s2 : e === 3 ? n = i._s3 : n = i.getAt(e), n != null && n.node === t ? n.version = t.version : i.claimExisting(t, e) || this._insertNewDependency(t, e), t.flags & x.IS_COMPUTED && (i.hasComputeds = !0), this._trackCount = e + 1;
+  }
+  _insertNewDependency(t, s) {
+    let e;
+    try {
+      const i = t.subscribe(this._notifyCallback);
+      e = new H(t, t.version, i);
+    } catch (i) {
+      const n = T(i, D, l.EFFECT_EXECUTION_FAILED);
+      if (console.error(n), this._onError) try {
+        this._onError(n);
+      } catch {
       }
+      e = new H(t, t.version, void 0);
     }
-    if (r !== -1) {
-      const h = e[r];
-      h.version = t.version, i[this._trackCount] = h, e[r] = null;
-    } else
-      try {
-        const h = t.subscribe(this._notifyCallback);
-        i[this._trackCount] = new y(t, t.version, h);
-      } catch (h) {
-        const o = S(h, C, c.EFFECT_EXECUTION_FAILED);
-        if (console.error(o), this._onError)
-          try {
-            this._onError(o);
-          } catch {
-          }
-        i[this._trackCount] = new y(t, t.version, void 0);
-      }
-    this._trackCount++;
+    this._deps.insertNew(s, e);
   }
-  /**
-   * Executes effect with tracking.
-   */
   execute(t = !1) {
-    if (this.flags & (_.DISPOSED | _.EXECUTING) || !t && this._links.length > 0 && !this._isDirty()) return;
-    this._checkInfiniteLoops(), this.flags |= _.EXECUTING, this._execCleanup(), this._prevLinks = this._links, this._nextLinks = this._links, this._currentEpoch = w(), this._trackCount = 0;
-    let s = !1;
+    if (this.flags & (f.DISPOSED | f.EXECUTING)) return;
+    const s = this._deps;
+    if (!t && s.size > 0 && !this._isDirty()) return;
+    this._checkInfiniteLoops(), this.flags |= f.EXECUTING, this._execCleanup(), this._currentEpoch = Q(), this._trackCount = 0, s.prepareTracking(), this._hotIndex = -1;
+    let e = !1;
     try {
-      const e = l.run(this, this._fn);
-      if (this._nextLinks === this._prevLinks)
-        if (this._trackCount === this._prevLinks.length)
-          s = !0;
-        else {
-          for (let i = this._trackCount; i < this._prevLinks.length; i++)
-            this._prevLinks[i]?.unsub?.();
-          this._prevLinks.length = this._trackCount, s = !0;
-        }
-      else
-        this._nextLinks.length = this._trackCount, s = !0;
-      this._links = this._nextLinks, rt(e) ? this._handleAsyncResult(e) : this._cleanup = typeof e == "function" ? e : null;
-    } catch (e) {
-      if (!s)
-        if (this._nextLinks === this._prevLinks) {
-          for (let i = this._trackCount; i < this._prevLinks.length; i++)
-            this._prevLinks[i]?.unsub?.();
-          this._prevLinks.length = this._trackCount, s = !0;
-        } else
-          this._nextLinks.length = this._trackCount, s = !0;
-      this._links = this._nextLinks, this._handleExecutionError(e), this._cleanup = null;
+      const i = _.run(this, this._fn);
+      s.truncateFrom(this._trackCount), s.seal(), e = !0, ht(i) ? this._handleAsyncResult(i) : this._cleanup = typeof i == "function" ? i : null;
+    } catch (i) {
+      if (!e) try {
+        s.truncateFrom(this._trackCount);
+      } catch {
+      }
+      this._handleExecutionError(i), this._cleanup = null;
     } finally {
-      this._finalizeDependencies(s, this._prevLinks, this._nextLinks), this.flags &= -9;
+      this.flags &= ~f.EXECUTING;
     }
   }
+  _isDirty() {
+    const t = this._deps;
+    return t.hasComputeds ? this._deepDirtyCheck() : t.isDirtyFast();
+  }
   _handleAsyncResult(t) {
     const s = ++this._execId;
-    t.then(
-      (e) => {
-        if (s !== this._execId || this.flags & _.DISPOSED) {
-          if (typeof e == "function")
-            try {
-              e();
-            } catch (i) {
-              this._handleExecutionError(i, c.EFFECT_CLEANUP_FAILED);
-            }
-          return;
+    t.then((e) => {
+      if (s !== this._execId || this.flags & f.DISPOSED) {
+        if (typeof e == "function") try {
+          e();
+        } catch (i) {
+          this._handleExecutionError(i, l.EFFECT_CLEANUP_FAILED);
         }
-        typeof e == "function" && (this._cleanup = e);
-      },
-      (e) => s === this._execId && this._handleExecutionError(e)
-    );
-  }
-  _finalizeDependencies(t, s, e) {
-    this._nextLinks = null, this._prevLinks = u, t ? e !== s && s !== u && (s.forEach((i) => i?.unsub?.()), f.release(s)) : e !== s && e !== u && e && (this._unsubLinks(e), f.release(e));
-  }
-  _unsubLinks(t) {
-    t.forEach((s) => s?.unsub?.());
+        return;
+      }
+      typeof e == "function" && (this._cleanup = e);
+    }, (e) => s === this._execId && this._handleExecutionError(e));
   }
-  _isDirty() {
-    const t = this._links, s = l.current;
-    l.current = null;
+  _deepDirtyCheck() {
+    const t = _.current;
+    _.current = null;
+    const s = this._deps;
     try {
-      return t.some((e) => {
-        const i = e.node;
-        if (i.flags & W.IS_COMPUTED)
-          try {
-            i.value;
-          } catch {
-            return !0;
-          }
-        return i.version !== e.version;
-      });
+      const e = s.size;
+      for (let i = 0; i < e; i++) {
+        const n = s.getAt(i);
+        if (n == null) continue;
+        const r = n.node;
+        if (r.flags & x.IS_COMPUTED && this._tryPullComputed(r), r.version !== n.version)
+          return this._hotIndex = i, !0;
+      }
+      return !1;
     } finally {
-      l.current = s;
+      _.current = t;
+    }
+  }
+  _tryPullComputed(t) {
+    try {
+      t.value;
+    } catch {
     }
   }
   _execCleanup() {
@@ -835,73 +1021,81 @@ class kt extends J {
       try {
         this._cleanup();
       } catch (t) {
-        this._handleExecutionError(t, c.EFFECT_CLEANUP_FAILED);
+        this._handleExecutionError(t, l.EFFECT_CLEANUP_FAILED);
       }
       this._cleanup = null;
     }
   }
   _checkInfiniteLoops() {
-    const t = et();
-    this._lastFlushEpoch !== t && (this._lastFlushEpoch = t, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), ft() > d.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++;
+    const t = nt();
+    this._lastFlushEpoch !== t && (this._lastFlushEpoch = t, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), ft() > m.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++;
+  }
+  _checkFrequencyLimit() {
+    if (!Number.isFinite(this._maxExecutions)) return;
+    const t = Date.now();
+    if (t - this._windowStart >= st.EFFECT_FREQUENCY_WINDOW) {
+      this._windowStart = t, this._windowCount = 1;
+      return;
+    }
+    if (++this._windowCount > this._maxExecutions) {
+      const s = new D(l.EFFECT_FREQUENCY_LIMIT_EXCEEDED);
+      throw this.dispose(), this._handleExecutionError(s), s;
+    }
   }
   get isDisposed() {
-    return (this.flags & _.DISPOSED) !== 0;
+    return (this.flags & f.DISPOSED) !== 0;
   }
   get executionCount() {
     return this._executionCount;
   }
   get isExecuting() {
-    return (this.flags & _.EXECUTING) !== 0;
+    return (this.flags & f.EXECUTING) !== 0;
   }
   _throwInfiniteLoopError(t) {
-    const s = new C(
-      `Infinite loop detected (${t}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${z}`
-    );
+    const s = new D(`Infinite loop detected (${t}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${Y}`);
     throw this.dispose(), console.error(s), s;
   }
-  _handleExecutionError(t, s = c.EFFECT_EXECUTION_FAILED) {
-    const e = S(t, C, s);
-    if (console.error(e), this._onError)
-      try {
-        this._onError(e);
-      } catch (i) {
-        console.error(S(i, C, c.CALLBACK_ERROR_IN_ERROR_HANDLER));
-      }
+  _handleExecutionError(t, s = l.EFFECT_EXECUTION_FAILED) {
+    const e = T(t, D, s);
+    if (console.error(e), this._onError) try {
+      this._onError(e);
+    } catch (i) {
+      console.error(T(i, D, l.CALLBACK_ERROR_IN_ERROR_HANDLER));
+    }
   }
+};
+function Nt(t, s = {}) {
+  if (typeof t != "function") throw new D(l.EFFECT_MUST_BE_FUNCTION);
+  const e = new It(t, s);
+  return e.execute(), e;
 }
-function Ot(n, t = {}) {
-  if (typeof n != "function")
-    throw new C(c.EFFECT_MUST_BE_FUNCTION);
-  const s = new kt(n, t);
-  return s.execute(), s;
-}
-function yt(n) {
-  if (typeof n != "function")
-    throw new TypeError(c.BATCH_CALLBACK_MUST_BE_FUNCTION);
-  T.startBatch();
+function At(t) {
+  if (typeof t != "function") throw new TypeError(l.BATCH_CALLBACK_MUST_BE_FUNCTION);
+  y.startBatch();
   try {
-    return n();
+    return t();
   } finally {
-    T.endBatch();
+    y.endBatch();
   }
 }
 export {
-  N as AsyncState,
-  k as AtomError,
-  I as ComputedError,
-  ht as DEBUG_CONFIG,
-  B as DEBUG_RUNTIME,
-  C as EffectError,
-  d as SCHEDULER_CONFIG,
-  m as SchedulerError,
-  bt as atom,
-  yt as batch,
-  At as computed,
-  Ot as effect,
-  Tt as isAtom,
-  Nt as isComputed,
-  Lt as isEffect,
-  T as scheduler,
-  Dt as untracked
+  b as AsyncState,
+  N as AtomError,
+  S as ComputedError,
+  st as DEBUG_CONFIG,
+  X as DEBUG_RUNTIME,
+  D as EffectError,
+  m as SCHEDULER_CONFIG,
+  R as SchedulerError,
+  Dt as atom,
+  At as batch,
+  Tt as computed,
+  Nt as effect,
+  St as isAtom,
+  gt as isComputed,
+  mt as isEffect,
+  y as scheduler,
+  vt as untracked
 };
-//# sourceMappingURL=index.mjs.map
+
+//# sourceMappingURL=index.mjs.map