versacompiler 2.3.4 → 2.4.0

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',
@@ -121,7 +121,13 @@ async function main() {
         description: 'Habilitar/Deshabilitar la verificación de tipos. Por defecto --typeCheck=false',
         default: false,
     })
-        .alias('t', 'typeCheck');
+        .alias('t', 'typeCheck')
+        .option('checkIntegrity', {
+        type: 'boolean',
+        description: 'Validar la integridad del código compilado (para builds de deploy). Por defecto --checkIntegrity=false',
+        default: false,
+    })
+        .alias('ci', 'checkIntegrity');
     // Definir la opción tailwind dinámicamente
     // Asumiendo que env.TAILWIND es una cadena que podría ser 'true', 'false', o undefined
     if (env.tailwindcss !== 'false') {
@@ -141,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,
@@ -177,7 +183,8 @@ async function main() {
         env.TAILWIND =
             argv.tailwind === undefined ? 'true' : String(argv.tailwind);
         env.ENABLE_LINTER = String(argv.linter);
-        env.VERBOSE = argv.verbose ? 'true' : 'false'; // 🎯 Configuración moderna y organizada
+        env.VERBOSE = argv.verbose ? 'true' : 'false';
+        env.CHECK_INTEGRITY = argv.checkIntegrity ? 'true' : 'false'; // 🎯 Configuración moderna y organizada
         logger.info(chalk.bold.blue('⚙️  Configuración'));
         logger.info(chalk.gray('   ┌─ Modo de ejecución'));
         const modes = [
@@ -199,6 +206,11 @@ async function main() {
                 icon: '🔍',
             },
             { label: 'Verificar tipos', value: argv.typeCheck, icon: '📘' },
+            {
+                label: 'Validar integridad',
+                value: argv.checkIntegrity,
+                icon: '🛡️',
+            },
             { label: 'Detallado', value: env.VERBOSE === 'true', icon: '📝' },
         ];
         modes.forEach(mode => {

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);
@@ -108,7 +113,8 @@ export function validateConfigStructure(config) {
         logger.error('compilerOptions es requerido y debe ser un objeto');
         return false;
     }
-    if (!config.compilerOptions.pathsAlias || typeof config.compilerOptions.pathsAlias !== 'object') {
+    if (!config.compilerOptions.pathsAlias ||
+        typeof config.compilerOptions.pathsAlias !== 'object') {
         logger.error('pathsAlias es requerido y debe ser un objeto');
         return false;
     }
@@ -130,11 +136,13 @@ export function validateConfigStructure(config) {
         }
     }
     // Validar sourceRoot si existe
-    if (config.compilerOptions.sourceRoot && !validatePath(config.compilerOptions.sourceRoot)) {
+    if (config.compilerOptions.sourceRoot &&
+        !validatePath(config.compilerOptions.sourceRoot)) {
         return false;
     }
     // Validar outDir si existe
-    if (config.compilerOptions.outDir && !validatePath(config.compilerOptions.outDir)) {
+    if (config.compilerOptions.outDir &&
+        !validatePath(config.compilerOptions.outDir)) {
         return false;
     }
     // Validar linter si existe
@@ -240,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]);
 }
 /**
@@ -306,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, '{}');