versacompiler 2.5.0 → 2.6.0

package/dist/hrm/versaHMR.js

@@ -0,0 +1,317 @@
+/* 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) ?? {}; },
+    };
+  })();
+}
+/**
+ * @fileoverview VersaHMR — Registry de módulos para Hot Module Replacement
+ *
+ * Permite que librerías y utilidades JS/TS reciban actualizaciones sin full-reload.
+ *
+ * Uso básico (en cualquier módulo que consuma una librería):
+ *
+ *   window.__versaHMR.accept('/public/utils/math.js', (newModule) => {
+ *     // Recibir la nueva versión y actualizar referencias locales
+ *     mathLib = newModule;
+ *   });
+ *
+ * Uso automático (para módulos que solo exportan funciones/constantes):
+ *   El sistema detecta automáticamente si es seguro hacer HMR y llama a los callbacks.
+ */
+
+/**
+ * @typedef {Object} ModuleEntry
+ * @property {any} module - La instancia actual del módulo
+ * @property {Set<Function>} callbacks - Callbacks registrados para actualizaciones
+ * @property {number} version - Versión (incrementa en cada update)
+ */
+
+class VersaModuleRegistry {
+    constructor() {
+        /** @type {Map<string, ModuleEntry>} */
+        this._registry = new Map();
+
+        /** @type {Map<string, Set<string>>} Árbol inverso: módulo → quién lo importa */
+        this._importers = new Map();
+
+        /** @type {Set<string>} Módulos que han fallado al actualizarse */
+        this._failedUpdates = new Set();
+
+        /** @type {Map<string, Set<Function>>} Callbacks de cleanup por módulo */
+        this._disposeCallbacks = new Map();
+
+        /** @type {Map<string, Object>} Datos persistentes entre ciclos HMR */
+        this._hotData = new Map();
+    }
+
+    /**
+     * Normaliza un moduleId para uso como clave en el registry.
+     * Elimina query params y asegura formato consistente.
+     * @param {string} moduleId
+     * @returns {string}
+     */
+    _normalizeId(moduleId) {
+        try {
+            // Si es una URL relativa, la convertimos a pathname limpio
+            const url = new URL(moduleId, window.location.origin);
+            return url.pathname;
+        } catch {
+            return moduleId.split('?')[0];
+        }
+    }
+
+    /**
+     * Registra un callback para recibir actualizaciones de un módulo.
+     * El callback se llama con (newModule, { moduleId, version }) cuando el módulo cambia.
+     *
+     * @param {string} moduleId - Path/URL del módulo a observar (ej: '/public/utils/math.js')
+     * @param {Function} updateCallback - Función llamada cuando el módulo cambia
+     * @returns {Function} Función para cancelar el registro (unsubscribe)
+     */
+    accept(moduleId, updateCallback) {
+        const id = this._normalizeId(moduleId);
+
+        if (!this._registry.has(id)) {
+            this._registry.set(id, {
+                module: null,
+                callbacks: new Set(),
+                version: 0,
+            });
+        }
+
+        const entry = this._registry.get(id);
+        entry.callbacks.add(updateCallback);
+
+        console.log(`[VersaHMR] Registrado observer para: ${id}`);
+
+        // Retornar función de cleanup
+        return () => {
+            const e = this._registry.get(id);
+            if (e) {
+                e.callbacks.delete(updateCallback);
+                if (e.callbacks.size === 0) {
+                    this._registry.delete(id);
+                    console.log(`[VersaHMR] Registry limpiado para: ${id}`);
+                }
+            }
+        };
+    }
+
+    /**
+     * Notifica a todos los observers registrados que un módulo fue actualizado.
+     * Llamado internamente por el handler de HRMHelper cuando recibe un nuevo módulo.
+     *
+     * @param {string} moduleId - Path del módulo actualizado
+     * @param {any} newModule - La nueva instancia del módulo exportado
+     * @returns {boolean} true si había al menos un observer y todos ejecutaron sin error
+     */
+    notifyUpdate(moduleId, newModule) {
+        const id = this._normalizeId(moduleId);
+        const entry = this._registry.get(id);
+
+        if (!entry || entry.callbacks.size === 0) {
+            return false;
+        }
+
+        // Ejecutar dispose callbacks antes de actualizar
+        this._runDispose(id);
+
+        entry.version++;
+        entry.module = newModule;
+        const meta = { moduleId: id, version: entry.version };
+
+        let allSucceeded = true;
+
+        for (const callback of entry.callbacks) {
+            try {
+                callback(newModule, meta);
+            } catch (err) {
+                console.error(
+                    `[VersaHMR] Error en callback de update para ${id}:`,
+                    err,
+                );
+                allSucceeded = false;
+                this._failedUpdates.add(id);
+            }
+        }
+
+        if (allSucceeded) {
+            this._failedUpdates.delete(id);
+            console.log(
+                `[VersaHMR] ✅ Módulo actualizado (v${entry.version}): ${id} — ${entry.callbacks.size} observer(s) notificado(s)`,
+            );
+        }
+
+        return allSucceeded;
+    }
+
+    /**
+     * Registra la relación de importación entre módulos.
+     * Esto permite propagación en cadena cuando cambia un módulo.
+     *
+     * @param {string} importer - Path del módulo que importa
+     * @param {string} imported - Path del módulo importado
+     */
+    registerImporter(importer, imported) {
+        const importedId = this._normalizeId(imported);
+        const importerId = this._normalizeId(importer);
+
+        if (!this._importers.has(importedId)) {
+            this._importers.set(importedId, new Set());
+        }
+        this._importers.get(importedId).add(importerId);
+    }
+
+    /**
+     * Obtiene el módulo actual registrado (si fue cargado via notifyUpdate).
+     * @param {string} moduleId
+     * @returns {any | null}
+     */
+    getModule(moduleId) {
+        const id = this._normalizeId(moduleId);
+        return this._registry.get(id)?.module ?? null;
+    }
+
+    /**
+     * Registra un callback de dispose que se ejecuta antes de que el módulo
+     * sea reemplazado. Permite cleanup de timers, event listeners, etc.
+     * Expuesto como import.meta.hot.dispose(cb) en el shim de HMR.
+     *
+     * @param {string} moduleId
+     * @param {Function} cb - Llamado con (data) donde data = _getHotData(moduleId)
+     */
+    _onDispose(moduleId, cb) {
+        const id = this._normalizeId(moduleId);
+        if (!this._disposeCallbacks.has(id)) {
+            this._disposeCallbacks.set(id, new Set());
+        }
+        this._disposeCallbacks.get(id).add(cb);
+    }
+
+    /**
+     * Retorna el objeto de datos persistentes de un módulo.
+     * El objeto sobrevive entre ciclos HMR para preservar estado local.
+     * Expuesto como import.meta.hot.data en el shim de HMR.
+     *
+     * @param {string} moduleId
+     * @returns {Object}
+     */
+    _getHotData(moduleId) {
+        const id = this._normalizeId(moduleId);
+        if (!this._hotData.has(id)) {
+            this._hotData.set(id, {});
+        }
+        return this._hotData.get(id);
+    }
+
+    /**
+     * Ejecuta los callbacks de dispose antes de un update HMR.
+     * Llamado internamente desde notifyUpdate antes de notificar observers.
+     *
+     * @param {string} moduleId
+     */
+    _runDispose(moduleId) {
+        const id = this._normalizeId(moduleId);
+        const disposers = this._disposeCallbacks.get(id);
+        if (!disposers || disposers.size === 0) return;
+
+        const data = this._getHotData(id);
+        for (const cb of disposers) {
+            try {
+                cb(data);
+            } catch (err) {
+                console.error(
+                    `[VersaHMR] Error en dispose callback para ${id}:`,
+                    err,
+                );
+            }
+        }
+        this._disposeCallbacks.delete(id);
+    }
+
+    /**
+     * Invalida un módulo: ejecuta dispose callbacks y fuerza recarga de página.
+     * Expuesto como import.meta.hot.invalidate() en el shim de HMR.
+     *
+     * @param {string} moduleId
+     */
+    _invalidate(moduleId) {
+        const id = this._normalizeId(moduleId);
+
+        // Ejecutar dispose callbacks antes de invalidar
+        this._runDispose(id);
+
+        // Limpiar estado del módulo
+        this._hotData.delete(id);
+        this._registry.delete(id);
+
+        console.log(
+            `[VersaHMR] Módulo invalidado: ${id} — forzando recarga completa`,
+        );
+        window.location.reload();
+    }
+
+    /**
+     * Indica si un módulo tiene observers registrados (puede hacer HMR).
+     * @param {string} moduleId
+     * @returns {boolean}
+     */
+    hasObservers(moduleId) {
+        const id = this._normalizeId(moduleId);
+        const entry = this._registry.get(id);
+        return !!(entry && entry.callbacks.size > 0);
+    }
+
+    /**
+     * Indica si un módulo tuvo fallos en el último update.
+     * @param {string} moduleId
+     * @returns {boolean}
+     */
+    hasFailed(moduleId) {
+        return this._failedUpdates.has(this._normalizeId(moduleId));
+    }
+
+    /**
+     * Limpia todos los registros (útil para tests o hot-reload del propio sistema).
+     */
+    clear() {
+        this._registry.clear();
+        this._importers.clear();
+        this._failedUpdates.clear();
+        this._disposeCallbacks.clear();
+        this._hotData.clear();
+    }
+
+    /**
+     * Estadísticas del registry (para debugging).
+     * @returns {{ modules: number, totalObservers: number, failedModules: number }}
+     */
+    getStats() {
+        let totalObservers = 0;
+        for (const entry of this._registry.values()) {
+            totalObservers += entry.callbacks.size;
+        }
+        return {
+            modules: this._registry.size,
+            totalObservers,
+            failedModules: this._failedUpdates.size,
+        };
+    }
+}
+
+// Singleton global expuesto en window.__versaHMR
+// Se preserva entre recargas parciales para no perder observers
+if (!window.__versaHMR) {
+    window.__versaHMR = new VersaModuleRegistry();
+    console.log('[VersaHMR] Registry inicializado');
+}
+
+export const versaHMR = window.__versaHMR;
+export default versaHMR;

package/dist/main.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) ?? {}; },
+    };
+  })();
+}
 #!/usr/bin/env node
 import * as path from 'node:path';
 import * as processModule from 'node:process';
@@ -259,6 +271,13 @@ async function main() {
                 try {
                     // Verificar si el archivo existe
                     await fs.access(file);
+                }
+                catch {
+                    logger.error(chalk.red(`❌ El archivo '${file}' no existe.`));
+                    hasErrors = true;
+                    continue;
+                }
+                try {
                     logger.info(chalk.blue(`🔄 Compilando: ${file}`));
                     const result = await compileFile(file);
                     if (result.success) {
@@ -269,8 +288,8 @@ async function main() {
                         hasErrors = true;
                     }
                 }
-                catch {
-                    logger.error(chalk.red(`❌ El archivo '${file}' no existe.`));
+                catch (err) {
+                    logger.error(chalk.red(`❌ Error al compilar '${file}': ${err instanceof Error ? err.message : String(err)}`));
                     hasErrors = true;
                 }
             }

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);
             }