xonecode 0.34.2 → 0.36.3

package/node_modules/@xone/xonecode-remoto/dist/contenido.js

@@ -0,0 +1,191 @@
+/**
+ * El contenido cifrado: un SUBCONJUNTO en lista blanca del cable de la consola web de xonecode.
+ * Las formas copian las de xonecode (`apps/web/src/tipos.ts`): si cambian allí, cambia aquí y
+ * sube `VERSION_DEL_PROTOCOLO`.
+ */
+const objeto = (x) => typeof x === "object" && x !== null && !Array.isArray(x);
+const texto = (x) => typeof x === "string";
+const noVacio = (x) => texto(x) && x.length > 0;
+const esActo = (x) => objeto(x) && texto(x.tipo);
+export function validarDelMovil(m) {
+    if (!objeto(m))
+        return undefined;
+    switch (m.clase) {
+        case "prosa":
+            if (!texto(m.texto) || m.adjuntos !== undefined)
+                return undefined;
+            if (m.detener === undefined)
+                return { clase: "prosa", texto: m.texto };
+            return m.detener === true ? { clase: "prosa", texto: m.texto, detener: true } : undefined;
+        case "decision": {
+            if (!objeto(m.decisiones))
+                return undefined;
+            const decisiones = {};
+            for (const [id, valor] of Object.entries(m.decisiones)) {
+                if (id === "__proto__")
+                    continue;
+                if (valor !== "approve" && valor !== "reject")
+                    return undefined;
+                decisiones[id] = valor;
+            }
+            if (m.consola === undefined)
+                return { clase: "decision", decisiones };
+            return noVacio(m.consola) ? { clase: "decision", decisiones, consola: m.consola } : undefined;
+        }
+        case "respuesta":
+            return texto(m.texto) && m.seleccion === undefined ? { clase: "respuesta", texto: m.texto } : undefined;
+        case "cancelar":
+            return { clase: "cancelar" };
+        case "feedback":
+            return noVacio(m.tarea) && texto(m.texto) && m.texto.trim() !== "" ? { clase: "feedback", tarea: m.tarea, texto: m.texto } : undefined;
+        case "continuar":
+            return noVacio(m.tarea) ? { clase: "continuar", tarea: m.tarea } : undefined;
+        default:
+            return undefined;
+    }
+}
+/** Pendientes, ficheros y diffs de una aprobación: la validación es UNA, la del mensaje `aprobacion` y la de cada consola del panorama. */
+function validarAprobacion(m) {
+    // Un anfitrión autenticado es de fiar en el CONTENIDO, no en la FORMA: se valida y se reconstruye.
+    if (!Array.isArray(m.pendientes) || !objeto(m.ficheros) || !objeto(m.diffs))
+        return undefined;
+    const pendientes = [];
+    for (const p of m.pendientes) {
+        if (!objeto(p) || !texto(p.id) || !texto(p.origen) || !texto(p.descripcion))
+            return undefined;
+        if (!Array.isArray(p.decisionesPermitidas) || !p.decisionesPermitidas.every(texto))
+            return undefined;
+        pendientes.push({
+            id: p.id,
+            origen: p.origen,
+            descripcion: p.descripcion,
+            decisionesPermitidas: [...p.decisionesPermitidas],
+            ...(p.remota === true ? { remota: true } : {}),
+        });
+    }
+    const ficheros = {};
+    for (const [k, v] of Object.entries(m.ficheros)) {
+        if (!texto(v))
+            return undefined;
+        ficheros[k] = v;
+    }
+    const diffs = {};
+    for (const [k, v] of Object.entries(m.diffs)) {
+        if (!Array.isArray(v))
+            return undefined;
+        const lineas = [];
+        for (const l of v) {
+            if (!objeto(l) || !texto(l.texto))
+                return undefined;
+            if (l.tipo !== "igual" && l.tipo !== "anadido" && l.tipo !== "quitado")
+                return undefined;
+            lineas.push({ tipo: l.tipo, texto: l.texto });
+        }
+        diffs[k] = lineas;
+    }
+    return { pendientes, ficheros, diffs };
+}
+const ESTADOS_DE_CONSOLA = ["trabajando", "esperando-aprobacion", "esperando-respuesta", "parada"];
+const ESTADOS_DE_TAREA = ["nuevo", "en-proceso", "requiere-atencion", "terminada"];
+/** Un campo de texto OPCIONAL: ausente vale, presente tiene que ser texto. `false` = forma mala. */
+const opcional = (x) => x === undefined || texto(x);
+function validarConsola(c) {
+    if (!objeto(c) || !texto(c.id) || !texto(c.proyecto) || typeof c.foco !== "boolean")
+        return undefined;
+    if (!texto(c.estado) || !ESTADOS_DE_CONSOLA.includes(c.estado))
+        return undefined;
+    if (!opcional(c.sesion) || !opcional(c.ultimaActividad))
+        return undefined;
+    let aprobacion;
+    if (c.aprobacion !== undefined) {
+        if (!objeto(c.aprobacion))
+            return undefined;
+        const a = validarAprobacion(c.aprobacion);
+        if (!a)
+            return undefined;
+        if (c.aprobacion.recortada !== undefined && c.aprobacion.recortada !== true)
+            return undefined;
+        aprobacion = { ...a, ...(c.aprobacion.recortada === true ? { recortada: true } : {}) };
+    }
+    return {
+        id: c.id,
+        proyecto: c.proyecto,
+        ...(texto(c.sesion) ? { sesion: c.sesion } : {}),
+        foco: c.foco,
+        estado: c.estado,
+        ...(texto(c.ultimaActividad) ? { ultimaActividad: c.ultimaActividad } : {}),
+        ...(aprobacion ? { aprobacion } : {}),
+    };
+}
+function validarTarea(t) {
+    if (!objeto(t) || !texto(t.id) || !texto(t.titulo) || !texto(t.proyecto) || !texto(t.creada))
+        return undefined;
+    if (!texto(t.estado) || !ESTADOS_DE_TAREA.includes(t.estado))
+        return undefined;
+    if (!opcional(t.tras) || !opcional(t.motivo) || !opcional(t.acabada))
+        return undefined;
+    return {
+        id: t.id,
+        titulo: t.titulo,
+        proyecto: t.proyecto,
+        estado: t.estado,
+        ...(texto(t.tras) ? { tras: t.tras } : {}),
+        ...(texto(t.motivo) ? { motivo: t.motivo } : {}),
+        creada: t.creada,
+        ...(texto(t.acabada) ? { acabada: t.acabada } : {}),
+    };
+}
+export function validarDelAnfitrion(m) {
+    if (!objeto(m))
+        return undefined;
+    switch (m.clase) {
+        // El contenido de los actos pasa tal cual lo mandó el anfitrión, a propósito: la interfaz lo pinta como texto.
+        case "acto":
+        case "sustitucion":
+            return esActo(m.acto) ? { clase: m.clase, acto: m.acto } : undefined;
+        case "reemision":
+            return Array.isArray(m.actos) && m.actos.every(esActo) ? { clase: "reemision", actos: m.actos } : undefined;
+        case "aprobacion": {
+            const a = validarAprobacion(m);
+            return a ? { clase: "aprobacion", ...a } : undefined;
+        }
+        case "pregunta":
+            // El móvil solo contesta TEXTO: una pregunta con forma de decisión (plan, casillas, selector) no se le reenvía.
+            if (m.decision !== undefined || m.seleccionable !== undefined || m.selector !== undefined)
+                return undefined;
+            return texto(m.texto) ? { clase: "pregunta", texto: m.texto } : undefined;
+        case "turno":
+            if (typeof m.activo !== "boolean")
+                return undefined;
+            return m.detenible === true ? { clase: "turno", activo: m.activo, detenible: true } : { clase: "turno", activo: m.activo };
+        case "remoto.estado":
+            return {
+                clase: "remoto.estado",
+                ...(texto(m.proyecto) ? { proyecto: m.proyecto } : {}),
+                ...(texto(m.sesion) ? { sesion: m.sesion } : {}),
+            };
+        case "panorama": {
+            if (!Array.isArray(m.consolas) || !Array.isArray(m.tareas))
+                return undefined;
+            if (typeof m.esperando !== "number" || !Number.isFinite(m.esperando) || m.esperando < 0)
+                return undefined;
+            const consolas = [];
+            for (const c of m.consolas) {
+                const v = validarConsola(c);
+                if (!v)
+                    return undefined;
+                consolas.push(v);
+            }
+            const tareas = [];
+            for (const t of m.tareas) {
+                const v = validarTarea(t);
+                if (!v)
+                    return undefined;
+                tareas.push(v);
+            }
+            return { clase: "panorama", consolas, tareas, esperando: m.esperando };
+        }
+        default:
+            return undefined;
+    }
+}

