versacompiler 2.0.1 → 2.0.3

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

@@ -18,10 +18,10 @@ export class TypeScriptWorkerPool {
     workerPath;
     initPromise = null;
     isInitialized = false; // Configuración optimizada con reciclaje de workers
-    TASK_TIMEOUT = 10000; // 10 segundos por tarea
+    TASK_TIMEOUT = 15000; // 15 segundos por tarea (aumentado)
     WORKER_INIT_TIMEOUT = 5000; // 5 segundos para inicializar
-    MAX_TASKS_PER_WORKER = 50; // Máximo de tareas por worker antes de reciclaje
-    WORKER_MEMORY_CHECK_INTERVAL = 100; // Verificar cada 100 tareas
+    MAX_TASKS_PER_WORKER = 25; // Reducido para liberar memoria más frecuentemente
+    WORKER_MEMORY_CHECK_INTERVAL = 50; // Verificar cada 50 tareas (más frecuente)
     // Métricas de rendimiento
     totalTasks = 0;
     completedTasks = 0;
@@ -31,6 +31,128 @@ export class TypeScriptWorkerPool {
         const cpuCount = os.cpus().length;
         this.poolSize = Math.min(Math.max(cpuCount - 1, 2), 8); // Entre 2 y 8 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
+     */
+    startMemoryMonitoring() {
+        // Monitoreo cada 15 segundos (más frecuente)
+        setInterval(() => {
+            this.checkWorkersMemory();
+        }, 15000);
+        // Limpieza de workers inactivos cada 2 minutos (más frecuente)
+        setInterval(() => {
+            this.cleanupInactiveWorkers();
+        }, 120000);
+    }
+    /**
+     * 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
+     */
+    getRecycleReason(poolWorker) {
+        const now = Date.now();
+        const MEMORY_LIMIT = 50 * 1024 * 1024; // 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
+     */
+    shouldRecycleWorker(poolWorker) {
+        const now = Date.now();
+        const MEMORY_LIMIT = 30 * 1024 * 1024; // 30MB (reducido)
+        const TIME_LIMIT = 15 * 60 * 1000; // 15 minutos (reducido)
+        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
@@ -40,7 +162,8 @@ export class TypeScriptWorkerPool {
             TypeScriptWorkerPool.instance = new TypeScriptWorkerPool();
         }
         return TypeScriptWorkerPool.instance;
-    } /**
+    }
+    /**
      * Configura el modo de operación del pool
      */
     setMode(mode) {
@@ -72,7 +195,8 @@ export class TypeScriptWorkerPool {
     }
     /**
      * Realiza la inicialización del pool de workers
-     */ async _performPoolInitialization() {
+     */
+    async _performPoolInitialization() {
         try {
             // Verificar que el archivo del worker existe
             const fs = await import('node:fs');
@@ -92,7 +216,8 @@ export class TypeScriptWorkerPool {
     }
     /**
      * Crea un worker individual
-     */ async createWorker(workerId) {
+     */
+    async createWorker(workerId) {
         return new Promise((resolve, reject) => {
             try {
                 const worker = new Worker(this.workerPath, {
@@ -108,6 +233,12 @@ export class TypeScriptWorkerPool {
                     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);
@@ -141,7 +272,8 @@ export class TypeScriptWorkerPool {
     }
     /**
      * Configura los listeners para un worker individual
-     */ setupWorkerListeners(poolWorker) {
+     */
+    setupWorkerListeners(poolWorker) {
         const { worker } = poolWorker;
         worker.on('message', (response) => {
             try {
@@ -149,7 +281,12 @@ export class TypeScriptWorkerPool {
                 if (response.id === 'worker-ready' ||
                     response.message === 'pong') {
                     return;
-                } // Buscar la tarea pendiente
+                }
+                // ✨ 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;
@@ -161,20 +298,26 @@ export class TypeScriptWorkerPool {
                 if (poolWorker.pendingTasks.size === 0) {
                     poolWorker.busy = false;
                 }
-                // Procesar respuesta
+                // 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++;
-                    pendingTask.resolve({
+                    // Analizar y categorizar errores de TypeScript
+                    const categorizedResult = this.categorizeTypeScriptErrors({
                         diagnostics: response.diagnostics,
                         hasErrors: response.hasErrors,
-                    });
+                    }, pendingTask.fileName);
+                    pendingTask.resolve(categorizedResult);
                 }
                 else {
                     this.failedTasks++;
                     const errorMessage = response.error || 'Error desconocido del worker';
-                    pendingTask.reject(new Error(errorMessage));
+                    // ✨ Crear error categorizado
+                    const categorizedError = this.createCategorizedError(errorMessage, pendingTask.fileName, response);
+                    pendingTask.reject(categorizedError);
                 }
             }
             catch {
@@ -190,7 +333,8 @@ export class TypeScriptWorkerPool {
     }
     /**
      * Maneja errores de un worker específico con cleanup completo
-     */ async handleWorkerError(poolWorker, error) {
+     */
+    async handleWorkerError(poolWorker, error) {
         console.warn(`[WorkerPool] Manejando error del worker ${poolWorker.id}:`, error.message);
         // 1. Rechazar todas las tareas pendientes con cleanup de timeouts
         poolWorker.pendingTasks.forEach(task => {
@@ -222,7 +366,8 @@ export class TypeScriptWorkerPool {
                 console.error(`[WorkerPool] No se pudo recrear worker ${poolWorker.id}:`, recreateError);
             }
         }
-    } /**
+    }
+    /**
      * Maneja la salida inesperada de un worker con cleanup completo
      */
     async handleWorkerExit(poolWorker, code) {
@@ -254,7 +399,8 @@ export class TypeScriptWorkerPool {
     }
     /**
      * Recrea un worker que falló
-     */ async recreateWorker(failedWorker) {
+     */
+    async recreateWorker(failedWorker) {
         try {
             const newWorker = await this.createWorker(failedWorker.id);
             // Reemplazar en el array
@@ -272,7 +418,8 @@ export class TypeScriptWorkerPool {
      */
     async recycleWorker(poolWorker) {
         try {
-            console.log(`[WorkerPool] Reciclando worker ${poolWorker.id} después de ${poolWorker.taskCounter} tareas`); // 1. Esperar a que termine tareas pendientes (timeout corto)
+            console.log(`[WorkerPool] Reciclando worker ${poolWorker.id} después de ${poolWorker.taskCounter} tareas`);
+            // 1. Esperar a que termine tareas pendientes (timeout corto)
             const maxWait = 2000; // 2 segundos máximo
             const startTime = Date.now();
             await new Promise(resolve => {
@@ -353,7 +500,8 @@ export class TypeScriptWorkerPool {
         catch {
             return this.typeCheckWithSyncFallback(fileName, content, compilerOptions);
         }
-    } /**
+    }
+    /**
      * Realiza type checking usando un worker específico con reciclaje automático
      */
     async typeCheckWithWorker(poolWorker, fileName, content, compilerOptions) {
@@ -363,16 +511,20 @@ export class TypeScriptWorkerPool {
         }
         return new Promise((resolve, reject) => {
             const taskId = `task-${poolWorker.id}-${++poolWorker.taskCounter}-${Date.now()}`;
-            // Marcar worker como ocupado
+            // 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);
             // Configurar timeout para la tarea
             const timeout = setTimeout(() => {
                 poolWorker.pendingTasks.delete(taskId);
                 if (poolWorker.pendingTasks.size === 0) {
                     poolWorker.busy = false;
                 }
-                reject(new Error(`Timeout en type checking para ${fileName}`));
-            }, this.TASK_TIMEOUT);
+                reject(new Error(`Timeout (${dynamicTimeout}ms) en type checking para ${fileName} - archivo complejo detectado`));
+            }, dynamicTimeout);
             // Agregar tarea a la lista de pendientes del worker
             poolWorker.pendingTasks.set(taskId, {
                 resolve,
@@ -382,12 +534,16 @@ export class TypeScriptWorkerPool {
                 startTime: Date.now(),
             });
             try {
-                // Crear mensaje para el worker
+                // Crear mensaje para el worker con configuración de timeout
                 const message = {
                     id: taskId,
                     fileName,
                     content,
-                    compilerOptions,
+                    compilerOptions: {
+                        ...compilerOptions,
+                        // ✨ Añadir timeout al worker para manejo interno
+                        _workerTimeout: dynamicTimeout - 1000, // 1 segundo menos para cleanup interno
+                    },
                 };
                 // Enviar mensaje al worker
                 poolWorker.worker.postMessage(message);
@@ -403,6 +559,59 @@ export class TypeScriptWorkerPool {
             }
         });
     }
+    /**
+     * 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
      */
@@ -419,7 +628,8 @@ export class TypeScriptWorkerPool {
     }
     /**
      * Cierra todos los workers del pool con cleanup completo
-     */ async terminate() {
+     */
+    async terminate() {
         console.log('[WorkerPool] Cerrando pool de workers...');
         // 1. Rechazar todas las tareas pendientes con cleanup
         let totalPendingTasks = 0;
@@ -440,7 +650,8 @@ export class TypeScriptWorkerPool {
         }
         if (totalPendingTasks > 0) {
             console.log(`[WorkerPool] Se cancelaron ${totalPendingTasks} tareas pendientes`);
-        } // 2. Cerrar todos los workers con manejo de errores
+        }
+        // 2. Cerrar todos los workers con manejo de errores
         const terminatePromises = this.workers.map(async (poolWorker) => {
             try {
                 await poolWorker.worker.terminate();
@@ -475,5 +686,157 @@ export class TypeScriptWorkerPool {
             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

package/dist/compiler/typescript-worker-thread.cjs

@@ -158,9 +158,8 @@ class WorkerTypeScriptLanguageServiceHost {
  */
 function validateTypesInWorker(fileName, content, compilerOptions) {
     let actualFileName = fileName;
-
     try {
-        let scriptContent = content;
+        const scriptContent = content;
 
         // Si el script está vacío o es solo espacios en blanco, no validar
         if (!scriptContent.trim()) {

package/dist/hrm/getInstanciaVue.js

@@ -56,7 +56,7 @@ function getVueInstanceFromElement(selector = '#app') {
 function findVueInstanceInDOM() {
     const allElements = document.querySelectorAll('*');
 
-    for (let element of allElements) {
+    for (const element of allElements) {
         // Vue 3
         if (element.__vue_app__) {
             return element.__vue_app__;

package/dist/hrm/initHRM.js

@@ -10,7 +10,7 @@
  */
 
 import { hideErrorOverlay, showErrorOverlay } from './errorScreen.js';
-import obtenerInstanciaVue from './getInstanciaVue.js';
+import { obtenerInstanciaVue } from './getInstanciaVue.js';
 import { reloadComponent } from './VueHRM.js';
 
 /**