@but212/atom-effect 0.30.1 → 0.32.0

package/dist/index.mjs

@@ -1,1201 +1,1366 @@
-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
-}, 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({
+var E = {
+  CORE: 0,
+  COMPUTED: 8,
+  ASYNC: 16,
+  PRIMITIVE: 24
+}, c = {
+  DISPOSED: 1 << E.CORE + 0,
+  IS_COMPUTED: 1 << E.CORE + 1,
+  DIRTY: 1 << E.COMPUTED + 0,
+  RECOMPUTING: 1 << E.COMPUTED + 1,
+  HAS_ERROR: 1 << E.COMPUTED + 2,
+  FORCE_COMPUTE: 1 << E.COMPUTED + 3,
+  IDLE: 1 << E.ASYNC + 0,
+  PENDING: 1 << E.ASYNC + 1,
+  RESOLVED: 1 << E.ASYNC + 2,
+  REJECTED: 1 << E.ASYNC + 3,
+  ATOM_SYNC: 1 << E.PRIMITIVE + 0,
+  ATOM_NOTIFICATION_SCHEDULED: 1 << E.PRIMITIVE + 1,
+  EFFECT_EXECUTING: 1 << E.PRIMITIVE + 4
+}, ke = Object.freeze({
+  ASYNC_STATE: c.IDLE | c.PENDING | c.RESOLVED | c.REJECTED,
+  COMPUTED_DIRTY_MASK: c.DIRTY | c.RECOMPUTING | c.FORCE_COMPUTE
+}), H = 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
-}), C = Object.freeze({
+}), v = Object.freeze({
+  DISPOSED: c.DISPOSED,
+  EXECUTING: c.EFFECT_EXECUTING
+}), y = Object.freeze({
+  DISPOSED: c.DISPOSED,
+  IS_COMPUTED: c.IS_COMPUTED,
+  DIRTY: c.DIRTY,
+  IDLE: c.IDLE,
+  PENDING: c.PENDING,
+  RESOLVED: c.RESOLVED,
+  REJECTED: c.REJECTED,
+  RECOMPUTING: c.RECOMPUTING,
+  HAS_ERROR: c.HAS_ERROR,
+  FORCE_COMPUTE: c.FORCE_COMPUTE
+}), g = Object.freeze({
+  DISPOSED: c.DISPOSED,
+  SYNC: c.ATOM_SYNC,
+  NOTIFICATION_SCHEDULED: c.ATOM_NOTIFICATION_SCHEDULED
+}), m = 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({
+}), Ct = 1073741823, et = Object.freeze({
   WARN_INFINITE_LOOP: !0,
   EFFECT_FREQUENCY_WINDOW: 1e3,
   LOOP_THRESHOLD: 100
-}), ft = Object.freeze({ MAX_PROMISE_ID: k }), w = Object.freeze({
+}), L = Object.freeze({
   UNINITIALIZED: -1,
   MIN: 1
-}), 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;
-  }
-  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";
-  }
-}, m = class extends g {
-  constructor(t, e = null, s = !1, i) {
-    super(t, e, s, i), this.name = "EffectError";
-  }
-}, L = class extends g {
-  constructor(t, e = null, s = !1, i) {
-    super(t, e, s, i), this.name = "SchedulerError";
+}), Vt = () => {
+  try {
+    return !!(typeof globalThis < "u" && globalThis.__ATOM_DEBUG__ || typeof sessionStorage < "u" && sessionStorage.getItem("__ATOM_DEBUG__") === "true");
+  } catch {
+    return !1;
   }
-}, 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",
-  COMPUTED_ASYNC_COMPUTATION_FAILED: "Async computation execution failed",
-  COMPUTED_CIRCULAR_DEPENDENCY: "Circular dependency detected",
-  COMPUTED_DISPOSED: "Attempted to access disposed computed",
-  ATOM_SUBSCRIBER_MUST_BE_FUNCTION: "Subscriber must be a function or Subscriber object",
-  ATOM_INDIVIDUAL_SUBSCRIBER_FAILED: "Subscriber execution failed",
-  EFFECT_MUST_BE_FUNCTION: "Effect target must be a function",
-  EFFECT_EXECUTION_FAILED: "Effect execution failed",
-  EFFECT_CLEANUP_FAILED: "Effect cleanup failed",
-  EFFECT_DISPOSED: "Attempted to run disposed effect",
-  SCHEDULER_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 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);
+}, Yt = () => {
+  try {
+    return !1;
+  } catch {
+    return !1;
   }
-  return new e(g.format("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 {
+}, G = {
+  node: typeof process < "u" && process.env && process.env.NODE_ENV !== "production",
+  bundler: typeof __DEV__ < "u" && !!__DEV__,
+  esm: typeof process > "u" && Yt(),
+  runtime: Vt()
+}, d = G.node || G.bundler || G.esm || G.runtime, jt = Object.freeze([]), Xt = /* @__PURE__ */ Symbol.for("atom-effect.Option"), Wt = /* @__PURE__ */ Symbol.for("atom-effect.Result"), Pe = Object.freeze({
+  ok: !1,
+  value: void 0,
+  [Xt]: !0
+}), Le = Object.freeze({
+  ok: !0,
+  value: void 0,
+  error: void 0,
+  [Wt]: !0
+}), $t = [
+  0,
+  1,
+  0,
+  2,
+  0,
+  1,
+  0,
+  3,
+  0,
+  1,
+  0,
+  2,
+  0,
+  1,
+  0,
+  -1
+], _ = 4, Kt = 15, St = 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.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));
-    }, 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];
-    };
-  }
-}, It = {
-  enabled: !1,
-  warnInfiniteLoop: !1,
-  warn: () => {
-  },
-  registerNode: () => {
-  },
-  attachDebugInfo: () => {
-  },
-  trackUpdate: () => {
-  },
-  dumpGraph: () => [],
-  getDebugName: () => {
-  },
-  getDebugType: () => {
+    this._count = 0, this._actualCount = 0, this._mask = 0, this._s0 = null, this._s1 = null, this._s2 = null, this._s3 = null, this._overflow = null, this._freeIndices = null, this._lockCount = 0, this._pendingCompact = !1;
   }
-}, d = _ ? new pt() : It, Ct = 1, gt = () => Ct++ | 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;
+  _firstFreeSlot(t) {
+    return $t[t & Kt];
   }
   _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;
-    }
+    if (t < _) {
+      const s = 1 << t;
+      e === null ? this._mask &= ~s : this._mask |= s, t === 0 ? this._s0 = e : t === 1 ? this._s1 = e : t === 2 ? this._s2 = e : t === 3 && (this._s3 = e);
+    } else
+      this._overflow || (this._overflow = []), this._overflow[t - _] = e;
   }
   _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;
+    const e = this._mask, s = this._firstFreeSlot(e);
+    if (s !== -1)
+      return this._mask = e | 1 << s, s === 0 ? this._s0 = t : s === 1 ? this._s1 = t : s === 2 ? this._s2 = t : this._s3 = t, s;
+    this._overflow || (this._overflow = []);
+    const r = this._overflow, i = this._freeIndices;
+    if (i?.length) {
+      const n = i.pop();
+      return r[n] = t, n + _;
     }
-    return e.push(t), 4 + e.length - 1;
+    return r.push(t), _ - 1 + r.length;
   }
   _rawSwap(t, e) {
     if (t === e) return;
-    const s = this.getAt(t), i = this.getAt(e);
-    this._rawWrite(t, i), this._rawWrite(e, s);
+    const s = this.at(t), r = this.at(e);
+    this._rawWrite(t, r), this._rawWrite(e, s);
+  }
+  get length() {
+    return this._count;
   }
   get size() {
     return this._actualCount;
   }
-  get physicalSize() {
-    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;
+  at(t) {
+    if (t < _)
+      return t === 0 ? this._s0 : t === 1 ? this._s1 : t === 2 ? this._s2 : t === 3 ? this._s3 : null;
+    const e = this._overflow;
+    return e ? e[t - _] ?? null : 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));
+    const s = this.at(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--;
-  }
-  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--));
-    const e = this._overflow;
-    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--);
+    if (t === this._count - 1) {
+      if (this._count--, this._count > _) {
+        const e = this._overflow;
+        for (; this._count > _ && e[this._count - (_ + 1)] == null; ) this._count--;
       }
-      t <= 4 ? this._overflow = null : e.length = t - 4;
+      this._count <= _ && (this._count = 32 - Math.clz32(this._mask));
     }
