versacompiler 2.1.0 → 2.2.0

package/dist/compiler/typescript-worker-pool.js

@@ -1 +1,936 @@
-import*as e from"node:os";import*as t from"node:path";import*as n from"node:process";import{Worker as r}from"node:worker_threads";import{validateTypesWithLanguageService as i}from"./typescript-sync-validator.js";export class TypeScriptWorkerPool{static instance;workers=[];poolSize;workerPath;initPromise=null;isInitialized=!1;TASK_TIMEOUT=8e3;WORKER_INIT_TIMEOUT=3e3;MAX_TASKS_PER_WORKER=200;WORKER_MEMORY_CHECK_INTERVAL=500;memoryCheckInterval=null;cleanupInterval=null;totalTasks=0;completedTasks=0;failedTasks=0;constructor(){let r=e.cpus().length;this.poolSize=Math.min(Math.max(r,4),16),this.workerPath=t.join(n.env.PATH_PROY||t.join(n.cwd(),`src`),`compiler`,`typescript-worker-thread.cjs`)}startMemoryMonitoring(){this.stopMemoryMonitoring(),this.memoryCheckInterval=setInterval(()=>{this.checkWorkersMemory()},15e3),this.cleanupInterval=setInterval(()=>{this.cleanupInactiveWorkers()},12e4)}stopMemoryMonitoring(){this.memoryCheckInterval&&(clearInterval(this.memoryCheckInterval),this.memoryCheckInterval=null),this.cleanupInterval&&(clearInterval(this.cleanupInterval),this.cleanupInterval=null)}async checkWorkersMemory(){let e=Date.now();for(let t of this.workers){t.lastMemoryCheck=e;try{if(t.memoryUsage=(await this.getWorkerMemoryUsage(t)).heapUsed,this.shouldRecycleWorker(t)){let e=this.getRecycleReason(t);console.warn(`[WorkerPool] Worker ${t.id} requiere reciclaje: ${e}`),await this.recycleWorker(t)}}catch(e){console.warn(`[WorkerPool] Error verificando memoria del worker ${t.id}:`,e)}}}async getWorkerMemoryUsage(e){return new Promise(t=>{let n=setTimeout(()=>{t({heapUsed:e.tasksProcessed*2048,heapTotal:e.tasksProcessed*3072,rss:e.tasksProcessed*4096})},1e3),r=`memory-${e.id}-${Date.now()}`,i=a=>{a.id===r&&a.type===`memory-usage`&&(clearTimeout(n),e.worker.off(`message`,i),t({heapUsed:a.memoryUsage?.heapUsed||e.tasksProcessed*2048,heapTotal:a.memoryUsage?.heapTotal||e.tasksProcessed*3072,rss:a.memoryUsage?.rss||e.tasksProcessed*4096}))};e.worker.on(`message`,i),e.worker.postMessage({type:`get-memory-usage`,id:r})})}getRecycleReason(e){let t=Date.now(),n=100*1024*1024,r=1800*1e3,i=this.MAX_TASKS_PER_WORKER,a=[];return e.memoryUsage>n&&a.push(`memoria excede ${Math.round(n/1024/1024)}MB (actual: ${Math.round(e.memoryUsage/1024/1024)}MB)`),t-e.creationTime>r&&a.push(`tiempo de vida excede ${Math.round(r/6e4)} minutos`),e.tasksProcessed>=i&&a.push(`tareas procesadas exceden ${i} (actual: ${e.tasksProcessed})`),a.join(`, `)}async cleanupInactiveWorkers(){let e=Date.now();for(let t of this.workers){let n=e-t.lastActivityTime;n>3e5&&!t.busy&&t.pendingTasks.size===0&&(console.info(`[WorkerPool] Worker ${t.id} inactivo por ${Math.round(n/6e4)} minutos, reciclando...`),await this.recycleWorker(t))}}shouldRecycleWorker(e){let t=Date.now(),n=this.MAX_TASKS_PER_WORKER;return e.memoryUsage>104857600||t-e.creationTime>18e5||e.tasksProcessed>=n}static getInstance(){return TypeScriptWorkerPool.instance||(TypeScriptWorkerPool.instance=new TypeScriptWorkerPool),TypeScriptWorkerPool.instance}setMode(t){switch(t){case`batch`:this.poolSize=Math.min(e.cpus().length,20);break;case`watch`:this.poolSize=Math.min(e.cpus().length,12);break;case`individual`:this.poolSize=Math.min(8,e.cpus().length);break}}async initializePool(){return this.initPromise||(this.initPromise=this._performPoolInitialization()),this.initPromise}async _performPoolInitialization(){try{if(!(await import(`node:fs`)).existsSync(this.workerPath))throw Error(`Worker thread file not found: ${this.workerPath}`);let e=Array.from({length:this.poolSize},(e,t)=>this.createWorker(t));this.workers=await Promise.all(e),this.isInitialized=!0}catch(e){throw this.isInitialized=!1,e}}async createWorker(e){return new Promise((t,i)=>{try{let a=new r(this.workerPath,{env:{...n.env,NODE_OPTIONS:``,WORKER_ID:e.toString()}}),o={worker:a,id:e,busy:!1,pendingTasks:new Map,taskCounter:0,memoryUsage:0,lastMemoryCheck:Date.now(),tasksProcessed:0,creationTime:Date.now(),lastActivityTime:Date.now()};this.setupWorkerListeners(o);let s=setTimeout(()=>{i(Error(`Worker ${e} initialization timeout`))},this.WORKER_INIT_TIMEOUT);a.on(`message`,function e(n){(n.id===`worker-ready`||n.message===`pong`)&&(clearTimeout(s),a.off(`message`,e),t(o))}),a.on(`error`,e=>{clearTimeout(s),i(e)}),a.postMessage({type:`ping`})}catch(e){i(e)}})}setupWorkerListeners(e){let{worker:t}=e;t.on(`message`,t=>{try{if(t.id===`worker-ready`||t.message===`pong`||t.type===`memory-usage`)return;let n=e.pendingTasks.get(t.id);if(!n)return;if(clearTimeout(n.timeout),e.pendingTasks.delete(t.id),e.pendingTasks.size===0&&(e.busy=!1),e.lastActivityTime=Date.now(),t.success&&t.diagnostics!==void 0&&t.hasErrors!==void 0){this.completedTasks++;let e=this.categorizeTypeScriptErrors({diagnostics:t.diagnostics,hasErrors:t.hasErrors},n.fileName);n.resolve(e)}else{this.failedTasks++;let e=t.error||`Error desconocido del worker`,r=this.createCategorizedError(e,n.fileName,t);n.reject(r)}}catch{}}),t.on(`error`,async t=>{await this.handleWorkerError(e,t)}),t.on(`exit`,async t=>{await this.handleWorkerExit(e,t)})}async handleWorkerError(e,t){console.warn(`[WorkerPool] Manejando error del worker ${e.id}:`,t.message),e.pendingTasks.forEach(n=>{clearTimeout(n.timeout),this.failedTasks++,n.reject(Error(`Worker ${e.id} failed: ${t.message}`))}),e.pendingTasks.clear();try{e.worker.removeAllListeners(),await e.worker.terminate()}catch(t){console.error(`[WorkerPool] Error terminando worker ${e.id}:`,t)}if(e.busy=!1,this.isInitialized&&this.workers.length>0)try{let t=await this.createWorker(e.id),n=this.workers.findIndex(t=>t.id===e.id);n!==-1&&(this.workers[n]=t)}catch(t){console.error(`[WorkerPool] No se pudo recrear worker ${e.id}:`,t)}}async handleWorkerExit(e,t){console.warn(`[WorkerPool] Worker ${e.id} salió con código ${t}`),e.pendingTasks.forEach(n=>{clearTimeout(n.timeout),this.failedTasks++,n.reject(Error(`Worker ${e.id} exited with code ${t}`))}),e.pendingTasks.clear(),e.busy=!1;try{e.worker.removeAllListeners()}catch{}if(this.isInitialized&&this.workers.length>0)try{await this.recreateWorker(e)}catch(t){console.error(`[WorkerPool] Error recreando worker ${e.id}:`,t)}}async recreateWorker(e){try{let t=await this.createWorker(e.id),n=this.workers.findIndex(t=>t.id===e.id);n!==-1&&(this.workers[n]=t)}catch{}}async recycleWorker(e){try{console.log(`[WorkerPool] Reciclando worker ${e.id} después de ${e.taskCounter} tareas`);let t=Date.now();await new Promise(n=>{let r=()=>{e.pendingTasks.size===0||Date.now()-t>=2e3?n():setTimeout(r,100)};r()});let n=Array.from(e.pendingTasks.entries());for(let[e,t]of n)clearTimeout(t.timeout),t.reject(Error(`Worker being recycled`));e.pendingTasks.clear();let r=e.worker;r.removeAllListeners(`message`),r.removeAllListeners(`error`),r.removeAllListeners(`exit`),r.removeAllListeners(`online`),r.removeAllListeners(`messageerror`);let i=e.worker;e.worker=null;let a=i.terminate(),o=new Promise((e,t)=>setTimeout(()=>t(Error(`Terminate timeout`)),3e3));await Promise.race([a,o]).catch(t=>{console.warn(`[WorkerPool] Warning al terminar worker ${e.id}:`,t)});let s=await this.createWorker(e.id),c=this.workers.findIndex(t=>t.id===e.id);c!==-1&&(this.workers[c]=s)}catch(t){console.error(`[WorkerPool] Error reciclando worker ${e.id}:`,t)}}findAvailableWorker(){let e=this.workers.find(e=>!e.busy&&e.pendingTasks.size===0);if(e)return e;let t=this.workers.reduce((e,t)=>t.pendingTasks.size<e.pendingTasks.size?t:e);return t.pendingTasks.size<5?t:null}async typeCheck(e,t,n){if(await this.initializePool(),!this.isInitialized)return this.typeCheckWithSyncFallback(e,t,n);let r=this.findAvailableWorker();if(!r)return this.typeCheckWithSyncFallback(e,t,n);try{return this.totalTasks++,await this.typeCheckWithWorker(r,e,t,n)}catch{return this.typeCheckWithSyncFallback(e,t,n)}}async typeCheckWithWorker(e,t,n,r){return e.taskCounter>=this.MAX_TASKS_PER_WORKER&&await this.recycleWorker(e),new Promise((i,a)=>{let o=`task-${e.id}-${++e.taskCounter}-${Date.now()}`;e.busy=!0,e.lastActivityTime=Date.now(),e.tasksProcessed++;let s=this.calculateDynamicTimeout(t,n,r),c=setTimeout(()=>{e.pendingTasks.delete(o),e.pendingTasks.size===0&&(e.busy=!1),a(Error(`Timeout (${s}ms) en type checking para ${t} - archivo complejo detectado`))},s);e.pendingTasks.set(o,{resolve:i,reject:a,timeout:c,fileName:t,startTime:Date.now()});try{let i={id:o,fileName:t,content:n,compilerOptions:{...r,_workerTimeout:s-1e3}};e.worker.postMessage(i)}catch(t){clearTimeout(c),e.pendingTasks.delete(o),e.pendingTasks.size===0&&(e.busy=!1),a(t)}})}calculateDynamicTimeout(e,t,n){let r=this.TASK_TIMEOUT,i=1,a=t.length;a>1e5?i+=1.5:a>5e4?i+=1:a>2e4&&(i+=.5);let o=(t.match(/^import\s+/gm)||[]).length,s=(t.match(/\btype\s+\w+/g)||[]).length,c=(t.match(/\binterface\s+\w+/g)||[]).length,l=(t.match(/<[^>]*>/g)||[]).length,u=o+s+c+l*.5;u>100?i+=2:u>50?i+=1:u>20&&(i+=.5),(n?.strict||n?.noImplicitAny)&&(i+=.3),e.includes(`.d.ts`)?i+=1:e.includes(`.vue`)&&(i+=.5),i=Math.min(i,5),i=Math.max(i,.5);let d=Math.round(r*i);return Math.min(d,6e4)}typeCheckWithSyncFallback(e,t,n){try{return i(e,t,n)}catch{return{diagnostics:[],hasErrors:!1}}}async terminate(){console.log(`[WorkerPool] Cerrando pool de workers...`),this.stopMemoryMonitoring();let e=0;for(let t of this.workers){e+=t.pendingTasks.size,t.pendingTasks.forEach(e=>{clearTimeout(e.timeout),e.reject(Error(`Worker pool cerrado`))}),t.pendingTasks.clear();try{t.worker.removeAllListeners()}catch{}}e>0&&console.log(`[WorkerPool] Se cancelaron ${e} tareas pendientes`);let t=this.workers.map(async e=>{try{await e.worker.terminate()}catch(t){console.warn(`[WorkerPool] Error terminando worker ${e.id}:`,t)}});await Promise.allSettled(t),this.workers=[],this.isInitialized=!1,this.initPromise=null,console.log(`[WorkerPool] Pool cerrado. Estadísticas finales: ${this.completedTasks} completadas, ${this.failedTasks} fallidas`)}getStats(){let e=this.workers.filter(e=>e.busy).length,t=this.workers.reduce((e,t)=>e+t.pendingTasks.size,0),n=this.totalTasks>0?Math.round(this.completedTasks/this.totalTasks*100):0;return{poolSize:this.workers.length,busyWorkers:e,totalPendingTasks:t,totalTasks:this.totalTasks,completedTasks:this.completedTasks,failedTasks:this.failedTasks,successRate:n}}categorizeTypeScriptErrors(e,t){if(!e.hasErrors||!e.diagnostics?.length)return e;let n=e.diagnostics.map(e=>({...e,_category:this.getErrorCategory(e),_severity:this.getErrorSeverity(e),_fileName:t,_timestamp:Date.now()}));return{...e,diagnostics:n,_errorStats:this.calculateErrorStats(n)}}getErrorCategory(e){let t=e.code;return[2304,2339,2346].includes(t)?`MISSING_DECLARATION`:[2322,2322,2345].includes(t)?`TYPE_MISMATCH`:[2307,2317].includes(t)?`MODULE_RESOLUTION`:[2552,2551].includes(t)?`PROPERTY_ACCESS`:t>=1e3&&t<2e3?`SYNTAX_ERROR`:t>=2e3&&t<3e3?`SEMANTIC_ERROR`:t>=4e3?`CONFIG_ERROR`:`OTHER`}getErrorSeverity(e){switch(e.category){case 1:return`ERROR`;case 2:return`WARNING`;case 3:return`INFO`;default:return`ERROR`}}calculateErrorStats(e){let t={totalErrors:e.length,errorsByCategory:{},errorsBySeverity:{},mostCommonError:null};e.forEach(e=>{let n=e._category||`OTHER`,r=e._severity||`ERROR`;t.errorsByCategory[n]=(t.errorsByCategory[n]||0)+1,t.errorsBySeverity[r]=(t.errorsBySeverity[r]||0)+1});let n={};e.forEach(e=>{let t=String(e.code);n[t]=(n[t]||0)+1});let r=Object.keys(n);if(r.length>0){let i=r.reduce((e,t)=>(n[e]||0)>(n[t]||0)?e:t);t.mostCommonError={code:i,count:n[i],message:e.find(e=>String(e.code)===i)?.messageText}}return t}createCategorizedError(e,t,n){let r=Error(e);return r.fileName=t,r.timestamp=Date.now(),r.workerResponse=n,r.category=this.categorizeGenericError(e),r.isRecoverable=this.isRecoverableError(e),r}categorizeGenericError(e){return e.includes(`timeout`)||e.includes(`Timeout`)?`TIMEOUT`:e.includes(`memory`)||e.includes(`Memory`)?`MEMORY`:e.includes(`Worker`)&&e.includes(`exited`)?`WORKER_CRASH`:e.includes(`initialization`)||e.includes(`init`)?`INITIALIZATION`:`UNKNOWN`}isRecoverableError(e){return[`timeout`,`Worker being recycled`,`Worker pool cerrado`,`temporary`].some(t=>e.toLowerCase().includes(t.toLowerCase()))}}
+/**
+ * TypeScript Worker Pool - Pool de workers para compilación paralela
+ * Reemplaza el worker único con múltiples workers para aprovecha la concurrencia real
+ */
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as process from 'node:process';
+import { setImmediate } from 'node:timers';
+import { Worker } from 'node:worker_threads';
+import { validateTypesWithLanguageService } from './typescript-sync-validator.js';
+/**
+ * Pool de workers para compilación TypeScript paralela
+ * Distribuye las tareas entre múltiples workers para mayor rendimiento
+ */
+export class TypeScriptWorkerPool {
+    static instance;
+    workers = [];
+    poolSize;
+    workerPath;
+    initPromise = null;
+    isInitialized = false; // Configuración optimizada con reciclaje de workers
+    TASK_TIMEOUT = 8000; // 8 segundos por tarea (reducido para mayor velocidad)
+    WORKER_INIT_TIMEOUT = 3000; // 3 segundos para inicializar (reducido)
+    MAX_TASKS_PER_WORKER = 200; // ✨ OPTIMIZADO: Aumentado de 50 a 200 para reducir overhead de reciclaje
+    WORKER_MEMORY_CHECK_INTERVAL = 500; // ✨ OPTIMIZADO: Verificar cada 500 tareas (reducir overhead)
+    // ✨ FIX #1: Referencias a timers para limpieza adecuada
+    memoryCheckInterval = null;
+    cleanupInterval = null;
+    // Métricas de rendimiento
+    totalTasks = 0;
+    completedTasks = 0;
+    failedTasks = 0;
+    constructor() {
+        // Determinar tamaño óptimo del pool - MÁS AGRESIVO para mejor rendimiento
+        const cpuCount = os.cpus().length;
+        // Usar más workers para aprovechar mejor el CPU
+        this.poolSize = Math.min(Math.max(cpuCount, 4), 16); // Entre 4 y 16 workers
+        this.workerPath = path.join(process.env.PATH_PROY || path.join(process.cwd(), 'src'), 'compiler', 'typescript-worker-thread.cjs');
+        // ✨ ISSUE #4: Configurar monitoreo de memoria automático        this.startMemoryMonitoring();
+    }
+    // ✨ ISSUE #4: Métodos de control de memoria y timeouts
+    /**
+     * Inicia el monitoreo automático de memoria de workers
+     * ✨ FIX #1: Ahora almacena referencias a los intervalos para limpieza posterior
+     */
+    startMemoryMonitoring() {
+        // Limpiar intervalos previos si existen
+        this.stopMemoryMonitoring();
+        // Monitoreo cada 15 segundos (más frecuente)
+        this.memoryCheckInterval = setInterval(() => {
+            this.checkWorkersMemory();
+        }, 15000);
+        // Limpieza de workers inactivos cada 2 minutos (más frecuente)
+        this.cleanupInterval = setInterval(() => {
+            this.cleanupInactiveWorkers();
+        }, 120000);
+    }
+    /**
+     * ✨ FIX #1: Detiene el monitoreo automático de memoria
+     */
+    stopMemoryMonitoring() {
+        if (this.memoryCheckInterval) {
+            clearInterval(this.memoryCheckInterval);
+            this.memoryCheckInterval = null;
+        }
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+    }
+    /**
+     * Verifica el uso de memoria de todos los workers con medición real
+     */
+    async checkWorkersMemory() {
+        const now = Date.now();
+        for (const poolWorker of this.workers) {
+            // Actualizar tiempo de última verificación
+            poolWorker.lastMemoryCheck = now;
+            try {
+                // ✨ ISSUE #4: Obtener memoria real del worker
+                const memoryInfo = await this.getWorkerMemoryUsage(poolWorker);
+                poolWorker.memoryUsage = memoryInfo.heapUsed;
+                // Verificar límites de memoria y reciclaje automático
+                if (this.shouldRecycleWorker(poolWorker)) {
+                    const reason = this.getRecycleReason(poolWorker);
+                    console.warn(`[WorkerPool] Worker ${poolWorker.id} requiere reciclaje: ${reason}`);
+                    await this.recycleWorker(poolWorker);
+                }
+            }
+            catch (error) {
+                console.warn(`[WorkerPool] Error verificando memoria del worker ${poolWorker.id}:`, error);
+            }
+        }
+    }
+    /**
+     * Obtiene el uso real de memoria de un worker
+     */
+    async getWorkerMemoryUsage(poolWorker) {
+        return new Promise(resolve => {
+            const timeout = setTimeout(() => {
+                // Fallback con estimación si no hay respuesta
+                resolve({
+                    heapUsed: poolWorker.tasksProcessed * 2048, // 2KB por tarea
+                    heapTotal: poolWorker.tasksProcessed * 3072, // 3KB total estimado
+                    rss: poolWorker.tasksProcessed * 4096, // 4KB RSS estimado
+                });
+            }, 1000);
+            // Solicitar memoria real del worker
+            const memoryRequestId = `memory-${poolWorker.id}-${Date.now()}`;
+            const handler = (response) => {
+                if (response.id === memoryRequestId &&
+                    response.type === 'memory-usage') {
+                    clearTimeout(timeout);
+                    poolWorker.worker.off('message', handler);
+                    resolve({
+                        heapUsed: response.memoryUsage?.heapUsed ||
+                            poolWorker.tasksProcessed * 2048,
+                        heapTotal: response.memoryUsage?.heapTotal ||
+                            poolWorker.tasksProcessed * 3072,
+                        rss: response.memoryUsage?.rss ||
+                            poolWorker.tasksProcessed * 4096,
+                    });
+                }
+            };
+            poolWorker.worker.on('message', handler);
+            poolWorker.worker.postMessage({
+                type: 'get-memory-usage',
+                id: memoryRequestId,
+            });
+        });
+    }
+    /**
+     * Obtiene la razón por la cual un worker debe ser reciclado
+     * ✨ OPTIMIZACIÓN #11: Límites aumentados para reducir overhead de reciclaje
+     */
+    getRecycleReason(poolWorker) {
+        const now = Date.now();
+        const MEMORY_LIMIT = 100 * 1024 * 1024; // ✨ 100MB (aumentado de 50MB)
+        const TIME_LIMIT = 30 * 60 * 1000; // 30 minutos
+        const TASK_LIMIT = this.MAX_TASKS_PER_WORKER;
+        const reasons = [];
+        if (poolWorker.memoryUsage > MEMORY_LIMIT) {
+            reasons.push(`memoria excede ${Math.round(MEMORY_LIMIT / 1024 / 1024)}MB (actual: ${Math.round(poolWorker.memoryUsage / 1024 / 1024)}MB)`);
+        }
+        if (now - poolWorker.creationTime > TIME_LIMIT) {
+            reasons.push(`tiempo de vida excede ${Math.round(TIME_LIMIT / 60000)} minutos`);
+        }
+        if (poolWorker.tasksProcessed >= TASK_LIMIT) {
+            reasons.push(`tareas procesadas exceden ${TASK_LIMIT} (actual: ${poolWorker.tasksProcessed})`);
+        }
+        return reasons.join(', ');
+    } /**
+     * Limpia workers que han estado inactivos por mucho tiempo
+     */
+    async cleanupInactiveWorkers() {
+        const now = Date.now();
+        const INACTIVE_TIMEOUT = 5 * 60 * 1000; // 5 minutos (reducido)
+        for (const poolWorker of this.workers) {
+            const timeSinceLastActivity = now - poolWorker.lastActivityTime;
+            if (timeSinceLastActivity > INACTIVE_TIMEOUT &&
+                !poolWorker.busy &&
+                poolWorker.pendingTasks.size === 0) {
+                console.info(`[WorkerPool] Worker ${poolWorker.id} inactivo por ${Math.round(timeSinceLastActivity / 60000)} minutos, reciclando...`);
+                await this.recycleWorker(poolWorker);
+            }
+        }
+    } /**
+     * Verifica si un worker debe ser reciclado por límites de memoria/tiempo
+     * ✨ OPTIMIZACIÓN #11: Límites aumentados para reducir overhead de reciclaje
+     */
+    shouldRecycleWorker(poolWorker) {
+        const now = Date.now();
+        const MEMORY_LIMIT = 100 * 1024 * 1024; // ✨ 100MB (aumentado de 30MB)
+        const TIME_LIMIT = 30 * 60 * 1000; // ✨ 30 minutos (aumentado de 15 min)
+        const TASK_LIMIT = this.MAX_TASKS_PER_WORKER;
+        return (poolWorker.memoryUsage > MEMORY_LIMIT ||
+            now - poolWorker.creationTime > TIME_LIMIT ||
+            poolWorker.tasksProcessed >= TASK_LIMIT);
+    }
+    /**
+     * Obtiene la instancia singleton del Worker Pool
+     */
+    static getInstance() {
+        if (!TypeScriptWorkerPool.instance) {
+            TypeScriptWorkerPool.instance = new TypeScriptWorkerPool();
+        }
+        return TypeScriptWorkerPool.instance;
+    }
+    /**
+     * Configura el modo de operación del pool - OPTIMIZADO para máxima velocidad
+     */
+    setMode(mode) {
+        // Ajustar configuración según el modo - MÁS AGRESIVO
+        switch (mode) {
+            case 'batch':
+                // Para modo batch, máxima concurrencia para throughput
+                this.poolSize = Math.min(os.cpus().length, 20);
+                break;
+            case 'watch':
+                // Para modo watch, más workers para mejor responsividad
+                this.poolSize = Math.min(os.cpus().length, 12);
+                break;
+            case 'individual':
+                // Para individual, pool moderado
+                this.poolSize = Math.min(8, os.cpus().length);
+                break;
+        }
+    }
+    /**
+     * Inicializa el pool de workers
+     */
+    async initializePool() {
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+        this.initPromise = this._performPoolInitialization();
+        return this.initPromise;
+    }
+    /**
+     * Realiza la inicialización del pool de workers
+     */
+    async _performPoolInitialization() {
+        try {
+            // Verificar que el archivo del worker existe
+            const fs = await import('node:fs');
+            const exists = fs.existsSync(this.workerPath);
+            if (!exists) {
+                throw new Error(`Worker thread file not found: ${this.workerPath}`);
+            }
+            // Crear workers en paralelo
+            const workerPromises = Array.from({ length: this.poolSize }, (_, index) => this.createWorker(index));
+            this.workers = await Promise.all(workerPromises);
+            this.isInitialized = true;
+        }
+        catch (error) {
+            this.isInitialized = false;
+            throw error;
+        }
+    }
+    /**
+     * Crea un worker individual
+     */
+    async createWorker(workerId) {
+        return new Promise((resolve, reject) => {
+            try {
+                const worker = new Worker(this.workerPath, {
+                    env: {
+                        ...process.env,
+                        NODE_OPTIONS: '',
+                        WORKER_ID: workerId.toString(),
+                    },
+                });
+                const poolWorker = {
+                    worker,
+                    id: workerId,
+                    busy: false,
+                    pendingTasks: new Map(),
+                    taskCounter: 0,
+                    // ✨ ISSUE #4: Inicializar controles de memoria
+                    memoryUsage: 0,
+                    lastMemoryCheck: Date.now(),
+                    tasksProcessed: 0,
+                    creationTime: Date.now(),
+                    lastActivityTime: Date.now(),
+                };
+                // Configurar listeners
+                this.setupWorkerListeners(poolWorker);
+                // Timeout para inicialización
+                const initTimeout = setTimeout(() => {
+                    reject(new Error(`Worker ${workerId} initialization timeout`));
+                }, this.WORKER_INIT_TIMEOUT);
+                // Esperar que el worker esté listo
+                const checkReady = () => {
+                    worker.postMessage({ type: 'ping' });
+                };
+                worker.on('message', function readyHandler(response) {
+                    if (response.id === 'worker-ready' ||
+                        response.message === 'pong') {
+                        clearTimeout(initTimeout);
+                        worker.off('message', readyHandler);
+                        resolve(poolWorker);
+                    }
+                });
+                worker.on('error', (error) => {
+                    clearTimeout(initTimeout);
+                    reject(error);
+                });
+                // Intentar conectar
+                checkReady();
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Configura los listeners para un worker individual
+     */
+    setupWorkerListeners(poolWorker) {
+        const { worker } = poolWorker;
+        worker.on('message', (response) => {
+            try {
+                // Ignorar mensajes de control
+                if (response.id === 'worker-ready' ||
+                    response.message === 'pong') {
+                    return;
+                }
+                // ✨ ISSUE #4: Manejar reportes de memoria del worker
+                if (response.type === 'memory-usage') {
+                    return; // Ya manejado en getWorkerMemoryUsage
+                }
+                // Buscar la tarea pendiente
+                const pendingTask = poolWorker.pendingTasks.get(response.id);
+                if (!pendingTask) {
+                    return;
+                }
+                // ✨ FIX MEMORIA: Limpiar timeout INMEDIATAMENTE para liberar referencias
+                clearTimeout(pendingTask.timeout);
+                // ✨ FIX MEMORIA: Guardar referencias necesarias antes de eliminar la tarea
+                const { resolve, reject } = pendingTask;
+                // ✨ FIX MEMORIA: Eliminar la tarea del mapa ANTES de procesarla
+                poolWorker.pendingTasks.delete(response.id);
+                // Marcar worker como disponible si no tiene más tareas
+                if (poolWorker.pendingTasks.size === 0) {
+                    poolWorker.busy = false;
+                }
+                // Actualizar actividad del worker
+                poolWorker.lastActivityTime = Date.now();
+                // ✨ ISSUE #4: Manejo mejorado de errores de TypeScript
+                if (response.success &&
+                    response.diagnostics !== undefined &&
+                    response.hasErrors !== undefined) {
+                    this.completedTasks++;
+                    // ✨ FIX MEMORIA: Crear resultado sin referencias circulares
+                    const result = {
+                        diagnostics: response.diagnostics || [],
+                        hasErrors: response.hasErrors,
+                    };
+                    // ✨ FIX MEMORIA: No mantener response completo en memoria
+                    resolve(result);
+                    // ✨ FIX MEMORIA: Limpiar diagnostics después de resolver
+                    setImmediate(() => {
+                        if (response.diagnostics) {
+                            response.diagnostics.length = 0;
+                        }
+                    });
+                }
+                else {
+                    this.failedTasks++;
+                    const errorMessage = response.error || 'Error desconocido del worker';
+                    // ✨ FIX MEMORIA: Error simple sin referencias pesadas
+                    const error = new Error(errorMessage);
+                    reject(error);
+                }
+            }
+            catch {
+                // Error silencioso - no imprimir cada error
+            }
+        });
+        worker.on('error', async (error) => {
+            await this.handleWorkerError(poolWorker, error);
+        });
+        worker.on('exit', async (code) => {
+            await this.handleWorkerExit(poolWorker, code);
+        });
+    }
+    /**
+     * Maneja errores de un worker específico con cleanup completo
+     * ✨ FIX MEMORIA: Limpieza agresiva y sin esperas
+     */
+    async handleWorkerError(poolWorker, error) {
+        console.warn(`[WorkerPool] Manejando error del worker ${poolWorker.id}:`, error.message);
+        // 1. ✨ FIX MEMORIA: Limpiar INMEDIATAMENTE todas las tareas pendientes
+        const pendingTasksArray = Array.from(poolWorker.pendingTasks.entries());
+        for (const [taskId, task] of pendingTasksArray) {
+            clearTimeout(task.timeout);
+            this.failedTasks++;
+            task.reject(new Error(`Worker ${poolWorker.id} failed`));
+            poolWorker.pendingTasks.delete(taskId);
+        }
+        poolWorker.pendingTasks.clear();
+        // 2. ✨ FIX MEMORIA: Remover listeners antes de terminar
+        try {
+            poolWorker.worker.removeAllListeners('message');
+            poolWorker.worker.removeAllListeners('error');
+            poolWorker.worker.removeAllListeners('exit');
+            poolWorker.worker.removeAllListeners('online');
+            poolWorker.worker.removeAllListeners('messageerror');
+        }
+        catch {
+            // Silencioso
+        }
+        // 3. ✨ FIX MEMORIA: Terminar sin esperar
+        const workerToTerminate = poolWorker.worker;
+        poolWorker.worker = null;
+        poolWorker.busy = false;
+        workerToTerminate.terminate().catch(() => {
+            // Silencioso
+        });
+        // 4. ✨ FIX MEMORIA: Recrear worker asíncronamente sin bloquear
+        if (this.isInitialized && this.workers.length > 0) {
+            setImmediate(async () => {
+                try {
+                    const newWorker = await this.createWorker(poolWorker.id);
+                    const index = this.workers.findIndex(w => w.id === poolWorker.id);
+                    if (index !== -1) {
+                        this.workers[index] = newWorker;
+                    }
+                }
+                catch {
+                    // Silencioso
+                }
+            });
+        }
+    }
+    /**
+     * Maneja la salida inesperada de un worker con cleanup completo
+     */
+    async handleWorkerExit(poolWorker, code) {
+        console.warn(`[WorkerPool] Worker ${poolWorker.id} salió con código ${code}`);
+        // 1. Rechazar tareas pendientes con cleanup
+        poolWorker.pendingTasks.forEach(task => {
+            clearTimeout(task.timeout);
+            this.failedTasks++;
+            task.reject(new Error(`Worker ${poolWorker.id} exited with code ${code}`));
+        });
+        poolWorker.pendingTasks.clear();
+        poolWorker.busy = false;
+        // 2. Limpiar listeners para evitar memory leaks
+        try {
+            poolWorker.worker.removeAllListeners();
+        }
+        catch {
+            // Error silencioso en cleanup
+        }
+        // 3. Recrear worker si es necesario y el pool está activo
+        if (this.isInitialized && this.workers.length > 0) {
+            try {
+                await this.recreateWorker(poolWorker);
+            }
+            catch (recreateError) {
+                console.error(`[WorkerPool] Error recreando worker ${poolWorker.id}:`, recreateError);
+            }
+        }
+    }
+    /**
+     * Recrea un worker que falló
+     */
+    async recreateWorker(failedWorker) {
+        try {
+            const newWorker = await this.createWorker(failedWorker.id);
+            // Reemplazar en el array
+            const index = this.workers.findIndex(w => w.id === failedWorker.id);
+            if (index !== -1) {
+                this.workers[index] = newWorker;
+            }
+        }
+        catch {
+            // Error silencioso en recreación
+        }
+    }
+    /**
+     * Recicla un worker para prevenir memory leaks
+     * ✨ FIX MEMORIA: Limpieza agresiva de todas las referencias
+     */
+    async recycleWorker(poolWorker) {
+        try {
+            console.log(`[WorkerPool] Reciclando worker ${poolWorker.id} después de ${poolWorker.taskCounter} tareas`);
+            // 1. ✨ FIX MEMORIA: No esperar, rechazar inmediatamente todas las tareas pendientes
+            const pendingTasksArray = Array.from(poolWorker.pendingTasks.entries());
+            for (const [taskId, task] of pendingTasksArray) {
+                clearTimeout(task.timeout);
+                task.reject(new Error('Worker being recycled'));
+                poolWorker.pendingTasks.delete(taskId);
+            }
+            // ✨ FIX MEMORIA: Forzar limpieza del Map
+            poolWorker.pendingTasks.clear();
+            // 2. ✨ FIX MEMORIA: Remover listeners explícitamente por tipo
+            const worker = poolWorker.worker;
+            worker.removeAllListeners('message');
+            worker.removeAllListeners('error');
+            worker.removeAllListeners('exit');
+            worker.removeAllListeners('online');
+            worker.removeAllListeners('messageerror');
+            // 3. ✨ FIX MEMORIA: Guardar referencia temporal y limpiar poolWorker
+            const workerToTerminate = poolWorker.worker;
+            const workerId = poolWorker.id;
+            // Limpiar todas las propiedades del poolWorker
+            poolWorker.worker = null;
+            poolWorker.busy = false;
+            poolWorker.taskCounter = 0;
+            poolWorker.tasksProcessed = 0;
+            poolWorker.memoryUsage = 0;
+            // 4. ✨ FIX MEMORIA: Terminar con timeout agresivo
+            const terminatePromise = workerToTerminate.terminate();
+            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Terminate timeout')), 2000));
+            await Promise.race([terminatePromise, timeoutPromise]).catch(() => {
+                // Forzar terminación si falla
+                try {
+                    workerToTerminate.terminate();
+                }
+                catch {
+                    // Silencioso
+                }
+            });
+            // ✨ FIX MEMORIA: Forzar garbage collection del worker terminado
+            setImmediate(() => {
+                // Dar tiempo al GC para limpiar
+            });
+            // 5. ✨ FIX MEMORIA: Crear y reemplazar con nuevo worker
+            const newWorker = await this.createWorker(workerId);
+            const index = this.workers.findIndex(w => w.id === workerId);
+            if (index !== -1) {
+                this.workers[index] = newWorker;
+            }
+        }
+        catch (error) {
+            console.error(`[WorkerPool] Error reciclando worker ${poolWorker.id}:`, error);
+            // ✨ FIX MEMORIA: Asegurar limpieza incluso en error
+            poolWorker.pendingTasks.clear();
+            poolWorker.busy = false;
+        }
+    }
+    /**
+     * Encuentra el worker menos ocupado
+     */
+    findAvailableWorker() {
+        // Buscar worker completamente libre
+        const freeWorker = this.workers.find(w => !w.busy && w.pendingTasks.size === 0);
+        if (freeWorker) {
+            return freeWorker;
+        }
+        // Si no hay workers libres, buscar el menos ocupado
+        const leastBusyWorker = this.workers.reduce((least, current) => {
+            if (current.pendingTasks.size < least.pendingTasks.size) {
+                return current;
+            }
+            return least;
+        });
+        // Solo devolver si no está demasiado ocupado
+        if (leastBusyWorker.pendingTasks.size < 5) {
+            return leastBusyWorker;
+        }
+        return null; // Todos los workers están muy ocupados
+    }
+    /**
+     * Realiza type checking usando el pool de workers
+     */
+    async typeCheck(fileName, content, compilerOptions) {
+        // Asegurar que el pool esté inicializado
+        await this.initializePool();
+        if (!this.isInitialized) {
+            return this.typeCheckWithSyncFallback(fileName, content, compilerOptions);
+        }
+        // Buscar worker disponible
+        const availableWorker = this.findAvailableWorker();
+        // ✨ FIX: Incrementar totalTasks ANTES del try/catch para conteo correcto
+        this.totalTasks++;
+        if (!availableWorker) {
+            return this.typeCheckWithSyncFallback(fileName, content, compilerOptions);
+        }
+        try {
+            return await this.typeCheckWithWorker(availableWorker, fileName, content, compilerOptions);
+        }
+        catch {
+            return this.typeCheckWithSyncFallback(fileName, content, compilerOptions);
+        }
+    }
+    /**
+     * Realiza type checking usando un worker específico con reciclaje automático
+     * ✨ FIX MEMORIA: Optimizado para prevenir fugas de memoria
+     */
+    async typeCheckWithWorker(poolWorker, fileName, content, compilerOptions) {
+        // Verificar si el worker necesita reciclaje por número de tareas
+        if (poolWorker.taskCounter >= this.MAX_TASKS_PER_WORKER) {
+            // ✨ FIX: No esperar el reciclaje, usar fallback
+            return this.typeCheckWithSyncFallback(fileName, content, compilerOptions);
+        }
+        return new Promise((resolve, reject) => {
+            const taskId = `task-${poolWorker.id}-${++poolWorker.taskCounter}-${Date.now()}`;
+            // Marcar worker como ocupado y actualizar actividad
+            poolWorker.busy = true;
+            poolWorker.lastActivityTime = Date.now();
+            poolWorker.tasksProcessed++;
+            // ✨ ISSUE #4: Timeout dinámico basado en complejidad del archivo
+            const dynamicTimeout = this.calculateDynamicTimeout(fileName, content, compilerOptions);
+            // ✨ FIX MEMORIA: Configurar timeout con limpieza explícita
+            const timeout = setTimeout(() => {
+                const task = poolWorker.pendingTasks.get(taskId);
+                if (task) {
+                    poolWorker.pendingTasks.delete(taskId);
+                    if (poolWorker.pendingTasks.size === 0) {
+                        poolWorker.busy = false;
+                    }
+                    reject(new Error(`Timeout (${dynamicTimeout}ms) en type checking para ${fileName}`));
+                }
+            }, dynamicTimeout);
+            // ✨ FIX MEMORIA: Wrapper para resolver/rechazar que limpia el timeout
+            const wrappedResolve = (result) => {
+                clearTimeout(timeout);
+                resolve(result);
+            };
+            const wrappedReject = (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            };
+            // ✨ FIX MEMORIA: Agregar tarea con wrappers que auto-limpian
+            poolWorker.pendingTasks.set(taskId, {
+                resolve: wrappedResolve,
+                reject: wrappedReject,
+                timeout,
+                fileName,
+                startTime: Date.now(),
+            });
+            try {
+                // ✨ FIX: Pasar todas las opciones relevantes del tsconfig.json de forma serializable
+                // Crear copia limpia con solo valores primitivos (sin funciones, símbolos, etc.)
+                const serializableOptions = {};
+                for (const key in compilerOptions) {
+                    const value = compilerOptions[key];
+                    // Solo pasar valores serializables (primitivos, arrays, objetos simples)
+                    if (value !== undefined &&
+                        value !== null &&
+                        typeof value !== 'function' &&
+                        typeof value !== 'symbol') {
+                        serializableOptions[key] = value;
+                    }
+                }
+                const message = {
+                    id: taskId,
+                    fileName,
+                    content,
+                    compilerOptions: serializableOptions,
+                };
+                // Enviar mensaje al worker
+                poolWorker.worker.postMessage(message);
+            }
+            catch (error) {
+                // Limpiar en caso de error
+                clearTimeout(timeout);
+                poolWorker.pendingTasks.delete(taskId);
+                if (poolWorker.pendingTasks.size === 0) {
+                    poolWorker.busy = false;
+                }
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Calcula un timeout dinámico basado en la complejidad del archivo TypeScript
+     */
+    calculateDynamicTimeout(fileName, content, compilerOptions) {
+        const baseTimeout = this.TASK_TIMEOUT; // 10 segundos base
+        let complexityMultiplier = 1;
+        // Factor 1: Tamaño del archivo
+        const contentLength = content.length;
+        if (contentLength > 100000) {
+            // Archivos > 100KB
+            complexityMultiplier += 1.5;
+        }
+        else if (contentLength > 50000) {
+            // Archivos > 50KB
+            complexityMultiplier += 1;
+        }
+        else if (contentLength > 20000) {
+            // Archivos > 20KB
+            complexityMultiplier += 0.5;
+        }
+        // Factor 2: Complejidad sintáctica
+        const importCount = (content.match(/^import\s+/gm) || []).length;
+        const typeCount = (content.match(/\btype\s+\w+/g) || []).length;
+        const interfaceCount = (content.match(/\binterface\s+\w+/g) || [])
+            .length;
+        const genericCount = (content.match(/<[^>]*>/g) || []).length;
+        const complexConstructs = importCount + typeCount + interfaceCount + genericCount * 0.5;
+        if (complexConstructs > 100) {
+            complexityMultiplier += 2;
+        }
+        else if (complexConstructs > 50) {
+            complexityMultiplier += 1;
+        }
+        else if (complexConstructs > 20) {
+            complexityMultiplier += 0.5;
+        }
+        // Factor 3: Configuración de TypeScript estricta
+        if (compilerOptions?.strict || compilerOptions?.noImplicitAny) {
+            complexityMultiplier += 0.3;
+        }
+        // Factor 4: Extensión de archivo compleja (.d.ts, .vue.ts, etc.)
+        if (fileName.includes('.d.ts')) {
+            complexityMultiplier += 1; // Los archivos de definición son más complejos
+        }
+        else if (fileName.includes('.vue')) {
+            complexityMultiplier += 0.5; // Los archivos Vue requieren procesamiento adicional
+        }
+        // Aplicar límites razonables
+        complexityMultiplier = Math.min(complexityMultiplier, 5); // Máximo 5x el timeout base
+        complexityMultiplier = Math.max(complexityMultiplier, 0.5); // Mínimo 0.5x el timeout base
+        const finalTimeout = Math.round(baseTimeout * complexityMultiplier);
+        return Math.min(finalTimeout, 60000); // Máximo absoluto de 60 segundos
+    }
+    /**
+     * Fallback síncrono para type checking
+     * ✨ FIX: Ahora trackea las tareas correctamente
+     */
+    typeCheckWithSyncFallback(fileName, content, compilerOptions) {
+        try {
+            const result = validateTypesWithLanguageService(fileName, content, compilerOptions);
+            this.completedTasks++; // ✨ FIX: Contabilizar tareas completadas en fallback
+            return result;
+        }
+        catch {
+            this.failedTasks++; // ✨ FIX: Contabilizar tareas fallidas en fallback
+            return {
+                diagnostics: [],
+                hasErrors: false,
+            };
+        }
+    }
+    /**
+     * Cierra todos los workers del pool con cleanup completo
+     * ✨ FIX #1: Ahora limpia timers de monitoreo para evitar fugas de memoria
+     */
+    async terminate() {
+        console.log('[WorkerPool] Cerrando pool de workers...');
+        // 0. ✨ FIX #1: Detener monitoreo de memoria primero
+        this.stopMemoryMonitoring();
+        // 1. Rechazar todas las tareas pendientes con cleanup
+        let totalPendingTasks = 0;
+        for (const poolWorker of this.workers) {
+            totalPendingTasks += poolWorker.pendingTasks.size;
+            poolWorker.pendingTasks.forEach(task => {
+                clearTimeout(task.timeout);
+                task.reject(new Error('Worker pool cerrado'));
+            });
+            poolWorker.pendingTasks.clear();
+            // Limpiar listeners para evitar memory leaks
+            try {
+                poolWorker.worker.removeAllListeners();
+            }
+            catch {
+                // Error silencioso en cleanup
+            }
+        }
+        if (totalPendingTasks > 0) {
+            console.log(`[WorkerPool] Se cancelaron ${totalPendingTasks} tareas pendientes`);
+        }
+        // 2. Cerrar todos los workers con manejo de errores
+        const terminatePromises = this.workers.map(async (poolWorker) => {
+            try {
+                await poolWorker.worker.terminate();
+            }
+            catch (error) {
+                console.warn(`[WorkerPool] Error terminando worker ${poolWorker.id}:`, error);
+            }
+        });
+        await Promise.allSettled(terminatePromises);
+        // 3. Limpiar estado
+        this.workers = [];
+        this.isInitialized = false;
+        this.initPromise = null;
+        console.log(`[WorkerPool] Pool cerrado. Estadísticas finales: ${this.completedTasks} completadas, ${this.failedTasks} fallidas`);
+    }
+    /**
+     * Obtiene estadísticas del pool
+     */
+    getStats() {
+        const busyWorkers = this.workers.filter(w => w.busy).length;
+        const totalPendingTasks = this.workers.reduce((sum, w) => sum + w.pendingTasks.size, 0);
+        const successRate = this.totalTasks > 0
+            ? Math.round((this.completedTasks / this.totalTasks) * 100)
+            : 0;
+        return {
+            poolSize: this.workers.length,
+            busyWorkers,
+            totalPendingTasks,
+            totalTasks: this.totalTasks,
+            completedTasks: this.completedTasks,
+            failedTasks: this.failedTasks,
+            successRate,
+        };
+    }
+    // ✨ ISSUE #4: Métodos de categorización de errores de TypeScript
+    /**
+     * Categoriza y mejora los errores de TypeScript para mejor debugging
+     */
+    categorizeTypeScriptErrors(result, fileName) {
+        if (!result.hasErrors || !result.diagnostics?.length) {
+            return result;
+        }
+        const categorizedDiagnostics = result.diagnostics.map(diagnostic => {
+            // Añadir metadatos útiles para debugging
+            const enhanced = {
+                ...diagnostic,
+                _category: this.getErrorCategory(diagnostic),
+                _severity: this.getErrorSeverity(diagnostic),
+                _fileName: fileName,
+                _timestamp: Date.now(),
+            };
+            return enhanced;
+        });
+        return {
+            ...result,
+            diagnostics: categorizedDiagnostics,
+            // Añadir estadísticas de errores
+            _errorStats: this.calculateErrorStats(categorizedDiagnostics),
+        };
+    } /**
+     * Determina la categoría de un error de TypeScript
+     */
+    getErrorCategory(diagnostic) {
+        const code = diagnostic.code;
+        // Categorización basada en códigos de error comunes
+        if ([2304, 2339, 2346].includes(code)) {
+            return 'MISSING_DECLARATION'; // No puede encontrar nombre/propiedad
+        }
+        else if ([2322, 2322, 2345].includes(code)) {
+            return 'TYPE_MISMATCH'; // Error de tipos
+        }
+        else if ([2307, 2317].includes(code)) {
+            return 'MODULE_RESOLUTION'; // Error de resolución de módulos
+        }
+        else if ([2552, 2551].includes(code)) {
+            return 'PROPERTY_ACCESS'; // Error de acceso a propiedades
+        }
+        else if (code >= 1000 && code < 2000) {
+            return 'SYNTAX_ERROR'; // Errores de sintaxis
+        }
+        else if (code >= 2000 && code < 3000) {
+            return 'SEMANTIC_ERROR'; // Errores semánticos
+        }
+        else if (code >= 4000) {
+            return 'CONFIG_ERROR'; // Errores de configuración
+        }
+        return 'OTHER';
+    }
+    /**
+     * Determina la severidad de un error de TypeScript
+     */
+    getErrorSeverity(diagnostic) {
+        const category = diagnostic.category;
+        switch (category) {
+            case 1:
+                return 'ERROR'; // typescript.DiagnosticCategory.Error
+            case 2:
+                return 'WARNING'; // typescript.DiagnosticCategory.Warning
+            case 3:
+                return 'INFO'; // typescript.DiagnosticCategory.Message
+            default:
+                return 'ERROR';
+        }
+    }
+    /**
+     * Calcula estadísticas de errores para análisis
+     */
+    calculateErrorStats(diagnostics) {
+        const stats = {
+            totalErrors: diagnostics.length,
+            errorsByCategory: {},
+            errorsBySeverity: {},
+            mostCommonError: null,
+        };
+        // Contar por categoría y severidad
+        diagnostics.forEach(diag => {
+            const category = diag._category || 'OTHER';
+            const severity = diag._severity || 'ERROR';
+            stats.errorsByCategory[category] =
+                (stats.errorsByCategory[category] || 0) + 1;
+            stats.errorsBySeverity[severity] =
+                (stats.errorsBySeverity[severity] || 0) + 1;
+        }); // Encontrar el error más común
+        const errorCounts = {};
+        diagnostics.forEach(diag => {
+            const code = String(diag.code);
+            errorCounts[code] = (errorCounts[code] || 0) + 1;
+        });
+        const errorCountKeys = Object.keys(errorCounts);
+        if (errorCountKeys.length > 0) {
+            const mostCommonCode = errorCountKeys.reduce((a, b) => (errorCounts[a] || 0) > (errorCounts[b] || 0) ? a : b);
+            stats.mostCommonError = {
+                code: mostCommonCode,
+                count: errorCounts[mostCommonCode],
+                message: diagnostics.find(d => String(d.code) === mostCommonCode)?.messageText,
+            };
+        }
+        return stats;
+    }
+    /**
+     * Crea un error categorizado con información de contexto
+     */
+    createCategorizedError(errorMessage, fileName, response) {
+        const error = new Error(errorMessage);
+        // Añadir metadatos del error
+        error.fileName = fileName;
+        error.timestamp = Date.now();
+        error.workerResponse = response;
+        error.category = this.categorizeGenericError(errorMessage);
+        error.isRecoverable = this.isRecoverableError(errorMessage);
+        return error;
+    }
+    /**
+     * Categoriza errores genéricos del worker
+     */
+    categorizeGenericError(errorMessage) {
+        if (errorMessage.includes('timeout') ||
+            errorMessage.includes('Timeout')) {
+            return 'TIMEOUT';
+        }
+        else if (errorMessage.includes('memory') ||
+            errorMessage.includes('Memory')) {
+            return 'MEMORY';
+        }
+        else if (errorMessage.includes('Worker') &&
+            errorMessage.includes('exited')) {
+            return 'WORKER_CRASH';
+        }
+        else if (errorMessage.includes('initialization') ||
+            errorMessage.includes('init')) {
+            return 'INITIALIZATION';
+        }
+        return 'UNKNOWN';
+    }
+    /**
+     * Determina si un error es recuperable
+     */
+    isRecoverableError(errorMessage) {
+        const recoverablePatterns = [
+            'timeout',
+            'Worker being recycled',
+            'Worker pool cerrado',
+            'temporary',
+        ];
+        return recoverablePatterns.some(pattern => errorMessage.toLowerCase().includes(pattern.toLowerCase()));
+    }
+}
+//# sourceMappingURL=typescript-worker-pool.js.map