tracereports 0.2.0 → 0.4.0

package/README.es.md

@@ -12,7 +12,8 @@ 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.
+- **Selenium WebDriver o cualquier runner**: con `seleniumOptions(options)` y `withDriver`, la red (pestaña
+  Red, Lab) y la consola de cada test, y la captura y el DOM al fallar ([guía de Selenium](https://github.com/josemiguellopez/tracereports/blob/main/docs/es/selenium.md)).
 - **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;

package/README.md

@@ -12,7 +12,8 @@ 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.
+- **Selenium WebDriver or any runner**: with `seleniumOptions(options)` and `withDriver`, each test's network
+  (Network tab, Lab) and console, and the screenshot and DOM on failure ([Selenium guide](https://github.com/josemiguellopez/tracereports/blob/main/docs/en/selenium.md)).
 - **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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tracereports",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "TraceReports client for JavaScript/TypeScript: Playwright Test reporter and fixtures, Selenium WebDriver helpers and a client for any runner.",
   "keywords": [
     "testing",

package/src/index.d.ts

@@ -26,6 +26,10 @@ export interface RunOptions { environment?: string; project?: string; branch?: s
 export interface TestOptions {
   category?: string; description?: string; key?: string; suite?: string; params?: string; worker?: string | number;
   status?: string; onFailure?: (t: TraceTest, err: unknown) => unknown | Promise<unknown>;
+  /** Right after the test starts (e.g. discard the browser logs of earlier tests). */
+  onStart?: (t: TraceTest) => unknown | Promise<unknown>;
+  /** Before the test is closed, passed or failed (`err` is null when it passed): network, console... */
+  onEnd?: (t: TraceTest, err: unknown) => unknown | Promise<unknown>;
 }
 
 export type Status = "INFO" | "PASS" | "FAIL" | "WARNING" | "SKIP";

package/src/index.js

@@ -22,12 +22,13 @@ import fs from "node:fs";
 import path from "node:path";
 import { detectBranch, detectCommit } from "./context.js";
 import { env } from "./env.js";
+import { screenshotAllowed } from "./mask.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";
+export const VERSION = "0.4.0";
 const STATUSES = new Set(["INFO", "PASS", "FAIL", "WARNING", "SKIP"]);
 const truthy = (v) => ["1", "true", "yes"].includes(String(v || "").toLowerCase());
 
@@ -314,19 +315,23 @@ export class TraceReports {
 
   /**
    * Corre `fn` como un test: lo inicia, lo cierra según el resultado y, si falla, adjunta la
-   * captura y el snapshot de `onFailure` (opcional). El error se vuelve a lanzar.
+   * captura y el snapshot de `onFailure` (opcional). `onStart` corre al empezar y `onEnd` antes de
+   * cerrarlo, pase o falle (la red y la consola de `withDriver`). El error se vuelve a lanzar.
    */
   async test(name, opts, fn) {
     if (typeof opts === "function") [fn, opts] = [opts, {}];
     const t = await this.startTest(name, opts);
+    // la evidencia nunca rompe el test
+    const hook = async (h, ...args) => { if (h) { try { await h(t, ...args); } catch { /* sin evidencia */ } } };
+    await hook(opts.onStart);
     try {
       const out = await fn(t);
+      await hook(opts.onEnd, null);
       t.finish(opts.status);
       return out;
     } catch (err) {
-      if (opts.onFailure) {
-        try { await opts.onFailure(t, err); } catch { /* la evidencia nunca rompe el test */ }
-      }
+      await hook(opts.onFailure, err);
+      await hook(opts.onEnd, err);
       t.fail(`${err?.name || "Error"}: ${err?.message ?? err}`);
       t.finish("FAIL", { error: err });
       throw err;
@@ -365,7 +370,8 @@ export class TraceTest {
    * base64 (Selenium `driver.takeScreenshot()`).
    */
   screenshot(image, message = "", status = "INFO") {
-    if (!this.active || !image) return;
+    // TRACEREPORTS_SCREENSHOTS=off|failures: la captura no se envía (ver mask.js)
+    if (!this.active || !image || !screenshotAllowed(status)) return;
     const data = typeof image === "string" ? Buffer.from(image, "base64") : Buffer.from(image);
     const boundary = `----tracereports${Math.random().toString(16).slice(2)}`;
     const part = (name, value) => `--${boundary}\r\nContent-Disposition: form-data; name="${name}"\r\n\r\n${value}\r\n`;

package/src/mask.js

@@ -0,0 +1,107 @@
+// Capturas sin datos sensibles: se tapan antes de capturar.
+//
+// - TRACEREPORTS_SCREENSHOT_MASK: selectores CSS a tapar (un grupo CSS: "input[name=rut], .tarjeta").
+// - Siempre se tapan input[type=password] y los elementos con el atributo data-tracereports-mask;
+//   TRACEREPORTS_SCREENSHOT_MASK_DEFAULTS=off lo desactiva.
+// - TRACEREPORTS_SCREENSHOTS: all (por defecto), failures (solo la captura de un paso FAIL) u off
+//   (ninguna). El servidor aplica la misma política por su cuenta.
+//
+// Playwright usa su opción nativa `mask`. Selenium no la tiene: se ponen recuadros del mismo color
+// sobre los elementos, se captura y se quitan, también si la captura falla, así el DOM queda igual.
+// Sin dependencias: lo importan index.js, playwright.js y selenium.js.
+
+import { env } from "./env.js";
+
+/** Lo que se tapa siempre (salvo TRACEREPORTS_SCREENSHOT_MASK_DEFAULTS=off). */
+export const DEFAULT_MASK = "input[type=password], [data-tracereports-mask]";
+/** Color de los recuadros: el mismo que usa Playwright por defecto. */
+export const MASK_COLOR = "#FF00FF";
+
+const OVERLAY_ATTR = "data-tracereports-mask-overlay";
+
+/** Nombre del attachment de Playwright con la captura al fallar ya tapada (la toman los fixtures). */
+export const MASKED_SHOT = "tracereports-screenshot";
+
+/** El grupo de selectores CSS a tapar ("" = nada). */
+export function maskSelector() {
+  const parts = [];
+  if (!["off", "0", "false", "no"].includes(String(env("SCREENSHOT_MASK_DEFAULTS") ?? "").trim().toLowerCase())) {
+    parts.push(DEFAULT_MASK);
+  }
+  const extra = String(env("SCREENSHOT_MASK") ?? "").trim().replace(/^,+|,+$/g, "").trim();
+  if (extra) parts.push(extra);
+  return parts.join(", ");
+}
+
+/** TRACEREPORTS_SCREENSHOTS: all, failures u off (un valor desconocido cuenta como all). */
+export function screenshotsPolicy() {
+  const v = String(env("SCREENSHOTS") ?? "").trim().toLowerCase();
+  return v === "failures" || v === "off" ? v : "all";
+}
+
+/** Si la política deja enviar una captura de un paso con este estado. */
+export function screenshotAllowed(status) {
+  const policy = screenshotsPolicy();
+  if (policy === "off") return false;
+  return policy === "all" || String(status).toUpperCase() === "FAIL";
+}
+
+/** `page.screenshot()` de Playwright con los elementos sensibles tapados (opción `mask`). */
+export function playwrightScreenshot(page, options = {}) {
+  const selector = maskSelector();
+  const opts = { ...options };
+  if (selector) {
+    opts.mask ??= [page.locator(selector)];
+    opts.maskColor ??= MASK_COLOR;
+  }
+  return page.screenshot(opts);
+}
+
+// Recuadros fijos sobre cada elemento visible del selector (la captura de Selenium es del viewport).
+const COVER_JS = `
+const [sel, color, attr] = arguments;
+let n = 0;
+for (const el of document.querySelectorAll(sel)) {
+  const r = el.getBoundingClientRect();
+  if (!r.width || !r.height) continue;
+  const d = document.createElement("div");
+  d.setAttribute(attr, "");
+  d.style.cssText = "position:fixed;left:" + r.left + "px;top:" + r.top + "px;width:" + r.width + "px;height:" + r.height + "px;" +
+    "background:" + color + ";z-index:2147483647;pointer-events:none;margin:0;padding:0;border:0";
+  document.documentElement.appendChild(d);
+  n++;
+}
+return n;
+`;
+
+const UNCOVER_JS = `for (const d of document.querySelectorAll("[" + arguments[0] + "]")) d.remove();`;
+
+/**
+ * Captura de Selenium (base64, lo que acepta `t.screenshot`) con los elementos sensibles tapados, o
+ * null si el navegador ya no responde. Los recuadros se quitan siempre; si no se pueden poner (un
+ * selector inválido) no se captura: mejor sin captura que sin máscara.
+ */
+export async function seleniumScreenshot(driver) {
+  const selector = maskSelector();
+  let covered = false;
+  try {
+    if (selector) {
+      try {
+        await driver.executeScript(COVER_JS, selector, MASK_COLOR, OVERLAY_ATTR);
+        covered = true;
+      } catch (err) {
+        console.warn(`tracereports: no se pudo tapar ${JSON.stringify(selector)} antes de la captura: ${err?.message ?? err}`);
+        return null;
+      }
+    }
+    return await driver.takeScreenshot();
+  } catch {
+    return null;
+  } finally {
+    if (covered) {
+      try {
+        await driver.executeScript(UNCOVER_JS, OVERLAY_ATTR);
+      } catch { /* el navegador ya no responde */ }
+    }
+  }
+}

package/src/mirror.js

@@ -17,7 +17,7 @@ export class Mirror {
     this.closed = false;
     this.disabled = false;
     this.active = 0;
-    fs.mkdirSync(directory, { recursive: true });
+    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
     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");
@@ -33,7 +33,7 @@ export class Mirror {
       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" });
+        fs.writeFileSync(mapping, String(local), { flag: "wx", mode: 0o600 });
         m.mirror.runs.push({ local, server: runId });
         this.write(MARKER, m);
       } else {
@@ -52,7 +52,7 @@ export class Mirror {
   locked(fn) {
     const lock = path.join(this.directory, ".mirror-lock");
     for (let n = 0; ; n++) {
-      try { fs.mkdirSync(lock); break; } catch (err) {
+      try { fs.mkdirSync(lock, { mode: 0o700 }); break; } catch (err) {
         if (err.code !== "EEXIST") throw err;
         if (n >= 50) {
           let stale = false;
@@ -70,7 +70,7 @@ export class Mirror {
   write(name, value) {
     const dest = path.join(this.directory, name), tmp = `${dest}.${randomUUID()}.tmp`;
     try {
-      fs.writeFileSync(tmp, JSON.stringify(value));
+      fs.writeFileSync(tmp, JSON.stringify(value), { mode: 0o600 });
       try { fs.renameSync(tmp, dest); }
       catch (err) {
         // Windows can reject a replacement rename even while this process owns the lock.

package/src/offline.js

@@ -42,10 +42,11 @@ export class Recorder {
     this.nextId = 0;
     this.block = 0;
     this.tag = randomUUID().slice(0, 8);
-    fs.mkdirSync(path.join(directory, "bodies"), { recursive: true });
+    // la grabación lleva la evidencia sin redactar (eso lo hace el servidor): solo para el usuario
+    fs.mkdirSync(path.join(directory, "bodies"), { recursive: true, mode: 0o700 });
     try {
       fs.writeFileSync(path.join(directory, MARKER),
-        JSON.stringify({ format: "tracereports-offline", version: FORMAT_VERSION, id: randomUUID().replace(/-/g, "") }), { flag: "wx" });
+        JSON.stringify({ format: "tracereports-offline", version: FORMAT_VERSION, id: randomUUID().replace(/-/g, "") }), { flag: "wx", mode: 0o600 });
     } catch (err) {
       if (err.code !== "EEXIST") throw err; // otro proceso ya lo creó
     }
@@ -64,11 +65,11 @@ export class Recorder {
 
   reserveBlock() {
     const ids = path.join(this.directory, "ids");
-    fs.mkdirSync(ids, { recursive: true });
+    fs.mkdirSync(ids, { recursive: true, mode: 0o700 });
     for (let i = 0; i < 100; i++) {
       const block = randomInt(MIN_BLOCK, MAX_BLOCK);
       try {
-        fs.writeFileSync(path.join(ids, String(block)), "", { flag: "wx" });
+        fs.writeFileSync(path.join(ids, String(block)), "", { flag: "wx", mode: 0o600 });
         return block;
       } catch (err) {
         if (err.code !== "EEXIST") throw err; // ya es de otro grabador: se prueba otro
@@ -91,7 +92,7 @@ export class Recorder {
     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 ?? "");
+      fs.writeFileSync(path.join(this.directory, name), body ?? "", { mode: 0o600 });
       event.body_file = name;
     }
     let res = {};
@@ -99,7 +100,7 @@ export class Recorder {
     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
+    fs.appendFileSync(this.file, JSON.stringify(event) + "\n", { mode: 0o600 }); // síncrono: si el proceso muere, lo escrito queda
     this.stats.recorded++;
     return res;
   }

package/src/playwright.js

@@ -14,14 +14,18 @@
 //     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"`.
+//   - si el test falla: snapshot del DOM (recomendador de locators) y una captura con los datos
+//     sensibles tapados (ver mask.js); el reporter la sube en vez de la de `screenshot:
+//     "only-on-failure"`, que Playwright toma sin máscara.
 // Todo viaja como attachments del test; el reporter `tracereports/reporter` los sube.
 
 import { createRequire } from "node:module";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { domSnapshotInPage } from "./dom.js";
+import { MASKED_SHOT, playwrightScreenshot, screenshotsPolicy } from "./mask.js";
+
+export { MASKED_SHOT, playwrightScreenshot };
 
 // @playwright/test se carga desde el proyecto que corre los tests: así hay una sola copia aunque
 // este paquete esté instalado como enlace (npm install ../tracereports/client/js).
@@ -169,11 +173,11 @@ const fixtures = {
     if (testInfo.status !== testInfo.expectedStatus) {
       const snap = await captureDom(page);
       if (snap) await testInfo.attach("tracereports-dom", { body: JSON.stringify(snap), contentType: "application/json" });
-      const mode = testInfo.project.use?.screenshot;
-      const auto = mode === "on" || mode === "only-on-failure" || mode?.mode === "on" || mode?.mode === "only-on-failure";
-      if (!auto) {
+      // siempre la captura tapada: la automática de Playwright (screenshot: "only-on-failure") no se
+      // puede tapar, y el reporter la reemplaza por esta
+      if (screenshotsPolicy() !== "off") {
         try {
-          await testInfo.attach("Captura al fallar", { body: await page.screenshot({ timeout: 5000 }), contentType: "image/png" });
+          await testInfo.attach(MASKED_SHOT, { body: await playwrightScreenshot(page, { timeout: 5000 }), contentType: "image/png" });
         } catch { /* la página puede estar cerrada */ }
       }
     }

package/src/reporter.js

@@ -23,6 +23,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { env } from "./env.js";
 import { TraceReports } from "./index.js";
+import { MASKED_SHOT, screenshotAllowed, screenshotsPolicy } from "./mask.js";
 
 const ANSI = /\u001b\[[0-9;]*m/g;
 const truthy = (v) => ["1", "true", "yes"].includes(String(v || "").toLowerCase());
@@ -131,17 +132,25 @@ export default class TraceReportsReporter {
       }));
       for (const l of [...steps, ...logs].sort((a, b) => a.timestamp - b.timestamp)) ct.log(l.status, l.message, l.timestamp);
 
+      // la captura automática de Playwright no viene tapada: si los fixtures dejaron la suya, va esa
+      const masked = result.attachments.some((a) => a.name === MASKED_SHOT);
+      // trace y video muestran la pantalla: siguen TRACEREPORTS_SCREENSHOTS
+      const policy = screenshotsPolicy();
+      const artifacts = policy === "all" || (policy === "failures" && unexpected);
       for (const att of result.attachments) {
+        if (att.name === "screenshot" && masked) continue;
+        const isImage = att.contentType?.startsWith("image/");
+        if (isImage && !screenshotAllowed(unexpected ? "FAIL" : "INFO")) continue;
         const body = att.body ?? (att.path && fs.existsSync(att.path) ? fs.readFileSync(att.path) : null);
         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,
+        else if (isImage) ct.screenshot(body, att.name === "screenshot" || att.name === MASKED_SHOT ? "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);
+        else if (att.name === "trace" && att.contentType === "application/zip") { if (artifacts) ct.artifact("trace", body, `trace-${result.retry + 1}.zip`); }
+        else if (att.contentType?.startsWith("video/")) { if (artifacts) ct.artifact("video", body, att.name === "video" ? `video-${result.retry + 1}` : att.name); }
       }
       const final = asExpected || skipped || result.retry >= test.retries;
       if (!final) {

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,21 +18,38 @@
 //   });
 //   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";
+import { seleniumScreenshot } from "./mask.js";
 
-/** Captura de pantalla como base64 (lo que acepta `t.screenshot`), o null. */
-export async function screenshot(driver) {
-  try {
-    return await driver.takeScreenshot();
-  } catch {
-    return null;
+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`) con los datos sensibles tapados
+ * (ver mask.js), o null.
+ */
+export async function screenshot(driver) {
+  return seleniumScreenshot(driver);
+}
+
+export { seleniumScreenshot };
+
 /** Snapshot de los elementos de la página, o null si el navegador ya no responde. */
 export async function captureDom(driver) {
   try {
@@ -36,14 +59,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);
+    },
   };
 }