versacompiler 2.0.7 → 2.0.8

package/dist/compiler/typescript-worker-pool.js

@@ -1,842 +1 @@
-/**
- * TypeScript Worker Pool - Pool de workers para compilación paralela
- * Reemplaza el worker único con múltiples workers para aprovecha la concurrencia real
- */
-import * as os from 'node:os';
-import * as path from 'node:path';
-import * as process from 'node:process';
-import { Worker } from 'node:worker_threads';
-import { validateTypesWithLanguageService } from './typescript-sync-validator.js';
-/**
- * Pool de workers para compilación TypeScript paralela
- * Distribuye las tareas entre múltiples workers para mayor rendimiento
- */
-export class TypeScriptWorkerPool {
-    static instance;
-    workers = [];
-    poolSize;
-    workerPath;
-    initPromise = null;
-    isInitialized = false; // Configuración optimizada con reciclaje de workers
-    TASK_TIMEOUT = 15000; // 15 segundos por tarea (aumentado)
-    WORKER_INIT_TIMEOUT = 5000; // 5 segundos para inicializar
-    MAX_TASKS_PER_WORKER = 25; // Reducido para liberar memoria más frecuentemente
-    WORKER_MEMORY_CHECK_INTERVAL = 50; // Verificar cada 50 tareas (más frecuente)
-    // Métricas de rendimiento
-    totalTasks = 0;
-    completedTasks = 0;
-    failedTasks = 0;
-    constructor() {
-        // Determinar tamaño óptimo del pool
-        const cpuCount = os.cpus().length;
-        this.poolSize = Math.min(Math.max(cpuCount - 1, 2), 8); // Entre 2 y 8 workers
-        this.workerPath = path.join(process.env.PATH_PROY || path.join(process.cwd(), 'src'), 'compiler', 'typescript-worker-thread.cjs');
-        // ✨ ISSUE #4: Configurar monitoreo de memoria automático        this.startMemoryMonitoring();
-    }
-    // ✨ ISSUE #4: Métodos de control de memoria y timeouts
-    /**
-     * Inicia el monitoreo automático de memoria de workers
-     */
-    startMemoryMonitoring() {
-        // Monitoreo cada 15 segundos (más frecuente)
-        setInterval(() => {
-            this.checkWorkersMemory();
-        }, 15000);
-        // Limpieza de workers inactivos cada 2 minutos (más frecuente)
-        setInterval(() => {
-            this.cleanupInactiveWorkers();
-        }, 120000);
-    }
-    /**
-     * Verifica el uso de memoria de todos los workers con medición real
-     */
-    async checkWorkersMemory() {
-        const now = Date.now();
-        for (const poolWorker of this.workers) {
-            // Actualizar tiempo de última verificación
-            poolWorker.lastMemoryCheck = now;
-            try {
-                // ✨ ISSUE #4: Obtener memoria real del worker
-                const memoryInfo = await this.getWorkerMemoryUsage(poolWorker);
-                poolWorker.memoryUsage = memoryInfo.heapUsed;
-                // Verificar límites de memoria y reciclaje automático
-                if (this.shouldRecycleWorker(poolWorker)) {
-                    const reason = this.getRecycleReason(poolWorker);
-                    console.warn(`[WorkerPool] Worker ${poolWorker.id} requiere reciclaje: ${reason}`);
-                    await this.recycleWorker(poolWorker);
-                }
-            }
-            catch (error) {
-                console.warn(`[WorkerPool] Error verificando memoria del worker ${poolWorker.id}:`, error);
-            }
-        }
-    }
-    /**
-     * Obtiene el uso real de memoria de un worker
-     */
-    async getWorkerMemoryUsage(poolWorker) {
-        return new Promise(resolve => {
-            const timeout = setTimeout(() => {
-                // Fallback con estimación si no hay respuesta
-                resolve({
-                    heapUsed: poolWorker.tasksProcessed * 2048, // 2KB por tarea
-                    heapTotal: poolWorker.tasksProcessed * 3072, // 3KB total estimado
-                    rss: poolWorker.tasksProcessed * 4096, // 4KB RSS estimado
-                });
-            }, 1000);
-            // Solicitar memoria real del worker
-            const memoryRequestId = `memory-${poolWorker.id}-${Date.now()}`;
-            const handler = (response) => {
-                if (response.id === memoryRequestId &&
-                    response.type === 'memory-usage') {
-                    clearTimeout(timeout);
-                    poolWorker.worker.off('message', handler);
-                    resolve({
-                        heapUsed: response.memoryUsage?.heapUsed ||
-                            poolWorker.tasksProcessed * 2048,
-                        heapTotal: response.memoryUsage?.heapTotal ||
-                            poolWorker.tasksProcessed * 3072,
-                        rss: response.memoryUsage?.rss ||
-                            poolWorker.tasksProcessed * 4096,
-                    });
-                }
-            };
-            poolWorker.worker.on('message', handler);
-            poolWorker.worker.postMessage({
-                type: 'get-memory-usage',
-                id: memoryRequestId,
-            });
-        });
-    }
-    /**
-     * Obtiene la razón por la cual un worker debe ser reciclado
-     */
-    getRecycleReason(poolWorker) {
-        const now = Date.now();
-        const MEMORY_LIMIT = 50 * 1024 * 1024; // 50MB
-        const TIME_LIMIT = 30 * 60 * 1000; // 30 minutos
-        const TASK_LIMIT = this.MAX_TASKS_PER_WORKER;
-        const reasons = [];
-        if (poolWorker.memoryUsage > MEMORY_LIMIT) {
-            reasons.push(`memoria excede ${Math.round(MEMORY_LIMIT / 1024 / 1024)}MB (actual: ${Math.round(poolWorker.memoryUsage / 1024 / 1024)}MB)`);
-        }
-        if (now - poolWorker.creationTime > TIME_LIMIT) {
-            reasons.push(`tiempo de vida excede ${Math.round(TIME_LIMIT / 60000)} minutos`);
-        }
-        if (poolWorker.tasksProcessed >= TASK_LIMIT) {
-            reasons.push(`tareas procesadas exceden ${TASK_LIMIT} (actual: ${poolWorker.tasksProcessed})`);
-        }
-        return reasons.join(', ');
-    } /**
-     * Limpia workers que han estado inactivos por mucho tiempo
-     */
-    async cleanupInactiveWorkers() {
-        const now = Date.now();
-        const INACTIVE_TIMEOUT = 5 * 60 * 1000; // 5 minutos (reducido)
-        for (const poolWorker of this.workers) {
-            const timeSinceLastActivity = now - poolWorker.lastActivityTime;
-            if (timeSinceLastActivity > INACTIVE_TIMEOUT &&
-                !poolWorker.busy &&
-                poolWorker.pendingTasks.size === 0) {
-                console.info(`[WorkerPool] Worker ${poolWorker.id} inactivo por ${Math.round(timeSinceLastActivity / 60000)} minutos, reciclando...`);
-                await this.recycleWorker(poolWorker);
-            }
-        }
-    } /**
-     * Verifica si un worker debe ser reciclado por límites de memoria/tiempo
-     */
-    shouldRecycleWorker(poolWorker) {
-        const now = Date.now();
-        const MEMORY_LIMIT = 30 * 1024 * 1024; // 30MB (reducido)
-        const TIME_LIMIT = 15 * 60 * 1000; // 15 minutos (reducido)
-        const TASK_LIMIT = this.MAX_TASKS_PER_WORKER;
-        return (poolWorker.memoryUsage > MEMORY_LIMIT ||
-            now - poolWorker.creationTime > TIME_LIMIT ||
-            poolWorker.tasksProcessed >= TASK_LIMIT);
-    }
-    /**
-     * Obtiene la instancia singleton del Worker Pool
-     */
-    static getInstance() {
-        if (!TypeScriptWorkerPool.instance) {
-            TypeScriptWorkerPool.instance = new TypeScriptWorkerPool();
-        }
-        return TypeScriptWorkerPool.instance;
-    }
-    /**
-     * Configura el modo de operación del pool
-     */
-    setMode(mode) {
-        // Ajustar configuración según el modo
-        switch (mode) {
-            case 'batch':
-                // Para modo batch, optimizar para throughput
-                this.poolSize = Math.min(os.cpus().length, 12);
-                break;
-            case 'watch':
-                // Para modo watch, menos workers pero más responsivos
-                this.poolSize = Math.min(Math.max(os.cpus().length / 2, 2), 6);
-                break;
-            case 'individual':
-                // Para individual, pool pequeño
-                this.poolSize = Math.min(4, os.cpus().length);
-                break;
-        }
-    }
-    /**
-     * Inicializa el pool de workers
-     */
-    async initializePool() {
-        if (this.initPromise) {
-            return this.initPromise;
-        }
-        this.initPromise = this._performPoolInitialization();
-        return this.initPromise;
-    }
-    /**
-     * Realiza la inicialización del pool de workers
-     */
-    async _performPoolInitialization() {
-        try {
-            // Verificar que el archivo del worker existe
-            const fs = await import('node:fs');
-            const exists = fs.existsSync(this.workerPath);
-            if (!exists) {
-                throw new Error(`Worker thread file not found: ${this.workerPath}`);
-            }
-            // Crear workers en paralelo
-            const workerPromises = Array.from({ length: this.poolSize }, (_, index) => this.createWorker(index));
-            this.workers = await Promise.all(workerPromises);
-            this.isInitialized = true;
-        }
-        catch (error) {
-            this.isInitialized = false;
-            throw error;
-        }
-    }
-    /**
-     * Crea un worker individual
-     */
-    async createWorker(workerId) {
-        return new Promise((resolve, reject) => {
-            try {
-                const worker = new Worker(this.workerPath, {
-                    env: {
-                        ...process.env,
-                        NODE_OPTIONS: '',
-                        WORKER_ID: workerId.toString(),
-                    },
-                });
-                const poolWorker = {
-                    worker,
-                    id: workerId,
-                    busy: false,
-                    pendingTasks: new Map(),
-                    taskCounter: 0,
-                    // ✨ ISSUE #4: Inicializar controles de memoria
-                    memoryUsage: 0,
-                    lastMemoryCheck: Date.now(),
-                    tasksProcessed: 0,
-                    creationTime: Date.now(),
-                    lastActivityTime: Date.now(),
-                };
-                // Configurar listeners
-                this.setupWorkerListeners(poolWorker);
-                // Timeout para inicialización
-                const initTimeout = setTimeout(() => {
-                    reject(new Error(`Worker ${workerId} initialization timeout`));
-                }, this.WORKER_INIT_TIMEOUT);
-                // Esperar que el worker esté listo
-                const checkReady = () => {
-                    worker.postMessage({ type: 'ping' });
-                };
-                worker.on('message', function readyHandler(response) {
-                    if (response.id === 'worker-ready' ||
-                        response.message === 'pong') {
-                        clearTimeout(initTimeout);
-                        worker.off('message', readyHandler);
-                        resolve(poolWorker);
-                    }
-                });
-                worker.on('error', error => {
-                    clearTimeout(initTimeout);
-                    reject(error);
-                });
-                // Intentar conectar
-                checkReady();
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    }
-    /**
-     * Configura los listeners para un worker individual
-     */
-    setupWorkerListeners(poolWorker) {
-        const { worker } = poolWorker;
-        worker.on('message', (response) => {
-            try {
-                // Ignorar mensajes de control
-                if (response.id === 'worker-ready' ||
-                    response.message === 'pong') {
-                    return;
-                }
-                // ✨ ISSUE #4: Manejar reportes de memoria del worker
-                if (response.type === 'memory-usage') {
-                    return; // Ya manejado en getWorkerMemoryUsage
-                }
-                // Buscar la tarea pendiente
-                const pendingTask = poolWorker.pendingTasks.get(response.id);
-                if (!pendingTask) {
-                    return;
-                }
-                // Limpiar timeout y eliminar tarea
-                clearTimeout(pendingTask.timeout);
-                poolWorker.pendingTasks.delete(response.id);
-                // Marcar worker como disponible si no tiene más tareas
-                if (poolWorker.pendingTasks.size === 0) {
-                    poolWorker.busy = false;
-                }
-                // Actualizar actividad del worker
-                poolWorker.lastActivityTime = Date.now();
-                // ✨ ISSUE #4: Manejo mejorado de errores de TypeScript
-                if (response.success &&
-                    response.diagnostics !== undefined &&
-                    response.hasErrors !== undefined) {
-                    this.completedTasks++;
-                    // Analizar y categorizar errores de TypeScript
-                    const categorizedResult = this.categorizeTypeScriptErrors({
-                        diagnostics: response.diagnostics,
-                        hasErrors: response.hasErrors,
-                    }, pendingTask.fileName);
-                    pendingTask.resolve(categorizedResult);
-                }
-                else {
-                    this.failedTasks++;
-                    const errorMessage = response.error || 'Error desconocido del worker';
-                    // ✨ Crear error categorizado
-                    const categorizedError = this.createCategorizedError(errorMessage, pendingTask.fileName, response);
-                    pendingTask.reject(categorizedError);
-                }
-            }
-            catch {
-                // Error silencioso - no imprimir cada error
-            }
-        });
-        worker.on('error', async (error) => {
-            await this.handleWorkerError(poolWorker, error);
-        });
-        worker.on('exit', async (code) => {
-            await this.handleWorkerExit(poolWorker, code);
-        });
-    }
-    /**
-     * Maneja errores de un worker específico con cleanup completo
-     */
-    async handleWorkerError(poolWorker, error) {
-        console.warn(`[WorkerPool] Manejando error del worker ${poolWorker.id}:`, error.message);
-        // 1. Rechazar todas las tareas pendientes con cleanup de timeouts
-        poolWorker.pendingTasks.forEach(task => {
-            clearTimeout(task.timeout);
-            this.failedTasks++;
-            task.reject(new Error(`Worker ${poolWorker.id} failed: ${error.message}`));
-        });
-        poolWorker.pendingTasks.clear();
-        // 2. Terminar worker correctamente para evitar memory leaks
-        try {
-            poolWorker.worker.removeAllListeners();
-            await poolWorker.worker.terminate();
-        }
-        catch (terminateError) {
-            console.error(`[WorkerPool] Error terminando worker ${poolWorker.id}:`, terminateError);
-        }
-        // 3. Marcar como no disponible
-        poolWorker.busy = false;
-        // 4. Recrear worker si el pool está activo
-        if (this.isInitialized && this.workers.length > 0) {
-            try {
-                const newWorker = await this.createWorker(poolWorker.id);
-                const index = this.workers.findIndex(w => w.id === poolWorker.id);
-                if (index !== -1) {
-                    this.workers[index] = newWorker;
-                }
-            }
-            catch (recreateError) {
-                console.error(`[WorkerPool] No se pudo recrear worker ${poolWorker.id}:`, recreateError);
-            }
-        }
-    }
-    /**
-     * Maneja la salida inesperada de un worker con cleanup completo
-     */
-    async handleWorkerExit(poolWorker, code) {
-        console.warn(`[WorkerPool] Worker ${poolWorker.id} salió con código ${code}`);
-        // 1. Rechazar tareas pendientes con cleanup
-        poolWorker.pendingTasks.forEach(task => {
-            clearTimeout(task.timeout);
-            this.failedTasks++;
-            task.reject(new Error(`Worker ${poolWorker.id} exited with code ${code}`));
-        });
-        poolWorker.pendingTasks.clear();
-        poolWorker.busy = false;
-        // 2. Limpiar listeners para evitar memory leaks
-        try {
-            poolWorker.worker.removeAllListeners();
-        }
-        catch {
-            // Error silencioso en cleanup
-        }
-        // 3. Recrear worker si es necesario y el pool está activo
-        if (this.isInitialized && this.workers.length > 0) {
-            try {
-                await this.recreateWorker(poolWorker);
-            }
-            catch (recreateError) {
-                console.error(`[WorkerPool] Error recreando worker ${poolWorker.id}:`, recreateError);
-            }
-        }
-    }
-    /**
-     * Recrea un worker que falló
-     */
-    async recreateWorker(failedWorker) {
-        try {
-            const newWorker = await this.createWorker(failedWorker.id);
-            // Reemplazar en el array
-            const index = this.workers.findIndex(w => w.id === failedWorker.id);
-            if (index !== -1) {
-                this.workers[index] = newWorker;
-            }
-        }
-        catch {
-            // Error silencioso en recreación
-        }
-    }
-    /**
-     * Recicla un worker para prevenir memory leaks
-     */
-    async recycleWorker(poolWorker) {
-        try {
-            console.log(`[WorkerPool] Reciclando worker ${poolWorker.id} después de ${poolWorker.taskCounter} tareas`);
-            // 1. Esperar a que termine tareas pendientes (timeout corto)
-            const maxWait = 2000; // 2 segundos máximo
-            const startTime = Date.now();
-            await new Promise(resolve => {
-                const checkPending = () => {
-                    if (poolWorker.pendingTasks.size === 0 ||
-                        Date.now() - startTime >= maxWait) {
-                        resolve();
-                    }
-                    else {
-                        setTimeout(checkPending, 100);
-                    }
-                };
-                checkPending();
-            });
-            // 2. Si aún hay tareas pendientes, rechazarlas
-            if (poolWorker.pendingTasks.size > 0) {
-                poolWorker.pendingTasks.forEach(task => {
-                    clearTimeout(task.timeout);
-                    task.reject(new Error('Worker being recycled'));
-                });
-                poolWorker.pendingTasks.clear();
-            }
-            // 3. Terminar worker actual
-            poolWorker.worker.removeAllListeners();
-            await poolWorker.worker.terminate();
-            // 4. Crear nuevo worker
-            const newWorker = await this.createWorker(poolWorker.id);
-            // 5. Reemplazar en el array
-            const index = this.workers.findIndex(w => w.id === poolWorker.id);
-            if (index !== -1) {
-                this.workers[index] = newWorker;
-            }
-        }
-        catch (error) {
-            console.error(`[WorkerPool] Error reciclando worker ${poolWorker.id}:`, error);
-        }
-    }
-    /**
-     * Encuentra el worker menos ocupado
-     */
-    findAvailableWorker() {
-        // Buscar worker completamente libre
-        const freeWorker = this.workers.find(w => !w.busy && w.pendingTasks.size === 0);
-        if (freeWorker) {
-            return freeWorker;
-        }
-        // Si no hay workers libres, buscar el menos ocupado
-        const leastBusyWorker = this.workers.reduce((least, current) => {
-            if (current.pendingTasks.size < least.pendingTasks.size) {
-                return current;
-            }
-            return least;
-        });
-        // Solo devolver si no está demasiado ocupado
-        if (leastBusyWorker.pendingTasks.size < 5) {
-            return leastBusyWorker;
-        }
-        return null; // Todos los workers están muy ocupados
-    }
-    /**
-     * Realiza type checking usando el pool de workers
-     */
-    async typeCheck(fileName, content, compilerOptions) {
-        // Asegurar que el pool esté inicializado
-        await this.initializePool();
-        if (!this.isInitialized) {
-            return this.typeCheckWithSyncFallback(fileName, content, compilerOptions);
-        }
-        // Buscar worker disponible
-        const availableWorker = this.findAvailableWorker();
-        if (!availableWorker) {
-            return this.typeCheckWithSyncFallback(fileName, content, compilerOptions);
-        }
-        try {
-            this.totalTasks++;
-            return await this.typeCheckWithWorker(availableWorker, fileName, content, compilerOptions);
-        }
-        catch {
-            return this.typeCheckWithSyncFallback(fileName, content, compilerOptions);
-        }
-    }
-    /**
-     * Realiza type checking usando un worker específico con reciclaje automático
-     */
-    async typeCheckWithWorker(poolWorker, fileName, content, compilerOptions) {
-        // Verificar si el worker necesita reciclaje por número de tareas
-        if (poolWorker.taskCounter >= this.MAX_TASKS_PER_WORKER) {
-            await this.recycleWorker(poolWorker);
-        }
-        return new Promise((resolve, reject) => {
-            const taskId = `task-${poolWorker.id}-${++poolWorker.taskCounter}-${Date.now()}`;
-            // Marcar worker como ocupado y actualizar actividad
-            poolWorker.busy = true;
-            poolWorker.lastActivityTime = Date.now();
-            poolWorker.tasksProcessed++;
-            // ✨ ISSUE #4: Timeout dinámico basado en complejidad del archivo
-            const dynamicTimeout = this.calculateDynamicTimeout(fileName, content, compilerOptions);
-            // Configurar timeout para la tarea
-            const timeout = setTimeout(() => {
-                poolWorker.pendingTasks.delete(taskId);
-                if (poolWorker.pendingTasks.size === 0) {
-                    poolWorker.busy = false;
-                }
-                reject(new Error(`Timeout (${dynamicTimeout}ms) en type checking para ${fileName} - archivo complejo detectado`));
-            }, dynamicTimeout);
-            // Agregar tarea a la lista de pendientes del worker
-            poolWorker.pendingTasks.set(taskId, {
-                resolve,
-                reject,
-                timeout,
-                fileName,
-                startTime: Date.now(),
-            });
-            try {
-                // Crear mensaje para el worker con configuración de timeout
-                const message = {
-                    id: taskId,
-                    fileName,
-                    content,
-                    compilerOptions: {
-                        ...compilerOptions,
-                        // ✨ Añadir timeout al worker para manejo interno
-                        _workerTimeout: dynamicTimeout - 1000, // 1 segundo menos para cleanup interno
-                    },
-                };
-                // Enviar mensaje al worker
-                poolWorker.worker.postMessage(message);
-            }
-            catch (error) {
-                // Limpiar en caso de error
-                clearTimeout(timeout);
-                poolWorker.pendingTasks.delete(taskId);
-                if (poolWorker.pendingTasks.size === 0) {
-                    poolWorker.busy = false;
-                }
-                reject(error);
-            }
-        });
-    }
-    /**
-     * Calcula un timeout dinámico basado en la complejidad del archivo TypeScript
-     */
-    calculateDynamicTimeout(fileName, content, compilerOptions) {
-        const baseTimeout = this.TASK_TIMEOUT; // 10 segundos base
-        let complexityMultiplier = 1;
-        // Factor 1: Tamaño del archivo
-        const contentLength = content.length;
-        if (contentLength > 100000) {
-            // Archivos > 100KB
-            complexityMultiplier += 1.5;
-        }
-        else if (contentLength > 50000) {
-            // Archivos > 50KB
-            complexityMultiplier += 1;
-        }
-        else if (contentLength > 20000) {
-            // Archivos > 20KB
-            complexityMultiplier += 0.5;
-        }
-        // Factor 2: Complejidad sintáctica
-        const importCount = (content.match(/^import\s+/gm) || []).length;
-        const typeCount = (content.match(/\btype\s+\w+/g) || []).length;
-        const interfaceCount = (content.match(/\binterface\s+\w+/g) || [])
-            .length;
-        const genericCount = (content.match(/<[^>]*>/g) || []).length;
-        const complexConstructs = importCount + typeCount + interfaceCount + genericCount * 0.5;
-        if (complexConstructs > 100) {
-            complexityMultiplier += 2;
-        }
-        else if (complexConstructs > 50) {
-            complexityMultiplier += 1;
-        }
-        else if (complexConstructs > 20) {
-            complexityMultiplier += 0.5;
-        }
-        // Factor 3: Configuración de TypeScript estricta
-        if (compilerOptions?.strict || compilerOptions?.noImplicitAny) {
-            complexityMultiplier += 0.3;
-        }
-        // Factor 4: Extensión de archivo compleja (.d.ts, .vue.ts, etc.)
-        if (fileName.includes('.d.ts')) {
-            complexityMultiplier += 1; // Los archivos de definición son más complejos
-        }
-        else if (fileName.includes('.vue')) {
-            complexityMultiplier += 0.5; // Los archivos Vue requieren procesamiento adicional
-        }
-        // Aplicar límites razonables
-        complexityMultiplier = Math.min(complexityMultiplier, 5); // Máximo 5x el timeout base
-        complexityMultiplier = Math.max(complexityMultiplier, 0.5); // Mínimo 0.5x el timeout base
-        const finalTimeout = Math.round(baseTimeout * complexityMultiplier);
-        return Math.min(finalTimeout, 60000); // Máximo absoluto de 60 segundos
-    }
-    /**
-     * Fallback síncrono para type checking
-     */
-    typeCheckWithSyncFallback(fileName, content, compilerOptions) {
-        try {
-            return validateTypesWithLanguageService(fileName, content, compilerOptions);
-        }
-        catch {
-            return {
-                diagnostics: [],
-                hasErrors: false,
-            };
-        }
-    }
-    /**
-     * Cierra todos los workers del pool con cleanup completo
-     */
-    async terminate() {
-        console.log('[WorkerPool] Cerrando pool de workers...');
-        // 1. Rechazar todas las tareas pendientes con cleanup
-        let totalPendingTasks = 0;
-        for (const poolWorker of this.workers) {
-            totalPendingTasks += poolWorker.pendingTasks.size;
-            poolWorker.pendingTasks.forEach(task => {
-                clearTimeout(task.timeout);
-                task.reject(new Error('Worker pool cerrado'));
-            });
-            poolWorker.pendingTasks.clear();
-            // Limpiar listeners para evitar memory leaks
-            try {
-                poolWorker.worker.removeAllListeners();
-            }
-            catch {
-                // Error silencioso en cleanup
-            }
-        }
-        if (totalPendingTasks > 0) {
-            console.log(`[WorkerPool] Se cancelaron ${totalPendingTasks} tareas pendientes`);
-        }
-        // 2. Cerrar todos los workers con manejo de errores
-        const terminatePromises = this.workers.map(async (poolWorker) => {
-            try {
-                await poolWorker.worker.terminate();
-            }
-            catch (error) {
-                console.warn(`[WorkerPool] Error terminando worker ${poolWorker.id}:`, error);
-            }
-        });
-        await Promise.allSettled(terminatePromises);
-        // 3. Limpiar estado
-        this.workers = [];
-        this.isInitialized = false;
-        this.initPromise = null;
-        console.log(`[WorkerPool] Pool cerrado. Estadísticas finales: ${this.completedTasks} completadas, ${this.failedTasks} fallidas`);
-    }
-    /**
-     * Obtiene estadísticas del pool
-     */
-    getStats() {
-        const busyWorkers = this.workers.filter(w => w.busy).length;
-        const totalPendingTasks = this.workers.reduce((sum, w) => sum + w.pendingTasks.size, 0);
-        const successRate = this.totalTasks > 0
-            ? Math.round((this.completedTasks / this.totalTasks) * 100)
-            : 0;
-        return {
-            poolSize: this.workers.length,
-            busyWorkers,
-            totalPendingTasks,
-            totalTasks: this.totalTasks,
-            completedTasks: this.completedTasks,
-            failedTasks: this.failedTasks,
-            successRate,
-        };
-    }
-    // ✨ ISSUE #4: Métodos de categorización de errores de TypeScript
-    /**
-     * Categoriza y mejora los errores de TypeScript para mejor debugging
-     */
-    categorizeTypeScriptErrors(result, fileName) {
-        if (!result.hasErrors || !result.diagnostics?.length) {
-            return result;
-        }
-        const categorizedDiagnostics = result.diagnostics.map(diagnostic => {
-            // Añadir metadatos útiles para debugging
-            const enhanced = {
-                ...diagnostic,
-                _category: this.getErrorCategory(diagnostic),
-                _severity: this.getErrorSeverity(diagnostic),
-                _fileName: fileName,
-                _timestamp: Date.now(),
-            };
-            return enhanced;
-        });
-        return {
-            ...result,
-            diagnostics: categorizedDiagnostics,
-            // Añadir estadísticas de errores
-            _errorStats: this.calculateErrorStats(categorizedDiagnostics),
-        };
-    } /**
-     * Determina la categoría de un error de TypeScript
-     */
-    getErrorCategory(diagnostic) {
-        const code = diagnostic.code;
-        // Categorización basada en códigos de error comunes
-        if ([2304, 2339, 2346].includes(code)) {
-            return 'MISSING_DECLARATION'; // No puede encontrar nombre/propiedad
-        }
-        else if ([2322, 2322, 2345].includes(code)) {
-            return 'TYPE_MISMATCH'; // Error de tipos
-        }
-        else if ([2307, 2317].includes(code)) {
-            return 'MODULE_RESOLUTION'; // Error de resolución de módulos
-        }
-        else if ([2552, 2551].includes(code)) {
-            return 'PROPERTY_ACCESS'; // Error de acceso a propiedades
-        }
-        else if (code >= 1000 && code < 2000) {
-            return 'SYNTAX_ERROR'; // Errores de sintaxis
-        }
-        else if (code >= 2000 && code < 3000) {
-            return 'SEMANTIC_ERROR'; // Errores semánticos
-        }
-        else if (code >= 4000) {
-            return 'CONFIG_ERROR'; // Errores de configuración
-        }
-        return 'OTHER';
-    }
-    /**
-     * Determina la severidad de un error de TypeScript
-     */
-    getErrorSeverity(diagnostic) {
-        const category = diagnostic.category;
-        switch (category) {
-            case 1:
-                return 'ERROR'; // typescript.DiagnosticCategory.Error
-            case 2:
-                return 'WARNING'; // typescript.DiagnosticCategory.Warning
-            case 3:
-                return 'INFO'; // typescript.DiagnosticCategory.Message
-            default:
-                return 'ERROR';
-        }
-    }
-    /**
-     * Calcula estadísticas de errores para análisis
-     */
-    calculateErrorStats(diagnostics) {
-        const stats = {
-            totalErrors: diagnostics.length,
-            errorsByCategory: {},
-            errorsBySeverity: {},
-            mostCommonError: null,
-        };
-        // Contar por categoría y severidad
-        diagnostics.forEach(diag => {
-            const category = diag._category || 'OTHER';
-            const severity = diag._severity || 'ERROR';
-            stats.errorsByCategory[category] =
-                (stats.errorsByCategory[category] || 0) + 1;
-            stats.errorsBySeverity[severity] =
-                (stats.errorsBySeverity[severity] || 0) + 1;
-        }); // Encontrar el error más común
-        const errorCounts = {};
-        diagnostics.forEach(diag => {
-            const code = String(diag.code);
-            errorCounts[code] = (errorCounts[code] || 0) + 1;
-        });
-        const errorCountKeys = Object.keys(errorCounts);
-        if (errorCountKeys.length > 0) {
-            const mostCommonCode = errorCountKeys.reduce((a, b) => (errorCounts[a] || 0) > (errorCounts[b] || 0) ? a : b);
-            stats.mostCommonError = {
-                code: mostCommonCode,
-                count: errorCounts[mostCommonCode],
-                message: diagnostics.find(d => String(d.code) === mostCommonCode)?.messageText,
-            };
-        }
-        return stats;
-    }
-    /**
-     * Crea un error categorizado con información de contexto
-     */
-    createCategorizedError(errorMessage, fileName, response) {
-        const error = new Error(errorMessage);
-        // Añadir metadatos del error
-        error.fileName = fileName;
-        error.timestamp = Date.now();
-        error.workerResponse = response;
-        error.category = this.categorizeGenericError(errorMessage);
-        error.isRecoverable = this.isRecoverableError(errorMessage);
-        return error;
-    }
-    /**
-     * Categoriza errores genéricos del worker
-     */
-    categorizeGenericError(errorMessage) {
-        if (errorMessage.includes('timeout') ||
-            errorMessage.includes('Timeout')) {
-            return 'TIMEOUT';
-        }
-        else if (errorMessage.includes('memory') ||
-            errorMessage.includes('Memory')) {
-            return 'MEMORY';
-        }
-        else if (errorMessage.includes('Worker') &&
-            errorMessage.includes('exited')) {
-            return 'WORKER_CRASH';
-        }
-        else if (errorMessage.includes('initialization') ||
-            errorMessage.includes('init')) {
-            return 'INITIALIZATION';
-        }
-        return 'UNKNOWN';
-    }
-    /**
-     * Determina si un error es recuperable
-     */
-    isRecoverableError(errorMessage) {
-        const recoverablePatterns = [
-            'timeout',
-            'Worker being recycled',
-            'Worker pool cerrado',
-            'temporary',
-        ];
-        return recoverablePatterns.some(pattern => errorMessage.toLowerCase().includes(pattern.toLowerCase()));
-    }
-}
-//# sourceMappingURL=typescript-worker-pool.js.map
+import*as e from"node:os";import*as t from"node:path";import*as n from"node:process";import{Worker as r}from"node:worker_threads";import{validateTypesWithLanguageService as i}from"./typescript-sync-validator.js";export class TypeScriptWorkerPool{static instance;workers=[];poolSize;workerPath;initPromise=null;isInitialized=!1;TASK_TIMEOUT=15e3;WORKER_INIT_TIMEOUT=5e3;MAX_TASKS_PER_WORKER=25;WORKER_MEMORY_CHECK_INTERVAL=50;totalTasks=0;completedTasks=0;failedTasks=0;constructor(){let r=e.cpus().length;this.poolSize=Math.min(Math.max(r-1,2),8),this.workerPath=t.join(n.env.PATH_PROY||t.join(n.cwd(),`src`),`compiler`,`typescript-worker-thread.cjs`)}startMemoryMonitoring(){setInterval(()=>{this.checkWorkersMemory()},15e3),setInterval(()=>{this.cleanupInactiveWorkers()},12e4)}async checkWorkersMemory(){let e=Date.now();for(let t of this.workers){t.lastMemoryCheck=e;try{let e=await this.getWorkerMemoryUsage(t);if(t.memoryUsage=e.heapUsed,this.shouldRecycleWorker(t)){let e=this.getRecycleReason(t);console.warn(`[WorkerPool] Worker ${t.id} requiere reciclaje: ${e}`),await this.recycleWorker(t)}}catch(e){console.warn(`[WorkerPool] Error verificando memoria del worker ${t.id}:`,e)}}}async getWorkerMemoryUsage(e){return new Promise(t=>{let n=setTimeout(()=>{t({heapUsed:e.tasksProcessed*2048,heapTotal:e.tasksProcessed*3072,rss:e.tasksProcessed*4096})},1e3),r=`memory-${e.id}-${Date.now()}`,i=a=>{a.id===r&&a.type===`memory-usage`&&(clearTimeout(n),e.worker.off(`message`,i),t({heapUsed:a.memoryUsage?.heapUsed||e.tasksProcessed*2048,heapTotal:a.memoryUsage?.heapTotal||e.tasksProcessed*3072,rss:a.memoryUsage?.rss||e.tasksProcessed*4096}))};e.worker.on(`message`,i),e.worker.postMessage({type:`get-memory-usage`,id:r})})}getRecycleReason(e){let t=Date.now(),n=50*1024*1024,r=1800*1e3,i=this.MAX_TASKS_PER_WORKER,a=[];return e.memoryUsage>n&&a.push(`memoria excede ${Math.round(n/1024/1024)}MB (actual: ${Math.round(e.memoryUsage/1024/1024)}MB)`),t-e.creationTime>r&&a.push(`tiempo de vida excede ${Math.round(r/6e4)} minutos`),e.tasksProcessed>=i&&a.push(`tareas procesadas exceden ${i} (actual: ${e.tasksProcessed})`),a.join(`, `)}async cleanupInactiveWorkers(){let e=Date.now(),t=300*1e3;for(let t of this.workers){let n=e-t.lastActivityTime;n>3e5&&!t.busy&&t.pendingTasks.size===0&&(console.info(`[WorkerPool] Worker ${t.id} inactivo por ${Math.round(n/6e4)} minutos, reciclando...`),await this.recycleWorker(t))}}shouldRecycleWorker(e){let t=Date.now(),n=30*1024*1024,r=900*1e3,i=this.MAX_TASKS_PER_WORKER;return e.memoryUsage>31457280||t-e.creationTime>9e5||e.tasksProcessed>=i}static getInstance(){return TypeScriptWorkerPool.instance||=new TypeScriptWorkerPool,TypeScriptWorkerPool.instance}setMode(t){switch(t){case`batch`:this.poolSize=Math.min(e.cpus().length,12);break;case`watch`:this.poolSize=Math.min(Math.max(e.cpus().length/2,2),6);break;case`individual`:this.poolSize=Math.min(4,e.cpus().length);break}}async initializePool(){return this.initPromise||=this._performPoolInitialization(),this.initPromise}async _performPoolInitialization(){try{let e=await import(`node:fs`),t=e.existsSync(this.workerPath);if(!t)throw Error(`Worker thread file not found: ${this.workerPath}`);let n=Array.from({length:this.poolSize},(e,t)=>this.createWorker(t));this.workers=await Promise.all(n),this.isInitialized=!0}catch(e){throw this.isInitialized=!1,e}}async createWorker(e){return new Promise((t,i)=>{try{let a=new r(this.workerPath,{env:{...n.env,NODE_OPTIONS:``,WORKER_ID:e.toString()}}),o={worker:a,id:e,busy:!1,pendingTasks:new Map,taskCounter:0,memoryUsage:0,lastMemoryCheck:Date.now(),tasksProcessed:0,creationTime:Date.now(),lastActivityTime:Date.now()};this.setupWorkerListeners(o);let s=setTimeout(()=>{i(Error(`Worker ${e} initialization timeout`))},this.WORKER_INIT_TIMEOUT),c=()=>{a.postMessage({type:`ping`})};a.on(`message`,function e(n){(n.id===`worker-ready`||n.message===`pong`)&&(clearTimeout(s),a.off(`message`,e),t(o))}),a.on(`error`,e=>{clearTimeout(s),i(e)}),c()}catch(e){i(e)}})}setupWorkerListeners(e){let{worker:t}=e;t.on(`message`,t=>{try{if(t.id===`worker-ready`||t.message===`pong`||t.type===`memory-usage`)return;let n=e.pendingTasks.get(t.id);if(!n)return;if(clearTimeout(n.timeout),e.pendingTasks.delete(t.id),e.pendingTasks.size===0&&(e.busy=!1),e.lastActivityTime=Date.now(),t.success&&t.diagnostics!==void 0&&t.hasErrors!==void 0){this.completedTasks++;let e=this.categorizeTypeScriptErrors({diagnostics:t.diagnostics,hasErrors:t.hasErrors},n.fileName);n.resolve(e)}else{this.failedTasks++;let e=t.error||`Error desconocido del worker`,r=this.createCategorizedError(e,n.fileName,t);n.reject(r)}}catch{}}),t.on(`error`,async t=>{await this.handleWorkerError(e,t)}),t.on(`exit`,async t=>{await this.handleWorkerExit(e,t)})}async handleWorkerError(e,t){console.warn(`[WorkerPool] Manejando error del worker ${e.id}:`,t.message),e.pendingTasks.forEach(n=>{clearTimeout(n.timeout),this.failedTasks++,n.reject(Error(`Worker ${e.id} failed: ${t.message}`))}),e.pendingTasks.clear();try{e.worker.removeAllListeners(),await e.worker.terminate()}catch(t){console.error(`[WorkerPool] Error terminando worker ${e.id}:`,t)}if(e.busy=!1,this.isInitialized&&this.workers.length>0)try{let t=await this.createWorker(e.id),n=this.workers.findIndex(t=>t.id===e.id);n!==-1&&(this.workers[n]=t)}catch(t){console.error(`[WorkerPool] No se pudo recrear worker ${e.id}:`,t)}}async handleWorkerExit(e,t){console.warn(`[WorkerPool] Worker ${e.id} salió con código ${t}`),e.pendingTasks.forEach(n=>{clearTimeout(n.timeout),this.failedTasks++,n.reject(Error(`Worker ${e.id} exited with code ${t}`))}),e.pendingTasks.clear(),e.busy=!1;try{e.worker.removeAllListeners()}catch{}if(this.isInitialized&&this.workers.length>0)try{await this.recreateWorker(e)}catch(t){console.error(`[WorkerPool] Error recreando worker ${e.id}:`,t)}}async recreateWorker(e){try{let t=await this.createWorker(e.id),n=this.workers.findIndex(t=>t.id===e.id);n!==-1&&(this.workers[n]=t)}catch{}}async recycleWorker(e){try{console.log(`[WorkerPool] Reciclando worker ${e.id} después de ${e.taskCounter} tareas`);let t=2e3,n=Date.now();await new Promise(t=>{let r=()=>{e.pendingTasks.size===0||Date.now()-n>=2e3?t():setTimeout(r,100)};r()}),e.pendingTasks.size>0&&(e.pendingTasks.forEach(e=>{clearTimeout(e.timeout),e.reject(Error(`Worker being recycled`))}),e.pendingTasks.clear()),e.worker.removeAllListeners(),await e.worker.terminate();let r=await this.createWorker(e.id),i=this.workers.findIndex(t=>t.id===e.id);i!==-1&&(this.workers[i]=r)}catch(t){console.error(`[WorkerPool] Error reciclando worker ${e.id}:`,t)}}findAvailableWorker(){let e=this.workers.find(e=>!e.busy&&e.pendingTasks.size===0);if(e)return e;let t=this.workers.reduce((e,t)=>t.pendingTasks.size<e.pendingTasks.size?t:e);return t.pendingTasks.size<5?t:null}async typeCheck(e,t,n){if(await this.initializePool(),!this.isInitialized)return this.typeCheckWithSyncFallback(e,t,n);let r=this.findAvailableWorker();if(!r)return this.typeCheckWithSyncFallback(e,t,n);try{return this.totalTasks++,await this.typeCheckWithWorker(r,e,t,n)}catch{return this.typeCheckWithSyncFallback(e,t,n)}}async typeCheckWithWorker(e,t,n,r){return e.taskCounter>=this.MAX_TASKS_PER_WORKER&&await this.recycleWorker(e),new Promise((i,a)=>{let o=`task-${e.id}-${++e.taskCounter}-${Date.now()}`;e.busy=!0,e.lastActivityTime=Date.now(),e.tasksProcessed++;let s=this.calculateDynamicTimeout(t,n,r),c=setTimeout(()=>{e.pendingTasks.delete(o),e.pendingTasks.size===0&&(e.busy=!1),a(Error(`Timeout (${s}ms) en type checking para ${t} - archivo complejo detectado`))},s);e.pendingTasks.set(o,{resolve:i,reject:a,timeout:c,fileName:t,startTime:Date.now()});try{let i={id:o,fileName:t,content:n,compilerOptions:{...r,_workerTimeout:s-1e3}};e.worker.postMessage(i)}catch(t){clearTimeout(c),e.pendingTasks.delete(o),e.pendingTasks.size===0&&(e.busy=!1),a(t)}})}calculateDynamicTimeout(e,t,n){let r=this.TASK_TIMEOUT,i=1,a=t.length;a>1e5?i+=1.5:a>5e4?i+=1:a>2e4&&(i+=.5);let o=(t.match(/^import\s+/gm)||[]).length,s=(t.match(/\btype\s+\w+/g)||[]).length,c=(t.match(/\binterface\s+\w+/g)||[]).length,l=(t.match(/<[^>]*>/g)||[]).length,u=o+s+c+l*.5;u>100?i+=2:u>50?i+=1:u>20&&(i+=.5),(n?.strict||n?.noImplicitAny)&&(i+=.3),e.includes(`.d.ts`)?i+=1:e.includes(`.vue`)&&(i+=.5),i=Math.min(i,5),i=Math.max(i,.5);let d=Math.round(r*i);return Math.min(d,6e4)}typeCheckWithSyncFallback(e,t,n){try{return i(e,t,n)}catch{return{diagnostics:[],hasErrors:!1}}}async terminate(){console.log(`[WorkerPool] Cerrando pool de workers...`);let e=0;for(let t of this.workers){e+=t.pendingTasks.size,t.pendingTasks.forEach(e=>{clearTimeout(e.timeout),e.reject(Error(`Worker pool cerrado`))}),t.pendingTasks.clear();try{t.worker.removeAllListeners()}catch{}}e>0&&console.log(`[WorkerPool] Se cancelaron ${e} tareas pendientes`);let t=this.workers.map(async e=>{try{await e.worker.terminate()}catch(t){console.warn(`[WorkerPool] Error terminando worker ${e.id}:`,t)}});await Promise.allSettled(t),this.workers=[],this.isInitialized=!1,this.initPromise=null,console.log(`[WorkerPool] Pool cerrado. Estadísticas finales: ${this.completedTasks} completadas, ${this.failedTasks} fallidas`)}getStats(){let e=this.workers.filter(e=>e.busy).length,t=this.workers.reduce((e,t)=>e+t.pendingTasks.size,0),n=this.totalTasks>0?Math.round(this.completedTasks/this.totalTasks*100):0;return{poolSize:this.workers.length,busyWorkers:e,totalPendingTasks:t,totalTasks:this.totalTasks,completedTasks:this.completedTasks,failedTasks:this.failedTasks,successRate:n}}categorizeTypeScriptErrors(e,t){if(!e.hasErrors||!e.diagnostics?.length)return e;let n=e.diagnostics.map(e=>{let n={...e,_category:this.getErrorCategory(e),_severity:this.getErrorSeverity(e),_fileName:t,_timestamp:Date.now()};return n});return{...e,diagnostics:n,_errorStats:this.calculateErrorStats(n)}}getErrorCategory(e){let t=e.code;return[2304,2339,2346].includes(t)?`MISSING_DECLARATION`:[2322,2322,2345].includes(t)?`TYPE_MISMATCH`:[2307,2317].includes(t)?`MODULE_RESOLUTION`:[2552,2551].includes(t)?`PROPERTY_ACCESS`:t>=1e3&&t<2e3?`SYNTAX_ERROR`:t>=2e3&&t<3e3?`SEMANTIC_ERROR`:t>=4e3?`CONFIG_ERROR`:`OTHER`}getErrorSeverity(e){let t=e.category;switch(t){case 1:return`ERROR`;case 2:return`WARNING`;case 3:return`INFO`;default:return`ERROR`}}calculateErrorStats(e){let t={totalErrors:e.length,errorsByCategory:{},errorsBySeverity:{},mostCommonError:null};e.forEach(e=>{let n=e._category||`OTHER`,r=e._severity||`ERROR`;t.errorsByCategory[n]=(t.errorsByCategory[n]||0)+1,t.errorsBySeverity[r]=(t.errorsBySeverity[r]||0)+1});let n={};e.forEach(e=>{let t=String(e.code);n[t]=(n[t]||0)+1});let r=Object.keys(n);if(r.length>0){let i=r.reduce((e,t)=>(n[e]||0)>(n[t]||0)?e:t);t.mostCommonError={code:i,count:n[i],message:e.find(e=>String(e.code)===i)?.messageText}}return t}createCategorizedError(e,t,n){let r=Error(e);return r.fileName=t,r.timestamp=Date.now(),r.workerResponse=n,r.category=this.categorizeGenericError(e),r.isRecoverable=this.isRecoverableError(e),r}categorizeGenericError(e){return e.includes(`timeout`)||e.includes(`Timeout`)?`TIMEOUT`:e.includes(`memory`)||e.includes(`Memory`)?`MEMORY`:e.includes(`Worker`)&&e.includes(`exited`)?`WORKER_CRASH`:e.includes(`initialization`)||e.includes(`init`)?`INITIALIZATION`:`UNKNOWN`}isRecoverableError(e){let t=[`timeout`,`Worker being recycled`,`Worker pool cerrado`,`temporary`];return t.some(t=>e.toLowerCase().includes(t.toLowerCase()))}}