-    this._count = t, this._actualCount < 0 && (this._actualCount = 0), this._freeIndices = null;
   }
-  _onItemRemoved(t) {
+  truncateFrom(t) {
+    const e = this._count;
+    if (!(t >= e)) {
+      for (let s = t; s < e; s++) this.at(s) !== null && this._actualCount--;
+      t < _ ? (this._mask &= (1 << t) - 1, t <= 0 && (this._s0 = null), t <= 1 && (this._s1 = null), t <= 2 && (this._s2 = null), t <= 3 && (this._s3 = null), this._overflow = null) : this._overflow && (this._overflow.length = t - _), this._count = t, this._freeIndices = null;
+    }
   }
-  add(t) {
+  push(t) {
     const e = this._rawAdd(t);
     return e >= this._count && (this._count = e + 1), this._actualCount++, e;
   }
   remove(t) {
-    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));
+    if (this._actualCount === 0) return !1;
+    const e = this._mask;
+    if (e & 1 && this._s0 === t) return this._removeAt(0);
+    if (e & 2 && this._s1 === t) return this._removeAt(1);
+    if (e & 4 && this._s2 === t) return this._removeAt(2);
+    if (e & 8 && this._s3 === t) return this._removeAt(3);
+    const s = this._overflow;
+    if (s) {
+      for (let r = 0, i = s.length; r < i; r++) if (s[r] === t)
+        return s[r] = null, this._actualCount--, this._shrinkPhysicalSizeFrom(r + _), this._freeIndices || (this._freeIndices = []), this._freeIndices.push(r), !0;
     }
-    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;
+    return !1;
+  }
+  _removeAt(t) {
+    return this._rawWrite(t, null), this._actualCount--, this._shrinkPhysicalSizeFrom(t), !0;
   }
   has(t) {
     if (this._actualCount === 0) return !1;
-    if (this._s0 === t || this._s1 === t || this._s2 === t || this._s3 === t) return !0;
-    const e = this._overflow;
-    return e !== null ? e.indexOf(t) !== -1 : !1;
+    const e = this._mask;
+    if (e & 1 && this._s0 === t || e & 2 && this._s1 === t || e & 4 && this._s2 === t || e & 8 && this._s3 === t) return !0;
+    const s = this._overflow;
+    if (s) {
+      for (let r = 0, i = s.length; r < i; r++) if (s[r] === t) return !0;
+    }
+    return !1;
   }
   forEach(t) {
-    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 (this._actualCount === 0) return;
+    const e = this._mask;
+    e & 1 && t(this._s0), e & 2 && t(this._s1), e & 4 && t(this._s2), e & 8 && t(this._s3);
+    const s = this._overflow;
+    if (s) for (let r = 0, i = s.length; r < i; r++) {
+      const n = s[r];
+      n != null && t(n);
+    }
+  }
+  some(t) {
+    if (this._actualCount === 0) return !1;
+    const e = this._mask;
+    if (e & 1 && t(this._s0) || e & 2 && t(this._s1) || e & 4 && t(this._s2) || e & 8 && t(this._s3)) return !0;
+    const s = this._overflow;
+    if (s) for (let r = 0, i = s.length; r < i; r++) {
+      const n = s[r];
+      if (n != null && t(n)) return !0;
+    }
+    return !1;
+  }
+  compact() {
+    if (this._lockCount > 0) {
+      this._pendingCompact = !0;
+      return;
+    }
+    const t = this._actualCount, e = this._count;
+    if (t === e) return;
+    if (t === 0) {
+      this.clear();
       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))
+    const r = this._overflow;
+    for (let i = 0; i < e; i++) {
+      const n = this.at(i);
+      if (n !== null && (i !== s && (this._rawWrite(s, n), this._rawWrite(i, null)), ++s === t))
         break;
     }
+    this._count = t, r !== null && (s <= _ ? this._overflow = null : r.length = s - _), this._freeIndices = null, this._pendingCompact = !1;
   }
-  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++);
-    }
-    this._count = this._actualCount, this._overflow !== null && (t <= 4 ? this._overflow = null : this._overflow.length = t - 4), this._freeIndices = null;
+  lock() {
+    this._lockCount++;
+  }
+  unlock() {
+    --this._lockCount === 0 && this._pendingCompact && this.compact();
   }
   clear() {
-    this._s0 = this._s1 = this._s2 = this._s3 = null, this._count = 0, this._actualCount = 0, this._overflow = null, this._freeIndices = null;
+    this._s0 = this._s1 = this._s2 = this._s3 = null, this._count = 0, this._actualCount = 0, this._mask = 0, this._overflow = null, this._freeIndices = null, this._pendingCompact = !1;
   }
   dispose() {
     this.clear();
   }
-}, ht = class extends ut {
-  constructor(...t) {
-    super(...t), this._map = null, this._SCAN_THRESHOLD = 32, this.hasComputeds = !1;
-  }
-  prepareTracking() {
-    this.hasComputeds = !1;
+  get isLocked() {
+    return this._lockCount > 0;
   }
-  _onItemRemoved(t) {
-    t.unsub?.();
-  }
-  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, 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;
+};
+function gt(t) {
+  return t instanceof Promise ? !0 : t === null || typeof t != "object" && typeof t != "function" ? !1 : typeof t.then == "function";
+}
+var Qt = Object.prototype.hasOwnProperty;
+function qt(t, e) {
+  if (t === e) return !0;
+  if (t === null || e === null || typeof t != "object" || typeof e != "object") return !1;
+  const s = t, r = e, i = Object.keys(s);
+  if (i.length !== Object.keys(r).length) return !1;
+  for (const n of i) if (!Qt.call(r, n) || !Object.is(s[n], r[n])) return !1;
+  return !0;
+}
+var b = class extends Error {
+  constructor(t, e = null, s = !0, r) {
+    super(t), this.cause = e, this.recoverable = s, this.code = r, this.name = "AtomError", Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
   }
-  _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);
-    }
+  getChain() {
+    const t = [], e = /* @__PURE__ */ new Set();
+    let s = this;
+    for (; s != null && !e.has(s); )
+      t.push(s), e.add(s), s = s?.cause;
     return t;
   }
-  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);
-    }
-    this._rawWrite(t, e), 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);
-    return this._map !== null && t.unsub && this._map.set(t.node, e), e;
+  toJSON(t = /* @__PURE__ */ new Set()) {
+    return t.has(this) ? {
+      name: this.name,
+      message: "[Circular Reference]",
+      recoverable: this.recoverable,
+      code: this.code
+    } : (t.add(this), {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      recoverable: this.recoverable,
+      stack: this.stack,
+      cause: Dt(this.cause, t)
+    });
   }
