@but212/atom-effect 0.13.1 → 0.14.0

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

@@ -1 +1 @@
-{"version":3,"file":"atom-effect.min.js","sources":["../src/constants.ts","../src/errors/errors.ts","../src/errors/messages.ts","../src/utils/debug.ts","../src/core/base.ts","../src/utils/array-pool.ts","../src/internal/pool.ts","../src/utils/type-guards.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/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 * Bit flags for effect state management\n * Using bit flags for efficient state checks (O(1) operations)\n */\nexport const EFFECT_STATE_FLAGS = {\n  DISPOSED: 1 << 0, // 0001 - Effect has been disposed\n  EXECUTING: 1 << 1, // 0010 - Effect is currently executing\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  DIRTY: 1 << 0, // 0001 - Needs recomputation\n  IDLE: 1 << 1, // 0010 - Initial state, not computed yet\n  PENDING: 1 << 2, // 0100 - Async computation in progress\n  RESOLVED: 1 << 3, // 1000 - Successfully computed\n  REJECTED: 1 << 4, // 10000 - Computation failed\n  RECOMPUTING: 1 << 5, // 100000 - Currently recomputing\n  HAS_ERROR: 1 << 6, // 1000000 - Has error state\n} as const;\n\n/**\n * Bit flags for atom state management\n */\nexport const ATOM_STATE_FLAGS = {\n  SYNC: 1 << 0,\n  NOTIFICATION_SCHEDULED: 1 << 1,\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} 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 * Phase-Shift Versioning Constants\n *\n * Implements discrete phase rotation for branchless version management.\n * Inspired by imaginary number rotation (e^iθ) for cyclic state tracking.\n *\n * Version Structure (30 bits total, fits in V8 Smi):\n * - Cycle (upper 10 bits): Complete rotation count (0-1023)\n * - Phase (lower 20 bits): Current angle in discrete steps (0-1,048,575)\n *\n * Branchless Operations:\n * - rotatePhase: (version + 1) & 0x3fffffff\n * - getShift: (current - cached) & 0x3fffffff\n * - urgentPriority: ((PHASE_THRESHOLD - 1 - shift) >>> 31) & 1\n */\nexport const PHASE_BITS = 20;\nexport const PHASE_MASK = (1 << PHASE_BITS) - 1; // 0x000fffff (1,048,575)\n\n/**\n * Phase threshold for urgent scheduling (equivalent to 180° rotation)\n * When shift exceeds this value, the job is considered \"urgent\"\n * and placed in the priority queue for glitch reduction.\n */\nexport const PHASE_THRESHOLD = 1 << (PHASE_BITS - 1); // 524,288\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 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  // 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 { 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 *\n * Optimized for V8 hidden classes:\n * - Initializes Smi (Small Integer) fields first.\n * - Provides common identity, flag, and version management.\n *\n * Phase-Shift Versioning:\n * - version uses 30-bit structure (10-bit Cycle + 20-bit Phase)\n * - Enables branchless operations for version comparison and priority calculation\n */\nexport class ReactiveNode {\n  /** Internal flags (Smi) for state management (Disposed, Dirty, etc.) */\n  flags: number;\n\n  /**\n   * Version counter using phase-shift encoding (Smi).\n   * Upper 10 bits = Cycle (rotation count), Lower 20 bits = Phase (angle)\n   * Enables branchless comparison and priority calculation.\n   */\n  version: number;\n\n  /** Last seen epoch for dependency collection (Smi) */\n  _lastSeenEpoch: number;\n\n  /** Unique numerical identifier (Smi) */\n  readonly id: DependencyId;\n\n  constructor() {\n    this.flags = 0;\n    this.version = 0;\n    this._lastSeenEpoch = -1;\n    this.id = (generateId() & SMI_MAX) as DependencyId;\n  }\n\n  /**\n   * Rotates the phase by 1, automatically incrementing cycle on overflow.\n   *\n   * Performance Benefits:\n   * - Branchless: No conditional statements\n   * - O(1): Single bitwise AND operation\n   * - Smi-safe: Result always within 30-bit range (0x3fffffff)\n   *\n   * When Phase reaches 0xfffff (1,048,575), the next increment:\n   * - Overflows into Cycle bits\n   * - Phase resets to 0\n   * - Cycle increments by 1\n   *\n   * @returns The new version after phase rotation\n   */\n  protected rotatePhase(): number {\n    this.version = (this.version + 1) & SMI_MAX;\n    return this.version;\n  }\n\n  /**\n   * Calculates the logical distance (shift) between current and cached version.\n   *\n   * Uses modular arithmetic to handle cycle wraparound correctly.\n   * The result represents how many phase rotations have occurred since\n   * the cached version was recorded.\n   *\n   * Performance Benefits:\n   * - Branchless: Single subtraction with mask\n   * - Handles wraparound: Works correctly even when version overflows\n   *\n   * Use Cases:\n   * - Scheduler priority: Large shifts indicate stale updates\n   * - Dependency staleness: Detect how outdated a cached value is\n   *\n   * @param cachedVersion - The previously cached version to compare against\n   * @returns Non-negative shift distance (0 to 0x3fffffff)\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 *\n * Extends ReactiveNode with subscriber management capabilities.\n * Inherits phase-shift versioning from ReactiveNode.\n *\n * Performance Note:\n * Storage fields for subscribers are defined in subclasses but managed here\n * to ensure optimal object shape. Subclasses should initialize _fnSubs and _objSubs.\n */\nexport abstract class ReactiveDependency<T> extends ReactiveNode {\n  /** Array of function-based subscribers */\n  protected abstract _fnSubs: ((newValue?: T, oldValue?: T) => void)[] | null;\n  /** Array of object-based subscribers */\n  protected abstract _objSubs: Subscriber[] | null;\n\n  /**\n   * Subscribes a listener function or Subscriber object to value changes.\n   *\n   * @param listener - Function or Subscriber object to call when the value changes\n   * @returns An unsubscribe function\n   * @throws {AtomError} If listener is not a function or Subscriber\n   */\n  subscribe(listener: ((newValue?: T, oldValue?: T) => void) | Subscriber): () => void {\n    if (typeof listener === 'object' && listener !== null && 'execute' in listener) {\n      return this._addSubscriber(this._getObjSubs(), listener);\n    }\n\n    if (typeof listener !== 'function') {\n      throw new AtomError(ERROR_MESSAGES.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);\n    }\n    return this._addSubscriber(this._getFnSubs(), listener);\n  }\n\n  /**\n   * Gets the total number of active subscribers.\n   */\n  subscriberCount(): number {\n    return (this._fnSubs?.length ?? 0) + (this._objSubs?.length ?? 0);\n  }\n\n  protected abstract _getFnSubs(): ((newValue?: T, oldValue?: T) => void)[];\n  protected abstract _getObjSubs(): Subscriber[];\n\n  private _addSubscriber<S>(subs: S[], subscriber: S): () => void {\n    if (subs.indexOf(subscriber) !== -1) return () => {};\n\n    subs.push(subscriber);\n\n    let isUnsubscribed = false;\n    return () => {\n      if (isUnsubscribed) return;\n      isUnsubscribed = true;\n\n      const idx = subs.indexOf(subscriber);\n      if (idx !== -1) {\n        const lastIndex = subs.length - 1;\n        if (idx !== lastIndex) {\n          subs[idx] = subs[lastIndex]!;\n        }\n        subs.pop();\n      }\n    };\n  }\n\n  /**\n   * Notifies all subscribers of a change.\n   *\n   * @param newValue - The new value\n   * @param oldValue - The old value\n   */\n  protected _notifySubscribers(newValue: T | undefined, oldValue: T | undefined): void {\n    const fnSubs = this._fnSubs;\n    if (fnSubs) {\n      for (let i = fnSubs.length - 1; i >= 0; i--) {\n        try {\n          const sub = fnSubs[i];\n          if (sub) 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    const objSubs = this._objSubs;\n    if (objSubs) {\n      for (let i = objSubs.length - 1; i >= 0; i--) {\n        try {\n          const sub = objSubs[i];\n          if (sub) 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","import { IS_DEV } from '@/constants';\nimport type { PoolStats } from '@/types';\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 = 50;\n  private readonly maxReusableCapacity = 256;\n\n  private stats = IS_DEV\n    ? {\n        acquired: 0,\n        released: 0,\n        rejected: { frozen: 0, tooLarge: 0, poolFull: 0 },\n      }\n    : null;\n\n  /** Acquires an array from the pool or creates a new one if the pool is empty. */\n  acquire(): T[] {\n    if (IS_DEV && this.stats) this.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   * @param arr - The array to release.\n   * @param emptyConst - Optional reference to a constant empty array to skip.\n   */\n  release(arr: T[], emptyConst?: readonly T[]): void {\n    if (emptyConst && arr === emptyConst) return;\n\n    if (Object.isFrozen(arr)) {\n      if (IS_DEV && this.stats) this.stats.rejected.frozen++;\n      return;\n    }\n\n    if (arr.length > this.maxReusableCapacity) {\n      if (IS_DEV && this.stats) this.stats.rejected.tooLarge++;\n      return;\n    }\n\n    if (this.pool.length >= this.maxPoolSize) {\n      if (IS_DEV && this.stats) this.stats.rejected.poolFull++;\n      return;\n    }\n\n    arr.length = 0;\n    this.pool.push(arr);\n    if (IS_DEV && this.stats) this.stats.released++;\n  }\n\n  /** Returns current stats for the pool (dev mode only). */\n  getStats(): PoolStats | null {\n    if (!IS_DEV || !this.stats) return null;\n    const { acquired, released, rejected } = this.stats;\n    const totalRejected = rejected.frozen + rejected.tooLarge + rejected.poolFull;\n    return {\n      acquired,\n      released,\n      rejected,\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    if (IS_DEV && this.stats) {\n      this.stats.acquired = 0;\n      this.stats.released = 0;\n      this.stats.rejected = { frozen: 0, tooLarge: 0, 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 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 || obj === undefined || 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 { EMPTY_DEPS, EMPTY_UNSUBS, unsubArrayPool } from '@/internal/pool';\nimport type { Dependency, Subscriber } from '@/types';\nimport { debug } from '@/utils/debug';\nimport { hasDependencyMethod, hasExecuteMethod, isPlainListener } from '@/utils/type-guards';\n\n/**\n * Registers a dependency with the current listener (if any).\n *\n * @param dependency - The reactive node to be tracked (Atom or Computed)\n * @param current - The current listener from the tracking context\n * @param functionSubscribers - Manager for function-based subscribers\n * @param objectSubscribers - Manager for object-based subscribers\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) return;\n\n  // Priority 1: TrackableListener pattern (addDependency method)\n  // Used by Computed atoms to collect dependencies\n  if (hasDependencyMethod(current)) {\n    current.addDependency(dependency);\n    return;\n  }\n\n  // Priority 2: Plain function callback\n  // Used by simple effects or manual tracking\n  if (isPlainListener(current)) {\n    const subscriber = current as (newValue?: T, oldValue?: T) => void;\n    if (functionSubscribers.indexOf(subscriber) === -1) {\n      functionSubscribers.push(subscriber);\n    }\n    return;\n  }\n\n  // Priority 3: Subscriber pattern (execute method)\n  // Used by Effect objects or other subscribers\n  if (hasExecuteMethod(current)) {\n    if (objectSubscribers.indexOf(current) === -1) {\n      objectSubscribers.push(current);\n    }\n  }\n}\n\n/**\n * Synchronizes subscriptions based on dependency changes using O(N) strategy.\n * Maps unsubs 1:1 with dependencies array.\n *\n * Shared logic for Computed and Effect to manage their dependencies.\n *\n * @param nextDeps - The new list of dependencies collected\n * @param prevDeps - The previous list of dependencies\n * @param prevUnsubs - The previous list of unsubscribe functions\n * @param tracker - The object tracking these dependencies (Computed or Effect)\n * @returns The new list of unsubscribe functions\n */\nexport function syncDependencies(\n  nextDeps: Dependency[],\n  prevDeps: Dependency[],\n  prevUnsubs: (() => void)[],\n  tracker: Subscriber\n): (() => void)[] {\n  // 1. Map existing subscriptions to dependencies for O(1) lookup during sync\n  if (prevDeps !== EMPTY_DEPS && prevUnsubs !== EMPTY_UNSUBS) {\n    for (let i = 0; i < prevDeps.length; i++) {\n      const dep = prevDeps[i];\n      if (dep) dep._tempUnsub = prevUnsubs[i];\n    }\n  }\n\n  // 2. Build new unsubscribe array\n  const nextUnsubs = unsubArrayPool.acquire();\n\n  // Ensure nextUnsubs has same length as nextDeps\n  nextUnsubs.length = nextDeps.length;\n\n  for (let i = 0; i < nextDeps.length; i++) {\n    const dep = nextDeps[i];\n    if (!dep) continue;\n\n    if (dep._tempUnsub) {\n      // Reuse existing subscription\n      nextUnsubs[i] = dep._tempUnsub;\n      dep._tempUnsub = undefined; // Consumed\n    } else {\n      debug.checkCircular(dep, tracker);\n      nextUnsubs[i] = dep.subscribe(tracker);\n    }\n  }\n\n  // 3. Cleanup unused subscriptions (from removals)\n  if (prevDeps !== EMPTY_DEPS) {\n    for (let i = 0; i < prevDeps.length; i++) {\n      const dep = prevDeps[i];\n      if (dep?._tempUnsub) {\n        // Still has _tempUnsub => was not reused in nextDeps => Removed\n        dep._tempUnsub();\n        dep._tempUnsub = undefined;\n      }\n    }\n  }\n\n  // 4. Release old unsub array\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;\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 { PHASE_THRESHOLD, SCHEDULER_CONFIG } from '@/constants';\nimport { SchedulerError } from '@/errors/errors';\nimport { endFlush, startFlush } from '@/internal/epoch';\n\nexport enum SchedulerPhase {\n  IDLE = 0,\n  BATCHING = 1,\n  FLUSHING = 2,\n}\n\n/**\n * Scheduler job interface with phase-shift tracking support.\n * _cachedVersion enables priority calculation based on staleness.\n */\nexport interface SchedulerJob {\n  (): void;\n  /** Epoch for deduplication */\n  _nextEpoch?: number;\n  /** Cached version for phase-shift priority calculation */\n  _cachedVersion?: number;\n}\n\n/**\n * Interface for nodes that support phase-shift priority calculation.\n * Used by Scheduler to determine job urgency.\n */\ninterface PhaseShiftNode {\n  getShift(cachedVersion: number): number;\n}\n\n/**\n * Scheduler for reactive updates with phase-shift priority scheduling.\n *\n * Features:\n * - Double-buffered queue for efficient processing\n * - Urgent queue for high-priority updates (glitch reduction)\n * - Branchless priority calculation using phase-shift\n * - Batching support for transactional updates\n *\n * Priority Logic:\n * When a job's phase shift exceeds PHASE_THRESHOLD (90° equivalent),\n * it's considered \"urgent\" and processed before normal jobs.\n * This reduces glitches by prioritizing stale updates.\n */\nclass Scheduler {\n  // Normal queue (double-buffered)\n  private queueA: SchedulerJob[] = [];\n  private queueB: SchedulerJob[] = [];\n  private queue: SchedulerJob[] = this.queueA;\n  private queueSize = 0;\n\n  // Urgent queue for high-priority jobs (phase shift > THRESHOLD)\n  private urgentQueueA: SchedulerJob[] = [];\n  private urgentQueueB: SchedulerJob[] = [];\n  private urgentQueue: SchedulerJob[] = this.urgentQueueA;\n  private urgentQueueSize = 0;\n\n  private _epoch = 0;\n  private isProcessing: boolean = false;\n  public isBatching: boolean = false;\n  private batchDepth: number = 0;\n  private batchQueue: SchedulerJob[] = [];\n  private batchQueueSize = 0;\n  private isFlushingSync: boolean = false;\n  private maxFlushIterations: number = SCHEDULER_CONFIG.MAX_FLUSH_ITERATIONS;\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  /**\n   * Schedules a task for execution with optional priority based on phase shift.\n   *\n   * Priority Calculation (Branchless):\n   * - If sourceNode and cachedVersion are provided, calculates shift\n   * - Jobs with shift >= PHASE_THRESHOLD go to urgentQueue\n   * - Uses branchless bit manipulation: ((shift - THRESHOLD) >>> 31) ^ 1\n   *\n   * @param callback - The function to execute\n   * @param sourceNode - Optional reactive node for shift calculation\n   * @throws {SchedulerError} If the callback is not a function\n   */\n  schedule(callback: SchedulerJob, sourceNode?: PhaseShiftNode): void {\n    if (typeof callback !== 'function') {\n      throw new SchedulerError('Scheduler callback must be a function');\n    }\n\n    // O(1) dedup via epoch\n    if (callback._nextEpoch === this._epoch) return;\n    callback._nextEpoch = this._epoch;\n\n    if (this.isBatching || this.isFlushingSync) {\n      // During batching, all jobs go to batchQueue (priority determined at merge time)\n      this.batchQueue[this.batchQueueSize++] = callback;\n    } else {\n      // Calculate urgency using branchless operation\n      // urgentPriority = 1 if shift >= THRESHOLD, else 0\n      const isUrgent = this._calculateUrgency(callback, sourceNode);\n\n      // Branchless queue selection using multiplication\n      // If isUrgent=1: adds to urgentQueue, else adds to normal queue\n      this.urgentQueue[this.urgentQueueSize] = callback;\n      this.queue[this.queueSize] = callback;\n      this.urgentQueueSize += isUrgent;\n      this.queueSize += isUrgent ^ 1;\n\n      if (!this.isProcessing) {\n        this.flush();\n      }\n    }\n  }\n\n  /**\n   * Calculates urgency flag using branchless bit manipulation.\n   *\n   * Formula: ((shift - PHASE_THRESHOLD) >>> 31) ^ 1\n   * - If shift >= THRESHOLD: (negative >>> 31) = 0, XOR 1 = 1 (urgent)\n   * - If shift < THRESHOLD: (positive >>> 31) = 0... wait, that's wrong\n   *\n   * Correct formula: (shift >= THRESHOLD) ? 1 : 0\n   * Branchless: ((PHASE_THRESHOLD - 1 - shift) >>> 31)\n   *\n   * @returns 1 if urgent, 0 if normal\n   */\n  private _calculateUrgency(callback: SchedulerJob, sourceNode?: PhaseShiftNode): number {\n    if (!sourceNode || callback._cachedVersion === undefined) {\n      return 0;\n    }\n\n    const shift = sourceNode.getShift(callback._cachedVersion);\n\n    // Branchless urgency check:\n    // If shift >= PHASE_THRESHOLD, result is 1\n    // If shift < PHASE_THRESHOLD, result is 0\n    // Formula: ((PHASE_THRESHOLD - 1 - shift) >> 31) & 1 gives 1 when shift >= THRESHOLD\n    return ((PHASE_THRESHOLD - 1 - shift) >>> 31) & 1;\n  }\n\n  private flush(): void {\n    if (this.isProcessing || (this.queueSize === 0 && this.urgentQueueSize === 0)) return;\n\n    this.isProcessing = true;\n\n    queueMicrotask(() => {\n      try {\n        if (this.queueSize === 0 && this.urgentQueueSize === 0) return;\n\n        const flushStarted = startFlush();\n        this._drainQueue();\n        if (flushStarted) endFlush();\n      } finally {\n        this.isProcessing = false;\n\n        if ((this.queueSize > 0 || this.urgentQueueSize > 0) && !this.isBatching) {\n          this.flush();\n        }\n      }\n    });\n  }\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  private _mergeBatchQueue(): void {\n    this._epoch++;\n    if (this.batchQueueSize > 0) {\n      for (let i = 0; i < this.batchQueueSize; i++) {\n        const job = this.batchQueue[i];\n        if (job && job._nextEpoch !== this._epoch) {\n          job._nextEpoch = this._epoch;\n          // Batch jobs go to normal queue (priority already accounted for during batching)\n          this.queue[this.queueSize++] = job;\n        }\n      }\n      this.batchQueueSize = 0;\n    }\n  }\n\n  /**\n   * Drains all queues, processing urgent queue completely first.\n   *\n   * Processing Order:\n   * 1. Process all urgent jobs (high phase shift = stale updates)\n   * 2. Process normal jobs\n   * 3. Repeat until both queues are empty\n   *\n   * This ordering reduces glitches by ensuring that the most\n   * impactful state changes are propagated first.\n   */\n  private _drainQueue(): void {\n    let iterations = 0;\n\n    while (this.urgentQueueSize > 0 || this.queueSize > 0) {\n      if (++iterations > this.maxFlushIterations) {\n        this._handleFlushOverflow();\n        return;\n      }\n\n      // Process urgent queue first (glitch reduction)\n      if (this.urgentQueueSize > 0) {\n        this._processUrgentQueue();\n      }\n\n      // Then process normal queue\n      if (this.queueSize > 0) {\n        this._processCurrentQueue();\n      }\n\n      this._mergeBatchQueue();\n    }\n  }\n\n  /**\n   * Processes the urgent queue using double-buffering.\n   */\n  private _processUrgentQueue(): void {\n    const jobs = this.urgentQueue;\n    const count = this.urgentQueueSize;\n\n    // Swap to other buffer\n    this.urgentQueue =\n      this.urgentQueue === this.urgentQueueA ? this.urgentQueueB : this.urgentQueueA;\n    this.urgentQueueSize = 0;\n    this._epoch++;\n\n    this._processJobs(jobs, count);\n  }\n\n  private _processCurrentQueue(): void {\n    const jobs = this.queue;\n    const count = this.queueSize;\n\n    this.queue = this.queue === this.queueA ? this.queueB : this.queueA;\n    this.queueSize = 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.queueSize = 0;\n    this.queue.length = 0;\n    this.urgentQueueSize = 0;\n    this.urgentQueue.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      const job = jobs[i];\n      if (job) {\n        try {\n          job();\n        } catch (error) {\n          console.error(\n            new SchedulerError('Error occurred during scheduler execution', error as Error)\n          );\n        }\n      }\n    }\n    jobs.length = 0;\n  }\n\n  /** Starts a new batch of updates. Updates will be deferred until endBatch is called. */\n  startBatch(): void {\n    this.batchDepth++;\n    this.isBatching = true;\n  }\n\n  /**\n   * Ends the current batch. If the batch depth reaches zero, all pending updates are flushed synchronously.\n   */\n  endBatch(): void {\n    this.batchDepth = Math.max(0, this.batchDepth - 1);\n\n    if (this.batchDepth === 0) {\n      this.flushSync();\n      this.isBatching = false;\n    }\n  }\n\n  /**\n   * Configures the maximum number of iterations allowed during a synchronous flush.\n   * Used to prevent infinite loops.\n   * @param max - Maximum iterations count.\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 } 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)[] | null = null;\n  protected _objSubs: Subscriber[] | null = null;\n\n  constructor(initialValue: T, sync: boolean) {\n    super();\n    this._value = initialValue;\n    if (sync) this.flags |= ATOM_STATE_FLAGS.SYNC;\n\n    // Attach debug info in dev mode\n    debug.attachDebugInfo(this, 'atom', this.id);\n  }\n\n  protected _getFnSubs(): ((newValue?: T, oldValue?: T) => void)[] {\n    this._fnSubs ??= [];\n    return this._fnSubs;\n  }\n\n  protected _getObjSubs(): Subscriber[] {\n    this._objSubs ??= [];\n    return this._objSubs;\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) trackDependency(this, current, this._getFnSubs(), this._getObjSubs());\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    if (Object.is(this._value, newValue)) return;\n\n    const oldValue = this._value;\n    this._value = newValue;\n\n    // Branchless phase rotation: automatically handles cycle overflow\n    this.rotatePhase();\n\n    // Check for subscribers: O(1) before scheduling\n    if ((this._fnSubs?.length ?? 0) > 0 || (this._objSubs?.length ?? 0) > 0) {\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    if (!(this.flags & ATOM_STATE_FLAGS.NOTIFICATION_SCHEDULED)) {\n      this._pendingOldValue = oldValue;\n      this.flags |= ATOM_STATE_FLAGS.NOTIFICATION_SCHEDULED;\n    }\n\n    // Flush immediately if sync and not batching\n    if (this.flags & ATOM_STATE_FLAGS.SYNC && !scheduler.isBatching) {\n      this._flushNotifications();\n      return;\n    }\n\n    if (!this._notifyTask) {\n      this._notifyTask = () => this._flushNotifications();\n    }\n    scheduler.schedule(this._notifyTask);\n  }\n\n  private _flushNotifications(): void {\n    if (!(this.flags & ATOM_STATE_FLAGS.NOTIFICATION_SCHEDULED)) return;\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  peek(): T {\n    return this._value;\n  }\n\n  dispose(): void {\n    this._fnSubs = null;\n    this._objSubs = null;\n    this._value = undefined as T;\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 {\n  AsyncState,\n  COMPUTED_STATE_FLAGS,\n  EMPTY_ERROR_ARRAY,\n  PHASE_THRESHOLD,\n  SMI_MAX,\n} 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  ComputationContext,\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\ntype TrackableListener = (() => void) & {\n  addDependency: (dep: Dependency) => void;\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)[] | null = null;\n  protected _objSubs: Subscriber[] | null = null;\n\n  private _dependencies: Dependency[];\n  private _dependencyVersions: number[];\n  private _unsubscribes: (() => void)[];\n\n  // Error propagation fields\n  private _cachedErrors: readonly Error[] | null = null;\n  private _errorCacheEpoch = -1;\n\n  // Async phase drift validation fields\n  private _asyncStartAggregateVersion: number = 0;\n  private _asyncRetryCount: number = 0;\n  private readonly MAX_ASYNC_RETRIES: number = 3;\n\n  private readonly _notifyJob: () => void;\n  private readonly _trackable: TrackableListener;\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    this._value = undefined as T;\n    this.flags = COMPUTED_STATE_FLAGS.DIRTY | COMPUTED_STATE_FLAGS.IDLE;\n\n    this._error = null;\n    this._promiseId = 0;\n    this._equal = options.equal ?? Object.is;\n\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._dependencies = EMPTY_DEPS;\n    this._dependencyVersions = EMPTY_VERSIONS;\n    this._unsubscribes = EMPTY_UNSUBS;\n\n    this._notifyJob = () => {\n      const fnSubs = this._fnSubs;\n      if (fnSubs) {\n        for (let i = fnSubs.length - 1; i >= 0; i--) {\n          try {\n            const sub = fnSubs[i];\n            if (sub) sub(undefined, undefined);\n          } catch (err) {\n            console.error(err);\n          }\n        }\n      }\n\n      const objSubs = this._objSubs;\n      if (objSubs) {\n        for (let i = objSubs.length - 1; i >= 0; i--) {\n          try {\n            const sub = objSubs[i];\n            if (sub) sub.execute();\n          } catch (err) {\n            console.error(err);\n          }\n        }\n      }\n    };\n\n    this._trackable = Object.assign(() => this._markDirty(), {\n      addDependency: (_dep: Dependency) => {},\n    });\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._isDirty();\n      debugObj.dependencies = this._dependencies;\n      debugObj.stateFlags = this._getFlagsAsString();\n    }\n\n    if (options.lazy === false) {\n      try {\n        this._recompute();\n      } catch {\n        // Ignore initial computation failure\n      }\n    }\n  }\n\n  protected _getFnSubs(): ((newValue?: T, oldValue?: T) => void)[] {\n    this._fnSubs ??= [];\n    return this._fnSubs;\n  }\n\n  protected _getObjSubs(): Subscriber[] {\n    this._objSubs ??= [];\n    return this._objSubs;\n  }\n\n  get value(): T {\n    // Register tracking FIRST so this computed becomes a dependency\n    // even if _computeValue throws. This is critical for error propagation.\n    this._registerTracking();\n    const result = this._computeValue();\n    return result;\n  }\n\n  peek(): T {\n    return this._value;\n  }\n\n  get state(): AsyncStateType {\n    this._registerTracking();\n    return this._getAsyncState();\n  }\n\n  get hasError(): boolean {\n    this._registerTracking();\n\n    // 1. Check own error state\n    if (this._isRejected()) {\n      return true;\n    }\n\n    // 2. Check dependency errors (early return)\n    for (let i = 0; i < this._dependencies.length; i++) {\n      const dep = this._dependencies[i];\n      if (dep && 'hasError' in dep && (dep as unknown as ComputedAtom<unknown>).hasError) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  get isValid(): boolean {\n    return !this.hasError;\n  }\n\n  get errors(): readonly Error[] {\n    this._registerTracking();\n\n    // Fast path: no errors\n    if (!this.hasError) {\n      return EMPTY_ERROR_ARRAY;\n    }\n\n    // Check epoch cache\n    const epoch = currentEpoch();\n    if (this._errorCacheEpoch === epoch && this._cachedErrors !== null) {\n      return this._cachedErrors;\n    }\n\n    // Collect errors (lazy) using Set for deduplication\n    const errorSet = new Set<Error>();\n\n    // Own error\n    if (this._error) {\n      errorSet.add(this._error);\n    }\n\n    // Dependency errors (recursive collection, deduplicated)\n    for (let i = 0; i < this._dependencies.length; i++) {\n      const dep = this._dependencies[i];\n      if (dep && 'errors' in dep) {\n        const depErrors = (dep as unknown as ComputedAtom<unknown>).errors;\n        for (let j = 0; j < depErrors.length; j++) {\n          const err = depErrors[j];\n          if (err) {\n            errorSet.add(err);\n          }\n        }\n      }\n    }\n\n    // Cache and freeze\n    this._cachedErrors = Object.freeze([...errorSet]);\n    this._errorCacheEpoch = epoch;\n\n    return this._cachedErrors;\n  }\n\n  get lastError(): Error | null {\n    this._registerTracking();\n    return this._error;\n  }\n\n  get isPending(): boolean {\n    this._registerTracking();\n    return this._isPending();\n  }\n\n  get isResolved(): boolean {\n    this._registerTracking();\n    return this._isResolved();\n  }\n\n  invalidate(): void {\n    this._markDirty();\n    if (this._dependencyVersions !== EMPTY_VERSIONS) {\n      versionArrayPool.release(this._dependencyVersions);\n      this._dependencyVersions = EMPTY_VERSIONS;\n    }\n    // Invalidate error cache\n    this._errorCacheEpoch = -1;\n    this._cachedErrors = null;\n  }\n\n  dispose(): void {\n    if (this._unsubscribes !== EMPTY_UNSUBS) {\n      for (let i = 0; i < this._unsubscribes.length; i++) {\n        const unsub = this._unsubscribes[i];\n        if (unsub) unsub();\n      }\n      unsubArrayPool.release(this._unsubscribes);\n      this._unsubscribes = EMPTY_UNSUBS;\n    }\n\n    if (this._dependencies !== EMPTY_DEPS) {\n      depArrayPool.release(this._dependencies);\n      this._dependencies = EMPTY_DEPS;\n    }\n\n    if (this._dependencyVersions !== EMPTY_VERSIONS) {\n      versionArrayPool.release(this._dependencyVersions);\n      this._dependencyVersions = EMPTY_VERSIONS;\n    }\n\n    this._fnSubs = null;\n    this._objSubs = null;\n    this.flags = 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    // Clear error cache\n    this._cachedErrors = null;\n    this._errorCacheEpoch = -1;\n  }\n\n  // State flag operations\n  private _isDirty(): boolean {\n    return (this.flags & COMPUTED_STATE_FLAGS.DIRTY) !== 0;\n  }\n\n  private _setDirty(): void {\n    this.flags |= COMPUTED_STATE_FLAGS.DIRTY;\n  }\n\n  private _clearDirty(): void {\n    this.flags &= ~COMPUTED_STATE_FLAGS.DIRTY;\n  }\n\n  private _isIdle(): boolean {\n    return (this.flags & COMPUTED_STATE_FLAGS.IDLE) !== 0;\n  }\n\n  private _setIdle(): void {\n    this.flags |= COMPUTED_STATE_FLAGS.IDLE;\n    this.flags &= ~(\n      COMPUTED_STATE_FLAGS.PENDING |\n      COMPUTED_STATE_FLAGS.RESOLVED |\n      COMPUTED_STATE_FLAGS.REJECTED\n    );\n  }\n\n  private _isPending(): boolean {\n    return (this.flags & COMPUTED_STATE_FLAGS.PENDING) !== 0;\n  }\n\n  private _setPending(): void {\n    this.flags |= COMPUTED_STATE_FLAGS.PENDING;\n    this.flags &= ~(\n      COMPUTED_STATE_FLAGS.IDLE |\n      COMPUTED_STATE_FLAGS.RESOLVED |\n      COMPUTED_STATE_FLAGS.REJECTED\n    );\n  }\n\n  private _isResolved(): boolean {\n    return (this.flags & COMPUTED_STATE_FLAGS.RESOLVED) !== 0;\n  }\n\n  private _setResolved(): void {\n    this.flags |= COMPUTED_STATE_FLAGS.RESOLVED;\n    this.flags &= ~(\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    this.flags |= COMPUTED_STATE_FLAGS.REJECTED | COMPUTED_STATE_FLAGS.HAS_ERROR;\n    this.flags &= ~(\n      COMPUTED_STATE_FLAGS.IDLE |\n      COMPUTED_STATE_FLAGS.PENDING |\n      COMPUTED_STATE_FLAGS.RESOLVED\n    );\n  }\n\n  private _isRecomputing(): boolean {\n    return (this.flags & COMPUTED_STATE_FLAGS.RECOMPUTING) !== 0;\n  }\n\n  private _setRecomputing(value: boolean): void {\n    const mask = COMPUTED_STATE_FLAGS.RECOMPUTING;\n    this.flags = (this.flags & ~mask) | (-Number(value) & mask);\n  }\n\n  private _getAsyncState(): AsyncStateType {\n    return ASYNC_STATE_LOOKUP[this.flags & ASYNC_STATE_MASK];\n  }\n\n  private _getFlagsAsString(): string {\n    const states: string[] = [];\n    if (this._isDirty()) states.push('DIRTY');\n    if (this._isIdle()) states.push('IDLE');\n    if (this._isPending()) states.push('PENDING');\n    if (this._isResolved()) states.push('RESOLVED');\n    if (this._isRejected()) states.push('REJECTED');\n    if (this._isRecomputing()) states.push('RECOMPUTING');\n    return states.join(' | ');\n  }\n\n  private _computeValue(): T {\n    if (this._isRecomputing()) return this._value;\n\n    if (this._isDirty() || this._isIdle()) {\n      this._recompute();\n    }\n\n    if (this._isPending()) return this._handlePending();\n    if (this._isRejected()) return this._handleRejected();\n\n    return this._value;\n  }\n\n  private _recompute(): void {\n    if (this._isRecomputing()) return;\n\n    this._setRecomputing(true);\n\n    const context = this._prepareComputationContext();\n    let committed = false;\n\n    try {\n      const result = trackingContext.run(this._trackable, this._fn);\n\n      this._commitDependencies(context);\n      committed = true;\n\n      isPromise(result) ? this._handleAsyncComputation(result) : this._handleSyncResult(result);\n    } catch (err) {\n      if (!committed) {\n        try {\n          this._commitDependencies(context);\n          committed = true;\n        } catch (commitErr) {\n          this._handleComputationError(commitErr);\n        }\n      }\n      this._handleComputationError(err);\n    } finally {\n      this._cleanupContext(context, committed);\n      this._setRecomputing(false);\n    }\n  }\n\n  private _prepareComputationContext(): ComputationContext {\n    const prevDeps = this._dependencies;\n    const prevVersions = this._dependencyVersions;\n    const nextDeps = depArrayPool.acquire();\n    const nextVersions = versionArrayPool.acquire();\n    const epoch = nextEpoch();\n    const state = { depCount: 0 };\n\n    const collect = (dep: Dependency) => {\n      if (dep._lastSeenEpoch === epoch) return;\n      dep._lastSeenEpoch = epoch;\n\n      if (state.depCount < nextDeps.length) {\n        nextDeps[state.depCount] = dep;\n        nextVersions[state.depCount] = dep.version;\n      } else {\n        nextDeps.push(dep);\n        nextVersions.push(dep.version);\n      }\n      state.depCount++;\n    };\n\n    const originalAdd = this._trackable.addDependency;\n    this._trackable.addDependency = collect;\n\n    return { prevDeps, prevVersions, nextDeps, nextVersions, originalAdd, state };\n  }\n\n  private _commitDependencies(ctx: ComputationContext): void {\n    const { nextDeps, nextVersions, state, prevDeps } = ctx;\n\n    nextDeps.length = state.depCount;\n    nextVersions.length = state.depCount;\n\n    this._unsubscribes = syncDependencies(nextDeps, prevDeps, this._unsubscribes, this);\n    this._dependencies = nextDeps;\n    this._dependencyVersions = nextVersions;\n  }\n\n  private _cleanupContext(ctx: ComputationContext, committed: boolean): void {\n    this._trackable.addDependency = ctx.originalAdd;\n\n    if (committed) {\n      if (ctx.prevDeps !== EMPTY_DEPS) {\n        depArrayPool.release(ctx.prevDeps);\n      }\n      if (ctx.prevVersions !== EMPTY_VERSIONS) {\n        versionArrayPool.release(ctx.prevVersions);\n      }\n    } else {\n      depArrayPool.release(ctx.nextDeps);\n      versionArrayPool.release(ctx.nextVersions);\n    }\n  }\n\n  /**\n   * Calculates aggregate shift from all dependencies.\n   * Used for scheduling priority in computed chains.\n   *\n   * Performance: O(N) where N = dependency count\n   * Branchless: Each dep.getShift uses modular arithmetic\n   *\n   * @returns Sum of all dependency shifts (capped at SMI_MAX)\n   */\n  private _getAggregateShift(): number {\n    let totalShift = 0;\n    const deps = this._dependencies;\n    const versions = this._dependencyVersions;\n\n    for (let i = 0; i < deps.length; i++) {\n      const dep = deps[i];\n      const cachedVersion = versions[i];\n      if (dep && cachedVersion !== undefined) {\n        // getShift uses branchless modular arithmetic\n        totalShift = (totalShift + dep.getShift(cachedVersion)) & SMI_MAX;\n      }\n    }\n\n    return totalShift;\n  }\n\n  /**\n   * Checks if this computed should be scheduled with urgent priority.\n   * Based on aggregate shift from all dependencies.\n   *\n   * @returns true if aggregate shift exceeds PHASE_THRESHOLD\n   */\n  isUrgent(): boolean {\n    return this._getAggregateShift() >= PHASE_THRESHOLD;\n  }\n\n  private _handleSyncResult(result: T): void {\n    this._finalizeResolution(result);\n  }\n\n  private _handleAsyncComputation(promise: Promise<T>): void {\n    this._setPending();\n    this._clearDirty();\n    this._notifyJob();\n\n    // Capture version snapshot at async start for drift validation\n    this._asyncStartAggregateVersion = this._captureVersionSnapshot();\n    this._asyncRetryCount = 0;\n\n    this._promiseId = this._promiseId >= this.MAX_PROMISE_ID ? 1 : this._promiseId + 1;\n    const promiseId = this._promiseId;\n\n    promise\n      .then((resolvedValue) => {\n        if (promiseId !== this._promiseId) return;\n\n        // Phase drift validation: check if dependencies changed significantly during async\n        const currentAggregate = this._captureVersionSnapshot();\n        const drift = (currentAggregate - this._asyncStartAggregateVersion) & SMI_MAX;\n\n        // Branchless stale detection: 1 if drift >= PHASE_THRESHOLD, else 0\n        const isStale = ((PHASE_THRESHOLD - 1 - drift) >>> 31) & 1;\n\n        // If stale, handle retry or fail-fast\n        if (isStale) {\n          if (this._asyncRetryCount < this.MAX_ASYNC_RETRIES) {\n            // Retry: trigger recomputation with fresh dependencies\n            this._asyncRetryCount++;\n            this._markDirty();\n            return;\n          }\n\n          // Fail-Fast Policy: retries exhausted, reject with descriptive error\n          // This allows UI layer to gracefully degrade using hasError/defaultValue\n          const error = new ComputedError(\n            `Async drift exceeded threshold after ${this.MAX_ASYNC_RETRIES} retries. Dependencies changed too rapidly for stable computation.`\n          );\n          this._handleAsyncRejection(error);\n          return;\n        }\n\n        this._handleAsyncResolution(resolvedValue);\n      })\n      .catch((err) => {\n        if (promiseId !== this._promiseId) return;\n        this._handleAsyncRejection(err);\n      });\n  }\n\n  /**\n   * Captures the aggregate version of all dependencies.\n   * Used for phase drift validation in async computations.\n   *\n   * @returns Sum of all dependency versions (capped at SMI_MAX)\n   */\n  private _captureVersionSnapshot(): number {\n    let aggregate = 0;\n    const deps = this._dependencies;\n    for (let i = 0; i < deps.length; i++) {\n      const dep = deps[i];\n      if (dep) {\n        aggregate = (aggregate + dep.version) & SMI_MAX;\n      }\n    }\n    return aggregate;\n  }\n\n  private _handleAsyncResolution(resolvedValue: T): void {\n    this._finalizeResolution(resolvedValue);\n    this._notifyJob();\n  }\n\n  /**\n   * Unified success finalization for sync and async results.\n   * Handles phase rotation, state transition, and error cache clearing.\n   */\n  private _finalizeResolution(value: T): void {\n    const valueChanged = !this._isResolved() || !this._equal(this._value, value);\n\n    // Conditional phase rotation: only rotate if value actually changed\n    if (valueChanged) this.rotatePhase();\n\n    this._value = value;\n    this._clearDirty();\n    this._setResolved();\n    this._error = null;\n    this._setRecomputing(false);\n\n    // Clear error cache on successful computation (recovery)\n    this._cachedErrors = null;\n    this._errorCacheEpoch = -1;\n  }\n\n  private _handleAsyncRejection(err: unknown): void {\n    const error = wrapError(err, ComputedError, ERROR_MESSAGES.COMPUTED_ASYNC_COMPUTATION_FAILED);\n\n    // Rotate phase so effects detect the state change (pending -> rejected)\n    const stateChanged = !this._isRejected();\n    if (stateChanged) this.rotatePhase();\n\n    this._error = error;\n    this._setRejected();\n    this._clearDirty();\n    this._setRecomputing(false);\n\n    if (this._onError) {\n      try {\n        this._onError(error);\n      } catch (callbackError) {\n        console.error(ERROR_MESSAGES.CALLBACK_ERROR_IN_ERROR_HANDLER, callbackError);\n      }\n    }\n\n    this._notifyJob();\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    if (this._onError) {\n      try {\n        this._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    if (this._error?.recoverable && this._hasDefaultValue) {\n      return this._defaultValue;\n    }\n    throw this._error;\n  }\n\n  /** Subscriber interface - marks dirty on dependency change */\n  execute(): void {\n    this._markDirty();\n  }\n\n  private _markDirty(): void {\n    if (this._isRecomputing() || this._isDirty()) return;\n\n    this._setDirty();\n    this._notifyJob();\n  }\n\n  private _registerTracking(): void {\n    trackDependency(this, trackingContext.getCurrent(), this._getFnSubs(), this._getObjSubs());\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  /** Cleanup function returned by the last execution */\n  private _cleanup: (() => void) | null;\n  /** Current active dependencies */\n  private _dependencies: Dependency[];\n  /** Cached versions of dependencies at last execution */\n  private _dependencyVersions: number[];\n  /** Unsubscribe functions for current dependencies */\n  private _unsubscribes: (() => void)[];\n  /** Temporary storage for dependencies being tracked in current execution */\n  private _nextDeps: Dependency[] | null;\n  /** Temporary storage for dependency versions being tracked in current execution */\n  private _nextVersions: number[] | null;\n  /** Temporary storage for unsubscribes being tracked in current execution */\n  private _nextUnsubs: (() => void)[] | null;\n\n  /** Error handler callback */\n  private readonly _onError: ((error: unknown) => void) | null;\n\n  /** Current execution epoch for tracking freshness */\n  private _currentEpoch: number;\n  /** Epoch of the last scheduler flush */\n  private _lastFlushEpoch: number;\n  /** Number of executions within the current flush */\n  private _executionsInEpoch: number;\n\n  /** The effect function to execute */\n  private readonly _fn: EffectFunction;\n  /** Whether to execute synchronously on dependency change */\n  private readonly _sync: boolean;\n  /** Maximum allowed executions per second */\n  private readonly _maxExecutions: number;\n  /** Maximum allowed executions per scheduler flush */\n  private readonly _maxExecutionsPerFlush: number;\n  /** Whether to track if dependencies are modified during execution */\n  private readonly _trackModifications: boolean;\n\n  /** Execution timestamps for rate limiting (dev only) */\n  private _history: number[] | null;\n  /** Total number of executions */\n  private _executionCount: number;\n\n  /** Pointer for circular buffer history */\n  private _historyPtr: number;\n  /** Capacity of the history buffer */\n  private readonly _historyCapacity: number;\n\n  /**\n   * Creates a new EffectImpl instance.\n   * @param fn - The effect function to run.\n   * @param options - Configuration options for the effect.\n   */\n\n  constructor(fn: EffectFunction, options: EffectOptions = {}) {\n    super();\n\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._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._historyPtr = 0;\n    const isFiniteLimit = Number.isFinite(this._maxExecutions);\n    this._historyCapacity = isFiniteLimit\n      ? Math.min(this._maxExecutions + 1, SCHEDULER_CONFIG.MAX_EXECUTIONS_PER_SECOND + 1)\n      : 0;\n\n    // Pre-allocate array for circular buffer in Dev mode to avoid dynamic resizing\n    this._history =\n      IS_DEV && isFiniteLimit && this._historyCapacity > 0\n        ? new Array(this._historyCapacity).fill(0)\n        : null;\n    this._executionCount = 0;\n\n    debug.attachDebugInfo(this, 'effect', this.id);\n  }\n\n  /**\n   * Manually triggers effect execution.\n   * Forces re-execution even if dependencies haven't changed.\n   * @throws {EffectError} If the effect is already disposed.\n   */\n  public run = (): void => {\n    if (this.isDisposed) {\n      throw new EffectError(ERROR_MESSAGES.EFFECT_MUST_BE_FUNCTION);\n    }\n    if (this._dependencyVersions !== EMPTY_VERSIONS) {\n      versionArrayPool.release(this._dependencyVersions);\n      this._dependencyVersions = EMPTY_VERSIONS as number[];\n    }\n    this.execute();\n  };\n\n  /**\n   * Disposes of the effect, cleaning up all subscriptions and resources.\n   * Prevents further executions and releases arrays back to pools.\n   */\n  public dispose = (): void => {\n    if (this.isDisposed) return;\n\n    this._setDisposed();\n    this._safeCleanup();\n\n    if (this._unsubscribes !== EMPTY_UNSUBS) {\n      for (let i = 0; i < this._unsubscribes.length; i++) {\n        const unsub = this._unsubscribes[i];\n        if (unsub) unsub();\n      }\n      unsubArrayPool.release(this._unsubscribes);\n      this._unsubscribes = EMPTY_UNSUBS;\n    }\n\n    if (this._dependencies !== EMPTY_DEPS) {\n      depArrayPool.release(this._dependencies);\n      this._dependencies = EMPTY_DEPS;\n    }\n\n    if (this._dependencyVersions !== EMPTY_VERSIONS) {\n      versionArrayPool.release(this._dependencyVersions);\n      this._dependencyVersions = EMPTY_VERSIONS;\n    }\n  };\n\n  /**\n   * Adds a dependency to the current tracking context.\n   * Called automatically when a reactive node is accessed during execution.\n   * @param dep - The dependency to track.\n   */\n  public addDependency = (dep: Dependency): void => {\n    if (this.isExecuting && this._nextDeps && this._nextUnsubs && this._nextVersions) {\n      const epoch = this._currentEpoch;\n\n      if (dep._lastSeenEpoch === epoch) return;\n      dep._lastSeenEpoch = epoch;\n\n      this._nextDeps.push(dep);\n      this._nextVersions.push(dep.version);\n\n      if (dep._tempUnsub) {\n        this._nextUnsubs.push(dep._tempUnsub);\n        dep._tempUnsub = undefined;\n      } else {\n        this._subscribeTo(dep);\n      }\n    }\n  };\n\n  /**\n   * Executes the effect function.\n   * Handles dependency tracking, cleanup, and infinite loop protection.\n   * If the function returns a cleanup function or a Promise, it will be handled accordingly.\n   */\n  public execute = (): void => {\n    if (this.isDisposed || this.isExecuting) return;\n    if (!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      this._commitEffect(context);\n      committed = true;\n\n      this._checkLoopWarnings();\n\n      if (isPromise(result)) {\n        result\n          .then((asyncCleanup) => {\n            if (!this.isDisposed && typeof asyncCleanup === 'function') {\n              this._cleanup = asyncCleanup;\n            }\n          })\n          .catch((error) => {\n            this._handleExecutionError(error);\n          });\n      } else {\n        this._cleanup = typeof result === 'function' ? result : null;\n      }\n    } catch (error) {\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  /**\n   * Prepares the execution context by acquiring pools and setting up epoch.\n   * @returns The prepared EffectExecutionContext.\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 && prevUnsubs !== EMPTY_UNSUBS) {\n      for (let i = 0; i < prevDeps.length; 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  /**\n   * Commits the tracked dependencies as the current active dependencies.\n   * @param ctx - The current effect context.\n   */\n  private _commitEffect(ctx: EffectExecutionContext): void {\n    // Structural Guarantee: nextDeps length is controlled by the tracking phase\n    // We use the context's nextDeps directly, avoiding `this._nextDeps!`\n    const trackedCount = ctx.nextDeps.length;\n\n    ctx.nextDeps.length = trackedCount;\n    ctx.nextVersions.length = trackedCount;\n\n    this._dependencies = ctx.nextDeps;\n    this._dependencyVersions = ctx.nextVersions;\n    this._unsubscribes = ctx.nextUnsubs;\n  }\n\n  /**\n   * Cleans up the effect execution context, releasing resources back to pools.\n   * @param ctx - The effect context to clean up.\n   * @param committed - Whether the changes were committed to the effect.\n   */\n  private _cleanupEffect(ctx: EffectExecutionContext, committed: boolean): void {\n    this._nextDeps = null;\n    this._nextVersions = null;\n    this._nextUnsubs = null;\n\n    if (committed) {\n      if (ctx.prevDeps !== EMPTY_DEPS) {\n        for (let i = 0; i < ctx.prevDeps.length; i++) {\n          const dep = ctx.prevDeps[i];\n          if (dep?._tempUnsub) {\n            dep._tempUnsub();\n            dep._tempUnsub = undefined;\n          }\n        }\n        depArrayPool.release(ctx.prevDeps);\n      }\n      if (ctx.prevUnsubs !== EMPTY_UNSUBS) {\n        unsubArrayPool.release(ctx.prevUnsubs);\n      }\n      if (ctx.prevVersions !== EMPTY_VERSIONS) {\n        versionArrayPool.release(ctx.prevVersions);\n      }\n    } else {\n      depArrayPool.release(ctx.nextDeps);\n      versionArrayPool.release(ctx.nextVersions);\n      for (let i = 0; i < ctx.nextUnsubs.length; i++) {\n        ctx.nextUnsubs[i]?.();\n      }\n      unsubArrayPool.release(ctx.nextUnsubs);\n\n      if (ctx.prevDeps !== EMPTY_DEPS) {\n        for (let i = 0; i < ctx.prevDeps.length; i++) {\n          const dep = ctx.prevDeps[i];\n          if (dep) dep._tempUnsub = undefined;\n        }\n      }\n    }\n  }\n\n  /**\n   * Subscribes to a dependency's changes.\n   * @param dep - The dependency to subscribe to.\n   */\n  private _subscribeTo(dep: Dependency): void {\n    try {\n      const unsubscribe = dep.subscribe(() => {\n        if (this._trackModifications && this.isExecuting) {\n          dep._modifiedAtEpoch = this._currentEpoch;\n        }\n\n        if (this._sync) {\n          this.execute();\n        } else {\n          scheduler.schedule(this.execute);\n        }\n      });\n      if (this._nextUnsubs) {\n        this._nextUnsubs.push(unsubscribe);\n      }\n    } catch (error) {\n      console.error(wrapError(error, EffectError, ERROR_MESSAGES.EFFECT_EXECUTION_FAILED));\n      if (this._nextUnsubs) this._nextUnsubs.push(() => {});\n    }\n  }\n\n  /**\n   * Whether the effect has been disposed.\n   */\n  get isDisposed(): boolean {\n    return (this.flags & EFFECT_STATE_FLAGS.DISPOSED) !== 0;\n  }\n\n  /**\n   * Total number of times this effect has executed.\n   */\n  get executionCount(): number {\n    return this._executionCount;\n  }\n\n  /**\n   * Whether the effect is currently executing.\n   */\n  get isExecuting(): boolean {\n    return (this.flags & EFFECT_STATE_FLAGS.EXECUTING) !== 0;\n  }\n\n  private _setDisposed(): void {\n    this.flags |= EFFECT_STATE_FLAGS.DISPOSED;\n  }\n\n  private _setExecuting(value: boolean): void {\n    const mask = EFFECT_STATE_FLAGS.EXECUTING;\n    this.flags = (this.flags & ~mask) | (-Number(value) & mask);\n  }\n\n  /**\n   * Executes the cleanup function if it exists.\n   */\n  private _safeCleanup(): void {\n    if (this._cleanup) {\n      try {\n        this._cleanup();\n      } catch (error) {\n        console.error(wrapError(error, EffectError, ERROR_MESSAGES.EFFECT_CLEANUP_FAILED));\n      }\n      this._cleanup = null;\n    }\n  }\n\n  /**\n   * Checks for infinite loops by tracking execution counts within a flush and time period.\n   * @throws {EffectError} If an infinite loop is detected.\n   */\n  private _checkInfiniteLoop(): void {\n    if (this._lastFlushEpoch !== flushEpoch) {\n      this._lastFlushEpoch = flushEpoch;\n      this._executionsInEpoch = 0;\n    }\n\n    this._executionsInEpoch++;\n\n    if (this._executionsInEpoch > this._maxExecutionsPerFlush) {\n      this._throwInfiniteLoopError('per-effect');\n    }\n\n    if (incrementFlushExecutionCount() > SCHEDULER_CONFIG.MAX_EXECUTIONS_PER_FLUSH) {\n      this._throwInfiniteLoopError('global');\n    }\n\n    this._executionCount++;\n\n    if (this._history && this._maxExecutions > 0) {\n      const now = Date.now();\n      const ptr = this._historyPtr;\n      const capacity = this._historyCapacity;\n\n      // 1. Record current timestamp\n      this._history[ptr] = now;\n\n      // 2. Check the oldest timestamp in our window (O(1) lookback)\n      // The slot (ptr + 1) % capacity holds the oldest recorded timestamp in the circular buffer\n      // (or 0 if not yet filled).\n      const oldestPtr = (ptr + 1) % capacity;\n      const oldestTime = this._history[oldestPtr] ?? 0;\n\n      // 3. Update pointer\n      this._historyPtr = oldestPtr;\n\n      // 4. Check if we exceeded the rate limit\n      // If the oldest time (capacity steps ago) is within 1 second of now, we are too fast.\n      // We check > 0 to ensure the buffer is filled at least once.\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\n        if (IS_DEV) {\n          throw error;\n        }\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  /**\n   * Determines if the effect should execute based on dependency versions.\n   * @returns true if any dependency has changed or if it's the first run.\n   */\n  private _shouldExecute(): boolean {\n    // Early exit: no deps or no version cache means first run or invalidated\n    if (this._dependencies === EMPTY_DEPS || this._dependencyVersions === EMPTY_VERSIONS)\n      return true;\n\n    for (let i = 0; i < this._dependencies.length; i++) {\n      const dep = this._dependencies[i];\n      if (!dep) continue;\n\n      if ('value' in dep) {\n        try {\n          untracked(() => (dep as { value: unknown }).value);\n        } catch {\n          return true;\n        }\n      }\n\n      if (dep.version !== this._dependencyVersions[i]) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  /**\n   * Handles errors occurring during effect execution.\n   * Wraps the error, logs it to console, and calls onError callback if provided.\n   */\n  private _handleExecutionError(error: unknown): void {\n    const errorObj = wrapError(error, EffectError, ERROR_MESSAGES.EFFECT_EXECUTION_FAILED);\n    console.error(errorObj);\n    if (this._onError) this._onError(errorObj);\n  }\n\n  /**\n   * Checks for potential infinite loops where an effect modifies its own dependencies.\n   * Only active if trackModifications is enabled and debug is on.\n   */\n  private _checkLoopWarnings(): void {\n    if (this._trackModifications && debug.enabled) {\n      const dependencies = this._dependencies;\n      for (let i = 0; i < dependencies.length; i++) {\n        const dep = dependencies[i];\n        if (dep && dep._modifiedAtEpoch === this._currentEpoch) {\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","EFFECT_STATE_FLAGS","COMPUTED_STATE_FLAGS","ATOM_STATE_FLAGS","POOL_CONFIG","SCHEDULER_CONFIG","DEBUG_CONFIG","SMI_MAX","PHASE_THRESHOLD","IS_DEV","EMPTY_ERROR_ARRAY","AtomError","message","cause","recoverable","ComputedError","EffectError","SchedulerError","ERROR_MESSAGES","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","isUnsubscribed","idx","lastIndex","newValue","oldValue","fnSubs","sub","err","objSubs","ArrayPool","arr","emptyConst","acquired","released","rejected","totalRejected","EMPTY_DEPS","EMPTY_UNSUBS","EMPTY_VERSIONS","depArrayPool","unsubArrayPool","versionArrayPool","isAtom","isComputed","debugType","isEffect","isPromise","value","isNonNullObject","hasDependencyMethod","isPlainListener","hasExecuteMethod","trackDependency","dependency","functionSubscribers","objectSubscribers","syncDependencies","nextDeps","prevDeps","prevUnsubs","tracker","nextUnsubs","collectorEpoch","nextEpoch","currentEpoch","flushEpoch","flushExecutionCount","isFlushing","startFlush","endFlush","incrementFlushExecutionCount","Scheduler","callback","sourceNode","isUrgent","shift","flushStarted","job","iterations","jobs","count","error","max","scheduler","TrackingContext","fn","prev","trackingContext","untracked","AtomImpl","initialValue","sync","atom","options","wrapError","ErrorClass","context","errorMessage","ASYNC_STATE_MASK","ASYNC_STATE_LOOKUP","ComputedAtomImpl","_dep","debugObj","errorSet","depErrors","j","unsub","mask","states","committed","result","commitErr","prevVersions","nextVersions","state","collect","originalAdd","ctx","totalShift","versions","promise","promiseId","resolvedValue","drift","aggregate","callbackError","computed","EffectImpl","asyncCleanup","isFiniteLimit","trackedCount","unsubscribe","now","ptr","capacity","oldestPtr","oldestTime","errorObj","dependencies","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 * Phase-Shift Versioning Constants\n *\n * Implements discrete phase rotation for version management.\n * Inspired by imaginary number rotation (e^iθ) for cyclic state tracking.\n *\n * Version Structure (30 bits total, fits in V8 Smi):\n * - Cycle (upper 10 bits): Complete rotation count (0-1023)\n * - Phase (lower 20 bits): Current angle in discrete steps (0-1,048,575)\n *\n * Operations:\n * - rotatePhase: (version + 1) & 0x3fffffff\n * - getShift: (current - cached) & 0x3fffffff\n * - urgentPriority: ((PHASE_THRESHOLD - 1 - shift) >>> 31) & 1\n */\nexport const PHASE_BITS = 20;\nexport const PHASE_MASK = (1 << PHASE_BITS) - 1; // 0x000fffff (1,048,575)\n\n/**\n * Phase threshold for urgent scheduling (equivalent to 180° rotation)\n * When shift exceeds this value, the job is considered \"urgent\"\n * and placed in the priority queue for glitch reduction.\n */\nexport const PHASE_THRESHOLD = 1 << (PHASE_BITS - 1); // 524,288\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 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  // 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 { 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) return () => {};\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/**\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 */\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;\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 { PHASE_THRESHOLD, 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 with phase-shift tracking support.\n */\nexport interface SchedulerJob {\n  (): void;\n  /** Epoch for deduplication */\n  _nextEpoch?: number;\n  /** Cached version for phase-shift priority calculation */\n  _cachedVersion?: number;\n}\n\n/**\n * Interface for nodes that support phase-shift priority calculation.\n */\ninterface PhaseShiftNode {\n  getShift(cachedVersion: number): number;\n}\n\n/**\n * Scheduler for reactive updates with double-buffered priority queues.\n */\nclass Scheduler {\n  private _queueBuffers: [[SchedulerJob[], SchedulerJob[]], [SchedulerJob[], SchedulerJob[]]];\n  private _bufferIndices: Uint8Array;\n  private _sizes: Uint32Array;\n  private _activeQueues: [SchedulerJob[], SchedulerJob[]];\n  private _epoch: number;\n  private isProcessing: boolean;\n  public 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._queueBuffers = [\n      [[], []], // Normal [0][0], [0][1]\n      [[], []], // Urgent [1][0], [1][1]\n    ];\n    this._bufferIndices = new Uint8Array(2);\n    this._sizes = new Uint32Array(2);\n    this._activeQueues = [this._queueBuffers[0][0], this._queueBuffers[1][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 normal jobs. */\n  get queueSize(): number {\n    return this._sizes[0]!;\n  }\n\n  /** Current number of pending urgent jobs. */\n  get urgentQueueSize(): number {\n    return this._sizes[1]!;\n  }\n\n  /**\n   * Schedules a task for execution with optional priority based on phase shift.\n   */\n  schedule(callback: SchedulerJob, sourceNode?: PhaseShiftNode): void {\n    if (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    // Branchless routing: 0 -> normal, 1 -> urgent\n    const urgent = this._calculateUrgency(callback, sourceNode);\n    this._activeQueues[urgent][this._sizes[urgent]!++] = callback;\n\n    if (!this.isProcessing) {\n      this.flush();\n    }\n  }\n\n  /**\n   * Calculates urgency flag using branchless bit manipulation.\n   *\n   * Logic:\n   * 1. Calculate the 'shift' (rotation distance) from the cached version.\n   * 2. Compare against PHASE_THRESHOLD (180° rotation equivalent).\n   * 3. Use (N >>> 31) to extract the sign bit in O(1) time.\n   *\n   * @returns 1 if urgent (shift >= PHASE_THRESHOLD), 0 otherwise.\n   */\n  private _calculateUrgency(callback: SchedulerJob, sourceNode?: PhaseShiftNode): 0 | 1 {\n    if (!sourceNode || callback._cachedVersion === undefined) {\n      return 0;\n    }\n    const shift = sourceNode.getShift(callback._cachedVersion);\n    // Formula: ((THRESHOLD - 1 - shift) >>> 31) & 1\n    // If shift >= THRESHOLD: (negative >>> 31) = 1\n    // If shift < THRESHOLD: (positive >>> 31) = 0\n    return (((PHASE_THRESHOLD - 1 - shift) >>> 31) & 1) as 0 | 1;\n  }\n\n  /**\n   * Schedules a microtask-based flush of the queues.\n   * Coalesces multiple schedule calls into a single microtask execution.\n   */\n  private flush(): void {\n    if (this.isProcessing || (this._sizes[0]! === 0 && this._sizes[1]! === 0)) return;\n\n    this.isProcessing = true;\n\n    queueMicrotask(() => {\n      try {\n        if (this._sizes[0]! === 0 && this._sizes[1]! === 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._sizes[0]! > 0 || this._sizes[1]! > 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 normal queue.\n   * Increments the epoch/uses provided 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._activeQueues[0];\n    let targetSize = this._sizes[0]!;\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._sizes[0] = 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._sizes[1]! > 0 || this._sizes[0]! > 0) {\n      if (++iterations > maxIterations) {\n        this._handleFlushOverflow();\n        return;\n      }\n\n      if (this._sizes[1]! > 0) this._processQueue(1);\n      if (this._sizes[0]! > 0) this._processQueue(0);\n\n      this._mergeBatchQueue();\n    }\n  }\n\n  private _processQueue(type: 0 | 1): void {\n    const buffers = this._queueBuffers[type];\n    const index = this._bufferIndices[type]!;\n    const jobs = buffers[index]!;\n    const count = this._sizes[type]!;\n\n    // Swap to other buffer branchlessly\n    const nextIndex = index ^ 1;\n    this._bufferIndices[type] = nextIndex;\n    this._activeQueues[type] = buffers[nextIndex]!;\n    this._sizes[type] = 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._sizes[0] = 0;\n    this._activeQueues[0].length = 0;\n    this._sizes[1] = 0;\n    this._activeQueues[1].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        // Density guaranteed by schedule mechanism, avoiding redundant if(job)\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    this.batchDepth = Math.max(0, this.batchDepth - 1);\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    if (!(this.flags & ATOM_STATE_FLAGS.NOTIFICATION_SCHEDULED)) {\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 || obj === undefined || 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 {\n  AsyncState,\n  COMPUTED_STATE_FLAGS,\n  EMPTY_ERROR_ARRAY,\n  PHASE_THRESHOLD,\n  SMI_MAX,\n} 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) return this._value;\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 _getAggregateShift(): number {\n    let totalShift = 0;\n    const deps = this._dependencies;\n    const versions = this._dependencyVersions;\n\n    for (let i = 0, len = deps.length; i < len; i++) {\n      const dep = deps[i];\n      const version = versions[i];\n      if (dep && version !== undefined) {\n        totalShift = (totalShift + dep.getShift(version)) & SMI_MAX;\n      }\n    }\n\n    return totalShift;\n  }\n\n  isUrgent(): boolean {\n    return this._getAggregateShift() >= PHASE_THRESHOLD;\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 drift = (currentAggregate - this._asyncStartAggregateVersion) & SMI_MAX;\n        const isStale = ((PHASE_THRESHOLD - 1 - drift) >>> 31) & 1;\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        aggregate = (aggregate + dep.version) & 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    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    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\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\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_MUST_BE_FUNCTION);\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      if (isPromise(result)) {\n        result\n          .then((asyncCleanup) => {\n            if (!(this.flags & EFFECT_STATE_FLAGS.DISPOSED) && typeof asyncCleanup === 'function') {\n              this._cleanup = asyncCleanup;\n            }\n          })\n          .catch((error) => this._handleExecutionError(error));\n      } else {\n        this._cleanup = typeof result === 'function' ? result : null;\n      }\n    } catch (error) {\n      committed = true; // Still commit what we tracked before the error if possible\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 _setDisposed(): void {\n    this.flags |= EFFECT_STATE_FLAGS.DISPOSED;\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        console.error(wrapError(error, EffectError, 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        if (IS_DEV) throw error;\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(error: unknown): void {\n    const errorObj = wrapError(error, EffectError, ERROR_MESSAGES.EFFECT_EXECUTION_FAILED);\n    console.error(errorObj);\n    const onError = this._onError;\n    if (onError) onError(errorObj);\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","PHASE_THRESHOLD","IS_DEV","EMPTY_ERROR_ARRAY","AtomError","message","cause","recoverable","ComputedError","EffectError","SchedulerError","ERROR_MESSAGES","DEBUG_NAME","DEBUG_ID","DEBUG_TYPE","NO_DEFAULT_VALUE","hasDependencies","obj","globalCheckEpoch","checkCircularInternal","dep","current","epoch","deps","child","debug","condition","type","id","target","nextId","generateId","ReactiveNode","cachedVersion","ReactiveDependency","listener","subs","subscriber","flag","unsubscribed","currentIdx","last","newValue","oldValue","flags","subMask","i","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","sourceNode","urgent","shift","flushStarted","size","queue","targetQueue","targetSize","job","iterations","maxIterations","buffers","index","jobs","count","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","totalShift","version","promise","promiseId","resolvedValue","drift","aggregate","onError","callbackError","computed","EffectImpl","isFiniteLimit","capacity","temp","force","trackedCount","asyncCleanup","ctx","unsubscribe","cleanup","history","now","ptr","nextPtr","oldestTime","errorObj","effect","effectInstance","batch"],"mappings":"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"}