versacompiler 2.0.0 → 2.0.1

package/dist/compiler/compile.js

@@ -1,7 +1,8 @@
+import { createHash } from 'node:crypto';
 import { glob, mkdir, readFile, stat, unlink, writeFile, } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { env } from 'node:process';
+import { cwd, env, stdout } from 'node:process';
 // Lazy loading optimizations - Only import lightweight modules synchronously
 import { logger } from '../servicios/logger.js';
 import { promptUser } from '../utils/promptUser.js';
@@ -16,157 +17,267 @@ let generateTailwindCSS;
 let estandarizaCode;
 let preCompileTS;
 let preCompileVue;
-// 🚀 Sistema de Carga Inteligente de Módulos - VERSIÓN OPTIMIZADA
-class ModuleManager {
+// 🚀 Importar optimizador de transformaciones
+let TransformOptimizer;
+// 🚀 Importar optimizador de resolución de módulos
+let ModuleResolutionOptimizer;
+// 🚀 Sistema de Carga Inteligente de Módulos - VERSIÓN OPTIMIZADA V2
+class OptimizedModuleManager {
     static instance;
     isInitialized = false;
-    initializationPromise = null;
     loadedModules = new Set();
-    // NUEVOS: Gestión de modo y precarga
-    currentMode = null;
-    preloadPromises = new Map();
-    moduleCache = new Map();
-    constructor() { }
+    // ✨ NUEVAS OPTIMIZACIONES
+    modulePool = new Map(); // Pool de instancias reutilizables
+    loadingPromises = new Map(); // Prevenir cargas duplicadas
+    usageStats = new Map(); // Estadísticas de uso
+    preloadQueue = new Set(); // Cola de precarga
+    backgroundLoader = null; // Cargador en background
+    // Módulos críticos que siempre se precargan
+    HOT_MODULES = ['chalk', 'parser'];
+    // Contexto actual para optimizar cargas
+    currentContext = null;
+    constructor() {
+        // Iniciar precarga en background inmediatamente
+        this.startBackgroundPreloading();
+    }
     static getInstance() {
-        if (!ModuleManager.instance) {
-            ModuleManager.instance = new ModuleManager();
+        if (!OptimizedModuleManager.instance) {
+            OptimizedModuleManager.instance = new OptimizedModuleManager();
         }
-        return ModuleManager.instance;
+        return OptimizedModuleManager.instance;
     }
     /**
-     * NUEVO: Precarga estratégica para modo watch
+     * ✨ NUEVO: Precarga en background para módulos críticos
      */
-    async preloadForWatchMode() {
-        const essentialModules = ['chalk', 'parser', 'transforms'];
-        const preloadPromises = essentialModules.map(async (moduleName) => {
-            if (!this.loadedModules.has(moduleName)) {
-                switch (moduleName) {
-                    case 'chalk':
-                        return this._loadModule('chalk', loadChalk);
-                    case 'parser':
-                        return this._loadModule('parser', loadParser);
-                    case 'transforms':
-                        return this._loadModule('transforms', loadTransforms);
-                }
-            }
-        });
-        await Promise.all(preloadPromises);
-        // console.log('[ModuleManager] Precarga completada para modo watch');
-    } /**
-     * MEJORADO: Inicializa los módulos necesarios según el contexto de compilación
-     * @param context Contexto de compilación: 'individual', 'batch', 'watch'
-     * @param fileExtensions Extensiones de archivos a compilar para optimizar la carga
+    startBackgroundPreloading() {
+        this.backgroundLoader = this.preloadCriticalModules();
+    }
+    /**
+     * ✨ NUEVO: Precarga módulos críticos en background
      */
-    async initializeModules(context = 'individual', fileExtensions = new Set()) {
-        // Si cambia el contexto, reinicializar
-        if (this.currentMode !== context) {
-            this.currentMode = context;
-            // En modo watch, precargar módulos esenciales
-            if (context === 'watch') {
-                await this.preloadForWatchMode();
-            }
+    async preloadCriticalModules() {
+        try {
+            // Precargar módulos críticos de forma asíncrona
+            const preloadPromises = this.HOT_MODULES.map(moduleName => this.ensureModuleLoaded(moduleName).catch(() => {
+                // Silenciar errores de precarga, se intentará cargar después
+            }));
+            await Promise.allSettled(preloadPromises);
         }
-        if (this.initializationPromise) {
-            return this.initializationPromise;
+        catch {
+            // Fallos en precarga no deben afectar la funcionalidad principal
         }
-        if (this.isInitialized && context !== 'individual') {
-            return;
-        }
-        this.initializationPromise = this._performInitialization(context, fileExtensions);
-        await this.initializationPromise;
-        this.initializationPromise = null;
     }
-    async _performInitialization(context, fileExtensions) {
-        const modulesToLoad = [];
-        // Módulos siempre necesarios
-        if (!this.loadedModules.has('chalk')) {
-            modulesToLoad.push(this._loadModule('chalk', loadChalk));
-        }
-        if (!this.loadedModules.has('parser')) {
-            modulesToLoad.push(this._loadModule('parser', loadParser));
-        }
-        if (!this.loadedModules.has('transforms')) {
-            modulesToLoad.push(this._loadModule('transforms', loadTransforms));
+    /**
+     * ✨ MEJORADO: Precarga contextual basada en tipos de archivo
+     */
+    async preloadForContext(context, fileTypes = new Set()) {
+        this.currentContext = context;
+        // Esperar que termine la precarga crítica si está en progreso
+        if (this.backgroundLoader) {
+            await this.backgroundLoader;
         }
-        // Carga contextual según el tipo de compilación
+        const toPreload = []; // Precarga basada en contexto
         if (context === 'batch' || context === 'watch') {
-            // En modo batch/watch, precargar todos los módulos necesarios
-            if (!this.loadedModules.has('vue')) {
-                modulesToLoad.push(this._loadModule('vue', loadVue));
-            }
-            if (!this.loadedModules.has('typescript')) {
-                modulesToLoad.push(this._loadModule('typescript', loadTypeScript));
-            }
-            if (!this.loadedModules.has('minify')) {
-                modulesToLoad.push(this._loadModule('minify', loadMinify));
-            }
+            // En batch/watch, precargar todos los módulos comunes
+            toPreload.push('transforms', 'vue', 'typescript', 'module-resolution-optimizer');
         }
         else {
-            // En modo individual, cargar solo según las extensiones necesarias
-            if (fileExtensions.has('.vue') && !this.loadedModules.has('vue')) {
-                modulesToLoad.push(this._loadModule('vue', loadVue));
-            }
-            if ((fileExtensions.has('.ts') || fileExtensions.has('.vue')) &&
-                !this.loadedModules.has('typescript')) {
-                modulesToLoad.push(this._loadModule('typescript', loadTypeScript));
-            }
-            if (env.isPROD === 'true' && !this.loadedModules.has('minify')) {
-                modulesToLoad.push(this._loadModule('minify', loadMinify));
-            }
-        }
-        // Cargar módulos en paralelo
-        await Promise.all(modulesToLoad);
-        this.isInitialized = true;
-    }
-    async _loadModule(name, loadFunction) {
-        if (!this.loadedModules.has(name)) {
-            await loadFunction();
-            this.loadedModules.add(name);
+            // En individual, cargar solo según tipos de archivo detectados
+            if (fileTypes.has('.vue'))
+                toPreload.push('vue');
+            if (fileTypes.has('.ts') || fileTypes.has('.vue'))
+                toPreload.push('typescript');
+            if (!this.loadedModules.has('transforms'))
+                toPreload.push('transforms');
         }
+        // Precargar en paralelo
+        const preloadPromises = toPreload.map(moduleName => this.ensureModuleLoaded(moduleName).catch(() => {
+            // Log warning pero no fallar
+            console.warn(`Warning: No se pudo precargar módulo ${moduleName}`);
+        }));
+        await Promise.allSettled(preloadPromises);
     }
     /**
-     * Carga un módulo específico bajo demanda (lazy loading)
+     * ✨ MEJORADO: Carga inteligente con pooling y deduplicación
      */
     async ensureModuleLoaded(moduleName) {
-        if (this.loadedModules.has(moduleName)) {
-            return;
+        // 1. Verificar pool de módulos primero
+        if (this.modulePool.has(moduleName)) {
+            this.updateUsageStats(moduleName);
+            return this.modulePool.get(moduleName);
         }
+        // 2. Verificar si ya está cargando (deduplicación)
+        if (this.loadingPromises.has(moduleName)) {
+            return this.loadingPromises.get(moduleName);
+        }
+        // 3. Iniciar carga
+        const loadPromise = this.loadModuleInternal(moduleName);
+        this.loadingPromises.set(moduleName, loadPromise);
+        try {
+            const moduleInstance = await loadPromise;
+            // 4. Almacenar en pool y estadísticas
+            this.modulePool.set(moduleName, moduleInstance);
+            this.loadedModules.add(moduleName);
+            this.updateUsageStats(moduleName);
+            return moduleInstance;
+        }
+        finally {
+            // 5. Limpiar promesa de carga
+            this.loadingPromises.delete(moduleName);
+        }
+    }
+    /**
+     * ✨ NUEVO: Actualiza estadísticas de uso para optimizaciones futuras
+     */
+    updateUsageStats(moduleName) {
+        const currentCount = this.usageStats.get(moduleName) || 0;
+        this.usageStats.set(moduleName, currentCount + 1);
+    }
+    /**
+     * ✨ MEJORADO: Carga interna de módulos con mejor manejo de errores
+     */ async loadModuleInternal(moduleName) {
         switch (moduleName) {
+            case 'chalk':
+                return this.loadChalk();
+            case 'parser':
+                return this.loadParser();
+            case 'transforms':
+                return this.loadTransforms();
             case 'vue':
-                await this._loadModule('vue', loadVue);
-                break;
+                return this.loadVue();
             case 'typescript':
-                await this._loadModule('typescript', loadTypeScript);
-                break;
+                return this.loadTypeScript();
             case 'minify':
-                await this._loadModule('minify', loadMinify);
-                break;
+                return this.loadMinify();
             case 'tailwind':
-                await this._loadModule('tailwind', loadTailwind);
-                break;
+                return this.loadTailwind();
             case 'linter':
-                await this._loadModule('linter', loadLinter);
-                break;
+                return this.loadLinter();
+            case 'transform-optimizer':
+                return this.loadTransformOptimizer();
+            case 'module-resolution-optimizer':
+                return this.loadModuleResolutionOptimizer();
             default:
                 throw new Error(`Módulo desconocido: ${moduleName}`);
         }
     }
+    // ✨ Métodos de carga específicos optimizados
+    async loadChalk() {
+        if (!chalk) {
+            chalk = (await import('chalk')).default;
+        }
+        return chalk;
+    }
+    async loadParser() {
+        if (!getCodeFile) {
+            const parserModule = await import('./parser.js');
+            getCodeFile = parserModule.getCodeFile;
+        }
+        return getCodeFile;
+    }
+    async loadTransforms() {
+        if (!estandarizaCode) {
+            const transformsModule = await import('./transforms.js');
+            estandarizaCode = transformsModule.estandarizaCode;
+        }
+        return estandarizaCode;
+    }
+    async loadVue() {
+        if (!preCompileVue) {
+            const vueModule = await import('./vuejs.js');
+            preCompileVue = vueModule.preCompileVue;
+        }
+        return preCompileVue;
+    }
+    async loadTypeScript() {
+        if (!preCompileTS) {
+            const typescriptModule = await import('./typescript-manager.js');
+            preCompileTS = typescriptModule.preCompileTS;
+        }
+        return preCompileTS;
+    }
+    async loadMinify() {
+        if (!minifyJS) {
+            const minifyModule = await import('./minify.js');
+            minifyJS = minifyModule.minifyJS;
+        }
+        return minifyJS;
+    }
+    async loadTailwind() {
+        if (!generateTailwindCSS) {
+            const tailwindModule = await import('./tailwindcss.js');
+            generateTailwindCSS = tailwindModule.generateTailwindCSS;
+        }
+        return generateTailwindCSS;
+    }
+    async loadLinter() {
+        if (!ESLint || !OxLint) {
+            const linterModule = await import('./linter.js');
+            ESLint = linterModule.ESLint;
+            OxLint = linterModule.OxLint;
+        }
+        return { ESLint, OxLint };
+    }
+    async loadTransformOptimizer() {
+        if (!TransformOptimizer) {
+            const transformModule = await import('./transform-optimizer.js');
+            TransformOptimizer =
+                transformModule.TransformOptimizer.getInstance();
+        }
+        return TransformOptimizer;
+    }
+    async loadModuleResolutionOptimizer() {
+        if (!ModuleResolutionOptimizer) {
+            const resolutionModule = await import('./module-resolution-optimizer.js');
+            ModuleResolutionOptimizer =
+                resolutionModule.ModuleResolutionOptimizer.getInstance();
+        }
+        return ModuleResolutionOptimizer;
+    }
+    /**
+     * ✨ NUEVO: Obtiene estadísticas de performance del manager
+     */
+    getPerformanceStats() {
+        const sortedByUsage = Array.from(this.usageStats.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5)
+            .map(([name]) => name);
+        return {
+            loadedModules: Array.from(this.loadedModules),
+            usageStats: Object.fromEntries(this.usageStats),
+            poolSize: this.modulePool.size,
+            loadingInProgress: Array.from(this.loadingPromises.keys()),
+            mostUsedModules: sortedByUsage,
+        };
+    }
+    /**
+     * ✨ NUEVO: Limpia módulos no utilizados para liberar memoria
+     */
+    cleanupUnusedModules() {
+        const threshold = 1; // Mínimo de usos para mantener en pool
+        for (const [moduleName, usageCount] of this.usageStats) {
+            if (usageCount < threshold &&
+                !this.HOT_MODULES.includes(moduleName)) {
+                this.modulePool.delete(moduleName);
+                this.loadedModules.delete(moduleName);
+                this.usageStats.delete(moduleName);
+            }
+        }
+    }
     /**
      * Resetea el estado del manager (útil para tests)
      */
     reset() {
         this.isInitialized = false;
-        this.initializationPromise = null;
         this.loadedModules.clear();
-    }
-    /**
-     * Obtiene estadísticas de módulos cargados
-     */
-    getStats() {
-        return {
-            loaded: Array.from(this.loadedModules),
-            initialized: this.isInitialized,
-        };
+        this.modulePool.clear();
+        this.loadingPromises.clear();
+        this.usageStats.clear();
+        this.preloadQueue.clear();
+        this.currentContext = null;
+        this.backgroundLoader = null;
+        // Reiniciar precarga crítica
+        this.startBackgroundPreloading();
     }
 }
 // Lazy loading helper functions
@@ -214,7 +325,7 @@ async function loadTransforms() {
 }
 async function loadTypeScript() {
     if (!preCompileTS) {
-        const typescriptModule = await import('./typescript.js');
+        const typescriptModule = await import('./typescript-manager.js');
         preCompileTS = typescriptModule.preCompileTS;
     }
     return preCompileTS;
@@ -229,40 +340,194 @@ async function loadVue() {
 // Almacenamiento global de errores y resultados
 const compilationErrors = [];
 const compilationResults = [];
-const compilationCache = new Map();
-const CACHE_DIR = path.join(path.resolve(env.PATH_PROY || process.cwd(), 'compiler'), '.cache');
-const CACHE_FILE = path.join(CACHE_DIR, 'versacompile-cache.json');
-async function loadCache() {
-    try {
-        if (env.cleanCache === 'true') {
-            compilationCache.clear();
-            try {
-                await unlink(CACHE_FILE);
+class SmartCompilationCache {
+    cache = new Map();
+    maxEntries = 500; // Máximo archivos en cache
+    maxMemory = 100 * 1024 * 1024; // 100MB límite
+    currentMemoryUsage = 0;
+    /**
+     * Genera hash SHA-256 del contenido del archivo
+     */ async generateContentHash(filePath) {
+        try {
+            const content = await readFile(filePath, 'utf8');
+            return createHash('sha256').update(content).digest('hex');
+        }
+        catch {
+            // Si no se puede leer el archivo, generar hash único basado en la ruta y timestamp
+            const fallback = `${filePath}-${Date.now()}`;
+            return createHash('sha256').update(fallback).digest('hex');
+        }
+    }
+    /**
+     * Verifica si una entrada de cache es válida
+     */
+    async isValid(filePath) {
+        const entry = this.cache.get(filePath);
+        if (!entry)
+            return false;
+        try {
+            // Verificar si el archivo de salida existe
+            await stat(entry.outputPath);
+            // Verificar si el contenido ha cambiado
+            const currentHash = await this.generateContentHash(filePath);
+            if (entry.contentHash !== currentHash) {
+                this.cache.delete(filePath);
+                return false;
             }
-            catch {
-                // Ignorar errores al eliminar el archivo
+            // Verificar tiempo de modificación como backup
+            const stats = await stat(filePath);
+            if (stats.mtimeMs > entry.mtime) {
+                this.cache.delete(filePath);
+                return false;
             }
+            // Actualizar tiempo de uso para LRU
+            entry.lastUsed = Date.now();
+            return true;
         }
-        const cacheData = await readFile(CACHE_FILE, 'utf-8');
-        const parsed = JSON.parse(cacheData);
-        for (const [key, value] of Object.entries(parsed)) {
-            compilationCache.set(key, value);
+        catch {
+            // Si hay error verificando, eliminar del cache
+            this.cache.delete(filePath);
+            return false;
         }
     }
-    catch {
-        // Cache file doesn't exist or is invalid, start fresh
+    /**
+     * Añade una entrada al cache
+     */
+    async set(filePath, outputPath) {
+        try {
+            const stats = await stat(filePath);
+            const contentHash = await this.generateContentHash(filePath);
+            const entry = {
+                contentHash,
+                mtime: stats.mtimeMs,
+                outputPath,
+                lastUsed: Date.now(),
+                size: stats.size,
+            };
+            // Aplicar límites de memoria y entradas antes de agregar
+            this.evictIfNeeded(entry.size);
+            this.cache.set(filePath, entry);
+            this.currentMemoryUsage += entry.size;
+        }
+        catch (error) {
+            // Si hay error, no cachear
+            console.warn(`Warning: No se pudo cachear ${filePath}:`, error);
+        }
     }
-}
-async function saveCache() {
-    try {
-        await mkdir(CACHE_DIR, { recursive: true });
-        const cacheData = Object.fromEntries(compilationCache);
-        await writeFile(CACHE_FILE, JSON.stringify(cacheData, null, 2));
+    /**
+     * Aplica política LRU para liberar espacio
+     */
+    evictIfNeeded(newEntrySize) {
+        // Verificar límite de entradas
+        while (this.cache.size >= this.maxEntries) {
+            this.evictLRU();
+        }
+        // Verificar límite de memoria
+        while (this.currentMemoryUsage + newEntrySize > this.maxMemory &&
+            this.cache.size > 0) {
+            this.evictLRU();
+        }
+    }
+    /**
+     * Elimina la entrada menos recientemente usada
+     */
+    evictLRU() {
+        let oldestKey = '';
+        let oldestTime = Infinity;
+        for (const [key, entry] of this.cache) {
+            if (entry.lastUsed < oldestTime) {
+                oldestTime = entry.lastUsed;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey) {
+            const entry = this.cache.get(oldestKey);
+            if (entry) {
+                this.currentMemoryUsage -= entry.size;
+                this.cache.delete(oldestKey);
+            }
+        }
+    }
+    /**
+     * Carga el cache desde disco
+     */
+    async load(cacheFile) {
+        try {
+            if (env.cleanCache === 'true') {
+                this.cache.clear();
+                this.currentMemoryUsage = 0;
+                try {
+                    await unlink(cacheFile);
+                }
+                catch {
+                    // Ignorar errores al eliminar el archivo
+                }
+                return;
+            }
+            const cacheData = await readFile(cacheFile, 'utf-8');
+            const parsed = JSON.parse(cacheData);
+            // Validar y cargar entradas del cache
+            for (const [key, value] of Object.entries(parsed)) {
+                const entry = value;
+                if (entry.contentHash && entry.outputPath && entry.mtime) {
+                    this.cache.set(key, entry);
+                    this.currentMemoryUsage += entry.size || 0;
+                }
+            }
+        }
+        catch {
+            // Cache file doesn't exist or is invalid, start fresh
+            this.cache.clear();
+            this.currentMemoryUsage = 0;
+        }
     }
-    catch {
-        // Ignore save errors
+    /**
+     * Guarda el cache a disco
+     */
+    async save(cacheFile, cacheDir) {
+        try {
+            await mkdir(cacheDir, { recursive: true });
+            const cacheData = Object.fromEntries(this.cache);
+            await writeFile(cacheFile, JSON.stringify(cacheData, null, 2));
+        }
+        catch (error) {
+            console.warn('Warning: No se pudo guardar el cache:', error);
+        }
+    }
+    /**
+     * Limpia completamente el cache
+     */
+    clear() {
+        this.cache.clear();
+        this.currentMemoryUsage = 0;
+    } /**
+     * Obtiene la ruta de salida para un archivo cacheado
+     */
+    getOutputPath(filePath) {
+        const entry = this.cache.get(filePath);
+        return entry?.outputPath || '';
+    }
+    /**
+     * Obtiene estadísticas del cache
+     */
+    getStats() {
+        return {
+            entries: this.cache.size,
+            memoryUsage: this.currentMemoryUsage,
+            hitRate: 0, // Se calculará externamente
+        };
     }
 }
+// Instancia global del cache inteligente
+const smartCache = new SmartCompilationCache();
+const CACHE_DIR = path.join(path.resolve(env.PATH_PROY || cwd(), 'compiler'), '.cache');
+const CACHE_FILE = path.join(CACHE_DIR, 'versacompile-cache.json');
+async function loadCache() {
+    await smartCache.load(CACHE_FILE);
+}
+async function saveCache() {
+    await smartCache.save(CACHE_FILE, CACHE_DIR);
+}
 // 🎯 Funciones del Sistema Unificado de Manejo de Errores
 /**
  * Registra un error de compilación en el sistema unificado
@@ -551,10 +816,10 @@ class WatchModeOptimizer {
                     if (cached && cached.mtime >= stats.mtimeMs) {
                         resolve({ success: true, cached: true });
                         return;
-                    } // Configurar worker para modo watch
-                    const { TypeScriptWorkerManager } = await import('./typescript-worker.js');
-                    const workerManager = TypeScriptWorkerManager.getInstance();
-                    workerManager.setMode('watch');
+                    } // Configurar worker pool para modo watch
+                    const { TypeScriptWorkerPool } = await import('./typescript-worker-pool.js');
+                    const workerPool = TypeScriptWorkerPool.getInstance();
+                    workerPool.setMode('watch');
                     const result = await compileFn(filePath);
                     this.fileSystemCache.set(filePath, {
                         mtime: stats.mtimeMs,
@@ -579,9 +844,8 @@ async function compileJS(inPath, outPath, mode = 'individual') {
     // Si la ruta ya es absoluta, no la resolvamos de nuevo
     inPath = path.isAbsolute(inPath)
         ? normalizeRuta(inPath)
-        : normalizeRuta(path.resolve(inPath));
-    // 🚀 Usar ModuleManager para carga optimizada
-    const moduleManager = ModuleManager.getInstance();
+        : normalizeRuta(path.resolve(inPath)); // 🚀 Usar OptimizedModuleManager para carga optimizada
+    const moduleManager = OptimizedModuleManager.getInstance();
     // Timing de lectura
     let start = Date.now();
     const extension = path.extname(inPath);
@@ -729,9 +993,6 @@ async function compileJS(inPath, outPath, mode = 'individual') {
     const destinationDir = path.dirname(outPath);
     await mkdir(destinationDir, { recursive: true });
     await writeFile(outPath, code, 'utf-8');
-    if (env.VERBOSE === 'true') {
-        logger.info(`\n📊 Timings para ${path.basename(inPath)}:`, JSON.stringify(timings));
-    }
     return {
         error: null,
         action: 'extension',
@@ -740,11 +1001,11 @@ async function compileJS(inPath, outPath, mode = 'individual') {
 export async function initCompile(ruta, compileTailwind = true, mode = 'individual') {
     try {
         // 🚀 Sistema de Carga Inteligente de Módulos
-        const moduleManager = ModuleManager.getInstance();
+        const moduleManager = OptimizedModuleManager.getInstance();
         const fileExtension = path.extname(ruta);
         const fileExtensions = new Set([fileExtension]);
         // Inicializar módulos según el contexto
-        await moduleManager.initializeModules(mode === 'all' ? 'batch' : mode, fileExtensions);
+        await moduleManager.preloadForContext(mode === 'all' ? 'batch' : mode, fileExtensions);
         // Generar TailwindCSS si está habilitado
         if (compileTailwind && Boolean(env.TAILWIND)) {
             await moduleManager.ensureModuleLoaded('tailwind');
@@ -950,28 +1211,7 @@ function createProgressBar(current, total, width = 30) {
 }
 // Función helper para verificar si un archivo debe ser omitido por cache
 async function shouldSkipFile(filePath) {
-    try {
-        const stats = await stat(filePath);
-        const cacheEntry = compilationCache.get(filePath);
-        if (!cacheEntry) {
-            return false; // No hay entrada en cache, debe compilarse
-        }
-        // Verificar si el archivo no ha cambiado desde la última compilación
-        if (stats.mtimeMs <= cacheEntry.mtime) {
-            // Verificar si el archivo de salida existe
-            try {
-                await stat(cacheEntry.outputPath);
-                return true; // Archivo existe y no ha cambiado, se puede omitir
-            }
-            catch {
-                return false; // Archivo de salida no existe, debe recompilarse
-            }
-        }
-        return false; // Archivo ha cambiado, debe recompilarse
-    }
-    catch {
-        return false; // Error al verificar, compilar por seguridad
-    }
+    return await smartCache.isValid(filePath);
 }
 // Función para compilar archivos con límite de concurrencia
 async function compileWithConcurrencyLimit(files, maxConcurrency = 8) {
@@ -987,7 +1227,7 @@ async function compileWithConcurrencyLimit(files, maxConcurrency = 8) {
         const progressPercent = Math.round((currentTotal / total) * 100);
         if (progressPercent > lastProgressUpdate + 1 ||
             currentTotal === total) {
-            process.stdout.write(`\r🚀 ${progressBar} [✅ ${completed} | ⏭️ ${skipped} | ❌ ${failed}]`);
+            stdout.write(`\r🚀 ${progressBar} [✅ ${completed} | ⏭️ ${skipped} | ❌ ${failed}]`);
             lastProgressUpdate = progressPercent;
         }
     }
@@ -1001,18 +1241,12 @@ async function compileWithConcurrencyLimit(files, maxConcurrency = 8) {
                     return {
                         success: true,
                         cached: true,
-                        output: compilationCache.get(file)?.outputPath || '',
+                        output: smartCache.getOutputPath(file),
                     };
                 }
-                const result = await initCompile(file, false, 'batch');
-                // Actualizar cache si la compilación fue exitosa
+                const result = await initCompile(file, false, 'batch'); // Actualizar cache si la compilación fue exitosa
                 if (result.success && result.output) {
-                    const stats = await stat(file);
-                    compilationCache.set(file, {
-                        hash: '', // Se podría implementar hash del contenido si es necesario
-                        mtime: stats.mtimeMs,
-                        outputPath: result.output,
-                    });
+                    await smartCache.set(file, result.output);
                 }
                 completed++;
                 showProgress();
@@ -1094,7 +1328,15 @@ export async function initCompileAll() {
         else {
             maxConcurrency = Math.min(cpuCount * 2, 16);
         }
-        logger.info(`🚀 Compilando ${fileCount} archivos con concurrencia optimizada (${maxConcurrency} hilos)...`);
+        logger.info(`🚀 Compilando ${fileCount} archivos con concurrencia optimizada (${maxConcurrency} hilos)...`); // Configurar worker pool para modo batch
+        try {
+            const { TypeScriptWorkerPool } = await import('./typescript-worker-pool.js');
+            const workerPool = TypeScriptWorkerPool.getInstance();
+            workerPool.setMode('batch');
+        }
+        catch {
+            // Error silencioso en configuración del pool
+        }
         await compileWithConcurrencyLimit(filesToCompile, maxConcurrency);
         // Guardar cache al final
         await saveCache();