@tontoko/fast-playwright-mcp 0.0.4

package/lib/diagnostics/unified-system.js

@@ -0,0 +1,717 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/diagnostics/unified-system.ts
+import { getErrorMessage } from "../utils/common-formatters.js";
+import {
+  createAdvancedStage,
+  createCoreStage,
+  createDependentStage,
+  InitializationManager
+} from "./common/initialization-manager.js";
+import { PerformanceTracker } from "./common/performance-tracker.js";
+import { DiagnosticError } from "./diagnostic-error.js";
+import { ElementDiscovery } from "./element-discovery.js";
+import { EnhancedErrorHandler } from "./enhanced-error-handler.js";
+import { PageAnalyzer } from "./page-analyzer.js";
+import { ParallelPageAnalyzer } from "./parallel-page-analyzer.js";
+import { ResourceManager } from "./resource-manager.js";
+import { SmartConfigManager } from "./smart-config.js";
+
+class UnifiedDiagnosticSystem {
+  static instances = new Map;
+  page;
+  configManager;
+  initializationManager;
+  performanceTracker;
+  disposed = false;
+  pageAnalyzer;
+  parallelAnalyzer;
+  elementDiscovery;
+  resourceManager;
+  errorHandler;
+  get isInitialized() {
+    return this.initializationManager?.getIsInitialized() ?? false;
+  }
+  get initializationPromise() {
+    return this.initializationManager?.initializationPromise ?? null;
+  }
+  stats;
+  operationHistory = [];
+  constructor(page, config) {
+    this.page = page;
+    this.configManager = SmartConfigManager.getInstance(config);
+    if (!this.configManager) {
+      throw new DiagnosticError("Failed to initialize SmartConfigManager", {
+        timestamp: Date.now(),
+        component: "UnifiedSystem",
+        operation: "constructor",
+        suggestions: [
+          "Ensure SmartConfigManager singleton is not reset during initialization",
+          "Check if config parameter is valid",
+          "Verify no concurrent initialization issues"
+        ]
+      });
+    }
+    this.performanceTracker = new PerformanceTracker;
+    this.initializationManager = new InitializationManager({
+      componentName: "UnifiedSystem",
+      config,
+      performanceTracker: this.performanceTracker
+    });
+    this.stats = this.initializeStats();
+    this.setupConfigurationListener();
+  }
+  async initializeComponents() {
+    if (this.disposed) {
+      throw new DiagnosticError("System has been disposed and cannot be reinitialized", {
+        timestamp: Date.now(),
+        component: "UnifiedSystem",
+        operation: "initializeComponents",
+        suggestions: [
+          "Create a new system instance instead of reusing disposed instance",
+          "Check component dependencies",
+          "Ensure proper disposal handling"
+        ]
+      });
+    }
+    if (!this.initializationManager) {
+      throw new DiagnosticError("InitializationManager is not available", {
+        timestamp: Date.now(),
+        component: "UnifiedSystem",
+        operation: "initializeComponents",
+        suggestions: [
+          "Verify system was properly constructed",
+          "Check if instance was disposed",
+          "Ensure getInstance was called with valid page"
+        ]
+      });
+    }
+    try {
+      const stages = [
+        createCoreStage("core-infrastructure", [
+          () => {
+            this.resourceManager = new ResourceManager;
+            this.initializationManager.trackPartialInitialization(this.resourceManager);
+            return Promise.resolve();
+          }
+        ]),
+        createDependentStage("page-dependent", ["core-infrastructure"], [
+          () => {
+            if (!this.configManager) {
+              throw new DiagnosticError("SmartConfigManager is not available during component initialization", {
+                timestamp: Date.now(),
+                component: "UnifiedSystem",
+                operation: "initializeComponents",
+                suggestions: [
+                  "Check if SmartConfigManager instance was reset during initialization",
+                  "Ensure singleton lifecycle is properly managed",
+                  "Verify no concurrent disposal operations"
+                ]
+              });
+            }
+            const componentConfig = this.configManager.getComponentConfig("pageAnalyzer");
+            this.pageAnalyzer = new PageAnalyzer(this.page);
+            this.elementDiscovery = new ElementDiscovery(this.page);
+            this.errorHandler = new EnhancedErrorHandler(this.page, componentConfig.diagnostic);
+            this.initializationManager.trackPartialInitialization(this.pageAnalyzer);
+            this.initializationManager.trackPartialInitialization(this.elementDiscovery);
+            return Promise.resolve();
+          }
+        ]),
+        createAdvancedStage("advanced-features", [
+          () => {
+            this.parallelAnalyzer = new ParallelPageAnalyzer(this.page);
+            this.initializationManager.trackPartialInitialization(this.parallelAnalyzer);
+            return Promise.resolve();
+          }
+        ])
+      ];
+      await this.initializationManager.initialize(stages);
+    } catch (error) {
+      if (error instanceof DiagnosticError) {
+        throw error;
+      }
+      const baseError = error instanceof Error ? error : new Error(String(error));
+      throw new DiagnosticError(`Component initialization failed: ${baseError.message}`, {
+        timestamp: Date.now(),
+        component: "UnifiedSystem",
+        operation: "initializeComponents",
+        suggestions: [
+          "Review component dependencies",
+          "Check page and configuration validity",
+          "Verify all required components are available"
+        ],
+        context: {
+          stage: "initialization",
+          failedComponents: this ? this.getFailedComponents?.() ?? [] : []
+        }
+      }, baseError);
+    }
+  }
+  getFailedComponents() {
+    const failedComponents = [];
+    if (!this.resourceManager) {
+      failedComponents.push("ResourceManager");
+    }
+    if (!this.pageAnalyzer) {
+      failedComponents.push("PageAnalyzer");
+    }
+    if (!this.elementDiscovery) {
+      failedComponents.push("ElementDiscovery");
+    }
+    if (!this.errorHandler) {
+      failedComponents.push("ErrorHandler");
+    }
+    if (!this.parallelAnalyzer) {
+      failedComponents.push("ParallelAnalyzer");
+    }
+    return failedComponents;
+  }
+  async cleanupPartialInitialization(components) {
+    await Promise.allSettled(components.map(async (component) => {
+      try {
+        await component.dispose();
+      } catch {}
+    }));
+  }
+  async ensureInitialized() {
+    if (!this.initializationManager.getIsInitialized()) {
+      await this.initializeComponents();
+    }
+    if (!this.initializationManager.getIsInitialized()) {
+      const error = this.initializationManager.getInitializationError();
+      throw error || new DiagnosticError("UnifiedSystem components are not initialized", {
+        timestamp: Date.now(),
+        component: "UnifiedSystem",
+        operation: "ensureInitialized",
+        suggestions: [
+          "Call initializeComponents() before using the system",
+          "Check for initialization errors",
+          "Verify page and configuration are valid"
+        ]
+      });
+    }
+  }
+  static getInstance(page, config) {
+    if (!UnifiedDiagnosticSystem.instances.has(page)) {
+      const instance = new UnifiedDiagnosticSystem(page, config);
+      UnifiedDiagnosticSystem.instances.set(page, instance);
+    }
+    const system = UnifiedDiagnosticSystem.instances.get(page);
+    if (!system) {
+      throw new Error("UnifiedDiagnosticSystem instance not found");
+    }
+    return system;
+  }
+  static disposeInstance(page) {
+    const instance = UnifiedDiagnosticSystem.instances.get(page);
+    if (instance) {
+      instance.dispose();
+      UnifiedDiagnosticSystem.instances.delete(page);
+    }
+  }
+  initializeStats() {
+    return {
+      operationCount: {},
+      errorCount: {
+        PageAnalyzer: 0,
+        ElementDiscovery: 0,
+        ResourceManager: 0,
+        ErrorHandler: 0,
+        ConfigManager: 0,
+        UnifiedSystem: 0,
+        InitializationManager: 0
+      },
+      performanceMetrics: {
+        averageExecutionTime: {},
+        peakMemoryUsage: 0,
+        totalOperations: 0,
+        successRate: 1
+      },
+      resourceUsage: {
+        currentHandles: 0,
+        peakHandles: 0,
+        memoryLeaks: 0,
+        autoDisposeCount: 0
+      }
+    };
+  }
+  setupConfigurationListener() {
+    if (!this.configManager) {
+      return;
+    }
+    this.configManager.onConfigChange((_config) => {});
+  }
+  async executeOperation(operation, component, fn, options) {
+    const startTime = Date.now();
+    if (!this.configManager) {
+      throw new DiagnosticError("SmartConfigManager is not available for operation execution", {
+        timestamp: startTime,
+        component: "UnifiedSystem",
+        operation: "executeOperation",
+        suggestions: [
+          "Ensure UnifiedSystem is properly initialized",
+          "Check if SmartConfigManager instance was disposed",
+          "Verify system lifecycle management"
+        ],
+        context: {
+          operation,
+          targetComponent: component
+        }
+      });
+    }
+    const config = this.configManager.getConfig();
+    let componentConfigType;
+    switch (component) {
+      case "ElementDiscovery":
+        componentConfigType = "elementDiscovery";
+        break;
+      case "ResourceManager":
+        componentConfigType = "resourceManager";
+        break;
+      default:
+        componentConfigType = "pageAnalyzer";
+    }
+    const componentConfig = this.configManager.getComponentConfig(componentConfigType);
+    try {
+      const timeout = Number(options?.timeout ?? componentConfig.executionTimeout ?? 1e4);
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error(`Operation timeout after ${timeout}ms`)), timeout);
+      });
+      const result = await Promise.race([fn(), timeoutPromise]);
+      const executionTime = Date.now() - startTime;
+      this.recordOperation(operation, component, executionTime, true);
+      return {
+        success: true,
+        data: result,
+        executionTime
+      };
+    } catch (error) {
+      const executionTime = Date.now() - startTime;
+      this.recordOperation(operation, component, executionTime, false);
+      this.stats.errorCount[component]++;
+      let enhancedDiagnosticError;
+      if (error instanceof DiagnosticError) {
+        enhancedDiagnosticError = error;
+      } else {
+        const baseError = error instanceof Error ? error : new Error(getErrorMessage(error));
+        enhancedDiagnosticError = DiagnosticError.from(baseError, component, operation, {
+          executionTime,
+          timestamp: startTime
+        });
+      }
+      let enrichedError = enhancedDiagnosticError;
+      if (config.errorHandling.enableErrorEnrichment) {
+        try {
+          enrichedError = await this.enrichError(enhancedDiagnosticError, operation);
+        } catch {}
+      }
+      return {
+        success: false,
+        error: enrichedError,
+        executionTime
+      };
+    }
+  }
+  recordOperation(operation, component, executionTime, success) {
+    this.updateOperationStats(operation, executionTime, success);
+    this.updateOperationHistory(operation, component, executionTime, success);
+    this.performAdaptiveThresholdAdjustment(operation, component);
+  }
+  updateOperationStats(operation, executionTime, success) {
+    this.stats.operationCount[operation] = (this.stats.operationCount[operation] ?? 0) + 1;
+    const currentAvg = this.stats.performanceMetrics.averageExecutionTime[operation] ?? 0;
+    const currentCount = this.stats.operationCount[operation];
+    this.stats.performanceMetrics.averageExecutionTime[operation] = (currentAvg * (currentCount - 1) + executionTime) / currentCount;
+    this.stats.performanceMetrics.totalOperations++;
+    const successfulOps = this.operationHistory.filter((op) => op.success).length + (success ? 1 : 0);
+    const totalOps = this.operationHistory.length + 1;
+    this.stats.performanceMetrics.successRate = successfulOps / totalOps;
+  }
+  updateOperationHistory(operation, component, executionTime, success) {
+    this.operationHistory.push({
+      operation,
+      component,
+      timestamp: Date.now(),
+      executionTime,
+      success
+    });
+    const maxHistory = this.configManager ? this.configManager.getConfig().errorHandling.maxErrorHistory : 100;
+    if (this.operationHistory.length > maxHistory) {
+      this.operationHistory = this.operationHistory.slice(-maxHistory);
+    }
+  }
+  performAdaptiveThresholdAdjustment(operation, component) {
+    if (!this.configManager?.isAdaptiveThresholdsEnabled()) {
+      return;
+    }
+    const recentOps = this.operationHistory.filter((op) => op.operation === operation && Date.now() - op.timestamp < 300000);
+    if (recentOps.length >= 10) {
+      const avgTime = recentOps.reduce((sum, op) => sum + op.executionTime, 0) / recentOps.length;
+      const successRate = recentOps.filter((op) => op.success).length / recentOps.length;
+      this.adjustComponentThresholds(component, avgTime, successRate);
+    }
+  }
+  adjustComponentThresholds(component, avgTime, successRate) {
+    if (!this.configManager) {
+      return;
+    }
+    if (component === "PageAnalyzer") {
+      this.configManager.adjustThresholds("pageAnalysis", avgTime, successRate);
+    } else if (component === "ElementDiscovery") {
+      this.configManager.adjustThresholds("elementDiscovery", avgTime, successRate);
+    } else if (component === "ResourceManager") {
+      this.configManager.adjustThresholds("resourceMonitoring", avgTime, successRate);
+    }
+  }
+  async enrichError(error, operation) {
+    try {
+      if (!this.errorHandler) {
+        return error;
+      }
+      const enrichedPlaywrightError = await this.errorHandler.enhanceToolError({
+        toolName: operation,
+        error: new Error(error.message),
+        toolArgs: { component: error.component, operation: error.operation }
+      });
+      const enrichedDiagnosticError = new DiagnosticError(enrichedPlaywrightError.message, {
+        timestamp: error.timestamp,
+        component: error.component,
+        operation: error.operation,
+        executionTime: error.executionTime,
+        performanceImpact: error.performanceImpact,
+        suggestions: [
+          ...error.suggestions,
+          ...enrichedPlaywrightError.suggestions ?? []
+        ]
+      }, error.originalError);
+      return enrichedDiagnosticError;
+    } catch {
+      return error;
+    }
+  }
+  async analyzePageStructure(forceParallel) {
+    await this.ensureInitialized();
+    if (!this.configManager) {
+      throw new DiagnosticError("Cannot analyze page structure: SmartConfigManager is not available", {
+        timestamp: Date.now(),
+        component: "UnifiedSystem",
+        operation: "analyzePageStructure",
+        suggestions: [
+          "Ensure UnifiedSystem is properly initialized",
+          "Check if SmartConfigManager instance was disposed",
+          "Verify system lifecycle management"
+        ]
+      });
+    }
+    const config = this.configManager.getConfig();
+    const shouldUseParallel = forceParallel ?? config.features.enableParallelAnalysis;
+    if (shouldUseParallel) {
+      return this.executeOperation("analyzePageStructure", "PageAnalyzer", async () => {
+        const recommendation = await this.pageAnalyzer?.shouldUseParallelAnalysis();
+        if (recommendation?.recommended ?? forceParallel) {
+          return await this.parallelAnalyzer?.runParallelAnalysis();
+        }
+        return await this.pageAnalyzer?.analyzePageStructure();
+      });
+    }
+    return this.executeOperation("analyzePageStructure", "PageAnalyzer", async () => this.pageAnalyzer?.analyzePageStructure());
+  }
+  async findAlternativeElements(searchCriteria) {
+    await this.ensureInitialized();
+    return this.executeOperation("findAlternativeElements", "ElementDiscovery", async () => this.elementDiscovery?.findAlternativeElements({
+      originalSelector: "",
+      searchCriteria,
+      maxResults: 10
+    }));
+  }
+  async analyzePerformanceMetrics() {
+    await this.ensureInitialized();
+    return this.executeOperation("analyzePerformanceMetrics", "PageAnalyzer", async () => this.pageAnalyzer?.analyzePerformanceMetrics());
+  }
+  async createSmartHandle(creator, _disposer, _options) {
+    await this.ensureInitialized();
+    const handle = await creator();
+    const smartHandle = this.resourceManager?.createSmartHandle(handle, "dispose");
+    return smartHandle?.handle ?? handle;
+  }
+  updateConfiguration(updates) {
+    if (!this.configManager) {
+      throw new DiagnosticError("Cannot update configuration: SmartConfigManager is not available", {
+        timestamp: Date.now(),
+        component: "UnifiedSystem",
+        operation: "updateConfiguration",
+        suggestions: [
+          "Ensure UnifiedSystem is properly initialized",
+          "Check if SmartConfigManager instance was disposed",
+          "Verify system lifecycle management"
+        ]
+      });
+    }
+    this.configManager.updateConfig(updates);
+  }
+  getConfiguration() {
+    if (!this.configManager) {
+      throw new DiagnosticError("Cannot get configuration: SmartConfigManager is not available", {
+        timestamp: Date.now(),
+        component: "UnifiedSystem",
+        operation: "getConfiguration",
+        suggestions: [
+          "Ensure UnifiedSystem is properly initialized",
+          "Check if SmartConfigManager instance was disposed",
+          "Verify system lifecycle management"
+        ]
+      });
+    }
+    return this.configManager.getConfig();
+  }
+  getSystemStats() {
+    if (!(this.initializationManager.getIsInitialized() && this.resourceManager)) {
+      return this.stats;
+    }
+    const currentResourceUsage = this.resourceManager.getResourceStats();
+    return {
+      ...this.stats,
+      resourceUsage: {
+        ...this.stats.resourceUsage,
+        currentHandles: currentResourceUsage.activeCount,
+        peakHandles: Math.max(this.stats.resourceUsage.peakHandles ?? 0, currentResourceUsage.activeCount)
+      }
+    };
+  }
+  getRecentOperations(limit = 50) {
+    return this.operationHistory.slice(-limit);
+  }
+  getConfigurationReport() {
+    const configData = this.getConfigData();
+    const configurationStatus = this.determineConfigurationStatus(configData.configSummary);
+    const appliedOverrides = this.buildAppliedOverrides(configData.impactReport);
+    const performanceBaseline = this.calculatePerformanceBaseline(configData.config);
+    const recommendations = this.generateAllRecommendations(configData.impactReport, performanceBaseline.deviations);
+    return {
+      configurationStatus,
+      appliedOverrides,
+      performanceBaseline,
+      recommendations: this.sortRecommendations(recommendations)
+    };
+  }
+  getConfigData() {
+    if (!this.configManager) {
+      throw new DiagnosticError("Cannot get configuration data: SmartConfigManager is not available", {
+        timestamp: Date.now(),
+        component: "UnifiedSystem",
+        operation: "getConfigData",
+        suggestions: [
+          "Ensure UnifiedSystem is properly initialized",
+          "Check if SmartConfigManager instance was disposed",
+          "Verify system lifecycle management"
+        ]
+      });
+    }
+    const config = this.configManager.getConfig();
+    const impactReport = this.configManager.getConfigurationImpactReport();
+    const configSummary = this.configManager.getConfigurationSummary();
+    return { config, impactReport, configSummary };
+  }
+  determineConfigurationStatus(configSummary) {
+    if (configSummary.totalOverrides === 0) {
+      return "default";
+    }
+    return configSummary.totalOverrides > 5 ? "heavily-customized" : "customized";
+  }
+  buildAppliedOverrides(impactReport) {
+    return [
+      {
+        category: "Performance Thresholds",
+        changes: Object.entries(impactReport.performanceImpact.executionTimeChanges).map(([component, change]) => `${component}: ${change.from}ms → ${change.to}ms (${change.percentChange > 0 ? "+" : ""}${change.percentChange}%)`),
+        impact: Object.keys(impactReport.performanceImpact.executionTimeChanges).length > 2 ? "high" : "medium"
+      },
+      {
+        category: "Feature Flags",
+        changes: [
+          ...impactReport.featureChanges.enabled.map((feature) => `${feature}: Enabled`),
+          ...impactReport.featureChanges.disabled.map((feature) => `${feature}: Disabled`),
+          ...impactReport.featureChanges.modified
+        ],
+        impact: impactReport.featureChanges.enabled.length + impactReport.featureChanges.disabled.length > 2 ? "medium" : "low"
+      }
+    ].filter((override) => override.changes.length > 0);
+  }
+  calculatePerformanceBaseline(config) {
+    const expectedExecutionTimes = {
+      pageAnalysis: config.performance.thresholds.executionTime.pageAnalysis,
+      elementDiscovery: config.performance.thresholds.executionTime.elementDiscovery,
+      resourceMonitoring: config.performance.thresholds.executionTime.resourceMonitoring
+    };
+    const actualAverages = {
+      pageAnalysis: this.stats.performanceMetrics.averageExecutionTime.analyzePageStructure ?? 0,
+      elementDiscovery: this.stats.performanceMetrics.averageExecutionTime.findAlternativeElements ?? 0,
+      resourceMonitoring: this.stats.performanceMetrics.averageExecutionTime.resourceMonitoring ?? 0
+    };
+    const deviations = this.calculateDeviations(expectedExecutionTimes, actualAverages);
+    return { expectedExecutionTimes, actualAverages, deviations };
+  }
+  calculateDeviations(expected, actual) {
+    const deviations = {};
+    for (const key of Object.keys(expected)) {
+      const expectedTime = expected[key];
+      const actualTime = actual[key];
+      if (actualTime > 0 && expectedTime > 0) {
+        const percent = (actualTime - expectedTime) / expectedTime * 100;
+        let significance = "normal";
+        if (Math.abs(percent) > 50) {
+          significance = "significant";
+        } else if (Math.abs(percent) > 25) {
+          significance = "notable";
+        }
+        deviations[key] = { percent: Math.round(percent), significance };
+      }
+    }
+    return deviations;
+  }
+  generateAllRecommendations(impactReport, deviations) {
+    const recommendations = [];
+    this.addPerformanceRecommendations(recommendations, deviations);
+    this.addConfigurationRecommendations(recommendations, impactReport);
+    this.addErrorRateRecommendations(recommendations);
+    return recommendations;
+  }
+  addPerformanceRecommendations(recommendations, deviations) {
+    for (const [component, deviation] of Object.entries(deviations)) {
+      if (deviation.significance === "significant") {
+        if (deviation.percent > 50) {
+          recommendations.push({
+            type: "warning",
+            message: `${component} is taking ${Math.abs(deviation.percent)}% longer than expected - consider optimization`,
+            priority: "high"
+          });
+        } else if (deviation.percent < -50) {
+          recommendations.push({
+            type: "info",
+            message: `${component} is performing ${Math.abs(deviation.percent)}% faster than expected - thresholds may be too conservative`,
+            priority: "low"
+          });
+        }
+      }
+    }
+  }
+  addConfigurationRecommendations(recommendations, impactReport) {
+    if (impactReport.performanceImpact.recommendedOptimizations.length > 0) {
+      for (const optimization of impactReport.performanceImpact.recommendedOptimizations) {
+        recommendations.push({
+          type: "optimization",
+          message: optimization,
+          priority: "medium"
+        });
+      }
+    }
+    for (const warning of impactReport.validationStatus.warnings) {
+      recommendations.push({
+        type: "warning",
+        message: warning,
+        priority: "medium"
+      });
+    }
+  }
+  addErrorRateRecommendations(recommendations) {
+    const totalErrors = Object.values(this.stats.errorCount).reduce((sum, count) => sum + count, 0);
+    const errorRate = totalErrors / Math.max(this.stats.performanceMetrics.totalOperations, 1);
+    if (errorRate > 0.05) {
+      recommendations.push({
+        type: "warning",
+        message: `Error rate is ${(errorRate * 100).toFixed(1)}% - consider reviewing recent failures`,
+        priority: "high"
+      });
+    }
+  }
+  sortRecommendations(recommendations) {
+    return recommendations.sort((a, b) => {
+      const priorityOrder = { high: 3, medium: 2, low: 1 };
+      return priorityOrder[b.priority] - priorityOrder[a.priority];
+    });
+  }
+  performHealthCheck() {
+    const issues = [];
+    const recommendations = [];
+    if (!this.configManager) {
+      issues.push("SmartConfigManager is not available");
+      recommendations.push("Reinitialize UnifiedSystem with proper configuration");
+      return { status: "critical", issues, recommendations };
+    }
+    const config = this.configManager.getConfig();
+    if (!this.initializationManager.getIsInitialized()) {
+      issues.push("System not initialized");
+      recommendations.push("Call initializeComponents() to initialize the system");
+      return { status: "critical", issues, recommendations };
+    }
+    const resourceStats = this.resourceManager?.getResourceStats();
+    if (!resourceStats) {
+      issues.push("Resource manager not initialized");
+      recommendations.push("Initialize the system components");
+      return { status: "critical", issues, recommendations };
+    }
+    if (resourceStats.activeCount > config.maxConcurrentHandles * 0.9) {
+      issues.push(`High handle usage: ${resourceStats.activeCount}/${config.maxConcurrentHandles}`);
+      recommendations.push("Consider reducing concurrent operations or increasing maxConcurrentHandles");
+    }
+    const totalErrors = Object.values(this.stats.errorCount).reduce((sum, count) => sum + count, 0);
+    const errorRate = totalErrors / Math.max(this.stats.performanceMetrics.totalOperations, 1);
+    if (errorRate > 0.1) {
+      issues.push(`High error rate: ${(errorRate * 100).toFixed(1)}%`);
+      recommendations.push("Review recent errors and consider adjusting timeout thresholds");
+    }
+    const avgExecutionTimes = Object.values(this.stats.performanceMetrics.averageExecutionTime);
+    const avgOverall = avgExecutionTimes.reduce((sum, time) => sum + time, 0) / Math.max(avgExecutionTimes.length, 1);
+    if (avgOverall > 2000) {
+      issues.push(`Slow performance: average ${avgOverall.toFixed(0)}ms`);
+      recommendations.push("Consider enabling parallel analysis or optimizing operations");
+    }
+    let status = "healthy";
+    if (issues.length > 2) {
+      status = "critical";
+    } else if (issues.length > 0) {
+      status = "warning";
+    }
+    return { status, issues, recommendations };
+  }
+  async dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    try {
+      const disposePromises = [];
+      if (this.pageAnalyzer) {
+        disposePromises.push(this.pageAnalyzer.dispose());
+      }
+      if (this.parallelAnalyzer) {
+        disposePromises.push(this.parallelAnalyzer.dispose());
+      }
+      if (this.resourceManager) {
+        disposePromises.push(this.resourceManager.dispose());
+      }
+      await Promise.all(disposePromises);
+      await this.initializationManager.dispose();
+    } catch {}
+  }
+}
+export {
+  UnifiedDiagnosticSystem
+};