versacompiler 2.3.5 → 2.4.0

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

@@ -26,15 +26,20 @@ export class TypeScriptWorkerPool {
     // ✨ 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 = 50;
+    // 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();
     }
@@ -190,19 +195,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 3 workers conservando al menos 1 CPU libre
+                this.poolSize = Math.min(3, 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 +232,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 +242,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,8 +367,9 @@ 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;
                         }
@@ -543,6 +573,28 @@ export class TypeScriptWorkerPool {
         }
         return null; // Todos los workers están muy ocupados
     }
+    /**
+     * 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;
+        if (poolWorker.taskCounter >= this.MAX_TASKS_PER_WORKER)
+            return;
+        const queued = this.taskQueue.shift();
+        if (!queued)
+            return;
+        const waitMs = Date.now() - queued.queuedAt;
+        if (waitMs > 30000) {
+            queued.reject(new Error(`Queue task expired after ${waitMs}ms`));
+            return;
+        }
+        this.typeCheckWithWorker(poolWorker, queued.fileName, queued.content, queued.compilerOptions)
+            .then(queued.resolve)
+            .catch(queued.reject);
+    }
     /**
      * Realiza type checking usando el pool de workers
      */
@@ -550,30 +602,45 @@ 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ó; intentar encolar
+            }
         }
-        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);
         }
