create-panal-agent 0.12.0 → 0.13.1

package/template/src/vigilante.ts

@@ -21,6 +21,20 @@
  * el enlace de reenvío y se espera. Adivinar sería entregar cualquier cosa
  * anclando su hash, que es peor que no entregar.
  *
+ * «MIRADA» NO ES «RESUELTA», y confundirlas costó dos tareas de verdad.
+ *
+ * La marca guarda hasta dónde se ha ENUMERADO, no hasta dónde se ha resuelto.
+ * Antes se escribía al final de cada ronda pasara lo que pasara, así que una
+ * tarea que fallaba a mitad —el modelo colgado, el RPC caído— se quedaba por
+ * detrás de la marca y no volvía a mirarse nunca. Y lo que la recordaba vivía
+ * solo en memoria, o sea que un reinicio conservaba la mitad optimista (la
+ * marca, en disco) y perdía la otra (los pendientes, en RAM).
+ *
+ * Ahora las dos cosas viven en el MISMO archivo y se escriben juntas: la marca
+ * dice hasta dónde se enumeró, y `pendientes` lleva las excepciones. Una tarea
+ * sale de esa lista cuando de verdad se cierra —entregada, completada,
+ * cancelada— y no cuando se intentó algo con ella.
+ *
  * SE SONDEA, NO SE ESCUCHAN EVENTOS. `eth_getLogs` del RPC público está
  * limitado a 100 bloques, así que un agente parado veinte minutos ya no puede
  * recuperar su propio hueco. Leer el contador de tareas y mirar las nuevas es
