@but212/atom-effect 0.26.0 → 0.28.0

package/dist/index.mjs

@@ -1,12 +1,12 @@
-var y = {
+var A = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
   REJECTED: "rejected"
-}, c = {
+}, I = {
   DISPOSED: 1,
   EXECUTING: 8
-}, B = {
+}, z = {
   DISPOSED: 1,
   IS_COMPUTED: 2,
   DIRTY: 8,
@@ -21,50 +21,56 @@ var y = {
   DISPOSED: 1,
   SYNC: 8,
   NOTIFICATION_SCHEDULED: 16
-}, I = {
+}, C = {
   MAX_EXECUTIONS_PER_SECOND: 1e3,
   MAX_EXECUTIONS_PER_EFFECT: 100,
   MAX_EXECUTIONS_PER_FLUSH: 1e4,
   MAX_FLUSH_ITERATIONS: 1e3,
   MIN_FLUSH_ITERATIONS: 10,
   BATCH_QUEUE_SHRINK_THRESHOLD: 1e3
-}, tt = {
+}, et = {
   WARN_INFINITE_LOOP: !0,
   EFFECT_FREQUENCY_WINDOW: 1e3
-}, $ = {
+}, W = {
   MAX_ASYNC_RETRIES: 3,
   MAX_PROMISE_ID: Number.MAX_SAFE_INTEGER - 1
-}, p = {
+}, T = {
   UNINITIALIZED: -1,
   MIN: 1
-}, st = 1073741823, j = { VERSION_BITS: 16 }, Ct = (typeof process < "u" && process.env, !1), q = Object.freeze([]), x = class {
+}, U = 1073741823, Et = { VERSION_BITS: 16 }, Ot = (typeof process < "u" && process.env, !1), K = Object.freeze([]), X = class {
   constructor(t, s, e = void 0) {
     this.node = t, this.version = s, this.unsub = e;
   }
-}, ut = class {
+}, dt = class {
   constructor(t, s) {
     this.fn = t, this.sub = s;
   }
   notify(t, s) {
-    this.fn ? this.fn(t, s) : this.sub && this.sub.execute();
+    const e = this.fn;
+    if (e !== void 0) {
+      e(t, s);
+      return;
+    }
+    const i = this.sub;
+    i !== void 0 && i.execute();
   }
-}, T = class extends Error {
+}, N = class extends Error {
   constructor(t, s = null, e = !0) {
     super(t), this.cause = s, this.recoverable = e, this.name = "AtomError";
   }
-}, v = class extends T {
+}, S = class extends N {
   constructor(t, s = null) {
     super(t, s, !0), this.name = "ComputedError";
   }
-}, D = class extends T {
+}, v = class extends N {
   constructor(t, s = null) {
     super(t, s, !1), this.name = "EffectError";
   }
-}, R = class extends T {
+}, P = class extends N {
   constructor(t, s = null) {
     super(t, s, !1), this.name = "SchedulerError";
   }
-}, h = {
+}, _ = {
   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",
@@ -83,7 +89,7 @@ var y = {
   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"
-}, et = class {
+}, it = class {
   constructor() {
     this._s0 = null, this._s1 = null, this._s2 = null, this._s3 = null, this._count = 0, this._overflow = null, this._freeIndices = null;
   }
@@ -91,7 +97,7 @@ var y = {
     return this._count;
   }
   getAt(t) {
-    switch (t) {
+    if (t < 4) switch (t) {
       case 0:
         return this._s0;
       case 1:
@@ -100,15 +106,13 @@ var y = {
         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;
-      }
     }
+    const s = this._overflow;
+    if (s !== null) {
+      const e = s[t - 4];
+      return e === void 0 ? null : e;
+    }
+    return null;
   }
   setAt(t, s) {
     switch (t) {
@@ -124,41 +128,38 @@ var y = {
       case 3:
         this._s3 = s;
         break;
-      default: {
-        this._overflow ??= [];
-        const e = this._overflow;
-        e[t - 4] = s;
-      }
+      default:
+        this._overflow ??= [], this._overflow[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: {
+    if (t <= 3) {
+      if (t <= 0) {
         const i = this._s0;
         i != null && (this._onItemRemoved(i), this._s0 = null);
       }
-      case 1: {
+      if (t <= 1) {
         const i = this._s1;
         i != null && (this._onItemRemoved(i), this._s1 = null);
       }
-      case 2: {
+      if (t <= 2) {
         const i = this._s2;
         i != null && (this._onItemRemoved(i), this._s2 = null);
       }
-      case 3: {
+      if (t <= 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 o = i; o < n; o++) {
-        const r = e[o];
-        r != null && (this._onItemRemoved(r), e[o] = null);
+      const i = t > 4 ? t - 4 : 0, r = e.length;
+      for (let n = i; n < r; n++) {
+        const o = e[n];
+        o != null && (this._onItemRemoved(o), e[n] = null);
       }
       t <= 4 ? (e.length = 0, this._overflow = null) : e.length = t - 4;
     }
@@ -186,10 +187,11 @@ var y = {
     this._addToOverflow(t);
   }
   _addToOverflow(t) {
-    if (this._overflow === null) this._overflow = [t];
+    const s = this._overflow;
+    if (s === null) this._overflow = [t];
     else {
-      const s = this._freeIndices;
-      s !== null && s.length > 0 ? this._overflow[s.pop()] = t : this._overflow.push(t);
+      const e = this._freeIndices;
+      e !== null && e.length > 0 ? s[e.pop()] = t : s.push(t);
     }
     this._count++;
   }
@@ -204,8 +206,11 @@ var y = {
       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--, this._freeIndices === null && (this._freeIndices = []), this._freeIndices.push(e), !0;
+    for (let e = 0, i = s.length; e < i; e++) if (s[e] === t) {
+      s[e] = null, this._count--;
+      let r = this._freeIndices;
+      return r === null && (r = this._freeIndices = []), r.push(e), !0;
+    }
     return !1;
   }
   has(t) {
@@ -218,19 +223,26 @@ var y = {
     return !1;
   }
   forEach(t) {
-    if (this._count === 0) return;
-    const s = this._s0;
-    s != null && t(s);
-    const e = this._s1;
-    e != null && t(e);
-    const i = this._s2;
-    i != null && t(i);
-    const n = this._s3;
-    n != null && t(n);
-    const o = this._overflow;
-    if (o != null) for (let r = 0, u = o.length; r < u; r++) {
-      const l = o[r];
-      l != null && t(l);
+    const s = this._count;
+    if (s === 0) return;
+    let e = 0;
+    const i = this._s0;
+    if (i != null && (t(i), ++e === s))
+      return;
+    const r = this._s1;
+    if (r != null && (t(r), ++e === s))
+      return;
+    const n = this._s2;
+    if (n != null && (t(n), ++e === s))
+      return;
+    const o = this._s3;
+    if (o != null && (t(o), ++e === s))
+      return;
+    const u = this._overflow;
+    if (u != null) for (let l = 0, h = u.length; l < h; l++) {
+      const c = u[l];
+      if (c != null && (t(c), ++e === s))
+        return;
     }
   }
   forEachIndexed(t) {
@@ -238,29 +250,37 @@ var y = {
     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 o = this._s2;
-    o != null && (t(o), e++);
-    const r = this._s3;
-    if (r != null && (t(r), e++), e === s) return e;
+    if (i != null && (t(i), ++e === s))
+      return e;
+    const r = this._s1;
+    if (r != null && (t(r), ++e === s))
+      return e;
+    const n = this._s2;
+    if (n != null && (t(n), ++e === s))
+      return e;
+    const o = this._s3;
+    if (o != null && (t(o), ++e === s))
+      return e;
     const u = this._overflow;
-    if (u != null) for (let l = 0, O = u.length; l < O; l++) {
-      const Y = u[l];
-      Y != null && (t(Y), e++);
+    if (u != null) for (let l = 0, h = u.length; l < h; l++) {
+      const c = u[l];
+      if (c != null && (t(c), ++e === s))
+        return e;
     }
     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) {
-      for (; t.length > s && t[t.length - 1] === null; ) t.pop();
-      t.length > s && (t[s] = t.pop(), s++);
-    } else s++;
-    this._freeIndices = null, t.length === 0 && (this._overflow = null);
+    if (t === null) return;
+    let s = t.length;
+    if (s === 0) return;
+    let e = 0;
+    for (; e < s; ) if (t[e] === null) {
+      for (; s > e && t[s - 1] === null; )
+        t.pop(), s--;
+      s > e && (t[e] = t.pop(), s--, e++);
+    } else e++;
+    this._freeIndices = null, s === 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), this._freeIndices = null;
@@ -268,111 +288,170 @@ var y = {
   dispose() {
     this.clear();
   }
-}, W = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), lt = /* @__PURE__ */ Symbol("AtomEffect.Id"), K = /* @__PURE__ */ Symbol("AtomEffect.Type"), b = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), G = {
-  enabled: !1,
-  warnInfiniteLoop: tt.WARN_INFINITE_LOOP,
+}, Z = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), pt = /* @__PURE__ */ Symbol("AtomEffect.Id"), J = /* @__PURE__ */ Symbol("AtomEffect.Type"), M = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), Ct = class {
+  constructor() {
+    this.enabled = !1, this.warnInfiniteLoop = et.WARN_INFINITE_LOOP;
+  }
   warn(t, s) {
-  },
+  }
   attachDebugInfo(t, s, e) {
-  },
-  getDebugName: (t) => t?.[W],
-  getDebugType: (t) => t?.[K]
-}, _t = 1, ct = () => _t++;
-function g(t, s, e) {
-  if (t instanceof T) return t;
-  const i = t instanceof Error, n = i ? t.message : String(t), o = i ? t : void 0;
-  return new s(`${i ? t.constructor.name : "Unexpected error"} (${e}): ${n}`, o);
+  }
+  getDebugName(t) {
+    if (t != null)
+      return t[Z];
+  }
+  getDebugType(t) {
+    if (t != null)
+      return t[J];
+  }
+}, Q = new Ct(), It = 1, Dt = () => It++ | 0;
+function m(t, s, e) {
+  return t instanceof N ? t : t instanceof Error ? new s(`${t.name || t.constructor.name || "Error"} (${e}): ${t.message}`, t) : new s(`Unexpected error (${e}): ${String(t)}`);
 }
-var X = class {
+var Y = class {
   constructor() {
-    this.flags = 0, this.version = 0, this._lastSeenEpoch = p.UNINITIALIZED, this._notifying = 0, this._hotIndex = -1, this._slots = null, this._deps = null, this.id = ct() & st;
+    this.flags = 0, this.version = 0, this._lastSeenEpoch = T.UNINITIALIZED, this._notifying = 0, this._hotIndex = -1, this._slots = null, this._deps = null, this.id = Dt() & U;
+  }
+  get isDisposed() {
+    return (this.flags & z.DISPOSED) !== 0;
+  }
+  get isComputed() {
+    return (this.flags & z.IS_COMPUTED) !== 0;
+  }
+  get hasError() {
+    return !1;
   }
   subscribe(t) {
     const s = typeof t == "function";
-    if (!s && (!t || typeof t.execute != "function")) throw g(/* @__PURE__ */ new TypeError("Invalid subscriber"), T, h.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
+    if (!s && (!t || typeof t.execute != "function")) throw m(/* @__PURE__ */ new TypeError("Invalid subscriber"), N, _.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
     let e = this._slots;
-    e || (e = new et(), this._slots = e);
+    e || (e = new it(), this._slots = e);
     let i = !1;
-    if (e.forEach((o) => {
-      (s ? o.fn === t : o.sub === t) && (i = !0);
-    }), i)
+    if (e._s0 != null && (s ? e._s0.fn === t : e._s0.sub === t)) i = !0;
+    else if (e._s1 != null && (s ? e._s1.fn === t : e._s1.sub === t)) i = !0;
+    else if (e._s2 != null && (s ? e._s2.fn === t : e._s2.sub === t)) i = !0;
+    else if (e._s3 != null && (s ? e._s3.fn === t : e._s3.sub === t)) i = !0;
+    else {
+      const n = e._overflow;
+      if (n != null) for (let o = 0, u = n.length; o < u; o++) {
+        const l = n[o];
+        if (l != null && (s ? l.fn === t : l.sub === t)) {
+          i = !0;
+          break;
+        }
+      }
+    }
+    if (i)
       return () => {
       };
-    const n = new ut(s ? t : void 0, s ? void 0 : t);
-    return e.add(n), () => this._unsubscribe(n);
+    const r = new dt(s ? t : void 0, s ? void 0 : t);
+    return e.add(r), () => this._unsubscribe(r);
   }
   _unsubscribe(t) {
-    if (this._slots) {
-      if (this._notifying > 0) {
-        this._slots.remove(t);
-        return;
-      }
-      this._slots.remove(t), this._slots.compact();
-    }
+    const s = this._slots;
+    s && (s.remove(t), this._notifying === 0 && s.compact());
   }
   subscriberCount() {
-    return this._slots ? this._slots.size : 0;
+    const t = this._slots;
+    return t === null ? 0 : t.size;
   }
   _notifySubscribers(t, s) {
     const e = this._slots;
-    if (!(!e || e.size === 0)) {
+    if (!(e === null || e.size === 0)) {
       this._notifying++;
       try {
-        e.forEach((i) => {
-          try {
-            i.notify(t, s);
-          } catch (n) {
-            console.error(g(n, T, h.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
+        let i = e._s0;
+        if (i != null) try {
+          i.notify(t, s);
+        } catch (n) {
+          this._logNotifyError(n);
+        }
+        if (i = e._s1, i != null) try {
+          i.notify(t, s);
+        } catch (n) {
+          this._logNotifyError(n);
+        }
+        if (i = e._s2, i != null) try {
+          i.notify(t, s);
+        } catch (n) {
+          this._logNotifyError(n);
+        }
+        if (i = e._s3, i != null) try {
+          i.notify(t, s);
+        } catch (n) {
+          this._logNotifyError(n);
+        }
+        const r = e._overflow;
+        if (r != null) for (let n = 0, o = r.length; n < o; n++) {
+          const u = r[n];
+          if (u != null) try {
+            u.notify(t, s);
+          } catch (l) {
+            this._logNotifyError(l);
           }
-        });
+        }
       } finally {
-        this._notifying--, this._notifying === 0 && e.compact();
+        --this._notifying === 0 && e.compact();
       }
     }
   }
+  _logNotifyError(t) {
+    console.error(m(t, N, _.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;
+    if (t === null || t.size === 0) return !1;
+    const s = this._hotIndex;
+    if (s !== -1) {
+      const e = t.getAt(s);
+      if (e != null && e.node.version !== e.version) return !0;
     }
     return !t.hasComputeds && !t.isDirtyFast() ? !1 : this._deepDirtyCheck();
   }
-}, U = 0, k = () => (U = U + 1 & 1073741823 || 1, U), H = (t) => t + 1 & 1073741823 || 1, V = 0, F = !1, it = 0, nt = () => it;
-function Z() {
-  return F ? !1 : (F = !0, it = k(), V = 0, !0);
+}, x = 0;
+function k() {
+  const t = x + 1 & U;
+  return x = t === 0 ? 1 : t, x;
+}
+function G(t) {
+  const s = t + 1 & U;
+  return s === 0 ? 1 : s;
 }
-var J = () => {
+var V = 0, F = !1, nt = 0;
+function rt() {
+  return nt;
+}
+function tt() {
+  return F ? !1 : (F = !0, nt = k(), V = 0, !0);
+}
+function st() {
   F = !1;
-}, ft = () => {
+}
+function vt() {
   if (!F) return 0;
   const t = ++V;
-  if (t > I.MAX_EXECUTIONS_PER_FLUSH) throw new Error(`[atom-effect] Infinite loop detected: flush execution count exceeded ${I.MAX_EXECUTIONS_PER_FLUSH}`);
-  return t;
-}, w = /* @__PURE__ */ (function(t) {
-  return t[t.IDLE = 0] = "IDLE", t[t.BATCHING = 1] = "BATCHING", t[t.FLUSHING = 2] = "FLUSHING", t;
-})({}), at = class {
+  if (t <= C.MAX_EXECUTIONS_PER_FLUSH) return t;
+  throw new Error(`[atom-effect] Infinite loop detected: flush execution count exceeded ${C.MAX_EXECUTIONS_PER_FLUSH}`);
+}
+var St = 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 = I.MAX_FLUSH_ITERATIONS, this.onOverflow = null, this._boundRunLoop = this._runLoop.bind(this);
-  }
-  get phase() {
-    return this._isProcessing || this._isFlushingSync ? w.FLUSHING : this._isBatching ? w.BATCHING : w.IDLE;
+    this._queueBuffer = [[], []], this._bufferIndex = 0, this._size = 0, this._epoch = 0, this._isProcessing = !1, this._isFlushingSync = !1, this._batchDepth = 0, this._batchQueue = [], this._batchQueueSize = 0, this._maxFlushIterations = C.MAX_FLUSH_ITERATIONS, this.onOverflow = null, this._boundRunLoop = this._runLoop.bind(this);
   }
   get queueSize() {
     return this._size;
   }
   get isBatching() {
-    return this._isBatching;
+    return this._batchDepth > 0;
   }
   schedule(t) {
-    if (t._nextEpoch !== this._epoch) {
-      if (t._nextEpoch = this._epoch, this._isBatching || this._isFlushingSync) {
-        this._batchQueue[this._batchQueueSize++] = t;
-        return;
-      }
-      this._queueBuffer[this._bufferIndex][this._size++] = t, this._isProcessing || this._flush();
+    const s = this._epoch;
+    if (t._nextEpoch === s) return;
+    if (t._nextEpoch = s, this._batchDepth > 0 || this._isFlushingSync) {
+      this._batchQueue[this._batchQueueSize++] = t;
+      return;
     }
+    const e = this._bufferIndex, i = this._queueBuffer[e];
+    i[this._size++] = t, this._isProcessing || this._flush();
   }
   _flush() {
     this._isProcessing || this._size === 0 || (this._isProcessing = !0, queueMicrotask(this._boundRunLoop));
@@ -380,30 +459,31 @@ var J = () => {
   _runLoop() {
     try {
       if (this._size === 0) return;
-      const t = Z();
-      this._drainQueue(), t && J();
+      const t = tt();
+      this._drainQueue(), t && st();
     } finally {
-      this._isProcessing = !1, this._size > 0 && !this._isBatching && this._flush();
+      this._isProcessing = !1, this._size > 0 && this._batchDepth === 0 && this._flush();
     }
   }
   _flushSync() {
     this._isFlushingSync = !0;
-    const t = Z();
+    const t = tt();
     try {
       this._mergeBatchQueue(), this._drainQueue();
     } finally {
-      this._isFlushingSync = !1, t && J();
+      this._isFlushingSync = !1, t && st();
     }
   }
   _mergeBatchQueue() {
-    if (this._batchQueueSize === 0) return;
-    const t = ++this._epoch, s = this._batchQueue, e = this._queueBuffer[this._bufferIndex];
-    let i = this._size;
-    for (let n = 0; n < this._batchQueueSize; n++) {
-      const o = s[n];
-      o._nextEpoch !== t && (o._nextEpoch = t, e[i++] = o);
+    const t = this._batchQueueSize;
+    if (t === 0) return;
+    const s = ++this._epoch, e = this._batchQueue, i = this._bufferIndex, r = this._queueBuffer[i];
+    let n = this._size;
+    for (let o = 0; o < t; o++) {
+      const u = e[o];
+      u._nextEpoch !== s && (u._nextEpoch = s, r[n++] = u);
     }
-    this._size = i, this._batchQueueSize = 0, s.length = 0;
+    this._size = n, this._batchQueueSize = 0, e.length = 0;
   }
   _drainQueue() {
     let t = 0;
@@ -417,35 +497,44 @@ var J = () => {
   }
   _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 n = s[i];
-      typeof n == "function" ? n() : n.execute();
-    } catch (n) {
-      console.error(new R("Error occurred during scheduler execution", n));
+    this._bufferIndex = t ^ 1, this._size = 0, this._epoch = this._epoch + 1 | 0;
+    for (let i = 0; i < e; i++) {
+      const r = s[i];
+      try {
+        typeof r == "function" ? r() : r.execute();
+      } catch (n) {
+        console.error(new P("Error occurred during scheduler execution", n));
+      }
     }
     s.length = 0;
   }
   _handleFlushOverflow() {
-    const t = this._size + this._batchQueueSize;
-    if (console.error(new R(h.SCHEDULER_FLUSH_OVERFLOW(this._maxFlushIterations, t))), this._size = 0, this._queueBuffer[this._bufferIndex].length = 0, this._batchQueueSize = 0, this.onOverflow) try {
-      this.onOverflow(t);
+    const t = this._size + this._batchQueueSize, s = this._maxFlushIterations;
+    console.error(new P(_.SCHEDULER_FLUSH_OVERFLOW(s, t))), this._size = 0;
+    const e = this._bufferIndex;
+    this._queueBuffer[e].length = 0, this._batchQueueSize = 0;
+    const i = this.onOverflow;
+    if (i) try {
+      i(t);
     } catch {
     }
   }
   startBatch() {
-    this._batchDepth++, this._isBatching = !0;
+    this._batchDepth++;
   }
   endBatch() {
-    this._batchDepth !== 0 && --this._batchDepth === 0 && (this._flushSync(), this._isBatching = !1);
+    this._batchDepth !== 0 && --this._batchDepth === 0 && this._flushSync();
   }
   setMaxFlushIterations(t) {
-    if (t < I.MIN_FLUSH_ITERATIONS) throw new R(`Max flush iterations must be at least ${I.MIN_FLUSH_ITERATIONS}`);
+    if (t < C.MIN_FLUSH_ITERATIONS) throw new P(`Max flush iterations must be at least ${C.MIN_FLUSH_ITERATIONS}`);
     this._maxFlushIterations = t;
   }
-}, A = new at(), Q = /* @__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,
+}, w = new St(), $ = /* @__PURE__ */ Symbol.for("atom-effect/atom"), ot = /* @__PURE__ */ Symbol.for("atom-effect/computed"), ut = /* @__PURE__ */ Symbol.for("atom-effect/effect"), gt = /* @__PURE__ */ Symbol.for("atom-effect/writable"), Tt = class {
+  constructor() {
+    this.current = null;
+  }
   run(t, s) {
+    if (this.current === t) return s();
     const e = this.current;
     this.current = t;
     try {
@@ -454,53 +543,55 @@ var J = () => {
       this.current = e;
     }
   }
-};
-function Dt(t) {
-  const s = _.current;
-  if (s === null) return t();
-  _.current = null;
+}, f = new Tt();
+function Rt(t) {
+  const s = f, e = s.current;
+  if (e === null) return t();
+  s.current = null;
   try {
     return t();
   } finally {
-    _.current = s;
+    s.current = e;
   }
 }
-var dt = class extends X {
+var mt = class extends Y {
   constructor(t, s) {
-    super(), this[Q] = !0, this[Et] = !0, this._value = t, this._pendingOldValue = void 0, s && (this.flags |= a.SYNC), G.attachDebugInfo(this, "atom", this.id);
+    super(), this[$] = !0, this[gt] = !0, this._value = t, s && (this.flags |= a.SYNC), Q.attachDebugInfo(this, "atom", this.id);
+  }
+  get isNotificationScheduled() {
+    return (this.flags & a.NOTIFICATION_SCHEDULED) !== 0;
+  }
+  get isSync() {
+    return (this.flags & a.SYNC) !== 0;
   }
   get value() {
-    const t = _.current;
+    const t = f.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 = H(this.version);
-    const e = this._slots, i = this.flags;
-    if (e == null || e.size === 0 || i & a.NOTIFICATION_SCHEDULED) return;
-    this._pendingOldValue = s;
-    const n = i | a.NOTIFICATION_SCHEDULED;
-    if (this.flags = n, (n & a.SYNC) !== 0 && !A.isBatching) {
-      this._flushNotifications();
-      return;
-    }
-    A.schedule(this);
+    this._value = t, this.version = G(this.version);
+    const e = this.flags;
+    if ((e & a.NOTIFICATION_SCHEDULED) !== 0) return;
+    const i = this._slots;
+    i == null || i.size === 0 || (this._pendingOldValue = s, this.flags = e | a.NOTIFICATION_SCHEDULED, (e & a.SYNC) !== 0 && !w.isBatching ? this._flushNotifications() : w.schedule(this));
   }
   execute() {
     this._flushNotifications();
   }
   _flushNotifications() {
     const t = this.flags;
-    if (!(t & a.NOTIFICATION_SCHEDULED) || t & a.DISPOSED) return;
+    if ((t & (a.NOTIFICATION_SCHEDULED | a.DISPOSED)) !== a.NOTIFICATION_SCHEDULED) return;
     const s = this._pendingOldValue;
-    this._pendingOldValue = void 0, this.flags &= ~a.NOTIFICATION_SCHEDULED, this._notifySubscribers(this._value, s);
+    this._pendingOldValue = void 0, this.flags = t & ~a.NOTIFICATION_SCHEDULED, this._notifySubscribers(this._value, s);
   }
   peek() {
     return this._value;
   }
   dispose() {
-    this.flags & a.DISPOSED || (this._slots?.clear(), this.flags |= a.DISPOSED, this._value = void 0, this._pendingOldValue = void 0);
+    const t = this.flags;
+    (t & a.DISPOSED) === 0 && (this._slots?.clear(), this.flags = t | a.DISPOSED, this._value = void 0, this._pendingOldValue = void 0);
   }
   _deepDirtyCheck() {
     return !1;
@@ -509,12 +600,12 @@ var dt = class extends X {
     this.dispose();
   }
 };
-function vt(t, s = {}) {
-  return new dt(t, s.sync ?? !1);
+function Ft(t, s = {}) {
+  return new mt(t, s.sync ?? !1);
 }
-var z = 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;
+var lt = class extends it {
+  constructor(...t) {
+    super(...t), this._map = null, this._SCAN_THRESHOLD = 32, this.hasComputeds = !1, this._depsHash = 0;
   }
   prepareTracking() {
     this.hasComputeds = !1;
@@ -530,88 +621,101 @@ var z = class extends et {
     if (this._map !== null || i > this._SCAN_THRESHOLD) return this._claimViaMap(t, s);
     if (s < 4) switch (s) {
       case 0: {
-        const r = this._s0;
-        if (r && r.node === t && r.unsub)
-          return r.version = t.version, !0;
+        const n = this._s0;
+        if (n && n.node === t && n.unsub)
+          return n.version = t.version, !0;
       }
       case 1:
         if (e > 1) {
-          const r = this._s1;
-          if (r && r.node === t && r.unsub)
-            return r.version = t.version, s !== 1 && (this._s1 = this._s0, this._s0 = r), !0;
+          const n = this._s1;
+          if (n && n.node === t && n.unsub)
+            return n.version = t.version, s !== 1 && (this._s1 = this._s0, this._s0 = n), !0;
         }
       case 2:
         if (e > 2) {
-          const r = this._s2;
-          if (r && r.node === t && r.unsub) {
-            if (r.version = t.version, s !== 2) {
-              const u = s === 0 ? this._s0 : this._s1;
-              s === 0 ? this._s0 = r : this._s1 = r, this._s2 = u;
+          const n = this._s2;
+          if (n && n.node === t && n.unsub) {
+            if (n.version = t.version, s !== 2) {
+              const o = s === 0 ? this._s0 : this._s1;
+              s === 0 ? this._s0 = n : this._s1 = n, this._s2 = o;
             }
             return !0;
           }
         }
       case 3:
         if (e > 3) {
-          const r = this._s3;
-          if (r && r.node === t && r.unsub) {
-            if (r.version = t.version, s !== 3) {
-              let u;
-              s === 0 ? (u = this._s0, this._s0 = r) : s === 1 ? (u = this._s1, this._s1 = r) : (u = this._s2, this._s2 = r), this._s3 = u;
+          const n = this._s3;
+          if (n && n.node === t && n.unsub) {
+            if (n.version = t.version, s !== 3) {
+              let o;
+              s === 0 ? (o = this._s0, this._s0 = n) : s === 1 ? (o = this._s1, this._s1 = n) : (o = this._s2, this._s2 = n), this._s3 = o;
             }
             return !0;
           }
         }
     }
-    const n = s > 4 ? s : 4, o = this._overflow;
-    if (o) for (let r = n - 4, u = o.length; r < u; r++) {
-      const l = o[r];
-      if (l && l.node === t && l.unsub)
-        return l.version = t.version, this._swapGeneral(r + 4, s, l), !0;
+    const r = this._overflow;
+    if (r) {
+      const n = t.version, o = s > 4 ? s : 4, u = r.length;
+      for (let l = o - 4; l < u; l++) {
+        const h = r[l];
+        if (h && h.node === t && h.unsub)
+          return h.version = n, this._swapGeneral(l + 4, s, h), !0;
+      }
     }
     return !1;
   }
   _claimViaMap(t, s) {
-    if (this._map === null) {
-      this._map = /* @__PURE__ */ new Map();
+    let e = this._map;
+    if (e === null) {
+      e = 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));
+      if (s < 4) {
+        const u = this._s0;
+        s <= 0 && u?.unsub && e.set(u.node, 0);
+        const l = this._s1;
+        s <= 1 && l?.unsub && e.set(l.node, 1);
+        const h = this._s2;
+        s <= 2 && h?.unsub && e.set(h.node, 2);
+        const c = this._s3;
+        s <= 3 && c?.unsub && e.set(c.node, 3);
+      }
       const o = this._overflow;
       if (o && n > 4) {
-        const r = s > 4 ? s : 4;
-        for (let u = r - 4, l = o.length; u < l; u++) {
-          const O = o[u];
-          O?.unsub && this._map.set(O.node, u + 4);
+        const u = s > 4 ? s : 4, l = o.length;
+        for (let h = u - 4; h < l; h++) {
+          const c = o[h];
+          c?.unsub && e.set(c.node, h + 4);
         }
       }
     }
-    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);
+    const i = e.get(t);
+    if (i === void 0 || i < s) return !1;
+    const r = this.getAt(i);
+    if (r == null || !r.unsub) return !1;
+    if (r.version = t.version, i !== s) {
+      let n;
+      s === 0 ? n = this._s0 : s === 1 ? n = this._s1 : s === 2 ? n = this._s2 : s === 3 ? n = this._s3 : n = this._overflow[s - 4] ?? null, this.setAt(s, r), this.setAt(i, n), n?.unsub && e.set(n.node, i), e.set(t, s);
     }
     return !0;
   }
   _swapGeneral(t, s, e) {
     if (t === s) return;
-    const i = this.getAt(s);
-    if (this.setAt(s, e), t === 0) this._s0 = i;
+    let i;
+    if (s === 0 ? i = this._s0 : s === 1 ? i = this._s1 : s === 2 ? i = this._s2 : s === 3 ? i = this._s3 : i = this._overflow[s - 4] ?? null, 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;
+      const r = this._overflow;
+      r[t - 4] = i;
     }
   }
   insertNew(t, s) {
     const e = this._count;
     if (t < e) {
-      const i = this.getAt(t);
-      i != null && (this._addToOverflow(i), this._map !== null && i.unsub && this._map.set(i.node, this._count - 1));
+      let i;
+      t === 0 ? i = this._s0 : t === 1 ? i = this._s1 : t === 2 ? i = this._s2 : t === 3 ? i = this._s3 : i = this._overflow[t - 4] ?? null, i != null && (this._addToOverflow(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;
@@ -627,70 +731,47 @@ var z = class extends et {
     t >= this._count || (super.truncateFrom(t), this._map !== null && (this._map.clear(), this._map = null));
   }
   seal() {
-    const t = this._count;
-    if (t === 0) {
-      this._depsHash = 0;
-      return;
-    }
-    const s = j.VERSION_BITS;
-    let e = 0;
-    if (t >= 1) {
-      const i = this._s0;
-      e = e + (i.version << s) + i.node.id | 0;
-    }
-    if (t >= 2) {
-      const i = this._s1;
-      e = e + (i.version << s) + i.node.id | 0;
-    }
-    if (t >= 3) {
-      const i = this._s2;
-      e = e + (i.version << s) + i.node.id | 0;
-    }
-    if (t >= 4) {
-      const i = this._s3;
-      e = e + (i.version << s) + i.node.id | 0;
-    }
-    if (t > 4) {
-      const i = this._overflow;
-      for (let n = 0, o = i.length; n < o; n++) {
-        const r = i[n];
-        e = e + (r.version << s) + r.node.id | 0;
-      }
-    }
-    this._depsHash = e;
+    this._depsHash = this._calculateHash(!1);
   }
   isDirtyFast() {
-    const t = this._count;
-    if (t === 0) return !1;
-    const s = j.VERSION_BITS;
-    let e = 0;
-    if (t >= 1) {
-      const i = this._s0.node;
-      e = e + (i.version << s) + i.id | 0;
-    }
-    if (t >= 2) {
-      const i = this._s1.node;
-      e = e + (i.version << s) + i.id | 0;
-    }
-    if (t >= 3) {
-      const i = this._s2.node;
-      e = e + (i.version << s) + i.id | 0;
-    }
-    if (t >= 4) {
-      const i = this._s3.node;
-      e = e + (i.version << s) + i.id | 0;
+    return this._calculateHash(!0) !== this._depsHash;
+  }
+  _calculateHash(t) {
+    const s = this._count;
+    if (s === 0) return 0;
+    const e = Et.VERSION_BITS;
+    let i = 0;
+    const r = this._s0;
+    if (r != null) {
+      const n = r.node, o = t ? n.version : r.version;
+      i = i + (o << e) + n.id | 0;
+      const u = this._s1;
+      if (s > 1 && u != null) {
+        const l = u.node, h = t ? l.version : u.version;
+        i = i + (h << e) + l.id | 0;
+        const c = this._s2;
+        if (s > 2 && c != null) {
+          const q = c.node, ft = t ? q.version : c.version;
+          i = i + (ft << e) + q.id | 0;
+          const L = this._s3;
+          if (s > 3 && L != null) {
+            const j = L.node, at = t ? j.version : L.version;
+            i = i + (at << e) + j.id | 0;
+          }
+        }
+      }
     }
-    if (t > 4) {
-      const i = this._overflow;
-      for (let n = 0, o = i.length; n < o; n++) {
-        const r = i[n].node;
-        e = e + (r.version << s) + r.id | 0;
+    if (s > 4) {
+      const n = this._overflow;
+      for (let o = 0, u = n.length; o < u; o++) {
+        const l = n[o], h = l.node, c = t ? h.version : l.version;
+        i = i + (c << e) + h.id | 0;
       }
     }
-    return e !== this._depsHash;
+    return i;
   }
   disposeAll() {
-    this._count > 0 && this.truncateFrom(0), this.hasComputeds = !1, this._map !== null && (this._map.clear(), this._map = null);
+    this._count > 0 && this.truncateFrom(0), this.hasComputeds = !1;
   }
   remove(t) {
     throw new Error("remove() is strictly prohibited in DepSlotBuffer to preserve sequential cache paths.");
@@ -698,47 +779,63 @@ var z = class extends et {
   compact() {
   }
 };
-function St(t) {
-  return t !== null && typeof t == "object" && Q in t;
+function wt(t) {
+  return typeof t == "object" && t !== null && $ in t;
 }
-function gt(t) {
-  return t !== null && typeof t == "object" && rt in t;
+function Ut(t) {
+  return typeof t == "object" && t !== null && ot in t;
 }
-function Tt(t) {
-  return t !== null && typeof t == "object" && ot in t;
+function Lt(t) {
+  return typeof t == "object" && t !== null && ut in t;
 }
 function ht(t) {
-  return t !== null && typeof t == "object" && typeof t.then == "function";
+  return typeof t == "object" && t !== null && typeof t.then == "function";
 }
-var { IDLE: d, DIRTY: f, PENDING: S, RESOLVED: E, REJECTED: C, HAS_ERROR: m, RECOMPUTING: N, DISPOSED: L, IS_COMPUTED: M, FORCE_COMPUTE: P } = B, pt = class extends X {
+var { IDLE: p, DIRTY: E, PENDING: g, RESOLVED: d, REJECTED: D, HAS_ERROR: b, RECOMPUTING: y, DISPOSED: B, IS_COMPUTED: O, FORCE_COMPUTE: H } = z, Nt = class extends Y {
   constructor(t, s = {}) {
-    if (typeof t != "function") throw new v(h.COMPUTED_MUST_BE_FUNCTION);
-    if (super(), this[Q] = !0, this[rt] = !0, this._error = null, this._promiseId = 0, this._deps = new z(), this._asyncRetryCount = 0, this._lastDriftEpoch = p.UNINITIALIZED, this._trackEpoch = p.UNINITIALIZED, this._trackCount = 0, this._value = void 0, this.flags = M | f | d, this._equal = s.equal ?? Object.is, this._fn = t, this._defaultValue = "defaultValue" in s ? s.defaultValue : b, this._onError = s.onError ?? null, this._maxAsyncRetries = (s.maxAsyncRetries ?? $.MAX_ASYNC_RETRIES) & st, G.attachDebugInfo(this, "computed", this.id), s.lazy === !1) try {
+    if (typeof t != "function") throw new S(_.COMPUTED_MUST_BE_FUNCTION);
+    if (super(), this[$] = !0, this[ot] = !0, this._error = null, this._promiseId = 0, this._deps = new lt(), this._asyncRetryCount = 0, this._lastDriftEpoch = T.UNINITIALIZED, this._trackEpoch = T.UNINITIALIZED, this._trackCount = 0, this._value = void 0, this.flags = O | E | p, this._equal = s.equal ?? Object.is, this._fn = t, this._defaultValue = "defaultValue" in s ? s.defaultValue : M, this._onError = s.onError ?? null, this._maxAsyncRetries = (s.maxAsyncRetries ?? W.MAX_ASYNC_RETRIES) & U, Q.attachDebugInfo(this, "computed", this.id), s.lazy === !1) try {
       this._recompute();
     } catch {
     }
   }
+  get isDirty() {
+    return (this.flags & E) !== 0;
+  }
+  get isRejected() {
+    return (this.flags & D) !== 0;
+  }
+  get isRecomputing() {
+    return (this.flags & y) !== 0;
+  }
+  get _hasErrorInternal() {
+    return (this.flags & b) !== 0;
+  }
   _track() {
-    _.current?.addDependency(this);
+    f.current?.addDependency(this);
   }
   get value() {
-    this._track();
-    const t = this.flags;
-    if ((t & (E | f | d)) === E) return this._value;
-    if (t & L) throw new v(h.COMPUTED_DISPOSED);
-    if (t & N) {
-      if (this._defaultValue !== b) return this._defaultValue;
-      throw new v(h.COMPUTED_CIRCULAR_DEPENDENCY);
+    const t = f.current;
+    t?.addDependency(this);
+    let s = this.flags;
+    if ((s & (d | E | p)) === d) return this._value;
+    if ((s & B) !== 0) throw new S(_.COMPUTED_DISPOSED);
+    if ((s & y) !== 0) {
+      const r = this._defaultValue;
+      if (r !== M) return r;
+      throw new S(_.COMPUTED_CIRCULAR_DEPENDENCY);
     }
-    if (t & (f | d) && ((t & d) === 0 && (t & P) === 0 && this._deps.size > 0 && !this._isDirty() ? this.flags &= ~f : this._recompute(), this.flags & E))
-      return this._value;
-    const s = this._defaultValue, e = s !== b;
-    if (this.flags & S) {
-      if (e) return s;
-      throw new v(h.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    if ((s & (E | p)) !== 0) {
+      const r = this._deps;
+      if ((s & p) === 0 && (s & H) === 0 && r.size > 0 && !this._isDirty() ? s = this.flags &= ~E : (this._recompute(), s = this.flags), (s & d) !== 0) return this._value;
     }
-    if (this.flags & C) {
-      if (e) return s;
+    const e = this._defaultValue, i = e !== M;
+    if ((s & g) !== 0) {
+      if (i) return e;
+      throw new S(_.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    }
+    if ((s & D) !== 0) {
+      if (i) return e;
       throw this._error;
     }
     return this._value;
@@ -747,208 +844,232 @@ var { IDLE: d, DIRTY: f, PENDING: S, RESOLVED: E, REJECTED: C, HAS_ERROR: m, REC
     return this._value;
   }
   get state() {
-    this._track();
-    const t = this.flags;
-    return t & E ? y.RESOLVED : t & S ? y.PENDING : t & C ? y.REJECTED : y.IDLE;
+    const t = f.current;
+    t?.addDependency(this);
+    const s = this.flags;
+    return (s & d) !== 0 ? A.RESOLVED : (s & g) !== 0 ? A.PENDING : (s & D) !== 0 ? A.REJECTED : A.IDLE;
   }
   get hasError() {
-    if (this._track(), this.flags & (C | m)) 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 & m) return !0;
-    }
+    const t = f.current;
+    if (t?.addDependency(this), (this.flags & (D | b)) !== 0) return !0;
+    const s = this._deps;
+    if (!s.hasComputeds) return !1;
+    const e = s.size;
+    for (let i = 0; i < e; i++) if (s.getAt(i)?.node.hasError) return !0;
     return !1;
   }
   get isValid() {
     return !this.hasError;
   }
   get errors() {
-    this._track();
-    const t = [];
-    this._error && t.push(this._error);
-    const s = this._deps;
-    if (!s.hasComputeds) return t.length === 0 ? q : Object.freeze(t);
-    const e = s.size;
-    for (let i = 0; i < e; i++) {
-      const n = s.getAt(i);
-      if (n == null) continue;
-      const o = n.node;
-      o.flags & m && this._collectErrorsFromDep(o, t);
+    const t = f.current;
+    t?.addDependency(this);
+    const s = this._error, e = this._deps;
+    if (!e.hasComputeds)
+      return s == null ? K : Object.freeze([s]);
+    const i = [];
+    s != null && i.push(s);
+    const r = e.size;
+    for (let n = 0; n < r; n++) {
+      const o = e.getAt(n);
+      if (o == null) continue;
+      const u = o.node;
+      (u.flags & O) !== 0 && u.hasError && this._collectErrorsFromDep(u, i);
     }
-    return t.length === 0 ? q : Object.freeze(t);
+    return i.length === 0 ? K : Object.freeze(i);
   }
   _collectErrorsFromDep(t, s) {
     const e = t.errors, i = e.length;
-    for (let n = 0; n < i; n++) {
-      const o = e[n];
-      o != null && !s.includes(o) && s.push(o);
+    for (let r = 0; r < i; r++) {
+      const n = e[r];
+      n != null && !s.includes(n) && s.push(n);
     }
   }
   get lastError() {
-    return this._track(), this._error;
+    const t = f.current;
+    return t?.addDependency(this), this._error;
   }
   get isPending() {
-    return this._track(), (this.flags & S) !== 0;
+    const t = f.current;
+    return t?.addDependency(this), (this.flags & g) !== 0;
   }
   get isResolved() {
-    return this._track(), (this.flags & E) !== 0;
+    const t = f.current;
+    return t?.addDependency(this), (this.flags & d) !== 0;
   }
   invalidate() {
-    this.flags |= P, this._markDirty();
+    this.flags |= H, this._markDirty();
   }
   dispose() {
-    this.flags & L || (this._deps.disposeAll(), this._slots?.clear(), this.flags = L | f | d, this._error = null, this._value = void 0, this._hotIndex = -1);
+    (this.flags & B) === 0 && (this._deps.disposeAll(), this._slots != null && this._slots.clear(), this.flags = B | E | p, this._error = null, this._value = void 0, this._hotIndex = -1);
   }
   [Symbol.dispose]() {
     this.dispose();
   }
   addDependency(t) {
-    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 x(t, t.version, t.subscribe(this));
-      this._deps.insertNew(s, i);
+    const s = this._trackEpoch;
+    if (t._lastSeenEpoch === s) return;
+    t._lastSeenEpoch = s;
+    const e = this._trackCount++, i = this._deps, r = i.getAt(e);
+    if (r != null && r.node === t) r.version = t.version;
+    else if (!i.claimExisting(t, e)) {
+      const n = new X(t, t.version, t.subscribe(this));
+      i.insertNew(e, n);
     }
-    t.flags & M && (this._deps.hasComputeds = !0), this._trackCount = s + 1;
+    (t.flags & O) !== 0 && (i.hasComputeds = !0);
   }
   _recompute() {
-    if (this.flags & N) return;
-    this.flags = (this.flags | N) & ~P, this._trackEpoch = k(), this._trackCount = 0, this._deps.prepareTracking(), this._hotIndex = -1;
+    if (this.isRecomputing) return;
+    this.flags = (this.flags | y) & ~H, this._trackEpoch = k(), this._trackCount = 0, this._deps.prepareTracking(), this._hotIndex = -1;
     let t = !1;
     try {
-      const s = _.run(this, this._fn);
+      const s = f.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, h.COMPUTED_COMPUTATION_FAILED, !0);
+      this._handleError(s, _.COMPUTED_COMPUTATION_FAILED, !0);
     } finally {
-      this._trackEpoch = p.UNINITIALIZED, this._trackCount = 0, this.flags &= ~N;
+      this._trackEpoch = T.UNINITIALIZED, this._trackCount = 0, this.flags &= ~y;
     }
   }
   _handleAsyncComputation(t) {
-    this.flags = (this.flags | S) & ~(d | f | E | C), this._notifySubscribers(void 0, void 0), this._asyncRetryCount = 0, this._promiseId = (this._promiseId + 1) % $.MAX_PROMISE_ID;
+    this.flags = (this.flags | g) & ~(p | E | d | D), this._notifySubscribers(void 0, void 0), this._asyncRetryCount = 0, this._promiseId = (this._promiseId + 1) % W.MAX_PROMISE_ID;
     const s = this._promiseId;
     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 v(`Async drift threshold exceeded after ${this._maxAsyncRetries} retries.`), h.COMPUTED_ASYNC_COMPUTATION_FAILED);
+          const i = rt();
+          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.`), _.COMPUTED_ASYNC_COMPUTATION_FAILED);
         }
         this._finalizeResolution(e), this._notifySubscribers(e, void 0);
       }
-    }, (e) => s === this._promiseId && this._handleError(e, h.COMPUTED_ASYNC_COMPUTATION_FAILED));
+    }, (e) => s === this._promiseId && this._handleError(e, _.COMPUTED_ASYNC_COMPUTATION_FAILED));
   }
   _handleError(t, s, e = !1) {
-    const i = g(t, v, s);
-    if (!e && !(this.flags & C) && (this.version = H(this.version)), this._error = i, this.flags = this.flags & ~(d | f | S | E) | C | m, this._onError) try {
+    const i = m(t, S, s);
+    if (!e && !this.isRejected && (this.version = G(this.version)), this._error = i, this.flags = this.flags & ~(p | E | g | d) | D | b, this._onError) try {
       this._onError(i);
-    } catch (n) {
-      console.error(h.CALLBACK_ERROR_IN_ERROR_HANDLER, n);
+    } catch (r) {
+      console.error(_.CALLBACK_ERROR_IN_ERROR_HANDLER, r);
     }
     if (e) throw i;
     this._notifySubscribers(void 0, void 0);
   }
   _finalizeResolution(t) {
-    (!(this.flags & E) || !this._equal(this._value, t)) && (this.version = H(this.version)), this._value = t, this._error = null, this.flags = (this.flags | E) & ~(d | f | S | C | m);
+    const s = this.flags;
+    ((s & d) === 0 || !this._equal(this._value, t)) && (this.version = G(this.version)), this._value = t, this._error = null, this.flags = (s | d) & ~(p | E | g | D | b);
   }
   execute() {
     this._markDirty();
   }
   _markDirty() {
-    this.flags & (N | f) || (this.flags |= f, this._notifySubscribers(void 0, void 0));
+    const t = this.flags;
+    (t & (y | E)) === 0 && (this.flags = t | 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;
+    const t = this._deps, s = f.current;
+    f.current = null;
     try {
       const e = t.size;
       for (let i = 0; i < e; i++) {
-        const n = t.getAt(i);
-        if (n == null) continue;
-        const o = n.node;
-        if (o.flags & M) try {
-          o.value;
+        const r = t.getAt(i);
+        if (r == null) continue;
+        const n = r.node;
+        if ((n.flags & O) !== 0) try {
+          n.value;
         } catch {
         }
-        if (o.version !== n.version)
+        if (n.version !== r.version)
           return this._hotIndex = i, !0;
       }
       return this._hotIndex = -1, !1;
     } finally {
-      _.current = s;
+      f.current = s;
     }
   }
 };
-function mt(t, s = {}) {
-  return new pt(t, s);
+function Pt(t, s = {}) {
+  return new Nt(t, s);
 }
-var It = class extends X {
+var yt = class extends Y {
   constructor(t, s = {}) {
-    super(), this[ot] = !0, this._cleanup = null, this._deps = new z(), this._currentEpoch = p.UNINITIALIZED, this._lastFlushEpoch = p.UNINITIALIZED, this._fn = t, this._onError = s.onError ?? null, this._sync = s.sync ?? !1, this._maxExecutions = s.maxExecutionsPerSecond ?? I.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = s.maxExecutionsPerFlush ?? I.MAX_EXECUTIONS_PER_EFFECT, this._cleanup = null, this._deps = new z(), this._currentEpoch = p.UNINITIALIZED, this._lastFlushEpoch = p.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 = () => A.schedule(this), G.attachDebugInfo(this, "effect", this.id);
+    super(), this[ut] = !0, this._cleanup = null, this._deps = new lt(), this._currentEpoch = T.UNINITIALIZED, this._lastFlushEpoch = T.UNINITIALIZED, this._fn = t, this._onError = s.onError ?? null, this._sync = s.sync ?? !1, this._maxExecutions = s.maxExecutionsPerSecond ?? C.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = s.maxExecutionsPerFlush ?? C.MAX_EXECUTIONS_PER_EFFECT, 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 = () => w.schedule(this), Q.attachDebugInfo(this, "effect", this.id);
   }
   run() {
-    if (this.flags & c.DISPOSED) throw new D(h.EFFECT_DISPOSED);
+    if (this.isDisposed) throw new v(_.EFFECT_DISPOSED);
     this.execute(!0);
   }
   dispose() {
-    this.flags & c.DISPOSED || (this.flags |= c.DISPOSED, this._execCleanup(), this._deps?.disposeAll());
+    this.isDisposed || (this.flags |= I.DISPOSED, this._execCleanup(), this._deps?.disposeAll());
   }
   [Symbol.dispose]() {
     this.dispose();
   }
   addDependency(t) {
-    if (!(this.flags & c.EXECUTING)) return;
+    if ((this.flags & I.EXECUTING) === 0) return;
     const s = this._currentEpoch;
     if (t._lastSeenEpoch === s) return;
     t._lastSeenEpoch = s;
-    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 & B.IS_COMPUTED && (i.hasComputeds = !0), this._trackCount = e + 1;
+    const e = this._trackCount++, i = this._deps;
+    let r;
+    switch (e) {
+      case 0:
+        r = i._s0;
+        break;
+      case 1:
+        r = i._s1;
+        break;
+      case 2:
+        r = i._s2;
+        break;
+      case 3:
+        r = i._s3;
+        break;
+      default:
+        r = i.getAt(e);
+    }
+    r != null && r.node === t ? r.version = t.version : i.claimExisting(t, e) || this._insertNewDependency(t, e), t.isComputed && (i.hasComputeds = !0);
   }
   _insertNewDependency(t, s) {
     let e;
     try {
       const i = t.subscribe(this._notifyCallback);
-      e = new x(t, t.version, i);
+      e = new X(t, t.version, i);
     } catch (i) {
-      const n = g(i, D, h.EFFECT_EXECUTION_FAILED);
-      if (console.error(n), this._onError) try {
-        this._onError(n);
+      const r = m(i, v, _.EFFECT_EXECUTION_FAILED);
+      if (console.error(r), this._onError) try {
+        this._onError(r);
       } catch {
       }
-      e = new x(t, t.version, void 0);
+      e = new X(t, t.version, void 0);
     }
     this._deps.insertNew(s, e);
   }
   execute(t = !1) {
-    if (this.flags & (c.DISPOSED | c.EXECUTING)) return;
-    const s = this._deps;
-    if (!t && s.size > 0 && !this._isDirty()) return;
-    this._checkInfiniteLoops(), this.flags |= c.EXECUTING, this._execCleanup(), this._currentEpoch = k(), this._trackCount = 0, s.prepareTracking(), this._hotIndex = -1;
-    let e = !1;
+    const s = this.flags;
+    if ((s & (I.DISPOSED | I.EXECUTING)) !== 0) return;
+    const e = this._deps;
+    if (!t && e.size > 0 && !this._isDirty()) return;
+    this._checkInfiniteLoops(), this.flags = s | I.EXECUTING, this._execCleanup(), this._currentEpoch = k(), this._trackCount = 0, e.prepareTracking(), this._hotIndex = -1;
+    let i = !1;
     try {
-      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);
+      const r = f.run(this, this._fn);
+      e.truncateFrom(this._trackCount), e.seal(), i = !0, ht(r) ? this._handleAsyncResult(r) : this._cleanup = typeof r == "function" ? r : null;
+    } catch (r) {
+      if (!i) try {
+        e.truncateFrom(this._trackCount);
       } catch {
       }
-      this._handleExecutionError(i), this._cleanup = null;
+      this._handleExecutionError(r), this._cleanup = null;
     } finally {
-      this.flags &= ~c.EXECUTING;
+      this.flags &= ~I.EXECUTING;
     }
   }
   _isDirty() {
@@ -958,11 +1079,11 @@ var It = class extends X {
   _handleAsyncResult(t) {
     const s = ++this._execId;
     t.then((e) => {
-      if (s !== this._execId || this.flags & c.DISPOSED) {
+      if (s !== this._execId || this.isDisposed) {
         if (typeof e == "function") try {
           e();
         } catch (i) {
-          this._handleExecutionError(i, h.EFFECT_CLEANUP_FAILED);
+          this._handleExecutionError(i, _.EFFECT_CLEANUP_FAILED);
         }
         return;
       }
@@ -970,21 +1091,21 @@ var It = class extends X {
     }, (e) => s === this._execId && this._handleExecutionError(e));
   }
   _deepDirtyCheck() {
-    const t = _.current;
-    _.current = null;
+    const t = f.current;
+    f.current = null;
     const s = this._deps;
     try {
       const e = s.size;
       for (let i = 0; i < e; i++) {
-        const n = s.getAt(i);
-        if (n == null) continue;
-        const o = n.node;
-        if (o.flags & B.IS_COMPUTED && this._tryPullComputed(o), o.version !== n.version)
+        const r = s.getAt(i);
+        if (r == null) continue;
+        const n = r.node;
+        if (n.isComputed && this._tryPullComputed(n), n.version !== r.version)
           return this._hotIndex = i, !0;
       }
       return !1;
     } finally {
-      _.current = t;
+      f.current = t;
     }
   }
   _tryPullComputed(t) {
@@ -994,85 +1115,142 @@ var It = class extends X {
     }
   }
   _execCleanup() {
-    if (this._cleanup) {
+    const t = this._cleanup;
+    if (t != null) {
+      this._cleanup = null;
       try {
-        this._cleanup();
-      } catch (t) {
-        this._handleExecutionError(t, h.EFFECT_CLEANUP_FAILED);
+        t();
+      } catch (s) {
+        this._handleExecutionError(s, _.EFFECT_CLEANUP_FAILED);
       }
-      this._cleanup = null;
     }
   }
   _checkInfiniteLoops() {
-    const t = nt();
-    this._lastFlushEpoch !== t && (this._lastFlushEpoch = t, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), ft() > I.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++;
+    const t = rt();
+    this._lastFlushEpoch !== t && (this._lastFlushEpoch = t, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), vt() > C.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++;
   }
   _checkFrequencyLimit() {
     if (!Number.isFinite(this._maxExecutions)) return;
     const t = Date.now();
-    if (t - this._windowStart >= tt.EFFECT_FREQUENCY_WINDOW) {
+    if (t - this._windowStart >= et.EFFECT_FREQUENCY_WINDOW) {
       this._windowStart = t, this._windowCount = 1;
       return;
     }
     if (++this._windowCount > this._maxExecutions) {
-      const s = new D(h.EFFECT_FREQUENCY_LIMIT_EXCEEDED);
+      const s = new v(_.EFFECT_FREQUENCY_LIMIT_EXCEEDED);
       throw this.dispose(), this._handleExecutionError(s), s;
     }
   }
-  get isDisposed() {
-    return (this.flags & c.DISPOSED) !== 0;
-  }
   get executionCount() {
     return this._executionCount;
   }
   get isExecuting() {
-    return (this.flags & c.EXECUTING) !== 0;
+    return (this.flags & I.EXECUTING) !== 0;
   }
   _throwInfiniteLoopError(t) {
-    const s = new D(`Infinite loop detected (${t}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${V}`);
+    const s = new v(`Infinite loop detected (${t}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${V}`);
     throw this.dispose(), console.error(s), s;
   }
-  _handleExecutionError(t, s = h.EFFECT_EXECUTION_FAILED) {
-    const e = g(t, D, s);
+  _handleExecutionError(t, s = _.EFFECT_EXECUTION_FAILED) {
+    const e = m(t, v, s);
     if (console.error(e), this._onError) try {
       this._onError(e);
     } catch (i) {
-      console.error(g(i, D, h.CALLBACK_ERROR_IN_ERROR_HANDLER));
+      console.error(m(i, v, _.CALLBACK_ERROR_IN_ERROR_HANDLER));
     }
   }
 };
-function Nt(t, s = {}) {
-  if (typeof t != "function") throw new D(h.EFFECT_MUST_BE_FUNCTION);
-  const e = new It(t, s);
+function Mt(t, s = {}) {
+  if (typeof t != "function") throw new v(_.EFFECT_MUST_BE_FUNCTION);
+  const e = new yt(t, s);
   return e.execute(), e;
 }
-function At(t) {
-  if (typeof t != "function") throw new TypeError(h.BATCH_CALLBACK_MUST_BE_FUNCTION);
-  A.startBatch();
+var At = /* @__PURE__ */ Symbol.for("atom-effect/atom"), bt = /* @__PURE__ */ Symbol.for("atom-effect/writable");
+function ct(t, s, e, i) {
+  if (e === s.length) return i;
+  const r = s[e], n = t != null && typeof t == "object" ? t : {}, o = n[r], u = ct(o, s, e + 1, i);
+  if (Object.is(o, u)) return t;
+  if (Array.isArray(n)) {
+    const l = n.slice(), h = Number.parseInt(r, 10);
+    return Number.isNaN(h) ? l[r] = u : l[h] = u, l;
+  }
+  return {
+    ...n,
+    [r]: u
+  };
+}
+function R(t, s) {
+  let e = t;
+  const i = s.length;
+  for (let r = 0; r < i; r++) {
+    if (e == null) return;
+    e = e[s[r]];
+  }
+  return e;
+}
+function _t(t, s) {
+  const e = s.includes(".") ? s.split(".") : [s], i = /* @__PURE__ */ new Set(), r = () => {
+    i.forEach((n) => n()), i.clear();
+  };
+  return {
+    get value() {
+      return R(t.value, e);
+    },
+    set value(n) {
+      const o = t.peek(), u = ct(o, e, 0, n);
+      u !== o && (t.value = u);
+    },
+    peek: () => R(t.peek(), e),
+    subscribe(n) {
+      const o = t.subscribe((u, l) => {
+        const h = R(u, e), c = R(l, e);
+        Object.is(h, c) || n(h, c);
+      });
+      return i.add(o), () => {
+        o(), i.delete(o);
+      };
+    },
+    subscriberCount: () => i.size,
+    dispose: r,
+    [Symbol.dispose]: r,
+    [At]: !0,
+    [bt]: !0
+  };
+}
+var xt = (t, s) => _t(t, s), Bt = (t) => (s) => _t(t, s);
+function Ht(t) {
+  if (typeof t != "function") throw new TypeError(_.BATCH_CALLBACK_MUST_BE_FUNCTION);
+  const s = w;
+  s.startBatch();
   try {
     return t();
   } finally {
-    A.endBatch();
+    s.endBatch();
   }
 }
 export {
-  y as AsyncState,
-  T as AtomError,
-  v as ComputedError,
-  tt as DEBUG_CONFIG,
-  G as DEBUG_RUNTIME,
-  D as EffectError,
-  I as SCHEDULER_CONFIG,
-  R as SchedulerError,
-  vt as atom,
-  At as batch,
-  mt as computed,
-  Nt as effect,
-  St as isAtom,
-  gt as isComputed,
-  Tt as isEffect,
-  A as scheduler,
-  Dt as untracked
+  A as AsyncState,
+  N as AtomError,
+  S as ComputedError,
+  et as DEBUG_CONFIG,
+  Q as DEBUG_RUNTIME,
+  v as EffectError,
+  C as SCHEDULER_CONFIG,
+  P as SchedulerError,
+  Ft as atom,
+  _t as atomLens,
+  Ht as batch,
+  xt as composeLens,
+  Pt as computed,
+  Mt as effect,
+  R as getPathValue,
+  wt as isAtom,
+  Ut as isComputed,
+  Lt as isEffect,
+  Bt as lensFor,
+  w as scheduler,
+  ct as setDeepValue,
+  Rt as untracked
 };
 
 //# sourceMappingURL=index.mjs.map