claude-flow-novice 2.15.2 → 2.15.4

package/dist/lib/lock-health-monitor.js

@@ -0,0 +1,298 @@
+/**
+ * Lock Health Monitor
+ *
+ * Monitors distributed locks for health issues, detects deadlocks,
+ * and performs automatic cleanup of stale locks.
+ *
+ * Features:
+ * - Deadlock detection (locks held >5x TTL)
+ * - Stale lock cleanup
+ * - Lock usage statistics
+ * - Contention hotspot detection
+ * - Background cleanup task
+ * - Incident logging
+ *
+ * Part of Phase 2, Task P2-2.2: Distributed Locking Enhancement
+ */ import { createLogger } from './logging.js';
+const logger = createLogger('lock-health-monitor');
+/**
+ * Lock Health Monitor
+ */ export class LockHealthMonitor {
+    redisClient;
+    lockManager;
+    deadlockIncidents = [];
+    cleanupStats = {
+        totalCleaned: 0,
+        cleanupRuns: 0
+    };
+    lockUsage = new Map();
+    contentionFailures = new Map();
+    backgroundCleanupTimer;
+    constructor(redisClient, lockManager){
+        this.redisClient = redisClient;
+        this.lockManager = lockManager;
+        logger.info('Lock health monitor initialized');
+    }
+    /**
+   * Detect deadlocks in the system
+   */ async detectDeadlocks() {
+        const deadlocks = [];
+        try {
+            // Get all lock keys from Redis
+            const lockKeys = await this.redisClient.keys('lock:*');
+            for (const lockKey of lockKeys){
+                const data = await this.redisClient.get(lockKey);
+                if (!data) continue;
+                const metadata = JSON.parse(data);
+                const acquiredAt = new Date(metadata.acquiredAt).getTime();
+                const expiresAt = new Date(metadata.expiresAt).getTime();
+                const now = Date.now();
+                const ttl = expiresAt - acquiredAt;
+                const heldDuration = now - acquiredAt;
+                // Detect stuck locks (held for >5x TTL)
+                if (heldDuration > ttl * 5) {
+                    deadlocks.push({
+                        lockKey,
+                        metadata,
+                        heldDuration,
+                        detectedAt: new Date(),
+                        type: 'stuck'
+                    });
+                    logger.warn('Deadlock detected: stuck lock', {
+                        lockKey,
+                        heldDuration,
+                        ttl,
+                        lockId: metadata.lockId
+                    });
+                }
+            }
+            // TODO: Advanced feature - detect circular wait deadlocks
+            // This would require tracking lock wait queues and building dependency graphs
+            return deadlocks;
+        } catch (err) {
+            logger.error('Error detecting deadlocks', err);
+            return deadlocks;
+        }
+    }
+    /**
+   * Resolve a deadlock by force-releasing the lock
+   */ async resolveDeadlock(deadlock) {
+        try {
+            logger.warn('Resolving deadlock', {
+                lockKey: deadlock.lockKey,
+                type: deadlock.type,
+                heldDuration: deadlock.heldDuration
+            });
+            // Extract resource key from lock key (remove 'lock:' prefix)
+            const resourceKey = deadlock.lockKey.replace(/^lock:/, '');
+            // Force release the lock
+            await this.lockManager.forceRelease(resourceKey);
+            // Log incident
+            const incident = {
+                lockKey: deadlock.lockKey,
+                detectedAt: deadlock.detectedAt,
+                resolvedAt: new Date(),
+                resolutionMethod: 'force-release',
+                metadata: deadlock.metadata
+            };
+            this.deadlockIncidents.push(incident);
+            // Keep only last 100 incidents
+            if (this.deadlockIncidents.length > 100) {
+                this.deadlockIncidents.shift();
+            }
+            logger.info('Deadlock resolved', {
+                lockKey: deadlock.lockKey,
+                resolutionMethod: incident.resolutionMethod
+            });
+        } catch (err) {
+            logger.error('Error resolving deadlock', err, {
+                lockKey: deadlock.lockKey
+            });
+            throw err;
+        }
+    }
+    /**
+   * Get deadlock incident history
+   */ getDeadlockIncidents() {
+        return [
+            ...this.deadlockIncidents
+        ];
+    }
+    /**
+   * Find stale locks (expired TTL but still in Redis)
+   */ async findStaleLocks() {
+        const staleLocks = [];
+        try {
+            const lockKeys = await this.redisClient.keys('lock:*');
+            for (const lockKey of lockKeys){
+                const ttl = await this.redisClient.pttl(lockKey);
+                // TTL < 0 means expired or no expiry set
+                if (ttl === -2) {
+                    continue;
+                }
+                if (ttl === -1) {
+                    // No expiry set - this is a stale lock!
+                    staleLocks.push(lockKey);
+                    logger.warn('Stale lock detected (no TTL)', {
+                        lockKey
+                    });
+                }
+                // Also check metadata expiration
+                const data = await this.redisClient.get(lockKey);
+                if (data) {
+                    const metadata = JSON.parse(data);
+                    const expiresAt = new Date(metadata.expiresAt).getTime();
+                    if (Date.now() > expiresAt) {
+                        staleLocks.push(lockKey);
+                        logger.warn('Stale lock detected (expired metadata)', {
+                            lockKey,
+                            expiresAt: metadata.expiresAt
+                        });
+                    }
+                }
+            }
+            return staleLocks;
+        } catch (err) {
+            logger.error('Error finding stale locks', err);
+            return staleLocks;
+        }
+    }
+    /**
+   * Cleanup stale locks
+   */ async cleanupStaleLocks() {
+        let cleaned = 0;
+        try {
+            const staleLocks = await this.findStaleLocks();
+            for (const lockKey of staleLocks){
+                try {
+                    await this.redisClient.del(lockKey);
+                    cleaned++;
+                    logger.info('Stale lock cleaned', {
+                        lockKey
+                    });
+                } catch (err) {
+                    logger.error('Error cleaning stale lock', err, {
+                        lockKey
+                    });
+                }
+            }
+            // Update cleanup stats
+            this.cleanupStats.totalCleaned += cleaned;
+            this.cleanupStats.lastCleanupAt = new Date();
+            this.cleanupStats.cleanupRuns++;
+            if (cleaned > 0) {
+                logger.info('Stale lock cleanup complete', {
+                    cleaned,
+                    totalCleaned: this.cleanupStats.totalCleaned
+                });
+            }
+            return cleaned;
+        } catch (err) {
+            logger.error('Error during stale lock cleanup', err);
+            return cleaned;
+        }
+    }
+    /**
+   * Get cleanup statistics
+   */ getCleanupStats() {
+        return {
+            ...this.cleanupStats
+        };
+    }
+    /**
+   * Start background cleanup task
+   */ startBackgroundCleanup(intervalMs = 60000) {
+        if (this.backgroundCleanupTimer) {
+            logger.warn('Background cleanup already running');
+            return;
+        }
+        logger.info('Starting background cleanup', {
+            intervalMs
+        });
+        this.backgroundCleanupTimer = setInterval(async ()=>{
+            try {
+                await this.cleanupStaleLocks();
+            } catch (err) {
+                logger.error('Background cleanup error', err);
+            }
+        }, intervalMs);
+    }
+    /**
+   * Stop background cleanup task
+   */ stopBackgroundCleanup() {
+        if (this.backgroundCleanupTimer) {
+            clearInterval(this.backgroundCleanupTimer);
+            this.backgroundCleanupTimer = undefined;
+            logger.info('Background cleanup stopped');
+        }
+    }
+    /**
+   * Track lock acquisition for usage statistics
+   */ trackAcquisition(resource) {
+        const count = this.lockUsage.get(resource) || 0;
+        this.lockUsage.set(resource, count + 1);
+    }
+    /**
+   * Track failed lock acquisition for contention detection
+   */ trackFailedAcquisition(resource) {
+        const existing = this.contentionFailures.get(resource);
+        if (existing) {
+            existing.failedAttempts++;
+            existing.lastFailureAt = new Date();
+        } else {
+            this.contentionFailures.set(resource, {
+                resource,
+                failedAttempts: 1,
+                lastFailureAt: new Date()
+            });
+        }
+    }
+    /**
+   * Get lock statistics
+   */ getLockStatistics() {
+        return this.lockManager.getStatistics();
+    }
+    /**
+   * Get lock usage by resource
+   */ getLockUsageByResource() {
+        const usage = {};
+        for (const [resource, count] of this.lockUsage.entries()){
+            usage[resource] = count;
+        }
+        return usage;
+    }
+    /**
+   * Get contention hotspots (resources with high failure rates)
+   */ getContentionHotspots() {
+        const hotspots = Array.from(this.contentionFailures.values());
+        // Sort by failed attempts (descending)
+        hotspots.sort((a, b)=>b.failedAttempts - a.failedAttempts);
+        return hotspots;
+    }
+    /**
+   * Generate health report
+   */ async generateHealthReport() {
+        const deadlocks = await this.detectDeadlocks();
+        const staleLocks = await this.findStaleLocks();
+        const statistics = this.getLockStatistics();
+        const usage = this.getLockUsageByResource();
+        const hotspots = this.getContentionHotspots();
+        const cleanupStats = this.getCleanupStats();
+        return {
+            deadlocks,
+            staleLocks,
+            statistics,
+            usage,
+            hotspots,
+            cleanupStats
+        };
+    }
+    /**
+   * Shutdown cleanup
+   */ async shutdown() {
+        this.stopBackgroundCleanup();
+        logger.info('Lock health monitor shut down');
+    }
+}
+
+//# sourceMappingURL=lock-health-monitor.js.map

