tracereports 0.1.2 → 0.2.0

package/README.es.md

@@ -9,4 +9,18 @@ Selenium WebDriver y cualquier runner. Node 18+, sin dependencias.
 npm install --save-dev tracereports
 ```
 
+- **Playwright Test**: el reporter envía cada test con sus pasos, error y capturas, más los traces y
+  videos que guarda Playwright; con los fixtures, también la red que vio el navegador, el DOM al
+  fallar y la consola del navegador.
+- **Selenium WebDriver o cualquier runner**: captura y DOM al fallar, y una API para pasos y red.
+- **Nunca frena ni rompe tus tests**: la evidencia sale en segundo plano, con reintentos y sin
+  duplicados; los shards pueden unirse a la misma ejecución.
+- **Sin servidor**: si el servidor está caído o rechaza el token, la ejecución se graba en local;
+  `tracereports report <carpeta>` arma el reporte HTML y `tracereports push <carpeta>` lo sube después.
+  Con `TRACEREPORTS_OFFLINE=both` además guarda esa copia local mientras envía al servidor
+  ([guía del reporte local](https://github.com/josemiguellopez/tracereports/blob/main/docs/es/local-report.md)).
+- **Configuración** desde el entorno o el `.env` del proyecto (`TRACEREPORTS_URL`, `TRACEREPORTS_TOKEN`…).
+
 Documentación completa: [docs/es/javascript.md](https://github.com/josemiguellopez/tracereports/blob/main/docs/es/javascript.md).
+
+Sin binario instalado, al cerrar se descarga y verifica el renderer v0.2.0 en la caché del usuario; `TRACEREPORTS_BIN_DOWNLOAD=0` permite trabajar sin internet con un binario instalado o en caché. Ver [modo offline](../../docs/es/offline.md).

package/README.md

@@ -9,4 +9,18 @@ Selenium WebDriver and any runner. Node 18+, no dependencies.
 npm install --save-dev tracereports
 ```
 