-  remove(t) {
-    throw new Error("remove() prohibited");
+  static format(t, e, s) {
+    return `${t} (${e}): ${s}`;
   }
-  compact() {
+}, w = class extends b {
+  constructor(...t) {
+    super(...t), this.name = "ComputedError";
   }
-  truncateFrom(t) {
-    super.truncateFrom(t), this._map !== null && (this._map = null);
+}, R = class extends b {
+  constructor(t, e = null, s = !1, r) {
+    super(t, e, s, r), this.name = "EffectError";
   }
-  disposeAll() {
-    this.truncateFrom(0), this.hasComputeds = !1;
+}, nt = class extends b {
+  constructor(t, e = null, s = !1, r) {
+    super(t, e, s, r), this.name = "SchedulerError";
   }
-}, F = /* @__PURE__ */ Symbol.for("atom-effect/brand"), p = {
+}, a = {
+  COMPUTED_MUST_BE_FUNCTION: "Computed target must be a function",
+  COMPUTED_ASYNC_PENDING_NO_DEFAULT: "Async computation pending with no default value",
+  COMPUTED_COMPUTATION_FAILED: "Computation execution failed",
+  COMPUTED_ASYNC_COMPUTATION_FAILED: "Async computation execution failed",
+  COMPUTED_CIRCULAR_DEPENDENCY: "Circular dependency detected",
+  COMPUTED_DISPOSED: "Attempted to access disposed computed",
+  ATOM_SUBSCRIBER_MUST_BE_FUNCTION: "Subscriber must be a function or Subscriber object",
+  ATOM_INDIVIDUAL_SUBSCRIBER_FAILED: "Subscriber execution failed",
+  EFFECT_MUST_BE_FUNCTION: "Effect target must be a function",
+  EFFECT_EXECUTION_FAILED: "Effect execution failed",
+  EFFECT_CLEANUP_FAILED: "Effect cleanup failed",
+  EFFECT_DISPOSED: "Attempted to run disposed effect",
+  SCHEDULER_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 X(t, e, s) {
+  const r = Jt(t);
+  return new e(b.format(r.name, s, r.message), t, r.recoverable, r.code);
+}
+function Jt(t) {
+  return t instanceof b ? {
+    name: t.name,
+    message: t.message,
+    recoverable: t.recoverable,
+    code: t.code
+  } : t instanceof Error ? {
+    name: t.name,
+    message: t.message,
+    recoverable: !0,
+    code: t?.code
+  } : {
+    name: "Unexpected error",
+    message: String(t),
+    recoverable: !0,
+    code: void 0
+  };
+}
+function Dt(t, e) {
+  return t == null || typeof t != "object" ? t : e.has(t) ? "[Circular Reference]" : t instanceof b ? t.toJSON(e) : t instanceof Error ? (e.add(t), {
+    name: t.name,
+    message: t.message,
+    stack: t.stack,
+    cause: Dt(t.cause, e)
+  }) : t;
+}
+var A = /* @__PURE__ */ Symbol.for("atom-effect/brand"), h = {
   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 yt(t) {
-  return $(t, p.Atom);
-}
-function Rt(t) {
-  return $(t, p.Computed);
-}
-function wt(t) {
-  return $(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";
-}
-var W = class {
-  constructor(t, e, s = void 0) {
-    this.node = t, this.version = e, this.unsub = s;
-  }
-}, Dt = 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();
-    });
-  }
-}, St = class {
+}, st = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), Zt = {
+  [h.Atom]: "atom",
+  [h.Computed]: "computed",
+  [h.Effect]: "effect"
+}, te = h.Atom | h.Computed | h.Effect, J = "[Atom Effect]", U = () => {
+}, ee = class {
   constructor() {
-    this.current = null;
+    this.enabled = !0, this.warnInfiniteLoop = et.WARN_INFINITE_LOOP, this._updateCounts = /* @__PURE__ */ new Map(), this._registry = /* @__PURE__ */ new Map(), this.trackGraph = !1, this._finalizer = new FinalizationRegistry((t) => {
+      this._registry.delete(t), this._updateCounts.delete(t);
+    }), this._threshold = et.LOOP_THRESHOLD, this._cleanupScheduled = !1, this._failedEvaluations = /* @__PURE__ */ new Set(), this._failureCleanupScheduled = !1, this._resetUpdateCounts = () => {
+      this._updateCounts.clear(), this._cleanupScheduled = !1;
+    }, this._resetFailedEvaluations = () => {
+      this._failedEvaluations.clear(), this._failureCleanupScheduled = !1;
+    };
+  }
+  warn(t, e) {
+    this.enabled && t && console.warn(`${J} ${e}`);
+  }
+  registerNode(t) {
+    const e = t.id, s = this._getOrCreateMetadata(t, e);
+    s.ref = new WeakRef(t), this._finalizer.register(t, e);
+  }
+  attachDebugInfo(t, e, s, r) {
+    if (!this.enabled || r === void 0 && !this.trackGraph) return;
+    let i = this._registry.get(s);
+    i ? (r !== void 0 && (i.name = r), i.type = e) : (i = {
+      name: r ?? `${e}_${s}`,
+      type: e
+    }, this._registry.set(s, i)), this.registerNode(t);
+  }
+  trackUpdate(t, e) {
+    if (!this.enabled || !this.warnInfiniteLoop) return;
+    const s = this._updateCounts, r = (s.get(t) || 0) + 1;
+    s.set(t, r), r > this._threshold && r === this._threshold + 1 && console.warn(`${J} Infinite loop detected for ${e ?? `dependency ${t}`}. Detected ${r} updates within a single execution scope, exceeding the threshold of ${this._threshold}.`), this._cleanupScheduled || (this._cleanupScheduled = !0, queueMicrotask(this._resetUpdateCounts));
+  }
+  trackEvaluationFailure(t) {
+    !this.enabled || this._failedEvaluations.has(t) || (this._failedEvaluations.add(t), console.warn(`${J} Dependency #${t} evaluation failed during dirty check.`), this._failureCleanupScheduled || (this._failureCleanupScheduled = !0, queueMicrotask(this._resetFailedEvaluations)));
+  }
+  dumpGraph() {
+    const t = this._registry;
+    if (t.size === 0) return [];
+    const e = [], s = this._updateCounts;
+    for (const [r, i] of t)
+      this.trackGraph && i.ref?.deref() === void 0 || e.push({
+        id: r,
+        name: i.name,
+        type: i.type,
+        updateCount: s.get(r) ?? 0
+      });
+    return e;
   }
-  run(t, e) {
-    if (this.current === t) return e();
-    const s = this.current;
-    this.current = t;
+  getDebugName(t) {
+    if (!this.enabled || !t) return;
+    const e = t.id;
+    if (e === void 0) return;
+    const s = this._registry.get(e);
+    return s ? s.name : `${this._getTypeFromBrand(t) ?? "unknown"}_${e}`;
+  }
+  getDebugType(t) {
+    if (!this.enabled || !t) return;
+    const e = t.id;
+    if (e === void 0) return;
+    const s = this._registry.get(e);
+    return s ? s.type : this._getTypeFromBrand(t);
+  }
+  _getOrCreateMetadata(t, e) {
+    let s = this._registry.get(e);
+    if (!s) {
+      const r = this._getTypeFromBrand(t) ?? "unknown";
+      s = {
+        name: `${r}_${e}`,
+        type: r
+      }, this._registry.set(e, s);
+    }
+    return s;
+  }
+  _getTypeFromBrand(t) {
+    const e = t[A];
+    return e !== void 0 ? Zt[e & te] : void 0;
+  }
+}, se = {
+  enabled: !1,
+  warnInfiniteLoop: !1,
+  trackGraph: !1,
+  warn: U,
+  registerNode: U,
+  attachDebugInfo: U,
+  trackUpdate: U,
+  dumpGraph: () => [],
+  getDebugName: () => {
+  },
+  getDebugType: () => {
+  },
+  trackEvaluationFailure: U
+}, S = d ? new ee() : se, re = 1, ie = () => re++, K = {
+  get: () => {
+  },
+  set: () => {
+  },
+  delete: () => {
+  }
+}, It = class extends Map {
+};
+function Tt() {
+  return {
+    slots: new St(),
+    map: K,
+    hasComputeds: !1
+  };
+}
+function vt(t) {
+  t.hasComputeds = !1;
+}
+function Ot(t, e, s) {
+  const { slots: r } = t;
+  if (r.length <= s) return !1;
+  const i = r.at(s);
+  if (i?.node === e && i.unsub)
+    return i.version = e.version, !0;
+  const n = ne(t, e, s);
+  if (n === -1) return !1;
+  const o = r.at(n);
+  o.version = e.version;
+  const u = r.at(s);
+  return rt(t, s, o), rt(t, n, u), !0;
+}
+function ne(t, e, s) {
+  const r = t.map.get(e);
+  if (r !== void 0) return r >= s ? r : -1;
+  const i = t.slots;
+  for (let n = s + 1, o = i.length; n < o; n++) {
+    const u = i.at(n);
+    if (u?.node === e && u.unsub) return n;
+  }
+  return -1;
+}
+function mt(t, e, s) {
+  const r = t.slots.at(e);
+  rt(t, e, s), r !== null && oe(t, r);
+}
+function rt(t, e, s) {
+  const r = t.slots.at(e);
+  t.slots.setAt(e, s), r && t.map.delete(r.node), s?.unsub && (t.map === K && (t.map = new It()), t.map.set(s.node, e));
+}
+function oe(t, e) {
+  const s = t.slots.push(e);
+  return e.unsub && (t.map === K && (t.map = new It()), t.map.set(e.node, s)), s;
+}
+var ue = {
+  0: (t) => t.node.version !== t.version,
+  [y.IS_COMPUTED]: (t) => {
+    const e = t.node;
     try {
-      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;
-    } finally {
-      this.current = s;
+      e.value;
+    } catch {
+      d && S.trackEvaluationFailure(e.id);
     }
+    return e.version !== t.version;
   }
-}, l = new St();
+};
 function M(t) {
-  const e = l, s = e.current;
-  if (s === null) return t();
-  e.current = null;
+  const e = t.slots, s = e.length;
+  if (e.size === 0) return !1;
+  const r = ue;
+  for (let i = 0; i < s; i++) {
+    const n = e.at(i);
+    if (n && r[n.node.flags & y.IS_COMPUTED](n))
+      return !0;
+  }
+  return !1;
+}
+function ce(t) {
+  const e = t.slots, s = e.length;
+  for (let r = 0; r < s; r++) {
+    const i = e.at(r);
+    if (!i) continue;
+    const n = i.node;
+    if (n.version !== i.version || (n.flags & y.DIRTY) !== 0) return !0;
+  }
+  return !1;
+}
+function ot(t, e) {
+  const s = t.slots, r = s.length;
+  for (let i = e; i < r; i++) {
+    const n = s.at(i);
+    if (n) {
+      const o = n.unsub;
+      if (o) try {
+        o();
+      } catch (u) {
+        d && console.error("[atom-effect] Unsubscribe failed:", u);
+      }
+    }
+  }
+  s.truncateFrom(e), t.map = K;
+}
+function Nt(t) {
+  ot(t, 0), t.hasComputeds = !1;
+}
+function bt(t, e, s = void 0) {
+  return {
+    node: t,
+    version: e,
+    unsub: s
+  };
+}
+function ft(t = void 0, e = void 0) {
+  return {
+    fn: t,
+    sub: e
+  };
+}
+function le(t, e, s) {
+  if (t !== null)
+    try {
+      const { fn: r, sub: i } = t;
+      r !== void 0 && r(e, s), i !== void 0 && i.execute();
+    } catch (r) {
+      console.error("[atom-effect] Subscriber failed:", r);
+    }
+}
+function ae() {
+  return {
+    stack: [],
+    current: null
+  };
+}
+function ut(t, e) {
+  t.stack.push(e), t.current = e;
+}
+function At(t) {
+  const e = t.stack;
+  e.pop();
+  const s = e.length;
+  t.current = s > 0 ? e[s - 1] : null;
+}
+function ct(t, e) {
+  const s = t.stack;
+  s.length = e;
+  const r = s.length;
+  t.current = r > 0 ? s[r - 1] : null;
+}
+function Rt(t, e, s) {
+  if (t.current === e) return s();
+  ut(t, e);
+  try {
+    return s();
+  } finally {
+    At(t);
+  }
+}
+function he(t) {
+  t.stack.length = 0, t.current = null;
+}
+var l = ae();
+function _t(t) {
+  if (l.current === null) return t();
+  ut(l, null);
   try {
     return t();
   } finally {
-    e.current = s;
+    At(l);
   }
 }
-var K = class {
+var lt = 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 = L.UNINITIALIZED, this._nextEpoch = void 0, this.id = ie() & Ct, this._slots = null, this._deps = null;
   }
   get isDisposed() {
-    return (this.flags & Q.DISPOSED) !== 0;
+    return (this.flags & y.DISPOSED) !== 0;
   }
   get isComputed() {
-    return (this.flags & Q.IS_COMPUTED) !== 0;
+    return (this.flags & y.IS_COMPUTED) !== 0;
+  }
+  get isNotifying() {
+    return this._slots?.isLocked ?? !1;
+  }
+  _hasFlag(t) {
+    return (this.flags & t) !== 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);
+    let e;
+    if (typeof t == "function" ? e = ft(t, void 0) : t != null && typeof t.execute == "function" && (e = ft(void 0, t)), !e) throw X(/* @__PURE__ */ new TypeError("Invalid subscriber"), b, a.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 (i)
-      return _ && console.warn(`[atom-effect] Duplicate subscription ignored on node ${this.id}`), () => {
+    if (s === null) this._slots = s = new St();
+    else if (this._hasSubscription(t))
+      return d && 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);
+    return s.push(e), () => this._unsubscribe(e);
+  }
+  _hasSubscription(t) {
+    const e = this._slots;
+    return !e || e.size === 0 ? !1 : e.some((s) => s.fn === t || s.sub === t);
   }
   _unsubscribe(t) {
     const e = this._slots;
-    e && (e.remove(t), this._notifying === 0 && e.compact());
+    e !== null && (e.remove(t), e.compact());
   }
   subscriberCount() {
-    const t = this._slots;
-    return t === null ? 0 : t.size;
+    return this._slots?.size ?? 0;
   }
   _notifySubscribers(t, e) {
     const s = this._slots;
-    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 (i = s._s1, i != null) try {
-          i.notify(t, e);
-        } catch (r) {
-          this._logNotifyError(r);
-        }
-        if (i = s._s2, i != null) try {
-          i.notify(t, e);
-        } catch (r) {
-          this._logNotifyError(r);
-        }
-        if (i = s._s3, i != null) try {
-          i.notify(t, e);
-        } catch (r) {
-          this._logNotifyError(r);
-        }
-        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 && s.compact();
-      }
+    if (!s || s.size === 0) return;
+    const r = l.stack.length;
+    ut(l, null), s.lock();
+    try {
+      s.forEach((i) => {
+        le(i, t, e);
+      });
+    } finally {
+      ct(l, r), s.unlock();
     }
   }
