@revealui/core 0.0.1-pre.4 → 0.2.0

package/dist/monitoring/cleanup-manager.js

@@ -0,0 +1,226 @@
+/**
+ * Cleanup Manager
+ *
+ * Global cleanup handler registry and graceful shutdown coordination.
+ * Ensures all resources are properly released when the process exits.
+ */
+import { logger } from '../utils/logger-server.js';
+/**
+ * Cleanup manager class
+ */
+class CleanupManager {
+    handlers = new Map();
+    isShuttingDown = false;
+    shutdownTimeout = 30_000; // 30 seconds
+    signalHandlersRegistered = false;
+    /**
+     * Register a cleanup handler
+     */
+    register(id, handler, description, priority = 0) {
+        if (this.handlers.has(id)) {
+            logger.warn('Cleanup handler already registered', { id });
+            return;
+        }
+        this.handlers.set(id, {
+            id,
+            handler,
+            priority,
+            description,
+        });
+        logger.debug('Registered cleanup handler', { id, description, priority });
+        // Register signal handlers on first handler registration
+        if (!this.signalHandlersRegistered) {
+            this.registerSignalHandlers();
+        }
+    }
+    /**
+     * Unregister a cleanup handler
+     */
+    unregister(id) {
+        if (this.handlers.delete(id)) {
+            logger.debug('Unregistered cleanup handler', { id });
+        }
+    }
+    /**
+     * Execute all cleanup handlers
+     */
+    async cleanup(signal) {
+        if (this.isShuttingDown) {
+            logger.warn('Cleanup already in progress');
+            return;
+        }
+        this.isShuttingDown = true;
+        logger.info('Starting graceful shutdown', {
+            signal,
+            handlers: this.handlers.size,
+        });
+        // Sort handlers by priority (highest first)
+        const sortedHandlers = Array.from(this.handlers.values()).sort((a, b) => b.priority - a.priority);
+        const results = [];
+        // Execute handlers with timeout
+        const cleanupPromise = this.executeHandlers(sortedHandlers, results);
+        const timeoutPromise = new Promise((resolve) => {
+            setTimeout(() => {
+                logger.error('Cleanup timeout exceeded, forcing shutdown', {
+                    timeout: this.shutdownTimeout,
+                });
+                resolve();
+            }, this.shutdownTimeout);
+        });
+        await Promise.race([cleanupPromise, timeoutPromise]);
+        // Log results
+        const successCount = results.filter((r) => r.success).length;
+        const failureCount = results.filter((r) => !r.success).length;
+        logger.info('Cleanup complete', {
+            total: results.length,
+            success: successCount,
+            failures: failureCount,
+        });
+        if (failureCount > 0) {
+            logger.error('Some cleanup handlers failed', {
+                failures: results.filter((r) => !r.success),
+            });
+        }
+    }
+    /**
+     * Execute cleanup handlers in sequence
+     */
+    async executeHandlers(handlers, results) {
+        for (const registration of handlers) {
+            try {
+                logger.debug('Executing cleanup handler', {
+                    id: registration.id,
+                    description: registration.description,
+                });
+                const handlerPromise = Promise.resolve(registration.handler());
+                // Individual handler timeout (10 seconds)
+                const handlerTimeout = new Promise((_, reject) => {
+                    setTimeout(() => {
+                        reject(new Error('Handler timeout'));
+                    }, 10_000);
+                });
+                await Promise.race([handlerPromise, handlerTimeout]);
+                results.push({ id: registration.id, success: true });
+                logger.debug('Cleanup handler completed', {
+                    id: registration.id,
+                });
+            }
+            catch (error) {
+                logger.error('Cleanup handler failed', {
+                    id: registration.id,
+                    error,
+                });
+                results.push({ id: registration.id, success: false, error });
+            }
+        }
+    }
+    /**
+     * Register signal handlers for graceful shutdown
+     */
+    registerSignalHandlers() {
+        if (this.signalHandlersRegistered)
+            return;
+        const signals = ['SIGTERM', 'SIGINT', 'SIGHUP'];
+        for (const signal of signals) {
+            process.on(signal, () => {
+                logger.info('Received signal, initiating cleanup', { signal });
+                this.cleanup(signal)
+                    .then(() => {
+                    logger.info('Cleanup successful, exiting', { signal });
+                    process.exit(0);
+                })
+                    .catch((error) => {
+                    logger.error('Cleanup failed, forcing exit', { signal, error });
+                    process.exit(1);
+                });
+            });
+        }
+        // Handle uncaught exceptions
+        process.on('uncaughtException', (error) => {
+            logger.error('Uncaught exception, initiating cleanup', { error });
+            this.cleanup('uncaughtException')
+                .then(() => {
+                process.exit(1);
+            })
+                .catch(() => {
+                process.exit(1);
+            });
+        });
+        // Handle unhandled rejections
+        process.on('unhandledRejection', (reason) => {
+            logger.error('Unhandled rejection, initiating cleanup', { reason });
+            this.cleanup('unhandledRejection')
+                .then(() => {
+                process.exit(1);
+            })
+                .catch(() => {
+                process.exit(1);
+            });
+        });
+        this.signalHandlersRegistered = true;
+        logger.debug('Signal handlers registered', { signals });
+    }
+    /**
+     * Force immediate cleanup (skip timeout)
+     */
+    async forceCleanup() {
+        const originalTimeout = this.shutdownTimeout;
+        this.shutdownTimeout = 0;
+        try {
+            await this.cleanup('force');
+        }
+        finally {
+            this.shutdownTimeout = originalTimeout;
+        }
+    }
+    /**
+     * Get registered handlers
+     */
+    getHandlers() {
+        return Array.from(this.handlers.values());
+    }
+    /**
+     * Check if shutdown is in progress
+     */
+    isShutdownInProgress() {
+        return this.isShuttingDown;
+    }
+    /**
+     * Set shutdown timeout
+     */
+    setShutdownTimeout(ms) {
+        this.shutdownTimeout = ms;
+    }
+    /**
+     * Clear all handlers
+     */
+    clear() {
+        this.handlers.clear();
+        this.isShuttingDown = false;
+    }
+}
+/**
+ * Singleton instance
+ */
+export const cleanupManager = new CleanupManager();
+/**
+ * Convenience functions
+ */
+export function registerCleanupHandler(id, handler, description, priority = 0) {
+    cleanupManager.register(id, handler, description, priority);
+}
+export function unregisterCleanupHandler(id) {
+    cleanupManager.unregister(id);
+}
+export function initiateCleanup(signal) {
+    return cleanupManager.cleanup(signal);
+}
+export function forceCleanup() {
+    return cleanupManager.forceCleanup();
+}
+export function getCleanupHandlers() {
+    return cleanupManager.getHandlers();
+}
+export function isShutdownInProgress() {
+    return cleanupManager.isShutdownInProgress();
+}

