@getparallel/parx 0.4.4 → 0.6.0

package/dist/par.js

@@ -0,0 +1,355 @@
+export const LADO = 16;
+export const TONOS = {
+    300: { cuerpo: '#ae9bff', sombra: '#8b70ff', detalle: '#ddd3ff' },
+    400: { cuerpo: '#8b70ff', sombra: '#6d4aff', detalle: '#ae9bff' },
+    500: { cuerpo: '#7b5cff', sombra: '#5a36e6', detalle: '#ae9bff' },
+    600: { cuerpo: '#6d4aff', sombra: '#5a36e6', detalle: '#ae9bff' },
+    700: { cuerpo: '#5a36e6', sombra: '#4626ba', detalle: '#8b70ff' },
+};
+export const ORDEN_DE_TONOS = [600, 400, 700, 500, 300];
+export const TINTA = '#15131f';
+export const CLARO = '#d3cde8';
+export const ORO = '#f2b632';
+function huella(s) {
+    let h = 2166136261;
+    for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return h >>> 0;
+}
+export function tonoDe(semilla) {
+    if (!semilla)
+        return 600;
+    return ORDEN_DE_TONOS[huella(semilla) % ORDEN_DE_TONOS.length];
+}
+export function tonosDelEquipo(semillas) {
+    const usados = new Set();
+    return semillas.map((s) => {
+        let t = tonoDe(s);
+        if (usados.size < ORDEN_DE_TONOS.length) {
+            let i = ORDEN_DE_TONOS.indexOf(t);
+            while (usados.has(t)) {
+                i = (i + 1) % ORDEN_DE_TONOS.length;
+                t = ORDEN_DE_TONOS[i];
+            }
+        }
+        usados.add(t);
+        return t;
+    });
+}
+export function colorDe(c, tono) {
+    const t = TONOS[tono];
+    switch (c) {
+        case 'B':
+            return t.cuerpo;
+        case 'D':
+            return t.sombra;
+        case 'A':
+            return t.detalle;
+        case 'E':
+            return TINTA;
+        case 'W':
+            return CLARO;
+        case 'Y':
+            return ORO;
+        default:
+            return null;
+    }
+}
+const INICIO = [7, 11];
+const ARRIBA = 2;
+const FILAS = 12;
+const FILA_OJO = ARRIBA + 3;
+function pon(m, x, y, c) {
+    if (x >= 0 && x < LADO && y >= 0 && y < LADO)
+        m[y][x] = c;
+}
+export function matrizDe(c, accesorio) {
+    const m = Array.from({ length: LADO }, () => Array(LADO).fill('.'));
+    const ojos = Array.isArray(c.ojos) ? c.ojos : [c.ojos ?? 'abierto', c.ojos ?? 'abierto'];
+    [c.izq, c.der].forEach((b, k) => {
+        const dx = b?.dx ?? 0;
+        const dy = b?.dy ?? 0;
+        const estira = b?.estira ?? 0;
+        const inicio = INICIO[k];
+        const xDe = (y) => inicio - Math.floor((y - ARRIBA) / 2) + dx;
+        for (let y = ARRIBA - estira; y <= ARRIBA + FILAS; y++) {
+            const color = y === ARRIBA + FILAS ? 'D' : 'B';
+            for (let i = 0; i < 3; i++)
+                pon(m, xDe(y) + i, y + dy, color);
+        }
+        const filaOjo = FILA_OJO - estira;
+        const fy = filaOjo + dy;
+        const cx = xDe(filaOjo) + 1;
+        const ojo = ojos[k];
+        switch (ojo) {
+            case 'abierto':
+                pon(m, cx, fy, 'E');
+                break;
+            case 'cerrado':
+                pon(m, cx - 1, fy, 'D');
+                pon(m, cx, fy, 'D');
+                pon(m, cx + 1, fy, 'D');
+                break;
+            case 'feliz':
+                pon(m, cx, fy - 1, 'E');
+                pon(m, cx - 1, fy, 'E');
+                pon(m, cx + 1, fy, 'E');
+                break;
+            case 'grande':
+                pon(m, cx, fy - 1, 'E');
+                pon(m, cx, fy, 'E');
+                break;
+            case 'x':
+                pon(m, cx - 1, fy - 1, 'E');
+                pon(m, cx + 1, fy - 1, 'E');
+                pon(m, cx, fy, 'E');
+                pon(m, cx - 1, fy + 1, 'E');
+                pon(m, cx + 1, fy + 1, 'E');
+                break;
+            case 'abajo':
+                pon(m, cx, fy + 1, 'E');
+                break;
+            case 'arriba':
+                pon(m, cx, fy - 1, 'E');
+                break;
+            case 'izquierda':
+                pon(m, cx - 1, fy, 'E');
+                break;
+            case 'derecha':
+                pon(m, cx + 1, fy, 'E');
+                break;
+        }
+    });
+    if (accesorio) {
+        for (const [x, y, ch] of PIEZAS[accesorio]) {
+            const b = x <= 9 ? c.izq : c.der;
+            pon(m, x + (b?.dx ?? 0), y + (b?.dy ?? 0) - (b?.estira ?? 0), ch);
+        }
+    }
+    for (const p of c.extra ?? [])
+        pon(m, p[0], p[1], p[2] ?? 'A');
+    return m.map((f) => f.join(''));
+}
+const FILAS_DE_ACCESORIOS = {
+    gorra: { 0: '...........DDD..', 1: '...........DDDDD' },
+    copa: { 0: '.......EAE......', 1: '......EEEEE.....' },
+    astronauta: { 0: '........WWWWW...', 1: '......WW.....WW.', 2: '......W.......W.', 3: '......W.......W.' },
+    corona: { 0: '...........Y.Y..', 1: '...........YYY..' },
+    gafas_sol: { 4: '......WEE.WEE...', 5: '......EEEEEEE...' },
+    gafas: { 4: '......YYY.YYY...', 5: '......Y.YYY.Y...', 6: '......YYY.YYY...' },
+    bigote: { 7: '.......EEE......' },
+    pajarita: { 9: '.....EEAEE......' },
+    idea: { 0: '.......YYY......', 1: '......A.Y.A.....' },
+    gato: { 0: '...........B.B..', 1: '...........BBB..' },
+    fiesta: { 0: '........Y.......', 1: '.......YEY......' },
+    auriculares: { 0: '............E...', 1: '...........E.E..', 3: '..........E....E', 4: '..........E....E' },
+    cocinero: { 0: '......WWWWW.....', 1: '.......WWW......' },
+    pirata: { 4: '......EEE.......', 5: '......EEE.......' },
+    bufanda: { 10: '...YYY.YYY......', 11: '........YY......' },
+    antena: { 0: '............Y...', 1: '............D...' },
+    sombrilla: { 0: '.......DDD......', 1: '......DDDDD.....' },
+    nube: { 0: '.......WW.......', 1: '......WWWW......', 2: '.....A..........', 3: '....A...........', 4: '.....A..........' },
+    halo: { 0: '.......YYY......' },
+    pelo: { 0: '......B.B.B.....', 1: '......BBBBB.....' },
+};
+export const LISTA_DE_ACCESORIOS = Object.keys(FILAS_DE_ACCESORIOS);
+const PIEZAS = Object.fromEntries(LISTA_DE_ACCESORIOS.map((id) => [
+    id,
+    Object.entries(FILAS_DE_ACCESORIOS[id]).flatMap(([y, fila]) => [...fila].flatMap((ch, x) => (ch === '.' ? [] : [[x, Number(y), ch]]))),
+]));
+export function accesorioDe(semilla) {
+    if (!semilla)
+        return null;
+    return LISTA_DE_ACCESORIOS[huella(`${semilla}·accesorio`) % LISTA_DE_ACCESORIOS.length];
+}
+export function accesoriosDelEquipo(semillas) {
+    const usados = new Set();
+    return semillas.map((s) => {
+        let a = accesorioDe(s || 'parallel');
+        if (usados.size < LISTA_DE_ACCESORIOS.length) {
+            let i = LISTA_DE_ACCESORIOS.indexOf(a);
+            while (usados.has(a)) {
+                i = (i + 1) % LISTA_DE_ACCESORIOS.length;
+                a = LISTA_DE_ACCESORIOS[i];
+            }
+        }
+        usados.add(a);
+        return a;
+    });
+}
+const P = (puntos, dx = 0, dy = 0, c = 'A') => puntos.map(([x, y]) => [x + dx, y + dy, c]);
+const INTERROGACION = [[1, 0], [2, 0], [3, 1], [2, 2], [2, 4]];
+const EXCLAMACION = [[2, 0], [2, 1], [2, 2], [2, 4]];
+const TIC = [[0, 2], [1, 3], [2, 2], [3, 1], [4, 0]];
+const CORAZON = [[1, 0], [3, 0], [0, 1], [1, 1], [2, 1], [3, 1], [4, 1], [1, 2], [2, 2], [3, 2], [2, 3]];
+const ZETA = [[0, 0], [1, 0], [2, 0], [1, 1], [0, 2], [1, 2], [2, 2]];
+const NOTA = [[1, 0], [2, 0], [1, 1], [1, 2], [0, 3], [1, 3]];
+export const ANIMACIONES = {
+    reposo: [{ ms: 1500 }, { ojos: 'cerrado', ms: 120 }, { ms: 1800 }, { ojos: 'derecha', ms: 700 }, { ms: 500 }, { izq: { dy: 1 }, der: { dy: 1 }, ms: 400 }, { ms: 900 }],
+    saludo: [
+        { ojos: 'feliz', ms: 200 },
+        { ojos: 'feliz', der: { dx: 1, dy: -1 }, ms: 180 },
+        { ojos: 'feliz', ms: 180 },
+        { ojos: 'feliz', der: { dx: 1, dy: -1 }, ms: 180 },
+        { ojos: 'feliz', ms: 600 },
+    ],
+    pensando: [
+        { ojos: 'arriba', ms: 350 },
+        { ojos: 'arriba', extra: P([[2, 1]]), ms: 350 },
+        { ojos: 'arriba', extra: P([[2, 1], [4, 1]]), ms: 350 },
+        { ojos: 'arriba', extra: P([[2, 1], [4, 1], [6, 0]]), ms: 600 },
+        { ojos: 'cerrado', extra: P([[2, 1], [4, 1], [6, 0]]), ms: 120 },
+    ],
+    trabajando: [
+        { izq: { dy: -1 }, extra: P([[1, 9], [15, 3]]), ms: 170 },
+        { der: { dy: -1 }, extra: P([[0, 7], [15, 6]]), ms: 170 },
+    ],
+    escribiendo: [
+        { ojos: 'abajo', extra: P([[3, 15]]), ms: 220 },
+        { ojos: 'abajo', extra: P([[3, 15], [5, 15]]), ms: 220 },
+        { ojos: 'abajo', extra: P([[3, 15], [5, 15], [7, 15]]), ms: 220 },
+        { ojos: 'abajo', ms: 220 },
+    ],
+    buscando: [{ ojos: 'izquierda', ms: 380 }, { ms: 200 }, { ojos: 'derecha', ms: 380 }, { ms: 200 }],
+    esperando: [{ ms: 450 }, { extra: P(INTERROGACION, 1, 1), ms: 650 }, { extra: P(INTERROGACION, 1, 1), ojos: 'cerrado', ms: 120 }, { extra: P(INTERROGACION, 1, 1), ms: 650 }],
+    hecho: [
+        { ms: 200 },
+        { izq: { dy: -1 }, der: { dy: -1 }, ojos: 'feliz', ms: 140 },
+        { izq: { dy: -2 }, der: { dy: -2 }, ojos: 'feliz', extra: P(TIC, 1, 1), ms: 240 },
+        { izq: { dy: -1 }, der: { dy: -1 }, ojos: 'feliz', extra: P(TIC, 1, 1), ms: 140 },
+        { ojos: 'feliz', extra: P(TIC, 1, 1), ms: 900 },
+    ],
+    error: [
+        { ojos: 'x', izq: { dx: -1 }, der: { dx: -1 }, ms: 90 },
+        { ojos: 'x', izq: { dx: 1 }, der: { dx: 1 }, ms: 90 },
+        { ojos: 'x', izq: { dx: -1 }, der: { dx: -1 }, ms: 90 },
+        { ojos: 'x', izq: { dx: 1 }, der: { dx: 1 }, ms: 90 },
+        { ojos: 'x', ms: 900 },
+    ],
+    dormido: [
+        { ojos: 'cerrado', extra: P(ZETA, 1, 6), ms: 600 },
+        { ojos: 'cerrado', izq: { dy: 1 }, der: { dy: 1 }, extra: P(ZETA, 1, 3), ms: 600 },
+        { ojos: 'cerrado', extra: P(ZETA, 2, 0), ms: 600 },
+        { ojos: 'cerrado', izq: { dy: 1 }, der: { dy: 1 }, ms: 600 },
+    ],
+    estirarse: [
+        { ms: 300 },
+        { izq: { estira: 1 }, der: { estira: 1 }, ojos: 'cerrado', ms: 220 },
+        { izq: { estira: 2 }, der: { estira: 2 }, ojos: 'cerrado', ms: 500 },
+        { izq: { estira: 1 }, der: { estira: 1 }, ojos: 'cerrado', ms: 200 },
+        { ojos: 'feliz', ms: 600 },
+    ],
+    salto: [
+        { izq: { dy: 1 }, der: { dy: 1 }, ms: 160 },
+        { izq: { dy: -1 }, der: { dy: -1 }, ojos: 'feliz', ms: 120 },
+        { izq: { dy: -2 }, der: { dy: -2 }, ojos: 'feliz', ms: 220 },
+        { izq: { dy: -1 }, der: { dy: -1 }, ojos: 'feliz', ms: 120 },
+        { izq: { dy: 1 }, der: { dy: 1 }, ms: 140 },
+        { ms: 500 },
+    ],
+    baile: [
+        { izq: { dy: -1, dx: -1 }, der: { dx: -1 }, ojos: 'feliz', extra: P(NOTA, 0, 1), ms: 220 },
+        { izq: { dx: 1 }, der: { dy: -1, dx: 1 }, ojos: 'feliz', ms: 220 },
+        { izq: { dy: -1, dx: -1 }, der: { dx: -1 }, ojos: 'feliz', ms: 220 },
+        { izq: { dx: 1 }, der: { dy: -1, dx: 1 }, ojos: 'feliz', extra: P(NOTA, 0, 0), ms: 220 },
+    ],
+    guino: [{ ms: 600 }, { ojos: ['abierto', 'cerrado'], ms: 260 }, { ojos: 'feliz', ms: 700 }],
+    corazon: [
+        { ojos: 'feliz', extra: P(CORAZON, 0, 3), ms: 260 },
+        { ojos: 'feliz', extra: P(CORAZON, 0, 2), ms: 260 },
+        { ojos: 'feliz', extra: P(CORAZON, 0, 1), ms: 260 },
+        { ojos: 'feliz', extra: P(CORAZON, 0, 0), ms: 700 },
+    ],
+    fiesta: [
+        { ojos: 'feliz', izq: { dy: -1 }, der: { dy: -1 }, extra: P([[1, 2], [4, 0], [15, 1], [14, 9], [0, 11]]), ms: 200 },
+        { ojos: 'feliz', extra: P([[2, 4], [5, 1], [14, 3], [15, 11], [1, 13]]), ms: 200 },
+        { ojos: 'feliz', izq: { dy: -1 }, der: { dy: -1 }, extra: P([[0, 6], [3, 0], [15, 5], [13, 13], [2, 15]]), ms: 200 },
+        { ojos: 'feliz', extra: P([[1, 8], [6, 0], [14, 7], [15, 14], [0, 1]]), ms: 200 },
+    ],
+    musica: [
+        { ojos: 'cerrado', izq: { dx: -1 }, der: { dx: -1 }, extra: P(NOTA, 1, 5), ms: 380 },
+        { ojos: 'cerrado', extra: P(NOTA, 1, 3), ms: 380 },
+        { ojos: 'cerrado', izq: { dx: 1 }, der: { dx: 1 }, extra: P(NOTA, 2, 1), ms: 380 },
+        { ojos: 'cerrado', extra: P(NOTA, 2, 0), ms: 380 },
+    ],
+    mirar: [{ ojos: 'izquierda', ms: 600 }, { ms: 250 }, { ojos: 'derecha', ms: 600 }, { ojos: 'arriba', ms: 500 }, { ms: 500 }],
+    sorpresa: [{ ms: 300 }, { ojos: 'grande', izq: { dy: -1 }, der: { dy: -1 }, extra: P(EXCLAMACION, 1, 1), ms: 200 }, { ojos: 'grande', extra: P(EXCLAMACION, 1, 1), ms: 900 }],
+    asomarse: [
+        { izq: { dy: 12 }, der: { dy: 12 }, ms: 500 },
+        { izq: { dy: 8 }, der: { dy: 8 }, ms: 140 },
+        { izq: { dy: 5 }, der: { dy: 5 }, ms: 140 },
+        { izq: { dy: 3 }, der: { dy: 3 }, ms: 900 },
+        { izq: { dy: 3 }, der: { dy: 3 }, ojos: 'cerrado', ms: 120 },
+        { izq: { dy: 3 }, der: { dy: 3 }, ojos: 'derecha', ms: 700 },
+        { izq: { dy: 6 }, der: { dy: 6 }, ms: 140 },
+        { izq: { dy: 12 }, der: { dy: 12 }, ms: 700 },
+    ],
+};
+export const LISTA_DE_ANIMACIONES = Object.keys(ANIMACIONES);
+export const DEL_TRABAJO = ['saludo', 'pensando', 'trabajando', 'escribiendo', 'buscando', 'esperando', 'hecho', 'error'];
+export function animacionDelEstado(estado) {
+    switch (estado) {
+        case 'trabajando':
+            return 'trabajando';
+        case 'espera':
+            return 'esperando';
+        case 'parado':
+            return 'error';
+        case 'hecho':
+            return 'hecho';
+        default:
+            return 'reposo';
+    }
+}
+const cache = new Map();
+export function fotogramasDe(a, accesorio) {
+    const clave = `${a}|${accesorio ?? ''}`;
+    let f = cache.get(clave);
+    if (!f) {
+        f = ANIMACIONES[a].map((c) => ({ matriz: matrizDe(c, accesorio), ms: c.ms }));
+        cache.set(clave, f);
+    }
+    return f;
+}
+export function duracionDe(a) {
+    return fotogramasDe(a).reduce((s, f) => s + f.ms, 0);
+}
+export function fotogramaEn(a, t, accesorio) {
+    const fs = fotogramasDe(a, accesorio);
+    const total = duracionDe(a);
+    let r = ((t % total) + total) % total;
+    for (const f of fs) {
+        if (r < f.ms)
+            return f;
+        r -= f.ms;
+    }
+    return fs[fs.length - 1];
+}
+export function rectangulosDe(matriz, tono) {
+    const out = [];
+    matriz.forEach((fila, y) => {
+        let x = 0;
+        while (x < LADO) {
+            const c = fila[x];
+            const color = colorDe(c, tono);
+            if (!color) {
+                x++;
+                continue;
+            }
+            let fin = x + 1;
+            while (fin < LADO && fila[fin] === c)
+                fin++;
+            out.push({ x, y, ancho: fin - x, color });
+            x = fin;
+        }
+    });
+    return out;
+}
+export function svgDe(matriz, tono, px = 64) {
+    const r = rectangulosDe(matriz, tono)
+        .map((q) => `<rect x="${q.x}" y="${q.y}" width="${q.ancho}" height="1" fill="${q.color}"/>`)
+        .join('');
+    return `<svg xmlns="http://www.w3.org/2000/svg" width="${px}" height="${px}" viewBox="0 0 16 16" shape-rendering="crispEdges">${r}</svg>`;
+}