+- **Playwright Test**: the reporter sends each test with its steps, error and screenshots, plus the
+  traces and videos Playwright keeps; with the fixtures, also the network the browser saw, the DOM
+  at the failure and the browser console.
+- **Selenium WebDriver or any runner**: screenshot and DOM on failure, and an API for steps and network.
+- **Never slows down or breaks your tests**: evidence goes out in the background with retries and
+  no duplicates; shards can join the same run.
+- **Without a server**: if the server is down or rejects the token, the run is recorded locally;
+  `tracereports report <folder>` builds the HTML report and `tracereports push <folder>` uploads it later.
+  With `TRACEREPORTS_OFFLINE=both` it also keeps that local copy while sending to the server
+  ([local report guide](https://github.com/josemiguellopez/tracereports/blob/main/docs/en/local-report.md)).
+- **Configuration** from the environment or the project's `.env` (`TRACEREPORTS_URL`, `TRACEREPORTS_TOKEN`…).
+
 Full documentation: [docs/en/javascript.md](https://github.com/josemiguellopez/tracereports/blob/main/docs/en/javascript.md).
+
+Without an installed binary, closing downloads and verifies the v0.2.0 renderer in the user cache; `TRACEREPORTS_BIN_DOWNLOAD=0` supports offline use with an installed or cached binary. See [offline mode](../../docs/en/offline.md).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tracereports",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "TraceReports client for JavaScript/TypeScript: Playwright Test reporter and fixtures, Selenium WebDriver helpers and a client for any runner.",
   "keywords": [
     "testing",
@@ -43,7 +43,8 @@
     "node": ">=18"
   },
   "scripts": {
-    "test": "node --test \"test/*.test.js\""
+    "test": "node --test \"test/*.test.js\"",
+    "typecheck": "npx --yes -p typescript@7.0.2 tsc --noEmit --strict --skipLibCheck --target es2022 --module nodenext --moduleResolution nodenext test/types/public-api.ts"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.40"

package/src/binary.js

@@ -0,0 +1,125 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { gunzipSync, inflateRawSync } from "node:zlib";
+import { setTimeout as sleep } from "node:timers/promises";
+import { env } from "./env.js";
+
+export const REPORT_VERSION = "0.2.0";
+const RELEASES = "https://github.com/josemiguellopez/tracereports/releases/download";
+const MAX_BINARY = 256 * 1024 * 1024;
+const STALE_LOCK_MS = 300_000;
+const sha = data => createHash("sha256").update(data).digest("hex");
+
+// Read only the exact executable member; archive paths are never used as output paths.
+function executable(archive, name, windows) {
+  let found;
+  const accept = data => { if (found || !data.length || data.length > MAX_BINARY) throw Error("invalid release executable"); found = data; };
+  if (windows) {
+    let end = archive.length - 22;
+    while (end >= Math.max(0, archive.length - 65557) && archive.readUInt32LE(end) !== 0x06054b50) end--;
+    if (end < 0 || archive.readUInt32LE(end) !== 0x06054b50) throw Error("invalid ZIP");
+    let offset = archive.readUInt32LE(end + 16);
+    for (let i = 0; i < archive.readUInt16LE(end + 10); i++) {
+      if (archive.readUInt32LE(offset) !== 0x02014b50) throw Error("invalid ZIP directory");
+      const length = archive.readUInt16LE(offset + 28);
+      if (archive.toString("utf8", offset + 46, offset + 46 + length) === name) {
+        const method = archive.readUInt16LE(offset + 10), size = archive.readUInt32LE(offset + 20);
+        const local = archive.readUInt32LE(offset + 42);
+        if (archive.readUInt32LE(local) !== 0x04034b50 || archive.readUInt32LE(offset + 24) > MAX_BINARY) throw Error("invalid ZIP executable");
+        const start = local + 30 + archive.readUInt16LE(local + 26) + archive.readUInt16LE(local + 28);
+        if (start + size > archive.length) throw Error("truncated ZIP");
+        const compressed = archive.subarray(start, start + size);
+        if (![0, 8].includes(method)) throw Error("unsupported ZIP compression");
+        accept(method === 0 ? compressed : inflateRawSync(compressed, { maxOutputLength: MAX_BINARY }));
+      }
+      offset += 46 + length + archive.readUInt16LE(offset + 30) + archive.readUInt16LE(offset + 32);
+    }
+  } else {
+    const tar = gunzipSync(archive, { maxOutputLength: MAX_BINARY + 8 * 1024 * 1024 });
+    for (let offset = 0; offset + 512 <= tar.length; ) {
+      const header = tar.subarray(offset, offset + 512);
+      if (header.every(b => b === 0)) break;
+      const member = header.toString("utf8", 0, 100).split("\0")[0];
+      const size = parseInt(header.toString("ascii", 124, 136).replace(/\0/g, "").trim(), 8);
+      if (!Number.isSafeInteger(size) || size < 0 || offset + 512 + size > tar.length) throw Error("invalid TAR member");
+      if (member === name && [0, 48].includes(header[156]) && header[345] === 0) accept(tar.subarray(offset + 512, offset + 512 + size));
+      offset += 512 + Math.ceil(size / 512) * 512;
+    }
+  }
+  if (!found) throw Error("release executable missing");
+  return found;
+}
+
+export async function downloadBinary(timeoutMs = 60_000) {
+  const system = { win32: "windows", linux: "linux", darwin: "darwin" }[process.platform];
+  const arch = { x64: "amd64", arm64: "arm64" }[process.arch];
+  if (!system || !arch) throw Error("unsupported report platform");
+  const base = (system === "windows" ? process.env.LOCALAPPDATA : system === "darwin" ? "" : process.env.XDG_CACHE_HOME) ||
+    (system === "darwin" ? path.join(os.homedir(), "Library", "Caches") : path.join(os.homedir(), ".cache"));
+  const parent = path.join(base, "tracereports", REPORT_VERSION), target = path.join(parent, `${system}_${arch}`);
+  const name = system === "windows" ? "tracereports.exe" : "tracereports", binary = path.join(target, name);
+  const cached = () => {
+    try { return fs.lstatSync(binary).isFile() && sha(fs.readFileSync(binary)) === fs.readFileSync(path.join(target, "binary.sha256"), "utf8").trim(); }
+    catch { return false; }
+  };
+  if (cached()) return binary;
+  if (env("BIN_DOWNLOAD", "1") === "0") throw Error("binary download disabled");
+  const deadline = Date.now() + timeoutMs, lock = path.join(parent, `${system}_${arch}.lock`);
+  fs.mkdirSync(parent, { recursive: true });
+  while (true) {
+    if (cached()) return binary;
+    if (Date.now() >= deadline) throw Error("waiting for report binary cache timed out");
+    try { fs.mkdirSync(lock); break; }
+    catch (err) {
+      if (err.code !== "EEXIST") throw err;
+      // A download holds the lock for at most its timeout: an older one was left by a process that
+      // died mid-download and would otherwise block every later run.
+      try { if (Date.now() - fs.statSync(lock).mtimeMs > STALE_LOCK_MS) { fs.rmdirSync(lock); continue; } } catch { /* removed meanwhile */ }
+      await sleep(50);
+    }
+  }
+  let staging;
+  const controller = new AbortController(), timer = setTimeout(() => controller.abort(), Math.max(1, deadline - Date.now()));
+  try {
+    if (cached()) return binary;
+    const baseUrl = env("BIN_BASE_URL") || RELEASES;
+    if (baseUrl !== RELEASES) {
+      const url = new URL(baseUrl);
+      if (url.protocol !== "http:" || !["127.0.0.1", "localhost", "[::1]"].includes(url.hostname) || url.username || url.password) throw Error("BIN_BASE_URL must be a loopback test server");
+    }
+    const asset = `tracereports_${REPORT_VERSION}_${system}_${arch}.${system === "windows" ? "zip" : "tar.gz"}`;
+    const download = async (filename, limit) => {
+      const response = await fetch(`${baseUrl.replace(/\/$/, "")}/v${REPORT_VERSION}/${filename}`, { signal: controller.signal });
+      if (!response.ok) { await response.body?.cancel(); throw Error(`release download HTTP ${response.status}`); }
+      const chunks = []; let size = 0;
+      for await (const chunk of response.body) {
+        size += chunk.length;
+        if (size > limit) throw Error("release download too large");
+        chunks.push(chunk);
+      }
+      return Buffer.concat(chunks);
+    };
+    const checksums = (await download("checksums.txt", 1024 * 1024)).toString("utf8");
+    const hashes = checksums.split(/\r?\n/).map(line => line.trim().split(/\s+/)).filter(p => p.length === 2 && p[1].replace(/^\*/, "") === asset).map(p => p[0].toLowerCase());
+    if (hashes.length !== 1 || !/^[a-f0-9]{64}$/.test(hashes[0])) throw Error("release checksum missing or ambiguous");
+    const archive = await download(asset, 128 * 1024 * 1024);
+    if (sha(archive) !== hashes[0]) throw Error("release checksum mismatch");
+    const data = executable(archive, name, system === "windows");
+    fs.mkdirSync(target, { recursive: true });
+    staging = fs.mkdtempSync(path.join(parent, ".download-"));
+    fs.writeFileSync(path.join(staging, name), data, { mode: 0o755 });
+    fs.writeFileSync(path.join(staging, "binary.sha256"), sha(data));
+    // Other processes wait on the lock while the two cache files are replaced.
+    fs.rmSync(binary, { force: true });
+    fs.rmSync(path.join(target, "binary.sha256"), { force: true });
+    fs.renameSync(path.join(staging, "binary.sha256"), path.join(target, "binary.sha256"));
+    fs.renameSync(path.join(staging, name), binary);
+    return binary;
+  } finally {
+    clearTimeout(timer);
+    if (staging) fs.rmSync(staging, { recursive: true, force: true });
+    fs.rmdirSync(lock);
+  }
+}

package/src/env.js

@@ -86,10 +86,13 @@ export function resetEnvFile() {
   filePath = null;
 }
 
-/** TRACEREPORTS_<name>: primero del entorno, después del .env del proyecto. */
+/**
+ * TRACEREPORTS_<name>: del entorno y, si no está definida ahí, del .env del proyecto. Definida en el
+ * entorno manda aunque esté vacía (como en el servidor): vacía es "sin configurar" (fallback) y el
+ * .env no la reemplaza.
+ */
 export function env(name, fallback = undefined) {
-  for (const v of [process.env[PREFIX + name], fromFile()[PREFIX + name]]) {
-    if (v !== undefined && v !== "") return v;
-  }
-  return fallback;
+  const own = process.env[PREFIX + name];
+  const v = own !== undefined ? own : fromFile()[PREFIX + name];
+  return v !== undefined && v !== "" ? v : fallback;
 }

package/src/index.d.ts

@@ -4,11 +4,21 @@ export interface Delivery {
   sent: number; retried: number; rejected: number; dropped: number; lost: number; pending: number; unregisteredTests: number;
   /** 1 si el servidor no confirmó el cierre de la ejecución. */
   runNotClosed: number;
+  /** Events recorded locally, including the copy in both mode. */
+  recorded?: number;
 }
 
 export interface TraceReportsOptions {
   baseUrl?: string; token?: string; enabled?: boolean; timeoutMs?: number; uploadTimeoutMs?: number;
   flushTimeoutMs?: number; maxQueueItems?: number; maxQueueMB?: number;
+  /** Exact recording folder, shared by the processes of one run (default $TRACEREPORTS_OFFLINE_DIR; without it, a new folder per session inside offlineBase). */
+  offlineDir?: string;
+  /** Folder where each session creates its own recording folder (default $TRACEREPORTS_OFFLINE_BASE or ./tracereports-offline). */
+  offlineBase?: string;
+  /** Label for automatically created recording folders (default: the run name). */
+  offlineName?: string;
+  /** auto (default): record if run creation fails; always: no server; both: send and record; off: never record. */
+  offline?: "auto" | "always" | "both" | "off";
 }
 
 export interface RunOptions { environment?: string; project?: string; branch?: string; commit?: string; framework?: string }
@@ -25,6 +35,8 @@ export interface Connection {
   failed?: boolean; error_text?: string; started_at?: number; duration_ms?: number | null;
   request_headers?: Record<string, string>; post_data?: string; response_headers?: Record<string, string>;
   response_body?: string; body_size?: number; expected?: boolean;
+  /** The body was already cut before reaching the client (body_size keeps the original size). */
+  body_truncated?: boolean;
 }
 
 export class TraceReports {
@@ -32,9 +44,13 @@ export class TraceReports {
   baseUrl: string; runId: number | null; runCreated: boolean; enabled: boolean;
   readonly delivery: Delivery;
   readonly reportUrl: string;
+  /** True when evidence is recorded locally, including both mode. */
+  readonly recording: boolean;
+  offlineDir: string | null;
+  offlineReport: string | null;
   deliveryProblems(): number;
   startRun(name: string, opts?: RunOptions): Promise<number | null>;
-  joinRun(runId: number | string): number | null;
+  joinRun(runId: number | string, opts?: { offlineDir?: string }): number | null;
   finishRun(opts?: { interrupted?: boolean }): Promise<unknown>;
   flush(timeoutMs?: number): Promise<number>;
   startTest(name: string, opts?: TestOptions): Promise<TraceTest>;
@@ -42,7 +58,13 @@ export class TraceReports {
   test<T>(name: string, opts: TestOptions, fn: (t: TraceTest) => T | Promise<T>): Promise<T>;
 }
 
+export interface ConsoleEntry { level: "error" | "warning" | "pageerror" | "info" | "log" | "debug"; text: string; location?: string; timestamp?: number }
+
 export class TraceTest {
+  /** Browser console of the test (its "Console" tab). Captured by the tracereports/playwright fixtures. */
+  console(entries: ConsoleEntry[]): boolean;
+  /** Attaches the Playwright trace (trace.zip) or the test video (WebM/MP4): a Buffer or a file path. */
+  artifact(kind: "trace" | "video", data: Buffer | Uint8Array | string, name?: string): boolean;
   readonly id: number | null; readonly active: boolean; attempts: number;
   log(status: Status, message: string, timestamp?: number): void;
   info(message: string): void; pass(message: string): void; fail(message: string): void; warn(message: string): void; skip(message: string): void;
@@ -53,6 +75,10 @@ export class TraceTest {
   finish(status?: Status | "", opts?: { errorMessage?: string; errorTrace?: string; error?: unknown; attempts?: number }): void;
 }
 
+/** Lotes de red (bytes del JSON enviado): el servidor acepta hasta 48 MiB por request. */
+export const NETWORK_BATCH_BYTES: number;
+export const NETWORK_ALONE_BYTES: number;
+export function networkBatches(payload: object[], opts?: { maxCount?: number; maxBytes?: number; aloneBytes?: number }): string[];
 export const DOM_SCRIPT: string;
 
 export function domSnapshotInPage(): unknown;

package/src/index.js

@@ -12,18 +12,71 @@
 //   await cr.finishRun();                                  // espera la cola y cierra la ejecución
 //
 // Nunca rompe ni frena la suite: la evidencia sale en segundo plano con reintentos e
-// Idempotency-Key (sin duplicados); si el servidor no responde, los métodos siguen funcionando
-// como no-op y `cr.delivery` dice qué no llegó.
+// Idempotency-Key (sin duplicados); `cr.delivery` dice qué no llegó. Si la ejecución no se puede
+// crear (sin servidor, caído o con el token equivocado) la evidencia se graba en una carpeta
+// ($TRACEREPORTS_OFFLINE_DIR, default ./tracereports-offline/<sesión>) en vez de perderse:
+// `tracereports report <carpeta>` arma el reporte HTML y `tracereports push <carpeta>` la sube.
 
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
 import path from "node:path";
 import { detectBranch, detectCommit } from "./context.js";
 import { env } from "./env.js";
+import { Recorder, newSessionDir } from "./offline.js";
+import { Mirror } from "./mirror.js";
 import { Sender } from "./transport.js";
+import { downloadBinary } from "./binary.js";
 
 export const VERSION = "0.1.0";
 const STATUSES = new Set(["INFO", "PASS", "FAIL", "WARNING", "SKIP"]);
 const truthy = (v) => ["1", "true", "yes"].includes(String(v || "").toLowerCase());
 
+// Lotes de red: el servidor acepta hasta 48 MiB por request. Se arma cada lote por los bytes del
+// JSON que realmente se envía (UTF-8, con escapes), hasta NETWORK_BATCH_BYTES y batchSize
+// conexiones. Una conexión más grande va sola; si sola pasa NETWORK_ALONE_BYTES, se envía sin
+// bodies ni headers (body_truncated, con su body_size original) para que siempre entre.
+export const NETWORK_BATCH_BYTES = 8 << 20;
+export const NETWORK_ALONE_BYTES = 40 << 20;
+
+const cut = (s, n) => {
+  const str = String(s ?? "");
+  if (str.length <= n) return str;
+  const end = /[\uD800-\uDBFF]/.test(str[n - 1]) ? n - 1 : n; // sin partir un par sustituto
+  return str.slice(0, end);
+};
+
+function slimConnection(c) {
+  return {
+    ...c, url: cut(c.url, 4096), status_text: cut(c.status_text, 256), mime_type: cut(c.mime_type, 256),
+    resource_type: cut(c.resource_type, 32), error_text: cut(c.error_text, 2048), method: cut(c.method, 16),
+    request_headers: {}, response_headers: {}, post_data: "", response_body: "", body_truncated: true,
+  };
+}
+
+/** Lotes de JSON {"connections":[...]} de a lo sumo maxBytes y maxCount, en orden. */
+export function networkBatches(payload, { maxCount = 200, maxBytes = NETWORK_BATCH_BYTES, aloneBytes = NETWORK_ALONE_BYTES } = {}) {
+  const head = '{"connections":[', tail = "]}";
+  const out = [];
+  let parts = [], size = 0;
+  for (let c of payload) {
+    let raw = JSON.stringify(c), n = Buffer.byteLength(raw);
+    if (n + head.length + tail.length > aloneBytes) {
+      raw = JSON.stringify(slimConnection(c));
+      n = Buffer.byteLength(raw);
+    }
+    if (parts.length && (parts.length >= maxCount || size + 1 + n > maxBytes)) {
+      out.push(head + parts.join(",") + tail);
+      parts = [];
+      size = head.length + tail.length;
+    }
+    if (!parts.length) size = head.length + tail.length;
+    size += (parts.length ? 1 : 0) + n;
+    parts.push(raw);
+  }
+  if (parts.length) out.push(head + parts.join(",") + tail);
+  return out;
+}
+
 export class TraceReports {
   /**
    * @param {object} [opts]
@@ -35,6 +88,10 @@ export class TraceReports {
    * @param {number} [opts.flushTimeoutMs]  cuánto espera finishRun la cola (default $TRACEREPORTS_FLUSH_TIMEOUT s o 30 s)
    * @param {number} [opts.maxQueueItems]   default 5000
    * @param {number} [opts.maxQueueMB]      default 64
+   * @param {string} [opts.offlineDir] dónde grabar sin servidor (default $TRACEREPORTS_OFFLINE_DIR; sin
+   *   ella, una carpeta nueva por sesión dentro de ./tracereports-offline)
+   * @param {"auto"|"always"|"both"|"off"} [opts.offline] auto (default, $TRACEREPORTS_OFFLINE): grabar solo si
+   *   la ejecución no se puede crear; always: grabar sin intentar un servidor; off: nunca
    */
   constructor(opts = {}) {
     this.baseUrl = (opts.baseUrl || env("URL") || "http://localhost:8080").replace(/\/+$/, "");
@@ -51,6 +108,68 @@ export class TraceReports {
     this.runCreated = false;
     this.runNotClosed = false;
     this.unregisteredTests = 0;
+
+    let mode = String(opts.offline ?? env("OFFLINE", "auto")).trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(mode)) mode = "always";
+    if (["0", "false", "no"].includes(mode)) mode = "off";
+    this.offlineMode = mode;
+    const explicit = opts.offlineDir || env("OFFLINE_DIR") || "";
+    // sin carpeta exacta, cada sesión crea la suya dentro de la base: corridas sucesivas no se pisan
+    this.offlineBase = explicit || opts.offlineBase || env("OFFLINE_BASE") || "tracereports-offline";
+   this.offlineExplicit = Boolean(explicit);
+    this.offlineName = opts.offlineName || env("OFFLINE_NAME", "");
+    this.offlineDir = null; // carpeta donde se graba (null: se envía al servidor)
+    this.offlineReport = null; // index.html generado al cerrar
+  }
+
+  /** true si la evidencia se graba localmente (sin servidor). */
+  get recording() {
+    return this.offlineDir != null;
+  }
+
+  goOffline(reason = "") {
+    const dir = this.offlineExplicit ? this.offlineBase : newSessionDir(this.offlineBase, this.offlineName);
+    try {
+      this.sender = new Recorder(dir);
+    } catch (err) {
+      console.warn(`tracereports: no se pudo grabar en ${dir}: ${err.message}`);
+      return;
+    }
+    this.offlineDir = dir;
+    if (reason) {
+      console.warn(`tracereports: ${reason}; la evidencia se graba en ${dir}`);
+    }
+  }
+
+  goMirror(runId, payload, directory) {
+    const dir = directory || (this.offlineExplicit ? this.offlineBase : newSessionDir(this.offlineBase, this.offlineName));
+    try {
+      this.sender = new Mirror(this.sender, dir, this.baseUrl, runId, payload);
+      this.offlineDir = dir;
+    } catch (err) { console.warn(`tracereports: no se pudo iniciar la copia local en ${dir}: ${err.message}`); }
+  }
+
+  /** Arma el HTML con el binario instalado o el renderer verificado de la caché. */
+  async buildOfflineReport({ zip } = {}) {
+    try {
+      if (["0", "false", "no"].includes(String(env("OFFLINE_REPORT", "1")).toLowerCase())) throw Error("automatic report disabled");
+      const bin = env("BIN") || findInPath("tracereports") || await downloadBinary();
+      const out = path.join(this.offlineDir, "report");
+      const args = ["report", "-o", out, ...(zip ? ["--zip", zip] : []), this.offlineDir];
+      const res = spawnSync(bin, args, { timeout: 300_000, encoding: "utf8" });
+      if (res.status !== 0) throw Error((res.stderr || res.error?.message || "renderer failed").trim());
+      const index = path.join(out, "index.html");
+      if (!fs.statSync(index).isFile()) throw Error("renderer did not create index.html");
+      this.offlineReport = index;
+      if (this.runId > 0) console.warn(`tracereports: server report: ${this.reportUrl}`);
+      console.warn(`tracereports: reporte local: ${this.offlineReport}`);
+      return this.offlineReport;
+    } catch (err) {
+      console.warn(`tracereports: local report unavailable (${err.message}); evidence retained in ${this.offlineDir}. ` +
+        `install the binary and run \`tracereports report ${this.offlineDir}\`, or run ` +
+        `\`tracereports push ${this.offlineDir}\` with the correct token when the server is available.`);
+      return null;
+    }
   }
 
   headers() {
@@ -76,6 +195,7 @@ export class TraceReports {
   }
 
   get reportUrl() {
+    if (this.recording && this.runId < 0) return this.offlineReport || "";
     return this.runId ? `${this.baseUrl}/#run=${this.runId}&view=dashboard` : "";
   }
 
@@ -98,16 +218,26 @@ export class TraceReports {
    * ambiente y rama.
    */
   async startRun(name, { environment = "", project, branch, commit, framework = "" } = {}) {
+    this.offlineName = name || this.offlineName;
     if (env("RUN_ID")) return this.joinRun(env("RUN_ID"));
-    const res = await this.request("POST", "/api/v1/runs", {
+    const payload = {
       name,
       environment,
       project: project ?? env("PROJECT") ?? path.basename(process.cwd()),
       branch: branch ?? detectBranch(),
       commit: commit ?? detectCommit(),
       framework,
-    });
-    this.runId = res?.run_id ?? null;
+    };
+    if (this.enabled && this.offlineMode === "always" && !this.recording) this.goOffline("offline mode");
+    const res = await this.request("POST", "/api/v1/runs", payload);
+    let created = res;
+    if (!created && this.enabled && ["auto", "both"].includes(this.offlineMode) && !this.recording) {
+      // sin servidor, caído o con el token equivocado: se graba en vez de perderlo todo
+      this.goOffline(`no se pudo crear la ejecución en ${this.baseUrl} (servidor caído o token incorrecto)`);
+      if (this.recording) created = await this.request("POST", "/api/v1/runs", payload);
+    }
+    if (created?.run_id > 0 && this.offlineMode === "both" && !this.recording) this.goMirror(created.run_id, payload);
+    this.runId = created?.run_id ?? null;
     this.runCreated = Boolean(this.runId);
     if (this.enabled && !this.runId) {
       console.warn(`tracereports: no se pudo crear la ejecución en ${this.baseUrl}; los tests siguen sin reporte.`);
@@ -115,8 +245,19 @@ export class TraceReports {
     return this.runId;
   }
 
-  /** Reporta en una ejecución creada en otro proceso; quien la creó la cierra. */
-  joinRun(runId) {
+  /**
+   * Reporta en una ejecución creada en otro proceso; quien la creó la cierra. Un runId negativo es
+   * una ejecución que se graba sin servidor: pasa la misma `offlineDir`.
+   */
+  joinRun(runId, { offlineDir } = {}) {
+    if (runId && Number(runId) < 0 && this.enabled && !this.recording) {
+      if (offlineDir || env("OFFLINE_DIR")) {
+        this.offlineBase = offlineDir || env("OFFLINE_DIR");
+        this.offlineExplicit = true;
+      }
+      this.goOffline();
+    }
+    if (Number(runId) > 0 && this.enabled && this.offlineMode === "both" && !this.recording) this.goMirror(Number(runId), null, offlineDir);
     this.runId = runId ? Number(runId) : null;
     this.runCreated = false;
     return this.runId;
@@ -124,13 +265,26 @@ export class TraceReports {
 
   /** Espera la cola (flushTimeoutMs) y cierra la ejecución. interrupted: incompleta, nunca verde. */
   async finishRun({ interrupted = false } = {}) {
-    await this.flush();
+    if (this.sender instanceof Mirror && this.sender.closed) return null;
+    const pending = await this.flush();
     this.sender.abandon();
+    if (!this.runCreated && this.sender instanceof Mirror) this.sender.close(pending === 0 && this.deliveryProblems() === 0 && !interrupted);
     if (!this.runId || !this.runCreated || !this.enabled) return null; // unido a otra: la cierra su dueño
     // el cierre importa más que un paso: más reintentos, siempre con la misma Idempotency-Key
     const res = await this.sender.sendNow("PATCH", `/api/v1/runs/${this.runId}/finish`,
       JSON.stringify({ interrupted }), "application/json", this.timeoutMs, 4, { ignoreCircuit: true });
     this.runNotClosed = res == null;
+    if (this.recording) {
+      if (this.sender instanceof Mirror) {
+        this.sender.close(pending === 0 && this.deliveryProblems() === 0 && !interrupted);
+        const before = this.sender.prepare();
+        await this.buildOfflineReport();
+        this.sender.finalize(this.offlineReport, env("OFFLINE_KEEP") === "1", before);
+        return res;
+      }
+      await this.buildOfflineReport();
+      return res;
+    }
     if (this.runNotClosed) {
       console.warn(`tracereports: el servidor no confirmó el cierre de la ejecución #${this.runId}: quedó abierta ` +
         `(ciérrala con PATCH ${this.baseUrl}/api/v1/runs/${this.runId}/finish)`);
@@ -154,7 +308,7 @@ export class TraceReports {
     if (!this.runId) return new TraceTest(this, null);
     const res = await this.request("POST", `/api/v1/runs/${this.runId}/tests`,
       { name, category, description, key, suite, params, worker: String(worker ?? "") });
-    if (this.enabled && !res?.test_id) this.unregisteredTests++;
+    if (this.enabled && (!res?.test_id || (this.sender instanceof Mirror && res.test_id < 0))) this.unregisteredTests++;
     return new TraceTest(this, res?.test_id ?? null);
   }
 
@@ -224,6 +378,47 @@ export class TraceTest {
     this.cr.emit("POST", `/api/v1/tests/${this.id}/screenshot`, body, `multipart/form-data; boundary=${boundary}`, this.cr.uploadTimeoutMs);
   }
 
+  /**
+   * Consola del navegador del test (pestaña "Consola"): [{level: "error"|"warning"|"pageerror"|...,
+   * text, location, timestamp}]. Con los fixtures de `tracereports/playwright` se captura sola.
+   */
+  console(entries) {
+    if (!this.active || !entries?.length) return false;
+    return this.cr.emit("POST", `/api/v1/tests/${this.id}/console`, JSON.stringify({ entries: entries.slice(0, 500) }), "application/json",
+      Math.max(this.cr.uploadTimeoutMs, 10_000));
+  }
+
+  /**
+   * Adjunta el trace de Playwright (`kind: "trace"`, el trace.zip) o el video del test
+   * (`kind: "video"`, WebM o MP4): Buffer o ruta. Hasta 100 MB; el reporte muestra el video y abre el
+   * trace en el Trace Viewer.
+   */
+  artifact(kind, data, name = "") {
+    if (!this.active || !data) return false;
+    let body = data;
+    if (typeof data === "string") {
+      try {
+        body = fs.readFileSync(data);
+        name ||= path.basename(data);
+      } catch {
+        return false;
+      }
+    }
+    if (body.length > 100 << 20) {
+      console.warn(`tracereports: ${name || kind} pesa más de 100 MB: no se adjunta`);
+      return false;
+    }
+    const boundary = `----tracereports${Math.random().toString(16).slice(2)}`;
+    const part = (n, v) => `--${boundary}\r\nContent-Disposition: form-data; name="${n}"\r\n\r\n${v}\r\n`;
+    const multipart = Buffer.concat([
+      Buffer.from(part("kind", kind) + part("name", String(name).replace(/[\r\n"]/g, " "))),
+      Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="artifact"\r\nContent-Type: application/octet-stream\r\n\r\n`),
+      Buffer.from(body),
+      Buffer.from(`\r\n--${boundary}--\r\n`),
+    ]);
+    return this.cr.emit("POST", `/api/v1/tests/${this.id}/artifact`, multipart, `multipart/form-data; boundary=${boundary}`, Math.max(this.cr.uploadTimeoutMs, 60_000));
+  }
+
   /**
    * Declara una respuesta negativa que el test verifica a propósito (p. ej. un 401 con
    * credenciales inválidas): no cuenta como error ni como causa del fallo. `url`: texto contenido
@@ -256,14 +451,14 @@ export class TraceTest {
         error_text: String(c.error_text || ""), started_at: Math.round(c.started_at || 0),
         duration_ms: c.duration_ms == null ? null : Math.round(c.duration_ms),
         request_headers: c.request_headers || {}, post_data: String(c.post_data || ""),
-        response_headers: c.response_headers || {}, response_body: body.slice(0, limit),
-        body_size: Math.max(Number(c.body_size || 0), body.length), body_truncated: body.length > limit,
+        // el body pudo llegar ya recortado (captura): su indicador y su tamaño original (bytes) se conservan
+        response_headers: c.response_headers || {}, response_body: cut(body, limit),
+        body_size: Math.max(Number(c.body_size || 0), Buffer.byteLength(body)), body_truncated: Boolean(c.body_truncated) || body.length > limit,
         expected: Boolean(c.expected) || this.isExpected(c),
       };
     });
-    for (let i = 0; i < payload.length; i += batchSize) {
-      this.cr.emit("POST", `/api/v1/tests/${this.id}/network`, JSON.stringify({ connections: payload.slice(i, i + batchSize) }),
-        "application/json", this.cr.uploadTimeoutMs);
+    for (const body of networkBatches(payload, { maxCount: batchSize })) {
+      this.cr.emit("POST", `/api/v1/tests/${this.id}/network`, body, "application/json", this.cr.uploadTimeoutMs);
     }
     return { stored: payload.length, errors: payload.filter((p) => !p.expected && (p.failed || p.status >= 400)).length };
   }
@@ -294,3 +489,17 @@ export class TraceTest {
 
 export { DOM_SCRIPT, domSnapshotInPage } from "./dom.js";
 
+function findInPath(name) {
+  const exts = process.platform === "win32" ? (process.env.PATHEXT || ".EXE").split(";") : [""];
+  for (const dir of (process.env.PATH || "").split(path.delimiter)) {
+    for (const ext of exts) {
+      const file = path.join(dir, name + ext.toLowerCase());
+      try {
+        if (dir && fs.statSync(file).isFile()) return file;
+      } catch {
+        // no está aquí
+      }
+    }
+  }
+  return null;
+}

package/src/mirror.js

@@ -0,0 +1,173 @@
+// Copia de cada llamada lógica; los reintentos siguen siendo responsabilidad del Sender.
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { Recorder, MARKER } from "./offline.js";
+
+// Un proceso tiene el bloqueo unos milisegundos: uno más viejo quedó de un proceso que murió.
+const STALE_LOCK_MS = 30_000;
+
+export class Mirror {
+  constructor(sender, directory, server, runId, payload) {
+    this.sender = sender;
+    this.directory = directory;
+    this.runs = new Map();
+    this.tests = new Map();
+    this.failed = false;
+    this.closed = false;
+    this.disabled = false;
+    this.active = 0;
+    fs.mkdirSync(directory, { recursive: true });
+    this.locked(() => {
+      const marker = path.join(directory, MARKER);
+      if (fs.existsSync(marker) && JSON.parse(fs.readFileSync(marker)).raw_removed) throw new Error("la carpeta solo contiene el reporte; usa otra carpeta");
+      this.recorder = new Recorder(directory);
+      this.status = `status-${process.pid}-${this.recorder.tag}.json`;
+      this.write(this.status, { complete: false, reason: "active" });
+      const m = JSON.parse(fs.readFileSync(marker));
+      if (m.mirror && m.mirror.server !== server) throw new Error("la carpeta pertenece a otro servidor");
+      m.mirror ||= { server, runs: [], complete: false };
+      m.mirror.complete = false;
+      this.write(MARKER, m);
+      let local;
+      const mapping = path.join(directory, "ids", `server-${runId}`);
+      if (payload) {
+        local = this.recorder.record("POST", "/api/v1/runs", JSON.stringify(payload), "application/json").run_id;
+        fs.writeFileSync(mapping, String(local), { flag: "wx" });
+        m.mirror.runs.push({ local, server: runId });
+        this.write(MARKER, m);
+      } else {
+        try {
+          local = Number(fs.readFileSync(mapping, "utf8"));
+          if (!Number.isSafeInteger(local) || local >= 0) throw new Error("id local inválido");
+        } catch (err) {
+          this.failed = true;
+          console.warn(`tracereports: falta el id local de la ejecución #${runId}: ${err.message}`);
+        }
+      }
+      if (local) this.runs.set(runId, local);
+    });
+  }
+
+  locked(fn) {
+    const lock = path.join(this.directory, ".mirror-lock");
+    for (let n = 0; ; n++) {
+      try { fs.mkdirSync(lock); break; } catch (err) {
+        if (err.code !== "EEXIST") throw err;
+        if (n >= 50) {
+          let stale = false;
+          try { stale = Date.now() - fs.statSync(lock).mtimeMs > STALE_LOCK_MS; } catch { /* ya no existe */ }
+          if (!stale) throw new Error(`${lock} lo tiene otro proceso (bórralo si ninguna ejecución usa esta carpeta)`);
+          try { fs.rmdirSync(lock); } catch { /* otro proceso lo retiró antes */ }
+          n = 0; // huérfano: se retira y se vuelve a intentar
+        }
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+      }
+    }
+    try { return fn(); } finally { fs.rmdirSync(lock); }
+  }
+
+  write(name, value) {
+    const dest = path.join(this.directory, name), tmp = `${dest}.${randomUUID()}.tmp`;
+    try {
+      fs.writeFileSync(tmp, JSON.stringify(value));
+      try { fs.renameSync(tmp, dest); }
+      catch (err) {
+        // Windows can reject a replacement rename even while this process owns the lock.
+        if (err.code !== "EPERM" && err.code !== "EACCES") throw err;
+        fs.copyFileSync(tmp, dest);
+        fs.rmSync(tmp, { force: true });
+      }
+    } finally { fs.rmSync(tmp, { force: true }); }
+  }
+
+  diskError(err) {
+    this.failed = true;
+    if (!this.disabled) console.warn(`tracereports: se detuvo la copia local en ${this.directory}: ${err.message}`);
+    this.disabled = true;
+  }
+
+  record(method, apiPath, body, contentType) {
+    if (this.disabled || this.closed) return null;
+    try {
+      const localPath = apiPath.replace(/^\/api\/v1\/(runs|tests)\/(-?\d+)/, (match, kind, id) => {
+        const ids = kind === "runs" ? this.runs : this.tests;
+        let local = ids.get(Number(id));
+        if (Number(id) > 0 && !local) {
+          this.failed = true;
+          // Referencia local sin creación: replay la omite, nunca modifica un run remoto ajeno.
+          local = this.recorder.localId();
+          ids.set(Number(id), local);
+        }
+        return `/api/v1/${kind}/${local ?? id}`;
+      });
+      return this.recorder.record(method, localPath, body, contentType);
+    } catch (err) { this.diskError(err); return null; }
+  }
+
+  async sendNow(method, apiPath, body, contentType, ...args) {
+    this.active++;
+    const local = this.record(method, apiPath, body, contentType);
+    try {
+      const remote = /\/(runs|tests)\/-\d+/.test(apiPath) ? null : await this.sender.sendNow(method, apiPath, body, contentType, ...args);
+      if (remote == null) this.failed = true;
+      if (local?.test_id && remote?.test_id) this.tests.set(remote.test_id, local.test_id);
+      // Si el servidor ya no crea tests, la evidencia posterior sigue usando el id local.
+      return remote ?? (local?.test_id ? local : null);
+    } finally { this.active--; }
+  }
+
+  enqueue(method, apiPath, body, contentType, ...args) {
+    this.record(method, apiPath, body, contentType);
+    if (/\/(runs|tests)\/-\d+/.test(apiPath)) { this.failed = true; return false; }
+    const ok = this.sender.enqueue(method, apiPath, body, contentType, ...args);
+    if (!ok) this.failed = true;
+    return ok;
+  }
+
+  get stats() { return { ...this.sender.stats, recorded: this.recorder.stats.recorded }; }
+  get pending() { return this.sender.pending; }
+  serverDown() { return this.sender.serverDown(); }
+  flush(...args) { return this.sender.flush(...args); }
+  abandon() { return this.sender.abandon(); }
+
+  close(complete) {
+    if (this.closed) return;
+    this.closed = true;
+    try {
+      const ok = complete && !this.failed && this.active === 0;
+      this.locked(() => this.write(this.status, { complete: ok, reason: ok ? "" : "delivery or recording incomplete" }));
+    } catch (err) { this.diskError(err); }
+  }
+
+  snapshot() {
+    const files = fs.readdirSync(this.directory).filter(n => /^status-.*\.json$/.test(n)).sort();
+    const events = fs.readdirSync(this.directory).filter(n => /^events-.*\.jsonl$/.test(n));
+    if (!files.length || events.some(n => !files.includes(n.replace(/^events-/, "status-").replace(/\.jsonl$/, ".json")))) return null;
+    const entries = files.map(n => [n, fs.readFileSync(path.join(this.directory, n), "utf8")]);
+    return entries.every(([, raw]) => JSON.parse(raw).complete === true) ? JSON.stringify(entries) : null;
+  }
+
+  prepare() {
+    try { return this.locked(() => this.snapshot()); } catch (err) { this.diskError(err); return null; }
+  }
+
+  finalize(report, keep, before) {
+    try {
+      this.locked(() => {
+        const snapshot = this.snapshot();
+        const marker = JSON.parse(fs.readFileSync(path.join(this.directory, MARKER)));
+        marker.mirror.complete = !this.failed && snapshot !== null;
+        const remove = marker.mirror.complete && before === snapshot && report && fs.existsSync(report) && !keep;
+        // Se marca antes de borrar: una interrupción no deja una grabación parcial subible.
+        if (remove) marker.raw_removed = true;
+        this.write(MARKER, marker);
+        if (remove) {
+          for (const n of fs.readdirSync(this.directory)) {
+            if (/^(events-.*\.jsonl|status-.*\.json)$/.test(n) || ["bodies", "ids"].includes(n)) fs.rmSync(path.join(this.directory, n), { recursive: true, force: true });
+          }
+        }
+      });
+    } catch (err) { this.diskError(err); }
+  }
+}

package/src/offline.js

@@ -0,0 +1,132 @@
+// Grabación local cuando no hay servidor (no responde o rechaza el token): en vez de perder la
+// evidencia, el cliente escribe en una carpeta las mismas llamadas a la API que habría hecho.
+// Después: `tracereports report <carpeta>` arma el reporte HTML y `tracereports push <carpeta>`
+// la sube al servidor. Mismo formato que el cliente Python (lo lee el binario: internal/offline).
+
+import { randomInt, randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+export const FORMAT_VERSION = 1;
+export const MARKER = "tracereports-offline.json";
+
+const pad = (n) => String(n).padStart(2, "0");
+
+// Ids locales: cada grabador reserva bloques de ID_BLOCK ids creando <carpeta>/ids/<bloque> en
+// exclusiva, así dos grabadores que comparten la carpeta (mismo proceso, otro proceso u otra
+// sesión) nunca repiten un id. El bloque es aleatorio en [MIN_BLOCK, MAX_BLOCK): no choca con los
+// ids de grabaciones anteriores (pid % 10^6) y -(bloque * ID_BLOCK + n) sigue siendo un entero
+// exacto en JavaScript (< 2^53). Mismo esquema en los clientes Python, Java y Go.
+const ID_BLOCK = 100_000;
+const MIN_BLOCK = 1_000_000;
+const MAX_BLOCK = 90_000_000_000;
+
+/** Carpeta nueva para una sesión dentro de `base` (no mezcla corridas distintas). */
+export function sessionSlug(name) {
+  const ascii = String(name || "").normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase();
+  return (ascii.replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40).replace(/-+$/g, "") || "run");
+}
+
+export function newSessionDir(base, name = "") {
+  const d = new Date();
+  const stamp = `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+  return path.join(base, `${sessionSlug(name)}-${stamp}-${randomUUID().replace(/-/g, "").slice(0, 6)}`);
+}
+
+/** Reemplaza al Sender: graba cada llamada y responde con ids locales (negativos). */
+export class Recorder {
+  constructor(directory) {
+    this.directory = directory;
+    this.stats = { sent: 0, retried: 0, rejected: 0, dropped: 0, lost: 0, recorded: 0 };
+    this.seq = 0;
+    this.nextId = 0;
+    this.block = 0;
+    this.tag = randomUUID().slice(0, 8);
+    fs.mkdirSync(path.join(directory, "bodies"), { recursive: true });
+    try {
+      fs.writeFileSync(path.join(directory, MARKER),
+        JSON.stringify({ format: "tracereports-offline", version: FORMAT_VERSION, id: randomUUID().replace(/-/g, "") }), { flag: "wx" });
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err; // otro proceso ya lo creó
+    }
+    this.file = path.join(directory, `events-${process.pid}-${this.tag}.jsonl`);
+  }
+
+  // ids locales negativos, únicos entre los grabadores que graban en la misma carpeta
+  localId() {
+    if (!this.block || this.nextId >= ID_BLOCK - 1) {
+      this.block = this.reserveBlock();
+      this.nextId = 0;
+    }
+    this.nextId++;
+    return -(this.block * ID_BLOCK + this.nextId);
+  }
+
+  reserveBlock() {
+    const ids = path.join(this.directory, "ids");
+    fs.mkdirSync(ids, { recursive: true });
+    for (let i = 0; i < 100; i++) {
+      const block = randomInt(MIN_BLOCK, MAX_BLOCK);
+      try {
+        fs.writeFileSync(path.join(ids, String(block)), "", { flag: "wx" });
+        return block;
+      } catch (err) {
+        if (err.code !== "EEXIST") throw err; // ya es de otro grabador: se prueba otro
+      }
+    }
+    throw new Error(`tracereports: could not reserve local ids in ${ids}`);
+  }
+
+  record(method, apiPath, body, contentType) {
+    this.seq++;
+    const event = { seq: this.seq, ts: Date.now(), method, path: apiPath, content_type: contentType };
+    let parsed;
+    if (contentType.startsWith("application/json")) {
+      try {
+        parsed = JSON.parse(body?.length ? body.toString() : "{}");
+      } catch {
+        parsed = undefined;
+      }
+    }
+    if (parsed !== undefined) event.body = parsed;
+    else {
+      const name = `bodies/${process.pid}-${this.tag}-${this.seq}.bin`;
+      fs.writeFileSync(path.join(this.directory, name), body ?? "");
+      event.body_file = name;
+    }
+    let res = {};
+    if (method === "POST" && apiPath === "/api/v1/runs") res = { run_id: this.localId() };
+    else if (method === "POST" && apiPath.startsWith("/api/v1/runs/") && apiPath.endsWith("/tests")) res = { test_id: this.localId() };
+    const id = res.run_id ?? res.test_id;
+    if (id) event.local_id = id;
+    fs.appendFileSync(this.file, JSON.stringify(event) + "\n"); // síncrono: si el proceso muere, lo escrito queda
+    this.stats.recorded++;
+    return res;
+  }
+
+  // ─── interfaz del Sender
+  async sendNow(method, apiPath, body, contentType) {
+    return this.record(method, apiPath, body, contentType);
+  }
+
+  enqueue(method, apiPath, body, contentType) {
+    this.record(method, apiPath, body, contentType);
+    return true;
+  }
+
+  get pending() {
+    return 0;
+  }
+
+  serverDown() {
+    return false;
+  }
+
+  async flush() {
+    return 0;
+  }
+
+  abandon() {
+    return 0;
+  }
+}

package/src/playwright.js

@@ -12,6 +12,8 @@
 // Con la `page` del test:
 //   - captura las llamadas HTTP que hace el navegador (pestaña "Red"; es el tráfico visto desde el
 //     navegador, no los logs del backend);
+//   - captura la consola: console.error, console.warn y los errores de JavaScript sin manejar
+//     (pestaña "Consola");
 //   - si el test falla: snapshot del DOM (recomendador de locators) y una captura si el proyecto
 //     no tiene `screenshot: "only-on-failure"`.
 // Todo viaja como attachments del test; el reporter `tracereports/reporter` los sube.
@@ -66,7 +68,12 @@ export function captureNetwork(page, { apiPatterns = ["/api/"] } = {}) {
     const isApi = BODY_TYPES.has(c.resource_type) || apiPatterns.some((p) => c.url.includes(p));
     if (isApi || c.status >= 400) {
       const p = res.text()
-        .then((body) => { c.body_size = body.length; c.response_body = body.slice(0, MAX_BODY); })
+        .then((body) => {
+          // el recorte se marca aquí, donde ocurre; el tamaño original va en bytes UTF-8 (como el servidor)
+          c.body_size = Buffer.byteLength(body);
+          c.body_truncated = body.length > MAX_BODY;
+          c.response_body = body.length > MAX_BODY ? body.slice(0, /[\uD800-\uDBFF]/.test(body[MAX_BODY - 1]) ? MAX_BODY - 1 : MAX_BODY) : body;
+        })
         .catch(() => {})
         .finally(() => pending.delete(p));
       pending.add(p);
@@ -99,6 +106,32 @@ export function captureNetwork(page, { apiPatterns = ["/api/"] } = {}) {
   };
 }
 
+/**
+ * Engancha la captura de la consola a una página: errores y advertencias, y los errores de
+ * JavaScript que la página no manejó. Devuelve un colector con `drain()`.
+ */
+export function captureConsole(page) {
+  const entries = [];
+  let reported = 0;
+  page.on("console", (msg) => {
+    const level = msg.type() === "warning" ? "warning" : msg.type();
+    if (level !== "error" && level !== "warning") return;
+    const loc = msg.location?.() || {};
+    entries.push({ level, text: msg.text(), location: loc.url ? `${loc.url}:${loc.lineNumber}:${loc.columnNumber}` : "", timestamp: Date.now() });
+  });
+  page.on("pageerror", (err) => {
+    entries.push({ level: "pageerror", text: err?.stack || String(err), location: "", timestamp: Date.now() });
+  });
+  return {
+    entries,
+    drain() {
+      const out = entries.slice(reported);
+      reported = entries.length;
+      return out;
+    },
+  };
+}
+
 /** Snapshot de los elementos de la página, o null si ya no está disponible. */
 export async function captureDom(page) {
   try {
@@ -122,12 +155,17 @@ export function withTraceReports(baseTest) {
 const fixtures = {
   page: async ({ page }, use, testInfo) => {
     const net = captureNetwork(page);
+    const cons = captureConsole(page);
     await use(page);
     await net.settle(2000).catch(() => {});
     const conns = net.drain();
     if (conns.length) {
       await testInfo.attach("tracereports-network", { body: JSON.stringify(conns), contentType: "application/json" });
     }
+    const logs = cons.drain();
+    if (logs.length) {
+      await testInfo.attach("tracereports-console", { body: JSON.stringify(logs.slice(0, 500)), contentType: "application/json" });
+    }
     if (testInfo.status !== testInfo.expectedStatus) {
       const snap = await captureDom(page);
       if (snap) await testInfo.attach("tracereports-dom", { body: JSON.stringify(snap), contentType: "application/json" });

package/src/reporter.js

@@ -11,9 +11,13 @@
 //   testInfo.attach con imagen) y, con los fixtures de `tracereports/playwright`, la red y el DOM.
 // - Al terminar espera la cola y cierra la ejecución; imprime el link. TRACEREPORTS_STRICT=1 hace fallar
 //   la corrida si parte de la evidencia no llegó al servidor.
+// - Sin servidor (no responde o el token es incorrecto) la evidencia se graba en
+//   ./tracereports-offline/<sesión>: `tracereports report <carpeta>` arma el reporte HTML.
 //
 // Opciones (o variables): url (TRACEREPORTS_URL), token (TRACEREPORTS_TOKEN), runName (TRACEREPORTS_RUN_NAME),
-// environment (TRACEREPORTS_ENV), project (TRACEREPORTS_PROJECT), strict (TRACEREPORTS_STRICT).
+// environment (TRACEREPORTS_ENV), project (TRACEREPORTS_PROJECT), strict (TRACEREPORTS_STRICT),
+// offlineDir (TRACEREPORTS_OFFLINE_DIR), offlineBase (TRACEREPORTS_OFFLINE_BASE),
+// offline: "auto" | "always" | "both" | "off" (TRACEREPORTS_OFFLINE).
 
 import fs from "node:fs";
 import path from "node:path";
@@ -26,7 +30,7 @@ const truthy = (v) => ["1", "true", "yes"].includes(String(v || "").toLowerCase(
 export default class TraceReportsReporter {
   constructor(options = {}) {
     this.options = options;
-    this.cr = new TraceReports({ baseUrl: options.url, token: options.token });
+    this.cr = new TraceReports({ baseUrl: options.url, token: options.token, offlineDir: options.offlineDir, offlineBase: options.offlineBase, offline: options.offline });
     this.tests = new Map(); // test.id -> { ct: Promise<TraceTest>, lastError }
     this.steps = new Map(); // test.id -> intento -> pasos (test.step)
     this.strict = options.strict ?? truthy(env("STRICT"));
@@ -132,8 +136,12 @@ export default class TraceReportsReporter {
         if (!body) continue;
         if (att.name === "tracereports-network") ct.network(JSON.parse(body.toString()));
         else if (att.name === "tracereports-dom") ct.dom(JSON.parse(body.toString()));
+        else if (att.name === "tracereports-console") ct.console(JSON.parse(body.toString()));
         else if (att.contentType?.startsWith("image/")) ct.screenshot(body, att.name === "screenshot" ? "Captura al fallar" : att.name,
           unexpected ? "FAIL" : "INFO");
+        // trace: "on" / "retain-on-failure" / "on-first-retry"; video: lo mismo en use.video
+        else if (att.name === "trace" && att.contentType === "application/zip") ct.artifact("trace", body, `trace-${result.retry + 1}.zip`);
+        else if (att.contentType?.startsWith("video/")) ct.artifact("video", body, att.name === "video" ? `video-${result.retry + 1}` : att.name);
       }
       const final = asExpected || skipped || result.retry >= test.retries;
       if (!final) {
@@ -161,9 +169,16 @@ export default class TraceReportsReporter {
     await this.started;
     const interrupted = result.status === "interrupted" || result.status === "timedout";
     await this.cr.finishRun({ interrupted });
-    const problems = this.cr.deliveryProblems();
-    if (this.cr.runId) console.log(`TraceReports: ${this.cr.reportUrl}`);
-    if (problems) {
+    const problems = this.cr.deliveryProblems() + (this.cr.recording && this.cr.runId < 0 && ["auto", "both"].includes(this.cr.offlineMode) ? 1 : 0);
+    if (this.cr.recording && this.cr.runId > 0) {
+      console.log(`TraceReports: ${this.cr.reportUrl}`);
+      console.log(`TraceReports copia local: ${this.cr.offlineReport || `tracereports report ${this.cr.offlineDir}`}`);
+    } else if (this.cr.recording) {
+      console.log(`TraceReports (sin servidor): evidencia en ${this.cr.offlineDir}; reporte: ` +
+        (this.cr.reportUrl || `\`tracereports report ${this.cr.offlineDir} -o reporte\``) +
+        `; para subirla: \`tracereports push ${this.cr.offlineDir}\``);
+    } else if (this.cr.runId) console.log(`TraceReports: ${this.cr.reportUrl}`);
+    if (problems && (!this.cr.recording || this.cr.runId > 0)) {
       const d = this.cr.delivery;
       console.warn(`TraceReports: atención: ${problems - d.runNotClosed} eventos de evidencia no llegaron al servidor ` +
         `(enviados ${d.sent}, rechazados ${d.rejected}, descartados ${d.dropped}, perdidos ${d.lost})` +

package/src/transport.js

@@ -33,6 +33,7 @@ export class Sender {
     this.downUntil = 0;
     this.running = false;
     this.waiters = [];
+    this.pause = null; // backoff en curso: {timer, wake}, para que abandon() lo corte
     this.stats = { sent: 0, retried: 0, rejected: 0, dropped: 0, lost: 0 };
   }
 
@@ -118,7 +119,7 @@ export class Sender {
         item.attempts++;
         this.stats.retried++;
         this.queue.unshift(item);
-        await sleep(Math.min(limits.maxBackoffMs, 500 * 2 ** Math.min(item.attempts, 6)));
+        await this.backoff(Math.min(limits.maxBackoffMs, 500 * 2 ** Math.min(item.attempts, 6)));
         continue;
       }
       this.bytes -= item.size;
@@ -134,10 +135,30 @@ export class Sender {
     for (const w of this.waiters.splice(0)) w();
   }
 
-  /** Espera a que la cola se vacíe (máx. timeoutMs). Devuelve lo que quedó pendiente. */
+  /** Espera de un reintento que abandon() puede cortar (si no, mantendría vivo el proceso). */
+  backoff(ms) {
+    return new Promise((wake) => {
+      const timer = setTimeout(() => { this.pause = null; wake(); }, ms);
+      this.pause = { timer, wake };
+    });
+  }
+
+  /**
+   * Espera a que la cola se vacíe (máx. timeoutMs). Devuelve lo que quedó pendiente. Lo que gana
+   * cancela lo otro: si se vacía, el temporizador del timeout se borra (no retiene el proceso);
+   * si vence, el waiter sale de la lista.
+   */
   async flush(timeoutMs) {
     if (!this.pending) return 0;
-    await Promise.race([new Promise((r) => this.waiters.push(r)), sleep(timeoutMs)]);
+    let timer, waiter;
+    await new Promise((resolve) => {
+      waiter = resolve;
+      this.waiters.push(waiter);
+      timer = setTimeout(resolve, timeoutMs);
+    });
+    clearTimeout(timer);
+    const i = this.waiters.indexOf(waiter);
+    if (i >= 0) this.waiters.splice(i, 1);
     return this.pending;
   }
 
@@ -149,6 +170,13 @@ export class Sender {
     this.inflight = null;
     this.bytes = 0;
     this.stats.lost += items.length;
+    // nada queda esperando: el backoff en curso termina ya y los flush pendientes vuelven
+    if (this.pause) {
+      clearTimeout(this.pause.timer);
+      this.pause.wake();
+      this.pause = null;
+    }
+    this.notify();
     if (items.length) {
       console.warn(`tracereports: ${items.length} eventos de evidencia no se pudieron enviar y se perdieron`);
     }