@randomdev/pulsedev 0.1.2

package/helpers/counterChar.js

@@ -0,0 +1,40 @@
+/**
+ * no podemos usar el metodo write porque apendea, y aqui necesitamos reescribir
+ * y tampoco write por estariamos creando una referencia circular con el writter que ejecuta counter
+ */
+import { writeFile, readFile } from "node:fs/promises";
+/**
+ * vamos a crar un hilo de procesador que se ocupe especificamente de la tarea de leer, cortar y unir
+ */
+import { parentPort } from "node:worker_threads";
+
+parentPort.on("message", async (data) => {
+    const { path, logLimit } = data;
+
+    try {
+        let text = await readFile(path, "utf-8");
+        if (!text) return;
+
+        const MAX_CHARACTERS = (logLimit || 1) * 1000;
+
+        if (text.length > MAX_CHARACTERS) {
+            // 1. convertimos en array por salto de pagina
+            let lines = text.split("\n");
+
+            while (lines.join("\n").length > (MAX_CHARACTERS * 0.8)) {
+                // 1.1 sistema FIFO(first in, first out)
+                // los logs mas viejos son los primeros en entrar, y por ende los primeros en borrarse
+                lines.shift();
+            }
+
+            // 2. volvemos a unir
+            let cleanedText = lines.join("\n");
+
+            await writeFile(path, cleanedText, "utf-8");
+        }
+    } catch (error) {
+        console.error("[worker] - error: " + error.message);
+    } finally {
+        process.exit(0);
+    }
+});

package/helpers/hashFingerprint.js

@@ -0,0 +1,39 @@
+/**
+ * Debemos comparar el hash existe en un archivo con el nuevo creado
+ */
+
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+
+const fileHashes = new Map();
+
+export async function compareChanges(filepath) {
+    try {
+        const content = await readFile(filepath, "utf8");
+
+        const currentHash = createHash("md5").update(content).digest("hex");
+        // ver si el mismo archivo ya existe en map
+        const previousHash = fileHashes.get(filepath);
+
+        // si son iguales se retorna false
+        if(currentHash === previousHash) {
+            return false;
+        }
+
+        // si no lo son guardamos el hash en el map y retornamos verdadero
+        fileHashes.set(filepath, currentHash);
+        return true
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * inyectamos el hash a la url del archivo
+ */
+
+export function injectToUrl(urlPath, hash){
+    if(!hash)  return urlPath;
+
+    return `${urlPath}?v=${hash.substring(0,8)}`;
+}

package/helpers/mimeTypes.js

@@ -0,0 +1,75 @@
+export const contentTypes = {
+    'html': 'text/html',
+    'htm': 'text/html',
+    'css': 'text/css',
+    'js': 'application/javascript',
+    'mjs': 'application/javascript',
+    'json': 'application/json',
+    'xml': 'application/xml',
+    'txt': 'text/plain',
+    'md': 'text/markdown',
+
+    'svg': 'image/svg+xml',
+    'png': 'image/png',
+    'jpg': 'image/jpeg',
+    'jpeg': 'image/jpeg',
+    'gif': 'image/gif',
+    'webp': 'image/webp',
+    'avif': 'image/avif',
+    'ico': 'image/x-icon',
+    'bmp': 'image/bmp',
+    'tiff': 'image/tiff',
+    'tif': 'image/tiff',
+
+    'ttf': 'font/ttf',
+    'otf': 'font/otf',
+    'woff': 'font/woff',
+    'woff2': 'font/woff2',
+    'eot': 'application/vnd.ms-fontobject',
+
+    'mp3': 'audio/mpeg',
+    'wav': 'audio/wav',
+    'ogg': 'audio/ogg',
+    'm4a': 'audio/mp4',
+    'flac': 'audio/flac',
+    'aac': 'audio/aac',
+    'opus': 'audio/opus',
+
+    'mp4': 'video/mp4',
+    'webm': 'video/webm',
+    'ogv': 'video/ogg',
+    'avi': 'video/x-msvideo',
+    'mov': 'video/quicktime',
+    'mkv': 'video/x-matroska',
+    'flv': 'video/x-flv',
+    'mpeg': 'video/mpeg',
+    'mpg': 'video/mpeg',
+
+    'pdf': 'application/pdf',
+    'doc': 'application/msword',
+    'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    'xls': 'application/vnd.ms-excel',
+    'xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    'ppt': 'application/vnd.ms-powerpoint',
+    'pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    'zip': 'application/zip',
+    'rar': 'application/x-rar-compressed',
+    '7z': 'application/x-7z-compressed'
+};
+
+export const binaryExtensions = new Set([
+    'png', 'jpg', 'jpeg', 'gif', 'webp', 'avif', 'ico', 'bmp', 'tiff', 'tif',
+    'ttf', 'otf', 'woff', 'woff2', 'eot',
+    'mp3', 'wav', 'ogg', 'm4a', 'flac', 'aac', 'opus',
+    'mp4', 'webm', 'ogv', 'avi', 'mov', 'mkv', 'flv', 'mpeg', 'mpg',
+    'pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'zip', 'rar', '7z'
+]);
+
+export const noHashExtensions = new Set([
+    'png', 'jpg', 'jpeg', 'gif', 'webp', 'avif', 'ico', 'bmp', 'tiff', 'tif',
+    'ttf', 'otf', 'woff', 'woff2', 'eot',
+    'mp3', 'wav', 'ogg', 'm4a', 'flac', 'aac', 'opus',
+    'mp4', 'webm', 'ogv', 'avi', 'mov', 'mkv', 'flv', 'mpeg', 'mpg',
+    'pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'zip', 'rar', '7z',
+    'svg'
+]);

package/helpers/resourceHasher.js

@@ -0,0 +1,33 @@
+import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+import { injectToUrl } from "./hashFingerprint.js";
+
+async function replaceAsync(str, regex, asyncFn) {
+    const promises = [];
+    str.replace(regex, (match, ...args) => {
+        promises.push(asyncFn(match, ...args));
+        return match;
+    });
+    const data = await Promise.all(promises);
+    return str.replace(regex, () => data.shift());
+}
+
+export async function injectResourceHashes(htmlContent, currentDirectory) {
+    const regexResources = /(src|href)="([^"]+\.(js|css))"/g;
+
+    const result = await replaceAsync(htmlContent, regexResources, async (match, attr, routeResource) => {
+        const pathResource = join(currentDirectory, "src", routeResource);
+
+        if (existsSync(pathResource)) {
+            const resourceContent = await readFile(pathResource, "utf8");
+            const resourceHash = createHash("md5").update(resourceContent).digest("hex");
+            const urlConHash = injectToUrl(routeResource, resourceHash);
+            return `${attr}="${urlConHash}"`;
+        }
+        return match;
+    });
+
+    return result;
+}