package/dist/monitoring/health-monitor.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Health Monitor
+ *
+ * Collects and aggregates system health metrics including process stats,
+ * database pools, memory/CPU usage, and active alerts.
+ */
+import type { Alert, HealthMetrics, PoolMetrics } from './types.js';
+/**
+ * Get current system health metrics
+ */
+export declare function getHealthMetrics(databasePools?: {
+    rest: PoolMetrics[];
+    vector: PoolMetrics[];
+}): HealthMetrics;
+/**
+ * Get health status based on alerts
+ */
+export declare function getHealthStatus(alerts: Alert[]): {
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    statusCode: number;
+};
+//# sourceMappingURL=health-monitor.d.ts.map

package/dist/monitoring/health-monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health-monitor.d.ts","sourceRoot":"","sources":["../../src/monitoring/health-monitor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,KAAK,EAA2B,aAAa,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAI5F;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,aAAa,CAAC,EAAE;IAC/C,IAAI,EAAE,WAAW,EAAE,CAAA;IACnB,MAAM,EAAE,WAAW,EAAE,CAAA;CACtB,GAAG,aAAa,CAqChB;AAoID;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG;IAChD,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,WAAW,CAAA;IAC5C,UAAU,EAAE,MAAM,CAAA;CACnB,CAWA"}

package/dist/monitoring/health-monitor.js

