@vedmalex/statemachine 1.0.0-beta.1

package/dist/index.js

@@ -0,0 +1,3943 @@
+// src/scheduler.ts
+var TimerScheduler = class {
+  // Min-Heap: элемент с наименьшим executeAt всегда в index 0
+  heap = [];
+  // Set для быстрой проверки отмененных задач (Lazy Cancellation)
+  // Это позволяет удалять задачи за O(1) без поиска в куче O(n)
+  activeTokens = /* @__PURE__ */ new WeakSet();
+  intervalId = null;
+  pollingInterval = 100;
+  // ms
+  constructor() {
+  }
+  /**
+   * Настройка режима опроса
+   * @param interval Интервал проверки в мс. Если 0 или null - авто-тик выключается (ручной режим)
+   */
+  setPollingInterval(interval) {
+    this.stop();
+    if (interval !== null && interval > 0) {
+      this.pollingInterval = interval;
+      this.start();
+    }
+  }
+  /**
+   * Проверка активности планировщика
+   */
+  isActive() {
+    return this.intervalId !== null;
+  }
+  /**
+   * Запуск единого таймера
+   */
+  start() {
+    if (this.intervalId) return;
+    this.intervalId = setInterval(() => this.process(), this.pollingInterval);
+  }
+  /**
+   * Остановка единого таймера
+   */
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+  }
+  /**
+   * Добавить задачу
+   * @param delay задержка в мс
+   * @param callback функция для выполнения
+   * @returns токен для отмены
+   */
+  schedule(delay, callback) {
+    const token = {};
+    const executeAt = Date.now() + delay;
+    const task = { token, executeAt, callback };
+    this.activeTokens.add(token);
+    this.insert(task);
+    return token;
+  }
+  /**
+   * Отменить задачу
+   * @param token токен задачи
+   */
+  cancel(token) {
+    this.activeTokens.delete(token);
+  }
+  /**
+   * Обработать очередь (вызывается таймером или вручную)
+   */
+  process(now = Date.now()) {
+    while (this.heap.length > 0) {
+      const task = this.heap[0];
+      if (task === void 0) break;
+      if (task.executeAt > now) {
+        break;
+      }
+      this.extractMin();
+      if (this.activeTokens.has(task.token)) {
+        this.activeTokens.delete(task.token);
+        try {
+          task.callback();
+        } catch (e) {
+          console.error("Error in scheduled task", e);
+        }
+      }
+    }
+  }
+  /**
+   * Очистить все задачи
+   */
+  clear() {
+    this.heap = [];
+    this.activeTokens = /* @__PURE__ */ new WeakSet();
+  }
+  // === Min-Heap Implementation ===
+  insert(task) {
+    this.heap.push(task);
+    this.bubbleUp(this.heap.length - 1);
+  }
+  extractMin() {
+    if (this.heap.length === 0) return void 0;
+    const min = this.heap[0];
+    if (min === void 0) return void 0;
+    const last = this.heap.pop();
+    if (this.heap.length > 0 && last !== void 0) {
+      this.heap[0] = last;
+      this.sinkDown(0);
+    }
+    return min;
+  }
+  bubbleUp(index) {
+    while (index > 0) {
+      const parentIndex = Math.floor((index - 1) / 2);
+      const parent = this.heap[parentIndex];
+      const current = this.heap[index];
+      if (parent === void 0 || current === void 0) break;
+      if (parent.executeAt <= current.executeAt) break;
+      this.swap(index, parentIndex);
+      index = parentIndex;
+    }
+  }
+  sinkDown(index) {
+    const length = this.heap.length;
+    const element = this.heap[index];
+    if (element === void 0) return;
+    while (true) {
+      const leftChildIdx = 2 * index + 1;
+      const rightChildIdx = 2 * index + 2;
+      let swapIdx = null;
+      if (leftChildIdx < length) {
+        const leftChild = this.heap[leftChildIdx];
+        if (leftChild !== void 0 && leftChild.executeAt < element.executeAt) {
+          swapIdx = leftChildIdx;
+        }
+      }
+      if (rightChildIdx < length) {
+        const rightChild = this.heap[rightChildIdx];
+        if (rightChild !== void 0) {
+          if (swapIdx === null && rightChild.executeAt < element.executeAt || /* c8 ignore next */
+          swapIdx !== null && this.heap[swapIdx] !== void 0 && rightChild.executeAt < this.heap[swapIdx].executeAt) {
+            swapIdx = rightChildIdx;
+          }
+        }
+      }
+      if (swapIdx === null) break;
+      this.swap(index, swapIdx);
+      index = swapIdx;
+    }
+  }
+  swap(a, b) {
+    const temp = this.heap[a];
+    const other = this.heap[b];
+    if (temp === void 0 || other === void 0) return;
+    this.heap[a] = other;
+    this.heap[b] = temp;
+  }
+};
+function createDefaultScheduler() {
+  return new TimerScheduler();
+}
+
+// src/logger.ts
+var LogLevel = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3,
+  FATAL: 4,
+  OFF: 5
+};
+var LogLevelNames = {
+  [LogLevel.DEBUG]: "DEBUG",
+  [LogLevel.INFO]: "INFO",
+  [LogLevel.WARN]: "WARN",
+  [LogLevel.ERROR]: "ERROR",
+  [LogLevel.FATAL]: "FATAL",
+  [LogLevel.OFF]: "OFF"
+};
+var DEFAULT_LOGGER_CONFIG = {
+  level: LogLevel.WARN,
+  // Only warnings and above in production
+  enableConsole: true,
+  enableStructuredLogging: false,
+  timestampFormat: "iso",
+  includeStackTrace: false
+};
+var ConsoleAppender = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  append(entry) {
+    if (!this.config.enableConsole) return;
+    const timestamp = this.formatTimestamp(entry.timestamp);
+    const levelName = LogLevelNames[entry.level];
+    const prefix = `[${timestamp}] [${levelName}] [${entry.source}]`;
+    if (this.config.enableStructuredLogging) {
+      const structuredEntry = {
+        timestamp: entry.timestamp,
+        level: levelName,
+        source: entry.source,
+        message: entry.message,
+        context: entry.context,
+        error: entry.error?.message
+      };
+      console.log(JSON.stringify(structuredEntry));
+    } else {
+      const message = `${prefix} ${entry.message}`;
+      switch (entry.level) {
+        case LogLevel.DEBUG:
+        case LogLevel.INFO:
+          console.log(message, entry.context || "");
+          break;
+        case LogLevel.WARN:
+          console.warn(message, entry.context || "");
+          break;
+        case LogLevel.ERROR:
+        case LogLevel.FATAL:
+          console.error(message, entry.context || "", entry.error || "");
+          if (this.config.includeStackTrace && entry.error) {
+            console.error(entry.error.stack);
+          }
+          break;
+      }
+    }
+  }
+  formatTimestamp(timestamp) {
+    switch (this.config.timestampFormat) {
+      case "unix":
+        return timestamp.toString();
+      case "relative":
+        return `+${timestamp - Date.now()}ms`;
+      case "iso":
+      default:
+        return new Date(timestamp).toISOString();
+    }
+  }
+};
+var Logger = class _Logger {
+  config;
+  appenders = [];
+  source;
+  constructor(source, config = {}) {
+    this.source = source;
+    this.config = { ...DEFAULT_LOGGER_CONFIG, ...config };
+    this.appenders.push(new ConsoleAppender(this.config));
+  }
+  // Add custom appender
+  addAppender(appender) {
+    this.appenders.push(appender);
+  }
+  // Remove appender
+  removeAppender(appender) {
+    const index = this.appenders.indexOf(appender);
+    if (index > -1) {
+      this.appenders.splice(index, 1);
+    }
+  }
+  // Update configuration
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  // Check if level is enabled
+  isLevelEnabled(level) {
+    return level >= this.config.level && this.config.level !== LogLevel.OFF;
+  }
+  // Core logging method
+  log(level, message, context, error) {
+    if (!this.isLevelEnabled(level)) return;
+    const entry = {
+      timestamp: Date.now(),
+      level,
+      message,
+      ...context !== void 0 ? { context } : {},
+      ...error !== void 0 ? { error } : {},
+      source: this.source
+    };
+    this.appenders.forEach((appender) => {
+      try {
+        appender.append(entry);
+      } catch (e) {
+        console.error("Logger appender failed:", e);
+      }
+    });
+  }
+  // Convenience methods
+  debug(message, context) {
+    this.log(LogLevel.DEBUG, message, context);
+  }
+  info(message, context) {
+    this.log(LogLevel.INFO, message, context);
+  }
+  warn(message, context) {
+    this.log(LogLevel.WARN, message, context);
+  }
+  error(message, context, error) {
+    this.log(LogLevel.ERROR, message, context, error);
+  }
+  fatal(message, context, error) {
+    this.log(LogLevel.FATAL, message, context, error);
+  }
+  // Create child logger with additional context
+  child(childSource, _additionalContext) {
+    const childLogger = new _Logger(`${this.source}.${childSource}`, this.config);
+    childLogger.appenders = this.appenders;
+    return childLogger;
+  }
+};
+var LoggerFactory = class _LoggerFactory {
+  static defaultConfig = DEFAULT_LOGGER_CONFIG;
+  static loggers = /* @__PURE__ */ new Map();
+  static setDefaultConfig(config) {
+    _LoggerFactory.defaultConfig = { ...DEFAULT_LOGGER_CONFIG, ...config };
+  }
+  static getLogger(source, config) {
+    const key = source;
+    if (!_LoggerFactory.loggers.has(key)) {
+      const loggerConfig = config ? { ..._LoggerFactory.defaultConfig, ...config } : _LoggerFactory.defaultConfig;
+      _LoggerFactory.loggers.set(key, new Logger(source, loggerConfig));
+    }
+    return _LoggerFactory.loggers.get(key);
+  }
+  static clearLoggers() {
+    _LoggerFactory.loggers.clear();
+  }
+};
+var getLogger = LoggerFactory.getLogger;
+var stateMachineLogger = getLogger("StateMachine");
+var securityLogger = getLogger("Security");
+
+// src/security.ts
+var BUILTIN_PATTERNS = [
+  {
+    pattern: /\beval\s*\(/gi,
+    risk: "critical",
+    description: "Direct eval() usage",
+    category: "eval"
+  },
+  {
+    pattern: /\bFunction\s*\(/gi,
+    risk: "high",
+    description: "Dynamic Function constructor call",
+    category: "eval"
+  },
+  {
+    pattern: /new\s+Function\s*\(/gi,
+    risk: "high",
+    description: "Dynamic function creation",
+    category: "eval"
+  },
+  {
+    pattern: /setTimeout\s*\(\s*['"`][^'"`]*['"`]/gi,
+    risk: "high",
+    description: "setTimeout with string code",
+    category: "eval"
+  },
+  {
+    pattern: /setInterval\s*\(\s*['"`][^'"`]*['"`]/gi,
+    risk: "high",
+    description: "setInterval with string code",
+    category: "eval"
+  },
+  {
+    pattern: /\bfetch\s*\(/gi,
+    risk: "medium",
+    description: "Network request via fetch",
+    category: "network"
+  },
+  {
+    pattern: /XMLHttpRequest/gi,
+    risk: "medium",
+    description: "XMLHttpRequest usage",
+    category: "network"
+  },
+  {
+    pattern: /WebSocket/gi,
+    risk: "medium",
+    description: "WebSocket connection",
+    category: "network"
+  },
+  {
+    pattern: /require\s*\(\s*['"`]fs['"`]\s*\)/gi,
+    risk: "high",
+    description: 'File system access via require("fs")',
+    category: "filesystem"
+  },
+  {
+    pattern: /import.*from\s*['"`]fs['"`]/gi,
+    risk: "high",
+    description: "File system access via import",
+    category: "filesystem"
+  },
+  {
+    pattern: /document\./gi,
+    risk: "medium",
+    description: "DOM access",
+    category: "dom"
+  },
+  {
+    pattern: /window\./gi,
+    risk: "medium",
+    description: "Window object access",
+    category: "dom"
+  },
+  {
+    pattern: /innerHTML/gi,
+    risk: "high",
+    description: "innerHTML manipulation (XSS risk)",
+    category: "dom"
+  },
+  {
+    pattern: /global\./gi,
+    risk: "high",
+    description: "Global scope access",
+    category: "global"
+  },
+  {
+    pattern: /process\./gi,
+    risk: "high",
+    description: "Process object access",
+    category: "process"
+  },
+  {
+    pattern: /child_process/gi,
+    risk: "critical",
+    description: "Child process execution",
+    category: "process"
+  },
+  {
+    pattern: /exec\s*\(/gi,
+    risk: "critical",
+    description: "Command execution",
+    category: "process"
+  },
+  {
+    pattern: /require\s*\(/gi,
+    risk: "critical",
+    description: "CommonJS require",
+    category: "module"
+  },
+  {
+    pattern: /import\s*\(/gi,
+    risk: "critical",
+    description: "Dynamic import",
+    category: "module"
+  },
+  {
+    pattern: /__proto__/gi,
+    risk: "critical",
+    description: "Prototype pollution",
+    category: "prototype"
+  },
+  {
+    pattern: /constructor/gi,
+    risk: "critical",
+    description: "Constructor access",
+    category: "prototype"
+  },
+  {
+    pattern: /prototype/gi,
+    risk: "critical",
+    description: "Prototype access",
+    category: "prototype"
+  },
+  {
+    pattern: /\[['"]__proto__['"]\]/gi,
+    risk: "critical",
+    description: "Prototype pollution via bracket notation",
+    category: "prototype"
+  },
+  {
+    pattern: /constructor\s*\[/gi,
+    risk: "critical",
+    description: "Constructor access via bracket notation",
+    category: "prototype"
+  }
+];
+var DEFAULT_SECURITY_CONFIG = {
+  allowedFunctionNames: /* @__PURE__ */ new Set([
+    // Common safe function patterns
+    "onEnter",
+    "onExit",
+    "onBeforeEnter",
+    "onAfterEnter",
+    "onBeforeExit",
+    "onAfterExit",
+    "onTransition",
+    "onError",
+    "guard",
+    "onBefore",
+    "onAfter",
+    "onSuccess",
+    // Internal serializer function names (used as metadata)
+    "config_onError",
+    "state_onError",
+    "event_onBefore",
+    "event_onAfter",
+    "event_onSuccess",
+    "event_onError",
+    "transition_guard",
+    "transition_onTransition",
+    "transition_onError",
+    "invoke_cond",
+    "invoke_action",
+    // Legacy deserialization marker
+    "legacy_deserialization"
+  ]),
+  maxFunctionLength: 1e4,
+  // 10KB limit
+  enableValidation: true,
+  customPatterns: []
+};
+var FunctionValidator = class {
+  config;
+  allPatterns;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_SECURITY_CONFIG, ...config };
+    this.allPatterns = [
+      ...BUILTIN_PATTERNS,
+      ...this.config.customPatterns ?? []
+    ];
+  }
+  addCustomPattern(pattern) {
+    this.allPatterns.push(pattern);
+  }
+  /**
+   * Validates function body for security threats.
+   *
+   * Never throws: returns a structured result.
+   */
+  validate(body, functionName) {
+    if (!this.config.enableValidation) {
+      return {
+        isValid: true,
+        errors: [],
+        riskLevel: "low",
+        detectedPatterns: []
+      };
+    }
+    const errors = [];
+    const detectedPatterns = [];
+    let riskLevel = "low";
+    if (body.length > this.config.maxFunctionLength) {
+      errors.push(
+        `Function body exceeds maximum length of ${this.config.maxFunctionLength} characters`
+      );
+      riskLevel = "high";
+    }
+    const riskPriority = {
+      low: 0,
+      medium: 1,
+      high: 2,
+      critical: 3
+    };
+    for (const { pattern, risk, description } of this.allPatterns) {
+      if (pattern.global || pattern.sticky) {
+        pattern.lastIndex = 0;
+      }
+      if (pattern.test(body)) {
+        errors.push(`Function contains dangerous pattern: ${description}`);
+        detectedPatterns.push(description);
+        if (riskPriority[risk] > riskPriority[riskLevel]) {
+          riskLevel = risk;
+        }
+      }
+    }
+    if (functionName && !this.config.allowedFunctionNames.has(functionName)) {
+      errors.push(`Function name '${functionName}' is not in allowed list`);
+      if (riskLevel === "low") riskLevel = "medium";
+    }
+    return {
+      isValid: errors.length === 0,
+      errors,
+      riskLevel,
+      detectedPatterns
+    };
+  }
+  /**
+   * Validates function body for security threats
+   */
+  validateFunctionBody(body, functionName) {
+    const result = this.validate(body, functionName);
+    if (!result.isValid) {
+      throw new Error(result.errors.join("; "));
+    }
+    return result.isValid;
+  }
+  /**
+   * Creates a security hash for function validation
+   */
+  async createSecurityHash(body, metadata) {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(body + JSON.stringify(metadata));
+    if (typeof crypto !== "undefined" && crypto.subtle) {
+      const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+      return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    const str = body + JSON.stringify(metadata);
+    let hash = 2166136261;
+    for (let i = 0; i < str.length; i++) {
+      hash ^= str.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16);
+  }
+  /**
+   * Validates security hash
+   */
+  async validateSecurityHash(body, metadata, expectedHash) {
+    const actualHash = await this.createSecurityHash(body, metadata);
+    return actualHash === expectedHash;
+  }
+};
+var SafeFunctionSerializer = class {
+  validator;
+  constructor(config) {
+    this.validator = new FunctionValidator(config);
+  }
+  /**
+   * Safely serializes an action with security validation (Async)
+   */
+  async serializeActionAsync(action, functionName) {
+    if (typeof action === "string") {
+      return { type: "string", name: action };
+    } else if (typeof action === "function") {
+      const body = action.toString();
+      this.validator.validateFunctionBody(body, functionName);
+      const metadata = {
+        length: body.length,
+        createdAt: Date.now(),
+        ...functionName !== void 0 ? { functionName } : {}
+      };
+      const hash = await this.validator.createSecurityHash(body, metadata);
+      return {
+        type: "function",
+        body,
+        hash,
+        metadata
+      };
+    }
+    return void 0;
+  }
+  /**
+   * Legacy synchronous serialization (Uses weak hash, kept for backward compatibility)
+   * @deprecated Use serializeActionAsync instead for better security
+   */
+  serializeAction(action, functionName) {
+    if (typeof action === "string") {
+      return { type: "string", name: action };
+    } else if (typeof action === "function") {
+      const body = action.toString();
+      this.validator.validateFunctionBody(body, functionName);
+      const metadata = {
+        length: body.length,
+        createdAt: Date.now(),
+        ...functionName !== void 0 ? { functionName } : {}
+      };
+      const str = body + JSON.stringify(metadata);
+      let hash = 2166136261;
+      for (let i = 0; i < str.length; i++) {
+        hash ^= str.charCodeAt(i);
+        hash = Math.imul(hash, 16777619);
+      }
+      return {
+        type: "function",
+        body,
+        hash: (hash >>> 0).toString(16),
+        metadata
+      };
+    }
+    return void 0;
+  }
+  /**
+   * Safely deserializes an action with security validation (Async)
+   */
+  async deserializeActionAsync(serializedAction) {
+    if (!serializedAction) {
+      return void 0;
+    }
+    if (serializedAction.type === "string") {
+      return serializedAction.name;
+    } else if (serializedAction.type === "function") {
+      try {
+        const isValid = await this.validator.validateSecurityHash(
+          serializedAction.body,
+          serializedAction.metadata,
+          serializedAction.hash
+        );
+        if (!isValid) {
+          const str = serializedAction.body + JSON.stringify(serializedAction.metadata);
+          let hash = 2166136261;
+          for (let i = 0; i < str.length; i++) {
+            hash ^= str.charCodeAt(i);
+            hash = Math.imul(hash, 16777619);
+          }
+          const legacyHash = (hash >>> 0).toString(16);
+          if (legacyHash !== serializedAction.hash) {
+            throw new Error("Function security hash validation failed");
+          }
+        }
+        this.validator.validateFunctionBody(
+          serializedAction.body,
+          serializedAction.metadata.functionName
+        );
+        return this.createSafeFunction(serializedAction.body);
+      } catch (e) {
+        securityLogger.error(
+          "Error deserializing function",
+          {
+            functionName: serializedAction.metadata.functionName,
+            bodyLength: serializedAction.body.length,
+            hash: serializedAction.hash
+          },
+          e instanceof Error ? e : new Error(String(e))
+        );
+        return void 0;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Safely deserializes an action (Synchronous - Legacy/Weak)
+   */
+  deserializeAction(serializedAction) {
+    if (!serializedAction) {
+      return void 0;
+    }
+    if (serializedAction.type === "string") {
+      return serializedAction.name;
+    } else if (serializedAction.type === "function") {
+      try {
+        const str = serializedAction.body + JSON.stringify(serializedAction.metadata);
+        let hash = 2166136261;
+        for (let i = 0; i < str.length; i++) {
+          hash ^= str.charCodeAt(i);
+          hash = Math.imul(hash, 16777619);
+        }
+        const calculatedHash = (hash >>> 0).toString(16);
+        if (calculatedHash !== serializedAction.hash) {
+          if (serializedAction.hash.length === 64) {
+            console.warn(
+              "Warning: Skipping verification of SHA-256 hash in synchronous deserializeAction. Use deserializeActionAsync for security."
+            );
+          } else {
+            throw new Error("Function security hash validation failed (Legacy)");
+          }
+        }
+        this.validator.validateFunctionBody(
+          serializedAction.body,
+          serializedAction.metadata.functionName
+        );
+        return this.createSafeFunction(serializedAction.body);
+      } catch (e) {
+        securityLogger.error(
+          "Error deserializing function",
+          {
+            functionName: serializedAction.metadata.functionName,
+            bodyLength: serializedAction.body.length,
+            hash: serializedAction.hash
+          },
+          e instanceof Error ? e : new Error(String(e))
+        );
+        return void 0;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Safely deserializes legacy function strings (without security metadata)
+   * This method provides backward compatibility for old string-based function serialization
+   * while maintaining security through validation and sandboxing.
+   */
+  deserializeLegacyString(action) {
+    if (!action || typeof action !== "string") {
+      return void 0;
+    }
+    try {
+      this.validator.validateFunctionBody(action, "legacy_deserialization");
+      return this.createSafeFunction(action);
+    } catch (e) {
+      securityLogger.error(
+        "Blocked unsafe legacy function string",
+        { actionLength: action.length },
+        e instanceof Error ? e : new Error(String(e))
+      );
+      return void 0;
+    }
+  }
+  /**
+   * Creates a function safely without using new Function()
+   * Uses a whitelist approach with predefined function templates
+   */
+  createSafeFunction(body) {
+    try {
+      const source = body.trim();
+      const executor = new Function(
+        "adaptee",
+        "args",
+        `
+        // Block dangerous globals by creating local variables that shadow them
+        var eval = undefined;
+        var Function = undefined;
+        var setTimeout = undefined;
+        var setInterval = undefined;
+        var document = undefined;
+        var window = undefined;
+        var global = undefined;
+        var process = undefined;
+        var require = undefined;
+
+        const __fn = (${source});
+        if (typeof __fn !== 'function') {
+          throw new Error('Deserialized source is not a function');
+        }
+        return __fn(adaptee, ...(Array.isArray(args) ? args : []));
+      `
+      );
+      return ((adaptee, ...args) => executor(adaptee, args));
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      throw new Error(`Failed to create safe function: ${message}`);
+    }
+  }
+};
+var safeFunctionSerializer = new SafeFunctionSerializer();
+var serializeAction = safeFunctionSerializer.serializeAction.bind(
+  safeFunctionSerializer
+);
+var deserializeAction = safeFunctionSerializer.deserializeAction.bind(
+  safeFunctionSerializer
+);
+
+// src/monitoring.ts
+var HealthStatus = {
+  HEALTHY: "healthy",
+  WARNING: "warning",
+  CRITICAL: "critical",
+  UNKNOWN: "unknown"
+};
+var DEFAULT_MONITORING_CONFIG = {
+  enabled: true,
+  metricsInterval: 5e3,
+  // 5 seconds
+  healthCheckInterval: 3e4,
+  // 30 seconds
+  maxMetricsHistory: 1e3,
+  thresholds: {
+    transitionTimeWarning: 100,
+    // 100ms
+    transitionTimeCritical: 500,
+    // 500ms
+    errorRateWarning: 5,
+    // 5%
+    errorRateCritical: 15
+    // 15%
+  }
+};
+var MetricsCollector = class {
+  metrics = [];
+  config;
+  startTime = Date.now();
+  transitionCount = 0;
+  errorCount = 0;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_MONITORING_CONFIG, ...config };
+  }
+  /**
+   * Record a state transition
+   */
+  recordTransition(transitionTime) {
+    if (!this.config.enabled) return;
+    this.transitionCount++;
+    const metrics = {
+      transitionTime,
+      stateChangeCount: this.transitionCount,
+      errorCount: this.errorCount,
+      timestamp: Date.now()
+    };
+    this.addMetrics(metrics);
+    this.logMetrics(metrics);
+  }
+  /**
+   * Record an error
+   */
+  recordError() {
+    if (!this.config.enabled) return;
+    this.errorCount++;
+  }
+  /**
+   * Get current metrics summary
+   */
+  getMetricsSummary() {
+    const now = Date.now();
+    const uptime = now - this.startTime;
+    const recentMetrics = this.getRecentMetrics(6e4);
+    const averageTransitionTime = recentMetrics.length > 0 ? recentMetrics.reduce((sum, m) => sum + m.transitionTime, 0) / recentMetrics.length : 0;
+    const errorRate = this.transitionCount > 0 ? this.errorCount / this.transitionCount * 100 : 0;
+    return {
+      totalTransitions: this.transitionCount,
+      totalErrors: this.errorCount,
+      averageTransitionTime,
+      errorRate,
+      uptime
+    };
+  }
+  /**
+   * Get metrics history
+   */
+  getMetricsHistory(timeRange) {
+    if (timeRange) {
+      return this.getRecentMetrics(timeRange);
+    }
+    return [...this.metrics];
+  }
+  /**
+   * Clear metrics history
+   */
+  clearMetrics() {
+    this.metrics = [];
+    this.transitionCount = 0;
+    this.errorCount = 0;
+    this.startTime = Date.now();
+  }
+  /**
+   * Get recent metrics within time range
+   */
+  getRecentMetrics(timeRange) {
+    const cutoff = Date.now() - timeRange;
+    return this.metrics.filter((m) => m.timestamp >= cutoff);
+  }
+  /**
+   * Add metrics to history with size limit
+   */
+  addMetrics(metrics) {
+    this.metrics.push(metrics);
+    if (this.metrics.length > this.config.maxMetricsHistory) {
+      this.metrics = this.metrics.slice(-this.config.maxMetricsHistory);
+    }
+  }
+  /**
+   * Log metrics if significant
+   */
+  logMetrics(metrics) {
+    const { thresholds } = this.config;
+    if (metrics.transitionTime > thresholds.transitionTimeCritical) {
+      stateMachineLogger.error("Critical transition time detected", {
+        transitionTime: metrics.transitionTime,
+        threshold: thresholds.transitionTimeCritical
+      });
+    } else if (metrics.transitionTime > thresholds.transitionTimeWarning) {
+      stateMachineLogger.warn("Slow transition detected", {
+        transitionTime: metrics.transitionTime,
+        threshold: thresholds.transitionTimeWarning
+      });
+    }
+  }
+};
+var PerformanceMonitor = class {
+  metricsCollector;
+  config;
+  intervalId;
+  isRunning = false;
+  constructor(metricsCollector, config = {}) {
+    this.metricsCollector = metricsCollector;
+    this.config = { ...DEFAULT_MONITORING_CONFIG, ...config };
+  }
+  /**
+   * Start performance monitoring
+   */
+  start() {
+    if (this.isRunning || !this.config.enabled) return;
+    this.isRunning = true;
+    this.intervalId = setInterval(() => {
+      this.collectMetrics();
+    }, this.config.metricsInterval);
+    stateMachineLogger.info("Performance monitoring started", {
+      interval: this.config.metricsInterval
+    });
+  }
+  /**
+   * Stop performance monitoring
+   */
+  stop() {
+    if (!this.isRunning) return;
+    this.isRunning = false;
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = void 0;
+    }
+    stateMachineLogger.info("Performance monitoring stopped");
+  }
+  /**
+   * Get current performance status
+   */
+  getPerformanceStatus() {
+    const summary = this.metricsCollector.getMetricsSummary();
+    const issues = [];
+    let status = HealthStatus.HEALTHY;
+    if (summary.errorRate >= this.config.thresholds.errorRateCritical) {
+      status = HealthStatus.CRITICAL;
+      issues.push(`Critical error rate: ${summary.errorRate.toFixed(2)}%`);
+    } else if (summary.errorRate >= this.config.thresholds.errorRateWarning) {
+      status = HealthStatus.WARNING;
+      issues.push(`High error rate: ${summary.errorRate.toFixed(2)}%`);
+    }
+    if (summary.averageTransitionTime >= this.config.thresholds.transitionTimeCritical) {
+      status = HealthStatus.CRITICAL;
+      issues.push(
+        `Critical transition time: ${summary.averageTransitionTime.toFixed(2)}ms`
+      );
+    } else if (summary.averageTransitionTime >= this.config.thresholds.transitionTimeWarning) {
+      if (status === HealthStatus.HEALTHY) status = HealthStatus.WARNING;
+      issues.push(
+        `Slow transitions: ${summary.averageTransitionTime.toFixed(2)}ms`
+      );
+    }
+    return { status, summary, issues };
+  }
+  /**
+   * Collect current metrics
+   */
+  collectMetrics() {
+    const summary = this.metricsCollector.getMetricsSummary();
+    stateMachineLogger.debug("Performance metrics collected", {
+      totalTransitions: summary.totalTransitions,
+      errorRate: summary.errorRate,
+      averageTransitionTime: summary.averageTransitionTime
+    });
+  }
+};
+var HealthChecker = class {
+  performanceMonitor;
+  config;
+  intervalId;
+  isRunning = false;
+  lastHealthCheck;
+  constructor(performanceMonitor, config = {}) {
+    this.performanceMonitor = performanceMonitor;
+    this.config = { ...DEFAULT_MONITORING_CONFIG, ...config };
+  }
+  /**
+   * Start health checking
+   */
+  start() {
+    if (this.isRunning || !this.config.enabled) return;
+    this.isRunning = true;
+    this.intervalId = setInterval(() => {
+      this.performHealthCheck();
+    }, this.config.healthCheckInterval);
+    stateMachineLogger.info("Health checking started", {
+      interval: this.config.healthCheckInterval
+    });
+  }
+  /**
+   * Stop health checking
+   */
+  stop() {
+    if (!this.isRunning) return;
+    this.isRunning = false;
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = void 0;
+    }
+    stateMachineLogger.info("Health checking stopped");
+  }
+  /**
+   * Perform immediate health check
+   */
+  performHealthCheck() {
+    const performanceStatus = this.performanceMonitor.getPerformanceStatus();
+    const result = {
+      status: performanceStatus.status,
+      message: this.generateHealthMessage(performanceStatus),
+      timestamp: Date.now(),
+      metrics: performanceStatus.summary
+    };
+    this.lastHealthCheck = result;
+    this.logHealthCheck(result);
+    return result;
+  }
+  /**
+   * Get last health check result
+   */
+  getLastHealthCheck() {
+    return this.lastHealthCheck;
+  }
+  /**
+   * Generate health message based on status
+   */
+  generateHealthMessage(performanceStatus) {
+    const { status, issues, summary } = performanceStatus;
+    if (status === HealthStatus.HEALTHY) {
+      return `StateMachine is healthy. ${summary.totalTransitions} transitions, ${summary.errorRate.toFixed(2)}% error rate`;
+    }
+    if (status === HealthStatus.WARNING) {
+      return `StateMachine has warnings: ${issues.join(", ")}`;
+    }
+    if (status === HealthStatus.CRITICAL) {
+      return `StateMachine is in critical state: ${issues.join(", ")}`;
+    }
+    return "StateMachine health status unknown";
+  }
+  /**
+   * Log health check results
+   */
+  logHealthCheck(result) {
+    const logData = {
+      status: result.status,
+      message: result.message,
+      metrics: result.metrics
+    };
+    switch (result.status) {
+      case HealthStatus.HEALTHY:
+        stateMachineLogger.debug("Health check passed", logData);
+        break;
+      case HealthStatus.WARNING:
+        stateMachineLogger.warn("Health check warning", logData);
+        break;
+      case HealthStatus.CRITICAL:
+        stateMachineLogger.error("Health check critical", logData);
+        break;
+      /* c8 ignore next 2 */
+      default:
+        stateMachineLogger.info("Health check completed", logData);
+    }
+  }
+};
+var StateMachineMonitor = class {
+  metricsCollector;
+  performanceMonitor;
+  healthChecker;
+  config;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_MONITORING_CONFIG, ...config };
+    this.metricsCollector = new MetricsCollector(this.config);
+    this.performanceMonitor = new PerformanceMonitor(
+      this.metricsCollector,
+      this.config
+    );
+    this.healthChecker = new HealthChecker(this.performanceMonitor, this.config);
+  }
+  /**
+   * Start all monitoring components
+   */
+  start() {
+    this.performanceMonitor.start();
+    this.healthChecker.start();
+    stateMachineLogger.info("StateMachine monitoring started", {
+      config: this.config
+    });
+  }
+  /**
+   * Stop all monitoring components
+   */
+  stop() {
+    this.performanceMonitor.stop();
+    this.healthChecker.stop();
+    stateMachineLogger.info("StateMachine monitoring stopped");
+  }
+  /**
+   * Record a transition for monitoring (F-T4-TS-5 widening: added success + context params)
+   */
+  recordTransition(transitionTime, success = true, _context) {
+    this.metricsCollector.recordTransition(transitionTime);
+    if (!success) this.metricsCollector.recordError();
+  }
+  /**
+   * Record an error for monitoring (F-T4-TS-5 widening: added error + context params)
+   */
+  recordError(_error, _context) {
+    this.metricsCollector.recordError();
+  }
+  /**
+   * Record an event for monitoring (optional IMonitor extension)
+   */
+  recordEvent(_eventName, _duration) {
+  }
+  /**
+   * Get aggregate metrics snapshot (optional IMonitor extension)
+   */
+  getMetrics() {
+    const summary = this.metricsCollector.getMetricsSummary();
+    return {
+      totalTransitions: summary.totalTransitions,
+      successCount: summary.totalTransitions - summary.totalErrors,
+      errorCount: summary.totalErrors,
+      averageDuration: summary.averageTransitionTime
+    };
+  }
+  /**
+   * Get comprehensive monitoring report
+   */
+  getMonitoringReport() {
+    const health = this.healthChecker.performHealthCheck();
+    const performance = this.performanceMonitor.getPerformanceStatus();
+    const metrics = this.metricsCollector.getMetricsSummary();
+    return {
+      health,
+      performance,
+      metrics,
+      config: this.config
+    };
+  }
+  /**
+   * Export metrics for external monitoring systems
+   */
+  exportMetrics() {
+    const metrics = this.metricsCollector.getMetricsSummary();
+    const health = this.healthChecker.getLastHealthCheck();
+    const jsonExport = {
+      timestamp: Date.now(),
+      metrics,
+      health,
+      config: this.config
+    };
+    const prometheusExport = this.generatePrometheusMetrics(metrics, health);
+    return {
+      prometheus: prometheusExport,
+      json: jsonExport
+    };
+  }
+  /**
+   * Generate Prometheus-compatible metrics (without memory metrics)
+   */
+  generatePrometheusMetrics(metrics, health) {
+    const lines = [];
+    lines.push(
+      "# HELP statemachine_transitions_total Total number of state transitions"
+    );
+    lines.push("# TYPE statemachine_transitions_total counter");
+    lines.push(`statemachine_transitions_total ${metrics.totalTransitions}`);
+    lines.push("# HELP statemachine_errors_total Total number of errors");
+    lines.push("# TYPE statemachine_errors_total counter");
+    lines.push(`statemachine_errors_total ${metrics.totalErrors}`);
+    lines.push(
+      "# HELP statemachine_transition_time_avg Average transition time in milliseconds"
+    );
+    lines.push("# TYPE statemachine_transition_time_avg gauge");
+    lines.push(
+      `statemachine_transition_time_avg ${metrics.averageTransitionTime}`
+    );
+    lines.push("# HELP statemachine_error_rate Error rate percentage");
+    lines.push("# TYPE statemachine_error_rate gauge");
+    lines.push(`statemachine_error_rate ${metrics.errorRate}`);
+    lines.push("# HELP statemachine_uptime Uptime in milliseconds");
+    lines.push("# TYPE statemachine_uptime gauge");
+    lines.push(`statemachine_uptime ${metrics.uptime}`);
+    if (health) {
+      const healthValue = health.status === HealthStatus.HEALTHY ? 1 : health.status === HealthStatus.WARNING ? 0.5 : 0;
+      lines.push(
+        "# HELP statemachine_health Health status (1=healthy, 0.5=warning, 0=critical)"
+      );
+      lines.push("# TYPE statemachine_health gauge");
+      lines.push(`statemachine_health ${healthValue}`);
+    }
+    return lines.join("\n");
+  }
+};
+function createDefaultMonitor() {
+  return new StateMachineMonitor();
+}
+
+// src/types.ts
+var StateMachineError = class _StateMachineError extends Error {
+  context;
+  constructor(message, context, cause) {
+    super(message);
+    this.name = "StateMachineError";
+    this.context = context;
+    this.cause = cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _StateMachineError);
+    }
+  }
+  toString() {
+    const { state, event, action, transition, phase } = this.context;
+    const details = [];
+    if (state) details.push(`state: ${state}`);
+    if (event) details.push(`event: ${event}`);
+    if (action) details.push(`action: ${action}`);
+    if (transition) details.push(`transition: ${transition}`);
+    if (phase) details.push(`phase: ${phase}`);
+    return `${this.name}: ${this.message}${details.length ? ` (${details.join(", ")})` : ""}`;
+  }
+};
+function isAdapter(inp) {
+  return !!inp && typeof inp === "object" && "set" in inp && "get" in inp;
+}
+var MemoryAdapter = class {
+  adaptee;
+  _savedState;
+  constructor(data) {
+    this.adaptee = data;
+  }
+  set(property, value) {
+    this.adaptee[property] = value;
+  }
+  get(property) {
+    return this.adaptee[property];
+  }
+  // StatePersistenceAdapter implementation
+  async save(state) {
+    this._savedState = state;
+  }
+  async restore() {
+    return this._savedState;
+  }
+};
+var LocalStorageAdapter = class {
+  adaptee;
+  key;
+  constructor(data, storageKey = "state_machine") {
+    this.adaptee = data;
+    this.key = storageKey;
+  }
+  set(property, value) {
+    this.adaptee[property] = value;
+  }
+  get(property) {
+    return this.adaptee[property];
+  }
+  // StatePersistenceAdapter implementation
+  async save(state) {
+    const data = { ...this.adaptee, state };
+    globalThis.localStorage.setItem(this.key, JSON.stringify(data));
+  }
+  async restore() {
+    const stored = globalThis.localStorage.getItem(this.key);
+    return stored ? JSON.parse(stored).state : { currentState: "", history: {} };
+  }
+};
+var SessionStorageAdapter = class {
+  adaptee;
+  key;
+  constructor(data, storageKey = "state_machine") {
+    this.adaptee = data;
+    this.key = storageKey;
+  }
+  set(property, value) {
+    this.adaptee[property] = value;
+  }
+  get(property) {
+    return this.adaptee[property];
+  }
+  // StatePersistenceAdapter implementation
+  async save(state) {
+    const data = { ...this.adaptee, state };
+    globalThis.sessionStorage.setItem(this.key, JSON.stringify(data));
+  }
+  async restore() {
+    const stored = globalThis.sessionStorage.getItem(this.key);
+    return stored ? JSON.parse(stored).state : void 0;
+  }
+};
+var ServerAdapter = class _ServerAdapter {
+  adaptee;
+  static data = {};
+  endpoint;
+  constructor(data, endpoint = "/api/state") {
+    this.adaptee = data;
+    this.endpoint = endpoint;
+  }
+  set(property, value) {
+    this.adaptee[property] = value;
+  }
+  get(property) {
+    return this.adaptee[property];
+  }
+  // StatePersistenceAdapter implementation (simulated async)
+  async save(state) {
+    if (state) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      _ServerAdapter.data[this.endpoint] = state;
+    }
+  }
+  async restore() {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    return _ServerAdapter.data[this.endpoint] || { currentState: "", history: {} };
+  }
+};
+
+// src/error_handling.ts
+var ErrorSeverity = {
+  LOW: "low",
+  MEDIUM: "medium",
+  HIGH: "high",
+  CRITICAL: "critical"
+};
+var ErrorCategory = {
+  VALIDATION: "validation",
+  TRANSITION: "transition",
+  ACTION: "action",
+  SERIALIZATION: "serialization",
+  CONFIGURATION: "configuration",
+  SECURITY: "security",
+  PERFORMANCE: "performance",
+  NETWORK: "network",
+  UNKNOWN: "unknown"
+};
+var EnhancedStateMachineError = class extends StateMachineError {
+  severity;
+  category;
+  extendedContext;
+  recoverable;
+  errorCode;
+  constructor(message, context, options = {}) {
+    super(message, context, options.cause);
+    this.severity = options.severity || ErrorSeverity.MEDIUM;
+    this.category = options.category || ErrorCategory.UNKNOWN;
+    this.recoverable = options.recoverable ?? true;
+    this.errorCode = options.errorCode || this.generateErrorCode();
+    this.extendedContext = {
+      ...context,
+      timestamp: Date.now(),
+      stackTrace: this.stack,
+      additionalData: options.additionalData
+    };
+  }
+  generateErrorCode() {
+    const categoryCode = this.category.toUpperCase().substring(0, 3);
+    const severityCode = this.severity.toUpperCase().substring(0, 1);
+    const timestamp = Date.now().toString().slice(-6);
+    return `SM_${categoryCode}_${severityCode}_${timestamp}`;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      errorCode: this.errorCode,
+      severity: this.severity,
+      category: this.category,
+      recoverable: this.recoverable,
+      context: this.extendedContext,
+      stack: this.stack
+    };
+  }
+};
+var RetryRecoveryStrategy = class {
+  name = "retry";
+  maxRetries;
+  retryDelay;
+  constructor(maxRetries = 3, retryDelay = 1e3) {
+    this.maxRetries = maxRetries;
+    this.retryDelay = retryDelay;
+  }
+  canRecover(error) {
+    return error.recoverable && error.category !== ErrorCategory.SECURITY && error.severity !== ErrorSeverity.CRITICAL;
+  }
+  async recover(error, context) {
+    const retryCount = context.retryCount || 0;
+    if (retryCount >= this.maxRetries) {
+      stateMachineLogger.warn("Max retries exceeded", {
+        errorCode: error.errorCode,
+        retryCount,
+        maxRetries: this.maxRetries
+      });
+      return false;
+    }
+    stateMachineLogger.info("Attempting error recovery", {
+      errorCode: error.errorCode,
+      strategy: this.name,
+      attempt: retryCount + 1
+    });
+    await new Promise((resolve) => setTimeout(resolve, this.retryDelay));
+    context.retryCount = retryCount + 1;
+    return true;
+  }
+};
+var FallbackStateRecoveryStrategy = class {
+  name = "fallback_state";
+  fallbackState;
+  constructor(fallbackState = "error_state") {
+    this.fallbackState = fallbackState;
+  }
+  canRecover(error) {
+    return error.category === ErrorCategory.TRANSITION || error.category === ErrorCategory.ACTION;
+  }
+  async recover(error, context) {
+    try {
+      if (context.stateMachine && typeof context.stateMachine.setCurrentState === "function") {
+        stateMachineLogger.info("Recovering to fallback state", {
+          errorCode: error.errorCode,
+          fallbackState: this.fallbackState,
+          originalState: error.context.state
+        });
+        context.stateMachine.setCurrentState(this.fallbackState);
+        return true;
+      }
+    } catch (recoveryError) {
+      stateMachineLogger.error(
+        "Fallback recovery failed",
+        {
+          errorCode: error.errorCode,
+          fallbackState: this.fallbackState
+        },
+        /* c8 ignore next */
+        recoveryError instanceof Error ? recoveryError : new Error(String(recoveryError))
+      );
+    }
+    return false;
+  }
+};
+var ErrorAnalytics = class {
+  errors = [];
+  maxStoredErrors;
+  constructor(maxStoredErrors = 1e3) {
+    this.maxStoredErrors = maxStoredErrors;
+  }
+  recordError(error) {
+    this.errors.push(error);
+    if (this.errors.length > this.maxStoredErrors) {
+      this.errors = this.errors.slice(-this.maxStoredErrors);
+    }
+    stateMachineLogger.error(
+      "StateMachine error recorded",
+      {
+        errorCode: error.errorCode,
+        severity: error.severity,
+        category: error.category,
+        recoverable: error.recoverable
+      },
+      error
+    );
+  }
+  getErrorStats() {
+    const now = Date.now();
+    const oneHourAgo = now - 60 * 60 * 1e3;
+    const recentErrors = this.errors.filter(
+      (e) => e.extendedContext.timestamp > oneHourAgo
+    );
+    const bySeverity = Object.values(ErrorSeverity).reduce(
+      (acc, severity) => {
+        acc[severity] = this.errors.filter(
+          (e) => e.severity === severity
+        ).length;
+        return acc;
+      },
+      {}
+    );
+    const byCategory = Object.values(ErrorCategory).reduce(
+      (acc, category) => {
+        acc[category] = this.errors.filter(
+          (e) => e.category === category
+        ).length;
+        return acc;
+      },
+      {}
+    );
+    return {
+      total: this.errors.length,
+      bySeverity,
+      byCategory,
+      recentErrors: recentErrors.length,
+      errorRate: recentErrors.length / 60
+      // errors per minute
+    };
+  }
+  getTopErrors(limit = 10) {
+    const errorGroups = /* @__PURE__ */ new Map();
+    this.errors.forEach((error) => {
+      const key = `${error.message}_${error.category}`;
+      const existing = errorGroups.get(key);
+      if (existing) {
+        existing.count++;
+        existing.lastOccurrence = Math.max(
+          existing.lastOccurrence,
+          error.extendedContext.timestamp
+        );
+      } else {
+        errorGroups.set(key, {
+          errorCode: error.errorCode,
+          message: error.message,
+          count: 1,
+          lastOccurrence: error.extendedContext.timestamp,
+          severity: error.severity,
+          category: error.category
+        });
+      }
+    });
+    return Array.from(errorGroups.values()).sort((a, b) => b.count - a.count).slice(0, limit);
+  }
+  clearErrors() {
+    this.errors = [];
+  }
+};
+var ErrorHandler = class {
+  recoveryStrategies = [];
+  analytics;
+  enabled = true;
+  constructor() {
+    this.analytics = new ErrorAnalytics();
+    this.addRecoveryStrategy(new RetryRecoveryStrategy());
+    this.addRecoveryStrategy(new FallbackStateRecoveryStrategy());
+  }
+  addRecoveryStrategy(strategy) {
+    this.recoveryStrategies.push(strategy);
+  }
+  removeRecoveryStrategy(strategyName) {
+    this.recoveryStrategies = this.recoveryStrategies.filter(
+      (s) => s.name !== strategyName
+    );
+  }
+  async handleError(error, context = {}) {
+    if (!this.enabled) {
+      return false;
+    }
+    const enhancedError = error instanceof EnhancedStateMachineError ? error : this.convertToEnhancedError(error, context);
+    this.analytics.recordError(enhancedError);
+    for (const strategy of this.recoveryStrategies) {
+      if (strategy.canRecover(enhancedError)) {
+        try {
+          const recovered = await strategy.recover(enhancedError, context);
+          if (recovered) {
+            stateMachineLogger.info("Error recovery successful", {
+              errorCode: enhancedError.errorCode,
+              strategy: strategy.name
+            });
+            return true;
+          }
+        } catch (recoveryError) {
+          stateMachineLogger.error(
+            "Recovery strategy failed",
+            {
+              errorCode: enhancedError.errorCode,
+              strategy: strategy.name
+            },
+            /* c8 ignore next */
+            recoveryError instanceof Error ? recoveryError : new Error(String(recoveryError))
+          );
+        }
+      }
+    }
+    stateMachineLogger.error("All recovery strategies failed", {
+      errorCode: enhancedError.errorCode,
+      severity: enhancedError.severity,
+      category: enhancedError.category
+    });
+    return false;
+  }
+  convertToEnhancedError(error, context) {
+    let category = ErrorCategory.UNKNOWN;
+    let severity = ErrorSeverity.MEDIUM;
+    if (error.message.includes("transition") || error.message.includes("state")) {
+      category = ErrorCategory.TRANSITION;
+    } else if (error.message.includes("action")) {
+      category = ErrorCategory.ACTION;
+    } else if (error.message.includes("validation")) {
+      category = ErrorCategory.VALIDATION;
+      severity = ErrorSeverity.HIGH;
+    } else if (error.message.includes("security") || error.message.includes("injection")) {
+      category = ErrorCategory.SECURITY;
+      severity = ErrorSeverity.CRITICAL;
+    }
+    return new EnhancedStateMachineError(
+      error.message,
+      context.errorContext || {},
+      {
+        category,
+        severity,
+        cause: error,
+        additionalData: context
+      }
+    );
+  }
+  getAnalytics() {
+    return this.analytics;
+  }
+  enable() {
+    this.enabled = true;
+  }
+  disable() {
+    this.enabled = false;
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+};
+function createDefaultErrorHandler() {
+  return new ErrorHandler();
+}
+function createEnhancedError(message, context, options) {
+  return new EnhancedStateMachineError(message, context, options);
+}
+function isRecoverableError(error) {
+  if (error instanceof EnhancedStateMachineError) {
+    return error.recoverable;
+  }
+  return true;
+}
+
+// src/state_machine.ts
+var ConsoleLogger = {
+  debug: () => {
+  },
+  // По умолчанию выключено для Lite
+  info: () => {
+  },
+  warn: (msg, ctx) => console.warn(msg, ctx),
+  error: (msg, ctx, err) => console.error(msg, ctx, err)
+};
+var StateMachine = class _StateMachine {
+  // Приватные поля для зависимостей
+  logger;
+  monitor;
+  scheduler;
+  errorHandler;
+  // Свойства
+  states;
+  events;
+  stateAttribute;
+  onError;
+  adaptee;
+  context;
+  historyMap = /* @__PURE__ */ new Map();
+  initialState;
+  persistenceAdapter;
+  activeTimers = /* @__PURE__ */ new Map();
+  stateEntryTimes = /* @__PURE__ */ new Map();
+  // Event Queue Infrastructure (SCXML Run-to-Completion)
+  externalQueue = [];
+  internalQueue = [];
+  isProcessing = false;
+  eventIdCounter = 0;
+  transitionDepth = 0;
+  MAX_TRANSITION_DEPTH = 100;
+  // Optional configuration
+  transitionTimeout;
+  errorState;
+  abortOnExitError;
+  maxQueueDepth = 1e3;
+  // Transition state visibility
+  _isTransitioning = false;
+  _targetState;
+  get isTransitioning() {
+    return this._isTransitioning;
+  }
+  get targetState() {
+    return this._targetState;
+  }
+  // Геттеры и сеттеры
+  set currentState(state) {
+    if (!this.adaptee) throw new StateMachineError("no adaptee", { state });
+    this.setCurrentState(state, this.adaptee);
+  }
+  get currentState() {
+    if (!this.adaptee) {
+      const s = this.getCurrentState();
+      throw new StateMachineError("no adaptee", s !== void 0 ? { state: s } : {});
+    }
+    return this.getCurrentState(this.adaptee) ?? "";
+  }
+  // Конструктор
+  constructor(config, adaptee, options) {
+    this.initialState = config.initialState;
+    this.logger = options?.logger ?? ConsoleLogger;
+    this.monitor = options?.monitor ?? createDefaultMonitor();
+    this.scheduler = options?.scheduler ?? createDefaultScheduler();
+    this.errorHandler = options?.errorHandler ?? createDefaultErrorHandler();
+    if (adaptee) {
+      if (!isAdapter(adaptee)) {
+        this.adaptee = new MemoryAdapter(adaptee);
+      } else {
+        this.adaptee = adaptee;
+      }
+    }
+    if (options?.transitionTimeout !== void 0) {
+      this.transitionTimeout = options.transitionTimeout;
+    }
+    if (options?.errorState !== void 0) {
+      this.errorState = options.errorState;
+    }
+    if (options?.abortOnExitError !== void 0) {
+      this.abortOnExitError = options.abortOnExitError;
+    }
+    if (options?.maxQueueDepth !== void 0) {
+      this.maxQueueDepth = options.maxQueueDepth;
+    }
+    if (config.onError !== void 0) {
+      this.onError = config.onError;
+    }
+    this.stateAttribute = config.stateAttribute;
+    this.states = /* @__PURE__ */ new Map();
+    this.events = new Map(
+      Object.entries(config.events).map(([name, value]) => [
+        name,
+        {
+          name,
+          ...value,
+          transitions: value.transitions.map((t) => ({
+            ...t,
+            // Support 'action' alias for 'onTransition'
+            onTransition: t.onTransition || t.action
+          }))
+        }
+      ])
+    );
+    this.processStates(config.states);
+    if (adaptee) {
+      this.persistenceAdapter = adaptee;
+      this.setInitialState(config.initialState);
+    }
+    this.logger.info("StateMachine initialized", { name: config.name });
+  }
+  // Основные публичные методы
+  setContext(context) {
+    this.context = context;
+  }
+  enqueueEvent(eventName, obj, args, type) {
+    if (this.externalQueue.length + this.internalQueue.length >= this.maxQueueDepth) {
+      const _s0 = this.getCurrentState(obj);
+      return Promise.reject(
+        new StateMachineError("Event queue overflow \u2014 possible infinite loop", {
+          /* c8 ignore next */
+          ..._s0 !== void 0 ? { state: _s0 } : {},
+          event: eventName
+        })
+      );
+    }
+    if (type === "external") {
+      return new Promise((resolve, reject) => {
+        this.externalQueue.push({
+          id: `ext_${++this.eventIdCounter}`,
+          eventName,
+          obj,
+          args,
+          resolve,
+          reject,
+          timestamp: Date.now(),
+          type: "external"
+        });
+        this.scheduleProcessing();
+      });
+    }
+    this.internalQueue.push({
+      id: `int_${++this.eventIdCounter}`,
+      eventName,
+      obj,
+      args,
+      timestamp: Date.now(),
+      type: "internal"
+    });
+    return Promise.resolve(true);
+  }
+  raiseEvent(eventName, obj, ...args) {
+    this.internalQueue.push({
+      id: `int_${++this.eventIdCounter}`,
+      eventName,
+      obj,
+      args,
+      timestamp: Date.now(),
+      type: "internal"
+    });
+  }
+  scheduleProcessing() {
+    if (this.isProcessing) return;
+    queueMicrotask(() => this.processQueues());
+  }
+  async processQueues() {
+    if (this.isProcessing) return;
+    this.isProcessing = true;
+    try {
+      while (this.internalQueue.length > 0 || this.externalQueue.length > 0) {
+        if (this.transitionDepth >= this.MAX_TRANSITION_DEPTH) {
+          const _s1 = this.getCurrentState();
+          const error = new StateMachineError(
+            "Max transition depth exceeded \u2014 possible infinite loop",
+            /* c8 ignore next */
+            { ..._s1 !== void 0 ? { state: _s1 } : {}, event: "processQueues" }
+          );
+          while (this.externalQueue.length > 0) {
+            const evt = this.externalQueue.shift();
+            evt.reject?.(error);
+          }
+          this.internalQueue.length = 0;
+          throw error;
+        }
+        if (this.internalQueue.length > 0) {
+          const evt = this.internalQueue.shift();
+          this.transitionDepth++;
+          try {
+            await this.executeQueuedTransition(evt);
+          } finally {
+            this.transitionDepth--;
+          }
+        } else {
+          const evt = this.externalQueue.shift();
+          this.transitionDepth++;
+          try {
+            const result = await this.executeQueuedTransition(evt);
+            evt.resolve?.(result);
+          } catch (error) {
+            evt.reject?.(error);
+          } finally {
+            this.transitionDepth--;
+          }
+        }
+      }
+    } finally {
+      this.isProcessing = false;
+      this.transitionDepth = 0;
+    }
+  }
+  async executeQueuedTransition(queuedEvent) {
+    const { eventName, obj, args } = queuedEvent;
+    const targetObj = obj;
+    let currentStateRaw = this.getCurrentState(targetObj);
+    if (!currentStateRaw) {
+      this.setInitialState(this.initialState, targetObj);
+      currentStateRaw = this.getCurrentState(targetObj);
+    }
+    const currentState = currentStateRaw ?? "";
+    let event = this.events.get(eventName);
+    let transitions = event ? event.transitions.filter(
+      (t) => this.isTransitionPossible(t, currentState)
+    ) : [];
+    if (!transitions.length) {
+      const wildcardEvent = this.events.get("*");
+      if (wildcardEvent) {
+        const wildcardTransitions = wildcardEvent.transitions.filter(
+          (t) => this.isTransitionPossible(t, currentState)
+        );
+        if (wildcardTransitions.length > 0) {
+          event = wildcardEvent;
+          transitions = wildcardTransitions;
+        }
+      }
+    }
+    if (!event || !transitions.length) {
+      throw new StateMachineError(
+        `Invalid event: ${eventName} for state: ${currentState}`,
+        { state: currentState, event: eventName }
+      );
+    }
+    const allowedTransition = await this.getAllowedTransitions(
+      targetObj,
+      transitions,
+      ...args
+    ).catch((error) => {
+      this.logger.error(
+        "Error determining allowed transition",
+        { event: eventName, state: currentState },
+        /* c8 ignore next */
+        error instanceof Error ? error : new Error(String(error))
+      );
+      return void 0;
+    });
+    if (!allowedTransition) {
+      return false;
+    }
+    const toState = await this.applyTransition(
+      targetObj,
+      currentState,
+      allowedTransition,
+      args,
+      eventName,
+      event
+    ).catch((error) => {
+      this.logger.error(
+        "Error applying transition",
+        {
+          event: eventName,
+          state: currentState,
+          transition: `${allowedTransition.from} -> ${allowedTransition.to}`
+        },
+        /* c8 ignore next */
+        error instanceof Error ? error : new Error(String(error))
+      );
+      if (this.errorHandler.isEnabled()) {
+        this.monitor.recordError(
+          error instanceof Error ? error : new Error(String(error)),
+          { state: currentState, event: eventName }
+        );
+      }
+      throw error;
+    });
+    if (!toState) {
+      return false;
+    }
+    this.setCurrentState(toState.name, targetObj);
+    return true;
+  }
+  async fireEvent(eventName, obj, ...args) {
+    let targetObj;
+    if (!obj) {
+      if (this.adaptee) targetObj = this.adaptee;
+      else
+        throw new StateMachineError("no adaptee or object passed", {
+          event: String(eventName)
+        });
+    } else if (!isAdapter(obj)) {
+      args.unshift(obj);
+      if (this.adaptee) targetObj = this.adaptee;
+      else
+        throw new StateMachineError("no adaptee or object passed", {
+          event: String(eventName)
+        });
+    } else {
+      targetObj = obj;
+    }
+    return this.enqueueEvent(String(eventName), targetObj, args, "external");
+  }
+  getQueueDepth() {
+    return {
+      internal: this.internalQueue.length,
+      external: this.externalQueue.length,
+      total: this.internalQueue.length + this.externalQueue.length
+    };
+  }
+  getQueuedEvents() {
+    const now = Date.now();
+    const mapEvent = (evt) => ({
+      id: evt.id,
+      event: evt.eventName,
+      age: now - evt.timestamp,
+      type: evt.type
+    });
+    return [
+      ...this.internalQueue.map(mapEvent),
+      ...this.externalQueue.map(mapEvent)
+    ];
+  }
+  isProcessingEvents() {
+    return this.isProcessing;
+  }
+  /**
+   * Checks if an event can be fired in the current state.
+   *
+   * @param eventName - The name of the event to check.
+   * @param adaptee - Optional adapter/object to check against (defaults to internal adaptee).
+   * @returns boolean - True if the event has a valid transition from the current state (guards are not executed).
+   */
+  canFireEvent(eventName, adaptee) {
+    const targetAdaptee = adaptee || this.adaptee;
+    if (!targetAdaptee) return false;
+    const currentState = this.getCurrentState(targetAdaptee);
+    const effectiveState = currentState === "" ? this.getInitialCompositeState(this.initialState) : currentState;
+    if (effectiveState === void 0) return false;
+    const event = this.events.get(String(eventName));
+    if (!event || !event.transitions.some(
+      (t) => this.isTransitionPossible(t, effectiveState)
+    )) {
+      const wildcardEvent = this.events.get("*");
+      if (wildcardEvent) {
+        return wildcardEvent.transitions.some(
+          (t) => this.isTransitionPossible(t, effectiveState)
+        );
+      }
+      return false;
+    }
+    return true;
+  }
+  getAvailableEvents(adaptee) {
+    const available = [];
+    for (const [name] of this.events) {
+      if (this.canFireEvent(name, adaptee)) {
+        available.push(String(name));
+      }
+    }
+    return available;
+  }
+  async reset(adaptee) {
+    const targetAdaptee = adaptee || this.adaptee;
+    if (!targetAdaptee) {
+      const _s2 = this.getCurrentState();
+      throw new StateMachineError("no adaptee", _s2 !== void 0 ? { state: _s2 } : {});
+    }
+    this.historyMap.clear();
+    for (const timers of this.activeTimers.values()) {
+      for (const id of timers) {
+        this.clearTimer(id);
+      }
+    }
+    this.activeTimers.clear();
+    this.stateEntryTimes.clear();
+    this.setInitialState(this.initialState, targetAdaptee);
+  }
+  getStateHistory() {
+    return Object.fromEntries(this.historyMap);
+  }
+  getCurrentStateInfo() {
+    const currentState = this.getCurrentState();
+    if (currentState === void 0) return void 0;
+    const isComposite = currentState.includes("|");
+    if (isComposite) {
+      const activeStates = currentState.split("|").filter(Boolean);
+      const regions2 = activeStates.map((s) => this.getRegionKey(s));
+      return {
+        name: currentState,
+        isComposite: true,
+        regions: regions2,
+        children: activeStates
+      };
+    }
+    const state = this.states.get(currentState);
+    if (!state) return void 0;
+    const parent = currentState.includes(".") ? currentState.split(".").slice(0, -1).join(".") : void 0;
+    const children = this.getDirectChildren(currentState);
+    const regions = state.regions ? Object.keys(state.regions) : void 0;
+    return {
+      name: currentState,
+      ...state.display !== void 0 ? { display: state.display } : {},
+      isComposite: Boolean(state.regions),
+      ...regions !== void 0 ? { regions } : {},
+      ...parent !== void 0 ? { parent } : {},
+      ...children.length ? { children } : {}
+    };
+  }
+  /**
+   * Checks if the machine is in a specific state.
+   * Supports hierarchical states (e.g. 'parent' matches 'parent.child').
+   *
+   * @param expectedState - The state name to check.
+   * @param adaptee - Optional adapter to check against.
+   * @returns boolean - True if the current state matches or is a substate of the expected state.
+   */
+  isInState(expectedState, adaptee) {
+    const currentState = this.getCurrentState(adaptee);
+    if (!currentState) return expectedState === "";
+    const currentParts = currentState.split("|").sort();
+    const expectedParts = expectedState.split("|").sort();
+    if (currentParts.length !== expectedParts.length) return false;
+    return currentParts.every((part, index) => part === expectedParts[index]);
+  }
+  attachToObject(object, eventMap) {
+    for (const objectEventName in eventMap) {
+      if (eventMap.hasOwnProperty(objectEventName)) {
+        const stateMachineEventName = eventMap[objectEventName];
+        if (stateMachineEventName === void 0) continue;
+        if (typeof object.addEventListener === "function") {
+          object.addEventListener(objectEventName, (...args) => {
+            this.fireEvent(stateMachineEventName, object, ...args).catch(
+              (e) => this.logger.error(
+                "Error firing event",
+                {
+                  objectEventName,
+                  stateMachineEventName
+                },
+                /* c8 ignore next */
+                e instanceof Error ? e : new Error(String(e))
+              )
+            );
+          });
+        } else if (typeof object.on === "function") {
+          object.on(objectEventName, (...args) => {
+            this.fireEvent(stateMachineEventName, object, ...args).catch(
+              (e) => this.logger.error(
+                "Error firing event",
+                {
+                  objectEventName,
+                  stateMachineEventName
+                },
+                /* c8 ignore next */
+                e instanceof Error ? e : new Error(String(e))
+              )
+            );
+          });
+        } else {
+          object[`on${objectEventName}`] = async (...args) => {
+            return this.fireEvent(stateMachineEventName, object, ...args).catch(
+              (e) => this.logger.error(
+                "Error firing event",
+                {
+                  objectEventName,
+                  stateMachineEventName
+                },
+                /* c8 ignore next */
+                e instanceof Error ? e : new Error(String(e))
+              )
+            );
+          };
+        }
+      }
+    }
+  }
+  // Методы для работы с состоянием
+  async saveState(adapter) {
+    const targetAdapter = adapter || this.persistenceAdapter;
+    if (!targetAdapter) {
+      return;
+    }
+    const currentState = this.getCurrentState() ?? "";
+    const history = Object.fromEntries(this.historyMap);
+    const stateData = {
+      currentState,
+      history,
+      stateEntryTimes: Object.fromEntries(this.stateEntryTimes)
+    };
+    await targetAdapter.save(stateData);
+  }
+  async restoreState(adapter) {
+    const targetAdapter = adapter || this.persistenceAdapter;
+    if (!targetAdapter) {
+      return;
+    }
+    const result = await targetAdapter.restore();
+    this.validateCompositeState(result.currentState);
+    this.historyMap = new Map(Object.entries(result.history));
+    if (result.stateEntryTimes) {
+      this.stateEntryTimes = new Map(Object.entries(result.stateEntryTimes));
+    }
+    this.setCurrentState(result.currentState);
+    this.resumeTimers();
+  }
+  // Статические методы
+  static fromData(config, initialState, context, options) {
+    const sm = new _StateMachine(config, context, options);
+    if (sm.adaptee) {
+      sm.setCurrentState(initialState || config.initialState);
+    }
+    return sm;
+  }
+  static fromJSON(jsonData, obj, options) {
+    const parsedData = JSON.parse(jsonData);
+    const { config, currentState, historyMap, stateEntryTimes } = parsedData;
+    const deserializedStates = _StateMachine.deserializeStates(
+      config.states
+    );
+    const deserializedEvents = _StateMachine.deserializeEvents(
+      config.events
+    );
+    const smConfig = {
+      name: "DeserializedStateMachine",
+      initialState: config.initialState,
+      stateAttribute: config.stateAttribute,
+      states: deserializedStates,
+      events: deserializedEvents,
+      onError: _StateMachine.deserializeAction(config.onError)
+    };
+    const sm = new _StateMachine(
+      smConfig,
+      obj,
+      options
+    );
+    sm.historyMap = new Map(historyMap);
+    if (stateEntryTimes) {
+      sm.stateEntryTimes = new Map(stateEntryTimes);
+    }
+    if (sm.adaptee && currentState) {
+      sm.setCurrentState(currentState);
+      sm.resumeTimers();
+    }
+    return sm;
+  }
+  /**
+   * Securely deserializes a StateMachine from JSON string (Async).
+   * Verifies cryptographic hashes of serialized functions.
+   */
+  static async fromSecureJSON(jsonData, obj, options) {
+    const parsedData = JSON.parse(jsonData);
+    const { config, currentState, historyMap, stateEntryTimes } = parsedData;
+    const deserializedStates = await _StateMachine.deserializeStatesAsync(config.states);
+    const deserializedEvents = await _StateMachine.deserializeEventsAsync(config.events);
+    const smConfig = {
+      name: "DeserializedStateMachine",
+      initialState: config.initialState,
+      stateAttribute: config.stateAttribute,
+      states: deserializedStates,
+      events: deserializedEvents,
+      onError: await _StateMachine.deserializeActionAsync(
+        config.onError
+      )
+    };
+    const sm = new _StateMachine(
+      smConfig,
+      obj,
+      options
+    );
+    sm.historyMap = new Map(historyMap);
+    if (stateEntryTimes) {
+      sm.stateEntryTimes = new Map(stateEntryTimes);
+    }
+    if (sm.adaptee && currentState) {
+      sm.setCurrentState(currentState);
+      sm.resumeTimers();
+    }
+    return sm;
+  }
+  /**
+   * Deserialize states configuration (Async)
+   */
+  static async deserializeStatesAsync(statesConfig) {
+    const result = {};
+    for (const [name, stateData] of Object.entries(statesConfig)) {
+      const deserializedState = {
+        ...stateData,
+        onBeforeEnter: await _StateMachine.deserializeActionAsync(
+          stateData.onBeforeEnter
+        ),
+        onEnter: await _StateMachine.deserializeActionAsync(stateData.onEnter),
+        onAfterEnter: await _StateMachine.deserializeActionAsync(
+          stateData.onAfterEnter
+        ),
+        onBeforeExit: await _StateMachine.deserializeActionAsync(
+          stateData.onBeforeExit
+        ),
+        onExit: await _StateMachine.deserializeActionAsync(stateData.onExit),
+        onAfterExit: await _StateMachine.deserializeActionAsync(
+          stateData.onAfterExit
+        ),
+        onError: await _StateMachine.deserializeActionAsync(stateData.onError)
+      };
+      if (stateData.invoke && Array.isArray(stateData.invoke)) {
+        deserializedState.invoke = await Promise.all(
+          stateData.invoke.map(async (inv) => ({
+            ...inv,
+            cond: await _StateMachine.deserializeActionAsync(inv.cond),
+            action: await _StateMachine.deserializeActionAsync(inv.action)
+          }))
+        );
+      }
+      result[name] = deserializedState;
+    }
+    return result;
+  }
+  /**
+   * Deserialize states configuration
+   */
+  static deserializeStates(statesConfig) {
+    return Object.entries(statesConfig).reduce(
+      (acc, [name, stateData]) => {
+        const deserializedState = {
+          ...stateData,
+          onBeforeEnter: _StateMachine.deserializeAction(
+            stateData.onBeforeEnter
+          ),
+          onEnter: _StateMachine.deserializeAction(stateData.onEnter),
+          onAfterEnter: _StateMachine.deserializeAction(stateData.onAfterEnter),
+          onBeforeExit: _StateMachine.deserializeAction(stateData.onBeforeExit),
+          onExit: _StateMachine.deserializeAction(stateData.onExit),
+          onAfterExit: _StateMachine.deserializeAction(stateData.onAfterExit),
+          onError: _StateMachine.deserializeAction(stateData.onError)
+        };
+        if (stateData.invoke && Array.isArray(stateData.invoke)) {
+          deserializedState.invoke = stateData.invoke.map((inv) => ({
+            ...inv,
+            cond: _StateMachine.deserializeAction(inv.cond),
+            action: _StateMachine.deserializeAction(inv.action)
+          }));
+        }
+        acc[name] = deserializedState;
+        return acc;
+      },
+      {}
+    );
+  }
+  /**
+   * Deserialize events configuration (Async)
+   */
+  static async deserializeEventsAsync(eventsConfig) {
+    const result = {};
+    for (const [name, eventData] of Object.entries(eventsConfig)) {
+      result[name] = {
+        ...eventData,
+        onBefore: await _StateMachine.deserializeActionAsync(eventData.onBefore),
+        onAfter: await _StateMachine.deserializeActionAsync(eventData.onAfter),
+        onSuccess: await _StateMachine.deserializeActionAsync(
+          eventData.onSuccess
+        ),
+        onError: await _StateMachine.deserializeActionAsync(eventData.onError),
+        transitions: await Promise.all(
+          eventData.transitions.map(
+            (transitionData) => _StateMachine.deserializeTransitionAsync(transitionData)
+          )
+        )
+      };
+    }
+    return result;
+  }
+  /**
+   * Deserialize events configuration
+   */
+  static deserializeEvents(eventsConfig) {
+    return Object.entries(eventsConfig).reduce(
+      (acc, [name, eventData]) => {
+        acc[name] = {
+          ...eventData,
+          onBefore: _StateMachine.deserializeAction(eventData.onBefore),
+          onAfter: _StateMachine.deserializeAction(eventData.onAfter),
+          onSuccess: _StateMachine.deserializeAction(eventData.onSuccess),
+          onError: _StateMachine.deserializeAction(eventData.onError),
+          transitions: eventData.transitions.map(
+            (transitionData) => _StateMachine.deserializeTransition(transitionData)
+          )
+        };
+        return acc;
+      },
+      {}
+    );
+  }
+  /**
+   * Deserialize transition configuration (Async)
+   */
+  static async deserializeTransitionAsync(transitionData) {
+    return {
+      ...transitionData,
+      guard: await _StateMachine.deserializeActionAsync(transitionData.guard),
+      // Support 'action' alias for 'onTransition'
+      onTransition: await _StateMachine.deserializeActionAsync(
+        transitionData.onTransition || transitionData.action
+      ),
+      onError: await _StateMachine.deserializeActionAsync(
+        transitionData.onError
+      )
+    };
+  }
+  /**
+   * Deserialize transition configuration
+   */
+  static deserializeTransition(transitionData) {
+    return {
+      ...transitionData,
+      guard: _StateMachine.deserializeAction(transitionData.guard),
+      // Support 'action' alias for 'onTransition' for compatibility
+      onTransition: _StateMachine.deserializeAction(
+        transitionData.onTransition || transitionData.action
+      ),
+      onError: _StateMachine.deserializeAction(transitionData.onError)
+    };
+  }
+  /**
+   * Static method for deserializing actions (Async)
+   */
+  static async deserializeActionAsync(action) {
+    if (!action) return action;
+    if (typeof action === "object" && action.type === "function") {
+      return safeFunctionSerializer.deserializeActionAsync(action);
+    }
+    return _StateMachine.deserializeAction(action);
+  }
+  /**
+   * Static method for deserializing actions (now using safe deserializer)
+   */
+  static deserializeAction(action) {
+    if (!action) return action;
+    if (typeof action === "object" && action.type === "function") {
+      return safeFunctionSerializer.deserializeAction(action);
+    }
+    if (typeof action === "string") {
+      const trimmed = action.trim();
+      if (trimmed.startsWith("function") || trimmed.startsWith("(") || trimmed.includes("=>")) {
+        const safeFn = safeFunctionSerializer.deserializeLegacyString(action);
+        if (safeFn) {
+          return safeFn;
+        }
+        return void 0;
+      }
+    }
+    return action;
+  }
+  static fromJSONWithContext(jsonData, context, options) {
+    const sm = _StateMachine.fromJSON(
+      jsonData,
+      void 0,
+      options
+    );
+    if (context !== void 0) {
+      sm.setContext(context);
+    }
+    return sm;
+  }
+  // Приватные методы
+  setCurrentState(state, obj) {
+    const adaptee = obj || this.adaptee;
+    const stateConfig = this.states.get(state);
+    if (stateConfig?.history && stateConfig.history !== "deep" && stateConfig.regions) {
+      const historyState = this.historyMap.get(state);
+      if (historyState && adaptee) {
+        const currentState = this.getCurrentState(adaptee) ?? "";
+        const newCompositeState = this.updatePartialState(
+          currentState,
+          state,
+          historyState
+        );
+        adaptee.set(
+          this.stateAttribute,
+          newCompositeState
+        );
+        return;
+      }
+    }
+    if (stateConfig?.history === "deep" && stateConfig.regions) {
+      const historyState = this.historyMap.get(state);
+      if (historyState && adaptee) {
+        adaptee.set(
+          this.stateAttribute,
+          historyState
+        );
+        return;
+      }
+    }
+    if (adaptee) {
+      this.setCurrentStateInternal(state, adaptee);
+    }
+  }
+  setCurrentStateInternal(state, adaptee) {
+    const currentState = this.getCurrentState(adaptee) || "";
+    const currentStateMap = this.parseCompositeState(currentState);
+    const newStateParts = state.split("|");
+    const isRootState = newStateParts.length === 1 && !state.includes(".");
+    if (isRootState) {
+      currentStateMap.clear();
+      currentStateMap.set(state, state);
+    } else {
+      for (const newStatePart of newStateParts) {
+        if (!this.states.has(newStatePart)) {
+          throw new StateMachineError(
+            `Invalid state path: ${newStatePart} in composite state: ${state} states: ${Array.from(this.states.keys()).join(",")}`,
+            { state: newStatePart }
+          );
+        }
+        const regionKey = this.getRegionKey(newStatePart);
+        const stateConfig = this.states.get(newStatePart);
+        for (const [existingRegionKey] of currentStateMap.entries()) {
+          if (existingRegionKey === regionKey || existingRegionKey.startsWith(regionKey + ".") || regionKey.startsWith(existingRegionKey + ".")) {
+            currentStateMap.delete(existingRegionKey);
+          }
+        }
+        if (stateConfig?.regions) {
+          const initialStatesForRegions = this.getInitialStatesForRegions(
+            stateConfig.regions,
+            newStatePart
+          );
+          const regionStates = initialStatesForRegions.split("|");
+          for (const regionState of regionStates) {
+            const regionKeyNested = this.getRegionKey(regionState);
+            currentStateMap.set(regionKeyNested, regionState);
+          }
+        } else {
+          currentStateMap.set(regionKey, newStatePart);
+        }
+      }
+      for (const [key, value] of currentStateMap.entries()) {
+        if (!value.includes(".")) {
+          currentStateMap.delete(key);
+        }
+      }
+    }
+    const newCompositeState = Array.from(currentStateMap.values()).join("|");
+    this.validateCompositeState(newCompositeState);
+    adaptee.set(
+      this.stateAttribute,
+      newCompositeState
+    );
+  }
+  getCurrentState(adaptee) {
+    const targetAdaptee = adaptee || this.adaptee;
+    if (!targetAdaptee) return;
+    const currentState = targetAdaptee.get(this.stateAttribute);
+    if (!currentState) return "";
+    const stateParts = currentState.split("|");
+    for (const statePart of stateParts) {
+      if (!this.states.has(statePart)) {
+        throw new StateMachineError(
+          `Invalid state path in current state: ${statePart}`,
+          { state: currentState }
+        );
+      }
+    }
+    return currentState;
+  }
+  setInitialState(initialState, obj) {
+    const targetAdaptee = obj || this.adaptee;
+    if (!targetAdaptee) return;
+    const stateConfig = this.states.get(initialState);
+    let initialStates;
+    if (stateConfig?.regions) {
+      initialStates = this.getInitialStatesForRegions(
+        stateConfig.regions,
+        initialState
+      );
+    } else {
+      initialStates = initialState;
+    }
+    this.setCurrentState(initialStates, targetAdaptee);
+    const stateParts = initialStates.split("|");
+    const context = {
+      state: initialStates,
+      phase: "enter"
+    };
+    for (const statePart of stateParts) {
+      this.executeEnterActions(
+        targetAdaptee,
+        statePart,
+        [],
+        context
+      ).catch((err) => {
+        this.logger.error(
+          "Error in initial state enter actions",
+          { state: statePart },
+          err
+        );
+      });
+    }
+  }
+  getInitialCompositeState(initialState) {
+    const stateConfig = this.states.get(initialState);
+    if (stateConfig?.regions) {
+      return this.getInitialStatesForRegions(stateConfig.regions, initialState);
+    }
+    return initialState;
+  }
+  getDirectChildren(stateName) {
+    const prefix = `${stateName}.`;
+    const depth = stateName.split(".").length + 1;
+    const children = [];
+    for (const name of this.states.keys()) {
+      const nameStr = String(name);
+      if (!nameStr.startsWith(prefix)) continue;
+      if (nameStr.split(".").length !== depth) continue;
+      children.push(nameStr);
+    }
+    return children;
+  }
+  getInitialStatesForRegions(regions, parentPath) {
+    const regionStates = [];
+    for (const [regionName, regionStatesConfig] of Object.entries(regions)) {
+      const regionPath = `${parentPath}.${regionName}`;
+      const initialState = regionStatesConfig.initial || Object.keys(regionStatesConfig)[0];
+      const fullPath = `${regionPath}.${initialState}`;
+      const stateConfig = this.states.get(fullPath);
+      if (stateConfig?.regions) {
+        const nestedInitialStates = this.getInitialStatesForRegions(
+          stateConfig.regions,
+          fullPath
+        );
+        regionStates.push(...nestedInitialStates.split("|"));
+      } else {
+        regionStates.push(fullPath);
+      }
+    }
+    return regionStates.join("|");
+  }
+  validateCompositeState(compositeState) {
+    const stateParts = compositeState.split("|");
+    const regionKeys = /* @__PURE__ */ new Set();
+    for (const statePart of stateParts) {
+      const regionKey = this.getRegionKey(statePart);
+      if (regionKeys.has(regionKey)) {
+        throw new StateMachineError(
+          `Contradictory state detected: multiple states for region ${regionKey} in composite state ${compositeState}`,
+          { state: compositeState }
+        );
+      }
+      regionKeys.add(regionKey);
+    }
+  }
+  processStates(statesConfig, parentStateName) {
+    for (const [name, value] of Object.entries(statesConfig)) {
+      if (name === "initial") continue;
+      const stateName = parentStateName ? `${parentStateName}.${name}` : name;
+      const state = { name: stateName, ...value };
+      this.states.set(stateName, state);
+      if (value.regions) {
+        this.processRegions(value.regions, stateName);
+      }
+    }
+  }
+  processRegions(regionsConfig, parentStateName) {
+    for (const [regionName, regionStatesConfig] of Object.entries(
+      regionsConfig
+    )) {
+      this.processStates(regionStatesConfig, `${parentStateName}.${regionName}`);
+    }
+  }
+  processError(adaptee, context, ...fallback) {
+    let handler = (adaptee2, err) => {
+      let currentState;
+      try {
+        if (adaptee2 && typeof adaptee2.get === "function") {
+          currentState = this.getCurrentState(
+            adaptee2
+          ) ?? "";
+        } else {
+          currentState = context.state || "";
+        }
+      } catch {
+        currentState = context.state || "";
+      }
+      const _phase = err instanceof StateMachineError ? err.context.phase ?? context.phase : context.phase;
+      const _event = err instanceof StateMachineError ? err.context.event ?? context.event : context.event;
+      const _action = err instanceof StateMachineError ? err.context.action ?? context.action : context.action;
+      const _transition = err instanceof StateMachineError ? err.context.transition ?? context.transition : context.transition;
+      const errorContext = {
+        state: currentState,
+        ..._phase !== void 0 ? { phase: _phase } : {},
+        ..._event !== void 0 ? { event: _event } : {},
+        ..._action !== void 0 ? { action: _action } : {},
+        ..._transition !== void 0 ? { transition: _transition } : {}
+      };
+      throw new StateMachineError(
+        `Error in state machine: ${err ? err instanceof Error ? err.message : String(err) : "Unknown error"}`,
+        errorContext,
+        err instanceof StateMachineError ? err.cause : err instanceof Error ? err : void 0
+      );
+    };
+    const handlers = (fallback ?? [this.onError]).filter(Boolean);
+    if (handlers.length > 0) {
+      const r = handlers.map(
+        (action) => action ? typeof action === "function" ? action : this.context && this.context[action] || adaptee.get(action) : void 0
+      ).filter(Boolean).find((t) => t);
+      if (r) handler = r;
+    }
+    return (...args) => {
+      const targetAdaptee = args.length >= 2 ? args[0] : adaptee;
+      const error = args.length >= 2 ? args[1] : args[0];
+      return handler(targetAdaptee, error);
+    };
+  }
+  async callAction(obj, actionName, ...args) {
+    const _callActionState = this.getCurrentState(
+      obj
+    );
+    const context = {
+      /* c8 ignore next */
+      ..._callActionState !== void 0 ? { state: _callActionState } : {},
+      phase: "action",
+      action: typeof actionName === "string" ? actionName : "anonymous"
+    };
+    const executeAction = async () => {
+      try {
+        if (this.context && this.context[actionName]) {
+          const action = this.context[actionName];
+          if (typeof action === "function") {
+            const result = action(this.context, ...args);
+            return result instanceof Promise ? await result : result;
+          }
+        } else if (typeof actionName === "function") {
+          const result = actionName(obj, ...args);
+          return result instanceof Promise ? await result : result;
+        } else if (obj.get(actionName)) {
+          const action = obj.get(actionName);
+          if (typeof action === "function") {
+            const result = action(obj, ...args);
+            return result instanceof Promise ? await result : result;
+          }
+        }
+        throw new StateMachineError("No action found", context);
+      } catch (error) {
+        if (error instanceof StateMachineError) throw error;
+        throw new StateMachineError(
+          `Error executing action: ${error instanceof Error ? error.message : String(error)}`,
+          context,
+          /* c8 ignore next */
+          error instanceof Error ? error : void 0
+        );
+      }
+    };
+    if (this.transitionTimeout && this.transitionTimeout > 0) {
+      return Promise.race([
+        executeAction(),
+        new Promise(
+          (_, reject) => setTimeout(
+            () => reject(new StateMachineError("Transition timeout", {
+              /* c8 ignore next */
+              action: typeof actionName === "string" ? actionName : "anonymous",
+              phase: "action"
+            })),
+            this.transitionTimeout
+          )
+        )
+      ]);
+    }
+    return executeAction();
+  }
+  async getAllowedTransitions(obj, transitions, ...args) {
+    let highestPriority = Number.NEGATIVE_INFINITY;
+    let selectedTransition;
+    for (const transition of transitions) {
+      if ((transition.priority ?? Number.NEGATIVE_INFINITY) < highestPriority) {
+        continue;
+      }
+      const _guardState = this.getCurrentState(obj);
+      const context = {
+        /* c8 ignore next */
+        ..._guardState !== void 0 ? { state: _guardState } : {},
+        phase: "guard",
+        transition: `${transition.from} -> ${transition.to}`
+      };
+      const guardResult = transition.guard ? await this.callAction(obj, transition.guard, ...args).catch(
+        this.processError(
+          obj,
+          context,
+          transition.onError,
+          this.onError
+        )
+      ) : true;
+      if (!guardResult) {
+        continue;
+      }
+      highestPriority = transition.priority ?? Number.NEGATIVE_INFINITY;
+      selectedTransition = transition;
+    }
+    return selectedTransition;
+  }
+  isTransitionPossible(transition, currentState) {
+    const currentStates = this.parseCompositeState(currentState);
+    if (transition.from === "*") {
+      return true;
+    }
+    const fromStates = transition.from.split("|");
+    return fromStates.every((fromState) => {
+      if (fromState === "*") return true;
+      const regionKey = this.getRegionKey(fromState);
+      const currentStateForRegion = currentStates.get(regionKey);
+      if (!currentStateForRegion) return false;
+      return currentStateForRegion === fromState || this.isParentState(currentStateForRegion, fromState);
+    });
+  }
+  isParentState(parentState, childState) {
+    return childState.startsWith(parentState + ".") || childState === parentState;
+  }
+  async applyTransition(obj, currentState, transition, args, eventName, event) {
+    const context = {
+      state: currentState,
+      event: String(eventName),
+      transition: `${transition.from} -> ${transition.to}`,
+      phase: "transition"
+    };
+    const targetState = transition.to === "*" ? currentState : transition.to;
+    this._isTransitioning = true;
+    this._targetState = targetState;
+    try {
+      if (transition.guard) {
+        const allow = await this.callAction(obj, transition.guard, ...args).catch(
+          this.processError(
+            obj,
+            { ...context, phase: "guard" },
+            transition.onError,
+            this.onError
+          )
+        );
+        if (!allow) {
+          return void 0;
+        }
+      }
+      if (event.onBefore) {
+        await this.callAction(obj, event.onBefore, ...args).catch(
+          this.processError(
+            obj,
+            { ...context },
+            transition.onError,
+            this.onError
+          )
+        );
+      }
+      try {
+        await this.executeExitActions(obj, transition.from, args, context);
+      } catch (error) {
+        if (this.abortOnExitError) {
+          this.logger.warn("Transition aborted due to onExit error", { state: currentState, error });
+          return void 0;
+        }
+        throw error;
+      }
+      this.manageStateHistory(transition.from, currentState, obj);
+      if (transition.onTransition) {
+        await this.callAction(obj, transition.onTransition, ...args).catch(
+          this.processError(
+            obj,
+            { ...context },
+            transition.onError,
+            this.onError
+          )
+        );
+      }
+      try {
+        await this.executeEnterActions(obj, transition.to, args, context);
+      } catch (error) {
+        if (this.errorState) {
+          this.logger.error(`Failed to enter state '${targetState}'. Fallback to error state '${this.errorState}'`, { error });
+          const newState2 = this.updateState(currentState, this.errorState);
+          this.setCurrentState(newState2, obj);
+          return this.states.get(this.errorState);
+        }
+        throw error;
+      }
+      if (event.onAfter) {
+        try {
+          await this.callAction(obj, event.onAfter, ...args);
+        } catch (error) {
+          const errorHandler = this.processError(
+            obj,
+            { ...context },
+            event.onError,
+            this.onError
+          );
+          errorHandler(obj, error);
+        }
+      }
+      const transitionStartTime = Date.now();
+      const newState = this.updateState(currentState, targetState);
+      this.setCurrentState(newState, obj);
+      const transitionTime = Date.now() - transitionStartTime;
+      this.monitor.recordTransition(transitionTime, true);
+      return this.states.get(targetState);
+    } finally {
+      this._isTransitioning = false;
+      this._targetState = void 0;
+    }
+  }
+  /**
+   * Execute exit actions for a state
+   */
+  async executeExitActions(obj, fromStateName, args, context) {
+    const fromState = this.states.get(fromStateName);
+    if (this.activeTimers.has(fromStateName)) {
+      const timers = this.activeTimers.get(fromStateName) || [];
+      for (const timerId of timers) {
+        this.clearTimer(timerId);
+      }
+      this.activeTimers.delete(fromStateName);
+    }
+    this.stateEntryTimes.delete(fromStateName);
+    if (!fromState) return;
+    const exitContext = { ...context, phase: "exit" };
+    const exitActions = [
+      fromState.onBeforeExit,
+      fromState.onExit,
+      fromState.onAfterExit
+    ];
+    for (const action of exitActions) {
+      if (action) {
+        await this.callAction(obj, action, ...args).catch(
+          this.processError(obj, exitContext, fromState.onError, this.onError)
+        );
+      }
+    }
+  }
+  /**
+   * Execute enter actions for a state
+   */
+  async executeEnterActions(obj, toStateName, args, context) {
+    const toState = this.states.get(toStateName);
+    if (!toState) return;
+    const enterContext = { ...context, phase: "enter" };
+    const enterActions = [
+      toState.onBeforeEnter,
+      toState.onEnter,
+      toState.onAfterEnter
+    ];
+    for (const action of enterActions) {
+      if (action) {
+        await this.callAction(obj, action, ...args).catch(
+          this.processError(obj, enterContext, toState.onError, this.onError)
+        );
+      }
+    }
+    if (toState.invoke && toState.invoke.length > 0) {
+      if (!this.stateEntryTimes.has(toStateName)) {
+        this.stateEntryTimes.set(toStateName, Date.now());
+      }
+      const timers = [];
+      for (const invocation of toState.invoke) {
+        if (invocation.cond) {
+          try {
+            const shouldInvoke = invocation.cond(obj.adaptee);
+            if (!shouldInvoke) continue;
+          } catch (e) {
+            this.logger.error(
+              "Error in invoke condition",
+              { state: toStateName },
+              e
+            );
+            continue;
+          }
+        }
+        const callback = async () => {
+          const currentState = this.getCurrentState(obj);
+          if (currentState?.split("|").includes(toStateName)) {
+            try {
+              if (invocation.action) {
+                await this.callAction(obj, invocation.action);
+              }
+              this.raiseEvent(invocation.event, obj);
+              this.scheduleProcessing();
+            } catch (err) {
+              this.logger.error(
+                "Invocation error",
+                { state: toStateName, event: invocation.event },
+                err
+              );
+            }
+          }
+        };
+        const timerId = this.setTimer(callback, invocation.delay);
+        timers.push(timerId);
+      }
+      this.activeTimers.set(toStateName, timers);
+    }
+  }
+  /**
+   * Helper to set timer (native or scheduled)
+   */
+  setTimer(callback, delay) {
+    const scheduler = this.scheduler;
+    if (scheduler.isActive()) {
+      return scheduler.schedule(delay, callback);
+    }
+    return setTimeout(callback, delay);
+  }
+  /**
+   * Helper to clear timer
+   */
+  clearTimer(timerId) {
+    const scheduler = this.scheduler;
+    if (scheduler.isActive() && typeof timerId === "object" && timerId !== null && !("ref" in timerId)) {
+      scheduler.cancel(timerId);
+    } else {
+      clearTimeout(timerId);
+    }
+  }
+  /**
+   * Manage state history for transitions
+   */
+  manageStateHistory(fromStateName, currentState, obj) {
+    const fromState = this.states.get(fromStateName);
+    if (fromState?.history) {
+      if (fromState.history === "deep") {
+        this.historyMap.set(fromState.name, currentState);
+      } else if (fromState.history === "shallow" && fromState.regions) {
+        this.historyMap.set(fromState.name, this.getCurrentState(obj) ?? "");
+      }
+    }
+    const fromStateParent = this.findParentStateWithHistory(fromStateName);
+    if (fromStateParent?.history) {
+      this.historyMap.set(fromStateParent.name, currentState);
+    }
+  }
+  findParentStateWithHistory(stateName) {
+    let current = stateName;
+    while (current.includes(".")) {
+      current = current.split(".").slice(0, -1).join(".");
+      const state = this.states.get(current);
+      if (state?.history) return state;
+    }
+    return void 0;
+  }
+  updatePartialState(currentState, parentState, newSubstate) {
+    if (!currentState) return newSubstate;
+    const currentParts = currentState.split("|");
+    const regionKey = parentState.split(".").slice(0, -1).join(".");
+    let updatedParts = currentParts.map((part) => {
+      const partRegionKey = this.getRegionKey(part);
+      if (partRegionKey === regionKey) {
+        return newSubstate;
+      }
+      if (partRegionKey.startsWith(`${regionKey}.`)) {
+        return null;
+      }
+      return part;
+    }).filter((m) => m !== null && m !== void 0);
+    if (!updatedParts.some((part) => this.getRegionKey(part) === regionKey)) {
+      const regionState = this.states.get(newSubstate);
+      if (regionState?.regions) {
+        return currentState;
+      } else {
+        updatedParts.push(newSubstate);
+      }
+    }
+    updatedParts = updatedParts.filter((part) => part !== null);
+    const newCompositeState = updatedParts.join("|");
+    this.validateCompositeState(newCompositeState);
+    return newCompositeState;
+  }
+  updateState(currentState, toState) {
+    const currentStateMap = this.parseCompositeState(currentState);
+    const toStateParts = toState.split("|");
+    if (toStateParts.length === 1 && !toState.includes(".")) {
+      currentStateMap.clear();
+      currentStateMap.set(toState, toState);
+      return toState;
+    }
+    for (const toStatePart of toStateParts) {
+      const regionKey = this.getRegionKey(toStatePart);
+      const stateConfig = this.states.get(toStatePart);
+      this.removeConflictingStates(currentStateMap, regionKey);
+      if (stateConfig?.regions) {
+        this.addRegionStates(currentStateMap, stateConfig, toStatePart);
+      } else {
+        currentStateMap.set(regionKey, toStatePart);
+      }
+    }
+    this.cleanupRootStates(currentStateMap);
+    const newCompositeState = Array.from(currentStateMap.values()).join("|");
+    this.validateCompositeState(newCompositeState);
+    return newCompositeState;
+  }
+  /**
+   * Remove conflicting states from the state map
+   */
+  removeConflictingStates(currentStateMap, regionKey) {
+    const keysToDelete = [];
+    for (const [key, value] of currentStateMap.entries()) {
+      const existingRegionKey = this.getRegionKey(value);
+      if (existingRegionKey === regionKey || existingRegionKey.startsWith(`${regionKey}.`)) {
+        keysToDelete.push(key);
+      }
+    }
+    for (const key of keysToDelete) {
+      currentStateMap.delete(key);
+    }
+  }
+  /**
+   * Add region states to the state map
+   */
+  addRegionStates(currentStateMap, stateConfig, toStatePart) {
+    const initialStatesForRegions = this.getInitialStatesForRegions(
+      stateConfig.regions,
+      toStatePart
+    );
+    const regionStates = initialStatesForRegions.split("|");
+    for (const regionState of regionStates) {
+      const regionKeyNested = this.getRegionKey(regionState);
+      currentStateMap.set(regionKeyNested, regionState);
+    }
+  }
+  /**
+   * Clean up root states from the state map
+   */
+  cleanupRootStates(currentStateMap) {
+    const keysToDelete = [];
+    for (const [key, value] of currentStateMap.entries()) {
+      if (!value.includes(".")) {
+        keysToDelete.push(key);
+      }
+    }
+    for (const key of keysToDelete) {
+      currentStateMap.delete(key);
+    }
+  }
+  parseCompositeState(compositeState) {
+    const stateMap = /* @__PURE__ */ new Map();
+    if (!compositeState) return stateMap;
+    const stateParts = compositeState.split("|");
+    for (let i = 0; i < stateParts.length; i++) {
+      const statePart = stateParts[i];
+      if (statePart === void 0) continue;
+      const regionKey = this.getRegionKey(statePart);
+      stateMap.set(regionKey, statePart);
+    }
+    return stateMap;
+  }
+  getRegionKey(statePath) {
+    const lastDotIndex = statePath.lastIndexOf(".");
+    return lastDotIndex === -1 ? statePath : statePath.substring(0, lastDotIndex);
+  }
+  resumeTimers() {
+    for (const timers of this.activeTimers.values()) {
+      for (const id of timers) {
+        this.clearTimer(id);
+      }
+    }
+    this.activeTimers.clear();
+    const currentState = this.getCurrentState();
+    if (!currentState) return;
+    const activeStates = currentState.split("|");
+    const activeStatesSet = new Set(activeStates);
+    for (const stateName of this.stateEntryTimes.keys()) {
+      if (!activeStatesSet.has(stateName)) {
+        this.stateEntryTimes.delete(stateName);
+      }
+    }
+    const now = Date.now();
+    for (const stateName of activeStates) {
+      const state = this.states.get(stateName);
+      if (!state || !state.invoke || state.invoke.length === 0) continue;
+      const entryTime = this.stateEntryTimes.get(stateName);
+      const startTime = entryTime || now;
+      if (!entryTime) {
+        this.stateEntryTimes.set(stateName, startTime);
+      }
+      const elapsed = now - startTime;
+      const timers = [];
+      for (const invocation of state.invoke) {
+        const remaining = Math.max(0, invocation.delay - elapsed);
+        const callback = async () => {
+          const current = this.getCurrentState(this.adaptee);
+          if (current?.split("|").includes(stateName)) {
+            try {
+              if (invocation.cond && this.adaptee) {
+                try {
+                  if (!invocation.cond(this.adaptee.adaptee)) return;
+                } catch (_e) {
+                  return;
+                }
+              }
+              if (invocation.action && this.adaptee) {
+                await this.callAction(this.adaptee, invocation.action);
+              }
+              await this.fireEvent(invocation.event).catch((err) => {
+                this.logger.error(
+                  "Resumed timer transition error",
+                  { state: stateName, event: invocation.event },
+                  err
+                );
+              });
+            } catch (_err) {
+            }
+          }
+        };
+        const timerId = this.setTimer(callback, remaining);
+        timers.push(timerId);
+      }
+      this.activeTimers.set(stateName, timers);
+    }
+  }
+  // Методы сериализации
+  toJSON() {
+    const serializedStates = {};
+    const serializedEvents = {};
+    for (const [name, state] of this.states) {
+      serializedStates[name] = this.serializeState(state);
+    }
+    for (const [name, event] of this.events) {
+      serializedEvents[name] = this.serializeEvent(event);
+    }
+    const config = {
+      initialState: this.initialState,
+      stateAttribute: this.stateAttribute,
+      states: serializedStates,
+      events: serializedEvents,
+      onError: this.serializeAction(this.onError, "config_onError")
+    };
+    return JSON.stringify({
+      config,
+      currentState: this.getCurrentState(),
+      historyMap: Array.from(this.historyMap.entries()),
+      stateEntryTimes: Array.from(this.stateEntryTimes.entries())
+    });
+  }
+  /**
+   * Securely serializes the StateMachine to JSON (Async).
+   * Generates cryptographic hashes for all functions.
+   */
+  async toSecureJSON() {
+    const serializedStates = {};
+    const serializedEvents = {};
+    for (const [name, state] of this.states) {
+      serializedStates[name] = await this.serializeStateAsync(state);
+    }
+    for (const [name, event] of this.events) {
+      serializedEvents[name] = await this.serializeEventAsync(event);
+    }
+    const config = {
+      initialState: this.initialState,
+      stateAttribute: this.stateAttribute,
+      states: serializedStates,
+      events: serializedEvents,
+      onError: await this.serializeActionAsync(this.onError, "config_onError")
+    };
+    return JSON.stringify({
+      config,
+      currentState: this.getCurrentState(),
+      historyMap: Array.from(this.historyMap.entries()),
+      stateEntryTimes: Array.from(this.stateEntryTimes.entries())
+    });
+  }
+  /**
+   * Serialize state with optimized performance (Async)
+   */
+  async serializeStateAsync(state) {
+    const { name: _name, ...stateWithoutName } = state;
+    const serializedState = {
+      ...stateWithoutName,
+      onBeforeEnter: await this.serializeActionAsync(
+        state.onBeforeEnter,
+        "onBeforeEnter"
+      ),
+      onEnter: await this.serializeActionAsync(state.onEnter, "onEnter"),
+      onAfterEnter: await this.serializeActionAsync(
+        state.onAfterEnter,
+        "onAfterEnter"
+      ),
+      onBeforeExit: await this.serializeActionAsync(
+        state.onBeforeExit,
+        "onBeforeExit"
+      ),
+      onExit: await this.serializeActionAsync(state.onExit, "onExit"),
+      onAfterExit: await this.serializeActionAsync(
+        state.onAfterExit,
+        "onAfterExit"
+      ),
+      onError: await this.serializeActionAsync(state.onError, "state_onError")
+    };
+    if (state.invoke) {
+      serializedState.invoke = await Promise.all(
+        state.invoke.map(async (inv) => ({
+          ...inv,
+          cond: inv.cond != null ? await safeFunctionSerializer.serializeActionAsync(
+            inv.cond,
+            "invoke_cond"
+          ) : void 0,
+          action: inv.action != null ? await safeFunctionSerializer.serializeActionAsync(
+            inv.action,
+            "invoke_action"
+          ) : void 0
+        }))
+      );
+    }
+    return serializedState;
+  }
+  /**
+   * Serialize state with optimized performance
+   */
+  serializeState(state) {
+    const { name: _name, ...stateWithoutName } = state;
+    const serializedState = {
+      ...stateWithoutName,
+      onBeforeEnter: this.serializeAction(state.onBeforeEnter, "onBeforeEnter"),
+      onEnter: this.serializeAction(state.onEnter, "onEnter"),
+      onAfterEnter: this.serializeAction(state.onAfterEnter, "onAfterEnter"),
+      onBeforeExit: this.serializeAction(state.onBeforeExit, "onBeforeExit"),
+      onExit: this.serializeAction(state.onExit, "onExit"),
+      onAfterExit: this.serializeAction(state.onAfterExit, "onAfterExit"),
+      onError: this.serializeAction(state.onError, "state_onError")
+    };
+    if (state.invoke) {
+      serializedState.invoke = state.invoke.map((inv) => ({
+        ...inv,
+        cond: inv.cond != null ? safeFunctionSerializer.serializeAction(inv.cond, "invoke_cond") : void 0,
+        action: inv.action != null ? safeFunctionSerializer.serializeAction(inv.action, "invoke_action") : void 0
+      }));
+    }
+    return serializedState;
+  }
+  /**
+   * Serialize event with optimized performance (Async)
+   */
+  async serializeEventAsync(event) {
+    const { name: _name, ...eventWithoutName } = event;
+    return {
+      ...eventWithoutName,
+      onBefore: await this.serializeActionAsync(
+        event.onBefore,
+        "event_onBefore"
+      ),
+      onAfter: await this.serializeActionAsync(event.onAfter, "event_onAfter"),
+      onSuccess: await this.serializeActionAsync(
+        event.onSuccess,
+        "event_onSuccess"
+      ),
+      onError: await this.serializeActionAsync(event.onError, "event_onError"),
+      transitions: await Promise.all(
+        event.transitions.map((t) => this.serializeTransitionAsync(t))
+      )
+    };
+  }
+  /**
+   * Serialize transition (Async)
+   */
+  async serializeTransitionAsync(transition) {
+    return {
+      ...transition,
+      guard: await this.serializeActionAsync(
+        transition.guard,
+        "transition_guard"
+      ),
+      onTransition: await this.serializeActionAsync(
+        transition.onTransition,
+        "transition_onTransition"
+      ),
+      onError: await this.serializeActionAsync(
+        transition.onError,
+        "transition_onError"
+      )
+    };
+  }
+  /**
+   * Serialize event with optimized performance
+   */
+  serializeEvent(event) {
+    const { name: _name, ...eventWithoutName } = event;
+    return {
+      ...eventWithoutName,
+      onBefore: this.serializeAction(event.onBefore, "event_onBefore"),
+      onAfter: this.serializeAction(event.onAfter, "event_onAfter"),
+      onSuccess: this.serializeAction(event.onSuccess, "event_onSuccess"),
+      onError: this.serializeAction(event.onError, "event_onError"),
+      transitions: event.transitions.map((transition) => ({
+        ...transition,
+        guard: this.serializeAction(transition.guard, "transition_guard"),
+        onTransition: this.serializeAction(
+          transition.onTransition,
+          "transition_onTransition"
+        ),
+        onError: this.serializeAction(transition.onError, "transition_onError")
+      }))
+    };
+  }
+  async serializeActionAsync(action, name) {
+    if (!action) return void 0;
+    return safeFunctionSerializer.serializeActionAsync(action, name);
+  }
+  /**
+   * Optimized action serialization using safe serializer
+   */
+  serializeAction(action, functionName) {
+    if (typeof action === "function") {
+      return safeFunctionSerializer.serializeAction(action, functionName);
+    }
+    return action;
+  }
+};
+
+// src/lite.ts
+function createMachine(config, owner, options) {
+  if (owner && "get" in owner) {
+    return new StateMachine(config, owner, options);
+  } else if (owner) {
+    const adapter = new MemoryAdapter(owner);
+    return new StateMachine(config, adapter, options);
+  } else {
+    return new StateMachine(config, void 0, options);
+  }
+}
+
+// src/config_validator.ts
+var DEFAULT_VALIDATION_CONFIG = {
+  strictMode: false,
+  allowEmptyStates: false,
+  allowEmptyEvents: false,
+  maxStateDepth: 10,
+  maxStatesCount: 1e3,
+  maxEventsCount: 1e3,
+  requireInitialState: true,
+  validateTransitionPaths: true,
+  validateActionReferences: false
+  // Disabled by default as actions might be dynamic
+};
+var ConfigValidator = class {
+  config;
+  errors = [];
+  warnings = [];
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_VALIDATION_CONFIG, ...config };
+  }
+  /**
+   * Validates a complete StateMachine configuration
+   */
+  validate(smConfig) {
+    this.errors = [];
+    this.warnings = [];
+    try {
+      this.validateBasicStructure(smConfig);
+      this.validateStates(smConfig.states, "states");
+      this.validateEvents(smConfig.events, smConfig.states, "events");
+      this.validateInitialState(smConfig);
+      this.validateCrossReferences(smConfig);
+      this.validatePerformanceConstraints(smConfig);
+      this.runCustomRules(smConfig);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      this.addError(
+        "VALIDATION_FAILED",
+        `Validation process failed: ${msg}`,
+        "validation"
+      );
+    }
+    const result = {
+      isValid: this.errors.length === 0,
+      errors: this.errors,
+      warnings: this.warnings
+    };
+    if (!result.isValid) {
+      stateMachineLogger.error("StateMachine configuration validation failed", {
+        errorCount: this.errors.length,
+        warningCount: this.warnings.length,
+        configName: smConfig.name
+      });
+    } else if (this.warnings.length > 0) {
+      stateMachineLogger.warn("StateMachine configuration has warnings", {
+        warningCount: this.warnings.length,
+        configName: smConfig.name
+      });
+    }
+    return result;
+  }
+  /**
+   * Runs custom validation rules
+   */
+  runCustomRules(smConfig) {
+    if (!this.config.customRules || this.config.customRules.length === 0) return;
+    const context = {
+      addError: (code, msg, path, sugg) => this.addError(code, msg, path, void 0, sugg),
+      addWarning: (code, msg, path, sugg) => this.addWarning(code, msg, path, void 0, sugg)
+    };
+    for (const rule of this.config.customRules) {
+      try {
+        rule.validate(smConfig, context);
+      } catch (e) {
+        this.addError(
+          "CUSTOM_RULE_ERROR",
+          `Rule ${rule.id} failed: ${e instanceof Error ? e.message : String(e)}`,
+          "root"
+        );
+      }
+    }
+  }
+  validateBasicStructure(smConfig) {
+    if (!smConfig.name || typeof smConfig.name !== "string") {
+      this.addError(
+        "MISSING_NAME",
+        "StateMachine must have a valid name",
+        "name"
+      );
+    }
+    if (!smConfig.stateAttribute || typeof smConfig.stateAttribute !== "string") {
+      this.addError(
+        "MISSING_STATE_ATTRIBUTE",
+        "StateMachine must have a valid stateAttribute",
+        "stateAttribute"
+      );
+    }
+    if (!smConfig.states || typeof smConfig.states !== "object") {
+      this.addError(
+        "MISSING_STATES",
+        "StateMachine must have states configuration",
+        "states"
+      );
+      return;
+    }
+    if (!smConfig.events || typeof smConfig.events !== "object") {
+      this.addError(
+        "MISSING_EVENTS",
+        "StateMachine must have events configuration",
+        "events"
+      );
+      return;
+    }
+    if (!this.config.allowEmptyStates && Object.keys(smConfig.states).length === 0) {
+      this.addError(
+        "EMPTY_STATES",
+        "StateMachine cannot have empty states collection",
+        "states"
+      );
+    }
+    if (!this.config.allowEmptyEvents && Object.keys(smConfig.events).length === 0) {
+      this.addError(
+        "EMPTY_EVENTS",
+        "StateMachine cannot have empty events collection",
+        "events"
+      );
+    }
+  }
+  validateStates(states, basePath, depth = 0) {
+    if (depth > this.config.maxStateDepth) {
+      this.addError(
+        "MAX_DEPTH_EXCEEDED",
+        `State nesting depth exceeds maximum of ${this.config.maxStateDepth}`,
+        basePath
+      );
+      return;
+    }
+    for (const [stateName, stateConfig] of Object.entries(states)) {
+      const statePath = `${basePath}.${stateName}`;
+      this.validateState(stateConfig, statePath, depth);
+    }
+  }
+  validateState(state, path, depth) {
+    if (!path.split(".").pop()) {
+      this.addError("INVALID_STATE_NAME", "State name cannot be empty", path);
+    }
+    if (state.display && typeof state.display !== "string") {
+      this.addWarning(
+        "INVALID_DISPLAY",
+        "State display should be a string",
+        `${path}.display`
+      );
+    }
+    if (state.regions) {
+      if (typeof state.regions !== "object") {
+        this.addError(
+          "INVALID_REGIONS",
+          "State regions must be an object",
+          `${path}.regions`
+        );
+      } else {
+        for (const [regionName, regionStates] of Object.entries(
+          state.regions
+        )) {
+          if (!regionName) {
+            this.addError(
+              "EMPTY_REGION_NAME",
+              "Region name cannot be empty",
+              `${path}.regions`
+            );
+            continue;
+          }
+          this.validateStates(
+            regionStates,
+            `${path}.regions.${regionName}`,
+            depth + 1
+          );
+        }
+      }
+    }
+    if (state.history && !["deep", "shallow"].includes(state.history)) {
+      this.addError(
+        "INVALID_HISTORY",
+        'State history must be "deep" or "shallow"',
+        `${path}.history`
+      );
+    }
+    if (state.regions && state.initial) {
+      const hasInitialState = Object.values(state.regions).some(
+        (regionStates) => Object.keys(regionStates).includes(state.initial)
+      );
+      if (!hasInitialState) {
+        this.addError(
+          "INVALID_INITIAL_STATE",
+          `Initial state "${state.initial}" not found in any region`,
+          `${path}.initial`
+        );
+      }
+    }
+    if (state.invoke) {
+      if (!Array.isArray(state.invoke)) {
+        this.addError(
+          "INVALID_INVOKE",
+          'State "invoke" must be an array of StateInvocation',
+          `${path}.invoke`
+        );
+      } else {
+        state.invoke.forEach((inv, index) => {
+          const invPath = `${path}.invoke[${index}]`;
+          if (typeof inv.delay !== "number" || inv.delay < 0) {
+            this.addError(
+              "INVALID_DELAY",
+              "Delay must be a positive number",
+              `${invPath}.delay`
+            );
+          }
+          if (!inv.event || typeof inv.event !== "string") {
+            this.addError(
+              "INVALID_EVENT_NAME",
+              "Event name must be a string",
+              `${invPath}.event`
+            );
+          }
+          if (inv.cond && typeof inv.cond !== "function") {
+            this.addError(
+              "INVALID_COND",
+              "Condition must be a function",
+              `${invPath}.cond`
+            );
+          }
+        });
+      }
+    }
+  }
+  validateEvents(events, states, basePath) {
+    for (const [eventName, eventConfig] of Object.entries(events)) {
+      const eventPath = `${basePath}.${eventName}`;
+      this.validateEvent(eventConfig, eventPath, states);
+    }
+  }
+  validateEvent(event, path, states) {
+    if (!event.transitions || !Array.isArray(event.transitions)) {
+      this.addError(
+        "MISSING_TRANSITIONS",
+        "Event must have transitions array",
+        `${path}.transitions`
+      );
+      return;
+    }
+    if (event.transitions.length === 0) {
+      this.addWarning(
+        "EMPTY_TRANSITIONS",
+        "Event has no transitions",
+        `${path}.transitions`
+      );
+    }
+    event.transitions.forEach((transition, index) => {
+      this.validateTransition(
+        transition,
+        `${path}.transitions[${index}]`,
+        states
+      );
+    });
+    const priorities = event.transitions.map((t) => t.priority).filter((p) => p !== void 0);
+    if (priorities.length > 0 && priorities.length !== event.transitions.length) {
+      this.addWarning(
+        "MIXED_PRIORITIES",
+        "Some transitions have priority while others do not",
+        `${path}.transitions`
+      );
+    }
+  }
+  validateTransition(transition, path, states) {
+    if (!transition.from || typeof transition.from !== "string") {
+      this.addError(
+        "INVALID_FROM_STATE",
+        "Transition must have a valid from state",
+        `${path}.from`
+      );
+    } else if (this.config.validateTransitionPaths) {
+      this.validateStatePath(transition.from, states, `${path}.from`);
+    }
+    if (!transition.to || typeof transition.to !== "string") {
+      this.addError(
+        "INVALID_TO_STATE",
+        "Transition must have a valid to state",
+        `${path}.to`
+      );
+    } else if (this.config.validateTransitionPaths) {
+      this.validateStatePath(transition.to, states, `${path}.to`);
+    }
+    if (transition.priority !== void 0 && typeof transition.priority !== "number") {
+      this.addError(
+        "INVALID_PRIORITY",
+        "Transition priority must be a number",
+        `${path}.priority`
+      );
+    }
+    if (transition.from === transition.to) {
+      this.addWarning(
+        "SELF_TRANSITION",
+        "Transition from and to states are the same",
+        path
+      );
+    }
+  }
+  validateStatePath(statePath, states, path) {
+    const stateParts = statePath.split("|");
+    for (const part of stateParts) {
+      if (!this.isValidStatePath(part, states)) {
+        this.addError(
+          "INVALID_STATE_PATH",
+          `State path "${part}" does not exist`,
+          path
+        );
+      }
+    }
+  }
+  isValidStatePath(statePath, states) {
+    const parts = statePath.split(".");
+    let currentStates = states;
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      if (part === void 0) return false;
+      if (i === 0) {
+        if (!currentStates[part]) {
+          return false;
+        }
+        const state = currentStates[part];
+        if (parts.length === 1) {
+          return true;
+        }
+        if (!state.regions) {
+          return false;
+        }
+      } else if (i === 1) {
+        const rootStatePart = parts[0];
+        if (rootStatePart === void 0) return false;
+        const rootState = currentStates[rootStatePart];
+        if (!rootState || !rootState.regions || !rootState.regions[part]) {
+          return false;
+        }
+        currentStates = rootState.regions[part];
+      } else {
+        if (!currentStates[part]) {
+          return false;
+        }
+        const state = currentStates[part];
+        if (i === parts.length - 1) {
+          return true;
+        }
+        if (!state.regions) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  validateInitialState(smConfig) {
+    if (this.config.requireInitialState) {
+      if (!smConfig.initialState) {
+        this.addError(
+          "MISSING_INITIAL_STATE",
+          "StateMachine must have an initial state",
+          "initialState"
+        );
+        return;
+      }
+      if (!smConfig.states[smConfig.initialState]) {
+        this.addError(
+          "INVALID_INITIAL_STATE",
+          `Initial state "${smConfig.initialState}" does not exist`,
+          "initialState",
+          void 0,
+          `Check the 'states' object. Ensure that '${smConfig.initialState}' is defined as a root state.`
+        );
+      }
+    }
+  }
+  validateCrossReferences(smConfig) {
+    const allStateNames = /* @__PURE__ */ new Set();
+    this.collectStateNames(smConfig.states, "", allStateNames);
+    const reachableStates = /* @__PURE__ */ new Set();
+    if (smConfig.initialState) {
+      reachableStates.add(smConfig.initialState);
+    }
+    for (const event of Object.values(smConfig.events)) {
+      for (const transition of event.transitions) {
+        if (transition.to) {
+          const toParts = transition.to.split("|");
+          toParts.forEach((part) => reachableStates.add(part));
+        }
+      }
+    }
+    for (const stateName of allStateNames) {
+      if (!reachableStates.has(stateName)) {
+        this.addWarning(
+          "UNREACHABLE_STATE",
+          `State "${stateName}" is not reachable`,
+          `states.${stateName}`
+        );
+      }
+    }
+    for (const [eventName, event] of Object.entries(smConfig.events)) {
+      const hasValidTransitions = event.transitions.some(
+        (t) => allStateNames.has(t.from) && allStateNames.has(t.to)
+      );
+      if (!hasValidTransitions) {
+        this.addWarning(
+          "UNUSED_EVENT",
+          `Event "${eventName}" has no valid transitions`,
+          `events.${eventName}`
+        );
+      }
+    }
+  }
+  collectStateNames(states, prefix, collector) {
+    for (const [stateName, state] of Object.entries(states)) {
+      const fullName = prefix ? `${prefix}.${stateName}` : stateName;
+      collector.add(fullName);
+      if (state.regions) {
+        for (const [regionName, regionStates] of Object.entries(
+          state.regions
+        )) {
+          this.collectStateNames(
+            regionStates,
+            `${fullName}.${regionName}`,
+            collector
+          );
+        }
+      }
+    }
+  }
+  validatePerformanceConstraints(smConfig) {
+    const stateCount = this.countStates(smConfig.states);
+    const eventCount = Object.keys(smConfig.events).length;
+    if (stateCount > this.config.maxStatesCount) {
+      this.addWarning(
+        "TOO_MANY_STATES",
+        `State count (${stateCount}) exceeds recommended maximum (${this.config.maxStatesCount})`,
+        "states"
+      );
+    }
+    if (eventCount > this.config.maxEventsCount) {
+      this.addWarning(
+        "TOO_MANY_EVENTS",
+        `Event count (${eventCount}) exceeds recommended maximum (${this.config.maxEventsCount})`,
+        "events"
+      );
+    }
+    let totalTransitions = 0;
+    for (const event of Object.values(smConfig.events)) {
+      totalTransitions += event.transitions.length;
+    }
+    if (totalTransitions > stateCount * 3) {
+      this.addWarning(
+        "COMPLEX_TRANSITIONS",
+        "High transition-to-state ratio may impact performance",
+        "events"
+      );
+    }
+  }
+  countStates(states) {
+    let count = Object.keys(states).length;
+    for (const state of Object.values(states)) {
+      if (state.regions) {
+        for (const regionStates of Object.values(state.regions)) {
+          count += this.countStates(regionStates);
+        }
+      }
+    }
+    return count;
+  }
+  addError(code, message, path, details, suggestion) {
+    this.errors.push({
+      code,
+      message,
+      severity: "error",
+      path,
+      ...details !== void 0 ? { details } : {},
+      ...suggestion !== void 0 ? { suggestion } : {}
+    });
+  }
+  addWarning(code, message, path, details, suggestion) {
+    this.warnings.push({
+      code,
+      message,
+      severity: "warning",
+      path,
+      ...details !== void 0 ? { details } : {},
+      ...suggestion !== void 0 ? { suggestion } : {}
+    });
+  }
+};
+function validateConfig(config, validationConfig) {
+  const validator = new ConfigValidator(validationConfig);
+  return validator.validate(config);
+}
+function validateConfigStrict(config) {
+  return validateConfig(config, { strictMode: true });
+}
+function isValidConfig(config) {
+  return validateConfig(config).isValid;
+}
+export {
+  ErrorHandler as EnhancedErrorHandler,
+  EnhancedStateMachineError,
+  ErrorAnalytics,
+  ErrorCategory,
+  ErrorSeverity,
+  FallbackStateRecoveryStrategy,
+  LocalStorageAdapter,
+  MemoryAdapter,
+  RetryRecoveryStrategy,
+  ServerAdapter,
+  SessionStorageAdapter,
+  StateMachine,
+  StateMachineError,
+  createEnhancedError,
+  createMachine,
+  isAdapter,
+  isRecoverableError,
+  isValidConfig,
+  validateConfig,
+  validateConfigStrict
+};
+//# sourceMappingURL=index.js.map