tracereports 0.1.2 → 0.3.0

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/selenium.js

@@ -1,8 +1,14 @@
-// Selenium WebDriver (selenium-webdriver) con TraceReports. Sirve con cualquier runner
-// (node:test, Mocha, Jest…): no importa selenium-webdriver, usa el `driver` que le pases.
+// Selenium WebDriver (selenium-webdriver) con TraceReports: red, consola, captura y DOM. Sirve con
+// cualquier runner (node:test, Mocha, Jest…): no importa selenium-webdriver, usa el `driver` que le
+// pases.
 //
+//   import { Builder } from "selenium-webdriver";
+//   import chrome from "selenium-webdriver/chrome.js";
 //   import { TraceReports } from "tracereports";
-//   import { withDriver, screenshot } from "tracereports/selenium";
+//   import { seleniumOptions, withDriver, screenshot } from "tracereports/selenium";
+//
+//   const options = seleniumOptions(new chrome.Options());   // activa los logs de red y de consola
+//   const driver = await new Builder().forBrowser("chrome").setChromeOptions(options).build();
 //
 //   const cr = new TraceReports();
 //   await cr.startRun("Regresión web", { environment: "chrome" });
@@ -12,12 +18,27 @@
 //   });
 //   await cr.finishRun();
 //
-// Si el test falla, `withDriver` adjunta la captura del momento y el snapshot del DOM (con él el
-// reporte recomienda selectores cuando se rompe un locator). Selenium no expone la red del
-// navegador: para la pestaña "Red" usa Playwright o envía las llamadas con `t.network([...])`.
+// `withDriver` envía la red (pestaña "Red", Lab) y la consola de cada test, y si falla la captura del
+// momento y el snapshot del DOM (con él el reporte recomienda selectores cuando se rompe un locator).
+// La red y la consola salen del log de rendimiento de Chrome y Edge (Firefox no lo tiene): hay que
+// crear el driver con `seleniumOptions(options)`. El body de una llamada hecha antes de que la
+// página navegara puede no estar ya disponible; el resto de la llamada sí.
 
 import { DOM_SCRIPT } from "./dom.js";
 