package/node_modules/@xone/xonecode-remoto/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./version.js";
+export * from "./base64url.js";
+export * from "./url.js";
+export * from "./sobre.js";
+export * from "./cifrado.js";
+export * from "./contenido.js";

package/node_modules/@xone/xonecode-remoto/dist/index.js

@@ -0,0 +1,6 @@
+export * from "./version.js";
+export * from "./base64url.js";
+export * from "./url.js";
+export * from "./sobre.js";
+export * from "./cifrado.js";
+export * from "./contenido.js";

package/node_modules/@xone/xonecode-remoto/dist/servidor/salas.d.ts

@@ -0,0 +1,46 @@
+import { type SobreDelServidor } from "../index.js";
+export interface Topes {
+    movilesPorSala: number;
+    bytesPorMensaje: number;
+    /** Ritmo sostenido de un MÓVIL (y de toda conexión antes de su primer mensaje). */
+    mensajesPorMinuto: number;
+    /**
+     * Ritmo sostenido de un ANFITRIÓN. xonecode manda una `sustitucion` cada 80 ms mientras el modelo
+     * escribe (unas 750 por minuto, hasta el doble con razonamiento): con el tope del móvil se cortaría.
+     */
+    mensajesPorMinutoAnfitrion: number;
+    graciaMs: number;
+}
+export declare const TOPES_POR_OMISION: Topes;
+type Enviar = (sobre: SobreDelServidor) => void;
+/** Salas en memoria: empareja y enruta. No sabe nada de lo que va dentro de `carga`. */
+export declare class Salas {
+    private readonly topes;
+    private readonly ahora;
+    private readonly nuevoId;
+    private readonly salas;
+    constructor(topes: Topes, ahora?: () => number, nuevoId?: () => string);
+    /** Todo envío pasa por aquí: un socket roto no puede cortar un bucle ni dejar una sala sin borrar. */
+    private emitir;
+    existe(sala: string): boolean;
+    /**
+     * Supuesto: no hay prueba de identidad del anfitrión durante la gracia. El id de sala solo lo
+     * conocen el relé y quien tiene la URL de la sesión, que ya controla la sesión por diseño; el
+     * cifrado extremo a extremo impide leer o falsificar nada. Lo peor es una denegación de servicio
+     * durante la gracia.
+     */
+    abrir(sala: string, enviar: Enviar): boolean;
+    entrar(sala: string, enviar: Enviar): string | undefined;
+    salir(sala: string, id: string): void;
+    datoDelAnfitrion(sala: string, para: string | undefined, carga: string): void;
+    /** Solo de un móvil que SIGUE en la sala: uno de una sala ya cerrada no llega a quien reabra el mismo id. */
+    datoDelMovil(sala: string, id: string, carga: string): void;
+    /** Solo vale si `enviar` es el anfitrión actual: el cierre tardío de uno viejo no echa al nuevo. */
+    anfitrionCaido(sala: string, enviar: Enviar): void;
+    /** Cierre pedido por el anfitrión actual; con otro `enviar` no hace nada. */
+    cerrar(sala: string, enviar: Enviar): void;
+    private expulsar;
+    /** Cierra las salas cuyo anfitrión lleva caído más que la gracia. Se llama periódicamente. */
+    barrer(): void;
+}
+export {};