-  _logNotifyError(t) {
-    console.error(N(t, g, h.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
-  }
   _isDirty() {
-    const t = this._deps;
-    if (t === null || t.size === 0) return !1;
-    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();
+    return this._deps ? M(this._deps) : !1;
   }
-}, H = 0;
-function J() {
-  const t = H + 1 & k;
-  return H = t === 0 ? 1 : t, H;
-}
-function j(t) {
-  const e = t + 1 & k;
+  _isShallowDirty() {
+    return this._deps ? ce(this._deps) : !1;
+  }
+}, yt = (t) => {
+  const e = t + 1 & Ct;
   return e === 0 ? 1 : e;
+};
+function it(t) {
+  return yt(t);
 }
-var Z = 0, z = !1, ct = 0;
-function Tt() {
-  return ct;
-}
-function nt() {
-  return z ? (_ && console.warn("startFlush() called during flush - ignored"), !1) : (z = !0, ct = J(), Z = 0, !0);
-}
-function rt() {
-  z = !1;
+var fe = 0, Z = 1, at = 2, Q = 4, _e = at | Q;
+function Ee() {
+  return {
+    size: 0,
+    epoch: 0,
+    batchQueueSize: 0,
+    state: fe,
+    batchDepth: 0,
+    maxFlushIterations: m.MAX_FLUSH_ITERATIONS,
+    sessionActive: !1,
+    sessionEpoch: 0,
+    sessionExecutionCount: 0,
+    activeBuffer: [],
+    standbyBuffer: [],
+    batchBuffer: [],
+    onOverflow: null
+  };
 }
-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}`);
+function Ut(t, e) {
+  const s = t.batchQueueSize;
+  if (s === 0) return;
+  const r = e(), i = t.batchBuffer, n = t.activeBuffer;
+  let o = t.size;
+  for (let u = 0; u < s; u++) {
+    const T = i[u];
+    T._nextEpoch !== r && (T._nextEpoch = r, n[o++] = T), i[u] = void 0;
+  }
+  t.size = o, t.batchQueueSize = 0, i.length > m.BATCH_QUEUE_SHRINK_THRESHOLD && (i.length = 0);
 }
-var vt = 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 + this._batchQueueSize;
-  }
-  get isBatching() {
-    return this._batchDepth > 0;
-  }
-  schedule(t) {
-    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;
+function Ft(t, e, s, r) {
+  let i = 0;
+  const n = t.maxFlushIterations;
+  for (; t.size > 0 || t.batchQueueSize > 0; ) {
+    if (++i > n) {
+      r(t);
       return;
     }
-    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));
+    t.batchQueueSize > 0 && Ut(t, e), t.size > 0 && s(t);
   }
-  _runLoop() {
+}
+function wt(t, e) {
+  const s = t.activeBuffer, r = t.size;
+  t.activeBuffer = t.standbyBuffer, t.standbyBuffer = s, t.size = 0, e();
+  for (let i = 0; i < r; i++) {
+    const n = s[i];
+    s[i] = void 0;
     try {
-      if (this._size === 0 && this._batchQueueSize === 0) return;
-      const t = nt();
-      this._drainQueue(), t && rt();
-    } finally {
-      this._isProcessing = !1;
+      typeof n == "function" ? n() : n.execute();
+    } catch (o) {
+      console.error(new nt("Error occurred during scheduler execution", o));
     }
   }
-  _flushSync() {
-    if (this._size === 0 && this._batchQueueSize === 0) return;
-    const t = this._isFlushingSync;
-    this._isFlushingSync = !0;
-    const e = nt();
+}
+function kt(t) {
+  const e = t.size + t.batchQueueSize;
+  if (console.error(new nt(a.SCHEDULER_FLUSH_OVERFLOW(t.maxFlushIterations, e))), t.size = 0, t.activeBuffer.length = 0, t.standbyBuffer.length = 0, t.batchQueueSize = 0, t.batchBuffer.length = 0, t.onOverflow) try {
+    t.onOverflow(e);
+  } catch {
+  }
+}
+function O(t) {
+  return t.epoch = yt(t.epoch), t.epoch;
+}
+function Pt(t) {
+  return t.sessionActive ? (d && console.warn("startFlush() called during flush - ignored"), !1) : (t.sessionActive = !0, t.sessionEpoch = O(t), t.sessionExecutionCount = 0, !0);
+}
+function Lt(t) {
+  t.sessionActive = !1;
+}
+function de(t) {
+  if (!t.sessionActive) return 0;
+  const e = ++t.sessionExecutionCount;
+  if (e <= m.MAX_EXECUTIONS_PER_FLUSH) return e;
+  throw new Error(`[atom-effect] Infinite loop detected: flush execution count exceeded ${m.MAX_EXECUTIONS_PER_FLUSH}`);
+}
+function W(t, e) {
+  if (d && typeof e != "function" && (!e || typeof e.execute != "function"))
+    throw new nt(a.SCHEDULER_CALLBACK_MUST_BE_FUNCTION);
+  e._nextEpoch !== t.epoch && (e._nextEpoch = t.epoch, (t.state & _e) === 0 ? t.activeBuffer[t.size++] = e : t.batchBuffer[t.batchQueueSize++] = e, (t.state & Z) === 0 && (t.state |= Z, queueMicrotask(() => {
     try {
-      this._mergeBatchQueue(), this._drainQueue();
+      if (t.size === 0 && t.batchQueueSize === 0) return;
+      const s = Pt(t);
+      Ft(t, () => O(t), (r) => wt(r, () => O(r)), (r) => kt(r)), s && Lt(t);
+    } catch (s) {
+      throw he(l), s;
     } finally {
-      this._isFlushingSync = t, e && rt();
-    }
-  }
-  _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];
-    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;
+      t.state &= ~Z;
     }
-    this._size = n, this._batchQueueSize = 0, s.length > C.BATCH_QUEUE_SHRINK_THRESHOLD && (s.length = 0);
-  }
-  _drainQueue() {
-    let t = 0;
-    for (; this._size > 0 || this._batchQueueSize > 0; ) {
-      if (++t > this._maxFlushIterations) {
-        this._handleFlushOverflow();
-        return;
-      }
-      this._batchQueueSize > 0 && this._mergeBatchQueue(), this._size > 0 && this._processQueue();
-    }
-  }
-  _processQueue() {
-    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 < s; i++) {
-      const n = e[i];
-      e[i] = void 0;
-      try {
-        typeof n == "function" ? n() : n.execute();
-      } catch (r) {
-        console.error(new L("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;
-    const e = this.onOverflow;
-    if (e) try {
-      e(t);
-    } catch {
-    }
-  }
-  startBatch() {
-    this._batchDepth++;
-  }
-  endBatch() {
-    if (this._batchDepth === 0) {
-      _ && console.warn(h.SCHEDULER_END_BATCH_WITHOUT_START);
-      return;
-    }
-    --this._batchDepth === 0 && (this._isFlushingSync || this._flushSync());
+  })));
+}
+function pe(t) {
+  if (t.size === 0 && t.batchQueueSize === 0) return;
+  const e = t.state;
+  t.state |= at;
+  const s = Pt(t);
+  try {
+    Ut(t, () => O(t)), Ft(t, () => O(t), (r) => wt(r, () => O(r)), (r) => kt(r));
+  } finally {
+    t.state = e, s && Lt(t);
   }
-  setMaxFlushIterations(t) {
-    if (t < C.MIN_FLUSH_ITERATIONS) throw new L(`Max iterations must be at least ${C.MIN_FLUSH_ITERATIONS}`);
-    this._maxFlushIterations = t;
+}
+function Ce(t) {
+  t.batchDepth++, t.state |= Q;
+}
+function Se(t) {
+  if (t.batchDepth === 0) {
+    d && console.warn(a.SCHEDULER_END_BATCH_WITHOUT_START);
+    return;
   }
-}, b = new vt();
-function Ft(t) {
-  if (_ && typeof t != "function") throw new TypeError(h.BATCH_CALLBACK_MUST_BE_FUNCTION);
-  b.startBatch();
+  --t.batchDepth === 0 && (t.state &= ~Q, (t.state & at) === 0 && pe(t));
+}
+function Et(t) {
+  return (t.state & Q) !== 0;
+}
+var p = Ee(), Mt = () => O(p), ge = () => p.sessionEpoch, De = () => de(p);
+function Ie(t) {
+  if (d && typeof t != "function") throw new TypeError(a.BATCH_CALLBACK_MUST_BE_FUNCTION);
+  Ce(p);
   try {
     return t();
   } finally {
-    b.endBatch();
+    Se(p);
   }
 }
-var Ot = class extends K {
+var F = null;
+function Me(t) {
+  return t ? new Promise((e, s) => {
+    W(p, () => {
+      try {
+        t(), e();
+      } catch (r) {
+        s(r);
+      }
+    });
+  }) : F || (F = new Promise((e) => {
+    W(p, () => {
+      F = null, e();
+    });
+  }), F);
+}
+var Te = class extends lt {
   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[A] = h.Atom | h.Writable, this._value = t, this._equal = e.equal ?? Object.is, e.sync && (this.flags |= g.SYNC), S.attachDebugInfo(this, "atom", this.id, e.name);
   }
   get isNotificationScheduled() {
-    return (this.flags & f.NOTIFICATION_SCHEDULED) !== 0;
+    return (this.flags & g.NOTIFICATION_SCHEDULED) !== 0;
   }
   get isSync() {
-    return (this.flags & f.SYNC) !== 0;
+    return (this.flags & g.SYNC) !== 0;
   }
   get value() {
-    const t = l.current;
-    return t?.addDependency(this), this._value;
+    return l.current?.addDependency(this), this._value;
   }
   set value(t) {
+    if (this._equal(this._value, t)) return;
     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));
+    this._value = t, this.version = it(this.version), d && S.trackUpdate(this.id, S.getDebugName(this)), this._scheduleNotification(e);
+  }
+  _scheduleNotification(t) {
+    const e = this.flags, s = g.NOTIFICATION_SCHEDULED;
+    (e & s) !== 0 || !this._slots?.length || (this._pendingOldValue = t, this.flags |= s, (e & g.SYNC) !== 0 && !Et(p) ? this.isNotifying || this._flushNotifications() : W(p, 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 = g.NOTIFICATION_SCHEDULED, e = t | g.DISPOSED, s = (this.flags & g.SYNC) !== 0 && !Et(p);
+    for (; (this.flags & e) === t; ) {
+      const r = this._pendingOldValue, i = this._value;
+      if (this._pendingOldValue = void 0, this.flags &= ~t, this._equal(i, r) || this._notifySubscribers(i, r), !s) 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 = g.DISPOSED;
+    (this.flags & t) === 0 && (this.flags |= t, 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 Be(t, e = {}) {
+  return new Te(t, e);
+}
+function q(t, e) {
+  return !t || typeof t != "object" && typeof t != "function" ? !1 : !!(t[A] & e);
+}
+function xe(t) {
+  return q(t, h.Atom);
+}
+function ze(t) {
+  return q(t, h.Writable);
+}
+function He(t) {
+  return q(t, h.Computed);
+}
+function Ge(t) {
+  return q(t, h.Effect);
+}
+function k(t, e = !1) {
+  const s = {};
+  for (let r = 0; r < t.length; r++) {
+    const i = e ? t[r].peek() : t[r].value;
+    i && typeof i == "object" && Object.assign(s, i);
+  }
+  return s;
 }
-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: P, DIRTY: D, PENDING: B, RESOLVED: I, REJECTED: N, HAS_ERROR: ht, RECOMPUTING: C, DISPOSED: V, IS_COMPUTED: dt, FORCE_COMPUTE: $ } = y, Bt = B | N, ve = P | $, xt = N | ht, tt = P | D | B | I | N | ht, Y = {
+  TO_RECOMPUTING: {
+    clear: $,
+    set: C
+  },
+  TO_RESOLVED: {
+    clear: tt | C,
+    set: I
+  },
+  TO_PENDING: {
+    clear: tt | C,
+    set: B
+  },
+  TO_REJECTED: {
+    clear: tt | C,
+    set: N | ht
+  }
+}, j = (t, e) => t & ~e.clear | e.set;
+function Oe(t, e, s, r) {
+  if ((t & I) !== 0) return e;
+  const i = r !== st, n = t & Bt;
+  if (n === 0) return e;
+  if (i) return r;
+  throw n === N ? s ?? /* @__PURE__ */ new Error("REJECTED without error") : new w(a.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+}
+function me(t, e) {
+  const s = (t & Bt) !== 0;
+  return (t & ve) !== 0 || M(e) || !s && e.slots.size === 0;
+}
+function pt(t, e) {
+  const s = [], r = /* @__PURE__ */ new Set(), i = (n) => {
+    if (r.has(n.id)) return !1;
+    if (r.add(n.id), (n.flags & xt) !== 0 && (s.push(n.lastError ?? /* @__PURE__ */ new Error("Internal Inconsistency: MASK_ERROR flag set but error is null")), e))
+      return !0;
+    const o = n._deps;
+    if (o?.hasComputeds) for (let u = 0, T = o.slots.length; u < T; u++) {
+      const f = o.slots.at(u);
+      if (f?.node.isComputed && i(f.node)) return !0;
+    }
+    return !1;
+  };
+  return i(t), s;
+}
+var Ne = class extends lt {
   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(a.COMPUTED_MUST_BE_FUNCTION);
+    if (super(), this[A] = h.Atom | h.Computed, this._activeSessionId = 0, this._sessionCounter = 0, this._trackEpoch = L.UNINITIALIZED, this._trackCount = 0, this._error = null, this._deps = Tt(), this._value = void 0, this.flags = dt | D | P, this._equal = e.equal ?? Object.is, this._computation = t, this._defaultValue = "defaultValue" in e ? e.defaultValue : st, this._onError = e.onError ?? null, S.attachDebugInfo(this, "computed", this.id, e.name), e.lazy === !1) try {
       this._recompute();
     } catch {
     }
   }
   get isDirty() {
-    return (this.flags & E) !== 0;
+    return (this.flags & D) !== 0;
   }
   get isRejected() {
-    return (this.flags & T) !== 0;
+    return (this.flags & N) !== 0;
   }
   get isRecomputing() {
-    return (this.flags & y) !== 0;
-  }
-  get _hasErrorInternal() {
-    return (this.flags & P) !== 0;
-  }
-  _track() {
-    l.current?.addDependency(this);
+    return (this.flags & C) !== 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 n = this._defaultValue;
-      if (n !== B) return n;
-      throw new A(h.COMPUTED_CIRCULAR_DEPENDENCY);
+    if (l.current?.addDependency(this), this._isStable()) return this._value;
+    if (this._ensureNotDisposed(), (this.flags & C) !== 0) {
+      if (this._defaultValue !== st) return this._defaultValue;
+      throw new w(a.COMPUTED_CIRCULAR_DEPENDENCY);
     }
-    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 s = this._defaultValue, i = s !== B;
-    if ((e & O) !== 0) {
-      if (i) return s;
-      throw new A(h.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
-    }
-    if ((e & T) !== 0) {
-      if (i) return s;
-      throw this._error;
-    }
-    return this._value;
+    return me(this.flags, this._deps) ? this._recompute() : this.flags &= ~D, Oe(this.flags, this._value, this._error, this._defaultValue);
+  }
+  _isStable() {
+    const t = I | D | P | V | C;
+    return (this.flags & t) === I;
+  }
+  _ensureNotDisposed() {
+    if ((this.flags & V) !== 0) throw new w(a.COMPUTED_DISPOSED);
   }
   peek() {
     return this._value;
   }
   get state() {
-    const t = l.current;
-    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;
+    l.current?.addDependency(this);
+    const t = this.flags;
+    return (t & I) !== 0 ? H.RESOLVED : (t & B) !== 0 ? H.PENDING : (t & N) !== 0 ? H.REJECTED : H.IDLE;
   }
   get hasError() {
-    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;
+    return l.current?.addDependency(this), (this.flags & xt) !== 0 ? !0 : this._deps.hasComputeds ? _t(() => pt(this, !0).length > 0) : !1;
   }
   get isValid() {
     return !this.hasError;
   }
   get errors() {
-    const t = l.current;
-    t?.addDependency(this);
-    const e = this._error, s = this._deps;
-    if (!s.hasComputeds)
-      return e == null ? et : Object.freeze([e]);
-    const i = [];
-    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);
-    }
+    return l.current?.addDependency(this), this._deps.hasComputeds ? _t(() => Object.freeze(pt(this, !1))) : this._error ? Object.freeze([this._error]) : jt;
   }
   get lastError() {
-    const t = l.current;
-    return t?.addDependency(this), this._error;
+    return l.current?.addDependency(this), this._error;
   }
   get isPending() {
-    const t = l.current;
-    return t?.addDependency(this), (this.flags & O) !== 0;
+    return l.current?.addDependency(this), (this.flags & B) !== 0;
   }
   get isResolved() {
-    const t = l.current;
-    return t?.addDependency(this), (this.flags & I) !== 0;
+    return l.current?.addDependency(this), (this.flags & I) !== 0;
   }
   invalidate() {
-    this.flags |= X, this._markDirty();
+    this.flags |= $, 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 & V) === 0 && (Nt(this._deps), this._slots?.clear(), this.flags = V | D | P, this._error = null, this._value = void 0);
   }
   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;
-    else if (!i.claimExisting(t, s)) {
-      const r = new W(t, t.version, t.subscribe(this));
-      i.insertNew(s, r);
-    }
-    (t.flags & R) !== 0 && (i.hasComputeds = !0);
+    const s = this._trackCount++, r = this._deps, i = r.slots.at(s);
+    i?.node === t ? i.version = t.version : Ot(r, t, s) || mt(r, s, bt(t, t.version, t.subscribe(this))), (t.flags & dt) !== 0 && (r.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;
-    let t = !1;
+    if ((this.flags & C) !== 0) return;
+    this.flags = j(this.flags, Y.TO_RECOMPUTING);
+    const t = l.stack.length;
+    this._startTracking();
+    let e, s = !1, r;
     try {
-      const e = l.run(this, this._fn);
-      this._deps.truncateFrom(this._trackCount), t = !0, q(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);
+      try {
+        e = Rt(l, this, this._computation);
+      } catch (i) {
+        throw ct(l, t), i;
       }
-      this._handleError(e, h.COMPUTED_COMPUTATION_FAILED, !0);
-    } finally {
-      this._trackEpoch = w.UNINITIALIZED, this._trackCount = 0, this.flags &= ~y;
+    } catch (i) {
+      s = !0, r = i;
+    }
+    s ? (this._commitDeps(), this._handleError(r, a.COMPUTED_COMPUTATION_FAILED, !1)) : (this._commitDeps(), gt(e) ? this._handleAsyncComputation(e) : this._finalizeResolution(e)), this._trackEpoch = L.UNINITIALIZED, this._trackCount = 0, this.flags &= ~C;
+  }
+  _startTracking() {
+    this._trackEpoch = Mt(), this._trackCount = 0, vt(this._deps);
+  }
+  _commitDeps() {
+    try {
+      ot(this._deps, this._trackCount);
+    } catch (t) {
+      d && console.warn("[atom-effect] _commitDeps failed during error recovery:", t);
     }
   }
   _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;
-    const e = this._promiseId;
-    t.then((s) => {
-      if (e === this._promiseId) {
+    this.flags = j(this.flags, Y.TO_PENDING), this._notifySubscribers(void 0, void 0);
+    const e = ++this._sessionCounter;
+    this._activeSessionId = e, t.then((s) => {
+      if (this._activeSessionId === e) {
         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) => {
+      this._activeSessionId === e && this._handleError(s, a.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 {
-      this._onError(i);
+    const r = X(t, w, e), i = this._error;
+    if ((!this.isRejected || i !== r) && (this.version = it(this.version)), this._error = r, this.flags = j(this.flags, Y.TO_REJECTED), this._onError) try {
+      this._onError(r);
     } catch (n) {
-      console.error(h.CALLBACK_ERROR_IN_ERROR_HANDLER, n);
+      console.error(a.CALLBACK_ERROR_IN_ERROR_HANDLER, n);
     }
-    if (this._notifySubscribers(void 0, void 0), s) throw i;
+    if (this._notifySubscribers(void 0, void 0), s) throw r;
   }
   _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);
+    ((this.flags & I) === 0 || !this._equal(this._value, t)) && (this.version = it(this.version)), this._value = t, this._error = null, this.flags = j(this.flags, Y.TO_RESOLVED);
   }
   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 & (C | D)) !== 0 || !(t & $) && !this._isShallowDirty() || (this.flags = t | D, S.trackUpdate(this.id, S.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 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;
-      }
-      return this._hotIndex = -1, !1;
-    });
+    return M(this._deps);
   }
 };
-function Lt(t, e = {}) {
-  return new Nt(t, e);
+function be(t, e = {}) {
+  return new Ne(t, e);
+}
+function Ve(...t) {
+  return be(() => k(t));
+}
+function Ae() {
+  return {
+    loopCount: 0,
+    lastFlushEpoch: L.UNINITIALIZED,
+    windowCount: 0,
+    windowStart: 0,
+    totalExecutions: 0
+  };
+}
+function Re(t, e, s, r, i) {
+  t.lastFlushEpoch !== s && (t.lastFlushEpoch = s, t.loopCount = 0), ++t.loopCount > e && i("per-effect"), r() > m.MAX_EXECUTIONS_PER_FLUSH && i("global"), t.totalExecutions++;
+}
+function ye(t, e, s) {
+  if (!Number.isFinite(e)) return;
+  const r = Date.now();
+  if (r - t.windowStart >= et.EFFECT_FREQUENCY_WINDOW) {
+    t.windowStart = r, t.windowCount = 1;
+    return;
+  }
+  ++t.windowCount > e && s();
 }
-var bt = class extends K {
+var Ue = class extends lt {
   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[A] = h.Effect, this._trackEpoch = L.UNINITIALIZED, this._trackCount = 0, this._trackSessionId = 0, this._budget = Ae(), this._deps = Tt(), this._cleanup = null, this._fn = t, this._onError = e.onError ?? null, this._sync = e.sync ?? !1, this._maxExecutions = e.maxExecutionsPerSecond ?? m.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = e.maxExecutionsPerFlush ?? m.MAX_EXECUTIONS_PER_EFFECT, this._notifyCallback = this._sync ? () => this.execute() : () => W(p, this), S.attachDebugInfo(this, "effect", this.id, e.name);
   }
   run() {
-    if (this.isDisposed) throw new m(h.EFFECT_DISPOSED);
+    if (this.isDisposed) throw new R(a.EFFECT_DISPOSED);
     this.execute(!0);
   }
   dispose() {
-    this.isDisposed || (this.flags |= S.DISPOSED, this._execCleanup(), this._deps?.disposeAll());
+    this.isDisposed || (this.flags |= v.DISPOSED, this._execCleanup(), this._deps && Nt(this._deps));
   }
-  [Symbol.dispose]() {
-    this.dispose();
+  get executionCount() {
+    return this._budget.totalExecutions;
   }
-  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);
-    }
-    n != null && n.node === t ? n.version = t.version : i.claimExisting(t, s) || this._insertNewDependency(t, s), t.isComputed && (i.hasComputeds = !0);
+  get isExecuting() {
+    return (this.flags & v.EXECUTING) !== 0;
+  }
+  get isDisposed() {
+    return (this.flags & v.DISPOSED) !== 0;
   }
-  _insertNewDependency(t, e) {
-    let s;
+  execute(t = !1) {
+    if (!this._prepareExecution(t)) return;
+    this._execCleanup(), this._startTracking();
+    const e = l.stack.length;
+    let s, r = !1, 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);
-      } catch {
+      try {
+        s = Rt(l, this, this._fn);
+      } catch (n) {
+        throw ct(l, e), n;
       }
-      s = new W(t, t.version, void 0);
+    } catch (n) {
+      r = !0, i = n;
     }
-    this._deps.insertNew(e, s);
+    this._commitDeps(), r ? this._handleExecutionError(i) : this._handleResult(s), this.flags &= ~v.EXECUTING;
   }
-  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;
-    let i = !1;
+  _prepareExecution(t) {
+    return (this.flags & (v.DISPOSED | v.EXECUTING)) !== 0 || !(t || this._deps.slots.length === 0 || this._isDirty()) ? !1 : (this._validateBudget(), S.trackUpdate(this.id, S.getDebugName(this)), this.flags |= v.EXECUTING, !0);
+  }
+  addDependency(t) {
+    if (!this.isExecuting || t._lastSeenEpoch === this._trackEpoch) return;
+    t._lastSeenEpoch = this._trackEpoch;
+    const e = this._trackCount++, s = this._deps, r = t.version, i = s.slots.at(e);
+    i?.node === t ? i.version = r : Ot(s, t, e) || this._insertNewDependency(t, e, r), t.isComputed && !s.hasComputeds && (s.hasComputeds = !0);
+  }
+  _insertNewDependency(t, e, s) {
+    const r = bt(t, s, t.subscribe(this._notifyCallback));
+    mt(this._deps, e, r);
+  }
+  _startTracking() {
+    this._trackEpoch = Mt(), this._trackCount = 0, vt(this._deps);
+  }
+  _commitDeps() {
     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;
-    } catch (n) {
-      if (!i) try {
-        s.truncateFrom(this._trackCount);
-      } catch (r) {
-        _ && console.warn("[atom-effect] _commitDeps failed during error recovery:", r);
-      }
-      this._handleExecutionError(n), this._cleanup = null;
-    } finally {
-      this.flags &= ~S.EXECUTING;
+      ot(this._deps, this._trackCount);
+    } catch (t) {
+      d && console.warn("[atom-effect] _commitDeps failed during error recovery:", t);
     }
   }
+  _handleResult(t) {
+    typeof t == "function" ? this._cleanup = t : gt(t) ? this._handleAsyncResult(t) : this._cleanup = null;
+  }
   _handleAsyncResult(t) {
-    const e = ++this._execId;
+    const e = ++this._trackSessionId;
     t.then((s) => {
-      if (e !== this._execId || this.isDisposed) {
+      if (this._trackSessionId !== e || this.isDisposed) {
         if (typeof s == "function") try {
           s();
-        } catch (i) {
-          this._handleExecutionError(i, h.EFFECT_CLEANUP_FAILED);
+        } catch (r) {
+          this._handleExecutionError(r, a.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;
-      }
-      return !1;
-    } finally {
-      l.current = t;
-    }
-  }
-  _tryPullComputed(t) {
-    try {
-      t.value;
-    } catch {
-      _ && console.warn(`[atom-effect] Dependency #${t.id} threw during dirty check`);
-    }
+    }, (s) => {
+      this._trackSessionId === e && this._handleExecutionError(s);
+    });
   }
   _execCleanup() {
     const t = this._cleanup;
-    if (t != null) {
+    if (t) {
       this._cleanup = null;
       try {
         t();
       } catch (e) {
-        this._handleExecutionError(e, h.EFFECT_CLEANUP_FAILED);
+        this._handleExecutionError(e, a.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();
-  }
-  _checkFrequencyLimit() {
-    if (!Number.isFinite(this._maxExecutions)) return;
-    const t = Date.now();
-    if (t - this._windowStart >= Y.EFFECT_FREQUENCY_WINDOW) {
-      this._windowStart = t, this._windowCount = 1;
-      return;
-    }
-    if (++this._windowCount > this._maxExecutions) {
-      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 & S.EXECUTING) !== 0;
+  _validateBudget() {
+    Re(this._budget, this._maxExecutionsPerFlush, ge(), De, (t) => this._abortExecution(t)), d && ye(this._budget, this._maxExecutions, () => {
+      const t = new R(a.EFFECT_FREQUENCY_LIMIT_EXCEEDED);
+      throw this.dispose(), this._handleExecutionError(t), t;
+    });
   }
-  _throwInfiniteLoopError(t) {
-    const e = new m(`Infinite loop detected (${t}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${Z}`);
+  _abortExecution(t) {
+    const e = new R(t === "per-effect" ? `Infinite loop detected (per-effect): executed ${this._budget.loopCount} times in current flush.` : "Infinite loop detected (global): exceeded total execution limit per flush.");
     throw this.dispose(), console.error(e), e;
   }
-  _handleExecutionError(t, e = h.EFFECT_EXECUTION_FAILED) {
-    const s = N(t, m, e);
+  _handleExecutionError(t, e = a.EFFECT_EXECUTION_FAILED) {
+    const s = X(t, R, e);
     if (console.error(s), this._onError) try {
       this._onError(s);
-    } catch (i) {
-      console.error(N(i, m, h.CALLBACK_ERROR_IN_ERROR_HANDLER));
+    } catch (r) {
+      console.error(X(r, R, a.CALLBACK_ERROR_IN_ERROR_HANDLER));
     }
   }
+  _isDirty() {
+    return M(this._deps);
+  }
+  _deepDirtyCheck() {
+    return M(this._deps);
+  }
 };
-function Pt(t, e = {}) {
-  if (typeof t != "function") throw new m(h.EFFECT_MUST_BE_FUNCTION);
-  const s = new bt(t, e);
+function Ye(t, e = {}) {
+  if (typeof t != "function") throw new R(a.EFFECT_MUST_BE_FUNCTION);
+  const s = new Ue(t, e);
   return s.execute(), s;
 }
-var lt = /^(?:__proto__|constructor|prototype)$/;
-function _t(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 (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;
-  }
-  return {
-    ...r,
-    [n]: c
+var zt = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+function Fe(t, e, s) {
+  if (Array.isArray(t)) {
+    const n = [...t];
+    return n[e] = s, n;
+  }
+  if (t instanceof Map) {
+    const n = new Map(t);
+    return n.set(e, s), n;
+  }
+  const r = Object.getPrototypeOf(t);
+  if (r === Object.prototype || r === null) return {
+    ...t,
+    [e]: s
   };
+  const i = Object.create(r);
+  return Object.assign(i, t), i[e] = s, i;
 }
-function x(t, e) {
+function Ht(t, e, s, r) {
+  if (s === e.length) return r;
+  const i = e[s];
+  if (zt.has(i) || t == null || typeof t != "object") return t;
+  const n = t instanceof Map ? t.get(i) : t[i], o = Ht(n, e, s + 1, r);
+  return Object.is(n, o) ? t : Fe(t, i, o);
+}
+function we(t, e) {
   let s = t;
-  const i = e.length;
-  for (let n = 0; n < i; n++) {
+  const r = e.length;
+  for (let i = 0; i < r; i++) {
     if (s == null) return;
-    const r = e[n];
-    if (lt.test(r)) return;
-    s = s[r];
+    s instanceof Map ? s = s.get(e[i]) : s = s[e[i]];
   }
   return s;
 }
-function at(t, e) {
-  const s = e.includes(".") ? e.split(".") : [e], i = /* @__PURE__ */ new Set(), n = () => {
-    i.forEach((r) => r()), i.clear();
+function Gt(t, e) {
+  const s = e.split("."), r = s.some((f) => zt.has(f)), i = /* @__PURE__ */ new Set();
+  let n = null, o;
+  const u = (f) => r ? void 0 : we(f, s), T = () => {
+    const f = u(t.peek());
+    if (!Object.is(f, o)) {
+      const x = o;
+      o = f, i.forEach((z) => z(f, x));
+    }
   };
   return {
     get value() {
-      return x(t.value, s);
+      return u(t.value);
     },
-    set value(r) {
-      const o = t.peek(), c = _t(o, s, 0, r);
-      c !== o && (t.value = c);
+    set value(f) {
+      if (r) return;
+      const x = t.peek(), z = Ht(x, s, 0, f);
+      z !== x && (t.value = z);
     },
-    peek: () => x(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);
-      });
-      return i.add(o), () => {
-        o(), i.delete(o);
+    peek: () => u(t.peek()),
+    subscribe(f) {
+      return i.size === 0 && (o = u(t.peek()), n = t.subscribe(T)), i.add(f), () => {
+        i.delete(f), i.size === 0 && n && (n(), n = null);
       };
     },
     subscriberCount: () => i.size,
-    dispose: n,
-    [Symbol.dispose]: n,
-    [F]: p.Atom | p.Writable
+    dispose: () => {
+      n?.(), n = null, i.clear();
+    },
+    [A]: h.Atom | h.Writable
+  };
+}
+var je = (t, e) => Gt(t, e), Xe = (t) => (e) => Gt(t, e);
+function We(...t) {
+  let e;
+  const s = /* @__PURE__ */ new Set(), r = [], i = () => {
+    const n = k(t, !0);
+    if (!qt(n, e)) {
+      const o = e;
+      e = n;
+      for (const u of s) u(n, o);
+    }
+  };
+  return {
+    get value() {
+      return k(t);
+    },
+    set value(n) {
+      Ie(() => {
+        for (let o = 0; o < t.length; o++) t[o].value = n;
+      });
+    },
+    peek: () => k(t, !0),
+    subscribe: (n) => {
+      if (s.size === 0) {
+        e = k(t, !0);
+        for (let o = 0; o < t.length; o++) r.push(t[o].subscribe(i));
+      }
+      return s.add(n), () => {
+        if (s.delete(n), s.size === 0) {
+          for (const o of r) o();
+          r.length = 0;
+        }
+      };
+    },
+    subscriberCount: () => s.size,
+    dispose: () => {
+      for (const n of r) n();
+      r.length = 0, s.clear();
+    },
+    [A]: h.Atom | h.Writable
   };
 }
-var xt = (t, e) => at(t, e), Mt = (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,
-  at as atomLens,
-  Ft as batch,
-  xt as composeLens,
-  Lt as computed,
-  Pt as effect,
-  x as getPathValue,
-  b as globalScheduler,
-  yt as isAtom,
-  Rt as isComputed,
-  wt as isEffect,
-  Mt as lensFor,
-  d as runtimeDebug,
-  _t as setDeepValue,
-  M as untracked
+  H as AsyncState,
+  b as AtomError,
+  A as BRAND,
+  h as BrandFlags,
+  w as ComputedError,
+  R as EffectError,
+  d as IS_DEV,
+  m as SCHEDULER_CONFIG,
+  nt as SchedulerError,
+  Me as aeNextTick,
+  Be as atom,
+  Gt as atomLens,
+  Ie as batch,
+  je as composeLens,
+  be as computed,
+  Ye as effect,
+  we as getPathValue,
+  p as globalScheduler,
+  xe as isAtom,
+  He as isComputed,
+  Ge as isEffect,
+  gt as isPromise,
+  ze as isWritable,
+  Xe as lensFor,
+  Ve as mergeAtoms,
+  We as mergeLenses,
+  S as runtimeDebug,
+  Ht as setDeepValue,
+  _t as untracked
 };
 
 //# sourceMappingURL=index.mjs.map