versacompiler 2.4.1 → 2.6.0

package/dist/compiler/pipeline/module-graph.js

@@ -0,0 +1,75 @@
+/* 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 class ModuleGraph {
+    nodes = new Map();
+    getNode(id) {
+        return this.nodes.get(id);
+    }
+    ensureNode(id) {
+        const existing = this.nodes.get(id);
+        if (existing)
+            return existing;
+        const node = {
+            id,
+            importers: new Set(),
+            imports: new Set(),
+            lastUpdated: Date.now(),
+        };
+        this.nodes.set(id, node);
+        return node;
+    }
+    updateImports(id, imports) {
+        const node = this.ensureNode(id);
+        node.imports.clear();
+        for (const dep of imports) {
+            node.imports.add(dep);
+            const depNode = this.ensureNode(dep);
+            depNode.importers.add(id);
+        }
+        node.lastUpdated = Date.now();
+    }
+    invalidate(id) {
+        const invalidated = new Set();
+        const queue = [id];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (invalidated.has(current))
+                continue;
+            invalidated.add(current);
+            const node = this.nodes.get(current);
+            if (!node)
+                continue;
+            for (const importer of node.importers) {
+                queue.push(importer);
+            }
+        }
+        return Array.from(invalidated);
+    }
+    remove(id) {
+        const node = this.nodes.get(id);
+        if (!node)
+            return;
+        for (const dep of node.imports) {
+            const depNode = this.nodes.get(dep);
+            if (depNode)
+                depNode.importers.delete(id);
+        }
+        for (const importer of node.importers) {
+            const importerNode = this.nodes.get(importer);
+            if (importerNode)
+                importerNode.imports.delete(id);
+        }
+        this.nodes.delete(id);
+    }
+}
+//# sourceMappingURL=module-graph.js.map

package/dist/compiler/pipeline/plugin-driver.js

@@ -0,0 +1,99 @@
+/* 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 class PluginDriver {
+    plugins;
+    constructor(plugins) {
+        this.plugins = plugins;
+    }
+    async resolve(args) {
+        for (const plugin of this.plugins) {
+            if (!plugin.onResolve)
+                continue;
+            const result = await plugin.onResolve(args);
+            if (result && (result.path || result.external || result.errors)) {
+                return result;
+            }
+        }
+        return {};
+    }
+    async load(args) {
+        for (const plugin of this.plugins) {
+            if (!plugin.onLoad)
+                continue;
+            const result = await plugin.onLoad(args);
+            if (result && (result.contents || result.errors)) {
+                return result;
+            }
+        }
+        return {};
+    }
+    async transform(args) {
+        let current = args.contents;
+        let currentLoader = args.loader;
+        let currentMeta = args.meta;
+        let errors = [];
+        for (const plugin of this.plugins) {
+            if (!plugin.onTransform)
+                continue;
+            const result = await plugin.onTransform({
+                ...args,
+                contents: current,
+                loader: currentLoader,
+                meta: currentMeta,
+            });
+            if (result.errors?.length)
+                errors = errors.concat(result.errors);
+            if (result.contents)
+                current = result.contents;
+            if (result.loader)
+                currentLoader = result.loader;
+            if (result.meta)
+                currentMeta = {
+                    ...(currentMeta || {}),
+                    ...result.meta,
+                };
+        }
+        return {
+            contents: current,
+            loader: currentLoader,
+            meta: currentMeta,
+            errors: errors.length ? errors : undefined,
+        };
+    }
+    async hotUpdate(args) {
+        let reload = 'none';
+        let errors = [];
+        for (const plugin of this.plugins) {
+            if (!plugin.onHotUpdate)
+                continue;
+            const result = await plugin.onHotUpdate(args);
+            if (result.errors?.length)
+                errors = errors.concat(result.errors);
+            if (result.reload === 'full')
+                reload = 'full';
+            if (result.reload === 'module' && reload !== 'full')
+                reload = 'module';
+        }
+        return { reload, errors: errors.length ? errors : undefined };
+    }
+    async end(errors) {
+        const args = { errors };
+        for (const plugin of this.plugins) {
+            if (!plugin.onEnd)
+                continue;
+            await plugin.onEnd(args);
+        }
+        return { errors };
+    }
+}
+//# sourceMappingURL=plugin-driver.js.map

package/dist/compiler/pipeline/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 {};
+//# sourceMappingURL=types.js.map

package/dist/compiler/tailwindcss.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 { env } from 'node:process';
 import { logger } from '../servicios/logger.js';
 import { TailwindNode } from '../wrappers/tailwind-node.js';

package/dist/compiler/transform-optimizer.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) ?? {}; },
+    };
+  })();
+}
 /**
  * Transform Optimizer - Sistema de optimización de transformaciones AST
  * Implementa procesamiento paralelo y caching inteligente para transformaciones

package/dist/compiler/transformTStoJS.js

@@ -1,16 +1,49 @@
+/* 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 { transform } from '/node_modules/oxc-transform/browser.js';
-export async function traspileTStoJS(filePath, sourceCode) {
+export async function transpileTStoJS(filePath, sourceCode) {
     try {
         const { code: outputText, declaration, errors: diagnostics, } = await transform(filePath, sourceCode);
+        // Si oxc-transform devuelve código vacío ante una entrada no vacía,
+        // usar el fuente original como fallback para no corromper el pipeline.
+        if (!outputText && sourceCode.trim()) {
+            return {
+                outputText: sourceCode,
+                declaration: declaration || '',
+                diagnostics: [
+                    `Warning: oxc-transform produjo salida vacía para ${filePath}, usando fuente original`,
+                    ...(diagnostics ?? []).map(d => typeof d === 'string' ? d : JSON.stringify(d)),
+                ],
+            };
+        }
         return {
-            outputText: outputText,
+            outputText: outputText ?? sourceCode,
             declaration: declaration || '',
-            diagnostics: diagnostics || [],
+            diagnostics: (diagnostics ?? []).map(d => typeof d === 'string' ? d : JSON.stringify(d)),
         };
     }
     catch (error) {
-        console.error(`Error transpiling ${filePath}:`, error);
-        return { outputText: '', declaration: '', diagnostics: [error] };
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        // Fallback al fuente original para que el pipeline no reciba código vacío
+        return {
+            outputText: sourceCode,
+            declaration: '',
+            diagnostics: [
+                `Error durante transpilación de ${filePath}: ${errorMsg}. Usando fuente original.`,
+            ],
+        };
     }
 }
+/** @deprecated Usar transpileTStoJS (corrección de typo histórico) */
+export const traspileTStoJS = transpileTStoJS;
 //# sourceMappingURL=transformTStoJS.js.map

