@meiti/render 0.0.0-stage → 0.2.0

package/dist/sesion.d.ts

@@ -0,0 +1,129 @@
+import type { Browser, Page } from 'puppeteer';
+import { type MapaPantalla, type ComparacionMapas } from './escaner.js';
+export type Accion = {
+    tipo: 'clic';
+    objetivo: string;
+} | {
+    tipo: 'llenar';
+    objetivo: string;
+    valor: string;
+} | {
+    tipo: 'elegir';
+    objetivo: string;
+    valor: string;
+} | {
+    tipo: 'marcar';
+    objetivo: string;
+    valor?: boolean;
+} | {
+    tipo: 'tecla';
+    tecla: string;
+} | {
+    tipo: 'ir';
+    url: string;
+};
+export interface PedidoRed {
+    metodo: string;
+    url: string;
+    status: number;
+}
+export interface ResultadoAccion {
+    accion: Accion;
+    objetivo: string | null;
+    ok: boolean;
+    error?: string;
+    cambio: ComparacionMapas | null;
+    red: PedidoRed[];
+    errores_pagina: string[];
+    dialogos: string[];
+    ms: number;
+}
+export type Expectativa = {
+    existe: string;
+} | {
+    no_existe: string;
+} | {
+    texto: string;
+    contiene: string;
+} | {
+    aparecio: string;
+} | {
+    desaparecio: string;
+} | {
+    sin_cambios: boolean;
+} | {
+    sin_fallas: true | string[];
+} | {
+    sin_errores: true;
+} | {
+    pedido: {
+        metodo?: string;
+        url_contiene: string;
+        status?: number;
+    };
+} | {
+    cargada: true;
+};
+export interface ResultadoExpectativa {
+    expectativa: Expectativa;
+    cumple: boolean;
+    prueba: string;
+    sin_prueba?: boolean;
+}
+export interface HuellaPagina {
+    url_contiene?: string;
+    titulo_contiene?: string;
+    titulo_es?: string;
+    existe?: string;
+}
+export interface EstadoCarga {
+    veredicto: 'cargada' | 'no_cargo' | 'incompleta' | 'otra_pagina';
+    motivos: string[];
+    http: number | null;
+    url: string;
+    titulo: string;
+    listo: string;
+    visibles: number;
+    texto: number;
+    pendientes: number;
+    huella?: {
+        cumple: boolean;
+        prueba: string;
+    };
+}
+/** El índice en el mapa del elemento al que se refiere el agente (-1 si no está). */
+export declare function resolver(mapa: MapaPantalla, objetivo: string): number;
+export declare class SesionRender {
+    readonly pagina: Page;
+    mapa: MapaPantalla | null;
+    ultima: ResultadoAccion | null;
+    private red;
+    private errores;
+    private dialogos;
+    estado: EstadoCarga | null;
+    huella: HuellaPagina | null;
+    private http;
+    private enCurso;
+    private errorNavegacion;
+    private constructor();
+    /**
+     * ¿Cargó la página? (y, con huella, ¿es la que se esperaba?). Se recalcula después de abrir y de cada acción.
+     * Señales del navegador, no adivinanzas: código HTTP, página de error del navegador, readyState, pedidos en curso,
+     * contenido visible y una pantalla que solo dice "error".
+     */
+    medirCarga(): Promise<EstadoCarga>;
+    /** La huella de la página que se espera (algo que la identifica): sin ella, el navegador sabe si cargó, no si es la correcta. */
+    esperarPagina(huella: HuellaPagina): Promise<EstadoCarga>;
+    static abrir(navegador: Browser, url: string, pantalla?: {
+        ancho: number;
+        alto: number;
+    }, preparar?: (pagina: Page) => Promise<void>): Promise<SesionRender>;
+    escanear(): Promise<MapaPantalla>;
+    private marcoDe;
+    private elemento;
+    /** Acción → escaneo → mapa nuevo → comparación con el anterior. */
+    hacer(accion: Accion): Promise<ResultadoAccion>;
+    /** El agente dice qué espera; la sesión contesta sí o no, con la prueba. */
+    verificar(expectativas: Expectativa[]): ResultadoExpectativa[];
+    cerrar(): Promise<void>;
+}

package/dist/sesion.js