@@ -0,0 +1,142 @@
+/**
+ * Health Monitor
+ *
+ * Collects and aggregates system health metrics including process stats,
+ * database pools, memory/CPU usage, and active alerts.
+ */
+import * as os from 'node:os';
+import { processRegistry } from './process-registry.js';
+import { DEFAULT_MONITORING_CONFIG } from './types.js';
+import { zombieDetector } from './zombie-detector.js';
+/**
+ * Get current system health metrics
+ */
+export function getHealthMetrics(databasePools) {
+    const stats = processRegistry.getStats();
+    const spawnRate = processRegistry.getSpawnRate();
+    const zombies = zombieDetector.getHistory();
+    // System metrics
+    const memUsage = process.memoryUsage();
+    const memoryUsageMB = Math.round(memUsage.rss / 1024 / 1024);
+    const cpuUsage = process.cpuUsage();
+    const uptimeSeconds = Math.floor(process.uptime());
+    // Generate alerts
+    const alerts = generateAlerts(stats, spawnRate, memoryUsageMB, databasePools);
+    return {
+        system: {
+            memoryUsage: memoryUsageMB,
+            cpuUsage: calculateCPUPercentage(cpuUsage),
+            uptime: uptimeSeconds,
+            platform: os.platform(),
+            nodeVersion: process.version,
+        },
+        processes: {
+            active: stats.running,
+            zombies: stats.zombies,
+            failed: stats.failed,
+            spawnRate,
+            bySource: stats.bySource,
+        },
+        database: databasePools || {
+            rest: [],
+            vector: [],
+        },
+        recentZombies: zombies.slice(0, 10), // Last 10 zombies
+        alerts,
+        timestamp: Date.now(),
+    };
+}
+/**
+ * Calculate CPU usage percentage
+ */
+function calculateCPUPercentage(cpuUsage) {
+    // This is approximate - for better accuracy, would need to track over time
+    const totalMicroseconds = cpuUsage.user + cpuUsage.system;
+    const uptimeMicroseconds = process.uptime() * 1_000_000;
+    const percentage = (totalMicroseconds / uptimeMicroseconds) * 100;
+    return Math.round(percentage * 100) / 100; // Round to 2 decimal places
+}
+/**
+ * Generate alerts based on current metrics and thresholds
+ */
+function generateAlerts(stats, spawnRate, memoryUsageMB, databasePools) {
+    const alerts = [];
+    const thresholds = DEFAULT_MONITORING_CONFIG.alertThresholds;
+    const now = Date.now();
+    // Check zombie processes
+    if (stats.zombies >= thresholds.zombies.critical) {
+        alerts.push(createAlert('critical', 'zombies', stats.zombies, thresholds.zombies.critical, now));
+    }
+    else if (stats.zombies >= thresholds.zombies.warning) {
+        alerts.push(createAlert('warning', 'zombies', stats.zombies, thresholds.zombies.warning, now));
+    }
+    // Check memory usage
+    if (memoryUsageMB >= thresholds.memory.critical) {
+        alerts.push(createAlert('critical', 'memory', memoryUsageMB, thresholds.memory.critical, now));
+    }
+    else if (memoryUsageMB >= thresholds.memory.warning) {
+        alerts.push(createAlert('warning', 'memory', memoryUsageMB, thresholds.memory.warning, now));
+    }
+    // Check active processes
+    if (stats.running >= thresholds.processes.active.critical) {
+        alerts.push(createAlert('critical', 'active_processes', stats.running, thresholds.processes.active.critical, now));
+    }
+    else if (stats.running >= thresholds.processes.active.warning) {
+        alerts.push(createAlert('warning', 'active_processes', stats.running, thresholds.processes.active.warning, now));
+    }
+    // Check spawn rate
+    if (spawnRate >= thresholds.spawnRate.critical) {
+        alerts.push(createAlert('critical', 'spawn_rate', spawnRate, thresholds.spawnRate.critical, now));
+    }
+    else if (spawnRate >= thresholds.spawnRate.warning) {
+        alerts.push(createAlert('warning', 'spawn_rate', spawnRate, thresholds.spawnRate.warning, now));
+    }
+    // Check database waiting connections
+    if (databasePools) {
+        const allPools = [...databasePools.rest, ...databasePools.vector];
+        const totalWaiting = allPools.reduce((sum, pool) => sum + pool.waitingCount, 0);
+        if (totalWaiting >= thresholds.database.waiting.critical) {
+            alerts.push(createAlert('critical', 'database_waiting', totalWaiting, thresholds.database.waiting.critical, now));
+        }
+        else if (totalWaiting >= thresholds.database.waiting.warning) {
+            alerts.push(createAlert('warning', 'database_waiting', totalWaiting, thresholds.database.waiting.warning, now));
+        }
+    }
+    return alerts;
+}
+/**
+ * Create an alert object
+ */
+function createAlert(level, metric, value, threshold, timestamp) {
+    const messages = {
+        zombies: (v, t) => `${v} zombie processes detected (threshold: ${t})`,
+        memory: (v, t) => `Memory usage at ${v}MB (threshold: ${t}MB)`,
+        active_processes: (v, t) => `${v} active processes (threshold: ${t})`,
+        database_waiting: (v, t) => `${v} database connections waiting (threshold: ${t})`,
+        spawn_rate: (v, t) => `Process spawn rate at ${v}/min (threshold: ${t}/min)`,
+    };
+    return {
+        level,
+        metric,
+        message: messages[metric](value, threshold),
+        value,
+        threshold,
+        timestamp,
+    };
+}
+/**
+ * Get health status based on alerts
+ */
+export function getHealthStatus(alerts) {
+    const hasCritical = alerts.some((a) => a.level === 'critical');
+    const hasWarning = alerts.some((a) => a.level === 'warning');
+    if (hasCritical) {
+        return { status: 'unhealthy', statusCode: 503 };
+    }
+    else if (hasWarning) {
+        return { status: 'degraded', statusCode: 206 };
+    }
+    else {
+        return { status: 'healthy', statusCode: 200 };
+    }
+}

