xonecode 0.26.1 → 0.28.0

package/dist/core/codificacion.js

@@ -0,0 +1,134 @@
+/**
+ * La codificación de un fichero de texto del proyecto, en las dos direcciones, con UNA tabla por
+ * juego de caracteres.
+ *
+ * Los proyectos XOne traen sus `.xne` en UTF-8 o en ISO-8859 (`<?xml … encoding="iso-8859-15"?>`,
+ * lo que emiten las plantillas de la skill). XOne los lee según ese `encoding=`, así que guardarlos
+ * en otra codificación rompería cada tilde sin un error que leer: un bug mudo, y el mismo que la
+ * skill nombra como «encoding incoherente». Lo que hace falta es escribir en la codificación que el
+ * fichero YA tenía, o la que DECLARA si todavía no la delatan sus bytes.
+ *
+ * Dos tablas de 8 bits, y se elige UNA por fichero en las dos direcciones —leer con una y escribir
+ * con otra movería caracteres—:
+ * - `iso-8859-15` si el prólogo lo declara: el € en 0xA4.
+ * - `windows-1252` en todo lo demás (lo que `TextDecoder("latin1")` es en WHATWG): el € en 0x80, y
+ *   los cinco bytes que windows-1252 no define salen como el control C1 del mismo número.
+ * Cada codificador se CONSTRUYE invirtiendo su decodificador byte a byte, no se copia de una tabla:
+ * así la ida y vuelta es exacta por construcción, C1 incluidos.
+ *
+ * Puro: `Uint8Array` y `TextDecoder`, sin `Buffer` ni disco.
+ */
+function construir(etiqueta) {
+    const decodificador = new TextDecoder(etiqueta);
+    const byteDe = new Map();
+    for (let byte = 0; byte < 256; byte++) {
+        byteDe.set(decodificador.decode(Uint8Array.of(byte)).codePointAt(0), byte);
+    }
+    return { decodificar: (bytes) => decodificador.decode(bytes), byteDe };
+}
+/** Se construyen una vez, al cargar el módulo. `latin1` es la etiqueta que usaba ya la lectura. */
+const TABLAS = {
+    "windows-1252": construir("latin1"),
+    "iso-8859-15": construir("iso-8859-15"),
+};
+/** Bytes de 8 bits → texto, con la tabla del fichero. */
+export function decodificar8Bits(bytes, tabla) {
+    return TABLAS[tabla].decodificar(bytes);
+}
+/**
+ * Texto → bytes de 8 bits, o el PRIMER carácter que no cabe. Nunca se sustituye por `?`: un `?` en
+ * lugar de una letra es otra forma del bug mudo. Se recorre por CODE POINT, así que un emoji (dos
+ * unidades UTF-16) se nombra entero.
+ */
+export function codificar8Bits(texto, tabla) {
+    const byteDe = TABLAS[tabla].byteDe;
+    const bytes = new Uint8Array(texto.length);
+    let n = 0;
+    let linea = 1;
+    for (const caracter of texto) {
+        const byte = byteDe.get(caracter.codePointAt(0));
+        if (byte === undefined)
+            return { caracter, linea };
+        if (caracter === "\n")
+            linea++;
+        bytes[n++] = byte;
+    }
+    return { bytes: bytes.subarray(0, n) };
+}
+/** Cómo se NOMBRA la tabla en un mensaje para una persona o para el agente. */
+export function nombreDeTabla(tabla) {
+    return tabla === "iso-8859-15" ? "ISO-8859-15" : "Latin-1";
+}
+/**
+ * La codificación que DECLARA el prólogo XML, mirada como la mira `xone-linter`
+ * (`XmlParser.js#detectEncoding`): la cabeza del texto, `<?xml … encoding="…"`, y «8859-15» antes
+ * que «8859-1» (que lo contiene). Lo que no es un prólogo al principio —sin contar el BOM y los
+ * blancos— no declara nada, y una codificación que no sabemos escribir tampoco.
+ */
+export function codificacionDeclarada(cabeza) {
+    const m = /^?\s*<\?xml[^?]*?encoding\s*=\s*["']([^"']+)["']/i.exec(cabeza.slice(0, 256));
+    if (m === null)
+        return undefined;
+    const declarada = m[1].toLowerCase();
+    if (declarada.includes("8859-15") || declarada === "latin-9" || declarada === "latin9")
+        return "iso-8859-15";
+    if (declarada.includes("8859-1") || declarada === "latin1" || declarada === "latin-1" || declarada.includes("1252")) {
+        return "windows-1252";
+    }
+    if (declarada === "utf-8" || declarada === "utf8")
+        return "utf-8";
+    return undefined;
+}
+/** La tabla de 8 bits de unos bytes que NO son UTF-8: la que declare su prólogo, o windows-1252. */
+export function tablaDeLosBytes(bytes) {
+    // La cabeza se mira byte a byte (como `latin1`): el prólogo es ASCII en cualquier tabla.
+    const cabeza = decodificar8Bits(bytes.subarray(0, 256), "windows-1252");
+    return codificacionDeclarada(cabeza) === "iso-8859-15" ? "iso-8859-15" : "windows-1252";
+}
+/** UTF-8 ESTRICTO, el mismo criterio que la lectura para decidir que un fichero no lo es. */
+export function esUtf8Valido(bytes) {
+    try {
+        new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function esAscii(bytes) {
+    return bytes.every((b) => b < 0x80);
+}
+/**
+ * En qué bytes se guarda `texto` sobre lo que hay (`actual`, ausente si el fichero es NUEVO). En
+ * orden:
+ * 1. Lo que ya no es UTF-8 sigue en 8 bits: con la tabla que declare lo que se escribe, si declara
+ *    una de 8 bits (la que usará la próxima lectura), o si no con la de sus bytes (`tablaDeLosBytes`).
+ * 2. Un UTF-8 con algo que no es ASCII se queda en UTF-8: nunca se transcodifica lo que nadie tocó.
+ * 3. Un ASCII puro —que es UTF-8 válido y no delata nada— o un fichero nuevo siguen lo que DECLARE el
+ *    texto que se escribe; sin declaración, UTF-8. Es el caso de toda colección nueva con la
+ *    plantilla de la skill (`encoding="iso-8859-15"`): sin esto, su primera tilde iba en UTF-8 bajo
+ *    una declaración de 8 bits.
+ */
+export function codificacionParaEscribir(actual, texto) {
+    if (actual !== undefined && !esUtf8Valido(actual)) {
+        // Si lo que se escribe CAMBIA la declaración a otra tabla de 8 bits, manda la nueva: es con la
+        // que se volverá a leer, y escribir con la vieja dejaría un € en 0x80 leído luego como control.
+        const declarada = codificacionDeclarada(texto);
+        return declarada !== undefined && declarada !== "utf-8" ? declarada : tablaDeLosBytes(actual);
+    }
+    if (actual !== undefined && !esAscii(actual))
+        return "utf-8";
+    return codificacionDeclarada(texto) ?? "utf-8";
+}
+/**
+ * Bytes de un texto del proyecto → el texto que ve el AGENTE: UTF-8 si lo es (con el BOM dentro,
+ * como `readFile(…, "utf8")`, que es lo que hace la librería), y si no, su tabla de 8 bits. Es lo
+ * que tiene que leer cualquiera que compare contra lo que el agente leyó —el ANTES de la tarjeta de
+ * aprobación—: con UTF-8 a secas, un ancla con tilde no calzaba y cada línea con tilde salía cambiada.
+ */
+export function decodificarComoTexto(bytes) {
+    return esUtf8Valido(bytes)
+        ? new TextDecoder("utf-8", { ignoreBOM: true }).decode(bytes)
+        : decodificar8Bits(bytes, tablaDeLosBytes(bytes));
+}
+//# sourceMappingURL=codificacion.js.map

package/dist/core/codificacion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codificacion.js","sourceRoot":"","sources":["../../src/core/codificacion.ts"],"names":[],"mappings":"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"}

package/dist/core/recargaEnCaliente.js

@@ -0,0 +1,114 @@
+/**
+ * Qué hace el aparato con un fichero recién guardado en el editor: la regla de la recarga en
+ * caliente, pura.
+ *
+ * La regla es la de `skills/xone-hotswap/scripts/xone-recargar-android`, MEDIDA contra el
+ * framework 5.0.5.5dev, y no se inventa una nueva:
+ *
+ *   colección (`.xne` con `<coll`)  →  `uploadFile` + `loadCollection`: se repinta en el acto. Solo
+ *                                      en memoria, y por eso se sube también a disco — sin eso,
+ *                                      relanzar la app la devuelve a la versión anterior.
+ *   JavaScript (`.js`)              →  `uploadFile` + `loadIncludeFile` con `compile: true`.
+ *   CSS, `.ini`, `app.xml`, un `.xne` sin colección (mappings)
+ *                                   →  `uploadFile`, y hace falta RELANZAR la app. Medido:
+ *                                      `setCssAttribute`, `relayout` y `refresh` contestan
+ *                                      `result:true` y no cambian nada.
+ *   todo lo demás (iconos, `bd/`, `files/`)  →  no se recarga: lo lleva el despliegue entero.
+ *
+ * **Relanzar no se hace solo**: se pierde el estado de la pantalla en que está la persona, así
+ * que lo que se devuelve es «hace falta relanzar» y la pantalla lo OFRECE.
+ */
+import { decodificarComoTexto, esUtf8Valido, tablaDeLosBytes } from "./codificacion.js";
+/** Las extensiones que el aparato sabe tomar sueltas. Las mismas del script. */
+const EXTENSIONES = new Set([".xne", ".js", ".css", ".ini", ".xml"]);
+/** Carpetas que nunca viajan sueltas. Las mismas del script. */
+const FUERA = ["bd", "files", "icons"];
+/** Una colección se declara con `<coll`: lo mismo que mira el script, sobre la cabeza del texto. */
+const DECLARA_COLECCION = /<coll[\s>/]/;
+function extension(ruta) {
+    const nombre = ruta.slice(ruta.lastIndexOf("/") + 1);
+    const punto = nombre.lastIndexOf(".");
+    return punto <= 0 ? "" : nombre.slice(punto).toLowerCase();
+}
+/**
+ * Cómo se aplica `ruta` (relativa, con `/`) con estos `bytes`. El texto se mira byte a byte: la
+ * etiqueta `<coll` es ASCII en cualquier tabla.
+ */
+export function claseDeRecarga(ruta, bytes) {
+    const limpia = ruta.replace(/^\/+/, "");
+    if (FUERA.some((f) => limpia === f || limpia.startsWith(`${f}/`)))
+        return "no-aplica";
+    const ext = extension(limpia);
+    if (!EXTENSIONES.has(ext))
+        return "no-aplica";
+    if (ext === ".js")
+        return "js";
+    if (ext === ".xne") {
+        let cabeza = "";
+        for (const b of bytes)
+            cabeza += String.fromCharCode(b);
+        return DECLARA_COLECCION.test(cabeza) ? "coleccion" : "relanzar";
+    }
+    return "relanzar";
+}
+/**
+ * El nombre de la codificación que se le dice al framework para que lea ESTOS bytes. Es la misma
+ * regla que la lectura del agente y del editor (`core/codificacion.ts`): UTF-8 si lo es; si no, la
+ * tabla de 8 bits que declare el prólogo (ISO-8859-15) o windows-1252. Mandar `UTF-8` a secas
+ * —lo que hace el script— enseñaba en el aparato un «�» en cada tilde de un `.xne` Latin-1.
+ * Los nombres son los de `java.nio.charset`, que es quien los lee al otro lado.
+ */
+export function codificacionParaElAparato(bytes) {
+    if (esUtf8Valido(bytes))
+        return "UTF-8";
+    return tablaDeLosBytes(bytes) === "iso-8859-15" ? "ISO-8859-15" : "windows-1252";
+}
+/**
+ * Lo que se le da a `loadCollection`: el MISMO XML, en UTF-8 y con el prólogo diciendo UTF-8.
+ *
+ * MEDIDO en el emulador (framework 5.0.5.5dev) con un `.xne` en ISO-8859-15 y «Año ñá»: con sus
+ * bytes y `encoding: "ISO-8859-15"` el aparato pintaba «Año ñá» —y estropeaba también el
+ * «Contraseña» que ya estaba—; con el texto en UTF-8 y el prólogo cambiado a UTF-8 se ve bien. El
+ * framework decodifica con `encoding` y su analizador vuelve a leer el prólogo: si los dos no dicen
+ * lo mismo que los bytes, cada tilde sale doble. Solo para la copia EN MEMORIA: lo que se sube a
+ * disco (`uploadFile`) son los bytes tal cual, que es lo que el framework lee al relanzar.
+ */
+export function xmlParaCargarEnMemoria(bytes) {
+    const texto = decodificarComoTexto(bytes).replace(/^\uFEFF/, "");
+    const conPrologoUtf8 = texto.replace(/^(\s*<\?xml[^?]*?encoding\s*=\s*)(["'])[^"']*\2/i, (_todo, antes, comilla) => `${antes}${comilla}UTF-8${comilla}`);
+    return new TextEncoder().encode(conPrologoUtf8);
+}
+/** Dónde guarda el framework lo que se le sube: `app_<nombre en minúsculas>/<ruta>` (medido). */
+export function destinoEnElAparato(app, ruta) {
+    return `app_${app.toLowerCase()}/${ruta.replace(/^\/+/, "")}`;
+}
+/** La frase que enseña la cabecera del editor. Pura para que el test la fije. */
+export function textoDeRecarga(r) {
+    switch (r.estado) {
+        case "aplicada":
+            return r.clase === "js"
+                ? "Aparato: JavaScript recargado; la app sigue viva"
+                : "Aparato: pantalla recargada en caliente; la app sigue viva";
+        case "relanzar":
+            return "Aparato: subido; para verlo hay que relanzar la app";
+        case "relanzada":
+            return "Aparato: app relanzada y viva";
+        case "sin-app":
+            // El motivo, si se sabe: «no hay aparato elegido» y «no está en la medida» no se arreglan
+            // en el mismo sitio que «la app no corre».
+            return r.motivo !== undefined && !r.motivo.includes("App is not running")
+                ? `Aparato: no se recarga (${r.motivo})`
+                : "Aparato: la app no está corriendo; lánzala desde Ejecutar o pulsa Probar";
+        case "desplegada":
+            return "Aparato: proyecto desplegado y la app viva";
+        case "desplegando":
+            return "Aparato: la app no corría; desplegando el proyecto (el recorrido, en Ejecutar)";
+        case "ocupado":
+            return "Aparato: hay un despliegue en curso; no se recarga encima";
+        case "no-aplica":
+            return "Aparato: este fichero no se recarga suelto; hace falta desplegar entero";
+        case "fallo":
+            return `Aparato: no se pudo recargar (${r.motivo ?? "sin motivo"})`;
+    }
+}
+//# sourceMappingURL=recargaEnCaliente.js.map

package/dist/core/recargaEnCaliente.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recargaEnCaliente.js","sourceRoot":"","sources":["../../src/core/recargaEnCaliente.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAE,oBAAoB,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAIxF,gFAAgF;AAChF,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAErE,gEAAgE;AAChE,MAAM,KAAK,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;AAEvC,oGAAoG;AACpG,MAAM,iBAAiB,GAAG,aAAa,CAAC;AAExC,SAAS,SAAS,CAAC,IAAY;IAC7B,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IACrD,MAAM,KAAK,GAAG,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IACtC,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;AAC7D,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,IAAY,EAAE,KAAiB;IAC5D,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IACxC,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,KAAK,CAAC,IAAI,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAAE,OAAO,WAAW,CAAC;IACtF,MAAM,GAAG,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;IAC9B,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC;QAAE,OAAO,WAAW,CAAC;IAC9C,IAAI,GAAG,KAAK,KAAK;QAAE,OAAO,IAAI,CAAC;IAC/B,IAAI,GAAG,KAAK,MAAM,EAAE,CAAC;QACnB,IAAI,MAAM,GAAG,EAAE,CAAC;QAChB,KAAK,MAAM,CAAC,IAAI,KAAK;YAAE,MAAM,IAAI,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QACxD,OAAO,iBAAiB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,UAAU,CAAC;IACnE,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,yBAAyB,CAAC,KAAiB;IACzD,IAAI,YAAY,CAAC,KAAK,CAAC;QAAE,OAAO,OAAO,CAAC;IACxC,OAAO,eAAe,CAAC,KAAK,CAAC,KAAK,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,cAAc,CAAC;AACnF,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,sBAAsB,CAAC,KAAiB;IACtD,MAAM,KAAK,GAAG,oBAAoB,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;IACjE,MAAM,cAAc,GAAG,KAAK,CAAC,OAAO,CAClC,kDAAkD,EAClD,CAAC,KAAK,EAAE,KAAa,EAAE,OAAe,EAAE,EAAE,CAAC,GAAG,KAAK,GAAG,OAAO,QAAQ,OAAO,EAAE,CAC/E,CAAC;IACF,OAAO,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;AAClD,CAAC;AAED,iGAAiG;AACjG,MAAM,UAAU,kBAAkB,CAAC,GAAW,EAAE,IAAY;IAC1D,OAAO,OAAO,GAAG,CAAC,WAAW,EAAE,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;AAChE,CAAC;AAoCD,iFAAiF;AACjF,MAAM,UAAU,cAAc,CAAC,CAAqB;IAClD,QAAQ,CAAC,CAAC,MAAM,EAAE,CAAC;QACjB,KAAK,UAAU;YACb,OAAO,CAAC,CAAC,KAAK,KAAK,IAAI;gBACrB,CAAC,CAAC,kDAAkD;gBACpD,CAAC,CAAC,4DAA4D,CAAC;QACnE,KAAK,UAAU;YACb,OAAO,qDAAqD,CAAC;QAC/D,KAAK,WAAW;YACd,OAAO,+BAA+B,CAAC;QACzC,KAAK,SAAS;YACZ,0FAA0F;YAC1F,2CAA2C;YAC3C,OAAO,CAAC,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,oBAAoB,CAAC;gBACvE,CAAC,CAAC,2BAA2B,CAAC,CAAC,MAAM,GAAG;gBACxC,CAAC,CAAC,0EAA0E,CAAC;QACjF,KAAK,YAAY;YACf,OAAO,4CAA4C,CAAC;QACtD,KAAK,aAAa;YAChB,OAAO,gFAAgF,CAAC;QAC1F,KAAK,SAAS;YACZ,OAAO,2DAA2D,CAAC;QACrE,KAAK,WAAW;YACd,OAAO,yEAAyE,CAAC;QACnF,KAAK,OAAO;YACV,OAAO,iCAAiC,CAAC,CAAC,MAAM,IAAI,YAAY,GAAG,CAAC;IACxE,CAAC;AACH,CAAC"}

package/dist/web/servidor/arranque.js

@@ -55,8 +55,11 @@ import { PLATAFORMAS_DE_DISPOSITIVO } from "../../core/settings.js";
 import { instalarHerramientaDeDispositivos, verificarDispositivo } from "../../agent/dispositivos/dispositivosEnMaquina.js";
 import { arrancarEmulador, pararEmulador } from "../../agent/dispositivos/arranqueDeEmulador.js";
 import { borrarAvd, clonarAvd, correrPasoDeReceta, crearAvd } from "../../agent/dispositivos/instalacionEnMaquina.js";
-import { asignarPuertosPendientes, motivoDeNombreDeAvdInaceptable, motivoDePuertoInaceptable, puertoDeAvd, } from "../../core/puertosDeAvd.js";
+import { asignarPuertosPendientes, motivoDeNombreDeAvdInaceptable, motivoDePuertoInaceptable, puertoDeAvd, PUERTO_DEL_HOTSWAP, } from "../../core/puertosDeAvd.js";
 import { abrirCarpetaDelSistema, abrirDirectorioDelSistema } from "../../agent/config/selectorEnMaquina.js";
+import { recargarFicheroDelProyecto, relanzarEnAparato, } from "../../agent/dispositivos/recargaEnAparato.js";
+import { textoDeRecarga } from "../../core/recargaEnCaliente.js";
+import { nombreDeApp } from "../../core/descriptoresDeApp.js";
 import { modelosDeMotor } from "../../agent/config/modelosDeMotor.js";
 import { parsear, compatibleConOpenAi, esProveedorPersonalizado, idDeProveedorPersonalizado, motivoDeEndpointInaceptable, motivoDeSlugInaceptable, nombreDeProveedor, PROVEEDORES, slugDesdeNombre, resolver, SIN_CREDENCIAL, PAPELES, } from "../../core/modelos.js";
 import { hayCredencial } from "../../cli/consola.js";
@@ -3020,15 +3023,21 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
      * se pintó el botón. Una revalidación que no pasa se contesta con un `lanzamiento` en `fallo`
      * y NO se llama al lanzador.
      */
-    const atenderLanzarApp = async () => {
+    /**
+     * `alAcabar` es para quien lanzó por OTRO camino que la pestaña (el «Probar» del editor): le dice
+     * cómo acabó, para que su línea no se quede en «desplegando» para siempre.
+     */
+    const atenderLanzarApp = async (alAcabar) => {
         // Ya hay uno: se reenvía su estado en vez de lanzar otro, como `atenderReceta`.
         if (lanzamiento !== undefined) {
             emitirLanzamiento("corriendo");
+            alAcabar?.("ocupado");
             return;
         }
         const medida = await medirLanzamiento();
         if (medida === undefined) {
             informar("no hay ningún proyecto abierto que lanzar");
+            alAcabar?.("fallo", "no hay ningún proyecto abierto");
             return;
         }
         const foto = medida.dispositivo === undefined ? undefined : fotoDeDispositivo(medida.dispositivo);
@@ -3043,6 +3052,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
                 ms: 0,
                 motivo,
             });
+            alAcabar?.("fallo", motivo);
         };
         const lanzar = opciones.lanzarEnDispositivo;
         const primeraFalta = medida.veredicto.causas[0];
@@ -3127,6 +3137,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             ultimoLanzamiento = 0;
             trabajo.fase = resultado.fase;
             emitirLanzamiento(resultado.estado, resultado.motivo);
+            alAcabar?.(resultado.estado === "ok" ? "ok" : "fallo", resultado.motivo ?? (resultado.estado === "ok" ? undefined : resultado.estado));
         }
         catch (error) {
             // El contrato del lanzador es no lanzar nunca, así que esto es un bug suyo; aun así hay
@@ -3134,6 +3145,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             // muerto y sin una palabra.
             ultimoLanzamiento = 0;
             emitirLanzamiento("fallo", motivoLegible(error));
+            alAcabar?.("fallo", motivoLegible(error));
         }
         finally {
             lanzamiento = undefined;
@@ -3814,7 +3826,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
      *  - lo demás —guardas de ruta, huella, tope— lo decide el puerto y lo DEVUELVE.
      * El `try` es el de `atenderFichero`: un fallo inesperado contesta sin la ruta de la máquina.
      */
-    const atenderGuardarFichero = async (ruta, texto, huella, id, proyecto) => {
+    const atenderGuardarFichero = async (ruta, texto, huella, id, proyecto, recargar = false) => {
         const abierto = vestibulo.proyectoAbierto();
         if (abierto === undefined) {
             emitir({ clase: "ficheroGuardado", ruta, id, error: "no hay ningún proyecto abierto" });
@@ -3842,13 +3854,152 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             // `id` lo pone la pestaña en CADA guardado y vuelve en la respuesta: esta va a todas las
             // pestañas, y cada una reconoce la suya por él. La huella no vale —dos pestañas que parten de
             // la misma versión mandan la misma—.
-            emitir({ clase: "ficheroGuardado", ...(await opciones.escribirFichero(abierto.raiz, ruta, texto, huella)), id });
+            const guardado = await opciones.escribirFichero(abierto.raiz, ruta, texto, huella);
+            emitir({ clase: "ficheroGuardado", ...guardado, id });
+            // DESPUÉS de contestar el guardado, y sin esperarla: el «Guardando…» no depende del aparato,
+            // y nada de la recarga puede convertir un guardado bueno en uno fallido.
+            if (recargar && guardado.huella !== undefined && guardado.error === undefined) {
+                void atenderRecarga(abierto.raiz, ruta, { probar: false }).catch(contar);
+            }
         }
         catch (error) {
             informar(`no se pudo guardar «${ruta}» (${codigoDe(error)})`);
             emitir({ clase: "ficheroGuardado", ruta, id, error: "no se pudo guardar el fichero" });
         }
     };
+    /**
+     * A qué aparato y app va una recarga, resuelto aquí y no en el cliente: el dispositivo ELEGIDO en
+     * la sesión (si no hay, no se recarga — sin adivinar uno), Android, el puerto de SU AVD (con dos
+     * emuladores, el 8443 le hablaría al otro sin error) y el nombre de la app de `app.ini`, el
+     * MISMO que usa Ejecutar. `undefined` = no hay a dónde recargar, y eso no es un fallo.
+     */
+    const destinoDeRecarga = async (abierto) => {
+        if (abierto.dispositivo === undefined)
+            return { motivo: "no hay un aparato elegido en la sesión" };
+        const { dispositivo } = dispositivoDeLaSesion(abierto.dispositivo, informeDeDispositivos);
+        // La foto de Dispositivos solo se toma al conectar y al pulsar «Refrescar»: un emulador
+        // arrancado después no está en ella, y decir «la app no corre» mandaría a buscar donde no es.
+        if (dispositivo === undefined) {
+            return { motivo: "el aparato de la sesión no está en la última medida: pulsa Refrescar en Dispositivos" };
+        }
+        if (dispositivo.plataforma !== "android")
+            return { motivo: "la recarga en caliente solo existe en Android" };
+        const ini = await leerDescriptor(abierto.raiz, "app.ini");
+        const app = ini.texto === undefined ? undefined : nombreDeApp(ini.texto);
+        if (app === undefined)
+            return { motivo: "app.ini no dice el nombre de la app (name=)" };
+        return {
+            serie: dispositivo.id,
+            puerto: dispositivo.avd === undefined ? PUERTO_DEL_HOTSWAP : puertoDeAvd(ajustesDeDispositivos(), dispositivo.avd),
+            app,
+        };
+    };
+    /**
+     * UNA recarga a la vez para toda la máquina, como el lanzamiento: dos al mismo aparato se
+     * cruzarían en el canal (las respuestas se emparejan por ORDEN). Un guardado que llega con una en
+     * vuelo deja su ruta como SIGUIENTE, y la última pisa a la anterior: tras varios Cmd+S seguidos lo
+     * que importa es cómo quedó el fichero, no cada versión intermedia.
+     */
+    let recargando = false;
+    let siguienteRecarga;
+    const emitirRecarga = (ruta, resultado) => {
+        emitir({
+            clase: "recargaEnAparato",
+            ruta,
+            estado: resultado.estado,
+            ...(resultado.clase === undefined ? {} : { tipo: resultado.clase }),
+            texto: textoDeRecarga(resultado),
+        });
+    };
+    /**
+     * Recargar en el aparato. **Nunca lanza ni contesta un error al guardado**: sin aparato o sin
+     * app, dice `sin-app` y ya. Con `probar` y la app sin correr, lanza el despliegue entero de
+     * Ejecutar —que sube el proyecto entero— en vez de recargar lo que nadie tiene cargado.
+     */
+    const atenderRecarga = async (raiz, ruta, { probar }) => {
+        if (recargando) {
+            siguienteRecarga = { raiz, ruta, probar };
+            return;
+        }
+        recargando = true;
+        try {
+            const abierto = vestibulo.proyectoAbierto();
+            if (abierto === undefined || abierto.raiz !== raiz)
+                return;
+            if (lanzamiento !== undefined) {
+                emitirRecarga(ruta, { estado: "ocupado" });
+                return;
+            }
+            const destino = await destinoDeRecarga(abierto);
+            const recargar = opciones.recargarEnAparato;
+            if ("motivo" in destino) {
+                // Sin a dónde recargar tampoco hay a dónde desplegar: se dice por qué, y nada más.
+                emitirRecarga(ruta, { estado: "sin-app", motivo: destino.motivo });
+                return;
+            }
+            if (recargar === undefined) {
+                emitirRecarga(ruta, { estado: "sin-app", motivo: "esta ejecución no recarga en el aparato" });
+                return;
+            }
+            const resultado = await recargar(raiz, ruta, destino);
+            if (resultado.estado === "sin-app" && probar) {
+                emitirRecarga(ruta, { estado: "desplegando" });
+                // Y cómo acabó, en la MISMA línea: sin esto se quedaba en «desplegando» para siempre.
+                void atenderLanzarApp((estado, motivo) => {
+                    if (estado === "ok")
+                        emitirRecarga(ruta, { estado: "desplegada" });
+                    else if (estado === "ocupado")
+                        emitirRecarga(ruta, { estado: "ocupado" });
+                    else
+                        emitirRecarga(ruta, { estado: "fallo", motivo: `el despliegue no acabó bien: ${motivo ?? "sin motivo"}` });
+                }).catch(contar);
+                return;
+            }
+            emitirRecarga(ruta, resultado);
+        }
+        catch (error) {
+            // Su contrato es no lanzar; si lo hace, se dice como fallo de la RECARGA, nunca del guardado.
+            emitirRecarga(ruta, { estado: "fallo", motivo: motivoLegible(error) });
+        }
+        finally {
+            recargando = false;
+            const otra = siguienteRecarga;
+            siguienteRecarga = undefined;
+            if (otra !== undefined)
+                void atenderRecarga(otra.raiz, otra.ruta, { probar: otra.probar }).catch(contar);
+        }
+    };
+    /** Relanzar la app a petición (un CSS solo se ve así). Con las mismas reglas que la recarga. */
+    const atenderRelanzar = async (ruta) => {
+        const abierto = vestibulo.proyectoAbierto();
+        if (abierto === undefined)
+            return;
+        if (lanzamiento !== undefined || recargando) {
+            emitirRecarga(ruta, { estado: "ocupado" });
+            return;
+        }
+        const destino = await destinoDeRecarga(abierto);
+        const relanzar = opciones.relanzarEnAparato;
+        if ("motivo" in destino || relanzar === undefined) {
+            emitirRecarga(ruta, { estado: "sin-app", motivo: "motivo" in destino ? destino.motivo : "esta ejecución no relanza" });
+            return;
+        }
+        recargando = true;
+        try {
+            emitirRecarga(ruta, await relanzar(destino));
+        }
+        catch (error) {
+            emitirRecarga(ruta, { estado: "fallo", motivo: motivoLegible(error) });
+        }
+        finally {
+            recargando = false;
+            // Un guardado que llegó mientras se relanzaba quedó como siguiente: sin esto se perdía.
+            const otra = siguienteRecarga;
+            siguienteRecarga = undefined;
+            if (otra !== undefined)
+                void atenderRecarga(otra.raiz, otra.ruta, { probar: otra.probar }).catch(contar);
+        }
+    };
     /**
      * La base de las marcas del editor. Con la sesión ABIERTA (`abierto.sesion`, la misma que mira
      * Revisión): su ref es la foto del inicio. Sin puerto se contesta `sinBase` —el editor funciona
@@ -5377,7 +5528,7 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             typeof mensaje.huella === "string" &&
             typeof mensaje.id === "string" &&
             typeof mensaje.proyecto === "string") {
-            void atenderGuardarFichero(mensaje.ruta, mensaje.texto, mensaje.huella, mensaje.id, mensaje.proyecto).catch(contar);
+            void atenderGuardarFichero(mensaje.ruta, mensaje.texto, mensaje.huella, mensaje.id, mensaje.proyecto, mensaje.recargar === true).catch(contar);
             respuesta.writeHead(204);
             respuesta.end();
             return;
@@ -5879,6 +6030,22 @@ export function montarRutas(servidor, vestibulo, opciones = {}) {
             respuesta.end();
             return;
         }
+        if (typeof mensaje === "object" &&
+            mensaje !== null &&
+            mensaje.clase === "recargarEnAparato" &&
+            typeof mensaje.ruta === "string") {
+            // Suelto: habla con el aparato, y la respuesta va por el SSE como `recargaEnAparato`.
+            const abierto = vestibulo.proyectoAbierto();
+            if (abierto !== undefined) {
+                if (mensaje.relanzar === true)
+                    void atenderRelanzar(mensaje.ruta).catch(contar);
+                else
+                    void atenderRecarga(abierto.raiz, mensaje.ruta, { probar: mensaje.probar === true }).catch(contar);
+            }
+            respuesta.writeHead(204);
+            respuesta.end();
+            return;
+        }
         if (typeof mensaje === "object" && mensaje !== null && mensaje.clase === "cancelarLanzamiento") {
             // Este SÍ es síncrono: `cancelar` solo mata el grupo del proceso en curso.
             atenderCancelarLanzamiento();
@@ -6486,6 +6653,17 @@ export function ficherosCableados() {
  * (`guardarAjusteDeAvd(undefined, …)`). `arrancar` entra solo para que un test vea qué recibe la
  * de verdad sin lanzar un emulador.
  */
+/**
+ * La recarga en caliente del editor, con las funciones de VERDAD y compuesta fuera del cableado
+ * por la trampa de siempre: un campo opcional olvidado en `arrancarConsolaWeb` deja la casilla
+ * pintada y sin hacer nada, con todo en verde. El `adb` y el canal reales los ponen ellas.
+ */
+export function recargaCableada() {
+    return {
+        recargarEnAparato: (raiz, ruta, destino) => recargarFicheroDelProyecto(raiz, ruta, destino),
+        relanzarEnAparato: (destino) => relanzarEnAparato(destino),
+    };
+}
 export function emuladoresCableados(opciones = {}) {
     const arrancar = opciones.arrancar ?? arrancarEmulador;
     return {
@@ -7048,6 +7226,7 @@ export async function arrancarConsolaWeb(opciones) {
          * arriba: una composición de producción que solo existe en el cableado nadie la prueba.
          */
         lanzarEnDispositivo,
+        ...recargaCableada(),
         catalogoDeModelos: async (proveedor) => {
             const modelos = await new CatalogoModelos(undefined, undefined, proveedoresPersonalizados).listar(proveedor);
             return modelos.map((m) => ({ id: m.id, ...(m.nombre === undefined ? {} : { nombre: m.nombre }) }));