+const LOG_PREFS = { performance: "ALL", browser: "ALL" };
+const BODY_TYPES = new Set(["xhr", "fetch"]);
+const TEXT_MIME = ["json", "text", "xml", "javascript", "html", "x-www-form-urlencoded", "graphql"];
+
+/** Activa en las opciones de Chrome o Edge los logs de rendimiento (red) y del navegador (consola). */
+export function seleniumOptions(options) {
+  options.set("goog:loggingPrefs", { ...LOG_PREFS });
+  if (/edge/i.test(options?.constructor?.name || "") || options.get?.("browserName") === "MicrosoftEdge") {
+    options.set("ms:loggingPrefs", { ...LOG_PREFS });
+  }
+  return options;
+}
+
 /** Captura de pantalla como base64 (lo que acepta `t.screenshot`), o null. */
 export async function screenshot(driver) {
   try {
@@ -36,14 +57,179 @@ export async function captureDom(driver) {
   }
 }
 
-/** Opciones para `cr.test(...)` que, al fallar, adjuntan captura y DOM desde `driver`. */
+function* events(entries) {
+  for (const entry of entries || []) {
+    let msg;
+    try {
+      msg = JSON.parse(entry.message).message;
+    } catch {
+      continue;
+    }
+    if (msg?.method?.startsWith("Network.")) yield [msg.method, msg.params || {}];
+  }
+}
+
+/**
+ * Convierte las entradas del log "performance" (`driver.manage().logs().get("performance")`) en
+ * conexiones (el formato de `t.network`). Cada una lleva `_requestId` para pedir su body después.
+ */
+export function connectionsFromLog(entries) {
+  const byId = new Map();
+  const order = [];
+  const extraReq = new Map();
+  const extraRes = new Map();
+  const ms = (from, to) => (from == null || to == null ? undefined : Math.round((to - from) * 1000));
+  const setResponse = (c, r) => {
+    c.status = Number(r.status || 0);
+    c.status_text = r.statusText || "";
+    c.mime_type = r.mimeType || "";
+    c.response_headers = { ...(r.headers || {}) };
+  };
+  for (const [method, p] of events(entries)) {
+    const id = p.requestId;
+    if (!id) continue;
+    if (method === "Network.requestWillBeSent") {
+      const prev = byId.get(id);
+      if (prev && p.redirectResponse) {
+        // la redirección cierra el salto anterior con su propia respuesta
+        setResponse(prev, p.redirectResponse);
+        prev.duration_ms = ms(prev._ts, p.timestamp);
+        prev._requestId = null;
+      }
+      const req = p.request || {};
+      const c = {
+        _requestId: id, _ts: p.timestamp, method: req.method || "", url: req.url || "",
+        resource_type: String(p.type || "").toLowerCase(), request_headers: { ...(req.headers || {}) },
+        post_data: req.postData || "", _hasPostData: Boolean(req.hasPostData || req.postData),
+        started_at: p.wallTime ? Math.round(p.wallTime * 1000) : 0, status: 0,
+      };
+      byId.set(id, c);
+      order.push(c);
+    } else if (method === "Network.requestWillBeSentExtraInfo") {
+      extraReq.set(id, { ...(extraReq.get(id) || {}), ...(p.headers || {}) });
+    } else if (method === "Network.responseReceived" && byId.has(id)) {
+      const c = byId.get(id);
+      setResponse(c, p.response || {});
+      if (p.type) c.resource_type = String(p.type).toLowerCase();
+    } else if (method === "Network.responseReceivedExtraInfo") {
+      extraRes.set(id, { ...(extraRes.get(id) || {}), ...(p.headers || {}) });
+    } else if (method === "Network.loadingFinished" && byId.has(id)) {
+      const c = byId.get(id);
+      c.duration_ms = ms(c._ts, p.timestamp);
+    } else if (method === "Network.loadingFailed" && byId.has(id)) {
+      const c = byId.get(id);
+      c.failed = true;
+      c.error_text = p.errorText || (p.canceled ? "canceled" : "failed");
+      c.duration_ms = ms(c._ts, p.timestamp);
+    }
+  }
+  const out = [];
+  for (const c of order) {
+    if (/^(data|blob):/.test(c.url)) continue;
+    // los headers reales que salieron, con la cookie de sesión
+    if (extraReq.has(c._requestId)) c.request_headers = { ...c.request_headers, ...extraReq.get(c._requestId) };
+    if (extraRes.has(c._requestId) && c.response_headers) c.response_headers = { ...c.response_headers, ...extraRes.get(c._requestId) };
+    delete c._ts;
+    out.push(c);
+  }
+  return out;
+}
+
+async function cdp(driver, cmd, params) {
+  try {
+    return (await driver.sendAndGetDevToolsCommand(cmd, params)) || {};
+  } catch {
+    return {}; // otro navegador, o el recurso ya no existe (la página navegó)
+  }
+}
+
+function wantsBody(c) {
+  if (c.failed || !c._requestId) return false;
+  if (!BODY_TYPES.has(c.resource_type) && c.status < 400) return false;
+  const mime = String(c.mime_type || "").toLowerCase();
+  return !mime || TEXT_MIME.some((t) => mime.includes(t));
+}
+
+async function readLog(driver, kind) {
+  try {
+    return await driver.manage().logs().get(kind);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Las llamadas de red desde la última lectura (el log se vacía al leerlo: cada test lee las
+ * suyas), con los bodies de las APIs y de las respuestas con error. [] si el driver no tiene el
+ * log de rendimiento (ver `seleniumOptions`).
+ */
+export async function captureNetwork(driver) {
+  const conns = connectionsFromLog(await readLog(driver, "performance"));
+  for (const c of conns) {
+    if (c._hasPostData && !c.post_data && c._requestId) {
+      c.post_data = (await cdp(driver, "Network.getRequestPostData", { requestId: c._requestId })).postData || "";
+    }
+    if (wantsBody(c)) {
+      const res = await cdp(driver, "Network.getResponseBody", { requestId: c._requestId });
+      if (typeof res.body === "string") {
+        const body = res.base64Encoded ? Buffer.from(res.body, "base64").toString("utf8") : res.body;
+        c.body_size = Buffer.byteLength(body);
+        c.response_body = body;
+      }
+    }
+    delete c._requestId;
+    delete c._hasPostData;
+  }
+  return conns;
+}
+
+/** Errores y warnings de la consola desde la última lectura (el formato de `t.console`). */
+export async function captureConsole(driver) {
+  const out = [];
+  for (const e of await readLog(driver, "browser")) {
+    const name = String(e?.level?.name ?? e?.level ?? "").toUpperCase();
+    let level = name === "SEVERE" ? "error" : name === "WARNING" ? "warning" : "";
+    if (!level) continue;
+    if (level === "error" && /\bUncaught\b/.test(e.message || "")) level = "pageerror";
+    out.push({ level, text: String(e.message || ""), location: "", timestamp: Number(e.timestamp || 0) });
+  }
+  return out;
+}
+
+/** Vacía los logs del driver: lo de antes del test (otro test con el mismo driver) no se envía. */
+export async function discardLogs(driver) {
+  await readLog(driver, "performance");
+  await readLog(driver, "browser");
+}
+
+/** Envía al test la red y la consola desde la última lectura. Devuelve cuántas llamadas envió. */
+export async function reportSelenium(t, driver) {
+  const conns = await captureNetwork(driver);
+  if (conns.length) t.network(conns);
+  const consoleEntries = await captureConsole(driver);
+  if (consoleEntries.length) t.console(consoleEntries);
+  return conns.length;
+}
+
+/**
+ * Opciones para `cr.test(...)` con un driver de Selenium: al empezar descarta los logs anteriores,
+ * al terminar envía la red y la consola del test, y si falla la captura y el DOM.
+ */
 export function withDriver(driver, opts = {}) {
   return {
     ...opts,
+    async onStart(t) {
+      await discardLogs(driver);
+      if (opts.onStart) await opts.onStart(t);
+    },
     async onFailure(t, err) {
       t.screenshot(await screenshot(driver), "Captura al fallar", "FAIL");
       t.dom(await captureDom(driver));
       if (opts.onFailure) await opts.onFailure(t, err);
     },
+    async onEnd(t, err) {
+      await reportSelenium(t, driver);
+      if (opts.onEnd) await opts.onEnd(t, err);
+    },
   };
 }