package/node_modules/@xone/xonecode-remoto/dist/servidor/salas.js

@@ -0,0 +1,128 @@
+import { TOPE_DE_SOBRE } from "../index.js";
+export const TOPES_POR_OMISION = {
+    movilesPorSala: 5,
+    bytesPorMensaje: TOPE_DE_SOBRE,
+    mensajesPorMinuto: 600,
+    mensajesPorMinutoAnfitrion: 6000,
+    graciaMs: 300_000,
+};
+/** Salas en memoria: empareja y enruta. No sabe nada de lo que va dentro de `carga`. */
+export class Salas {
+    topes;
+    ahora;
+    nuevoId;
+    salas = new Map();
+    constructor(topes, ahora = Date.now, nuevoId = () => crypto.randomUUID()) {
+        this.topes = topes;
+        this.ahora = ahora;
+        this.nuevoId = nuevoId;
+    }
+    /** Todo envío pasa por aquí: un socket roto no puede cortar un bucle ni dejar una sala sin borrar. */
+    emitir(enviar, sobre) {
+        if (enviar === undefined)
+            return;
+        try {
+            enviar(sobre);
+        }
+        catch {
+            // se ignora: la conexión rota la limpia su propio cierre
+        }
+    }
+    existe(sala) {
+        return this.salas.has(sala);
+    }
+    /**
+     * Supuesto: no hay prueba de identidad del anfitrión durante la gracia. El id de sala solo lo
+     * conocen el relé y quien tiene la URL de la sesión, que ya controla la sesión por diseño; el
+     * cifrado extremo a extremo impide leer o falsificar nada. Lo peor es una denegación de servicio
+     * durante la gracia.
+     */
+    abrir(sala, enviar) {
+        const existente = this.salas.get(sala);
+        if (existente !== undefined && existente.anfitrion !== undefined) {
+            this.emitir(enviar, { t: "error", motivo: "sala-ocupada" });
+            return false;
+        }
+        const s = existente ?? { anfitrion: undefined, caidoDesde: undefined, moviles: new Map() };
+        s.anfitrion = enviar;
+        s.caidoDesde = undefined;
+        this.salas.set(sala, s);
+        this.emitir(enviar, { t: "abierta" });
+        if (s.moviles.size > 0) {
+            this.emitir(enviar, { t: "presencia", moviles: [...s.moviles.keys()] });
+            for (const movil of s.moviles.values())
+                this.emitir(movil, { t: "anfitrion", conectado: true });
+        }
+        return true;
+    }
+    entrar(sala, enviar) {
+        const s = this.salas.get(sala);
+        if (s === undefined) {
+            this.emitir(enviar, { t: "error", motivo: "sala-inexistente" });
+            return undefined;
+        }
+        if (s.moviles.size >= this.topes.movilesPorSala) {
+            this.emitir(enviar, { t: "error", motivo: "tope-de-moviles" });
+            return undefined;
+        }
+        const id = this.nuevoId();
+        s.moviles.set(id, enviar);
+        this.emitir(enviar, { t: "entrada", id });
+        this.emitir(enviar, { t: "anfitrion", conectado: s.anfitrion !== undefined });
+        this.emitir(s.anfitrion, { t: "presencia", moviles: [...s.moviles.keys()] });
+        return id;
+    }
+    salir(sala, id) {
+        const s = this.salas.get(sala);
+        if (s === undefined || !s.moviles.delete(id))
+            return;
+        this.emitir(s.anfitrion, { t: "presencia", moviles: [...s.moviles.keys()] });
+    }
+    datoDelAnfitrion(sala, para, carga) {
+        const s = this.salas.get(sala);
+        if (s === undefined)
+            return;
+        if (para !== undefined) {
+            this.emitir(s.moviles.get(para), { t: "dato", carga });
+            return;
+        }
+        for (const movil of s.moviles.values())
+            this.emitir(movil, { t: "dato", carga });
+    }
+    /** Solo de un móvil que SIGUE en la sala: uno de una sala ya cerrada no llega a quien reabra el mismo id. */
+    datoDelMovil(sala, id, carga) {
+        const s = this.salas.get(sala);
+        if (s === undefined || !s.moviles.has(id))
+            return;
+        this.emitir(s.anfitrion, { t: "dato", de: id, carga });
+    }
+    /** Solo vale si `enviar` es el anfitrión actual: el cierre tardío de uno viejo no echa al nuevo. */
+    anfitrionCaido(sala, enviar) {
+        const s = this.salas.get(sala);
+        if (s === undefined || s.anfitrion !== enviar)
+            return;
+        s.anfitrion = undefined;
+        s.caidoDesde = this.ahora();
+        for (const movil of s.moviles.values())
+            this.emitir(movil, { t: "anfitrion", conectado: false });
+    }
+    /** Cierre pedido por el anfitrión actual; con otro `enviar` no hace nada. */
+    cerrar(sala, enviar) {
+        const s = this.salas.get(sala);
+        if (s === undefined || s.anfitrion !== enviar)
+            return;
+        this.expulsar(sala, s);
+    }
+    expulsar(sala, s) {
+        for (const movil of s.moviles.values())
+            this.emitir(movil, { t: "cerrada" });
+        this.salas.delete(sala);
+    }
+    /** Cierra las salas cuyo anfitrión lleva caído más que la gracia. Se llama periódicamente. */
+    barrer() {
+        for (const [sala, s] of this.salas) {
+            if (s.caidoDesde !== undefined && this.ahora() - s.caidoDesde > this.topes.graciaMs)
+                this.expulsar(sala, s);
+        }
+    }
+}

