utn-mcp 0.2.0 → 0.6.7

package/build/shared/documents/index.js

@@ -1,68 +1,68 @@
 import { htmlToText } from "../html.js";
-import { abrirOffice, formatoOffice } from "./office.js";
-import { abrirPdf } from "./pdf.js";
-export class FormatoNoSoportado extends Error {
-    formato;
-    constructor(formato) {
-        super(`No sé leer archivos ${formato}.`);
-        this.formato = formato;
-        this.name = "FormatoNoSoportado";
+import { detectOfficeFormat, openOffice } from "./office.js";
+import { openPdf } from "./pdf.js";
+export class UnsupportedFormat extends Error {
+    format;
+    constructor(format) {
+        super(`No sé leer archivos ${format}.`);
+        this.format = format;
+        this.name = "UnsupportedFormat";
     }
 }
 /** Tamaño de cada fragmento cuando un texto largo viene de una sola pieza (un docx, un html). */
-export const FRAGMENTO = 15_000;
-const IMAGENES = [
+export const CHUNK_SIZE = 15_000;
+const IMAGE_SIGNATURES = [
     [[0x89, 0x50, 0x4e, 0x47], "image/png"],
     [[0xff, 0xd8, 0xff], "image/jpeg"],
     [[0x47, 0x49, 0x46, 0x38], "image/gif"],
 ];
-const empieza = (bytes, firma) => firma.every((b, i) => bytes[i] === b);
+const hasSignature = (bytes, signature) => signature.every((b, i) => bytes[i] === b);
 /** Reconoce el formato por los primeros bytes; el nombre solo se usa para los de texto plano. */
-export async function abrirDocumento(bytes, nombre) {
-    if (empieza(bytes, [0x25, 0x50, 0x44, 0x46]))
-        return abrirPdf(bytes);
-    for (const [firma, mimeType] of IMAGENES) {
-        if (empieza(bytes, firma))
-            return deTexto("imagen", "imagen", [{ imagen: bytes, mimeType }]);
+export async function openDocument(bytes, name) {
+    if (hasSignature(bytes, [0x25, 0x50, 0x44, 0x46]))
+        return openPdf(bytes);
+    for (const [signature, mimeType] of IMAGE_SIGNATURES) {
+        if (hasSignature(bytes, signature))
+            return inMemory("imagen", "imagen", [{ image: bytes, mimeType }]);
     }
-    if (empieza(bytes, [0x50, 0x4b, 0x03, 0x04])) {
-        const formato = formatoOffice(bytes);
-        if (!formato)
-            throw new FormatoNoSoportado("comprimidos (.zip)");
-        return abrirOffice(bytes, formato);
+    if (hasSignature(bytes, [0x50, 0x4b, 0x03, 0x04])) {
+        const format = detectOfficeFormat(bytes);
+        if (!format)
+            throw new UnsupportedFormat("comprimidos (.zip)");
+        return openOffice(bytes, format);
     }
-    if (empieza(bytes, [0xd0, 0xcf, 0x11, 0xe0])) {
-        throw new FormatoNoSoportado("de Office viejo (.doc, .xls, .ppt, .pps)");
+    if (hasSignature(bytes, [0xd0, 0xcf, 0x11, 0xe0])) {
+        throw new UnsupportedFormat("de Office viejo (.doc, .xls, .ppt, .pps)");
     }
-    const extension = nombre.toLowerCase().match(/\.(\w+)$/)?.[1] ?? "";
+    const extension = name.toLowerCase().match(/\.(\w+)$/)?.[1] ?? "";
     if (["txt", "csv", "md", "html", "htm"].includes(extension)) {
-        const texto = new TextDecoder().decode(bytes);
-        const plano = extension.startsWith("htm") ? htmlToText(texto) : texto;
-        return deTexto(extension, "fragmento", fragmentar(plano).map((t) => ({ texto: t })));
+        const text = new TextDecoder().decode(bytes);
+        const plain = extension.startsWith("htm") ? htmlToText(text) : text;
+        return inMemory(extension, "fragmento", splitText(plain).map((t) => ({ text: t })));
     }
-    throw new FormatoNoSoportado(extension ? `.${extension}` : "de este tipo");
+    throw new UnsupportedFormat(extension ? `.${extension}` : "de este tipo");
 }
 /** Un documento que ya está entero en memoria. */
-export function deTexto(formato, unidad, partes) {
+export function inMemory(format, unit, parts) {
     return {
-        formato,
-        unidad,
-        total: partes.length,
-        parte: async (n) => partes[n - 1],
-        cerrar: async () => { },
+        format,
+        unit,
+        total: parts.length,
+        part: async (n) => parts[n - 1],
+        close: async () => { },
     };
 }
 /** Corta un texto largo en pedazos de hasta `max` caracteres, prefiriendo cortar en un salto de línea. */
-export function fragmentar(texto, max = FRAGMENTO) {
-    const fragmentos = [];
-    let resto = texto.trim();
-    while (resto.length > max) {
-        const corte = resto.lastIndexOf("\n", max);
-        const fin = corte > max / 2 ? corte : max;
-        fragmentos.push(resto.slice(0, fin).trim());
-        resto = resto.slice(fin).trim();
+export function splitText(text, max = CHUNK_SIZE) {
+    const chunks = [];
+    let rest = text.trim();
+    while (rest.length > max) {
+        const cut = rest.lastIndexOf("\n", max);
+        const end = cut > max / 2 ? cut : max;
+        chunks.push(rest.slice(0, end).trim());
+        rest = rest.slice(end).trim();
     }
-    if (resto || fragmentos.length === 0)
-        fragmentos.push(resto);
-    return fragmentos;
+    if (rest || chunks.length === 0)
+        chunks.push(rest);
+    return chunks;
 }

package/build/shared/documents/office.js

@@ -1,118 +1,118 @@
-import { deTexto, fragmentar } from "./index.js";
-import { leerEntrada, listarZip } from "./zip.js";
+import { inMemory, splitText } from "./index.js";
+import { listZip, readEntry } from "./zip.js";
 /** Tope por entrada descomprimida: un XML de texto de más que esto es un zip malicioso o no es un documento. */
-const MAX_ENTRADA = 50 * 1024 * 1024;
-const MARCAS = {
+const MAX_ENTRY_BYTES = 50 * 1024 * 1024;
+const MARKERS = {
     docx: "word/document.xml",
     pptx: "ppt/presentation.xml",
     xlsx: "xl/workbook.xml",
 };
 /** Mira la lista de entradas del zip sin descomprimir nada. */
-export function formatoOffice(bytes) {
-    const nombres = new Set(listarZip(bytes).map((e) => e.nombre));
-    return Object.keys(MARCAS).find((f) => nombres.has(MARCAS[f])) ?? null;
+export function detectOfficeFormat(bytes) {
+    const names = new Set(listZip(bytes).map((e) => e.name));
+    return Object.keys(MARKERS).find((f) => names.has(MARKERS[f])) ?? null;
 }
-export function abrirOffice(bytes, formato) {
-    const texto = new TextDecoder();
-    const zip = Object.fromEntries(listarZip(bytes)
-        .filter((e) => necesaria(formato, e.nombre))
-        .map((e) => [e.nombre, texto.decode(leerEntrada(bytes, e, MAX_ENTRADA))]));
-    switch (formato) {
+export function openOffice(bytes, format) {
+    const decoder = new TextDecoder();
+    const zip = Object.fromEntries(listZip(bytes)
+        .filter((e) => isNeeded(format, e.name))
+        .map((e) => [e.name, decoder.decode(readEntry(bytes, e, MAX_ENTRY_BYTES))]));
+    switch (format) {
         case "docx":
-            return deTexto("docx", "fragmento", fragmentar(xmlTexto(leer(zip, "word/document.xml"), "w")).map((texto) => ({ texto })));
+            return inMemory("docx", "fragmento", splitText(xmlText(read(zip, "word/document.xml"), "w")).map((text) => ({ text })));
         case "pptx":
-            return deTexto("pptx", "diapositiva", Object.keys(zip)
+            return inMemory("pptx", "diapositiva", Object.keys(zip)
                 .filter((p) => /^ppt\/slides\/slide\d+\.xml$/.test(p))
-                .sort((a, b) => numero(a) - numero(b))
-                .map((p) => ({ texto: xmlTexto(leer(zip, p), "a") || "(diapositiva sin texto)" })));
+                .sort((a, b) => slideNumber(a) - slideNumber(b))
+                .map((p) => ({ text: xmlText(read(zip, p), "a") || "(diapositiva sin texto)" })));
         case "xlsx":
-            return deTexto("xlsx", "fragmento", hojas(zip).flatMap(({ nombre, texto }) => {
-                const partes = fragmentar(texto);
-                return partes.map((t, i) => ({
-                    titulo: partes.length > 1 ? `hoja "${nombre}" (${i + 1}/${partes.length})` : `hoja "${nombre}"`,
-                    texto: t,
+            return inMemory("xlsx", "fragmento", sheets(zip).flatMap(({ name, text }) => {
+                const chunks = splitText(text);
+                return chunks.map((t, i) => ({
+                    title: chunks.length > 1 ? `hoja "${name}" (${i + 1}/${chunks.length})` : `hoja "${name}"`,
+                    text: t,
                 }));
             }));
     }
 }
-function necesaria(formato, nombre) {
-    switch (formato) {
+function isNeeded(format, name) {
+    switch (format) {
         case "docx":
-            return nombre === "word/document.xml";
+            return name === "word/document.xml";
         case "pptx":
-            return /^ppt\/slides\/slide\d+\.xml$/.test(nombre);
+            return /^ppt\/slides\/slide\d+\.xml$/.test(name);
         case "xlsx":
-            return nombre === "xl/workbook.xml" || nombre === "xl/sharedStrings.xml" ||
-                nombre === "xl/_rels/workbook.xml.rels" || nombre.startsWith("xl/worksheets/");
+            return name === "xl/workbook.xml" || name === "xl/sharedStrings.xml" ||
+                name === "xl/_rels/workbook.xml.rels" || name.startsWith("xl/worksheets/");
     }
 }
-const leer = (zip, ruta) => zip[ruta] ?? "";
-const numero = (ruta) => Number(ruta.match(/(\d+)\.xml$/)?.[1]);
-const ENTIDADES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
-const decodificar = (s) => s.replace(/&(#x[0-9a-f]+|#\d+|\w+);/gi, (m, e) => e[0] !== "#" ? (ENTIDADES[e] ?? m) : String.fromCodePoint(e[1].toLowerCase() === "x" ? parseInt(e.slice(2), 16) : Number(e.slice(1))));
+const read = (zip, path) => zip[path] ?? "";
+const slideNumber = (path) => Number(path.match(/(\d+)\.xml$/)?.[1]);
+const ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+const decodeEntities = (s) => s.replace(/&(#x[0-9a-f]+|#\d+|\w+);/gi, (m, e) => e[0] !== "#" ? (ENTITIES[e] ?? m) : String.fromCodePoint(e[1].toLowerCase() === "x" ? parseInt(e.slice(2), 16) : Number(e.slice(1))));
 /**
  * Texto de un XML de Word (`w`) o PowerPoint (`a`), recorriendo los tags en orden: texto de los nodos
  * de texto, salto de línea al cerrar un párrafo, y las tablas como filas con celdas separadas por " | ".
  */
-function xmlTexto(xml, ns) {
+function xmlText(xml, ns) {
     let out = "";
-    let enTexto = false;
-    let enCelda = 0;
-    for (const [, cierre, tag, , autocierre, chars] of xml.matchAll(/<(\/?)([\w:]+)((?:[^>"]|"[^"]*")*?)(\/?)>|([^<]+)/g)) {
+    let inText = false;
+    let cellDepth = 0;
+    for (const [, closing, tag, , selfClosing, chars] of xml.matchAll(/<(\/?)([\w:]+)((?:[^>"]|"[^"]*")*?)(\/?)>|([^<]+)/g)) {
         if (chars !== undefined) {
-            if (enTexto)
-                out += decodificar(chars);
+            if (inText)
+                out += decodeEntities(chars);
         }
         else if (tag === `${ns}:t`) {
-            enTexto = !cierre && !autocierre;
+            inText = !closing && !selfClosing;
         }
-        else if (tag === `${ns}:tc` && !autocierre) {
-            enCelda += cierre ? -1 : 1;
-            if (cierre)
+        else if (tag === `${ns}:tc` && !selfClosing) {
+            cellDepth += closing ? -1 : 1;
+            if (closing)
                 out += " | ";
         }
-        else if (tag === `${ns}:tr` && cierre) {
+        else if (tag === `${ns}:tr` && closing) {
             out += "\n";
         }
-        else if (tag === `${ns}:p` && cierre) {
-            out += enCelda ? " " : "\n";
+        else if (tag === `${ns}:p` && closing) {
+            out += cellDepth ? " " : "\n";
         }
         else if (tag === `${ns}:tab`) {
             out += " ";
         }
         else if (tag === `${ns}:br`) {
-            out += enCelda ? " " : "\n";
+            out += cellDepth ? " " : "\n";
         }
     }
     return out
         .split("\n")
         .map((l) => l.replace(/\s+/g, " ").replace(/\s*\|\s*$/, "").trim())
-        .filter((l, i, todas) => l !== "|" && (l !== "" || todas[i - 1] !== ""))
+        .filter((l, i, all) => l !== "|" && (l !== "" || all[i - 1] !== ""))
         .join("\n")
         .trim();
 }
 /** Cada hoja como filas de celdas separadas por tabs, en el orden del libro. */
-function hojas(zip) {
-    const compartidas = [...leer(zip, "xl/sharedStrings.xml").matchAll(/<si>([\s\S]*?)<\/si>/g)].map((m) => decodificar([...m[1].matchAll(/<t[^>]*>([\s\S]*?)<\/t>/g)].map((t) => t[1]).join("")));
-    const rels = Object.fromEntries([...leer(zip, "xl/_rels/workbook.xml.rels").matchAll(/<Relationship [^>]*>/g)].map(([tag]) => [
+function sheets(zip) {
+    const sharedStrings = [...read(zip, "xl/sharedStrings.xml").matchAll(/<si>([\s\S]*?)<\/si>/g)].map((m) => decodeEntities([...m[1].matchAll(/<t[^>]*>([\s\S]*?)<\/t>/g)].map((t) => t[1]).join("")));
+    const rels = Object.fromEntries([...read(zip, "xl/_rels/workbook.xml.rels").matchAll(/<Relationship [^>]*>/g)].map(([tag]) => [
         tag.match(/Id="([^"]+)"/)?.[1],
         tag.match(/Target="([^"]+)"/)?.[1],
     ]));
-    return [...leer(zip, "xl/workbook.xml").matchAll(/<sheet [^>]*>/g)].map(([tag]) => {
-        const nombre = decodificar(tag.match(/name="([^"]*)"/)?.[1] ?? "");
-        const destino = rels[tag.match(/r:id="([^"]+)"/)?.[1] ?? ""] ?? "";
-        const ruta = destino.replace(/^\//, "").replace(/^(xl\/)?/, "xl/");
-        const filas = [...leer(zip, ruta).matchAll(/<row[^>]*>([\s\S]*?)<\/row>/g)].map((fila) => [...fila[1].matchAll(/<c ([^>]*?)(?:\/>|>([\s\S]*?)<\/c>)/g)]
-            .map(([, attrs, cuerpo = ""]) => {
-            const tipo = attrs.match(/\bt="(\w+)"/)?.[1];
-            if (tipo === "s")
-                return compartidas[Number(cuerpo.match(/<v>(\d+)<\/v>/)?.[1])] ?? "";
-            if (tipo === "inlineStr")
-                return decodificar(cuerpo.match(/<t[^>]*>([\s\S]*?)<\/t>/)?.[1] ?? "");
-            return decodificar(cuerpo.match(/<v>([\s\S]*?)<\/v>/)?.[1] ?? "");
+    return [...read(zip, "xl/workbook.xml").matchAll(/<sheet [^>]*>/g)].map(([tag]) => {
+        const name = decodeEntities(tag.match(/name="([^"]*)"/)?.[1] ?? "");
+        const target = rels[tag.match(/r:id="([^"]+)"/)?.[1] ?? ""] ?? "";
+        const path = target.replace(/^\//, "").replace(/^(xl\/)?/, "xl/");
+        const rows = [...read(zip, path).matchAll(/<row[^>]*>([\s\S]*?)<\/row>/g)].map((row) => [...row[1].matchAll(/<c ([^>]*?)(?:\/>|>([\s\S]*?)<\/c>)/g)]
+            .map(([, attrs, body = ""]) => {
+            const type = attrs.match(/\bt="(\w+)"/)?.[1];
+            if (type === "s")
+                return sharedStrings[Number(body.match(/<v>(\d+)<\/v>/)?.[1])] ?? "";
+            if (type === "inlineStr")
+                return decodeEntities(body.match(/<t[^>]*>([\s\S]*?)<\/t>/)?.[1] ?? "");
+            return decodeEntities(body.match(/<v>([\s\S]*?)<\/v>/)?.[1] ?? "");
         })
             .join("\t")
             .replace(/\t+$/, ""));
-        return { nombre, texto: filas.filter(Boolean).join("\n") || "(hoja vacía)" };
+        return { name, text: rows.filter(Boolean).join("\n") || "(hoja vacía)" };
     });
 }

package/build/shared/documents/pdf.js

@@ -1,18 +1,18 @@
-import { pngGris } from "./png.js";
+import { grayscalePng } from "./png.js";
 /**
  * pdf.js no es una dependencia: scripts/vendor-pdfjs.mjs copia a vendor/pdfjs los pocos archivos que
  * usamos. Está a la misma altura desde src/ y desde build/, así que la ruta sirve en dev y publicado.
  */
 const VENDOR = new URL("../../../vendor/pdfjs/", import.meta.url);
 /** Al arrancar en Node, pdf.js avisa que le falta canvas para renderizar. No renderizamos: son ruido en el log. */
-const AVISOS_DE_CANVAS = /@napi-rs\/canvas|Cannot polyfill/;
-let pdfjsCargado;
+const CANVAS_WARNINGS = /@napi-rs\/canvas|Cannot polyfill/;
+let pdfjsLoading;
 /** Se carga recién al primer PDF: son 3 MB que el servidor no necesita para arrancar. */
 function pdfjs() {
-    pdfjsCargado ??= (async () => {
+    pdfjsLoading ??= (async () => {
         const warn = console.warn;
         console.warn = (...args) => {
-            if (!AVISOS_DE_CANVAS.test(String(args[0])))
+            if (!CANVAS_WARNINGS.test(String(args[0])))
                 warn(...args);
         };
         try {
@@ -22,17 +22,19 @@ function pdfjs() {
             console.warn = warn;
         }
     })();
-    return pdfjsCargado;
+    return pdfjsLoading;
 }
 /** Menos texto que esto en una página la tratamos como escaneada. */
-const MIN_TEXTO = 20;
+const MIN_TEXT_CHARS = 20;
 /** Lado largo de la imagen de una página: el tamaño que Claude procesa sin reescalar. */
-const LADO_IMAGEN = 1568;
+const IMAGE_LONG_SIDE = 1568;
 /** Muestras por eje y por píxel al reducir la imagen; suaviza los bordes y mejora la lectura. */
-const MUESTREO = 2;
-export async function abrirPdf(bytes) {
+const SUPERSAMPLING = 2;
+/** Cuánto esperar una imagen ya decodificada antes de seguir sin ella, en milisegundos. */
+const IMAGE_WAIT_MS = 10_000;
+export async function openPdf(bytes) {
     const lib = await pdfjs();
-    const carga = lib.getDocument({
+    const loadingTask = lib.getDocument({
         data: bytes,
         verbosity: 0,
         isOffscreenCanvasSupported: false,
@@ -40,84 +42,102 @@ export async function abrirPdf(bytes) {
         useWasm: false,
         wasmUrl: new URL("wasm/", VENDOR).href,
     });
-    const pdf = await carga.promise;
+    const pdf = await loadingTask.promise;
     return {
-        formato: "pdf",
-        unidad: "página",
+        format: "pdf",
+        unit: "página",
         total: pdf.numPages,
-        parte: async (n) => leerPagina(lib, await pdf.getPage(n)),
-        cerrar: () => carga.destroy(),
+        part: async (n) => readPage(lib, await pdf.getPage(n)),
+        close: () => loadingTask.destroy(),
     };
 }
-async function leerPagina(lib, pagina) {
-    const contenido = await pagina.getTextContent();
-    let texto = "";
-    for (const item of contenido.items) {
+async function readPage(lib, page) {
+    const content = await page.getTextContent();
+    let text = "";
+    for (const item of content.items) {
         if (!("str" in item))
             continue;
-        texto += item.str + (item.hasEOL ? "\n" : "");
+        text += item.str + (item.hasEOL ? "\n" : "");
     }
-    texto = texto.replace(/[ \t]+/g, " ").replace(/ ?\n ?/g, "\n").trim();
-    if (texto.length >= MIN_TEXTO)
-        return { texto };
-    const escaneo = await rasterizarImagenes(lib, pagina);
-    if (escaneo)
-        return { titulo: "escaneada, como imagen", imagen: escaneo, mimeType: "image/png" };
-    return { texto: texto || "(página sin texto)" };
+    text = text.replace(/[ \t]+/g, " ").replace(/ ?\n ?/g, "\n").trim();
+    if (text.length >= MIN_TEXT_CHARS)
+        return { text };
+    const scan = await rasterizeImages(lib, page);
+    if (scan)
+        return { title: "escaneada, como imagen", image: scan, mimeType: "image/png" };
+    return { text: text || "(página sin texto)" };
 }
 /**
  * Reconstruye la página dibujando solo sus imágenes, con la posición y rotación con que el PDF
  * las ubica. Una página escaneada es eso: una imagen. Así se evita un renderizador completo, que
  * en Node necesita un canvas nativo.
  */
-async function rasterizarImagenes({ OPS, Util }, pagina) {
-    const base = pagina.getViewport({ scale: 1 });
-    const vista = pagina.getViewport({ scale: LADO_IMAGEN / Math.max(base.width, base.height) });
-    const ancho = Math.round(vista.width);
-    const alto = Math.round(vista.height);
-    const lienzo = new Uint8Array(ancho * alto).fill(255);
-    const ops = await pagina.getOperatorList();
+async function rasterizeImages({ OPS, Util }, page) {
+    const base = page.getViewport({ scale: 1 });
+    const viewport = page.getViewport({ scale: IMAGE_LONG_SIDE / Math.max(base.width, base.height) });
+    const width = Math.round(viewport.width);
+    const height = Math.round(viewport.height);
+    const canvas = new Uint8Array(width * height).fill(255);
+    const ops = await page.getOperatorList();
     let ctm = [1, 0, 0, 1, 0, 0];
-    const pila = [];
-    let pintadas = 0;
+    const stack = [];
+    let painted = 0;
     for (let i = 0; i < ops.fnArray.length; i++) {
         const args = ops.argsArray[i];
         switch (ops.fnArray[i]) {
             case OPS.save:
-                pila.push(ctm);
+                stack.push(ctm);
                 break;
             case OPS.restore:
-                ctm = pila.pop() ?? ctm;
+                ctm = stack.pop() ?? ctm;
                 break;
             case OPS.transform:
                 ctm = Util.transform(ctm, args);
                 break;
             case OPS.paintFormXObjectBegin:
-                pila.push(ctm);
+                stack.push(ctm);
                 if (args[0])
                     ctm = Util.transform(ctm, args[0]);
                 break;
             case OPS.paintFormXObjectEnd:
-                ctm = pila.pop() ?? ctm;
+                ctm = stack.pop() ?? ctm;
                 break;
             case OPS.paintImageXObject:
             case OPS.paintInlineImageXObject: {
-                const imagen = typeof args[0] === "string" ? await new Promise((res) => pagina.objs.get(args[0], res)) : args[0];
-                if (imagen?.data && pintar(lienzo, ancho, alto, imagen, Util.transform(vista.transform, ctm))) {
-                    pintadas++;
+                const image = typeof args[0] === "string" ? await imageObject(page, args[0]) : args[0];
+                if (image?.data && paint(canvas, width, height, image, Util.transform(viewport.transform, ctm))) {
+                    painted++;
                 }
                 break;
             }
         }
     }
-    return pintadas ? pngGris(ancho, alto, lienzo) : null;
+    return painted ? grayscalePng(width, height, canvas) : null;
+}
+/**
+ * Las imágenes que se repiten entre páginas (ids "g_...") pdf.js las guarda en `commonObjs`, no en los
+ * objetos de la página; su propio renderizador elige así. Buscarlas en `objs` espera para siempre.
+ * Con el tope, una imagen que no llega deja la página sin ella en vez de colgar la lectura.
+ */
+async function imageObject(page, id) {
+    const store = id.startsWith("g_") ? page.commonObjs : page.objs;
+    let timer;
+    try {
+        return await Promise.race([
+            new Promise((resolve) => store.get(id, resolve)),
+            new Promise((resolve) => (timer = setTimeout(() => resolve(null), IMAGE_WAIT_MS))),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
 }
 /**
  * Pinta una imagen en el lienzo. La imagen ocupa el cuadrado unitario transformado por `m`; por cada
  * píxel del lienzo se busca el píxel de origen con la transformación inversa, así cualquier rotación
  * o espejado sale bien sin casos especiales.
  */
-function pintar(lienzo, ancho, alto, img, m) {
+function paint(canvas, width, height, img, m) {
     const [a, b, c, d, e, f] = m;
     const det = a * d - b * c;
     if (!det)
@@ -126,38 +146,38 @@ function pintar(lienzo, ancho, alto, img, m) {
     const xs = [e, a + e, c + e, a + c + e];
     const ys = [f, b + f, d + f, b + d + f];
     const x0 = Math.max(0, Math.floor(Math.min(...xs)));
-    const x1 = Math.min(ancho, Math.ceil(Math.max(...xs)));
+    const x1 = Math.min(width, Math.ceil(Math.max(...xs)));
     const y0 = Math.max(0, Math.floor(Math.min(...ys)));
-    const y1 = Math.min(alto, Math.ceil(Math.max(...ys)));
+    const y1 = Math.min(height, Math.ceil(Math.max(...ys)));
     const { width: w, height: h, kind } = img;
     const data = img.data;
-    const bytesPorFila = (w + 7) >> 3;
-    const canales = kind === 2 ? 3 : 4;
-    const gris = (col, fila) => {
+    const bytesPerRow = (w + 7) >> 3;
+    const channels = kind === 2 ? 3 : 4;
+    const gray = (col, row) => {
         if (kind === 1)
-            return ((data[fila * bytesPorFila + (col >> 3)] >> (7 - (col & 7))) & 1) * 255;
-        const i = (fila * w + col) * canales;
+            return ((data[row * bytesPerRow + (col >> 3)] >> (7 - (col & 7))) & 1) * 255;
+        const i = (row * w + col) * channels;
         return data[i] * 0.3 + data[i + 1] * 0.59 + data[i + 2] * 0.11;
     };
     for (let y = y0; y < y1; y++) {
         for (let x = x0; x < x1; x++) {
-            let suma = 0;
+            let sum = 0;
             let n = 0;
-            for (let sy = 0; sy < MUESTREO; sy++) {
-                for (let sx = 0; sx < MUESTREO; sx++) {
-                    const px = x + (sx + 0.5) / MUESTREO;
-                    const py = y + (sy + 0.5) / MUESTREO;
+            for (let sy = 0; sy < SUPERSAMPLING; sy++) {
+                for (let sx = 0; sx < SUPERSAMPLING; sx++) {
+                    const px = x + (sx + 0.5) / SUPERSAMPLING;
+                    const py = y + (sy + 0.5) / SUPERSAMPLING;
                     const u = inv[0] * px + inv[2] * py + inv[4];
                     const v = inv[1] * px + inv[3] * py + inv[5];
                     if (u < 0 || u >= 1 || v < 0 || v >= 1)
                         continue;
                     // En el espacio de la imagen v crece hacia arriba; las filas de datos, hacia abajo.
-                    suma += gris(Math.floor(u * w), Math.floor((1 - v) * h));
+                    sum += gray(Math.floor(u * w), Math.floor((1 - v) * h));
                     n++;
                 }
             }
             if (n)
-                lienzo[y * ancho + x] = suma / n;
+                canvas[y * width + x] = sum / n;
         }
     }
     return true;

package/build/shared/documents/png.js

@@ -1,34 +1,34 @@
 import { deflateSync } from "node:zlib";
 /** PNG en escala de grises, 8 bits. Alcanza para páginas escaneadas y evita una dependencia de imágenes. */
-export function pngGris(ancho, alto, pixeles) {
+export function grayscalePng(width, height, pixels) {
     // Cada fila va precedida por el byte de filtro (0 = sin filtro).
-    const filas = new Uint8Array(alto * (ancho + 1));
-    for (let y = 0; y < alto; y++)
-        filas.set(pixeles.subarray(y * ancho, (y + 1) * ancho), y * (ancho + 1) + 1);
+    const rows = new Uint8Array(height * (width + 1));
+    for (let y = 0; y < height; y++)
+        rows.set(pixels.subarray(y * width, (y + 1) * width), y * (width + 1) + 1);
     const ihdr = new Uint8Array(13);
-    const vista = new DataView(ihdr.buffer);
-    vista.setUint32(0, ancho);
-    vista.setUint32(4, alto);
+    const view = new DataView(ihdr.buffer);
+    view.setUint32(0, width);
+    view.setUint32(4, height);
     ihdr[8] = 8; // bits por canal
     ihdr[9] = 0; // escala de grises
     return concat([
         new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
         chunk("IHDR", ihdr),
-        chunk("IDAT", deflateSync(filas, { level: 6 })),
+        chunk("IDAT", deflateSync(rows, { level: 6 })),
         chunk("IEND", new Uint8Array()),
     ]);
 }
-function chunk(tipo, datos) {
-    const out = new Uint8Array(12 + datos.length);
-    const vista = new DataView(out.buffer);
-    vista.setUint32(0, datos.length);
+function chunk(type, data) {
+    const out = new Uint8Array(12 + data.length);
+    const view = new DataView(out.buffer);
+    view.setUint32(0, data.length);
     for (let i = 0; i < 4; i++)
-        out[4 + i] = tipo.charCodeAt(i);
-    out.set(datos, 8);
-    vista.setUint32(8 + datos.length, crc32(out.subarray(4, 8 + datos.length)));
+        out[4 + i] = type.charCodeAt(i);
+    out.set(data, 8);
+    view.setUint32(8 + data.length, crc32(out.subarray(4, 8 + data.length)));
     return out;
 }
-const TABLA_CRC = Int32Array.from({ length: 256 }, (_, n) => {
+const CRC_TABLE = Int32Array.from({ length: 256 }, (_, n) => {
     let c = n;
     for (let k = 0; k < 8; k++)
         c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
@@ -37,13 +37,13 @@ const TABLA_CRC = Int32Array.from({ length: 256 }, (_, n) => {
 function crc32(bytes) {
     let c = -1;
     for (const b of bytes)
-        c = TABLA_CRC[(c ^ b) & 0xff] ^ (c >>> 8);
+        c = CRC_TABLE[(c ^ b) & 0xff] ^ (c >>> 8);
     return ~c >>> 0;
 }
-function concat(partes) {
-    const out = new Uint8Array(partes.reduce((n, p) => n + p.length, 0));
+function concat(parts) {
+    const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
     let i = 0;
-    for (const p of partes) {
+    for (const p of parts) {
         out.set(p, i);
         i += p.length;
     }