package/helpers/watcher.js

@@ -0,0 +1,158 @@
+import { watch, stat } from "node:fs/promises";
+import { existsSync, mkdirSync } from "node:fs";
+import { join, extname, basename } from "node:path";
+import { hostname } from "node:os";
+import { styleText } from "node:util";
+import { compareChanges } from "./hashFingerprint.js";
+import { write } from "./writter.js";
+
+// Almacena referencias a watchers activos para poder cerrarlos desde tests
+const _activeWatchers = [];
+
+/**
+ * Cierra todos los watchers activos. Exportado para testing.
+ */
+export async function _closeActiveWatchers() {
+    const closers = [..._activeWatchers];
+    _activeWatchers.length = 0;
+    await Promise.allSettled(closers.map(c => { try { return c(); } catch {} }));
+}
+
+export const startWatcher = async (config, currentDirectory, reloadServer, abortSignal) => {
+    if (!Array.isArray(config.watchPath)) {
+        console.log(styleText("bgRed", " error ") +
+            ' watchPath debe ser un array en pulsedev.json. Ejemplo: ["*"] o ["./src/css", "./src/js"]');
+        process.exit(1);
+    }
+
+    const extensionesIgnoradas = (Array.isArray(config.ignoreExtensions)
+        ? config.ignoreExtensions
+        : []
+    ).map(ext => ext.replace("*", ""));
+
+    const isWildcard = config.watchPath.includes("*");
+
+    /**
+     * VALIDACIÓN DE CONFIGURACIÓN DE ESCUCHA (RECURSIVE)
+     * 
+     * Determinamos si el watcher debe ser recursivo basándonos en la configuración
+     * y el tipo de ruta (comodín o rutas específicas).
+     */
+    let isRecursive = config.recursive ?? true;
+
+    /**
+     * Caso 1: watchPath es wildcard ["*"] y recursive es false
+     * → Configuración inválida: el watcher solo escucharía la raíz (pulsedev.json).
+     *   Forzamos recursive: true para que detecte cambios en /src y subcarpetas.
+     */
+    if (isWildcard && config.recursive === false) {
+        console.log(
+            styleText("bgYellow", " advertencia ") +
+            " recursive: false no tiene efecto cuando watchPath es [\"*\"]." +
+            " El watcher solo escucharía la raíz del proyecto y nunca detectaría" +
+            " cambios en src/. Se usará recursive: true automáticamente." +
+            " Para usar recursive: false definí rutas específicas en watchPath," +
+            " por ejemplo: [\"./src/css\", \"./src/js\"]."
+        );
+        isRecursive = true;
+    }
+
+    /**
+     * Caso 2: watchPath tiene rutas propias y recursive es false
+     * → Configuración válida: el usuario elige vigilar solo la raíz de carpetas específicas.
+     *   Informamos al usuario que el modo no recursivo está activo.
+     */
+    if (!isWildcard && config.recursive === false) {
+        console.log(
+            styleText("bgCyan", " info ") +
+            " Modo de escucha no recursivo activo." +
+            " Solo se vigilarán los archivos en la raíz de cada ruta configurada en watchPath." +
+            " Los subdirectorios no serán vigilados."
+        );
+    }
+
+    /**
+     * Definimos las rutas absolutas a vigilar.
+     * Si es wildcard, vigilamos el directorio actual (raíz).
+     */
+    const pathToWatch = isWildcard
+        ? [currentDirectory]
+        : config.watchPath.map(p => join(currentDirectory, p));
+
+    // debounce: esperamos el tiempo configurado antes de ejecutar el reload
+    // si llegan multiples eventos seguidos, solo se ejecuta una vez al final
+    let debounceTimer = null;
+    const debounceDelay = (config.debounceDelay || 0.5) * 1000;
+
+    const triggerReload = () => {
+        clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(() => {
+            reloadServer();
+        }, debounceDelay);
+    };
+
+    for (const target of pathToWatch) {
+        // IIFE correctamente invocada con () al final
+        (async () => {
+            try {
+                // Iniciamos el watcher con el flag de recursividad validado previamente
+                // y la señal de aborto para poder cerrarlo desde tests sin dejar el event loop colgado
+                const watchOptions = { recursive: isRecursive, persistent: false };
+                if (abortSignal) watchOptions.signal = abortSignal;
+                const watcher = watch(target, watchOptions);
+
+                // Guardamos referencia para poder cerrarlo desde tests
+                _activeWatchers.push(async () => { try { await watcher.close(); } catch {} });
+
+                // Generador Asíncrono, "escupe" promesas en cada iteración del bucle
+                for await (const event of watcher) {
+                    const { filename } = event;
+                    if (!filename) continue;
+
+                    let absolutePath = join(target, filename);
+
+                    /**
+                     * si la ruta que formamos es un carpeta el fingerprint intentara leerla y fallará
+                     * debemos evitar que intente hacerlo, solo se puede leer archivos
+                     */
+                    try {
+                        const stats = await stat(absolutePath);
+                        if (stats.isDirectory()) continue;
+                    } catch (error) {
+                        continue;
+                    }
+
+                    let ext = extname(absolutePath);
+                    let name = basename(absolutePath);
+
+                    // ignorar extensiones configuradas
+                    if (extensionesIgnoradas.includes(ext)) continue;
+
+                    // ignorar archivos de log propios y archivos ocultos
+                    if (name === "requests.log" || name === "errors.log" || name.startsWith(".")) continue;
+
+                    // solo recargar si el contenido realmente cambio
+                    let hasChange = await compareChanges(absolutePath);
+
+                    if (hasChange) {
+                        console.log(styleText("bgCyan", " watcher ") + ` archivo modificado: ${filename}`);
+                        triggerReload();
+                    }
+                }
+
+            } catch (err) {
+                if (err.code === 'ENOENT' || err.name === 'AbortError') return;
+
+                if (config.outputPath === "log") {
+                    if (!existsSync(`${currentDirectory}/logs`)) {
+                        mkdirSync(join(currentDirectory, 'logs'), { recursive: true });
+                    }
+                    let messageError = `${Date.now()} - ${hostname()}/${currentDirectory}: ${err.message}`;
+                    await write(`${currentDirectory}/logs/errors.log`, messageError);
+                } else {
+                    console.error(`Error en el watcher sobre la ruta ${target}:`, err.message);
+                }
+            }
+        })(); // <- () que faltaba
+    }
+};

