versacompiler 2.5.0 → 2.6.1

package/dist/servicios/browserSync.js

@@ -1,3 +1,17 @@
+/* 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) ?? {}; },
+    };
+    window.__versaHMR.accept("/path/to/file.js", () => { import(_id + '?t=' + Date.now()); });
+    window.__versaHMR.accept("/public/js/bar.js", () => { import(_id + '?t=' + Date.now()); });
+  })();
+}
 import { createHash } from 'node:crypto';
 import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
@@ -315,6 +329,54 @@ class BrowserSyncFileCache {
 }
 // Instancia global del cache de archivos
 const fileCache = BrowserSyncFileCache.getInstance();
+// ─── HMR Import Rewriting ─────────────────────────────────────────────────────
+// Cuando un módulo se re-compila en watch mode, registramos su path con timestamp.
+// Al servir requests con ?t= (re-imports HMR), reescribimos los static imports de
+// ese archivo para que también incluyan ?t=, forzando al browser a cargar la nueva
+// versión en lugar de usar el módulo cacheado en su module registry.
+/** Map de path normalizado → timestamp de la última compilación exitosa */
+const recentHMRTimestamps = new Map();
+/** TTL para limpiar entradas viejas del mapa (5 minutos) */
+const HMR_TIMESTAMP_TTL = 5 * 60 * 1000;
+/**
+ * Registra que un output file fue re-compilado en modo watch.
+ * Debe llamarse inmediatamente después de escribir el archivo a disco.
+ * @param outputPath - Path relativo del output compilado (ej: 'public/js/sampleFile.js')
+ */
+export function registerHMRUpdate(outputPath) {
+    // Normalizar a path absoluto con / inicial (como lo ve el browser)
+    const normalized = '/' + outputPath.replace(/\\/g, '/').replace(/^\.?\/+/, '');
+    recentHMRTimestamps.set(normalized, Date.now());
+    // Limpiar entradas viejas para evitar crecimiento ilimitado
+    const cutoff = Date.now() - HMR_TIMESTAMP_TTL;
+    for (const [key, ts] of recentHMRTimestamps) {
+        if (ts < cutoff)
+            recentHMRTimestamps.delete(key);
+    }
+}
+/**
+ * Reescribe los static imports de un archivo JS para agregar ?t=<timestamp>
+ * a cualquier módulo que haya sido recientemente re-compilado.
+ * Esto fuerza al browser a crear un nuevo module record (URL diferente)
+ * en lugar de reusar el módulo cacheado del registry.
+ */
+function rewriteImportsForHMR(content) {
+    if (recentHMRTimestamps.size === 0)
+        return content;
+    // Reescribir: from '/path/to/file.js' → from '/path/to/file.js?t=<ts>'
+    // Handles: import ... from '...', export ... from '...'
+    // Solo paths absolutos (con /) → son los compilados por VersaCompiler
+    return content.replace(/((?:from|import)\s+['"])(\/.+?\.js)(['""])/g, (_match, prefix, importPath, suffix) => {
+        // Quitar ?t= previo si ya existe
+        const cleanPath = importPath.split('?')[0];
+        const ts = recentHMRTimestamps.get(cleanPath);
+        if (ts) {
+            return `${prefix}${cleanPath}?t=${ts}${suffix}`;
+        }
+        return _match;
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────────
 // Lazy loading para chalk - pre-cargado para mejor rendimiento
 let chalk;
 let chalkPromise = null;
@@ -388,6 +450,9 @@ export async function browserSyncServer() {
                     fn: (snippet, match) => {
                         return `
                             ${snippet}${match}
+                            <script
+                                type="module"
+                                src="/__versa/versaHMR.js"></script>
                             <script
                                 type="module"
                                 src="/__versa/initHRM.js"></script>
@@ -447,8 +512,19 @@ export async function browserSyncServer() {
                     }
                     // Si la URL comienza con /__versa/hrm/, sirve los archivos de dist/hrm
                     if (req.url.startsWith('/__versa/')) {
-                        // ✨ OPTIMIZADO: Usar cache para archivos Versa
-                        const filePath = path.join(relativeHrmPath, req.url.replace('/__versa/', ''));
+                        // ✨ SEGURIDAD: Prevenir path traversal normalizando y verificando el directorio
+                        const requestedRelative = req.url
+                            .replace('/__versa/', '')
+                            .split('?')[0]; // strip query string
+                        const resolvedFilePath = path.resolve(relativeHrmPath, requestedRelative);
+                        const allowedBase = path.resolve(relativeHrmPath);
+                        if (!resolvedFilePath.startsWith(allowedBase + path.sep) &&
+                            resolvedFilePath !== allowedBase) {
+                            res.statusCode = 403;
+                            res.end('// Forbidden');
+                            return;
+                        }
+                        const filePath = resolvedFilePath;
                         const cachedFile = await fileCache.getOrReadFile(filePath);
                         if (cachedFile) {
                             res.setHeader('Content-Type', cachedFile.contentType);
@@ -473,8 +549,19 @@ export async function browserSyncServer() {
                     }
                     // Si la URL comienza con /node_modules/, sirve los archivos de node_modules
                     if (req.url.startsWith('/node_modules/')) {
-                        // ✨ OPTIMIZADO: Usar cache para módulos de node_modules
-                        const modulePath = path.join(process.cwd(), req.url);
+                        // ✨ SEGURIDAD: Prevenir path traversal verificando que el path resuelto
+                        // permanece dentro de node_modules del proyecto
+                        const requestedRelative = req.url
+                            .replace('/node_modules/', '')
+                            .split('?')[0]; // strip query string
+                        const nodeModulesBase = path.resolve(process.cwd(), 'node_modules');
+                        const modulePath = path.resolve(nodeModulesBase, requestedRelative);
+                        if (!modulePath.startsWith(nodeModulesBase + path.sep) &&
+                            modulePath !== nodeModulesBase) {
+                            res.statusCode = 403;
+                            res.end('// Forbidden');
+                            return;
+                        }
                         const cachedFile = await fileCache.getOrReadFile(modulePath);
                         if (cachedFile) {
                             res.setHeader('Content-Type', cachedFile.contentType);
@@ -497,6 +584,34 @@ export async function browserSyncServer() {
                         }
                         return;
                     }
+                    // ── HMR re-import: reescribir imports para que el browser no use caché ──
+                    // Cuando el cliente hace import('/public/js/foo.js?t=123'), el browser crea
+                    // un nuevo module record para esa URL. Al evaluar el módulo, sus static imports
+                    // (ej: import { x } from '/public/js/bar.js') SIN timestamp reusan el módulo
+                    // cacheado del registry → se ve el código viejo.
+                    // Solución: interceptar estas requests y reescribir los imports del archivo
+                    // para que también lleven ?t= en los módulos recientemente modificados.
+                    const isHMRReimport = req.method === 'GET' &&
+                        req.url.includes('?t=') &&
+                        /\.js\?/.test(req.url) &&
+                        !req.url.startsWith('/__versa/') &&
+                        !req.url.startsWith('/node_modules/');
+                    if (isHMRReimport) {
+                        const urlPath = req.url.split('?')[0];
+                        const filePath = path.join(process.cwd(), urlPath);
+                        try {
+                            const rawContent = await fs.readFile(filePath, 'utf-8');
+                            const rewritten = rewriteImportsForHMR(rawContent);
+                            res.setHeader('Content-Type', 'application/javascript; charset=utf-8');
+                            res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
+                            res.end(rewritten);
+                            return;
+                        }
+                        catch {
+                            // Archivo no encontrado, seguir al handler estático
+                        }
+                    }
+                    // ──────────────────────────────────────────────────────────────────────────
                     // detectar si es un archivo estático, puede que contenga un . y alguna extensión o dashUsers.js?v=1746559083866
                     const isAssets = req.url.match(/\.(js|css|png|jpg|jpeg|gif|svg|ico|woff|woff2|ttf|eot|map|webp|avif|json|html|xml|txt|pdf|zip|mp4|mp3|wav|ogg)(\?.*)?$/i);
                     if (req.method === 'GET') {

package/dist/servicios/file-watcher.js

@@ -1,4 +1,16 @@
-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;
@@ -6,7 +18,7 @@ import * as chokidar from 'chokidar';
 import { minimatch } from 'minimatch';
 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;
@@ -162,11 +217,23 @@ class WatchDebouncer {
                     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: 'reloadFull',
+                            extensionAction: invalidatedAction,
                             isAdditionalFile: false,
                         });
                     }
@@ -203,6 +270,10 @@ class WatchDebouncer {
             }
             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;
@@ -211,20 +282,38 @@ class WatchDebouncer {
                     if (pluginHmrReload === 'full') {
                         accion = 'reloadFull';
                     }
-                    const graph = getPipelineModuleGraph();
-                    const node = graph?.getNode(change.filePath);
-                    const importers = node ? Array.from(node.importers) : [];
-                    const strategy = importers.length > 0 ? 'propagate' : 'full-reload';
-                    if (pluginHmrReload === 'module') {
-                        payload.strategy = 'propagate';
-                    }
                     else {
-                        payload.strategy = strategy;
+                        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,
+                        };
                     }
-                    payload = {
-                        importers,
-                        ...payload,
-                    };
                 }
                 emitirCambios(this.browserSyncInstance, accion || 'reloadFull', result.output, payload);
             }

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';
@@ -439,7 +451,7 @@ export default defineConfig({
     },
     resolve: {
         alias: {
-            '/dist': 'src',
+            '/dist/public': 'src',
             '/dist/public': 'public',
         },
     },

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

@@ -1,2 +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,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) ?? {}; },
+    };
+  })();
+}
 // Opción con librería 'resolve' (npm install resolve)
 import fs, { readFileSync } from 'node:fs';
 import { dirname, join, relative } from 'node:path';

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';

package/dist/utils/proxyValidator.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 { get as httpGet } from 'node:http';
 import { get as httpsGet } from 'node:https';
 import { URL } from 'node:url';

package/dist/utils/resolve-bin.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 path from 'node:path';
 import * as process from 'node:process';
 import * as fs from 'fs-extra';

package/dist/utils/utils.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) ?? {}; },
+    };
+  })();
+}
 /**
  * Converts a 24-hour time string to a 12-hour time string with AM/PM.
  *

package/dist/utils/vue-types-setup.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) ?? {}; },
+    };
+  })();
+}
 /**
  * Utilidad para configurar automáticamente los tipos de Vue en proyectos
  * Facilita la integración de tipado robusto para archivos Vue
@@ -81,8 +93,8 @@ const createProjectTsConfig = async (projectRoot, options) => {
             // Paths para tipos
             baseUrl: '.',
             paths: {
-                '/dist/*': ['src/*'],
-                '/dist/types/*': ['src/types/*'],
+                '/dist/public/*': ['src/*'],
+                '/dist/public/types/*': ['src/types/*'],
             },
             types: [
                 'node',

package/dist/wrappers/eslint-node.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 path from 'node:path';
 import { cwd } from 'node:process'; // Añadir importación de cwd
 import { execa } from 'execa';

package/dist/wrappers/oxlint-node.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 { execa } from 'execa';
 import { resolveBin } from '../utils/resolve-bin.js';
 export class OxlintNode {

package/dist/wrappers/tailwind-node.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 { execa } from 'execa';
 import { resolveBin } from '../utils/resolve-bin.js';
 export class TailwindNode {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "versacompiler",
-    "version": "2.5.0",
+    "version": "2.6.1",
     "description": "Una herramienta para compilar y minificar archivos .vue, .js y .ts para proyectos de Vue 3 con soporte para TypeScript.",
     "keywords": [
         "compiler",
@@ -61,7 +61,8 @@
         "test:ui": "vitest --ui",
         "test:coverage": "vitest run --coverage",
         "lint": "oxlint --fix --config .oxlintrc.json",
-        "lint:eslint": "eslint --ext .js,.ts,.vue src/ --fix"
+        "lint:eslint": "eslint --ext .js,.ts,.vue src/ --fix",
+        "fmt": "oxfmt --write --config .oxfmtrc.json ."
     },
     "dependencies": {
         "@vue/compiler-dom": "^3.5.31",
@@ -114,7 +115,7 @@
         "eslint-plugin-promise": "^7.2.1",
         "eslint-plugin-unicorn": "^64.0.0",
         "eslint-plugin-vue": "^10.8.0",
-        "oxfmt": "^0.42.0",
+        "oxfmt": "^0.43.0",
         "oxlint": "^1.57.0",
         "pinia": "^3.0.4",
         "prettier": "3.8.1",