versacompiler 2.4.1 → 2.6.0

package/dist/servicios/file-watcher.js

@@ -1,12 +1,24 @@
-import { readdir, rm, stat, unlink } from 'node:fs/promises';
+/* VersaCompiler HMR shim [dev] */
+if (typeof window !== 'undefined' && window.__versaHMR) {
+  (() => {
+    const _id = new URL(import.meta.url).pathname;
+    import.meta.hot = {
+      accept(cb) { window.__versaHMR.accept(_id, typeof cb === 'function' ? cb : () => {}); },
+      invalidate() { window.__versaHMR._invalidate?.(_id); },
+      dispose(cb) { window.__versaHMR._onDispose?.(_id, cb); },
+      get data() { return window.__versaHMR._getHotData?.(_id) ?? {}; },
+    };
+  })();
+}
+import { readdir, readFile, rm, stat, unlink } from 'node:fs/promises';
 import * as path from 'node:path';
 import * as process from 'node:process';
 const { env } = process;
 import * as chokidar from 'chokidar';
 import { minimatch } from 'minimatch';
-import { clearCompilationState, getOutputPath, initCompile, normalizeRuta } from '../compiler/compile.js';
+import { clearCompilationState, getOutputPath, getPipelineModuleGraph, initCompile, normalizeRuta, runPipelineHotUpdate, } from '../compiler/compile.js';
 import { promptUser } from '../utils/promptUser.js';
-import { emitirCambios } from './browserSync.js';
+import { emitirCambios, registerHMRUpdate } from './browserSync.js';
 import { logger } from './logger.js';
 // Lazy loading para chalk
 let chalk;
@@ -16,6 +28,49 @@ async function loadChalk() {
     }
     return chalk;
 }
