versacompiler 2.4.0 → 2.4.1

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

@@ -19,8 +19,8 @@ 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
@@ -28,7 +28,7 @@ export class TypeScriptWorkerPool {
     cleanupInterval = null;
     // Cola de tareas para cuando todos los workers están ocupados
     taskQueue = [];
-    MAX_QUEUE_SIZE = 50;
+    MAX_QUEUE_SIZE = 1000; // Suficiente para proyectos de 300+ archivos
     // Flag para evitar concurrencia en ensureWorkerCapacity
     isScalingUp = false;
     // Métricas de rendimiento
@@ -85,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);
@@ -198,8 +201,8 @@ export class TypeScriptWorkerPool {
         const cpuCount = os.cpus().length;
         switch (mode) {
             case 'batch':
-                // Para modo batch, hasta 3 workers conservando al menos 1 CPU libre
-                this.poolSize = Math.min(3, Math.max(1, cpuCount - 1));
+                // 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, hasta 2 workers para menor impacto en sistema
@@ -376,9 +379,10 @@ export class TypeScriptWorkerPool {
                     });
                 }
                 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);
                 }
@@ -404,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);
         }
@@ -436,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
@@ -451,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();
@@ -543,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);
@@ -573,6 +583,18 @@ 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
      */
@@ -581,19 +603,27 @@ export class TypeScriptWorkerPool {
             return;
         if (poolWorker.busy || poolWorker.pendingTasks.size > 0)
             return;
-        if (poolWorker.taskCounter >= this.MAX_TASKS_PER_WORKER)
+        // 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);
+            .catch(queued.reject); // queued.reject incluye failedTasks++ en el wrapper
     }
     /**
      * Realiza type checking usando el pool de workers
@@ -613,23 +643,38 @@ export class TypeScriptWorkerPool {
                 return await this.typeCheckWithWorker(availableWorker, fileName, content, compilerOptions);
             }
             catch {
-                // Worker falló; intentar encolar
+                // 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(() => { });
+                }
             }
         }
         // Ningún worker disponible: encolar la tarea
         if (this.taskQueue.length >= this.MAX_QUEUE_SIZE) {
-            // Cola llena → fallback síncrono para no perder el type check
-            return this.typeCheckWithSyncFallback(fileName, content, compilerOptions);
+            // 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,
+                reject: wrappedReject,
                 queuedAt: Date.now(),
             });
         });
@@ -639,9 +684,9 @@ export class TypeScriptWorkerPool {
      * ✨ FIX MEMORIA: Optimizado para prevenir fugas de memoria
      */
     async typeCheckWithWorker(poolWorker, fileName, content, compilerOptions) {
-        // Si el worker alcanzó su límite de tareas, usar fallback síncrono
+        // Si el worker alcanzó su límite de tareas, encolar para reciclaje
         if (poolWorker.taskCounter >= this.MAX_TASKS_PER_WORKER) {
-            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()}`;
@@ -660,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
@@ -764,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

package/dist/compiler/typescript-worker-thread.cjs

@@ -154,6 +154,38 @@ class WorkerTypeScriptLanguageServiceHost {
     }
 }
 
+/**
+ * Language Service persistente para reusar entre tareas (evita cold-start de 200-500ms por tarea)
+ * Se resetea periódicamente para controlar el uso de memoria
+ */
+let _persistentHost = null;
+let _persistentLS = null;
+let _persistentCompilerOptionsStr = null;
+let _tasksSinceReset = 0;
+const MAX_TASKS_BEFORE_LS_RESET = 50; // Resetear cada 50 tareas para controlar memoria
+
+function getOrResetLanguageService(compilerOptions) {
+    const optionsStr = JSON.stringify(compilerOptions);
+    const needsReset =
+        !_persistentLS ||
+        optionsStr !== _persistentCompilerOptionsStr ||
+        _tasksSinceReset >= MAX_TASKS_BEFORE_LS_RESET;
+
+    if (needsReset) {
+        if (_persistentLS) {
+            try { _persistentLS.dispose(); } catch { /* ignore */ }
+            _persistentLS = null;
+        }
+        _persistentHost = new WorkerTypeScriptLanguageServiceHost(compilerOptions);
+        _persistentLS = ts.createLanguageService(_persistentHost);
+        _persistentCompilerOptionsStr = optionsStr;
+        _tasksSinceReset = 0;
+    }
+
+    _tasksSinceReset++;
+    return { host: _persistentHost, ls: _persistentLS };
+}
+
 /**
  * Realiza validación de tipos en el worker thread
  */
@@ -167,30 +199,16 @@ function validateTypesInWorker(fileName, content, compilerOptions) {
             return { diagnostics: [], hasErrors: false };
         }
 
-        // Crear Language Service Host
-        const host = new WorkerTypeScriptLanguageServiceHost(compilerOptions); // Para archivos Vue, crear un archivo virtual .ts
+        // Obtener o crear Language Service persistente (rápido después del primer uso)
+        const { host, ls: languageService } = getOrResetLanguageService(compilerOptions);
+
+        // Para archivos Vue, crear un archivo virtual .ts
         if (fileName.endsWith('.vue')) {
-            // Crear un nombre de archivo virtual único
             const virtualFileName = `${fileName}.ts`;
             host.addFile(virtualFileName, scriptContent);
             actualFileName = virtualFileName;
-            // console.log('[Worker] Archivo Vue agregado como:', virtualFileName);
-        } else {
-            // Para archivos virtuales, usar el nombre tal como viene
-            host.addFile(fileName, scriptContent);
-            actualFileName = fileName;
-            // console.log('[Worker] Archivo agregado como:', fileName);
-        }
-
-        // console.log(
-        //     '[Worker] Contenido del archivo:',
-        //     scriptContent.substring(0, 100) + '...',
-        // );
-        // console.log('[Worker] Archivos en host:', host.getScriptFileNames());
 
-        // Agregar declaraciones básicas de tipos para Vue si es necesario
-        if (fileName.endsWith('.vue')) {
-            // Usar el directorio del archivo actual para las declaraciones
+            // Agregar declaraciones de tipos Vue si es necesario
             const projectDir = path.dirname(actualFileName);
             const vueTypesPath = path.join(projectDir, 'vue-types.d.ts');
             const vueTypesDeclaration = `// Declaraciones de tipos Vue para validación
@@ -214,10 +232,27 @@ function validateTypesInWorker(fileName, content, compilerOptions) {
                 }
                 export {};`;
             host.addFile(vueTypesPath, vueTypesDeclaration);
-        }
 
-        // Crear Language Service
-        const languageService = ts.createLanguageService(host);
+            // Eliminar archivos de tareas anteriores para evitar que el programa crezca.
+            // Se hace DESPUÉS de addFile para que la versión se incremente correctamente
+            // (evita que el LS use resultados cacheados de versiones anteriores).
+            for (const key of host.files.keys()) {
+                if (key !== virtualFileName && key !== vueTypesPath) {
+                    host.files.delete(key);
+                }
+            }
+        } else {
+            host.addFile(fileName, scriptContent);
+            actualFileName = fileName;
+
+            // Eliminar archivos de tareas anteriores para evitar que el programa crezca.
+            // Se hace DESPUÉS de addFile para que la versión se incremente correctamente.
+            for (const key of host.files.keys()) {
+                if (key !== fileName) {
+                    host.files.delete(key);
+                }
+            }
+        }
 
         try {
             // Verificar que el archivo existe en el host antes de solicitar diagnósticos
@@ -225,17 +260,12 @@ function validateTypesInWorker(fileName, content, compilerOptions) {
                 return { diagnostics: [], hasErrors: false };
             }
 
-
             // Obtener diagnósticos de tipos con manejo de errores
             let syntacticDiagnostics = [];
             let semanticDiagnostics = [];
             try {
                 syntacticDiagnostics =
                     languageService.getSyntacticDiagnostics(actualFileName);
-                // console.log(
-                //     '[Worker] Diagnósticos sintácticos:',
-                //     syntacticDiagnostics.length,
-                // );
             } catch (error) {
                 console.error(
                     '[Worker] Error obteniendo diagnósticos sintácticos:',
@@ -246,37 +276,18 @@ function validateTypesInWorker(fileName, content, compilerOptions) {
             try {
                 semanticDiagnostics =
                     languageService.getSemanticDiagnostics(actualFileName);
-                // console.log(
-                //     '[Worker] Diagnósticos semánticos:',
-                //     semanticDiagnostics.length,
-                // );
             } catch (error) {
                 console.error(
                     '[Worker] Error obteniendo diagnósticos semánticos:',
                     error.message,
                 );
-            } // Combinar todos los diagnósticos
+            }
+
             const allDiagnostics = [
                 ...syntacticDiagnostics,
                 ...semanticDiagnostics,
             ];
 
-            // console.log(
-            //     '[Worker] Total diagnósticos encontrados:',
-            //     allDiagnostics.length,
-            // );
-
-            // Log de todos los diagnósticos antes del filtrado
-            // allDiagnostics.forEach((diag, index) => {
-            //     const messageText = ts.flattenDiagnosticMessageText(
-            //         diag.messageText,
-            //         '\n',
-            //     );
-            //     console.log(
-            //         `[Worker] Diagnóstico ${index + 1}: [${diag.category}] ${messageText}`,
-            //     );
-            // });
-
             // Filtrar diagnósticos relevantes
             const filteredDiagnostics = allDiagnostics.filter(diag => {
                 const messageText = ts.flattenDiagnosticMessageText(
@@ -287,7 +298,9 @@ function validateTypesInWorker(fileName, content, compilerOptions) {
                 // Solo errores de categoría Error
                 if (diag.category !== ts.DiagnosticCategory.Error) {
                     return false;
-                } // Ignorar SOLO errores específicos de infraestructura Vue y rutas de módulos
+                }
+
+                // Ignorar errores de infraestructura Vue y rutas de módulos
                 return (
                     !messageText.includes('Cannot find module') &&
                     !messageText.includes('Could not find source file') &&
@@ -315,17 +328,12 @@ function validateTypesInWorker(fileName, content, compilerOptions) {
                     !messageText.includes(
                         "Parameter '_cache' implicitly has an 'any' type",
                     ) &&
-                    // Ignorar errores específicos de decorators cuando están mal configurados
                     !messageText.includes(
                         'Unable to resolve signature of method decorator when called as an expression',
                     ) &&
                     !messageText.includes(
                         'The runtime will invoke the decorator with',
                     ) &&
-                    // NO ignorar errores TS7031 y TS7006 de forma general, solo para parámetros específicos de Vue
-                    // diag.code !== 7031 &&
-                    // diag.code !== 7006 &&
-                    // Ignorar errores TS1241 (decorator signature mismatch) durante desarrollo
                     diag.code !== 1241 &&
                     !(
                         messageText.includes("implicitly has an 'any' type") &&
@@ -345,8 +353,6 @@ function validateTypesInWorker(fileName, content, compilerOptions) {
             };
         } 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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "versacompiler",
-    "version": "2.4.0",
+    "version": "2.4.1",
     "description": "Una herramienta para compilar y minificar archivos .vue, .js y .ts para proyectos de Vue 3 con soporte para TypeScript.",
     "main": "dist/main.js",
     "bin": {
@@ -21,7 +21,7 @@
         "build": "tsx src/main.ts --all -t --cc --co -y --verbose",
         "compileDev": "tsx src/main.ts --all --ci --cc -y -t --linter --verbose",
         "vlint": "tsx src/main.ts --all --cc --co -y --linter",
-        "vtlint": "tsx src/main.ts --all --cc --co -y -t",
+        "vtlint": "tsx src/main.ts --all --cc --co -y -t --verbose",
         "test": "vitest run",
         "test:watch": "vitest",
         "test:ui": "vitest --ui",