@but212/atom-effect 0.16.1 → 0.17.0

package/dist/atom-effect.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"atom-effect.min.js","sources":["../src/constants.ts","../src/errors/errors.ts","../src/utils/debug.ts","../src/core/dep-tracking.ts","../src/errors/messages.ts","../src/core/base.ts","../src/internal/epoch.ts","../src/internal/scheduler.ts","../src/tracking/context.ts","../src/tracking/untracked.ts","../src/core/atom.ts","../src/utils/array-pool.ts","../src/internal/pool.ts","../src/utils/error.ts","../src/utils/type-guards.ts","../src/core/computed.ts","../src/core/effect.ts","../src/internal/batch.ts"],"sourcesContent":["/**\n * Time-related constants (in milliseconds)\n */\nexport const TIME_CONSTANTS = {\n  /** One second in milliseconds */\n  ONE_SECOND_MS: 1000,\n} as const;\n\n/**\n * Async computation states for computed atoms\n */\nexport const AsyncState = {\n  IDLE: 'idle' as const,\n  PENDING: 'pending' as const,\n  RESOLVED: 'resolved' as const,\n  REJECTED: 'rejected' as const,\n} as const;\n\n/**\n * Common bit flags for all reactive nodes (ReactiveNode)\n * Reserved lower bits for base class state\n */\nexport const NODE_FLAGS = {\n  DISPOSED: 1 << 0,\n  HAS_FN_SUBS: 1 << 1,\n  HAS_OBJ_SUBS: 1 << 2,\n} as const;\n\n/**\n * Bit flags for effect state management\n * Using bit flags for efficient state checks (O(1) operations)\n */\nexport const EFFECT_STATE_FLAGS = {\n  ...NODE_FLAGS,\n  EXECUTING: 1 << 3,\n} as const;\n\n/**\n * Bit flags for computed atom state management\n * Enables fast state transitions and checks without multiple boolean fields\n */\nexport const COMPUTED_STATE_FLAGS = {\n  ...NODE_FLAGS,\n  DIRTY: 1 << 3,\n  IDLE: 1 << 4,\n  PENDING: 1 << 5,\n  RESOLVED: 1 << 6,\n  REJECTED: 1 << 7,\n  RECOMPUTING: 1 << 8,\n  HAS_ERROR: 1 << 9,\n} as const;\n\n/**\n * Bit flags for atom state management\n */\nexport const ATOM_STATE_FLAGS = {\n  ...NODE_FLAGS,\n  SYNC: 1 << 3,\n  NOTIFICATION_SCHEDULED: 1 << 4,\n} as const;\n\n/**\n * Object pool configuration\n * Controls memory management and GC pressure reduction\n */\nexport const POOL_CONFIG = {\n  /** Maximum number of pooled objects to prevent memory bloat */\n  MAX_SIZE: 1000,\n  /** Number of objects to pre-allocate for performance-critical paths */\n  WARMUP_SIZE: 100,\n} as const;\n\n/**\n * Scheduler configuration\n * Controls batching behavior and performance limits\n */\nexport const SCHEDULER_CONFIG = {\n  /** Maximum effect executions per second to detect infinite loops (Legacy/Fallback) */\n  MAX_EXECUTIONS_PER_SECOND: 1000,\n  /** Threshold for cleaning up old execution timestamps */\n  CLEANUP_THRESHOLD: 1000,\n\n  /**\n   * Maximum executions per effect within a single flush cycle\n   * Increased from 50 to 100\n   */\n  MAX_EXECUTIONS_PER_EFFECT: 100,\n\n  /**\n   * Maximum total executions across all effects in a single flush cycle\n   * Increased from 5000 to 10000\n   */\n  MAX_EXECUTIONS_PER_FLUSH: 10000,\n\n  /** Maximum iterations for synchronous flush loop to prevent infinite loops */\n  MAX_FLUSH_ITERATIONS: 1000,\n\n  /** Minimum allowed value for max flush iterations */\n  MIN_FLUSH_ITERATIONS: 10,\n\n  /** Threshold for shrinking the batch queue to assist GC */\n  BATCH_QUEUE_SHRINK_THRESHOLD: 1000,\n} as const;\n\n/**\n * Debug configuration defaults\n */\nexport const DEBUG_CONFIG = {\n  /** Maximum dependencies before warning about large dependency graphs */\n  MAX_DEPENDENCIES: 1000,\n  /** Enable infinite loop detection warnings */\n  WARN_INFINITE_LOOP: true,\n} as const;\n\n/**\n * Maximum Small Integer (Smi) value in V8 (31-bit signed integer)\n * Used for IDs and Versions to prevent HeapNumber allocation\n */\nexport const SMI_MAX = 0x3fffffff;\n\n/**\n * Environment detection\n */\nexport const IS_DEV =\n  typeof process !== 'undefined' && process.env && process.env.NODE_ENV !== 'production';\n\n/**\n * Empty frozen error array constant to avoid allocations\n * Used for computed atoms with no errors (the common case)\n */\nexport const EMPTY_ERROR_ARRAY: readonly Error[] = Object.freeze([]);\n","/**\n * Base error class for all atom-effect errors\n *\n * Provides enhanced error information including:\n * - Original cause tracking for error chains\n * - Recoverability flag for error handling strategies\n * - Timestamp for debugging and logging\n *\n * @example\n * ```ts\n * throw new AtomError('Invalid state', originalError, false);\n * ```\n */\nexport class AtomError extends Error {\n  /** Original error that caused this error, if any */\n  cause: Error | null;\n  /** Whether this error can be recovered from */\n  recoverable: boolean;\n  /** When this error occurred */\n  timestamp: Date;\n\n  /**\n   * Creates a new AtomError\n   * @param message - Error message describing what went wrong\n   * @param cause - Original error that caused this error\n   * @param recoverable - Whether the operation can be retried\n   */\n  constructor(message: string, cause: Error | null = null, recoverable: boolean = true) {\n    super(message);\n    this.name = 'AtomError';\n    this.cause = cause;\n    this.recoverable = recoverable;\n    this.timestamp = new Date();\n  }\n}\n\n/**\n * Error thrown during computed value computation\n *\n * Computed errors are considered recoverable by default since they typically\n * result from transient data issues rather than programming errors.\n */\nexport class ComputedError extends AtomError {\n  /**\n   * Creates a new ComputedError\n   * @param message - Error message\n   * @param cause - Original error\n   */\n  constructor(message: string, cause: Error | null = null) {\n    super(message, cause, true);\n    this.name = 'ComputedError';\n  }\n}\n\n/**\n * Error thrown during effect execution\n *\n * Effect errors are considered non-recoverable by default since effects\n * typically represent critical side effects that shouldn't fail silently.\n */\nexport class EffectError extends AtomError {\n  /**\n   * Creates a new EffectError\n   * @param message - Error message\n   * @param cause - Original error\n   */\n  constructor(message: string, cause: Error | null = null) {\n    super(message, cause, false);\n    this.name = 'EffectError';\n  }\n}\n\n/**\n * Error thrown by the scheduler system\n *\n * Scheduler errors indicate fundamental issues with the batching/scheduling\n * mechanism and are considered non-recoverable.\n */\nexport class SchedulerError extends AtomError {\n  /**\n   * Creates a new SchedulerError\n   * @param message - Error message\n   * @param cause - Original error\n   */\n  constructor(message: string, cause: Error | null = null) {\n    super(message, cause, false);\n    this.name = 'SchedulerError';\n  }\n}\n","import { DEBUG_CONFIG } from '@/constants';\nimport { ComputedError } from '@/errors/errors';\nimport type { DebugConfig, Dependency, DependencyId } from '@/types';\n\n/** Symbol for debug display name on reactive objects */\nexport const DEBUG_NAME: unique symbol = Symbol('debugName');\n\n/** Symbol for unique identifier on reactive objects */\nexport const DEBUG_ID: unique symbol = Symbol('id');\n\n/** Symbol for type discriminator ('atom' | 'computed' | 'effect') */\nexport const DEBUG_TYPE: unique symbol = Symbol('type');\n\n/** Sentinel to distinguish \"no default\" from explicit `undefined` */\nexport const NO_DEFAULT_VALUE: unique symbol = Symbol('noDefaultValue');\n\n/** Type guard for objects with dependencies array */\nfunction hasDependencies(obj: Dependency): obj is Dependency & { dependencies: Dependency[] } {\n  return 'dependencies' in obj && Array.isArray((obj as { dependencies: unknown }).dependencies);\n}\n\n/** Internal recursive checker for circular dependency detection */\nfunction checkCircularInternal(dep: Dependency, current: object, visited: Set<number>): void {\n  if (visited.has(dep.id)) {\n    return;\n  }\n  visited.add(dep.id);\n\n  if (dep === current) {\n    throw new ComputedError('Indirect circular dependency detected');\n  }\n\n  if (hasDependencies(dep)) {\n    const deps = dep.dependencies;\n    for (let i = 0; i < deps.length; i++) {\n      const child = deps[i];\n      if (child) checkCircularInternal(child, current, visited);\n    }\n  }\n}\n\n/**\n * Debug utilities for development-time dependency tracking and circular detection.\n * Most features only active when `NODE_ENV === 'development'`.\n */\nexport const debug: DebugConfig = {\n  enabled:\n    typeof process !== 'undefined' && (process as NodeJS.Process).env?.NODE_ENV === 'development',\n\n  maxDependencies: DEBUG_CONFIG.MAX_DEPENDENCIES,\n\n  warnInfiniteLoop: DEBUG_CONFIG.WARN_INFINITE_LOOP,\n\n  warn(condition: boolean, message: string): void {\n    if (this.enabled && condition) {\n      console.warn(`[Atom Effect] ${message}`);\n    }\n  },\n\n  /**\n   * Checks for circular dependencies.\n   * Direct check runs always; indirect check only in dev mode.\n   * @throws {ComputedError} When circular dependency detected\n   */\n  checkCircular(dep: Dependency, current: object): void {\n    if (dep === current) {\n      throw new ComputedError('Direct circular dependency detected');\n    }\n\n    if (!this.enabled) {\n      return;\n    }\n\n    checkCircularInternal(dep, current, new Set<number>());\n  },\n\n  attachDebugInfo(obj: object, type: string, id: DependencyId): void {\n    if (!this.enabled) {\n      return;\n    }\n\n    const target = obj as Record<symbol, unknown>;\n    target[DEBUG_NAME] = `${type}_${id}`;\n    target[DEBUG_ID] = id;\n    target[DEBUG_TYPE] = type;\n  },\n\n  getDebugName(obj: object | null | undefined): string | undefined {\n    if (obj != null && DEBUG_NAME in obj) {\n      return (obj as Record<symbol, unknown>)[DEBUG_NAME] as string | undefined;\n    }\n    return undefined;\n  },\n\n  getDebugType(obj: object | null | undefined): string | undefined {\n    if (obj != null && DEBUG_TYPE in obj) {\n      return (obj as Record<symbol, unknown>)[DEBUG_TYPE] as string | undefined;\n    }\n    return undefined;\n  },\n};\n\nlet nextId = 1;\n\n/** Generates a unique numeric ID for reactive objects */\nexport const generateId = (): DependencyId => nextId++ as DependencyId;\n","import { NODE_FLAGS } from '@/constants';\nimport type { DependencySubscriber } from '@/tracking/tracking.types';\nimport type { Dependency, Subscriber } from '@/types';\nimport { debug } from '@/utils/debug';\n\n/**\n * Tracks a dependency for the current reactive context.\n */\nexport function trackDependency<T>(\n  dependency: Dependency,\n  current: unknown,\n  subscribers: SubscriberLink<T>[]\n): void {\n  if (current === undefined || current === null) return;\n\n  // 1. DependencySubscriber path (Computed, Effect) - Most common case\n  const depSub = current as DependencySubscriber;\n  if (typeof depSub.addDependency === 'function') {\n    depSub.addDependency(dependency);\n    return;\n  }\n\n  // 2. Manual function listeners\n  if (typeof current === 'function') {\n    const fn = current as (newValue?: T, oldValue?: T) => void;\n    // Optimization: Hoist length to avoid repeated access\n    const len = subscribers.length;\n    for (let i = 0; i < len; i++) {\n      if (subscribers[i]!.fn === fn) return;\n    }\n    subscribers.push(new SubscriberLink(fn));\n    dependency.flags |= NODE_FLAGS.HAS_FN_SUBS;\n    return;\n  }\n\n  // 3. Subscriber objects with 'execute' method\n  const sub = current as Subscriber;\n  if (typeof sub.execute === 'function') {\n    const len = subscribers.length;\n    for (let i = 0; i < len; i++) {\n      if (subscribers[i]!.sub === sub) return;\n    }\n    subscribers.push(new SubscriberLink(undefined, sub));\n    dependency.flags |= NODE_FLAGS.HAS_OBJ_SUBS;\n  }\n}\n\n/**\n * Synchronizes subscriptions using an O(N) strategy optimized for cache locality.\n * Uses DependencyLink (AOS) to improve data cohesion.\n */\nexport function syncDependencies(\n  nextLinks: DependencyLink[],\n  prevLinks: DependencyLink[],\n  tracker: Subscriber\n): void {\n  const prevLen = prevLinks.length;\n  const nextLen = nextLinks.length;\n\n  // 1. Mark existing dependencies\n  // Optimization: Unrolled simplified loop for setup\n  if (prevLen > 0) {\n    for (let i = 0; i < prevLen; i++) {\n      const link = prevLinks[i];\n      if (link) {\n        link.node._tempUnsub = link.unsub;\n      }\n    }\n  }\n\n  // 2. Process new dependencies (Sweep/Reuse)\n  for (let i = 0; i < nextLen; i++) {\n    const link = nextLinks[i];\n    if (!link) continue;\n\n    // cache node access\n    const node = link.node;\n    const existingUnsub = node._tempUnsub;\n\n    if (existingUnsub !== undefined) {\n      link.unsub = existingUnsub;\n      node._tempUnsub = undefined;\n    } else {\n      // New dependency found\n      debug.checkCircular(node, tracker);\n      link.unsub = node.subscribe(tracker);\n    }\n  }\n\n  // 3. Cleanup removed dependencies\n  if (prevLen > 0) {\n    for (let i = 0; i < prevLen; i++) {\n      const link = prevLinks[i];\n      if (link) {\n        // optimization: use cached node ref if possible, but here we access link.node\n        const node = link.node;\n        const remainingUnsub = node._tempUnsub;\n        if (remainingUnsub !== undefined) {\n          remainingUnsub();\n          node._tempUnsub = undefined;\n        }\n        // Link objects should be ideally cleaned up or returned to a pool\n        link.unsub = undefined;\n      }\n    }\n  }\n}\n\n/**\n * Encapsulates a link to a dependency with its version and subscription.\n * Part of the AOS (Array of Structs) refactoring to improve data cohesion.\n */\nexport class DependencyLink {\n  /** The dependency node being tracked */\n  node: Dependency;\n  /** The version of the dependency at the time of tracking */\n  version: number;\n  /** The unsubscription function for the dependency */\n  unsub: (() => void) | undefined;\n\n  constructor(node: Dependency, version: number, unsub: (() => void) | undefined = undefined) {\n    this.node = node;\n    this.version = version;\n    this.unsub = unsub;\n  }\n}\n\n/**\n * Encapsulates a link to a subscriber (either function or object).\n * Part of the AOS refactoring to unify subscriber management.\n */\nexport class SubscriberLink<T> {\n  /** Function listener (if any) */\n  fn: ((newValue?: T, oldValue?: T) => void) | undefined;\n  /** Subscriber object (if any) */\n  sub: Subscriber | undefined;\n\n  constructor(\n    fn?: ((newValue?: T, oldValue?: T) => void) | undefined,\n    sub?: Subscriber | undefined\n  ) {\n    this.fn = fn;\n    this.sub = sub;\n  }\n}\n","/**\n * Centralized error message constants for the atom-effect library.\n *\n * @description\n * Provides consistent, maintainable error messages across the library.\n * All messages are in English for international accessibility.\n *\n * @remarks\n * - Computed errors: Related to computed atom creation and execution\n * - Atom errors: Related to atom subscription and notification\n * - Effect errors: Related to effect lifecycle and cleanup\n * - Debug warnings: Non-critical warnings for debugging\n *\n * @example\n * ```ts\n * import { ERROR_MESSAGES } from './messages';\n *\n * if (typeof fn !== 'function') {\n *   throw new Error(ERROR_MESSAGES.COMPUTED_MUST_BE_FUNCTION);\n * }\n * ```\n */\nexport const ERROR_MESSAGES = {\n  // ─────────────────────────────────────────────────────────────────\n  // Computed errors\n  // ─────────────────────────────────────────────────────────────────\n\n  /**\n   * Error thrown when computed() receives a non-function argument.\n   */\n  COMPUTED_MUST_BE_FUNCTION: 'Computed function must be a function',\n\n  /**\n   * Error thrown when accessing a pending async computed without a default value.\n   */\n  COMPUTED_ASYNC_PENDING_NO_DEFAULT: 'Async computation is pending. No default value provided',\n\n  /**\n   * Error thrown when a synchronous computed computation fails.\n   */\n  COMPUTED_COMPUTATION_FAILED: 'Computed computation failed',\n\n  /**\n   * Error thrown when an asynchronous computed computation fails.\n   */\n  COMPUTED_ASYNC_COMPUTATION_FAILED: 'Async computed computation failed',\n\n  /**\n   * Error thrown when a circular dependency is detected during computation.\n   */\n  COMPUTED_CIRCULAR_DEPENDENCY: 'Circular dependency detected during computation',\n\n  /**\n   * Error thrown when accessing a disposed computed value.\n   */\n  COMPUTED_DISPOSED: 'Cannot access a disposed computed',\n\n  // ─────────────────────────────────────────────────────────────────\n  // Atom errors\n  // ─────────────────────────────────────────────────────────────────\n\n  /**\n   * Error thrown when atom.subscribe() receives an invalid listener.\n   */\n  ATOM_SUBSCRIBER_MUST_BE_FUNCTION: 'Subscription listener must be a function or Subscriber object',\n\n  /**\n   * Error logged when an individual subscriber throws during notification.\n   * @remarks This error is caught and logged to prevent cascading failures.\n   */\n  ATOM_INDIVIDUAL_SUBSCRIBER_FAILED: 'Error during individual atom subscriber execution',\n\n  // ─────────────────────────────────────────────────────────────────\n  // Effect errors\n  // ─────────────────────────────────────────────────────────────────\n\n  /**\n   * Error thrown when effect() receives a non-function argument.\n   */\n  EFFECT_MUST_BE_FUNCTION: 'Effect function must be a function',\n\n  /**\n   * Error thrown when an effect's execution fails.\n   */\n  EFFECT_EXECUTION_FAILED: 'Effect execution failed',\n\n  /**\n   * Error thrown when an effect's cleanup function fails.\n   */\n  EFFECT_CLEANUP_FAILED: 'Effect cleanup function execution failed',\n\n  /**\n   * Error thrown when attempting to run a disposed effect.\n   */\n  EFFECT_DISPOSED: 'Cannot run a disposed effect',\n\n  // ─────────────────────────────────────────────────────────────────\n  // Debug warnings\n  // ─────────────────────────────────────────────────────────────────\n\n  /**\n   * Warning message for large dependency graphs.\n   *\n   * @param count - The number of dependencies detected\n   * @returns Formatted warning message with dependency count\n   *\n   * @example\n   * ```ts\n   * console.warn(ERROR_MESSAGES.LARGE_DEPENDENCY_GRAPH(150));\n   * // Output: \"Large dependency graph detected: 150 dependencies\"\n   * ```\n   */\n  LARGE_DEPENDENCY_GRAPH: (count: number): string =>\n    `Large dependency graph detected: ${count} dependencies`,\n\n  /**\n   * Error logged when the onError callback itself throws an error.\n   * @remarks This prevents cascading failures from masking the original error.\n   */\n  CALLBACK_ERROR_IN_ERROR_HANDLER: 'Error occurred during onError callback execution',\n} as const;\n","import { IS_DEV, NODE_FLAGS, SMI_MAX } from '@/constants';\nimport { SubscriberLink } from '@/core/dep-tracking';\nimport { AtomError } from '@/errors/errors';\nimport { ERROR_MESSAGES } from '@/errors/messages';\nimport type { DependencyId, Subscriber } from '@/types';\nimport { generateId } from '@/utils/debug';\n\n/**\n * Base class for all reactive nodes (Atoms, Computed, Effects).\n */\nexport class ReactiveNode {\n  /** Bit flags representing the node's state */\n  flags: number;\n  /** Current version of the node's value */\n  version: number;\n  /** Last epoch this node was observed by the system */\n  _lastSeenEpoch: number;\n  /** Epoch when this node was last modified */\n  _modifiedAtEpoch: number;\n  /** Unique numeric identifier within SMI range */\n  readonly id: DependencyId;\n\n  /** @internal Temporary unsubscription function used during sync/propagation */\n  _tempUnsub: (() => void) | undefined;\n\n  constructor() {\n    this.flags = 0;\n    this.version = 0;\n    this._lastSeenEpoch = -1;\n    this._modifiedAtEpoch = -1;\n    this.id = (generateId() & SMI_MAX) as DependencyId;\n\n    this._tempUnsub = undefined;\n  }\n}\n\n/**\n * Abstract base class for reactive nodes that can be dependencies (Atom, Computed).\n */\nexport abstract class ReactiveDependency<T> extends ReactiveNode {\n  protected abstract _subscribers: SubscriberLink<T>[];\n\n  /**\n   * Subscribes a listener function or Subscriber object to value changes.\n   */\n  subscribe(listener: ((newValue?: T, oldValue?: T) => void) | Subscriber): () => void {\n    const subs = this._subscribers;\n    const isFn = typeof listener === 'function';\n\n    // Guard clause for invalid input\n    if (\n      !isFn &&\n      (listener === null ||\n        typeof listener !== 'object' ||\n        typeof (listener as Subscriber).execute !== 'function')\n    ) {\n      throw new AtomError(ERROR_MESSAGES.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);\n    }\n\n    // Optimization: Loop specialization to avoid branch inside loop\n    const len = subs.length;\n    if (isFn) {\n      for (let i = 0; i < len; i++) {\n        if (subs[i]!.fn === listener) {\n          if (IS_DEV) {\n            console.warn(\n              'Attempted to subscribe the same listener twice. Ignoring duplicate subscription.'\n            );\n          }\n          return () => {};\n        }\n      }\n    } else {\n      for (let i = 0; i < len; i++) {\n        if (subs[i]!.sub === listener) {\n          if (IS_DEV) {\n            console.warn(\n              'Attempted to subscribe the same listener twice. Ignoring duplicate subscription.'\n            );\n          }\n          return () => {};\n        }\n      }\n    }\n\n    const link = isFn\n      ? new SubscriberLink<T>(listener as (newValue?: T, oldValue?: T) => void)\n      : new SubscriberLink<T>(undefined, listener as Subscriber);\n\n    subs.push(link);\n    this.flags |= isFn ? NODE_FLAGS.HAS_FN_SUBS : NODE_FLAGS.HAS_OBJ_SUBS;\n\n    return () => {\n      const idx = subs.indexOf(link);\n      if (idx === -1) return;\n\n      // Fast removal (swap-pop)\n      const last = subs.pop()!;\n      if (idx < subs.length) {\n        subs[idx] = last;\n      }\n\n      const activeLen = subs.length;\n      if (activeLen === 0) {\n        this.flags &= ~(NODE_FLAGS.HAS_FN_SUBS | NODE_FLAGS.HAS_OBJ_SUBS);\n      } else {\n        // Optimization: Early exit if we still have both types\n        let foundFn = false;\n        let foundObj = false;\n\n        for (let i = 0; i < activeLen; i++) {\n          const s = subs[i]!;\n          if (s.fn) foundFn = true;\n          else foundObj = true;\n\n          if (foundFn && foundObj) break;\n        }\n\n        let newFlags = this.flags;\n        if (!foundFn) newFlags &= ~NODE_FLAGS.HAS_FN_SUBS;\n        if (!foundObj) newFlags &= ~NODE_FLAGS.HAS_OBJ_SUBS;\n        this.flags = newFlags;\n      }\n    };\n  }\n\n  /**\n   * Gets the total number of active subscribers.\n   */\n  subscriberCount(): number {\n    return this._subscribers.length;\n  }\n\n  /**\n   * Notifies all subscribers of a change.\n   */\n  protected _notifySubscribers(newValue: T | undefined, oldValue: T | undefined): void {\n    const flags = this.flags;\n    if (!(flags & (NODE_FLAGS.HAS_FN_SUBS | NODE_FLAGS.HAS_OBJ_SUBS))) return;\n\n    const subs = this._subscribers;\n    const len = subs.length;\n\n    for (let i = 0; i < len; i++) {\n      const s = subs[i]!;\n      try {\n        // Optimization: Direct property check prefers function (likely common case)\n        if (s.fn) {\n          s.fn(newValue, oldValue);\n        } else if (s.sub) {\n          s.sub.execute();\n        }\n      } catch (err) {\n        this._handleNotifyError(err);\n      }\n    }\n  }\n\n  /**\n   * Hoisted error reporter to keep notification loops lean and aid JIT inlining.\n   */\n  private _handleNotifyError(err: unknown): void {\n    console.error(new AtomError(ERROR_MESSAGES.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, err as Error));\n  }\n}\n","import { IS_DEV, SMI_MAX } from '@/constants';\n\nlet collectorEpoch = 0;\n\n/**\n * Increments and returns the next tracking epoch.\n * Used for O(1) dependency management and freshness checks.\n */\nexport function nextEpoch(): number {\n  collectorEpoch = (collectorEpoch + 1) & SMI_MAX || 1;\n  return collectorEpoch;\n}\n\n/** Returns the current tracking epoch. */\nexport function currentEpoch(): number {\n  return collectorEpoch;\n}\n\nexport let flushEpoch = 0;\nexport let flushExecutionCount = 0;\nlet isFlushing = false;\n\n/**\n * Starts a new scheduler flush cycle.\n * Increments the flush epoch and resets execution counts for loop detection.\n * @returns true if a new flush cycle was started, false if already flushing.\n */\nexport function startFlush(): boolean {\n  if (isFlushing) {\n    if (IS_DEV) {\n      console.warn(\n        'Warning: startFlush() called during flush - ignored to prevent infinite loop detection bypass'\n      );\n    }\n    return false;\n  }\n\n  isFlushing = true;\n  flushEpoch = (flushEpoch + 1) & SMI_MAX || 1;\n  flushExecutionCount = 0;\n  return true;\n}\n\n/** Ends the current scheduler flush cycle. */\nexport function endFlush(): void {\n  isFlushing = false;\n}\n\n/**\n * Increments the global execution count for the current flush cycle.\n * Used to detect global infinite loops.\n * @returns The new execution count.\n */\nexport function incrementFlushExecutionCount(): number {\n  if (!isFlushing) return 0;\n  return ++flushExecutionCount;\n}\n\n/** Resets all flush-related state. */\nexport function resetFlushState(): void {\n  flushEpoch = 0;\n  flushExecutionCount = 0;\n  isFlushing = false;\n}\n","import { IS_DEV, SCHEDULER_CONFIG } from '@/constants';\nimport { SchedulerError } from '@/errors/errors';\nimport { endFlush, startFlush } from '@/internal/epoch';\n\n/**\n * Current state of the scheduler.\n */\nexport enum SchedulerPhase {\n  /** No pending jobs, not currently flushing. */\n  IDLE = 0,\n  /** Currently within a batch() block. */\n  BATCHING = 1,\n  /** Currently executing queued jobs. */\n  FLUSHING = 2,\n}\n\n/**\n * Scheduler job interface.\n */\nexport interface SchedulerJob {\n  (): void;\n  /** Epoch for deduplication */\n  _nextEpoch?: number;\n}\n\n/**\n * Simplified scheduler for reactive updates with double-buffered queue.\n */\nclass Scheduler {\n  private readonly _queueBuffer: [SchedulerJob[], SchedulerJob[]];\n  private _bufferIndex: number;\n  private _size: number;\n  private _epoch: number;\n  private _isProcessing: boolean;\n  private _isBatching: boolean;\n  private _batchDepth: number;\n  private _batchQueue: SchedulerJob[];\n  private _batchQueueSize: number;\n  private _isFlushingSync: boolean;\n  private _maxFlushIterations: number;\n\n  constructor() {\n    this._queueBuffer = [[], []];\n    this._bufferIndex = 0;\n    this._size = 0;\n    this._epoch = 0;\n    this._isProcessing = false;\n    this._isBatching = false;\n    this._batchDepth = 0;\n    this._batchQueue = [];\n    this._batchQueueSize = 0;\n    this._isFlushingSync = false;\n    this._maxFlushIterations = SCHEDULER_CONFIG.MAX_FLUSH_ITERATIONS;\n  }\n\n  /**\n   * Returns the current operational phase of the scheduler.\n   */\n  get phase(): SchedulerPhase {\n    if (this._isProcessing || this._isFlushingSync) {\n      return SchedulerPhase.FLUSHING;\n    }\n    if (this._isBatching) {\n      return SchedulerPhase.BATCHING;\n    }\n    return SchedulerPhase.IDLE;\n  }\n\n  /** Current number of pending jobs. */\n  get queueSize(): number {\n    return this._size;\n  }\n\n  /**\n   * Returns whether the scheduler is currently batching updates.\n   */\n  get isBatching(): boolean {\n    return this._isBatching;\n  }\n\n  /**\n   * Schedules a task for execution.\n   */\n  schedule(callback: SchedulerJob): void {\n    if (IS_DEV && typeof callback !== 'function') {\n      throw new SchedulerError('Scheduler callback must be a function');\n    }\n\n    const epoch = this._epoch;\n    if (callback._nextEpoch === epoch) return;\n    callback._nextEpoch = epoch;\n\n    if (this._isBatching || this._isFlushingSync) {\n      this._batchQueue[this._batchQueueSize++] = callback;\n      return;\n    }\n\n    const index = this._bufferIndex;\n    const size = this._size;\n    this._queueBuffer[index]![size] = callback;\n    this._size = size + 1;\n\n    if (!this._isProcessing) {\n      this.flush();\n    }\n  }\n\n  /**\n   * Schedules a microtask-based flush of the queue.\n   * Coalesces multiple schedule calls into a single microtask execution.\n   */\n  private flush(): void {\n    if (this._isProcessing || this._size === 0) return;\n\n    this._isProcessing = true;\n\n    queueMicrotask(() => {\n      try {\n        if (this._size === 0) return;\n\n        const flushStarted = startFlush();\n        this._drainQueue();\n        if (flushStarted) endFlush();\n      } finally {\n        this._isProcessing = false;\n\n        // Recursively trigger next flush if new jobs were added during drainage\n        if (this._size > 0 && !this._isBatching) {\n          this.flush();\n        }\n      }\n    });\n  }\n\n  /**\n   * Immediately flushes all queues synchronously.\n   * Used at the end of a batch block or when immediate reflection is required.\n   */\n  private flushSync(): void {\n    this._isFlushingSync = true;\n    const flushStarted = startFlush();\n\n    try {\n      this._mergeBatchQueue();\n      this._drainQueue();\n    } finally {\n      this._isFlushingSync = false;\n      if (flushStarted) endFlush();\n    }\n  }\n\n  /**\n   * Merges jobs from the batching queue into the primary queue.\n   * Increments the epoch to ensure deduplication.\n   */\n  private _mergeBatchQueue(): void {\n    const size = this._batchQueueSize;\n    if (size === 0) return;\n\n    const epoch = ++this._epoch;\n    const bQueue = this._batchQueue;\n    const targetBuffer = this._queueBuffer[this._bufferIndex]!;\n    let targetSize = this._size;\n\n    for (let i = 0; i < size; i++) {\n      const job = bQueue[i]!;\n      if (job._nextEpoch !== epoch) {\n        job._nextEpoch = epoch;\n        targetBuffer[targetSize++] = job;\n      }\n    }\n\n    this._size = targetSize;\n    this._batchQueueSize = 0;\n    if (bQueue.length > SCHEDULER_CONFIG.BATCH_QUEUE_SHRINK_THRESHOLD) {\n      bQueue.length = 0;\n    }\n  }\n\n  private _drainQueue(): void {\n    let iterations = 0;\n    const max = this._maxFlushIterations;\n\n    while (this._size > 0) {\n      if (++iterations > max) {\n        this._handleFlushOverflow();\n        return;\n      }\n\n      this._processQueue();\n      this._mergeBatchQueue();\n    }\n  }\n\n  private _processQueue(): void {\n    const index = this._bufferIndex;\n    const jobs = this._queueBuffer[index]!;\n    const count = this._size;\n\n    // Swap to other buffer\n    this._bufferIndex = index ^ 1;\n    this._size = 0;\n    this._epoch++;\n\n    this._processJobs(jobs, count);\n  }\n\n  private _handleFlushOverflow(): void {\n    console.error(\n      new SchedulerError(\n        `Maximum flush iterations (${this._maxFlushIterations}) exceeded. Possible infinite loop.`\n      )\n    );\n    this._size = 0;\n    this._queueBuffer[this._bufferIndex]!.length = 0;\n    this._batchQueueSize = 0;\n  }\n\n  private _processJobs(jobs: SchedulerJob[], count: number): void {\n    for (let i = 0; i < count; i++) {\n      try {\n        const job = jobs[i];\n        if (job) job();\n      } catch (error) {\n        console.error(\n          new SchedulerError('Error occurred during scheduler execution', error as Error)\n        );\n      }\n    }\n    // O(1) clear of the array to release references without re-allocating\n    jobs.length = 0;\n  }\n\n  startBatch(): void {\n    this._batchDepth++;\n    this._isBatching = true;\n  }\n\n  endBatch(): void {\n    const depth = this._batchDepth;\n    if (depth === 0) {\n      if (IS_DEV) {\n        console.warn('endBatch() called without matching startBatch(). Ignoring.');\n      }\n      return;\n    }\n\n    const nextDepth = depth - 1;\n    this._batchDepth = nextDepth;\n\n    if (nextDepth === 0) {\n      this.flushSync();\n      this._isBatching = false;\n    }\n  }\n\n  setMaxFlushIterations(max: number): void {\n    if (max < SCHEDULER_CONFIG.MIN_FLUSH_ITERATIONS) {\n      throw new SchedulerError(\n        `Max flush iterations must be at least ${SCHEDULER_CONFIG.MIN_FLUSH_ITERATIONS}`\n      );\n    }\n    this._maxFlushIterations = max;\n  }\n}\n\nexport const scheduler = new Scheduler();\n","import type { Listener } from './tracking.types';\n\n/** Interface for the tracking context managing dependency collection */\nexport interface ITrackingContext {\n  current: Listener | null;\n\n  /** Executes fn within tracking context with given listener */\n  run<T>(listener: Listener, fn: () => T): T;\n\n  getCurrent(): Listener | null;\n}\n\n/**\n * Manages the active tracking context to identify dependencies during execution.\n */\nexport class TrackingContext implements ITrackingContext {\n  current: Listener | null = null;\n\n  /**\n   * Runs the provided function within the context of the given listener.\n   * Restores the previous context after the function completes or throws.\n   *\n   * @param listener - The tracking listener to associate with the current execution.\n   * @param fn - The function to execute.\n   */\n  run<T>(listener: Listener, fn: () => T): T {\n    const prev = this.current;\n    this.current = listener;\n    try {\n      return fn();\n    } finally {\n      this.current = prev;\n    }\n  }\n\n  /**\n   * Retrieves the listener currently associated with the tracking context.\n   */\n  getCurrent(): Listener | null {\n    return this.current;\n  }\n}\n\n/**\n * Global tracking context for dependency collection.\n * Atoms register as dependencies when accessed within a tracked context.\n */\nexport const trackingContext: TrackingContext = new TrackingContext();\n","import { AtomError } from '@/errors/errors';\nimport { trackingContext } from './context';\n\n/**\n * Executes a function without tracking any reactive dependencies accessed during its execution.\n * This prevents the calling context from subscribing to any atoms read within the callback.\n *\n * @param fn - The function to execute in an untracked context.\n * @returns The value returned by the provided function.\n * @throws {AtomError} If the provided argument is not a function.\n */\nexport function untracked<T>(fn: () => T): T {\n  if (typeof fn !== 'function') {\n    throw new AtomError('Untracked callback must be a function');\n  }\n\n  const prev = trackingContext.current;\n  trackingContext.current = null;\n\n  try {\n    return fn();\n  } finally {\n    trackingContext.current = prev;\n  }\n}\n","import { ATOM_STATE_FLAGS, SMI_MAX } from '@/constants';\nimport { ReactiveDependency } from '@/core/base';\nimport { type SubscriberLink, trackDependency } from '@/core/dep-tracking';\nimport { scheduler } from '@/internal/scheduler';\nimport { trackingContext } from '@/tracking';\nimport type { AtomOptions, WritableAtom } from '@/types';\nimport { debug } from '@/utils/debug';\n\n/**\n * Internal {@link WritableAtom} implementation.\n * Extends {@link ReactiveDependency} to provide reactive state that can be observed and updated.\n */\nclass AtomImpl<T> extends ReactiveDependency<T> implements WritableAtom<T> {\n  private _value: T;\n  private _pendingOldValue: T | undefined;\n  private _notifyTask: (() => void) | undefined;\n\n  protected _subscribers: SubscriberLink<T>[];\n\n  constructor(initialValue: T, sync: boolean) {\n    super();\n\n    this._value = initialValue;\n    this._pendingOldValue = undefined;\n    this._notifyTask = undefined;\n    this._subscribers = [];\n\n    if (sync) {\n      this.flags |= ATOM_STATE_FLAGS.SYNC;\n    }\n\n    // Attach debug info in dev mode\n    debug.attachDebugInfo(this, 'atom', this.id);\n  }\n\n  /**\n   * Returns the current value and registers the atom as a dependency if in a tracking context.\n   */\n  get value(): T {\n    const current = trackingContext.current;\n    if (current) {\n      trackDependency(this, current, this._subscribers);\n    }\n    return this._value;\n  }\n\n  /**\n   * Sets a new value and schedules notifications if the value has changed.\n   */\n  set value(newValue: T) {\n    const oldValue = this._value;\n    // Optimization: Identity check is significantly faster than Object.is for common cases.\n    if (oldValue === newValue || Object.is(oldValue, newValue)) return;\n\n    this._value = newValue;\n    this.version = (this.version + 1) & SMI_MAX;\n\n    let flags = this.flags;\n    // Combined bitwise check to reduce property access overhead\n    if (flags & (ATOM_STATE_FLAGS.HAS_FN_SUBS | ATOM_STATE_FLAGS.HAS_OBJ_SUBS)) {\n      if (flags & ATOM_STATE_FLAGS.NOTIFICATION_SCHEDULED) {\n        return;\n      }\n\n      this._pendingOldValue = oldValue;\n      flags |= ATOM_STATE_FLAGS.NOTIFICATION_SCHEDULED;\n      this.flags = flags;\n\n      // Bypass scheduler if in SYNC mode and not currently batching\n      if (flags & ATOM_STATE_FLAGS.SYNC && !scheduler.isBatching) {\n        this._flushNotifications();\n        return;\n      }\n\n      if (!this._notifyTask) {\n        this._notifyTask = () => this._flushNotifications();\n      }\n      scheduler.schedule(this._notifyTask);\n    }\n  }\n\n  /**\n   * Flushes scheduled notifications and resets state for the next cycle.\n   */\n  private _flushNotifications(): void {\n    const flags = this.flags;\n    // Combined guard clause for disposal and redundant flush cycles\n    if (!(flags & ATOM_STATE_FLAGS.NOTIFICATION_SCHEDULED) || flags & ATOM_STATE_FLAGS.DISPOSED) {\n      return;\n    }\n\n    const oldValue = this._pendingOldValue as T;\n    this._pendingOldValue = undefined;\n    this.flags = flags & ~ATOM_STATE_FLAGS.NOTIFICATION_SCHEDULED;\n\n    this._notifySubscribers(this._value, oldValue);\n  }\n\n  /**\n   * Returns the current value without registering it as a dependency.\n   */\n  peek(): T {\n    return this._value;\n  }\n\n  /**\n   * Disposes of the atom and releases all subscribers and tasks.\n   */\n  dispose(): void {\n    const flags = this.flags;\n    if (flags & ATOM_STATE_FLAGS.DISPOSED) {\n      return;\n    }\n\n    // Reuse arrays by clearing length to avoid new allocations if resubscribed/later pooled\n    this._subscribers.length = 0;\n\n    this.flags = flags | ATOM_STATE_FLAGS.DISPOSED;\n    this._value = undefined as T;\n    this._pendingOldValue = undefined;\n    this._notifyTask = undefined;\n  }\n}\n\n/**\n * Creates a reactive atom holding mutable state.\n *\n * @param initialValue - The initial value of the atom.\n * @param options - Configuration options (sync: boolean).\n */\nexport function atom<T>(initialValue: T, options: AtomOptions = {}): WritableAtom<T> {\n  return new AtomImpl(initialValue, options.sync ?? false);\n}\n","import { IS_DEV } from '@/constants';\nimport type { PoolStats } from '@/types';\n\n/** @internal */\nclass PoolStatsRejected {\n  frozen: number;\n  tooLarge: number;\n  poolFull: number;\n\n  constructor() {\n    this.frozen = 0;\n    this.tooLarge = 0;\n    this.poolFull = 0;\n  }\n}\n\n/** @internal */\nclass PoolStatsCollector {\n  acquired: number;\n  released: number;\n  rejected: PoolStatsRejected;\n\n  constructor() {\n    this.acquired = 0;\n    this.released = 0;\n    this.rejected = new PoolStatsRejected();\n  }\n}\n\n/**\n * Generic Array Pool.\n * Provides type-safe pooling for different array types to reduce GC pressure.\n * Supports capacity limits and stats tracking in development mode.\n */\nexport class ArrayPool<T> {\n  private pool: T[][];\n  private readonly maxPoolSize: number;\n  private readonly maxReusableCapacity: number;\n  private stats: PoolStatsCollector | null;\n\n  constructor() {\n    this.pool = [];\n    this.maxPoolSize = 50;\n    this.maxReusableCapacity = 256;\n    this.stats = IS_DEV ? new PoolStatsCollector() : null;\n  }\n\n  /** Acquires an array from the pool or creates a new one if the pool is empty. */\n  acquire(): T[] {\n    const stats = this.stats;\n    if (stats) stats.acquired++;\n    return this.pool.pop() ?? [];\n  }\n\n  /**\n   * Releases an array back to the pool.\n   * Clears the array before storing it.\n   */\n  release(arr: T[], emptyConst?: readonly T[]): void {\n    const stats = this.stats;\n\n    // 1. Skip if empty constant (identity check is very fast)\n    if (emptyConst && arr === emptyConst) return;\n\n    // 2. Accuracy check: Skip frozen arrays (prevent length manipulation errors)\n    // Object.isFrozen is expensive, so it should be checked after ID checks\n    if (Object.isFrozen(arr)) {\n      if (stats) stats.rejected.frozen++;\n      return;\n    }\n\n    // 3. Reject based on capacity or pool size\n    if (arr.length > this.maxReusableCapacity) {\n      if (stats) stats.rejected.tooLarge++;\n      return;\n    }\n\n    const pool = this.pool;\n    if (pool.length >= this.maxPoolSize) {\n      if (stats) stats.rejected.poolFull++;\n      return;\n    }\n\n    // 4. Clear and store\n    arr.length = 0;\n    pool.push(arr);\n    if (stats) stats.released++;\n  }\n\n  /** Returns current stats for the pool (dev mode only). */\n  getStats(): PoolStats | null {\n    const stats = this.stats;\n    if (!stats) return null;\n\n    const { acquired, released, rejected } = stats;\n    const { frozen, tooLarge, poolFull } = rejected;\n\n    return {\n      acquired,\n      released,\n      rejected: {\n        frozen,\n        tooLarge,\n        poolFull,\n      },\n      leaked: acquired - released - (frozen + tooLarge + poolFull),\n      poolSize: this.pool.length,\n    };\n  }\n\n  /** Resets the pool and its stats. */\n  reset(): void {\n    this.pool.length = 0;\n    const stats = this.stats;\n    if (stats) {\n      stats.acquired = 0;\n      stats.released = 0;\n      stats.rejected.frozen = 0;\n      stats.rejected.tooLarge = 0;\n      stats.rejected.poolFull = 0;\n    }\n  }\n}\n","import type { DependencyLink, SubscriberLink } from '@/core/dep-tracking';\nimport type { Dependency, Subscriber } from '@/types';\nimport { ArrayPool } from '@/utils/array-pool';\n\n// Shared Constants\nexport const EMPTY_DEPS = Object.freeze([]) as unknown as Dependency[];\nexport const EMPTY_SUBS = Object.freeze([]) as unknown as Subscriber[];\nexport const EMPTY_UNSUBS = Object.freeze([]) as unknown as (() => void)[];\nexport const EMPTY_VERSIONS = Object.freeze([]) as unknown as number[];\nexport const EMPTY_LINKS = Object.freeze([]) as unknown as DependencyLink[];\nexport const EMPTY_SUBSCRIBERS = Object.freeze([]) as unknown as SubscriberLink<unknown>[];\n\nexport const depArrayPool = new ArrayPool<Dependency>();\nexport const unsubArrayPool = new ArrayPool<() => void>();\nexport const versionArrayPool = new ArrayPool<number>();\nexport const linksArrayPool = new ArrayPool<DependencyLink>();\nexport const subscriberPool = new ArrayPool<SubscriberLink<unknown>>();\n","import { AtomError } from '@/errors/errors';\n\n/**\n * Wraps an unknown error in the appropriate AtomError subclass\n *\n * Provides consistent error handling by:\n * - Preserving original error information in the cause field\n * - Adding contextual information about where the error occurred\n * - Returning existing AtomErrors unchanged\n * - Handling various error types (TypeError, ReferenceError, etc.)\n *\n * @param error - Unknown error to wrap\n * @param ErrorClass - AtomError subclass to use for wrapping\n * @param context - Context string describing where the error occurred\n * @returns Wrapped error with contextual information\n *\n * @example\n * ```ts\n * try {\n *   computeFn();\n * } catch (err) {\n *   throw wrapError(err, ComputedError, 'computation phase');\n * }\n * ```\n */\nexport function wrapError(\n  error: unknown,\n  ErrorClass: typeof AtomError,\n  context: string\n): AtomError {\n  if (error instanceof TypeError) {\n    return new ErrorClass(`Type error (${context}): ${error.message}`, error);\n  }\n  if (error instanceof ReferenceError) {\n    return new ErrorClass(`Reference error (${context}): ${error.message}`, error);\n  }\n  if (error instanceof AtomError) {\n    return error;\n  }\n\n  // Handle other error types\n  const errorMessage = error instanceof Error ? error.message : String(error);\n  const cause = error instanceof Error ? error : null;\n  return new ErrorClass(`Unexpected error (${context}): ${errorMessage}`, cause);\n}\n","import type { ComputedAtom, EffectObject, ReadonlyAtom } from '@/types';\nimport { debug } from './debug';\n\n/** Checks if the given object is a ReadonlyAtom. */\nexport function isAtom(obj: unknown): obj is ReadonlyAtom {\n  return (\n    obj !== null &&\n    typeof obj === 'object' &&\n    'value' in obj &&\n    typeof (obj as { subscribe?: unknown }).subscribe === 'function'\n  );\n}\n\n/** Checks if the given object is a ComputedAtom. */\nexport function isComputed(obj: unknown): obj is ComputedAtom {\n  if (debug.enabled && obj != null && typeof obj === 'object') {\n    if (debug.getDebugType(obj) === 'computed') return true;\n  }\n  return isAtom(obj) && typeof (obj as { invalidate?: unknown }).invalidate === 'function';\n}\n\n/** Checks if the given object is an EffectObject. */\nexport function isEffect(obj: unknown): obj is EffectObject {\n  return (\n    obj !== null &&\n    typeof obj === 'object' &&\n    typeof (obj as { dispose?: unknown }).dispose === 'function' &&\n    typeof (obj as { run?: unknown }).run === 'function'\n  );\n}\n\n/**\n * Type guard to check if a value is a Promise\n */\nexport function isPromise<T>(value: unknown): value is Promise<T> {\n  return value != null && typeof (value as { then?: unknown }).then === 'function';\n}\n","import { AsyncState, COMPUTED_STATE_FLAGS, EMPTY_ERROR_ARRAY, SMI_MAX } from '@/constants';\nimport { ReactiveDependency } from '@/core/base';\nimport {\n  DependencyLink,\n  type SubscriberLink,\n  syncDependencies,\n  trackDependency,\n} from '@/core/dep-tracking';\nimport type { AtomError } from '@/errors/errors';\nimport { ComputedError } from '@/errors/errors';\nimport { ERROR_MESSAGES } from '@/errors/messages';\nimport { currentEpoch, nextEpoch } from '@/internal/epoch';\nimport { EMPTY_LINKS, linksArrayPool } from '@/internal/pool';\nimport { trackingContext } from '@/tracking';\nimport type {\n  AsyncStateType,\n  ComputedAtom,\n  ComputedOptions,\n  Dependency,\n  Subscriber,\n} from '@/types';\nimport { debug, NO_DEFAULT_VALUE } from '@/utils/debug';\nimport { wrapError } from '@/utils/error';\nimport { isPromise } from '@/utils/type-guards';\n\n// AsyncState mapping\nconst ASYNC_STATE_MASK =\n  COMPUTED_STATE_FLAGS.RESOLVED | COMPUTED_STATE_FLAGS.PENDING | COMPUTED_STATE_FLAGS.REJECTED;\nconst ASYNC_STATE_LOOKUP = Array(ASYNC_STATE_MASK + 1).fill(AsyncState.IDLE);\nASYNC_STATE_LOOKUP[COMPUTED_STATE_FLAGS.RESOLVED] = AsyncState.RESOLVED;\nASYNC_STATE_LOOKUP[COMPUTED_STATE_FLAGS.PENDING] = AsyncState.PENDING;\nASYNC_STATE_LOOKUP[COMPUTED_STATE_FLAGS.REJECTED] = AsyncState.REJECTED;\n\nconst MAX_ASYNC_RETRIES = 3;\nconst MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1;\n\n/**\n * Computed atom with lazy evaluation, caching, and async support.\n * Uses bit flags for state and epoch-based dependency deduplication.\n */\nclass ComputedAtomImpl<T> extends ReactiveDependency<T> implements ComputedAtom<T>, Subscriber {\n  private _value: T;\n  private _error: AtomError | null;\n  private _promiseId: number;\n  private readonly _equal: (a: T, b: T) => boolean;\n\n  private readonly _fn: () => T | Promise<T>;\n  private readonly _defaultValue: T;\n  private readonly _onError: ((error: Error) => void) | null;\n\n  protected _subscribers: SubscriberLink<T>[];\n\n  private _links: DependencyLink[];\n\n  // Error propagation fields\n  private _cachedErrors: readonly Error[] | null;\n  private _errorCacheEpoch: number;\n\n  // Async phase drift validation fields\n  private _asyncStartAggregateVersion: number;\n  private _asyncRetryCount: number;\n\n  // Dependency tracking state\n  private _trackEpoch: number;\n  private _trackLinks: DependencyLink[];\n  private _trackCount: number;\n\n  constructor(fn: () => T | Promise<T>, options: ComputedOptions<T> = {}) {\n    if (typeof fn !== 'function') {\n      throw new ComputedError(ERROR_MESSAGES.COMPUTED_MUST_BE_FUNCTION);\n    }\n\n    super();\n\n    this._value = undefined as T;\n    this.flags = COMPUTED_STATE_FLAGS.DIRTY | COMPUTED_STATE_FLAGS.IDLE;\n    this._error = null;\n    this._promiseId = 0;\n    this._equal = options.equal ?? Object.is;\n    this._fn = fn;\n    this._defaultValue = 'defaultValue' in options ? options.defaultValue : (NO_DEFAULT_VALUE as T);\n    this._onError = options.onError ?? null;\n\n    this._subscribers = [];\n    this._links = EMPTY_LINKS;\n    this._cachedErrors = null;\n    this._errorCacheEpoch = -1;\n    this._asyncStartAggregateVersion = 0;\n    this._asyncRetryCount = 0;\n\n    this._trackEpoch = -1;\n    this._trackLinks = EMPTY_LINKS;\n    this._trackCount = 0;\n\n    debug.attachDebugInfo(this, 'computed', this.id);\n\n    if (debug.enabled) {\n      const debugObj = this as unknown as Record<string, unknown>;\n      debugObj.subscriberCount = this.subscriberCount.bind(this);\n      debugObj.isDirty = () => (this.flags & COMPUTED_STATE_FLAGS.DIRTY) !== 0;\n      debugObj.links = this._links;\n    }\n\n    if (options.lazy === false) {\n      try {\n        this._recompute();\n      } catch {\n        // Initial computation failure suppressed\n      }\n    }\n  }\n\n  get value(): T {\n    const current = trackingContext.current;\n    if (current) trackDependency(this, current, this._subscribers);\n\n    let flags = this.flags;\n\n    // Fast path: Already resolved and not invalidated\n    if (\n      (flags &\n        (COMPUTED_STATE_FLAGS.RESOLVED |\n          COMPUTED_STATE_FLAGS.DIRTY |\n          COMPUTED_STATE_FLAGS.IDLE)) ===\n      COMPUTED_STATE_FLAGS.RESOLVED\n    ) {\n      return this._value;\n    }\n\n    if (flags & COMPUTED_STATE_FLAGS.DISPOSED) {\n      throw new ComputedError(ERROR_MESSAGES.COMPUTED_DISPOSED);\n    }\n\n    if (flags & COMPUTED_STATE_FLAGS.RECOMPUTING) {\n      const defValue = this._defaultValue;\n      if (defValue !== (NO_DEFAULT_VALUE as T)) return defValue;\n      throw new ComputedError(ERROR_MESSAGES.COMPUTED_CIRCULAR_DEPENDENCY);\n    }\n\n    if (flags & (COMPUTED_STATE_FLAGS.DIRTY | COMPUTED_STATE_FLAGS.IDLE)) {\n      this._recompute();\n      flags = this.flags;\n    }\n\n    if (flags & COMPUTED_STATE_FLAGS.RESOLVED) {\n      return this._value;\n    }\n\n    const defaultValue = this._defaultValue;\n    const hasDefault = defaultValue !== (NO_DEFAULT_VALUE as T);\n\n    if (flags & COMPUTED_STATE_FLAGS.PENDING) {\n      if (hasDefault) return defaultValue;\n      throw new ComputedError(ERROR_MESSAGES.COMPUTED_ASYNC_PENDING_NO_DEFAULT);\n    }\n\n    if (flags & COMPUTED_STATE_FLAGS.REJECTED) {\n      const error = this._error;\n      if (error?.recoverable && hasDefault) return defaultValue;\n      throw error;\n    }\n\n    return this._value;\n  }\n\n  peek(): T {\n    return this._value;\n  }\n\n  get state(): AsyncStateType {\n    const current = trackingContext.current;\n    if (current) trackDependency(this, current, this._subscribers);\n    return ASYNC_STATE_LOOKUP[this.flags & ASYNC_STATE_MASK];\n  }\n\n  get hasError(): boolean {\n    const current = trackingContext.current;\n    if (current) trackDependency(this, current, this._subscribers);\n\n    const flags = this.flags;\n    if (flags & (COMPUTED_STATE_FLAGS.REJECTED | COMPUTED_STATE_FLAGS.HAS_ERROR)) return true;\n\n    const links = this._links;\n    for (let i = 0, len = links.length; i < len; i++) {\n      const link = links[i]!;\n      if (link.node.flags & COMPUTED_STATE_FLAGS.HAS_ERROR) return true;\n    }\n    return false;\n  }\n\n  get isValid(): boolean {\n    return !this.hasError;\n  }\n\n  get errors(): readonly Error[] {\n    const current = trackingContext.current;\n    if (current) trackDependency(this, current, this._subscribers);\n\n    if (!this.hasError) return EMPTY_ERROR_ARRAY;\n\n    const epoch = currentEpoch();\n    if (this._errorCacheEpoch === epoch && this._cachedErrors !== null) {\n      return this._cachedErrors;\n    }\n\n    const errorSet = new Set<Error>();\n    const localError = this._error;\n    if (localError) errorSet.add(localError);\n\n    const links = this._links;\n    for (let i = 0, len = links.length; i < len; i++) {\n      const dep = links[i]!.node;\n      if (dep.flags & COMPUTED_STATE_FLAGS.HAS_ERROR) {\n        const depErrors = (dep as unknown as ComputedAtom<unknown>).errors;\n        if (depErrors) {\n          for (let j = 0, jLen = depErrors.length; j < jLen; j++) {\n            const err = depErrors[j];\n            if (err) errorSet.add(err);\n          }\n        }\n      }\n    }\n\n    const errors = Object.freeze(Array.from(errorSet));\n    this._errorCacheEpoch = epoch;\n    this._cachedErrors = errors;\n    return errors;\n  }\n\n  get lastError(): Error | null {\n    const current = trackingContext.current;\n    if (current) trackDependency(this, current, this._subscribers);\n    return this._error;\n  }\n\n  get isPending(): boolean {\n    const current = trackingContext.current;\n    if (current) trackDependency(this, current, this._subscribers);\n    return (this.flags & COMPUTED_STATE_FLAGS.PENDING) !== 0;\n  }\n\n  get isResolved(): boolean {\n    const current = trackingContext.current;\n    if (current) trackDependency(this, current, this._subscribers);\n    return (this.flags & COMPUTED_STATE_FLAGS.RESOLVED) !== 0;\n  }\n\n  invalidate(): void {\n    this._markDirty();\n    this._errorCacheEpoch = -1;\n    this._cachedErrors = null;\n  }\n\n  dispose(): void {\n    const flags = this.flags;\n    if (flags & COMPUTED_STATE_FLAGS.DISPOSED) return;\n\n    const links = this._links;\n    if (links !== EMPTY_LINKS) {\n      for (let i = 0, len = links.length; i < len; i++) {\n        const link = links[i];\n        if (link?.unsub) link.unsub();\n      }\n      linksArrayPool.release(links);\n      this._links = EMPTY_LINKS;\n    }\n\n    this._subscribers.length = 0;\n    this.flags =\n      COMPUTED_STATE_FLAGS.DISPOSED | COMPUTED_STATE_FLAGS.DIRTY | COMPUTED_STATE_FLAGS.IDLE;\n    this._error = null;\n    this._value = undefined as T;\n    this._promiseId = (this._promiseId + 1) % MAX_PROMISE_ID;\n    this._cachedErrors = null;\n    this._errorCacheEpoch = -1;\n  }\n\n  addDependency(dep: Dependency): void {\n    const epoch = this._trackEpoch;\n    if (dep._lastSeenEpoch === epoch) return;\n    dep._lastSeenEpoch = epoch;\n\n    const count = this._trackCount;\n    const links = this._trackLinks;\n\n    if (count < links.length) {\n      const link = links[count]!;\n      link.node = dep;\n      link.version = dep.version;\n    } else {\n      links.push(new DependencyLink(dep, dep.version));\n    }\n    this._trackCount = count + 1;\n  }\n\n  private _commitDeps(prevLinks: DependencyLink[]): void {\n    const nextLinks = this._trackLinks;\n    const depCount = this._trackCount;\n\n    nextLinks.length = depCount;\n\n    syncDependencies(nextLinks, prevLinks, this);\n    this._links = nextLinks;\n  }\n\n  private _recompute(): void {\n    if (this.flags & COMPUTED_STATE_FLAGS.RECOMPUTING) return;\n\n    this.flags |= COMPUTED_STATE_FLAGS.RECOMPUTING;\n\n    const prevLinks = this._links;\n\n    this._trackEpoch = nextEpoch();\n    this._trackLinks = linksArrayPool.acquire();\n    this._trackCount = 0;\n\n    let committed = false;\n\n    try {\n      const result = trackingContext.run(this, this._fn);\n\n      // Commit Dependencies\n      this._commitDeps(prevLinks);\n      committed = true;\n\n      if (isPromise(result)) {\n        this._handleAsyncComputation(result);\n      } else {\n        this._finalizeResolution(result);\n      }\n    } catch (e) {\n      let err = e as Error;\n      if (!committed) {\n        try {\n          this._commitDeps(prevLinks);\n          committed = true;\n        } catch (commitErr) {\n          err = commitErr as Error;\n        }\n      }\n      this._handleComputationError(err);\n    } finally {\n      if (committed) {\n        if (prevLinks !== EMPTY_LINKS) linksArrayPool.release(prevLinks);\n      } else {\n        linksArrayPool.release(this._trackLinks);\n      }\n      this._trackEpoch = -1;\n      this._trackLinks = EMPTY_LINKS;\n      this._trackCount = 0;\n\n      this.flags &= ~COMPUTED_STATE_FLAGS.RECOMPUTING;\n    }\n  }\n\n  private _handleAsyncComputation(promise: Promise<T>): void {\n    this.flags =\n      (this.flags | COMPUTED_STATE_FLAGS.PENDING) &\n      ~(\n        COMPUTED_STATE_FLAGS.IDLE |\n        COMPUTED_STATE_FLAGS.DIRTY |\n        COMPUTED_STATE_FLAGS.RESOLVED |\n        COMPUTED_STATE_FLAGS.REJECTED\n      );\n\n    this._notifySubscribers(undefined, undefined);\n\n    this._asyncStartAggregateVersion = this._captureVersionSnapshot();\n    this._asyncRetryCount = 0;\n\n    this._promiseId = (this._promiseId + 1) % MAX_PROMISE_ID;\n    const promiseId = this._promiseId;\n\n    promise\n      .then((resolvedValue) => {\n        if (promiseId !== this._promiseId) return;\n\n        // Drift detection\n        if (this._captureVersionSnapshot() !== this._asyncStartAggregateVersion) {\n          if (this._asyncRetryCount < MAX_ASYNC_RETRIES) {\n            this._asyncRetryCount++;\n            this._markDirty();\n            return;\n          }\n          this._handleAsyncRejection(\n            new ComputedError(`Async drift threshold exceeded after ${MAX_ASYNC_RETRIES} retries.`)\n          );\n          return;\n        }\n\n        this._finalizeResolution(resolvedValue);\n        this._notifySubscribers(resolvedValue, undefined);\n      })\n      .catch((err) => {\n        if (promiseId !== this._promiseId) return;\n        this._handleAsyncRejection(err);\n      });\n  }\n\n  private _captureVersionSnapshot(): number {\n    let aggregate = 0;\n    const links = this._links;\n    for (let i = 0, len = links.length; i < len; i++) {\n      const v = links[i]!.node.version;\n      aggregate = ((((aggregate << 5) - aggregate) | 0) + v) & SMI_MAX;\n    }\n    return aggregate;\n  }\n\n  private _handleAsyncRejection(err: unknown): void {\n    const error = wrapError(err, ComputedError, ERROR_MESSAGES.COMPUTED_ASYNC_COMPUTATION_FAILED);\n\n    if (!(this.flags & COMPUTED_STATE_FLAGS.REJECTED)) {\n      this.version = (this.version + 1) & SMI_MAX;\n    }\n\n    this._error = error;\n    this.flags =\n      (this.flags &\n        ~(\n          COMPUTED_STATE_FLAGS.IDLE |\n          COMPUTED_STATE_FLAGS.DIRTY |\n          COMPUTED_STATE_FLAGS.PENDING |\n          COMPUTED_STATE_FLAGS.RESOLVED\n        )) |\n      (COMPUTED_STATE_FLAGS.REJECTED | COMPUTED_STATE_FLAGS.HAS_ERROR);\n\n    const onError = this._onError;\n    if (onError) {\n      try {\n        onError(error);\n      } catch (callbackError) {\n        console.error(ERROR_MESSAGES.CALLBACK_ERROR_IN_ERROR_HANDLER, callbackError);\n      }\n    }\n\n    this._notifySubscribers(undefined, undefined);\n  }\n\n  private _finalizeResolution(value: T): void {\n    if (!(this.flags & COMPUTED_STATE_FLAGS.RESOLVED) || !this._equal(this._value, value)) {\n      this.version = (this.version + 1) & SMI_MAX;\n    }\n\n    this._value = value;\n    this._error = null;\n    this.flags =\n      (this.flags | COMPUTED_STATE_FLAGS.RESOLVED) &\n      ~(\n        COMPUTED_STATE_FLAGS.IDLE |\n        COMPUTED_STATE_FLAGS.DIRTY |\n        COMPUTED_STATE_FLAGS.PENDING |\n        COMPUTED_STATE_FLAGS.REJECTED |\n        COMPUTED_STATE_FLAGS.HAS_ERROR\n      );\n\n    this._cachedErrors = null;\n    this._errorCacheEpoch = -1;\n  }\n\n  private _handleComputationError(err: unknown): never {\n    const error = wrapError(err, ComputedError, ERROR_MESSAGES.COMPUTED_COMPUTATION_FAILED);\n\n    this._error = error;\n    this.flags =\n      (this.flags &\n        ~(\n          COMPUTED_STATE_FLAGS.IDLE |\n          COMPUTED_STATE_FLAGS.DIRTY |\n          COMPUTED_STATE_FLAGS.PENDING |\n          COMPUTED_STATE_FLAGS.RESOLVED\n        )) |\n      (COMPUTED_STATE_FLAGS.REJECTED | COMPUTED_STATE_FLAGS.HAS_ERROR);\n\n    const onError = this._onError;\n    if (onError) {\n      try {\n        onError(error);\n      } catch (callbackError) {\n        console.error(ERROR_MESSAGES.CALLBACK_ERROR_IN_ERROR_HANDLER, callbackError);\n      }\n    }\n\n    throw error;\n  }\n\n  execute(): void {\n    this._markDirty();\n  }\n\n  /** @internal */\n  _markDirty(): void {\n    const flags = this.flags;\n    if (flags & (COMPUTED_STATE_FLAGS.RECOMPUTING | COMPUTED_STATE_FLAGS.DIRTY)) return;\n\n    this.flags = flags | COMPUTED_STATE_FLAGS.DIRTY;\n    this._notifySubscribers(undefined, undefined);\n  }\n}\n\nObject.freeze(ComputedAtomImpl.prototype);\n\n/**\n * Creates a computed value with automatic dependency tracking.\n * Supports sync/async computations with caching and lazy evaluation.\n * @param fn - Computation function (sync or async)\n * @param options - { equal?, defaultValue?, onError?, lazy? }\n */\nexport function computed<T>(fn: () => T, options?: ComputedOptions<T>): ComputedAtom<T>;\nexport function computed<T>(\n  fn: () => Promise<T>,\n  options: ComputedOptions<T> & { defaultValue: T }\n): ComputedAtom<T>;\nexport function computed<T>(\n  fn: () => T | Promise<T>,\n  options: ComputedOptions<T> = {}\n): ComputedAtom<T> {\n  return new ComputedAtomImpl(fn, options);\n}\n","import { EFFECT_STATE_FLAGS, IS_DEV, SCHEDULER_CONFIG, TIME_CONSTANTS } from '@/constants';\nimport { ReactiveNode } from '@/core/base';\nimport { DependencyLink } from '@/core/dep-tracking';\nimport { EffectError } from '@/errors/errors';\nimport { ERROR_MESSAGES } from '@/errors/messages';\nimport {\n  flushEpoch,\n  flushExecutionCount,\n  incrementFlushExecutionCount,\n  nextEpoch,\n} from '@/internal/epoch';\nimport { EMPTY_LINKS, linksArrayPool } from '@/internal/pool';\nimport { scheduler } from '@/internal/scheduler';\nimport { type DependencyTracker, trackingContext, untracked } from '@/tracking';\nimport type { Dependency, EffectFunction, EffectObject, EffectOptions } from '@/types';\nimport { debug } from '@/utils/debug';\nimport { wrapError } from '@/utils/error';\nimport { isPromise } from '@/utils/type-guards';\n\n/**\n * Internal effect implementation with dependency tracking and infinite loop detection.\n * Extends {@link ReactiveNode} and implements {@link EffectObject} and {@link DependencyTracker}.\n */\nclass EffectImpl extends ReactiveNode implements EffectObject, DependencyTracker {\n  private _cleanup: (() => void) | null;\n  private _links: DependencyLink[];\n  private _nextLinks: DependencyLink[] | null;\n  private _executeTask: (() => void) | undefined;\n\n  private readonly _onError: ((error: unknown) => void) | null;\n\n  private _currentEpoch: number;\n  private _lastFlushEpoch: number;\n  private _executionsInEpoch: number;\n\n  private readonly _fn: EffectFunction;\n  private readonly _sync: boolean;\n  private readonly _maxExecutions: number;\n  private readonly _maxExecutionsPerFlush: number;\n  private readonly _trackModifications: boolean;\n\n  private _history: number[] | null;\n  private _executionCount: number;\n  private _historyPtr: number;\n  private readonly _historyCapacity: number;\n  private _execId: number;\n\n  constructor(fn: EffectFunction, options: EffectOptions = {}) {\n    super();\n\n    this._cleanup = null;\n    this._links = EMPTY_LINKS;\n    this._nextLinks = null;\n    this._executeTask = undefined;\n    this._onError = options.onError ?? null;\n\n    this._currentEpoch = -1;\n    this._lastFlushEpoch = -1;\n    this._executionsInEpoch = 0;\n\n    this._fn = fn;\n    this._sync = options.sync ?? false;\n    this._maxExecutions =\n      options.maxExecutionsPerSecond ?? SCHEDULER_CONFIG.MAX_EXECUTIONS_PER_SECOND;\n    this._maxExecutionsPerFlush =\n      options.maxExecutionsPerFlush ?? SCHEDULER_CONFIG.MAX_EXECUTIONS_PER_EFFECT;\n    this._trackModifications = options.trackModifications ?? false;\n\n    this._executionCount = 0;\n    this._historyPtr = 0;\n\n    const isFiniteLimit = Number.isFinite(this._maxExecutions);\n    const capacity = isFiniteLimit\n      ? Math.min(this._maxExecutions + 1, SCHEDULER_CONFIG.MAX_EXECUTIONS_PER_SECOND + 1)\n      : 0;\n    this._historyCapacity = capacity;\n    this._history = IS_DEV && isFiniteLimit && capacity > 0 ? new Array(capacity).fill(0) : null;\n    this._execId = 0;\n\n    debug.attachDebugInfo(this, 'effect', this.id);\n  }\n\n  public run(): void {\n    if (this.flags & EFFECT_STATE_FLAGS.DISPOSED) {\n      throw new EffectError(ERROR_MESSAGES.EFFECT_DISPOSED);\n    }\n    this.execute(true);\n  }\n\n  public dispose(): void {\n    const flags = this.flags;\n    if (flags & EFFECT_STATE_FLAGS.DISPOSED) return;\n\n    this.flags = flags | EFFECT_STATE_FLAGS.DISPOSED;\n\n    if (this._cleanup) {\n      try {\n        this._cleanup();\n      } catch (error) {\n        this._handleExecutionError(error, ERROR_MESSAGES.EFFECT_CLEANUP_FAILED);\n      }\n      this._cleanup = null;\n    }\n\n    const links = this._links;\n    if (links !== EMPTY_LINKS) {\n      for (let i = 0, len = links.length; i < len; i++) {\n        const link = links[i];\n        if (link?.unsub) link.unsub();\n      }\n      linksArrayPool.release(links);\n      this._links = EMPTY_LINKS;\n    }\n\n    this._executeTask = undefined;\n  }\n\n  public addDependency(dep: Dependency): void {\n    const flags = this.flags;\n    if (!(flags & EFFECT_STATE_FLAGS.EXECUTING)) return;\n\n    const epoch = this._currentEpoch;\n    if (dep._lastSeenEpoch === epoch) return;\n    dep._lastSeenEpoch = epoch;\n\n    const nextLinks = this._nextLinks!;\n\n    const tempUnsub = dep._tempUnsub;\n    if (tempUnsub) {\n      nextLinks.push(new DependencyLink(dep, dep.version, tempUnsub));\n      dep._tempUnsub = undefined;\n      return;\n    }\n\n    try {\n      const isSync = this._sync;\n      const trackMod = this._trackModifications;\n\n      const unsubscribe = dep.subscribe(() => {\n        if (trackMod && this.flags & EFFECT_STATE_FLAGS.EXECUTING) {\n          dep._modifiedAtEpoch = this._currentEpoch;\n        }\n\n        if (isSync) {\n          this.execute();\n          return;\n        }\n\n        if (!this._executeTask) {\n          this._executeTask = () => this.execute();\n        }\n        const task = this._executeTask;\n        scheduler.schedule(task);\n      });\n      nextLinks.push(new DependencyLink(dep, dep.version, unsubscribe));\n    } catch (error) {\n      console.error(wrapError(error, EffectError, ERROR_MESSAGES.EFFECT_EXECUTION_FAILED));\n    }\n  }\n\n  public execute(force = false): void {\n    const flags = this.flags;\n    if (flags & (EFFECT_STATE_FLAGS.DISPOSED | EFFECT_STATE_FLAGS.EXECUTING)) return;\n\n    // 1. Dependency Dirty Check (Fast Path)\n    if (!force) {\n      const links = this._links;\n      const dLen = links.length;\n      if (dLen > 0) {\n        let isDirty = false;\n        for (let i = 0; i < dLen; i++) {\n          const link = links[i]!;\n          const dep = link.node;\n          if (dep.version !== link.version) {\n            isDirty = true;\n            break;\n          }\n          if ('value' in (dep as unknown as Record<string, unknown>)) {\n            try {\n              untracked(() => (dep as unknown as { value: unknown }).value);\n              if (dep.version !== link.version) {\n                isDirty = true;\n                break;\n              }\n            } catch {\n              isDirty = true;\n              break;\n            }\n          }\n        }\n        if (!isDirty) return;\n      }\n    }\n\n    // 2. Infinite Loop & Rate Limit Detection\n    const epoch = flushEpoch;\n    if (this._lastFlushEpoch !== epoch) {\n      this._lastFlushEpoch = epoch;\n      this._executionsInEpoch = 0;\n    }\n\n    if (++this._executionsInEpoch > this._maxExecutionsPerFlush) {\n      this._throwInfiniteLoopError('per-effect');\n    }\n\n    if (incrementFlushExecutionCount() > SCHEDULER_CONFIG.MAX_EXECUTIONS_PER_FLUSH) {\n      this._throwInfiniteLoopError('global');\n    }\n\n    this._executionCount++;\n\n    const history = this._history;\n    if (history) {\n      const now = Date.now();\n      const ptr = this._historyPtr;\n      history[ptr] = now;\n      const nextPtr = (ptr + 1) % this._historyCapacity;\n      this._historyPtr = nextPtr;\n\n      const oldestTime = history[nextPtr] || 0;\n      if (oldestTime > 0 && now - oldestTime < TIME_CONSTANTS.ONE_SECOND_MS) {\n        const error = new EffectError(\n          `Effect executed too frequently within 1 second. Suspected infinite loop.`\n        );\n        this.dispose();\n        this._handleExecutionError(error);\n        if (IS_DEV) throw error;\n        return;\n      }\n    }\n\n    this.flags |= EFFECT_STATE_FLAGS.EXECUTING;\n\n    // 3. Preparation\n    if (this._cleanup) {\n      try {\n        this._cleanup();\n      } catch (error) {\n        this._handleExecutionError(error, ERROR_MESSAGES.EFFECT_CLEANUP_FAILED);\n      }\n      this._cleanup = null;\n    }\n\n    const prevLinks = this._links;\n\n    if (prevLinks !== EMPTY_LINKS) {\n      for (let i = 0, len = prevLinks.length; i < len; i++) {\n        const link = prevLinks[i];\n        if (link) link.node._tempUnsub = link.unsub;\n      }\n    }\n\n    const nextLinks = linksArrayPool.acquire();\n\n    this._nextLinks = nextLinks;\n    this._currentEpoch = nextEpoch();\n\n    let committed = false;\n\n    try {\n      const result = trackingContext.run(this, this._fn);\n\n      // Commit\n      this._links = nextLinks;\n      committed = true;\n\n      this._checkLoopWarnings();\n\n      const execId = ++this._execId;\n\n      if (isPromise(result)) {\n        result\n          .then((asyncCleanup) => {\n            if (execId !== this._execId || this.flags & EFFECT_STATE_FLAGS.DISPOSED) {\n              if (typeof asyncCleanup === 'function') {\n                try {\n                  asyncCleanup();\n                } catch (error) {\n                  this._handleExecutionError(error, ERROR_MESSAGES.EFFECT_CLEANUP_FAILED);\n                }\n              }\n              return;\n            }\n            if (typeof asyncCleanup === 'function') {\n              this._cleanup = asyncCleanup;\n            }\n          })\n          .catch((error) => {\n            if (execId === this._execId) {\n              this._handleExecutionError(error);\n            }\n          });\n      } else {\n        this._cleanup = typeof result === 'function' ? result : null;\n      }\n    } catch (error) {\n      committed = true; // Dependencies are valid even if fn threw\n      this._handleExecutionError(error);\n      this._cleanup = null;\n    } finally {\n      this._nextLinks = null;\n\n      if (committed) {\n        if (prevLinks !== EMPTY_LINKS) {\n          for (let i = 0, len = prevLinks.length; i < len; i++) {\n            const link = prevLinks[i];\n            const unsub = link ? link.node._tempUnsub : undefined;\n            if (unsub) {\n              unsub();\n              if (link) link.node._tempUnsub = undefined;\n            }\n          }\n          linksArrayPool.release(prevLinks);\n        }\n      } else {\n        // Rollback\n        for (let i = 0, len = nextLinks.length; i < len; i++) {\n          const link = nextLinks[i];\n          if (link?.unsub) link.unsub();\n        }\n        linksArrayPool.release(nextLinks);\n\n        if (prevLinks !== EMPTY_LINKS) {\n          for (let i = 0, len = prevLinks.length; i < len; i++) {\n            const link = prevLinks[i];\n            if (link) link.node._tempUnsub = undefined;\n          }\n        }\n      }\n\n      this.flags &= ~EFFECT_STATE_FLAGS.EXECUTING;\n    }\n  }\n\n  get isDisposed(): boolean {\n    return (this.flags & EFFECT_STATE_FLAGS.DISPOSED) !== 0;\n  }\n\n  get executionCount(): number {\n    return this._executionCount;\n  }\n\n  get isExecuting(): boolean {\n    return (this.flags & EFFECT_STATE_FLAGS.EXECUTING) !== 0;\n  }\n\n  private _throwInfiniteLoopError(type: 'per-effect' | 'global'): never {\n    const error = new EffectError(\n      `Infinite loop detected (${type}): ` +\n        `effect executed ${this._executionsInEpoch} times in current flush. ` +\n        `Total executions in flush: ${flushExecutionCount}`\n    );\n    this.dispose();\n    console.error(error);\n    throw error;\n  }\n\n  private _handleExecutionError(\n    error: unknown,\n    message: string = ERROR_MESSAGES.EFFECT_EXECUTION_FAILED\n  ): void {\n    const errorObj = wrapError(error, EffectError, message);\n    console.error(errorObj);\n\n    const onError = this._onError;\n    if (onError) {\n      try {\n        onError(errorObj);\n      } catch (e) {\n        console.error(wrapError(e, EffectError, ERROR_MESSAGES.CALLBACK_ERROR_IN_ERROR_HANDLER));\n      }\n    }\n  }\n\n  private _checkLoopWarnings(): void {\n    if (this._trackModifications && debug.enabled) {\n      const links = this._links;\n      const epoch = this._currentEpoch;\n      for (let i = 0, len = links.length; i < len; i++) {\n        const link = links[i]!;\n        const dep = link.node;\n        if (dep && dep._modifiedAtEpoch === epoch) {\n          debug.warn(\n            true,\n            `Effect is reading a dependency (${\n              debug.getDebugName(dep) || 'unknown'\n            }) that it just modified. Infinite loop may occur`\n          );\n        }\n      }\n    }\n  }\n}\n\n/**\n * Creates and starts a reactive effect that automatically tracks dependencies.\n * The effect function is executed immediately and re-scheduled whenever its\n * reactive dependencies change.\n *\n * @param fn - The function to be executed as a reactive effect.\n * @param options - Configuration options to customize effect behavior (e.g., scheduling, error handling).\n * @returns An effect instance providing control over the effect's lifecycle.\n * @throws {EffectError} If the provided `fn` is not a function.\n */\nexport function effect(fn: EffectFunction, options: EffectOptions = {}): EffectObject {\n  if (typeof fn !== 'function') {\n    throw new EffectError(ERROR_MESSAGES.EFFECT_MUST_BE_FUNCTION);\n  }\n\n  const effectInstance = new EffectImpl(fn, options);\n  effectInstance.execute();\n\n  return effectInstance;\n}\n","import { AtomError } from '@/errors/errors';\nimport { scheduler } from './scheduler';\n\n/**\n * Groups multiple state updates into a single notification cycle.\n * This optimizes performance by deferring the execution of scheduled effects\n * until the provided callback finishes execution, preventing redundant computations.\n *\n * @param callback - The function containing state updates to be batched.\n * @returns The value returned by the callback.\n * @throws {AtomError} If the provided callback is not a function.\n */\nexport function batch<T>(callback: () => T): T {\n  if (typeof callback !== 'function') {\n    throw new AtomError('Batch callback must be a function');\n  }\n\n  scheduler.startBatch();\n\n  try {\n    return callback();\n  } finally {\n    scheduler.endBatch();\n  }\n}\n"],"names":["TIME_CONSTANTS","AsyncState","NODE_FLAGS","EFFECT_STATE_FLAGS","COMPUTED_STATE_FLAGS","ATOM_STATE_FLAGS","POOL_CONFIG","SCHEDULER_CONFIG","DEBUG_CONFIG","SMI_MAX","IS_DEV","EMPTY_ERROR_ARRAY","AtomError","message","cause","recoverable","ComputedError","EffectError","SchedulerError","DEBUG_NAME","DEBUG_ID","DEBUG_TYPE","NO_DEFAULT_VALUE","hasDependencies","obj","checkCircularInternal","dep","current","visited","deps","i","child","debug","condition","type","id","target","nextId","generateId","trackDependency","dependency","subscribers","depSub","fn","len","SubscriberLink","sub","syncDependencies","nextLinks","prevLinks","tracker","prevLen","nextLen","link","node","existingUnsub","remainingUnsub","DependencyLink","version","unsub","ERROR_MESSAGES","count","ReactiveNode","ReactiveDependency","listener","subs","isFn","idx","last","activeLen","foundFn","foundObj","newFlags","newValue","oldValue","s","err","collectorEpoch","nextEpoch","currentEpoch","flushEpoch","flushExecutionCount","isFlushing","startFlush","endFlush","incrementFlushExecutionCount","Scheduler","callback","epoch","index","size","flushStarted","bQueue","targetBuffer","targetSize","job","iterations","max","jobs","error","depth","nextDepth","scheduler","TrackingContext","prev","trackingContext","untracked","AtomImpl","initialValue","sync","flags","atom","options","PoolStatsRejected","PoolStatsCollector","ArrayPool","stats","arr","emptyConst","pool","acquired","released","rejected","frozen","tooLarge","poolFull","EMPTY_LINKS","linksArrayPool","wrapError","ErrorClass","context","errorMessage","isAtom","isComputed","isEffect","isPromise","value","ASYNC_STATE_MASK","ASYNC_STATE_LOOKUP","MAX_ASYNC_RETRIES","MAX_PROMISE_ID","ComputedAtomImpl","debugObj","defValue","defaultValue","hasDefault","links","errorSet","localError","depErrors","j","jLen","errors","depCount","committed","result","e","commitErr","promise","promiseId","resolvedValue","aggregate","v","onError","callbackError","computed","EffectImpl","isFiniteLimit","capacity","tempUnsub","isSync","trackMod","unsubscribe","task","force","dLen","isDirty","history","now","ptr","nextPtr","oldestTime","execId","asyncCleanup","errorObj","effect","effectInstance","batch"],"mappings":"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"}
+{"version":3,"file":"atom-effect.min.js","sources":["../src/constants.ts","../src/errors/errors.ts","../src/utils/debug.ts","../src/core/dep-tracking.ts","../src/errors/messages.ts","../src/utils/error.ts","../src/core/base.ts","../src/internal/epoch.ts","../src/internal/scheduler.ts","../src/tracking/context.ts","../src/tracking/untracked.ts","../src/core/atom.ts","../src/utils/array-pool.ts","../src/internal/pool.ts","../src/utils/type-guards.ts","../src/core/computed.ts","../src/core/effect.ts","../src/internal/batch.ts"],"sourcesContent":["/**\n * Global time constants.\n * Used for debouncing, throttling, and scheduling.\n */\nexport const TIME_CONSTANTS = {\n  ONE_SECOND_MS: 1000,\n} as const;\n\n/**\n * Async operation states.\n */\nexport const AsyncState = {\n  IDLE: 'idle',\n  PENDING: 'pending',\n  RESOLVED: 'resolved',\n  REJECTED: 'rejected',\n} as const;\n\n/**\n * Base Node Flags.\n */\nexport const NODE_FLAGS = {\n  DISPOSED: 1 << 0,\n  HAS_FN_SUBS: 1 << 1,\n  HAS_OBJ_SUBS: 1 << 2,\n} as const;\n\n/**\n * Effect flags.\n */\nexport const EFFECT_STATE_FLAGS = {\n  ...NODE_FLAGS,\n  EXECUTING: 1 << 3,\n} as const;\n\n/**\n * Computed flags.\n */\nexport const COMPUTED_STATE_FLAGS = {\n  ...NODE_FLAGS,\n  DIRTY: 1 << 3,\n  IDLE: 1 << 4,\n  PENDING: 1 << 5,\n  RESOLVED: 1 << 6,\n  REJECTED: 1 << 7,\n  RECOMPUTING: 1 << 8,\n  HAS_ERROR: 1 << 9,\n} as const;\n\n/**\n * Writable Atom Flags.\n */\nexport const ATOM_STATE_FLAGS = {\n  ...NODE_FLAGS,\n  SYNC: 1 << 3,\n  NOTIFICATION_SCHEDULED: 1 << 4,\n} as const;\n\n/**\n * Array pool configuration.\n */\nexport const POOL_CONFIG = {\n  MAX_SIZE: 1000,\n  WARMUP_SIZE: 100,\n} as const;\n\n/**\n * Scheduler configuration.\n */\nexport const SCHEDULER_CONFIG = {\n  // Infinite loop protection\n  MAX_EXECUTIONS_PER_SECOND: 1000,\n  MAX_EXECUTIONS_PER_EFFECT: 100,\n\n  // Batch processing limits to prevent blocking the main thread for too long\n  MAX_EXECUTIONS_PER_FLUSH: 10000,\n  MAX_FLUSH_ITERATIONS: 1000,\n  MIN_FLUSH_ITERATIONS: 10,\n\n  // Memory management\n  CLEANUP_THRESHOLD: 1000,\n  BATCH_QUEUE_SHRINK_THRESHOLD: 1000,\n} as const;\n\n/**\n * Debugging thresholds.\n */\nexport const DEBUG_CONFIG = {\n  MAX_DEPENDENCIES: 1000,\n  WARN_INFINITE_LOOP: true,\n} as const;\n\n/**\n * V8 Small Integer (SMI) max value.\n */\nexport const SMI_MAX = 0x3fffffff;\n\n/**\n * Development environment flag.\n */\nexport const IS_DEV =\n  (typeof process !== 'undefined' && process.env && process.env.NODE_ENV !== 'production') ||\n  (typeof __DEV__ !== 'undefined' && !!__DEV__);\n\n// Fallback declaration for __DEV__ if not present in environment\ndeclare const __DEV__: boolean;\n\nexport const EMPTY_ERROR_ARRAY: readonly Error[] = Object.freeze([]);\n","/**\n * Base error class.\n */\nexport class AtomError extends Error {\n  readonly timestamp = new Date();\n\n  constructor(\n    message: string,\n    public cause: Error | null = null,\n    public recoverable = true\n  ) {\n    super(message);\n    this.name = 'AtomError';\n  }\n}\n\n/** Computed error. */\nexport class ComputedError extends AtomError {\n  constructor(message: string, cause: Error | null = null) {\n    super(message, cause, true);\n    this.name = 'ComputedError';\n  }\n}\n\n/** Effect error. */\nexport class EffectError extends AtomError {\n  constructor(message: string, cause: Error | null = null) {\n    super(message, cause, false);\n    this.name = 'EffectError';\n  }\n}\n\n/** Scheduler error. */\nexport class SchedulerError extends AtomError {\n  constructor(message: string, cause: Error | null = null) {\n    super(message, cause, false);\n    this.name = 'SchedulerError';\n  }\n}\n","import { DEBUG_CONFIG, IS_DEV } from '@/constants';\nimport { ComputedError } from '@/errors/errors';\nimport type { DebugConfig, Dependency, DependencyId } from '@/types';\n\n// Debug symbols\nexport const DEBUG_NAME = Symbol('AtomEffect.DebugName');\nexport const DEBUG_ID = Symbol('AtomEffect.Id');\nexport const DEBUG_TYPE = Symbol('AtomEffect.Type');\nexport const NO_DEFAULT_VALUE = Symbol('AtomEffect.NoDefaultValue');\n\n/**\n * Dependency type guard.\n */\nconst hasDeps = (o: Dependency): o is Dependency & { dependencies: Dependency[] } =>\n  'dependencies' in o && Array.isArray((o as { dependencies: unknown }).dependencies);\n\n/**\n * Cycle detection.\n */\nfunction checkCircularInternal(dep: Dependency, current: object, visited: Set<number>): void {\n  // Cycle detected in *this* path\n  if (dep === current) {\n    throw new ComputedError(\n      'Circular dependency detected: The computation refers to itself explicitly or implicitly.'\n    );\n  }\n\n  // Cycle check\n  if (visited.has(dep.id)) return;\n  visited.add(dep.id);\n\n  if (hasDeps(dep)) {\n    const deps = dep.dependencies;\n    // Check dependencies\n    for (let i = 0; i < deps.length; i++) {\n      const child = deps[i];\n      if (child) {\n        checkCircularInternal(child, current, visited);\n      }\n    }\n  }\n}\n\n/**\n * Debug controller.\n */\nexport const debug: DebugConfig = {\n  // Dev mode flag\n  enabled: IS_DEV,\n\n  maxDependencies: DEBUG_CONFIG.MAX_DEPENDENCIES,\n  warnInfiniteLoop: DEBUG_CONFIG.WARN_INFINITE_LOOP,\n\n  warn(cond, msg) {\n    if (IS_DEV && this.enabled && cond) {\n      console.warn(`[Atom Effect] ${msg}`);\n    }\n  },\n\n  checkCircular(dep, current) {\n    if (dep === current) {\n      throw new ComputedError('Direct circular dependency detected');\n    }\n\n    if (IS_DEV && this.enabled) {\n      checkCircularInternal(dep, current, new Set());\n    }\n  },\n\n  attachDebugInfo(obj, type, id) {\n    if (!IS_DEV || !this.enabled) return;\n\n    const t = obj as Record<symbol, unknown>;\n    t[DEBUG_NAME] = `${type}_${id}`;\n    t[DEBUG_ID] = id;\n    t[DEBUG_TYPE] = type;\n  },\n\n  getDebugName: (obj) =>\n    (obj as Record<symbol, unknown> | null)?.[DEBUG_NAME] as string | undefined,\n\n  getDebugType: (obj) =>\n    (obj as Record<symbol, unknown> | null)?.[DEBUG_TYPE] as string | undefined,\n};\n\n/**\n * ID counter.\n */\nlet nextId = 1;\n\n/**\n * Generates ID.\n */\nexport const generateId = () => nextId++ as DependencyId;\n","import { NODE_FLAGS } from '@/constants';\nimport type { DependencySubscriber, Listener } from '@/tracking/tracking.types';\nimport type { Dependency, Subscriber } from '@/types';\nimport { debug } from '@/utils/debug';\n/**\n * Tracks dependency.\n */\nexport function trackDependency<T>(\n  dependency: Dependency,\n  current: Listener,\n  subscribers: SubscriberLink<T>[]\n): void {\n  if (typeof current === 'function') {\n    const fn = current as (newValue?: T, oldValue?: T) => void;\n    // Check for existing subscription\n    for (let i = 0, len = subscribers.length; i < len; i++) {\n      const link = subscribers[i];\n      if (link && link.fn === fn) return;\n    }\n    subscribers.push(new SubscriberLink(fn, undefined));\n    dependency.flags |= NODE_FLAGS.HAS_FN_SUBS;\n    if ('_fnSubCount' in dependency) {\n      (dependency as unknown as { _fnSubCount: number })._fnSubCount++;\n    }\n    return;\n  }\n\n  if ('addDependency' in (current as object)) {\n    (current as DependencySubscriber).addDependency(dependency);\n    return;\n  }\n\n  const sub = current as Subscriber;\n  for (let i = 0, len = subscribers.length; i < len; i++) {\n    const link = subscribers[i];\n    if (link && link.sub === sub) return;\n  }\n  subscribers.push(new SubscriberLink(undefined, sub));\n  dependency.flags |= NODE_FLAGS.HAS_OBJ_SUBS;\n  if ('_objSubCount' in dependency) {\n    (dependency as unknown as { _objSubCount: number })._objSubCount++;\n  }\n}\n\n/**\n * Syncs dependencies.\n */\nexport function syncDependencies(\n  nextLinks: DependencyLink[],\n  prevLinks: DependencyLink[],\n  tracker: Subscriber\n): void {\n  for (let i = 0, len = prevLinks.length; i < len; i++) {\n    const link = prevLinks[i];\n    if (link) {\n      link.node._tempUnsub = link.unsub;\n    }\n  }\n\n  for (let i = 0, len = nextLinks.length; i < len; i++) {\n    const link = nextLinks[i];\n    if (!link) continue;\n\n    const node = link.node;\n    if (node._tempUnsub !== undefined) {\n      // Re-link: Found in previous set, reclaim the subscription\n      link.unsub = node._tempUnsub;\n      node._tempUnsub = undefined; // Consumed\n    } else {\n      // New Link: Subscribe afresh\n      debug.checkCircular(node, tracker);\n      link.unsub = node.subscribe(tracker);\n    }\n  }\n\n  for (let i = 0, len = prevLinks.length; i < len; i++) {\n    const link = prevLinks[i];\n    if (link) {\n      const node = link.node;\n      if (node._tempUnsub !== undefined) {\n        node._tempUnsub(); // Release\n        node._tempUnsub = undefined;\n      }\n      link.unsub = undefined;\n    }\n  }\n}\n\n/**\n * Dependency graph edge.\n */\nexport class DependencyLink {\n  constructor(\n    public node: Dependency,\n    public version: number,\n    public unsub: (() => void) | undefined = undefined\n  ) {}\n}\n\n/**\n * Subscriber link.\n */\nexport class SubscriberLink<T> {\n  constructor(\n    public fn: ((newValue?: T, oldValue?: T) => void) | undefined,\n    public sub: Subscriber | undefined\n  ) {}\n}\n","/**\n * Error message registry.\n */\nexport const ERROR_MESSAGES = {\n  // Computed Errors\n  COMPUTED_MUST_BE_FUNCTION: 'Computed target must be a function',\n  COMPUTED_ASYNC_PENDING_NO_DEFAULT: 'Async computation pending with no default value',\n  COMPUTED_COMPUTATION_FAILED: 'Computation execution failed',\n  COMPUTED_ASYNC_COMPUTATION_FAILED: 'Async computation execution failed',\n  COMPUTED_CIRCULAR_DEPENDENCY: 'Circular dependency detected',\n  COMPUTED_DISPOSED: 'Attempted to access disposed computed',\n\n  // Atom Errors\n  ATOM_SUBSCRIBER_MUST_BE_FUNCTION: 'Subscriber must be a function or Subscriber object',\n  ATOM_INDIVIDUAL_SUBSCRIBER_FAILED: 'Subscriber execution failed',\n\n  // Effect Errors\n  EFFECT_MUST_BE_FUNCTION: 'Effect target must be a function',\n  EFFECT_EXECUTION_FAILED: 'Effect execution failed',\n  EFFECT_CLEANUP_FAILED: 'Effect cleanup failed',\n  EFFECT_DISPOSED: 'Attempted to run disposed effect',\n\n  // System / Debug\n  LARGE_DEPENDENCY_GRAPH: (count: number): string => `Large dependency graph (${count} nodes)`,\n  CALLBACK_ERROR_IN_ERROR_HANDLER: 'Exception encountered in onError handler',\n} as const;\n","import { AtomError } from '@/errors/errors';\n\n/**\n * Wraps error.\n *\n * @param error - Raw error.\n * @param ErrorClass - Error class.\n * @param context - Error context.\n */\nexport function wrapError(\n  error: unknown,\n  ErrorClass: typeof AtomError,\n  context: string\n): AtomError {\n  // Return if wrapped\n  if (error instanceof AtomError) {\n    return error;\n  }\n\n  const isNativeError = error instanceof Error;\n  const originalMessage = isNativeError ? error.message : String(error);\n  const cause = isNativeError ? error : undefined;\n\n  // Error category\n  let type = 'Unexpected error';\n  if (error instanceof TypeError) type = 'Type error';\n  else if (error instanceof ReferenceError) type = 'Reference error';\n\n  const finalMessage = `${type} (${context}): ${originalMessage}`;\n\n  return new ErrorClass(finalMessage, cause);\n}\n","import { IS_DEV, NODE_FLAGS, SMI_MAX } from '@/constants';\nimport { SubscriberLink } from '@/core/dep-tracking';\nimport { AtomError } from '@/errors/errors';\nimport { ERROR_MESSAGES } from '@/errors/messages';\nimport type { DependencyId, Subscriber } from '@/types';\nimport { generateId } from '@/utils/debug';\nimport { wrapError } from '@/utils/error';\n\n/**\n * Base class for all reactive nodes.\n */\nexport class ReactiveNode {\n  /** State flags */\n  flags = 0;\n  /** Version counter */\n  version = 0;\n  /** Last access epoch */\n  _lastSeenEpoch = -1;\n  /** Modified epoch */\n  _modifiedAtEpoch = -1;\n  /** Debug ID */\n  readonly id: DependencyId = (generateId() & SMI_MAX) as DependencyId;\n  /** Temporary unsubscribe slot */\n  _tempUnsub: (() => void) | undefined = undefined;\n}\n\n/**\n * Reactive dependency base class.\n */\nexport abstract class ReactiveDependency<T> extends ReactiveNode {\n  protected abstract _subscribers: SubscriberLink<T>[];\n\n  /** @internal */\n  public _fnSubCount = 0;\n  /** @internal */\n  public _objSubCount = 0;\n\n  /**\n   * Adds subscriber.\n   */\n  subscribe(listener: ((newValue?: T, oldValue?: T) => void) | Subscriber): () => void {\n    const isFn = typeof listener === 'function';\n    // Validate subscriber\n    if (!isFn && (!listener || typeof (listener as Subscriber).execute !== 'function')) {\n      throw wrapError(\n        new TypeError('Invalid subscriber'),\n        AtomError,\n        ERROR_MESSAGES.ATOM_SUBSCRIBER_MUST_BE_FUNCTION\n      );\n    }\n\n    const subs = this._subscribers;\n    for (let i = 0, len = subs.length; i < len; i++) {\n      const sub = subs[i];\n      if (!sub) continue;\n      if (isFn ? sub.fn === listener : sub.sub === listener) {\n        if (IS_DEV) console.warn('Duplicate subscription ignored.');\n        return () => {};\n      }\n    }\n\n    const link = new SubscriberLink<T>(\n      isFn ? (listener as (newValue?: T, oldValue?: T) => void) : undefined,\n      !isFn ? (listener as Subscriber) : undefined\n    );\n\n    subs.push(link);\n    if (isFn) {\n      this._fnSubCount++;\n      this.flags |= NODE_FLAGS.HAS_FN_SUBS;\n    } else {\n      this._objSubCount++;\n      this.flags |= NODE_FLAGS.HAS_OBJ_SUBS;\n    }\n\n    return () => this._unsubscribe(link);\n  }\n\n  private _unsubscribe(link: SubscriberLink<T>): void {\n    const subs = this._subscribers;\n    const idx = subs.indexOf(link);\n    if (idx === -1) return;\n\n    // Remove subscriber\n    const last = subs.pop();\n    if (idx < subs.length && last) {\n      subs[idx] = last;\n    }\n\n    if (link.fn) {\n      this._fnSubCount--;\n    } else {\n      this._objSubCount--;\n    }\n\n    if (subs.length === 0) {\n      this.flags &= ~(NODE_FLAGS.HAS_FN_SUBS | NODE_FLAGS.HAS_OBJ_SUBS);\n      this._fnSubCount = 0;\n      this._objSubCount = 0;\n    } else if (link.fn && this._fnSubCount <= 0) {\n      this.flags &= ~NODE_FLAGS.HAS_FN_SUBS;\n      this._fnSubCount = 0;\n    } else if (!link.fn && this._objSubCount <= 0) {\n      this.flags &= ~NODE_FLAGS.HAS_OBJ_SUBS;\n      this._objSubCount = 0;\n    }\n  }\n\n  subscriberCount(): number {\n    return this._subscribers.length;\n  }\n\n  protected _notifySubscribers(newValue: T | undefined, oldValue: T | undefined): void {\n    if (!(this.flags & (NODE_FLAGS.HAS_FN_SUBS | NODE_FLAGS.HAS_OBJ_SUBS))) return;\n\n    const subs = this._subscribers;\n    const len = subs.length;\n\n    for (let i = 0; i < len; i++) {\n      const s = subs[i];\n      if (!s) continue;\n\n      try {\n        if (s.fn) s.fn(newValue, oldValue);\n        else if (s.sub) s.sub.execute();\n      } catch (err) {\n        this._handleNotifyError(err);\n      }\n    }\n  }\n\n  private _handleNotifyError(err: unknown): void {\n    console.error(wrapError(err, AtomError, ERROR_MESSAGES.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));\n  }\n}\n","import { IS_DEV, SMI_MAX } from '@/constants';\n\n// Global epoch counter.\nlet collectorEpoch = 0;\n\n/**\n * Next tracking epoch.\n */\nexport const nextEpoch = () => {\n  collectorEpoch = (collectorEpoch + 1) & SMI_MAX || 1;\n  return collectorEpoch;\n};\n\n/** Current tracking epoch. */\nexport const currentEpoch = () => collectorEpoch;\n\nexport let flushEpoch = 0;\nexport let flushExecutionCount = 0;\nlet isFlushing = false;\n\n/**\n * Starts flush cycle.\n */\nexport function startFlush(): boolean {\n  if (isFlushing) {\n    if (IS_DEV) console.warn('startFlush() called during flush - ignored');\n    return false;\n  }\n\n  isFlushing = true;\n  flushEpoch = (flushEpoch + 1) & SMI_MAX || 1;\n  flushExecutionCount = 0;\n  return true;\n}\n\n/** Ends flush cycle. */\nexport const endFlush = () => {\n  isFlushing = false;\n};\n\n/**\n * Increments execution count.\n */\nexport const incrementFlushExecutionCount = () => (isFlushing ? ++flushExecutionCount : 0);\n\n/**\n * Resets flush state.\n */\nexport function resetFlushState(): void {\n  flushEpoch = 0;\n  flushExecutionCount = 0;\n  isFlushing = false;\n}\n","import { IS_DEV, SCHEDULER_CONFIG } from '@/constants';\nimport { SchedulerError } from '@/errors/errors';\nimport { endFlush, startFlush } from '@/internal/epoch';\n\nexport enum SchedulerPhase {\n  IDLE = 0,\n  BATCHING = 1,\n  FLUSHING = 2,\n}\n\nexport interface SchedulerJob {\n  (): void;\n  /** Next scheduled epoch */\n  _nextEpoch?: number;\n}\n\n/**\n * Scheduler implementation.\n */\nexport const scheduler = {\n  /** Queue buffer */\n  _queueBuffer: [[], []] as [SchedulerJob[], SchedulerJob[]],\n  _bufferIndex: 0,\n  _size: 0,\n\n  /** Epoch counter */\n  _epoch: 0,\n\n  /** State flags */\n  _isProcessing: false,\n  _isBatching: false,\n  _isFlushingSync: false,\n\n  /** Batching state */\n  _batchDepth: 0,\n  _batchQueue: [] as SchedulerJob[],\n  _batchQueueSize: 0,\n\n  /** Config */\n  _maxFlushIterations: SCHEDULER_CONFIG.MAX_FLUSH_ITERATIONS as number,\n\n  get phase(): SchedulerPhase {\n    if (this._isProcessing || this._isFlushingSync) return SchedulerPhase.FLUSHING;\n    if (this._isBatching) return SchedulerPhase.BATCHING;\n    return SchedulerPhase.IDLE;\n  },\n\n  get queueSize(): number {\n    return this._size;\n  },\n\n  get isBatching(): boolean {\n    return this._isBatching;\n  },\n\n  /**\n   * Schedules job.\n   */\n  schedule(callback: SchedulerJob): void {\n    if (IS_DEV && typeof callback !== 'function') {\n      throw new SchedulerError('Scheduler callback must be a function');\n    }\n\n    // Deduplicate job\n    if (callback._nextEpoch === this._epoch) return;\n    callback._nextEpoch = this._epoch;\n\n    if (this._isBatching || this._isFlushingSync) {\n      this._batchQueue[this._batchQueueSize++] = callback;\n      return;\n    }\n\n    // Push to current active buffer\n    this._queueBuffer[this._bufferIndex]![this._size++] = callback;\n\n    // Wake up if sleeping\n    if (!this._isProcessing) {\n      this._flush();\n    }\n  },\n\n  /**\n   * Triggers flush.\n   */\n  _flush(): void {\n    if (this._isProcessing || this._size === 0) return;\n    this._isProcessing = true;\n\n    queueMicrotask(this._runLoop);\n  },\n\n  /**\n   * Scheduler loop.\n   */\n  _runLoop: () => {\n    try {\n      if (scheduler._size === 0) return;\n\n      const started = startFlush();\n      scheduler._drainQueue();\n      if (started) endFlush();\n    } finally {\n      scheduler._isProcessing = false;\n      // If new jobs arrived during flush (and not batching), re-schedule\n      if (scheduler._size > 0 && !scheduler._isBatching) {\n        scheduler._flush();\n      }\n    }\n  },\n\n  _flushSync(): void {\n    this._isFlushingSync = true;\n    const started = startFlush();\n    try {\n      this._mergeBatchQueue();\n      this._drainQueue();\n    } finally {\n      this._isFlushingSync = false;\n      if (started) endFlush();\n    }\n  },\n\n  _mergeBatchQueue(): void {\n    if (this._batchQueueSize === 0) return;\n\n    // Increment epoch\n    const epoch = ++this._epoch;\n    const bQueue = this._batchQueue;\n    const targetBuffer = this._queueBuffer[this._bufferIndex]!;\n    let currentSize = this._size;\n\n    // Merge batch\n    for (let i = 0; i < this._batchQueueSize; i++) {\n      const job = bQueue[i]!;\n      // Retag jobs\n      if (job._nextEpoch !== epoch) {\n        job._nextEpoch = epoch;\n        targetBuffer[currentSize++] = job;\n      }\n    }\n\n    this._size = currentSize;\n    this._batchQueueSize = 0;\n\n    // Resize batch queue\n    if (bQueue.length > SCHEDULER_CONFIG.BATCH_QUEUE_SHRINK_THRESHOLD) {\n      bQueue.length = 0;\n    }\n  },\n\n  _drainQueue(): void {\n    let iterations = 0;\n    // Process queue\n    while (this._size > 0) {\n      // Overflow check\n      if (++iterations > this._maxFlushIterations) {\n        this._handleFlushOverflow();\n        return;\n      }\n\n      this._processQueue();\n      // If batch updates happened during processing, merge them in now\n      this._mergeBatchQueue();\n    }\n  },\n\n  _processQueue(): void {\n    const idx = this._bufferIndex;\n    const jobs = this._queueBuffer[idx]!;\n    const count = this._size;\n\n    // Swap buffers\n    this._bufferIndex = idx ^ 1;\n    this._size = 0;\n    this._epoch++;\n\n    for (let i = 0; i < count; i++) {\n      // Execute job\n      try {\n        jobs[i]!();\n      } catch (e) {\n        console.error(new SchedulerError('Error occurred during scheduler execution', e as Error));\n      }\n    }\n    // Clear the consumed buffer\n    jobs.length = 0;\n  },\n\n  _handleFlushOverflow(): void {\n    console.error(\n      new SchedulerError(\n        `Maximum flush iterations (${this._maxFlushIterations}) exceeded. Possible infinite loop.`\n      )\n    );\n    this._size = 0;\n    this._queueBuffer[this._bufferIndex]!.length = 0;\n    this._batchQueueSize = 0;\n  },\n\n  startBatch(): void {\n    this._batchDepth++;\n    this._isBatching = true;\n  },\n\n  endBatch(): void {\n    if (this._batchDepth === 0) {\n      if (IS_DEV) console.warn('endBatch() called without matching startBatch(). Ignoring.');\n      return;\n    }\n\n    if (--this._batchDepth === 0) {\n      this._flushSync();\n      this._isBatching = false;\n    }\n  },\n\n  setMaxFlushIterations(max: number): void {\n    if (max < SCHEDULER_CONFIG.MIN_FLUSH_ITERATIONS)\n      throw new SchedulerError(\n        `Max flush iterations must be at least ${SCHEDULER_CONFIG.MIN_FLUSH_ITERATIONS}`\n      );\n    this._maxFlushIterations = max;\n  },\n};\n","import type { Listener } from './tracking.types';\n\n/**\n * Global tracking context.\n */\nexport const trackingContext = {\n  /** Active listener. */\n  current: null as Listener | null,\n\n  /**\n   * Executes in context.\n   *\n   * @param listener - The subscriber.\n   * @param fn - The logic to execute.\n   * @returns The result of `fn`.\n   */\n  run<T>(listener: Listener, fn: () => T): T {\n    const prev = this.current;\n    this.current = listener;\n    try {\n      return fn();\n    } finally {\n      this.current = prev;\n    }\n  },\n};\n\n/**\n * Tracking context type.\n */\nexport type ITrackingContext = typeof trackingContext;\n","import { trackingContext } from './context';\n\n/**\n * Untracked execution.\n *\n * @param fn - Function to execute.\n * @returns Result of `fn`.\n */\nexport function untracked<T>(fn: () => T): T {\n  const prev = trackingContext.current;\n\n  // Skip if untracked\n  if (prev === null) return fn();\n\n  trackingContext.current = null;\n  try {\n    return fn();\n  } finally {\n    trackingContext.current = prev;\n  }\n}\n","import { ATOM_STATE_FLAGS, SMI_MAX } from '@/constants';\nimport { ReactiveDependency } from '@/core/base';\nimport { type SubscriberLink, trackDependency } from '@/core/dep-tracking';\nimport { scheduler } from '@/internal/scheduler';\nimport { trackingContext } from '@/tracking';\nimport type { AtomOptions, WritableAtom } from '@/types';\nimport { debug } from '@/utils/debug';\n\n// Pre-compute subscription mask\nconst SUBS_MASK = ATOM_STATE_FLAGS.HAS_FN_SUBS | ATOM_STATE_FLAGS.HAS_OBJ_SUBS;\n\n/**\n * Internal {@link WritableAtom} implementation.\n */\nclass AtomImpl<T> extends ReactiveDependency<T> implements WritableAtom<T> {\n  private _value: T;\n  /** Old value for notifications */\n  private _pendingOldValue: T | undefined = undefined;\n  /** Cached notification task */\n  private _notifyTask: (() => void) | undefined = undefined;\n  protected _subscribers: SubscriberLink<T>[] = [];\n\n  constructor(initialValue: T, sync: boolean) {\n    super();\n    this._value = initialValue;\n    if (sync) this.flags |= ATOM_STATE_FLAGS.SYNC;\n    debug.attachDebugInfo(this, 'atom', this.id);\n  }\n\n  get value(): T {\n    const current = trackingContext.current;\n    if (current) {\n      trackDependency(this, current, this._subscribers);\n    }\n    return this._value;\n  }\n\n  set value(newValue: T) {\n    const oldValue = this._value;\n    if (Object.is(oldValue, newValue)) return;\n\n    this._value = newValue;\n    this.version = (this.version + 1) & SMI_MAX;\n\n    const flags = this.flags;\n    if ((flags & SUBS_MASK) === 0 || flags & ATOM_STATE_FLAGS.NOTIFICATION_SCHEDULED) {\n      return;\n    }\n\n    this._pendingOldValue = oldValue;\n    this.flags = flags | ATOM_STATE_FLAGS.NOTIFICATION_SCHEDULED;\n\n    // Sync handling\n    if (flags & ATOM_STATE_FLAGS.SYNC && !scheduler.isBatching) {\n      this._flushNotifications();\n      return;\n    }\n\n    // Async scheduling\n    if (!this._notifyTask) {\n      // Create notification task\n      this._notifyTask = () => this._flushNotifications();\n    }\n    scheduler.schedule(this._notifyTask);\n  }\n\n  /**\n   * Triggers subscribers.\n   */\n  private _flushNotifications(): void {\n    const flags = this.flags;\n    // Guard: Spurious flush or already disposed\n    if (!(flags & ATOM_STATE_FLAGS.NOTIFICATION_SCHEDULED) || flags & ATOM_STATE_FLAGS.DISPOSED) {\n      return;\n    }\n\n    const oldValue = this._pendingOldValue as T;\n    this._pendingOldValue = undefined;\n    this.flags &= ~ATOM_STATE_FLAGS.NOTIFICATION_SCHEDULED;\n\n    this._notifySubscribers(this._value, oldValue);\n  }\n\n  peek(): T {\n    return this._value;\n  }\n\n  dispose(): void {\n    if (this.flags & ATOM_STATE_FLAGS.DISPOSED) return;\n\n    this._subscribers.length = 0;\n    this.flags |= ATOM_STATE_FLAGS.DISPOSED;\n    // Release references\n    this._value = undefined as T;\n    this._pendingOldValue = undefined;\n    this._notifyTask = undefined;\n  }\n}\n\n/**\n * Creates a reactive atom holding mutable state.\n *\n * @param initialValue - The initial value of the atom.\n * @param options - Configuration options (sync: boolean).\n */\nexport function atom<T>(initialValue: T, options: AtomOptions = {}): WritableAtom<T> {\n  return new AtomImpl(initialValue, options.sync ?? false);\n}\n","import { IS_DEV } from '@/constants';\nimport type { PoolStats } from '@/types';\n\n/**\n * Array pool.\n *\n * @template T - Element type.\n */\nexport class ArrayPool<T> {\n  private readonly pool: T[][] = [];\n\n  // Mutable stats container, null in production\n  private stats = IS_DEV\n    ? {\n        acquired: 0,\n        released: 0,\n        rejected: { frozen: 0, tooLarge: 0, poolFull: 0 },\n      }\n    : null;\n\n  /**\n   * @param limit - Max unique arrays to hold (default: 50). Prevents the pool itself from consuming too much memory.\n   * @param capacity - Max length of an array to accept (default: 256).\n   */\n  constructor(\n    private readonly limit = 50,\n    private readonly capacity = 256\n  ) {}\n\n  /**\n   * Acquires array.\n   */\n  acquire(): T[] {\n    if (IS_DEV && this.stats) {\n      this.stats.acquired++;\n    }\n    // LIFO reuse for better cache locality\n    return this.pool.pop() ?? [];\n  }\n\n  /**\n   * Releases array.\n   *\n   * @param arr - Array to release.\n   * @param emptyConst - Optional empty constant.\n   */\n  release(arr: T[], emptyConst?: readonly T[]): void {\n    if (emptyConst && arr === emptyConst) return;\n\n    if (arr.length > this.capacity) {\n      if (IS_DEV && this.stats) this.stats.rejected.tooLarge++;\n      return;\n    }\n\n    if (this.pool.length >= this.limit) {\n      if (IS_DEV && this.stats) this.stats.rejected.poolFull++;\n      return;\n    }\n\n    if (Object.isFrozen(arr)) {\n      if (IS_DEV && this.stats) this.stats.rejected.frozen++;\n      return;\n    }\n\n    arr.length = 0;\n    this.pool.push(arr);\n\n    if (IS_DEV && this.stats) {\n      this.stats.released++;\n    }\n  }\n\n  /**\n   * Pool stats.\n   */\n  getStats(): PoolStats | null {\n    if (!IS_DEV || !this.stats) return null;\n\n    const { acquired, released, rejected } = this.stats;\n    const leakCount =\n      acquired - released - (rejected.frozen + rejected.tooLarge + rejected.poolFull);\n\n    return {\n      acquired,\n      released,\n      rejected: { ...rejected },\n      leaked: leakCount,\n      poolSize: this.pool.length,\n    };\n  }\n\n  /**\n   * Resets pool.\n   */\n  reset(): void {\n    this.pool.length = 0;\n    if (IS_DEV && this.stats) {\n      this.stats = {\n        acquired: 0,\n        released: 0,\n        rejected: { frozen: 0, tooLarge: 0, poolFull: 0 },\n      };\n    }\n  }\n}\n","import type { DependencyLink, SubscriberLink } from '@/core/dep-tracking';\nimport type { Dependency, Subscriber } from '@/types';\nimport { ArrayPool } from '@/utils/array-pool';\n\nconst freeze = <T>(arr: T[]): readonly T[] => Object.freeze(arr);\n\n// Empty constants\nexport const EMPTY_DEPS = freeze<Dependency>([]);\nexport const EMPTY_SUBS = freeze<Subscriber>([]);\nexport const EMPTY_UNSUBS = freeze<() => void>([]);\nexport const EMPTY_VERSIONS = freeze<number>([]);\nexport const EMPTY_LINKS = freeze<DependencyLink>([]);\nexport const EMPTY_SUBSCRIBERS = freeze<SubscriberLink<unknown>>([]);\n\n// Array pools\nexport const depArrayPool = new ArrayPool<Dependency>();\nexport const unsubArrayPool = new ArrayPool<() => void>();\nexport const versionArrayPool = new ArrayPool<number>();\nexport const linksArrayPool = new ArrayPool<DependencyLink>();\nexport const subscriberPool = new ArrayPool<SubscriberLink<unknown>>();\n","import type { ComputedAtom, EffectObject, ReadonlyAtom, WritableAtom } from '@/types';\n\n/**\n * Readonly atom check.\n *\n * @param obj - Object to check.\n */\nexport function isAtom(obj: unknown): obj is ReadonlyAtom {\n  return (\n    obj !== null &&\n    typeof obj === 'object' &&\n    'value' in obj &&\n    typeof (obj as { subscribe?: unknown }).subscribe === 'function'\n  );\n}\n\n/**\n * Writable atom check.\n */\nexport function isWritable(obj: unknown): obj is WritableAtom {\n  return isAtom(obj) && typeof (obj as { dispose?: unknown }).dispose === 'function';\n}\n\n/**\n * Computed atom check.\n */\nexport function isComputed(obj: unknown): obj is ComputedAtom {\n  return isAtom(obj) && typeof (obj as { invalidate?: unknown }).invalidate === 'function';\n}\n\n/**\n * Effect object check.\n */\nexport function isEffect(obj: unknown): obj is EffectObject {\n  return (\n    obj !== null &&\n    typeof obj === 'object' &&\n    typeof (obj as { dispose?: unknown }).dispose === 'function' &&\n    typeof (obj as { run?: unknown }).run === 'function'\n  );\n}\n\n/**\n * Promise check.\n */\nexport function isPromise<T>(value: unknown): value is Promise<T> {\n  return (\n    value !== null &&\n    typeof value === 'object' &&\n    typeof (value as { then?: unknown }).then === 'function'\n  );\n}\n","import { AsyncState, COMPUTED_STATE_FLAGS, EMPTY_ERROR_ARRAY, SMI_MAX } from '@/constants';\nimport { ReactiveDependency } from '@/core/base';\nimport {\n  DependencyLink,\n  type SubscriberLink,\n  syncDependencies,\n  trackDependency,\n} from '@/core/dep-tracking';\nimport { ComputedError } from '@/errors/errors';\nimport { ERROR_MESSAGES } from '@/errors/messages';\nimport { currentEpoch, nextEpoch } from '@/internal/epoch';\nimport { EMPTY_LINKS, linksArrayPool } from '@/internal/pool';\nimport { trackingContext } from '@/tracking';\nimport type {\n  AsyncStateType,\n  ComputedAtom,\n  ComputedOptions,\n  Dependency,\n  Subscriber,\n} from '@/types';\nimport { debug, NO_DEFAULT_VALUE } from '@/utils/debug';\nimport { wrapError } from '@/utils/error';\nimport { isPromise } from '@/utils/type-guards';\n\n// Async state map\nconst ASYNC_STATE_MASK =\n  COMPUTED_STATE_FLAGS.RESOLVED | COMPUTED_STATE_FLAGS.PENDING | COMPUTED_STATE_FLAGS.REJECTED;\nconst ASYNC_STATE_LOOKUP = Array(ASYNC_STATE_MASK + 1).fill(AsyncState.IDLE);\nASYNC_STATE_LOOKUP[COMPUTED_STATE_FLAGS.RESOLVED] = AsyncState.RESOLVED;\nASYNC_STATE_LOOKUP[COMPUTED_STATE_FLAGS.PENDING] = AsyncState.PENDING;\nASYNC_STATE_LOOKUP[COMPUTED_STATE_FLAGS.REJECTED] = AsyncState.REJECTED;\n\nconst MAX_ASYNC_RETRIES = 3;\nconst MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1;\n\n/**\n * Computed atom implementation.\n */\nclass ComputedAtomImpl<T> extends ReactiveDependency<T> implements ComputedAtom<T>, Subscriber {\n  private _value: T;\n  private _error: Error | null = null;\n  /** Promise tracking ID */\n  private _promiseId = 0;\n\n  private readonly _equal: (a: T, b: T) => boolean;\n  private readonly _fn: () => T | Promise<T>;\n  private readonly _defaultValue: T;\n  private readonly _onError: ((error: Error) => void) | null;\n\n  protected _subscribers: SubscriberLink<T>[] = [];\n  private _links: DependencyLink[] = EMPTY_LINKS as unknown as DependencyLink[];\n\n  /** Error cache */\n  private _cachedErrors: readonly Error[] | null = null;\n  private _errorCacheEpoch = -1;\n\n  // Async state\n  private _asyncStartAggregateVersion = 0;\n  private _asyncRetryCount = 0;\n\n  // Dependency collection state\n  private _trackEpoch = -1;\n  private _trackLinks: DependencyLink[] = EMPTY_LINKS as unknown as DependencyLink[];\n  private _trackCount = 0;\n\n  constructor(fn: () => T | Promise<T>, options: ComputedOptions<T> = {}) {\n    if (typeof fn !== 'function') throw new ComputedError(ERROR_MESSAGES.COMPUTED_MUST_BE_FUNCTION);\n    super();\n\n    this._value = undefined as T;\n    // Start dirty so first access triggers computation\n    this.flags = COMPUTED_STATE_FLAGS.DIRTY | COMPUTED_STATE_FLAGS.IDLE;\n    this._equal = options.equal ?? Object.is;\n    this._fn = fn;\n    this._defaultValue = 'defaultValue' in options ? options.defaultValue : (NO_DEFAULT_VALUE as T);\n    this._onError = options.onError ?? null;\n\n    debug.attachDebugInfo(this, 'computed', this.id);\n\n    // Eager evaluation if not lazy\n    if (options.lazy === false) {\n      try {\n        this._recompute();\n      } catch {} // Ignore error during eager init, it will be captured later\n    }\n  }\n\n  private _track(): void {\n    const current = trackingContext.current;\n    if (current) trackDependency(this, current, this._subscribers);\n  }\n\n  get value(): T {\n    this._track();\n\n    const flags = this.flags;\n    if (\n      (flags &\n        (COMPUTED_STATE_FLAGS.RESOLVED |\n          COMPUTED_STATE_FLAGS.DIRTY |\n          COMPUTED_STATE_FLAGS.IDLE)) ===\n      COMPUTED_STATE_FLAGS.RESOLVED\n    ) {\n      return this._value;\n    }\n\n    if (flags & COMPUTED_STATE_FLAGS.DISPOSED) {\n      throw new ComputedError(ERROR_MESSAGES.COMPUTED_DISPOSED);\n    }\n\n    if (flags & COMPUTED_STATE_FLAGS.RECOMPUTING) {\n      if (this._defaultValue !== (NO_DEFAULT_VALUE as T)) return this._defaultValue;\n      throw new ComputedError(ERROR_MESSAGES.COMPUTED_CIRCULAR_DEPENDENCY);\n    }\n\n    if (flags & (COMPUTED_STATE_FLAGS.DIRTY | COMPUTED_STATE_FLAGS.IDLE)) {\n      this._recompute();\n      // Re-read flags after update\n      if (this.flags & COMPUTED_STATE_FLAGS.RESOLVED) return this._value;\n    }\n\n    // 3. Async/Error handling\n    const def = this._defaultValue;\n    const hasDef = def !== (NO_DEFAULT_VALUE as T);\n\n    if (this.flags & COMPUTED_STATE_FLAGS.PENDING) {\n      if (hasDef) return def;\n      throw new ComputedError(ERROR_MESSAGES.COMPUTED_ASYNC_PENDING_NO_DEFAULT);\n    }\n\n    if (this.flags & COMPUTED_STATE_FLAGS.REJECTED) {\n      if ((this._error as ComputedError)?.recoverable && hasDef) return def;\n      throw this._error;\n    }\n\n    return this._value;\n  }\n\n  peek(): T {\n    return this._value;\n  }\n\n  get state(): AsyncStateType {\n    this._track();\n    return ASYNC_STATE_LOOKUP[this.flags & ASYNC_STATE_MASK];\n  }\n\n  get hasError(): boolean {\n    this._track();\n    if (this.flags & (COMPUTED_STATE_FLAGS.REJECTED | COMPUTED_STATE_FLAGS.HAS_ERROR)) return true;\n\n    // Check dependencies\n    const links = this._links;\n    for (let i = 0, len = links.length; i < len; i++) {\n      const node = links[i]?.node;\n      if (node && node.flags & COMPUTED_STATE_FLAGS.HAS_ERROR) return true;\n    }\n    return false;\n  }\n\n  // ... (isValid, errors, lastError getters remain structurally similar, omitted for brevity if mostly unchanged) ...\n  get isValid(): boolean {\n    return !this.hasError;\n  }\n\n  get errors(): readonly Error[] {\n    this._track();\n    if (!this.hasError) return EMPTY_ERROR_ARRAY;\n\n    const epoch = currentEpoch();\n    if (this._errorCacheEpoch === epoch && this._cachedErrors) return this._cachedErrors;\n\n    const errorSet = new Set<Error>();\n    if (this._error) errorSet.add(this._error);\n\n    const links = this._links;\n    for (let i = 0, len = links.length; i < len; i++) {\n      const dep = links[i]!.node;\n      if (dep.flags & COMPUTED_STATE_FLAGS.HAS_ERROR) {\n        const computedDep = dep as unknown as ComputedAtom<unknown>;\n        if (computedDep.errors) {\n          const depErrors = computedDep.errors;\n          for (let j = 0; j < depErrors.length; j++) {\n            const err = depErrors[j];\n            if (err) errorSet.add(err);\n          }\n        }\n      }\n    }\n\n    const errors = Object.freeze(Array.from(errorSet));\n    this._errorCacheEpoch = epoch;\n    this._cachedErrors = errors;\n    return errors;\n  }\n\n  get lastError(): Error | null {\n    this._track();\n    return this._error;\n  }\n\n  get isPending(): boolean {\n    this._track();\n    return (this.flags & COMPUTED_STATE_FLAGS.PENDING) !== 0;\n  }\n\n  get isResolved(): boolean {\n    this._track();\n    return (this.flags & COMPUTED_STATE_FLAGS.RESOLVED) !== 0;\n  }\n\n  invalidate(): void {\n    this._markDirty();\n    this._errorCacheEpoch = -1;\n    this._cachedErrors = null;\n  }\n\n  dispose(): void {\n    if (this.flags & COMPUTED_STATE_FLAGS.DISPOSED) return;\n\n    const links = this._links;\n    if (links !== EMPTY_LINKS) {\n      for (let i = 0, len = links.length; i < len; i++) {\n        links[i]!.unsub?.();\n      }\n      linksArrayPool.release(links);\n      this._links = EMPTY_LINKS as unknown as DependencyLink[];\n    }\n\n    this._subscribers.length = 0;\n    this.flags =\n      COMPUTED_STATE_FLAGS.DISPOSED | COMPUTED_STATE_FLAGS.DIRTY | COMPUTED_STATE_FLAGS.IDLE;\n\n    // Release Memory\n    this._error = null;\n    this._value = undefined as T;\n    this._promiseId = (this._promiseId + 1) % MAX_PROMISE_ID;\n    this._cachedErrors = null;\n    this._errorCacheEpoch = -1;\n  }\n\n  addDependency(dep: Dependency): void {\n    // Deduplicate dependencies\n    if (dep._lastSeenEpoch === this._trackEpoch) return;\n    dep._lastSeenEpoch = this._trackEpoch;\n\n    // Resize array if needed\n    if (this._trackCount < this._trackLinks.length) {\n      const link = this._trackLinks[this._trackCount]!;\n      link.node = dep;\n      link.version = dep.version;\n    } else {\n      this._trackLinks.push(new DependencyLink(dep, dep.version));\n    }\n    this._trackCount++;\n  }\n\n  private _commitDeps(prevLinks: DependencyLink[]): void {\n    // Sync dependencies\n    this._trackLinks.length = this._trackCount;\n    syncDependencies(this._trackLinks, prevLinks, this);\n    this._links = this._trackLinks;\n  }\n\n  private _recompute(): void {\n    if (this.flags & COMPUTED_STATE_FLAGS.RECOMPUTING) return;\n    this.flags |= COMPUTED_STATE_FLAGS.RECOMPUTING;\n\n    const prevLinks = this._links;\n    this._trackEpoch = nextEpoch();\n    this._trackLinks = linksArrayPool.acquire();\n    this._trackCount = 0;\n\n    let committed = false;\n    try {\n      // Execute function\n      const result = trackingContext.run(this, this._fn);\n\n      this._commitDeps(prevLinks);\n      committed = true;\n\n      // Handle Result\n      if (isPromise(result)) {\n        this._handleAsyncComputation(result);\n      } else {\n        this._finalizeResolution(result);\n      }\n    } catch (e) {\n      // Commit dependencies on error\n      if (!committed) {\n        try {\n          this._commitDeps(prevLinks);\n          committed = true;\n        } catch {}\n      }\n      this._handleError(e as Error, ERROR_MESSAGES.COMPUTED_COMPUTATION_FAILED, true);\n    } finally {\n      // Release pool\n      if (committed && prevLinks !== EMPTY_LINKS) {\n        linksArrayPool.release(prevLinks);\n      } else if (!committed) {\n        linksArrayPool.release(this._trackLinks);\n      }\n\n      // Reset transient state\n      this._trackEpoch = -1;\n      this._trackLinks = EMPTY_LINKS as unknown as DependencyLink[];\n      this._trackCount = 0;\n      this.flags &= ~COMPUTED_STATE_FLAGS.RECOMPUTING;\n    }\n  }\n\n  private _handleAsyncComputation(promise: Promise<T>): void {\n    this.flags =\n      (this.flags | COMPUTED_STATE_FLAGS.PENDING) &\n      ~(\n        COMPUTED_STATE_FLAGS.IDLE |\n        COMPUTED_STATE_FLAGS.DIRTY |\n        COMPUTED_STATE_FLAGS.RESOLVED |\n        COMPUTED_STATE_FLAGS.REJECTED\n      );\n    // Notify pending\n    this._notifySubscribers(undefined, undefined);\n\n    this._asyncStartAggregateVersion = this._captureVersionSnapshot();\n    this._asyncRetryCount = 0;\n    // Invalidate old promises\n    this._promiseId = (this._promiseId + 1) % MAX_PROMISE_ID;\n    const promiseId = this._promiseId;\n\n    promise.then(\n      (res) => {\n        if (promiseId !== this._promiseId) return; // Stale\n\n        // Check for stale reads (did deps change while we waited?)\n        if (this._captureVersionSnapshot() !== this._asyncStartAggregateVersion) {\n          if (this._asyncRetryCount++ < MAX_ASYNC_RETRIES) {\n            return this._markDirty(); // Retry\n          }\n          return this._handleError(\n            new ComputedError(`Async drift threshold exceeded after ${MAX_ASYNC_RETRIES} retries.`),\n            ERROR_MESSAGES.COMPUTED_ASYNC_COMPUTATION_FAILED\n          );\n        }\n\n        this._finalizeResolution(res);\n        this._notifySubscribers(res, undefined);\n      },\n      (err) =>\n        promiseId === this._promiseId &&\n        this._handleError(err, ERROR_MESSAGES.COMPUTED_ASYNC_COMPUTATION_FAILED)\n    );\n  }\n\n  private _captureVersionSnapshot(): number {\n    let aggregate = 0;\n    const links = this._links;\n    for (let i = 0, len = links.length; i < len; i++) {\n      // Hash mixing\n      aggregate = ((((aggregate << 5) - aggregate) | 0) + links[i]!.node.version) & SMI_MAX;\n    }\n    return aggregate;\n  }\n\n  private _handleError(err: unknown, msg: string, throwErr = false): void {\n    const error = wrapError(err, ComputedError, msg);\n\n    if (!throwErr && !(this.flags & COMPUTED_STATE_FLAGS.REJECTED)) {\n      // Update version\n      this.version = (this.version + 1) & SMI_MAX;\n    }\n\n    this._error = error;\n    this.flags =\n      (this.flags &\n        ~(\n          COMPUTED_STATE_FLAGS.IDLE |\n          COMPUTED_STATE_FLAGS.DIRTY |\n          COMPUTED_STATE_FLAGS.PENDING |\n          COMPUTED_STATE_FLAGS.RESOLVED\n        )) |\n      (COMPUTED_STATE_FLAGS.REJECTED | COMPUTED_STATE_FLAGS.HAS_ERROR);\n\n    if (this._onError) {\n      try {\n        this._onError(error);\n      } catch (e) {\n        console.error(ERROR_MESSAGES.CALLBACK_ERROR_IN_ERROR_HANDLER, e);\n      }\n    }\n\n    if (throwErr) throw error;\n    this._notifySubscribers(undefined, undefined);\n  }\n\n  private _finalizeResolution(value: T): void {\n    // Only bump version if value actually changed or first resolve\n    if (!(this.flags & COMPUTED_STATE_FLAGS.RESOLVED) || !this._equal(this._value, value)) {\n      this.version = (this.version + 1) & SMI_MAX;\n    }\n\n    this._value = value;\n    this._error = null;\n    this.flags =\n      (this.flags | COMPUTED_STATE_FLAGS.RESOLVED) &\n      ~(\n        COMPUTED_STATE_FLAGS.IDLE |\n        COMPUTED_STATE_FLAGS.DIRTY |\n        COMPUTED_STATE_FLAGS.PENDING |\n        COMPUTED_STATE_FLAGS.REJECTED |\n        COMPUTED_STATE_FLAGS.HAS_ERROR\n      );\n\n    this._cachedErrors = null;\n    this._errorCacheEpoch = -1;\n  }\n\n  execute(): void {\n    // Subscriber implementation\n    this._markDirty();\n  }\n\n  /** @internal */\n  _markDirty(): void {\n    if (this.flags & (COMPUTED_STATE_FLAGS.RECOMPUTING | COMPUTED_STATE_FLAGS.DIRTY)) return;\n    this.flags |= COMPUTED_STATE_FLAGS.DIRTY;\n    this._notifySubscribers(undefined, undefined);\n  }\n}\n\nObject.freeze(ComputedAtomImpl.prototype);\n\n/**\n * Creates a computed value.\n * @param fn - Computation function\n * @param options - Options object\n */\nexport function computed<T>(fn: () => T, options?: ComputedOptions<T>): ComputedAtom<T>;\nexport function computed<T>(\n  fn: () => Promise<T>,\n  options: ComputedOptions<T> & { defaultValue: T }\n): ComputedAtom<T>;\nexport function computed<T>(\n  fn: () => T | Promise<T>,\n  options: ComputedOptions<T> = {}\n): ComputedAtom<T> {\n  return new ComputedAtomImpl(fn, options);\n}\n","import { EFFECT_STATE_FLAGS, IS_DEV, SCHEDULER_CONFIG, TIME_CONSTANTS } from '@/constants';\nimport { ReactiveNode } from '@/core/base';\nimport { DependencyLink } from '@/core/dep-tracking';\nimport { EffectError } from '@/errors/errors';\nimport { ERROR_MESSAGES } from '@/errors/messages';\nimport {\n  flushEpoch,\n  flushExecutionCount,\n  incrementFlushExecutionCount,\n  nextEpoch,\n} from '@/internal/epoch';\nimport { EMPTY_LINKS, linksArrayPool } from '@/internal/pool';\nimport { scheduler } from '@/internal/scheduler';\nimport { type DependencyTracker, trackingContext, untracked } from '@/tracking';\nimport type { Dependency, EffectFunction, EffectObject, EffectOptions } from '@/types';\nimport { debug } from '@/utils/debug';\nimport { wrapError } from '@/utils/error';\nimport { isPromise } from '@/utils/type-guards';\n\n/**\n * Effect implementation.\n */\nclass EffectImpl extends ReactiveNode implements EffectObject, DependencyTracker {\n  private _cleanup: (() => void) | null = null;\n  private _links: DependencyLink[] = EMPTY_LINKS as unknown as DependencyLink[];\n  private _nextLinks: DependencyLink[] | null = null;\n  private _executeTask: (() => void) | undefined;\n\n  private readonly _onError: ((error: unknown) => void) | null;\n\n  // Cycle detection\n  private _currentEpoch = -1;\n  private _lastFlushEpoch = -1;\n  private _executionsInEpoch = 0;\n\n  private readonly _fn: EffectFunction;\n  private readonly _sync: boolean;\n  private readonly _maxExecutions: number;\n  private readonly _maxExecutionsPerFlush: number;\n  private readonly _trackModifications: boolean;\n\n  // Execution history (Dev)\n  private _history: number[] | null;\n  private _executionCount = 0;\n  private _historyPtr = 0;\n  private readonly _historyCapacity: number;\n  private _execId = 0;\n\n  constructor(fn: EffectFunction, options: EffectOptions = {}) {\n    super();\n    this._fn = fn;\n    this._onError = options.onError ?? null;\n    this._sync = options.sync ?? false;\n    this._maxExecutions =\n      options.maxExecutionsPerSecond ?? SCHEDULER_CONFIG.MAX_EXECUTIONS_PER_SECOND;\n    this._maxExecutionsPerFlush =\n      options.maxExecutionsPerFlush ?? SCHEDULER_CONFIG.MAX_EXECUTIONS_PER_EFFECT;\n    this._trackModifications = options.trackModifications ?? false;\n\n    // Initialize history buffer\n    const isFiniteLimit = Number.isFinite(this._maxExecutions);\n    const capacity = isFiniteLimit\n      ? Math.min(this._maxExecutions + 1, SCHEDULER_CONFIG.MAX_EXECUTIONS_PER_SECOND + 1)\n      : 0;\n    this._historyCapacity = capacity;\n    this._history = IS_DEV && isFiniteLimit && capacity > 0 ? new Array(capacity).fill(0) : null;\n\n    debug.attachDebugInfo(this, 'effect', this.id);\n  }\n\n  public run(): void {\n    if (this.flags & EFFECT_STATE_FLAGS.DISPOSED) {\n      throw new EffectError(ERROR_MESSAGES.EFFECT_DISPOSED);\n    }\n    this.execute(true);\n  }\n\n  public dispose(): void {\n    if (this.flags & EFFECT_STATE_FLAGS.DISPOSED) return;\n    this.flags |= EFFECT_STATE_FLAGS.DISPOSED;\n\n    this._execCleanup();\n    this._releaseLinks(this._links);\n\n    // Reset State\n    this._links = EMPTY_LINKS as unknown as DependencyLink[];\n    this._executeTask = undefined;\n  }\n\n  public addDependency(dep: Dependency): void {\n    // Only track if currently executing (double check)\n    if (!(this.flags & EFFECT_STATE_FLAGS.EXECUTING)) return;\n\n    // Deduplicate in current epoch\n    if (dep._lastSeenEpoch === this._currentEpoch) return;\n    dep._lastSeenEpoch = this._currentEpoch;\n\n    const nextLinks = this._nextLinks!;\n\n    if (dep._tempUnsub) {\n      nextLinks.push(new DependencyLink(dep, dep.version, dep._tempUnsub));\n      dep._tempUnsub = undefined;\n      return;\n    }\n\n    try {\n      const unsubscribe = dep.subscribe(() => {\n        if (this._trackModifications && this.flags & EFFECT_STATE_FLAGS.EXECUTING)\n          dep._modifiedAtEpoch = this._currentEpoch;\n\n        if (this._sync) return this.execute();\n\n        // Task creation\n        if (!this._executeTask) this._executeTask = () => this.execute();\n        scheduler.schedule(this._executeTask!);\n      });\n      nextLinks.push(new DependencyLink(dep, dep.version, unsubscribe));\n    } catch (error) {\n      console.error(wrapError(error, EffectError, ERROR_MESSAGES.EFFECT_EXECUTION_FAILED));\n    }\n  }\n\n  /**\n   * Executes effect with tracking.\n   */\n  public execute(force = false): void {\n    if (this.flags & (EFFECT_STATE_FLAGS.DISPOSED | EFFECT_STATE_FLAGS.EXECUTING)) return;\n\n    // Skip if not dirty\n    if (!force && this._links.length > 0 && !this._isDirty()) return;\n\n    this._checkInfiniteLoops();\n\n    this.flags |= EFFECT_STATE_FLAGS.EXECUTING;\n    this._execCleanup();\n\n    const prevLinks = this._links;\n    // Park subscriptions\n    if (prevLinks !== EMPTY_LINKS) {\n      for (let i = 0, len = prevLinks.length; i < len; i++) {\n        const link = prevLinks[i];\n        if (link) link.node._tempUnsub = link.unsub;\n      }\n    }\n\n    // Setup tracking\n    const nextLinks = linksArrayPool.acquire();\n    this._nextLinks = nextLinks;\n    this._currentEpoch = nextEpoch();\n\n    let committed = false;\n    try {\n      const result = trackingContext.run(this, this._fn);\n      this._links = nextLinks;\n      committed = true;\n\n      this._checkLoopWarnings();\n\n      // Handle result\n      if (isPromise(result)) {\n        this._handleAsyncResult(result);\n      } else {\n        this._cleanup = typeof result === 'function' ? result : null;\n      }\n    } catch (error) {\n      // Commit on error\n      committed = true;\n      this._handleExecutionError(error);\n      this._cleanup = null;\n    } finally {\n      this._finalizeDependencies(committed, prevLinks, nextLinks);\n      this.flags &= ~EFFECT_STATE_FLAGS.EXECUTING;\n    }\n  }\n\n  private _handleAsyncResult(promise: Promise<unknown>): void {\n    const execId = ++this._execId;\n    promise.then(\n      (cleanup) => {\n        // Guard against race conditions (new execution or disposal happened)\n        if (execId !== this._execId || this.flags & EFFECT_STATE_FLAGS.DISPOSED) {\n          if (typeof cleanup === 'function') {\n            try {\n              cleanup();\n            } catch (e) {\n              this._handleExecutionError(e, ERROR_MESSAGES.EFFECT_CLEANUP_FAILED);\n            }\n          }\n          return;\n        }\n        if (typeof cleanup === 'function') this._cleanup = cleanup as () => void;\n      },\n      (err) => execId === this._execId && this._handleExecutionError(err)\n    );\n  }\n\n  private _finalizeDependencies(\n    committed: boolean,\n    prevLinks: DependencyLink[],\n    nextLinks: DependencyLink[]\n  ): void {\n    this._nextLinks = null;\n\n    if (committed) {\n      // Cleanup unused subscriptions\n      if (prevLinks !== EMPTY_LINKS) {\n        for (let i = 0, len = prevLinks.length; i < len; i++) {\n          const link = prevLinks[i];\n          const unsub = link?.node._tempUnsub;\n          if (unsub) {\n            unsub();\n            if (link) link.node._tempUnsub = undefined;\n          }\n        }\n        linksArrayPool.release(prevLinks);\n      }\n    } else {\n      // Abort and restore\n      this._releaseLinks(nextLinks);\n      linksArrayPool.release(nextLinks);\n\n      if (prevLinks !== EMPTY_LINKS) {\n        for (let i = 0, len = prevLinks.length; i < len; i++) {\n          // Clear park slots\n          if (prevLinks[i]) prevLinks[i]!.node._tempUnsub = undefined;\n        }\n      }\n    }\n  }\n\n  private _releaseLinks(links: DependencyLink[]): void {\n    if (links === EMPTY_LINKS) return;\n    for (let i = 0, len = links.length; i < len; i++) {\n      links[i]?.unsub?.();\n    }\n    linksArrayPool.release(links);\n  }\n\n  private _isDirty(): boolean {\n    const links = this._links;\n    for (let i = 0, len = links.length; i < len; i++) {\n      const link = links[i]!;\n      const dep = link.node;\n      // Version Check\n      if (dep.version !== link.version) return true;\n\n      // Check computed values\n      if ('value' in (dep as object)) {\n        try {\n          untracked(() => (dep as { value: unknown }).value);\n        } catch {\n          return true; // Error usually implies dirty/re-eval needed\n        }\n        if (dep.version !== link.version) return true;\n      }\n    }\n    return false;\n  }\n\n  private _execCleanup(): void {\n    if (!this._cleanup) return;\n    try {\n      this._cleanup();\n    } catch (error) {\n      this._handleExecutionError(error, ERROR_MESSAGES.EFFECT_CLEANUP_FAILED);\n    }\n    this._cleanup = null;\n  }\n\n  private _checkInfiniteLoops(): void {\n    const epoch = flushEpoch;\n    if (this._lastFlushEpoch !== epoch) {\n      this._lastFlushEpoch = epoch;\n      this._executionsInEpoch = 0;\n    }\n\n    if (++this._executionsInEpoch > this._maxExecutionsPerFlush)\n      this._throwInfiniteLoopError('per-effect');\n    if (incrementFlushExecutionCount() > SCHEDULER_CONFIG.MAX_EXECUTIONS_PER_FLUSH)\n      this._throwInfiniteLoopError('global');\n\n    this._executionCount++;\n\n    // Frequency check\n    if (this._history) {\n      const now = Date.now();\n      this._history[this._historyPtr] = now;\n      this._historyPtr = (this._historyPtr + 1) % this._historyCapacity;\n      const oldest = this._history[this._historyPtr] || 0;\n\n      if (oldest > 0 && now - oldest < TIME_CONSTANTS.ONE_SECOND_MS) {\n        const err = new EffectError(\n          `Effect executed too frequently within 1 second. Suspected infinite loop.`\n        );\n        this.dispose();\n        this._handleExecutionError(err);\n        if (IS_DEV) throw err;\n      }\n    }\n  }\n\n  get isDisposed(): boolean {\n    return (this.flags & EFFECT_STATE_FLAGS.DISPOSED) !== 0;\n  }\n  get executionCount(): number {\n    return this._executionCount;\n  }\n  get isExecuting(): boolean {\n    return (this.flags & EFFECT_STATE_FLAGS.EXECUTING) !== 0;\n  }\n\n  private _throwInfiniteLoopError(type: 'per-effect' | 'global'): never {\n    const error = new EffectError(\n      `Infinite loop detected (${type}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${flushExecutionCount}`\n    );\n    this.dispose();\n    console.error(error);\n    throw error;\n  }\n\n  private _handleExecutionError(\n    error: unknown,\n    message: string = ERROR_MESSAGES.EFFECT_EXECUTION_FAILED\n  ): void {\n    const errorObj = wrapError(error, EffectError, message);\n    console.error(errorObj);\n    if (this._onError) {\n      try {\n        this._onError(errorObj);\n      } catch (e) {\n        console.error(wrapError(e, EffectError, ERROR_MESSAGES.CALLBACK_ERROR_IN_ERROR_HANDLER));\n      }\n    }\n  }\n\n  private _checkLoopWarnings(): void {\n    if (this._trackModifications && debug.enabled) {\n      const epoch = this._currentEpoch;\n      const links = this._links;\n      for (let i = 0, len = links.length; i < len; i++) {\n        const dep = links[i]!.node;\n        if (dep._modifiedAtEpoch === epoch) {\n          debug.warn(\n            true,\n            `Effect is reading a dependency (${debug.getDebugName(dep) || 'unknown'}) that it just modified. Infinite loop may occur`\n          );\n        }\n      }\n    }\n  }\n}\n\n/**\n * Creates and starts an effect.\n *\n * @param fn - Effect function.\n * @param options - Configuration options.\n * @returns Effect instance.\n */\nexport function effect(fn: EffectFunction, options: EffectOptions = {}): EffectObject {\n  if (typeof fn !== 'function') {\n    throw new EffectError(ERROR_MESSAGES.EFFECT_MUST_BE_FUNCTION);\n  }\n\n  const effectInstance = new EffectImpl(fn, options);\n  effectInstance.execute();\n\n  return effectInstance;\n}\n","import { scheduler } from './scheduler';\n\n/**\n * Batches updates.\n *\n * @param fn - Batch function.\n * @returns - Result of `fn`.\n */\nexport function batch<T>(fn: () => T): T {\n  // Validate callback\n  if (typeof fn !== 'function') {\n    throw new TypeError('Batch callback must be a function');\n  }\n\n  scheduler.startBatch();\n  try {\n    return fn();\n  } finally {\n    scheduler.endBatch();\n  }\n}\n"],"names":["TIME_CONSTANTS","AsyncState","NODE_FLAGS","EFFECT_STATE_FLAGS","COMPUTED_STATE_FLAGS","ATOM_STATE_FLAGS","POOL_CONFIG","SCHEDULER_CONFIG","DEBUG_CONFIG","SMI_MAX","IS_DEV","EMPTY_ERROR_ARRAY","AtomError","message","cause","recoverable","ComputedError","EffectError","SchedulerError","DEBUG_NAME","DEBUG_ID","DEBUG_TYPE","NO_DEFAULT_VALUE","hasDeps","o","checkCircularInternal","dep","current","visited","deps","i","child","debug","cond","msg","obj","type","id","t","nextId","generateId","trackDependency","dependency","subscribers","fn","len","link","SubscriberLink","sub","syncDependencies","nextLinks","prevLinks","tracker","node","DependencyLink","version","unsub","ERROR_MESSAGES","wrapError","error","ErrorClass","context","isNativeError","originalMessage","finalMessage","ReactiveNode","ReactiveDependency","listener","isFn","subs","idx","last","newValue","oldValue","s","err","collectorEpoch","nextEpoch","currentEpoch","flushEpoch","flushExecutionCount","isFlushing","startFlush","endFlush","incrementFlushExecutionCount","scheduler","callback","started","epoch","bQueue","targetBuffer","currentSize","job","iterations","jobs","count","e","max","trackingContext","prev","untracked","SUBS_MASK","AtomImpl","initialValue","sync","flags","atom","options","ArrayPool","limit","capacity","arr","emptyConst","acquired","released","rejected","leakCount","freeze","EMPTY_LINKS","linksArrayPool","isAtom","isComputed","isEffect","isPromise","value","ASYNC_STATE_MASK","ASYNC_STATE_LOOKUP","MAX_ASYNC_RETRIES","MAX_PROMISE_ID","ComputedAtomImpl","def","hasDef","links","errorSet","computedDep","depErrors","j","errors","committed","result","promise","promiseId","res","aggregate","throwErr","computed","EffectImpl","isFiniteLimit","unsubscribe","force","execId","cleanup","now","oldest","errorObj","effect","effectInstance","batch"],"mappings":"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"}

