@but212/atom-effect 0.27.0 → 0.28.0

package/dist/index.mjs

@@ -6,7 +6,7 @@ var A = {
 }, I = {
   DISPOSED: 1,
   EXECUTING: 8
-}, H = {
+}, z = {
   DISPOSED: 1,
   IS_COMPUTED: 2,
   DIRTY: 8,
@@ -28,20 +28,20 @@ var A = {
   MAX_FLUSH_ITERATIONS: 1e3,
   MIN_FLUSH_ITERATIONS: 10,
   BATCH_QUEUE_SHRINK_THRESHOLD: 1e3
-}, st = {
+}, et = {
   WARN_INFINITE_LOOP: !0,
   EFFECT_FREQUENCY_WINDOW: 1e3
-}, j = {
+}, W = {
   MAX_ASYNC_RETRIES: 3,
   MAX_PROMISE_ID: Number.MAX_SAFE_INTEGER - 1
 }, T = {
   UNINITIALIZED: -1,
   MIN: 1
-}, w = 1073741823, _t = { VERSION_BITS: 16 }, mt = (typeof process < "u" && process.env, !1), W = Object.freeze([]), z = 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;
   }
-}, ft = class {
+}, dt = class {
   constructor(t, s) {
     this.fn = t, this.sub = s;
   }
@@ -66,11 +66,11 @@ var A = {
   constructor(t, s = null) {
     super(t, s, !1), this.name = "EffectError";
   }
-}, L = class extends N {
+}, P = class extends N {
   constructor(t, s = null) {
     super(t, s, !1), this.name = "SchedulerError";
   }
-}, c = {
+}, _ = {
   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",
@@ -89,7 +89,7 @@ var A = {
   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;
   }
@@ -239,9 +239,9 @@ var A = {
     if (o != null && (t(o), ++e === s))
       return;
     const u = this._overflow;
-    if (u != null) for (let h = 0, l = u.length; h < l; h++) {
-      const f = u[h];
-      if (f != null && (t(f), ++e === s))
+    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;
     }
   }
@@ -262,9 +262,9 @@ var A = {
     if (o != null && (t(o), ++e === s))
       return e;
     const u = this._overflow;
-    if (u != null) for (let h = 0, l = u.length; h < l; h++) {
-      const f = u[h];
-      if (f != null && (t(f), ++e === s))
+    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;
@@ -288,9 +288,9 @@ var A = {
   dispose() {
     this.clear();
   }
-}, K = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), at = /* @__PURE__ */ Symbol("AtomEffect.Id"), Z = /* @__PURE__ */ Symbol("AtomEffect.Type"), P = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), Et = class {
+}, 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 = st.WARN_INFINITE_LOOP;
+    this.enabled = !1, this.warnInfiniteLoop = et.WARN_INFINITE_LOOP;
   }
   warn(t, s) {
   }
@@ -298,34 +298,34 @@ var A = {
   }
   getDebugName(t) {
     if (t != null)
-      return t[K];
+      return t[Z];
   }
   getDebugType(t) {
     if (t != null)
-      return t[Z];
+      return t[J];
   }
-}, G = new Et(), dt = 1, pt = () => dt++ | 0;
+}, 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 Q = class {
+var Y = class {
   constructor() {
-    this.flags = 0, this.version = 0, this._lastSeenEpoch = T.UNINITIALIZED, this._notifying = 0, this._hotIndex = -1, this._slots = null, this._deps = null, this.id = pt() & w;
+    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 & H.DISPOSED) !== 0;
+    return (this.flags & z.DISPOSED) !== 0;
   }
   get isComputed() {
-    return (this.flags & H.IS_COMPUTED) !== 0;
+    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 m(/* @__PURE__ */ new TypeError("Invalid subscriber"), N, c.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._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;
@@ -334,8 +334,8 @@ var Q = class {
     else {
       const n = e._overflow;
       if (n != null) for (let o = 0, u = n.length; o < u; o++) {
-        const h = n[o];
-        if (h != null && (s ? h.fn === t : h.sub === t)) {
+        const l = n[o];
+        if (l != null && (s ? l.fn === t : l.sub === t)) {
           i = !0;
           break;
         }
@@ -344,7 +344,7 @@ var Q = class {
     if (i)
       return () => {
       };
-    const r = new ft(s ? t : void 0, s ? void 0 : t);
+    const r = new dt(s ? t : void 0, s ? void 0 : t);
     return e.add(r), () => this._unsubscribe(r);
   }
   _unsubscribe(t) {
@@ -386,8 +386,8 @@ var Q = class {
           const u = r[n];
           if (u != null) try {
             u.notify(t, s);
-          } catch (h) {
-            this._logNotifyError(h);
+          } catch (l) {
+            this._logNotifyError(l);
           }
         }
       } finally {
@@ -396,7 +396,7 @@ var Q = class {
     }
   }
   _logNotifyError(t) {
-    console.error(m(t, N, c.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
+    console.error(m(t, N, _.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
   }
   _isDirty() {
     const t = this._deps;
@@ -408,32 +408,32 @@ var Q = class {
     }
     return !t.hasComputeds && !t.isDirtyFast() ? !1 : this._deepDirtyCheck();
   }
-}, M = 0;
-function Y() {
-  const t = M + 1 & w;
-  return M = t === 0 ? 1 : t, M;
+}, x = 0;
+function k() {
+  const t = x + 1 & U;
+  return x = t === 0 ? 1 : t, x;
 }
-function X(t) {
-  const s = t + 1 & w;
+function G(t) {
+  const s = t + 1 & U;
   return s === 0 ? 1 : s;
 }
-var k = 0, R = !1, it = 0;
-function nt() {
-  return it;
-}
-function J() {
-  return R ? !1 : (R = !0, it = Y(), k = 0, !0);
+var V = 0, F = !1, nt = 0;
+function rt() {
+  return nt;
 }
 function tt() {
-  R = !1;
+  return F ? !1 : (F = !0, nt = k(), V = 0, !0);
+}
+function st() {
+  F = !1;
 }
-function Ct() {
-  if (!R) return 0;
-  const t = ++k;
+function vt() {
+  if (!F) return 0;
+  const t = ++V;
   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 It = class {
+var St = class {
   constructor() {
     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);
   }
@@ -459,19 +459,19 @@ var It = class {
   _runLoop() {
     try {
       if (this._size === 0) return;
-      const t = J();
-      this._drainQueue(), t && tt();
+      const t = tt();
+      this._drainQueue(), t && st();
     } finally {
       this._isProcessing = !1, this._size > 0 && this._batchDepth === 0 && this._flush();
     }
   }
   _flushSync() {
     this._isFlushingSync = !0;
-    const t = J();
+    const t = tt();
     try {
       this._mergeBatchQueue(), this._drainQueue();
     } finally {
-      this._isFlushingSync = !1, t && tt();
+      this._isFlushingSync = !1, t && st();
     }
   }
   _mergeBatchQueue() {
@@ -503,14 +503,14 @@ var It = class {
       try {
         typeof r == "function" ? r() : r.execute();
       } catch (n) {
-        console.error(new L("Error occurred during scheduler execution", n));
+        console.error(new P("Error occurred during scheduler execution", n));
       }
     }
     s.length = 0;
   }
   _handleFlushOverflow() {
     const t = this._size + this._batchQueueSize, s = this._maxFlushIterations;
-    console.error(new L(c.SCHEDULER_FLUSH_OVERFLOW(s, t))), this._size = 0;
+    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;
@@ -526,14 +526,15 @@ var It = class {
     this._batchDepth !== 0 && --this._batchDepth === 0 && this._flushSync();
   }
   setMaxFlushIterations(t) {
-    if (t < C.MIN_FLUSH_ITERATIONS) throw new L(`Max flush iterations must be at least ${C.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;
   }
-}, F = new It(), V = /* @__PURE__ */ Symbol.for("atom-effect/atom"), rt = /* @__PURE__ */ Symbol.for("atom-effect/computed"), ot = /* @__PURE__ */ Symbol.for("atom-effect/effect"), Dt = /* @__PURE__ */ Symbol.for("atom-effect/writable"), vt = class {
+}, 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 {
@@ -542,9 +543,9 @@ var It = class {
       this.current = e;
     }
   }
-}, _ = new vt();
-function Nt(t) {
-  const s = _, e = s.current;
+}, f = new Tt();
+function Rt(t) {
+  const s = f, e = s.current;
   if (e === null) return t();
   s.current = null;
   try {
@@ -553,9 +554,9 @@ function Nt(t) {
     s.current = e;
   }
 }
-var St = class extends Q {
+var mt = class extends Y {
   constructor(t, s) {
-    super(), this[V] = !0, this[Dt] = !0, this._value = t, 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;
@@ -564,17 +565,17 @@ var St = class extends Q {
     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 = X(this.version);
+    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 && !F.isBatching ? this._flushNotifications() : F.schedule(this));
+    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();
@@ -599,10 +600,10 @@ var St = class extends Q {
     this.dispose();
   }
 };
-function yt(t, s = {}) {
-  return new St(t, s.sync ?? !1);
+function Ft(t, s = {}) {
+  return new mt(t, s.sync ?? !1);
 }
-var ut = class extends et {
+var lt = class extends it {
   constructor(...t) {
     super(...t), this._map = null, this._SCAN_THRESHOLD = 32, this.hasComputeds = !1, this._depsHash = 0;
   }
@@ -656,10 +657,10 @@ var ut = class extends et {
     const r = this._overflow;
     if (r) {
       const n = t.version, o = s > 4 ? s : 4, u = r.length;
-      for (let h = o - 4; h < u; h++) {
-        const l = r[h];
-        if (l && l.node === t && l.unsub)
-          return l.version = n, this._swapGeneral(h + 4, s, l), !0;
+      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;
@@ -672,19 +673,19 @@ var ut = class extends et {
       if (s < 4) {
         const u = this._s0;
         s <= 0 && u?.unsub && e.set(u.node, 0);
-        const h = this._s1;
-        s <= 1 && h?.unsub && e.set(h.node, 1);
-        const l = this._s2;
-        s <= 2 && l?.unsub && e.set(l.node, 2);
-        const f = this._s3;
-        s <= 3 && f?.unsub && e.set(f.node, 3);
+        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 u = s > 4 ? s : 4, h = o.length;
-        for (let l = u - 4; l < h; l++) {
-          const f = o[l];
-          f?.unsub && e.set(f.node, l + 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);
         }
       }
     }
@@ -738,7 +739,7 @@ var ut = class extends et {
   _calculateHash(t) {
     const s = this._count;
     if (s === 0) return 0;
-    const e = _t.VERSION_BITS;
+    const e = Et.VERSION_BITS;
     let i = 0;
     const r = this._s0;
     if (r != null) {
@@ -746,16 +747,16 @@ var ut = class extends et {
       i = i + (o << e) + n.id | 0;
       const u = this._s1;
       if (s > 1 && u != null) {
-        const h = u.node, l = t ? h.version : u.version;
-        i = i + (l << e) + h.id | 0;
-        const f = this._s2;
-        if (s > 2 && f != null) {
-          const $ = f.node, lt = t ? $.version : f.version;
-          i = i + (lt << e) + $.id | 0;
-          const U = this._s3;
-          if (s > 3 && U != null) {
-            const q = U.node, ct = t ? q.version : U.version;
-            i = i + (ct << e) + q.id | 0;
+        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;
           }
         }
       }
@@ -763,8 +764,8 @@ var ut = class extends et {
     if (s > 4) {
       const n = this._overflow;
       for (let o = 0, u = n.length; o < u; o++) {
-        const h = n[o], l = h.node, f = t ? l.version : h.version;
-        i = i + (f << e) + l.id | 0;
+        const l = n[o], h = l.node, c = t ? h.version : l.version;
+        i = i + (c << e) + h.id | 0;
       }
     }
     return i;
@@ -778,22 +779,22 @@ var ut = class extends et {
   compact() {
   }
 };
-function At(t) {
-  return typeof t == "object" && t !== null && V in t;
-}
-function Ot(t) {
-  return typeof t == "object" && t !== null && rt in t;
+function wt(t) {
+  return typeof t == "object" && t !== null && $ in t;
 }
-function bt(t) {
+function Ut(t) {
   return typeof t == "object" && t !== null && ot in t;
 }
+function Lt(t) {
+  return typeof t == "object" && t !== null && ut in t;
+}
 function ht(t) {
   return typeof t == "object" && t !== null && typeof t.then == "function";
 }
-var { IDLE: p, DIRTY: E, PENDING: g, RESOLVED: d, REJECTED: D, HAS_ERROR: O, RECOMPUTING: y, DISPOSED: x, IS_COMPUTED: b, FORCE_COMPUTE: B } = H, gt = class extends Q {
+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 S(c.COMPUTED_MUST_BE_FUNCTION);
-    if (super(), this[V] = !0, this[rt] = !0, this._error = null, this._promiseId = 0, this._deps = new ut(), this._asyncRetryCount = 0, this._lastDriftEpoch = T.UNINITIALIZED, this._trackEpoch = T.UNINITIALIZED, this._trackCount = 0, this._value = void 0, this.flags = b | E | p, this._equal = s.equal ?? Object.is, this._fn = t, this._defaultValue = "defaultValue" in s ? s.defaultValue : P, this._onError = s.onError ?? null, this._maxAsyncRetries = (s.maxAsyncRetries ?? j.MAX_ASYNC_RETRIES) & w, 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 {
     }
@@ -808,30 +809,30 @@ var { IDLE: p, DIRTY: E, PENDING: g, RESOLVED: d, REJECTED: D, HAS_ERROR: O, REC
     return (this.flags & y) !== 0;
   }
   get _hasErrorInternal() {
-    return (this.flags & O) !== 0;
+    return (this.flags & b) !== 0;
   }
   _track() {
-    _.current?.addDependency(this);
+    f.current?.addDependency(this);
   }
   get value() {
-    const t = _.current;
+    const t = f.current;
     t?.addDependency(this);
     let s = this.flags;
     if ((s & (d | E | p)) === d) return this._value;
-    if ((s & x) !== 0) throw new S(c.COMPUTED_DISPOSED);
+    if ((s & B) !== 0) throw new S(_.COMPUTED_DISPOSED);
     if ((s & y) !== 0) {
       const r = this._defaultValue;
-      if (r !== P) return r;
-      throw new S(c.COMPUTED_CIRCULAR_DEPENDENCY);
+      if (r !== M) return r;
+      throw new S(_.COMPUTED_CIRCULAR_DEPENDENCY);
     }
     if ((s & (E | p)) !== 0) {
       const r = this._deps;
-      if ((s & p) === 0 && (s & B) === 0 && r.size > 0 && !this._isDirty() ? s = this.flags &= ~E : (this._recompute(), s = this.flags), (s & d) !== 0) return this._value;
+      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;
     }
-    const e = this._defaultValue, i = e !== P;
+    const e = this._defaultValue, i = e !== M;
     if ((s & g) !== 0) {
       if (i) return e;
-      throw new S(c.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+      throw new S(_.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
     }
     if ((s & D) !== 0) {
       if (i) return e;
@@ -843,14 +844,14 @@ var { IDLE: p, DIRTY: E, PENDING: g, RESOLVED: d, REJECTED: D, HAS_ERROR: O, REC
     return this._value;
   }
   get state() {
-    const t = _.current;
+    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() {
-    const t = _.current;
-    if (t?.addDependency(this), (this.flags & (D | O)) !== 0) 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;
@@ -861,11 +862,11 @@ var { IDLE: p, DIRTY: E, PENDING: g, RESOLVED: d, REJECTED: D, HAS_ERROR: O, REC
     return !this.hasError;
   }
   get errors() {
-    const t = _.current;
+    const t = f.current;
     t?.addDependency(this);
     const s = this._error, e = this._deps;
     if (!e.hasComputeds)
-      return s == null ? W : Object.freeze([s]);
+      return s == null ? K : Object.freeze([s]);
     const i = [];
     s != null && i.push(s);
     const r = e.size;
@@ -873,9 +874,9 @@ var { IDLE: p, DIRTY: E, PENDING: g, RESOLVED: d, REJECTED: D, HAS_ERROR: O, REC
       const o = e.getAt(n);
       if (o == null) continue;
       const u = o.node;
-      (u.flags & b) !== 0 && u.hasError && this._collectErrorsFromDep(u, i);
+      (u.flags & O) !== 0 && u.hasError && this._collectErrorsFromDep(u, i);
     }
-    return i.length === 0 ? W : Object.freeze(i);
+    return i.length === 0 ? K : Object.freeze(i);
   }
   _collectErrorsFromDep(t, s) {
     const e = t.errors, i = e.length;
@@ -885,22 +886,22 @@ var { IDLE: p, DIRTY: E, PENDING: g, RESOLVED: d, REJECTED: D, HAS_ERROR: O, REC
     }
   }
   get lastError() {
-    const t = _.current;
+    const t = f.current;
     return t?.addDependency(this), this._error;
   }
   get isPending() {
-    const t = _.current;
+    const t = f.current;
     return t?.addDependency(this), (this.flags & g) !== 0;
   }
   get isResolved() {
-    const t = _.current;
+    const t = f.current;
     return t?.addDependency(this), (this.flags & d) !== 0;
   }
   invalidate() {
-    this.flags |= B, this._markDirty();
+    this.flags |= H, this._markDirty();
   }
   dispose() {
-    (this.flags & x) === 0 && (this._deps.disposeAll(), this._slots != null && this._slots.clear(), this.flags = x | E | p, 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();
@@ -912,54 +913,54 @@ var { IDLE: p, DIRTY: E, PENDING: g, RESOLVED: d, REJECTED: D, HAS_ERROR: O, REC
     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 z(t, t.version, t.subscribe(this));
+      const n = new X(t, t.version, t.subscribe(this));
       i.insertNew(e, n);
     }
-    (t.flags & b) !== 0 && (i.hasComputeds = !0);
+    (t.flags & O) !== 0 && (i.hasComputeds = !0);
   }
   _recompute() {
     if (this.isRecomputing) return;
-    this.flags = (this.flags | y) & ~B, this._trackEpoch = Y(), this._trackCount = 0, this._deps.prepareTracking(), this._hotIndex = -1;
+    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, c.COMPUTED_COMPUTATION_FAILED, !0);
+      this._handleError(s, _.COMPUTED_COMPUTATION_FAILED, !0);
     } finally {
       this._trackEpoch = T.UNINITIALIZED, this._trackCount = 0, this.flags &= ~y;
     }
   }
   _handleAsyncComputation(t) {
-    this.flags = (this.flags | g) & ~(p | E | d | D), this._notifySubscribers(void 0, void 0), this._asyncRetryCount = 0, this._promiseId = (this._promiseId + 1) % j.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 S(`Async drift threshold exceeded after ${this._maxAsyncRetries} retries.`), c.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, c.COMPUTED_ASYNC_COMPUTATION_FAILED));
+    }, (e) => s === this._promiseId && this._handleError(e, _.COMPUTED_ASYNC_COMPUTATION_FAILED));
   }
   _handleError(t, s, e = !1) {
     const i = m(t, S, s);
-    if (!e && !this.isRejected && (this.version = X(this.version)), this._error = i, this.flags = this.flags & ~(p | E | g | d) | D | O, this._onError) try {
+    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 (r) {
-      console.error(c.CALLBACK_ERROR_IN_ERROR_HANDLER, r);
+      console.error(_.CALLBACK_ERROR_IN_ERROR_HANDLER, r);
     }
     if (e) throw i;
     this._notifySubscribers(void 0, void 0);
   }
   _finalizeResolution(t) {
     const s = this.flags;
-    ((s & d) === 0 || !this._equal(this._value, t)) && (this.version = X(this.version)), this._value = t, this._error = null, this.flags = (s | d) & ~(p | E | g | D | O);
+    ((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();
@@ -973,15 +974,15 @@ var { IDLE: p, DIRTY: E, PENDING: g, RESOLVED: d, REJECTED: D, HAS_ERROR: O, REC
     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 r = t.getAt(i);
         if (r == null) continue;
         const n = r.node;
-        if ((n.flags & b) !== 0) try {
+        if ((n.flags & O) !== 0) try {
           n.value;
         } catch {
         }
@@ -990,19 +991,19 @@ var { IDLE: p, DIRTY: E, PENDING: g, RESOLVED: d, REJECTED: D, HAS_ERROR: O, REC
       }
       return this._hotIndex = -1, !1;
     } finally {
-      _.current = s;
+      f.current = s;
     }
   }
 };
-function Rt(t, s = {}) {
-  return new gt(t, s);
+function Pt(t, s = {}) {
+  return new Nt(t, s);
 }
-var Tt = class extends Q {
+var yt = class extends Y {
   constructor(t, s = {}) {
-    super(), this[ot] = !0, this._cleanup = null, this._deps = new ut(), 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 = () => F.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.isDisposed) throw new v(c.EFFECT_DISPOSED);
+    if (this.isDisposed) throw new v(_.EFFECT_DISPOSED);
     this.execute(!0);
   }
   dispose() {
@@ -1040,14 +1041,14 @@ var Tt = class extends Q {
     let e;
     try {
       const i = t.subscribe(this._notifyCallback);
-      e = new z(t, t.version, i);
+      e = new X(t, t.version, i);
     } catch (i) {
-      const r = m(i, v, c.EFFECT_EXECUTION_FAILED);
+      const r = m(i, v, _.EFFECT_EXECUTION_FAILED);
       if (console.error(r), this._onError) try {
         this._onError(r);
       } catch {
       }
-      e = new z(t, t.version, void 0);
+      e = new X(t, t.version, void 0);
     }
     this._deps.insertNew(s, e);
   }
@@ -1056,10 +1057,10 @@ var Tt = class extends Q {
     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 = Y(), this._trackCount = 0, e.prepareTracking(), this._hotIndex = -1;
+    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 r = _.run(this, this._fn);
+      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 {
@@ -1082,7 +1083,7 @@ var Tt = class extends Q {
         if (typeof e == "function") try {
           e();
         } catch (i) {
-          this._handleExecutionError(i, c.EFFECT_CLEANUP_FAILED);
+          this._handleExecutionError(i, _.EFFECT_CLEANUP_FAILED);
         }
         return;
       }
@@ -1090,8 +1091,8 @@ var Tt = class extends Q {
     }, (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;
@@ -1104,7 +1105,7 @@ var Tt = class extends Q {
       }
       return !1;
     } finally {
-      _.current = t;
+      f.current = t;
     }
   }
   _tryPullComputed(t) {
@@ -1120,23 +1121,23 @@ var Tt = class extends Q {
       try {
         t();
       } catch (s) {
-        this._handleExecutionError(s, c.EFFECT_CLEANUP_FAILED);
+        this._handleExecutionError(s, _.EFFECT_CLEANUP_FAILED);
       }
     }
   }
   _checkInfiniteLoops() {
-    const t = nt();
-    this._lastFlushEpoch !== t && (this._lastFlushEpoch = t, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), Ct() > C.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 >= st.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 v(c.EFFECT_FREQUENCY_LIMIT_EXCEEDED);
+      const s = new v(_.EFFECT_FREQUENCY_LIMIT_EXCEEDED);
       throw this.dispose(), this._handleExecutionError(s), s;
     }
   }
@@ -1147,26 +1148,79 @@ var Tt = class extends Q {
     return (this.flags & I.EXECUTING) !== 0;
   }
   _throwInfiniteLoopError(t) {
-    const s = new v(`Infinite loop detected (${t}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${k}`);
+    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 = c.EFFECT_EXECUTION_FAILED) {
+  _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(m(i, v, c.CALLBACK_ERROR_IN_ERROR_HANDLER));
+      console.error(m(i, v, _.CALLBACK_ERROR_IN_ERROR_HANDLER));
     }
   }
 };
-function Ft(t, s = {}) {
-  if (typeof t != "function") throw new v(c.EFFECT_MUST_BE_FUNCTION);
-  const e = new Tt(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 wt(t) {
-  if (typeof t != "function") throw new TypeError(c.BATCH_CALLBACK_MUST_BE_FUNCTION);
-  const s = F;
+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();
@@ -1178,20 +1232,25 @@ export {
   A as AsyncState,
   N as AtomError,
   S as ComputedError,
-  st as DEBUG_CONFIG,
-  G as DEBUG_RUNTIME,
+  et as DEBUG_CONFIG,
+  Q as DEBUG_RUNTIME,
   v as EffectError,
   C as SCHEDULER_CONFIG,
-  L as SchedulerError,
-  yt as atom,
-  wt as batch,
-  Rt as computed,
-  Ft as effect,
-  At as isAtom,
-  Ot as isComputed,
-  bt as isEffect,
-  F as scheduler,
-  Nt as untracked
+  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