package/dist/compiler/transforms.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 path from 'node:path';
 import { env } from 'node:process';
 import { logger } from '../servicios/logger.js';
@@ -90,7 +102,9 @@ function isExternalModule(moduleRequest, pathAlias) {
         return true;
     } // Descartar alias conocidos
     for (const alias of Object.keys(pathAlias)) {
-        const aliasPattern = alias.replace('/*', '');
+        // Quitar solo el '*' final para conservar el separador '/'
+        // Ejemplo: '@/*' → '@/', así '@vueuse/core' no hace match pero '@/foo' sí
+        const aliasPattern = alias.replace('*', '');
         if (moduleRequest.startsWith(aliasPattern)) {
             return false;
         }
@@ -105,6 +119,211 @@ function isExternalModule(moduleRequest, pathAlias) {
     // Si llegamos aquí, es probablemente un módulo externo
     return true;
 }
+async function resolveModuleRequest(moduleRequest, file, pathAlias) {
+    let newPath = null;
+    let transformed = false;
+    if (!transformed && isExternalModule(moduleRequest, pathAlias)) {
+        try {
+            const optimizedResult = await getOptimizedModulePath(moduleRequest, file);
+            if (optimizedResult.excluded) {
+                return null;
+            }
+            if (optimizedResult.path) {
+                newPath = optimizedResult.path;
+                transformed = true;
+            }
+            else {
+                const modulePath = getModuleSubPath(moduleRequest, file);
+                if (modulePath === null) {
+                    return null;
+                }
+                if (modulePath) {
+                    newPath = modulePath;
+                    transformed = true;
+                }
+            }
+        }
+        catch (error) {
+            if (env.VERBOSE === 'true')
+                logger.warn(`Error resolviendo módulo ${moduleRequest}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (!transformed) {
+        const aliasPath = getOptimizedAliasPath(moduleRequest);
+        if (aliasPath) {
+            let newImportPath = aliasPath;
+            if (newImportPath.endsWith('.ts') ||
+                newImportPath.endsWith('.vue')) {
+                newImportPath = newImportPath.replace(/\.(ts|vue)$/, '.js');
+            }
+            else if (!/\.(js|mjs|css|json)$/.test(newImportPath)) {
+                newImportPath += '.js';
+            }
+            newPath = newImportPath;
+            transformed = true;
+        }
+        else {
+            for (const [alias] of Object.entries(pathAlias)) {
+                const aliasPattern = alias.replace('*', '');
+                if (moduleRequest.startsWith(aliasPattern)) {
+                    const relativePath = moduleRequest.replace(aliasPattern, '');
+                    let newImportPath = path.join('/', env.PATH_DIST, relativePath);
+                    newImportPath = newImportPath
+                        .replace(/\/\.\//g, '/')
+                        .replace(/\\/g, '/');
+                    if (newImportPath.endsWith('.ts') ||
+                        newImportPath.endsWith('.vue')) {
+                        newImportPath = newImportPath.replace(/\.(ts|vue)$/, '.js');
+                    }
+                    else if (!/\.(js|mjs|css|json)$/.test(newImportPath)) {
+                        newImportPath += '.js';
+                    }
+                    newPath = newImportPath;
+                    transformed = true;
+                    break;
+                }
+            }
+        }
+    }
+    if (!transformed &&
+        (moduleRequest.startsWith('./') || moduleRequest.startsWith('../'))) {
+        let relativePath = moduleRequest;
+        if (relativePath.endsWith('.ts') || relativePath.endsWith('.vue')) {
+            relativePath = relativePath.replace(/\.(ts|vue)$/, '.js');
+            newPath = relativePath;
+            transformed = true;
+        }
+        else if (!/\.(js|mjs|css|json)$/.test(relativePath)) {
+            newPath = relativePath + '.js';
+            transformed = true;
+        }
+    }
+    return transformed ? newPath : null;
+}
+function extractLiteralValue(raw) {
+    if (!raw || raw.length < 2)
+        return null;
+    const quote = raw[0];
+    const last = raw[raw.length - 1];
+    if ((quote !== '"' && quote !== "'" && quote !== '`') || last !== quote) {
+        return null;
+    }
+    if (quote === '`' && raw.includes('${')) {
+        return null;
+    }
+    return { quote, value: raw.slice(1, -1) };
+}
+function resolveAliasTemplateLiteral(raw, pathAlias) {
+    if (!raw.startsWith('`'))
+        return null;
+    const exprIndex = raw.indexOf('${');
+    if (exprIndex === -1)
+        return null;
+    const prefix = raw.slice(1, exprIndex);
+    if (!prefix)
+        return null;
+    const sortedAliases = Object.entries(pathAlias).sort((a, b) => {
+        const aliasA = a[0].replace('/*', '');
+        const aliasB = b[0].replace('/*', '');
+        return aliasB.length - aliasA.length;
+    });
+    for (const [alias, target] of sortedAliases) {
+        const aliasPattern = alias.replace('/*', '');
+        if (!prefix.startsWith(aliasPattern))
+            continue;
+        const relativePath = prefix.replace(aliasPattern, '');
+        const targetArray = Array.isArray(target) ? target : [target];
+        const targetPath = targetArray[0];
+        if (!targetPath)
+            continue;
+        let newPrefix;
+        if (targetPath.startsWith('/')) {
+            newPrefix = path.join('/', env.PATH_DIST, relativePath);
+        }
+        else {
+            const cleanTarget = targetPath.replace('./', '').replace('/*', '');
+            const normalizedPathDist = env.PATH_DIST.replace('./', '');
+            if (cleanTarget === normalizedPathDist) {
+                newPrefix = path.join('/', normalizedPathDist, relativePath);
+            }
+            else {
+                newPrefix = path.join('/', normalizedPathDist, cleanTarget, relativePath);
+            }
+        }
+        newPrefix = newPrefix
+            .replace(/\/\.\//g, '/')
+            .replace(/\\/g, '/')
+            .replace(/\/+/g, '/');
+        return `\`${newPrefix}${raw.slice(exprIndex)}`;
+    }
+    return null;
+}
+async function replaceAliasImportsAst(code, file, ast) {
+    if (!env.PATH_ALIAS || !env.PATH_DIST) {
+        return code;
+    }
+    const pathAlias = getParsedPathAlias();
+    if (!pathAlias)
+        return code;
+    const replacements = [];
+    const staticImports = ast?.module?.staticImports || [];
+    for (const item of staticImports) {
+        const moduleRequest = item?.moduleRequest?.value;
+        const start = item?.moduleRequest?.start;
+        const end = item?.moduleRequest?.end;
+        if (typeof moduleRequest !== 'string')
+            continue;
+        if (typeof start !== 'number' || typeof end !== 'number')
+            continue;
+        const newPath = await resolveModuleRequest(moduleRequest, file, pathAlias);
+        if (!newPath || newPath === moduleRequest)
+            continue;
+        const raw = code.slice(start, end);
+        const literal = extractLiteralValue(raw);
+        if (!literal)
+            continue;
+        replacements.push({
+            start,
+            end,
+            value: `${literal.quote}${newPath}${literal.quote}`,
+        });
+    }
+    const dynamicImports = ast?.module?.dynamicImports || [];
+    for (const item of dynamicImports) {
+        const start = item?.moduleRequest?.start;
+        const end = item?.moduleRequest?.end;
+        if (typeof start !== 'number' || typeof end !== 'number')
+            continue;
+        const raw = code.slice(start, end);
+        const literal = extractLiteralValue(raw);
+        if (!literal) {
+            const replaced = resolveAliasTemplateLiteral(raw, pathAlias);
+            if (replaced) {
+                replacements.push({ start, end, value: replaced });
+            }
+            continue;
+        }
+        const newPath = await resolveModuleRequest(literal.value, file, pathAlias);
+        if (!newPath || newPath === literal.value)
+            continue;
+        replacements.push({
+            start,
+            end,
+            value: `${literal.quote}${newPath}${literal.quote}`,
+        });
+    }
+    if (replacements.length === 0)
+        return code;
+    replacements.sort((a, b) => b.start - a.start);
+    let resultCode = code;
+    for (const replacement of replacements) {
+        resultCode =
+            resultCode.slice(0, replacement.start) +
+                replacement.value +
+                resultCode.slice(replacement.end);
+    }
+    return resultCode;
+}
 export async function replaceAliasImportStatic(file, code) {
     if (!env.PATH_ALIAS || !env.PATH_DIST) {
         return code;
@@ -124,13 +343,13 @@ export async function replaceAliasImportStatic(file, code) {
         if (!transformed && isExternalModule(moduleRequest, pathAlias)) {
             try {
                 // Usar el sistema optimizado primero
-                const optimizedPath = await getOptimizedModulePath(moduleRequest, file);
-                if (optimizedPath === null) {
-                    // Si el optimizador retorna null, significa que es un módulo excluido
+                const optimizedResult = await getOptimizedModulePath(moduleRequest, file);
+                if (optimizedResult.excluded) {
+                    // Módulo excluido explícitamente: mantener importación original
                     continue;
                 }
-                if (optimizedPath) {
-                    newPath = optimizedPath;
+                if (optimizedResult.path) {
+                    newPath = optimizedResult.path;
                     transformed = true;
                 }
                 else {
@@ -169,7 +388,7 @@ export async function replaceAliasImportStatic(file, code) {
             else {
                 // Fallback al sistema anterior
                 for (const [alias] of Object.entries(pathAlias)) {
-                    const aliasPattern = alias.replace('/*', '');
+                    const aliasPattern = alias.replace('*', '');
                     if (moduleRequest.startsWith(aliasPattern)) {
                         // Reemplazar el alias con la ruta del target
                         const relativePath = moduleRequest.replace(aliasPattern, '');
@@ -239,13 +458,13 @@ export async function replaceAliasImportDynamic(code, _imports, file) {
         if (!transformed && isExternalModule(moduleRequest, pathAlias)) {
             try {
                 // Usar el sistema optimizado primero
-                const optimizedPath = await getOptimizedModulePath(moduleRequest, file);
-                if (optimizedPath === null) {
-                    // Si el optimizador retorna null, significa que es un módulo excluido
+                const optimizedResult = await getOptimizedModulePath(moduleRequest, file);
+                if (optimizedResult.excluded) {
+                    // Módulo excluido explícitamente: mantener importación original
                     continue;
                 }
-                if (optimizedPath) {
-                    newPath = optimizedPath;
+                if (optimizedResult.path) {
+                    newPath = optimizedResult.path;
                     transformed = true;
                 }
                 else {
@@ -284,7 +503,7 @@ export async function replaceAliasImportDynamic(code, _imports, file) {
             else {
                 // Fallback al sistema anterior
                 for (const [alias] of Object.entries(pathAlias)) {
-                    const aliasPattern = alias.replace('/*', '');
+                    const aliasPattern = alias.replace('*', '');
                     if (moduleRequest.startsWith(aliasPattern)) {
                         // Reemplazar el alias con la ruta del target
                         const relativePath = moduleRequest.replace(aliasPattern, '');
@@ -356,7 +575,7 @@ export async function replaceAliasImportDynamic(code, _imports, file) {
         // 2. Verificar aliases en template literals
         if (!transformed) {
             for (const [alias] of Object.entries(pathAlias)) {
-                const aliasPattern = alias.replace('/*', '');
+                const aliasPattern = alias.replace('*', '');
                 if (moduleRequest.includes(aliasPattern)) {
                     const relativePath = moduleRequest.replace(aliasPattern, '');
                     // Para alias que apuntan a la raíz (como @/* -> /src/*),
@@ -550,8 +769,7 @@ export async function estandarizaCode(code, file) {
             const firstError = ast.errors[0];
             throw new Error(firstError?.message || 'Error sin mensaje');
         }
-        code = await replaceAliasImportStatic(file, code);
-        code = await replaceAliasImportDynamic(code, ast?.module.dynamicImports, file);
+        code = await replaceAliasImportsAst(code, file, ast);
         code = await replaceAliasInStrings(code);
         code = await removehtmlOfTemplateString(code);
         code = await removeCodeTagImport(code);

package/dist/compiler/typescript-compiler.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 fs from 'node:fs';
 import path from 'node:path';
 import * as process from 'node:process';

package/dist/compiler/typescript-error-parser.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 { readFileSync } from 'node:fs';
 import * as typescript from 'typescript';
 /**

package/dist/compiler/typescript-manager.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 fs from 'node:fs';
 import path from 'node:path';
 import * as process from 'node:process';
@@ -55,7 +67,9 @@ export const loadTypeScriptConfig = (fileName) => {
         }
         catch (error) {
             console.warn(`[loadTypeScriptConfig] Error cargando ${configPath}:`, error);
-            throw new Error(`No se puede continuar sin un tsconfig.json válido. Error: ${error}`, { cause: error });
+            throw new Error(`No se puede continuar sin un tsconfig.json válido. Error: ${error}`, {
+                cause: error,
+            });
         }
         // ✨ FIX #9: Guardar en cache con timestamp
         configCache = {