versacompiler 2.1.0 → 2.2.0

package/dist/compiler/compile.js

@@ -1,25 +1,2520 @@
-import{createHash as e}from"node:crypto";import{glob as t,mkdir as n,readFile as r,stat as i,unlink as a,writeFile as o}from"node:fs/promises";import s from"node:os";import c from"node:path";import l,{argv as u,cwd as d,env as f}from"node:process";import{logger as p,setProgressManagerGetter as m}from"../servicios/logger.js";import{promptUser as h}from"../utils/promptUser.js";import{showTimingForHumans as g}from"../utils/utils.js";m(()=>Z.getInstance());async function _(e,t,n){let r=new Promise((e,r)=>setTimeout(()=>r(Error(`Timeout en ${n} (${t}ms)`)),t));return Promise.race([e,r])}let v,y,b,x,S,C,w,T,E,D,O;class k{static instance;isInitialized=!1;loadedModules=new Set;modulePool=new Map;loadingPromises=new Map;usageStats=new Map;preloadQueue=new Set;backgroundLoader=null;preloadLock=null;MAX_POOL_MEMORY=100*1024*1024;MAX_POOL_SIZE=15;HOT_MODULES=[`chalk`,`parser`];currentContext=null;constructor(){this.startBackgroundPreloading()}static getInstance(){return k.instance||(k.instance=new k),k.instance}startBackgroundPreloading(){this.backgroundLoader=this.preloadCriticalModules()}async preloadCriticalModules(){try{let e=this.HOT_MODULES.map(e=>this.ensureModuleLoaded(e).catch(()=>{}));await Promise.allSettled(e)}catch{}}async preloadForContext(e,t=new Set){if(this.preloadLock){await this.preloadLock;return}this.preloadLock=this.doPreload(e,t);try{await this.preloadLock}finally{this.preloadLock=null}}async doPreload(e,t=new Set){this.currentContext=e,this.backgroundLoader&&await this.backgroundLoader;let n=[];e===`batch`||e===`watch`?n.push(`transforms`,`vue`,`typescript`,`module-resolution-optimizer`):(t.has(`.vue`)&&n.push(`vue`),(t.has(`.ts`)||t.has(`.vue`))&&n.push(`typescript`),this.loadedModules.has(`transforms`)||n.push(`transforms`));for(let e of[[`chalk`,`parser`],[`transforms`],[`vue`,`typescript`],[`module-resolution-optimizer`],[`minify`]]){let t=e.filter(e=>n.includes(e));t.length>0&&await Promise.allSettled(t.map(async e=>{try{await this.ensureModuleLoaded(e)}catch(t){if(f.VERBOSE===`true`){let n=t instanceof Error?t.message:String(t);console.warn(`[Verbose] Warning: No se pudo precargar módulo ${e}:`,n)}}}))}}async ensureModuleLoaded(e){if(this.modulePool.has(e))return this.updateUsageStats(e),this.modulePool.get(e);if(this.loadingPromises.has(e))return this.loadingPromises.get(e);let t=this.loadModuleInternal(e);this.loadingPromises.set(e,t);try{let n=await t;return this.modulePool.set(e,n),this.loadedModules.add(e),this.updateUsageStats(e),n}finally{this.loadingPromises.delete(e)}}updateUsageStats(e){let t=this.usageStats.get(e)||0;this.usageStats.set(e,t+1)}async loadModuleInternal(e){switch(e){case`chalk`:return this.loadChalk();case`parser`:return this.loadParser();case`transforms`:return this.loadTransforms();case`vue`:return this.loadVue();case`typescript`:return this.loadTypeScript();case`minify`:return this.loadMinify();case`tailwind`:return this.loadTailwind();case`linter`:return this.loadLinter();case`transform-optimizer`:return this.loadTransformOptimizer();case`module-resolution-optimizer`:return this.loadModuleResolutionOptimizer();default:throw Error(`Módulo desconocido: ${e}`)}}async loadChalk(){return v||(v=(await import(`chalk`)).default),v}async loadParser(){return S||(S=(await import(`./parser.js`)).getCodeFile),S}async loadTransforms(){return w||(w=(await import(`./transforms.js`)).estandarizaCode),w}async loadVue(){return E||(E=(await import(`./vuejs.js`)).preCompileVue),E}async loadTypeScript(){return T||(T=(await import(`./typescript-manager.js`)).preCompileTS),T}async loadMinify(){return x||(x=(await import(`./minify.js`)).minifyWithTemplates),x}async loadTailwind(){return C||(C=(await import(`./tailwindcss.js`)).generateTailwindCSS),C}async loadLinter(){if(!y||!b){let e=await import(`./linter.js`);y=e.ESLint,b=e.OxLint}return{ESLint:y,OxLint:b}}async loadTransformOptimizer(){return D||(D=(await import(`./transform-optimizer.js`)).TransformOptimizer.getInstance()),D}async loadModuleResolutionOptimizer(){return O||(O=(await import(`./module-resolution-optimizer.js`)).ModuleResolutionOptimizer.getInstance()),O}getPerformanceStats(){let e=Array.from(this.usageStats.entries()).sort((e,t)=>t[1]-e[1]).slice(0,5).map(([e])=>e);return{loadedModules:Array.from(this.loadedModules),usageStats:Object.fromEntries(this.usageStats),poolSize:this.modulePool.size,loadingInProgress:Array.from(this.loadingPromises.keys()),mostUsedModules:e}}estimateModuleSize(e){let t={"transform-optimizer":5*1024*1024,typescript:10*1024*1024,vue:8*1024*1024,"module-resolution-optimizer":3*1024*1024,transforms:2*1024*1024,minify:2*1024*1024,linter:1*1024*1024,parser:500*1024,chalk:100*1024,default:500*1024};return t[e]??t.default}getPoolMemoryUsage(){let e=0;for(let t of this.modulePool.keys())e+=this.estimateModuleSize(t);return e}cleanupUnusedModules(){let e=this.getPoolMemoryUsage(),t=this.modulePool.size;if(e>this.MAX_POOL_MEMORY||t>this.MAX_POOL_SIZE){let n=Array.from(this.usageStats.entries()).sort((e,t)=>e[1]-t[1]).filter(([e])=>!this.HOT_MODULES.includes(e)),r=this.MAX_POOL_MEMORY*.7,i=this.MAX_POOL_SIZE*.7;for(let[e]of n){this.modulePool.delete(e),this.loadedModules.delete(e),this.usageStats.delete(e);let t=this.getPoolMemoryUsage(),n=this.modulePool.size;if(t<=r&&n<=i)break}f.VERBOSE===`true`&&console.log(`[ModuleManager] Limpieza: ${t} → ${this.modulePool.size} módulos, ${Math.round(e/1024/1024)}MB → ${Math.round(this.getPoolMemoryUsage()/1024/1024)}MB`)}}reset(){this.isInitialized=!1,this.loadedModules.clear(),this.modulePool.clear(),this.loadingPromises.clear(),this.usageStats.clear(),this.preloadQueue.clear(),this.currentContext=null,this.backgroundLoader=null,this.startBackgroundPreloading()}}async function A(){return v||(v=(await import(`chalk`)).default),v}async function j(){if(!y||!b){let e=await import(`./linter.js`);y=e.ESLint,b=e.OxLint}return{ESLint:y,OxLint:b}}async function oe(){return x||(x=(await import(`./minify.js`)).minifyWithTemplates),x}async function M(){return S||(S=(await import(`./parser.js`)).getCodeFile),S}async function N(){return C||(C=(await import(`./tailwindcss.js`)).generateTailwindCSS),C}async function se(){return w||(w=(await import(`./transforms.js`)).estandarizaCode),w}async function ce(){return T||(T=(await import(`./typescript-manager.js`)).preCompileTS),T}async function le(){return E||(E=(await import(`./vuejs.js`)).preCompileVue),E}const P=[],F=[],I=[`NODE_ENV`,`isPROD`,`TAILWIND`,`ENABLE_LINTER`,`VERBOSE`,`typeCheck`,`PATH_ALIAS`,`tailwindcss`,`linter`,`tsconfigFile`];class L{cache=new Map;maxEntries=200;maxMemory=50*1024*1024;currentMemoryUsage=0;fileWatchers=new Map;dependencyGraph=new Map;reverseDependencyGraph=new Map;packageJsonPath=c.join(d(),`package.json`);nodeModulesPath=c.join(d(),`node_modules`);isWatchingDependencies=!1;async generateContentHash(t){try{let n=await r(t,`utf8`);return e(`sha256`).update(n).digest(`hex`)}catch{let n=`${t}-${Date.now()}`;return e(`sha256`).update(n).digest(`hex`)}}generateConfigHash(){try{let t={isPROD:f.isPROD||`false`,TAILWIND:f.TAILWIND||`false`,ENABLE_LINTER:f.ENABLE_LINTER||`false`,PATH_ALIAS:f.PATH_ALIAS||`{}`,tailwindcss:f.tailwindcss||`false`,linter:f.linter||`false`,tsconfigFile:f.tsconfigFile||`./tsconfig.json`},n=JSON.stringify(t,Object.keys(t).sort());return e(`sha256`).update(n).digest(`hex`).substring(0,12)}catch{return`no-config`}}generateEnvHash(){try{let t=I.map(e=>`${e}=${f[e]||``}`).join(`|`);return e(`sha256`).update(t).digest(`hex`).substring(0,12)}catch{return`no-env`}}async generateDependencyHash(){try{let t=e(`sha256`),n=await r(c.join(d(),`package.json`),`utf8`),a=JSON.parse(n),o={...a.dependencies,...a.devDependencies},s=JSON.stringify(o,Object.keys(o).sort());t.update(`package:${s}`);try{let e=await r(c.join(d(),`package-lock.json`),`utf8`),n=JSON.parse(e),i={};if(n.packages){for(let[e,t]of Object.entries(n.packages))if(e&&e!==``&&typeof t==`object`&&t){let n=e.replace(`node_modules/`,``);t.version&&(i[n]=t.version)}}t.update(`lock:${JSON.stringify(i,Object.keys(i).sort())}`)}catch{}try{let e=c.join(d(),`node_modules`),n=await i(e);t.update(`nmtime:${n.mtimeMs}`);let r=Object.keys(o).slice(0,10);for(let n of r)try{let r=await i(c.join(e,n));t.update(`${n}:${r.mtimeMs}`)}catch{t.update(`${n}:missing`)}}catch{t.update(`nmtime:none`)}return t.digest(`hex`).substring(0,16)}catch(t){return e(`sha256`).update(`error:${t instanceof Error?t.message:`unknown`}`).digest(`hex`).substring(0,16)}}async generateCacheKey(e){let t=await this.generateContentHash(e),n=this.generateConfigHash(),r=this.generateEnvHash(),i=await this.generateDependencyHash();return`${e}|${t.substring(0,12)}|${n}|${r}|${i}`}async isValid(e){let t=this.cache.get(e);if(!t)return!1;try{await i(t.outputPath);let n=await this.generateContentHash(e);if(t.contentHash!==n)return this.cache.delete(e),!1;let r=this.generateConfigHash();if(t.configHash!==r)return this.cache.delete(e),!1;let a=this.generateEnvHash();if(t.envHash!==a)return this.cache.delete(e),!1;let o=await this.generateDependencyHash();return t.dependencyHash!==o||(await i(e)).mtimeMs>t.mtime?(this.cache.delete(e),!1):(t.lastUsed=Date.now(),!0)}catch{return this.cache.delete(e),!1}}async set(e,t){try{let n=await i(e),r={contentHash:await this.generateContentHash(e),configHash:this.generateConfigHash(),envHash:this.generateEnvHash(),dependencyHash:await this.generateDependencyHash(),mtime:n.mtimeMs,outputPath:t,lastUsed:Date.now(),size:n.size};this.evictIfNeeded(r.size),this.cache.set(e,r),this.currentMemoryUsage+=r.size}catch(t){console.warn(`Warning: No se pudo cachear ${e}:`,t)}}evictIfNeeded(e){for(;this.cache.size>=this.maxEntries*.8;)this.evictLRU();for(;this.currentMemoryUsage+e>this.maxMemory*.8&&this.cache.size>0;)this.evictLRU();if(l.memoryUsage().heapUsed/(1024*1024)>200&&this.cache.size>50){let e=Math.min(this.cache.size-50,10);for(let t=0;t<e;t++)this.evictLRU()}}evictLRU(){let e=``,t=1/0;for(let[n,r]of this.cache)r.lastUsed<t&&(t=r.lastUsed,e=n);if(e){let t=this.cache.get(e);t&&(this.currentMemoryUsage-=t.size,this.cache.delete(e))}}cleanOldEntries(e=20){let t=0;for(let n=0;n<e&&this.cache.size>0;n++){let e=this.cache.size;if(this.evictLRU(),this.cache.size<e)t++;else break}return t}async load(e){try{if(f.cleanCache===`true`){this.cache.clear(),this.currentMemoryUsage=0;try{await a(e)}catch{}return}let t=await r(e,`utf-8`),n=JSON.parse(t);for(let[e,t]of Object.entries(n)){let n=t;n.contentHash&&n.outputPath&&n.mtime&&(this.cache.set(e,n),this.currentMemoryUsage+=n.size||0)}}catch{this.cache.clear(),this.currentMemoryUsage=0}}async save(e,t){try{await n(t,{recursive:!0});let r=Object.fromEntries(this.cache);await o(e,JSON.stringify(r,null,2))}catch(e){console.warn(`Warning: No se pudo guardar el cache:`,e)}}clear(){this.cache.clear(),this.currentMemoryUsage=0}getOutputPath(e){return this.cache.get(e)?.outputPath||``}getStats(){return{entries:this.cache.size,memoryUsage:this.currentMemoryUsage,hitRate:0}}async startDependencyWatching(){if(!this.isWatchingDependencies)try{let e=await import(`chokidar`);if(await this.fileExists(this.packageJsonPath)){let t=e.watch(this.packageJsonPath,{persistent:!1,ignoreInitial:!0});t.on(`change`,()=>{p.info(`📦 package.json modificado - invalidando cache de dependencias`),this.invalidateByDependencyChange()}),this.fileWatchers.set(`package.json`,t)}if(await this.fileExists(this.nodeModulesPath)){let t=e.watch(this.nodeModulesPath,{persistent:!1,ignoreInitial:!0,depth:1,ignored:/(^|[/\\])\../});t.on(`addDir`,e=>{p.info(`📦 Nueva dependencia instalada: ${e.split(/[/\\]/).pop()}`),this.invalidateByDependencyChange()}),t.on(`unlinkDir`,e=>{p.info(`📦 Dependencia eliminada: ${e.split(/[/\\]/).pop()}`),this.invalidateByDependencyChange()}),this.fileWatchers.set(`node_modules`,t)}this.isWatchingDependencies=!0,p.info(`🔍 Vigilancia de dependencias iniciada`)}catch(e){p.warn(`⚠️ No se pudo iniciar vigilancia de dependencias:`,e)}}async stopDependencyWatching(){for(let[e,t]of this.fileWatchers)try{await t.close(),p.info(`🛑 Vigilancia detenida: ${e}`)}catch(t){p.warn(`⚠️ Error cerrando watcher ${e}:`,t)}this.fileWatchers.clear(),this.isWatchingDependencies=!1}registerDependencies(e,t){let n=this.dependencyGraph.get(e);if(n)for(let t of n){let n=this.reverseDependencyGraph.get(t);n&&(n.delete(e),n.size===0&&this.reverseDependencyGraph.delete(t))}let r=new Set(t);this.dependencyGraph.set(e,r);for(let t of r)this.reverseDependencyGraph.has(t)||this.reverseDependencyGraph.set(t,new Set),this.reverseDependencyGraph.get(t).add(e)}invalidateByDependencyChange(){let e=0;for(let[t]of this.cache)this.cache.delete(t),e++;this.dependencyGraph.clear(),this.reverseDependencyGraph.clear(),this.currentMemoryUsage=0,p.info(`🗑️ Cache invalidado: ${e} archivos (cambio en dependencias)`)}invalidateCascade(e){let t=[],n=new Set([e]),r=[e];for(;r.length>0;){let e=r.shift(),t=this.reverseDependencyGraph.get(e);if(t)for(let e of t)n.has(e)||(n.add(e),r.push(e))}for(let e of n)if(this.cache.has(e)){let n=this.cache.get(e);this.currentMemoryUsage-=n.size,this.cache.delete(e),t.push(e)}return t.length>0&&p.info(`🔄 Invalidación cascada: ${t.length} archivos afectados por ${e}`),t}async fileExists(e){try{return await i(e),!0}catch{return!1}}getAdvancedStats(){return{entries:this.cache.size,memoryUsage:this.currentMemoryUsage,hitRate:0,dependencyNodes:this.dependencyGraph.size,watchingDependencies:this.isWatchingDependencies,activeWatchers:this.fileWatchers.size}}}const R=new L,z=c.join(c.resolve(f.PATH_PROY||d(),`compiler`),`.cache`),B=c.join(z,`versacompile-cache.json`);async function ue(){await R.load(B),(f.WATCH_MODE===`true`||u.includes(`--watch`)||u.includes(`-w`))&&await R.startDependencyWatching()}async function de(){await R.save(B,z)}function V(e,t,n,r=`error`,i,a){P.push({file:e,stage:t,message:n,severity:r,details:i,help:a,timestamp:Date.now()})}function H(e,t,n,r=[]){let i=F.find(t=>t.stage===e);i?(i.errors+=t,i.success+=n,i.files.push(...r)):F.push({stage:e,errors:t,success:n,files:[...r]})}async function U(e,t,n,r,i=!1){let a=e instanceof Error?e.message:e,o=e instanceof Error?e.stack:void 0;if(V(t,n,a,`error`,o),H(n,1,0,[t]),r===`individual`||r===`watch`){let e=await A(),r=c.basename(t),s=await J(n);if(i)p.error(e.red(`❌ Error en etapa ${s(n)} - ${r}:`)),p.error(e.red(a)),o&&(n===`typescript`||n===`vue`)&&o.split(`
-`).slice(0,5).forEach(t=>{t.trim()&&p.error(e.gray(`  ${t.trim()}`))});else{let t=a.split(`
-`)[0];p.error(e.red(`❌ Error en ${s(n)}: ${r}`)),p.error(e.red(`   ${t}`)),p.info(e.yellow(`💡 Usa --verbose para ver detalles completos`))}}}function W(e,t){H(t,0,1,[e])}function G(){P.length=0,F.length=0}async function K(e=!1,t){let n=await A();if(P.length===0&&F.length===0){p.info(n.green(`✅ No hay errores de compilación para mostrar.`)),t&&p.info(n.bold(`\n⏱️ TIEMPO TOTAL DE COMPILACIÓN: ${t}`));return}let r=`━`.repeat(40);if(p.info(``),p.info(n.bold.cyan(`📊 Resumen de Compilación`)),p.info(n.gray(r)),t&&(p.info(n.bold(`⏱️  Tiempo Total: ${n.green(t)}`)),p.info(``)),F.length>0){p.info(n.bold.blue(`🔧 Estadísticas por Etapa:`));for(let e of F){let t=e.success+e.errors,r=t>0?Math.round(e.success/t*100):0,i=_e(e.stage),a=e.errors===0?n.green:n.red,o=$(r,20);p.info(`   ${i} ${n.bold(e.stage)}`),p.info(`     ${a(`●`)} ${e.success}/${t} archivos ${a(`(${r}%)`)}`),p.info(`     ${o}`),e.errors>0&&p.info(`     ${n.red(`⚠`)} ${e.errors} ${e.errors===1?`error`:`errores`}`),p.info(``)}}if(P.length>0){p.info(n.red(`\n❌ Se encontraron ${P.length} errores:`));let t=new Map;P.forEach(e=>{t.has(e.file)||t.set(e.file,[]),t.get(e.file).push(e)});let r=1;for(let[i,a]of t){let t=c.basename(i),o=a.filter(e=>e.severity===`error`).length,s=a.filter(e=>e.severity===`warning`).length;p.info(n.cyan(`\n📄 ${r}. ${t}`)),p.info(n.gray(`   Ruta: ${i}`)),p.info(n.yellow(`   ${o} errores, ${s} advertencias`));for(let t of a){let r=t.severity===`error`?`❌`:`⚠️`,i=await J(t.stage);p.info(`   ${r} [${i(t.stage)}] ${t.message}`),e&&t.details&&t.details.split(`
-`).slice(0,5).forEach(e=>{e.trim()&&p.info(n.gray(`      ${e.trim()}`))}),t.help&&p.info(n.blue(`      💡 ${t.help}`))}r++}let i=P.filter(e=>e.severity===`error`).length,a=P.filter(e=>e.severity===`warning`).length,o=t.size,s=`═`.repeat(50);p.info(``),p.info(n.bold.cyan(s)),p.info(n.bold.cyan(`                📊 RESUMEN FINAL`)),p.info(n.bold.cyan(s)),p.info(``),p.info(n.bold(`🎯 Resultados:`)),p.info(`   📁 Archivos afectados: ${n.cyan.bold(o)}`),p.info(`   ${i>0?n.red(`●`):n.green(`○`)} Errores: ${i>0?n.red.bold(i):n.green.bold(`0`)}`),p.info(`   ${a>0?n.yellow(`●`):n.green(`○`)} Advertencias: ${a>0?n.yellow.bold(a):n.green.bold(`0`)}`),p.info(``),i>0?(p.info(n.red.bold(`🚨 COMPILACIÓN COMPLETADA CON ERRORES`)),p.info(n.red(`   Por favor revisa y corrige los problemas anteriores.`))):a>0?(p.info(n.yellow.bold(`⚠️  COMPILACIÓN COMPLETADA CON ADVERTENCIAS`)),p.info(n.yellow(`   Considera revisar las advertencias anteriores.`))):(p.info(n.green.bold(`✅ COMPILACIÓN EXITOSA`)),p.info(n.green(`   ¡Todos los archivos se compilaron sin problemas!`))),p.info(``),p.info(n.bold.cyan(s))}else{let e=`═`.repeat(50);p.info(``),p.info(n.bold.green(e)),p.info(n.bold.green(`                ✨ ÉXITO`)),p.info(n.bold.green(e)),p.info(``),p.info(n.green.bold(`🎉 COMPILACIÓN COMPLETADA EXITOSAMENTE`)),p.info(n.green(`   ¡No se encontraron errores ni advertencias!`)),p.info(``),p.info(n.bold.green(e))}p.info(``)}async function q(e){let t=await A(),n=new Map;e.forEach(e=>{n.has(e.file)||n.set(e.file,[]),n.get(e.file).push(e)});let r=e.filter(e=>e.severity===`error`).length,i=e.filter(e=>e.severity===`warning`).length,a=n.size;p.info(t.bold.rgb(255,120,120)(`╭─────────────────────────────────────────────────────────────╮`)),p.info(t.bold.rgb(255,120,120)(`│                    `)+t.bold.white(`🔍 LINTER REPORT`)+t.bold.rgb(255,120,120)(`                    │`)),p.info(t.bold.rgb(255,120,120)(`╰─────────────────────────────────────────────────────────────╯`));let o=r>0?t.red(`●`):t.green(`○`),s=i>0?t.yellow(`●`):t.green(`○`);if(p.info(``),p.info(t.bold(`📊 Summary:`)),p.info(`   ${o} ${t.bold(r)} ${t.red(`errors`)}`),p.info(`   ${s} ${t.bold(i)} ${t.yellow(`warnings`)}`),p.info(`   📁 ${t.bold(a)} ${t.cyan(`files`)}`),p.info(``),r===0&&i===0){p.info(t.green.bold(`✨ All checks passed! No issues found.`));return}let c=1;for(let[e,r]of n)await fe(e,r,c,a),c++,c<=a&&p.info(t.gray(`─`.repeat(80)));p.info(``),p.info(t.bold.rgb(255,120,120)(`╭─────────────────────────────────────────────────────────────╮`)),p.info(t.bold.rgb(255,120,120)(`│  `)+t.bold.white(`Found ${r+i} issues in ${a} files`)+` `.repeat(Math.max(0,52-`Found ${r+i} issues in ${a} files`.length))+t.bold.rgb(255,120,120)(`  │`)),p.info(t.bold.rgb(255,120,120)(`╰─────────────────────────────────────────────────────────────╯`))}async function fe(e,t,n,r){let i=await A(),a=t.filter(e=>e.severity===`error`).length,o=t.filter(e=>e.severity===`warning`).length,s=a>0?i.red(`✕`):i.yellow(`⚠`),u=e.endsWith(`.vue`)?`🎨`:e.endsWith(`.ts`)?`📘`:e.endsWith(`.js`)?`📜`:`📄`;p.info(``),p.info(i.bold(`${s} ${u} ${i.cyan(c.relative(l.cwd(),e))}`)),p.info(i.gray(`   ${a} errors, ${o} warnings`)),p.info(``);for(let n=0;n<t.length;n++){let r=t[n];await pe(r,e,n+1,t.length)}}async function pe(e,t,n,r){let i=await A(),a=await import(`node:fs/promises`),o=e.severity===`error`,s=o?i.red:i.yellow,l=o?`✕`:`⚠`,u=e.line||1,d=e.column||1,f=e.ruleId||e.from||`unknown`,m=`  ${s(l)} ${i.bold(e.message)}`,h=`${i.gray(f)}`,g=`${i.blue(`${u}:${d}`)}`;p.info(m),p.info(`    ${i.gray(`at`)} ${g} ${i.gray(`·`)} ${h}`);try{let e=c.resolve(t),n=(await a.readFile(e,`utf-8`)).split(`
-`),r=parseInt(u.toString())-1;if(r>=0&&r<n.length){p.info(``);let e=Math.max(0,r-1),t=Math.min(n.length-1,r+1),a=(t+1).toString().length;for(let o=e;o<=t;o++){let e=o+1,t=n[o]||``,c=e.toString().padStart(a,` `);if(o===r){p.info(`    ${i.red(`>`)} ${i.gray(c)} ${i.gray(`│`)} ${t}`);let e=` `.repeat(Math.max(0,d-1))+s(`^`);p.info(`    ${i.gray(` `)} ${i.gray(` `.repeat(a))} ${i.gray(`│`)} ${e}`)}else p.info(`    ${i.gray(` `)} ${i.gray(c)} ${i.gray(`│`)} ${i.gray(t)}`)}}}catch{p.info(`    ${i.gray(`│`)} ${i.gray(`(Unable to read file content)`)}`)}if(e.help){p.info(``);let t=e.help.replace(/^Regla \w+: /,``).trim();p.info(`    ${i.blue(`💡`)} ${i.blue(`Help:`)} ${i.gray(t)}`)}n<r&&p.info(``)}async function J(e){let t=await A();switch(e){case`vue`:return t.green;case`typescript`:return t.blue;case`standardization`:return t.yellow;case`minification`:return t.red;case`tailwind`:return t.magenta;case`file-read`:return t.gray;default:return t.white}}export function normalizeRuta(e){if(c.isAbsolute(e))return c.normalize(e).replace(/\\/g,`/`);let t=c.normalize(e.startsWith(`.`)?e:`./`+e).replace(/\\/g,`/`);return t.startsWith(`./`)?t:`./${t}`}export function getOutputPath(e){let t=f.PATH_SOURCE??``,n=f.PATH_DIST??``;if(!t||!n)return e.replace(/\.(vue|ts)$/,`.js`);let r=c.normalize(e).replace(/\\/g,`/`),i=c.normalize(t).replace(/\\/g,`/`),a=c.normalize(n).replace(/\\/g,`/`),o;if(r.includes(i)){let e=r.substring(r.indexOf(i)+i.length).replace(/^[/\\]/,``);o=c.join(a,e).replace(/\\/g,`/`)}else{let e=c.basename(r);o=c.join(a,e).replace(/\\/g,`/`)}return o.includes(`vue`)||o.includes(`ts`)?o.replace(/\.(vue|ts)$/,`.js`):o}class Y{static instance;fileSystemCache=new Map;debounceTimers=new Map;DEBOUNCE_DELAY=100;static getInstance(){return Y.instance||(Y.instance=new Y),Y.instance}async compileForWatch(e,t){return new Promise(n=>{let r=this.debounceTimers.get(e);r&&clearTimeout(r);let a=setTimeout(async()=>{this.debounceTimers.delete(e);try{let r=await i(e),a=this.fileSystemCache.get(e);if(a&&a.mtime>=r.mtimeMs){n({success:!0,cached:!0});return}let{TypeScriptWorkerPool:o}=await import(`./typescript-worker-pool.js`);o.getInstance().setMode(`watch`);let s=await t(e);this.fileSystemCache.set(e,{mtime:r.mtimeMs}),n(s)}catch(e){n({success:!1,error:e})}},this.DEBOUNCE_DELAY);this.debounceTimers.set(e,a)})}cleanup(){this.debounceTimers.forEach(e=>clearTimeout(e)),this.debounceTimers.clear(),this.fileSystemCache.clear()}}async function me(e,t,r=`individual`){let i={};e=c.isAbsolute(e)?normalizeRuta(e):normalizeRuta(c.resolve(e));let a=k.getInstance(),s=Date.now(),l=c.extname(e);await a.ensureModuleLoaded(`parser`);let u=await(await M())(e),d=u.code,m=u.error;if(i.fileRead=Date.now()-s,m)throw await U(m instanceof Error?m:Error(String(m)),e,`file-read`,r,f.VERBOSE===`true`),Error(m instanceof Error?m.message:String(m));if(!d||d.trim().length===0||d===`undefined`||d===`null`)throw await U(Error(`El archivo está vacío o no se pudo leer.`),e,`file-read`,r,f.VERBOSE===`true`),Error(`El archivo está vacío o no se pudo leer.`);let h=f.VERBOSE===`true`,g;if(l===`.vue`){s=Date.now(),h&&p.info(v.green(`💚 Precompilando VUE: ${c.basename(e)}`)),await a.ensureModuleLoaded(`vue`);let t=await le();if(typeof t!=`function`)throw Error(`loadVue devolvió ${typeof t} en lugar de una función para archivo: ${e}`);if(g=await t(d,e,f.isPROD===`true`),i.vueCompile=Date.now()-s,g==null)throw Error(`preCompileVue devolvió ${g} para archivo: ${e}`);if(g.error)throw await U(g.error instanceof Error?g.error:Error(String(g.error)),e,`vue`,r,f.VERBOSE===`true`),Error(g.error instanceof Error?g.error.message:String(g.error));W(e,`vue`),d=g.data}if(!d||d.trim().length===0)throw await U(Error(`El código Vue compilado está vacío.`),e,`vue`,r,f.VERBOSE===`true`),Error(`El código Vue compilado está vacío.`);let _;if(l===`.ts`||g?.lang===`ts`){s=Date.now(),h&&p.info(v.blue(`🔄️ Precompilando TS: ${c.basename(e)}`)),await a.ensureModuleLoaded(`typescript`);let t=await ce();if(typeof t!=`function`)throw Error(`loadTypeScript devolvió ${typeof t} en lugar de una función para archivo: ${e}`);if(_=await t(d,e),i.tsCompile=Date.now()-s,_==null)throw Error(`preCompileTS devolvió ${_} para archivo: ${e}`);if(_.error)if(r===`all`)V(e,`typescript`,_.error instanceof Error?_.error.message:String(_.error),`error`);else throw await U(_.error,e,`typescript`,r,f.VERBOSE===`true`),Error(_.error instanceof Error?_.error.message:String(_.error));else W(e,`typescript`),d=_.data}if(!d||d.trim().length===0)throw await U(Error(`El código TypeScript compilado está vacío.`),e,`typescript`,r,f.VERBOSE===`true`),Error(`El código TypeScript compilado está vacío.`);h&&p.info(v.yellow(`💛 Estandarizando: ${c.basename(e)}`)),s=Date.now(),await a.ensureModuleLoaded(`transforms`);let y=await(await se())(d,e);if(i.standardization=Date.now()-s,y==null)throw Error(`estandarizaCode devolvió ${y} para archivo: ${e}`);if(y.error)throw await U(Error(y.error),e,`standardization`,r,f.VERBOSE===`true`),Error(y.error);if(W(e,`standardization`),d=y.code,!d||d.trim().length===0)throw await U(Error(`El código estandarizado está vacío.`),e,`standardization`,r,f.VERBOSE===`true`),Error(`El código estandarizado está vacío.`);if(f.isPROD===`true`){s=Date.now(),h&&p.info(v.red(`🤖 Minificando: ${c.basename(e)}`)),await a.ensureModuleLoaded(`minify`);let t=await(await oe())(d,e,!0);if(i.minification=Date.now()-s,t==null)throw Error(`minifyJS devolvió ${t} para archivo: ${e}`);if(t.error)throw await U(t.error instanceof Error?t.error:Error(String(t.error)),e,`minification`,r,f.VERBOSE===`true`),Error(t.error instanceof Error?t.error.message:String(t.error));W(e,`minification`),d=t.code}if(await n(c.dirname(t),{recursive:!0}),await o(t,d,`utf-8`),h){let t=Object.values(i).reduce((e,t)=>e+t,0);p.info(v.cyan(`⏱️ Timing para ${c.basename(e)}:`)),i.fileRead&&p.info(v.cyan(`  📖 Lectura: ${i.fileRead}ms`)),i.vueCompile&&p.info(v.cyan(`  💚 Vue: ${i.vueCompile}ms`)),i.tsCompile&&p.info(v.cyan(`  🔄️ TypeScript: ${i.tsCompile}ms`)),i.standardization&&p.info(v.cyan(`  💛 Estandarización: ${i.standardization}ms`)),i.minification&&p.info(v.cyan(`  🤖 Minificación: ${i.minification}ms`)),p.info(v.cyan(`  🏁 Total: ${t}ms`))}return{error:null,action:`extension`}}export async function initCompile(e,t=!0,n=`individual`){try{let r=k.getInstance(),i=c.extname(e),a=new Set([i]);if(await r.preloadForContext(n===`all`?`batch`:n,a),t&&f.TAILWIND){await r.ensureModuleLoaded(`tailwind`);let e=await(await N())();if(typeof e!=`boolean`)if(e?.success)p.info(`🎨 ${e.message}`);else{let t=`${e.message}${e.details?`
-`+e.details:``}`;await U(Error(t),`tailwind.config.js`,`tailwind`,n,f.VERBOSE===`true`)}}let o=Date.now(),s=normalizeRuta(e),l=getOutputPath(s);if((n===`watch`||n===`individual`)&&await Q(s))return f.VERBOSE===`true`&&p.info(`⏭️ Archivo omitido (cache): ${c.basename(s)}`),{success:!0,cached:!0,output:R.getOutputPath(s)||l,action:`cached`};n===`individual`&&f.VERBOSE===`true`&&p.info(`🔜 Fuente: ${s}`);let u=await me(s,l,n);if(u.error)throw Error(u.error);(n===`watch`||n===`individual`)&&await R.set(s,l);let d=g(Date.now()-o);if(n===`individual`){f.VERBOSE===`true`&&(p.info(`🔚 Destino: ${l}`),p.info(`⏱️ Tiempo: ${d}`));let e=await A();p.info(e.green(`✅ Compilación exitosa: ${c.basename(s)}`))}return{success:!0,output:l,action:u.action}}catch(t){let n=t instanceof Error?t.message:String(t);return f.VERBOSE===`true`&&p.error(`❌ Error en compilación de ${c.basename(e)}: ${n}`),{success:!1,output:``,error:n}}}let X=0;class Z{static instance;progressActive=!1;lastProgressLine=``;logBuffer=[];originalConsoleLog;originalConsoleError;originalConsoleWarn;hasProgressLine=!1;constructor(){this.originalConsoleLog=console.log,this.originalConsoleError=console.error,this.originalConsoleWarn=console.warn}static getInstance(){return Z.instance||(Z.instance=new Z),Z.instance}interceptConsole(){console.log=(...e)=>{this.addLog(e.map(e=>String(e)).join(` `))},console.error=(...e)=>{this.addLog(e.map(e=>String(e)).join(` `))},console.warn=(...e)=>{this.addLog(e.map(e=>String(e)).join(` `))}}restoreConsole(){console.log=this.originalConsoleLog,console.error=this.originalConsoleError,console.warn=this.originalConsoleWarn}startProgress(){this.progressActive=!0,this.logBuffer=[],this.hasProgressLine=!1,this.interceptConsole();let e=`━`.repeat(48);l.stdout.write(`
-\x1B[96m`+e+`\x1B[0m
-`),l.stdout.write(`\x1B[96m│ \x1B[97m\x1B[1m🚀 Iniciando Compilación\x1B[0m\x1B[96m`+` `.repeat(22)+`│\x1B[0m
-`),l.stdout.write(`\x1B[96m`+e+`\x1B[0m
-`)}updateProgress(e){if(!this.progressActive)return;if(this.logBuffer.length>0){this.hasProgressLine&&l.stdout.write(`\r\x1B[K`);for(let e of this.logBuffer)l.stdout.write((this.hasProgressLine?`
-`:``)+e+`
-`),this.hasProgressLine=!1;this.logBuffer=[]}this.hasProgressLine?l.stdout.write(`\r\x1B[K`):l.stdout.write(`
-\x1B[96m`+`▔`.repeat(50)+`\x1B[0m
-`);let t=this.getStageFromText(e),{bgColor:n,textColor:r,icon:i}=this.getProgressColors(t),a=`█`.repeat(3),o=`\x1b[${n}m\x1b[${r}m ${a} ${i} ${e} ${a} \x1b[0m`;l.stdout.write(o),this.hasProgressLine=!0,this.lastProgressLine=e}addLog(e){this.progressActive?this.logBuffer.push(e):this.originalConsoleLog(e)}addImmediateLog(e){this.progressActive?(this.hasProgressLine&&l.stdout.write(`\r\x1B[K`),l.stdout.write(`\x1B[90m│\x1B[0m `+e+`
-`),this.hasProgressLine=!1):this.originalConsoleLog(e)}endProgress(){if(this.progressActive){this.hasProgressLine&&l.stdout.write(`
-`),l.stdout.write(`
-\x1B[33m`+`-`.repeat(50)+`\x1B[0m
-`);let e=`█`.repeat(3),t=`\x1b[42m\x1b[30m ${e} ✅ PROCESO COMPLETADO 100% ${e} \x1b[0m`;l.stdout.write(t+`
-`);let n=`━`.repeat(48);if(l.stdout.write(`\x1B[92m`+n+`\x1B[0m
-`),l.stdout.write(`\x1B[92m│ \x1B[97m\x1B[1m✅ ¡Compilación Completada!\x1B[0m\x1B[92m`+` `.repeat(23)+`│\x1B[0m
-`),l.stdout.write(`\x1B[92m`+n+`\x1B[0m
-
-`),this.logBuffer.length>0)for(let e of this.logBuffer)l.stdout.write(e+`
-`)}this.restoreConsole(),this.progressActive=!1,this.lastProgressLine=``,this.logBuffer=[],this.hasProgressLine=!1}isActive(){return this.progressActive}getStageFromText(e){return e.includes(`Iniciando`)||e.includes(`Starting`)?`start`:e.includes(`Tailwind`)||e.includes(`CSS`)?`tailwind`:e.includes(`Recopilando`)||e.includes(`archivos`)||e.includes(`files`)?`files`:e.includes(`Compilando`)||e.includes(`workers`)?`compile`:e.includes(`cache`)||e.includes(`Guardando`)?`cache`:e.includes(`linter`)||e.includes(`Linter`)?`linter`:e.includes(`completado`)||e.includes(`Complete`)?`complete`:`default`}getProgressColors(e){return{start:{bgColor:`45`,textColor:`97`,icon:`🚀`},tailwind:{bgColor:`105`,textColor:`97`,icon:`🎨`},files:{bgColor:`43`,textColor:`30`,icon:`📁`},compile:{bgColor:`42`,textColor:`30`,icon:`⚙️`},cache:{bgColor:`44`,textColor:`97`,icon:`💾`},linter:{bgColor:`101`,textColor:`97`,icon:`🔍`},complete:{bgColor:`102`,textColor:`30`,icon:`✅`},default:{bgColor:`100`,textColor:`30`,icon:`⏳`}}[e]||{bgColor:`100`,textColor:`30`,icon:`⏳`}}}export async function runLinter(e=!1){let t=f.linter,n=[],r=[],i=!0;if(f.ENABLE_LINTER!==`true`)return!0;if(typeof t==`string`&&t.trim()!==``){p.info(`🔍 Ejecutando linting...`);try{let a=JSON.parse(t);if(Array.isArray(a)){let{ESLint:e,OxLint:t}=await j();for(let i of a)if(i.name.toLowerCase()===`eslint`){p.info(`🔧 Ejecutando ESLint con config: ${i.configFile||`por defecto`}`);let t=e(i).then(e=>{e&&e.json&&(Array.isArray(e.json)?e.json.forEach(e=>{let t=e.filePath||e.file||`archivo no especificado`;r.push({from:`eslint`,line:e.line||`N/A`,column:e.column||1,file:t,message:e.message,severity:e.severity===2?`error`:`warning`,help:e.ruleId?`Regla ESLint: ${e.ruleId}`:void 0})}):e.json.results&&Array.isArray(e.json.results)&&e.json.results.forEach(e=>{e.messages&&Array.isArray(e.messages)&&e.messages.forEach(t=>{let n=e.filePath||e.file||`archivo no especificado`;r.push({from:`eslint`,line:t.line||`N/A`,column:t.column||1,file:n,message:t.message,severity:t.severity===2?`error`:`warning`,help:t.ruleId?`Regla ESLint: ${t.ruleId}`:void 0})})}))}).catch(e=>{p.error(`❌ Error durante la ejecución de ESLint: ${e.message}`),r.push({file:i.configFile||`ESLint Config`,message:`Fallo al ejecutar ESLint: ${e.message}`,severity:`error`})});n.push(t)}else if(i.name.toLowerCase()===`oxlint`){p.info(`🔧 Ejecutando OxLint con config: ${i.configFile||`por defecto`}`);let e=t(i).then(e=>{e&&e.json&&Array.isArray(e.json.diagnostics)&&e.json.diagnostics.forEach(e=>{let t=e.filename||e.file||`archivo no especificado`,n=e.labels&&e.labels[0]&&e.labels[0].span?e.labels[0].span.line||e.labels[0].span.start?.line:`N/A`,i=e.labels&&e.labels[0]&&e.labels[0].span?e.labels[0].span.column||e.labels[0].span.start?.column:1;r.push({from:`oxlint`,line:n,column:i,file:t,message:e.message,severity:typeof e.severity==`string`?e.severity.toLowerCase():`error`,help:e.help||(e.code?`Regla Oxlint: ${e.code}`:void 0)})})}).catch(e=>{p.error(`❌ Error durante la ejecución de OxLint: ${e.message}`),r.push({file:i.configFile||`Oxlint Config`,message:`Fallo al ejecutar Oxlint: ${e.message}`,severity:`error`})});n.push(e)}}else p.warn(`⚠️ La configuración de linter no es un array válido.`);if(await Promise.all(n),e)if(r.length>0)await q(r);else{let e=await A();p.info(e.green(`✅ No se encontraron errores ni advertencias de linting.`))}else r.length>0&&(await q(r),p.warn(`🚨 Se encontraron errores o advertencias durante el linting.`),f.yes===`false`&&(await h(`¿Deseas continuar con la compilación a pesar de los errores de linting? (s/N): `)).toLowerCase()!==`s`&&(p.info(`🛑 Compilación cancelada por el usuario.`),i=!1))}catch(e){p.warn(`Error parseando configuración de linter: ${e instanceof Error?e.message:`Error desconocido`}, omitiendo...`)}}return i}function he(e,t,n=30){let r=Math.round(e/t*100),i=Math.round(r/100*n),a=n-i;return`[${`█`.repeat(i)}${` `.repeat(a)}] ${r}% (${e}/${t})`}async function Q(e){return await R.isValid(e)}async function ge(e,t=8){let n=[],r=[],i=e.length,a=0,o=0,s=0,u=Z.getInstance(),d=!1,m=0;function h(){let e=a+o+s,t=he(e,i),n=Math.round(e/i*100);if(e===0&&!d||n>X+1&&e>0||e===i){let r=`🚀 ${t} [✅ ${a} | ⏭️ ${o} | ❌ ${s}]`;u.updateProgress(r),e===0&&(d=!0),X=n}}h();for(let i of e){let e=(async()=>{try{if(f.VERBOSE===`true`&&p.info(`🔄 Compilando: ${c.basename(i)}`),await Q(i))return o++,f.VERBOSE===`true`&&p.info(`⏭️ Archivo omitido (cache): ${c.basename(i)}`),h(),{success:!0,cached:!0,output:R.getOutputPath(i)};let e=await initCompile(i,!1,`batch`);if(e.success&&e.output?(await R.set(i,e.output),f.VERBOSE===`true`&&p.info(`✅ Completado: ${c.basename(i)} → ${c.basename(e.output)}`)):f.VERBOSE===`true`&&p.info(`❌ Error en: ${c.basename(i)}`),a++,m++,m%20==0){try{typeof globalThis.gc==`function`&&globalThis.gc()}catch{}let e=l.memoryUsage().heapUsed/(1024*1024);if(e>300&&R.getStats().entries>50){console.log(`[Memory] Heap alto (${e.toFixed(1)}MB), limpiando cache...`);let t=R.cleanOldEntries(20);t>0&&console.log(`[Memory] Se removieron ${t} entradas del cache`)}}return h(),e}catch(e){if(s++,f.VERBOSE===`true`){let t=e instanceof Error?e.message:String(e);p.error(`💥 Falló: ${c.basename(i)} - ${t}`)}return h(),{success:!1,error:e instanceof Error?e.message:String(e)}}})();if(n.push(e),r.push(e),r.length>=t){let e=await Promise.race(r),t=r.indexOf(e);t!==-1&&r.splice(t,1)}e.then(()=>{let t=r.indexOf(e);t!==-1&&r.splice(t,1)})}await Promise.all(n)}export async function initCompileAll(){try{let e=Z.getInstance();if(e.startProgress(),e.updateProgress(`🚀 Iniciando compilación...`),G(),e.updateProgress(`📦 Cargando cache...`),await ue(),X=0,e.updateProgress(`🔍 Ejecutando linter...`),!await runLinter(!1)){e.endProgress();return}let n=Date.now(),r=f.PATH_SOURCE??``,i=f.PATH_DIST??``,a=r.replace(/\\/g,`/`),o=[`${a}/**/*.js`,`${a}/**/*.vue`,`${a}/**/*.ts`,`${a}/**/*.mjs`,`${a}/**/*.cjs`];p.info(`📝 Compilando todos los archivos...`),p.info(`🔜 Fuente: ${r}`),p.info(`🔚 Destino: ${i}\n`),e.updateProgress(`🎨 Generando TailwindCSS...`);let u=await(await N())();typeof u!=`boolean`&&(u?.success?p.info(`🎨 ${u.message}\n`):await U(Error(`${u.message}${u.details?`
-`+u.details:``}`),`tailwind.config.js`,`tailwind`,`all`,f.VERBOSE===`true`)),e.updateProgress(`📁 Recopilando archivos...`);let d=[];for await(let e of t(o))e.endsWith(`.d.ts`)||d.push(e);let m=s.cpus().length,h=d.length;if(m<4&&(m=4,f.VERBOSE===`true`&&p.warn(`⚠️  Solo se detectó ${s.cpus().length} CPU. Usando ${m} hilos por defecto.`)),l.env.VERSACOMPILER_MAX_THREADS){let e=parseInt(l.env.VERSACOMPILER_MAX_THREADS,10);!isNaN(e)&&e>0&&(m=e,f.VERBOSE===`true`&&p.info(`🔧 Usando ${m} hilos (variable de entorno VERSACOMPILER_MAX_THREADS)`))}let _=s.totalmem()/(1024*1024),v=s.freemem()/(1024*1024),y=(_-v)/_*100,b;b=y>90?Math.max(4,Math.floor(m*.5)):h<5?h:h<20?m:h<50?Math.floor(m*1.5):h<200?m*2:Math.min(m*3,48),h>10&&b<4&&(b=4,f.VERBOSE===`true`&&p.info(`⚡ Ajustando a mínimo de 4 hilos para proyecto de ${h} archivos`)),e.updateProgress(`⚙️ Configurando workers...`),p.info(`🚀 Compilando ${h} archivos con concurrencia optimizada (${b} hilos)...`),p.info(`   📊 CPUs detectados: ${s.cpus().length} (usando: ${m})`),p.info(`   💾 Memoria libre: ${v.toFixed(0)}MB / ${_.toFixed(0)}MB (${(100-y).toFixed(1)}% libre)`),p.info(`   ⚡ Hilos configurados: ${b} (${(b/m).toFixed(1)}x CPUs)`);let x=Math.min(m*2,24);if(h>50&&b<x*.5){let e=await A();p.warn(e.yellow(`⚠️  Solo se usarán ${b} hilos para ${h} archivos.`)),p.info(e.yellow(`   💡 Tip: export VERSACOMPILER_MAX_THREADS=${x}`))}h>50&&b<8&&(p.warn(`⚠️  Solo se usarán ${b} hilos para ${h} archivos.`),p.warn(`   💡 Tip: Establece VERSACOMPILER_MAX_THREADS para forzar más hilos:`),p.warn(`   💡 export VERSACOMPILER_MAX_THREADS=16`));let S=k.getInstance(),C=new Set(d.map(e=>c.extname(e)));await S.preloadForContext(`batch`,C);try{let{TypeScriptWorkerPool:e}=await import(`./typescript-worker-pool.js`);e.getInstance().setMode(`batch`)}catch{}e.updateProgress(`🚀 Iniciando compilación de ${h} archivos...`),await ge(d,b),e.updateProgress(`💾 Guardando cache...`),await de(),e.updateProgress(`🧹 Limpiando módulos no usados...`),S.cleanupUnusedModules();let w=g(Date.now()-n);e.endProgress(),await K(f.VERBOSE===`true`,w)}catch(e){let t=Z.getInstance();t.isActive()&&t.endProgress();let n=e instanceof Error?e.message:String(e);p.error(`🚩 Error al compilar todos los archivos: ${n}`),await U(e instanceof Error?e:Error(String(e)),`compilación general`,`all`,`all`,f.VERBOSE===`true`),await K(f.VERBOSE===`true`)}}function _e(e){return{vue:`🎨`,typescript:`📘`,standardization:`💛`,minification:`🗜️`,tailwind:`🎨`,"file-read":`📖`,default:`⚙️`}[e]??`⚙️`}function $(e,t){let n=Math.round(e/100*t),r=t-n;return`${`\x1B[32m`+`█`.repeat(n)+`\x1B[0m`}${`\x1B[90m`+`░`.repeat(r)+`\x1B[0m`} ${e}%`}export async function compileFile(e){return await _(initCompile(e,!0,`individual`),6e4,`compilación de ${c.basename(e)}`)}export{Y as WatchModeOptimizer};
+import { createHash } from 'node:crypto';
+import { glob, mkdir, readFile, stat, unlink, writeFile, } from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as process from 'node:process';
+const { argv, cwd, env } = process;
+// Lazy loading optimizations - Only import lightweight modules synchronously
+import { logger, setProgressManagerGetter } from '../servicios/logger.js';
+import { promptUser } from '../utils/promptUser.js';
+import { showTimingForHumans } from '../utils/utils.js';
+// Configurar el getter del ProgressManager para el logger
+setProgressManagerGetter(() => ProgressManager.getInstance());
+/**
+ * ✨ FIX #5: Wrapper con timeout para operaciones críticas
+ * Evita que promesas colgadas bloqueen la compilación indefinidamente
+ */
+async function withTimeout(promise, timeoutMs, operationName) {
+    const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout en ${operationName} (${timeoutMs}ms)`)), timeoutMs));
+    return Promise.race([promise, timeoutPromise]);
+}
+// Heavy dependencies will be loaded dynamically when needed
+let chalk;
+let ESLint;
+let OxLint;
+let minifyJS;
+let getCodeFile;
+let generateTailwindCSS;
+let estandarizaCode;
+let preCompileTS;
+let preCompileVue;
+// 🚀 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;
+    loadedModules = new Set();
+    // ✨ 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
+    preloadLock = null; // Lock para evitar precargas concurrentes
+    // ✨ FIX #4: Límites estrictos de memoria para el pool
+    MAX_POOL_MEMORY = 100 * 1024 * 1024; // 100MB límite total
+    MAX_POOL_SIZE = 15; // Máximo 15 módulos en pool
+    // 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 (!OptimizedModuleManager.instance) {
+            OptimizedModuleManager.instance = new OptimizedModuleManager();
+        }
+        return OptimizedModuleManager.instance;
+    }
+    /**
+     * ✨ NUEVO: Precarga en background para módulos críticos
+     */
+    startBackgroundPreloading() {
+        this.backgroundLoader = this.preloadCriticalModules();
+    }
+    /**
+     * ✨ NUEVO: Precarga módulos críticos en background
+     */
+    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);
+        }
+        catch {
+            // Fallos en precarga no deben afectar la funcionalidad principal
+        }
+    }
+    /**
+     * ✨ MEJORADO: Precarga contextual basada en tipos de archivo con lock para prevenir cargas concurrentes
+     */
+    async preloadForContext(context, fileTypes = new Set()) {
+        // Si ya hay una precarga en progreso, esperar a que termine
+        if (this.preloadLock) {
+            await this.preloadLock;
+            return;
+        }
+        // Crear el lock
+        this.preloadLock = this.doPreload(context, fileTypes);
+        try {
+            await this.preloadLock;
+        }
+        finally {
+            this.preloadLock = null;
+        }
+    }
+    /**
+     * ✨ Método interno de precarga
+     */
+    async doPreload(context, fileTypes = new Set()) {
+        this.currentContext = context;
+        // Esperar que termine la precarga crítica si está en progreso
+        if (this.backgroundLoader) {
+            await this.backgroundLoader;
+        }
+        const toPreload = []; // Precarga basada en contexto
+        if (context === 'batch' || context === 'watch') {
+            // En batch/watch, precargar todos los módulos comunes
+            toPreload.push('transforms', 'vue', 'typescript', 'module-resolution-optimizer');
+        }
+        else {
+            // 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');
+        }
+        // ✨ OPTIMIZACIÓN #10: Agrupar módulos compatibles y cargarlos en paralelo
+        // Grupos de módulos que NO comparten dependencias nativas problemáticas
+        const moduleGroups = [
+            ['chalk', 'parser'], // Grupo 1: Módulos ligeros sin node:crypto
+            ['transforms'], // Grupo 2: Puede usar node:crypto pero independiente
+            ['vue', 'typescript'], // Grupo 3: Comparten configuración
+            ['module-resolution-optimizer'], // Grupo 4: Independiente
+            ['minify'], // Grupo 5: Independiente
+        ];
+        // Cargar cada grupo en paralelo, pero grupos secuencialmente
+        for (const group of moduleGroups) {
+            const modulesToLoad = group.filter(name => toPreload.includes(name));
+            if (modulesToLoad.length > 0) {
+                // Cargar módulos del grupo en paralelo
+                await Promise.allSettled(modulesToLoad.map(async (moduleName) => {
+                    try {
+                        await this.ensureModuleLoaded(moduleName);
+                    }
+                    catch (error) {
+                        // Silenciar errores de precarga - los módulos se cargarán bajo demanda
+                        if (env.VERBOSE === 'true') {
+                            const errorMessage = error instanceof Error
+                                ? error.message
+                                : String(error);
+                            console.warn(`[Verbose] Warning: No se pudo precargar módulo ${moduleName}:`, errorMessage);
+                        }
+                    }
+                }));
+            }
+        }
+    }
+    /**
+     * ✨ MEJORADO: Carga inteligente con pooling y deduplicación
+     */
+    async ensureModuleLoaded(moduleName) {
+        // 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':
+                return this.loadVue();
+            case 'typescript':
+                return this.loadTypeScript();
+            case 'minify':
+                return this.loadMinify();
+            case 'tailwind':
+                return this.loadTailwind();
+            case 'linter':
+                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');
+            // ✨ Usar minifyWithTemplates para minificar templates HTML ANTES del JS
+            minifyJS = minifyModule.minifyWithTemplates;
+        }
+        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,
+        };
+    }
+    /**
+     * ✨ FIX #4: Estima el tamaño en memoria de un módulo
+     */
+    estimateModuleSize(moduleName) {
+        // Estimaciones basadas en tipos de módulo
+        const sizeMap = {
+            'transform-optimizer': 5 * 1024 * 1024, // 5MB
+            typescript: 10 * 1024 * 1024, // 10MB
+            vue: 8 * 1024 * 1024, // 8MB
+            'module-resolution-optimizer': 3 * 1024 * 1024, // 3MB
+            transforms: 2 * 1024 * 1024, // 2MB
+            minify: 2 * 1024 * 1024, // 2MB
+            linter: 1 * 1024 * 1024, // 1MB
+            parser: 500 * 1024, // 500KB
+            chalk: 100 * 1024, // 100KB
+            default: 500 * 1024, // 500KB por defecto
+        };
+        return sizeMap[moduleName] ?? sizeMap.default;
+    }
+    /**
+     * ✨ FIX #4: Obtiene el uso total de memoria del pool
+     */
+    getPoolMemoryUsage() {
+        let totalSize = 0;
+        for (const moduleName of this.modulePool.keys()) {
+            totalSize += this.estimateModuleSize(moduleName);
+        }
+        return totalSize;
+    }
+    /**
+     * ✨ FIX #4: Limpia módulos no utilizados con control de memoria LRU
+     */
+    cleanupUnusedModules() {
+        const currentMemory = this.getPoolMemoryUsage();
+        const currentSize = this.modulePool.size;
+        // Limpiar si excedemos límites de memoria o tamaño
+        if (currentMemory > this.MAX_POOL_MEMORY ||
+            currentSize > this.MAX_POOL_SIZE) {
+            // LRU: Ordenar por menos usado
+            const sortedModules = Array.from(this.usageStats.entries())
+                .sort((a, b) => a[1] - b[1]) // Ascendente por uso
+                .filter(([name]) => !this.HOT_MODULES.includes(name)); // No eliminar HOT_MODULES
+            // Eliminar módulos hasta estar por debajo del 70% del límite
+            const targetMemory = this.MAX_POOL_MEMORY * 0.7;
+            const targetSize = this.MAX_POOL_SIZE * 0.7;
+            for (const [moduleName] of sortedModules) {
+                this.modulePool.delete(moduleName);
+                this.loadedModules.delete(moduleName);
+                this.usageStats.delete(moduleName);
+                const newMemory = this.getPoolMemoryUsage();
+                const newSize = this.modulePool.size;
+                if (newMemory <= targetMemory && newSize <= targetSize) {
+                    break;
+                }
+            }
+            if (env.VERBOSE === 'true') {
+                console.log(`[ModuleManager] Limpieza: ${currentSize} → ${this.modulePool.size} módulos, ` +
+                    `${Math.round(currentMemory / 1024 / 1024)}MB → ${Math.round(this.getPoolMemoryUsage() / 1024 / 1024)}MB`);
+            }
+        }
+    }
+    /**
+     * Resetea el estado del manager (útil para tests)
+     */
+    reset() {
+        this.isInitialized = false;
+        this.loadedModules.clear();
+        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
+async function loadChalk() {
+    if (!chalk) {
+        chalk = (await import('chalk')).default;
+    }
+    return chalk;
+}
+async function loadLinter() {
+    if (!ESLint || !OxLint) {
+        const linterModule = await import('./linter.js');
+        ESLint = linterModule.ESLint;
+        OxLint = linterModule.OxLint;
+    }
+    return { ESLint, OxLint };
+}
+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;
+}
+async function loadParser() {
+    if (!getCodeFile) {
+        const parserModule = await import('./parser.js');
+        getCodeFile = parserModule.getCodeFile;
+    }
+    return getCodeFile;
+}
+async function loadTailwind() {
+    if (!generateTailwindCSS) {
+        const tailwindModule = await import('./tailwindcss.js');
+        generateTailwindCSS = tailwindModule.generateTailwindCSS;
+    }
+    return generateTailwindCSS;
+}
+async function loadTransforms() {
+    if (!estandarizaCode) {
+        const transformsModule = await import('./transforms.js');
+        estandarizaCode = transformsModule.estandarizaCode;
+    }
+    return estandarizaCode;
+}
+async function loadTypeScript() {
+    if (!preCompileTS) {
+        const typescriptModule = await import('./typescript-manager.js');
+        preCompileTS = typescriptModule.preCompileTS;
+    }
+    return preCompileTS;
+}
+async function loadVue() {
+    if (!preCompileVue) {
+        const vueModule = await import('./vuejs.js');
+        preCompileVue = vueModule.preCompileVue;
+    }
+    return preCompileVue;
+}
+// Almacenamiento global de errores y resultados
+const compilationErrors = [];
+const compilationResults = [];
+// Variables de entorno relevantes para compilación
+const COMPILATION_ENV_VARS = [
+    'NODE_ENV',
+    'isPROD',
+    'TAILWIND',
+    'ENABLE_LINTER',
+    'VERBOSE',
+    'typeCheck',
+    'PATH_ALIAS',
+    'tailwindcss',
+    'linter',
+    'tsconfigFile',
+];
+class SmartCompilationCache {
+    cache = new Map();
+    maxEntries = 200; // Reducido para tests de estrés
+    maxMemory = 50 * 1024 * 1024; // 50MB límite (reducido)
+    currentMemoryUsage = 0;
+    // ✨ ISSUE #3: Sistema de vigilancia de dependencias
+    fileWatchers = new Map(); // chokidar watchers
+    dependencyGraph = new Map(); // archivo -> dependencias
+    reverseDependencyGraph = new Map(); // dependencia -> archivos que la usan
+    packageJsonPath = path.join(cwd(), 'package.json');
+    nodeModulesPath = path.join(cwd(), 'node_modules');
+    isWatchingDependencies = false;
+    /**
+     * 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');
+        }
+    }
+    /**
+     * Genera hash de la configuración del compilador
+     */
+    generateConfigHash() {
+        try {
+            // Recopilar configuración relevante de variables de entorno
+            const config = {
+                isPROD: env.isPROD || 'false',
+                TAILWIND: env.TAILWIND || 'false',
+                ENABLE_LINTER: env.ENABLE_LINTER || 'false',
+                PATH_ALIAS: env.PATH_ALIAS || '{}',
+                tailwindcss: env.tailwindcss || 'false',
+                linter: env.linter || 'false',
+                tsconfigFile: env.tsconfigFile || './tsconfig.json',
+            };
+            const configStr = JSON.stringify(config, Object.keys(config).sort());
+            return createHash('sha256')
+                .update(configStr)
+                .digest('hex')
+                .substring(0, 12);
+        }
+        catch {
+            return 'no-config';
+        }
+    }
+    /**
+     * Genera hash de variables de entorno relevantes
+     */
+    generateEnvHash() {
+        try {
+            const envVars = COMPILATION_ENV_VARS.map(key => `${key}=${env[key] || ''}`).join('|');
+            return createHash('sha256')
+                .update(envVars)
+                .digest('hex')
+                .substring(0, 12);
+        }
+        catch {
+            return 'no-env';
+        }
+    } /**
+     * ✨ ISSUE #3: Genera hash avanzado de dependencias del proyecto
+     * Incluye vigilancia de package.json, node_modules y versiones instaladas
+     */
+    async generateDependencyHash() {
+        try {
+            const hash = createHash('sha256');
+            // 1. Hash del package.json con versiones
+            const packagePath = path.join(cwd(), 'package.json');
+            const packageContent = await readFile(packagePath, 'utf8');
+            const pkg = JSON.parse(packageContent);
+            const deps = {
+                ...pkg.dependencies,
+                ...pkg.devDependencies,
+            };
+            const depsStr = JSON.stringify(deps, Object.keys(deps).sort());
+            hash.update(`package:${depsStr}`);
+            // 2. Hash del package-lock.json si existe (versiones exactas instaladas)
+            try {
+                const lockPath = path.join(cwd(), 'package-lock.json');
+                const lockContent = await readFile(lockPath, 'utf8');
+                const lockData = JSON.parse(lockContent);
+                // Solo incluir las versiones instaladas, no todo el lockfile
+                const installedVersions = {};
+                if (lockData.packages) {
+                    for (const [pkgPath, pkgInfo] of Object.entries(lockData.packages)) {
+                        if (pkgPath &&
+                            pkgPath !== '' &&
+                            typeof pkgInfo === 'object' &&
+                            pkgInfo !== null) {
+                            const pkgName = pkgPath.replace('node_modules/', '');
+                            if (pkgInfo.version) {
+                                installedVersions[pkgName] = pkgInfo.version;
+                            }
+                        }
+                    }
+                }
+                hash.update(`lock:${JSON.stringify(installedVersions, Object.keys(installedVersions).sort())}`);
+            }
+            catch {
+                // Ignorar si no existe package-lock.json
+            }
+            // 3. ✨ NUEVO: Hash de timestamps críticos de node_modules
+            try {
+                const nodeModulesPath = path.join(cwd(), 'node_modules');
+                const nodeModulesStat = await stat(nodeModulesPath);
+                hash.update(`nmtime:${nodeModulesStat.mtimeMs}`);
+                // Verificar timestamps de dependencias críticas instaladas
+                const criticalDeps = Object.keys(deps).slice(0, 10); // Top 10 para performance
+                for (const dep of criticalDeps) {
+                    try {
+                        const depPath = path.join(nodeModulesPath, dep);
+                        const depStat = await stat(depPath);
+                        hash.update(`${dep}:${depStat.mtimeMs}`);
+                    }
+                    catch {
+                        // Dependencia no instalada o error
+                        hash.update(`${dep}:missing`);
+                    }
+                }
+            }
+            catch {
+                // node_modules no existe
+                hash.update('nmtime:none');
+            }
+            return hash.digest('hex').substring(0, 16);
+        }
+        catch (error) {
+            // Incluir información del error en el hash para debugging
+            return createHash('sha256')
+                .update(`error:${error instanceof Error ? error.message : 'unknown'}`)
+                .digest('hex')
+                .substring(0, 16);
+        }
+    }
+    /**
+     * Genera clave de cache granular que incluye todos los factores
+     */
+    async generateCacheKey(filePath) {
+        const contentHash = await this.generateContentHash(filePath);
+        const configHash = this.generateConfigHash();
+        const envHash = this.generateEnvHash();
+        const dependencyHash = await this.generateDependencyHash();
+        // Usar | como separador para evitar problemas con rutas de Windows
+        return `${filePath}|${contentHash.substring(0, 12)}|${configHash}|${envHash}|${dependencyHash}`;
+    } /**
+     * 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 currentContentHash = await this.generateContentHash(filePath);
+            if (entry.contentHash !== currentContentHash) {
+                this.cache.delete(filePath);
+                return false;
+            }
+            // Verificar si la configuración ha cambiado
+            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) {
+                this.cache.delete(filePath);
+                return false;
+            }
+            // Actualizar tiempo de uso para LRU
+            entry.lastUsed = Date.now();
+            return true;
+        }
+        catch {
+            // Si hay error verificando, eliminar del cache
+            this.cache.delete(filePath);
+            return false;
+        }
+    } /**
+     * Añade una entrada al cache
+     */
+    async set(filePath, outputPath) {
+        try {
+            const stats = await stat(filePath);
+            const contentHash = await this.generateContentHash(filePath);
+            const configHash = this.generateConfigHash();
+            const envHash = this.generateEnvHash();
+            const dependencyHash = await this.generateDependencyHash();
+            const entry = {
+                contentHash,
+                configHash,
+                envHash,
+                dependencyHash,
+                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);
+        }
+    } /**
+     * Aplica política LRU para liberar espacio
+     */
+    evictIfNeeded(newEntrySize) {
+        // Verificar límite de entradas más agresivamente
+        while (this.cache.size >= this.maxEntries * 0.8) {
+            // Limpiar cuando llegue al 80%
+            this.evictLRU();
+        }
+        // Verificar límite de memoria más agresivamente
+        while (this.currentMemoryUsage + newEntrySize > this.maxMemory * 0.8 && // Limpiar cuando llegue al 80%
+            this.cache.size > 0) {
+            this.evictLRU();
+        }
+        // Eviction adicional si la memoria total del proceso es alta
+        const memUsage = process.memoryUsage();
+        const heapUsedMB = memUsage.heapUsed / (1024 * 1024);
+        if (heapUsedMB > 200 && this.cache.size > 50) {
+            // Si heap > 200MB, limpiar más agresivamente
+            const entriesToRemove = Math.min(this.cache.size - 50, 10);
+            for (let i = 0; i < entriesToRemove; i++) {
+                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);
+            }
+        }
+    }
+    /**
+     * Método público para limpiar entradas del cache cuando sea necesario
+     */
+    cleanOldEntries(maxEntriesToRemove = 20) {
+        let removedCount = 0;
+        for (let i = 0; i < maxEntriesToRemove && this.cache.size > 0; i++) {
+            const sizeBefore = this.cache.size;
+            this.evictLRU();
+            if (this.cache.size < sizeBefore) {
+                removedCount++;
+            }
+            else {
+                break; // No se pudo remover más entradas
+            }
+        }
+        return removedCount;
+    }
+    /**
+     * 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;
+        }
+    }
+    /**
+     * 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
+        };
+    }
+    // ✨ ISSUE #3: Métodos de vigilancia y invalidación cascada
+    /**
+     * Inicializa vigilancia de package.json y node_modules
+     */
+    async startDependencyWatching() {
+        if (this.isWatchingDependencies)
+            return;
+        try {
+            // Lazy load chokidar para evitar problemas de importación
+            const chokidar = await import('chokidar');
+            // Vigilar package.json
+            if (await this.fileExists(this.packageJsonPath)) {
+                const packageWatcher = chokidar.watch(this.packageJsonPath, {
+                    persistent: false, // No mantener el proceso vivo
+                    ignoreInitial: true,
+                });
+                packageWatcher.on('change', () => {
+                    logger.info('📦 package.json modificado - invalidando cache de dependencias');
+                    this.invalidateByDependencyChange();
+                });
+                this.fileWatchers.set('package.json', packageWatcher);
+            }
+            // Vigilar node_modules (solo cambios en el directorio raíz para performance)
+            if (await this.fileExists(this.nodeModulesPath)) {
+                const nodeModulesWatcher = chokidar.watch(this.nodeModulesPath, {
+                    persistent: false,
+                    ignoreInitial: true,
+                    depth: 1, // Solo primer nivel para performance
+                    ignored: /(^|[/\\])\../, // Ignorar archivos ocultos
+                });
+                nodeModulesWatcher.on('addDir', (path) => {
+                    logger.info(`📦 Nueva dependencia instalada: ${path.split(/[/\\]/).pop()}`);
+                    this.invalidateByDependencyChange();
+                });
+                nodeModulesWatcher.on('unlinkDir', (path) => {
+                    logger.info(`📦 Dependencia eliminada: ${path.split(/[/\\]/).pop()}`);
+                    this.invalidateByDependencyChange();
+                });
+                this.fileWatchers.set('node_modules', nodeModulesWatcher);
+            }
+            this.isWatchingDependencies = true;
+            logger.info('🔍 Vigilancia de dependencias iniciada');
+        }
+        catch (error) {
+            logger.warn('⚠️ No se pudo iniciar vigilancia de dependencias:', error);
+        }
+    }
+    /**
+     * Detiene la vigilancia de dependencias
+     */
+    async stopDependencyWatching() {
+        for (const [name, watcher] of this.fileWatchers) {
+            try {
+                await watcher.close();
+                logger.info(`🛑 Vigilancia detenida: ${name}`);
+            }
+            catch (error) {
+                logger.warn(`⚠️ Error cerrando watcher ${name}:`, error);
+            }
+        }
+        this.fileWatchers.clear();
+        this.isWatchingDependencies = false;
+    }
+    /**
+     * Registra dependencias de un archivo para invalidación cascada
+     */
+    registerDependencies(filePath, dependencies) {
+        // Limpiar dependencias anteriores
+        const oldDeps = this.dependencyGraph.get(filePath);
+        if (oldDeps) {
+            for (const dep of oldDeps) {
+                const reverseDeps = this.reverseDependencyGraph.get(dep);
+                if (reverseDeps) {
+                    reverseDeps.delete(filePath);
+                    if (reverseDeps.size === 0) {
+                        this.reverseDependencyGraph.delete(dep);
+                    }
+                }
+            }
+        }
+        // Registrar nuevas dependencias
+        const newDeps = new Set(dependencies);
+        this.dependencyGraph.set(filePath, newDeps);
+        for (const dep of newDeps) {
+            if (!this.reverseDependencyGraph.has(dep)) {
+                this.reverseDependencyGraph.set(dep, new Set());
+            }
+            this.reverseDependencyGraph.get(dep).add(filePath);
+        }
+    }
+    /**
+     * Invalida cache por cambios en dependencias
+     */
+    invalidateByDependencyChange() {
+        let invalidatedCount = 0;
+        // Invalidar todos los archivos que dependen de dependencias externas
+        for (const [filePath] of this.cache) {
+            this.cache.delete(filePath);
+            invalidatedCount++;
+        }
+        // Limpiar grafos de dependencias
+        this.dependencyGraph.clear();
+        this.reverseDependencyGraph.clear();
+        this.currentMemoryUsage = 0;
+        logger.info(`🗑️ Cache invalidado: ${invalidatedCount} archivos (cambio en dependencias)`);
+    }
+    /**
+     * Invalida cascada cuando un archivo específico cambia
+     */
+    invalidateCascade(changedFile) {
+        const invalidated = [];
+        const toInvalidate = new Set([changedFile]);
+        // BFS para encontrar todos los archivos afectados
+        const queue = [changedFile];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            const dependents = this.reverseDependencyGraph.get(current);
+            if (dependents) {
+                for (const dependent of dependents) {
+                    if (!toInvalidate.has(dependent)) {
+                        toInvalidate.add(dependent);
+                        queue.push(dependent);
+                    }
+                }
+            }
+        }
+        // Invalidar archivos
+        for (const filePath of toInvalidate) {
+            if (this.cache.has(filePath)) {
+                const entry = this.cache.get(filePath);
+                this.currentMemoryUsage -= entry.size;
+                this.cache.delete(filePath);
+                invalidated.push(filePath);
+            }
+        }
+        if (invalidated.length > 0) {
+            logger.info(`🔄 Invalidación cascada: ${invalidated.length} archivos afectados por ${changedFile}`);
+        }
+        return invalidated;
+    }
+    /**
+     * Verifica si un archivo existe
+     */
+    async fileExists(filePath) {
+        try {
+            await stat(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Obtiene estadísticas avanzadas del cache
+     */
+    getAdvancedStats() {
+        return {
+            entries: this.cache.size,
+            memoryUsage: this.currentMemoryUsage,
+            hitRate: 0,
+            dependencyNodes: this.dependencyGraph.size,
+            watchingDependencies: this.isWatchingDependencies,
+            activeWatchers: this.fileWatchers.size,
+        };
+    }
+}
+// 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);
+    // ✨ ISSUE #3: Iniciar vigilancia de dependencias en modo watch
+    if (env.WATCH_MODE === 'true' ||
+        argv.includes('--watch') ||
+        argv.includes('-w')) {
+        await smartCache.startDependencyWatching();
+    }
+}
+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
+ */
+function registerCompilationError(file, stage, message, severity = 'error', details, help) {
+    compilationErrors.push({
+        file,
+        stage,
+        message,
+        severity,
+        details,
+        help,
+        timestamp: Date.now(),
+    });
+}
+/**
+ * Registra un resultado de compilación (éxitos/errores por etapa)
+ */
+function registerCompilationResult(stage, errors, success, files = []) {
+    const existingResult = compilationResults.find(r => r.stage === stage);
+    if (existingResult) {
+        existingResult.errors += errors;
+        existingResult.success += success;
+        existingResult.files.push(...files);
+    }
+    else {
+        compilationResults.push({
+            stage,
+            errors,
+            success,
+            files: [...files],
+        });
+    }
+}
+/**
+ * Maneja errores según el modo de compilación
+ */
+async function handleCompilationError(error, fileName, stage, mode, isVerbose = false) {
+    const errorMessage = error instanceof Error ? error.message : error;
+    const errorDetails = error instanceof Error ? error.stack : undefined;
+    // Registrar el error en el sistema unificado
+    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 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));
+            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()}`));
+                    }
+                });
+            }
+        }
+        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`));
+        }
+    }
+    // En modo 'all', los errores se acumulan silenciosamente para el resumen final
+}
+/**
+ * Registra un éxito de compilación
+ */
+function registerCompilationSuccess(fileName, stage) {
+    registerCompilationResult(stage, 0, 1, [fileName]);
+}
+/**
+ * Limpia todos los errores y resultados acumulados
+ */
+function clearCompilationState() {
+    compilationErrors.length = 0;
+    compilationResults.length = 0;
+}
+/**
+ * Muestra un resumen detallado de todos los errores de compilación
+ */
+async function displayCompilationSummary(isVerbose = false, totalTime) {
+    const chalk = await loadChalk();
+    if (compilationErrors.length === 0 && compilationResults.length === 0) {
+        logger.info(chalk.green('✅ No hay errores de compilación para mostrar.'));
+        if (totalTime) {
+            logger.info(chalk.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
+    if (totalTime) {
+        logger.info(chalk.bold(`⏱️  Tiempo Total: ${chalk.green(totalTime)}`));
+        logger.info('');
+    } // 🔧 Estadísticas por etapa con mejor formato
+    if (compilationResults.length > 0) {
+        logger.info(chalk.bold.blue('🔧 Estadísticas por Etapa:'));
+        for (const result of compilationResults) {
+            const totalFiles = result.success + result.errors;
+            const successRate = totalFiles > 0
+                ? Math.round((result.success / totalFiles) * 100)
+                : 0;
+            // Iconos y colores dinámicos por etapa
+            const stageIcon = getStageIcon(result.stage);
+            const statusColor = result.errors === 0 ? chalk.green : chalk.red;
+            const progressBar = createProgressBarWithPercentage(successRate, 20);
+            logger.info(`   ${stageIcon} ${chalk.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('');
+        }
+    }
+    // Mostrar errores detallados
+    if (compilationErrors.length > 0) {
+        logger.info(chalk.red(`\n❌ Se encontraron ${compilationErrors.length} errores:`));
+        // Agrupar errores por archivo para mejor organización
+        const errorsByFile = new Map();
+        compilationErrors.forEach(error => {
+            if (!errorsByFile.has(error.file)) {
+                errorsByFile.set(error.file, []);
+            }
+            errorsByFile.get(error.file).push(error);
+        });
+        // Mostrar errores por archivo
+        let fileIndex = 1;
+        for (const [filePath, fileErrors] of errorsByFile) {
+            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`));
+            for (const error of fileErrors) {
+                const icon = error.severity === 'error' ? '❌' : '⚠️';
+                const stageColor = await getStageColor(error.stage);
+                logger.info(`   ${icon} [${stageColor(error.stage)}] ${error.message}`);
+                if (isVerbose && error.details) {
+                    // En modo verbose, mostrar detalles adicionales
+                    const detailLines = error.details.split('\n').slice(0, 5);
+                    detailLines.forEach(line => {
+                        if (line.trim()) {
+                            logger.info(chalk.gray(`      ${line.trim()}`));
+                        }
+                    });
+                }
+                if (error.help) {
+                    logger.info(chalk.blue(`      💡 ${error.help}`));
+                }
+            }
+            fileIndex++;
+        } // 📊 Mostrar totales finales con diseño moderno
+        const totalErrors = compilationErrors.filter(e => e.severity === 'error').length;
+        const totalWarnings = compilationErrors.filter(e => e.severity === 'warning').length;
+        const totalFiles = errorsByFile.size;
+        // 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));
+        // 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('');
+        // 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.'));
+        }
+        else if (totalWarnings > 0) {
+            logger.info(chalk.yellow.bold('⚠️  COMPILACIÓN COMPLETADA CON ADVERTENCIAS'));
+            logger.info(chalk.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('');
+        logger.info(chalk.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('');
+        logger.info(chalk.green.bold('🎉 COMPILACIÓN COMPLETADA EXITOSAMENTE'));
+        logger.info(chalk.green('   ¡No se encontraron errores ni advertencias!'));
+        logger.info('');
+        logger.info(chalk.bold.green(successLine));
+    }
+    logger.info('');
+}
+/**
+ * Muestra errores del linter con formato visual moderno y profesional
+ */
+async function displayLinterErrors(errors) {
+    const chalk = await loadChalk();
+    // Agrupar errores por archivo
+    const errorsByFile = new Map();
+    errors.forEach(error => {
+        if (!errorsByFile.has(error.file)) {
+            errorsByFile.set(error.file, []);
+        }
+        errorsByFile.get(error.file).push(error);
+    });
+    const totalErrors = errors.filter(e => e.severity === 'error').length;
+    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)('╰─────────────────────────────────────────────────────────────╯'));
+    // Resumen con iconos profesionales
+    const errorIcon = totalErrors > 0 ? chalk.red('●') : chalk.green('○');
+    const warningIcon = totalWarnings > 0 ? chalk.yellow('●') : chalk.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('');
+    if (totalErrors === 0 && totalWarnings === 0) {
+        logger.info(chalk.green.bold('✨ All checks passed! No issues found.'));
+        return;
+    }
+    // Mostrar errores por archivo con formato elegante
+    let fileIndex = 1;
+    for (const [filePath, fileErrors] of errorsByFile) {
+        await displayFileErrorsGroup(filePath, fileErrors, fileIndex, totalFiles);
+        fileIndex++;
+        if (fileIndex <= totalFiles) {
+            logger.info(chalk.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`) +
+        ' '.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)('╰─────────────────────────────────────────────────────────────╯'));
+}
+/**
+ * Muestra un grupo de errores para un archivo específico con formato moderno
+ */
+async function displayFileErrorsGroup(filePath, fileErrors, _fileIndex, _totalFiles) {
+    const chalk = 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 fileIcon = filePath.endsWith('.vue')
+        ? '🎨'
+        : filePath.endsWith('.ts')
+            ? '📘'
+            : filePath.endsWith('.js')
+                ? '📜'
+                : '📄';
+    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('');
+    // Mostrar cada error con formato elegante
+    for (let i = 0; i < fileErrors.length; i++) {
+        const error = fileErrors[i];
+        await displayModernLinterError(error, filePath, i + 1, fileErrors.length);
+    }
+}
+/**
+ * Muestra un error individual con formato visual moderno tipo ESLint/Prettier
+ */
+async function displayModernLinterError(error, filePath, errorIndex, totalErrorsInFile) {
+    const chalk = 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 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}`)}`;
+    logger.info(errorHeader);
+    logger.info(`    ${chalk.gray('at')} ${locationInfo} ${chalk.gray('·')} ${ruleInfo}`);
+    // Mostrar código con contexto
+    try {
+        const absolutePath = path.resolve(filePath);
+        const fileContent = await fs.readFile(absolutePath, 'utf-8');
+        const lines = fileContent.split('\n');
+        const lineNum = parseInt(line.toString()) - 1;
+        if (lineNum >= 0 && lineNum < lines.length) {
+            logger.info('');
+            // Mostrar líneas de contexto con numeración elegante
+            const startLine = Math.max(0, lineNum - 1);
+            const endLine = Math.min(lines.length - 1, lineNum + 1);
+            const maxLineNumWidth = (endLine + 1).toString().length;
+            for (let i = startLine; i <= endLine; i++) {
+                const currentLineNum = i + 1;
+                const currentLine = lines[i] || '';
+                const lineNumStr = currentLineNum
+                    .toString()
+                    .padStart(maxLineNumWidth, ' ');
+                const isErrorLine = i === lineNum;
+                if (isErrorLine) {
+                    // Línea con el error - destacada
+                    logger.info(`    ${chalk.red('>')} ${chalk.gray(lineNumStr)} ${chalk.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}`);
+                }
+                else {
+                    // Líneas de contexto
+                    logger.info(`    ${chalk.gray(' ')} ${chalk.gray(lineNumStr)} ${chalk.gray('│')} ${chalk.gray(currentLine)}`);
+                }
+            }
+        }
+    }
+    catch {
+        // Si no se puede leer el archivo, mostrar formato simplificado
+        logger.info(`    ${chalk.gray('│')} ${chalk.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)}`);
+    }
+    // Separador entre errores (solo si no es el último)
+    if (errorIndex < totalErrorsInFile) {
+        logger.info('');
+    }
+}
+/**
+ * Muestra un solo error del linter con formato visual mejorado
+ * @deprecated Use displayModernLinterError instead
+ */
+async function _displaySingleLinterError(error, filePath) {
+    const chalk = 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}`;
+    logger.info(mainErrorLine);
+    // Intentar leer el contenido del archivo para mostrar contexto
+    try {
+        const absolutePath = path.resolve(filePath);
+        const fileContent = await fs.readFile(absolutePath, 'utf-8');
+        const lines = fileContent.split('\n');
+        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}]`));
+            // Mostrar líneas de contexto
+            const startLine = Math.max(0, lineNum - 1);
+            const endLine = Math.min(lines.length - 1, lineNum + 1);
+            for (let i = startLine; i <= endLine; i++) {
+                const currentLineNum = i + 1;
+                const currentLine = lines[i] || '';
+                const prefix = currentLineNum.toString().padStart(2, ' ');
+                if (i === lineNum) {
+                    // Línea con el error
+                    logger.info(chalk.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);
+                    // Mensaje de ubicación específica
+                    const messageIndent = ' '.repeat(Math.max(0, (column || 1) + 6));
+                    logger.info(chalk.blue(indent + '·') +
+                        messageIndent +
+                        chalk.red('╰── ') +
+                        chalk.gray(getErrorLocationMessage(error)));
+                }
+                else {
+                    // Líneas de contexto
+                    logger.info(chalk.blue(` ${prefix} │ `) + chalk.gray(currentLine));
+                }
+            }
+            logger.info(chalk.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('    ╰────'));
+    }
+    // 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(''); // Espacio entre errores
+}
+/**
+ * Genera un mensaje descriptivo para la ubicación específica del error
+ */
+function getErrorLocationMessage(error) {
+    if (error.message.includes('declared but never used')) {
+        const match = error.message.match(/'([^']+)'/);
+        if (match) {
+            return `'${match[1]}' is declared here`;
+        }
+    }
+    if (error.message.includes('Unexpected var')) {
+        return 'var declaration found here';
+    }
+    if (error.message.includes('never reassigned')) {
+        const match = error.message.match(/'([^']+)'/);
+        if (match) {
+            return `'${match[1]}' is assigned here`;
+        }
+    }
+    return 'error location';
+}
+/**
+ * Obtiene el color apropiado para cada etapa de compilación
+ */
+async function getStageColor(stage) {
+    const chalk = await loadChalk();
+    switch (stage) {
+        case 'vue':
+            return chalk.green;
+        case 'typescript':
+            return chalk.blue;
+        case 'standardization':
+            return chalk.yellow;
+        case 'minification':
+            return chalk.red;
+        case 'tailwind':
+            return chalk.magenta;
+        case 'file-read':
+            return chalk.gray;
+        default:
+            return chalk.white;
+    }
+}
+export function normalizeRuta(ruta) {
+    if (path.isAbsolute(ruta)) {
+        return path.normalize(ruta).replace(/\\/g, '/');
+    }
+    const file = path
+        .normalize(!ruta.startsWith('.') ? './' + ruta : ruta)
+        .replace(/\\/g, '/');
+    const sourceForDist = file.startsWith('./') ? file : `./${file}`;
+    return sourceForDist;
+}
+export function getOutputPath(ruta) {
+    const pathSource = env.PATH_SOURCE ?? '';
+    const pathDist = env.PATH_DIST ?? '';
+    if (!pathSource || !pathDist) {
+        return ruta.replace(/\.(vue|ts)$/, '.js');
+    }
+    const normalizedRuta = path.normalize(ruta).replace(/\\/g, '/');
+    const normalizedSource = path.normalize(pathSource).replace(/\\/g, '/');
+    const normalizedDist = path.normalize(pathDist).replace(/\\/g, '/');
+    let outputPath;
+    if (normalizedRuta.includes(normalizedSource)) {
+        const relativePath = normalizedRuta
+            .substring(normalizedRuta.indexOf(normalizedSource) +
+            normalizedSource.length)
+            .replace(/^[/\\]/, '');
+        outputPath = path
+            .join(normalizedDist, relativePath)
+            .replace(/\\/g, '/');
+    }
+    else {
+        const fileName = path.basename(normalizedRuta);
+        outputPath = path.join(normalizedDist, fileName).replace(/\\/g, '/');
+    }
+    if (outputPath.includes('vue') || outputPath.includes('ts')) {
+        return outputPath.replace(/\.(vue|ts)$/, '.js');
+    }
+    else {
+        return outputPath;
+    }
+}
+// Optimización para modo watch: debouncing y cache de archivos
+class WatchModeOptimizer {
+    static instance;
+    fileSystemCache = new Map();
+    debounceTimers = new Map();
+    DEBOUNCE_DELAY = 100; // 100ms debounce
+    static getInstance() {
+        if (!WatchModeOptimizer.instance) {
+            WatchModeOptimizer.instance = new WatchModeOptimizer();
+        }
+        return WatchModeOptimizer.instance;
+    }
+    async compileForWatch(filePath, compileFn) {
+        return new Promise(resolve => {
+            const existingTimer = this.debounceTimers.get(filePath);
+            if (existingTimer) {
+                clearTimeout(existingTimer);
+            }
+            const timer = setTimeout(async () => {
+                this.debounceTimers.delete(filePath);
+                try {
+                    const stats = await stat(filePath);
+                    const cached = this.fileSystemCache.get(filePath);
+                    if (cached && cached.mtime >= stats.mtimeMs) {
+                        resolve({ success: true, cached: true });
+                        return;
+                    } // 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,
+                    });
+                    resolve(result);
+                }
+                catch (error) {
+                    resolve({ success: false, error });
+                }
+            }, this.DEBOUNCE_DELAY);
+            this.debounceTimers.set(filePath, timer);
+        });
+    }
+    cleanup() {
+        this.debounceTimers.forEach(timer => clearTimeout(timer));
+        this.debounceTimers.clear();
+        this.fileSystemCache.clear();
+    }
+}
+async function compileJS(inPath, outPath, mode = 'individual') {
+    const timings = {};
+    // Si la ruta ya es absoluta, no la resolvamos de nuevo
+    inPath = path.isAbsolute(inPath)
+        ? normalizeRuta(inPath)
+        : 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); // Asegurar que el parser esté cargado
+    await moduleManager.ensureModuleLoaded('parser');
+    const getCodeFile = await loadParser();
+    const result = await getCodeFile(inPath);
+    let code = result.code;
+    const error = result.error;
+    timings.fileRead = Date.now() - start;
+    if (error) {
+        await handleCompilationError(error instanceof Error ? error : new Error(String(error)), inPath, 'file-read', mode, env.VERBOSE === 'true');
+        throw new Error(error instanceof Error ? error.message : String(error));
+    }
+    if (!code ||
+        code.trim().length === 0 ||
+        code === 'undefined' ||
+        code === 'null') {
+        await handleCompilationError(new Error('El archivo está vacío o no se pudo leer.'), inPath, 'file-read', mode, env.VERBOSE === 'true');
+        throw new Error('El archivo está vacío o no se pudo leer.');
+    } // Logs detallados en modo verbose
+    const shouldShowDetailedLogs = env.VERBOSE === 'true'; // Compilación de Vue
+    let vueResult;
+    if (extension === '.vue') {
+        start = Date.now();
+        if (shouldShowDetailedLogs) {
+            logger.info(chalk.green(`💚 Precompilando VUE: ${path.basename(inPath)}`));
+        }
+        // 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}`);
+        }
+        vueResult = await preCompileVue(code, inPath, env.isPROD === 'true');
+        timings.vueCompile = Date.now() - start;
+        if (vueResult === undefined || vueResult === null) {
+            throw new Error(`preCompileVue devolvió ${vueResult} para archivo: ${inPath}`);
+        }
+        if (vueResult.error) {
+            await handleCompilationError(vueResult.error instanceof Error
+                ? vueResult.error
+                : new Error(String(vueResult.error)), inPath, 'vue', mode, env.VERBOSE === 'true');
+            throw new Error(vueResult.error instanceof Error
+                ? vueResult.error.message
+                : String(vueResult.error));
+        }
+        registerCompilationSuccess(inPath, 'vue');
+        code = vueResult.data;
+    }
+    if (!code || code.trim().length === 0) {
+        await handleCompilationError(new Error('El código Vue compilado está vacío.'), inPath, 'vue', mode, env.VERBOSE === 'true');
+        throw new Error('El código Vue compilado está vacío.');
+    }
+    // Compilación de TypeScript
+    let tsResult;
+    if (extension === '.ts' || vueResult?.lang === 'ts') {
+        start = Date.now();
+        if (shouldShowDetailedLogs) {
+            logger.info(chalk.blue(`🔄️ Precompilando TS: ${path.basename(inPath)}`));
+        }
+        // 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}`);
+        }
+        tsResult = await preCompileTS(code, inPath);
+        timings.tsCompile = Date.now() - start;
+        if (tsResult === undefined || tsResult === null) {
+            throw new Error(`preCompileTS devolvió ${tsResult} para archivo: ${inPath}`);
+        }
+        if (tsResult.error) {
+            if (mode === 'all') {
+                // En modo --all, registrar el error pero continuar la compilación
+                registerCompilationError(inPath, 'typescript', tsResult.error instanceof Error
+                    ? tsResult.error.message
+                    : String(tsResult.error), 'error');
+            }
+            else {
+                await handleCompilationError(tsResult.error, inPath, 'typescript', mode, env.VERBOSE === 'true');
+                throw new Error(tsResult.error instanceof Error
+                    ? tsResult.error.message
+                    : String(tsResult.error));
+            }
+        }
+        else {
+            registerCompilationSuccess(inPath, 'typescript');
+            code = tsResult.data;
+        }
+    }
+    if (!code || code.trim().length === 0) {
+        await handleCompilationError(new Error('El código TypeScript compilado está vacío.'), inPath, 'typescript', mode, env.VERBOSE === 'true');
+        throw new Error('El código TypeScript compilado está vacío.');
+    } // Estandarización
+    if (shouldShowDetailedLogs) {
+        logger.info(chalk.yellow(`💛 Estandarizando: ${path.basename(inPath)}`));
+    }
+    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);
+    timings.standardization = Date.now() - start;
+    if (resultSTD === undefined || resultSTD === null) {
+        throw new Error(`estandarizaCode devolvió ${resultSTD} para archivo: ${inPath}`);
+    }
+    if (resultSTD.error) {
+        await handleCompilationError(new Error(resultSTD.error), inPath, 'standardization', mode, env.VERBOSE === 'true');
+        throw new Error(resultSTD.error);
+    }
+    registerCompilationSuccess(inPath, 'standardization');
+    code = resultSTD.code;
+    if (!code || code.trim().length === 0) {
+        await handleCompilationError(new Error('El código estandarizado está vacío.'), inPath, 'standardization', mode, env.VERBOSE === 'true');
+        throw new Error('El código estandarizado está vacío.');
+    }
+    // Minificación (solo en producción)
+    if (env.isPROD === 'true') {
+        start = Date.now();
+        if (shouldShowDetailedLogs) {
+            logger.info(chalk.red(`🤖 Minificando: ${path.basename(inPath)}`));
+        }
+        // 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);
+        timings.minification = Date.now() - start;
+        if (resultMinify === undefined || resultMinify === null) {
+            throw new Error(`minifyJS devolvió ${resultMinify} para archivo: ${inPath}`);
+        }
+        if (resultMinify.error) {
+            await handleCompilationError(resultMinify.error instanceof Error
+                ? resultMinify.error
+                : new Error(String(resultMinify.error)), inPath, 'minification', mode, env.VERBOSE === 'true');
+            throw new Error(resultMinify.error instanceof Error
+                ? resultMinify.error.message
+                : String(resultMinify.error));
+        }
+        registerCompilationSuccess(inPath, 'minification');
+        code = resultMinify.code;
+    } // Escribir archivo final
+    const destinationDir = path.dirname(outPath);
+    await mkdir(destinationDir, { recursive: true });
+    await writeFile(outPath, code, 'utf-8');
+    // Logs de timing detallados en modo verbose
+    if (shouldShowDetailedLogs) {
+        const totalTime = Object.values(timings).reduce((sum, time) => sum + time, 0);
+        logger.info(chalk.cyan(`⏱️ Timing para ${path.basename(inPath)}:`));
+        if (timings.fileRead)
+            logger.info(chalk.cyan(`  📖 Lectura: ${timings.fileRead}ms`));
+        if (timings.vueCompile)
+            logger.info(chalk.cyan(`  💚 Vue: ${timings.vueCompile}ms`));
+        if (timings.tsCompile)
+            logger.info(chalk.cyan(`  🔄️ TypeScript: ${timings.tsCompile}ms`));
+        if (timings.standardization)
+            logger.info(chalk.cyan(`  💛 Estandarización: ${timings.standardization}ms`));
+        if (timings.minification)
+            logger.info(chalk.cyan(`  🤖 Minificación: ${timings.minification}ms`));
+        logger.info(chalk.cyan(`  🏁 Total: ${totalTime}ms`));
+    }
+    return {
+        error: null,
+        action: 'extension',
+    };
+}
+export async function initCompile(ruta, compileTailwind = true, mode = 'individual') {
+    try {
+        // 🚀 Sistema de Carga Inteligente de Módulos
+        const moduleManager = OptimizedModuleManager.getInstance();
+        const fileExtension = path.extname(ruta);
+        const fileExtensions = new Set([fileExtension]);
+        // Inicializar módulos según el contexto
+        await moduleManager.preloadForContext(mode === 'all' ? 'batch' : mode, fileExtensions);
+        // Generar TailwindCSS si está habilitado
+        if (compileTailwind && Boolean(env.TAILWIND)) {
+            await moduleManager.ensureModuleLoaded('tailwind');
+            const generateTailwindCSS = await loadTailwind();
+            const resultTW = await generateTailwindCSS();
+            if (typeof resultTW !== 'boolean') {
+                if (resultTW?.success) {
+                    logger.info(`🎨 ${resultTW.message}`);
+                }
+                else {
+                    const errorMsg = `${resultTW.message}${resultTW.details ? '\n' + resultTW.details : ''}`;
+                    await handleCompilationError(new Error(errorMsg), 'tailwind.config.js', 'tailwind', mode, env.VERBOSE === 'true');
+                    // No hacer throw aquí, permitir que la compilación continúe
+                }
+            }
+        }
+        const startTime = Date.now();
+        const file = normalizeRuta(ruta);
+        const outFile = getOutputPath(file);
+        // 🚀 Verificar cache antes de compilar (especialmente importante en modo watch)
+        if (mode === 'watch' || mode === 'individual') {
+            if (await shouldSkipFile(file)) {
+                if (env.VERBOSE === 'true') {
+                    logger.info(`⏭️ Archivo omitido (cache): ${path.basename(file)}`);
+                }
+                return {
+                    success: true,
+                    cached: true,
+                    output: smartCache.getOutputPath(file) || outFile,
+                    action: 'cached',
+                };
+            }
+        }
+        if (mode === 'individual' && env.VERBOSE === 'true') {
+            logger.info(`🔜 Fuente: ${file}`);
+        }
+        const result = await compileJS(file, outFile, mode);
+        if (result.error) {
+            throw new Error(result.error);
+        }
+        // 🚀 Actualizar cache después de compilación exitosa (especialmente en modo watch)
+        if (mode === 'watch' || mode === 'individual') {
+            await smartCache.set(file, outFile);
+        }
+        const endTime = Date.now();
+        const elapsedTime = showTimingForHumans(endTime - startTime);
+        if (mode === 'individual') {
+            if (env.VERBOSE === 'true') {
+                logger.info(`🔚 Destino: ${outFile}`);
+                logger.info(`⏱️ Tiempo: ${elapsedTime}`);
+            }
+            const chalk = await loadChalk();
+            logger.info(chalk.green(`✅ Compilación exitosa: ${path.basename(file)}`));
+        }
+        return {
+            success: true,
+            output: outFile,
+            action: result.action,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (env.VERBOSE === 'true') {
+            logger.error(`❌ Error en compilación de ${path.basename(ruta)}: ${errorMessage}`);
+        }
+        return {
+            success: false,
+            output: '',
+            error: errorMessage,
+        };
+    }
+}
+// Variable para el último progreso mostrado (evitar spam)
+let lastProgressUpdate = 0;
+// Sistema de gestión de progreso persistente (como Jest)
+class ProgressManager {
+    static instance;
+    progressActive = false;
+    lastProgressLine = '';
+    logBuffer = [];
+    originalConsoleLog;
+    originalConsoleError;
+    originalConsoleWarn;
+    hasProgressLine = false;
+    constructor() {
+        // Guardar referencias originales
+        this.originalConsoleLog = console.log;
+        this.originalConsoleError = console.error;
+        this.originalConsoleWarn = console.warn;
+    }
+    static getInstance() {
+        if (!ProgressManager.instance) {
+            ProgressManager.instance = new ProgressManager();
+        }
+        return ProgressManager.instance;
+    }
+    interceptConsole() {
+        // Interceptar console.log y similares
+        console.log = (...args) => {
+            this.addLog(args.map(arg => String(arg)).join(' '));
+        };
+        console.error = (...args) => {
+            this.addLog(args.map(arg => String(arg)).join(' '));
+        };
+        console.warn = (...args) => {
+            this.addLog(args.map(arg => String(arg)).join(' '));
+        };
+    }
+    restoreConsole() {
+        console.log = this.originalConsoleLog;
+        console.error = this.originalConsoleError;
+        console.warn = this.originalConsoleWarn;
+    }
+    startProgress() {
+        this.progressActive = true;
+        this.logBuffer = [];
+        this.hasProgressLine = false;
+        this.interceptConsole();
+        // 🎨 Header moderno de inicio de compilación
+        const headerLine = '━'.repeat(48);
+        process.stdout.write('\n\x1b[96m' + headerLine + '\x1b[0m\n');
+        process.stdout.write('\x1b[96m│ \x1b[97m\x1b[1m🚀 Iniciando Compilación\x1b[0m\x1b[96m' +
+            ' '.repeat(22) +
+            '│\x1b[0m\n');
+        process.stdout.write('\x1b[96m' + headerLine + '\x1b[0m\n');
+    }
+    updateProgress(progressText) {
+        if (!this.progressActive)
+            return;
+        // Si hay logs pendientes, mostrarlos primero
+        if (this.logBuffer.length > 0) {
+            // Si ya hay una línea de progreso, limpiarla primero
+            if (this.hasProgressLine) {
+                process.stdout.write('\r\x1b[K');
+            }
+            // Escribir todos los logs pendientes
+            for (const log of this.logBuffer) {
+                process.stdout.write((this.hasProgressLine ? '\n' : '') + log + '\n');
+                this.hasProgressLine = false;
+            }
+            this.logBuffer = [];
+        } // Escribir separador elegante antes del progreso
+        if (this.hasProgressLine) {
+            process.stdout.write('\r\x1b[K');
+        }
+        else {
+            process.stdout.write('\n\x1b[96m' + '▔'.repeat(50) + '\x1b[0m\n');
+        }
+        // 🎨 Barra de progreso con colores dinámicos
+        const stage = this.getStageFromText(progressText);
+        const { bgColor, textColor, icon } = this.getProgressColors(stage);
+        const progressBar = '█'.repeat(3);
+        const enhancedProgress = `\x1b[${bgColor}m\x1b[${textColor}m ${progressBar} ${icon} ${progressText} ${progressBar} \x1b[0m`;
+        process.stdout.write(enhancedProgress);
+        this.hasProgressLine = true;
+        this.lastProgressLine = progressText;
+    }
+    addLog(message) {
+        if (this.progressActive) {
+            this.logBuffer.push(message);
+        }
+        else {
+            this.originalConsoleLog(message);
+        }
+    }
+    addImmediateLog(message) {
+        if (this.progressActive) {
+            if (this.hasProgressLine) {
+                process.stdout.write('\r\x1b[K');
+            }
+            // Añadir un punto de separación visual para logs inmediatos
+            process.stdout.write('\x1b[90m│\x1b[0m ' + message + '\n');
+            this.hasProgressLine = false;
+        }
+        else {
+            this.originalConsoleLog(message);
+        }
+    }
+    endProgress() {
+        if (this.progressActive) {
+            if (this.hasProgressLine) {
+                process.stdout.write('\n');
+            }
+            // Mostrar barra de progreso final completa antes del separador
+            process.stdout.write('\n\x1b[33m' + '-'.repeat(50) + '\x1b[0m\n');
+            const finalProgressBar = '█'.repeat(3);
+            const finalProgress = `\x1b[42m\x1b[30m ${finalProgressBar} ✅ PROCESO COMPLETADO 100% ${finalProgressBar} \x1b[0m`;
+            process.stdout.write(finalProgress + '\n');
+            // 🎨 Footer moderno de finalización
+            const footerLine = '━'.repeat(48);
+            process.stdout.write('\x1b[92m' + footerLine + '\x1b[0m\n');
+            process.stdout.write('\x1b[92m│ \x1b[97m\x1b[1m✅ ¡Compilación Completada!\x1b[0m\x1b[92m' +
+                ' '.repeat(23) +
+                '│\x1b[0m\n');
+            process.stdout.write('\x1b[92m' + footerLine + '\x1b[0m\n\n');
+            // Escribir logs finales pendientes
+            if (this.logBuffer.length > 0) {
+                for (const log of this.logBuffer) {
+                    process.stdout.write(log + '\n');
+                }
+            }
+        }
+        this.restoreConsole();
+        this.progressActive = false;
+        this.lastProgressLine = '';
+        this.logBuffer = [];
+        this.hasProgressLine = false;
+    }
+    isActive() {
+        return this.progressActive;
+    }
+    /**
+     * 🎨 Determina la etapa del progreso basándose en el texto
+     */
+    getStageFromText(text) {
+        if (text.includes('Iniciando') || text.includes('Starting'))
+            return 'start';
+        if (text.includes('Tailwind') || text.includes('CSS'))
+            return 'tailwind';
+        if (text.includes('Recopilando') ||
+            text.includes('archivos') ||
+            text.includes('files'))
+            return 'files';
+        if (text.includes('Compilando') || text.includes('workers'))
+            return 'compile';
+        if (text.includes('cache') || text.includes('Guardando'))
+            return 'cache';
+        if (text.includes('linter') || text.includes('Linter'))
+            return 'linter';
+        if (text.includes('completado') || text.includes('Complete'))
+            return 'complete';
+        return 'default';
+    }
+    /**
+     * 🌈 Obtiene colores dinámicos para cada etapa
+     */
+    getProgressColors(stage) {
+        const colorSchemes = {
+            start: { bgColor: '45', textColor: '97', icon: '🚀' }, // Cyan brillante
+            tailwind: { bgColor: '105', textColor: '97', icon: '🎨' }, // Magenta
+            files: { bgColor: '43', textColor: '30', icon: '📁' }, // Amarillo
+            compile: { bgColor: '42', textColor: '30', icon: '⚙️' }, // Verde
+            cache: { bgColor: '44', textColor: '97', icon: '💾' }, // Azul
+            linter: { bgColor: '101', textColor: '97', icon: '🔍' }, // Rojo claro
+            complete: { bgColor: '102', textColor: '30', icon: '✅' }, // Verde claro
+            default: { bgColor: '100', textColor: '30', icon: '⏳' }, // Gris claro
+        };
+        const defaultColors = { bgColor: '100', textColor: '30', icon: '⏳' };
+        return colorSchemes[stage] || defaultColors;
+    }
+}
+// Función para ejecutar el linter antes de la compilación
+export async function runLinter(showResult = false) {
+    const linterENV = env.linter;
+    const linterPromises = [];
+    const linterErrors = [];
+    let proceedWithCompilation = true;
+    if (env.ENABLE_LINTER !== 'true') {
+        return true;
+    }
+    if (typeof linterENV === 'string' && linterENV.trim() !== '') {
+        logger.info('🔍 Ejecutando linting...');
+        try {
+            const parsedLinterEnv = JSON.parse(linterENV);
+            if (Array.isArray(parsedLinterEnv)) {
+                // Cargar dependencias de linting de forma lazy
+                const { ESLint, OxLint } = 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)
+                            .then((eslintResult) => {
+                            if (eslintResult && eslintResult.json) {
+                                // Procesar resultados de ESLint
+                                if (Array.isArray(eslintResult.json)) {
+                                    eslintResult.json.forEach((result) => {
+                                        const filePath = result.filePath ||
+                                            result.file ||
+                                            'archivo no especificado';
+                                        linterErrors.push({
+                                            from: 'eslint',
+                                            line: result.line || 'N/A',
+                                            column: result.column || 1,
+                                            file: filePath,
+                                            message: result.message,
+                                            severity: result.severity === 2
+                                                ? 'error'
+                                                : 'warning',
+                                            help: result.ruleId
+                                                ? `Regla ESLint: ${result.ruleId}`
+                                                : undefined,
+                                        });
+                                    });
+                                }
+                                else if (eslintResult.json.results &&
+                                    Array.isArray(eslintResult.json.results)) {
+                                    eslintResult.json.results.forEach((fileResult) => {
+                                        if (fileResult.messages &&
+                                            Array.isArray(fileResult.messages)) {
+                                            fileResult.messages.forEach((msg) => {
+                                                const filePath = fileResult.filePath ||
+                                                    fileResult.file ||
+                                                    'archivo no especificado';
+                                                linterErrors.push({
+                                                    from: 'eslint',
+                                                    line: msg.line ||
+                                                        'N/A',
+                                                    column: msg.column ||
+                                                        1,
+                                                    file: filePath,
+                                                    message: msg.message,
+                                                    severity: msg.severity ===
+                                                        2
+                                                        ? 'error'
+                                                        : 'warning',
+                                                    help: msg.ruleId
+                                                        ? `Regla ESLint: ${msg.ruleId}`
+                                                        : undefined,
+                                                });
+                                            });
+                                        }
+                                    });
+                                }
+                            }
+                        })
+                            .catch((err) => {
+                            logger.error(`❌ Error durante la ejecución de ESLint: ${err.message}`);
+                            linterErrors.push({
+                                file: item.configFile || 'ESLint Config',
+                                message: `Fallo al ejecutar ESLint: ${err.message}`,
+                                severity: 'error',
+                            });
+                        });
+                        linterPromises.push(eslintPromise);
+                    }
+                    else if (item.name.toLowerCase() === 'oxlint') {
+                        logger.info(`🔧 Ejecutando OxLint con config: ${item.configFile || 'por defecto'}`);
+                        const oxlintPromise = OxLint(item)
+                            .then((oxlintResult) => {
+                            if (oxlintResult &&
+                                oxlintResult['json'] &&
+                                Array.isArray(oxlintResult['json']['diagnostics'])) {
+                                oxlintResult['json']['diagnostics'].forEach((result) => {
+                                    const filePath = result.filename ||
+                                        result.file ||
+                                        'archivo no especificado';
+                                    const lineNumber = result.labels &&
+                                        result.labels[0] &&
+                                        result.labels[0].span
+                                        ? result.labels[0].span
+                                            .line ||
+                                            result.labels[0].span
+                                                .start?.line
+                                        : 'N/A';
+                                    const columnNumber = result.labels &&
+                                        result.labels[0] &&
+                                        result.labels[0].span
+                                        ? result.labels[0].span
+                                            .column ||
+                                            result.labels[0].span
+                                                .start?.column
+                                        : 1;
+                                    linterErrors.push({
+                                        from: 'oxlint',
+                                        line: lineNumber,
+                                        column: columnNumber,
+                                        file: filePath,
+                                        message: result.message,
+                                        severity: typeof result.severity ===
+                                            'string'
+                                            ? result.severity.toLowerCase()
+                                            : 'error',
+                                        help: result.help ||
+                                            (result.code
+                                                ? `Regla Oxlint: ${result.code}`
+                                                : undefined),
+                                    });
+                                });
+                            }
+                        })
+                            .catch((err) => {
+                            logger.error(`❌ Error durante la ejecución de OxLint: ${err.message}`);
+                            linterErrors.push({
+                                file: item.configFile || 'Oxlint Config',
+                                message: `Fallo al ejecutar Oxlint: ${err.message}`,
+                                severity: 'error',
+                            });
+                        });
+                        linterPromises.push(oxlintPromise);
+                    }
+                }
+            }
+            else {
+                logger.warn('⚠️ La configuración de linter no es un array válido.');
+            }
+            await Promise.all(linterPromises);
+            if (showResult) {
+                // Modo --linter: Solo mostrar resultados sin preguntar
+                if (linterErrors.length > 0) {
+                    await displayLinterErrors(linterErrors);
+                }
+                else {
+                    const chalk = await loadChalk();
+                    logger.info(chalk.green('✅ No se encontraron errores ni advertencias de linting.'));
+                }
+            }
+            else {
+                // Modo compilación: Mostrar errores si los hay y preguntar al usuario
+                if (linterErrors.length > 0) {
+                    await displayLinterErrors(linterErrors);
+                    logger.warn('🚨 Se encontraron errores o advertencias durante el linting.');
+                    if (env.yes === 'false') {
+                        const result = await promptUser('¿Deseas continuar con la compilación a pesar de los errores de linting? (s/N): ');
+                        if (result.toLowerCase() !== 's') {
+                            logger.info('🛑 Compilación cancelada por el usuario.');
+                            proceedWithCompilation = false;
+                        }
+                    }
+                }
+            }
+        }
+        catch (parseError) {
+            logger.warn(`Error parseando configuración de linter: ${parseError instanceof Error ? parseError.message : 'Error desconocido'}, omitiendo...`);
+        }
+    }
+    return proceedWithCompilation;
+}
+// Función para crear una barra de progreso visual
+function createProgressBar(current, total, width = 30) {
+    const percentage = Math.round((current / total) * 100);
+    const filled = Math.round((percentage / 100) * width);
+    const empty = width - filled;
+    return `[${'█'.repeat(filled)}${' '.repeat(empty)}] ${percentage}% (${current}/${total})`;
+}
+// Función helper para verificar si un archivo debe ser omitido por cache
+async function shouldSkipFile(filePath) {
+    return await smartCache.isValid(filePath);
+}
+// Función para compilar archivos con límite de concurrencia
+async function compileWithConcurrencyLimit(files, maxConcurrency = 8) {
+    const results = [];
+    const executing = [];
+    const total = files.length;
+    let completed = 0;
+    let skipped = 0;
+    let failed = 0;
+    // Usar el gestor de progreso existente (ya iniciado en initCompileAll)
+    const progressManager = ProgressManager.getInstance();
+    // Variable para controlar el progreso inicial
+    let hasShownInitialProgress = false;
+    // Contador para limpieza periódica de memoria
+    let compilationCounter = 0;
+    const CLEANUP_INTERVAL = 20; // Limpiar cada 20 compilaciones
+    // Función para mostrar progreso
+    function showProgress() {
+        const currentTotal = completed + skipped + failed;
+        const progressBar = createProgressBar(currentTotal, total);
+        const progressPercent = Math.round((currentTotal / total) * 100);
+        // Mostrar progreso inicial cuando se inicie O cuando haya progreso real
+        if ((currentTotal === 0 && !hasShownInitialProgress) ||
+            (progressPercent > lastProgressUpdate + 1 && currentTotal > 0) ||
+            currentTotal === total) {
+            const progressText = `🚀 ${progressBar} [✅ ${completed} | ⏭️ ${skipped} | ❌ ${failed}]`;
+            progressManager.updateProgress(progressText);
+            if (currentTotal === 0) {
+                hasShownInitialProgress = true;
+            }
+            lastProgressUpdate = progressPercent;
+            // NO terminar el progreso aquí - se termina en initCompileAll
+        }
+    }
+    // Mostrar progreso inicial
+    showProgress();
+    for (const file of files) {
+        const promise = (async () => {
+            try {
+                // Log verbose: Iniciando compilación del archivo
+                if (env.VERBOSE === 'true') {
+                    logger.info(`🔄 Compilando: ${path.basename(file)}`);
+                }
+                // Verificar cache antes de compilar
+                if (await shouldSkipFile(file)) {
+                    skipped++;
+                    if (env.VERBOSE === 'true') {
+                        logger.info(`⏭️ Archivo omitido (cache): ${path.basename(file)}`);
+                    }
+                    showProgress();
+                    return {
+                        success: true,
+                        cached: true,
+                        output: smartCache.getOutputPath(file),
+                    };
+                }
+                const result = await initCompile(file, false, 'batch');
+                // Actualizar cache si la compilación fue exitosa
+                if (result.success && result.output) {
+                    await smartCache.set(file, result.output);
+                    if (env.VERBOSE === 'true') {
+                        logger.info(`✅ Completado: ${path.basename(file)} → ${path.basename(result.output)}`);
+                    }
+                }
+                else if (env.VERBOSE === 'true') {
+                    logger.info(`❌ Error en: ${path.basename(file)}`);
+                }
+                completed++;
+                compilationCounter++; // Limpieza periódica de memoria
+                if (compilationCounter % CLEANUP_INTERVAL === 0) {
+                    // Forzar garbage collection si está disponible
+                    try {
+                        if (typeof globalThis.gc === 'function') {
+                            globalThis.gc();
+                        }
+                    }
+                    catch {
+                        // gc no disponible, continuar normalmente
+                    }
+                    // Limpiar cache si la memoria es alta
+                    const memUsage = process.memoryUsage();
+                    const heapUsedMB = memUsage.heapUsed / (1024 * 1024);
+                    if (heapUsedMB > 300) {
+                        // Si el heap supera 300MB
+                        const cacheEntries = smartCache.getStats().entries;
+                        if (cacheEntries > 50) {
+                            console.log(`[Memory] Heap alto (${heapUsedMB.toFixed(1)}MB), limpiando cache...`);
+                            // Limpiar entradas más antiguas del cache
+                            const removedEntries = smartCache.cleanOldEntries(20);
+                            if (removedEntries > 0) {
+                                console.log(`[Memory] Se removieron ${removedEntries} entradas del cache`);
+                            }
+                        }
+                    }
+                }
+                showProgress();
+                return result;
+            }
+            catch (error) {
+                failed++;
+                if (env.VERBOSE === 'true') {
+                    const errorMsg = error instanceof Error ? error.message : String(error);
+                    logger.error(`💥 Falló: ${path.basename(file)} - ${errorMsg}`);
+                }
+                showProgress();
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        })();
+        results.push(promise);
+        executing.push(promise);
+        // ✅ FIX: Esperar correctamente a que termine alguna promesa antes de continuar
+        if (executing.length >= maxConcurrency) {
+            // Esperar a que termine cualquier promesa
+            const completedPromise = await Promise.race(executing);
+            // Remover la promesa completada del array executing
+            const index = executing.indexOf(completedPromise);
+            if (index !== -1) {
+                executing.splice(index, 1);
+            }
+        }
+        // Limpiar promesas completadas del array executing
+        promise.then(() => {
+            const index = executing.indexOf(promise);
+            if (index !== -1) {
+                executing.splice(index, 1);
+            }
+        });
+    }
+    await Promise.all(results);
+    // El progreso ya se termina automáticamente en showProgress() cuando se completa
+}
+export async function initCompileAll() {
+    try {
+        // Inicializar el gestor de progreso desde el inicio
+        const progressManager = ProgressManager.getInstance();
+        progressManager.startProgress();
+        // Fase 1: Preparación inicial
+        progressManager.updateProgress('🚀 Iniciando compilación...');
+        // Limpiar estado de compilación anterior
+        clearCompilationState();
+        // Cargar cache al inicio
+        progressManager.updateProgress('📦 Cargando cache...');
+        await loadCache();
+        lastProgressUpdate = 0; // Fase 2: Linting
+        progressManager.updateProgress('🔍 Ejecutando linter...');
+        const shouldContinue = await runLinter(false); // false = mostrar errores y preguntar si hay errores
+        if (!shouldContinue) {
+            // await displayCompilationSummary(env.VERBOSE === 'true');
+            progressManager.endProgress();
+            return;
+        }
+        const startTime = Date.now();
+        const rawPathSource = env.PATH_SOURCE ?? '';
+        const pathDist = env.PATH_DIST ?? '';
+        const normalizedGlobPathSource = rawPathSource.replace(/\\/g, '/');
+        const patterns = [
+            `${normalizedGlobPathSource}/**/*.js`,
+            `${normalizedGlobPathSource}/**/*.vue`,
+            `${normalizedGlobPathSource}/**/*.ts`,
+            `${normalizedGlobPathSource}/**/*.mjs`,
+            `${normalizedGlobPathSource}/**/*.cjs`,
+        ];
+        logger.info(`📝 Compilando todos los archivos...`);
+        logger.info(`🔜 Fuente: ${rawPathSource}`);
+        logger.info(`🔚 Destino: ${pathDist}\n`);
+        // Fase 3: TailwindCSS
+        progressManager.updateProgress('🎨 Generando TailwindCSS...');
+        const generateTailwindCSS = await loadTailwind();
+        const resultTW = await generateTailwindCSS();
+        if (typeof resultTW !== 'boolean') {
+            if (resultTW?.success) {
+                logger.info(`🎨 ${resultTW.message}\n`);
+            }
+            else {
+                await handleCompilationError(new Error(`${resultTW.message}${resultTW.details ? '\n' + resultTW.details : ''}`), 'tailwind.config.js', 'tailwind', 'all', env.VERBOSE === 'true');
+            }
+        }
+        // Fase 4: Recopilando archivos
+        progressManager.updateProgress('📁 Recopilando archivos...');
+        const filesToCompile = [];
+        for await (const file of glob(patterns)) {
+            if (file.endsWith('.d.ts')) {
+                continue;
+            }
+            // Usar la ruta tal como viene de glob, sin modificar
+            filesToCompile.push(file);
+        }
+        // ✨ OPTIMIZACIÓN: Determinar concurrencia basada en CPUs y tipo de operación
+        let cpuCount = os.cpus().length;
+        const fileCount = filesToCompile.length;
+        // ✅ FIX: En algunos entornos (Docker, VMs), os.cpus() retorna 1
+        // Establecer un mínimo razonable basado en el tipo de sistema
+        if (cpuCount < 4) {
+            // Probablemente un contenedor o VM mal configurado
+            // Usar un valor conservador pero razonable
+            cpuCount = 4;
+            if (env.VERBOSE === 'true') {
+                logger.warn(`⚠️  Solo se detectó ${os.cpus().length} CPU. Usando ${cpuCount} hilos por defecto.`);
+            }
+        }
+        // ✅ OVERRIDE MANUAL: Permitir al usuario forzar un número de hilos
+        if (process.env.VERSACOMPILER_MAX_THREADS) {
+            const envThreads = parseInt(process.env.VERSACOMPILER_MAX_THREADS, 10);
+            if (!isNaN(envThreads) && envThreads > 0) {
+                cpuCount = envThreads;
+                if (env.VERBOSE === 'true') {
+                    logger.info(`🔧 Usando ${cpuCount} hilos (variable de entorno VERSACOMPILER_MAX_THREADS)`);
+                }
+            }
+        }
+        // Obtener memoria total del sistema (no solo heap)
+        const totalMemoryMB = os.totalmem() / (1024 * 1024);
+        const freeMemoryMB = os.freemem() / (1024 * 1024);
+        const memoryUsagePercent = ((totalMemoryMB - freeMemoryMB) / totalMemoryMB) * 100;
+        let maxConcurrency;
+        // ✅ ESTRATEGIA AGRESIVA: Usar TODOS los cores disponibles por defecto
+        // La compilación de archivos es I/O bound, no CPU bound, así que podemos ser agresivos
+        if (memoryUsagePercent > 90) {
+            // Solo si la memoria del SISTEMA está al 90%, reducir hilos
+            maxConcurrency = Math.max(4, Math.floor(cpuCount * 0.5));
+        }
+        else if (fileCount < 5) {
+            // Muy pocos archivos: no tiene sentido más hilos que archivos
+            maxConcurrency = fileCount;
+        }
+        else if (fileCount < 20) {
+            // Pocos archivos: usar todos los CPUs
+            maxConcurrency = cpuCount;
+        }
+        else if (fileCount < 50) {
+            // Archivos moderados: 1.5x los CPUs (I/O permite más hilos)
+            maxConcurrency = Math.floor(cpuCount * 1.5);
+        }
+        else if (fileCount < 200) {
+            // Muchos archivos: 2x los CPUs
+            maxConcurrency = cpuCount * 2;
+        }
+        else {
+            // Proyectos grandes: máxima concurrencia
+            maxConcurrency = Math.min(cpuCount * 3, 48);
+        }
+        // ✅ GARANTIZAR MÍNIMO RAZONABLE: Nunca menos de 4 hilos en proyectos > 10 archivos
+        if (fileCount > 10 && maxConcurrency < 4) {
+            maxConcurrency = 4;
+            if (env.VERBOSE === 'true') {
+                logger.info(`⚡ Ajustando a mínimo de 4 hilos para proyecto de ${fileCount} archivos`);
+            }
+        }
+        // Fase 5: Configurando workers y precargando módulos
+        progressManager.updateProgress('⚙️ Configurando workers...');
+        // ✅ Logging mejorado con información de recursos
+        logger.info(`🚀 Compilando ${fileCount} archivos con concurrencia optimizada (${maxConcurrency} hilos)...`);
+        // ✅ SIEMPRE mostrar info de CPUs/memoria para detectar problemas
+        logger.info(`   📊 CPUs detectados: ${os.cpus().length} (usando: ${cpuCount})`);
+        logger.info(`   💾 Memoria libre: ${freeMemoryMB.toFixed(0)}MB / ${totalMemoryMB.toFixed(0)}MB (${(100 - memoryUsagePercent).toFixed(1)}% libre)`);
+        logger.info(`   ⚡ Hilos configurados: ${maxConcurrency} (${(maxConcurrency / cpuCount).toFixed(1)}x CPUs)`);
+        // ⚠️ 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}`));
+        }
+        // ⚠️ ADVERTENCIA: Si los hilos son muy bajos para el tamaño del proyecto
+        if (fileCount > 50 && maxConcurrency < 8) {
+            logger.warn(`⚠️  Solo se usarán ${maxConcurrency} hilos para ${fileCount} archivos.`);
+            logger.warn(`   💡 Tip: Establece VERSACOMPILER_MAX_THREADS para forzar más hilos:`);
+            logger.warn(`   💡 export VERSACOMPILER_MAX_THREADS=16`);
+        }
+        // Precargar módulos ANTES de iniciar la compilación concurrente
+        // Esto evita que múltiples hilos intenten cargar node:crypto simultáneamente
+        const moduleManager = OptimizedModuleManager.getInstance();
+        const fileExtensions = new Set(filesToCompile.map(f => path.extname(f)));
+        await moduleManager.preloadForContext('batch', fileExtensions);
+        // 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
+        }
+        // Fase 6: Compilación (el progreso continúa en compileWithConcurrencyLimit)
+        progressManager.updateProgress(`🚀 Iniciando compilación de ${fileCount} archivos...`);
+        await compileWithConcurrencyLimit(filesToCompile, maxConcurrency); // Guardar cache al final
+        progressManager.updateProgress('💾 Guardando cache...');
+        await saveCache();
+        // ✨ FIX #4: Limpiar módulos no usados después de compilación masiva
+        progressManager.updateProgress('🧹 Limpiando módulos no usados...');
+        moduleManager.cleanupUnusedModules();
+        const endTime = Date.now();
+        const elapsedTime = showTimingForHumans(endTime - startTime); // Finalizar progreso
+        progressManager.endProgress();
+        // Mostrar resumen de compilación con tiempo total
+        await displayCompilationSummary(env.VERBOSE === 'true', elapsedTime);
+    }
+    catch (error) {
+        // Asegurar que el progreso termine en caso de error
+        const progressManager = ProgressManager.getInstance();
+        if (progressManager.isActive()) {
+            progressManager.endProgress();
+        }
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(`🚩 Error al compilar todos los archivos: ${errorMessage}`);
+        // Registrar el error en el sistema unificado
+        await handleCompilationError(error instanceof Error ? error : new Error(String(error)), 'compilación general', 'all', 'all', env.VERBOSE === 'true'); // Mostrar resumen incluso si hay errores generales
+        await displayCompilationSummary(env.VERBOSE === 'true');
+    }
+}
+/**
+ * 🎨 Obtiene icono apropiado para cada etapa
+ */
+function getStageIcon(stage) {
+    const icons = {
+        vue: '🎨',
+        typescript: '📘',
+        standardization: '💛',
+        minification: '🗜️',
+        tailwind: '🎨',
+        'file-read': '📖',
+        default: '⚙️',
+    };
+    return icons[stage] ?? '⚙️';
+}
+/**
+ *  Crea una barra de progreso visual con porcentaje
+ */
+function createProgressBarWithPercentage(percentage, width) {
+    const filled = Math.round((percentage / 100) * width);
+    const empty = width - filled;
+    // Usar código directo para evitar problemas de importación
+    const greenBar = '\x1b[32m' + '█'.repeat(filled) + '\x1b[0m';
+    const grayBar = '\x1b[90m' + '░'.repeat(empty) + '\x1b[0m';
+    return `${greenBar}${grayBar} ${percentage}%`;
+}
+// Función wrapper para compatibilidad con tests
+// ✨ FIX #5: Con timeout de 60 segundos para compilación individual
+export async function compileFile(filePath) {
+    return await withTimeout(initCompile(filePath, true, 'individual'), 60000, `compilación de ${path.basename(filePath)}`);
+}
+export { WatchModeOptimizer };
+//# sourceMappingURL=compile.js.map