package/node_modules/@xone/xonecode-remoto/dist/servidor/servidor.d.ts

@@ -0,0 +1,31 @@
+import { type Topes } from "./salas.js";
+export interface OpcionesDelServidor {
+    puerto: number;
+    /** Dirección de escucha; por omisión solo loopback. */
+    host?: string;
+    /** La web móvil; por omisión la que viaja en el paquete (`web/`, relativa a este módulo). */
+    carpetaWeb?: string;
+    topes?: Topes;
+    /** Periodo del barrido y del ping de latido; por omisión 10 s. */
+    latidoMs?: number;
+    /** Plazo para el primer `abrir`/`entrar` válido; por omisión `PLAZO_PRIMER_MENSAJE_MS`. */
+    plazoPrimerMensajeMs?: number;
+    /** El reloj (ms) del ritmo y de la gracia de las salas; por omisión `Date.now`. Solo para los tests. */
+    ahora?: () => number;
+}
+/**
+ * Un cubo de fichas por conexión: cabe un minuto de ritmo y se rellena a ese ritmo, sin ventanas
+ * fijas que dejen pasar el doble a caballo del cambio de minuto. El tope lo da el papel de la
+ * conexión en cada mensaje, así que al pasar a anfitrión se rellena a su ritmo.
+ */
+export declare function crearCubo(ahora: () => number, inicial: number): {
+    /** Gasta una ficha si la hay; `false` es que se ha pasado del ritmo. */
+    gastar(porMinuto: number): boolean;
+};
+export declare const PLAZO_PRIMER_MENSAJE_MS = 10000;
+export interface ServidorEnMarcha {
+    urlHttp: string;
+    urlWs: string;
+    cerrar(): Promise<void>;
+}
+export declare function arrancarServidor(opciones: OpcionesDelServidor): Promise<ServidorEnMarcha>;

