@but212/atom-effect 0.29.0 → 0.30.0

package/dist/index.mjs

@@ -1,56 +1,118 @@
-var y = {
+var u = {
+  DISPOSED: 1,
+  IS_COMPUTED: 2,
+  DIRTY: 256,
+  RECOMPUTING: 512,
+  HAS_ERROR: 1024,
+  FORCE_COMPUTE: 2048,
+  IDLE: 65536,
+  PENDING: 131072,
+  RESOLVED: 262144,
+  REJECTED: 524288,
+  ATOM_SYNC: 16777216,
+  ATOM_NOTIFICATION_SCHEDULED: 33554432,
+  EFFECT_EXECUTING: 268435456
+}, bt = Object.freeze({
+  ASYNC_STATE: u.IDLE | u.PENDING | u.RESOLVED | u.REJECTED,
+  COMPUTED_DIRTY_MASK: u.DIRTY | u.RECOMPUTING | u.FORCE_COMPUTE
+}), U = Object.freeze({
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
   REJECTED: "rejected"
-}, I = {
-  DISPOSED: 1,
-  EXECUTING: 8
-}, B = {
-  DISPOSED: 1,
-  IS_COMPUTED: 2,
-  DIRTY: 8,
-  IDLE: 16,
-  PENDING: 32,
-  RESOLVED: 64,
-  REJECTED: 128,
-  RECOMPUTING: 256,
-  HAS_ERROR: 512,
-  FORCE_COMPUTE: 1024
-}, a = {
-  DISPOSED: 1,
-  SYNC: 8,
-  NOTIFICATION_SCHEDULED: 16
-}, C = {
+}), S = Object.freeze({
+  DISPOSED: u.DISPOSED,
+  EXECUTING: u.EFFECT_EXECUTING
+}), Q = Object.freeze({
+  DISPOSED: u.DISPOSED,
+  IS_COMPUTED: u.IS_COMPUTED,
+  DIRTY: u.DIRTY,
+  IDLE: u.IDLE,
+  PENDING: u.PENDING,
+  RESOLVED: u.RESOLVED,
+  REJECTED: u.REJECTED,
+  RECOMPUTING: u.RECOMPUTING,
+  HAS_ERROR: u.HAS_ERROR,
+  FORCE_COMPUTE: u.FORCE_COMPUTE
+}), f = Object.freeze({
+  DISPOSED: u.DISPOSED,
+  SYNC: u.ATOM_SYNC,
+  NOTIFICATION_SCHEDULED: u.ATOM_NOTIFICATION_SCHEDULED
+}), C = Object.freeze({
   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
-}, Z = {
+}), k = 1073741823, Y = Object.freeze({
   WARN_INFINITE_LOOP: !0,
-  EFFECT_FREQUENCY_WINDOW: 1e3
-}, ut = { MAX_PROMISE_ID: Number.MAX_SAFE_INTEGER - 1 }, b = {
+  EFFECT_FREQUENCY_WINDOW: 1e3,
+  LOOP_THRESHOLD: 100
+}), at = Object.freeze({ MAX_PROMISE_ID: k }), w = Object.freeze({
   UNINITIALIZED: -1,
   MIN: 1
-}, X = 1073741823, Tt = (typeof process < "u" && process.env, !1), Y = Object.freeze([]), T = class extends Error {
-  constructor(t, s = null, e = !0) {
-    super(t), this.cause = s, this.recoverable = e, this.name = "AtomError";
+}), ot = !1;
+try {
+  ot = !!(typeof globalThis < "u" && globalThis.__ATOM_DEBUG__ || typeof sessionStorage < "u" && sessionStorage.getItem("__ATOM_DEBUG__") === "true");
+} catch {
+}
+var _ = (typeof process < "u" && process.env, typeof __DEV__ < "u" && !!__DEV__ || ot), et = Object.freeze([]), g = class V extends Error {
+  constructor(e, s = null, i = !0, n) {
+    super(e), this.cause = s, this.recoverable = i, this.code = n, this.name = "AtomError", Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
+  }
+  getChain() {
+    if (this.cause === null || this.cause === void 0) return [this];
+    const e = [this], s = /* @__PURE__ */ new Set([this]);
+    let i = this.cause;
+    for (; i != null; ) {
+      const n = s.has(i);
+      if (e.push(i), n) break;
+      if (s.add(i), i instanceof V) i = i.cause;
+      else if (i instanceof Error && "cause" in i) i = i.cause;
+      else break;
+    }
+    return e;
   }
-}, m = class extends T {
-  constructor(t, s = null) {
-    super(t, s, !0), this.name = "ComputedError";
+  toJSON(e = /* @__PURE__ */ new Set()) {
+    if (e.has(this)) return {
+      name: this.name,
+      message: "[Circular Reference]",
+      recoverable: this.recoverable,
+      code: this.code
+    };
+    e.add(this);
+    let s = this.cause;
+    return this.cause instanceof V ? s = this.cause.toJSON(e) : this.cause instanceof Error && (s = {
+      name: this.cause.name,
+      message: this.cause.message,
+      stack: this.cause.stack,
+      cause: this.cause.cause
+    }), {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      recoverable: this.recoverable,
+      stack: this.stack,
+      cause: s
+    };
+  }
+  static format(e, s, i) {
+    return `${e} (${s}): ${i}`;
+  }
+}, A = class extends g {
+  constructor(...t) {
+    super(...t), this.name = "ComputedError";
   }
-}, v = class extends T {
-  constructor(t, s = null) {
-    super(t, s, !1), this.name = "EffectError";
+}, m = class extends g {
+  constructor(t, e = null, s = !1, i) {
+    super(t, e, s, i), this.name = "EffectError";
   }
-}, U = class extends T {
-  constructor(t, s = null) {
-    super(t, s, !1), this.name = "SchedulerError";
+}, L = class extends g {
+  constructor(t, e = null, s = !1, i) {
+    super(t, e, s, i), this.name = "SchedulerError";
   }
-}, c = {
+}, 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",
@@ -63,232 +125,209 @@ var y = {
   EFFECT_EXECUTION_FAILED: "Effect execution failed",
   EFFECT_CLEANUP_FAILED: "Effect cleanup failed",
   EFFECT_DISPOSED: "Attempted to run disposed effect",
-  SCHEDULER_FLUSH_OVERFLOW: (t, s) => `Maximum flush iterations (${t}) exceeded. ${s} jobs dropped. Possible infinite loop.`,
+  SCHEDULER_FLUSH_OVERFLOW: (t, e) => `Maximum flush iterations (${t}) exceeded. ${e} jobs dropped. Possible infinite loop.`,
   CALLBACK_ERROR_IN_ERROR_HANDLER: "Exception encountered in onError handler",
   EFFECT_FREQUENCY_LIMIT_EXCEEDED: "Effect executed too frequently within 1 second. Suspected infinite loop.",
   SCHEDULER_CALLBACK_MUST_BE_FUNCTION: "Scheduler callback must be a function",
   SCHEDULER_END_BATCH_WITHOUT_START: "endBatch() called without matching startBatch(). Ignoring.",
   BATCH_CALLBACK_MUST_BE_FUNCTION: "Batch callback must be a function"
 };
-function g(t, s, e) {
-  return t instanceof T ? t : t instanceof Error ? new s(`${t.name || t.constructor.name || "Error"} (${e}): ${t.message}`, t) : new s(`Unexpected error (${e}): ${String(t)}`);
+function O(t, e, s) {
+  if (t instanceof g) return new e(g.format(t.name, s, t.message), t, t.recoverable, t.code);
+  if (t instanceof Error) {
+    const i = t.name || t.constructor.name || "Error";
+    return new e(g.format(i, s, t.message), t);
+  }
+  return new e(g.format("Unexpected error", s, String(t)), t);
 }
-var q = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), lt = /* @__PURE__ */ Symbol("AtomEffect.Id"), j = /* @__PURE__ */ Symbol("AtomEffect.Type"), L = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), ht = class {
+var st = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), ft = /* @__PURE__ */ Symbol("AtomEffect.Id"), it = /* @__PURE__ */ Symbol("AtomEffect.Type"), B = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), Et = "[Atom Effect]", dt = class {
   constructor() {
-    this.enabled = !1, this.warnInfiniteLoop = Z.WARN_INFINITE_LOOP;
-  }
-  warn(t, s) {
-  }
-  attachDebugInfo(t, s, e) {
+    this.enabled = !0, this.warnInfiniteLoop = Y.WARN_INFINITE_LOOP, this._updateCounts = /* @__PURE__ */ new Map(), this._nodeRegistry = /* @__PURE__ */ new Map(), this._threshold = Y.LOOP_THRESHOLD, this._cleanupScheduled = !1, this.warn = (t, e) => {
+      this.enabled && t && console.warn(`${Et} ${e}`);
+    }, this.registerNode = (t) => {
+      this._nodeRegistry.set(t.id, new WeakRef(t));
+    }, this.attachDebugInfo = (t, e, s, i) => {
+      this.enabled && (Object.defineProperties(t, {
+        [st]: {
+          value: i ?? `${e}_${s}`,
+          configurable: !0
+        },
+        [ft]: {
+          value: s,
+          configurable: !0
+        },
+        [it]: {
+          value: e,
+          configurable: !0
+        }
+      }), this.registerNode(t));
+    }, this.trackUpdate = (t, e) => {
+      if (!this.enabled || !this.warnInfiniteLoop) return;
+      const s = this._updateCounts, i = (s.get(t) ?? 0) + 1;
+      i > this._threshold ? this.warn(!0, `Infinite loop detected for ${e ?? `dependency ${t}`}. Over ${this._threshold} updates in a single execution scope.`) : s.set(t, i), this._cleanupScheduled || (this._cleanupScheduled = !0, Promise.resolve().then(() => {
+        this._updateCounts.clear(), this._cleanupScheduled = !1;
+      }));
+    }, this.dumpGraph = () => {
+      const t = [];
+      for (const [e, s] of this._nodeRegistry) {
+        const i = s.deref();
+        i ? t.push({
+          id: e,
+          name: this.getDebugName(i),
+          type: this.getDebugType(i),
+          updateCount: this._updateCounts.get(e) ?? 0
+        }) : (this._nodeRegistry.delete(e), this._updateCounts.delete(e));
+      }
+      return t;
+    }, this.getDebugName = (t) => {
+      if (t)
+        return t[st];
+    }, this.getDebugType = (t) => {
+      if (t)
+        return t[it];
+    };
+  }
+}, pt = {
+  enabled: !1,
+  warnInfiniteLoop: !1,
+  warn: () => {
+  },
+  registerNode: () => {
+  },
+  attachDebugInfo: () => {
+  },
+  trackUpdate: () => {
+  },
+  dumpGraph: () => [],
+  getDebugName: () => {
+  },
+  getDebugType: () => {
+  }
+}, d = _ ? new dt() : pt, It = 1, Ct = () => It++ | 0, ut = class {
+  constructor() {
+    this._s0 = null, this._s1 = null, this._s2 = null, this._s3 = null, this._count = 0, this._actualCount = 0, this._overflow = null, this._freeIndices = null;
   }
-  getDebugName(t) {
-    if (t != null)
-      return t[q];
+  _rawWrite(t, e) {
+    if (t < 4) t === 0 ? this._s0 = e : t === 1 ? this._s1 = e : t === 2 ? this._s2 = e : this._s3 = e;
+    else {
+      this._overflow === null && (this._overflow = []);
+      const s = this._overflow, i = t - 4;
+      s[i] = e;
+    }
   }
-  getDebugType(t) {
-    if (t != null)
-      return t[j];
+  _rawAdd(t) {
+    if (this._s0 === null)
+      return this._s0 = t, 0;
+    if (this._s1 === null)
+      return this._s1 = t, 1;
+    if (this._s2 === null)
+      return this._s2 = t, 2;
+    if (this._s3 === null)
+      return this._s3 = t, 3;
+    this._overflow === null && (this._overflow = []);
+    const e = this._overflow, s = this._freeIndices;
+    if (s !== null && s.length > 0) {
+      const i = s.pop();
+      return e[i] = t, i + 4;
+    }
+    return e.push(t), 4 + e.length - 1;
   }
-}, G = new ht(), ct = 1, _t = () => ct++ | 0, J = class {
-  constructor() {
-    this._s0 = null, this._s1 = null, this._s2 = null, this._s3 = null, this._count = 0, this._overflow = null, this._freeIndices = null;
+  _rawSwap(t, e) {
+    if (t === e) return;
+    const s = this.getAt(t), i = this.getAt(e);
+    this._rawWrite(t, i), this._rawWrite(e, s);
   }
   get size() {
+    return this._actualCount;
+  }
+  get physicalSize() {
     return this._count;
   }
   getAt(t) {
-    if (t < 4) switch (t) {
-      case 0:
-        return this._s0;
-      case 1:
-        return this._s1;
-      case 2:
-        return this._s2;
-      case 3:
-        return this._s3;
-    }
-    const s = this._overflow;
-    if (s !== null) {
-      const e = s[t - 4];
-      return e === void 0 ? null : e;
-    }
-    return null;
+    return t < 4 ? t === 0 ? this._s0 : t === 1 ? this._s1 : t === 2 ? this._s2 : this._s3 : this._overflow?.[t - 4] ?? null;
   }
-  setAt(t, s) {
-    switch (t) {
-      case 0:
-        this._s0 = s;
-        break;
-      case 1:
-        this._s1 = s;
-        break;
-      case 2:
-        this._s2 = s;
-        break;
-      case 3:
-        this._s3 = s;
-        break;
-      default:
-        this._overflow ??= [], this._overflow[t - 4] = s;
-    }
-    t >= this._count && (this._count = t + 1);
+  setAt(t, e) {
+    const s = this.getAt(t);
+    s !== e && (this._rawWrite(t, e), s === null ? this._actualCount++ : e === null && this._actualCount--, e !== null && t >= this._count ? this._count = t + 1 : e === null && this._shrinkPhysicalSizeFrom(t));
+  }
+  _shrinkPhysicalSizeFrom(t) {
+    if (t === this._count - 1)
+      for (this._count--; this._count > 0 && this.getAt(this._count - 1) == null; ) this._count--;
   }
   truncateFrom(t) {
-    const s = this._count;
-    if (t >= s) return;
-    if (t <= 3) {
-      if (t <= 0) {
-        const i = this._s0;
-        i != null && (this._onItemRemoved(i), this._s0 = null);
-      }
-      if (t <= 1) {
-        const i = this._s1;
-        i != null && (this._onItemRemoved(i), this._s1 = null);
-      }
-      if (t <= 2) {
-        const i = this._s2;
-        i != null && (this._onItemRemoved(i), this._s2 = null);
-      }
-      if (t <= 3) {
-        const i = this._s3;
-        i != null && (this._onItemRemoved(i), this._s3 = null);
-      }
-    }
+    t <= 3 && (t <= 0 && this._s0 !== null && (this._onItemRemoved(this._s0), this._s0 = null, this._actualCount--), t <= 1 && this._s1 !== null && (this._onItemRemoved(this._s1), this._s1 = null, this._actualCount--), t <= 2 && this._s2 !== null && (this._onItemRemoved(this._s2), this._s2 = null, this._actualCount--), t <= 3 && this._s3 !== null && (this._onItemRemoved(this._s3), this._s3 = null, this._actualCount--));
     const e = this._overflow;
-    if (e !== null && s > 4) {
-      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);
+    if (e !== null) {
+      const s = t > 4 ? t - 4 : 0, i = e.length;
+      for (let n = s; n < i; n++) {
+        const r = e[n];
+        r != null && (this._onItemRemoved(r), e[n] = null, this._actualCount--);
       }
-      t <= 4 ? (e.length = 0, this._overflow = null) : e.length = t - 4;
+      t <= 4 ? this._overflow = null : e.length = t - 4;
     }
-    this._freeIndices !== null && (this._freeIndices = null), this._count = t;
+    this._count = t, this._actualCount < 0 && (this._actualCount = 0), this._freeIndices = null;
   }
   _onItemRemoved(t) {
   }
   add(t) {
-    if (this._s0 === null) {
-      this._s0 = t, this._count++;
-      return;
-    }
-    if (this._s1 === null) {
-      this._s1 = t, this._count++;
-      return;
-    }
-    if (this._s2 === null) {
-      this._s2 = t, this._count++;
-      return;
-    }
-    if (this._s3 === null) {
-      this._s3 = t, this._count++;
-      return;
-    }
-    this._addToOverflow(t);
-  }
-  _addToOverflow(t) {
-    const s = this._overflow;
-    if (s === null) this._overflow = [t];
-    else {
-      const e = this._freeIndices;
-      e !== null && e.length > 0 ? s[e.pop()] = t : s.push(t);
-    }
-    this._count++;
+    const e = this._rawAdd(t);
+    return e >= this._count && (this._count = e + 1), this._actualCount++, e;
   }
   remove(t) {
-    if (this._s0 === t)
-      return this._s0 = null, this._count--, !0;
-    if (this._s1 === t)
-      return this._s1 = null, this._count--, !0;
-    if (this._s2 === t)
-      return this._s2 = null, this._count--, !0;
-    if (this._s3 === t)
-      return this._s3 = null, this._count--, !0;
-    const s = this._overflow;
-    if (s == null) return !1;
-    for (let e = 0, i = s.length; e < i; e++) if (s[e] === t) {
-      s[e] = null, this._count--;
-      let r = this._freeIndices;
-      return r === null && (r = this._freeIndices = []), r.push(e), !0;
+    let e = -1;
+    if (this._s0 === t) e = 0;
+    else if (this._s1 === t) e = 1;
+    else if (this._s2 === t) e = 2;
+    else if (this._s3 === t) e = 3;
+    else {
+      const s = this._overflow;
+      s !== null && (e = s.indexOf(t), e !== -1 && (e += 4));
     }
-    return !1;
+    return e !== -1 ? (this._rawWrite(e, null), this._shrinkPhysicalSizeFrom(e), this._actualCount--, e >= 4 && (this._freeIndices === null && (this._freeIndices = []), this._freeIndices.push(e - 4)), !0) : !1;
   }
   has(t) {
-    if (this._count === 0) return !1;
+    if (this._actualCount === 0) return !1;
     if (this._s0 === t || this._s1 === t || this._s2 === t || this._s3 === t) return !0;
-    const s = this._overflow;
-    if (s != null) {
-      for (let e = 0, i = s.length; e < i; e++) if (s[e] === t) return !0;
-    }
-    return !1;
+    const e = this._overflow;
+    return e !== null ? e.indexOf(t) !== -1 : !1;
   }
   forEach(t) {
-    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))
+    const e = this._actualCount;
+    if (e === 0) return;
+    if (e === this._count) {
+      this._s0 != null && t(this._s0), this._s1 != null && t(this._s1), this._s2 != null && t(this._s2), this._s3 != null && t(this._s3);
+      const n = this._overflow;
+      if (n !== null) for (let r = 0, o = n.length; r < o; r++) {
+        const c = n[r];
+        c != null && t(c);
+      }
       return;
-    const u = this._overflow;
-    if (u != null) for (let l = 0, h = u.length; l < h; l++) {
-      const f = u[l];
-      if (f != null && (t(f), ++e === s))
-        return;
     }
-  }
-  forEachIndexed(t) {
-    const s = this._count;
-    if (s === 0) return 0;
-    let e = 0;
-    const i = this._s0;
-    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, h = u.length; l < h; l++) {
-      const f = u[l];
-      if (f != null && (t(f), ++e === s))
-        return e;
+    let s = 0;
+    const i = this._count;
+    for (let n = 0; n < i; n++) {
+      const r = this.getAt(n);
+      if (r != null && (t(r), ++s >= e))
+        break;
     }
-    return e;
   }
   compact() {
-    const t = this._overflow;
-    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);
+    if (this._actualCount === this._count) return;
+    let t = 0;
+    const e = this._count;
+    for (let s = 0; s < e; s++) {
+      const i = this.getAt(s);
+      i != null && (s !== t && (this._rawWrite(t, i), this._rawWrite(s, null)), t++);
+    }
+    this._count = this._actualCount, this._overflow !== null && (t <= 4 ? this._overflow = null : this._overflow.length = t - 4), this._freeIndices = 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;
+    this._s0 = this._s1 = this._s2 = this._s3 = null, this._count = 0, this._actualCount = 0, this._overflow = null, this._freeIndices = null;
   }
   dispose() {
     this.clear();
   }
-}, tt = class extends J {
+}, ht = class extends ut {
   constructor(...t) {
     super(...t), this._map = null, this._SCAN_THRESHOLD = 32, this.hasComputeds = !1;
   }
@@ -296,383 +335,348 @@ var q = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), lt = /* @__PURE__ */ Sym
     this.hasComputeds = !1;
   }
   _onItemRemoved(t) {
-    const s = t.unsub;
-    s && s();
+    t.unsub?.();
   }
-  claimExisting(t, s) {
-    const e = this._count;
-    if (s >= e) return !1;
-    const i = e - s;
-    if (this._map !== null || i > this._SCAN_THRESHOLD) return this._claimViaMap(t, s);
-    if (s < 4) switch (s) {
-      case 0: {
-        const n = this._s0;
-        if (n && n.node === t && n.unsub)
-          return n.version = t.version, !0;
-      }
-      case 1:
-        if (e > 1) {
-          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 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 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 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;
-      }
+  setAt(t, e) {
+    const s = this.getAt(t);
+    super.setAt(t, e), this._map !== null && (s?.unsub && this._map.delete(s.node), e?.unsub && this._map.set(e.node, t));
+  }
+  claimExisting(t, e) {
+    const s = this._count;
+    if (s <= e) return !1;
+    const i = this.getAt(e);
+    if (i && i.node === t && i.unsub)
+      return i.version = t.version, !0;
+    if (this._map !== null || s - e > this._SCAN_THRESHOLD) return this._claimViaMap(t, e);
+    for (let n = e + 1; n < s; n++) {
+      const r = this.getAt(n);
+      if (r && r.node === t && r.unsub)
+        return r.version = t.version, this._rawSwap(n, e), !0;
     }
     return !1;
   }
-  _claimViaMap(t, s) {
-    let e = this._map;
-    if (e === null) {
-      e = this._map = /* @__PURE__ */ new Map();
-      const n = this._count;
-      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 f = this._s3;
-        s <= 3 && f?.unsub && e.set(f.node, 3);
-      }
-      const o = this._overflow;
-      if (o && n > 4) {
-        const u = s > 4 ? s : 4, l = o.length;
-        for (let h = u - 4; h < l; h++) {
-          const f = o[h];
-          f?.unsub && e.set(f.node, h + 4);
-        }
-      }
-    }
-    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);
+  _claimViaMap(t, e) {
+    this._map === null && (this._map = this._initMap());
+    const s = this._map, i = s.get(t);
+    if (i === void 0 || i < e) return !1;
+    const n = this.getAt(i);
+    if (n == null || !n.unsub) return !1;
+    if (n.version = t.version, i !== e) {
+      const r = this.getAt(e);
+      this._rawSwap(i, e), s.set(t, e), r?.unsub && s.set(r.node, i);
     }
     return !0;
   }
-  _swapGeneral(t, s, e) {
-    if (t === s) return;
-    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 r = this._overflow;
-      r[t - 4] = i;
+  _initMap() {
+    const t = /* @__PURE__ */ new Map();
+    for (let e = 0; e < this._count; e++) {
+      const s = this.getAt(e);
+      s?.unsub && t.set(s.node, e);
     }
+    return t;
   }
-  insertNew(t, s) {
-    const e = this._count;
-    if (t < e) {
-      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;
-    else if (t === 2) this._s2 = s;
-    else if (t === 3) this._s3 = s;
-    else {
-      let i = this._overflow;
-      i || (i = [], this._overflow = i), i[t - 4] = s;
+  insertNew(t, e) {
+    const s = this.getAt(t);
+    if (s !== null) {
+      const i = this._rawAdd(s);
+      i >= this._count && (this._count = i + 1), this._map !== null && s.unsub && this._map.set(s.node, i);
     }
-    t >= e && (this._count = t + 1);
-  }
-  truncateFrom(t) {
-    t >= this._count || (super.truncateFrom(t), this._map !== null && (this._map.clear(), this._map = null));
+    this._rawWrite(t, e), t >= this._count && (this._count = t + 1), this._actualCount++, this._map !== null && e.unsub && this._map.set(e.node, t);
   }
-  disposeAll() {
-    this._count > 0 && this.truncateFrom(0), this.hasComputeds = !1;
+  add(t) {
+    const e = super.add(t);
+    return this._map !== null && t.unsub && this._map.set(t.node, e), e;
   }
   remove(t) {
-    throw new Error("remove() is strictly prohibited in DepSlotBuffer to preserve sequential cache paths.");
+    throw new Error("remove() prohibited");
   }
   compact() {
   }
-}, z = class {
-  constructor(t, s, e = void 0) {
-    this.node = t, this.version = s, this.unsub = e;
-  }
-}, ft = class {
-  constructor(t, s) {
-    this.fn = t, this.sub = s;
+  truncateFrom(t) {
+    super.truncateFrom(t), this._map !== null && (this._map = null);
   }
-  notify(t, s) {
-    const e = this.fn;
-    if (e !== void 0) {
-      e(t, s);
-      return;
-    }
-    const i = this.sub;
-    i !== void 0 && i.execute();
+  disposeAll() {
+    this.truncateFrom(0), this.hasComputeds = !1;
   }
-}, at = class {
+}, F = /* @__PURE__ */ Symbol.for("atom-effect/brand"), p = {
+  Atom: 1,
+  Writable: 2,
+  Computed: 4,
+  Effect: 8
+};
+function q(t, e) {
+  if (!t) return !1;
+  const s = typeof t;
+  return (s === "object" || s === "function") && !!((t[F] ?? 0) & e);
+}
+function At(t) {
+  return q(t, p.Atom);
+}
+function yt(t) {
+  return q(t, p.Computed);
+}
+function Rt(t) {
+  return q(t, p.Effect);
+}
+function $(t) {
+  if (t instanceof Promise) return !0;
+  if (!t) return !1;
+  const e = typeof t;
+  return (e === "object" || e === "function") && typeof t.then == "function";
+}
+var j = class {
+  constructor(t, e, s = void 0) {
+    this.node = t, this.version = e, this.unsub = s;
+  }
+}, gt = class {
+  constructor(t = void 0, e = void 0) {
+    this.fn = t, this.sub = e;
+  }
+  notify(t, e) {
+    M(() => {
+      const s = this.fn;
+      s !== void 0 && s(t, e);
+      const i = this.sub;
+      i !== void 0 && i.execute();
+    });
+  }
+}, Dt = class {
   constructor() {
     this.current = null;
   }
-  run(t, s) {
-    if (this.current === t) return s();
-    const e = this.current;
+  run(t, e) {
+    if (this.current === t) return e();
+    const s = this.current;
     this.current = t;
     try {
-      return s();
+      const i = e();
+      return _ && d.warn($(i), 'Detected Promise returned within tracking context. Dependencies accessed after "await" will NOT be tracked. Consider using synchronous tracking before the async boundary.'), i;
     } finally {
-      this.current = e;
+      this.current = s;
     }
   }
-}, _ = new at();
-function mt(t) {
-  const s = _, e = s.current;
-  if (e === null) return t();
-  s.current = null;
+}, l = new Dt();
+function M(t) {
+  const e = l, s = e.current;
+  if (s === null) return t();
+  e.current = null;
   try {
     return t();
   } finally {
-    s.current = e;
+    e.current = s;
   }
 }
-var Q = class {
+var K = class {
   constructor() {
-    this.flags = 0, this.version = 0, this._lastSeenEpoch = b.UNINITIALIZED, this._notifying = 0, this._hotIndex = -1, this._slots = null, this._deps = null, this.id = _t() & X;
+    this.flags = 0, this.version = 0, this._lastSeenEpoch = w.UNINITIALIZED, this._nextEpoch = void 0, this._notifying = 0, this._hotIndex = -1, this._slots = null, this._deps = null, this.id = Ct() & k;
   }
   get isDisposed() {
-    return (this.flags & B.DISPOSED) !== 0;
+    return (this.flags & Q.DISPOSED) !== 0;
   }
   get isComputed() {
-    return (this.flags & B.IS_COMPUTED) !== 0;
+    return (this.flags & Q.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, c.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
-    let e = this._slots;
-    e || (e = new J(), this._slots = e);
+    const e = typeof t == "function";
+    if (!e && (!t || typeof t.execute != "function")) throw O(/* @__PURE__ */ new TypeError("Invalid subscriber"), g, h.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
+    let s = this._slots;
+    s || (s = new ut(), this._slots = s);
     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;
-    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;
+    if (s._s0 != null && (e ? s._s0.fn === t : s._s0.sub === t)) i = !0;
+    else if (s._s1 != null && (e ? s._s1.fn === t : s._s1.sub === t)) i = !0;
+    else if (s._s2 != null && (e ? s._s2.fn === t : s._s2.sub === t)) i = !0;
+    else if (s._s3 != null && (e ? s._s3.fn === t : s._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)) {
+      const r = s._overflow;
+      if (r != null) for (let o = 0, c = r.length; o < c; o++) {
+        const a = r[o];
+        if (a != null && (e ? a.fn === t : a.sub === t)) {
           i = !0;
           break;
         }
       }
     }
     if (i)
-      return () => {
+      return _ && console.warn(`[atom-effect] Duplicate subscription ignored on node ${this.id}`), () => {
       };
-    const r = new ft(s ? t : void 0, s ? void 0 : t);
-    return e.add(r), () => this._unsubscribe(r);
+    const n = new gt(e ? t : void 0, e ? void 0 : t);
+    return s.add(n), () => this._unsubscribe(n);
   }
   _unsubscribe(t) {
-    const s = this._slots;
-    s && (s.remove(t), this._notifying === 0 && s.compact());
+    const e = this._slots;
+    e && (e.remove(t), this._notifying === 0 && e.compact());
   }
   subscriberCount() {
     const t = this._slots;
     return t === null ? 0 : t.size;
   }
-  _notifySubscribers(t, s) {
-    const e = this._slots;
-    if (!(e === null || e.size === 0)) {
+  _notifySubscribers(t, e) {
+    const s = this._slots;
+    if (!(s === null || s.size === 0)) {
       this._notifying++;
       try {
-        let i = e._s0;
+        let i = s._s0;
         if (i != null) try {
-          i.notify(t, s);
-        } catch (n) {
-          this._logNotifyError(n);
+          i.notify(t, e);
+        } catch (r) {
+          this._logNotifyError(r);
         }
-        if (i = e._s1, i != null) try {
-          i.notify(t, s);
-        } catch (n) {
-          this._logNotifyError(n);
+        if (i = s._s1, i != null) try {
+          i.notify(t, e);
+        } catch (r) {
+          this._logNotifyError(r);
         }
-        if (i = e._s2, i != null) try {
-          i.notify(t, s);
-        } catch (n) {
-          this._logNotifyError(n);
+        if (i = s._s2, i != null) try {
+          i.notify(t, e);
+        } catch (r) {
+          this._logNotifyError(r);
         }
-        if (i = e._s3, i != null) try {
-          i.notify(t, s);
-        } catch (n) {
-          this._logNotifyError(n);
+        if (i = s._s3, i != null) try {
+          i.notify(t, e);
+        } catch (r) {
+          this._logNotifyError(r);
         }
-        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);
+        const n = s._overflow;
+        if (n != null) for (let r = 0, o = n.length; r < o; r++) {
+          const c = n[r];
+          if (c != null) try {
+            c.notify(t, e);
+          } catch (a) {
+            this._logNotifyError(a);
           }
         }
       } finally {
-        --this._notifying === 0 && e.compact();
+        --this._notifying === 0 && s.compact();
       }
     }
   }
   _logNotifyError(t) {
-    console.error(g(t, T, c.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
+    console.error(O(t, g, h.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
   }
   _isDirty() {
     const t = this._deps;
     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;
+    const e = this._hotIndex;
+    if (e !== -1) {
+      const s = t.getAt(e);
+      if (s != null && s.node.version !== s.version) return !0;
     }
     return this._deepDirtyCheck();
   }
-}, $ = /* @__PURE__ */ Symbol.for("atom-effect/atom"), st = /* @__PURE__ */ Symbol.for("atom-effect/computed"), et = /* @__PURE__ */ Symbol.for("atom-effect/effect"), Et = /* @__PURE__ */ Symbol.for("atom-effect/writable"), P = 0;
-function k() {
-  const t = P + 1 & X;
-  return P = t === 0 ? 1 : t, P;
+}, H = 0;
+function J() {
+  const t = H + 1 & k;
+  return H = t === 0 ? 1 : t, H;
 }
-function H(t) {
-  const s = t + 1 & X;
-  return s === 0 ? 1 : s;
+function W(t) {
+  const e = t + 1 & k;
+  return e === 0 ? 1 : e;
 }
-var V = 0, R = !1, it = 0;
-function dt() {
-  return it;
+var Z = 0, z = !1, ct = 0;
+function St() {
+  return ct;
 }
-function W() {
-  return R ? !1 : (R = !0, it = k(), V = 0, !0);
+function nt() {
+  return z ? (_ && console.warn("startFlush() called during flush - ignored"), !1) : (z = !0, ct = J(), Z = 0, !0);
 }
-function K() {
-  R = !1;
+function rt() {
+  z = !1;
 }
-function pt() {
-  if (!R) return 0;
-  const t = ++V;
+function Tt() {
+  if (!z) return 0;
+  const t = ++Z;
   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 Ct = class {
+var mt = 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);
   }
   get queueSize() {
-    return this._size;
+    return this._size + this._batchQueueSize;
   }
   get isBatching() {
     return this._batchDepth > 0;
   }
   schedule(t) {
-    const s = this._epoch;
-    if (t._nextEpoch === s) return;
-    if (t._nextEpoch = s, this._batchDepth > 0 || this._isFlushingSync) {
+    if (_ && typeof t != "function" && (!t || typeof t.execute != "function"))
+      throw new L(h.SCHEDULER_CALLBACK_MUST_BE_FUNCTION);
+    const e = this._epoch;
+    if (t._nextEpoch === e) return;
+    if (t._nextEpoch = e, 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();
+    const s = this._queueBuffer[this._bufferIndex];
+    s[this._size++] = t, this._isProcessing || this._flush();
   }
   _flush() {
     this._isProcessing || this._size === 0 || (this._isProcessing = !0, queueMicrotask(this._boundRunLoop));
   }
   _runLoop() {
     try {
-      if (this._size === 0) return;
-      const t = W();
-      this._drainQueue(), t && K();
+      if (this._size === 0 && this._batchQueueSize === 0) return;
+      const t = nt();
+      this._drainQueue(), t && rt();
     } finally {
-      this._isProcessing = !1, this._size > 0 && this._batchDepth === 0 && this._flush();
+      this._isProcessing = !1;
     }
   }
   _flushSync() {
+    if (this._size === 0 && this._batchQueueSize === 0) return;
+    const t = this._isFlushingSync;
     this._isFlushingSync = !0;
-    const t = W();
+    const e = nt();
     try {
       this._mergeBatchQueue(), this._drainQueue();
     } finally {
-      this._isFlushingSync = !1, t && K();
+      this._isFlushingSync = t, e && rt();
     }
   }
   _mergeBatchQueue() {
     const t = this._batchQueueSize;
     if (t === 0) return;
-    const s = ++this._epoch, e = this._batchQueue, i = this._bufferIndex, r = this._queueBuffer[i];
+    this._epoch = this._epoch + 1 | 0;
+    const e = this._epoch, s = this._batchQueue, i = this._queueBuffer[this._bufferIndex];
     let n = this._size;
-    for (let o = 0; o < t; o++) {
-      const u = e[o];
-      u._nextEpoch !== s && (u._nextEpoch = s, r[n++] = u);
+    for (let r = 0; r < t; r++) {
+      const o = s[r];
+      o._nextEpoch !== e && (o._nextEpoch = e, i[n++] = o), s[r] = void 0;
     }
-    this._size = n, this._batchQueueSize = 0, e.length = 0;
+    this._size = n, this._batchQueueSize = 0, s.length > C.BATCH_QUEUE_SHRINK_THRESHOLD && (s.length = 0);
   }
   _drainQueue() {
     let t = 0;
-    for (; this._size > 0; ) {
+    for (; this._size > 0 || this._batchQueueSize > 0; ) {
       if (++t > this._maxFlushIterations) {
         this._handleFlushOverflow();
         return;
       }
-      this._processQueue(), this._mergeBatchQueue();
+      this._batchQueueSize > 0 && this._mergeBatchQueue(), this._size > 0 && this._processQueue();
     }
   }
   _processQueue() {
-    const t = this._bufferIndex, s = this._queueBuffer[t], e = this._size;
+    const t = this._bufferIndex, e = this._queueBuffer[t], s = this._size;
     this._bufferIndex = t ^ 1, this._size = 0, this._epoch = this._epoch + 1 | 0;
-    for (let i = 0; i < e; i++) {
-      const r = s[i];
+    for (let i = 0; i < s; i++) {
+      const n = e[i];
+      e[i] = void 0;
       try {
-        typeof r == "function" ? r() : r.execute();
-      } catch (n) {
-        console.error(new U("Error occurred during scheduler execution", n));
+        typeof n == "function" ? n() : n.execute();
+      } catch (r) {
+        console.error(new L("Error occurred during scheduler execution", r));
       }
     }
-    s.length = 0;
   }
   _handleFlushOverflow() {
-    const t = this._size + this._batchQueueSize, s = this._maxFlushIterations;
-    console.error(new U(c.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);
+    const t = this._size + this._batchQueueSize;
+    console.error(new L(h.SCHEDULER_FLUSH_OVERFLOW(this._maxFlushIterations, t))), this._size = 0, this._queueBuffer[0].length = 0, this._queueBuffer[1].length = 0, this._batchQueueSize = 0, this._batchQueue.length = 0;
+    const e = this.onOverflow;
+    if (e) try {
+      e(t);
     } catch {
     }
   }
@@ -680,61 +684,62 @@ var Ct = class {
     this._batchDepth++;
   }
   endBatch() {
-    this._batchDepth !== 0 && --this._batchDepth === 0 && this._flushSync();
+    if (this._batchDepth === 0) {
+      _ && console.warn(h.SCHEDULER_END_BATCH_WITHOUT_START);
+      return;
+    }
+    --this._batchDepth === 0 && (this._isFlushingSync || this._flushSync());
   }
   setMaxFlushIterations(t) {
-    if (t < C.MIN_FLUSH_ITERATIONS) throw new U(`Max flush iterations must be at least ${C.MIN_FLUSH_ITERATIONS}`);
+    if (t < C.MIN_FLUSH_ITERATIONS) throw new L(`Max iterations must be at least ${C.MIN_FLUSH_ITERATIONS}`);
     this._maxFlushIterations = t;
   }
-}, w = new Ct();
-function Nt(t) {
-  if (typeof t != "function") throw new TypeError(c.BATCH_CALLBACK_MUST_BE_FUNCTION);
-  const s = w;
-  s.startBatch();
+}, N = new mt();
+function wt(t) {
+  if (_ && typeof t != "function") throw new TypeError(h.BATCH_CALLBACK_MUST_BE_FUNCTION);
+  N.startBatch();
   try {
     return t();
   } finally {
-    s.endBatch();
+    N.endBatch();
   }
 }
-var It = class extends Q {
-  constructor(t, s) {
-    super(), this[$] = !0, this[Et] = !0, this._value = t, s && (this.flags |= a.SYNC), G.attachDebugInfo(this, "atom", this.id);
+var vt = class extends K {
+  constructor(t, e) {
+    super(), this[F] = p.Atom | p.Writable, this._value = t, this._equal = e.equal ?? Object.is, e.sync && (this.flags |= f.SYNC), d.attachDebugInfo(this, "atom", this.id, e.name);
   }
   get isNotificationScheduled() {
-    return (this.flags & a.NOTIFICATION_SCHEDULED) !== 0;
+    return (this.flags & f.NOTIFICATION_SCHEDULED) !== 0;
   }
   get isSync() {
-    return (this.flags & a.SYNC) !== 0;
+    return (this.flags & f.SYNC) !== 0;
   }
   get value() {
-    const t = _.current;
+    const t = l.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.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));
+    const e = this._value;
+    if (this._equal(e, t) || (this._value = t, this.version = W(this.version), d.trackUpdate(this.id, d.getDebugName(this)), (this.flags & f.NOTIFICATION_SCHEDULED) !== 0)) return;
+    const s = this._slots;
+    s == null || s.size === 0 || (this._pendingOldValue = e, this.flags |= f.NOTIFICATION_SCHEDULED, (this.flags & f.SYNC) !== 0 && !N.isBatching ? this._notifying === 0 && this._flushNotifications() : N.schedule(this));
   }
   execute() {
     this._flushNotifications();
   }
   _flushNotifications() {
-    const t = this.flags;
-    if ((t & (a.NOTIFICATION_SCHEDULED | a.DISPOSED)) !== a.NOTIFICATION_SCHEDULED) return;
-    const s = this._pendingOldValue;
-    this._pendingOldValue = void 0, this.flags = t & ~a.NOTIFICATION_SCHEDULED, this._notifySubscribers(this._value, s);
+    const t = f.NOTIFICATION_SCHEDULED, e = f.DISPOSED, s = f.SYNC;
+    for (; (this.flags & (t | e)) === t; ) {
+      const i = this._pendingOldValue;
+      if (this._pendingOldValue = void 0, this.flags &= ~t, this._equal(this._value, i) || this._notifySubscribers(this._value, i), (this.flags & s) === 0 || N.isBatching) break;
+    }
   }
   peek() {
     return this._value;
   }
   dispose() {
     const t = this.flags;
-    (t & a.DISPOSED) === 0 && (this._slots?.clear(), this.flags = t | a.DISPOSED, this._value = void 0, this._pendingOldValue = void 0);
+    (t & f.DISPOSED) === 0 && (this._slots?.clear(), this.flags = t | f.DISPOSED, this._value = void 0, this._pendingOldValue = void 0, this._equal = Object.is);
   }
   _deepDirtyCheck() {
     return !1;
@@ -743,25 +748,13 @@ var It = class extends Q {
     this.dispose();
   }
 };
-function bt(t, s = {}) {
-  return new It(t, s.sync ?? !1);
+function Ft(t, e = {}) {
+  return new vt(t, e);
 }
-function yt(t) {
-  return typeof t == "object" && t !== null && $ in t;
-}
-function At(t) {
-  return typeof t == "object" && t !== null && st in t;
-}
-function Ot(t) {
-  return typeof t == "object" && t !== null && et in t;
-}
-function nt(t) {
-  return typeof t == "object" && t !== null && typeof t.then == "function";
-}
-var { IDLE: p, DIRTY: E, PENDING: S, RESOLVED: d, REJECTED: D, HAS_ERROR: A, RECOMPUTING: N, DISPOSED: M, IS_COMPUTED: O, FORCE_COMPUTE: x } = B, Dt = class extends Q {
-  constructor(t, s = {}) {
-    if (typeof t != "function") throw new m(c.COMPUTED_MUST_BE_FUNCTION);
-    if (super(), this[$] = !0, this[st] = !0, this._error = null, this._promiseId = 0, this._deps = new tt(), this._trackEpoch = b.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 : L, this._onError = s.onError ?? null, G.attachDebugInfo(this, "computed", this.id), s.lazy === !1) try {
+var { IDLE: D, DIRTY: E, PENDING: v, RESOLVED: I, REJECTED: T, HAS_ERROR: P, RECOMPUTING: y, DISPOSED: G, IS_COMPUTED: R, FORCE_COMPUTE: X } = Q, Ot = class extends K {
+  constructor(t, e = {}) {
+    if (typeof t != "function") throw new A(h.COMPUTED_MUST_BE_FUNCTION);
+    if (super(), this[F] = p.Atom | p.Computed, this._error = null, this._promiseId = 0, this._deps = new ht(), this._trackEpoch = w.UNINITIALIZED, this._trackCount = 0, this._value = void 0, this.flags = R | E | D, this._equal = e.equal ?? Object.is, this._fn = t, this._defaultValue = "defaultValue" in e ? e.defaultValue : B, this._onError = e.onError ?? null, d.attachDebugInfo(this, "computed", this.id, e.name), e.lazy === !1) try {
       this._recompute();
     } catch {
     }
@@ -770,39 +763,39 @@ var { IDLE: p, DIRTY: E, PENDING: S, RESOLVED: d, REJECTED: D, HAS_ERROR: A, REC
     return (this.flags & E) !== 0;
   }
   get isRejected() {
-    return (this.flags & D) !== 0;
+    return (this.flags & T) !== 0;
   }
   get isRecomputing() {
-    return (this.flags & N) !== 0;
+    return (this.flags & y) !== 0;
   }
   get _hasErrorInternal() {
-    return (this.flags & A) !== 0;
+    return (this.flags & P) !== 0;
   }
   _track() {
-    _.current?.addDependency(this);
+    l.current?.addDependency(this);
   }
   get value() {
-    const t = _.current;
+    const t = l.current;
     t?.addDependency(this);
-    let s = this.flags;
-    if ((s & (d | E | p)) === d) return this._value;
-    if ((s & M) !== 0) throw new m(c.COMPUTED_DISPOSED);
-    if ((s & N) !== 0) {
-      const r = this._defaultValue;
-      if (r !== L) return r;
-      throw new m(c.COMPUTED_CIRCULAR_DEPENDENCY);
+    let e = this.flags;
+    if ((e & (I | E | D)) === I) return this._value;
+    if ((e & G) !== 0) throw new A(h.COMPUTED_DISPOSED);
+    if ((e & y) !== 0) {
+      const n = this._defaultValue;
+      if (n !== B) return n;
+      throw new A(h.COMPUTED_CIRCULAR_DEPENDENCY);
     }
-    if ((s & (E | p)) !== 0) {
-      const r = this._deps;
-      if ((s & p) === 0 && (s & x) === 0 && r.size > 0 && !this._isDirty() ? s = this.flags &= ~E : (this._recompute(), s = this.flags), (s & d) !== 0) return this._value;
+    if ((e & (E | D)) !== 0) {
+      const n = this._deps;
+      if ((e & D) === 0 && (e & X) === 0 && n.size > 0 && !this._isDirty() ? e = this.flags &= ~E : (this._recompute(), e = this.flags), (e & I) !== 0) return this._value;
     }
-    const e = this._defaultValue, i = e !== L;
-    if ((s & S) !== 0) {
-      if (i) return e;
-      throw new m(c.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    const s = this._defaultValue, i = s !== B;
+    if ((e & v) !== 0) {
+      if (i) return s;
+      throw new A(h.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
     }
-    if ((s & D) !== 0) {
-      if (i) return e;
+    if ((e & T) !== 0) {
+      if (i) return s;
       throw this._error;
     }
     return this._value;
@@ -811,263 +804,266 @@ var { IDLE: p, DIRTY: E, PENDING: S, RESOLVED: d, REJECTED: D, HAS_ERROR: A, REC
     return this._value;
   }
   get state() {
-    const t = _.current;
+    const t = l.current;
     t?.addDependency(this);
-    const s = this.flags;
-    return (s & d) !== 0 ? y.RESOLVED : (s & S) !== 0 ? y.PENDING : (s & D) !== 0 ? y.REJECTED : y.IDLE;
+    const e = this.flags;
+    return (e & I) !== 0 ? U.RESOLVED : (e & v) !== 0 ? U.PENDING : (e & T) !== 0 ? U.REJECTED : U.IDLE;
   }
   get hasError() {
-    const t = _.current;
-    if (t?.addDependency(this), (this.flags & (D | A)) !== 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;
+    const t = l.current;
+    if (t?.addDependency(this), (this.flags & (T | P)) !== 0) return !0;
+    const e = this._deps;
+    return e.hasComputeds ? M(() => {
+      const s = e.size;
+      for (let i = 0; i < s; i++) if (e.getAt(i)?.node.hasError) return !0;
+      return !1;
+    }) : !1;
   }
   get isValid() {
     return !this.hasError;
   }
   get errors() {
-    const t = _.current;
+    const t = l.current;
     t?.addDependency(this);
-    const s = this._error, e = this._deps;
-    if (!e.hasComputeds)
-      return s == null ? Y : Object.freeze([s]);
+    const e = this._error, s = this._deps;
+    if (!s.hasComputeds)
+      return e == null ? et : Object.freeze([e]);
     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 i.length === 0 ? Y : Object.freeze(i);
-  }
-  _collectErrorsFromDep(t, s) {
-    const e = t.errors, i = e.length;
-    for (let r = 0; r < i; r++) {
-      const n = e[r];
-      n != null && !s.includes(n) && s.push(n);
+    return e != null && i.push(e), M(() => {
+      const n = s.size;
+      for (let r = 0; r < n; r++) {
+        const o = s.getAt(r)?.node;
+        o != null && (o.flags & R) !== 0 && this._accumulateErrors(o, i);
+      }
+    }), i.length === 0 ? et : Object.freeze(i);
+  }
+  _accumulateErrors(t, e) {
+    const s = t._error;
+    s != null && !e.includes(s) && e.push(s);
+    const i = t._deps;
+    if (!i.hasComputeds) return;
+    const n = i.size;
+    for (let r = 0; r < n; r++) {
+      const o = i.getAt(r)?.node;
+      o != null && (o.flags & R) !== 0 && this._accumulateErrors(o, e);
     }
   }
   get lastError() {
-    const t = _.current;
+    const t = l.current;
     return t?.addDependency(this), this._error;
   }
   get isPending() {
-    const t = _.current;
-    return t?.addDependency(this), (this.flags & S) !== 0;
+    const t = l.current;
+    return t?.addDependency(this), (this.flags & v) !== 0;
   }
   get isResolved() {
-    const t = _.current;
-    return t?.addDependency(this), (this.flags & d) !== 0;
+    const t = l.current;
+    return t?.addDependency(this), (this.flags & I) !== 0;
   }
   invalidate() {
-    this.flags |= x, this._markDirty();
+    this.flags |= X, this._markDirty();
   }
   dispose() {
-    (this.flags & M) === 0 && (this._deps.disposeAll(), this._slots != null && this._slots.clear(), this.flags = M | E | p, this._error = null, this._value = void 0, this._hotIndex = -1);
+    (this.flags & G) === 0 && (this._deps.disposeAll(), this._slots != null && this._slots.clear(), this.flags = G | E | D, this._error = null, this._value = void 0, this._hotIndex = -1);
   }
   [Symbol.dispose]() {
     this.dispose();
   }
   addDependency(t) {
-    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 z(t, t.version, t.subscribe(this));
-      i.insertNew(e, n);
+    const e = this._trackEpoch;
+    if (t._lastSeenEpoch === e) return;
+    t._lastSeenEpoch = e;
+    const s = this._trackCount++, i = this._deps, n = i.getAt(s);
+    if (n != null && n.node === t) n.version = t.version;
+    else if (!i.claimExisting(t, s)) {
+      const r = new j(t, t.version, t.subscribe(this));
+      i.insertNew(s, r);
     }
-    (t.flags & O) !== 0 && (i.hasComputeds = !0);
+    (t.flags & R) !== 0 && (i.hasComputeds = !0);
   }
   _recompute() {
     if (this.isRecomputing) return;
-    this.flags = (this.flags | N) & ~x, this._trackEpoch = k(), this._trackCount = 0, this._deps.prepareTracking(), this._hotIndex = -1;
+    this.flags = (this.flags | y) & ~X, this._trackEpoch = J(), this._trackCount = 0, this._deps.prepareTracking(), this._hotIndex = -1;
     let t = !1;
     try {
-      const s = _.run(this, this._fn);
-      this._deps.truncateFrom(this._trackCount), t = !0, nt(s) ? this._handleAsyncComputation(s) : this._finalizeResolution(s);
-    } catch (s) {
+      const e = l.run(this, this._fn);
+      this._deps.truncateFrom(this._trackCount), t = !0, $(e) ? this._handleAsyncComputation(e) : this._finalizeResolution(e);
+    } catch (e) {
       if (!t) try {
         this._deps.truncateFrom(this._trackCount);
-      } catch {
+      } catch (s) {
+        _ && console.warn("[atom-effect] _commitDeps failed during error recovery:", s);
       }
-      this._handleError(s, c.COMPUTED_COMPUTATION_FAILED, !0);
+      this._handleError(e, h.COMPUTED_COMPUTATION_FAILED, !0);
     } finally {
-      this._trackEpoch = b.UNINITIALIZED, this._trackCount = 0, this.flags &= ~N;
+      this._trackEpoch = w.UNINITIALIZED, this._trackCount = 0, this.flags &= ~y;
     }
   }
   _handleAsyncComputation(t) {
-    this.flags = (this.flags | S) & ~(p | E | d | D), this._notifySubscribers(void 0, void 0), this._promiseId = (this._promiseId + 1) % ut.MAX_PROMISE_ID;
-    const s = this._promiseId;
-    t.then((e) => {
-      if (s === this._promiseId) {
+    this.flags = (this.flags | v) & ~(D | E | I | T), this._notifySubscribers(void 0, void 0), this._promiseId = (this._promiseId + 1) % at.MAX_PROMISE_ID;
+    const e = this._promiseId;
+    t.then((s) => {
+      if (e === this._promiseId) {
         if (this._isDirty()) return this._markDirty();
-        this._finalizeResolution(e), this._notifySubscribers(e, void 0);
+        this._finalizeResolution(s), this._notifySubscribers(s, void 0);
       }
-    }, (e) => s === this._promiseId && this._handleError(e, c.COMPUTED_ASYNC_COMPUTATION_FAILED));
+    }, (s) => e === this._promiseId && this._handleError(s, h.COMPUTED_ASYNC_COMPUTATION_FAILED));
   }
-  _handleError(t, s, e = !1) {
-    const i = g(t, m, s);
-    if (!e && !this.isRejected && (this.version = H(this.version)), this._error = i, this.flags = this.flags & ~(p | E | S | d) | D | A, this._onError) try {
+  _handleError(t, e, s = !1) {
+    const i = O(t, A, e);
+    if ((!this.isRejected || this._error !== i) && (this.version = W(this.version)), this._error = i, this.flags = this.flags & ~(D | E | v | I) | T | P, this._onError) try {
       this._onError(i);
-    } catch (r) {
-      console.error(c.CALLBACK_ERROR_IN_ERROR_HANDLER, r);
+    } catch (n) {
+      console.error(h.CALLBACK_ERROR_IN_ERROR_HANDLER, n);
     }
-    if (e) throw i;
-    this._notifySubscribers(void 0, void 0);
+    if (this._notifySubscribers(void 0, void 0), s) throw i;
   }
   _finalizeResolution(t) {
-    const s = this.flags;
-    ((s & d) === 0 || !this._equal(this._value, t)) && (this.version = H(this.version)), this._value = t, this._error = null, this.flags = (s | d) & ~(p | E | S | D | A);
+    const e = this.flags;
+    ((e & I) === 0 || !this._equal(this._value, t)) && (this.version = W(this.version)), this._value = t, this._error = null, this.flags = (e | I) & ~(D | E | v | T | P);
   }
   execute() {
     this._markDirty();
   }
   _markDirty() {
     const t = this.flags;
-    (t & (N | E)) === 0 && (this.flags = t | E, this._notifySubscribers(void 0, void 0));
+    (t & (y | E)) === 0 && (this.flags = t | E, d.trackUpdate(this.id, d.getDebugName(this)), this._notifySubscribers(void 0, void 0));
   }
   _deepDirtyCheck() {
-    const t = this._deps, s = _.current;
-    _.current = null;
-    try {
+    const t = this._deps;
+    return M(() => {
       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 & O) !== 0) try {
+      for (let s = 0; s < e; s++) {
+        const i = t.getAt(s);
+        if (i == null) continue;
+        const n = i.node;
+        if ((n.flags & R) !== 0) try {
           n.value;
         } catch {
+          _ && console.warn(`[atom-effect] Dependency #${n.id} threw during dirty check`);
         }
-        if (n.version !== r.version)
-          return this._hotIndex = i, !0;
+        if (n.version !== i.version)
+          return this._hotIndex = s, !0;
       }
       return this._hotIndex = -1, !1;
-    } finally {
-      _.current = s;
-    }
+    });
   }
 };
-function Ft(t, s = {}) {
-  return new Dt(t, s);
+function Ut(t, e = {}) {
+  return new Ot(t, e);
 }
-var vt = class extends Q {
-  constructor(t, s = {}) {
-    super(), this[et] = !0, this._cleanup = null, this._deps = new tt(), this._currentEpoch = b.UNINITIALIZED, this._lastFlushEpoch = b.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), G.attachDebugInfo(this, "effect", this.id);
+var Nt = class extends K {
+  constructor(t, e = {}) {
+    super(), this[F] = p.Effect, this._cleanup = null, this._deps = new ht(), this._currentEpoch = w.UNINITIALIZED, this._lastFlushEpoch = w.UNINITIALIZED, this._fn = t, this._onError = e.onError ?? null, this._sync = e.sync ?? !1, this._maxExecutions = e.maxExecutionsPerSecond ?? C.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = e.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 = () => N.schedule(this), d.attachDebugInfo(this, "effect", this.id, e.name);
   }
   run() {
-    if (this.isDisposed) throw new v(c.EFFECT_DISPOSED);
+    if (this.isDisposed) throw new m(h.EFFECT_DISPOSED);
     this.execute(!0);
   }
   dispose() {
-    this.isDisposed || (this.flags |= I.DISPOSED, this._execCleanup(), this._deps?.disposeAll());
+    this.isDisposed || (this.flags |= S.DISPOSED, this._execCleanup(), this._deps?.disposeAll());
   }
   [Symbol.dispose]() {
     this.dispose();
   }
   addDependency(t) {
-    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 r;
-    switch (e) {
+    if ((this.flags & S.EXECUTING) === 0) return;
+    const e = this._currentEpoch;
+    if (t._lastSeenEpoch === e) return;
+    t._lastSeenEpoch = e;
+    const s = this._trackCount++, i = this._deps;
+    let n;
+    switch (s) {
       case 0:
-        r = i._s0;
+        n = i._s0;
         break;
       case 1:
-        r = i._s1;
+        n = i._s1;
         break;
       case 2:
-        r = i._s2;
+        n = i._s2;
         break;
       case 3:
-        r = i._s3;
+        n = i._s3;
         break;
       default:
-        r = i.getAt(e);
+        n = i.getAt(s);
     }
-    r != null && r.node === t ? r.version = t.version : i.claimExisting(t, e) || this._insertNewDependency(t, e), t.isComputed && (i.hasComputeds = !0);
+    n != null && n.node === t ? n.version = t.version : i.claimExisting(t, s) || this._insertNewDependency(t, s), t.isComputed && (i.hasComputeds = !0);
   }
-  _insertNewDependency(t, s) {
-    let e;
+  _insertNewDependency(t, e) {
+    let s;
     try {
       const i = t.subscribe(this._notifyCallback);
-      e = new z(t, t.version, i);
+      s = new j(t, t.version, i);
     } catch (i) {
-      const r = g(i, v, c.EFFECT_EXECUTION_FAILED);
-      if (console.error(r), this._onError) try {
-        this._onError(r);
+      const n = O(i, m, h.EFFECT_EXECUTION_FAILED);
+      if (console.error(n), this._onError) try {
+        this._onError(n);
       } catch {
       }
-      e = new z(t, t.version, void 0);
+      s = new j(t, t.version, void 0);
     }
-    this._deps.insertNew(s, e);
+    this._deps.insertNew(e, s);
   }
   execute(t = !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;
+    const e = this.flags;
+    if ((e & (S.DISPOSED | S.EXECUTING)) !== 0) return;
+    const s = this._deps;
+    if (!t && s.size > 0 && !this._isDirty()) return;
+    this._checkInfiniteLoops(), d.trackUpdate(this.id, d.getDebugName(this)), this.flags = e | S.EXECUTING, this._execCleanup(), this._currentEpoch = J(), this._trackCount = 0, s.prepareTracking(), this._hotIndex = -1;
     let i = !1;
     try {
-      const r = _.run(this, this._fn);
-      e.truncateFrom(this._trackCount), i = !0, nt(r) ? this._handleAsyncResult(r) : this._cleanup = typeof r == "function" ? r : null;
-    } catch (r) {
+      const n = l.run(this, this._fn);
+      s.truncateFrom(this._trackCount), i = !0, $(n) ? this._handleAsyncResult(n) : this._cleanup = typeof n == "function" ? n : null;
+    } catch (n) {
       if (!i) try {
-        e.truncateFrom(this._trackCount);
-      } catch {
+        s.truncateFrom(this._trackCount);
+      } catch (r) {
+        _ && console.warn("[atom-effect] _commitDeps failed during error recovery:", r);
       }
-      this._handleExecutionError(r), this._cleanup = null;
+      this._handleExecutionError(n), this._cleanup = null;
     } finally {
-      this.flags &= ~I.EXECUTING;
+      this.flags &= ~S.EXECUTING;
     }
   }
   _handleAsyncResult(t) {
-    const s = ++this._execId;
-    t.then((e) => {
-      if (s !== this._execId || this.isDisposed) {
-        if (typeof e == "function") try {
-          e();
+    const e = ++this._execId;
+    t.then((s) => {
+      if (e !== this._execId || this.isDisposed) {
+        if (typeof s == "function") try {
+          s();
         } catch (i) {
-          this._handleExecutionError(i, c.EFFECT_CLEANUP_FAILED);
+          this._handleExecutionError(i, h.EFFECT_CLEANUP_FAILED);
         }
         return;
       }
-      typeof e == "function" && (this._cleanup = e);
-    }, (e) => s === this._execId && this._handleExecutionError(e));
+      typeof s == "function" && (this._cleanup = s);
+    }, (s) => e === this._execId && this._handleExecutionError(s));
   }
   _deepDirtyCheck() {
-    const t = _.current;
-    _.current = null;
-    const s = this._deps;
+    const t = l.current;
+    l.current = null;
+    const e = this._deps;
     try {
-      const e = s.size;
-      for (let i = 0; i < e; i++) {
-        const r = s.getAt(i);
-        if (r == null) continue;
-        const n = r.node;
-        if (n.isComputed && this._tryPullComputed(n), n.version !== r.version)
+      const s = e.size;
+      for (let i = 0; i < s; i++) {
+        const n = e.getAt(i);
+        if (n == null) continue;
+        const r = n.node;
+        if (r.isComputed && this._tryPullComputed(r), r.version !== n.version)
           return this._hotIndex = i, !0;
       }
       return !1;
     } finally {
-      _.current = t;
+      l.current = t;
     }
   }
   _tryPullComputed(t) {
     try {
       t.value;
     } catch {
+      _ && console.warn(`[atom-effect] Dependency #${t.id} threw during dirty check`);
     }
   }
   _execCleanup() {
@@ -1076,127 +1072,125 @@ var vt = class extends Q {
       this._cleanup = null;
       try {
         t();
-      } catch (s) {
-        this._handleExecutionError(s, c.EFFECT_CLEANUP_FAILED);
+      } catch (e) {
+        this._handleExecutionError(e, h.EFFECT_CLEANUP_FAILED);
       }
     }
   }
   _checkInfiniteLoops() {
-    const t = dt();
-    this._lastFlushEpoch !== t && (this._lastFlushEpoch = t, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), pt() > C.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++;
+    const t = St();
+    this._lastFlushEpoch !== t && (this._lastFlushEpoch = t, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), Tt() > C.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, _ && this._checkFrequencyLimit();
   }
   _checkFrequencyLimit() {
     if (!Number.isFinite(this._maxExecutions)) return;
     const t = Date.now();
-    if (t - this._windowStart >= Z.EFFECT_FREQUENCY_WINDOW) {
+    if (t - this._windowStart >= Y.EFFECT_FREQUENCY_WINDOW) {
       this._windowStart = t, this._windowCount = 1;
       return;
     }
     if (++this._windowCount > this._maxExecutions) {
-      const s = new v(c.EFFECT_FREQUENCY_LIMIT_EXCEEDED);
-      throw this.dispose(), this._handleExecutionError(s), s;
+      const e = new m(h.EFFECT_FREQUENCY_LIMIT_EXCEEDED);
+      throw this.dispose(), this._handleExecutionError(e), e;
     }
   }
   get executionCount() {
     return this._executionCount;
   }
   get isExecuting() {
-    return (this.flags & I.EXECUTING) !== 0;
+    return (this.flags & S.EXECUTING) !== 0;
   }
   _throwInfiniteLoopError(t) {
-    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;
+    const e = new m(`Infinite loop detected (${t}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${Z}`);
+    throw this.dispose(), console.error(e), e;
   }
-  _handleExecutionError(t, s = c.EFFECT_EXECUTION_FAILED) {
-    const e = g(t, v, s);
-    if (console.error(e), this._onError) try {
-      this._onError(e);
+  _handleExecutionError(t, e = h.EFFECT_EXECUTION_FAILED) {
+    const s = O(t, m, e);
+    if (console.error(s), this._onError) try {
+      this._onError(s);
     } catch (i) {
-      console.error(g(i, v, c.CALLBACK_ERROR_IN_ERROR_HANDLER));
+      console.error(O(i, m, h.CALLBACK_ERROR_IN_ERROR_HANDLER));
     }
   }
 };
-function Rt(t, s = {}) {
-  if (typeof t != "function") throw new v(c.EFFECT_MUST_BE_FUNCTION);
-  const e = new vt(t, s);
-  return e.execute(), e;
+function Lt(t, e = {}) {
+  if (typeof t != "function") throw new m(h.EFFECT_MUST_BE_FUNCTION);
+  const s = new Nt(t, e);
+  return s.execute(), s;
 }
-var St = /* @__PURE__ */ Symbol.for("atom-effect/atom"), gt = /* @__PURE__ */ Symbol.for("atom-effect/writable");
-function rt(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 = rt(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;
+function lt(t, e, s, i) {
+  if (s === e.length) return i;
+  const n = e[s], r = t != null && typeof t == "object" ? t : {}, o = r[n], c = lt(o, e, s + 1, i);
+  if (Object.is(o, c)) return t;
+  if (Array.isArray(r)) {
+    const a = r.slice(), b = Number.parseInt(n, 10);
+    return Number.isNaN(b) ? a[n] = c : a[b] = c, a;
   }
   return {
-    ...n,
-    [r]: u
+    ...r,
+    [n]: c
   };
 }
-function F(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 x(t, e) {
+  let s = t;
+  const i = e.length;
+  for (let n = 0; n < i; n++) {
+    if (s == null) return;
+    s = s[e[n]];
+  }
+  return s;
 }
-function ot(t, s) {
-  const e = s.includes(".") ? s.split(".") : [s], i = /* @__PURE__ */ new Set(), r = () => {
-    i.forEach((n) => n()), i.clear();
+function _t(t, e) {
+  const s = e.includes(".") ? e.split(".") : [e], i = /* @__PURE__ */ new Set(), n = () => {
+    i.forEach((r) => r()), i.clear();
   };
   return {
     get value() {
-      return F(t.value, e);
+      return x(t.value, s);
     },
-    set value(n) {
-      const o = t.peek(), u = rt(o, e, 0, n);
-      u !== o && (t.value = u);
+    set value(r) {
+      const o = t.peek(), c = lt(o, s, 0, r);
+      c !== o && (t.value = c);
     },
-    peek: () => F(t.peek(), e),
-    subscribe(n) {
-      const o = t.subscribe((u, l) => {
-        const h = F(u, e), f = F(l, e);
-        Object.is(h, f) || n(h, f);
+    peek: () => x(t.peek(), s),
+    subscribe(r) {
+      const o = t.subscribe((c, a) => {
+        const b = x(c, s), tt = x(a, s);
+        Object.is(b, tt) || r(b, tt);
       });
       return i.add(o), () => {
         o(), i.delete(o);
       };
     },
     subscriberCount: () => i.size,
-    dispose: r,
-    [Symbol.dispose]: r,
-    [St]: !0,
-    [gt]: !0
+    dispose: n,
+    [Symbol.dispose]: n,
+    [F]: p.Atom | p.Writable
   };
 }
-var wt = (t, s) => ot(t, s), Ut = (t) => (s) => ot(t, s);
+var Pt = (t, e) => _t(t, e), xt = (t) => (e) => _t(t, e);
 export {
-  y as AsyncState,
-  T as AtomError,
-  m as ComputedError,
-  Z as DEBUG_CONFIG,
-  G as DEBUG_RUNTIME,
-  v as EffectError,
+  U as AsyncState,
+  g as AtomError,
+  A as ComputedError,
+  Y as DEBUG_CONFIG,
+  m as EffectError,
   C as SCHEDULER_CONFIG,
-  U as SchedulerError,
-  bt as atom,
-  ot as atomLens,
-  Nt as batch,
-  wt as composeLens,
-  Ft as computed,
-  Rt as effect,
-  F as getPathValue,
-  yt as isAtom,
-  At as isComputed,
-  Ot as isEffect,
-  Ut as lensFor,
-  w as scheduler,
-  rt as setDeepValue,
-  mt as untracked
+  L as SchedulerError,
+  Ft as atom,
+  _t as atomLens,
+  wt as batch,
+  Pt as composeLens,
+  Ut as computed,
+  Lt as effect,
+  x as getPathValue,
+  N as globalScheduler,
+  At as isAtom,
+  yt as isComputed,
+  Rt as isEffect,
+  xt as lensFor,
+  d as runtimeDebug,
+  lt as setDeepValue,
+  M as untracked
 };
 
 //# sourceMappingURL=index.mjs.map