versacompiler 2.3.5 → 2.4.1

package/dist/compiler/integrity-validator.js

@@ -15,6 +15,7 @@ export class IntegrityValidator {
     static instance;
     cache = new Map();
     MAX_CACHE_SIZE = 100;
+    CACHE_TTL = 30 * 60 * 1000; // 30 minutos
     // Estadísticas
     stats = {
         totalValidations: 0,
@@ -47,12 +48,12 @@ export class IntegrityValidator {
         // Revisar cache
         const cacheKey = this.getCacheKey(context, processed);
         const cached = this.cache.get(cacheKey);
-        if (cached) {
+        if (cached && (Date.now() - cached.timestamp) < this.CACHE_TTL) {
             this.stats.cacheHits++;
             if (options.verbose) {
                 logger.info(`[IntegrityValidator] Cache hit for ${context}`);
             }
-            return cached;
+            return cached.result;
         }
         this.stats.cacheMisses++;
         const errors = [];
@@ -70,14 +71,11 @@ export class IntegrityValidator {
             this.handleValidationResult(result, context, options);
             return result;
         }
-        // Check 2: Structure (~1ms) - TEMPORALMENTE DESHABILITADO
-        // TODO: Mejorar detección de character classes en regex literals
-        const structureOk = true; // this.checkStructure(processed);
-        // if (!structureOk) {
-        //     errors.push(
-        //         'Estructura de código inválida (paréntesis/llaves/corchetes desbalanceados)',
-        //     );
-        // }
+        // Check 2: Structure (~1ms)
+        const structureOk = this.checkStructure(processed);
+        if (!structureOk) {
+            errors.push('Estructura de código inválida (paréntesis/llaves/corchetes desbalanceados)');
+        }
         // Check 3: Exports (~1ms)
         const exportsOk = this.checkExports(original, processed);
         if (!exportsOk) {
@@ -493,7 +491,7 @@ export class IntegrityValidator {
                 this.cache.delete(firstKey);
             }
         }
-        this.cache.set(key, result);
+        this.cache.set(key, { result, timestamp: Date.now() });
     }
     /**
      * Obtener estadísticas de validación

package/dist/compiler/minify.js

@@ -57,13 +57,12 @@ class MinificationCache {
                 const validation = integrityValidator.validate(data, result.code, `minify:${filename}`, {
                     skipSyntaxCheck: false,
                     verbose: process.env.VERBOSE === 'true',
-                    throwOnError: true, // Detener build si falla
+                    throwOnError: false, // Usar fallback en lugar de lanzar excepción
                 });
                 if (!validation.valid) {
-                    // El validator ya lanzó el error si throwOnError=true
-                    // Pero por si acaso, retornamos el código original
-                    logger.error(`❌ Validación de integridad fallida para ${filename}`, validation.errors.join(', '));
-                    throw new Error(`Integrity check failed for ${filename}: ${validation.errors.join(', ')}`);
+                    logger.warn(`⚠️  Validación de integridad fallida para ${filename}: ${validation.errors.join(', ')}`);
+                    logger.warn(`   Usando código original sin minificar`);
+                    return { code: data, error: null, cached: false };
                 }
                 if (process.env.VERBOSE === 'true') {
                     logger.info(`✅ Validación de integridad OK para ${filename} (${validation.metrics.duration.toFixed(2)}ms)`);

package/dist/compiler/transforms.js

@@ -3,8 +3,8 @@ import { env } from 'node:process';
 import { logger } from '../servicios/logger.js';
 import { EXCLUDED_MODULES } from '../utils/excluded-modules.js';
 import { getModuleSubPath } from '../utils/module-resolver.js';
-import { integrityValidator } from './integrity-validator.js';
 import { analyzeAndFormatMultipleErrors } from './error-reporter.js';
+import { integrityValidator } from './integrity-validator.js';
 import { getOptimizedAliasPath, getOptimizedModulePath, } from './module-resolution-optimizer.js';
 import { parser } from './parser.js';
 // ✨ OPTIMIZACIÓN CRÍTICA: Cache de PATH_ALIAS parseado

package/dist/compiler/typescript-error-parser.js

@@ -135,139 +135,6 @@ function cleanErrorMessage(message) {
         .replace(/\s+/g, ' ')
         .trim());
 }
-/**
- * Mejora significativamente el mensaje de error TypeScript con contexto visual
- * ⚠️ DEPRECATED: Ya no se usa en el flujo normal para evitar overhead de performance
- * Se mantiene para compatibilidad futura o modo verbose avanzado
- * @param scriptInfo - Información de extracción de script para archivos Vue (opcional)
- */
-function enhanceErrorMessage(diagnostic, fileName, sourceCode, scriptInfo) {
-    // Extraer el mensaje del error
-    const message = typeof diagnostic.messageText === 'string'
-        ? diagnostic.messageText
-        : typescript.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
-    const enhancedMessage = cleanErrorMessage(message); // Información de ubicación
-    let location = `Código TS${diagnostic.code}`;
-    let codeContext = '';
-    if (diagnostic.file && diagnostic.start !== undefined) {
-        const sourceFile = diagnostic.file;
-        // Verificar que el método getLineAndCharacterOfPosition existe (para compatibilidad con mocks)
-        if (typeof sourceFile.getLineAndCharacterOfPosition === 'function') {
-            try {
-                const lineAndChar = sourceFile.getLineAndCharacterOfPosition(diagnostic.start);
-                // Ajustar línea si es un archivo Vue con script extraído
-                const line = scriptInfo
-                    ? lineAndChar.line + scriptInfo.startLine
-                    : lineAndChar.line + 1;
-                const column = lineAndChar.character + 1;
-                location = `Línea ${line}, Columna ${column} | Código TS${diagnostic.code}`;
-            }
-            catch {
-                // Si falla, solo mostrar el código de error
-                location = `Código TS${diagnostic.code}`;
-            }
-        }
-        else {
-            // Fallback: solo mostrar el código de error
-            location = `Código TS${diagnostic.code}`;
-        } // Agregar contexto del código si está disponible
-        if ((sourceCode || scriptInfo?.originalData || sourceFile.text) &&
-            typeof sourceFile.getLineAndCharacterOfPosition === 'function') {
-            try {
-                const lineAndChar = sourceFile.getLineAndCharacterOfPosition(diagnostic.start);
-                // Obtener código fuente apropiado
-                const text = scriptInfo?.originalData || sourceCode || sourceFile.text;
-                const lines = text.split('\n');
-                // Calcular la línea real en el archivo original
-                const actualLineIndex = scriptInfo
-                    ? lineAndChar.line + scriptInfo.startLine - 1
-                    : lineAndChar.line;
-                const errorLine = lines[actualLineIndex];
-                if (errorLine) {
-                    // Mostrar hasta 2 líneas antes y después para contexto
-                    const startLine = Math.max(0, actualLineIndex - 2);
-                    const endLine = Math.min(lines.length - 1, actualLineIndex + 2);
-                    codeContext = '\n\n📝 Contexto del código:\n';
-                    for (let i = startLine; i <= endLine; i++) {
-                        const currentLine = i + 1;
-                        const lineContent = lines[i] || '';
-                        const isErrorLine = i === actualLineIndex;
-                        if (isErrorLine) {
-                            codeContext += `  ${currentLine.toString().padStart(3, ' ')} ❌ ${lineContent}\n`;
-                            // Agregar flecha apuntando al error
-                            const arrow = ' '.repeat(6 + lineAndChar.character + 1) +
-                                '^^^';
-                            codeContext += `       ${arrow}\n`;
-                        }
-                        else {
-                            codeContext += `  ${currentLine.toString().padStart(3, ' ')}    ${lineContent}\n`;
-                        }
-                    }
-                }
-            }
-            catch {
-                // Si falla obtener el contexto, continuar sin él
-            }
-        }
-    }
-    // Agregar sugerencias basadas en el tipo de error
-    const suggestions = getErrorSuggestions(diagnostic.code, enhancedMessage);
-    const suggestionsText = suggestions.length > 0
-        ? `\n\n💡 Sugerencias:\n${suggestions.map(s => `   • ${s}`).join('\n')}`
-        : '';
-    return `${enhancedMessage}\n   📍 ${location}${codeContext}${suggestionsText}`;
-}
-/**
- * Proporciona sugerencias específicas basadas en el código de error TypeScript
- */
-function getErrorSuggestions(errorCode, message) {
-    const suggestions = [];
-    switch (errorCode) {
-        case 2304: // Cannot find name
-            suggestions.push('Verifica que la variable esté declarada');
-            suggestions.push('Asegúrate de importar el módulo correspondiente');
-            suggestions.push('Revisa la ortografía del nombre');
-            break;
-        case 2322: // Type assignment error
-            suggestions.push('Verifica que los tipos sean compatibles');
-            suggestions.push('Considera usar type assertion: valor as TipoEsperado');
-            break;
-        case 2307: // Cannot find module
-            suggestions.push('Verifica que el archivo exista en la ruta especificada');
-            suggestions.push('Revisa las rutas en tsconfig.json');
-            suggestions.push('Asegúrate de que el paquete esté instalado');
-            break;
-        case 2451: // Cannot redeclare block-scoped variable
-            suggestions.push('Cambia el nombre de la variable');
-            suggestions.push('Usa un scope diferente (function, block)');
-            break;
-        case 7006: // Parameter implicitly has 'any' type
-            suggestions.push('Agrega tipos explícitos a los parámetros');
-            suggestions.push('Considera habilitar "noImplicitAny": false en tsconfig.json');
-            break;
-        case 1155: // 'const' declarations must be initialized
-            suggestions.push('Agrega un valor inicial: const variable = valor;');
-            suggestions.push('O cambia a "let" si quieres asignar después');
-            break;
-        case 2339: // Property does not exist
-            suggestions.push('Verifica que la propiedad exista en el tipo');
-            suggestions.push('Considera usar optional chaining: objeto?.propiedad');
-            break;
-        default:
-            // Sugerencias genéricas basadas en el mensaje
-            if (message.includes('Cannot find')) {
-                suggestions.push('Verifica que el elemento exista y esté importado');
-            }
-            if (message.includes('Type')) {
-                suggestions.push('Revisa la compatibilidad de tipos');
-            }
-            if (message.includes('missing')) {
-                suggestions.push('Agrega el elemento faltante');
-            }
-            break;
-    }
-    return suggestions;
-}
 /**
  * Crea un mensaje de error unificado para errores múltiples
  */

package/dist/compiler/typescript-sync-validator.js

@@ -94,17 +94,17 @@ class TypeScriptLanguageServiceHost {
     getDefaultLibFileName(options) {
         return typescript.getDefaultLibFilePath(options);
     }
-    fileExists(path) {
-        return this.files.has(path) || fs.existsSync(path);
+    fileExists(filePath) {
+        return this.files.has(filePath) || fs.existsSync(filePath);
     }
-    readFile(path) {
-        const file = this.files.get(path);
+    readFile(filePath) {
+        const file = this.files.get(filePath);
         if (file) {
             return file.content;
         }
-        if (fs.existsSync(path)) {
+        if (fs.existsSync(filePath)) {
             try {
-                return fs.readFileSync(path, 'utf-8');
+                return fs.readFileSync(filePath, 'utf-8');
             }
             catch {
                 return undefined;
@@ -167,7 +167,6 @@ export const validateTypesWithLanguageService = (fileName, content, compilerOpti
         try {
             // Verificar que el archivo existe en el host antes de solicitar diagnósticos
             if (!host.fileExists(actualFileName)) {
-                console.log('File does not exist in host, returning empty result');
                 return { diagnostics: [], hasErrors: false };
             } // Obtener diagnósticos de tipos con manejo de errores
             let syntacticDiagnostics = [];
@@ -266,6 +265,12 @@ export const validateTypesWithLanguageService = (fileName, content, compilerOpti
         catch {
             return { diagnostics: [], hasErrors: false };
         }
+        finally {
+            try {
+                languageService.dispose();
+            }
+            catch { /* ignore dispose errors */ }
+        }
     }
     catch (error) {
         // En caso de error, devolver diagnóstico de error

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

@@ -19,22 +19,27 @@ export class TypeScriptWorkerPool {
     workerPath;
     initPromise = null;
     isInitialized = false; // Configuración optimizada con reciclaje de workers
-    TASK_TIMEOUT = 8000; // 8 segundos por tarea (reducido para mayor velocidad)
-    WORKER_INIT_TIMEOUT = 3000; // 3 segundos para inicializar (reducido)
+    TASK_TIMEOUT = 60000; // 60 segundos por tarea - workers son secuenciales, necesitan tiempo
+    WORKER_INIT_TIMEOUT = 10000; // 10 segundos para inicializar
     MAX_TASKS_PER_WORKER = 200; // ✨ OPTIMIZADO: Aumentado de 50 a 200 para reducir overhead de reciclaje
     WORKER_MEMORY_CHECK_INTERVAL = 500; // ✨ OPTIMIZADO: Verificar cada 500 tareas (reducir overhead)
     // ✨ FIX #1: Referencias a timers para limpieza adecuada
     memoryCheckInterval = null;
     cleanupInterval = null;
+    // Cola de tareas para cuando todos los workers están ocupados
+    taskQueue = [];
+    MAX_QUEUE_SIZE = 1000; // Suficiente para proyectos de 300+ archivos
+    // Flag para evitar concurrencia en ensureWorkerCapacity
+    isScalingUp = false;
     // Métricas de rendimiento
     totalTasks = 0;
     completedTasks = 0;
     failedTasks = 0;
     constructor() {
-        // Determinar tamaño óptimo del pool - MÁS AGRESIVO para mejor rendimiento
+        // Determinar tamaño conservador del pool para evitar sobrecarga de RAM/CPU
         const cpuCount = os.cpus().length;
-        // Usar más workers para aprovechar mejor el CPU
-        this.poolSize = Math.min(Math.max(cpuCount, 4), 16); // Entre 4 y 16 workers
+        const configuredMax = parseInt(process.env.TS_MAX_WORKERS || '2', 10);
+        this.poolSize = Math.min(configuredMax, Math.max(1, cpuCount - 1));
         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();
     }
@@ -80,8 +85,11 @@ export class TypeScriptWorkerPool {
                 // ✨ 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)) {
+                // Verificar límites de memoria y reciclaje automático.
+                // Solo reciclar workers INACTIVOS para evitar rechazar tareas en vuelo.
+                // Los workers con tareas pendientes se reciclan vía drainQueue cuando quedan libres.
+                const isIdle = !poolWorker.busy && poolWorker.pendingTasks.size === 0;
+                if (isIdle && this.shouldRecycleWorker(poolWorker)) {
                     const reason = this.getRecycleReason(poolWorker);
                     console.warn(`[WorkerPool] Worker ${poolWorker.id} requiere reciclaje: ${reason}`);
                     await this.recycleWorker(poolWorker);
@@ -190,19 +198,19 @@ export class TypeScriptWorkerPool {
      * Configura el modo de operación del pool - OPTIMIZADO para máxima velocidad
      */
     setMode(mode) {
-        // Ajustar configuración según el modo - MÁS AGRESIVO
+        const cpuCount = os.cpus().length;
         switch (mode) {
             case 'batch':
-                // Para modo batch, máxima concurrencia para throughput
-                this.poolSize = Math.min(os.cpus().length, 20);
+                // Para modo batch, hasta 4 workers para mejor rendimiento en proyectos grandes
+                this.poolSize = Math.min(4, Math.max(1, cpuCount - 1));
                 break;
             case 'watch':
-                // Para modo watch, más workers para mejor responsividad
-                this.poolSize = Math.min(os.cpus().length, 12);
+                // Para modo watch, hasta 2 workers para menor impacto en sistema
+                this.poolSize = Math.min(2, Math.max(1, cpuCount - 1));
                 break;
             case 'individual':
-                // Para individual, pool moderado
-                this.poolSize = Math.min(8, os.cpus().length);
+                // Para individual, 1 worker suficiente
+                this.poolSize = 1;
                 break;
         }
     }
@@ -227,9 +235,9 @@ export class TypeScriptWorkerPool {
             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);
+            // Crear solo el primer worker al iniciar; el resto se crean bajo demanda
+            const firstWorker = await this.createWorker(0);
+            this.workers = [firstWorker];
             this.isInitialized = true;
         }
         catch (error) {
@@ -237,6 +245,30 @@ export class TypeScriptWorkerPool {
             throw error;
         }
     }
+    /**
+     * Crea un worker adicional si todos están ocupados y la cola tiene tareas pendientes.
+     * Usa un flag para evitar que múltiples llamadas concurrentes creen workers de más.
+     */
+    async ensureWorkerCapacity() {
+        if (this.isScalingUp)
+            return;
+        if (this.workers.length >= this.poolSize)
+            return;
+        const allBusy = this.workers.every(w => w.busy || w.pendingTasks.size > 0);
+        if (!allBusy || this.taskQueue.length === 0)
+            return;
+        this.isScalingUp = true;
+        try {
+            const newWorker = await this.createWorker(this.workers.length);
+            this.workers.push(newWorker);
+        }
+        catch {
+            // Silencioso: se usará la cola cuando un worker quede libre
+        }
+        finally {
+            this.isScalingUp = false;
+        }
+    }
     /**
      * Crea un worker individual
      */
@@ -338,17 +370,19 @@ export class TypeScriptWorkerPool {
                     };
                     // ✨ FIX MEMORIA: No mantener response completo en memoria
                     resolve(result);
-                    // ✨ FIX MEMORIA: Limpiar diagnostics después de resolver
+                    // Procesar siguiente tarea de la cola y limpiar diagnostics
                     setImmediate(() => {
+                        this.drainQueue(poolWorker);
                         if (response.diagnostics) {
                             response.diagnostics.length = 0;
                         }
                     });
                 }
                 else {
-                    this.failedTasks++;
                     const errorMessage = response.error || 'Error desconocido del worker';
                     // ✨ FIX MEMORIA: Error simple sin referencias pesadas
+                    // failedTasks se incrementa en el wrapper de queued.reject para tareas de cola,
+                    // o en handleWorkerError/Exit para tareas directas que se re-encolan.
                     const error = new Error(errorMessage);
                     reject(error);
                 }
@@ -374,7 +408,8 @@ export class TypeScriptWorkerPool {
         const pendingTasksArray = Array.from(poolWorker.pendingTasks.entries());
         for (const [taskId, task] of pendingTasksArray) {
             clearTimeout(task.timeout);
-            this.failedTasks++;
+            // failedTasks se contabiliza en el wrapper de queued.reject (para cola)
+            // o via re-encolado en typeCheck() catch (para tareas directas).
             task.reject(new Error(`Worker ${poolWorker.id} failed`));
             poolWorker.pendingTasks.delete(taskId);
         }
@@ -406,6 +441,8 @@ export class TypeScriptWorkerPool {
                     if (index !== -1) {
                         this.workers[index] = newWorker;
                     }
+                    // Drenar la cola con el nuevo worker para evitar tareas atascadas
+                    setImmediate(() => this.drainAllWorkers());
                 }
                 catch {
                     // Silencioso
@@ -421,7 +458,8 @@ export class TypeScriptWorkerPool {
         // 1. Rechazar tareas pendientes con cleanup
         poolWorker.pendingTasks.forEach(task => {
             clearTimeout(task.timeout);
-            this.failedTasks++;
+            // failedTasks se contabiliza en el wrapper de queued.reject (para cola)
+            // o via re-encolado en typeCheck() catch (para tareas directas).
             task.reject(new Error(`Worker ${poolWorker.id} exited with code ${code}`));
         });
         poolWorker.pendingTasks.clear();
@@ -513,6 +551,8 @@ export class TypeScriptWorkerPool {
             if (index !== -1) {
                 this.workers[index] = newWorker;
             }
+            // Drenar la cola con el nuevo worker listo
+            setImmediate(() => this.drainQueue(newWorker));
         }
         catch (error) {
             console.error(`[WorkerPool] Error reciclando worker ${poolWorker.id}:`, error);
@@ -543,6 +583,48 @@ export class TypeScriptWorkerPool {
         }
         return null; // Todos los workers están muy ocupados
     }
+    /**
+     * Drena la cola en todos los workers disponibles
+     */
+    drainAllWorkers() {
+        for (const worker of this.workers) {
+            if (!worker.busy && worker.pendingTasks.size === 0) {
+                this.drainQueue(worker);
+                if (this.taskQueue.length === 0)
+                    break;
+            }
+        }
+    }
+    /**
+     * Procesa la siguiente tarea de la cola en el worker liberado
+     */
+    drainQueue(poolWorker) {
+        if (this.taskQueue.length === 0)
+            return;
+        if (poolWorker.busy || poolWorker.pendingTasks.size > 0)
+            return;
+        // Si el worker alcanzó el límite de tareas, reciclarlo y luego drenar
+        if (poolWorker.taskCounter >= this.MAX_TASKS_PER_WORKER) {
+            this.recycleWorker(poolWorker)
+                .then(() => setImmediate(() => this.drainAllWorkers()))
+                .catch(() => { });
+            return;
+        }
+        const queued = this.taskQueue.shift();
+        if (!queued)
+            return;
+        const waitMs = Date.now() - queued.queuedAt;
+        if (waitMs > 30000) {
+            // queued.reject incluye failedTasks++ en el wrapper (ver typeCheck())
+            queued.reject(new Error(`Queue task expired after ${waitMs}ms`));
+            // Continuar drenando la cola con la siguiente tarea
+            setImmediate(() => this.drainQueue(poolWorker));
+            return;
+        }
+        this.typeCheckWithWorker(poolWorker, queued.fileName, queued.content, queued.compilerOptions)
+            .then(queued.resolve)
+            .catch(queued.reject); // queued.reject incluye failedTasks++ en el wrapper
+    }
     /**
      * Realiza type checking usando el pool de workers
      */
@@ -550,31 +632,61 @@ export class TypeScriptWorkerPool {
         // Asegurar que el pool esté inicializado
         await this.initializePool();
         if (!this.isInitialized) {
+            // Solo usar fallback síncrono si el pool no pudo inicializarse del todo
             return this.typeCheckWithSyncFallback(fileName, content, compilerOptions);
         }
+        this.totalTasks++;
         // Buscar worker disponible
         const availableWorker = this.findAvailableWorker();
-        // ✨ FIX: Incrementar totalTasks ANTES del try/catch para conteo correcto
-        this.totalTasks++;
-        if (!availableWorker) {
-            return this.typeCheckWithSyncFallback(fileName, content, compilerOptions);
-        }
-        try {
-            return await this.typeCheckWithWorker(availableWorker, fileName, content, compilerOptions);
+        if (availableWorker) {
+            try {
+                return await this.typeCheckWithWorker(availableWorker, fileName, content, compilerOptions);
+            }
+            catch {
+                // Worker falló o llegó al límite de tareas
+                // Si alcanzó el límite, disparar reciclaje inmediato
+                if (availableWorker.taskCounter >= this.MAX_TASKS_PER_WORKER) {
+                    this.recycleWorker(availableWorker)
+                        .then(() => setImmediate(() => this.drainAllWorkers()))
+                        .catch(() => { });
+                }
+            }
         }
-        catch {
-            return this.typeCheckWithSyncFallback(fileName, content, compilerOptions);
+        // Ningún worker disponible: encolar la tarea
+        if (this.taskQueue.length >= this.MAX_QUEUE_SIZE) {
+            // Cola llena → omitir type check para no bloquear el event loop
+            // (con MAX_QUEUE_SIZE=1000 esto solo ocurre en proyectos extremadamente grandes)
+            console.warn(`[TypeCheckQueue] Cola llena (${this.MAX_QUEUE_SIZE} tareas). Type check omitido para: ${path.basename(fileName)}`);
+            this.completedTasks++; // Contabilizar como completado para mantener métricas consistentes
+            return { diagnostics: [], hasErrors: false };
         }
+        // Escalar el pool si es posible
+        this.ensureWorkerCapacity().catch(() => { });
+        return new Promise((resolve, reject) => {
+            // Wrapper para reject que garantiza que failedTasks se incrementa exactamente una vez
+            // para todas las tareas que pasan por la cola (drainQueue path).
+            const wrappedReject = (err) => {
+                this.failedTasks++;
+                reject(err);
+            };
+            this.taskQueue.push({
+                fileName,
+                content,
+                compilerOptions,
+                resolve,
+                reject: wrappedReject,
+                queuedAt: Date.now(),
+            });
+        });
     }
     /**
      * Realiza type checking usando un worker específico con reciclaje automático
      * ✨ FIX MEMORIA: Optimizado para prevenir fugas de memoria
      */
     async typeCheckWithWorker(poolWorker, fileName, content, compilerOptions) {
-        // Verificar si el worker necesita reciclaje por número de tareas
+        // Si el worker alcanzó su límite de tareas, encolar para reciclaje
         if (poolWorker.taskCounter >= this.MAX_TASKS_PER_WORKER) {
-            // ✨ FIX: No esperar el reciclaje, usar fallback
-            return this.typeCheckWithSyncFallback(fileName, content, compilerOptions);
+            throw new Error(`Worker ${poolWorker.id} ha alcanzado el límite de tareas`);
         }
         return new Promise((resolve, reject) => {
             const taskId = `task-${poolWorker.id}-${++poolWorker.taskCounter}-${Date.now()}`;
@@ -593,6 +705,8 @@ export class TypeScriptWorkerPool {
                         poolWorker.busy = false;
                     }
                     reject(new Error(`Timeout (${dynamicTimeout}ms) en type checking para ${fileName}`));
+                    // Drenar la cola cuando se libera la tarea por timeout
+                    setImmediate(() => this.drainQueue(poolWorker));
                 }
             }, dynamicTimeout);
             // ✨ FIX MEMORIA: Wrapper para resolver/rechazar que limpia el timeout
@@ -697,7 +811,7 @@ export class TypeScriptWorkerPool {
         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
+        return Math.min(finalTimeout, 120000); // Máximo absoluto de 120 segundos
     }
     /**
      * Fallback síncrono para type checking
@@ -725,6 +839,11 @@ export class TypeScriptWorkerPool {
         console.log('[WorkerPool] Cerrando pool de workers...');
         // 0. ✨ FIX #1: Detener monitoreo de memoria primero
         this.stopMemoryMonitoring();
+        // 0b. Rechazar todas las tareas en cola
+        for (const queued of this.taskQueue) {
+            queued.reject(new Error('Worker pool cerrado'));
+        }
+        this.taskQueue = [];
         // 1. Rechazar todas las tareas pendientes con cleanup
         let totalPendingTasks = 0;
         for (const poolWorker of this.workers) {