package/node_modules/@xone/xonecode-remoto/dist/servidor/servidor.js

@@ -0,0 +1,198 @@
+import { createServer } from "node:http";
+import { readFile } from "node:fs/promises";
+import { extname, join, normalize } from "node:path";
+import { fileURLToPath } from "node:url";
+import { WebSocketServer } from "ws";
+import { FORMA_DE_SALA, VERSION_DEL_PROTOCOLO, interpretarSobre } from "../index.js";
+import { Salas, TOPES_POR_OMISION } from "./salas.js";
+/** `dist/servidor/` y `src/servidor/` están a la misma profundidad de `web/`, que `npm run build` copia de la web. */
+const CARPETA_WEB_DEL_PAQUETE = fileURLToPath(new URL("../../web/", import.meta.url));
+/**
+ * Un cubo de fichas por conexión: cabe un minuto de ritmo y se rellena a ese ritmo, sin ventanas
+ * fijas que dejen pasar el doble a caballo del cambio de minuto. El tope lo da el papel de la
+ * conexión en cada mensaje, así que al pasar a anfitrión se rellena a su ritmo.
+ */
+export function crearCubo(ahora, inicial) {
+    let fichas = inicial;
+    let desde = ahora();
+    return {
+        /** Gasta una ficha si la hay; `false` es que se ha pasado del ritmo. */
+        gastar(porMinuto) {
+            const t = ahora();
+            fichas = Math.min(porMinuto, fichas + (Math.max(0, t - desde) * porMinuto) / 60_000);
+            desde = t;
+            if (fichas < 1)
+                return false;
+            fichas -= 1;
+            return true;
+        },
+    };
+}
+export const PLAZO_PRIMER_MENSAJE_MS = 10_000;
+const TIPOS = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".woff2": "font/woff2",
+    ".json": "application/json",
+};
+async function servirEstatico(carpeta, peticion, respuesta) {
+    const ruta = new URL(peticion.url ?? "/", "http://x").pathname;
+    if (ruta === "/salud") {
+        respuesta.writeHead(200, { "content-type": "text/plain" }).end("ok");
+        return;
+    }
+    // Toda URL de sesión sirve la misma página: la sala la lee la web, el secreto está en el fragmento.
+    const relativa = ruta === "/" || ruta.startsWith("/r/") ? "index.html" : normalize(ruta).replace(/^(\.\.[/\\])+/, "").replace(/^[/\\]+/, "");
+    try {
+        const cuerpo = await readFile(join(carpeta, relativa));
+        respuesta.writeHead(200, {
+            "content-type": TIPOS[extname(relativa)] ?? "application/octet-stream",
+            "x-content-type-options": "nosniff",
+            "referrer-policy": "no-referrer",
+            ...(relativa === "index.html" ? { "cache-control": "no-store" } : {}),
+        });
+        respuesta.end(cuerpo);
+    }
+    catch {
+        respuesta.writeHead(404).end();
+    }
+}
+export async function arrancarServidor(opciones) {
+    const topes = opciones.topes ?? TOPES_POR_OMISION;
+    const ahora = opciones.ahora ?? Date.now;
+    const salas = new Salas(topes, ahora);
+    const carpetaWeb = opciones.carpetaWeb ?? CARPETA_WEB_DEL_PAQUETE;
+    const http = createServer((peticion, respuesta) => void servirEstatico(carpetaWeb, peticion, respuesta));
+    const wss = new WebSocketServer({ server: http, path: "/ws", maxPayload: topes.bytesPorMensaje });
+    const vivos = new WeakMap();
+    const barrido = setInterval(() => {
+        salas.barrer();
+        for (const c of wss.clients) {
+            if (vivos.get(c) === false)
+                c.terminate();
+            else {
+                vivos.set(c, false);
+                c.ping();
+            }
+        }
+    }, opciones.latidoMs ?? 10_000);
+    barrido.unref();
+    wss.on("connection", (ws) => {
+        let papel;
+        let cerrando = false;
+        const cortar = () => {
+            cerrando = true;
+            ws.close();
+        };
+        const enviar = (s) => {
+            if (ws.readyState === ws.OPEN)
+                ws.send(JSON.stringify(s));
+            // `cerrada` es lo último que oye un móvil: su sala ya no existe, y un socket que sigue abierto es un zombi.
+            if (s.t === "cerrada")
+                cortar();
+        };
+        vivos.set(ws, true);
+        ws.on("pong", () => vivos.set(ws, true));
+        const plazo = setTimeout(() => {
+            if (papel === undefined)
+                ws.terminate();
+        }, opciones.plazoPrimerMensajeMs ?? PLAZO_PRIMER_MENSAJE_MS);
+        plazo.unref();
+        // Hasta su primer mensaje nadie sabe qué es: va con el tope del móvil, el más estrecho.
+        const cubo = crearCubo(ahora, topes.mensajesPorMinuto);
+        ws.on("message", (datos) => {
+            if (cerrando || ws.readyState !== ws.OPEN)
+                return;
+            if (!cubo.gastar(papel?.tipo === "anfitrion" ? topes.mensajesPorMinutoAnfitrion : topes.mensajesPorMinuto)) {
+                enviar({ t: "error", motivo: "ritmo" });
+                cortar();
+                return;
+            }
+            const texto = String(datos);
+            if (papel === undefined) {
+                const comoAnfitrion = interpretarSobre(texto, "anfitrion");
+                const comoMovil = interpretarSobre(texto, "movil");
+                const inicio = comoAnfitrion?.t === "abrir" ? comoAnfitrion : comoMovil?.t === "entrar" ? comoMovil : undefined;
+                if (inicio === undefined) {
+                    enviar({ t: "error", motivo: "mensaje-ilegible" });
+                    return;
+                }
+                if (inicio.v !== VERSION_DEL_PROTOCOLO) {
+                    enviar({ t: "error", motivo: "version" });
+                    cortar();
+                    return;
+                }
+                if (!FORMA_DE_SALA.test(inicio.sala)) {
+                    enviar({ t: "error", motivo: "mensaje-ilegible" });
+                    cortar();
+                    return;
+                }
+                if (inicio.t === "abrir") {
+                    if (salas.abrir(inicio.sala, enviar))
+                        papel = { tipo: "anfitrion", sala: inicio.sala };
+                    else
+                        cortar();
+                }
+                else {
+                    const id = salas.entrar(inicio.sala, enviar);
+                    if (id !== undefined)
+                        papel = { tipo: "movil", sala: inicio.sala, id };
+                    else
+                        cortar();
+                }
+                return;
+            }
+            if (papel.tipo === "anfitrion") {
+                const s = interpretarSobre(texto, "anfitrion");
+                if (s?.t === "dato")
+                    salas.datoDelAnfitrion(papel.sala, s.para, s.carga);
+                else if (s?.t === "cerrar") {
+                    salas.cerrar(papel.sala, enviar);
+                    papel = undefined;
+                    cortar();
+                }
+                else
+                    enviar({ t: "error", motivo: "mensaje-ilegible" });
+                return;
+            }
+            const s = interpretarSobre(texto, "movil");
+            if (s?.t === "dato")
+                salas.datoDelMovil(papel.sala, papel.id, s.carga);
+            else
+                enviar({ t: "error", motivo: "mensaje-ilegible" });
+        });
+        // Un mensaje mayor que el tope emite `error` en el socket del servidor; sin oyente tumbaría el proceso.
+        // `ws` ya ha empezado el cierre con su código (1009 para el tamaño, `TOPE_DE_SOBRE`): terminar aquí
+        // cortaría el TCP antes de mandar ese marco y el cliente vería un 1006 sin motivo. Solo se termina
+        // lo que siga abierto; el cierre en curso lo remata el propio plazo de `ws`.
+        ws.on("error", () => {
+            cerrando = true;
+            if (ws.readyState === ws.OPEN)
+                ws.terminate();
+        });
+        ws.on("close", () => {
+            clearTimeout(plazo);
+            if (papel?.tipo === "anfitrion")
+                salas.anfitrionCaido(papel.sala, enviar);
+            if (papel?.tipo === "movil")
+                salas.salir(papel.sala, papel.id);
+        });
+    });
+    await new Promise((resolver) => http.listen(opciones.puerto, opciones.host ?? "127.0.0.1", resolver));
+    const direccion = http.address();
+    const puerto = typeof direccion === "object" && direccion !== null ? direccion.port : opciones.puerto;
+    return {
+        urlHttp: `http://127.0.0.1:${puerto}`,
+        urlWs: `ws://127.0.0.1:${puerto}/ws`,
+        cerrar: async () => {
+            clearInterval(barrido);
+            for (const c of wss.clients)
+                c.terminate();
+            await new Promise((r) => wss.close(() => r()));
+            await new Promise((r) => http.close(() => r()));
+        },
+    };
+}

