@but212/atom-effect 0.15.2 → 0.15.4

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/errors/messages.ts","../src/utils/debug.ts","../src/core/base.ts","../src/utils/array-pool.ts","../src/internal/pool.ts","../src/core/dep-tracking.ts","../src/internal/epoch.ts","../src/internal/scheduler.ts","../src/tracking/context.ts","../src/tracking/untracked.ts","../src/core/atom.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","/**\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 subscribe() receives an invalid listener.\n   */\n  COMPUTED_SUBSCRIBER_MUST_BE_FUNCTION:\n    'Subscriber listener must be a function or Subscriber object',\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 subscribing to a dependency fails.\n   */\n  COMPUTED_DEPENDENCY_SUBSCRIPTION_FAILED: 'Failed to subscribe to dependency',\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 thrown when the atom subscriber notification process fails.\n   */\n  ATOM_SUBSCRIBER_EXECUTION_FAILED: 'Error occurred while executing atom subscribers',\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   * Warning logged when attempting to unsubscribe a non-existent listener.\n   */\n  UNSUBSCRIBE_NON_EXISTENT: 'Attempted to unsubscribe a non-existent listener',\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 { 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\nlet globalCheckEpoch = 0;\n\n/** Internal recursive checker for circular dependency detection */\nfunction checkCircularInternal(dep: Dependency, current: object, epoch: number): void {\n  if (dep._visitedEpoch === epoch) {\n    return;\n  }\n  dep._visitedEpoch = epoch;\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, epoch);\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    globalCheckEpoch++;\n    checkCircularInternal(dep, current, globalCheckEpoch);\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 { IS_DEV, NODE_FLAGS, SMI_MAX } from '@/constants';\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  /** Epoch used for circular dependency detection and graph traversal */\n  _visitedEpoch: 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    // Group numeric field initializations to establish a stable Hidden Class (Shape) for V8.\n    // Consistent initialization order prevents shape transitions, optimizing property access.\n    this.flags = 0;\n    this.version = 0;\n    this._lastSeenEpoch = -1;\n    this._modifiedAtEpoch = -1;\n    this._visitedEpoch = -1;\n    this.id = (generateId() & SMI_MAX) as DependencyId;\n\n    this._tempUnsub = undefined;\n  }\n\n  /**\n   * Calculates the logical distance (shift) between current and cached version.\n   */\n  getShift(cachedVersion: number): number {\n    return (this.version - cachedVersion) & SMI_MAX;\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 _fnSubs: ((newValue?: T, oldValue?: T) => void)[];\n  protected abstract _objSubs: Subscriber[];\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    // Optimization: Prioritize function listeners as they are the most common case\n    if (typeof listener === 'function') {\n      return this._addSubscriber(\n        this._fnSubs,\n        listener as (newValue?: T, oldValue?: T) => void,\n        NODE_FLAGS.HAS_FN_SUBS\n      );\n    }\n\n    // Guard: Ensure listener is a valid non-null object before checking 'execute' property\n    if (listener !== null && typeof listener === 'object' && 'execute' in listener) {\n      return this._addSubscriber(this._objSubs, listener as Subscriber, NODE_FLAGS.HAS_OBJ_SUBS);\n    }\n\n    throw new AtomError(ERROR_MESSAGES.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);\n  }\n\n  /**\n   * Gets the total number of active subscribers.\n   */\n  subscriberCount(): number {\n    return this._fnSubs.length + this._objSubs.length;\n  }\n\n  /**\n   * Adds a subscriber to the specified subscription list and returns an unsubscribe function.\n   * Uses swap-and-pop for efficient removals.\n   */\n  private _addSubscriber<S>(subs: S[], subscriber: S, flag: number): () => void {\n    const idx = subs.indexOf(subscriber);\n    if (idx !== -1) {\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    subs.push(subscriber);\n    this.flags |= flag;\n\n    let unsubscribed = false;\n    return () => {\n      if (unsubscribed) return;\n      unsubscribed = true;\n\n      const currentIdx = subs.indexOf(subscriber);\n      if (currentIdx !== -1) {\n        const last = subs.pop()!;\n        if (currentIdx < subs.length) {\n          subs[currentIdx] = last;\n        }\n        this.flags &= ~(subs.length === 0 ? flag : 0);\n      }\n    };\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    const subMask = NODE_FLAGS.HAS_FN_SUBS | NODE_FLAGS.HAS_OBJ_SUBS;\n\n    if (!(flags & subMask)) return;\n\n    if (flags & NODE_FLAGS.HAS_FN_SUBS) {\n      const subs = this._fnSubs;\n      for (let i = 0, len = subs.length; i < len; i++) {\n        const sub = subs[i];\n        if (sub) {\n          try {\n            sub(newValue, oldValue);\n          } catch (err) {\n            console.error(\n              new AtomError(ERROR_MESSAGES.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, err as Error)\n            );\n          }\n        }\n      }\n    }\n\n    if (flags & NODE_FLAGS.HAS_OBJ_SUBS) {\n      const subs = this._objSubs;\n      for (let i = 0, len = subs.length; i < len; i++) {\n        const sub = subs[i];\n        if (sub) {\n          try {\n            sub.execute();\n          } catch (err) {\n            console.error(\n              new AtomError(ERROR_MESSAGES.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, err as Error)\n            );\n          }\n        }\n      }\n    }\n  }\n}\n","import { IS_DEV } from '@/constants';\nimport type { PoolStats } from '@/types';\n\n/** @internal */\nclass PoolStatsCollector {\n  acquired = 0;\n  released = 0;\n  rejected = new PoolStatsRejected();\n}\n\n/** @internal */\nclass PoolStatsRejected {\n  frozen = 0;\n  tooLarge = 0;\n  poolFull = 0;\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 (IS_DEV && 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    // 1. Skip if empty constant or frozen (expensive check)\n    if ((emptyConst && arr === emptyConst) || Object.isFrozen(arr)) {\n      const stats = this.stats;\n      if (IS_DEV && stats && arr !== emptyConst) stats.rejected.frozen++;\n      return;\n    }\n\n    // 2. Reject based on capacity or pool size\n    const len = arr.length;\n    const pool = this.pool;\n    const poolLen = pool.length;\n\n    if (len > this.maxReusableCapacity || poolLen >= this.maxPoolSize) {\n      const stats = this.stats;\n      if (IS_DEV && stats) {\n        if (len > this.maxReusableCapacity) stats.rejected.tooLarge++;\n        else stats.rejected.poolFull++;\n      }\n      return;\n    }\n\n    // 3. Clear and store\n    arr.length = 0;\n    pool.push(arr);\n    const stats = this.stats;\n    if (IS_DEV && 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 (!IS_DEV || !stats) return null;\n    const { acquired, released, rejected } = stats;\n    const totalRejected = rejected.frozen + rejected.tooLarge + rejected.poolFull;\n    return {\n      acquired,\n      released,\n      rejected: {\n        frozen: rejected.frozen,\n        tooLarge: rejected.tooLarge,\n        poolFull: rejected.poolFull,\n      },\n      leaked: acquired - released - totalRejected,\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 (IS_DEV && 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 { 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)[];\n\nexport const EMPTY_VERSIONS = Object.freeze([]) as unknown as number[];\n\n// Per-type Pool Instances (V8 Shape Optimization)\nexport const depArrayPool = new ArrayPool<Dependency>();\nexport const subArrayPool = new ArrayPool<Subscriber>();\nexport const unsubArrayPool = new ArrayPool<() => void>();\nexport const versionArrayPool = new ArrayPool<number>();\n","import { NODE_FLAGS } from '@/constants';\nimport { EMPTY_DEPS, EMPTY_UNSUBS, unsubArrayPool } from '@/internal/pool';\nimport type { DependencySubscriber } from '@/tracking/tracking.types';\nimport type { Dependency, Subscriber } from '@/types';\nimport { debug } from '@/utils/debug';\n\nexport function trackDependency<T>(\n  dependency: Dependency,\n  current: unknown,\n  functionSubscribers: ((newValue?: T, oldValue?: T) => void)[],\n  objectSubscribers: Subscriber[]\n): void {\n  if (current === null || current === undefined) return;\n\n  // Inlined from hasDependencyMethod to avoid call overhead\n  if (\n    (typeof current === 'object' || typeof current === 'function') &&\n    typeof (current as DependencySubscriber).addDependency === 'function'\n  ) {\n    (current as DependencySubscriber).addDependency(dependency);\n    return;\n  }\n\n  if (typeof current === 'function') {\n    const subscriber = current as (newValue?: T, oldValue?: T) => void;\n    // O(N) check - typically small N\n    if (functionSubscribers.indexOf(subscriber) === -1) {\n      functionSubscribers.push(subscriber);\n      dependency.flags |= NODE_FLAGS.HAS_FN_SUBS;\n    }\n    return;\n  }\n\n  // Inlined from hasExecuteMethod\n  if (typeof current === 'object' && typeof (current as Subscriber).execute === 'function') {\n    if (objectSubscribers.indexOf(current as Subscriber) === -1) {\n      objectSubscribers.push(current as Subscriber);\n      dependency.flags |= NODE_FLAGS.HAS_OBJ_SUBS;\n    }\n  }\n}\n\n/**\n * Synchronizes subscriptions using an O(N) strategy optimized for cache locality.\n */\nexport function syncDependencies(\n  nextDeps: Dependency[],\n  prevDeps: Dependency[],\n  prevUnsubs: (() => void)[],\n  tracker: Subscriber\n): (() => void)[] {\n  const nextLen = nextDeps.length;\n  const prevLen = prevDeps.length;\n  const hasPrev = prevDeps !== EMPTY_DEPS && prevLen > 0;\n\n  // 1. Initial dense pass: map existing unsubs to dependencies\n  if (hasPrev) {\n    for (let i = 0; i < prevLen; i++) {\n      const dep = prevDeps[i];\n      if (dep) dep._tempUnsub = prevUnsubs[i];\n    }\n  }\n\n  // 2. Build new unsubs array: reuse or subscribe\n  const nextUnsubs = unsubArrayPool.acquire();\n  nextUnsubs.length = nextLen;\n\n  for (let i = 0; i < nextLen; i++) {\n    const dep = nextDeps[i];\n    if (!dep) continue;\n\n    const reuse = dep._tempUnsub;\n    if (reuse) {\n      nextUnsubs[i] = reuse;\n      dep._tempUnsub = undefined;\n    } else {\n      // Keep checkCircular outside debug.enabled guard if tests rely on global spying\n      debug.checkCircular(dep, tracker);\n      nextUnsubs[i] = dep.subscribe(tracker);\n    }\n  }\n\n  // 3. Final cleanup pass: unsubscribe stale dependencies\n  if (hasPrev) {\n    for (let i = 0; i < prevLen; i++) {\n      const dep = prevDeps[i];\n      if (dep) {\n        const unsub = dep._tempUnsub;\n        if (unsub) {\n          unsub();\n          dep._tempUnsub = undefined;\n        }\n      }\n    }\n  }\n\n  if (prevUnsubs !== EMPTY_UNSUBS) {\n    unsubArrayPool.release(prevUnsubs);\n  }\n\n  return nextUnsubs;\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\n// === Infinite Loop Detection State ===\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 _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    this._queueBuffer[this._bufferIndex]![this._size++] = callback;\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 queue = this.batchQueue;\n    const targetQueue = this._queueBuffer[this._bufferIndex];\n    let targetSize = this._size;\n\n    for (let i = 0; i < size; i++) {\n      const job = queue[i]!;\n      if (job._nextEpoch !== epoch) {\n        job._nextEpoch = epoch;\n        targetQueue![targetSize++] = job;\n      }\n    }\n\n    this._size = targetSize;\n    this.batchQueueSize = 0;\n    if (queue.length > SCHEDULER_CONFIG.BATCH_QUEUE_SHRINK_THRESHOLD) queue.length = 0;\n  }\n\n  private _drainQueue(): void {\n    let iterations = 0;\n    const maxIterations = this.maxFlushIterations;\n\n    while (this._size > 0) {\n      if (++iterations > maxIterations) {\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    const nextIndex = index ^ 1;\n    this._bufferIndex = nextIndex;\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        jobs[i]!();\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    if (this.batchDepth === 0) {\n      if (IS_DEV) {\n        console.warn('endBatch() called without matching startBatch(). Ignoring.');\n      }\n      return;\n    }\n    this.batchDepth--;\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    }\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.\n *\n * This utility allows reading atom values without establishing\n * a dependency relationship, useful for accessing values that\n * shouldn't trigger recomputation when they change.\n *\n * @template T - The return type of the function\n * @param fn - The function to execute without tracking\n * @returns The result of the executed function\n * @throws {AtomError} If the callback is not a function\n * @throws Propagates any error thrown by the callback function\n *\n * @example\n * ```typescript\n * const count = atom(0);\n * const doubled = computed(() => {\n *   // This read will NOT be tracked as a dependency\n *   const untrackedValue = untracked(() => count.value);\n *   return untrackedValue * 2;\n * });\n * ```\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 { trackDependency } from '@/core/dep-tracking';\nimport { scheduler } from '@/internal/scheduler';\nimport { trackingContext } from '@/tracking';\nimport type { AtomOptions, Subscriber, 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 _fnSubs: ((newValue?: T, oldValue?: T) => void)[];\n  protected _objSubs: Subscriber[];\n\n  constructor(initialValue: T, sync: boolean) {\n    super();\n    this._value = initialValue;\n    this._pendingOldValue = undefined;\n    this._notifyTask = undefined;\n    this._fnSubs = [];\n    this._objSubs = [];\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._fnSubs, this._objSubs);\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    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    const subMask = ATOM_STATE_FLAGS.HAS_FN_SUBS | ATOM_STATE_FLAGS.HAS_OBJ_SUBS;\n    if (flags & subMask) {\n      this._scheduleNotification(oldValue);\n    }\n  }\n\n  /**\n   * Schedules or flushes notifications based on sync mode and batching state.\n   */\n  private _scheduleNotification(oldValue: T): void {\n    let flags = this.flags;\n\n    if (!(flags & ATOM_STATE_FLAGS.NOTIFICATION_SCHEDULED)) {\n      this._pendingOldValue = oldValue;\n      this.flags = flags |= ATOM_STATE_FLAGS.NOTIFICATION_SCHEDULED;\n    }\n\n    if (flags & ATOM_STATE_FLAGS.SYNC && !scheduler.isBatching) {\n      this._flushNotifications();\n      return;\n    }\n\n    let task = this._notifyTask;\n    if (!task) {\n      task = this._notifyTask = () => this._flushNotifications();\n    }\n    scheduler.schedule(task);\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    if (!(flags & ATOM_STATE_FLAGS.NOTIFICATION_SCHEDULED) || flags & ATOM_STATE_FLAGS.DISPOSED) {\n      return;\n    }\n\n    const oldValue = this._pendingOldValue as T;\n    const newValue = this._value;\n\n    this._pendingOldValue = undefined;\n    this.flags &= ~ATOM_STATE_FLAGS.NOTIFICATION_SCHEDULED;\n\n    this._notifySubscribers(newValue, 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    if (this.flags & ATOM_STATE_FLAGS.DISPOSED) {\n      return;\n    }\n\n    this._fnSubs = [];\n    this._objSubs = [];\n    this.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 { 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 {\n  DependencySubscriber,\n  ExecutableSubscriber,\n  TrackableFunction,\n} from '@/tracking/tracking.types';\nimport 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    'subscribe' in obj &&\n    typeof (obj as Record<string, 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    const debugType = debug.getDebugType(obj);\n    if (debugType) {\n      return debugType === 'computed';\n    }\n  }\n  return (\n    isAtom(obj) &&\n    'invalidate' in obj &&\n    typeof (obj as Record<string, unknown>).invalidate === 'function'\n  );\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    'dispose' in obj &&\n    'run' in obj &&\n    typeof (obj as Record<string, unknown>).dispose === 'function' &&\n    typeof (obj as Record<string, unknown>).run === 'function'\n  );\n}\n\n/**\n * Type guard to check if a value is a Promise\n *\n * Uses duck-typing to detect Promise-like objects by checking for\n * the presence of a `then` method.\n *\n * @template T - The type the Promise resolves to\n * @param value - Value to check\n * @returns True if value has a `then` method (is Promise-like)\n */\nexport function isPromise<T>(value: unknown): value is Promise<T> {\n  return value != null && typeof (value as { then?: unknown }).then === 'function';\n}\n\n/** Internal guard to verify if a value is a non-null object. */\nfunction isNonNullObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null;\n}\n\n/** Checks if the value implements the {@link DependencySubscriber} interface. */\nexport function hasDependencyMethod(value: unknown): value is DependencySubscriber {\n  return (\n    (typeof value === 'object' || typeof value === 'function') &&\n    value !== null &&\n    typeof (value as DependencySubscriber).addDependency === 'function'\n  );\n}\n\n/** Checks if the value is a function with an `addDependency` method. */\nexport function isTrackableFunction(\n  value: unknown\n): value is TrackableFunction & DependencySubscriber {\n  return (\n    typeof value === 'function' && typeof (value as TrackableFunction).addDependency === 'function'\n  );\n}\n\n/** Checks if the value is a plain function without dependency tracking capabilities. */\nexport function isPlainListener(value: unknown): value is () => void {\n  return (\n    typeof value === 'function' && typeof (value as TrackableFunction).addDependency !== 'function'\n  );\n}\n\n/** Checks if the value implements the {@link ExecutableSubscriber} interface. */\nexport function hasExecuteMethod(value: unknown): value is ExecutableSubscriber {\n  return isNonNullObject(value) && typeof value.execute === 'function';\n}\n","import { AsyncState, COMPUTED_STATE_FLAGS, EMPTY_ERROR_ARRAY, SMI_MAX } from '@/constants';\nimport { ReactiveDependency } from '@/core/base';\nimport { syncDependencies, trackDependency } 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 {\n  depArrayPool,\n  EMPTY_DEPS,\n  EMPTY_UNSUBS,\n  EMPTY_VERSIONS,\n  unsubArrayPool,\n  versionArrayPool,\n} from '@/internal/pool';\nimport { trackingContext } from '@/tracking';\n\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\n/**\n * Internal helper for stable Hidden Class in V8\n * @internal\n */\nclass ComputedTrackable<T> implements Subscriber {\n  _epoch: number;\n  _nextDeps: Dependency[];\n  _nextVersions: number[];\n  _depCount: number;\n\n  constructor(private readonly _owner: ComputedAtomImpl<T>) {\n    this._epoch = -1;\n    this._nextDeps = EMPTY_DEPS;\n    this._nextVersions = EMPTY_VERSIONS;\n    this._depCount = 0;\n  }\n\n  execute(): void {\n    this._owner._markDirty();\n  }\n\n  addDependency(dep: Dependency): void {\n    if (dep._lastSeenEpoch === this._epoch) {\n      return;\n    }\n    dep._lastSeenEpoch = this._epoch;\n\n    const count = this._depCount;\n    const deps = this._nextDeps;\n    const versions = this._nextVersions;\n\n    if (count < deps.length) {\n      deps[count] = dep;\n      versions[count] = dep.version;\n    } else {\n      deps.push(dep);\n      versions.push(dep.version);\n    }\n    this._depCount = count + 1;\n  }\n\n  reset(): void {\n    this._epoch = -1;\n    this._nextDeps = EMPTY_DEPS;\n    this._nextVersions = EMPTY_VERSIONS;\n    this._depCount = 0;\n  }\n}\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 _hasDefaultValue: boolean;\n  private readonly _onError: ((error: Error) => void) | null;\n\n  protected _fnSubs: ((newValue?: T, oldValue?: T) => void)[];\n  protected _objSubs: Subscriber[];\n\n  private _dependencies: Dependency[];\n  private _dependencyVersions: number[];\n  private _unsubscribes: (() => void)[];\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  private readonly MAX_ASYNC_RETRIES: number = 3;\n\n  private readonly _trackable: ComputedTrackable<T>;\n  private readonly MAX_PROMISE_ID: 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    // V8 Hidden Class Stability: Group property initializations\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._hasDefaultValue = this._defaultValue !== (NO_DEFAULT_VALUE as T);\n    this._onError = options.onError ?? null;\n    this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1;\n\n    this._fnSubs = [];\n    this._objSubs = [];\n    this._dependencies = EMPTY_DEPS;\n    this._dependencyVersions = EMPTY_VERSIONS;\n    this._unsubscribes = EMPTY_UNSUBS;\n\n    this._cachedErrors = null;\n    this._errorCacheEpoch = -1;\n    this._asyncStartAggregateVersion = 0;\n    this._asyncRetryCount = 0;\n\n    this._trackable = new ComputedTrackable(this);\n\n    debug.attachDebugInfo(this as unknown as ComputedAtom<T>, 'computed', this.id);\n\n    if (debug.enabled) {\n      const debugObj = this as unknown as ComputedAtom<T> & {\n        subscriberCount: () => number;\n        isDirty: () => boolean;\n        dependencies: Dependency[];\n        stateFlags: string;\n      };\n      debugObj.subscriberCount = this.subscriberCount.bind(this);\n      debugObj.isDirty = () => (this.flags & COMPUTED_STATE_FLAGS.DIRTY) !== 0;\n      debugObj.dependencies = this._dependencies;\n      debugObj.stateFlags = ''; // Settable via getter logic if needed\n    }\n\n    if (options.lazy === false) {\n      try {\n        this._recompute();\n      } catch {\n        // Ignore initial computation failure\n      }\n    }\n  }\n\n  get value(): T {\n    const current = trackingContext.current;\n    if (current) trackDependency(this, current, this._fnSubs, this._objSubs);\n\n    const flags = this.flags;\n    if (flags & COMPUTED_STATE_FLAGS.RECOMPUTING) {\n      // Circular dependency detected: computation is accessing itself during recompute.\n      // Return default value if available, otherwise throw.\n      if (this._hasDefaultValue) return this._defaultValue;\n      throw new ComputedError(ERROR_MESSAGES.COMPUTED_CIRCULAR_DEPENDENCY);\n    }\n    if (flags & (COMPUTED_STATE_FLAGS.DIRTY | COMPUTED_STATE_FLAGS.IDLE)) this._recompute();\n\n    const currentFlags = this.flags;\n    if (currentFlags & COMPUTED_STATE_FLAGS.PENDING) return this._handlePending();\n    if (currentFlags & COMPUTED_STATE_FLAGS.REJECTED) return this._handleRejected();\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._fnSubs, this._objSubs);\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._fnSubs, this._objSubs);\n\n    const flags = this.flags;\n    if (flags & (COMPUTED_STATE_FLAGS.REJECTED | COMPUTED_STATE_FLAGS.HAS_ERROR)) return true;\n\n    const deps = this._dependencies;\n    for (let i = 0, len = deps.length; i < len; i++) {\n      const dep = deps[i];\n      if (dep && dep.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._fnSubs, this._objSubs);\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    if (this._error) errorSet.add(this._error);\n\n    const deps = this._dependencies;\n    for (let i = 0, len = deps.length; i < len; i++) {\n      const dep = deps[i];\n      if (dep && 'errors' in dep) {\n        const depErrors = (dep as unknown as ComputedAtom<unknown>).errors;\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    const result = Object.freeze([...errorSet]);\n    this._cachedErrors = result;\n    this._errorCacheEpoch = epoch;\n    return result;\n  }\n\n  get lastError(): Error | null {\n    const current = trackingContext.current;\n    if (current) trackDependency(this, current, this._fnSubs, this._objSubs);\n    return this._error;\n  }\n\n  get isPending(): boolean {\n    const current = trackingContext.current;\n    if (current) trackDependency(this, current, this._fnSubs, this._objSubs);\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._fnSubs, this._objSubs);\n    return (this.flags & COMPUTED_STATE_FLAGS.RESOLVED) !== 0;\n  }\n\n  invalidate(): void {\n    this._markDirty();\n    const versions = this._dependencyVersions;\n    if (versions !== EMPTY_VERSIONS) {\n      versionArrayPool.release(versions);\n      this._dependencyVersions = EMPTY_VERSIONS;\n    }\n    this._errorCacheEpoch = -1;\n    this._cachedErrors = null;\n  }\n\n  dispose(): void {\n    const unsubs = this._unsubscribes;\n    if (unsubs !== EMPTY_UNSUBS) {\n      for (let i = 0, len = unsubs.length; i < len; i++) {\n        const unsub = unsubs[i];\n        if (unsub) unsub();\n      }\n      unsubArrayPool.release(unsubs);\n      this._unsubscribes = EMPTY_UNSUBS;\n    }\n\n    const deps = this._dependencies;\n    if (deps !== EMPTY_DEPS) {\n      depArrayPool.release(deps);\n      this._dependencies = EMPTY_DEPS;\n    }\n\n    const versions = this._dependencyVersions;\n    if (versions !== EMPTY_VERSIONS) {\n      versionArrayPool.release(versions);\n      this._dependencyVersions = EMPTY_VERSIONS;\n    }\n\n    this._fnSubs = [];\n    this._objSubs = [];\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) % this.MAX_PROMISE_ID;\n    this._cachedErrors = null;\n    this._errorCacheEpoch = -1;\n  }\n\n  private _clearDirty(): void {\n    this.flags &= ~COMPUTED_STATE_FLAGS.DIRTY;\n  }\n\n  private _setPending(): void {\n    this.flags =\n      (this.flags | COMPUTED_STATE_FLAGS.PENDING) &\n      ~(COMPUTED_STATE_FLAGS.IDLE | COMPUTED_STATE_FLAGS.RESOLVED | COMPUTED_STATE_FLAGS.REJECTED);\n  }\n\n  private _isResolved(): boolean {\n    return (this.flags & COMPUTED_STATE_FLAGS.RESOLVED) !== 0;\n  }\n\n  private _setResolved(): void {\n    this.flags =\n      (this.flags | COMPUTED_STATE_FLAGS.RESOLVED) &\n      ~(\n        COMPUTED_STATE_FLAGS.IDLE |\n        COMPUTED_STATE_FLAGS.PENDING |\n        COMPUTED_STATE_FLAGS.REJECTED |\n        COMPUTED_STATE_FLAGS.HAS_ERROR\n      );\n  }\n\n  private _isRejected(): boolean {\n    return (this.flags & COMPUTED_STATE_FLAGS.REJECTED) !== 0;\n  }\n\n  private _setRejected(): void {\n    const mask =\n      COMPUTED_STATE_FLAGS.IDLE | COMPUTED_STATE_FLAGS.PENDING | COMPUTED_STATE_FLAGS.RESOLVED;\n    this.flags =\n      (this.flags & ~mask) | (COMPUTED_STATE_FLAGS.REJECTED | COMPUTED_STATE_FLAGS.HAS_ERROR);\n  }\n\n  private _setRecomputing(value: boolean): void {\n    const mask = COMPUTED_STATE_FLAGS.RECOMPUTING;\n    this.flags = (this.flags & ~mask) | ((value ? -1 : 0) & mask);\n  }\n\n  private _recompute(): void {\n    if (this.flags & COMPUTED_STATE_FLAGS.RECOMPUTING) {\n      return;\n    }\n\n    this._setRecomputing(true);\n\n    const trackable = this._trackable;\n    const prevDeps = this._dependencies;\n    const prevVersions = this._dependencyVersions;\n\n    trackable._epoch = nextEpoch();\n    trackable._nextDeps = depArrayPool.acquire();\n    trackable._nextVersions = versionArrayPool.acquire();\n    trackable._depCount = 0;\n\n    let committed = false;\n\n    try {\n      const result = trackingContext.run(trackable, this._fn);\n\n      // Commit Dependencies\n      const nextDeps = trackable._nextDeps;\n      const nextVersions = trackable._nextVersions;\n      const depCount = trackable._depCount;\n\n      nextDeps.length = depCount;\n      nextVersions.length = depCount;\n\n      this._unsubscribes = syncDependencies(nextDeps, prevDeps, this._unsubscribes, this);\n      this._dependencies = nextDeps;\n      this._dependencyVersions = nextVersions;\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        // Fallback commit for partial success/circular detection\n        try {\n          const nextDeps = trackable._nextDeps;\n          const nextVersions = trackable._nextVersions;\n          const depCount = trackable._depCount;\n          nextDeps.length = depCount;\n          nextVersions.length = depCount;\n          this._unsubscribes = syncDependencies(nextDeps, prevDeps, this._unsubscribes, this);\n          this._dependencies = nextDeps;\n          this._dependencyVersions = nextVersions;\n          committed = true;\n        } catch (commitErr) {\n          err = commitErr as Error;\n        }\n      }\n      this._handleComputationError(err);\n    } finally {\n      // Cleanup Trackable\n      if (committed) {\n        if (prevDeps !== EMPTY_DEPS) depArrayPool.release(prevDeps);\n        if (prevVersions !== EMPTY_VERSIONS) versionArrayPool.release(prevVersions);\n      } else {\n        depArrayPool.release(trackable._nextDeps);\n        versionArrayPool.release(trackable._nextVersions);\n      }\n      trackable.reset();\n      this._setRecomputing(false);\n    }\n  }\n\n  private _handleAsyncComputation(promise: Promise<T>): void {\n    this._setPending();\n    this._clearDirty();\n    this._notifySubscribers(undefined, undefined);\n\n    this._asyncStartAggregateVersion = this._captureVersionSnapshot();\n    this._asyncRetryCount = 0;\n\n    this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID;\n    const promiseId = this._promiseId;\n\n    promise\n      .then((resolvedValue) => {\n        if (promiseId !== this._promiseId) return;\n\n        // Drift detection: Compare aggregate dependency versions to detect changes during async.\n        // High drift indicates dependencies changed while awaiting; re-computation may be needed.\n        const currentAggregate = this._captureVersionSnapshot();\n        const isStale = currentAggregate !== this._asyncStartAggregateVersion;\n\n        if (isStale) {\n          if (this._asyncRetryCount < this.MAX_ASYNC_RETRIES) {\n            this._asyncRetryCount++;\n            this._markDirty();\n            return;\n          }\n          const error = new ComputedError(\n            `Async drift exceeded threshold after ${this.MAX_ASYNC_RETRIES} retries.`\n          );\n          this._handleAsyncRejection(error);\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 deps = this._dependencies;\n    for (let i = 0, len = deps.length; i < len; i++) {\n      const dep = deps[i];\n      if (dep) {\n        const v = dep.version;\n        // Use a simple mixing to reduce collisions: (hash << 5) - hash + v\n        // This is more robust than simple addition or XOR alone.\n        aggregate = ((((aggregate << 5) - aggregate) | 0) + v) & SMI_MAX;\n      }\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._setRejected();\n    this._clearDirty();\n    // Note: _recomputing is already false at this point.\n    // Promise resolves/rejects after _recompute's finally block has executed.\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    const valueChanged =\n      !(this.flags & COMPUTED_STATE_FLAGS.RESOLVED) || !this._equal(this._value, value);\n\n    if (valueChanged) {\n      this.version = (this.version + 1) & SMI_MAX;\n    }\n\n    this._value = value;\n    this._clearDirty();\n    this._setResolved();\n    this._error = null;\n    this._setRecomputing(false);\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._setRejected();\n    this._clearDirty();\n    this._setRecomputing(false);\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  private _handlePending(): T {\n    if (this._hasDefaultValue) {\n      return this._defaultValue;\n    }\n    throw new ComputedError(ERROR_MESSAGES.COMPUTED_ASYNC_PENDING_NO_DEFAULT);\n  }\n\n  private _handleRejected(): T {\n    const error = this._error;\n    if (error?.recoverable && this._hasDefaultValue) {\n      return this._defaultValue;\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) as unknown as ComputedAtom<T>;\n}\n","import { EFFECT_STATE_FLAGS, IS_DEV, SCHEDULER_CONFIG, TIME_CONSTANTS } from '@/constants';\nimport { ReactiveNode } from '@/core/base';\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 {\n  depArrayPool,\n  EMPTY_DEPS,\n  EMPTY_UNSUBS,\n  EMPTY_VERSIONS,\n  unsubArrayPool,\n  versionArrayPool,\n} from '@/internal/pool';\nimport { scheduler } from '@/internal/scheduler';\nimport { type DependencyTracker, trackingContext, untracked } from '@/tracking';\nimport type {\n  Dependency,\n  EffectExecutionContext,\n  EffectFunction,\n  EffectObject,\n  EffectOptions,\n} 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 */\n\nclass EffectImpl extends ReactiveNode implements EffectObject, DependencyTracker {\n  private _cleanup: (() => void) | null;\n  private _dependencies: Dependency[];\n  private _dependencyVersions: number[];\n  private _unsubscribes: (() => void)[];\n  private _nextDeps: Dependency[] | null;\n  private _nextVersions: number[] | null;\n  private _nextUnsubs: (() => void)[] | 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    // V8 Hidden Class Stability: Group property initializations\n    this._cleanup = null;\n    this._dependencies = EMPTY_DEPS;\n    this._dependencyVersions = EMPTY_VERSIONS;\n    this._unsubscribes = EMPTY_UNSUBS;\n    this._nextDeps = null;\n    this._nextVersions = null;\n    this._nextUnsubs = 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\n    // Pre-allocate history buffer only if rate limiting is active and in Dev/Prod as configured\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    // Force execution regardless of dependency versions\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    this._safeCleanup();\n\n    const unsubs = this._unsubscribes;\n    if (unsubs !== EMPTY_UNSUBS) {\n      for (let i = 0, len = unsubs.length; i < len; i++) {\n        const unsub = unsubs[i];\n        if (unsub) unsub();\n      }\n      unsubArrayPool.release(unsubs);\n      this._unsubscribes = EMPTY_UNSUBS;\n    }\n\n    const deps = this._dependencies;\n    if (deps !== EMPTY_DEPS) {\n      depArrayPool.release(deps);\n      this._dependencies = EMPTY_DEPS;\n    }\n\n    const versions = this._dependencyVersions;\n    if (versions !== EMPTY_VERSIONS) {\n      versionArrayPool.release(versions);\n      this._dependencyVersions = EMPTY_VERSIONS;\n    }\n\n    this._executeTask = undefined;\n  }\n\n  public addDependency(dep: Dependency): void {\n    const flags = this.flags;\n    // Guard: Only track if currently executing\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 nextDeps = this._nextDeps;\n    const nextVersions = this._nextVersions;\n    const nextUnsubs = this._nextUnsubs;\n\n    if (!nextDeps || !nextVersions || !nextUnsubs) return;\n\n    nextDeps.push(dep);\n    nextVersions.push(dep.version);\n\n    const temp = dep._tempUnsub;\n    if (temp) {\n      nextUnsubs.push(temp);\n      dep._tempUnsub = undefined;\n    } else {\n      this._subscribeTo(dep);\n    }\n  }\n\n  public execute(force = false): void {\n    const flags = this.flags;\n    // Guard: Prevent re-entrant execution (infinite recursion) and post-disposal execution\n    if (flags & (EFFECT_STATE_FLAGS.DISPOSED | EFFECT_STATE_FLAGS.EXECUTING)) return;\n    if (!force && !this._shouldExecute()) return;\n\n    this._checkInfiniteLoop();\n    this._setExecuting(true);\n    this._safeCleanup();\n\n    const context = this._prepareEffectExecutionContext();\n    let committed = false;\n\n    try {\n      const result = trackingContext.run(this, this._fn);\n\n      // Commit Effect\n      const trackedCount = context.nextDeps.length;\n      context.nextDeps.length = trackedCount;\n      context.nextVersions.length = trackedCount;\n\n      this._dependencies = context.nextDeps;\n      this._dependencyVersions = context.nextVersions;\n      this._unsubscribes = context.nextUnsubs;\n      committed = true;\n\n      this._checkLoopWarnings();\n\n      const execId = ++this._execId;\n\n      if (isPromise(result)) {\n        result\n          .then((asyncCleanup) => {\n            const isStale = execId !== this._execId;\n            const isDisposed = this.flags & EFFECT_STATE_FLAGS.DISPOSED;\n\n            if (isStale || isDisposed) {\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\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      // Dependencies were already committed before the callback threw\n      committed = true;\n      this._handleExecutionError(error);\n      this._cleanup = null;\n    } finally {\n      this._cleanupEffect(context, committed);\n      this._setExecuting(false);\n    }\n  }\n\n  private _prepareEffectExecutionContext(): EffectExecutionContext {\n    const prevDeps = this._dependencies;\n    const prevVersions = this._dependencyVersions;\n    const prevUnsubs = this._unsubscribes;\n    const nextDeps = depArrayPool.acquire();\n    const nextVersions = versionArrayPool.acquire();\n    const nextUnsubs = unsubArrayPool.acquire();\n    const epoch = nextEpoch();\n\n    if (prevDeps !== EMPTY_DEPS) {\n      for (let i = 0, len = prevDeps.length; i < len; i++) {\n        const dep = prevDeps[i];\n        if (dep) dep._tempUnsub = prevUnsubs[i];\n      }\n    }\n\n    this._nextDeps = nextDeps;\n    this._nextVersions = nextVersions;\n    this._nextUnsubs = nextUnsubs;\n    this._currentEpoch = epoch;\n\n    return { prevDeps, prevVersions, prevUnsubs, nextDeps, nextVersions, nextUnsubs };\n  }\n\n  private _cleanupEffect(ctx: EffectExecutionContext, committed: boolean): void {\n    this._nextDeps = null;\n    this._nextVersions = null;\n    this._nextUnsubs = null;\n\n    const prevDeps = ctx.prevDeps;\n    if (committed) {\n      if (prevDeps !== EMPTY_DEPS) {\n        for (let i = 0, len = prevDeps.length; i < len; i++) {\n          const dep = prevDeps[i];\n          const unsub = dep ? dep._tempUnsub : undefined;\n          if (unsub) {\n            unsub();\n            if (dep) dep._tempUnsub = undefined;\n          }\n        }\n        depArrayPool.release(prevDeps);\n      }\n      if (ctx.prevUnsubs !== EMPTY_UNSUBS) unsubArrayPool.release(ctx.prevUnsubs);\n      if (ctx.prevVersions !== EMPTY_VERSIONS) versionArrayPool.release(ctx.prevVersions);\n    } else {\n      depArrayPool.release(ctx.nextDeps);\n      versionArrayPool.release(ctx.nextVersions);\n      const nextUnsubs = ctx.nextUnsubs;\n      for (let i = 0, len = nextUnsubs.length; i < len; i++) {\n        nextUnsubs[i]?.();\n      }\n      unsubArrayPool.release(nextUnsubs);\n\n      if (prevDeps !== EMPTY_DEPS) {\n        for (let i = 0, len = prevDeps.length; i < len; i++) {\n          const dep = prevDeps[i];\n          if (dep) dep._tempUnsub = undefined;\n        }\n      }\n    }\n  }\n\n  private _subscribeTo(dep: Dependency): void {\n    try {\n      const unsubscribe = dep.subscribe(() => {\n        if (this._trackModifications && this.flags & EFFECT_STATE_FLAGS.EXECUTING) {\n          dep._modifiedAtEpoch = this._currentEpoch;\n        }\n\n        if (this._sync) {\n          this.execute();\n          return;\n        }\n\n        let task = this._executeTask;\n        if (!task) {\n          task = this._executeTask = () => this.execute();\n        }\n        scheduler.schedule(task);\n      });\n      const nextUnsubs = this._nextUnsubs;\n      if (nextUnsubs) {\n        nextUnsubs.push(unsubscribe);\n      }\n    } catch (error) {\n      console.error(wrapError(error, EffectError, ERROR_MESSAGES.EFFECT_EXECUTION_FAILED));\n      const nextUnsubs = this._nextUnsubs;\n      if (nextUnsubs) {\n        nextUnsubs.push(() => {});\n      }\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 _setExecuting(value: boolean): void {\n    const mask = EFFECT_STATE_FLAGS.EXECUTING;\n    this.flags = (this.flags & ~mask) | ((value ? -1 : 0) & mask);\n  }\n\n  private _safeCleanup(): void {\n    const cleanup = this._cleanup;\n    if (cleanup) {\n      try {\n        cleanup();\n      } catch (error) {\n        this._handleExecutionError(error, ERROR_MESSAGES.EFFECT_CLEANUP_FAILED);\n      }\n      this._cleanup = null;\n    }\n  }\n\n  private _checkInfiniteLoop(): void {\n    const epoch = flushEpoch;\n    if (this._lastFlushEpoch !== epoch) {\n      this._lastFlushEpoch = epoch;\n      this._executionsInEpoch = 0;\n    }\n\n    const count = ++this._executionsInEpoch;\n    if (count > 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      const capacity = this._historyCapacity;\n\n      history[ptr] = now;\n      const nextPtr = (ptr + 1) % capacity;\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 ${capacity} times within 1 second. Infinite loop suspected`\n        );\n        this.dispose();\n        console.error(error);\n        if (this._onError) this._onError(error);\n        // Always halt execution after disposing, throw only in DEV for debugging\n        if (IS_DEV) throw error;\n        return;\n      }\n    }\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 _shouldExecute(): boolean {\n    const deps = this._dependencies;\n    if (deps.length === 0) return true;\n\n    const versions = this._dependencyVersions;\n    for (let i = 0, len = deps.length; i < len; i++) {\n      const dep = deps[i];\n      if (!dep) continue;\n\n      if (dep.version !== versions[i]) return true;\n\n      // Accuracy check for computed dependencies\n      if ('value' in dep) {\n        try {\n          untracked(() => (dep as { value: unknown }).value);\n        } catch {\n          return true;\n        }\n      }\n    }\n\n    return false;\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        // Avoid cascading failures if the onError handler itself throws\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 deps = this._dependencies;\n      const epoch = this._currentEpoch;\n      for (let i = 0, len = deps.length; i < len; i++) {\n        const dep = deps[i];\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 a reactive effect that re-executes when its dependencies change.\n *\n * An effect automatically tracks any reactive state (atoms, computed) accessed during its execution.\n * When those dependencies change, the effect is scheduled for re-execution.\n *\n * @param fn - The effect function to execute. Can return a cleanup function or a Promise that resolves to one.\n * @param options - Configuration options for the effect.\n * @param options.sync - If true, the effect runs synchronously when dependencies change. Defaults to false (scheduled).\n * @param options.maxExecutionsPerSecond - Rate limiting for the effect.\n * @param options.trackModifications - If true, warns when an effect modifies its own dependencies.\n * @returns An object representing the effect with `run()` and `dispose()` methods.\n * @throws {EffectError} If `fn` is not a function.\n *\n * @example\n * ```ts\n * const count = atom(0);\n * const stop = effect(() => {\n *   console.log('Count changed:', count.value);\n *   return () => console.log('Cleaning up...');\n * });\n * ```\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 * Executes multiple reactive updates in a single batch and flushes them synchronously.\n *\n * While the engine automatically batches updates using microtasks, `batch()`\n * provides a way to group multiple changes and guarantee their immediate\n * reflection (synchronous flush) once the callback completes.\n *\n * @template T - The return type of the callback function\n * @param callback - The function containing batched updates\n * @returns The result of the callback function\n * @throws {AtomError} If the callback is not a function\n * @throws Propagates any error thrown by the callback function\n *\n * @example\n * ```typescript\n * const firstName = atom('John');\n * const lastName = atom('Doe');\n *\n * // With batching: triggers 1 combined synchronous update at the end\n * batch(() => {\n *   firstName.value = 'Jane';\n *   lastName.value = 'Smith';\n * });\n * // Changes are guaranteed to be applied here\n * ```\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","ERROR_MESSAGES","count","DEBUG_NAME","DEBUG_ID","DEBUG_TYPE","NO_DEFAULT_VALUE","hasDependencies","obj","globalCheckEpoch","checkCircularInternal","dep","current","epoch","deps","i","child","debug","condition","type","id","target","nextId","generateId","ReactiveNode","cachedVersion","ReactiveDependency","listener","subs","subscriber","flag","unsubscribed","currentIdx","last","newValue","oldValue","flags","subMask","len","sub","err","PoolStatsCollector","PoolStatsRejected","ArrayPool","stats","arr","emptyConst","pool","poolLen","acquired","released","rejected","totalRejected","EMPTY_DEPS","EMPTY_UNSUBS","EMPTY_VERSIONS","depArrayPool","unsubArrayPool","versionArrayPool","trackDependency","dependency","functionSubscribers","objectSubscribers","syncDependencies","nextDeps","prevDeps","prevUnsubs","tracker","nextLen","prevLen","hasPrev","nextUnsubs","reuse","unsub","collectorEpoch","nextEpoch","currentEpoch","flushEpoch","flushExecutionCount","isFlushing","startFlush","endFlush","incrementFlushExecutionCount","Scheduler","callback","flushStarted","size","queue","targetQueue","targetSize","job","iterations","maxIterations","index","jobs","nextIndex","error","max","scheduler","TrackingContext","fn","prev","trackingContext","untracked","AtomImpl","initialValue","sync","task","atom","options","wrapError","ErrorClass","context","errorMessage","isAtom","isComputed","debugType","isEffect","isPromise","value","ASYNC_STATE_MASK","ASYNC_STATE_LOOKUP","ComputedTrackable","_owner","versions","ComputedAtomImpl","debugObj","currentFlags","errorSet","depErrors","j","jLen","result","unsubs","mask","trackable","prevVersions","committed","nextVersions","depCount","e","commitErr","promise","promiseId","resolvedValue","aggregate","v","onError","callbackError","computed","EffectImpl","isFiniteLimit","capacity","temp","force","trackedCount","execId","asyncCleanup","isStale","isDisposed","ctx","unsubscribe","cleanup","history","now","ptr","nextPtr","oldestTime","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/errors/messages.ts","../src/utils/debug.ts","../src/core/base.ts","../src/utils/array-pool.ts","../src/internal/pool.ts","../src/core/dep-tracking.ts","../src/internal/epoch.ts","../src/internal/scheduler.ts","../src/tracking/context.ts","../src/tracking/untracked.ts","../src/core/atom.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","/**\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 subscribe() receives an invalid listener.\n   */\n  COMPUTED_SUBSCRIBER_MUST_BE_FUNCTION:\n    'Subscriber listener must be a function or Subscriber object',\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 subscribing to a dependency fails.\n   */\n  COMPUTED_DEPENDENCY_SUBSCRIPTION_FAILED: 'Failed to subscribe to dependency',\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 thrown when the atom subscriber notification process fails.\n   */\n  ATOM_SUBSCRIBER_EXECUTION_FAILED: 'Error occurred while executing atom subscribers',\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   * Warning logged when attempting to unsubscribe a non-existent listener.\n   */\n  UNSUBSCRIBE_NON_EXISTENT: 'Attempted to unsubscribe a non-existent listener',\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 { 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\nlet globalCheckEpoch = 0;\n\n/** Internal recursive checker for circular dependency detection */\nfunction checkCircularInternal(dep: Dependency, current: object, epoch: number): void {\n  if (dep._visitedEpoch === epoch) {\n    return;\n  }\n  dep._visitedEpoch = epoch;\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, epoch);\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    globalCheckEpoch++;\n    checkCircularInternal(dep, current, globalCheckEpoch);\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 { IS_DEV, NODE_FLAGS, SMI_MAX } from '@/constants';\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  /** Epoch used for circular dependency detection and graph traversal */\n  _visitedEpoch: 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    // Group numeric field initializations to establish a stable Hidden Class (Shape) for V8.\n    // Consistent initialization order prevents shape transitions, optimizing property access.\n    this.flags = 0;\n    this.version = 0;\n    this._lastSeenEpoch = -1;\n    this._modifiedAtEpoch = -1;\n    this._visitedEpoch = -1;\n    this.id = (generateId() & SMI_MAX) as DependencyId;\n\n    this._tempUnsub = undefined;\n  }\n\n  /**\n   * Calculates the logical distance (shift) between current and cached version.\n   */\n  getShift(cachedVersion: number): number {\n    return (this.version - cachedVersion) & SMI_MAX;\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 _fnSubs: ((newValue?: T, oldValue?: T) => void)[];\n  protected abstract _objSubs: Subscriber[];\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    // Optimization: Prioritize function listeners as they are the most common case\n    if (typeof listener === 'function') {\n      return this._addSubscriber(\n        this._fnSubs,\n        listener as (newValue?: T, oldValue?: T) => void,\n        NODE_FLAGS.HAS_FN_SUBS\n      );\n    }\n\n    // Guard: Ensure listener is a valid non-null object before checking 'execute' property\n    if (listener !== null && typeof listener === 'object' && 'execute' in listener) {\n      return this._addSubscriber(this._objSubs, listener as Subscriber, NODE_FLAGS.HAS_OBJ_SUBS);\n    }\n\n    throw new AtomError(ERROR_MESSAGES.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);\n  }\n\n  /**\n   * Gets the total number of active subscribers.\n   */\n  subscriberCount(): number {\n    return this._fnSubs.length + this._objSubs.length;\n  }\n\n  /**\n   * Adds a subscriber to the specified subscription list and returns an unsubscribe function.\n   * Uses swap-and-pop for efficient removals.\n   */\n  private _addSubscriber<S>(subs: S[], subscriber: S, flag: number): () => void {\n    const idx = subs.indexOf(subscriber);\n    if (idx !== -1) {\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    subs.push(subscriber);\n    this.flags |= flag;\n\n    let unsubscribed = false;\n    return () => {\n      if (unsubscribed) return;\n      unsubscribed = true;\n\n      const currentIdx = subs.indexOf(subscriber);\n      if (currentIdx !== -1) {\n        const last = subs.pop()!;\n        if (currentIdx < subs.length) {\n          subs[currentIdx] = last;\n        }\n        this.flags &= ~(subs.length === 0 ? flag : 0);\n      }\n    };\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    const subMask = NODE_FLAGS.HAS_FN_SUBS | NODE_FLAGS.HAS_OBJ_SUBS;\n\n    if (!(flags & subMask)) return;\n\n    if (flags & NODE_FLAGS.HAS_FN_SUBS) {\n      const subs = this._fnSubs;\n      for (let i = 0, len = subs.length; i < len; i++) {\n        const sub = subs[i];\n        if (sub) {\n          try {\n            sub(newValue, oldValue);\n          } catch (err) {\n            console.error(\n              new AtomError(ERROR_MESSAGES.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, err as Error)\n            );\n          }\n        }\n      }\n    }\n\n    if (flags & NODE_FLAGS.HAS_OBJ_SUBS) {\n      const subs = this._objSubs;\n      for (let i = 0, len = subs.length; i < len; i++) {\n        const sub = subs[i];\n        if (sub) {\n          try {\n            sub.execute();\n          } catch (err) {\n            console.error(\n              new AtomError(ERROR_MESSAGES.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, err as Error)\n            );\n          }\n        }\n      }\n    }\n  }\n}\n","import { IS_DEV } from '@/constants';\nimport type { PoolStats } from '@/types';\n\n/** @internal */\nclass PoolStatsCollector {\n  acquired = 0;\n  released = 0;\n  rejected = new PoolStatsRejected();\n}\n\n/** @internal */\nclass PoolStatsRejected {\n  frozen = 0;\n  tooLarge = 0;\n  poolFull = 0;\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 (IS_DEV && 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    // 1. Skip if empty constant or frozen (expensive check)\n    if ((emptyConst && arr === emptyConst) || Object.isFrozen(arr)) {\n      const stats = this.stats;\n      if (IS_DEV && stats && arr !== emptyConst) stats.rejected.frozen++;\n      return;\n    }\n\n    // 2. Reject based on capacity or pool size\n    const len = arr.length;\n    const pool = this.pool;\n    const poolLen = pool.length;\n\n    if (len > this.maxReusableCapacity || poolLen >= this.maxPoolSize) {\n      const stats = this.stats;\n      if (IS_DEV && stats) {\n        if (len > this.maxReusableCapacity) stats.rejected.tooLarge++;\n        else stats.rejected.poolFull++;\n      }\n      return;\n    }\n\n    // 3. Clear and store\n    arr.length = 0;\n    pool.push(arr);\n    const stats = this.stats;\n    if (IS_DEV && 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 (!IS_DEV || !stats) return null;\n    const { acquired, released, rejected } = stats;\n    const totalRejected = rejected.frozen + rejected.tooLarge + rejected.poolFull;\n    return {\n      acquired,\n      released,\n      rejected: {\n        frozen: rejected.frozen,\n        tooLarge: rejected.tooLarge,\n        poolFull: rejected.poolFull,\n      },\n      leaked: acquired - released - totalRejected,\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 (IS_DEV && 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 { 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)[];\n\nexport const EMPTY_VERSIONS = Object.freeze([]) as unknown as number[];\n\n// Per-type Pool Instances (V8 Shape Optimization)\nexport const depArrayPool = new ArrayPool<Dependency>();\nexport const subArrayPool = new ArrayPool<Subscriber>();\nexport const unsubArrayPool = new ArrayPool<() => void>();\nexport const versionArrayPool = new ArrayPool<number>();\n","import { NODE_FLAGS } from '@/constants';\nimport { EMPTY_DEPS, EMPTY_UNSUBS, unsubArrayPool } from '@/internal/pool';\nimport type { DependencySubscriber } from '@/tracking/tracking.types';\nimport type { Dependency, Subscriber } from '@/types';\nimport { debug } from '@/utils/debug';\n\nexport function trackDependency<T>(\n  dependency: Dependency,\n  current: unknown,\n  functionSubscribers: ((newValue?: T, oldValue?: T) => void)[],\n  objectSubscribers: Subscriber[]\n): void {\n  if (current === null || current === undefined) return;\n\n  // Inlined from hasDependencyMethod to avoid call overhead\n  if (\n    (typeof current === 'object' || typeof current === 'function') &&\n    typeof (current as DependencySubscriber).addDependency === 'function'\n  ) {\n    (current as DependencySubscriber).addDependency(dependency);\n    return;\n  }\n\n  if (typeof current === 'function') {\n    const subscriber = current as (newValue?: T, oldValue?: T) => void;\n    // O(N) check - typically small N\n    if (functionSubscribers.indexOf(subscriber) === -1) {\n      functionSubscribers.push(subscriber);\n      dependency.flags |= NODE_FLAGS.HAS_FN_SUBS;\n    }\n    return;\n  }\n\n  // Inlined from hasExecuteMethod\n  if (typeof current === 'object' && typeof (current as Subscriber).execute === 'function') {\n    if (objectSubscribers.indexOf(current as Subscriber) === -1) {\n      objectSubscribers.push(current as Subscriber);\n      dependency.flags |= NODE_FLAGS.HAS_OBJ_SUBS;\n    }\n  }\n}\n\n/**\n * Synchronizes subscriptions using an O(N) strategy optimized for cache locality.\n */\nexport function syncDependencies(\n  nextDeps: Dependency[],\n  prevDeps: Dependency[],\n  prevUnsubs: (() => void)[],\n  tracker: Subscriber\n): (() => void)[] {\n  const nextLen = nextDeps.length;\n  const prevLen = prevDeps.length;\n  const hasPrev = prevDeps !== EMPTY_DEPS && prevLen > 0;\n\n  // 1. Initial dense pass: map existing unsubs to dependencies\n  if (hasPrev) {\n    for (let i = 0; i < prevLen; i++) {\n      const dep = prevDeps[i];\n      if (dep) dep._tempUnsub = prevUnsubs[i];\n    }\n  }\n\n  // 2. Build new unsubs array: reuse or subscribe\n  const nextUnsubs = unsubArrayPool.acquire();\n  nextUnsubs.length = nextLen;\n\n  for (let i = 0; i < nextLen; i++) {\n    const dep = nextDeps[i];\n    if (!dep) continue;\n\n    const reuse = dep._tempUnsub;\n    if (reuse) {\n      nextUnsubs[i] = reuse;\n      dep._tempUnsub = undefined;\n    } else {\n      // Keep checkCircular outside debug.enabled guard if tests rely on global spying\n      debug.checkCircular(dep, tracker);\n      nextUnsubs[i] = dep.subscribe(tracker);\n    }\n  }\n\n  // 3. Final cleanup pass: unsubscribe stale dependencies\n  if (hasPrev) {\n    for (let i = 0; i < prevLen; i++) {\n      const dep = prevDeps[i];\n      if (dep) {\n        const unsub = dep._tempUnsub;\n        if (unsub) {\n          unsub();\n          dep._tempUnsub = undefined;\n        }\n      }\n    }\n  }\n\n  if (prevUnsubs !== EMPTY_UNSUBS) {\n    unsubArrayPool.release(prevUnsubs);\n  }\n\n  return nextUnsubs;\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\n// === Infinite Loop Detection State ===\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 _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    this._queueBuffer[this._bufferIndex]![this._size++] = callback;\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 queue = this.batchQueue;\n    const targetQueue = this._queueBuffer[this._bufferIndex];\n    let targetSize = this._size;\n\n    for (let i = 0; i < size; i++) {\n      const job = queue[i]!;\n      if (job._nextEpoch !== epoch) {\n        job._nextEpoch = epoch;\n        targetQueue![targetSize++] = job;\n      }\n    }\n\n    this._size = targetSize;\n    this.batchQueueSize = 0;\n    if (queue.length > SCHEDULER_CONFIG.BATCH_QUEUE_SHRINK_THRESHOLD) queue.length = 0;\n  }\n\n  private _drainQueue(): void {\n    let iterations = 0;\n    const maxIterations = this.maxFlushIterations;\n\n    while (this._size > 0) {\n      if (++iterations > maxIterations) {\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    const nextIndex = index ^ 1;\n    this._bufferIndex = nextIndex;\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        jobs[i]!();\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    if (this.batchDepth === 0) {\n      if (IS_DEV) {\n        console.warn('endBatch() called without matching startBatch(). Ignoring.');\n      }\n      return;\n    }\n    this.batchDepth--;\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    }\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.\n *\n * This utility allows reading atom values without establishing\n * a dependency relationship, useful for accessing values that\n * shouldn't trigger recomputation when they change.\n *\n * @template T - The return type of the function\n * @param fn - The function to execute without tracking\n * @returns The result of the executed function\n * @throws {AtomError} If the callback is not a function\n * @throws Propagates any error thrown by the callback function\n *\n * @example\n * ```typescript\n * const count = atom(0);\n * const doubled = computed(() => {\n *   // This read will NOT be tracked as a dependency\n *   const untrackedValue = untracked(() => count.value);\n *   return untrackedValue * 2;\n * });\n * ```\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 { trackDependency } from '@/core/dep-tracking';\nimport { scheduler } from '@/internal/scheduler';\nimport { trackingContext } from '@/tracking';\nimport type { AtomOptions, Subscriber, 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 _fnSubs: ((newValue?: T, oldValue?: T) => void)[];\n  protected _objSubs: Subscriber[];\n\n  constructor(initialValue: T, sync: boolean) {\n    super();\n    this._value = initialValue;\n    this._pendingOldValue = undefined;\n    this._notifyTask = undefined;\n    this._fnSubs = [];\n    this._objSubs = [];\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._fnSubs, this._objSubs);\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    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    const subMask = ATOM_STATE_FLAGS.HAS_FN_SUBS | ATOM_STATE_FLAGS.HAS_OBJ_SUBS;\n    if (flags & subMask) {\n      this._scheduleNotification(oldValue);\n    }\n  }\n\n  /**\n   * Schedules or flushes notifications based on sync mode and batching state.\n   */\n  private _scheduleNotification(oldValue: T): void {\n    let flags = this.flags;\n\n    if (!(flags & ATOM_STATE_FLAGS.NOTIFICATION_SCHEDULED)) {\n      this._pendingOldValue = oldValue;\n      this.flags = flags |= ATOM_STATE_FLAGS.NOTIFICATION_SCHEDULED;\n    }\n\n    if (flags & ATOM_STATE_FLAGS.SYNC && !scheduler.isBatching) {\n      this._flushNotifications();\n      return;\n    }\n\n    let task = this._notifyTask;\n    if (!task) {\n      task = this._notifyTask = () => this._flushNotifications();\n    }\n    scheduler.schedule(task);\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    if (!(flags & ATOM_STATE_FLAGS.NOTIFICATION_SCHEDULED) || flags & ATOM_STATE_FLAGS.DISPOSED) {\n      return;\n    }\n\n    const oldValue = this._pendingOldValue as T;\n    const newValue = this._value;\n\n    this._pendingOldValue = undefined;\n    this.flags &= ~ATOM_STATE_FLAGS.NOTIFICATION_SCHEDULED;\n\n    this._notifySubscribers(newValue, 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    if (this.flags & ATOM_STATE_FLAGS.DISPOSED) {\n      return;\n    }\n\n    this._fnSubs = [];\n    this._objSubs = [];\n    this.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 { 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 {\n  DependencySubscriber,\n  ExecutableSubscriber,\n  TrackableFunction,\n} from '@/tracking/tracking.types';\nimport 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    'subscribe' in obj &&\n    typeof (obj as Record<string, 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    const debugType = debug.getDebugType(obj);\n    if (debugType) {\n      return debugType === 'computed';\n    }\n  }\n  return (\n    isAtom(obj) &&\n    'invalidate' in obj &&\n    typeof (obj as Record<string, unknown>).invalidate === 'function'\n  );\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    'dispose' in obj &&\n    'run' in obj &&\n    typeof (obj as Record<string, unknown>).dispose === 'function' &&\n    typeof (obj as Record<string, unknown>).run === 'function'\n  );\n}\n\n/**\n * Type guard to check if a value is a Promise\n *\n * Uses duck-typing to detect Promise-like objects by checking for\n * the presence of a `then` method.\n *\n * @template T - The type the Promise resolves to\n * @param value - Value to check\n * @returns True if value has a `then` method (is Promise-like)\n */\nexport function isPromise<T>(value: unknown): value is Promise<T> {\n  return value != null && typeof (value as { then?: unknown }).then === 'function';\n}\n\n/** Internal guard to verify if a value is a non-null object. */\nfunction isNonNullObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null;\n}\n\n/** Checks if the value implements the {@link DependencySubscriber} interface. */\nexport function hasDependencyMethod(value: unknown): value is DependencySubscriber {\n  return (\n    (typeof value === 'object' || typeof value === 'function') &&\n    value !== null &&\n    typeof (value as DependencySubscriber).addDependency === 'function'\n  );\n}\n\n/** Checks if the value is a function with an `addDependency` method. */\nexport function isTrackableFunction(\n  value: unknown\n): value is TrackableFunction & DependencySubscriber {\n  return (\n    typeof value === 'function' && typeof (value as TrackableFunction).addDependency === 'function'\n  );\n}\n\n/** Checks if the value is a plain function without dependency tracking capabilities. */\nexport function isPlainListener(value: unknown): value is () => void {\n  return (\n    typeof value === 'function' && typeof (value as TrackableFunction).addDependency !== 'function'\n  );\n}\n\n/** Checks if the value implements the {@link ExecutableSubscriber} interface. */\nexport function hasExecuteMethod(value: unknown): value is ExecutableSubscriber {\n  return isNonNullObject(value) && typeof value.execute === 'function';\n}\n","import { AsyncState, COMPUTED_STATE_FLAGS, EMPTY_ERROR_ARRAY, SMI_MAX } from '@/constants';\nimport { ReactiveDependency } from '@/core/base';\nimport { syncDependencies, trackDependency } 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 {\n  depArrayPool,\n  EMPTY_DEPS,\n  EMPTY_UNSUBS,\n  EMPTY_VERSIONS,\n  unsubArrayPool,\n  versionArrayPool,\n} from '@/internal/pool';\nimport { trackingContext } from '@/tracking';\n\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\n/**\n * Internal helper for stable Hidden Class in V8\n * @internal\n */\nclass ComputedTrackable<T> implements Subscriber {\n  _epoch: number;\n  _nextDeps: Dependency[];\n  _nextVersions: number[];\n  _depCount: number;\n\n  constructor(private readonly _owner: ComputedAtomImpl<T>) {\n    this._epoch = -1;\n    this._nextDeps = EMPTY_DEPS;\n    this._nextVersions = EMPTY_VERSIONS;\n    this._depCount = 0;\n  }\n\n  execute(): void {\n    this._owner._markDirty();\n  }\n\n  addDependency(dep: Dependency): void {\n    if (dep._lastSeenEpoch === this._epoch) {\n      return;\n    }\n    dep._lastSeenEpoch = this._epoch;\n\n    const count = this._depCount;\n    const deps = this._nextDeps;\n    const versions = this._nextVersions;\n\n    if (count < deps.length) {\n      deps[count] = dep;\n      versions[count] = dep.version;\n    } else {\n      deps.push(dep);\n      versions.push(dep.version);\n    }\n    this._depCount = count + 1;\n  }\n\n  reset(): void {\n    this._epoch = -1;\n    this._nextDeps = EMPTY_DEPS;\n    this._nextVersions = EMPTY_VERSIONS;\n    this._depCount = 0;\n  }\n}\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 _hasDefaultValue: boolean;\n  private readonly _onError: ((error: Error) => void) | null;\n\n  protected _fnSubs: ((newValue?: T, oldValue?: T) => void)[];\n  protected _objSubs: Subscriber[];\n\n  private _dependencies: Dependency[];\n  private _dependencyVersions: number[];\n  private _unsubscribes: (() => void)[];\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  private readonly MAX_ASYNC_RETRIES: number = 3;\n\n  private readonly _trackable: ComputedTrackable<T>;\n  private readonly MAX_PROMISE_ID: 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    // V8 Hidden Class Stability: Group property initializations\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._hasDefaultValue = this._defaultValue !== (NO_DEFAULT_VALUE as T);\n    this._onError = options.onError ?? null;\n    this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1;\n\n    this._fnSubs = [];\n    this._objSubs = [];\n    this._dependencies = EMPTY_DEPS;\n    this._dependencyVersions = EMPTY_VERSIONS;\n    this._unsubscribes = EMPTY_UNSUBS;\n\n    this._cachedErrors = null;\n    this._errorCacheEpoch = -1;\n    this._asyncStartAggregateVersion = 0;\n    this._asyncRetryCount = 0;\n\n    this._trackable = new ComputedTrackable(this);\n\n    debug.attachDebugInfo(this as unknown as ComputedAtom<T>, 'computed', this.id);\n\n    if (debug.enabled) {\n      const debugObj = this as unknown as ComputedAtom<T> & {\n        subscriberCount: () => number;\n        isDirty: () => boolean;\n        dependencies: Dependency[];\n        stateFlags: string;\n      };\n      debugObj.subscriberCount = this.subscriberCount.bind(this);\n      debugObj.isDirty = () => (this.flags & COMPUTED_STATE_FLAGS.DIRTY) !== 0;\n      debugObj.dependencies = this._dependencies;\n      debugObj.stateFlags = ''; // Settable via getter logic if needed\n    }\n\n    if (options.lazy === false) {\n      try {\n        this._recompute();\n      } catch {\n        // Ignore initial computation failure\n      }\n    }\n  }\n\n  get value(): T {\n    const current = trackingContext.current;\n    if (current) trackDependency(this, current, this._fnSubs, this._objSubs);\n\n    const flags = this.flags;\n    if (flags & COMPUTED_STATE_FLAGS.DISPOSED) {\n      throw new ComputedError(ERROR_MESSAGES.COMPUTED_DISPOSED);\n    }\n    if (flags & COMPUTED_STATE_FLAGS.RECOMPUTING) {\n      // Circular dependency detected: computation is accessing itself during recompute.\n      // Return default value if available, otherwise throw.\n      if (this._hasDefaultValue) return this._defaultValue;\n      throw new ComputedError(ERROR_MESSAGES.COMPUTED_CIRCULAR_DEPENDENCY);\n    }\n    if (flags & (COMPUTED_STATE_FLAGS.DIRTY | COMPUTED_STATE_FLAGS.IDLE)) this._recompute();\n\n    const currentFlags = this.flags;\n    if (currentFlags & COMPUTED_STATE_FLAGS.PENDING) return this._handlePending();\n    if (currentFlags & COMPUTED_STATE_FLAGS.REJECTED) return this._handleRejected();\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._fnSubs, this._objSubs);\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._fnSubs, this._objSubs);\n\n    const flags = this.flags;\n    if (flags & (COMPUTED_STATE_FLAGS.REJECTED | COMPUTED_STATE_FLAGS.HAS_ERROR)) return true;\n\n    const deps = this._dependencies;\n    for (let i = 0, len = deps.length; i < len; i++) {\n      const dep = deps[i];\n      if (dep && dep.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._fnSubs, this._objSubs);\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    if (this._error) errorSet.add(this._error);\n\n    const deps = this._dependencies;\n    for (let i = 0, len = deps.length; i < len; i++) {\n      const dep = deps[i];\n      if (dep && 'errors' in dep) {\n        const depErrors = (dep as unknown as ComputedAtom<unknown>).errors;\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    const result = Object.freeze([...errorSet]);\n    this._cachedErrors = result;\n    this._errorCacheEpoch = epoch;\n    return result;\n  }\n\n  get lastError(): Error | null {\n    const current = trackingContext.current;\n    if (current) trackDependency(this, current, this._fnSubs, this._objSubs);\n    return this._error;\n  }\n\n  get isPending(): boolean {\n    const current = trackingContext.current;\n    if (current) trackDependency(this, current, this._fnSubs, this._objSubs);\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._fnSubs, this._objSubs);\n    return (this.flags & COMPUTED_STATE_FLAGS.RESOLVED) !== 0;\n  }\n\n  invalidate(): void {\n    this._markDirty();\n    const versions = this._dependencyVersions;\n    if (versions !== EMPTY_VERSIONS) {\n      versionArrayPool.release(versions);\n      this._dependencyVersions = EMPTY_VERSIONS;\n    }\n    this._errorCacheEpoch = -1;\n    this._cachedErrors = null;\n  }\n\n  dispose(): void {\n    const unsubs = this._unsubscribes;\n    if (unsubs !== EMPTY_UNSUBS) {\n      for (let i = 0, len = unsubs.length; i < len; i++) {\n        const unsub = unsubs[i];\n        if (unsub) unsub();\n      }\n      unsubArrayPool.release(unsubs);\n      this._unsubscribes = EMPTY_UNSUBS;\n    }\n\n    const deps = this._dependencies;\n    if (deps !== EMPTY_DEPS) {\n      depArrayPool.release(deps);\n      this._dependencies = EMPTY_DEPS;\n    }\n\n    const versions = this._dependencyVersions;\n    if (versions !== EMPTY_VERSIONS) {\n      versionArrayPool.release(versions);\n      this._dependencyVersions = EMPTY_VERSIONS;\n    }\n\n    this._fnSubs = [];\n    this._objSubs = [];\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) % this.MAX_PROMISE_ID;\n    this._cachedErrors = null;\n    this._errorCacheEpoch = -1;\n  }\n\n  private _clearDirty(): void {\n    this.flags &= ~COMPUTED_STATE_FLAGS.DIRTY;\n  }\n\n  private _setPending(): void {\n    this.flags =\n      (this.flags | COMPUTED_STATE_FLAGS.PENDING) &\n      ~(COMPUTED_STATE_FLAGS.IDLE | COMPUTED_STATE_FLAGS.RESOLVED | COMPUTED_STATE_FLAGS.REJECTED);\n  }\n\n  private _isResolved(): boolean {\n    return (this.flags & COMPUTED_STATE_FLAGS.RESOLVED) !== 0;\n  }\n\n  private _setResolved(): void {\n    this.flags =\n      (this.flags | COMPUTED_STATE_FLAGS.RESOLVED) &\n      ~(\n        COMPUTED_STATE_FLAGS.IDLE |\n        COMPUTED_STATE_FLAGS.PENDING |\n        COMPUTED_STATE_FLAGS.REJECTED |\n        COMPUTED_STATE_FLAGS.HAS_ERROR\n      );\n  }\n\n  private _isRejected(): boolean {\n    return (this.flags & COMPUTED_STATE_FLAGS.REJECTED) !== 0;\n  }\n\n  private _setRejected(): void {\n    const mask =\n      COMPUTED_STATE_FLAGS.IDLE | COMPUTED_STATE_FLAGS.PENDING | COMPUTED_STATE_FLAGS.RESOLVED;\n    this.flags =\n      (this.flags & ~mask) | (COMPUTED_STATE_FLAGS.REJECTED | COMPUTED_STATE_FLAGS.HAS_ERROR);\n  }\n\n  private _setRecomputing(value: boolean): void {\n    const mask = COMPUTED_STATE_FLAGS.RECOMPUTING;\n    this.flags = (this.flags & ~mask) | ((value ? -1 : 0) & mask);\n  }\n\n  private _recompute(): void {\n    if (this.flags & COMPUTED_STATE_FLAGS.RECOMPUTING) {\n      return;\n    }\n\n    this._setRecomputing(true);\n\n    const trackable = this._trackable;\n    const prevDeps = this._dependencies;\n    const prevVersions = this._dependencyVersions;\n\n    trackable._epoch = nextEpoch();\n    trackable._nextDeps = depArrayPool.acquire();\n    trackable._nextVersions = versionArrayPool.acquire();\n    trackable._depCount = 0;\n\n    let committed = false;\n\n    try {\n      const result = trackingContext.run(trackable, this._fn);\n\n      // Commit Dependencies\n      const nextDeps = trackable._nextDeps;\n      const nextVersions = trackable._nextVersions;\n      const depCount = trackable._depCount;\n\n      nextDeps.length = depCount;\n      nextVersions.length = depCount;\n\n      this._unsubscribes = syncDependencies(nextDeps, prevDeps, this._unsubscribes, this);\n      this._dependencies = nextDeps;\n      this._dependencyVersions = nextVersions;\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        // Fallback commit for partial success/circular detection\n        try {\n          const nextDeps = trackable._nextDeps;\n          const nextVersions = trackable._nextVersions;\n          const depCount = trackable._depCount;\n          nextDeps.length = depCount;\n          nextVersions.length = depCount;\n          this._unsubscribes = syncDependencies(nextDeps, prevDeps, this._unsubscribes, this);\n          this._dependencies = nextDeps;\n          this._dependencyVersions = nextVersions;\n          committed = true;\n        } catch (commitErr) {\n          err = commitErr as Error;\n        }\n      }\n      this._handleComputationError(err);\n    } finally {\n      // Cleanup Trackable\n      if (committed) {\n        if (prevDeps !== EMPTY_DEPS) depArrayPool.release(prevDeps);\n        if (prevVersions !== EMPTY_VERSIONS) versionArrayPool.release(prevVersions);\n      } else {\n        depArrayPool.release(trackable._nextDeps);\n        versionArrayPool.release(trackable._nextVersions);\n      }\n      trackable.reset();\n      this._setRecomputing(false);\n    }\n  }\n\n  private _handleAsyncComputation(promise: Promise<T>): void {\n    this._setPending();\n    this._clearDirty();\n    this._notifySubscribers(undefined, undefined);\n\n    this._asyncStartAggregateVersion = this._captureVersionSnapshot();\n    this._asyncRetryCount = 0;\n\n    this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID;\n    const promiseId = this._promiseId;\n\n    promise\n      .then((resolvedValue) => {\n        if (promiseId !== this._promiseId) return;\n\n        // Drift detection: Compare aggregate dependency versions to detect changes during async.\n        // High drift indicates dependencies changed while awaiting; re-computation may be needed.\n        const currentAggregate = this._captureVersionSnapshot();\n        const isStale = currentAggregate !== this._asyncStartAggregateVersion;\n\n        if (isStale) {\n          if (this._asyncRetryCount < this.MAX_ASYNC_RETRIES) {\n            this._asyncRetryCount++;\n            this._markDirty();\n            return;\n          }\n          const error = new ComputedError(\n            `Async drift exceeded threshold after ${this.MAX_ASYNC_RETRIES} retries.`\n          );\n          this._handleAsyncRejection(error);\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 deps = this._dependencies;\n    for (let i = 0, len = deps.length; i < len; i++) {\n      const dep = deps[i];\n      if (dep) {\n        const v = dep.version;\n        // Use a simple mixing to reduce collisions: (hash << 5) - hash + v\n        // This is more robust than simple addition or XOR alone.\n        aggregate = ((((aggregate << 5) - aggregate) | 0) + v) & SMI_MAX;\n      }\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._setRejected();\n    this._clearDirty();\n    // Note: _recomputing is already false at this point.\n    // Promise resolves/rejects after _recompute's finally block has executed.\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    const valueChanged =\n      !(this.flags & COMPUTED_STATE_FLAGS.RESOLVED) || !this._equal(this._value, value);\n\n    if (valueChanged) {\n      this.version = (this.version + 1) & SMI_MAX;\n    }\n\n    this._value = value;\n    this._clearDirty();\n    this._setResolved();\n    this._error = null;\n    this._setRecomputing(false);\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._setRejected();\n    this._clearDirty();\n    this._setRecomputing(false);\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  private _handlePending(): T {\n    if (this._hasDefaultValue) {\n      return this._defaultValue;\n    }\n    throw new ComputedError(ERROR_MESSAGES.COMPUTED_ASYNC_PENDING_NO_DEFAULT);\n  }\n\n  private _handleRejected(): T {\n    const error = this._error;\n    if (error?.recoverable && this._hasDefaultValue) {\n      return this._defaultValue;\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) as unknown as ComputedAtom<T>;\n}\n","import { EFFECT_STATE_FLAGS, IS_DEV, SCHEDULER_CONFIG, TIME_CONSTANTS } from '@/constants';\nimport { ReactiveNode } from '@/core/base';\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 {\n  depArrayPool,\n  EMPTY_DEPS,\n  EMPTY_UNSUBS,\n  EMPTY_VERSIONS,\n  unsubArrayPool,\n  versionArrayPool,\n} from '@/internal/pool';\nimport { scheduler } from '@/internal/scheduler';\nimport { type DependencyTracker, trackingContext, untracked } from '@/tracking';\nimport type {\n  Dependency,\n  EffectExecutionContext,\n  EffectFunction,\n  EffectObject,\n  EffectOptions,\n} 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 */\n\nclass EffectImpl extends ReactiveNode implements EffectObject, DependencyTracker {\n  private _cleanup: (() => void) | null;\n  private _dependencies: Dependency[];\n  private _dependencyVersions: number[];\n  private _unsubscribes: (() => void)[];\n  private _nextDeps: Dependency[] | null;\n  private _nextVersions: number[] | null;\n  private _nextUnsubs: (() => void)[] | 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    // V8 Hidden Class Stability: Group property initializations\n    this._cleanup = null;\n    this._dependencies = EMPTY_DEPS;\n    this._dependencyVersions = EMPTY_VERSIONS;\n    this._unsubscribes = EMPTY_UNSUBS;\n    this._nextDeps = null;\n    this._nextVersions = null;\n    this._nextUnsubs = 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\n    // Pre-allocate history buffer only if rate limiting is active and in Dev/Prod as configured\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    // Force execution regardless of dependency versions\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    this._safeCleanup();\n\n    const unsubs = this._unsubscribes;\n    if (unsubs !== EMPTY_UNSUBS) {\n      for (let i = 0, len = unsubs.length; i < len; i++) {\n        const unsub = unsubs[i];\n        if (unsub) unsub();\n      }\n      unsubArrayPool.release(unsubs);\n      this._unsubscribes = EMPTY_UNSUBS;\n    }\n\n    const deps = this._dependencies;\n    if (deps !== EMPTY_DEPS) {\n      depArrayPool.release(deps);\n      this._dependencies = EMPTY_DEPS;\n    }\n\n    const versions = this._dependencyVersions;\n    if (versions !== EMPTY_VERSIONS) {\n      versionArrayPool.release(versions);\n      this._dependencyVersions = EMPTY_VERSIONS;\n    }\n\n    this._executeTask = undefined;\n  }\n\n  public addDependency(dep: Dependency): void {\n    const flags = this.flags;\n    // Guard: Only track if currently executing\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 nextDeps = this._nextDeps;\n    const nextVersions = this._nextVersions;\n    const nextUnsubs = this._nextUnsubs;\n\n    if (!nextDeps || !nextVersions || !nextUnsubs) return;\n\n    nextDeps.push(dep);\n    nextVersions.push(dep.version);\n\n    const temp = dep._tempUnsub;\n    if (temp) {\n      nextUnsubs.push(temp);\n      dep._tempUnsub = undefined;\n    } else {\n      this._subscribeTo(dep);\n    }\n  }\n\n  public execute(force = false): void {\n    const flags = this.flags;\n    // Guard: Prevent re-entrant execution (infinite recursion) and post-disposal execution\n    if (flags & (EFFECT_STATE_FLAGS.DISPOSED | EFFECT_STATE_FLAGS.EXECUTING)) return;\n    if (!force && !this._shouldExecute()) return;\n\n    this._checkInfiniteLoop();\n    this._setExecuting(true);\n    this._safeCleanup();\n\n    const context = this._prepareEffectExecutionContext();\n    let committed = false;\n\n    try {\n      const result = trackingContext.run(this, this._fn);\n\n      // Commit Effect\n      const trackedCount = context.nextDeps.length;\n      context.nextDeps.length = trackedCount;\n      context.nextVersions.length = trackedCount;\n\n      this._dependencies = context.nextDeps;\n      this._dependencyVersions = context.nextVersions;\n      this._unsubscribes = context.nextUnsubs;\n      committed = true;\n\n      this._checkLoopWarnings();\n\n      const execId = ++this._execId;\n\n      if (isPromise(result)) {\n        result\n          .then((asyncCleanup) => {\n            const isStale = execId !== this._execId;\n            const isDisposed = this.flags & EFFECT_STATE_FLAGS.DISPOSED;\n\n            if (isStale || isDisposed) {\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\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      // Dependencies were already committed before the callback threw\n      committed = true;\n      this._handleExecutionError(error);\n      this._cleanup = null;\n    } finally {\n      this._cleanupEffect(context, committed);\n      this._setExecuting(false);\n    }\n  }\n\n  private _prepareEffectExecutionContext(): EffectExecutionContext {\n    const prevDeps = this._dependencies;\n    const prevVersions = this._dependencyVersions;\n    const prevUnsubs = this._unsubscribes;\n    const nextDeps = depArrayPool.acquire();\n    const nextVersions = versionArrayPool.acquire();\n    const nextUnsubs = unsubArrayPool.acquire();\n    const epoch = nextEpoch();\n\n    if (prevDeps !== EMPTY_DEPS) {\n      for (let i = 0, len = prevDeps.length; i < len; i++) {\n        const dep = prevDeps[i];\n        if (dep) dep._tempUnsub = prevUnsubs[i];\n      }\n    }\n\n    this._nextDeps = nextDeps;\n    this._nextVersions = nextVersions;\n    this._nextUnsubs = nextUnsubs;\n    this._currentEpoch = epoch;\n\n    return { prevDeps, prevVersions, prevUnsubs, nextDeps, nextVersions, nextUnsubs };\n  }\n\n  private _cleanupEffect(ctx: EffectExecutionContext, committed: boolean): void {\n    this._nextDeps = null;\n    this._nextVersions = null;\n    this._nextUnsubs = null;\n\n    const prevDeps = ctx.prevDeps;\n    if (committed) {\n      if (prevDeps !== EMPTY_DEPS) {\n        for (let i = 0, len = prevDeps.length; i < len; i++) {\n          const dep = prevDeps[i];\n          const unsub = dep ? dep._tempUnsub : undefined;\n          if (unsub) {\n            unsub();\n            if (dep) dep._tempUnsub = undefined;\n          }\n        }\n        depArrayPool.release(prevDeps);\n      }\n      if (ctx.prevUnsubs !== EMPTY_UNSUBS) unsubArrayPool.release(ctx.prevUnsubs);\n      if (ctx.prevVersions !== EMPTY_VERSIONS) versionArrayPool.release(ctx.prevVersions);\n    } else {\n      depArrayPool.release(ctx.nextDeps);\n      versionArrayPool.release(ctx.nextVersions);\n      const nextUnsubs = ctx.nextUnsubs;\n      for (let i = 0, len = nextUnsubs.length; i < len; i++) {\n        nextUnsubs[i]?.();\n      }\n      unsubArrayPool.release(nextUnsubs);\n\n      if (prevDeps !== EMPTY_DEPS) {\n        for (let i = 0, len = prevDeps.length; i < len; i++) {\n          const dep = prevDeps[i];\n          if (dep) dep._tempUnsub = undefined;\n        }\n      }\n    }\n  }\n\n  private _subscribeTo(dep: Dependency): void {\n    try {\n      const unsubscribe = dep.subscribe(() => {\n        if (this._trackModifications && this.flags & EFFECT_STATE_FLAGS.EXECUTING) {\n          dep._modifiedAtEpoch = this._currentEpoch;\n        }\n\n        if (this._sync) {\n          this.execute();\n          return;\n        }\n\n        let task = this._executeTask;\n        if (!task) {\n          task = this._executeTask = () => this.execute();\n        }\n        scheduler.schedule(task);\n      });\n      const nextUnsubs = this._nextUnsubs;\n      if (nextUnsubs) {\n        nextUnsubs.push(unsubscribe);\n      }\n    } catch (error) {\n      console.error(wrapError(error, EffectError, ERROR_MESSAGES.EFFECT_EXECUTION_FAILED));\n      const nextUnsubs = this._nextUnsubs;\n      if (nextUnsubs) {\n        nextUnsubs.push(() => {});\n      }\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 _setExecuting(value: boolean): void {\n    const mask = EFFECT_STATE_FLAGS.EXECUTING;\n    this.flags = (this.flags & ~mask) | ((value ? -1 : 0) & mask);\n  }\n\n  private _safeCleanup(): void {\n    const cleanup = this._cleanup;\n    if (cleanup) {\n      try {\n        cleanup();\n      } catch (error) {\n        this._handleExecutionError(error, ERROR_MESSAGES.EFFECT_CLEANUP_FAILED);\n      }\n      this._cleanup = null;\n    }\n  }\n\n  private _checkInfiniteLoop(): void {\n    const epoch = flushEpoch;\n    if (this._lastFlushEpoch !== epoch) {\n      this._lastFlushEpoch = epoch;\n      this._executionsInEpoch = 0;\n    }\n\n    const count = ++this._executionsInEpoch;\n    if (count > 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      const capacity = this._historyCapacity;\n\n      history[ptr] = now;\n      const nextPtr = (ptr + 1) % capacity;\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 ${capacity} times within 1 second. Infinite loop suspected`\n        );\n        this.dispose();\n        console.error(error);\n        if (this._onError) this._onError(error);\n        // Always halt execution after disposing, throw only in DEV for debugging\n        if (IS_DEV) throw error;\n        return;\n      }\n    }\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 _shouldExecute(): boolean {\n    const deps = this._dependencies;\n    if (deps.length === 0) return true;\n\n    const versions = this._dependencyVersions;\n    for (let i = 0, len = deps.length; i < len; i++) {\n      const dep = deps[i];\n      if (!dep) continue;\n\n      if (dep.version !== versions[i]) return true;\n\n      // Accuracy check for computed dependencies\n      if ('value' in dep) {\n        try {\n          untracked(() => (dep as { value: unknown }).value);\n          if (dep.version !== versions[i]) return true;\n        } catch {\n          return true;\n        }\n      }\n    }\n\n    return false;\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        // Avoid cascading failures if the onError handler itself throws\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 deps = this._dependencies;\n      const epoch = this._currentEpoch;\n      for (let i = 0, len = deps.length; i < len; i++) {\n        const dep = deps[i];\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 a reactive effect that re-executes when its dependencies change.\n *\n * An effect automatically tracks any reactive state (atoms, computed) accessed during its execution.\n * When those dependencies change, the effect is scheduled for re-execution.\n *\n * @param fn - The effect function to execute. Can return a cleanup function or a Promise that resolves to one.\n * @param options - Configuration options for the effect.\n * @param options.sync - If true, the effect runs synchronously when dependencies change. Defaults to false (scheduled).\n * @param options.maxExecutionsPerSecond - Rate limiting for the effect.\n * @param options.trackModifications - If true, warns when an effect modifies its own dependencies.\n * @returns An object representing the effect with `run()` and `dispose()` methods.\n * @throws {EffectError} If `fn` is not a function.\n *\n * @example\n * ```ts\n * const count = atom(0);\n * const stop = effect(() => {\n *   console.log('Count changed:', count.value);\n *   return () => console.log('Cleaning up...');\n * });\n * ```\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 * Executes multiple reactive updates in a single batch and flushes them synchronously.\n *\n * While the engine automatically batches updates using microtasks, `batch()`\n * provides a way to group multiple changes and guarantee their immediate\n * reflection (synchronous flush) once the callback completes.\n *\n * @template T - The return type of the callback function\n * @param callback - The function containing batched updates\n * @returns The result of the callback function\n * @throws {AtomError} If the callback is not a function\n * @throws Propagates any error thrown by the callback function\n *\n * @example\n * ```typescript\n * const firstName = atom('John');\n * const lastName = atom('Doe');\n *\n * // With batching: triggers 1 combined synchronous update at the end\n * batch(() => {\n *   firstName.value = 'Jane';\n *   lastName.value = 'Smith';\n * });\n * // Changes are guaranteed to be applied here\n * ```\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","ERROR_MESSAGES","count","DEBUG_NAME","DEBUG_ID","DEBUG_TYPE","NO_DEFAULT_VALUE","hasDependencies","obj","globalCheckEpoch","checkCircularInternal","dep","current","epoch","deps","i","child","debug","condition","type","id","target","nextId","generateId","ReactiveNode","cachedVersion","ReactiveDependency","listener","subs","subscriber","flag","unsubscribed","currentIdx","last","newValue","oldValue","flags","subMask","len","sub","err","PoolStatsCollector","PoolStatsRejected","ArrayPool","stats","arr","emptyConst","pool","poolLen","acquired","released","rejected","totalRejected","EMPTY_DEPS","EMPTY_UNSUBS","EMPTY_VERSIONS","depArrayPool","unsubArrayPool","versionArrayPool","trackDependency","dependency","functionSubscribers","objectSubscribers","syncDependencies","nextDeps","prevDeps","prevUnsubs","tracker","nextLen","prevLen","hasPrev","nextUnsubs","reuse","unsub","collectorEpoch","nextEpoch","currentEpoch","flushEpoch","flushExecutionCount","isFlushing","startFlush","endFlush","incrementFlushExecutionCount","Scheduler","callback","flushStarted","size","queue","targetQueue","targetSize","job","iterations","maxIterations","index","jobs","nextIndex","error","max","scheduler","TrackingContext","fn","prev","trackingContext","untracked","AtomImpl","initialValue","sync","task","atom","options","wrapError","ErrorClass","context","errorMessage","isAtom","isComputed","debugType","isEffect","isPromise","value","ASYNC_STATE_MASK","ASYNC_STATE_LOOKUP","ComputedTrackable","_owner","versions","ComputedAtomImpl","debugObj","currentFlags","errorSet","depErrors","j","jLen","result","unsubs","mask","trackable","prevVersions","committed","nextVersions","depCount","e","commitErr","promise","promiseId","resolvedValue","aggregate","v","onError","callbackError","computed","EffectImpl","isFiniteLimit","capacity","temp","force","trackedCount","execId","asyncCleanup","isStale","isDisposed","ctx","unsubscribe","cleanup","history","now","ptr","nextPtr","oldestTime","errorObj","effect","effectInstance","batch"],"mappings":"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"}