@meiti/render 0.1.0 → 0.2.0

package/README.md

@@ -9,6 +9,7 @@ Today an agent tests a screen like a person would: take a screenshot, send it to
 - **Seeing by comparing maps.** Act, scan, compare with the previous map: what appeared, what disappeared, what changed, what moved. "Nothing changed" is information too: a button that does nothing.
 - **What a screenshot never shows.** The requests sent to the server and their status, page errors, native dialogs.
 - **Visual issues measured exactly, no vision model needed.** Horizontal overflow, cut text, covered or off-screen elements, small touch targets, low contrast, broken images, buttons without a name.
+- **Knows whether the page loaded, and whether it is the right one.** Every map starts with the page state: LOADED, DID NOT LOAD (HTTP error, the browser's own error page, nothing visible, a screen that only shows an error) or NOT THE EXPECTED PAGE (with `expect_page`: something that identifies the page you meant to open). On a page that did not load or is not the expected one, negative checks like "not there" answer CANNOT PROVE instead of a false yes.
 - **Before and after.** Compare two versions of an app (home page plus up to 3 linked pages, phone and desktop): worse, better or the same.
 
 It works with apps that render inside same-origin iframes and waits until the screen is stable (two identical maps in a row and nothing loading) before reading it.
@@ -25,9 +26,9 @@ Tools:
 
 | Tool | What it does |
 |---|---|
-| `render_open` | Opens a URL (any size: 375 for a phone) and returns the map and its visual issues. |
+| `render_open` | Opens a URL (any size: 375 for a phone) and returns the map, its visual issues and the requests that failed while loading. Optional: `storage`, `cookies` and `headers` to open it already signed in, and `wait_for` for an element that appears after a request. Each session runs in its own browser context. |
 | `render_act` | One action by intent (`click`, `fill`, `select`, `check`, `key`, `goto`) and what changed. |
-| `render_expect` | Checks what you expect: yes or no, with the exact proof. |
+| `render_expect` | Checks what you expect: yes or no, with the exact proof. `no_errors` takes `ignore` for errors that are not the app's own. |
 | `render_scan` | Scans the current screen again. |
 | `render_compare` | Compares two versions of the same app. |
 | `render_close` | Closes a session. |

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 export { escanear, escanearEstable, comparar, mapaEnTexto, type MapaPantalla, type ElementoMapa, type FallaRender, type TipoFalla, type ComparacionMapas } from './escaner.js';
-export { SesionRender, resolver, type Accion, type Expectativa, type ResultadoAccion, type ResultadoExpectativa, type PedidoRed } from './sesion.js';
+export { SesionRender, resolver, type Accion, type Expectativa, type ResultadoAccion, type ResultadoExpectativa, type PedidoRed, type EstadoCarga, type HuellaPagina } from './sesion.js';
 export { rutasDeLaApp, recorrerApp, compararVersiones, PANTALLAS, type RecorridoApp, type ResultadoVisual, type RegresionVisual } from './recorrido.js';

package/dist/sesion.d.ts

@@ -61,11 +61,35 @@ export type Expectativa = {
         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;
@@ -76,7 +100,20 @@ export declare class SesionRender {
     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;

package/dist/sesion.js

@@ -1,4 +1,5 @@
 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}`;
@@ -47,6 +48,11 @@ export class SesionRender {
     red = [];
     errores = [];
     dialogos = [];
+    estado = null;
+    huella = null;
+    http = null;
+    enCurso = 0;
+    errorNavegacion = null;
     constructor(pagina) {
         this.pagina = pagina;
         pagina.on('response', (r) => {
@@ -60,6 +66,76 @@ export class SesionRender {
         // 🩹 [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();
@@ -67,8 +143,11 @@ export class SesionRender {
         if (preparar)
             await preparar(pagina); // por ejemplo, un servidor simulado (exámenes)
         const sesion = new SesionRender(pagina);
-        await pagina.goto(url, { waitUntil: 'networkidle2', timeout: 60_000 });
+        // 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() {
@@ -133,14 +212,18 @@ export class SesionRender {
             }
             else if (accion.tipo === 'tecla')
                 await this.pagina.keyboard.press(accion.tecla);
-            else if (accion.tipo === 'ir')
-                await this.pagina.goto(accion.url, { waitUntil: 'networkidle2', timeout: 60_000 });
+            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 };
@@ -151,9 +234,16 @@ export class SesionRender {
     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);

package/mcp.mjs

@@ -5,10 +5,23 @@
 // 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 } from './dist/index.js';
+import { SesionRender, mapaEnTexto, rutasDeLaApp, recorrerApp, compararVersiones, resolver } from './dist/index.js';
 
-const VERSION = '0.1.0';
+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.
@@ -43,6 +56,7 @@ function expectativaInterna(x) {
   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; };
@@ -52,12 +66,50 @@ 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.' } }, required: ['url'] },
+    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 sesion = await SesionRender.abrir(await abrirNavegador(), String(a.url), { ancho: Number(a.width) || 1280, alto: Number(a.height) || 800 });
+      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);
-      return `Session ${id}\n\n${mapaEnTexto(sesion.mapa)}`;
+      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');
     },
   },
   {
@@ -80,6 +132,7 @@ const HERRAMIENTAS = [
       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(' | ')}` : '',
@@ -90,19 +143,25 @@ const HERRAMIENTAS = [
   },
   {
     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}, {"request": {"method": "POST", "url_contains": "/api/x", "status": 201}}.',
+    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.cumple ? 'YES' : 'NO '} ${JSON.stringify(a.expectations[i])} · ${r.prueba}`).join('\n');
+      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(); return mapaEnTexto(s.mapa); },
+    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',
@@ -125,7 +184,14 @@ const HERRAMIENTAS = [
     name: 'render_close',
     description: 'Close a session.',
     inputSchema: { type: 'object', properties: { session: { type: 'string' } }, required: ['session'] },
-    async run(a) { const s = sesiones.get(String(a.session)); if (s) { await s.cerrar(); sesiones.delete(String(a.session)); } return 'Closed.'; },
+    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.';
+    },
   },
 ];
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meiti/render",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Render testing built for AI agents: a structured map of the screen instead of screenshots, actions by intent instead of coordinates, and map-to-map comparison to see what changed. MCP server and library. Verified by Healer.",
   "type": "module",
   "license": "MIT",