package/dist/index.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const nt={ONE_SECOND_MS:1e3},F={IDLE:"idle",PENDING:"pending",RESOLVED:"resolved",REJECTED:"rejected"},C={DISPOSED:1,HAS_FN_SUBS:2,HAS_OBJ_SUBS:4},S={...C,EXECUTING:8},h={...C,DIRTY:8,IDLE:16,PENDING:32,RESOLVED:64,REJECTED:128,RECOMPUTING:256,HAS_ERROR:512},I={...C,SYNC:8,NOTIFICATION_SCHEDULED:16},rt={MAX_SIZE:1e3,WARMUP_SIZE:100},b={MAX_EXECUTIONS_PER_SECOND:1e3,CLEANUP_THRESHOLD:1e3,MAX_EXECUTIONS_PER_EFFECT:100,MAX_EXECUTIONS_PER_FLUSH:1e4,MAX_FLUSH_ITERATIONS:1e3,MIN_FLUSH_ITERATIONS:10,BATCH_QUEUE_SHRINK_THRESHOLD:1e3},G={MAX_DEPENDENCIES:1e3,WARN_INFINITE_LOOP:!0},m=1073741823,y=typeof process<"u"&&process.env&&process.env.NODE_ENV!=="production",ot=Object.freeze([]);class O extends Error{constructor(t,e=null,s=!0){super(t),this.name="AtomError",this.cause=e,this.recoverable=s,this.timestamp=new Date}}class D extends O{constructor(t,e=null){super(t,e,!0),this.name="ComputedError"}}class A extends O{constructor(t,e=null){super(t,e,!1),this.name="EffectError"}}class L extends O{constructor(t,e=null){super(t,e,!1),this.name="SchedulerError"}}const M=Symbol("debugName"),ct=Symbol("id"),B=Symbol("type"),H=Symbol("noDefaultValue");function ht(i){return"dependencies"in i&&Array.isArray(i.dependencies)}function J(i,t,e){if(!e.has(i.id)){if(e.add(i.id),i===t)throw new D("Indirect circular dependency detected");if(ht(i)){const s=i.dependencies;for(let n=0;n<s.length;n++){const r=s[n];r&&J(r,t,e)}}}}const g={enabled:typeof process<"u"&&process.env?.NODE_ENV==="development",maxDependencies:G.MAX_DEPENDENCIES,warnInfiniteLoop:G.WARN_INFINITE_LOOP,warn(i,t){this.enabled&&i&&console.warn(`[Atom Effect] ${t}`)},checkCircular(i,t){if(i===t)throw new D("Direct circular dependency detected");this.enabled&&J(i,t,new Set)},attachDebugInfo(i,t,e){if(!this.enabled)return;const s=i;s[M]=`${t}_${e}`,s[ct]=e,s[B]=t},getDebugName(i){if(i!=null&&M in i)return i[M]},getDebugType(i){if(i!=null&&B in i)return i[B]}};let ut=1;const lt=()=>ut++;function T(i,t,e){if(t==null)return;const s=t;if(typeof s.addDependency=="function"){s.addDependency(i);return}if(typeof t=="function"){const r=t,o=e.length;for(let l=0;l<o;l++)if(e[l].fn===r)return;e.push(new P(r)),i.flags|=C.HAS_FN_SUBS;return}const n=t;if(typeof n.execute=="function"){const r=e.length;for(let o=0;o<r;o++)if(e[o].sub===n)return;e.push(new P(void 0,n)),i.flags|=C.HAS_OBJ_SUBS}}function at(i,t,e){const s=t.length,n=i.length;if(s>0)for(let r=0;r<s;r++){const o=t[r];o&&(o.node._tempUnsub=o.unsub)}for(let r=0;r<n;r++){const o=i[r];if(!o)continue;const l=o.node,c=l._tempUnsub;c!==void 0?(o.unsub=c,l._tempUnsub=void 0):(g.checkCircular(l,e),o.unsub=l.subscribe(e))}if(s>0)for(let r=0;r<s;r++){const o=t[r];if(o){const l=o.node,c=l._tempUnsub;c!==void 0&&(c(),l._tempUnsub=void 0),o.unsub=void 0}}}class z{constructor(t,e,s=void 0){this.node=t,this.version=e,this.unsub=s}}class P{constructor(t,e){this.fn=t,this.sub=e}}const _={COMPUTED_MUST_BE_FUNCTION:"Computed function must be a function",COMPUTED_ASYNC_PENDING_NO_DEFAULT:"Async computation is pending. No default value provided",COMPUTED_COMPUTATION_FAILED:"Computed computation failed",COMPUTED_ASYNC_COMPUTATION_FAILED:"Async computed computation failed",COMPUTED_CIRCULAR_DEPENDENCY:"Circular dependency detected during computation",COMPUTED_DISPOSED:"Cannot access a disposed computed",ATOM_SUBSCRIBER_MUST_BE_FUNCTION:"Subscription listener must be a function or Subscriber object",ATOM_INDIVIDUAL_SUBSCRIBER_FAILED:"Error during individual atom subscriber execution",EFFECT_MUST_BE_FUNCTION:"Effect function must be a function",EFFECT_EXECUTION_FAILED:"Effect execution failed",EFFECT_CLEANUP_FAILED:"Effect cleanup function execution failed",EFFECT_DISPOSED:"Cannot run a disposed effect",LARGE_DEPENDENCY_GRAPH:i=>`Large dependency graph detected: ${i} dependencies`,CALLBACK_ERROR_IN_ERROR_HANDLER:"Error occurred during onError callback execution"};class ${constructor(){this.flags=0,this.version=0,this._lastSeenEpoch=-1,this._modifiedAtEpoch=-1,this.id=lt()&m,this._tempUnsub=void 0}}class K extends ${subscribe(t){const e=this._subscribers,s=typeof t=="function";if(!s&&(t===null||typeof t!="object"||typeof t.execute!="function"))throw new O(_.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);const n=e.length;if(s){for(let o=0;o<n;o++)if(e[o].fn===t)return y&&console.warn("Attempted to subscribe the same listener twice. Ignoring duplicate subscription."),()=>{}}else for(let o=0;o<n;o++)if(e[o].sub===t)return y&&console.warn("Attempted to subscribe the same listener twice. Ignoring duplicate subscription."),()=>{};const r=s?new P(t):new P(void 0,t);return e.push(r),this.flags|=s?C.HAS_FN_SUBS:C.HAS_OBJ_SUBS,()=>{const o=e.indexOf(r);if(o===-1)return;const l=e.pop();o<e.length&&(e[o]=l);const c=e.length;if(c===0)this.flags&=-7;else{let a=!1,u=!1;for(let d=0;d<c&&(e[d].fn?a=!0:u=!0,!(a&&u));d++);let f=this.flags;a||(f&=-3),u||(f&=-5),this.flags=f}}}subscriberCount(){return this._subscribers.length}_notifySubscribers(t,e){if(!(this.flags&(C.HAS_FN_SUBS|C.HAS_OBJ_SUBS)))return;const n=this._subscribers,r=n.length;for(let o=0;o<r;o++){const l=n[o];try{l.fn?l.fn(t,e):l.sub&&l.sub.execute()}catch(c){this._handleNotifyError(c)}}}_handleNotifyError(t){console.error(new O(_.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED,t))}}let x=0;function W(){return x=x+1&m||1,x}function ft(){return x}let V=0,X=0,v=!1;function Y(){return v?(y&&console.warn("Warning: startFlush() called during flush - ignored to prevent infinite loop detection bypass"),!1):(v=!0,V=V+1&m||1,X=0,!0)}function j(){v=!1}function _t(){return v?++X:0}class Et{constructor(){this._queueBuffer=[[],[]],this._bufferIndex=0,this._size=0,this._epoch=0,this._isProcessing=!1,this._isBatching=!1,this._batchDepth=0,this._batchQueue=[],this._batchQueueSize=0,this._isFlushingSync=!1,this._maxFlushIterations=b.MAX_FLUSH_ITERATIONS}get phase(){return this._isProcessing||this._isFlushingSync?2:this._isBatching?1:0}get queueSize(){return this._size}get isBatching(){return this._isBatching}schedule(t){if(y&&typeof t!="function")throw new L("Scheduler callback must be a function");const e=this._epoch;if(t._nextEpoch===e)return;if(t._nextEpoch=e,this._isBatching||this._isFlushingSync){this._batchQueue[this._batchQueueSize++]=t;return}const s=this._bufferIndex,n=this._size;this._queueBuffer[s][n]=t,this._size=n+1,this._isProcessing||this.flush()}flush(){this._isProcessing||this._size===0||(this._isProcessing=!0,queueMicrotask(()=>{try{if(this._size===0)return;const t=Y();this._drainQueue(),t&&j()}finally{this._isProcessing=!1,this._size>0&&!this._isBatching&&this.flush()}}))}flushSync(){this._isFlushingSync=!0;const t=Y();try{this._mergeBatchQueue(),this._drainQueue()}finally{this._isFlushingSync=!1,t&&j()}}_mergeBatchQueue(){const t=this._batchQueueSize;if(t===0)return;const e=++this._epoch,s=this._batchQueue,n=this._queueBuffer[this._bufferIndex];let r=this._size;for(let o=0;o<t;o++){const l=s[o];l._nextEpoch!==e&&(l._nextEpoch=e,n[r++]=l)}this._size=r,this._batchQueueSize=0,s.length>b.BATCH_QUEUE_SHRINK_THRESHOLD&&(s.length=0)}_drainQueue(){let t=0;const e=this._maxFlushIterations;for(;this._size>0;){if(++t>e){this._handleFlushOverflow();return}this._processQueue(),this._mergeBatchQueue()}}_processQueue(){const t=this._bufferIndex,e=this._queueBuffer[t],s=this._size;this._bufferIndex=t^1,this._size=0,this._epoch++,this._processJobs(e,s)}_handleFlushOverflow(){console.error(new L(`Maximum flush iterations (${this._maxFlushIterations}) exceeded. Possible infinite loop.`)),this._size=0,this._queueBuffer[this._bufferIndex].length=0,this._batchQueueSize=0}_processJobs(t,e){for(let s=0;s<e;s++)try{const n=t[s];n&&n()}catch(n){console.error(new L("Error occurred during scheduler execution",n))}t.length=0}startBatch(){this._batchDepth++,this._isBatching=!0}endBatch(){const t=this._batchDepth;if(t===0){y&&console.warn("endBatch() called without matching startBatch(). Ignoring.");return}const e=t-1;this._batchDepth=e,e===0&&(this.flushSync(),this._isBatching=!1)}setMaxFlushIterations(t){if(t<b.MIN_FLUSH_ITERATIONS)throw new L(`Max flush iterations must be at least ${b.MIN_FLUSH_ITERATIONS}`);this._maxFlushIterations=t}}const U=new Et;class dt{constructor(){this.current=null}run(t,e){const s=this.current;this.current=t;try{return e()}finally{this.current=s}}getCurrent(){return this.current}}const E=new dt;function Z(i){if(typeof i!="function")throw new O("Untracked callback must be a function");const t=E.current;E.current=null;try{return i()}finally{E.current=t}}class pt extends K{constructor(t,e){super(),this._value=t,this._pendingOldValue=void 0,this._notifyTask=void 0,this._subscribers=[],e&&(this.flags|=I.SYNC),g.attachDebugInfo(this,"atom",this.id)}get value(){const t=E.current;return t&&T(this,t,this._subscribers),this._value}set value(t){const e=this._value;if(e===t||Object.is(e,t))return;this._value=t,this.version=this.version+1&m;let s=this.flags;if(s&(I.HAS_FN_SUBS|I.HAS_OBJ_SUBS)){if(s&I.NOTIFICATION_SCHEDULED)return;if(this._pendingOldValue=e,s|=I.NOTIFICATION_SCHEDULED,this.flags=s,s&I.SYNC&&!U.isBatching){this._flushNotifications();return}this._notifyTask||(this._notifyTask=()=>this._flushNotifications()),U.schedule(this._notifyTask)}}_flushNotifications(){const t=this.flags;if(!(t&I.NOTIFICATION_SCHEDULED)||t&I.DISPOSED)return;const e=this._pendingOldValue;this._pendingOldValue=void 0,this.flags=t&-17,this._notifySubscribers(this._value,e)}peek(){return this._value}dispose(){const t=this.flags;t&I.DISPOSED||(this._subscribers.length=0,this.flags=t|I.DISPOSED,this._value=void 0,this._pendingOldValue=void 0,this._notifyTask=void 0)}}function St(i,t={}){return new pt(i,t.sync??!1)}class gt{constructor(){this.frozen=0,this.tooLarge=0,this.poolFull=0}}class It{constructor(){this.acquired=0,this.released=0,this.rejected=new gt}}class Dt{constructor(){this.pool=[],this.maxPoolSize=50,this.maxReusableCapacity=256,this.stats=y?new It:null}acquire(){const t=this.stats;return t&&t.acquired++,this.pool.pop()??[]}release(t,e){const s=this.stats;if(e&&t===e)return;if(Object.isFrozen(t)){s&&s.rejected.frozen++;return}if(t.length>this.maxReusableCapacity){s&&s.rejected.tooLarge++;return}const n=this.pool;if(n.length>=this.maxPoolSize){s&&s.rejected.poolFull++;return}t.length=0,n.push(t),s&&s.released++}getStats(){const t=this.stats;if(!t)return null;const{acquired:e,released:s,rejected:n}=t,{frozen:r,tooLarge:o,poolFull:l}=n;return{acquired:e,released:s,rejected:{frozen:r,tooLarge:o,poolFull:l},leaked:e-s-(r+o+l),poolSize:this.pool.length}}reset(){this.pool.length=0;const t=this.stats;t&&(t.acquired=0,t.released=0,t.rejected.frozen=0,t.rejected.tooLarge=0,t.rejected.poolFull=0)}}const p=Object.freeze([]),R=new Dt;function k(i,t,e){if(i instanceof TypeError)return new t(`Type error (${e}): ${i.message}`,i);if(i instanceof ReferenceError)return new t(`Reference error (${e}): ${i.message}`,i);if(i instanceof O)return i;const s=i instanceof Error?i.message:String(i),n=i instanceof Error?i:null;return new t(`Unexpected error (${e}): ${s}`,n)}function tt(i){return i!==null&&typeof i=="object"&&"value"in i&&typeof i.subscribe=="function"}function Ct(i){return g.enabled&&i!=null&&typeof i=="object"&&g.getDebugType(i)==="computed"?!0:tt(i)&&typeof i.invalidate=="function"}function bt(i){return i!==null&&typeof i=="object"&&typeof i.dispose=="function"&&typeof i.run=="function"}function et(i){return i!=null&&typeof i.then=="function"}const st=h.RESOLVED|h.PENDING|h.REJECTED,w=Array(st+1).fill(F.IDLE);w[h.RESOLVED]=F.RESOLVED;w[h.PENDING]=F.PENDING;w[h.REJECTED]=F.REJECTED;const Q=3,q=Number.MAX_SAFE_INTEGER-1;class it extends K{constructor(t,e={}){if(typeof t!="function")throw new D(_.COMPUTED_MUST_BE_FUNCTION);if(super(),this._value=void 0,this.flags=h.DIRTY|h.IDLE,this._error=null,this._promiseId=0,this._equal=e.equal??Object.is,this._fn=t,this._defaultValue="defaultValue"in e?e.defaultValue:H,this._onError=e.onError??null,this._subscribers=[],this._links=p,this._cachedErrors=null,this._errorCacheEpoch=-1,this._asyncStartAggregateVersion=0,this._asyncRetryCount=0,this._trackEpoch=-1,this._trackLinks=p,this._trackCount=0,g.attachDebugInfo(this,"computed",this.id),g.enabled){const s=this;s.subscriberCount=this.subscriberCount.bind(this),s.isDirty=()=>(this.flags&h.DIRTY)!==0,s.links=this._links}if(e.lazy===!1)try{this._recompute()}catch{}}get value(){const t=E.current;t&&T(this,t,this._subscribers);let e=this.flags;if((e&(h.RESOLVED|h.DIRTY|h.IDLE))===h.RESOLVED)return this._value;if(e&h.DISPOSED)throw new D(_.COMPUTED_DISPOSED);if(e&h.RECOMPUTING){const r=this._defaultValue;if(r!==H)return r;throw new D(_.COMPUTED_CIRCULAR_DEPENDENCY)}if(e&(h.DIRTY|h.IDLE)&&(this._recompute(),e=this.flags),e&h.RESOLVED)return this._value;const s=this._defaultValue,n=s!==H;if(e&h.PENDING){if(n)return s;throw new D(_.COMPUTED_ASYNC_PENDING_NO_DEFAULT)}if(e&h.REJECTED){const r=this._error;if(r?.recoverable&&n)return s;throw r}return this._value}peek(){return this._value}get state(){const t=E.current;return t&&T(this,t,this._subscribers),w[this.flags&st]}get hasError(){const t=E.current;if(t&&T(this,t,this._subscribers),this.flags&(h.REJECTED|h.HAS_ERROR))return!0;const s=this._links;for(let n=0,r=s.length;n<r;n++)if(s[n].node.flags&h.HAS_ERROR)return!0;return!1}get isValid(){return!this.hasError}get errors(){const t=E.current;if(t&&T(this,t,this._subscribers),!this.hasError)return ot;const e=ft();if(this._errorCacheEpoch===e&&this._cachedErrors!==null)return this._cachedErrors;const s=new Set,n=this._error;n&&s.add(n);const r=this._links;for(let l=0,c=r.length;l<c;l++){const a=r[l].node;if(a.flags&h.HAS_ERROR){const u=a.errors;if(u)for(let f=0,d=u.length;f<d;f++){const N=u[f];N&&s.add(N)}}}const o=Object.freeze(Array.from(s));return this._errorCacheEpoch=e,this._cachedErrors=o,o}get lastError(){const t=E.current;return t&&T(this,t,this._subscribers),this._error}get isPending(){const t=E.current;return t&&T(this,t,this._subscribers),(this.flags&h.PENDING)!==0}get isResolved(){const t=E.current;return t&&T(this,t,this._subscribers),(this.flags&h.RESOLVED)!==0}invalidate(){this._markDirty(),this._errorCacheEpoch=-1,this._cachedErrors=null}dispose(){if(this.flags&h.DISPOSED)return;const e=this._links;if(e!==p){for(let s=0,n=e.length;s<n;s++){const r=e[s];r?.unsub&&r.unsub()}R.release(e),this._links=p}this._subscribers.length=0,this.flags=h.DISPOSED|h.DIRTY|h.IDLE,this._error=null,this._value=void 0,this._promiseId=(this._promiseId+1)%q,this._cachedErrors=null,this._errorCacheEpoch=-1}addDependency(t){const e=this._trackEpoch;if(t._lastSeenEpoch===e)return;t._lastSeenEpoch=e;const s=this._trackCount,n=this._trackLinks;if(s<n.length){const r=n[s];r.node=t,r.version=t.version}else n.push(new z(t,t.version));this._trackCount=s+1}_commitDeps(t){const e=this._trackLinks,s=this._trackCount;e.length=s,at(e,t,this),this._links=e}_recompute(){if(this.flags&h.RECOMPUTING)return;this.flags|=h.RECOMPUTING;const t=this._links;this._trackEpoch=W(),this._trackLinks=R.acquire(),this._trackCount=0;let e=!1;try{const s=E.run(this,this._fn);this._commitDeps(t),e=!0,et(s)?this._handleAsyncComputation(s):this._finalizeResolution(s)}catch(s){let n=s;if(!e)try{this._commitDeps(t),e=!0}catch(r){n=r}this._handleComputationError(n)}finally{e?t!==p&&R.release(t):R.release(this._trackLinks),this._trackEpoch=-1,this._trackLinks=p,this._trackCount=0,this.flags&=-257}}_handleAsyncComputation(t){this.flags=(this.flags|h.PENDING)&-217,this._notifySubscribers(void 0,void 0),this._asyncStartAggregateVersion=this._captureVersionSnapshot(),this._asyncRetryCount=0,this._promiseId=(this._promiseId+1)%q;const e=this._promiseId;t.then(s=>{if(e===this._promiseId){if(this._captureVersionSnapshot()!==this._asyncStartAggregateVersion){if(this._asyncRetryCount<Q){this._asyncRetryCount++,this._markDirty();return}this._handleAsyncRejection(new D(`Async drift threshold exceeded after ${Q} retries.`));return}this._finalizeResolution(s),this._notifySubscribers(s,void 0)}}).catch(s=>{e===this._promiseId&&this._handleAsyncRejection(s)})}_captureVersionSnapshot(){let t=0;const e=this._links;for(let s=0,n=e.length;s<n;s++){const r=e[s].node.version;t=((t<<5)-t|0)+r&m}return t}_handleAsyncRejection(t){const e=k(t,D,_.COMPUTED_ASYNC_COMPUTATION_FAILED);this.flags&h.REJECTED||(this.version=this.version+1&m),this._error=e,this.flags=this.flags&-121|(h.REJECTED|h.HAS_ERROR);const s=this._onError;if(s)try{s(e)}catch(n){console.error(_.CALLBACK_ERROR_IN_ERROR_HANDLER,n)}this._notifySubscribers(void 0,void 0)}_finalizeResolution(t){(!(this.flags&h.RESOLVED)||!this._equal(this._value,t))&&(this.version=this.version+1&m),this._value=t,this._error=null,this.flags=(this.flags|h.RESOLVED)&-697,this._cachedErrors=null,this._errorCacheEpoch=-1}_handleComputationError(t){const e=k(t,D,_.COMPUTED_COMPUTATION_FAILED);this._error=e,this.flags=this.flags&-121|(h.REJECTED|h.HAS_ERROR);const s=this._onError;if(s)try{s(e)}catch(n){console.error(_.CALLBACK_ERROR_IN_ERROR_HANDLER,n)}throw e}execute(){this._markDirty()}_markDirty(){const t=this.flags;t&(h.RECOMPUTING|h.DIRTY)||(this.flags=t|h.DIRTY,this._notifySubscribers(void 0,void 0))}}Object.freeze(it.prototype);function Ot(i,t={}){return new it(i,t)}class Nt extends ${constructor(t,e={}){super(),this._cleanup=null,this._links=p,this._nextLinks=null,this._executeTask=void 0,this._onError=e.onError??null,this._currentEpoch=-1,this._lastFlushEpoch=-1,this._executionsInEpoch=0,this._fn=t,this._sync=e.sync??!1,this._maxExecutions=e.maxExecutionsPerSecond??b.MAX_EXECUTIONS_PER_SECOND,this._maxExecutionsPerFlush=e.maxExecutionsPerFlush??b.MAX_EXECUTIONS_PER_EFFECT,this._trackModifications=e.trackModifications??!1,this._executionCount=0,this._historyPtr=0;const s=Number.isFinite(this._maxExecutions),n=s?Math.min(this._maxExecutions+1,b.MAX_EXECUTIONS_PER_SECOND+1):0;this._historyCapacity=n,this._history=y&&s&&n>0?new Array(n).fill(0):null,this._execId=0,g.attachDebugInfo(this,"effect",this.id)}run(){if(this.flags&S.DISPOSED)throw new A(_.EFFECT_DISPOSED);this.execute(!0)}dispose(){const t=this.flags;if(t&S.DISPOSED)return;if(this.flags=t|S.DISPOSED,this._cleanup){try{this._cleanup()}catch(s){this._handleExecutionError(s,_.EFFECT_CLEANUP_FAILED)}this._cleanup=null}const e=this._links;if(e!==p){for(let s=0,n=e.length;s<n;s++){const r=e[s];r?.unsub&&r.unsub()}R.release(e),this._links=p}this._executeTask=void 0}addDependency(t){if(!(this.flags&S.EXECUTING))return;const s=this._currentEpoch;if(t._lastSeenEpoch===s)return;t._lastSeenEpoch=s;const n=this._nextLinks,r=t._tempUnsub;if(r){n.push(new z(t,t.version,r)),t._tempUnsub=void 0;return}try{const o=this._sync,l=this._trackModifications,c=t.subscribe(()=>{if(l&&this.flags&S.EXECUTING&&(t._modifiedAtEpoch=this._currentEpoch),o){this.execute();return}this._executeTask||(this._executeTask=()=>this.execute());const a=this._executeTask;U.schedule(a)});n.push(new z(t,t.version,c))}catch(o){console.error(k(o,A,_.EFFECT_EXECUTION_FAILED))}}execute(t=!1){if(this.flags&(S.DISPOSED|S.EXECUTING))return;if(!t){const c=this._links,a=c.length;if(a>0){let u=!1;for(let f=0;f<a;f++){const d=c[f],N=d.node;if(N.version!==d.version){u=!0;break}if("value"in N)try{if(Z(()=>N.value),N.version!==d.version){u=!0;break}}catch{u=!0;break}}if(!u)return}}const s=V;this._lastFlushEpoch!==s&&(this._lastFlushEpoch=s,this._executionsInEpoch=0),++this._executionsInEpoch>this._maxExecutionsPerFlush&&this._throwInfiniteLoopError("per-effect"),_t()>b.MAX_EXECUTIONS_PER_FLUSH&&this._throwInfiniteLoopError("global"),this._executionCount++;const n=this._history;if(n){const c=Date.now(),a=this._historyPtr;n[a]=c;const u=(a+1)%this._historyCapacity;this._historyPtr=u;const f=n[u]||0;if(f>0&&c-f<nt.ONE_SECOND_MS){const d=new A("Effect executed too frequently within 1 second. Suspected infinite loop.");if(this.dispose(),this._handleExecutionError(d),y)throw d;return}}if(this.flags|=S.EXECUTING,this._cleanup){try{this._cleanup()}catch(c){this._handleExecutionError(c,_.EFFECT_CLEANUP_FAILED)}this._cleanup=null}const r=this._links;if(r!==p)for(let c=0,a=r.length;c<a;c++){const u=r[c];u&&(u.node._tempUnsub=u.unsub)}const o=R.acquire();this._nextLinks=o,this._currentEpoch=W();let l=!1;try{const c=E.run(this,this._fn);this._links=o,l=!0,this._checkLoopWarnings();const a=++this._execId;et(c)?c.then(u=>{if(a!==this._execId||this.flags&S.DISPOSED){if(typeof u=="function")try{u()}catch(f){this._handleExecutionError(f,_.EFFECT_CLEANUP_FAILED)}return}typeof u=="function"&&(this._cleanup=u)}).catch(u=>{a===this._execId&&this._handleExecutionError(u)}):this._cleanup=typeof c=="function"?c:null}catch(c){l=!0,this._handleExecutionError(c),this._cleanup=null}finally{if(this._nextLinks=null,l){if(r!==p){for(let c=0,a=r.length;c<a;c++){const u=r[c],f=u?u.node._tempUnsub:void 0;f&&(f(),u&&(u.node._tempUnsub=void 0))}R.release(r)}}else{for(let c=0,a=o.length;c<a;c++){const u=o[c];u?.unsub&&u.unsub()}if(R.release(o),r!==p)for(let c=0,a=r.length;c<a;c++){const u=r[c];u&&(u.node._tempUnsub=void 0)}}this.flags&=-9}}get isDisposed(){return(this.flags&S.DISPOSED)!==0}get executionCount(){return this._executionCount}get isExecuting(){return(this.flags&S.EXECUTING)!==0}_throwInfiniteLoopError(t){const e=new A(`Infinite loop detected (${t}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${X}`);throw this.dispose(),console.error(e),e}_handleExecutionError(t,e=_.EFFECT_EXECUTION_FAILED){const s=k(t,A,e);console.error(s);const n=this._onError;if(n)try{n(s)}catch(r){console.error(k(r,A,_.CALLBACK_ERROR_IN_ERROR_HANDLER))}}_checkLoopWarnings(){if(this._trackModifications&&g.enabled){const t=this._links,e=this._currentEpoch;for(let s=0,n=t.length;s<n;s++){const o=t[s].node;o&&o._modifiedAtEpoch===e&&g.warn(!0,`Effect is reading a dependency (${g.getDebugName(o)||"unknown"}) that it just modified. Infinite loop may occur`)}}}}function Tt(i,t={}){if(typeof i!="function")throw new A(_.EFFECT_MUST_BE_FUNCTION);const e=new Nt(i,t);return e.execute(),e}function At(i){if(typeof i!="function")throw new O("Batch callback must be a function");U.startBatch();try{return i()}finally{U.endBatch()}}exports.AsyncState=F;exports.AtomError=O;exports.ComputedError=D;exports.DEBUG_CONFIG=G;exports.DEBUG_RUNTIME=g;exports.EffectError=A;exports.POOL_CONFIG=rt;exports.SCHEDULER_CONFIG=b;exports.SchedulerError=L;exports.atom=St;exports.batch=At;exports.computed=Ot;exports.effect=Tt;exports.isAtom=tt;exports.isComputed=Ct;exports.isEffect=bt;exports.scheduler=U;exports.untracked=Z;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const it={ONE_SECOND_MS:1e3},y={IDLE:"idle",PENDING:"pending",RESOLVED:"resolved",REJECTED:"rejected"},S={DISPOSED:1,HAS_FN_SUBS:2,HAS_OBJ_SUBS:4},f={...S,EXECUTING:8},o={...S,DIRTY:8,IDLE:16,PENDING:32,RESOLVED:64,REJECTED:128,RECOMPUTING:256,HAS_ERROR:512},E={...S,SYNC:8,NOTIFICATION_SCHEDULED:16},nt={MAX_SIZE:1e3,WARMUP_SIZE:100},p={MAX_EXECUTIONS_PER_SECOND:1e3,MAX_EXECUTIONS_PER_EFFECT:100,MAX_EXECUTIONS_PER_FLUSH:1e4,MAX_FLUSH_ITERATIONS:1e3,MIN_FLUSH_ITERATIONS:10,CLEANUP_THRESHOLD:1e3,BATCH_QUEUE_SHRINK_THRESHOLD:1e3},k={MAX_DEPENDENCIES:1e3,WARN_INFINITE_LOOP:!0},C=1073741823,u=typeof process<"u"&&process.env&&process.env.NODE_ENV!=="production"||typeof __DEV__<"u"&&!!__DEV__,rt=Object.freeze([]);class O extends Error{constructor(t,e=null,s=!0){super(t),this.cause=e,this.recoverable=s,this.timestamp=new Date,this.name="AtomError"}}class d extends O{constructor(t,e=null){super(t,e,!0),this.name="ComputedError"}}class I extends O{constructor(t,e=null){super(t,e,!1),this.name="EffectError"}}class A extends O{constructor(t,e=null){super(t,e,!1),this.name="SchedulerError"}}const G=Symbol("AtomEffect.DebugName"),ot=Symbol("AtomEffect.Id"),V=Symbol("AtomEffect.Type"),L=Symbol("AtomEffect.NoDefaultValue"),ht=i=>"dependencies"in i&&Array.isArray(i.dependencies);function Q(i,t,e){if(i===t)throw new d("Circular dependency detected: The computation refers to itself explicitly or implicitly.");if(!e.has(i.id)&&(e.add(i.id),ht(i))){const s=i.dependencies;for(let n=0;n<s.length;n++){const r=s[n];r&&Q(r,t,e)}}}const D={enabled:u,maxDependencies:k.MAX_DEPENDENCIES,warnInfiniteLoop:k.WARN_INFINITE_LOOP,warn(i,t){u&&this.enabled&&i&&console.warn(`[Atom Effect] ${t}`)},checkCircular(i,t){if(i===t)throw new d("Direct circular dependency detected");u&&this.enabled&&Q(i,t,new Set)},attachDebugInfo(i,t,e){if(!u||!this.enabled)return;const s=i;s[G]=`${t}_${e}`,s[ot]=e,s[V]=t},getDebugName:i=>i?.[G],getDebugType:i=>i?.[V]};let ct=1;const ut=()=>ct++;function q(i,t,e){if(typeof t=="function"){const n=t;for(let r=0,h=e.length;r<h;r++){const c=e[r];if(c&&c.fn===n)return}e.push(new P(n,void 0)),i.flags|=S.HAS_FN_SUBS,"_fnSubCount"in i&&i._fnSubCount++;return}if("addDependency"in t){t.addDependency(i);return}const s=t;for(let n=0,r=e.length;n<r;n++){const h=e[n];if(h&&h.sub===s)return}e.push(new P(void 0,s)),i.flags|=S.HAS_OBJ_SUBS,"_objSubCount"in i&&i._objSubCount++}function _t(i,t,e){for(let s=0,n=t.length;s<n;s++){const r=t[s];r&&(r.node._tempUnsub=r.unsub)}for(let s=0,n=i.length;s<n;s++){const r=i[s];if(!r)continue;const h=r.node;h._tempUnsub!==void 0?(r.unsub=h._tempUnsub,h._tempUnsub=void 0):(D.checkCircular(h,e),r.unsub=h.subscribe(e))}for(let s=0,n=t.length;s<n;s++){const r=t[s];if(r){const h=r.node;h._tempUnsub!==void 0&&(h._tempUnsub(),h._tempUnsub=void 0),r.unsub=void 0}}}class x{constructor(t,e,s=void 0){this.node=t,this.version=e,this.unsub=s}}class P{constructor(t,e){this.fn=t,this.sub=e}}const _={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",CALLBACK_ERROR_IN_ERROR_HANDLER:"Exception encountered in onError handler"};function N(i,t,e){if(i instanceof O)return i;const s=i instanceof Error,n=s?i.message:String(i),r=s?i:void 0;let h="Unexpected error";i instanceof TypeError?h="Type error":i instanceof ReferenceError&&(h="Reference error");const c=`${h} (${e}): ${n}`;return new t(c,r)}class J{constructor(){this.flags=0,this.version=0,this._lastSeenEpoch=-1,this._modifiedAtEpoch=-1,this.id=ut()&C,this._tempUnsub=void 0}}class $ extends J{constructor(){super(...arguments),this._fnSubCount=0,this._objSubCount=0}subscribe(t){const e=typeof t=="function";if(!e&&(!t||typeof t.execute!="function"))throw N(new TypeError("Invalid subscriber"),O,_.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);const s=this._subscribers;for(let r=0,h=s.length;r<h;r++){const c=s[r];if(c&&(e?c.fn===t:c.sub===t))return u&&console.warn("Duplicate subscription ignored."),()=>{}}const n=new P(e?t:void 0,e?void 0:t);return s.push(n),e?(this._fnSubCount++,this.flags|=S.HAS_FN_SUBS):(this._objSubCount++,this.flags|=S.HAS_OBJ_SUBS),()=>this._unsubscribe(n)}_unsubscribe(t){const e=this._subscribers,s=e.indexOf(t);if(s===-1)return;const n=e.pop();s<e.length&&n&&(e[s]=n),t.fn?this._fnSubCount--:this._objSubCount--,e.length===0?(this.flags&=-7,this._fnSubCount=0,this._objSubCount=0):t.fn&&this._fnSubCount<=0?(this.flags&=-3,this._fnSubCount=0):!t.fn&&this._objSubCount<=0&&(this.flags&=-5,this._objSubCount=0)}subscriberCount(){return this._subscribers.length}_notifySubscribers(t,e){if(!(this.flags&(S.HAS_FN_SUBS|S.HAS_OBJ_SUBS)))return;const s=this._subscribers,n=s.length;for(let r=0;r<n;r++){const h=s[r];if(h)try{h.fn?h.fn(t,e):h.sub&&h.sub.execute()}catch(c){this._handleNotifyError(c)}}}_handleNotifyError(t){console.error(N(t,O,_.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED))}}let m=0;const K=()=>(m=m+1&C||1,m),lt=()=>m;let M=0,v=0,R=!1;function z(){return R?(u&&console.warn("startFlush() called during flush - ignored"),!1):(R=!0,M=M+1&C||1,v=0,!0)}const X=()=>{R=!1},at=()=>R?++v:0,l={_queueBuffer:[[],[]],_bufferIndex:0,_size:0,_epoch:0,_isProcessing:!1,_isBatching:!1,_isFlushingSync:!1,_batchDepth:0,_batchQueue:[],_batchQueueSize:0,_maxFlushIterations:p.MAX_FLUSH_ITERATIONS,get phase(){return this._isProcessing||this._isFlushingSync?2:this._isBatching?1:0},get queueSize(){return this._size},get isBatching(){return this._isBatching},schedule(i){if(u&&typeof i!="function")throw new A("Scheduler callback must be a function");if(i._nextEpoch!==this._epoch){if(i._nextEpoch=this._epoch,this._isBatching||this._isFlushingSync){this._batchQueue[this._batchQueueSize++]=i;return}this._queueBuffer[this._bufferIndex][this._size++]=i,this._isProcessing||this._flush()}},_flush(){this._isProcessing||this._size===0||(this._isProcessing=!0,queueMicrotask(this._runLoop))},_runLoop:()=>{try{if(l._size===0)return;const i=z();l._drainQueue(),i&&X()}finally{l._isProcessing=!1,l._size>0&&!l._isBatching&&l._flush()}},_flushSync(){this._isFlushingSync=!0;const i=z();try{this._mergeBatchQueue(),this._drainQueue()}finally{this._isFlushingSync=!1,i&&X()}},_mergeBatchQueue(){if(this._batchQueueSize===0)return;const i=++this._epoch,t=this._batchQueue,e=this._queueBuffer[this._bufferIndex];let s=this._size;for(let n=0;n<this._batchQueueSize;n++){const r=t[n];r._nextEpoch!==i&&(r._nextEpoch=i,e[s++]=r)}this._size=s,this._batchQueueSize=0,t.length>p.BATCH_QUEUE_SHRINK_THRESHOLD&&(t.length=0)},_drainQueue(){let i=0;for(;this._size>0;){if(++i>this._maxFlushIterations){this._handleFlushOverflow();return}this._processQueue(),this._mergeBatchQueue()}},_processQueue(){const i=this._bufferIndex,t=this._queueBuffer[i],e=this._size;this._bufferIndex=i^1,this._size=0,this._epoch++;for(let s=0;s<e;s++)try{t[s]()}catch(n){console.error(new A("Error occurred during scheduler execution",n))}t.length=0},_handleFlushOverflow(){console.error(new A(`Maximum flush iterations (${this._maxFlushIterations}) exceeded. Possible infinite loop.`)),this._size=0,this._queueBuffer[this._bufferIndex].length=0,this._batchQueueSize=0},startBatch(){this._batchDepth++,this._isBatching=!0},endBatch(){if(this._batchDepth===0){u&&console.warn("endBatch() called without matching startBatch(). Ignoring.");return}--this._batchDepth===0&&(this._flushSync(),this._isBatching=!1)},setMaxFlushIterations(i){if(i<p.MIN_FLUSH_ITERATIONS)throw new A(`Max flush iterations must be at least ${p.MIN_FLUSH_ITERATIONS}`);this._maxFlushIterations=i}},b={current:null,run(i,t){const e=this.current;this.current=i;try{return t()}finally{this.current=e}}};function W(i){const t=b.current;if(t===null)return i();b.current=null;try{return i()}finally{b.current=t}}const ft=E.HAS_FN_SUBS|E.HAS_OBJ_SUBS;class Et extends ${constructor(t,e){super(),this._pendingOldValue=void 0,this._notifyTask=void 0,this._subscribers=[],this._value=t,e&&(this.flags|=E.SYNC),D.attachDebugInfo(this,"atom",this.id)}get value(){const t=b.current;return t&&q(this,t,this._subscribers),this._value}set value(t){const e=this._value;if(Object.is(e,t))return;this._value=t,this.version=this.version+1&C;const s=this.flags;if(!((s&ft)===0||s&E.NOTIFICATION_SCHEDULED)){if(this._pendingOldValue=e,this.flags=s|E.NOTIFICATION_SCHEDULED,s&E.SYNC&&!l.isBatching){this._flushNotifications();return}this._notifyTask||(this._notifyTask=()=>this._flushNotifications()),l.schedule(this._notifyTask)}}_flushNotifications(){const t=this.flags;if(!(t&E.NOTIFICATION_SCHEDULED)||t&E.DISPOSED)return;const e=this._pendingOldValue;this._pendingOldValue=void 0,this.flags&=-17,this._notifySubscribers(this._value,e)}peek(){return this._value}dispose(){this.flags&E.DISPOSED||(this._subscribers.length=0,this.flags|=E.DISPOSED,this._value=void 0,this._pendingOldValue=void 0,this._notifyTask=void 0)}}function dt(i,t={}){return new Et(i,t.sync??!1)}class St{constructor(t=50,e=256){this.limit=t,this.capacity=e,this.pool=[],this.stats=u?{acquired:0,released:0,rejected:{frozen:0,tooLarge:0,poolFull:0}}:null}acquire(){return u&&this.stats&&this.stats.acquired++,this.pool.pop()??[]}release(t,e){if(!(e&&t===e)){if(t.length>this.capacity){u&&this.stats&&this.stats.rejected.tooLarge++;return}if(this.pool.length>=this.limit){u&&this.stats&&this.stats.rejected.poolFull++;return}if(Object.isFrozen(t)){u&&this.stats&&this.stats.rejected.frozen++;return}t.length=0,this.pool.push(t),u&&this.stats&&this.stats.released++}}getStats(){if(!u||!this.stats)return null;const{acquired:t,released:e,rejected:s}=this.stats,n=t-e-(s.frozen+s.tooLarge+s.poolFull);return{acquired:t,released:e,rejected:{...s},leaked:n,poolSize:this.pool.length}}reset(){this.pool.length=0,u&&this.stats&&(this.stats={acquired:0,released:0,rejected:{frozen:0,tooLarge:0,poolFull:0}})}}const T=i=>Object.freeze(i);T([]);T([]);T([]);T([]);const a=T([]);T([]);const g=new St;function Z(i){return i!==null&&typeof i=="object"&&"value"in i&&typeof i.subscribe=="function"}function pt(i){return Z(i)&&typeof i.invalidate=="function"}function It(i){return i!==null&&typeof i=="object"&&typeof i.dispose=="function"&&typeof i.run=="function"}function tt(i){return i!==null&&typeof i=="object"&&typeof i.then=="function"}const et=o.RESOLVED|o.PENDING|o.REJECTED,U=Array(et+1).fill(y.IDLE);U[o.RESOLVED]=y.RESOLVED;U[o.PENDING]=y.PENDING;U[o.REJECTED]=y.REJECTED;const j=3,Y=Number.MAX_SAFE_INTEGER-1;class st extends ${constructor(t,e={}){if(typeof t!="function")throw new d(_.COMPUTED_MUST_BE_FUNCTION);if(super(),this._error=null,this._promiseId=0,this._subscribers=[],this._links=a,this._cachedErrors=null,this._errorCacheEpoch=-1,this._asyncStartAggregateVersion=0,this._asyncRetryCount=0,this._trackEpoch=-1,this._trackLinks=a,this._trackCount=0,this._value=void 0,this.flags=o.DIRTY|o.IDLE,this._equal=e.equal??Object.is,this._fn=t,this._defaultValue="defaultValue"in e?e.defaultValue:L,this._onError=e.onError??null,D.attachDebugInfo(this,"computed",this.id),e.lazy===!1)try{this._recompute()}catch{}}_track(){const t=b.current;t&&q(this,t,this._subscribers)}get value(){this._track();const t=this.flags;if((t&(o.RESOLVED|o.DIRTY|o.IDLE))===o.RESOLVED)return this._value;if(t&o.DISPOSED)throw new d(_.COMPUTED_DISPOSED);if(t&o.RECOMPUTING){if(this._defaultValue!==L)return this._defaultValue;throw new d(_.COMPUTED_CIRCULAR_DEPENDENCY)}if(t&(o.DIRTY|o.IDLE)&&(this._recompute(),this.flags&o.RESOLVED))return this._value;const e=this._defaultValue,s=e!==L;if(this.flags&o.PENDING){if(s)return e;throw new d(_.COMPUTED_ASYNC_PENDING_NO_DEFAULT)}if(this.flags&o.REJECTED){if(this._error?.recoverable&&s)return e;throw this._error}return this._value}peek(){return this._value}get state(){return this._track(),U[this.flags&et]}get hasError(){if(this._track(),this.flags&(o.REJECTED|o.HAS_ERROR))return!0;const t=this._links;for(let e=0,s=t.length;e<s;e++){const n=t[e]?.node;if(n&&n.flags&o.HAS_ERROR)return!0}return!1}get isValid(){return!this.hasError}get errors(){if(this._track(),!this.hasError)return rt;const t=lt();if(this._errorCacheEpoch===t&&this._cachedErrors)return this._cachedErrors;const e=new Set;this._error&&e.add(this._error);const s=this._links;for(let r=0,h=s.length;r<h;r++){const c=s[r].node;if(c.flags&o.HAS_ERROR){const w=c;if(w.errors){const B=w.errors;for(let F=0;F<B.length;F++){const H=B[F];H&&e.add(H)}}}}const n=Object.freeze(Array.from(e));return this._errorCacheEpoch=t,this._cachedErrors=n,n}get lastError(){return this._track(),this._error}get isPending(){return this._track(),(this.flags&o.PENDING)!==0}get isResolved(){return this._track(),(this.flags&o.RESOLVED)!==0}invalidate(){this._markDirty(),this._errorCacheEpoch=-1,this._cachedErrors=null}dispose(){if(this.flags&o.DISPOSED)return;const t=this._links;if(t!==a){for(let e=0,s=t.length;e<s;e++)t[e].unsub?.();g.release(t),this._links=a}this._subscribers.length=0,this.flags=o.DISPOSED|o.DIRTY|o.IDLE,this._error=null,this._value=void 0,this._promiseId=(this._promiseId+1)%Y,this._cachedErrors=null,this._errorCacheEpoch=-1}addDependency(t){if(t._lastSeenEpoch!==this._trackEpoch){if(t._lastSeenEpoch=this._trackEpoch,this._trackCount<this._trackLinks.length){const e=this._trackLinks[this._trackCount];e.node=t,e.version=t.version}else this._trackLinks.push(new x(t,t.version));this._trackCount++}}_commitDeps(t){this._trackLinks.length=this._trackCount,_t(this._trackLinks,t,this),this._links=this._trackLinks}_recompute(){if(this.flags&o.RECOMPUTING)return;this.flags|=o.RECOMPUTING;const t=this._links;this._trackEpoch=K(),this._trackLinks=g.acquire(),this._trackCount=0;let e=!1;try{const s=b.run(this,this._fn);this._commitDeps(t),e=!0,tt(s)?this._handleAsyncComputation(s):this._finalizeResolution(s)}catch(s){if(!e)try{this._commitDeps(t),e=!0}catch{}this._handleError(s,_.COMPUTED_COMPUTATION_FAILED,!0)}finally{e&&t!==a?g.release(t):e||g.release(this._trackLinks),this._trackEpoch=-1,this._trackLinks=a,this._trackCount=0,this.flags&=-257}}_handleAsyncComputation(t){this.flags=(this.flags|o.PENDING)&-217,this._notifySubscribers(void 0,void 0),this._asyncStartAggregateVersion=this._captureVersionSnapshot(),this._asyncRetryCount=0,this._promiseId=(this._promiseId+1)%Y;const e=this._promiseId;t.then(s=>{if(e===this._promiseId){if(this._captureVersionSnapshot()!==this._asyncStartAggregateVersion)return this._asyncRetryCount++<j?this._markDirty():this._handleError(new d(`Async drift threshold exceeded after ${j} retries.`),_.COMPUTED_ASYNC_COMPUTATION_FAILED);this._finalizeResolution(s),this._notifySubscribers(s,void 0)}},s=>e===this._promiseId&&this._handleError(s,_.COMPUTED_ASYNC_COMPUTATION_FAILED))}_captureVersionSnapshot(){let t=0;const e=this._links;for(let s=0,n=e.length;s<n;s++)t=((t<<5)-t|0)+e[s].node.version&C;return t}_handleError(t,e,s=!1){const n=N(t,d,e);if(!s&&!(this.flags&o.REJECTED)&&(this.version=this.version+1&C),this._error=n,this.flags=this.flags&-121|(o.REJECTED|o.HAS_ERROR),this._onError)try{this._onError(n)}catch(r){console.error(_.CALLBACK_ERROR_IN_ERROR_HANDLER,r)}if(s)throw n;this._notifySubscribers(void 0,void 0)}_finalizeResolution(t){(!(this.flags&o.RESOLVED)||!this._equal(this._value,t))&&(this.version=this.version+1&C),this._value=t,this._error=null,this.flags=(this.flags|o.RESOLVED)&-697,this._cachedErrors=null,this._errorCacheEpoch=-1}execute(){this._markDirty()}_markDirty(){this.flags&(o.RECOMPUTING|o.DIRTY)||(this.flags|=o.DIRTY,this._notifySubscribers(void 0,void 0))}}Object.freeze(st.prototype);function Dt(i,t={}){return new st(i,t)}class gt extends J{constructor(t,e={}){super(),this._cleanup=null,this._links=a,this._nextLinks=null,this._currentEpoch=-1,this._lastFlushEpoch=-1,this._executionsInEpoch=0,this._executionCount=0,this._historyPtr=0,this._execId=0,this._fn=t,this._onError=e.onError??null,this._sync=e.sync??!1,this._maxExecutions=e.maxExecutionsPerSecond??p.MAX_EXECUTIONS_PER_SECOND,this._maxExecutionsPerFlush=e.maxExecutionsPerFlush??p.MAX_EXECUTIONS_PER_EFFECT,this._trackModifications=e.trackModifications??!1;const s=Number.isFinite(this._maxExecutions),n=s?Math.min(this._maxExecutions+1,p.MAX_EXECUTIONS_PER_SECOND+1):0;this._historyCapacity=n,this._history=u&&s&&n>0?new Array(n).fill(0):null,D.attachDebugInfo(this,"effect",this.id)}run(){if(this.flags&f.DISPOSED)throw new I(_.EFFECT_DISPOSED);this.execute(!0)}dispose(){this.flags&f.DISPOSED||(this.flags|=f.DISPOSED,this._execCleanup(),this._releaseLinks(this._links),this._links=a,this._executeTask=void 0)}addDependency(t){if(!(this.flags&f.EXECUTING)||t._lastSeenEpoch===this._currentEpoch)return;t._lastSeenEpoch=this._currentEpoch;const e=this._nextLinks;if(t._tempUnsub){e.push(new x(t,t.version,t._tempUnsub)),t._tempUnsub=void 0;return}try{const s=t.subscribe(()=>{if(this._trackModifications&&this.flags&f.EXECUTING&&(t._modifiedAtEpoch=this._currentEpoch),this._sync)return this.execute();this._executeTask||(this._executeTask=()=>this.execute()),l.schedule(this._executeTask)});e.push(new x(t,t.version,s))}catch(s){console.error(N(s,I,_.EFFECT_EXECUTION_FAILED))}}execute(t=!1){if(this.flags&(f.DISPOSED|f.EXECUTING)||!t&&this._links.length>0&&!this._isDirty())return;this._checkInfiniteLoops(),this.flags|=f.EXECUTING,this._execCleanup();const e=this._links;if(e!==a)for(let r=0,h=e.length;r<h;r++){const c=e[r];c&&(c.node._tempUnsub=c.unsub)}const s=g.acquire();this._nextLinks=s,this._currentEpoch=K();let n=!1;try{const r=b.run(this,this._fn);this._links=s,n=!0,this._checkLoopWarnings(),tt(r)?this._handleAsyncResult(r):this._cleanup=typeof r=="function"?r:null}catch(r){n=!0,this._handleExecutionError(r),this._cleanup=null}finally{this._finalizeDependencies(n,e,s),this.flags&=-9}}_handleAsyncResult(t){const e=++this._execId;t.then(s=>{if(e!==this._execId||this.flags&f.DISPOSED){if(typeof s=="function")try{s()}catch(n){this._handleExecutionError(n,_.EFFECT_CLEANUP_FAILED)}return}typeof s=="function"&&(this._cleanup=s)},s=>e===this._execId&&this._handleExecutionError(s))}_finalizeDependencies(t,e,s){if(this._nextLinks=null,t){if(e!==a){for(let n=0,r=e.length;n<r;n++){const h=e[n],c=h?.node._tempUnsub;c&&(c(),h&&(h.node._tempUnsub=void 0))}g.release(e)}}else if(this._releaseLinks(s),g.release(s),e!==a)for(let n=0,r=e.length;n<r;n++)e[n]&&(e[n].node._tempUnsub=void 0)}_releaseLinks(t){if(t!==a){for(let e=0,s=t.length;e<s;e++)t[e]?.unsub?.();g.release(t)}}_isDirty(){const t=this._links;for(let e=0,s=t.length;e<s;e++){const n=t[e],r=n.node;if(r.version!==n.version)return!0;if("value"in r){try{W(()=>r.value)}catch{return!0}if(r.version!==n.version)return!0}}return!1}_execCleanup(){if(this._cleanup){try{this._cleanup()}catch(t){this._handleExecutionError(t,_.EFFECT_CLEANUP_FAILED)}this._cleanup=null}}_checkInfiniteLoops(){const t=M;if(this._lastFlushEpoch!==t&&(this._lastFlushEpoch=t,this._executionsInEpoch=0),++this._executionsInEpoch>this._maxExecutionsPerFlush&&this._throwInfiniteLoopError("per-effect"),at()>p.MAX_EXECUTIONS_PER_FLUSH&&this._throwInfiniteLoopError("global"),this._executionCount++,this._history){const e=Date.now();this._history[this._historyPtr]=e,this._historyPtr=(this._historyPtr+1)%this._historyCapacity;const s=this._history[this._historyPtr]||0;if(s>0&&e-s<it.ONE_SECOND_MS){const n=new I("Effect executed too frequently within 1 second. Suspected infinite loop.");if(this.dispose(),this._handleExecutionError(n),u)throw n}}}get isDisposed(){return(this.flags&f.DISPOSED)!==0}get executionCount(){return this._executionCount}get isExecuting(){return(this.flags&f.EXECUTING)!==0}_throwInfiniteLoopError(t){const e=new I(`Infinite loop detected (${t}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${v}`);throw this.dispose(),console.error(e),e}_handleExecutionError(t,e=_.EFFECT_EXECUTION_FAILED){const s=N(t,I,e);if(console.error(s),this._onError)try{this._onError(s)}catch(n){console.error(N(n,I,_.CALLBACK_ERROR_IN_ERROR_HANDLER))}}_checkLoopWarnings(){if(this._trackModifications&&D.enabled){const t=this._currentEpoch,e=this._links;for(let s=0,n=e.length;s<n;s++){const r=e[s].node;r._modifiedAtEpoch===t&&D.warn(!0,`Effect is reading a dependency (${D.getDebugName(r)||"unknown"}) that it just modified. Infinite loop may occur`)}}}}function Ct(i,t={}){if(typeof i!="function")throw new I(_.EFFECT_MUST_BE_FUNCTION);const e=new gt(i,t);return e.execute(),e}function bt(i){if(typeof i!="function")throw new TypeError("Batch callback must be a function");l.startBatch();try{return i()}finally{l.endBatch()}}exports.AsyncState=y;exports.AtomError=O;exports.ComputedError=d;exports.DEBUG_CONFIG=k;exports.DEBUG_RUNTIME=D;exports.EffectError=I;exports.POOL_CONFIG=nt;exports.SCHEDULER_CONFIG=p;exports.SchedulerError=A;exports.atom=dt;exports.batch=bt;exports.computed=Dt;exports.effect=Ct;exports.isAtom=Z;exports.isComputed=pt;exports.isEffect=It;exports.scheduler=l;exports.untracked=W;
 //# sourceMappingURL=index.cjs.map