package/dist/lib/lock-health-monitor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/lock-health-monitor.ts"],"sourcesContent":["/**\r\n * Lock Health Monitor\r\n *\r\n * Monitors distributed locks for health issues, detects deadlocks,\r\n * and performs automatic cleanup of stale locks.\r\n *\r\n * Features:\r\n * - Deadlock detection (locks held >5x TTL)\r\n * - Stale lock cleanup\r\n * - Lock usage statistics\r\n * - Contention hotspot detection\r\n * - Background cleanup task\r\n * - Incident logging\r\n *\r\n * Part of Phase 2, Task P2-2.2: Distributed Locking Enhancement\r\n */\r\n\r\nimport { createLogger } from './logging.js';\r\nimport { DistributedLockManager, LockMetadata } from './distributed-lock.js';\r\n\r\nconst logger = createLogger('lock-health-monitor');\r\n\r\n/**\r\n * Deadlock information\r\n */\r\nexport interface Deadlock {\r\n  /** Lock key */\r\n  lockKey: string;\r\n  /** Lock metadata */\r\n  metadata: LockMetadata;\r\n  /** Duration lock has been held (ms) */\r\n  heldDuration: number;\r\n  /** Detection timestamp */\r\n  detectedAt: Date;\r\n  /** Deadlock type */\r\n  type: 'stuck' | 'circular';\r\n}\r\n\r\n/**\r\n * Deadlock incident (resolved)\r\n */\r\nexport interface DeadlockIncident {\r\n  /** Lock key */\r\n  lockKey: string;\r\n  /** Detection timestamp */\r\n  detectedAt: Date;\r\n  /** Resolution timestamp */\r\n  resolvedAt: Date;\r\n  /** Resolution method */\r\n  resolutionMethod: 'force-release' | 'timeout';\r\n  /** Lock metadata at detection */\r\n  metadata: LockMetadata;\r\n}\r\n\r\n/**\r\n * Cleanup statistics\r\n */\r\nexport interface CleanupStats {\r\n  /** Total locks cleaned */\r\n  totalCleaned: number;\r\n  /** Last cleanup time */\r\n  lastCleanupAt?: Date;\r\n  /** Cleanup runs */\r\n  cleanupRuns: number;\r\n}\r\n\r\n/**\r\n * Lock usage by resource\r\n */\r\nexport interface LockUsage {\r\n  [resource: string]: number;\r\n}\r\n\r\n/**\r\n * Contention hotspot\r\n */\r\nexport interface ContentionHotspot {\r\n  /** Resource key */\r\n  resource: string;\r\n  /** Failed acquisition attempts */\r\n  failedAttempts: number;\r\n  /** Last failure time */\r\n  lastFailureAt: Date;\r\n}\r\n\r\n/**\r\n * Lock Health Monitor\r\n */\r\nexport class LockHealthMonitor {\r\n  private redisClient: any;\r\n  private lockManager: DistributedLockManager;\r\n  private deadlockIncidents: DeadlockIncident[] = [];\r\n  private cleanupStats: CleanupStats = {\r\n    totalCleaned: 0,\r\n    cleanupRuns: 0,\r\n  };\r\n  private lockUsage: Map<string, number> = new Map();\r\n  private contentionFailures: Map<string, ContentionHotspot> = new Map();\r\n  private backgroundCleanupTimer?: NodeJS.Timeout;\r\n\r\n  constructor(redisClient: any, lockManager: DistributedLockManager) {\r\n    this.redisClient = redisClient;\r\n    this.lockManager = lockManager;\r\n    logger.info('Lock health monitor initialized');\r\n  }\r\n\r\n  /**\r\n   * Detect deadlocks in the system\r\n   */\r\n  async detectDeadlocks(): Promise<Deadlock[]> {\r\n    const deadlocks: Deadlock[] = [];\r\n\r\n    try {\r\n      // Get all lock keys from Redis\r\n      const lockKeys = await this.redisClient.keys('lock:*');\r\n\r\n      for (const lockKey of lockKeys) {\r\n        const data = await this.redisClient.get(lockKey);\r\n        if (!data) continue;\r\n\r\n        const metadata: LockMetadata = JSON.parse(data);\r\n        const acquiredAt = new Date(metadata.acquiredAt).getTime();\r\n        const expiresAt = new Date(metadata.expiresAt).getTime();\r\n        const now = Date.now();\r\n\r\n        const ttl = expiresAt - acquiredAt;\r\n        const heldDuration = now - acquiredAt;\r\n\r\n        // Detect stuck locks (held for >5x TTL)\r\n        if (heldDuration > ttl * 5) {\r\n          deadlocks.push({\r\n            lockKey,\r\n            metadata,\r\n            heldDuration,\r\n            detectedAt: new Date(),\r\n            type: 'stuck',\r\n          });\r\n\r\n          logger.warn('Deadlock detected: stuck lock', {\r\n            lockKey,\r\n            heldDuration,\r\n            ttl,\r\n            lockId: metadata.lockId,\r\n          });\r\n        }\r\n      }\r\n\r\n      // TODO: Advanced feature - detect circular wait deadlocks\r\n      // This would require tracking lock wait queues and building dependency graphs\r\n\r\n      return deadlocks;\r\n    } catch (err) {\r\n      logger.error('Error detecting deadlocks', err as Error);\r\n      return deadlocks;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Resolve a deadlock by force-releasing the lock\r\n   */\r\n  async resolveDeadlock(deadlock: Deadlock): Promise<void> {\r\n    try {\r\n      logger.warn('Resolving deadlock', {\r\n        lockKey: deadlock.lockKey,\r\n        type: deadlock.type,\r\n        heldDuration: deadlock.heldDuration,\r\n      });\r\n\r\n      // Extract resource key from lock key (remove 'lock:' prefix)\r\n      const resourceKey = deadlock.lockKey.replace(/^lock:/, '');\r\n\r\n      // Force release the lock\r\n      await this.lockManager.forceRelease(resourceKey);\r\n\r\n      // Log incident\r\n      const incident: DeadlockIncident = {\r\n        lockKey: deadlock.lockKey,\r\n        detectedAt: deadlock.detectedAt,\r\n        resolvedAt: new Date(),\r\n        resolutionMethod: 'force-release',\r\n        metadata: deadlock.metadata,\r\n      };\r\n\r\n      this.deadlockIncidents.push(incident);\r\n\r\n      // Keep only last 100 incidents\r\n      if (this.deadlockIncidents.length > 100) {\r\n        this.deadlockIncidents.shift();\r\n      }\r\n\r\n      logger.info('Deadlock resolved', {\r\n        lockKey: deadlock.lockKey,\r\n        resolutionMethod: incident.resolutionMethod,\r\n      });\r\n    } catch (err) {\r\n      logger.error('Error resolving deadlock', err as Error, {\r\n        lockKey: deadlock.lockKey,\r\n      });\r\n      throw err;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get deadlock incident history\r\n   */\r\n  getDeadlockIncidents(): DeadlockIncident[] {\r\n    return [...this.deadlockIncidents];\r\n  }\r\n\r\n  /**\r\n   * Find stale locks (expired TTL but still in Redis)\r\n   */\r\n  async findStaleLocks(): Promise<string[]> {\r\n    const staleLocks: string[] = [];\r\n\r\n    try {\r\n      const lockKeys = await this.redisClient.keys('lock:*');\r\n\r\n      for (const lockKey of lockKeys) {\r\n        const ttl = await this.redisClient.pttl(lockKey);\r\n\r\n        // TTL < 0 means expired or no expiry set\r\n        if (ttl === -2) {\r\n          // Key doesn't exist (race condition)\r\n          continue;\r\n        }\r\n\r\n        if (ttl === -1) {\r\n          // No expiry set - this is a stale lock!\r\n          staleLocks.push(lockKey);\r\n          logger.warn('Stale lock detected (no TTL)', { lockKey });\r\n        }\r\n\r\n        // Also check metadata expiration\r\n        const data = await this.redisClient.get(lockKey);\r\n        if (data) {\r\n          const metadata: LockMetadata = JSON.parse(data);\r\n          const expiresAt = new Date(metadata.expiresAt).getTime();\r\n\r\n          if (Date.now() > expiresAt) {\r\n            staleLocks.push(lockKey);\r\n            logger.warn('Stale lock detected (expired metadata)', {\r\n              lockKey,\r\n              expiresAt: metadata.expiresAt,\r\n            });\r\n          }\r\n        }\r\n      }\r\n\r\n      return staleLocks;\r\n    } catch (err) {\r\n      logger.error('Error finding stale locks', err as Error);\r\n      return staleLocks;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Cleanup stale locks\r\n   */\r\n  async cleanupStaleLocks(): Promise<number> {\r\n    let cleaned = 0;\r\n\r\n    try {\r\n      const staleLocks = await this.findStaleLocks();\r\n\r\n      for (const lockKey of staleLocks) {\r\n        try {\r\n          await this.redisClient.del(lockKey);\r\n          cleaned++;\r\n\r\n          logger.info('Stale lock cleaned', { lockKey });\r\n        } catch (err) {\r\n          logger.error('Error cleaning stale lock', err as Error, { lockKey });\r\n        }\r\n      }\r\n\r\n      // Update cleanup stats\r\n      this.cleanupStats.totalCleaned += cleaned;\r\n      this.cleanupStats.lastCleanupAt = new Date();\r\n      this.cleanupStats.cleanupRuns++;\r\n\r\n      if (cleaned > 0) {\r\n        logger.info('Stale lock cleanup complete', {\r\n          cleaned,\r\n          totalCleaned: this.cleanupStats.totalCleaned,\r\n        });\r\n      }\r\n\r\n      return cleaned;\r\n    } catch (err) {\r\n      logger.error('Error during stale lock cleanup', err as Error);\r\n      return cleaned;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get cleanup statistics\r\n   */\r\n  getCleanupStats(): CleanupStats {\r\n    return { ...this.cleanupStats };\r\n  }\r\n\r\n  /**\r\n   * Start background cleanup task\r\n   */\r\n  startBackgroundCleanup(intervalMs: number = 60000): void {\r\n    if (this.backgroundCleanupTimer) {\r\n      logger.warn('Background cleanup already running');\r\n      return;\r\n    }\r\n\r\n    logger.info('Starting background cleanup', { intervalMs });\r\n\r\n    this.backgroundCleanupTimer = setInterval(async () => {\r\n      try {\r\n        await this.cleanupStaleLocks();\r\n      } catch (err) {\r\n        logger.error('Background cleanup error', err as Error);\r\n      }\r\n    }, intervalMs);\r\n  }\r\n\r\n  /**\r\n   * Stop background cleanup task\r\n   */\r\n  stopBackgroundCleanup(): void {\r\n    if (this.backgroundCleanupTimer) {\r\n      clearInterval(this.backgroundCleanupTimer);\r\n      this.backgroundCleanupTimer = undefined;\r\n      logger.info('Background cleanup stopped');\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Track lock acquisition for usage statistics\r\n   */\r\n  trackAcquisition(resource: string): void {\r\n    const count = this.lockUsage.get(resource) || 0;\r\n    this.lockUsage.set(resource, count + 1);\r\n  }\r\n\r\n  /**\r\n   * Track failed lock acquisition for contention detection\r\n   */\r\n  trackFailedAcquisition(resource: string): void {\r\n    const existing = this.contentionFailures.get(resource);\r\n\r\n    if (existing) {\r\n      existing.failedAttempts++;\r\n      existing.lastFailureAt = new Date();\r\n    } else {\r\n      this.contentionFailures.set(resource, {\r\n        resource,\r\n        failedAttempts: 1,\r\n        lastFailureAt: new Date(),\r\n      });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get lock statistics\r\n   */\r\n  getLockStatistics() {\r\n    return this.lockManager.getStatistics();\r\n  }\r\n\r\n  /**\r\n   * Get lock usage by resource\r\n   */\r\n  getLockUsageByResource(): LockUsage {\r\n    const usage: LockUsage = {};\r\n\r\n    for (const [resource, count] of this.lockUsage.entries()) {\r\n      usage[resource] = count;\r\n    }\r\n\r\n    return usage;\r\n  }\r\n\r\n  /**\r\n   * Get contention hotspots (resources with high failure rates)\r\n   */\r\n  getContentionHotspots(): ContentionHotspot[] {\r\n    const hotspots = Array.from(this.contentionFailures.values());\r\n\r\n    // Sort by failed attempts (descending)\r\n    hotspots.sort((a, b) => b.failedAttempts - a.failedAttempts);\r\n\r\n    return hotspots;\r\n  }\r\n\r\n  /**\r\n   * Generate health report\r\n   */\r\n  async generateHealthReport(): Promise<{\r\n    deadlocks: Deadlock[];\r\n    staleLocks: string[];\r\n    statistics: any;\r\n    usage: LockUsage;\r\n    hotspots: ContentionHotspot[];\r\n    cleanupStats: CleanupStats;\r\n  }> {\r\n    const deadlocks = await this.detectDeadlocks();\r\n    const staleLocks = await this.findStaleLocks();\r\n    const statistics = this.getLockStatistics();\r\n    const usage = this.getLockUsageByResource();\r\n    const hotspots = this.getContentionHotspots();\r\n    const cleanupStats = this.getCleanupStats();\r\n\r\n    return {\r\n      deadlocks,\r\n      staleLocks,\r\n      statistics,\r\n      usage,\r\n      hotspots,\r\n      cleanupStats,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Shutdown cleanup\r\n   */\r\n  async shutdown(): Promise<void> {\r\n    this.stopBackgroundCleanup();\r\n    logger.info('Lock health monitor shut down');\r\n  }\r\n}\r\n"],"names":["createLogger","logger","LockHealthMonitor","redisClient","lockManager","deadlockIncidents","cleanupStats","totalCleaned","cleanupRuns","lockUsage","Map","contentionFailures","backgroundCleanupTimer","info","detectDeadlocks","deadlocks","lockKeys","keys","lockKey","data","get","metadata","JSON","parse","acquiredAt","Date","getTime","expiresAt","now","ttl","heldDuration","push","detectedAt","type","warn","lockId","err","error","resolveDeadlock","deadlock","resourceKey","replace","forceRelease","incident","resolvedAt","resolutionMethod","length","shift","getDeadlockIncidents","findStaleLocks","staleLocks","pttl","cleanupStaleLocks","cleaned","del","lastCleanupAt","getCleanupStats","startBackgroundCleanup","intervalMs","setInterval","stopBackgroundCleanup","clearInterval","undefined","trackAcquisition","resource","count","set","trackFailedAcquisition","existing","failedAttempts","lastFailureAt","getLockStatistics","getStatistics","getLockUsageByResource","usage","entries","getContentionHotspots","hotspots","Array","from","values","sort","a","b","generateHealthReport","statistics","shutdown"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED,SAASA,YAAY,QAAQ,eAAe;AAG5C,MAAMC,SAASD,aAAa;AAiE5B;;CAEC,GACD,OAAO,MAAME;IACHC,YAAiB;IACjBC,YAAoC;IACpCC,oBAAwC,EAAE,CAAC;IAC3CC,eAA6B;QACnCC,cAAc;QACdC,aAAa;IACf,EAAE;IACMC,YAAiC,IAAIC,MAAM;IAC3CC,qBAAqD,IAAID,MAAM;IAC/DE,uBAAwC;IAEhD,YAAYT,WAAgB,EAAEC,WAAmC,CAAE;QACjE,IAAI,CAACD,WAAW,GAAGA;QACnB,IAAI,CAACC,WAAW,GAAGA;QACnBH,OAAOY,IAAI,CAAC;IACd;IAEA;;GAEC,GACD,MAAMC,kBAAuC;QAC3C,MAAMC,YAAwB,EAAE;QAEhC,IAAI;YACF,+BAA+B;YAC/B,MAAMC,WAAW,MAAM,IAAI,CAACb,WAAW,CAACc,IAAI,CAAC;YAE7C,KAAK,MAAMC,WAAWF,SAAU;gBAC9B,MAAMG,OAAO,MAAM,IAAI,CAAChB,WAAW,CAACiB,GAAG,CAACF;gBACxC,IAAI,CAACC,MAAM;gBAEX,MAAME,WAAyBC,KAAKC,KAAK,CAACJ;gBAC1C,MAAMK,aAAa,IAAIC,KAAKJ,SAASG,UAAU,EAAEE,OAAO;gBACxD,MAAMC,YAAY,IAAIF,KAAKJ,SAASM,SAAS,EAAED,OAAO;gBACtD,MAAME,MAAMH,KAAKG,GAAG;gBAEpB,MAAMC,MAAMF,YAAYH;gBACxB,MAAMM,eAAeF,MAAMJ;gBAE3B,wCAAwC;gBACxC,IAAIM,eAAeD,MAAM,GAAG;oBAC1Bd,UAAUgB,IAAI,CAAC;wBACbb;wBACAG;wBACAS;wBACAE,YAAY,IAAIP;wBAChBQ,MAAM;oBACR;oBAEAhC,OAAOiC,IAAI,CAAC,iCAAiC;wBAC3ChB;wBACAY;wBACAD;wBACAM,QAAQd,SAASc,MAAM;oBACzB;gBACF;YACF;YAEA,0DAA0D;YAC1D,8EAA8E;YAE9E,OAAOpB;QACT,EAAE,OAAOqB,KAAK;YACZnC,OAAOoC,KAAK,CAAC,6BAA6BD;YAC1C,OAAOrB;QACT;IACF;IAEA;;GAEC,GACD,MAAMuB,gBAAgBC,QAAkB,EAAiB;QACvD,IAAI;YACFtC,OAAOiC,IAAI,CAAC,sBAAsB;gBAChChB,SAASqB,SAASrB,OAAO;gBACzBe,MAAMM,SAASN,IAAI;gBACnBH,cAAcS,SAAST,YAAY;YACrC;YAEA,6DAA6D;YAC7D,MAAMU,cAAcD,SAASrB,OAAO,CAACuB,OAAO,CAAC,UAAU;YAEvD,yBAAyB;YACzB,MAAM,IAAI,CAACrC,WAAW,CAACsC,YAAY,CAACF;YAEpC,eAAe;YACf,MAAMG,WAA6B;gBACjCzB,SAASqB,SAASrB,OAAO;gBACzBc,YAAYO,SAASP,UAAU;gBAC/BY,YAAY,IAAInB;gBAChBoB,kBAAkB;gBAClBxB,UAAUkB,SAASlB,QAAQ;YAC7B;YAEA,IAAI,CAAChB,iBAAiB,CAAC0B,IAAI,CAACY;YAE5B,+BAA+B;YAC/B,IAAI,IAAI,CAACtC,iBAAiB,CAACyC,MAAM,GAAG,KAAK;gBACvC,IAAI,CAACzC,iBAAiB,CAAC0C,KAAK;YAC9B;YAEA9C,OAAOY,IAAI,CAAC,qBAAqB;gBAC/BK,SAASqB,SAASrB,OAAO;gBACzB2B,kBAAkBF,SAASE,gBAAgB;YAC7C;QACF,EAAE,OAAOT,KAAK;YACZnC,OAAOoC,KAAK,CAAC,4BAA4BD,KAAc;gBACrDlB,SAASqB,SAASrB,OAAO;YAC3B;YACA,MAAMkB;QACR;IACF;IAEA;;GAEC,GACDY,uBAA2C;QACzC,OAAO;eAAI,IAAI,CAAC3C,iBAAiB;SAAC;IACpC;IAEA;;GAEC,GACD,MAAM4C,iBAAoC;QACxC,MAAMC,aAAuB,EAAE;QAE/B,IAAI;YACF,MAAMlC,WAAW,MAAM,IAAI,CAACb,WAAW,CAACc,IAAI,CAAC;YAE7C,KAAK,MAAMC,WAAWF,SAAU;gBAC9B,MAAMa,MAAM,MAAM,IAAI,CAAC1B,WAAW,CAACgD,IAAI,CAACjC;gBAExC,yCAAyC;gBACzC,IAAIW,QAAQ,CAAC,GAAG;oBAEd;gBACF;gBAEA,IAAIA,QAAQ,CAAC,GAAG;oBACd,wCAAwC;oBACxCqB,WAAWnB,IAAI,CAACb;oBAChBjB,OAAOiC,IAAI,CAAC,gCAAgC;wBAAEhB;oBAAQ;gBACxD;gBAEA,iCAAiC;gBACjC,MAAMC,OAAO,MAAM,IAAI,CAAChB,WAAW,CAACiB,GAAG,CAACF;gBACxC,IAAIC,MAAM;oBACR,MAAME,WAAyBC,KAAKC,KAAK,CAACJ;oBAC1C,MAAMQ,YAAY,IAAIF,KAAKJ,SAASM,SAAS,EAAED,OAAO;oBAEtD,IAAID,KAAKG,GAAG,KAAKD,WAAW;wBAC1BuB,WAAWnB,IAAI,CAACb;wBAChBjB,OAAOiC,IAAI,CAAC,0CAA0C;4BACpDhB;4BACAS,WAAWN,SAASM,SAAS;wBAC/B;oBACF;gBACF;YACF;YAEA,OAAOuB;QACT,EAAE,OAAOd,KAAK;YACZnC,OAAOoC,KAAK,CAAC,6BAA6BD;YAC1C,OAAOc;QACT;IACF;IAEA;;GAEC,GACD,MAAME,oBAAqC;QACzC,IAAIC,UAAU;QAEd,IAAI;YACF,MAAMH,aAAa,MAAM,IAAI,CAACD,cAAc;YAE5C,KAAK,MAAM/B,WAAWgC,WAAY;gBAChC,IAAI;oBACF,MAAM,IAAI,CAAC/C,WAAW,CAACmD,GAAG,CAACpC;oBAC3BmC;oBAEApD,OAAOY,IAAI,CAAC,sBAAsB;wBAAEK;oBAAQ;gBAC9C,EAAE,OAAOkB,KAAK;oBACZnC,OAAOoC,KAAK,CAAC,6BAA6BD,KAAc;wBAAElB;oBAAQ;gBACpE;YACF;YAEA,uBAAuB;YACvB,IAAI,CAACZ,YAAY,CAACC,YAAY,IAAI8C;YAClC,IAAI,CAAC/C,YAAY,CAACiD,aAAa,GAAG,IAAI9B;YACtC,IAAI,CAACnB,YAAY,CAACE,WAAW;YAE7B,IAAI6C,UAAU,GAAG;gBACfpD,OAAOY,IAAI,CAAC,+BAA+B;oBACzCwC;oBACA9C,cAAc,IAAI,CAACD,YAAY,CAACC,YAAY;gBAC9C;YACF;YAEA,OAAO8C;QACT,EAAE,OAAOjB,KAAK;YACZnC,OAAOoC,KAAK,CAAC,mCAAmCD;YAChD,OAAOiB;QACT;IACF;IAEA;;GAEC,GACDG,kBAAgC;QAC9B,OAAO;YAAE,GAAG,IAAI,CAAClD,YAAY;QAAC;IAChC;IAEA;;GAEC,GACDmD,uBAAuBC,aAAqB,KAAK,EAAQ;QACvD,IAAI,IAAI,CAAC9C,sBAAsB,EAAE;YAC/BX,OAAOiC,IAAI,CAAC;YACZ;QACF;QAEAjC,OAAOY,IAAI,CAAC,+BAA+B;YAAE6C;QAAW;QAExD,IAAI,CAAC9C,sBAAsB,GAAG+C,YAAY;YACxC,IAAI;gBACF,MAAM,IAAI,CAACP,iBAAiB;YAC9B,EAAE,OAAOhB,KAAK;gBACZnC,OAAOoC,KAAK,CAAC,4BAA4BD;YAC3C;QACF,GAAGsB;IACL;IAEA;;GAEC,GACDE,wBAA8B;QAC5B,IAAI,IAAI,CAAChD,sBAAsB,EAAE;YAC/BiD,cAAc,IAAI,CAACjD,sBAAsB;YACzC,IAAI,CAACA,sBAAsB,GAAGkD;YAC9B7D,OAAOY,IAAI,CAAC;QACd;IACF;IAEA;;GAEC,GACDkD,iBAAiBC,QAAgB,EAAQ;QACvC,MAAMC,QAAQ,IAAI,CAACxD,SAAS,CAACW,GAAG,CAAC4C,aAAa;QAC9C,IAAI,CAACvD,SAAS,CAACyD,GAAG,CAACF,UAAUC,QAAQ;IACvC;IAEA;;GAEC,GACDE,uBAAuBH,QAAgB,EAAQ;QAC7C,MAAMI,WAAW,IAAI,CAACzD,kBAAkB,CAACS,GAAG,CAAC4C;QAE7C,IAAII,UAAU;YACZA,SAASC,cAAc;YACvBD,SAASE,aAAa,GAAG,IAAI7C;QAC/B,OAAO;YACL,IAAI,CAACd,kBAAkB,CAACuD,GAAG,CAACF,UAAU;gBACpCA;gBACAK,gBAAgB;gBAChBC,eAAe,IAAI7C;YACrB;QACF;IACF;IAEA;;GAEC,GACD8C,oBAAoB;QAClB,OAAO,IAAI,CAACnE,WAAW,CAACoE,aAAa;IACvC;IAEA;;GAEC,GACDC,yBAAoC;QAClC,MAAMC,QAAmB,CAAC;QAE1B,KAAK,MAAM,CAACV,UAAUC,MAAM,IAAI,IAAI,CAACxD,SAAS,CAACkE,OAAO,GAAI;YACxDD,KAAK,CAACV,SAAS,GAAGC;QACpB;QAEA,OAAOS;IACT;IAEA;;GAEC,GACDE,wBAA6C;QAC3C,MAAMC,WAAWC,MAAMC,IAAI,CAAC,IAAI,CAACpE,kBAAkB,CAACqE,MAAM;QAE1D,uCAAuC;QACvCH,SAASI,IAAI,CAAC,CAACC,GAAGC,IAAMA,EAAEd,cAAc,GAAGa,EAAEb,cAAc;QAE3D,OAAOQ;IACT;IAEA;;GAEC,GACD,MAAMO,uBAOH;QACD,MAAMrE,YAAY,MAAM,IAAI,CAACD,eAAe;QAC5C,MAAMoC,aAAa,MAAM,IAAI,CAACD,cAAc;QAC5C,MAAMoC,aAAa,IAAI,CAACd,iBAAiB;QACzC,MAAMG,QAAQ,IAAI,CAACD,sBAAsB;QACzC,MAAMI,WAAW,IAAI,CAACD,qBAAqB;QAC3C,MAAMtE,eAAe,IAAI,CAACkD,eAAe;QAEzC,OAAO;YACLzC;YACAmC;YACAmC;YACAX;YACAG;YACAvE;QACF;IACF;IAEA;;GAEC,GACD,MAAMgF,WAA0B;QAC9B,IAAI,CAAC1B,qBAAqB;QAC1B3D,OAAOY,IAAI,CAAC;IACd;AACF"}