package/dist/remoto.js

@@ -0,0 +1,284 @@
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { abrirRemoto, cerrarRemoto, ErrorDeParallel, latidoRemoto, ordenesRemotas } from "./api.js";
+import { sinColor } from "./marca.js";
+export function seContestaDesdeFuera(clase) {
+    return clase !== 'credencial' && clase !== 'bypass';
+}
+const SECRETOS = [
+    /\b(sk|pk|rk)[-_](live|test|proj|ant)?[-_]?[A-Za-z0-9_-]{16,}/g,
+    /\bgh[pousr]_[A-Za-z0-9]{20,}/g,
+    /\bxox[abprs]-[A-Za-z0-9-]{10,}/g,
+    /\bAKIA[0-9A-Z]{16}\b/g,
+    /\bAIza[0-9A-Za-z_-]{30,}/g,
+    /\bpar_(term|key)_[A-Za-z0-9_-]{8,}/g,
+    /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g,
+];
+const CON_NOMBRE = [/\b(Bearer\s+)[A-Za-z0-9._~+/-]{16,}=*/gi, /\b((?:password|passwd|secret|token|api[_-]?key)\s*[:=]\s*['"]?)[^\s'"]{6,}/gi];
+export function taparSecretos(s) {
+    let r = s;
+    for (const re of CON_NOMBRE)
+        r = r.replace(re, (_m, nombre) => `${nombre}[hidden]`);
+    for (const re of SECRETOS)
+        r = r.replace(re, '[hidden]');
+    return r;
+}
+const MAX_TEXTO = 8000;
+export function paraElMovil(v, max = MAX_TEXTO) {
+    const s = taparSecretos(sinColor(typeof v === 'string' ? v : v == null ? '' : String(v)));
+    return s.length > max ? `${s.slice(0, max - 1)}…` : s;
+}
+function limpiar(datos) {
+    const out = {};
+    for (const [k, v] of Object.entries(datos)) {
+        if (typeof v === 'string')
+            out[k] = paraElMovil(v);
+        else if (Array.isArray(v))
+            out[k] = v.slice(0, 60).map((x) => (typeof x === 'string' ? paraElMovil(x, 400) : x && typeof x === 'object' ? limpiar(x) : x));
+        else if (v && typeof v === 'object')
+            out[k] = limpiar(v);
+        else
+            out[k] = v;
+    }
+    return out;
+}
+const API = { abrir: abrirRemoto, latido: latidoRemoto, ordenes: ordenesRemotas, cerrar: cerrarRemoto };
+let contadorDePreguntas = 0;
+export class Remoto {
+    id = null;
+    url = null;
+    o;
+    api;
+    n = 0;
+    cola = [];
+    estado = 'libre';
+    tarea = null;
+    acciones = 0;
+    modo = '';
+    modelo = '';
+    activo = false;
+    enviando = false;
+    otraVez = false;
+    relojEnvio = null;
+    relojLatido = null;
+    escucha = null;
+    ultimoEnvio = 0;
+    preguntas = new Map();
+    constructor(o) {
+        this.o = o;
+        this.api = { ...API, ...o.api };
+    }
+    get encendido() {
+        return this.activo;
+    }
+    async abrir(datos) {
+        const r = await this.api.abrir(this.o.servidor, this.o.token, datos);
+        this.id = r.id;
+        this.url = r.url;
+        this.modo = datos.modo;
+        this.modelo = datos.modelo;
+        this.activo = true;
+        this.relojLatido = setInterval(() => void this.enviar(), this.o.latidoMs ?? 15_000);
+        this.relojLatido.unref?.();
+        void this.enviar();
+        void this.escuchar();
+        return r;
+    }
+    async cerrar() {
+        if (!this.activo)
+            return;
+        this.apagar();
+        if (this.id) {
+            try {
+                await this.api.cerrar(this.o.servidor, this.o.token, this.id);
+            }
+            catch {
+            }
+        }
+    }
+    apagar() {
+        this.activo = false;
+        if (this.carpeta && !this.o.carpetaDeFotos)
+            rmSync(this.carpeta, { recursive: true, force: true });
+        if (this.relojEnvio)
+            clearTimeout(this.relojEnvio);
+        if (this.relojLatido)
+            clearInterval(this.relojLatido);
+        this.relojEnvio = this.relojLatido = null;
+        this.escucha?.abort();
+        this.escucha = null;
+        this.preguntas.clear();
+    }
+    evento(tipo, datos) {
+        if (!this.activo)
+            return;
+        this.cola.push({ n: this.n++, tipo, datos: limpiar(datos) });
+        if (!this.relojEnvio) {
+            this.relojEnvio = setTimeout(() => {
+                this.relojEnvio = null;
+                void this.enviar();
+            }, this.o.cadaMs ?? 400);
+            this.relojEnvio.unref?.();
+        }
+    }
+    fijarEstado(estado, tarea) {
+        if (!this.activo)
+            return;
+        const cambia = estado !== this.estado || (tarea !== undefined && tarea !== this.tarea);
+        this.estado = estado;
+        if (tarea !== undefined)
+            this.tarea = tarea ? paraElMovil(tarea, 200) : null;
+        if (cambia)
+            void this.enviar();
+    }
+    fijarModo(modo, modelo) {
+        this.modo = modo;
+        this.modelo = modelo;
+    }
+    progreso(acciones) {
+        this.acciones = acciones;
+    }
+    preguntaRemota(texto, clase, opciones) {
+        const id = `p${Date.now().toString(36)}${(contadorDePreguntas++).toString(36)}`;
+        const fuera = seContestaDesdeFuera(clase);
+        let deFuera = null;
+        const valores = opciones.map((x) => x.valor);
+        if (this.activo && fuera)
+            deFuera = new Promise((resolver) => this.preguntas.set(id, { resolver, valores }));
+        const anterior = this.estado;
+        this.evento('pregunta', { id, texto, clase, opciones: opciones.map((x) => ({ etiqueta: x.etiqueta, valor: x.valor })), remota: fuera });
+        this.fijarEstado('pregunta');
+        return {
+            id,
+            deFuera,
+            contestada: (valor, desde) => {
+                this.preguntas.delete(id);
+                this.evento('respuesta', { id, valor, desde });
+                this.fijarEstado(anterior === 'pregunta' ? 'trabajando' : anterior);
+            },
+        };
+    }
+    async enviar() {
+        if (!this.activo || !this.id)
+            return;
+        if (this.enviando) {
+            this.otraVez = true;
+            return;
+        }
+        this.enviando = true;
+        try {
+            const tanda = this.cola.slice(0, 200);
+            const r = await this.api.latido(this.o.servidor, this.o.token, this.id, {
+                estado: this.estado,
+                tarea: this.tarea,
+                acciones: this.acciones,
+                modo: this.modo,
+                modelo: this.modelo,
+                eventos: tanda,
+            });
+            this.cola.splice(0, tanda.length);
+            this.ultimoEnvio = Date.now();
+            if (r.cerrado) {
+                this.apagar();
+                this.o.alApagarse('web');
+                return;
+            }
+        }
+        catch (e) {
+            if (this.cola.length > 2000)
+                this.cola.splice(0, this.cola.length - 2000);
+            if (e instanceof ErrorDeParallel && (e.codigo === 'sesion' || e.codigo === 'sin_acceso')) {
+                this.apagar();
+                this.o.alApagarse(e.codigo);
+                return;
+            }
+        }
+        finally {
+            this.enviando = false;
+        }
+        if (this.otraVez || (this.cola.length && !this.relojEnvio)) {
+            this.otraVez = false;
+            void this.enviar();
+        }
+    }
+    async escuchar() {
+        let pausa = 1000;
+        while (this.activo && this.id) {
+            this.escucha = new AbortController();
+            try {
+                const r = await this.api.ordenes(this.o.servidor, this.o.token, this.id, this.o.esperaMs ?? 25_000, this.escucha.signal);
+                pausa = 1000;
+                if (r.cerrado) {
+                    this.apagar();
+                    this.o.alApagarse('web');
+                    return;
+                }
+                for (const orden of r.ordenes)
+                    this.cumplir(orden);
+            }
+            catch (e) {
+                if (!this.activo)
+                    return;
+                if (e instanceof ErrorDeParallel && (e.codigo === 'sesion' || e.codigo === 'sin_acceso')) {
+                    this.apagar();
+                    this.o.alApagarse(e.codigo);
+                    return;
+                }
+                await new Promise((r) => setTimeout(r, pausa).unref?.());
+                pausa = Math.min(30_000, pausa * 2);
+            }
+        }
+    }
+    cumplir(orden) {
+        if (!this.activo)
+            return;
+        if (orden.tipo === 'mensaje') {
+            const texto = typeof orden.datos.texto === 'string' ? orden.datos.texto.trim().slice(0, MAX_TEXTO) : '';
+            const rutas = this.guardarFotos(orden);
+            const conFotos = [texto || (rutas.length ? 'Look at this photo.' : ''), ...rutas.map((r) => `"${r}"`)].filter(Boolean).join(' ');
+            if (conFotos)
+                this.o.alMensaje(conFotos);
+            return;
+        }
+        if (orden.tipo === 'parar') {
+            this.o.alParar();
+            return;
+        }
+        if (orden.tipo === 'respuesta') {
+            const id = String(orden.datos.pregunta ?? '');
+            const valor = orden.datos.valor;
+            const p = this.preguntas.get(id);
+            if (!p || (valor !== 'si' && valor !== 'siempre' && valor !== 'no') || !p.valores.includes(valor))
+                return;
+            this.preguntas.delete(id);
+            p.resolver(valor);
+        }
+    }
+    carpeta = null;
+    guardarFotos(orden) {
+        const fotos = Array.isArray(orden.datos.fotos) ? orden.datos.fotos.slice(0, 3) : [];
+        const rutas = [];
+        fotos.forEach((f, i) => {
+            const ext = f.mime === 'image/png' ? 'png' : f.mime === 'image/webp' ? 'webp' : f.mime === 'image/jpeg' ? 'jpg' : null;
+            if (!ext || typeof f.datos !== 'string' || !/^[A-Za-z0-9+/]+={0,2}$/.test(f.datos))
+                return;
+            const buf = Buffer.from(f.datos, 'base64');
+            if (buf.length < 16 || buf.length > 2_500_000)
+                return;
+            try {
+                this.carpeta ??= this.o.carpetaDeFotos ?? join(tmpdir(), `parx-remoto-${process.pid}`);
+                mkdirSync(this.carpeta, { recursive: true, mode: 0o700 });
+                const ruta = join(this.carpeta, `photo-${orden.id.replace(/[^a-z0-9-]/gi, '').slice(0, 12)}-${i + 1}.${ext}`);
+                writeFileSync(ruta, buf, { mode: 0o600 });
+                rutas.push(ruta);
+            }
+            catch {
+            }
+        });
+        return rutas;
+    }
+    get msDesdeElUltimoEnvio() {
+        return this.ultimoEnvio ? Date.now() - this.ultimoEnvio : Number.POSITIVE_INFINITY;
+    }
+}