+/**
+ * Analiza el contenido de un módulo JS compilado para determinar si es seguro
+ * hacer HMR sin full-reload. Un módulo es "simple" si:
+ * - Solo exporta funciones, constantes o valores (no clases con estado ni patrones singleton)
+ * - No usa new/class en el scope raíz (como estado global mutable)
+ *
+ * @param outputPath - Ruta del archivo compilado a analizar
+ * @returns 'propagate' si es seguro sin full-reload, 'full-reload' si no se puede determinar
+ */
+async function analyzeCompiledModuleStrategy(outputPath) {
+    try {
+        const content = await readFile(outputPath, 'utf8');
+        // Si el módulo fue compilado por VersaCompiler en modo dev, el shim HMR
+        // está inyectado y gestiona la estrategia de reemplazo vía versaHMR.
+        // No analizar el shim como side-effect — siempre es propagate.
+        if (content.startsWith('/* VersaCompiler HMR shim [dev] */')) {
+            return 'propagate';
+        }
+        // Si el módulo declara que acepta HMR, propagate es seguro
+        if (/import\.meta\.hot\.accept/.test(content)) {
+            return 'propagate';
+        }
+        // Heurística: módulos con solo exports de funciones/constantes son seguros
+        const hasExports = /export\s+(const|let|function|async function|class\b)/.test(content) || /export\s+default/.test(content);
+        if (!hasExports) {
+            return 'full-reload';
+        }
+        // Señales de estado global mutable o efectos secundarios al import:
+        // new ClassName() en scope raíz, módulos con side-effects de init
+        const hasRootLevelSideEffects = 
+        // new en scope raíz (fuera de funciones/clases) — detectar heurísticamente
+        /^\s*(?:const|let|var)\s+\w+\s*=\s*new\s+\w+/m.test(content) ||
+            // Llamadas a funciones en scope raíz que sugieren init
+            /^\s*(?:init|setup|bootstrap|start|connect|register)\s*\(/m.test(content);
+        if (hasRootLevelSideEffects) {
+            return 'full-reload';
+        }
+        return 'propagate';
+    }
+    catch {
+        return 'full-reload';
+    }
+}
 class WatchDebouncer {
     pendingChanges = new Map();
     debounceTimer = null;
@@ -147,13 +202,44 @@ class WatchDebouncer {
      */
     async processCompilableFiles(compilableFiles) {
         const chalkInstance = await loadChalk();
+        const graph = getPipelineModuleGraph();
         // Procesar en batches para evitar sobrecarga
         for (let i = 0; i < compilableFiles.length; i += this.BATCH_SIZE) {
             const batch = compilableFiles.slice(i, i + this.BATCH_SIZE);
             if (batch.length > 1) {
                 logger.info(chalkInstance.cyan(`📦 Procesando batch de ${batch.length} archivos compilables (${i + 1}-${Math.min(i + this.BATCH_SIZE, compilableFiles.length)} de ${compilableFiles.length})`));
             }
-            const promises = batch.map(change => this.compileFile(change));
+            const expandedChanges = new Map();
+            for (const change of batch) {
+                expandedChanges.set(change.filePath, change);
+                if (graph) {
+                    const invalidated = graph.invalidate(change.filePath);
+                    for (const invalidatedPath of invalidated) {
+                        if (expandedChanges.has(invalidatedPath))
+                            continue;
+                        // Usar la acción correcta según la extensión del archivo invalidado
+                        // en lugar de forzar 'reloadFull' para todos los importers
+                        const invalidatedExt = path
+                            .extname(invalidatedPath)
+                            .replace('.', '');
+                        const invalidatedAction = {
+                            vue: 'HRMVue',
+                            ts: 'HRMHelper',
+                            js: 'HRMHelper',
+                            mjs: 'HRMHelper',
+                            cjs: 'HRMHelper',
+                        }[invalidatedExt] ?? 'reloadFull';
+                        expandedChanges.set(invalidatedPath, {
+                            filePath: invalidatedPath,
+                            action: 'change',
+                            timestamp: Date.now(),
+                            extensionAction: invalidatedAction,
+                            isAdditionalFile: false,
+                        });
+                    }
+                }
+            }
+            const promises = Array.from(expandedChanges.values()).map(change => this.compileFile(change));
             await Promise.allSettled(promises);
         }
         if (compilableFiles.length > 1) {
@@ -177,12 +263,59 @@ class WatchDebouncer {
      */
     async compileFile(change) {
         try {
+            let pluginHmrReload = 'none';
+            if (change.action !== 'unlink') {
+                const hotUpdate = await runPipelineHotUpdate(change.filePath, change.action);
+                pluginHmrReload = hotUpdate.reload || 'none';
+            }
             const result = await initCompile(change.filePath, true, 'watch');
             if (result.success) {
+                // Registrar el output para que el middleware HMR reescriba imports dependientes
+                if (result.output) {
+                    registerHMRUpdate(result.output);
+                }
                 let accion = result.action || change.extensionAction;
                 accion =
                     accion === 'extension' ? change.extensionAction : accion;
-                emitirCambios(this.browserSyncInstance, accion || 'reloadFull', result.output);
+                let payload = {};
+                if (accion === 'HRMHelper') {
+                    if (pluginHmrReload === 'full') {
+                        accion = 'reloadFull';
+                    }
+                    else {
+                        const graph = getPipelineModuleGraph();
+                        const node = graph?.getNode(change.filePath);
+                        const importers = node
+                            ? Array.from(node.importers)
+                            : [];
+                        // Determinar estrategia base:
+                        // Si el plugin dice 'module' → propagate garantizado
+                        // Si hay importers conocidos → propagate (los consumers actualizarán sus refs)
+                        // Si no hay importers → analizar el módulo compilado para detectar si es "simple"
+                        let strategy;
+                        if (pluginHmrReload === 'module') {
+                            strategy = 'propagate';
+                        }
+                        else if (importers.length > 0) {
+                            strategy = 'propagate';
+                        }
+                        else {
+                            // Sin importers conocidos: analizar el output compilado
+                            strategy = await analyzeCompiledModuleStrategy(result.output);
+                        }
+                        // moduleId: path del output relativo al proyecto para que el cliente
+                        // pueda hacer lookup en VersaModuleRegistry
+                        const moduleId = result.output.startsWith('/')
+                            ? result.output
+                            : `/${result.output}`;
+                        payload = {
+                            moduleId,
+                            importers,
+                            strategy,
+                        };
+                    }
+                }
+                emitirCambios(this.browserSyncInstance, accion || 'reloadFull', result.output, payload);
             }
         }
         catch (error) {
@@ -355,9 +488,7 @@ export async function initChokidar(bs) {
         // ✨ OPTIMIZACIÓN: Pre-cargar módulos críticos al iniciar el watcher
         watcher.on('ready', async () => {
             const chalkInstance = await loadChalk();
-            logger.info(chalkInstance.green(`👀 : Listo para observar \n${fileWatch
-                .map((item) => `${item}`)
-                .join('\n')}\n`));
+            logger.info(chalkInstance.green(`👀 : Listo para observar \n${fileWatch.map((item) => `${item}`).join('\n')}\n`));
             // Pre-cargar módulos críticos para primera compilación más rápida
             setImmediate(async () => {
                 try {

package/dist/servicios/logger.js

@@ -1,3 +1,15 @@
+/* VersaCompiler HMR shim [dev] */
+if (typeof window !== 'undefined' && window.__versaHMR) {
+  (() => {
+    const _id = new URL(import.meta.url).pathname;
+    import.meta.hot = {
+      accept(cb) { window.__versaHMR.accept(_id, typeof cb === 'function' ? cb : () => {}); },
+      invalidate() { window.__versaHMR._invalidate?.(_id); },
+      dispose(cb) { window.__versaHMR._onDispose?.(_id, cb); },
+      get data() { return window.__versaHMR._getHotData?.(_id) ?? {}; },
+    };
+  })();
+}
 import * as process from 'node:process';
 // Función para obtener ProgressManager (lazy import para evitar dependencias circulares)
 let getProgressManager = null;

package/dist/servicios/readConfig.js

@@ -1,3 +1,15 @@
+/* VersaCompiler HMR shim [dev] */
+if (typeof window !== 'undefined' && window.__versaHMR) {
+  (() => {
+    const _id = new URL(import.meta.url).pathname;
+    import.meta.hot = {
+      accept(cb) { window.__versaHMR.accept(_id, typeof cb === 'function' ? cb : () => {}); },
+      invalidate() { window.__versaHMR._invalidate?.(_id); },
+      dispose(cb) { window.__versaHMR._onDispose?.(_id, cb); },
+      get data() { return window.__versaHMR._getHotData?.(_id) ?? {}; },
+    };
+  })();
+}
 import { normalize, relative, resolve } from 'node:path';
 import * as process from 'node:process';
 import { env } from 'node:process';
@@ -25,7 +37,7 @@ export function validatePath(pathStr) {
         return false;
     }
     // Rechazar rutas absolutas de Windows (válido en cualquier plataforma)
-    if (/^[A-Za-z]:[\\\/]/.test(pathStr)) {
+    if (/^[A-Za-z]:[/\\]/.test(pathStr)) {
         logger.error(`Ruta absoluta de Windows no permitida: ${pathStr}`);
         return false;
     }
@@ -238,6 +250,80 @@ function safeJsonStringify(obj, fallback = 'false') {
         return fallback;
     }
 }
+function normalizeAliasKey(key) {
+    if (key.includes('*'))
+        return key;
+    if (key.endsWith('/'))
+        return `${key}*`;
+    return `${key}/*`;
+}
+function normalizeAliasValue(value) {
+    if (value.includes('*'))
+        return value;
+    if (value.endsWith('/'))
+        return `${value}*`;
+    return `${value}/*`;
+}
+function normalizeAlias(alias) {
+    if (!alias)
+        return {};
+    const result = {};
+    if (Array.isArray(alias)) {
+        for (const entry of alias) {
+            if (!entry || typeof entry.find !== 'string')
+                continue;
+            if (typeof entry.replacement !== 'string')
+                continue;
+            const key = normalizeAliasKey(entry.find);
+            const value = normalizeAliasValue(entry.replacement);
+            result[key] = [value];
+        }
+        return result;
+    }
+    for (const [key, value] of Object.entries(alias)) {
+        const normalizedKey = normalizeAliasKey(key);
+        if (Array.isArray(value)) {
+            result[normalizedKey] = value
+                .filter(v => typeof v === 'string')
+                .map(v => normalizeAliasValue(v));
+        }
+        else if (typeof value === 'string') {
+            result[normalizedKey] = [normalizeAliasValue(value)];
+        }
+    }
+    return result;
+}
+function normalizeConfig(input) {
+    if (input?.compilerOptions) {
+        return input;
+    }
+    const viteConfig = input;
+    const aliases = normalizeAlias(viteConfig?.resolve?.alias);
+    return {
+        tsconfig: viteConfig?.tsconfig,
+        compilerOptions: {
+            sourceRoot: viteConfig?.root || './src',
+            outDir: viteConfig?.build?.outDir || './dist',
+            pathsAlias: aliases,
+        },
+        plugins: viteConfig?.plugins,
+        proxyConfig: {
+            proxyUrl: viteConfig?.server?.proxyUrl || '',
+            assetsOmit: viteConfig?.server?.assetsOmit ?? false,
+        },
+        aditionalWatch: viteConfig?.watch?.additional ||
+            viteConfig?.server?.watch?.additional ||
+            [],
+        tailwindConfig: viteConfig?.tailwindConfig,
+        linter: viteConfig?.linter,
+        bundlers: viteConfig?.build?.bundlers,
+        typeCheckOptions: viteConfig?.typeCheckOptions,
+    };
+}
+let loadedConfig = null;
+export function getLoadedConfig() {
+    return loadedConfig;
+}
 /**
  * Wrapper para el import dinámico que permite mejor testing
  */
@@ -272,7 +358,8 @@ export async function readConfig() {
         if (!data) {
             throw new Error('No se pudo leer el archivo de configuración.');
         }
-        const tsConfig = data.default || data;
+        const rawConfig = data.default || data;
+        const tsConfig = normalizeConfig(rawConfig);
         // Validar tamaño de configuración
         if (!validateConfigSize(tsConfig)) {
             throw new Error('Configuración demasiado grande o contiene referencias circulares.');
@@ -323,6 +410,7 @@ export async function readConfig() {
         if (!tsConfig.compilerOptions.sourceRoot) {
             env.tsConfig = safeJsonStringify(tsConfig, '{}');
         }
+        loadedConfig = tsConfig;
         logger.info('✅ Configuration loaded and validated successfully');
         return true;
     }
@@ -347,58 +435,57 @@ export async function initConfig() {
             logger.warn(`🚩 El archivo de configuración '${env.PATH_CONFIG_FILE}' ya existe.`);
             return true;
         }
-        const configContent = `// Archivo de configuración de VersaCompiler
-export default {
-    tsconfig: './tsconfig.json',
-    compilerOptions: {
-        sourceRoot: './src',
-        outDir: './dist',
-        pathsAlias: {
-            '/dist/examples/*': ['src/*'],
-            '/dist/public/*': ['public/*'],
-        },
-    },
-    proxyConfig: {
-        proxyUrl: '',
-        assetsOmit: true,
-    },
-    aditionalWatch: ['./app/templates/**/*.twig', './app/templates/**/*.html'],
-    // puede dejar en false o no agregarlo si no quiere que se ejecute el compilador de tailwind
-    tailwindConfig: {
-        bin: './node_modules/.bin/tailwindcss',
-        input: './src/css/input.css',
-        output: './public/css/output.css',
-    },
-    linter: [
-        {
-            name: 'eslint',
-            bin: './node_modules/.bin/eslint',
-            configFile: './.eslintrc.json',
-            fix: false,
-            paths: ['src/']
-        },
-        {
-            name: 'oxlint',
-            bin: './node_modules/.bin/oxlint',
-            configFile: './.oxlintrc.json',
-            fix: false,
-            paths: ['src/']
-        },
-    ],
-    // Configuración de bundlers
-    bundlers: [
-        {
-            name: 'appLoader',
-            fileInput: './public/module/appLoader.js',
-            fileOutput: './public/module/appLoader.prod.js',
-        },
-        {
-            name: 'mainApp',
-            fileInput: './src/main.ts',
-            fileOutput: './dist/main.bundle.js',
-        }
-    ],
-};
+        const configContent = `import { defineConfig } from 'versacompiler/config';
+
+export default defineConfig({
+    root: './src',
+    build: {
+        outDir: './dist',
+        bundlers: [
+            {
+                name: 'appLoader',
+                fileInput: './public/module/appLoader.js',
+                fileOutput: './public/module/appLoader.prod.js',
+            },
+        ],
+    },
+    resolve: {
+        alias: {
+            '/dist/public': 'src',
+            '/dist/public': 'public',
+        },
+    },
+    server: {
+        proxyUrl: '',
+        assetsOmit: true,
+        watch: {
+            additional: ['./app/templates/**/*.twig', './app/templates/**/*.html'],
+        },
+    },
+    tsconfig: './tsconfig.json',
+    tailwindConfig: {
+        bin: './node_modules/.bin/tailwindcss',
+        input: './src/css/input.css',
+        output: './public/css/output.css',
+    },
+    linter: [
+        {
+            name: 'eslint',
+            bin: './node_modules/.bin/eslint',
+            configFile: './.eslintrc.json',
+            fix: false,
+            paths: ['src/'],
+        },
+        {
+            name: 'oxlint',
+            bin: './node_modules/.bin/oxlint',
+            configFile: './.oxlintrc.json',
+            fix: false,
+            paths: ['src/'],
+        },
+    ],
+    plugins: [],
+});
 `;
         fs.writeFileSync(configPath, configContent, 'utf8');
         logger.info(`🚩 Archivo de configuración '${env.PATH_CONFIG_FILE}' creado correctamente.`);

package/dist/servicios/versacompile.config.types.js

@@ -0,0 +1,14 @@
+/* VersaCompiler HMR shim [dev] */
+if (typeof window !== 'undefined' && window.__versaHMR) {
+  (() => {
+    const _id = new URL(import.meta.url).pathname;
+    import.meta.hot = {
+      accept(cb) { window.__versaHMR.accept(_id, typeof cb === 'function' ? cb : () => {}); },
+      invalidate() { window.__versaHMR._invalidate?.(_id); },
+      dispose(cb) { window.__versaHMR._onDispose?.(_id, cb); },
+      get data() { return window.__versaHMR._getHotData?.(_id) ?? {}; },
+    };
+  })();
+}
+export const defineConfig = (config) => config;
+//# sourceMappingURL=versacompile.config.types.js.map

package/dist/utils/excluded-modules.js

@@ -1,3 +1,15 @@
+/* VersaCompiler HMR shim [dev] */
+if (typeof window !== 'undefined' && window.__versaHMR) {
+  (() => {
+    const _id = new URL(import.meta.url).pathname;
+    import.meta.hot = {
+      accept(cb) { window.__versaHMR.accept(_id, typeof cb === 'function' ? cb : () => {}); },
+      invalidate() { window.__versaHMR._invalidate?.(_id); },
+      dispose(cb) { window.__versaHMR._onDispose?.(_id, cb); },
+      get data() { return window.__versaHMR._getHotData?.(_id) ?? {}; },
+    };
+  })();
+}
 /**
  * Lista centralizada de módulos excluidos de la resolución automática
  * Estos módulos se mantienen con su importación original sin transformar

package/dist/utils/module-resolver.js

@@ -1,9 +1,21 @@
-// Opción con librería '/node_modules/resolve/index.js' (npm install resolve)
+/* VersaCompiler HMR shim [dev] */
+if (typeof window !== 'undefined' && window.__versaHMR) {
+  (() => {
+    const _id = new URL(import.meta.url).pathname;
+    import.meta.hot = {
+      accept(cb) { window.__versaHMR.accept(_id, typeof cb === 'function' ? cb : () => {}); },
+      invalidate() { window.__versaHMR._invalidate?.(_id); },
+      dispose(cb) { window.__versaHMR._onDispose?.(_id, cb); },
+      get data() { return window.__versaHMR._getHotData?.(_id) ?? {}; },
+    };
+  })();
+}
+// Opción con librería 'resolve' (npm install resolve)
 import fs, { readFileSync } from 'node:fs';
 import { dirname, join, relative } from 'node:path';
 import { cwd, env } from 'node:process';
-// import pkg from '/node_modules/enhanced-resolve/lib/index.js';
-// import resolve from '/node_modules/resolve/index.js';
+// import pkg from 'enhanced-resolve';
+// import resolve from 'resolve';
 import { logger } from '../servicios/logger.js';
 import { EXCLUDED_MODULES } from './excluded-modules.js';
 class PackageJsonCache {
@@ -72,7 +84,7 @@ const packageJsonCache = PackageJsonCache.getInstance();
 //         return null;
 //     }
 // }
-// Opción con '/node_modules/enhanced-resolve/lib/index.js' (webpack's resolver)
+// Opción con 'enhanced-resolve' (webpack's resolver)
 // npm install enhanced-resolve
 // const { ResolverFactory } = pkg;
 // const resolver = ResolverFactory.createResolver({
@@ -350,26 +362,7 @@ function simpleESMResolver(moduleName) {
                     entryPoint = dotExport;
                 }
                 else if (typeof dotExport === 'object') {
-                    // Priorizar import > browser > default para compatibilidad ESM
-                    // Buscar específicamente patrones esm-browser primero
-                    const exportKeys = Object.keys(dotExport);
-                    const esmBrowserKey = exportKeys.find(key => key.includes('browser') &&
-                        (key.includes('esm') || key.includes('module')));
-                    if (esmBrowserKey &&
-                        typeof dotExport[esmBrowserKey] === 'string') {
-                        entryPoint = dotExport[esmBrowserKey];
-                    }
-                    else {
-                        // Priorizar import > browser > default
-                        entryPoint =
-                            (typeof dotExport.import === 'string'
-                                ? dotExport.import
-                                : null) ||
-                                dotExport.browser ||
-                                (typeof dotExport.default === 'string'
-                                    ? dotExport.default
-                                    : null);
-                    }
+                    entryPoint = resolveExportValue(dotExport);
                 }
             }
         }
@@ -489,6 +482,64 @@ function getNodeModulesRelativePath(fullPath, _fromFile) {
     }
     return rel;
 }
+/**
+ * Parses a module specifier into packageName and subPath.
+ * Handles scoped packages correctly.
+ * Examples:
+ *   '@vueuse/core'      → { packageName: '@vueuse/core', subPath: '' }
+ *   '@vueuse/core/sub'  → { packageName: '@vueuse/core', subPath: 'sub' }
+ *   'vue/dist/x'        → { packageName: 'vue', subPath: 'dist/x' }
+ *   'vue'               → { packageName: 'vue', subPath: '' }
+ */
+export function parseModuleSpecifier(moduleName) {
+    if (moduleName.startsWith('@')) {
+        const parts = moduleName.split('/');
+        if (parts.length < 2 || !parts[1]) {
+            return { packageName: moduleName, subPath: '' };
+        }
+        const packageName = `${parts[0]}/${parts[1]}`;
+        const subPath = parts.slice(2).join('/');
+        return { packageName, subPath };
+    }
+    else {
+        const slashIdx = moduleName.indexOf('/');
+        if (slashIdx === -1) {
+            return { packageName: moduleName, subPath: '' };
+        }
+        return {
+            packageName: moduleName.slice(0, slashIdx),
+            subPath: moduleName.slice(slashIdx + 1),
+        };
+    }
+}
+/**
+ * Recursively resolves a conditional export value.
+ * Priority: import > browser > module > default
+ * Handles nested objects up to a depth limit.
+ */
+export function resolveExportValue(exportVal, depth = 0) {
+    if (depth > 5)
+        return null;
+    if (typeof exportVal === 'string')
+        return exportVal;
+    if (typeof exportVal === 'object' && exportVal !== null) {
+        const obj = exportVal;
+        for (const key of [
+            'import',
+            'browser',
+            'module',
+            'default',
+            'require',
+        ]) {
+            if (obj[key] !== undefined) {
+                const resolved = resolveExportValue(obj[key], depth + 1);
+                if (resolved)
+                    return resolved;
+            }
+        }
+    }
+    return null;
+}
 export function getModulePath(moduleName, fromFile) {
     // Verificar si el módulo está en la lista de excluidos
     if (EXCLUDED_MODULES.has(moduleName)) {
@@ -501,14 +552,15 @@ export function getModuleSubPath(moduleName, fromFile) {
     // Verificar si el módulo está en la lista de excluidos
     if (EXCLUDED_MODULES.has(moduleName)) {
         return null; // Retornar null para mantener la importación original
-    } // Si contiene '/', es un subpath
+    }
+    // Usar parseModuleSpecifier para manejar correctamente paquetes con scope
+    const { packageName, subPath } = parseModuleSpecifier(moduleName);
+    // Si no hay subPath, delegar al resolver normal
+    if (!subPath) {
+        return getModulePath(moduleName, fromFile);
+    }
+    // Es un subpath: resolver con el packageName correcto
     if (moduleName.includes('/')) {
-        const [packageName, ...subPathParts] = moduleName.split('/');
-        const subPath = subPathParts.join('/');
-        // Verificar que packageName no esté vacío
-        if (!packageName) {
-            return null;
-        }
         try {
             const nodeModulesPath = join(cwd(), 'node_modules', packageName);
             const packagePath = join(nodeModulesPath, 'package.json');
@@ -525,15 +577,9 @@ export function getModuleSubPath(moduleName, fromFile) {
                 const exportKey = `./${subPath}`;
                 const exportPath = packageJson.exports[exportKey];
                 if (exportPath) {
-                    if (typeof exportPath === 'string') {
-                        return getNodeModulesRelativePath(join(moduleDir, exportPath), fromFile);
-                    }
-                    else if (typeof exportPath === 'object') {
-                        // Priorizar import > default para ESM
-                        const importPath = exportPath.import || exportPath.default;
-                        if (typeof importPath === 'string') {
-                            return getNodeModulesRelativePath(join(moduleDir, importPath), fromFile);
-                        }
+                    const resolved = resolveExportValue(exportPath);
+                    if (resolved) {
+                        return getNodeModulesRelativePath(join(moduleDir, resolved), fromFile);
                     }
                 }
             }

package/dist/utils/promptUser.js

@@ -1,3 +1,15 @@
+/* VersaCompiler HMR shim [dev] */
+if (typeof window !== 'undefined' && window.__versaHMR) {
+  (() => {
+    const _id = new URL(import.meta.url).pathname;
+    import.meta.hot = {
+      accept(cb) { window.__versaHMR.accept(_id, typeof cb === 'function' ? cb : () => {}); },
+      invalidate() { window.__versaHMR._invalidate?.(_id); },
+      dispose(cb) { window.__versaHMR._onDispose?.(_id, cb); },
+      get data() { return window.__versaHMR._getHotData?.(_id) ?? {}; },
+    };
+  })();
+}
 import process, { stdin as input, stdout as output } from 'node:process';
 import * as readline from 'node:readline/promises';
 import { logger } from '../servicios/logger.js';