+        // Escalar el pool si es posible
+        this.ensureWorkerCapacity().catch(() => { });
+        return new Promise((resolve, reject) => {
+            this.taskQueue.push({
+                fileName,
+                content,
+                compilerOptions,
+                resolve,
+                reject,
+                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, usar fallback síncrono
         if (poolWorker.taskCounter >= this.MAX_TASKS_PER_WORKER) {
-            // ✨ FIX: No esperar el reciclaje, usar fallback
             return this.typeCheckWithSyncFallback(fileName, content, compilerOptions);
         }
         return new Promise((resolve, reject) => {
@@ -725,6 +792,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) {

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

@@ -128,19 +128,19 @@ class WorkerTypeScriptLanguageServiceHost {
         return ts.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;
             }
@@ -225,6 +225,7 @@ function validateTypesInWorker(fileName, content, compilerOptions) {
                 return { diagnostics: [], hasErrors: false };
             }
 
+
             // Obtener diagnósticos de tipos con manejo de errores
             let syntacticDiagnostics = [];
             let semanticDiagnostics = [];
@@ -344,6 +345,8 @@ 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/dist/compiler/vuejs.js

@@ -91,16 +91,22 @@ class VueHMRInjectionCache {
         };
     }
     /**
-     * Limpia entradas de cache cuando se excede el límite
+     * Limpia entradas de cache cuando se excede el límite (O(n) en lugar de O(n log n))
      */
     evictIfNeeded() {
         if (this.cache.size <= this.MAX_CACHE_SIZE)
             return;
-        const entries = Array.from(this.cache.entries());
-        entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
-        // Eliminar las entradas más antiguas
-        const toDelete = entries.slice(0, entries.length - this.MAX_CACHE_SIZE);
-        toDelete.forEach(([key]) => this.cache.delete(key));
+        // Eliminar la entrada más antigua con un solo barrido O(n)
+        let oldestKey = '';
+        let oldestTime = Infinity;
+        for (const [key, entry] of this.cache) {
+            if (entry.timestamp < oldestTime) {
+                oldestTime = entry.timestamp;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey)
+            this.cache.delete(oldestKey);
     }
     /**
      * Limpia entradas expiradas

package/dist/hrm/initHRM.js

@@ -213,7 +213,7 @@ export async function handleLibraryHotReload(
         ) {
             try {
                 newLibraryVersion.clearCache();
-            } catch (_e) {
+            } catch {
                 // Ignorar errores de clearCache, no es crítico
             }
         }
@@ -238,7 +238,7 @@ export async function handleLibraryHotReload(
             ) {
                 window.performance.clearResourceTimings();
             }
-        } catch (_e) {
+        } catch {
             // Ignorar errores de limpieza de cache
         }
 

package/dist/main.js

@@ -63,10 +63,10 @@ function stopCompile() {
 async function main() {
     // Load yargs dynamically
     const { yargs: yargsInstance, hideBin: hideBinFn } = await loadYargs();
-    const chalk = await loadChalk();
+    const chalkInstance = await loadChalk();
     let yargInstance = yargsInstance(hideBinFn(globalProcess.argv))
         .scriptName('versa')
-        .usage(chalk.blue('VersaCompiler') + ' - Compilador de archivos Vue/TS/JS')
+        .usage(chalkInstance.blue('VersaCompiler') + ' - Compilador de archivos Vue/TS/JS')
         .option('init', {
         type: 'boolean',
         description: 'Inicializar la configuración',
@@ -147,8 +147,8 @@ async function main() {
     const argv = (await yargInstance
         .help()
         .alias('h', 'help')
-        .command('* [files...]', 'Compilar archivos específicos', (yargs) => {
-        return yargs.positional('files', {
+        .command('* [files...]', 'Compilar archivos específicos', (yargsCmd) => {
+        return yargsCmd.positional('files', {
             describe: 'Archivos para compilar',
             type: 'string',
             array: true,

package/dist/servicios/file-watcher.js

@@ -4,7 +4,7 @@ import * as process from 'node:process';
 const { env } = process;
 import * as chokidar from 'chokidar';
 import { minimatch } from 'minimatch';
-import { getOutputPath, initCompile, normalizeRuta } from '../compiler/compile.js';
+import { clearCompilationState, getOutputPath, initCompile, normalizeRuta } from '../compiler/compile.js';
 import { promptUser } from '../utils/promptUser.js';
 import { emitirCambios } from './browserSync.js';
 import { logger } from './logger.js';
@@ -76,6 +76,8 @@ class WatchDebouncer {
         if (this.isProcessing || this.pendingChanges.size === 0) {
             return;
         }
+        // Limpiar errores del ciclo anterior para evitar memory leak en watch mode
+        clearCompilationState();
         this.isProcessing = true;
         const changes = Array.from(this.pendingChanges.values());
         this.pendingChanges.clear();

package/dist/servicios/readConfig.js

@@ -24,6 +24,11 @@ export function validatePath(pathStr) {
         logger.warn(`Ruta demasiado larga: ${pathStr.length} caracteres`);
         return false;
     }
+    // Rechazar rutas absolutas de Windows (válido en cualquier plataforma)
+    if (/^[A-Za-z]:[\\\/]/.test(pathStr)) {
+        logger.error(`Ruta absoluta de Windows no permitida: ${pathStr}`);
+        return false;
+    }
     // Normalizar la ruta para detectar path traversal
     const normalizedPath = normalize(pathStr);
     const resolvedPath = resolve(process.cwd(), normalizedPath);
@@ -243,7 +248,7 @@ export async function dynamicImport(url) {
  * Timeout wrapper para promises
  */
 export function withTimeout(promise, timeoutMs, errorMessage) {
-    const timeoutPromise = new Promise((resolve, reject) => setTimeout(() => reject(new Error(errorMessage)), timeoutMs));
+    const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(errorMessage)), timeoutMs));
     return Promise.race([promise, timeoutPromise]);
 }
 /**
@@ -309,6 +314,11 @@ export async function readConfig() {
         env.PATH_DIST = outDir;
         env.aditionalWatch = safeJsonStringify(tsConfig?.aditionalWatch, '[]');
         env.bundlers = safeJsonStringify(tsConfig?.bundlers, 'false');
+        // Configurar número máximo de workers para type checking
+        if (tsConfig?.typeCheckOptions?.maxWorkers) {
+            const maxWorkers = Math.max(1, Math.min(8, Number(tsConfig.typeCheckOptions.maxWorkers)));
+            env.TS_MAX_WORKERS = String(maxWorkers);
+        }
         // Configuración adicional para compatibilidad
         if (!tsConfig.compilerOptions.sourceRoot) {
             env.tsConfig = safeJsonStringify(tsConfig, '{}');