package/helpers/websocket.js

@@ -0,0 +1,82 @@
+import crypto from "node:crypto";
+
+const clients = new Set();
+
+export function initWebSocket(httpServer) {
+
+    /**
+     * - "upgrade" es el evento que permite cambiar el modo de comunicación del servidor
+     */
+
+    httpServer.on("upgrade", (req, socket) => {
+        // verificar que el cliente haya enviado una key
+        const key = req.headers['sec-websocket-key'];
+        if (!key) {
+            socket.destroy();
+            return;
+        }
+
+        /* hasheamos la key, le damos un secret(GUID - identificador unico global) reconocible para cualquier navegador y la escribimos en el socket
+        *  - el digest convierte el binario en ASCII
+        *  - se escribe en socket para secuestrar la conexion tcp, y convertilo en un canal bidireccional
+        */
+        const acceptKey = crypto
+            .createHash("sha1")
+            .update(key + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
+            .digest('base64')
+
+        socket.write(
+            [
+                "HTTP/1.1 101 Switching Protocols",
+                "Upgrade: websocket",
+                "Connection: Upgrade",
+                `Sec-Websocket-Accept: ${acceptKey}`,
+                "\r\n"
+            ].join("\r\n")
+        );
+
+        /**
+         * agregar el cliente al set
+         */
+        clients.add(socket);
+
+        socket.on("close", () => clients.delete(socket));
+        socket.on("error", () => clients.delete(socket));
+    });
+}
+
+export function closeAllConnections() {
+    /**
+     * Frame WebSocket de texto con payload "reload" (6 bytes).
+     * Construido manualmente:
+     *   - byte 1: 0x81 (FIN=1, opcode=1 = texto)
+     *   - byte 2: longitud del payload (sin máscara, <126)
+     *   - resto:  payload
+     * El cliente lo lee en onmessage y dispara location.reload().
+     */
+    const payload = "reload";
+    const payloadBuffer = Buffer.from(payload, "utf-8");
+    const reloadFrame = Buffer.concat([
+        Buffer.from([0x81, payloadBuffer.length]),
+        payloadBuffer
+    ]);
+
+    for (const c of clients) {
+        try {
+            c.write(reloadFrame);
+        } catch (e) {
+            // el socket puede estar ya cerrado o en estado inválido: lo destruimos igual
+        }
+        try {
+            c.destroy();
+        } catch (e) {
+            console.error("WebSocket: error al cerrar conexión:", e.message);
+        }
+    }
+    /**
+     * Limpiar el Set como garantía extra. Si un destroy() falla silenciosamente
+     * (catch vacío), el socket muerto quedaría en clients indefinidamente.
+     * clients.clear() asegura que el Set queda vacío sin importar qué.
+     */
+    clients.clear();
+}

package/helpers/writter.js

@@ -0,0 +1,85 @@
+import { styleText } from "node:util";
+import { readFile, appendFile, mkdir, writeFile as fsWriteFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { Worker } from "node:worker_threads";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+let pendingLogCheck = null;
+
+export const write = async (pathFile, text, logLimit = 5) => {
+    if (!pathFile || !text) {
+        console.log(styleText("bgCyan", " advertencia: ") + "No se ha especificado ruta.");
+        return;
+    }
+
+    try {
+        const folder = dirname(pathFile);
+
+        await mkdir(folder, { recursive: true });
+
+        await appendFile(pathFile, text + "\n", "utf-8");
+
+        if (pathFile.endsWith("requests.log")) {
+            clearTimeout(pendingLogCheck);
+            pendingLogCheck = setTimeout(() => {
+                const workerPath = join(__dirname, "counterChar.js");
+                const worker = new Worker(workerPath);
+                worker.unref();
+
+                worker.postMessage({
+                    path: pathFile,
+                    logLimit: logLimit
+                });
+
+                worker.on("error", (err) => {
+                    console.error("Error de ejecución del worker de logs: ", err.message);
+                });
+            }, 1000);
+            pendingLogCheck.unref();
+        }
+
+} catch (err) {
+        console.error(styleText("bgRed", " error crítico de escritura: ") + err.message);
+    }
+}
+
+/**
+ * Sobrescribe un archivo con el contenido dado (NO append).
+ * A diferencia de write():
+ *   - No agrega "\n" al final (escribe el contenido tal cual)
+ *   - No dispara el worker de logs
+ *   - Crea la carpeta padre si no existe
+ * Pensado para archivos de configuración completos (JSON, etc) que
+ * se reescriben enteros.
+ */
+export const writeFile = async (pathFile, content) => {
+    if (!pathFile || content === undefined || content === null) {
+        console.log(styleText("bgCyan", " advertencia: ") + "No se ha especificado ruta o contenido.");
+        return;
+    }
+
+    try {
+        const folder = dirname(pathFile);
+        await mkdir(folder, { recursive: true });
+        await fsWriteFile(pathFile, content, "utf-8");
+    } catch (err) {
+        console.error(styleText("bgRed", " error crítico de escritura: ") + err.message);
+    }
+}
+
+export const read = async (pathFile) => {
+    if (!pathFile) {
+        console.log(styleText("bgCyan", " advertencia: ") + "No se ha especificado ruta.");
+        return null;
+    }
+
+    try {
+        const file = await readFile(pathFile, "utf-8");
+        return file;
+    } catch (err) {
+        // Si el archivo no existe al intentar leerlo, devolvemos null pacíficamente
+        return null;
+    }
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@randomdev/pulsedev",
+  "version": "0.1.2",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "description": "⚡ PulseDev - Fast, native Node.js development server featuring live reload, recursive file watching, configurable debouncing, native socket for client, and comprehensive logging without production dependencies",
+  "bin": {
+    "pulsedev": "./bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "core/",
+    "helpers/",
+    "web/"
+  ],
+  "keywords": ["guard","hot-reload", "reload","server","live-server", "watcher", "dev-server", "nodejs", "frontend", "socket", "node socket"],
+  "author": "randomdev",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pabloacisera/pulsedev_linux.git"
+  },
+  "homepage": "https://github.com/pabloacisera/pulsedev_linux#readme",
+  "bugs": {
+    "url": "https://github.com/pabloacisera/pulsedev_linux/issues"
+  },
+  "type": "module",
+  "scripts": {
+    "test": "node --test tests/*.test.js",
+    "test:watch": "node --test --watch tests/*.test.js",
+    "test:hash": "node --test tests/hashFingerprint.test.js",
+    "test:writter": "node --test tests/writter.test.js",
+    "test:counter": "node --test tests/counterChar.test.js",
+    "test:server": "node --test tests/server.test.js"
+  }
+}

package/web/assets/github.svg

@@ -0,0 +1 @@
+<svg role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>GitHub</title><path d="M12 .297c-6.63 0-12 5.373-12 12 0 5.303 3.438 9.8 8.205 11.385.6.113.82-.258.82-.577 0-.285-.01-1.04-.015-2.04-3.338.724-4.042-1.61-4.042-1.61C4.422 18.07 3.633 17.7 3.633 17.7c-1.087-.744.084-.729.084-.729 1.205.084 1.838 1.236 1.838 1.236 1.07 1.835 2.809 1.305 3.495.998.108-.776.417-1.305.76-1.605-2.665-.3-5.466-1.332-5.466-5.93 0-1.31.465-2.38 1.235-3.22-.135-.303-.54-1.523.105-3.176 0 0 1.005-.322 3.3 1.23.96-.267 1.98-.399 3-.405 1.02.006 2.04.138 3 .405 2.28-1.552 3.285-1.23 3.285-1.23.645 1.653.24 2.873.12 3.176.765.84 1.23 1.91 1.23 3.22 0 4.61-2.805 5.625-5.475 5.92.42.36.81 1.096.81 2.22 0 1.606-.015 2.896-.015 3.286 0 .315.21.69.825.57C20.565 22.092 24 17.592 24 12.297c0-6.627-5.373-12-12-12"/></svg>

package/web/assets/npm.svg

@@ -0,0 +1 @@
+<svg role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>npm</title><path d="M1.763 0C.786 0 0 .786 0 1.763v20.474C0 23.214.786 24 1.763 24h20.474c.977 0 1.763-.786 1.763-1.763V1.763C24 .786 23.214 0 22.237 0zM5.13 5.323l13.837.019-.009 13.836h-3.464l.01-10.382h-3.456L12.04 19.17H5.113z"/></svg>

package/web/templates/documentation.html

@@ -0,0 +1,65 @@
+<div class="docs-content">
+    <div class="docs-header">
+        <h1>⚡ PulseDev Documentation</h1>
+        <p class="docs-subtitle">Servidor local nativo · Cero dependencias · Hot Reload</p>
+    </div>
+
+    <h2>🚀 Comenzar</h2>
+    <p>Edita los archivos dentro del directorio <code>src/</code> de tu proyecto. PulseDev detectará automáticamente cualquier cambio en el sistema de archivos y actualizará el navegador al instante.</p>
+
+    <pre><code>src/
+├── index.html       ← Punto de entrada principal
+├── css/
+│   └── index.css    ← Estilos de la aplicación
+├── js/
+│   └── index.js     ← Lógica del lado del cliente
+└── assets/          ← Recursos estáticos (imágenes, fuentes)</code></pre>
+
+    <h2>⚙️ Configuración — <code>pulsedev.json</code></h2>
+    <div class="table-container">
+        <table>
+            <thead>
+                <tr>
+                    <th>Propiedad</th>
+                    <th>Descripción</th>
+                    <th>Por defecto</th>
+                </tr>
+            </thead>
+            <tbody>
+                <tr><td><code>watchPath</code></td><td>Directorios bajo vigilancia del watcher</td><td><code>["*"]</code></td></tr>
+                <tr><td><code>runFile</code></td><td>Archivo HTML de entrada inicial</td><td><code>"index.html"</code></td></tr>
+                <tr><td><code>port</code></td><td>Puerto de escucha del servidor local</td><td><code>3003</code></td></tr>
+                <tr><td><code>outputPath</code></td><td>Destino de logs: archivo (<code>"log"</code>) o salida estándar (<code>"terminal"</code>)</td><td><code>"log"</code></td></tr>
+                <tr><td><code>ignoreExtensions</code></td><td>Filtros de exclusión para el Hot Reload</td><td><code>["*.txt","*.log","*.env","*.md"]</code></td></tr>
+                <tr><td><code>debounceDelay</code></td><td>Tiempo de espera (segundos) antes de refrescar</td><td><code>0.5</code></td></tr>
+                <tr><td><code>recursive</code></td><td>Vigilancia de subdirectorios del árbol</td><td><code>true</code></td></tr>
+                <tr><td><code>logLimit</code></td><td>Umbral máximo del archivo de logs (KB)</td><td><code>5</code></td></tr>
+            </tbody>
+        </table>
+    </div>
+
+    <h2>🖥️ Comandos disponibles</h2>
+    <pre><code>pulsedev init      # Inicializa la estructura base del proyecto
+pulsedev run       # Ejecuta el servidor de desarrollo y el watcher
+pulsedev --help    # Muestra el panel de ayuda y opciones
+pulsedev --version # Devuelve la versión instalada en el sistema</code></pre>
+
+    <h2>👁️ Hot Reload Automático</h2>
+    <p>PulseDev monitorea el estado del proyecto utilizando primitivas nativas de <code>fs.watch</code>. Al detectar una modificación, realiza una verificación mediante un hash <strong>MD5</strong> para asegurar un cambio real en el contenido, evitando falsos positivos. Las respuestas de recursos estáticos incluyen políticas dinámicas de <em>cache busting</em> para forzar la lectura del nuevo código.</p>
+
+    <h3>🔌 Infraestructura WebSocket</h3>
+    <p>El mecanismo de sincronización utiliza un canal de comunicación bidireccional mediante <strong>WebSockets</strong> de bajo overhead:</p>
+    <ol>
+        <li>El cliente inicializa y sostiene una conexión persistente contra el socket del servidor de desarrollo.</li>
+        <li>Ante una recarga del proceso del servidor, las conexiones se finalizan de manera controlada.</li>
+        <li>El script cliente captura los eventos nativos de desconexión (<code>onclose</code> / <code>onerror</code>).</li>
+        <li>Se dispara una recarga forzada en el navegador web para reflejar el último estado.</li>
+    </ol>
+
+    <h3>📝 Arquitectura de Logs</h3>
+    <p>Por omisión, las interacciones HTTP son procesadas y enviadas hacia <code>logs/requests.log</code>. Un subproceso en segundo plano (<strong>Worker Thread</strong> nativo) gestiona las tareas de rotación del archivo en función de la propiedad <code>logLimit</code>, previniendo cuellos de botella en el bucle de eventos principal.</p>
+
+    <blockquote>
+        ⚡ PulseDev · Optimizado sobre Node.js Nativo · Peso total: 1.7MB
+    </blockquote>
+</div>