package/dist/monitoring/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Process Health Monitoring
+ *
+ * Centralized system for tracking processes, detecting zombies,
+ * managing cleanup, and monitoring system health.
+ */
+export { alertManager, getAlertStats, sendAlert, sendAlerts, setAlertChannels, } from './alerts.js';
+export { cleanupManager, forceCleanup, getCleanupHandlers, initiateCleanup, isShutdownInProgress, registerCleanupHandler, unregisterCleanupHandler, } from './cleanup-manager.js';
+export { getHealthMetrics, getHealthStatus } from './health-monitor.js';
+export { getAllProcesses, getProcess, getProcessStats, getRunningProcesses, getSpawnRate, getZombieProcesses, markProcessZombie, processRegistry, registerProcess, updateProcessStatus, } from './process-registry.js';
+export type * from './types.js';
+export { DEFAULT_MONITORING_CONFIG } from './types.js';
+export { getZombieCount, getZombieHistory, onZombieDetected, scanForZombies, startZombieDetection, stopZombieDetection, zombieDetector, } from './zombie-detector.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/monitoring/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/monitoring/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EACL,YAAY,EACZ,aAAa,EACb,SAAS,EACT,UAAU,EACV,gBAAgB,GACjB,MAAM,aAAa,CAAA;AAEpB,OAAO,EACL,cAAc,EACd,YAAY,EACZ,kBAAkB,EAClB,eAAe,EACf,oBAAoB,EACpB,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,sBAAsB,CAAA;AAE7B,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAEvE,OAAO,EACL,eAAe,EACf,UAAU,EACV,eAAe,EACf,mBAAmB,EACnB,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EACjB,eAAe,EACf,eAAe,EACf,mBAAmB,GACpB,MAAM,uBAAuB,CAAA;AAE9B,mBAAmB,YAAY,CAAA;AAC/B,OAAO,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAA;AAEtD,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,GACf,MAAM,sBAAsB,CAAA"}

package/dist/monitoring/index.js

@@ -0,0 +1,17 @@
+/**
+ * Process Health Monitoring
+ *
+ * Centralized system for tracking processes, detecting zombies,
+ * managing cleanup, and monitoring system health.
+ */
+// Export alert system
+export { alertManager, getAlertStats, sendAlert, sendAlerts, setAlertChannels, } from './alerts.js';
+// Export cleanup manager
+export { cleanupManager, forceCleanup, getCleanupHandlers, initiateCleanup, isShutdownInProgress, registerCleanupHandler, unregisterCleanupHandler, } from './cleanup-manager.js';
+// Export health monitor
+export { getHealthMetrics, getHealthStatus } from './health-monitor.js';
+// Export process registry
+export { getAllProcesses, getProcess, getProcessStats, getRunningProcesses, getSpawnRate, getZombieProcesses, markProcessZombie, processRegistry, registerProcess, updateProcessStatus, } from './process-registry.js';
+export { DEFAULT_MONITORING_CONFIG } from './types.js';
+// Export zombie detector
+export { getZombieCount, getZombieHistory, onZombieDetected, scanForZombies, startZombieDetection, stopZombieDetection, zombieDetector, } from './zombie-detector.js';

