versacompiler 2.3.4 → 2.4.0

package/dist/compiler/compile.js

@@ -8,6 +8,7 @@ const { argv, cwd, env } = process;
 import { logger, setProgressManagerGetter } from '../servicios/logger.js';
 import { promptUser } from '../utils/promptUser.js';
 import { showTimingForHumans } from '../utils/utils.js';
+import { integrityValidator } from './integrity-validator.js';
 // Configurar el getter del ProgressManager para el logger
 setProgressManagerGetter(() => ProgressManager.getInstance());
 /**
@@ -385,63 +386,31 @@ class OptimizedModuleManager {
         this.startBackgroundPreloading();
     }
 }
-// Lazy loading helper functions
+// Lazy loading helper functions - delegan al OptimizedModuleManager para evitar duplicación
+const moduleManagerRef = () => OptimizedModuleManager.getInstance();
 async function loadChalk() {
-    if (!chalk) {
-        chalk = (await import('chalk')).default;
-    }
-    return chalk;
+    return moduleManagerRef().ensureModuleLoaded('chalk');
 }
 async function loadLinter() {
-    if (!ESLint || !OxLint) {
-        const linterModule = await import('./linter.js');
-        ESLint = linterModule.ESLint;
-        OxLint = linterModule.OxLint;
-    }
-    return { ESLint, OxLint };
+    return moduleManagerRef().ensureModuleLoaded('linter');
 }
 async function loadMinify() {
-    if (!minifyJS) {
-        const minifyModule = await import('./minify.js');
-        // ✨ Usar minifyWithTemplates para minificar templates HTML ANTES del JS
-        minifyJS = minifyModule.minifyWithTemplates;
-    }
-    return minifyJS;
+    return moduleManagerRef().ensureModuleLoaded('minify');
 }
 async function loadParser() {
-    if (!getCodeFile) {
-        const parserModule = await import('./parser.js');
-        getCodeFile = parserModule.getCodeFile;
-    }
-    return getCodeFile;
+    return moduleManagerRef().ensureModuleLoaded('parser');
 }
 async function loadTailwind() {
-    if (!generateTailwindCSS) {
-        const tailwindModule = await import('./tailwindcss.js');
-        generateTailwindCSS = tailwindModule.generateTailwindCSS;
-    }
-    return generateTailwindCSS;
+    return moduleManagerRef().ensureModuleLoaded('tailwind');
 }
 async function loadTransforms() {
-    if (!estandarizaCode) {
-        const transformsModule = await import('./transforms.js');
-        estandarizaCode = transformsModule.estandarizaCode;
-    }
-    return estandarizaCode;
+    return moduleManagerRef().ensureModuleLoaded('transforms');
 }
 async function loadTypeScript() {
-    if (!preCompileTS) {
-        const typescriptModule = await import('./typescript-manager.js');
-        preCompileTS = typescriptModule.preCompileTS;
-    }
-    return preCompileTS;
+    return moduleManagerRef().ensureModuleLoaded('typescript');
 }
 async function loadVue() {
-    if (!preCompileVue) {
-        const vueModule = await import('./vuejs.js');
-        preCompileVue = vueModule.preCompileVue;
-    }
-    return preCompileVue;
+    return moduleManagerRef().ensureModuleLoaded('vue');
 }
 // Almacenamiento global de errores y resultados
 const compilationErrors = [];
@@ -464,6 +433,10 @@ class SmartCompilationCache {
     maxEntries = 200; // Reducido para tests de estrés
     maxMemory = 50 * 1024 * 1024; // 50MB límite (reducido)
     currentMemoryUsage = 0;
+    // Cache para dependencyHash con TTL de 5 minutos para evitar stat() redundantes
+    _cachedDepHash = null;
+    _depHashExpiry = 0;
+    DEP_HASH_TTL = 5 * 60 * 1000; // 5 minutos
     // ✨ ISSUE #3: Sistema de vigilancia de dependencias
     fileWatchers = new Map(); // chokidar watchers
     dependencyGraph = new Map(); // archivo -> dependencias
@@ -471,6 +444,7 @@ class SmartCompilationCache {
     packageJsonPath = path.join(cwd(), 'package.json');
     nodeModulesPath = path.join(cwd(), 'node_modules');
     isWatchingDependencies = false;
+    _depWatcherFailed = false; // Flag para indicar que el watcher de deps falló
     /**
      * Genera hash SHA-256 del contenido del archivo
      */ async generateContentHash(filePath) {
@@ -528,6 +502,11 @@ class SmartCompilationCache {
      * Incluye vigilancia de package.json, node_modules y versiones instaladas
      */
     async generateDependencyHash() {
+        // Retornar hash cacheado si sigue vigente (evita 10+ stat() por ciclo)
+        const now = Date.now();
+        if (this._cachedDepHash && now < this._depHashExpiry) {
+            return this._cachedDepHash;
+        }
         try {
             const hash = createHash('sha256');
             // 1. Hash del package.json con versiones
@@ -588,16 +567,29 @@ class SmartCompilationCache {
                 // node_modules no existe
                 hash.update('nmtime:none');
             }
-            return hash.digest('hex').substring(0, 16);
+            const result = hash.digest('hex').substring(0, 16);
+            this._cachedDepHash = result;
+            this._depHashExpiry = Date.now() + this.DEP_HASH_TTL;
+            return result;
         }
         catch (error) {
             // Incluir información del error en el hash para debugging
-            return createHash('sha256')
+            const result = createHash('sha256')
                 .update(`error:${error instanceof Error ? error.message : 'unknown'}`)
                 .digest('hex')
                 .substring(0, 16);
+            this._cachedDepHash = result;
+            this._depHashExpiry = Date.now() + this.DEP_HASH_TTL;
+            return result;
         }
     }
+    /**
+     * Invalida el cache de dependencyHash (llamar cuando package.json cambie)
+     */
+    invalidateDepHashCache() {
+        this._cachedDepHash = null;
+        this._depHashExpiry = 0;
+    }
     /**
      * Genera clave de cache granular que incluye todos los factores
      */
@@ -616,35 +608,21 @@ class SmartCompilationCache {
         if (!entry)
             return false;
         try {
-            // Verificar si el archivo de salida existe
-            await stat(entry.outputPath);
-            // Verificar si el contenido ha cambiado
-            const currentContentHash = await this.generateContentHash(filePath);
-            if (entry.contentHash !== currentContentHash) {
-                this.cache.delete(filePath);
-                return false;
-            }
-            // Verificar si la configuración ha cambiado
+            // Ejecutar todas las verificaciones independientes en paralelo
+            const [currentContentHash, currentDependencyHash, fileStat, _outputStat] = await Promise.all([
+                this.generateContentHash(filePath),
+                this.generateDependencyHash(),
+                stat(filePath),
+                stat(entry.outputPath),
+            ]);
+            // Los hashes síncronos son baratos, evaluarlos tras el await
             const currentConfigHash = this.generateConfigHash();
-            if (entry.configHash !== currentConfigHash) {
-                this.cache.delete(filePath);
-                return false;
-            }
-            // Verificar si las variables de entorno han cambiado
             const currentEnvHash = this.generateEnvHash();
-            if (entry.envHash !== currentEnvHash) {
-                this.cache.delete(filePath);
-                return false;
-            }
-            // Verificar si las dependencias han cambiado
-            const currentDependencyHash = await this.generateDependencyHash();
-            if (entry.dependencyHash !== currentDependencyHash) {
-                this.cache.delete(filePath);
-                return false;
-            }
-            // Verificar tiempo de modificación como backup
-            const stats = await stat(filePath);
-            if (stats.mtimeMs > entry.mtime) {
+            if (entry.contentHash !== currentContentHash ||
+                entry.configHash !== currentConfigHash ||
+                entry.envHash !== currentEnvHash ||
+                entry.dependencyHash !== currentDependencyHash ||
+                fileStat.mtimeMs > entry.mtime) {
                 this.cache.delete(filePath);
                 return false;
             }
@@ -727,7 +705,27 @@ class SmartCompilationCache {
             if (entry) {
                 this.currentMemoryUsage -= entry.size;
                 this.cache.delete(oldestKey);
+                // Podar el grafo de dependencias para evitar entradas obsoletas
+                this.pruneDependencyGraph(oldestKey);
+            }
+        }
+    }
+    /**
+     * Elimina entradas obsoletas del grafo de dependencias para un archivo
+     */
+    pruneDependencyGraph(filePath) {
+        const deps = this.dependencyGraph.get(filePath);
+        if (deps) {
+            for (const dep of deps) {
+                const reverseDeps = this.reverseDependencyGraph.get(dep);
+                if (reverseDeps) {
+                    reverseDeps.delete(filePath);
+                    if (reverseDeps.size === 0) {
+                        this.reverseDependencyGraph.delete(dep);
+                    }
+                }
             }
+            this.dependencyGraph.delete(filePath);
         }
     }
     /**
@@ -833,6 +831,7 @@ class SmartCompilationCache {
                 });
                 packageWatcher.on('change', () => {
                     logger.info('📦 package.json modificado - invalidando cache de dependencias');
+                    this.invalidateDepHashCache();
                     this.invalidateByDependencyChange();
                 });
                 this.fileWatchers.set('package.json', packageWatcher);
@@ -845,12 +844,12 @@ class SmartCompilationCache {
                     depth: 1, // Solo primer nivel para performance
                     ignored: /(^|[/\\])\../, // Ignorar archivos ocultos
                 });
-                nodeModulesWatcher.on('addDir', (path) => {
-                    logger.info(`📦 Nueva dependencia instalada: ${path.split(/[/\\]/).pop()}`);
+                nodeModulesWatcher.on('addDir', (dirPath) => {
+                    logger.info(`📦 Nueva dependencia instalada: ${dirPath.split(/[/\\]/).pop()}`);
                     this.invalidateByDependencyChange();
                 });
-                nodeModulesWatcher.on('unlinkDir', (path) => {
-                    logger.info(`📦 Dependencia eliminada: ${path.split(/[/\\]/).pop()}`);
+                nodeModulesWatcher.on('unlinkDir', (dirPath) => {
+                    logger.info(`📦 Dependencia eliminada: ${dirPath.split(/[/\\]/).pop()}`);
                     this.invalidateByDependencyChange();
                 });
                 this.fileWatchers.set('node_modules', nodeModulesWatcher);
@@ -860,6 +859,8 @@ class SmartCompilationCache {
         }
         catch (error) {
             logger.warn('⚠️ No se pudo iniciar vigilancia de dependencias:', error);
+            // Marcar fallo para que el sistema lo tenga en cuenta
+            this._depWatcherFailed = true;
         }
     }
     /**
@@ -1043,19 +1044,19 @@ async function handleCompilationError(error, fileName, stage, mode, isVerbose =
     registerCompilationError(fileName, stage, errorMessage, 'error', errorDetails);
     registerCompilationResult(stage, 1, 0, [fileName]); // Mostrar error inmediatamente solo en modo individual y watch
     if (mode === 'individual' || mode === 'watch') {
-        const chalk = await loadChalk();
+        const chalkLib = await loadChalk();
         const baseName = path.basename(fileName);
         const stageColor = await getStageColor(stage);
         if (isVerbose) {
             // Modo verbose: Mostrar error completo con contexto
-            logger.error(chalk.red(`❌ Error en etapa ${stageColor(stage)} - ${baseName}:`));
-            logger.error(chalk.red(errorMessage));
+            logger.error(chalkLib.red(`❌ Error en etapa ${stageColor(stage)} - ${baseName}:`));
+            logger.error(chalkLib.red(errorMessage));
             if (errorDetails && (stage === 'typescript' || stage === 'vue')) {
                 // Mostrar stack trace limitado para TypeScript y Vue
                 const stackLines = errorDetails.split('\n').slice(0, 5);
                 stackLines.forEach(line => {
                     if (line.trim()) {
-                        logger.error(chalk.gray(`  ${line.trim()}`));
+                        logger.error(chalkLib.gray(`  ${line.trim()}`));
                     }
                 });
             }
@@ -1063,9 +1064,9 @@ async function handleCompilationError(error, fileName, stage, mode, isVerbose =
         else {
             // Modo normal: Mostrar error simplificado
             const firstLine = errorMessage.split('\n')[0];
-            logger.error(chalk.red(`❌ Error en ${stageColor(stage)}: ${baseName}`));
-            logger.error(chalk.red(`   ${firstLine}`));
-            logger.info(chalk.yellow(`💡 Usa --verbose para ver detalles completos`));
+            logger.error(chalkLib.red(`❌ Error en ${stageColor(stage)}: ${baseName}`));
+            logger.error(chalkLib.red(`   ${firstLine}`));
+            logger.info(chalkLib.yellow(`💡 Usa --verbose para ver detalles completos`));
         }
     }
     // En modo 'all', los errores se acumulan silenciosamente para el resumen final
@@ -1079,7 +1080,7 @@ function registerCompilationSuccess(fileName, stage) {
 /**
  * Limpia todos los errores y resultados acumulados
  */
-function clearCompilationState() {
+export function clearCompilationState() {
     compilationErrors.length = 0;
     compilationResults.length = 0;
 }
@@ -1087,25 +1088,25 @@ function clearCompilationState() {
  * Muestra un resumen detallado de todos los errores de compilación
  */
 async function displayCompilationSummary(isVerbose = false, totalTime) {
-    const chalk = await loadChalk();
+    const chalkLib = await loadChalk();
     if (compilationErrors.length === 0 && compilationResults.length === 0) {
-        logger.info(chalk.green('✅ No hay errores de compilación para mostrar.'));
+        logger.info(chalkLib.green('✅ No hay errores de compilación para mostrar.'));
         if (totalTime) {
-            logger.info(chalk.bold(`\n⏱️ TIEMPO TOTAL DE COMPILACIÓN: ${totalTime}`));
+            logger.info(chalkLib.bold(`\n⏱️ TIEMPO TOTAL DE COMPILACIÓN: ${totalTime}`));
         }
         return;
     }
     // 🎨 Header moderno del resumen
     const summaryLine = '━'.repeat(40);
     logger.info('');
-    logger.info(chalk.bold.cyan('📊 Resumen de Compilación'));
-    logger.info(chalk.gray(summaryLine)); // ⏱️ Tiempo total con formato elegante
+    logger.info(chalkLib.bold.cyan('📊 Resumen de Compilación'));
+    logger.info(chalkLib.gray(summaryLine)); // ⏱️ Tiempo total con formato elegante
     if (totalTime) {
-        logger.info(chalk.bold(`⏱️  Tiempo Total: ${chalk.green(totalTime)}`));
+        logger.info(chalkLib.bold(`⏱️  Tiempo Total: ${chalkLib.green(totalTime)}`));
         logger.info('');
     } // 🔧 Estadísticas por etapa con mejor formato
     if (compilationResults.length > 0) {
-        logger.info(chalk.bold.blue('🔧 Estadísticas por Etapa:'));
+        logger.info(chalkLib.bold.blue('🔧 Estadísticas por Etapa:'));
         for (const result of compilationResults) {
             const totalFiles = result.success + result.errors;
             const successRate = totalFiles > 0
@@ -1113,20 +1114,20 @@ async function displayCompilationSummary(isVerbose = false, totalTime) {
                 : 0;
             // Iconos y colores dinámicos por etapa
             const stageIcon = getStageIcon(result.stage);
-            const statusColor = result.errors === 0 ? chalk.green : chalk.red;
+            const statusColor = result.errors === 0 ? chalkLib.green : chalkLib.red;
             const progressBar = createProgressBarWithPercentage(successRate, 20);
-            logger.info(`   ${stageIcon} ${chalk.bold(result.stage)}`);
+            logger.info(`   ${stageIcon} ${chalkLib.bold(result.stage)}`);
             logger.info(`     ${statusColor('●')} ${result.success}/${totalFiles} archivos ${statusColor(`(${successRate}%)`)}`);
             logger.info(`     ${progressBar}`);
             if (result.errors > 0) {
-                logger.info(`     ${chalk.red('⚠')} ${result.errors} ${result.errors === 1 ? 'error' : 'errores'}`);
+                logger.info(`     ${chalkLib.red('⚠')} ${result.errors} ${result.errors === 1 ? 'error' : 'errores'}`);
             }
             logger.info('');
         }
     }
     // Mostrar errores detallados
     if (compilationErrors.length > 0) {
-        logger.info(chalk.red(`\n❌ Se encontraron ${compilationErrors.length} errores:`));
+        logger.info(chalkLib.red(`\n❌ Se encontraron ${compilationErrors.length} errores:`));
         // Agrupar errores por archivo para mejor organización
         const errorsByFile = new Map();
         compilationErrors.forEach(error => {
@@ -1141,9 +1142,9 @@ async function displayCompilationSummary(isVerbose = false, totalTime) {
             const baseName = path.basename(filePath);
             const errorCount = fileErrors.filter(e => e.severity === 'error').length;
             const warningCount = fileErrors.filter(e => e.severity === 'warning').length;
-            logger.info(chalk.cyan(`\n📄 ${fileIndex}. ${baseName}`));
-            logger.info(chalk.gray(`   Ruta: ${filePath}`));
-            logger.info(chalk.yellow(`   ${errorCount} errores, ${warningCount} advertencias`));
+            logger.info(chalkLib.cyan(`\n📄 ${fileIndex}. ${baseName}`));
+            logger.info(chalkLib.gray(`   Ruta: ${filePath}`));
+            logger.info(chalkLib.yellow(`   ${errorCount} errores, ${warningCount} advertencias`));
             for (const error of fileErrors) {
                 const icon = error.severity === 'error' ? '❌' : '⚠️';
                 const stageColor = await getStageColor(error.stage);
@@ -1153,12 +1154,12 @@ async function displayCompilationSummary(isVerbose = false, totalTime) {
                     const detailLines = error.details.split('\n').slice(0, 5);
                     detailLines.forEach(line => {
                         if (line.trim()) {
-                            logger.info(chalk.gray(`      ${line.trim()}`));
+                            logger.info(chalkLib.gray(`      ${line.trim()}`));
                         }
                     });
                 }
                 if (error.help) {
-                    logger.info(chalk.blue(`      💡 ${error.help}`));
+                    logger.info(chalkLib.blue(`      💡 ${error.help}`));
                 }
             }
             fileIndex++;
@@ -1169,44 +1170,44 @@ async function displayCompilationSummary(isVerbose = false, totalTime) {
         // Header elegante para estadísticas finales
         const statLine = '═'.repeat(50);
         logger.info('');
-        logger.info(chalk.bold.cyan(statLine));
-        logger.info(chalk.bold.cyan('                📊 RESUMEN FINAL'));
-        logger.info(chalk.bold.cyan(statLine));
+        logger.info(chalkLib.bold.cyan(statLine));
+        logger.info(chalkLib.bold.cyan('                📊 RESUMEN FINAL'));
+        logger.info(chalkLib.bold.cyan(statLine));
         // Estadísticas con iconos y colores modernos
         logger.info('');
-        logger.info(chalk.bold('🎯 Resultados:'));
-        logger.info(`   📁 Archivos afectados: ${chalk.cyan.bold(totalFiles)}`);
-        logger.info(`   ${totalErrors > 0 ? chalk.red('●') : chalk.green('○')} Errores: ${totalErrors > 0 ? chalk.red.bold(totalErrors) : chalk.green.bold('0')}`);
-        logger.info(`   ${totalWarnings > 0 ? chalk.yellow('●') : chalk.green('○')} Advertencias: ${totalWarnings > 0 ? chalk.yellow.bold(totalWarnings) : chalk.green.bold('0')}`);
+        logger.info(chalkLib.bold('🎯 Resultados:'));
+        logger.info(`   📁 Archivos afectados: ${chalkLib.cyan.bold(totalFiles)}`);
+        logger.info(`   ${totalErrors > 0 ? chalkLib.red('●') : chalkLib.green('○')} Errores: ${totalErrors > 0 ? chalkLib.red.bold(totalErrors) : chalkLib.green.bold('0')}`);
+        logger.info(`   ${totalWarnings > 0 ? chalkLib.yellow('●') : chalkLib.green('○')} Advertencias: ${totalWarnings > 0 ? chalkLib.yellow.bold(totalWarnings) : chalkLib.green.bold('0')}`);
         logger.info('');
         // Estado final con diseño visual atractivo
         if (totalErrors > 0) {
-            logger.info(chalk.red.bold('🚨 COMPILACIÓN COMPLETADA CON ERRORES'));
-            logger.info(chalk.red('   Por favor revisa y corrige los problemas anteriores.'));
+            logger.info(chalkLib.red.bold('🚨 COMPILACIÓN COMPLETADA CON ERRORES'));
+            logger.info(chalkLib.red('   Por favor revisa y corrige los problemas anteriores.'));
         }
         else if (totalWarnings > 0) {
-            logger.info(chalk.yellow.bold('⚠️  COMPILACIÓN COMPLETADA CON ADVERTENCIAS'));
-            logger.info(chalk.yellow('   Considera revisar las advertencias anteriores.'));
+            logger.info(chalkLib.yellow.bold('⚠️  COMPILACIÓN COMPLETADA CON ADVERTENCIAS'));
+            logger.info(chalkLib.yellow('   Considera revisar las advertencias anteriores.'));
         }
         else {
-            logger.info(chalk.green.bold('✅ COMPILACIÓN EXITOSA'));
-            logger.info(chalk.green('   ¡Todos los archivos se compilaron sin problemas!'));
+            logger.info(chalkLib.green.bold('✅ COMPILACIÓN EXITOSA'));
+            logger.info(chalkLib.green('   ¡Todos los archivos se compilaron sin problemas!'));
         }
         logger.info('');
-        logger.info(chalk.bold.cyan(statLine));
+        logger.info(chalkLib.bold.cyan(statLine));
     }
     else {
         // Caso exitoso sin errores
         const successLine = '═'.repeat(50);
         logger.info('');
-        logger.info(chalk.bold.green(successLine));
-        logger.info(chalk.bold.green('                ✨ ÉXITO'));
-        logger.info(chalk.bold.green(successLine));
+        logger.info(chalkLib.bold.green(successLine));
+        logger.info(chalkLib.bold.green('                ✨ ÉXITO'));
+        logger.info(chalkLib.bold.green(successLine));
         logger.info('');
-        logger.info(chalk.green.bold('🎉 COMPILACIÓN COMPLETADA EXITOSAMENTE'));
-        logger.info(chalk.green('   ¡No se encontraron errores ni advertencias!'));
+        logger.info(chalkLib.green.bold('🎉 COMPILACIÓN COMPLETADA EXITOSAMENTE'));
+        logger.info(chalkLib.green('   ¡No se encontraron errores ni advertencias!'));
         logger.info('');
-        logger.info(chalk.bold.green(successLine));
+        logger.info(chalkLib.bold.green(successLine));
     }
     logger.info('');
 }
@@ -1214,7 +1215,7 @@ async function displayCompilationSummary(isVerbose = false, totalTime) {
  * Muestra errores del linter con formato visual moderno y profesional
  */
 async function displayLinterErrors(errors) {
-    const chalk = await loadChalk();
+    const chalkLib = await loadChalk();
     // Agrupar errores por archivo
     const errorsByFile = new Map();
     errors.forEach(error => {
@@ -1227,22 +1228,22 @@ async function displayLinterErrors(errors) {
     const totalWarnings = errors.filter(e => e.severity === 'warning').length;
     const totalFiles = errorsByFile.size;
     // Header estilo moderno con gradiente visual
-    logger.info(chalk.bold.rgb(255, 120, 120)('╭─────────────────────────────────────────────────────────────╮'));
-    logger.info(chalk.bold.rgb(255, 120, 120)('│                    ') +
-        chalk.bold.white('🔍 LINTER REPORT') +
-        chalk.bold.rgb(255, 120, 120)('                    │'));
-    logger.info(chalk.bold.rgb(255, 120, 120)('╰─────────────────────────────────────────────────────────────╯'));
+    logger.info(chalkLib.bold.rgb(255, 120, 120)('╭─────────────────────────────────────────────────────────────╮'));
+    logger.info(chalkLib.bold.rgb(255, 120, 120)('│                    ') +
+        chalkLib.bold.white('🔍 LINTER REPORT') +
+        chalkLib.bold.rgb(255, 120, 120)('                    │'));
+    logger.info(chalkLib.bold.rgb(255, 120, 120)('╰─────────────────────────────────────────────────────────────╯'));
     // Resumen con iconos profesionales
-    const errorIcon = totalErrors > 0 ? chalk.red('●') : chalk.green('○');
-    const warningIcon = totalWarnings > 0 ? chalk.yellow('●') : chalk.green('○');
+    const errorIcon = totalErrors > 0 ? chalkLib.red('●') : chalkLib.green('○');
+    const warningIcon = totalWarnings > 0 ? chalkLib.yellow('●') : chalkLib.green('○');
     logger.info('');
-    logger.info(chalk.bold('📊 Summary:'));
-    logger.info(`   ${errorIcon} ${chalk.bold(totalErrors)} ${chalk.red('errors')}`);
-    logger.info(`   ${warningIcon} ${chalk.bold(totalWarnings)} ${chalk.yellow('warnings')}`);
-    logger.info(`   📁 ${chalk.bold(totalFiles)} ${chalk.cyan('files')}`);
+    logger.info(chalkLib.bold('📊 Summary:'));
+    logger.info(`   ${errorIcon} ${chalkLib.bold(totalErrors)} ${chalkLib.red('errors')}`);
+    logger.info(`   ${warningIcon} ${chalkLib.bold(totalWarnings)} ${chalkLib.yellow('warnings')}`);
+    logger.info(`   📁 ${chalkLib.bold(totalFiles)} ${chalkLib.cyan('files')}`);
     logger.info('');
     if (totalErrors === 0 && totalWarnings === 0) {
-        logger.info(chalk.green.bold('✨ All checks passed! No issues found.'));
+        logger.info(chalkLib.green.bold('✨ All checks passed! No issues found.'));
         return;
     }
     // Mostrar errores por archivo con formato elegante
@@ -1251,29 +1252,29 @@ async function displayLinterErrors(errors) {
         await displayFileErrorsGroup(filePath, fileErrors, fileIndex, totalFiles);
         fileIndex++;
         if (fileIndex <= totalFiles) {
-            logger.info(chalk.gray('─'.repeat(80))); // Separador entre archivos
+            logger.info(chalkLib.gray('─'.repeat(80))); // Separador entre archivos
         }
     }
     // Footer con estadísticas
     logger.info('');
-    logger.info(chalk.bold.rgb(255, 120, 120)('╭─────────────────────────────────────────────────────────────╮'));
-    logger.info(chalk.bold.rgb(255, 120, 120)('│  ') +
-        chalk.bold.white(`Found ${totalErrors + totalWarnings} issues in ${totalFiles} files`) +
+    logger.info(chalkLib.bold.rgb(255, 120, 120)('╭─────────────────────────────────────────────────────────────╮'));
+    logger.info(chalkLib.bold.rgb(255, 120, 120)('│  ') +
+        chalkLib.bold.white(`Found ${totalErrors + totalWarnings} issues in ${totalFiles} files`) +
         ' '.repeat(Math.max(0, 52 -
             `Found ${totalErrors + totalWarnings} issues in ${totalFiles} files`
                 .length)) +
-        chalk.bold.rgb(255, 120, 120)('  │'));
-    logger.info(chalk.bold.rgb(255, 120, 120)('╰─────────────────────────────────────────────────────────────╯'));
+        chalkLib.bold.rgb(255, 120, 120)('  │'));
+    logger.info(chalkLib.bold.rgb(255, 120, 120)('╰─────────────────────────────────────────────────────────────╯'));
 }
 /**
  * Muestra un grupo de errores para un archivo específico con formato moderno
  */
 async function displayFileErrorsGroup(filePath, fileErrors, _fileIndex, _totalFiles) {
-    const chalk = await loadChalk();
+    const chalkLib = await loadChalk();
     // Header del archivo con iconos de estado
     const errorCount = fileErrors.filter(e => e.severity === 'error').length;
     const warningCount = fileErrors.filter(e => e.severity === 'warning').length;
-    const statusIcon = errorCount > 0 ? chalk.red('✕') : chalk.yellow('⚠');
+    const statusIcon = errorCount > 0 ? chalkLib.red('✕') : chalkLib.yellow('⚠');
     const fileIcon = filePath.endsWith('.vue')
         ? '🎨'
         : filePath.endsWith('.ts')
@@ -1282,8 +1283,8 @@ async function displayFileErrorsGroup(filePath, fileErrors, _fileIndex, _totalFi
                 ? '📜'
                 : '📄';
     logger.info('');
-    logger.info(chalk.bold(`${statusIcon} ${fileIcon} ${chalk.cyan(path.relative(process.cwd(), filePath))}`));
-    logger.info(chalk.gray(`   ${errorCount} errors, ${warningCount} warnings`));
+    logger.info(chalkLib.bold(`${statusIcon} ${fileIcon} ${chalkLib.cyan(path.relative(process.cwd(), filePath))}`));
+    logger.info(chalkLib.gray(`   ${errorCount} errors, ${warningCount} warnings`));
     logger.info('');
     // Mostrar cada error con formato elegante
     for (let i = 0; i < fileErrors.length; i++) {
@@ -1295,21 +1296,21 @@ async function displayFileErrorsGroup(filePath, fileErrors, _fileIndex, _totalFi
  * Muestra un error individual con formato visual moderno tipo ESLint/Prettier
  */
 async function displayModernLinterError(error, filePath, errorIndex, totalErrorsInFile) {
-    const chalk = await loadChalk();
+    const chalkLib = await loadChalk();
     const fs = await import('node:fs/promises');
     // Determinar tipo y color del error
     const isError = error.severity === 'error';
-    const typeColor = isError ? chalk.red : chalk.yellow;
+    const typeColor = isError ? chalkLib.red : chalkLib.yellow;
     const typeIcon = isError ? '✕' : '⚠';
     const line = error.line || 1;
     const column = error.column || 1;
     const ruleId = error.ruleId || error.from || 'unknown';
     // Línea principal del error con formato moderno
-    const errorHeader = `  ${typeColor(typeIcon)} ${chalk.bold(error.message)}`;
-    const ruleInfo = `${chalk.gray(ruleId)}`;
-    const locationInfo = `${chalk.blue(`${line}:${column}`)}`;
+    const errorHeader = `  ${typeColor(typeIcon)} ${chalkLib.bold(error.message)}`;
+    const ruleInfo = `${chalkLib.gray(ruleId)}`;
+    const locationInfo = `${chalkLib.blue(`${line}:${column}`)}`;
     logger.info(errorHeader);
-    logger.info(`    ${chalk.gray('at')} ${locationInfo} ${chalk.gray('·')} ${ruleInfo}`);
+    logger.info(`    ${chalkLib.gray('at')} ${locationInfo} ${chalkLib.gray('·')} ${ruleInfo}`);
     // Mostrar código con contexto
     try {
         const absolutePath = path.resolve(filePath);
@@ -1331,27 +1332,27 @@ async function displayModernLinterError(error, filePath, errorIndex, totalErrors
                 const isErrorLine = i === lineNum;
                 if (isErrorLine) {
                     // Línea con el error - destacada
-                    logger.info(`    ${chalk.red('>')} ${chalk.gray(lineNumStr)} ${chalk.gray('│')} ${currentLine}`);
+                    logger.info(`    ${chalkLib.red('>')} ${chalkLib.gray(lineNumStr)} ${chalkLib.gray('│')} ${currentLine}`);
                     // Indicador de posición del error
                     const pointer = ' '.repeat(Math.max(0, column - 1)) + typeColor('^');
-                    logger.info(`    ${chalk.gray(' ')} ${chalk.gray(' '.repeat(maxLineNumWidth))} ${chalk.gray('│')} ${pointer}`);
+                    logger.info(`    ${chalkLib.gray(' ')} ${chalkLib.gray(' '.repeat(maxLineNumWidth))} ${chalkLib.gray('│')} ${pointer}`);
                 }
                 else {
                     // Líneas de contexto
-                    logger.info(`    ${chalk.gray(' ')} ${chalk.gray(lineNumStr)} ${chalk.gray('│')} ${chalk.gray(currentLine)}`);
+                    logger.info(`    ${chalkLib.gray(' ')} ${chalkLib.gray(lineNumStr)} ${chalkLib.gray('│')} ${chalkLib.gray(currentLine)}`);
                 }
             }
         }
     }
     catch {
         // Si no se puede leer el archivo, mostrar formato simplificado
-        logger.info(`    ${chalk.gray('│')} ${chalk.gray('(Unable to read file content)')}`);
+        logger.info(`    ${chalkLib.gray('│')} ${chalkLib.gray('(Unable to read file content)')}`);
     }
     // Mostrar ayuda si está disponible
     if (error.help) {
         logger.info('');
         const helpText = error.help.replace(/^Regla \w+: /, '').trim();
-        logger.info(`    ${chalk.blue('💡')} ${chalk.blue('Help:')} ${chalk.gray(helpText)}`);
+        logger.info(`    ${chalkLib.blue('💡')} ${chalkLib.blue('Help:')} ${chalkLib.gray(helpText)}`);
     }
     // Separador entre errores (solo si no es el último)
     if (errorIndex < totalErrorsInFile) {
@@ -1363,14 +1364,14 @@ async function displayModernLinterError(error, filePath, errorIndex, totalErrors
  * @deprecated Use displayModernLinterError instead
  */
 async function _displaySingleLinterError(error, filePath) {
-    const chalk = await loadChalk();
+    const chalkLib = await loadChalk();
     const fs = await import('node:fs/promises');
     const icon = error.severity === 'error' ? '×' : '⚠';
     const ruleInfo = error.help || '';
     const line = error.line || 'N/A';
     const column = error.column || 10; // Columna por defecto si no está disponible
     // Línea principal del error
-    const mainErrorLine = `${chalk.red(icon)} ${chalk.cyan(`${error.from}(${ruleInfo.replace(/^Regla \w+: /, '')})`)}: ${error.message}`;
+    const mainErrorLine = `${chalkLib.red(icon)} ${chalkLib.cyan(`${error.from}(${ruleInfo.replace(/^Regla \w+: /, '')})`)}: ${error.message}`;
     logger.info(mainErrorLine);
     // Intentar leer el contenido del archivo para mostrar contexto
     try {
@@ -1380,7 +1381,7 @@ async function _displaySingleLinterError(error, filePath) {
         const lineNum = parseInt(line.toString()) - 1; // Convertir a índice 0-based
         if (lineNum >= 0 && lineNum < lines.length) {
             // Mostrar ubicación
-            logger.info(chalk.blue(`    ╭─[${filePath}:${line}:${column}]`));
+            logger.info(chalkLib.blue(`    ╭─[${filePath}:${line}:${column}]`));
             // Mostrar líneas de contexto
             const startLine = Math.max(0, lineNum - 1);
             const endLine = Math.min(lines.length - 1, lineNum + 1);
@@ -1390,38 +1391,38 @@ async function _displaySingleLinterError(error, filePath) {
                 const prefix = currentLineNum.toString().padStart(2, ' ');
                 if (i === lineNum) {
                     // Línea con el error
-                    logger.info(chalk.blue(` ${prefix} │ `) + currentLine);
+                    logger.info(chalkLib.blue(` ${prefix} │ `) + currentLine);
                     // Mostrar el indicador de error
                     const indent = ' '.repeat(prefix.length + 3); // Espacios para alinear
                     const pointer = ' '.repeat(Math.max(0, (column || 1) - 1)) +
-                        chalk.red('───────┬──────');
-                    logger.info(chalk.blue(indent + '·') + pointer);
+                        chalkLib.red('───────┬──────');
+                    logger.info(chalkLib.blue(indent + '·') + pointer);
                     // Mensaje de ubicación específica
                     const messageIndent = ' '.repeat(Math.max(0, (column || 1) + 6));
-                    logger.info(chalk.blue(indent + '·') +
+                    logger.info(chalkLib.blue(indent + '·') +
                         messageIndent +
-                        chalk.red('╰── ') +
-                        chalk.gray(getErrorLocationMessage(error)));
+                        chalkLib.red('╰── ') +
+                        chalkLib.gray(getErrorLocationMessage(error)));
                 }
                 else {
                     // Líneas de contexto
-                    logger.info(chalk.blue(` ${prefix} │ `) + chalk.gray(currentLine));
+                    logger.info(chalkLib.blue(` ${prefix} │ `) + chalkLib.gray(currentLine));
                 }
             }
-            logger.info(chalk.blue('    ╰────'));
+            logger.info(chalkLib.blue('    ╰────'));
         }
     }
     catch {
         // Si no se puede leer el archivo, mostrar formato simplificado
-        logger.info(chalk.blue(`    ╭─[${filePath}:${line}:${column}]`));
-        logger.info(chalk.blue('    │ ') +
-            chalk.gray('(No se pudo leer el contenido del archivo)'));
-        logger.info(chalk.blue('    ╰────'));
+        logger.info(chalkLib.blue(`    ╭─[${filePath}:${line}:${column}]`));
+        logger.info(chalkLib.blue('    │ ') +
+            chalkLib.gray('(No se pudo leer el contenido del archivo)'));
+        logger.info(chalkLib.blue('    ╰────'));
     }
     // Mostrar ayuda si está disponible
     if (error.help) {
         const helpMessage = error.help.replace(/^Regla \w+: /, '');
-        logger.info(chalk.blue('  help: ') + chalk.yellow(helpMessage));
+        logger.info(chalkLib.blue('  help: ') + chalkLib.yellow(helpMessage));
     }
     logger.info(''); // Espacio entre errores
 }
@@ -1450,22 +1451,22 @@ function getErrorLocationMessage(error) {
  * Obtiene el color apropiado para cada etapa de compilación
  */
 async function getStageColor(stage) {
-    const chalk = await loadChalk();
+    const chalkLib = await loadChalk();
     switch (stage) {
         case 'vue':
-            return chalk.green;
+            return chalkLib.green;
         case 'typescript':
-            return chalk.blue;
+            return chalkLib.blue;
         case 'standardization':
-            return chalk.yellow;
+            return chalkLib.yellow;
         case 'minification':
-            return chalk.red;
+            return chalkLib.red;
         case 'tailwind':
-            return chalk.magenta;
+            return chalkLib.magenta;
         case 'file-read':
-            return chalk.gray;
+            return chalkLib.gray;
         default:
-            return chalk.white;
+            return chalkLib.white;
     }
 }
 export function normalizeRuta(ruta) {
@@ -1568,8 +1569,8 @@ async function compileJS(inPath, outPath, mode = 'individual') {
     let start = Date.now();
     const extension = path.extname(inPath); // Asegurar que el parser esté cargado
     await moduleManager.ensureModuleLoaded('parser');
-    const getCodeFile = await loadParser();
-    const result = await getCodeFile(inPath);
+    const getCodeFileLib = await loadParser();
+    const result = await getCodeFileLib(inPath);
     let code = result.code;
     const error = result.error;
     timings.fileRead = Date.now() - start;
@@ -1593,11 +1594,11 @@ async function compileJS(inPath, outPath, mode = 'individual') {
         }
         // Asegurar que el módulo Vue esté cargado
         await moduleManager.ensureModuleLoaded('vue');
-        const preCompileVue = await loadVue();
-        if (typeof preCompileVue !== 'function') {
-            throw new Error(`loadVue devolvió ${typeof preCompileVue} en lugar de una función para archivo: ${inPath}`);
+        const preCompileVueLib = await loadVue();
+        if (typeof preCompileVueLib !== 'function') {
+            throw new Error(`loadVue devolvió ${typeof preCompileVueLib} en lugar de una función para archivo: ${inPath}`);
         }
-        vueResult = await preCompileVue(code, inPath, env.isPROD === 'true');
+        vueResult = await preCompileVueLib(code, inPath, env.isPROD === 'true');
         timings.vueCompile = Date.now() - start;
         if (vueResult === undefined || vueResult === null) {
             throw new Error(`preCompileVue devolvió ${vueResult} para archivo: ${inPath}`);
@@ -1626,12 +1627,12 @@ async function compileJS(inPath, outPath, mode = 'individual') {
         }
         // Asegurar que el módulo TypeScript esté cargado
         await moduleManager.ensureModuleLoaded('typescript');
-        const preCompileTS = await loadTypeScript();
-        if (typeof preCompileTS !== 'function') {
-            throw new Error(`loadTypeScript devolvió ${typeof preCompileTS} en lugar de una función para archivo: ${inPath}`);
+        const preCompileTSLib = await loadTypeScript();
+        if (typeof preCompileTSLib !== 'function') {
+            throw new Error(`loadTypeScript devolvió ${typeof preCompileTSLib} en lugar de una función para archivo: ${inPath}`);
         }
         // 🚀 OPTIMIZACIÓN: Pasar scriptInfo directamente sin crear objeto nuevo
-        tsResult = await preCompileTS(code, inPath, vueResult?.scriptInfo);
+        tsResult = await preCompileTSLib(code, inPath, vueResult?.scriptInfo);
         timings.tsCompile = Date.now() - start;
         if (tsResult === undefined || tsResult === null) {
             throw new Error(`preCompileTS devolvió ${tsResult} para archivo: ${inPath}`);
@@ -1665,8 +1666,8 @@ async function compileJS(inPath, outPath, mode = 'individual') {
     start = Date.now();
     // Asegurar que el módulo de transformaciones esté cargado
     await moduleManager.ensureModuleLoaded('transforms');
-    const estandarizaCode = await loadTransforms();
-    const resultSTD = await estandarizaCode(code, inPath);
+    const estandarizaCodeLib = await loadTransforms();
+    const resultSTD = await estandarizaCodeLib(code, inPath);
     timings.standardization = Date.now() - start;
     if (resultSTD === undefined || resultSTD === null) {
         throw new Error(`estandarizaCode devolvió ${resultSTD} para archivo: ${inPath}`);
@@ -1689,8 +1690,9 @@ async function compileJS(inPath, outPath, mode = 'individual') {
         }
         // Asegurar que el módulo de minificación esté cargado
         await moduleManager.ensureModuleLoaded('minify');
-        const minifyJS = await loadMinify();
-        const resultMinify = await minifyJS(code, inPath, true);
+        const minifyJSLib = await loadMinify();
+        const beforeMinification = code; // Guardar código antes de minificar
+        const resultMinify = await minifyJSLib(code, inPath, true);
         timings.minification = Date.now() - start;
         if (resultMinify === undefined || resultMinify === null) {
             throw new Error(`minifyJS devolvió ${resultMinify} para archivo: ${inPath}`);
@@ -1705,6 +1707,20 @@ async function compileJS(inPath, outPath, mode = 'individual') {
         }
         registerCompilationSuccess(inPath, 'minification');
         code = resultMinify.code;
+        // VALIDACIÓN DE INTEGRIDAD - Solo si flag está activo
+        // Esta es una validación redundante (ya se hizo en minify.ts)
+        // pero crítica para asegurar integridad antes de escribir archivo final
+        if (env.CHECK_INTEGRITY === 'true') {
+            const validation = integrityValidator.validate(beforeMinification, code, `compile:${path.basename(inPath)}`, {
+                skipSyntaxCheck: true, // Ya validado en minify.ts
+                verbose: env.VERBOSE === 'true',
+                throwOnError: true,
+            });
+            if (!validation.valid) {
+                logger.error(`❌ Validación de integridad fallida en compilación para ${path.basename(inPath)}`, validation.errors.join(', '));
+                throw new Error(`Compilation integrity check failed for ${path.basename(inPath)}: ${validation.errors.join(', ')}`);
+            }
+        }
     } // Escribir archivo final
     const destinationDir = path.dirname(outPath);
     await mkdir(destinationDir, { recursive: true });
@@ -1741,8 +1757,8 @@ export async function initCompile(ruta, compileTailwind = true, mode = 'individu
         // Generar TailwindCSS si está habilitado
         if (compileTailwind && Boolean(env.TAILWIND)) {
             await moduleManager.ensureModuleLoaded('tailwind');
-            const generateTailwindCSS = await loadTailwind();
-            const resultTW = await generateTailwindCSS();
+            const generateTailwindCSSLib = await loadTailwind();
+            const resultTW = await generateTailwindCSSLib();
             if (typeof resultTW !== 'boolean') {
                 if (resultTW?.success) {
                     logger.info(`🎨 ${resultTW.message}`);
@@ -1789,8 +1805,8 @@ export async function initCompile(ruta, compileTailwind = true, mode = 'individu
                 logger.info(`🔚 Destino: ${outFile}`);
                 logger.info(`⏱️ Tiempo: ${elapsedTime}`);
             }
-            const chalk = await loadChalk();
-            logger.info(chalk.green(`✅ Compilación exitosa: ${path.basename(file)}`));
+            const chalkLib = await loadChalk();
+            logger.info(chalkLib.green(`✅ Compilación exitosa: ${path.basename(file)}`));
         }
         return {
             success: true,
@@ -2004,11 +2020,11 @@ export async function runLinter(showResult = false) {
             const parsedLinterEnv = JSON.parse(linterENV);
             if (Array.isArray(parsedLinterEnv)) {
                 // Cargar dependencias de linting de forma lazy
-                const { ESLint, OxLint } = await loadLinter();
+                const { ESLint: ESLintLib, OxLint: OxLintLib } = await loadLinter();
                 for (const item of parsedLinterEnv) {
                     if (item.name.toLowerCase() === 'eslint') {
                         logger.info(`🔧 Ejecutando ESLint con config: ${item.configFile || 'por defecto'}`);
-                        const eslintPromise = ESLint(item)
+                        const eslintPromise = ESLintLib(item)
                             .then((eslintResult) => {
                             if (eslintResult && eslintResult.json) {
                                 // Procesar resultados de ESLint
@@ -2075,7 +2091,7 @@ export async function runLinter(showResult = false) {
                     }
                     else if (item.name.toLowerCase() === 'oxlint') {
                         logger.info(`🔧 Ejecutando OxLint con config: ${item.configFile || 'por defecto'}`);
-                        const oxlintPromise = OxLint(item)
+                        const oxlintPromise = OxLintLib(item)
                             .then((oxlintResult) => {
                             if (oxlintResult &&
                                 oxlintResult['json'] &&
@@ -2140,8 +2156,8 @@ export async function runLinter(showResult = false) {
                     await displayLinterErrors(linterErrors);
                 }
                 else {
-                    const chalk = await loadChalk();
-                    logger.info(chalk.green('✅ No se encontraron errores ni advertencias de linting.'));
+                    const chalkLib = await loadChalk();
+                    logger.info(chalkLib.green('✅ No se encontraron errores ni advertencias de linting.'));
                 }
             }
             else {
@@ -2345,8 +2361,8 @@ export async function initCompileAll() {
         logger.info(`🔚 Destino: ${pathDist}\n`);
         // Fase 3: TailwindCSS
         progressManager.updateProgress('🎨 Generando TailwindCSS...');
-        const generateTailwindCSS = await loadTailwind();
-        const resultTW = await generateTailwindCSS();
+        const generateTailwindCSSLib = await loadTailwind();
+        const resultTW = await generateTailwindCSSLib();
         if (typeof resultTW !== 'boolean') {
             if (resultTW?.success) {
                 logger.info(`🎨 ${resultTW.message}\n`);
@@ -2437,9 +2453,9 @@ export async function initCompileAll() {
         // ⚠️ Warning si los hilos son muy pocos para el tamaño del proyecto
         const optimalThreads = Math.min(cpuCount * 2, 24);
         if (fileCount > 50 && maxConcurrency < optimalThreads * 0.5) {
-            const chalk = await loadChalk();
-            logger.warn(chalk.yellow(`⚠️  Solo se usarán ${maxConcurrency} hilos para ${fileCount} archivos.`));
-            logger.info(chalk.yellow(`   💡 Tip: export VERSACOMPILER_MAX_THREADS=${optimalThreads}`));
+            const chalkLib = await loadChalk();
+            logger.warn(chalkLib.yellow(`⚠️  Solo se usarán ${maxConcurrency} hilos para ${fileCount} archivos.`));
+            logger.info(chalkLib.yellow(`   💡 Tip: export VERSACOMPILER_MAX_THREADS=${optimalThreads}`));
         }
         // ⚠️ ADVERTENCIA: Si los hilos son muy bajos para el tamaño del proyecto
         if (fileCount > 50 && maxConcurrency < 8) {