@@ -0,0 +1,289 @@
+import { escanear, escanearEstable, comparar, referenciaDe } from './escaner.js';
+const PANTALLA_DE_ERROR = /^(?:\s*(?:error\b|404\b|403\b|500\b|502\b|503\b)|[\s\S]*\b(?:not found|cannot get|application error|something went wrong|no se pudo cargar|page not found|internal server error|bad gateway|service unavailable)\b)/i;
+const normal = (s) => (s ?? '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase().replace(/\s+/g, ' ').trim();
+const INTERACTIVOS = new Set(['button', 'link', 'textbox', 'combobox', 'checkbox', 'radio', 'tab', 'menuitem', 'switch', 'option']);
+const describir = (e) => `${e.rol}${e.nombre ? ` "${e.nombre}"` : e.texto ? ` "${e.texto.slice(0, 60)}"` : ''}${e.valor !== undefined ? ` = "${e.valor}"` : ''} @${e.caja.x},${e.caja.y}`;
+/** El índice en el mapa del elemento al que se refiere el agente (-1 si no está). */
+export function resolver(mapa, objetivo) {
+    const els = mapa.elementos;
+    const exacto = els.findIndex((e) => e.id === objetivo);
+    if (exacto >= 0)
+        return exacto;
+    // 🩹 [2026-11-13, examen de uso real v2: el modelo copió la línea del mapa, 'combobox "Categoría"', y no se encontraba] Se acepta
+    // el objetivo como lo escribe un modelo: "rol:nombre", 'rol "nombre"' (con o sin la comilla de cierre) y lo que sobra después de
+    // un " | " o un " = " (restos del formato de la respuesta) se descarta.
+    const limpio = objetivo.split(/\s+[|=]\s*/)[0].trim();
+    let rol = null, texto = limpio;
+    const m = /^([a-z]+):(.+)$/.exec(limpio) || /^([a-z]+)\s+["'“‘](.+?)["'”’]?$/.exec(limpio);
+    if (m && els.some((e) => e.rol === m[1])) {
+        rol = m[1];
+        texto = m[2].trim();
+    }
+    if (texto !== objetivo) {
+        const exacto2 = els.findIndex((e) => e.id === (rol ? `${rol}:${texto}` : texto));
+        if (exacto2 >= 0)
+            return exacto2;
+    }
+    const buscado = normal(texto);
+    const candidatos = els.map((e, i) => ({ e, i })).filter(({ e }) => e.visible && (!rol || e.rol === rol));
+    const puntaje = (e) => {
+        const n = normal(e.nombre), t = normal(e.texto);
+        const base = n === buscado || t === buscado ? 3 : n.includes(buscado) || t.includes(buscado) ? 1 : 0;
+        return base ? base + (INTERACTIVOS.has(e.rol) ? 1 : 0) : 0;
+    };
+    const mejor = candidatos.map((c) => ({ ...c, p: puntaje(c.e) })).filter((c) => c.p > 0).sort((a, b) => b.p - a.p)[0];
+    return mejor ? mejor.i : -1;
+}
+/** Lo más parecido a lo que pidió el agente, para decirle qué hay cuando no encuentra lo que busca. */
+function parecidos(mapa, objetivo) {
+    const palabras = normal(objetivo).split(/[\s:]+/).filter((p) => p.length > 2);
+    return mapa.elementos.filter((e) => e.visible && INTERACTIVOS.has(e.rol))
+        .map((e) => ({ e, p: palabras.filter((w) => normal(e.nombre).includes(w) || normal(e.texto).includes(w)).length }))
+        .sort((a, b) => b.p - a.p).slice(0, 5).map(({ e }) => e.id);
+}
+export class SesionRender {
+    pagina;
+    mapa = null;
+    ultima = null;
+    red = [];
+    errores = [];
+    dialogos = [];
+    estado = null;
+    huella = null;
+    http = null;
+    enCurso = 0;
+    errorNavegacion = null;
+    constructor(pagina) {
+        this.pagina = pagina;
+        pagina.on('response', (r) => {
+            const tipo = r.request().resourceType();
+            if (tipo === 'xhr' || tipo === 'fetch' || tipo === 'document')
+                this.red.push({ metodo: r.request().method(), url: r.url(), status: r.status() });
+        });
+        pagina.on('console', (m) => { if (m.type() === 'error')
+            this.errores.push(m.text().slice(0, 300)); });
+        pagina.on('pageerror', (e) => { this.errores.push(String(e?.message || e).slice(0, 300)); });
+        // 🩹 [Aprendido de MEITI, ojo_optico.js] Un alert()/confirm() sin contestar deja la página congelada y cuelga todo lo que
+        // sigue: se acepta solo y queda anotado como dialogo (el agente lo ve en la respuesta de la acción).
+        pagina.on('dialog', (d) => { this.dialogos.push(`${d.type()}: ${d.message().slice(0, 200)}`); d.accept().catch(() => { }); });
+        // El código del documento principal (la navegación del marco principal) y los pedidos que siguen en curso.
+        pagina.on('response', (r) => { if (r.request().isNavigationRequest() && r.frame() === pagina.mainFrame())
+            this.http = r.status(); });
+        pagina.on('request', () => { this.enCurso++; });
+        pagina.on('requestfinished', () => { this.enCurso = Math.max(0, this.enCurso - 1); });
+        pagina.on('requestfailed', (r) => { this.enCurso = Math.max(0, this.enCurso - 1); if (r.isNavigationRequest() && r.frame() === pagina.mainFrame())
+            this.errorNavegacion = r.failure()?.errorText || 'navigation failed'; });
+    }
+    /**
+     * ¿Cargó la página? (y, con huella, ¿es la que se esperaba?). Se recalcula después de abrir y de cada acción.
+     * Señales del navegador, no adivinanzas: código HTTP, página de error del navegador, readyState, pedidos en curso,
+     * contenido visible y una pantalla que solo dice "error".
+     */
+    async medirCarga() {
+        const pagina = this.pagina;
+        // Que la red se calme (hasta 3 s). Lo que siga abierto después (un canal en vivo, un sondeo) es normal en muchas apps: se
+        // informa en "pendientes", pero no baja el veredicto (medido en meiti.dev: siempre queda 1 abierto).
+        await pagina.waitForNetworkIdle({ idleTime: 300, timeout: 3_000 }).catch(() => { });
+        const info = (await pagina.evaluate(`({ listo: document.readyState, titulo: document.title || '', url: location.href, texto: (document.body && document.body.innerText || '').trim().length, primero: ((document.body && document.body.innerText) || '').trim().slice(0, 160) })`).catch(() => null));
+        const mapa = this.mapa;
+        const visibles = mapa ? mapa.elementos.filter((e) => e.visible).length : 0;
+        const motivos = [];
+        const url = info?.url || pagina.url();
+        if (this.errorNavegacion)
+            motivos.push(`the navigation failed: ${this.errorNavegacion}`);
+        if (url.startsWith('chrome-error://'))
+            motivos.push('the browser showed its own error page');
+        if (this.http === null && !this.errorNavegacion && !/^(about|data|blob):/.test(url))
+            motivos.push('the page document got no response');
+        if (this.http !== null && this.http >= 400)
+            motivos.push(`the page document answered HTTP ${this.http}`);
+        if (!info)
+            motivos.push('the page could not be read');
+        if (info && !info.texto && visibles === 0)
+            motivos.push('nothing visible on the page');
+        // Una pantalla con casi nada y que dice "error": cargó el documento, pero la app no.
+        if (info && visibles <= 3 && (PANTALLA_DE_ERROR.test(info.primero) || PANTALLA_DE_ERROR.test(info.titulo)))
+            motivos.push(`the screen only shows an error: "${(info.primero || info.titulo).slice(0, 100)}"`);
+        let veredicto = motivos.length ? 'no_cargo' : 'cargada';
+        if (veredicto === 'cargada' && info && info.listo !== 'complete') {
+            veredicto = 'incompleta';
+            motivos.push(`the document is still "${info.listo}"`);
+        }
+        let huella;
+        if (this.huella && veredicto !== 'no_cargo') {
+            const h = this.huella, fallan = [], ok = [];
+            if (h.url_contiene)
+                (url.includes(h.url_contiene) ? ok : fallan).push(`url ${url.includes(h.url_contiene) ? 'has' : 'does not have'} "${h.url_contiene}" (${url.slice(0, 120)})`);
+            if (h.titulo_contiene)
+                (normal(info?.titulo).includes(normal(h.titulo_contiene)) ? ok : fallan).push(`title "${info?.titulo || ''}"`);
+            // Título exacto: cuando el nombre de la app también aparece en otras páginas (una app llamada "Meiti" contra la de MEITI).
+            if (h.titulo_es)
+                (normal(info?.titulo) === normal(h.titulo_es) ? ok : fallan).push(`title "${info?.titulo || ''}"`);
+            if (h.existe) {
+                const i = mapa ? resolver(mapa, h.existe) : -1;
+                (i >= 0 ? ok : fallan).push(i >= 0 ? describir(mapa.elementos[i]) : `"${h.existe}" is not on the screen`);
+            }
+            huella = { cumple: !fallan.length, prueba: fallan.length ? fallan.join('; ') : ok.join('; ') };
+            if (!huella.cumple) {
+                veredicto = 'otra_pagina';
+                motivos.push(`it is not the expected page: ${huella.prueba}`);
+            }
+        }
+        this.estado = { veredicto, motivos, http: this.http, url, titulo: info?.titulo || '', listo: info?.listo || '?', visibles, texto: info?.texto || 0, pendientes: this.enCurso, ...(huella ? { huella } : {}) };
+        return this.estado;
+    }
+    /** La huella de la página que se espera (algo que la identifica): sin ella, el navegador sabe si cargó, no si es la correcta. */
+    async esperarPagina(huella) {
+        this.huella = huella;
+        return this.medirCarga();
+    }
+    static async abrir(navegador, url, pantalla = { ancho: 1280, alto: 800 }, preparar) {
+        const pagina = await navegador.newPage();
+        await pagina.setViewport({ width: pantalla.ancho, height: pantalla.alto });
+        if (preparar)
+            await preparar(pagina); // por ejemplo, un servidor simulado (exámenes)
+        const sesion = new SesionRender(pagina);
+        // Una navegación que falla o tarda demasiado no corta: queda en el estado de carga ("no cargó", con el motivo).
+        await pagina.goto(url, { waitUntil: 'networkidle2', timeout: 60_000 }).catch((e) => { if (!sesion.errorNavegacion)
+            sesion.errorNavegacion = String(e?.message || e).split('\n')[0].slice(0, 160); });
+        sesion.mapa = await escanearEstable(pagina);
+        await sesion.medirCarga();
+        return sesion;
+    }
+    async escanear() {
+        this.mapa = await escanear(this.pagina);
+        return this.mapa;
+    }
+    // El elemento real, en su marco (documento principal o el iframe de su molde, ver escaner.ts).
+    marcoDe(mapa, indice) {
+        const r = referenciaDe(mapa, indice);
+        if (!r || r.marco.detached)
+            throw new Error('the screen changed since the last scan: scan again');
+        return r;
+    }
+    async elemento(mapa, indice) {
+        const r = this.marcoDe(mapa, indice);
+        const h = await r.marco.evaluateHandle(`window.__renderRefs && window.__renderRefs[${r.indice}]`);
+        const el = h.asElement();
+        if (!el)
+            throw new Error('the element is no longer on the page');
+        return el;
+    }
+    /** Acción → escaneo → mapa nuevo → comparación con el anterior. */
+    async hacer(accion) {
+        const inicio = Date.now();
+        const antes = this.mapa ?? (await this.escanear());
+        this.red = [];
+        this.errores = [];
+        this.dialogos = [];
+        let objetivo = null;
+        try {
+            if ('objetivo' in accion) {
+                const i = resolver(antes, accion.objetivo);
+                if (i < 0) {
+                    const hay = parecidos(antes, accion.objetivo);
+                    throw new Error(`could not find "${accion.objetivo}" on the screen${hay.length ? `; on the screen there is: ${hay.join(', ')}` : ''}`);
+                }
+                objetivo = antes.elementos[i].id;
+                const el = await this.elemento(antes, i);
+                if (accion.tipo === 'clic')
+                    await el.click();
+                else if (accion.tipo === 'llenar') {
+                    await el.click({ count: 3 });
+                    await this.pagina.keyboard.press('Backspace');
+                    await el.type(accion.valor);
+                }
+                else if (accion.tipo === 'marcar') {
+                    if (!!antes.elementos[i].estado?.marcado !== (accion.valor ?? true))
+                        await el.click();
+                }
+                else if (accion.tipo === 'elegir') {
+                    const elegido = await this.marcoDe(antes, i).marco.evaluate(`(function () {
+            var el = window.__renderRefs[${this.marcoDe(antes, i).indice}], v = ${JSON.stringify(accion.valor)}.toLowerCase();
+            for (var k = 0; k < el.options.length; k++) {
+              var o = el.options[k];
+              if (o.value.toLowerCase() === v || o.text.trim().toLowerCase() === v) { el.value = o.value; el.dispatchEvent(new Event('input', { bubbles: true })); el.dispatchEvent(new Event('change', { bubbles: true })); return true; }
+            }
+            return false;
+          })()`);
+                    if (!elegido)
+                        throw new Error(`"${accion.objetivo}" has no option "${accion.valor}"`);
+                }
+            }
+            else if (accion.tipo === 'tecla')
+                await this.pagina.keyboard.press(accion.tecla);
+            else if (accion.tipo === 'ir') {
+                this.http = null;
+                this.errorNavegacion = null;
+                await this.pagina.goto(accion.url, { waitUntil: 'networkidle2', timeout: 60_000 }).catch((e) => { this.errorNavegacion = String(e?.message || e).split('\n')[0].slice(0, 160); });
+            }
+            // Que termine lo que la acción disparó (pedidos, animaciones cortas) antes de volver a escanear.
+            await this.pagina.waitForNetworkIdle({ idleTime: 300, timeout: 4_000 }).catch(() => { });
+            await new Promise((ok) => setTimeout(ok, 150));
+            const despues = await escanearEstable(this.pagina, { maxMs: 6_000 });
+            this.mapa = despues;
+            this.ultima = { accion, objetivo, ok: true, cambio: comparar(antes, despues), red: [...this.red], errores_pagina: [...this.errores], dialogos: [...this.dialogos], ms: Date.now() - inicio };
+            await this.medirCarga();
+        }
+        catch (error) {
+            this.ultima = { accion, objetivo, ok: false, error: String(error?.message || error), cambio: null, red: [...this.red], errores_pagina: [...this.errores], dialogos: [...this.dialogos], ms: Date.now() - inicio };
+        }
+        return this.ultima;
+    }
+    /** El agente dice qué espera; la sesión contesta sí o no, con la prueba. */
+    verificar(expectativas) {
+        const mapa = this.mapa;
+        const u = this.ultima;
+        const estado = this.estado;
+        const sinCarga = estado && estado.veredicto !== 'cargada' && estado.veredicto !== 'incompleta' ? `cannot prove it: ${estado.veredicto === 'otra_pagina' ? 'this is not the expected page' : 'the page did not load'} (${estado.motivos.join('; ')})` : null;
+        return expectativas.map((x) => {
+            if (!mapa)
+                return { expectativa: x, cumple: false, prueba: 'no map yet' };
+            if ('cargada' in x)
+                return { expectativa: x, cumple: estado?.veredicto === 'cargada', prueba: estado ? `${estado.veredicto}${estado.motivos.length ? `: ${estado.motivos.join('; ')}` : ` (HTTP ${estado.http ?? '?'}, ${estado.visibles} visible elements)`}` : 'not measured' };
+            // Lo negativo ("no está", "no cambió", "desapareció") con una página que no cargó, o que no es la esperada, no es prueba.
+            if (sinCarga && ('no_existe' in x || 'sin_cambios' in x || 'desaparecio' in x))
+                return { expectativa: x, cumple: false, sin_prueba: true, prueba: sinCarga };
+            const buscar = (o) => { const i = resolver(mapa, o); return i >= 0 ? mapa.elementos[i] : null; };
+            if ('existe' in x) {
+                const e = buscar(x.existe);
+                return { expectativa: x, cumple: !!e, prueba: e ? describir(e) : `"${x.existe}" is not on the screen` };
+            }
+            if ('no_existe' in x) {
+                const e = buscar(x.no_existe);
+                return { expectativa: x, cumple: !e, prueba: e ? `it is there: ${describir(e)}` : 'not there' };
+            }
+            if ('texto' in x) {
+                const e = buscar(x.texto);
+                const dice = e ? [e.valor, e.texto, e.nombre].filter((v) => v !== undefined).join(' | ') : '';
+                return { expectativa: x, cumple: !!e && normal(dice).includes(normal(x.contiene)), prueba: e ? `${e.id} says "${dice}"` : `"${x.texto}" is not on the screen` };
+            }
+            if ('aparecio' in x || 'desaparecio' in x) {
+                const lista = 'aparecio' in x ? u?.cambio?.aparecieron : u?.cambio?.desaparecieron;
+                const buscado = normal('aparecio' in x ? x.aparecio : x.desaparecio);
+                const e = lista?.find((el) => el.id === ('aparecio' in x ? x.aparecio : x.desaparecio) || normal(el.nombre).includes(buscado) || normal(el.texto).includes(buscado));
+                return { expectativa: x, cumple: !!e, prueba: e ? describir(e) : `after the last action: ${u?.cambio?.resumen ?? 'no action yet'}` };
+            }
+            if ('sin_cambios' in x) {
+                const sin = !!u?.cambio?.sin_cambios;
+                return { expectativa: x, cumple: sin === x.sin_cambios, prueba: u?.cambio?.resumen ?? 'no action yet' };
+            }
+            if ('sin_fallas' in x) {
+                const fallas = mapa.fallas.filter((f) => x.sin_fallas === true || x.sin_fallas.includes(f.tipo));
+                return { expectativa: x, cumple: !fallas.length, prueba: fallas.length ? fallas.map((f) => `${f.tipo}${f.id ? ` en ${f.id}` : ''}: ${f.detalle}`).join('; ') : 'none' };
+            }
+            if ('sin_errores' in x) {
+                const err = u?.errores_pagina ?? [];
+                return { expectativa: x, cumple: !err.length, prueba: err.length ? err.join(' | ') : 'none' };
+            }
+            if ('pedido' in x) {
+                const p = x.pedido;
+                const coinciden = (u?.red ?? []).filter((r) => r.url.includes(p.url_contiene) && (!p.metodo || r.metodo === p.metodo.toUpperCase()));
+                const ok = coinciden.some((r) => p.status === undefined ? r.status < 400 : r.status === p.status);
+                return { expectativa: x, cumple: ok, prueba: coinciden.length ? coinciden.map((r) => `${r.metodo} ${r.url} → ${r.status}`).join('; ') : `no requests to "${p.url_contiene}"` };
+            }
+            return { expectativa: x, cumple: false, prueba: 'unknown expectation' };
+        });
+    }
+    async cerrar() { await this.pagina.close().catch(() => { }); }
+}

package/mcp.mjs

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+// 🛰️ @meiti/render: servidor MCP por stdio (JSON-RPC 2.0) para que un agente pruebe una pantalla sin fotos ni coordenadas.
+// Abre una sesión de navegador y la mantiene: cada acción es acción → escaneo → mapa nuevo → comparación con el anterior
+// (idea del usuario: "como un GPS y un escáner; comparar el mapa 1 con el mapa 2 es ver"). El motor vive en dist/ (armado
+// desde Healer, sanador/src/render). Textos para agentes en inglés, como todo lo que es para clientes.
+import readline from 'node:readline';
+import puppeteer from 'puppeteer';
+import { SesionRender, mapaEnTexto, rutasDeLaApp, recorrerApp, compararVersiones, resolver } from './dist/index.js';
+
+const VERSION = '0.2.0';
+const sesiones = new Map();
+// 0.2.0 (2026-11-15, aprendido probando apps reales de MEITI con login): cada sesión en su propio contexto (nada se filtra de
+// una a otra), sesión cargada ANTES de abrir (storage, cookies, headers), esperar un elemento que llega tarde (wait_for) y los
+// pedidos que fallan al cargar. id de sesión → { contexto, fallidos }.
+const extras = new Map();
+const espera = (ms) => new Promise((r) => setTimeout(r, ms));
+// 🧱 El estado de carga en una línea (ver EstadoCarga en sesion.ts): cargada, no cargó, incompleta u otra página.
+const ETIQUETA_CARGA = { cargada: 'LOADED', no_cargo: 'DID NOT LOAD', incompleta: 'STILL LOADING', otra_pagina: 'NOT THE EXPECTED PAGE' };
+function estadoEnTexto(e) {
+  if (!e) return 'Page: not measured';
+  const datos = `HTTP ${e.http ?? 'none'}, ${e.visibles} visible elements${e.pendientes ? `, ${e.pendientes} requests in flight` : ''}`;
+  return `Page: ${ETIQUETA_CARGA[e.veredicto] || e.veredicto} (${datos})${e.motivos.length ? ` · ${e.motivos.join('; ')}` : ''}${e.huella?.cumple ? ` · expected page: ${e.huella.prueba}` : ''}`;
+}
+const huellaInterna = (x) => (x && typeof x === 'object' ? { ...(x.url_contains ? { url_contiene: String(x.url_contains) } : {}), ...(x.title_contains ? { titulo_contiene: String(x.title_contains) } : {}), ...(x.title_is ? { titulo_es: String(x.title_is) } : {}), ...(x.exists ? { existe: String(x.exists) } : {}) } : null);
+let navegador = null;
+// Chrome: MEITI_RENDER_CHROME si se indica, el que descargó puppeteer, o el Chrome instalado en la máquina. Con npm 11+ los
+// scripts de instalación pueden quedar bloqueados y puppeteer no descarga el suyo: entonces se usa el del sistema.
+const ARGS = ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage'];
+async function lanzar() {
+  if (process.env.MEITI_RENDER_CHROME) return puppeteer.launch({ headless: true, args: ARGS, executablePath: process.env.MEITI_RENDER_CHROME });
+  try { return await puppeteer.launch({ headless: true, args: ARGS }); } catch (propio) {
+    try { return await puppeteer.launch({ headless: true, args: ARGS, channel: 'chrome' }); } catch {
+      throw new Error(`No Chrome found (${String(propio?.message || propio).split(String.fromCharCode(10))[0]}). Install one with "npx puppeteer browsers install chrome", or set MEITI_RENDER_CHROME to the path of a Chrome or Chromium executable.`);
+    }
+  }
+}
+const abrirNavegador = async () => (navegador ??= await lanzar());
+
+const ACCIONES = { click: 'clic', fill: 'llenar', select: 'elegir', check: 'marcar', key: 'tecla', goto: 'ir' };
+function accionInterna(a) {
+  const tipo = ACCIONES[a?.type];
+  if (!tipo) throw new Error('action.type is one of: click, fill, select, check, key, goto');
+  if (tipo === 'tecla') return { tipo, tecla: String(a.key || '') };
+  if (tipo === 'ir') return { tipo, url: String(a.url || '') };
+  if (!a.target) throw new Error('action.target is required (an id from the map, a label or a visible text)');
+  if (tipo === 'marcar') return { tipo, objetivo: String(a.target), valor: a.value === undefined ? true : !!a.value };
+  return { tipo, objetivo: String(a.target), ...(tipo === 'llenar' || tipo === 'elegir' ? { valor: String(a.value ?? '') } : {}) };
+}
+function expectativaInterna(x) {
+  if ('exists' in x) return { existe: String(x.exists) };
+  if ('not_exists' in x) return { no_existe: String(x.not_exists) };
+  if ('text' in x) return { texto: String(x.text), contiene: String(x.contains ?? '') };
+  if ('appeared' in x) return { aparecio: String(x.appeared) };
+  if ('disappeared' in x) return { desaparecio: String(x.disappeared) };
+  if ('no_changes' in x) return { sin_cambios: !!x.no_changes };
+  if ('no_issues' in x) return { sin_fallas: Array.isArray(x.no_issues) ? x.no_issues : true };
+  if ('no_errors' in x) return { sin_errores: true };
+  if ('request' in x) return { pedido: { metodo: x.request?.method, url_contiene: String(x.request?.url_contains ?? ''), status: x.request?.status } };
+  if ('loaded' in x) return { cargada: true };
+  throw new Error(`Unknown expectation: ${JSON.stringify(x)}`);
+}
+const sesionDe = (id) => { const s = sesiones.get(String(id)); if (!s) throw new Error(`No open session "${id}". Call render_open first.`); return s; };
+const fallasEnTexto = (fallas) => (fallas.length ? fallas.map((f) => `- ${f.tipo}${f.id ? ` (${f.id})` : ''}: ${f.detalle}`).join('\n') : 'none');
+
+const HERRAMIENTAS = [
+  {
+    name: 'render_open',
+    description: 'Open a page in a real browser and return its MAP: every element that matters (role, name, text, value, state, position) plus visual issues measured exactly (horizontal overflow, cut text, covered or off-screen elements, small touch targets, low contrast, broken images, unnamed buttons). Works inside same-origin iframes. Returns a session id for render_act, render_expect and render_scan.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        url: { type: 'string' },
+        width: { type: 'number', description: 'Viewport width. Default 1280; use 375 for a phone.' },
+        height: { type: 'number', description: 'Default 800.' },
+        storage: { type: 'object', description: 'localStorage entries to set on the page origin BEFORE it loads, as { key: value }. Use it to open an app already signed in (the same keys its login leaves), without driving the login screen.' },
+        cookies: { type: 'array', items: { type: 'object' }, description: 'Cookies to set before loading, on the page origin: [{ "name": "...", "value": "..." }].' },
+        headers: { type: 'object', description: 'Extra HTTP headers sent with every request of this session, as { name: value }.' },
+        wait_for: { type: 'string', description: 'An element that appears late (after a request): wait up to 15 s for it (an id from the map, a label or a visible text) before returning the map.' },
+        expect_page: { type: 'object', description: 'What identifies the page you meant to open: { "url_contains": "...", "title_contains": "...", "title_is": "...", "exists": "..." } (any of them; title_is is an exact title, for names that also appear on other pages). The browser knows whether a page loaded, not whether it is the RIGHT page: with this, a different page (a landing page, a login, a redirect) is reported as NOT THE EXPECTED PAGE, and negative checks on it cannot pass.' }
+      },
+      required: ['url']
+    },
+    async run(a) {
+      const url = String(a.url);
+      const origen = new URL(url).origin;
+      // Un contexto propio por sesión: lo que una guarda (storage, cookies) no lo ve la siguiente.
+      const contexto = await (await abrirNavegador()).createBrowserContext();
+      if (a.storage && typeof a.storage === 'object' && Object.keys(a.storage).length) {
+        const previa = await contexto.newPage();
+        await previa.goto(origen + '/robots.txt', { waitUntil: 'domcontentloaded' }).catch(() => {});
+        await previa.evaluate((pares) => { for (const [k, v] of pares) localStorage.setItem(k, String(v)); }, Object.entries(a.storage)).catch(() => {});
+        await previa.close();
+      }
+      const fallidos = [];
+      const sesion = await SesionRender.abrir(contexto, url, { ancho: Number(a.width) || 1280, alto: Number(a.height) || 800 }, async (pagina) => {
+        if (Array.isArray(a.cookies) && a.cookies.length) await pagina.setCookie(...a.cookies.map((c) => ({ url: origen, name: String(c.name), value: String(c.value ?? '') })));
+        if (a.headers && typeof a.headers === 'object') await pagina.setExtraHTTPHeaders(Object.fromEntries(Object.entries(a.headers).map(([k, v]) => [k, String(v)])));
+        pagina.on('response', (r) => { if (r.status() >= 400 && fallidos.length < 30) fallidos.push(`${r.status()} ${r.request().method()} ${r.url().replace(/[?#].*/, '')}`); });
+      });
+      if (a.wait_for) {
+        const hasta = Date.now() + 15000;
+        while (Date.now() < hasta && resolver(sesion.mapa, String(a.wait_for)) < 0) { await espera(500); await sesion.escanear(); }
+      }
+      if (a.expect_page) await sesion.esperarPagina(huellaInterna(a.expect_page)); else await sesion.medirCarga();
+      const id = Math.random().toString(36).slice(2, 10);
+      sesiones.set(id, sesion);
+      extras.set(id, { contexto, fallidos });
+      const partes = [`Session ${id}`, estadoEnTexto(sesion.estado)];
+      if (a.wait_for) partes.push(resolver(sesion.mapa, String(a.wait_for)) >= 0 ? `Waited for "${a.wait_for}": it is there.` : `Waited 15 s for "${a.wait_for}": it did not appear.`);
+      if (fallidos.length) partes.push(`Requests that failed while loading:\n${fallidos.map((f) => `- ${f}`).join('\n')}`);
+      partes.push('', mapaEnTexto(sesion.mapa));
+      return partes.join('\n');
+    },
+  },
+  {
+    name: 'render_act',
+    description: 'Do one action by INTENT (no coordinates) and return what changed on the screen: elements that appeared, disappeared, changed or moved (or "nothing changed": a control that does nothing), requests to the server with their status, page errors and native dialogs (accepted automatically). target is an id from the map (like "button:Save"), a label or a visible text; if it is not on the screen, the answer lists what is there.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        session: { type: 'string' },
+        action: { type: 'object', description: '{ "type": "click" | "fill" | "select" | "check" | "key" | "goto", "target": "...", "value": "...", "key": "Enter", "url": "..." }' },
+        include_map: { type: 'boolean', description: 'Also return the full new map. Default false (the change is usually enough).' },
+      },
+      required: ['session', 'action'],
+    },
+    async run(a) {
+      const sesion = sesionDe(a.session);
+      const r = await sesion.hacer(accionInterna(a.action));
+      if (!r.ok) return `Could not do it: ${r.error}`;
+      const red = r.red.filter((p) => !/\.(css|js|png|jpe?g|svg|woff2?|ico)(\?|$)/.test(p.url));
+      return [
+        `Acted on ${r.objetivo ?? '(page)'} in ${r.ms} ms.`,
+        `What changed: ${r.cambio?.resumen}`,
+        sesion.estado && sesion.estado.veredicto !== 'cargada' ? estadoEnTexto(sesion.estado) : '',
+        red.length ? `Requests:\n${red.map((p) => `- ${p.metodo} ${p.url} → ${p.status}`).join('\n')}` : 'Requests: none',
+        `Page errors: ${r.errores_pagina.length ? r.errores_pagina.join(' | ') : 'none'}`,
+        r.dialogos.length ? `Native dialogs (accepted): ${r.dialogos.join(' | ')}` : '',
+        r.cambio?.fallas_nuevas.length ? `New visual issues:\n${fallasEnTexto(r.cambio.fallas_nuevas)}` : '',
+        a.include_map ? `\n${mapaEnTexto(sesion.mapa)}` : '',
+      ].filter(Boolean).join('\n');
+    },
+  },
+  {
+    name: 'render_expect',
+    description: 'Check what you expect against the current screen and the last action; each answer is yes or no with its proof (the exact element or request). Expectations: {"exists": "..."}, {"not_exists": "..."}, {"text": "...", "contains": "..."}, {"appeared": "..."}, {"disappeared": "..."}, {"no_changes": true}, {"no_issues": true | ["contraste", ...]}, {"no_errors": true, "ignore": ["text of errors that are not yours, like a blocked analytics script"]}, {"request": {"method": "POST", "url_contains": "/api/x", "status": 201}}, {"loaded": true}. A negative check ("not_exists", "no_changes", "disappeared") on a page that did not load, or that is not the expected page, answers CANNOT PROVE instead of YES. Tip: "not_exists" only proves something if the page loaded: check something that must be there too.',
+    inputSchema: { type: 'object', properties: { session: { type: 'string' }, expectations: { type: 'array', items: { type: 'object' } } }, required: ['session', 'expectations'] },
+    async run(a) {
+      const resultados = sesionDe(a.session).verificar((a.expectations || []).map(expectativaInterna));
+      // no_errors con "ignore": los errores que no son de la app (un script de analítica bloqueado) no cuentan.
+      (a.expectations || []).forEach((x, i) => {
+        if (!x || !('no_errors' in x) || !Array.isArray(x.ignore) || resultados[i].cumple) return;
+        const propios = String(resultados[i].prueba).split(' | ').filter((e) => !x.ignore.some((patron) => e.includes(String(patron))));
+        resultados[i] = { ...resultados[i], cumple: propios.length === 0, prueba: propios.length ? propios.join(' | ') : 'no errors of its own (some ignored)' };
+      });
+      // Se devuelve la expectativa tal como la mandó el agente (no la forma interna).
+      return resultados.map((r, i) => `${r.sin_prueba ? 'CANNOT PROVE' : r.cumple ? 'YES' : 'NO '} ${JSON.stringify(a.expectations[i])} · ${r.prueba}`).join('\n');
+    },
+  },
+  {
+    name: 'render_scan',
+    description: 'Scan the current screen again (waits until it is stable) and return the full map with its visual issues.',
+    inputSchema: { type: 'object', properties: { session: { type: 'string' } }, required: ['session'] },
+    async run(a) { const s = sesionDe(a.session); await s.escanear(); await s.medirCarga(); return `${estadoEnTexto(s.estado)}\n\n${mapaEnTexto(s.mapa)}`; },
+  },
+  {
+    name: 'render_compare',
+    description: 'Compare two versions of the same app (for example before and after a change): the home page and up to 3 pages it links to, on a phone and a desktop. Says WORSE if a visual issue appears, an interactive element disappears or a page stops opening; BETTER if issues were fixed; SAME otherwise.',
+    inputSchema: { type: 'object', properties: { url_before: { type: 'string' }, url_after: { type: 'string' } }, required: ['url_before', 'url_after'] },
+    async run(a) {
+      const pagina = await (await abrirNavegador()).newPage();
+      try {
+        const rutas = await rutasDeLaApp(pagina, String(a.url_after)).catch(() => ['/']);
+        const despues = await recorrerApp(pagina, String(a.url_after), rutas);
+        const antes = await recorrerApp(pagina, String(a.url_before), rutas);
+        const r = compararVersiones(antes, despues);
+        const etiqueta = { peor: 'WORSE', mejor: 'BETTER', igual: 'SAME', sin_datos: 'NO DATA' }[r.veredicto];
+        return [`${etiqueta}: ${r.resumen}`, `Pages: ${rutas.join(', ')} (${r.pantallas} screens). Visual issues before ${r.fallas_antes}, after ${r.fallas_despues}.`,
+          ...r.regresiones.map((x) => `- ${x.tipo} · ${x.pantalla} · ${x.detalle}`), ...r.mejoras.map((m) => `+ fixed · ${m}`)].join('\n');
+      } finally { await pagina.close().catch(() => {}); }
+    },
+  },
+  {
+    name: 'render_close',
+    description: 'Close a session.',
+    inputSchema: { type: 'object', properties: { session: { type: 'string' } }, required: ['session'] },
+    async run(a) {
+      const id = String(a.session);
+      const s = sesiones.get(id);
+      if (s) { await s.cerrar().catch(() => {}); sesiones.delete(id); }
+      const x = extras.get(id);
+      if (x) { await x.contexto.close().catch(() => {}); extras.delete(id); }
+      return 'Closed.';
+    },
+  },
+];
+
+const responder = (id, result) => process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, result }) + '\n');
+const fallar = (id, code, message) => process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, error: { code, message } }) + '\n');
+const cerrarTodo = async () => { if (navegador) await navegador.close().catch(() => {}); process.exit(0); };
+
+const lector = readline.createInterface({ input: process.stdin });
+lector.on('close', cerrarTodo);
+lector.on('line', async (linea) => {
+  let m;
+  try { m = JSON.parse(linea); } catch { return; }
+  if (m.id === undefined) return;
+  try {
+    if (m.method === 'initialize') return responder(m.id, { protocolVersion: m.params?.protocolVersion || '2025-06-18', capabilities: { tools: {} }, serverInfo: { name: 'meiti-render', title: 'MEITI Render', version: VERSION, websiteUrl: 'https://meiti.dev/agents' }, instructions: 'Test screens like an agent, not like a person: render_open returns a map of the screen; render_act does one action by intent and tells you what changed; render_expect checks what you expect. Compare maps instead of looking at screenshots.' });
+    if (m.method === 'ping') return responder(m.id, {});
+    if (m.method === 'tools/list') return responder(m.id, { tools: HERRAMIENTAS.map(({ run, ...h }) => h) });
+    if (m.method === 'tools/call') {
+      const h = HERRAMIENTAS.find((x) => x.name === m.params?.name);
+      if (!h) return fallar(m.id, -32602, `Unknown tool: ${m.params?.name}`);
+      try { return responder(m.id, { content: [{ type: 'text', text: await h.run(m.params?.arguments || {}) }] }); }
+      catch (e) { return responder(m.id, { content: [{ type: 'text', text: String(e?.message || e) }], isError: true }); }
+    }
+    return fallar(m.id, -32601, `Method not supported: ${m.method}`);
+  } catch (e) {
+    return fallar(m.id, -32603, String(e?.message || e));
+  }
+});