package/dist/monitoring/process-registry.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Process Registry
+ *
+ * Central registry for tracking all spawned processes in the RevealUI system.
+ * Maintains process lifecycle information and provides query capabilities.
+ */
+import type { ProcessMetadata, ProcessSource, ProcessStatus, RegistryStats, TrackedProcess } from './types.js';
+/**
+ * Global process registry instance
+ */
+declare class ProcessRegistry {
+    private processes;
+    private enabled;
+    private maxHistorySize;
+    /**
+     * Register a new process
+     */
+    register(pid: number, command: string, args: string[], source: ProcessSource, metadata?: ProcessMetadata, ppid?: number): void;
+    /**
+     * Update process status
+     */
+    updateStatus(pid: number, status: ProcessStatus, exitCode?: number, signal?: string): void;
+    /**
+     * Mark process as zombie
+     */
+    markZombie(pid: number): void;
+    /**
+     * Get process by PID
+     */
+    get(pid: number): TrackedProcess | undefined;
+    /**
+     * Get all processes
+     */
+    getAll(): TrackedProcess[];
+    /**
+     * Get processes by status
+     */
+    getByStatus(status: ProcessStatus): TrackedProcess[];
+    /**
+     * Get processes by source
+     */
+    getBySource(source: ProcessSource): TrackedProcess[];
+    /**
+     * Get running processes
+     */
+    getRunning(): TrackedProcess[];
+    /**
+     * Get zombie processes
+     */
+    getZombies(): TrackedProcess[];
+    /**
+     * Get failed processes
+     */
+    getFailed(): TrackedProcess[];
+    /**
+     * Get registry statistics
+     */
+    getStats(): RegistryStats;
+    /**
+     * Calculate spawn rate (processes per minute)
+     */
+    getSpawnRate(): number;
+    /**
+     * Clear completed/failed processes older than retention period
+     */
+    private trimHistory;
+    /**
+     * Clear all processes
+     */
+    clear(): void;
+    /**
+     * Enable or disable tracking
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Check if tracking is enabled
+     */
+    isEnabled(): boolean;
+}
+/**
+ * Singleton instance
+ */
+export declare const processRegistry: ProcessRegistry;
+/**
+ * Convenience functions
+ */
+export declare function registerProcess(pid: number, command: string, args: string[], source: ProcessSource, metadata?: ProcessMetadata, ppid?: number): void;
+export declare function updateProcessStatus(pid: number, status: ProcessStatus, exitCode?: number, signal?: string): void;
+export declare function markProcessZombie(pid: number): void;
+export declare function getProcess(pid: number): TrackedProcess | undefined;
+export declare function getAllProcesses(): TrackedProcess[];
+export declare function getRunningProcesses(): TrackedProcess[];
+export declare function getZombieProcesses(): TrackedProcess[];
+export declare function getProcessStats(): RegistryStats;
+export declare function getSpawnRate(): number;
+export {};
+//# sourceMappingURL=process-registry.d.ts.map

package/dist/monitoring/process-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-registry.d.ts","sourceRoot":"","sources":["../../src/monitoring/process-registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACb,aAAa,EACb,aAAa,EACb,cAAc,EACf,MAAM,YAAY,CAAA;AAGnB;;GAEG;AACH,cAAM,eAAe;IACnB,OAAO,CAAC,SAAS,CAAyC;IAC1D,OAAO,CAAC,OAAO,CAA6C;IAC5D,OAAO,CAAC,cAAc,CAAmD;IAEzE;;OAEG;IACH,QAAQ,CACN,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,MAAM,EAAE,aAAa,EACrB,QAAQ,CAAC,EAAE,eAAe,EAC1B,IAAI,CAAC,EAAE,MAAM,GACZ,IAAI;IAkBP;;OAEG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAkB1F;;OAEG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAI7B;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAI5C;;OAEG;IACH,MAAM,IAAI,cAAc,EAAE;IAI1B;;OAEG;IACH,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,cAAc,EAAE;IAIpD;;OAEG;IACH,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,cAAc,EAAE;IAIpD;;OAEG;IACH,UAAU,IAAI,cAAc,EAAE;IAI9B;;OAEG;IACH,UAAU,IAAI,cAAc,EAAE;IAI9B;;OAEG;IACH,SAAS,IAAI,cAAc,EAAE;IAI7B;;OAEG;IACH,QAAQ,IAAI,aAAa;IA2BzB;;OAEG;IACH,YAAY,IAAI,MAAM;IAStB;;OAEG;IACH,OAAO,CAAC,WAAW;IAqCnB;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAIlC;;OAEG;IACH,SAAS,IAAI,OAAO;CAGrB;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,iBAAwB,CAAA;AAEpD;;GAEG;AAEH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,MAAM,EAAE,aAAa,EACrB,QAAQ,CAAC,EAAE,eAAe,EAC1B,IAAI,CAAC,EAAE,MAAM,GACZ,IAAI,CAEN;AAED,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,aAAa,EACrB,QAAQ,CAAC,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,MAAM,GACd,IAAI,CAEN;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAEnD;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAElE;AAED,wBAAgB,eAAe,IAAI,cAAc,EAAE,CAElD;AAED,wBAAgB,mBAAmB,IAAI,cAAc,EAAE,CAEtD;AAED,wBAAgB,kBAAkB,IAAI,cAAc,EAAE,CAErD;AAED,wBAAgB,eAAe,IAAI,aAAa,CAE/C;AAED,wBAAgB,YAAY,IAAI,MAAM,CAErC"}