@but212/atom-effect 0.30.1 → 0.31.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-var u = {
+var h = {
   DISPOSED: 1,
   IS_COMPUTED: 2,
   DIRTY: 256,
@@ -12,107 +12,108 @@ var u = {
   ATOM_SYNC: 16777216,
   ATOM_NOTIFICATION_SCHEDULED: 33554432,
   EFFECT_EXECUTING: 268435456
-}, At = 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({
+}, yt = Object.freeze({
+  ASYNC_STATE: h.IDLE | h.PENDING | h.RESOLVED | h.REJECTED,
+  COMPUTED_DIRTY_MASK: h.DIRTY | h.RECOMPUTING | h.FORCE_COMPUTE
+}), P = Object.freeze({
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
   REJECTED: "rejected"
 }), 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
+  DISPOSED: h.DISPOSED,
+  EXECUTING: h.EFFECT_EXECUTING
+}), $ = Object.freeze({
+  DISPOSED: h.DISPOSED,
+  IS_COMPUTED: h.IS_COMPUTED,
+  DIRTY: h.DIRTY,
+  IDLE: h.IDLE,
+  PENDING: h.PENDING,
+  RESOLVED: h.RESOLVED,
+  REJECTED: h.REJECTED,
+  RECOMPUTING: h.RECOMPUTING,
+  HAS_ERROR: h.HAS_ERROR,
+  FORCE_COMPUTE: h.FORCE_COMPUTE
 }), C = Object.freeze({
+  DISPOSED: h.DISPOSED,
+  SYNC: h.ATOM_SYNC,
+  NOTIFICATION_SCHEDULED: h.ATOM_NOTIFICATION_SCHEDULED
+}), g = 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
-}), k = 1073741823, Y = Object.freeze({
+}), H = 1073741823, W = Object.freeze({
   WARN_INFINITE_LOOP: !0,
   EFFECT_FREQUENCY_WINDOW: 1e3,
   LOOP_THRESHOLD: 100
-}), ft = Object.freeze({ MAX_PROMISE_ID: k }), w = Object.freeze({
+}), Et = Object.freeze({ MAX_PROMISE_ID: H }), U = Object.freeze({
   UNINITIALIZED: -1,
   MIN: 1
-}), ot = !1;
+}), ht = !1;
 try {
-  ot = !!(typeof globalThis < "u" && globalThis.__ATOM_DEBUG__ || typeof sessionStorage < "u" && sessionStorage.getItem("__ATOM_DEBUG__") === "true");
+  ht = !!(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 {
+var f = (typeof process < "u" && process.env, typeof __DEV__ < "u" && !!__DEV__ || ht), it = Object.freeze([]), y = class j 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;
+    const e = this.cause;
+    if (e == null) return [this];
+    const s = [this];
+    let i = e, n = null;
+    for (; i != null && (s.push(i), !(i === this || n?.has(i))); ) {
+      if (i instanceof j) i = i.cause;
+      else if (i instanceof Error) i = i.cause;
       else break;
+      s.length > 3 && (n === null ? n = new Set(s) : n.add(i));
     }
-    return e;
+    return s;
   }
-  toJSON(e = /* @__PURE__ */ new Set()) {
-    if (e.has(this)) return {
+  toJSON(e) {
+    const s = e ?? /* @__PURE__ */ new Set();
+    if (s.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
+    s.add(this);
+    let i = this.cause;
+    return i instanceof j ? i = i.toJSON(s) : i instanceof Error && (i = {
+      name: i.name,
+      message: i.message,
+      stack: i.stack,
+      cause: i.cause
     }), {
       name: this.name,
       message: this.message,
       code: this.code,
       recoverable: this.recoverable,
       stack: this.stack,
-      cause: s
+      cause: i
     };
   }
   static format(e, s, i) {
     return `${e} (${s}): ${i}`;
   }
-}, A = class extends g {
+}, w = class extends y {
   constructor(...t) {
     super(...t), this.name = "ComputedError";
   }
-}, m = class extends g {
+}, N = class extends y {
   constructor(t, e = null, s = !1, i) {
     super(t, e, s, i), this.name = "EffectError";
   }
-}, L = class extends g {
+}, x = class extends y {
   constructor(t, e = null, s = !1, i) {
     super(t, e, s, i), this.name = "SchedulerError";
   }
-}, h = {
+}, l = {
   COMPUTED_MUST_BE_FUNCTION: "Computed target must be a function",
   COMPUTED_ASYNC_PENDING_NO_DEFAULT: "Async computation pending with no default value",
   COMPUTED_COMPUTATION_FAILED: "Computation execution failed",
@@ -132,39 +133,24 @@ var _ = (typeof process < "u" && process.env, typeof __DEV__ < "u" && !!__DEV__
   SCHEDULER_END_BATCH_WITHOUT_START: "endBatch() called without matching startBatch(). Ignoring.",
   BATCH_CALLBACK_MUST_BE_FUNCTION: "Batch callback must be a function"
 };
-function N(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);
+function A(t, e, s) {
+  return t instanceof y ? new e(`${t.name} (${s}): ${t.message}`, t, t.recoverable, t.code) : t instanceof Error ? new e(`${t.name || "Error"} (${s}): ${t.message}`, t) : new e(`Unexpected error (${s}): ${String(t)}`, t);
 }
-var st = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), Et = /* @__PURE__ */ Symbol("AtomEffect.Id"), it = /* @__PURE__ */ Symbol("AtomEffect.Type"), B = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), dt = "[Atom Effect]", pt = class {
+var nt = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), dt = /* @__PURE__ */ Symbol("AtomEffect.Id"), rt = /* @__PURE__ */ Symbol("AtomEffect.Type"), G = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), pt = "[Atom Effect]", M = () => {
+}, It = class {
   constructor() {
-    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(`${dt} ${e}`);
+    this.enabled = !0, this.warnInfiniteLoop = W.WARN_INFINITE_LOOP, this._updateCounts = /* @__PURE__ */ new Map(), this._nodeRegistry = /* @__PURE__ */ new Map(), this._threshold = W.LOOP_THRESHOLD, this._cleanupScheduled = !1, this.warn = (t, e) => {
+      this.enabled && t && console.warn(`${pt} ${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
-        },
-        [Et]: {
-          value: s,
-          configurable: !0
-        },
-        [it]: {
-          value: e,
-          configurable: !0
-        }
-      }), this.registerNode(t));
+      if (!this.enabled) return;
+      const n = t;
+      n[nt] = i ?? `${e}_${s}`, n[dt] = s, n[rt] = e, 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(() => {
+      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, queueMicrotask(() => {
         this._updateCounts.clear(), this._cleanupScheduled = !1;
       }));
     }, this.dumpGraph = () => {
@@ -180,39 +166,35 @@ var st = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), Et = /* @__PURE__ */ Sy
       }
       return t;
     }, this.getDebugName = (t) => {
-      if (t)
-        return t[st];
+      if (t != null)
+        return t[nt];
     }, this.getDebugType = (t) => {
-      if (t)
-        return t[it];
+      if (t != null)
+        return t[rt];
     };
   }
-}, It = {
+}, Ct = {
   enabled: !1,
   warnInfiniteLoop: !1,
-  warn: () => {
-  },
-  registerNode: () => {
-  },
-  attachDebugInfo: () => {
-  },
-  trackUpdate: () => {
-  },
+  warn: M,
+  registerNode: M,
+  attachDebugInfo: M,
+  trackUpdate: M,
   dumpGraph: () => [],
   getDebugName: () => {
   },
   getDebugType: () => {
   }
-}, d = _ ? new pt() : It, Ct = 1, gt = () => Ct++ | 0, ut = class {
+}, d = f ? new It() : Ct, Dt = 1, gt = () => Dt++ | 0, lt = 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;
+    this._count = 0, this._actualCount = 0, this._s0 = null, this._s1 = null, this._s2 = null, this._s3 = null, this._overflow = null, this._freeIndices = null;
   }
   _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;
+      const s = this._overflow;
+      s[t - 4] = e;
     }
   }
   _rawAdd(t) {
@@ -230,7 +212,7 @@ var st = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), Et = /* @__PURE__ */ Sy
       const i = s.pop();
       return e[i] = t, i + 4;
     }
-    return e.push(t), 4 + e.length - 1;
+    return e.push(t), 3 + e.length;
   }
   _rawSwap(t, e) {
     if (t === e) return;
@@ -244,18 +226,26 @@ var st = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), Et = /* @__PURE__ */ Sy
     return this._count;
   }
   getAt(t) {
-    return t < 4 ? t === 0 ? this._s0 : t === 1 ? this._s1 : t === 2 ? this._s2 : this._s3 : this._overflow?.[t - 4] ?? null;
+    if (t < 4)
+      return t === 0 ? this._s0 : t === 1 ? this._s1 : t === 2 ? this._s2 : t === 3 ? this._s3 : null;
+    const e = this._overflow;
+    return e === null ? null : e[t - 4] ?? null;
   }
   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));
+    s !== e && (this._rawWrite(t, e), s === null ? this._actualCount++ : e === null && this._actualCount--, e !== null ? t >= this._count && (this._count = t + 1) : this._shrinkPhysicalSizeFrom(t));
   }
   _shrinkPhysicalSizeFrom(t) {
-    if (t === this._count - 1)
-      for (this._count--; this._count > 0 && this.getAt(this._count - 1) == null; ) this._count--;
+    if (t === this._count - 1) {
+      if (this._count--, this._count > 4) {
+        const e = this._overflow;
+        for (; this._count > 4 && e[this._count - 5] === null; ) this._count--;
+      }
+      this._count === 4 && this._s3 === null && (this._count = 3, this._s2 === null && (this._count = 2, this._s1 === null && (this._count = 1, this._s0 === null && (this._count = 0))));
+    }
   }
   truncateFrom(t) {
-    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--));
+    t <= 3 && (t <= 3 && this._s3 !== null && (this._onItemRemoved(this._s3), this._s3 = null, this._actualCount--), t <= 2 && this._s2 !== null && (this._onItemRemoved(this._s2), this._s2 = null, this._actualCount--), t <= 1 && this._s1 !== null && (this._onItemRemoved(this._s1), this._s1 = null, this._actualCount--), t <= 0 && this._s0 !== null && (this._onItemRemoved(this._s0), this._s0 = null, this._actualCount--));
     const e = this._overflow;
     if (e !== null) {
       const s = t > 4 ? t - 4 : 0, i = e.length;
@@ -295,31 +285,37 @@ var st = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), Et = /* @__PURE__ */ Sy
     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);
+      if (t(this._s0), e > 1 && (t(this._s1), e > 2 && (t(this._s2), e > 3 && (t(this._s3), e > 4)))) {
+        const n = this._overflow;
+        for (let r = 0, o = n.length; r < o; r++) t(n[r]);
       }
       return;
     }
     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;
+    if (this._s0 !== null && (t(this._s0), ++s >= e) || this._s1 !== null && (t(this._s1), ++s >= e) || this._s2 !== null && (t(this._s2), ++s >= e) || this._s3 !== null && (t(this._s3), ++s >= e))
+      return;
+    const i = this._overflow;
+    if (i !== null) for (let n = 0, r = i.length; n < r; n++) {
+      const o = i[n];
+      if (o != null && (t(o), ++s >= e))
+        return;
     }
   }
   compact() {
-    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++);
+    const t = this._actualCount;
+    if (t === this._count) return;
+    if (t === 0) {
+      this.clear();
+      return;
+    }
+    let e = 0;
+    const s = this._count;
+    for (let i = 0; i < s; i++) {
+      const n = this.getAt(i);
+      if (n !== null && (i !== e && (this._rawWrite(e, n), this._rawWrite(i, null)), e++, e === t))
+        break;
     }
-    this._count = this._actualCount, this._overflow !== null && (t <= 4 ? this._overflow = null : this._overflow.length = t - 4), this._freeIndices = null;
+    this._count = t, this._overflow !== null && (e <= 4 ? this._overflow = null : this._overflow.length = e - 4), this._freeIndices = null;
   }
   clear() {
     this._s0 = this._s1 = this._s2 = this._s3 = null, this._count = 0, this._actualCount = 0, this._overflow = null, this._freeIndices = null;
@@ -327,7 +323,7 @@ var st = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), Et = /* @__PURE__ */ Sy
   dispose() {
     this.clear();
   }
-}, ht = class extends ut {
+}, ct = class extends lt {
   constructor(...t) {
     super(...t), this._map = null, this._SCAN_THRESHOLD = 32, this.hasComputeds = !1;
   }
@@ -339,28 +335,41 @@ var st = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), Et = /* @__PURE__ */ Sy
   }
   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));
+    super.setAt(t, e), this._map !== null && (s !== null && this._map.delete(s.node), e !== null && 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)
+    let i = null;
+    if (e < 4 ? e === 0 ? i = this._s0 : e === 1 ? i = this._s1 : e === 2 ? i = this._s2 : i = this._s3 : i = this._overflow[e - 4] ?? null, 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;
+    let n = -1, r = null, o = e + 1;
+    for (; o < 4 && o < s; o++) {
+      const u = o === 1 ? this._s1 : o === 2 ? this._s2 : this._s3;
+      if (u && u.node === t && u.unsub) {
+        n = o, r = u;
+        break;
+      }
     }
-    return !1;
+    if (n === -1 && o < s) {
+      const u = this._overflow;
+      for (let c = o - 4, I = s - 4; c < I; c++) {
+        const E = u[c];
+        if (E && E.node === t && E.unsub) {
+          n = c + 4, r = E;
+          break;
+        }
+      }
+    }
+    return n !== -1 ? (r.version = t.version, this._rawWrite(e, r), this._rawWrite(n, i), !0) : !1;
   }
   _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 === 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);
@@ -369,19 +378,27 @@ var st = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), Et = /* @__PURE__ */ Sy
   }
   _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);
+    this._s0?.unsub && t.set(this._s0.node, 0), this._s1?.unsub && t.set(this._s1.node, 1), this._s2?.unsub && t.set(this._s2.node, 2), this._s3?.unsub && t.set(this._s3.node, 3);
+    const e = this._overflow;
+    if (e !== null) for (let s = 0, i = e.length; s < i; s++) {
+      const n = e[s];
+      n?.unsub && t.set(n.node, s + 4);
     }
     return t;
   }
   insertNew(t, e) {
-    const s = this.getAt(t);
+    let s = null;
+    if (t < 4) t === 0 ? (s = this._s0, this._s0 = e) : t === 1 ? (s = this._s1, this._s1 = e) : t === 2 ? (s = this._s2, this._s2 = e) : (s = this._s3, this._s3 = e);
+    else {
+      this._overflow === null && (this._overflow = []);
+      const i = this._overflow;
+      s = i[t - 4] ?? null, i[t - 4] = e;
+    }
     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);
     }
-    this._rawWrite(t, e), t >= this._count && (this._count = t + 1), this._actualCount++, this._map !== null && e.unsub && this._map.set(e.node, t);
+    t >= this._count && (this._count = t + 1), this._actualCount++, this._map !== null && e.unsub && this._map.set(e.node, t);
   }
   add(t) {
     const e = super.add(t);
@@ -398,49 +415,51 @@ var st = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), Et = /* @__PURE__ */ Sy
   disposeAll() {
     this.truncateFrom(0), this.hasComputeds = !1;
   }
-}, F = /* @__PURE__ */ Symbol.for("atom-effect/brand"), p = {
+}, L = /* @__PURE__ */ Symbol.for("atom-effect/brand"), p = {
   Atom: 1,
   Writable: 2,
   Computed: 4,
   Effect: 8
 };
-function $(t, e) {
-  if (!t) return !1;
-  const s = typeof t;
-  return (s === "object" || s === "function") && !!((t[F] ?? 0) & e);
+function J(t, e) {
+  return !t || typeof t != "object" && typeof t != "function" ? !1 : !!(t[L] & e);
 }
-function yt(t) {
-  return $(t, p.Atom);
+function wt(t) {
+  return J(t, p.Atom);
 }
 function Rt(t) {
-  return $(t, p.Computed);
+  return J(t, p.Computed);
 }
-function wt(t) {
-  return $(t, p.Effect);
+function Ft(t) {
+  return J(t, p.Effect);
 }
-function q(t) {
-  if (t instanceof Promise) return !0;
-  if (!t) return !1;
-  const e = typeof t;
-  return (e === "object" || e === "function") && typeof t.then == "function";
+function Z(t) {
+  return t instanceof Promise ? !0 : t === null || typeof t != "object" ? !1 : typeof t.then == "function";
 }
-var W = class {
+var q = class {
   constructor(t, e, s = void 0) {
     this.node = t, this.version = e, this.unsub = s;
   }
-}, Dt = class {
+}, St = 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();
-    });
+    const s = this.fn, i = this.sub;
+    if (s === void 0 && i === void 0) return;
+    const n = _, r = n.current;
+    if (r === null) {
+      s !== void 0 && s(t, e), i !== void 0 && i.execute();
+      return;
+    }
+    n.current = null;
+    try {
+      s !== void 0 && s(t, e), i !== void 0 && i.execute();
+    } finally {
+      n.current = r;
+    }
   }
-}, St = class {
+}, vt = class {
   constructor() {
     this.current = null;
   }
@@ -449,15 +468,16 @@ var W = class {
     const s = this.current;
     this.current = t;
     try {
+      if (!f) return e();
       const i = e();
-      return _ && d.warn(q(i), 'Detected Promise returned within tracking context. Dependencies accessed after "await" will NOT be tracked. Consider using synchronous tracking before the async boundary.'), i;
+      return d.warn(Z(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 = s;
     }
   }
-}, l = new St();
-function M(t) {
-  const e = l, s = e.current;
+}, _ = new vt();
+function X(t) {
+  const e = _, s = e.current;
   if (s === null) return t();
   e.current = null;
   try {
@@ -466,48 +486,56 @@ function M(t) {
     e.current = s;
   }
 }
-var K = class {
+var tt = class {
   constructor() {
-    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 = gt() & k;
+    this.flags = 0, this.version = 0, this._lastSeenEpoch = U.UNINITIALIZED, this._notifying = 0, this._hotIndex = -1, this.id = gt() & H, this._nextEpoch = void 0, this._slots = null, this._deps = null;
   }
   get isDisposed() {
-    return (this.flags & Q.DISPOSED) !== 0;
+    return (this.flags & $.DISPOSED) !== 0;
   }
   get isComputed() {
-    return (this.flags & Q.IS_COMPUTED) !== 0;
+    return (this.flags & $.IS_COMPUTED) !== 0;
   }
   get hasError() {
     return !1;
   }
   subscribe(t) {
     const e = typeof t == "function";
-    if (!e && (!t || typeof t.execute != "function")) throw N(/* @__PURE__ */ new TypeError("Invalid subscriber"), g, h.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
+    if (!e && (t === null || typeof t.execute != "function")) throw A(/* @__PURE__ */ new TypeError("Invalid subscriber"), y, l.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
     let s = this._slots;
-    s || (s = new ut(), this._slots = s);
-    let i = !1;
-    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 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 (s === null && (s = new lt(), this._slots = s), s.size > 0) {
+      let n = !1;
+      if (s._s0 !== null && (s._s0.fn === t || s._s0.sub === t) || s._s1 !== null && (s._s1.fn === t || s._s1.sub === t) || s._s2 !== null && (s._s2.fn === t || s._s2.sub === t) || s._s3 !== null && (s._s3.fn === t || s._s3.sub === t)) n = !0;
+      else {
+        const r = s._overflow;
+        if (r !== null) {
+          const o = r.length;
+          if (e) for (let u = 0; u < o; u++) {
+            const c = r[u];
+            if (c !== null && c?.fn === t) {
+              n = !0;
+              break;
+            }
+          }
+          else for (let u = 0; u < o; u++) {
+            const c = r[u];
+            if (c !== null && c?.sub === t) {
+              n = !0;
+              break;
+            }
+          }
         }
       }
+      if (n)
+        return f && console.warn(`[atom-effect] Duplicate subscription ignored on node ${this.id}`), () => {
+        };
     }
-    if (i)
-      return _ && console.warn(`[atom-effect] Duplicate subscription ignored on node ${this.id}`), () => {
-      };
-    const n = new Dt(e ? t : void 0, e ? void 0 : t);
-    return s.add(n), () => this._unsubscribe(n);
+    const i = new St(e ? t : void 0, e ? void 0 : t);
+    return s.add(i), () => this._unsubscribe(i);
   }
   _unsubscribe(t) {
     const e = this._slots;
-    e && (e.remove(t), this._notifying === 0 && e.compact());
+    e !== null && (e.remove(t), this._notifying === 0 && e.compact());
   }
   subscriberCount() {
     const t = this._slots;
@@ -518,34 +546,33 @@ var K = class {
     if (!(s === null || s.size === 0)) {
       this._notifying++;
       try {
-        let i = s._s0;
-        if (i != null) try {
-          i.notify(t, e);
-        } catch (r) {
-          this._logNotifyError(r);
+        if (s._s0 !== null) try {
+          s._s0.notify(t, e);
+        } catch (n) {
+          this._logNotifyError(n);
         }
-        if (i = s._s1, i != null) try {
-          i.notify(t, e);
-        } catch (r) {
-          this._logNotifyError(r);
+        if (s._s1 !== null) try {
+          s._s1.notify(t, e);
+        } catch (n) {
+          this._logNotifyError(n);
         }
-        if (i = s._s2, i != null) try {
-          i.notify(t, e);
-        } catch (r) {
-          this._logNotifyError(r);
+        if (s._s2 !== null) try {
+          s._s2.notify(t, e);
+        } catch (n) {
+          this._logNotifyError(n);
         }
-        if (i = s._s3, i != null) try {
-          i.notify(t, e);
-        } catch (r) {
-          this._logNotifyError(r);
+        if (s._s3 !== null) try {
+          s._s3.notify(t, e);
+        } catch (n) {
+          this._logNotifyError(n);
         }
-        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);
+        const i = s._overflow;
+        if (i !== null) for (let n = 0, r = i.length; n < r; n++) {
+          const o = i[n];
+          if (o !== null) try {
+            o?.notify(t, e);
+          } catch (u) {
+            this._logNotifyError(u);
           }
         }
       } finally {
@@ -554,7 +581,7 @@ var K = class {
     }
   }
   _logNotifyError(t) {
-    console.error(N(t, g, h.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
+    console.error(A(t, y, l.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
   }
   _isDirty() {
     const t = this._deps;
@@ -562,38 +589,38 @@ var K = class {
     const e = this._hotIndex;
     if (e !== -1) {
       const s = t.getAt(e);
-      if (s != null && s.node.version !== s.version) return !0;
+      if (s !== null && s.node.version !== s.version) return !0;
     }
     return this._deepDirtyCheck();
   }
-}, H = 0;
-function J() {
-  const t = H + 1 & k;
-  return H = t === 0 ? 1 : t, H;
+}, Q = 0;
+function et() {
+  const t = Q + 1 & H;
+  return Q = t === 0 ? 1 : t, Q;
 }
-function j(t) {
-  const e = t + 1 & k;
+function K(t) {
+  const e = t + 1 & H;
   return e === 0 ? 1 : e;
 }
-var Z = 0, z = !1, ct = 0;
+var st = 0, B = !1, _t = 0;
 function Tt() {
-  return ct;
+  return _t;
 }
-function nt() {
-  return z ? (_ && console.warn("startFlush() called during flush - ignored"), !1) : (z = !0, ct = J(), Z = 0, !0);
+function ot() {
+  return B ? (f && console.warn("startFlush() called during flush - ignored"), !1) : (B = !0, _t = et(), st = 0, !0);
 }
-function rt() {
-  z = !1;
+function ut() {
+  B = !1;
 }
 function mt() {
-  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}`);
+  if (!B) return 0;
+  const t = ++st;
+  if (t <= g.MAX_EXECUTIONS_PER_FLUSH) return t;
+  throw new Error(`[atom-effect] Infinite loop detected: flush execution count exceeded ${g.MAX_EXECUTIONS_PER_FLUSH}`);
 }
-var vt = class {
+var Ot = 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);
+    this._bufferIndex = 0, this._size = 0, this._epoch = 0, this._batchDepth = 0, this._batchQueueSize = 0, this._maxFlushIterations = g.MAX_FLUSH_ITERATIONS, this._isProcessing = !1, this._isFlushingSync = !1, this._buffer0 = [], this._buffer1 = [], this._batchQueue = [], this.onOverflow = null, this._boundRunLoop = this._runLoop.bind(this);
   }
   get queueSize() {
     return this._size + this._batchQueueSize;
@@ -602,25 +629,25 @@ var vt = class {
     return this._batchDepth > 0;
   }
   schedule(t) {
-    if (_ && typeof t != "function" && (!t || typeof t.execute != "function"))
-      throw new L(h.SCHEDULER_CALLBACK_MUST_BE_FUNCTION);
+    if (f && typeof t != "function" && (!t || typeof t.execute != "function"))
+      throw new x(l.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 s = this._queueBuffer[this._bufferIndex];
+    const s = this._bufferIndex === 0 ? this._buffer0 : this._buffer1;
     s[this._size++] = t, this._isProcessing || this._flush();
   }
   _flush() {
-    this._isProcessing || this._size === 0 || (this._isProcessing = !0, queueMicrotask(this._boundRunLoop));
+    this._isProcessing || this._size === 0 && this._batchQueueSize === 0 || (this._isProcessing = !0, queueMicrotask(this._boundRunLoop));
   }
   _runLoop() {
     try {
       if (this._size === 0 && this._batchQueueSize === 0) return;
-      const t = nt();
-      this._drainQueue(), t && rt();
+      const t = ot();
+      this._drainQueue(), t && ut();
     } finally {
       this._isProcessing = !1;
     }
@@ -629,24 +656,23 @@ var vt = class {
     if (this._size === 0 && this._batchQueueSize === 0) return;
     const t = this._isFlushingSync;
     this._isFlushingSync = !0;
-    const e = nt();
+    const e = ot();
     try {
       this._mergeBatchQueue(), this._drainQueue();
     } finally {
-      this._isFlushingSync = t, e && rt();
+      this._isFlushingSync = t, e && ut();
     }
   }
   _mergeBatchQueue() {
     const t = this._batchQueueSize;
     if (t === 0) return;
-    this._epoch = this._epoch + 1 | 0;
-    const e = this._epoch, s = this._batchQueue, i = this._queueBuffer[this._bufferIndex];
+    const e = ++this._epoch | 0, s = this._batchQueue, i = this._bufferIndex === 0 ? this._buffer0 : this._buffer1;
     let n = this._size;
     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, s.length > C.BATCH_QUEUE_SHRINK_THRESHOLD && (s.length = 0);
+    this._size = n, this._batchQueueSize = 0, s.length > g.BATCH_QUEUE_SHRINK_THRESHOLD && (s.length = 0);
   }
   _drainQueue() {
     let t = 0;
@@ -659,7 +685,7 @@ var vt = class {
     }
   }
   _processQueue() {
-    const t = this._bufferIndex, e = this._queueBuffer[t], s = this._size;
+    const t = this._bufferIndex, e = t === 0 ? this._buffer0 : this._buffer1, s = this._size;
     this._bufferIndex = t ^ 1, this._size = 0, this._epoch = this._epoch + 1 | 0;
     for (let i = 0; i < s; i++) {
       const n = e[i];
@@ -667,13 +693,13 @@ var vt = class {
       try {
         typeof n == "function" ? n() : n.execute();
       } catch (r) {
-        console.error(new L("Error occurred during scheduler execution", r));
+        console.error(new x("Error occurred during scheduler execution", r));
       }
     }
   }
   _handleFlushOverflow() {
     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;
+    console.error(new x(l.SCHEDULER_FLUSH_OVERFLOW(this._maxFlushIterations, t))), this._size = 0, this._buffer0.length = 0, this._buffer1.length = 0, this._batchQueueSize = 0, this._batchQueue.length = 0;
     const e = this.onOverflow;
     if (e) try {
       e(t);
@@ -685,116 +711,136 @@ var vt = class {
   }
   endBatch() {
     if (this._batchDepth === 0) {
-      _ && console.warn(h.SCHEDULER_END_BATCH_WITHOUT_START);
+      f && console.warn(l.SCHEDULER_END_BATCH_WITHOUT_START);
       return;
     }
     --this._batchDepth === 0 && (this._isFlushingSync || this._flushSync());
   }
   setMaxFlushIterations(t) {
-    if (t < C.MIN_FLUSH_ITERATIONS) throw new L(`Max iterations must be at least ${C.MIN_FLUSH_ITERATIONS}`);
+    if (t < g.MIN_FLUSH_ITERATIONS) throw new x(`Max iterations must be at least ${g.MIN_FLUSH_ITERATIONS}`);
     this._maxFlushIterations = t;
   }
-}, b = new vt();
-function Ft(t) {
-  if (_ && typeof t != "function") throw new TypeError(h.BATCH_CALLBACK_MUST_BE_FUNCTION);
-  b.startBatch();
+}, T = new Ot();
+function Ut(t) {
+  if (f && typeof t != "function") throw new TypeError(l.BATCH_CALLBACK_MUST_BE_FUNCTION);
+  T.startBatch();
   try {
     return t();
   } finally {
-    b.endBatch();
+    T.endBatch();
   }
 }
-var Ot = class extends K {
+var R = null;
+function Lt(t) {
+  return t ? new Promise((e, s) => {
+    T.schedule(() => {
+      try {
+        t(), e();
+      } catch (i) {
+        s(i);
+      }
+    });
+  }) : R || (R = new Promise((e) => {
+    T.schedule(() => {
+      R = null, e();
+    });
+  }), R);
+}
+var Nt = class extends tt {
   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);
+    super(), this[L] = p.Atom | p.Writable, this._value = t, this._equal = e.equal ?? Object.is, e.sync && (this.flags |= C.SYNC), f && d.attachDebugInfo(this, "atom", this.id, e.name);
   }
   get isNotificationScheduled() {
-    return (this.flags & f.NOTIFICATION_SCHEDULED) !== 0;
+    return (this.flags & C.NOTIFICATION_SCHEDULED) !== 0;
   }
   get isSync() {
-    return (this.flags & f.SYNC) !== 0;
+    return (this.flags & C.SYNC) !== 0;
   }
   get value() {
-    const t = l.current;
+    const t = _.current;
     return t?.addDependency(this), this._value;
   }
   set value(t) {
     const e = this._value;
-    if (this._equal(e, t) || (this._value = t, this.version = j(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 && !b.isBatching ? this._notifying === 0 && this._flushNotifications() : b.schedule(this));
+    if (this._equal(e, t)) return;
+    this._value = t, this.version = K(this.version), f && d.trackUpdate(this.id, d.getDebugName(this));
+    const s = this.flags, i = C.NOTIFICATION_SCHEDULED;
+    if ((s & i) !== 0) return;
+    const n = this._slots;
+    if (n === null || n.size === 0) return;
+    this._pendingOldValue = e;
+    const r = s | i;
+    if (this.flags = r, (r & C.SYNC) !== 0 && !T.isBatching) {
+      this._notifying === 0 && this._flushNotifications();
+      return;
+    }
+    T.schedule(this);
   }
   execute() {
     this._flushNotifications();
   }
   _flushNotifications() {
-    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 || b.isBatching) break;
+    const t = C.NOTIFICATION_SCHEDULED, e = C.DISPOSED, s = C.SYNC, i = t | e;
+    let n = this.flags;
+    for (; (n & i) === t; ) {
+      const r = this._pendingOldValue;
+      this._pendingOldValue = void 0, this.flags = n &= ~t;
+      const o = this._value;
+      if (this._equal(o, r) || this._notifySubscribers(o, r), n = this.flags, (n & s) === 0 || T.isBatching) break;
     }
   }
   peek() {
     return this._value;
   }
   dispose() {
-    const t = this.flags;
-    (t & f.DISPOSED) === 0 && (this._slots?.clear(), this.flags = t | f.DISPOSED, this._value = void 0, this._pendingOldValue = void 0, this._equal = Object.is);
+    const t = this.flags, e = C.DISPOSED;
+    (t & e) === 0 && (this.flags = t | e, this._slots?.clear(), this._value = void 0, this._pendingOldValue = void 0, this._equal = Object.is);
   }
   _deepDirtyCheck() {
     return !1;
   }
-  [Symbol.dispose]() {
-    this.dispose();
-  }
 };
-function Ut(t, e = {}) {
-  return new Ot(t, e);
+function Pt(t, e = {}) {
+  return new Nt(t, e);
 }
-var { IDLE: D, DIRTY: E, PENDING: O, RESOLVED: I, REJECTED: T, HAS_ERROR: P, RECOMPUTING: y, DISPOSED: G, IS_COMPUTED: R, FORCE_COMPUTE: X } = Q, Nt = class extends K {
+var { IDLE: v, DIRTY: a, PENDING: b, RESOLVED: D, REJECTED: m, HAS_ERROR: V, RECOMPUTING: O, DISPOSED: z, IS_COMPUTED: F, FORCE_COMPUTE: Y } = $, bt = class extends tt {
   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 {
+    if (typeof t != "function") throw new w(l.COMPUTED_MUST_BE_FUNCTION);
+    if (super(), this[L] = p.Atom | p.Computed, this._promiseId = 0, this._trackEpoch = U.UNINITIALIZED, this._trackCount = 0, this._error = null, this._deps = new ct(), this._value = void 0, this.flags = F | a | v, this._equal = e.equal ?? Object.is, this._computation = t, this._defaultValue = "defaultValue" in e ? e.defaultValue : G, this._onError = e.onError ?? null, d.attachDebugInfo(this, "computed", this.id, e.name), e.lazy === !1) try {
       this._recompute();
     } catch {
     }
   }
   get isDirty() {
-    return (this.flags & E) !== 0;
+    return (this.flags & a) !== 0;
   }
   get isRejected() {
-    return (this.flags & T) !== 0;
+    return (this.flags & m) !== 0;
   }
   get isRecomputing() {
-    return (this.flags & y) !== 0;
-  }
-  get _hasErrorInternal() {
-    return (this.flags & P) !== 0;
-  }
-  _track() {
-    l.current?.addDependency(this);
+    return (this.flags & O) !== 0;
   }
   get value() {
-    const t = l.current;
-    t?.addDependency(this);
-    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 t = _.current;
+    t !== null && t.addDependency(this);
+    const e = this.flags;
+    if ((e & (D | a | v | z | O)) === D) return this._value;
+    if ((e & z) !== 0) throw new w(l.COMPUTED_DISPOSED);
+    if ((e & O) !== 0) {
       const n = this._defaultValue;
-      if (n !== B) return n;
-      throw new A(h.COMPUTED_CIRCULAR_DEPENDENCY);
+      if (n !== G) return n;
+      throw new w(l.COMPUTED_CIRCULAR_DEPENDENCY);
     }
-    if ((e & (E | D)) !== 0) {
+    if ((e & (a | v)) !== 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;
+      if ((e & (v | Y)) !== 0 || n.size === 0 || this._isDirty() ? this._recompute() : this.flags &= ~a, (this.flags & D) !== 0) return this._value;
     }
-    const s = this._defaultValue, i = s !== B;
-    if ((e & O) !== 0) {
+    const s = this._defaultValue, i = s !== G;
+    if ((this.flags & b) !== 0) {
       if (i) return s;
-      throw new A(h.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+      throw new w(l.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
     }
-    if ((e & T) !== 0) {
+    if ((this.flags & m) !== 0) {
       if (i) return s;
       throw this._error;
     }
@@ -804,16 +850,16 @@ var { IDLE: D, DIRTY: E, PENDING: O, RESOLVED: I, REJECTED: T, HAS_ERROR: P, REC
     return this._value;
   }
   get state() {
-    const t = l.current;
-    t?.addDependency(this);
+    const t = _.current;
+    t !== null && t.addDependency(this);
     const e = this.flags;
-    return (e & I) !== 0 ? U.RESOLVED : (e & O) !== 0 ? U.PENDING : (e & T) !== 0 ? U.REJECTED : U.IDLE;
+    return (e & D) !== 0 ? P.RESOLVED : (e & b) !== 0 ? P.PENDING : (e & m) !== 0 ? P.REJECTED : P.IDLE;
   }
   get hasError() {
-    const t = l.current;
-    if (t?.addDependency(this), (this.flags & (T | P)) !== 0) return !0;
+    const t = _.current;
+    if (t !== null && t.addDependency(this), (this.flags & (m | V)) !== 0) return !0;
     const e = this._deps;
-    return e.hasComputeds ? M(() => {
+    return e.hasComputeds ? X(() => {
       const s = e.size;
       for (let i = 0; i < s; i++) if (e.getAt(i)?.node.hasError) return !0;
       return !1;
@@ -823,204 +869,196 @@ var { IDLE: D, DIRTY: E, PENDING: O, RESOLVED: I, REJECTED: T, HAS_ERROR: P, REC
     return !this.hasError;
   }
   get errors() {
-    const t = l.current;
-    t?.addDependency(this);
+    const t = _.current;
+    t !== null && t.addDependency(this);
     const e = this._error, s = this._deps;
     if (!s.hasComputeds)
-      return e == null ? et : Object.freeze([e]);
+      return e === null ? it : Object.freeze([e]);
     const i = [];
-    return e != null && i.push(e), M(() => {
+    return e !== null && i.push(e), X(() => {
       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);
+        o !== void 0 && (o.flags & F) !== 0 && this._accumulateErrors(o, i);
       }
-    }), i.length === 0 ? et : Object.freeze(i);
+    }), i.length === 0 ? it : Object.freeze(i);
   }
   _accumulateErrors(t, e) {
     const s = t._error;
-    s != null && !e.includes(s) && e.push(s);
+    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);
+      o !== void 0 && (o.flags & F) !== 0 && this._accumulateErrors(o, e);
     }
   }
   get lastError() {
-    const t = l.current;
-    return t?.addDependency(this), this._error;
+    const t = _.current;
+    return t !== null && t.addDependency(this), this._error;
   }
   get isPending() {
-    const t = l.current;
-    return t?.addDependency(this), (this.flags & O) !== 0;
+    const t = _.current;
+    return t !== null && t.addDependency(this), (this.flags & b) !== 0;
   }
   get isResolved() {
-    const t = l.current;
-    return t?.addDependency(this), (this.flags & I) !== 0;
+    const t = _.current;
+    return t !== null && t.addDependency(this), (this.flags & D) !== 0;
   }
   invalidate() {
-    this.flags |= X, this._markDirty();
+    this.flags |= Y, this._markDirty();
   }
   dispose() {
-    (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();
+    (this.flags & z) === 0 && (this._deps.disposeAll(), this._slots !== null && this._slots.clear(), this.flags = z | a | v, this._error = null, this._value = void 0, this._hotIndex = -1);
   }
   addDependency(t) {
     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;
+    const s = this._trackCount++, i = this._deps;
+    let n = null;
+    if (s < 4) s === 0 ? n = i._s0 : s === 1 ? n = i._s1 : s === 2 ? n = i._s2 : n = i._s3;
+    else {
+      const r = i._overflow;
+      r !== null && (n = r[s - 4] ?? null);
+    }
+    if (n !== null && n.node === t) n.version = t.version;
     else if (!i.claimExisting(t, s)) {
-      const r = new W(t, t.version, t.subscribe(this));
+      const r = new q(t, t.version, t.subscribe(this));
       i.insertNew(s, r);
     }
-    (t.flags & R) !== 0 && (i.hasComputeds = !0);
+    (t.flags & F) !== 0 && (i.hasComputeds = !0);
   }
   _recompute() {
-    if (this.isRecomputing) return;
-    this.flags = (this.flags | y) & ~X, this._trackEpoch = J(), this._trackCount = 0, this._deps.prepareTracking(), this._hotIndex = -1;
+    if ((this.flags & O) !== 0) return;
+    this.flags = (this.flags | O) & ~Y, this._trackEpoch = et(), this._trackCount = 0, this._deps.prepareTracking(), this._hotIndex = -1;
     let t = !1;
     try {
-      const e = l.run(this, this._fn);
-      this._deps.truncateFrom(this._trackCount), t = !0, q(e) ? this._handleAsyncComputation(e) : this._finalizeResolution(e);
+      const e = _.run(this, this._computation);
+      this._deps.truncateFrom(this._trackCount), t = !0, Z(e) ? this._handleAsyncComputation(e) : this._finalizeResolution(e);
     } catch (e) {
       if (!t) try {
         this._deps.truncateFrom(this._trackCount);
       } catch (s) {
-        _ && console.warn("[atom-effect] _commitDeps failed during error recovery:", s);
+        f && console.warn("[atom-effect] _commitDeps failed during error recovery:", s);
       }
-      this._handleError(e, h.COMPUTED_COMPUTATION_FAILED, !0);
+      this._handleError(e, l.COMPUTED_COMPUTATION_FAILED, !0);
     } finally {
-      this._trackEpoch = w.UNINITIALIZED, this._trackCount = 0, this.flags &= ~y;
+      this._trackEpoch = U.UNINITIALIZED, this._trackCount = 0, this.flags &= ~O;
     }
   }
   _handleAsyncComputation(t) {
-    this.flags = (this.flags | O) & ~(D | E | I | T), this._notifySubscribers(void 0, void 0), this._promiseId = (this._promiseId + 1) % ft.MAX_PROMISE_ID;
+    this.flags = (this.flags | b) & ~(v | a | D | m), this._notifySubscribers(void 0, void 0), this._promiseId = (this._promiseId + 1) % Et.MAX_PROMISE_ID;
     const e = this._promiseId;
     t.then((s) => {
       if (e === this._promiseId) {
         if (this._isDirty()) return this._markDirty();
         this._finalizeResolution(s), this._notifySubscribers(s, void 0);
       }
-    }, (s) => e === this._promiseId && this._handleError(s, h.COMPUTED_ASYNC_COMPUTATION_FAILED));
+    }, (s) => e === this._promiseId && this._handleError(s, l.COMPUTED_ASYNC_COMPUTATION_FAILED));
   }
   _handleError(t, e, s = !1) {
-    const i = N(t, A, e);
-    if ((!this.isRejected || this._error !== i) && (this.version = j(this.version)), this._error = i, this.flags = this.flags & ~(D | E | O | I) | T | P, this._onError) try {
+    const i = A(t, w, e);
+    if ((!this.isRejected || this._error !== i) && (this.version = K(this.version)), this._error = i, this.flags = this.flags & ~(v | a | b | D) | m | V, this._onError) try {
       this._onError(i);
     } catch (n) {
-      console.error(h.CALLBACK_ERROR_IN_ERROR_HANDLER, n);
+      console.error(l.CALLBACK_ERROR_IN_ERROR_HANDLER, n);
     }
     if (this._notifySubscribers(void 0, void 0), s) throw i;
   }
   _finalizeResolution(t) {
     const e = this.flags;
-    ((e & I) === 0 || !this._equal(this._value, t)) && (this.version = j(this.version)), this._value = t, this._error = null, this.flags = (e | I) & ~(D | E | O | T | P);
+    ((e & D) === 0 || !this._equal(this._value, t)) && (this.version = K(this.version)), this._value = t, this._error = null, this.flags = (e | D) & ~(v | a | b | m | V);
   }
   execute() {
     this._markDirty();
   }
   _markDirty() {
     const t = this.flags;
-    (t & (y | E)) === 0 && (this.flags = t | E, d.trackUpdate(this.id, d.getDebugName(this)), this._notifySubscribers(void 0, void 0));
+    (t & (O | a)) === 0 && (this.flags = t | a, d.trackUpdate(this.id, d.getDebugName(this)), this._notifySubscribers(void 0, void 0));
   }
   _deepDirtyCheck() {
-    const t = this._deps;
-    return M(() => {
-      const e = t.size;
-      for (let s = 0; s < e; s++) {
+    const t = this._deps, e = t.size, s = this._hotIndex;
+    return X(() => {
+      if (s !== -1 && s < e) {
         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 !== i.version)
-          return this._hotIndex = s, !0;
+        if (i !== null && this._checkLinkDirty(i)) return !0;
+      }
+      for (let i = 0; i < e; i++) {
+        if (i === s) continue;
+        const n = t.getAt(i);
+        if (n !== null && this._checkLinkDirty(n))
+          return this._hotIndex = i, !0;
       }
       return this._hotIndex = -1, !1;
     });
   }
+  _checkLinkDirty(t) {
+    const e = t.node;
+    if ((e.flags & F) !== 0) try {
+      e.value;
+    } catch {
+      f && console.warn(`[atom-effect] Dependency #${e.id} threw during check`);
+    }
+    return e.version !== t.version;
+  }
 };
-function Lt(t, e = {}) {
-  return new Nt(t, e);
+function xt(t, e = {}) {
+  return new bt(t, e);
 }
-var bt = class extends K {
+var At = class extends tt {
   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 = () => b.schedule(this), d.attachDebugInfo(this, "effect", this.id, e.name);
+    super(), this[L] = p.Effect, this._currentEpoch = U.UNINITIALIZED, this._lastFlushEpoch = U.UNINITIALIZED, this._executionsInEpoch = 0, this._executionCount = 0, this._windowStart = 0, this._windowCount = 0, this._execId = 0, this._trackCount = 0, this._cleanup = null, this._deps = new ct(), this._fn = t, this._onError = e.onError ?? null, this._sync = e.sync ?? !1, this._maxExecutions = e.maxExecutionsPerSecond ?? g.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = e.maxExecutionsPerFlush ?? g.MAX_EXECUTIONS_PER_EFFECT, this._sync ? this._notifyCallback = () => this.execute() : this._notifyCallback = () => T.schedule(this), d.attachDebugInfo(this, "effect", this.id, e.name);
   }
   run() {
-    if (this.isDisposed) throw new m(h.EFFECT_DISPOSED);
+    if (this.isDisposed) throw new N(l.EFFECT_DISPOSED);
     this.execute(!0);
   }
   dispose() {
     this.isDisposed || (this.flags |= S.DISPOSED, this._execCleanup(), this._deps?.disposeAll());
   }
-  [Symbol.dispose]() {
-    this.dispose();
-  }
   addDependency(t) {
-    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:
-        n = i._s0;
-        break;
-      case 1:
-        n = i._s1;
-        break;
-      case 2:
-        n = i._s2;
-        break;
-      case 3:
-        n = i._s3;
-        break;
-      default:
-        n = i.getAt(s);
+    if ((this.flags & S.EXECUTING) === 0 || t._lastSeenEpoch === this._currentEpoch) return;
+    t._lastSeenEpoch = this._currentEpoch;
+    const e = this._trackCount++, s = this._deps, i = t.version;
+    let n = null;
+    if (e < 4) e === 0 ? n = s._s0 : e === 1 ? n = s._s1 : e === 2 ? n = s._s2 : n = s._s3;
+    else {
+      const r = s._overflow;
+      r !== null && (n = r[e - 4] ?? null);
     }
-    n != null && n.node === t ? n.version = t.version : i.claimExisting(t, s) || this._insertNewDependency(t, s), t.isComputed && (i.hasComputeds = !0);
+    n !== null && n.node === t ? n.version = i : s.claimExisting(t, e) || this._insertNewDependency(t, e, i), t.isComputed && !s.hasComputeds && (s.hasComputeds = !0);
   }
-  _insertNewDependency(t, e) {
-    let s;
+  _insertNewDependency(t, e, s) {
+    let i;
     try {
-      const i = t.subscribe(this._notifyCallback);
-      s = new W(t, t.version, i);
-    } catch (i) {
-      const n = N(i, m, h.EFFECT_EXECUTION_FAILED);
-      if (console.error(n), this._onError) try {
-        this._onError(n);
+      i = new q(t, s, t.subscribe(this._notifyCallback));
+    } catch (n) {
+      const r = A(n, N, l.EFFECT_EXECUTION_FAILED);
+      if (console.error(r), this._onError) try {
+        this._onError(r);
       } catch {
       }
-      s = new W(t, t.version, void 0);
+      i = new q(t, s, void 0);
     }
-    this._deps.insertNew(e, s);
+    this._deps.insertNew(e, i);
   }
   execute(t = !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;
+    if (!t && s.physicalSize > 0 && !this._isDirty()) return;
+    this._checkInfiniteLoops(), d.trackUpdate(this.id, d.getDebugName(this)), this.flags = e | S.EXECUTING, this._execCleanup(), this._currentEpoch = et(), this._trackCount = 0, s.prepareTracking(), this._hotIndex = -1;
     let i = !1;
     try {
-      const n = l.run(this, this._fn);
-      s.truncateFrom(this._trackCount), i = !0, q(n) ? this._handleAsyncResult(n) : this._cleanup = typeof n == "function" ? n : null;
+      const n = _.run(this, this._fn);
+      s.truncateFrom(this._trackCount), i = !0, typeof n == "function" ? this._cleanup = n : Z(n) ? this._handleAsyncResult(n) : this._cleanup = null;
     } catch (n) {
       if (!i) try {
         s.truncateFrom(this._trackCount);
       } catch (r) {
-        _ && console.warn("[atom-effect] _commitDeps failed during error recovery:", r);
+        f && console.warn("[atom-effect] _commitDeps failed during error recovery:", r);
       }
       this._handleExecutionError(n), this._cleanup = null;
     } finally {
@@ -1030,40 +1068,50 @@ var bt = class extends K {
   _handleAsyncResult(t) {
     const e = ++this._execId;
     t.then((s) => {
-      if (e !== this._execId || this.isDisposed) {
+      if (e !== this._execId || (this.flags & S.DISPOSED) !== 0) {
         if (typeof s == "function") try {
           s();
         } catch (i) {
-          this._handleExecutionError(i, h.EFFECT_CLEANUP_FAILED);
+          this._handleExecutionError(i, l.EFFECT_CLEANUP_FAILED);
         }
         return;
       }
       typeof s == "function" && (this._cleanup = s);
     }, (s) => e === this._execId && this._handleExecutionError(s));
   }
-  _deepDirtyCheck() {
-    const t = l.current;
-    l.current = null;
-    const e = this._deps;
-    try {
-      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;
+  _isDirty() {
+    const t = this._deps, e = t.size;
+    if (e === 0) return !1;
+    const s = this._hotIndex;
+    if (s !== -1 && s < e) {
+      const i = t.getAt(s);
+      if (i !== null) {
+        const n = i.node;
+        if (!n.isComputed && n.version !== i.version) return !0;
       }
-      return !1;
-    } finally {
-      l.current = t;
     }
+    return this._deepDirtyCheck();
   }
-  _tryPullComputed(t) {
+  _deepDirtyCheck() {
+    const t = this._deps, e = t.size, s = this._hotIndex, i = _.current;
+    _.current = null;
     try {
-      t.value;
-    } catch {
-      _ && console.warn(`[atom-effect] Dependency #${t.id} threw during dirty check`);
+      for (let n = 0; n < e; n++) {
+        if (n === s) continue;
+        const r = t.getAt(n);
+        if (r === null) continue;
+        const o = r.node;
+        if (o.isComputed) try {
+          o.value;
+        } catch {
+          f && console.warn(`[atom-effect] Dependency #${o.id} error in check`);
+        }
+        if (o.version !== r.version)
+          return this._hotIndex = n, !0;
+      }
+      return this._hotIndex = -1, !1;
+    } finally {
+      _.current = i;
     }
   }
   _execCleanup() {
@@ -1073,23 +1121,23 @@ var bt = class extends K {
       try {
         t();
       } catch (e) {
-        this._handleExecutionError(e, h.EFFECT_CLEANUP_FAILED);
+        this._handleExecutionError(e, l.EFFECT_CLEANUP_FAILED);
       }
     }
   }
   _checkInfiniteLoops() {
     const t = Tt();
-    this._lastFlushEpoch !== t && (this._lastFlushEpoch = t, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), mt() > C.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, _ && this._checkFrequencyLimit();
+    this._lastFlushEpoch !== t && (this._lastFlushEpoch = t, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), mt() > g.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, f && this._checkFrequencyLimit();
   }
   _checkFrequencyLimit() {
     if (!Number.isFinite(this._maxExecutions)) return;
     const t = Date.now();
-    if (t - this._windowStart >= Y.EFFECT_FREQUENCY_WINDOW) {
+    if (t - this._windowStart >= W.EFFECT_FREQUENCY_WINDOW) {
       this._windowStart = t, this._windowCount = 1;
       return;
     }
     if (++this._windowCount > this._maxExecutions) {
-      const e = new m(h.EFFECT_FREQUENCY_LIMIT_EXCEEDED);
+      const e = new N(l.EFFECT_FREQUENCY_LIMIT_EXCEEDED);
       throw this.dispose(), this._handleExecutionError(e), e;
     }
   }
@@ -1100,102 +1148,103 @@ var bt = class extends K {
     return (this.flags & S.EXECUTING) !== 0;
   }
   _throwInfiniteLoopError(t) {
-    const e = new m(`Infinite loop detected (${t}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${Z}`);
+    const e = new N(`Infinite loop detected (${t}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${st}`);
     throw this.dispose(), console.error(e), e;
   }
-  _handleExecutionError(t, e = h.EFFECT_EXECUTION_FAILED) {
-    const s = N(t, m, e);
+  _handleExecutionError(t, e = l.EFFECT_EXECUTION_FAILED) {
+    const s = A(t, N, e);
     if (console.error(s), this._onError) try {
       this._onError(s);
     } catch (i) {
-      console.error(N(i, m, h.CALLBACK_ERROR_IN_ERROR_HANDLER));
+      console.error(A(i, N, l.CALLBACK_ERROR_IN_ERROR_HANDLER));
     }
   }
 };
-function Pt(t, e = {}) {
-  if (typeof t != "function") throw new m(h.EFFECT_MUST_BE_FUNCTION);
-  const s = new bt(t, e);
+function Mt(t, e = {}) {
+  if (typeof t != "function") throw new N(l.EFFECT_MUST_BE_FUNCTION);
+  const s = new At(t, e);
   return s.execute(), s;
 }
-var lt = /^(?:__proto__|constructor|prototype)$/;
-function _t(t, e, s, i) {
+function ft(t, e, s, i) {
   if (s === e.length) return i;
   const n = e[s];
-  if (lt.test(n)) return t;
-  const r = t != null && typeof t == "object" ? t : {}, o = r[n], c = _t(o, e, s + 1, i);
-  if (Object.is(o, c)) return t;
+  if (n === "__proto__" || n === "constructor" || n === "prototype") return t;
+  const r = t != null && typeof t == "object" ? t : {}, o = r[n], u = ft(o, e, s + 1, i);
+  if (Object.is(o, u)) return t;
   if (Array.isArray(r)) {
-    const a = r.slice(), v = Number(n);
-    return n.trim() !== "" && Number.isInteger(v) && v >= 0 ? a[v] = c : a[n] = c, a;
+    const I = r.slice(), E = +n;
+    return n.trim() !== "" && E >= 0 && E % 1 === 0 ? I[E] = u : I[n] = u, I;
   }
-  return {
-    ...r,
-    [n]: c
-  };
+  const c = { ...r };
+  return c[n] = u, c;
 }
-function x(t, e) {
+function k(t, e) {
   let s = t;
   const i = e.length;
   for (let n = 0; n < i; n++) {
     if (s == null) return;
     const r = e[n];
-    if (lt.test(r)) return;
+    if (r === "__proto__" || r === "constructor" || r === "prototype") return;
     s = s[r];
   }
   return s;
 }
 function at(t, e) {
-  const s = e.includes(".") ? e.split(".") : [e], i = /* @__PURE__ */ new Set(), n = () => {
-    i.forEach((r) => r()), i.clear();
-  };
+  const s = e.includes(".") ? e.split(".") : [e], i = /* @__PURE__ */ new Set();
   return {
     get value() {
-      return x(t.value, s);
+      return k(t.value, s);
     },
     set value(r) {
-      const o = t.peek(), c = _t(o, s, 0, r);
-      c !== o && (t.value = c);
+      const o = t.peek(), u = ft(o, s, 0, r);
+      u !== o && (t.value = u);
     },
-    peek: () => x(t.peek(), s),
+    peek: () => k(t.peek(), s),
     subscribe(r) {
-      const o = t.subscribe((c, a) => {
-        const v = x(c, s), tt = x(a, s);
-        Object.is(v, tt) || r(v, tt);
+      let o = k(t.peek(), s);
+      const u = t.subscribe((c) => {
+        const I = k(c, s);
+        if (!Object.is(I, o)) {
+          const E = o;
+          o = I, r(I, E);
+        }
       });
-      return i.add(o), () => {
-        o(), i.delete(o);
+      return i.add(u), () => {
+        u(), i.delete(u);
       };
     },
     subscriberCount: () => i.size,
-    dispose: n,
-    [Symbol.dispose]: n,
-    [F]: p.Atom | p.Writable
+    dispose: () => {
+      i.forEach((r) => r()), i.clear();
+    },
+    [L]: p.Atom | p.Writable
   };
 }
-var xt = (t, e) => at(t, e), Mt = (t) => (e) => at(t, e);
+var zt = (t, e) => at(t, e), kt = (t) => (e) => at(t, e);
 export {
-  U as AsyncState,
-  g as AtomError,
-  A as ComputedError,
-  Y as DEBUG_CONFIG,
-  m as EffectError,
-  C as SCHEDULER_CONFIG,
-  L as SchedulerError,
-  Ut as atom,
+  P as AsyncState,
+  y as AtomError,
+  w as ComputedError,
+  W as DEBUG_CONFIG,
+  N as EffectError,
+  g as SCHEDULER_CONFIG,
+  x as SchedulerError,
+  Lt as aeNextTick,
+  Pt as atom,
   at as atomLens,
-  Ft as batch,
-  xt as composeLens,
-  Lt as computed,
-  Pt as effect,
-  x as getPathValue,
-  b as globalScheduler,
-  yt as isAtom,
+  Ut as batch,
+  zt as composeLens,
+  xt as computed,
+  Mt as effect,
+  k as getPathValue,
+  T as globalScheduler,
+  wt as isAtom,
   Rt as isComputed,
-  wt as isEffect,
-  Mt as lensFor,
+  Ft as isEffect,
+  kt as lensFor,
   d as runtimeDebug,
-  _t as setDeepValue,
-  M as untracked
+  ft as setDeepValue,
+  X as untracked
 };
 
 //# sourceMappingURL=index.mjs.map