package/node_modules/@xone/xonecode-remoto/dist/sobre.d.ts

@@ -0,0 +1,53 @@
+/**
+ * El tope de un sobre en BYTES, tal como viaja (el JSON entero del sobre). Quien manda tiene que
+ * mantener cada sobre por debajo: la carga va cifrada (AES-GCM) y en base64url, que suman en torno a
+ * un 33 % al contenido en claro. Por encima, el relé no contesta con un `error`: cierra el socket con
+ * el código 1009 de WebSocket (mensaje demasiado grande).
+ */
+export declare const TOPE_DE_SOBRE = 1000000;
+export type MotivoDeError = "version" | "sala-inexistente" | "sala-ocupada" | "tope-de-moviles" | "ritmo" | "mensaje-ilegible";
+export type SobreDelAnfitrion = {
+    t: "abrir";
+    sala: string;
+    v: number;
+} | {
+    t: "dato";
+    para?: string;
+    carga: string;
+} | {
+    t: "cerrar";
+};
+export type SobreDelMovil = {
+    t: "entrar";
+    sala: string;
+    v: number;
+} | {
+    t: "dato";
+    carga: string;
+};
+export type SobreDelServidor = {
+    t: "abierta";
+} | {
+    t: "entrada";
+    id: string;
+} | {
+    t: "presencia";
+    moviles: string[];
+} | {
+    t: "anfitrion";
+    conectado: boolean;
+} | {
+    t: "dato";
+    de?: string;
+    carga: string;
+} | {
+    t: "error";
+    motivo: MotivoDeError;
+} | {
+    t: "cerrada";
+};
+type Lado = "anfitrion" | "movil" | "servidor";
+type SobreDe<L extends Lado> = L extends "anfitrion" ? SobreDelAnfitrion : L extends "movil" ? SobreDelMovil : SobreDelServidor;
+/** Lee un sobre de un lado. Lo que no tiene exactamente una forma permitida es `undefined`. */
+export declare function interpretarSobre<L extends Lado>(texto: string, lado: L): SobreDe<L> | undefined;
+export {};