@@ -40,8 +54,20 @@ export interface VigilanteDeps {
   yo: Address;
   /** Dónde guardar hasta dónde se miró. */
   dataDir: string;
-  /** Trabaja una tarea de la que YA se tiene el encargo. */
-  trabajar: (taskId: bigint, brief: string) => Promise<void>;
+  /**
+   * Trabaja una tarea de la que YA se tiene el encargo.
+   *
+   * Devuelve si la ENTREGÓ, y ese booleano es media corrección de este archivo.
+   * `work()` está escrito para no lanzar nunca —una tarea rota no puede tumbar
+   * la ronda entera—, así que desde aquí un reintento que funcionó y uno que
+   * volvió a reventar por límite de uso se veían exactamente igual: sin error.
+   * El vigilante daba por buena la tarea y dejaba de mirarla.
+   *
+   * Y no vale con relanzar el error: `work()` también sale limpio cuando la
+   * tarea espera adjuntos que no han llegado, que tampoco es haberla resuelto.
+   * Hace falta que lo diga, no que se deduzca de que nadie protestó.
+   */
+  trabajar: (taskId: bigint, brief: string) => Promise<boolean>;
   /**
    * ¿Se está trabajando esa tarea AHORA MISMO?
    *
@@ -100,98 +126,180 @@ const GRACIA_MS = 3 * 60 * 1000;
 /** Cuántas tareas hacia atrás se miran al arrancar sin marca previa. */
 const REPASO_INICIAL = 50n;
 
+/**
+ * Tope de la lista de pendientes.
+ *
+ * Una tarea sale de la lista cuando se cierra —entregada, completada,
+ * cancelada—, y todas acaban cerrándose: al vencer el plazo el cliente
+ * recupera su dinero y la tarea deja de estar abierta. Aun así el tope existe
+ * porque nadie OBLIGA al cliente a cancelar: una tarea abandonada puede
+ * quedarse abierta para siempre, y sin tope el archivo crecería sin fin.
+ *
+ * Al recortar se tiran las más VIEJAS, que son las que menos se pueden
+ * recuperar, y se dice en voz alta. Callarlo sería repetir el fallo que este
+ * archivo viene a arreglar.
+ */
+const MAX_PENDIENTES = 500;
+
+/** Qué se sabe de una tarea tras mirarla. «Se intentó» no es un veredicto. */
+type Veredicto = 'resuelta' | 'pendiente';
+
 export function arrancarVigilante(deps: VigilanteDeps): { parar: () => void } {
   if (process.env.VIGILANTE === 'off') {
     console.log('Vigilante desactivado (VIGILANTE=off).');
     return { parar: () => {} };
   }
 
-  const marcaPath = join(deps.dataDir, 'vigilante.json');
-  /** Tareas vistas sin encargo, con el momento en que se vieron. */
-  const huerfanas = new Map<string, number>();
+  const estadoPath = join(deps.dataDir, 'vigilante.json');
+  /**
+   * Cuándo se vio por primera vez una tarea sin encargo.
+   *
+   * Esto SÍ puede vivir solo en memoria: solo sirve para el margen de gracia
+   * antes de gritar, y perderlo en un reinicio únicamente reinicia esa cuenta
+   * atrás. Lo que no puede vivir solo en memoria es la lista de pendientes, y
+   * por eso está aparte.
+   */
+  const vistas = new Map<string, number>();
   /** De las que ya se avisó, para no repetir el aviso cada vuelta. */
   const avisadas = new Set<string>();
+  /** De los encargos guardados que no cuadran, para no repetir la queja. */
+  const quejadas = new Set<string>();
   let parado = false;
 
-  const leerMarca = (): bigint => {
+  interface Estado {
+    visto: bigint;
+    pendientes: Set<string>;
+  }
+
+  const leerEstado = (): Estado => {
     try {
-      const raw = JSON.parse(readFileSync(marcaPath, 'utf8')) as { visto?: string };
-      return BigInt(raw.visto ?? '0');
+      const raw = JSON.parse(readFileSync(estadoPath, 'utf8')) as {
+        visto?: string;
+        pendientes?: string[];
+      };
+      return {
+        // -1 y no 0: sin marca hay que hacer el repaso inicial.
+        visto: raw.visto === undefined ? -1n : BigInt(raw.visto),
+        // Un archivo de la versión anterior no trae la lista. Se lee como
+        // vacía y la primera ronda la vuelve a poblar con lo que siga abierto
+        // por delante de la marca; lo que quedó huérfano por detrás hay que
+        // recuperarlo a mano, que es exactamente el destrozo que esto corrige.
+        pendientes: new Set(raw.pendientes ?? []),
+      };
     } catch {
-      return -1n; // sin marca: se hace el repaso inicial
+      return { visto: -1n, pendientes: new Set() };
     }
   };
-  const escribirMarca = (visto: bigint): void => {
+
+  /**
+   * Las dos cosas se escriben JUNTAS, y ahí está la corrección.
+   *
+   * Antes la marca iba a disco y los pendientes se quedaban en RAM, así que un
+   * reinicio guardaba la mitad que dice «ya miré» y perdía la que dice «pero
+   * esto sigue sin resolver». En un solo archivo no puede pasar.
+   */
+  const escribirEstado = (visto: bigint, pendientes: Set<string>): void => {
+    let lista = [...pendientes];
+    if (lista.length > MAX_PENDIENTES) {
+      // Ordenadas por id: las más viejas primero, que son las que se tiran.
+      lista.sort((a, b) => (BigInt(a) < BigInt(b) ? -1 : 1));
+      const tiradas = lista.slice(0, lista.length - MAX_PENDIENTES);
+      lista = lista.slice(-MAX_PENDIENTES);
+      console.error(
+        `[vigilante] la lista de pendientes pasó de ${MAX_PENDIENTES}: dejo de seguir ` +
+          `${tiradas.length} tarea(s) vieja(s) (#${tiradas[0]}…#${tiradas[tiradas.length - 1]}). ` +
+          'Míralas a mano si alguna sigue abierta.',
+      );
+    }
     try {
-      writeFileSync(marcaPath, JSON.stringify({ visto: visto.toString() }, null, 2));
+      writeFileSync(estadoPath, JSON.stringify({ visto: visto.toString(), pendientes: lista }, null, 2));
     } catch (err) {
-      // Perder la marca solo cuesta repetir el repaso, así que no se para nada.
-      console.error(`[vigilante] no se pudo guardar la marca: ${err instanceof Error ? err.message : err}`);
+      // Perder el estado cuesta repetir el repaso, así que no se para nada.
+      console.error(`[vigilante] no se pudo guardar el estado: ${err instanceof Error ? err.message : err}`);
     }
   };
 
   /** true si encontro algo que atender: eso es lo que decide el ritmo. */
   async function repasar(): Promise<boolean> {
     const total = await deps.panal.getTaskCount();
-    const marca = leerMarca();
+    const { visto, pendientes } = leerEstado();
     // La primera vez se miran las últimas REPASO_INICIAL en vez de las 30.000
     // que pueda haber: las viejas están cerradas y no cambian.
-    const desde = marca >= 0n ? marca + 1n : total > REPASO_INICIAL ? total - REPASO_INICIAL : 0n;
+    const desde = visto >= 0n ? visto + 1n : total > REPASO_INICIAL ? total - REPASO_INICIAL : 0n;
 
-    // Las nuevas, más las que quedaron pendientes de vueltas anteriores.
-    const pendientes = new Set<string>(huerfanas.keys());
-    for (let i = desde; i < total; i++) pendientes.add(i.toString());
-    if (pendientes.size === 0) {
-      escribirMarca(total - 1n);
+    // Las nuevas, más las que quedaron sin resolver de vueltas anteriores.
+    const aMirar = new Set<string>(pendientes);
+    for (let i = desde; i < total; i++) aMirar.add(i.toString());
+    if (aMirar.size === 0) {
+      escribirEstado(total - 1n, aMirar);
       return false;
     }
 
-    for (const id of pendientes) {
-      if (parado) return true;
+    // Se PARTE de que todas siguen pendientes y solo sale la que devuelva un
+    // veredicto de resuelta. Antes era al revés —dentro salvo que alguien se
+    // quejara— y por eso un fallo a mitad equivalía a un éxito.
+    const restantes = new Set<string>(aMirar);
+    for (const id of aMirar) {
+      // `break` y no `return`: hay que guardar lo que sí se llegó a resolver,
+      // y sobre todo lo que no.
+      if (parado) break;
       const taskId = BigInt(id);
+      let veredicto: Veredicto = 'pendiente';
       try {
-        await revisarUna(taskId);
+        veredicto = await revisarUna(taskId);
       } catch (err) {
-        console.error(`[vigilante] #${taskId}: ${err instanceof Error ? err.message : err}`);
+        console.error(
+          `[vigilante] #${taskId}: ${err instanceof Error ? err.message : err} — sigue pendiente`,
+        );
       }
+      if (veredicto === 'resuelta') restantes.delete(id);
     }
-    escribirMarca(total - 1n);
+    escribirEstado(total - 1n, restantes);
     // Habia algo que mirar, aunque no fuera nuestro: no es una vuelta en blanco.
     return true;
   }
 
-  async function revisarUna(taskId: bigint): Promise<void> {
+  async function revisarUna(taskId: bigint): Promise<Veredicto> {
     const task = await deps.panal.getTask(taskId);
     const id = taskId.toString();
 
-    // Ni mía, ni viva: fuera de la lista y a otra cosa.
+    // No es mía: no hay nada que resolver y no hará falta volver a mirarla.
     if (task.worker.toLowerCase() !== deps.yo.toLowerCase()) {
-      huerfanas.delete(id);
-      return;
+      vistas.delete(id);
+      return 'resuelta';
     }
+    // Cerrada en la cadena —entregada, completada, disputada o cancelada—.
+    // ESTA es la única salida buena de la lista: lo dice el escrow, no nosotros.
     if (task.status !== TaskStatus.Open) {
-      huerfanas.delete(id);
+      vistas.delete(id);
       avisadas.delete(id);
-      return;
+      quejadas.delete(id);
+      return 'resuelta';
     }
 
     // Se está trabajando ahora mismo: no es un hueco, es el camino normal. Ni
     // se retoma, ni se avisa de que falte el encargo — lo tiene y lo está
     // usando. El vigilante solo se ocupa de lo que ya no se mueve.
+    //
+    // PERO SIGUE PENDIENTE. Antes esto la sacaba de la lista, y era el mismo
+    // fallo con otro disfraz: si ese trabajo en curso acababa reventando, la
+    // marca ya había pasado por encima y no volvía a mirarla nadie.
     if (deps.enCurso(taskId)) {
-      huerfanas.delete(id);
-      return;
+      vistas.delete(id);
+      return 'pendiente';
     }
 
     // CASO 3: el resultado está calculado y la tarea sigue abierta, así que la
     // entrega no llegó a anclarse. Se reintenta, que es gratis para el cliente
     // y le devuelve una tarea que daba por perdida.
+    //
+    // Si `reentregar` falla, lanza: sube a `repasar`, que la deja pendiente.
     const resultado = deps.resultadoGuardado(taskId);
     if (resultado !== null) {
       console.log(`[vigilante] #${taskId} tenía resultado sin anclar: se reintenta la entrega`);
       await deps.reentregar(taskId, resultado);
-      huerfanas.delete(id);
-      return;
+      vistas.delete(id);
+      return 'resuelta';
     }
 
     // CASO 2: el encargo está guardado pero no hay resultado, o sea que el
@@ -202,26 +310,38 @@ export function arrancarVigilante(deps: VigilanteDeps): { parar: () => void } {
       // otra ejecución y no vale fiarse: si no cuadra con lo que hay en la
       // cadena, trabajar sobre él sería entregar algo que el cliente no pidió.
       if (keccak256(toBytes(brief)) !== task.taskHash) {
-        console.error(
-          `[vigilante] #${taskId} el encargo guardado NO cuadra con el taskHash de la cadena: se ignora`,
-        );
-        huerfanas.delete(id);
-        return;
+        // Pendiente, NO resuelta: el cliente todavía puede reenviar el bueno
+        // por /reenviar y entonces sí se puede trabajar. Se queja una sola vez
+        // para no llenar el log en cada vuelta.
+        if (!quejadas.has(id)) {
+          quejadas.add(id);
+          console.error(
+            `[vigilante] #${taskId} el encargo guardado NO cuadra con el taskHash de la cadena: ` +
+              'no se trabaja sobre él. Que el cliente lo reenvíe.',
+          );
+        }
+        return 'pendiente';
       }
       console.log(`[vigilante] #${taskId} se quedó a medias: se retoma el trabajo`);
-      await deps.trabajar(taskId, brief);
-      huerfanas.delete(id);
-      return;
+      const entregada = await deps.trabajar(taskId, brief);
+      vistas.delete(id);
+      // AQUÍ vivía el segundo fallo: se daba por resuelta sin mirar si lo
+      // estaba. Un modelo que devuelve 429 dos veces seguidas se veía igual
+      // que una entrega perfecta.
+      if (!entregada) {
+        console.log(`[vigilante] #${taskId} no quedó entregada: sigue en la lista para la próxima vuelta`);
+      }
+      return entregada ? 'resuelta' : 'pendiente';
     }
 
     // CASO 1: hay tarea y no hay encargo. Aquí no se puede hacer nada más que
     // avisar: el texto no está en la cadena y adivinarlo sería inventárselo.
-    const visto = huerfanas.get(id);
+    const visto = vistas.get(id);
     if (visto === undefined) {
-      huerfanas.set(id, Date.now());
-      return;
+      vistas.set(id, Date.now());
+      return 'pendiente';
     }
-    if (Date.now() - visto < GRACIA_MS || avisadas.has(id)) return;
+    if (Date.now() - visto < GRACIA_MS || avisadas.has(id)) return 'pendiente';
 
     avisadas.add(id);
     // En cuánto vence, no cuándo. La fecha absoluta se imprimía en UTC junto a
@@ -242,6 +362,9 @@ export function arrancarVigilante(deps: VigilanteDeps): { parar: () => void } {
         ` o desde https://panal.lat/dashboard.\n` +
         `  Si nadie lo hace, el plazo vence ${vence} y el cliente recupera su dinero.`,
     );
+    // Sigue abierta y sin encargo: se queda en la lista hasta que la cadena
+    // diga otra cosa.
+    return 'pendiente';
   }
 
   console.log(`Vigilante activo: repasa cada ${CADA} s (VIGILANTE=off para apagarlo).`);

package/template/src/zip.ts

@@ -0,0 +1,245 @@
+/**
+ * Leer un ZIP sin dependencias.
+ *
+ * Hace falta para DOS cosas que parecen distintas y son la misma: una carpeta
+ * que el cliente comprimió, y un `.docx` —que es un ZIP con XML dentro—. Con
+ * un lector se resuelven las dos.
+ *
+ * Node trae `zlib`, que es el 90% del trabajo. Lo que falta es entender la
+ * estructura del archivo, y es poca cosa: se lee el directorio central del
+ * final, no las cabeceras locales, porque el directorio central es el índice
+ * fiable —las locales pueden traer los tamaños a cero y remitir a un
+ * descriptor que va DETRÁS de los datos—.
+ *
+ * ───────────────────────────────────────────────────────────────────────────
+ * ESTO LO MANDA UN DESCONOCIDO Y HAY QUE TRATARLO COMO TAL.
+ *
+ * El ZIP llega de un cliente que pagó, pero pagar no vuelve a nadie de fiar.
+ * Tres defensas, y las tres importan:
+ *
+ *   - Una bomba zip: 42 kB que se descomprimen en petabytes. Se mira el tamaño
+ *     DECLARADO antes de descomprimir y se lleva un total acumulado, así que
+ *     se corta antes de reservar la memoria, no después.
+ *   - Rutas con `..` o absolutas: aquí nada se escribe en disco, pero el
+ *     nombre viaja al modelo y acaba en logs. Se normaliza igual.
+ *   - Un ZIP con cien mil entradas vacías, que no infla memoria pero sí tiempo.
+ * ───────────────────────────────────────────────────────────────────────────
+ */
+
+import { inflateRawSync } from 'node:zlib';
+
+/** Un archivo dentro del ZIP, ya descomprimido. */
+export interface EntradaZip {
+  /** La ruta dentro del ZIP, ya normalizada. */
+  nombre: string;
+  bytes: Uint8Array;
+}
+
+export interface LimitesZip {
+  /** Cuántas entradas se miran como mucho. */
+  maxEntradas: number;
+  /** Tope del total descomprimido, sumando todas. */
+  maxTotalBytes: number;
+  /** Tope de una sola entrada. */
+  maxEntradaBytes: number;
+}
+
+export const LIMITES_ZIP: LimitesZip = {
+  maxEntradas: 200,
+  maxTotalBytes: 32 * 1024 * 1024,
+  maxEntradaBytes: 8 * 1024 * 1024,
+};
+
+/** Los cuatro bytes con los que empieza todo ZIP (y todo .docx, .xlsx, .odt). */
+export function esZip(bytes: Uint8Array): boolean {
+  return bytes.length > 4 && bytes[0] === 0x50 && bytes[1] === 0x4b && bytes[2] === 0x03 && bytes[3] === 0x04;
+}
+
+const u16 = (b: Uint8Array, i: number): number => b[i]! | (b[i + 1]! << 8);
+const u32 = (b: Uint8Array, i: number): number =>
+  (b[i]! | (b[i + 1]! << 8) | (b[i + 2]! << 16) | (b[i + 3]! << 24)) >>> 0;
+
+/**
+ * Quita lo que haría daño de una ruta interna.
+ *
+ * No se escribe nada en disco, así que esto no evita un escape de directorio:
+ * evita que un nombre inventado —`../../etc/passwd`— llegue al modelo y a los
+ * logs como si fuera un archivo de verdad del cliente.
+ */
+function rutaLimpia(nombre: string): string {
+  return nombre
+    .replace(/\\/g, '/')
+    .split('/')
+    .filter((p) => p && p !== '.' && p !== '..')
+    .join('/')
+    .slice(0, 200);
+}
+
+/** Dónde empieza el directorio central. Se busca desde el final. */
+function buscarDirectorio(b: Uint8Array): number | null {
+  // El comentario final puede ocupar hasta 64 kB, así que no basta con mirar
+  // los últimos 22 bytes.
+  const desde = Math.max(0, b.length - 22 - 0xffff);
+  for (let i = b.length - 22; i >= desde; i--) {
+    if (u32(b, i) === 0x06054b50) return u32(b, i + 16);
+  }
+  return null;
+}
+
+/**
+ * Los archivos de un ZIP, descomprimidos y acotados.
+ *
+ * Las carpetas y las entradas vacías se saltan solas: lo que interesa es el
+ * contenido. Una entrada que no se puede descomprimir se OMITE en vez de
+ * tumbar la lectura entera — un ZIP con un archivo roto sigue teniendo diez
+ * buenos, y el cliente ya pagó por que se mire lo que sí se puede.
+ */
+export function leerZip(datos: Uint8Array, limites: LimitesZip = LIMITES_ZIP): EntradaZip[] {
+  const inicio = buscarDirectorio(datos);
+  if (inicio === null || inicio >= datos.length) return [];
+
+  const salida: EntradaZip[] = [];
+  let total = 0;
+  let cursor = inicio;
+
+  while (cursor + 46 <= datos.length && u32(datos, cursor) === 0x02014b50) {
+    const metodo = u16(datos, cursor + 10);
+    const comprimido = u32(datos, cursor + 20);
+    const sinComprimir = u32(datos, cursor + 24);
+    const nLargo = u16(datos, cursor + 28);
+    const extraLargo = u16(datos, cursor + 30);
+    const comentarioLargo = u16(datos, cursor + 32);
+    const offsetLocal = u32(datos, cursor + 42);
+    const nombre = rutaLimpia(new TextDecoder().decode(datos.subarray(cursor + 46, cursor + 46 + nLargo)));
+
+    cursor += 46 + nLargo + extraLargo + comentarioLargo;
+
+    if (salida.length >= limites.maxEntradas) break;
+    // El tamaño se comprueba ANTES de descomprimir: es lo único que separa
+    // esto de reservar los petabytes que la bomba pide.
+    if (!nombre || sinComprimir === 0) continue;
+    if (sinComprimir > limites.maxEntradaBytes) continue;
+    if (total + sinComprimir > limites.maxTotalBytes) break;
+
+    // Ahora sí hay que mirar la cabecera local, sólo para saber dónde
+    // empiezan los datos: su longitud de extra puede ser distinta de la del
+    // directorio central, y darlo por hecho desplaza la lectura.
+    if (offsetLocal + 30 > datos.length || u32(datos, offsetLocal) !== 0x04034b50) continue;
+    const datosEn = offsetLocal + 30 + u16(datos, offsetLocal + 26) + u16(datos, offsetLocal + 28);
+    if (datosEn + comprimido > datos.length) continue;
+    const crudo = datos.subarray(datosEn, datosEn + comprimido);
+
+    try {
+      const bytes = metodo === 0 ? crudo : metodo === 8 ? new Uint8Array(inflateRawSync(crudo)) : null;
+      if (!bytes) continue;
+      total += bytes.length;
+      salida.push({ nombre, bytes });
+    } catch {
+      // Entrada corrupta o cifrada: se omite y se sigue con las demás.
+      continue;
+    }
+  }
+
+  return salida;
+}
+
+/* ══════════════════════════════════════════════════════════════════════════
+ * ESCRIBIR
+ *
+ * Hace falta para devolver un `.docx`, que es un ZIP con XML dentro. El mismo
+ * formato que se lee arriba, al revés.
+ * ══════════════════════════════════════════════════════════════════════════ */
+
+import { deflateRawSync } from 'node:zlib';
+
+/** CRC-32, que el ZIP exige por entrada. Tabla al vuelo: son 256 valores. */
+function crc32(bytes: Uint8Array): number {
+  let c: number;
+  const tabla: number[] = [];
+  for (let n = 0; n < 256; n++) {
+    c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    tabla[n] = c >>> 0;
+  }
+  let crc = 0xffffffff;
+  for (const b of bytes) crc = tabla[(crc ^ b) & 0xff]! ^ (crc >>> 8);
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function escribirU16(v: number): number[] {
+  return [v & 0xff, (v >>> 8) & 0xff];
+}
+function escribirU32(v: number): number[] {
+  return [v & 0xff, (v >>> 8) & 0xff, (v >>> 16) & 0xff, (v >>> 24) & 0xff];
+}
+
+/**
+ * Monta un ZIP.
+ *
+ * Se comprime todo con deflate. Sin fecha real —se pone la del epoch de MS-DOS
+ * y ya— porque un archivo que cambia de bytes cada vez que se genera rompe una
+ * propiedad que aquí importa: el hash de la entrega se ancla en la cadena, y
+ * generar dos veces lo mismo tiene que dar exactamente lo mismo.
+ */
+export function escribirZip(entradas: { nombre: string; bytes: Uint8Array }[]): Uint8Array {
+  const local: number[] = [];
+  const central: number[] = [];
+  let offset = 0;
+
+  for (const e of entradas) {
+    const nombre = [...new TextEncoder().encode(e.nombre)];
+    const comprimido = [...new Uint8Array(deflateRawSync(e.bytes))];
+    const crc = crc32(e.bytes);
+
+    const cabecera = [
+      ...escribirU32(0x04034b50),
+      ...escribirU16(20), // versión mínima
+      ...escribirU16(0),
+      ...escribirU16(8), // deflate
+      ...escribirU16(0), // hora
+      ...escribirU16(0x21), // fecha: 1980-01-01
+      ...escribirU32(crc),
+      ...escribirU32(comprimido.length),
+      ...escribirU32(e.bytes.length),
+      ...escribirU16(nombre.length),
+      ...escribirU16(0),
+      ...nombre,
+    ];
+    local.push(...cabecera, ...comprimido);
+
+    central.push(
+      ...escribirU32(0x02014b50),
+      ...escribirU16(20), // versión que lo creó
+      ...escribirU16(20),
+      ...escribirU16(0),
+      ...escribirU16(8),
+      ...escribirU16(0),
+      ...escribirU16(0x21),
+      ...escribirU32(crc),
+      ...escribirU32(comprimido.length),
+      ...escribirU32(e.bytes.length),
+      ...escribirU16(nombre.length),
+      ...escribirU16(0),
+      ...escribirU16(0), // comentario
+      ...escribirU16(0), // disco
+      ...escribirU16(0), // atributos internos
+      ...escribirU32(0), // atributos externos
+      ...escribirU32(offset),
+      ...nombre,
+    );
+    offset += cabecera.length + comprimido.length;
+  }
+
+  const fin = [
+    ...escribirU32(0x06054b50),
+    ...escribirU16(0),
+    ...escribirU16(0),
+    ...escribirU16(entradas.length),
+    ...escribirU16(entradas.length),
+    ...escribirU32(central.length),
+    ...escribirU32(local.length),
+    ...escribirU16(0),
+  ];
+
+  return new Uint8Array([...local, ...central, ...fin]);
+}