@piwitests/reporter 0.52.0 → 0.54.0

package/dist/internal/capture/capture-fixtures.js

@@ -49,6 +49,7 @@ __export(capture_fixtures_exports, {
   pageMapFetcher: () => pageMapFetcher,
   piwiFixtures: () => piwiFixtures,
   probeElementAttrs: () => probeElementAttrs,
+  readPageInteraction: () => readPageInteraction,
   recordResourceCensus: () => recordResourceCensus,
   resolveCodeReach: () => resolveCodeReach,
   startCodeReach: () => startCodeReach,
@@ -1634,6 +1635,57 @@ function mergeCandidates(base, extra) {
   return merged.sort((a, b) => b.score - a.score);
 }
 
+// ../core/src/page-interaction.ts
+var ELEMENT_PATH_MAX_CHARS = 2e3;
+var ELEMENT_LABEL_MAX_CHARS = 120;
+var MAX_INDETERMINATE = 20;
+var STEP = String.raw`[a-zA-Z][\w.-]*:[1-9]\d*`;
+var LEVEL = `${STEP}(?:/${STEP})*`;
+var ELEMENT_PATH_RE = new RegExp(`^${LEVEL}(?:\\|${LEVEL})*$`);
+function isElementPath(path14) {
+  return typeof path14 === "string" && path14.length <= ELEMENT_PATH_MAX_CHARS && ELEMENT_PATH_RE.test(path14);
+}
+var offsetOf = (v) => typeof v === "number" && Number.isInteger(v) && v >= 0 && v <= 1e7 ? v : null;
+function elementRef(v) {
+  if (!v || typeof v !== "object") return null;
+  const { path: path14, label } = v;
+  if (!isElementPath(path14)) return null;
+  return { path: path14, label: typeof label === "string" ? label.slice(0, ELEMENT_LABEL_MAX_CHARS) : "" };
+}
+function textPoint(v) {
+  if (!v || typeof v !== "object") return null;
+  const { path: path14, offset } = v;
+  const at = offsetOf(offset);
+  return isElementPath(path14) && at !== null ? { path: path14, offset: at } : null;
+}
+function sanitizePageInteraction(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const r = raw;
+  const out = {};
+  const focus = r.focus;
+  const focused = focus && typeof focus === "object" ? elementRef(focus.element) : null;
+  if (focus && focused) {
+    out.focus = { element: focused, visible: focus.visible === true };
+    const range = Array.isArray(focus.selection) && focus.selection.length === 2 ? focus.selection : [];
+    const [start, end] = range.map(offsetOf);
+    if (start != null && end != null && start <= end) out.focus.selection = [start, end];
+  }
+  const hover = elementRef(r.hover);
+  if (hover) out.hover = hover;
+  const selection = r.selection;
+  if (selection && typeof selection === "object") {
+    const start = textPoint(selection.start);
+    const end = textPoint(selection.end);
+    const length = offsetOf(selection.length);
+    if (start && end && length !== null && length > 0) out.selection = { start, end, length };
+  }
+  if (Array.isArray(r.indeterminate)) {
+    const boxes = r.indeterminate.map(elementRef).filter((ref) => ref !== null).slice(0, MAX_INDETERMINATE);
+    if (boxes.length) out.indeterminate = boxes;
+  }
+  return out;
+}
+
 // src/internal/capture/locator-healing.ts
 var path = __toESM(require("path"));
 
@@ -1971,6 +2023,9 @@ function captureCallerLocation(stack = new Error().stack ?? "") {
   return null;
 }
 
+// ../core/src/wire.ts
+var FAILURE_SCREENSHOT_ATTACHMENT = "piwi-failure-screenshot";
+
 // src/internal/capture/attachments.ts
 var ATTACHMENT_NAMES = {
   locators: "piwi-locators",
@@ -1982,6 +2037,7 @@ var ATTACHMENT_NAMES = {
   pageInventory: "piwi-page-inventory",
   locatorPages: "piwi-locator-pages",
   codeReach: "piwi-code-reach",
+  serverCoverageRequests: "piwi-server-coverage-requests",
   webVitals: "piwi-web-vitals",
   locatorSuggestion: "piwi-locator-suggestion",
   pageState: "piwi-page-state",
@@ -1994,6 +2050,25 @@ var INTERNAL_ATTACHMENT_NAMES = new Set(Object.values(ATTACHMENT_NAMES));
 var LOCATOR_SUGGESTION_ANNOTATION = ATTACHMENT_NAMES.locatorSuggestion;
 var USER_PICK_ANNOTATION = ATTACHMENT_NAMES.userPick;
 
+// src/internal/capture/failure-screenshot.ts
+function keepsFailureScreenshots(option, retry) {
+  const mode = typeof option === "string" ? option : option?.mode;
+  return mode === "on" || mode === "only-on-failure" || mode === "on-first-failure" && retry === 0;
+}
+async function readFailureScreenshot(page, option) {
+  const options = typeof option === "object" && option !== null ? option : null;
+  try {
+    return await page.screenshot({
+      fullPage: options?.fullPage,
+      omitBackground: options?.omitBackground,
+      timeout: 5e3,
+      caret: "initial"
+    });
+  } catch {
+    return null;
+  }
+}
+
 // src/internal/capture/page-inventory.ts
 var PAGE_INVENTORY_MAX_ENTRIES = 500;
 function collectPageInventoryInPage(maxEntries) {
@@ -2225,7 +2300,7 @@ var DEFAULTS = {
   // Off by default: the page inventory reads control and link names from every
   // visited page, so it stays opt-in until a project turns it on.
   capturePageInventory: false,
-  // Off by default: JavaScript coverage slows the page, so a scheduled job opts in.
+  // Off by default: JavaScript coverage adds time to every test, so a scheduled job opts in.
   captureCodeReach: false,
   captureServerTraces: true,
   captureResources: true,
@@ -2270,6 +2345,8 @@ var PIWI_ENV_KEYS = {
   capturePageInventory: "PIWI_CAPTURE_PAGE_INVENTORY",
   captureCodeReach: "PIWI_CAPTURE_CODE_REACH",
   codeReachRoots: "PIWI_CODE_REACH_ROOTS",
+  coverageBrowser: "PIWI_COVERAGE_BROWSER",
+  coverageServer: "PIWI_COVERAGE_SERVER",
   captureServerTraces: "PIWI_CAPTURE_SERVER_TRACES",
   captureResources: "PIWI_CAPTURE_RESOURCES",
   leakCheck: "PIWI_LEAK_CHECK",
@@ -3826,6 +3903,18 @@ async function pauseHere(page, testInfo, point, probe, onPick) {
   }
 }
 
+// src/internal/collect/coverage-settings.ts
+var SERVER_VALUES = /* @__PURE__ */ new Set(["files", "functions", "lines"]);
+function isServerGranularity(value) {
+  return typeof value === "string" && SERVER_VALUES.has(value);
+}
+function browserCoverageInWorker() {
+  return process.env[PIWI_ENV_KEYS.captureCodeReach] === "true" || process.env[PIWI_ENV_KEYS.coverageBrowser] === "files";
+}
+function serverCoverageInWorker() {
+  return isServerGranularity(process.env[PIWI_ENV_KEYS.coverageServer]);
+}
+
 // src/internal/support/aria-sampling.ts
 var path7 = __toESM(require("path"));
 var os3 = __toESM(require("os"));
@@ -3950,6 +4039,9 @@ function boxCaptureFrames(extraPrefixes = []) {
   } catch {
   }
 }
+function callMethod(target, prop, args) {
+  return target[prop](...args);
+}
 function internalCall(owner, run) {
   const wrap = owner?._wrapApiCall;
   if (typeof wrap !== "function") return run();
@@ -3962,6 +4054,16 @@ var fs6 = __toESM(require("fs"));
 var path10 = __toESM(require("path"));
 var import_node_child_process = require("child_process");
 
+// ../core/src/coverage.ts
+var MAX_PATH_LENGTH = 500;
+function normalizeCoveragePath(raw) {
+  if (typeof raw !== "string" || raw.length > MAX_PATH_LENGTH || raw.includes("\0")) return null;
+  const path14 = raw.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (!path14 || path14.startsWith("../") || path14.startsWith("/") || /^[A-Za-z]:\//.test(path14)) return null;
+  if (/(^|\/)node_modules\//.test(path14)) return null;
+  return path14;
+}
+
 // ../core/src/source-map.ts
 var BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 var BASE64_VALUE = new Int8Array(128).fill(-1);
@@ -4173,10 +4275,8 @@ function reachedSources(entry, map) {
 function finalizeCodeReach(files) {
   const out = /* @__PURE__ */ new Set();
   for (const raw of files) {
-    const file = raw.replace(/\\/g, "/").replace(/^\.\//, "");
-    if (!file || file.startsWith("../") || file.startsWith("/") || /^[A-Za-z]:\//.test(file)) continue;
-    if (/(^|\/)node_modules\//.test(file)) continue;
-    out.add(file);
+    const file = normalizeCoveragePath(raw);
+    if (file !== null) out.add(file);
   }
   return [...out].sort().slice(0, MAX_CODE_REACH_FILES);
 }
@@ -4277,8 +4377,8 @@ function fileForUrl(url, roots, bases) {
 function relativeToRepo(file, repoRoot) {
   return path10.relative(repoRoot, file).split(path10.sep).join("/");
 }
-function scriptHash(entry) {
-  return crypto2.createHash("sha1").update(entry.source ?? "").digest("hex");
+function scriptVersion(entry) {
+  return entry.hash ?? crypto2.createHash("sha1").update(entry.source ?? "").digest("hex");
 }
 async function loadMap(entry, fetchMap) {
   const ref = entry.source ? sourceMappingUrl(entry.source) : null;
@@ -4293,7 +4393,7 @@ async function loadMap(entry, fetchMap) {
   } catch {
     return null;
   }
-  const version = scriptHash(entry);
+  const version = scriptVersion(entry);
   let pending = mapCache.get(absolute, version);
   if (!pending) {
     pending = fetchMap(absolute).then((text) => text ? parseMap(text) : null);
@@ -4309,29 +4409,34 @@ function parseMap(text) {
   }
 }
 async function resolveScript(entry, roots, bases, fetchMap) {
-  const version = scriptHash(entry);
+  const version = scriptVersion(entry);
   const cached = scriptCache.get(entry.url, version);
   if (cached) return cached;
-  let resolution;
   const file = fileForUrl(entry.url, roots.roots, bases);
-  if (file) resolution = { kind: "file", file, lookup: await loadMap(entry, fetchMap) };
-  else {
-    const lookup = await loadMap(entry, fetchMap);
-    resolution = lookup ? { kind: "map", lookup, files: [] } : { kind: "none" };
-  }
-  scriptCache.set(entry.url, version, resolution);
+  const lookup = await loadMap(entry, fetchMap);
+  let resolution;
+  if (file) resolution = { kind: "file", file, lookup, source: entry.source };
+  else resolution = lookup ? { kind: "map", lookup, files: [], source: entry.source } : { kind: "none" };
+  if (entry.source !== void 0) scriptCache.set(entry.url, version, resolution);
   return resolution;
 }
+function withSource(entry, resolution) {
+  if (entry.source !== void 0 || resolution.source === void 0) return entry;
+  return { ...entry, source: resolution.source };
+}
 async function resolveCodeReach(entries, roots, fetchMap) {
   const files = /* @__PURE__ */ new Set();
   const bases = viteBases(entries);
-  for (const entry of entries) {
-    if (!entry.url || !entry.functions?.length || REPLAYED_SCRIPT.test(entry.url)) continue;
-    const resolution = await resolveScript(entry, roots, bases, fetchMap);
+  const scripts = entries.filter((entry) => entry.url && entry.functions?.length && !REPLAYED_SCRIPT.test(entry.url));
+  const known = scripts.map((entry) => scriptCache.get(entry.url, scriptVersion(entry)));
+  for (const [i, covered] of scripts.entries()) {
+    const resolution = known[i] ?? await resolveScript(covered, roots, bases, fetchMap);
     if (resolution.kind === "file") {
+      const entry = withSource(covered, resolution);
       const ran = resolution.lookup ? reachedSources(entry, resolution.lookup).size > 0 : scriptRan(entry);
       if (resolution.file && ran) files.add(relativeToRepo(resolution.file, roots.repoRoot));
     } else if (resolution.kind === "map") {
+      const entry = withSource(covered, resolution);
       for (const index of reachedSources(entry, resolution.lookup)) {
         if (resolution.files[index] === void 0) {
           const source = resolution.lookup.sources[index] ?? "";
@@ -4373,23 +4478,85 @@ function isChromiumPage(page) {
     return false;
   }
 }
+var captures = /* @__PURE__ */ new WeakMap();
+function versionKey(url, hash) {
+  return `${hash} ${url}`;
+}
+function onScriptParsed(page, capture, event) {
+  if (!event.url || REPLAYED_SCRIPT.test(event.url)) return;
+  capture.scripts.set(event.scriptId, { url: event.url, hash: event.hash });
+  const key = versionKey(event.url, event.hash);
+  if (capture.sources.has(key) || scriptCache.get(event.url, event.hash)) return;
+  const source = internalCall(
+    page,
+    () => capture.cdp.send("Debugger.getScriptSource", { scriptId: event.scriptId })
+  ).then(
+    (response) => response.scriptSource,
+    () => {
+      if (capture.sources.get(key) === source) capture.sources.delete(key);
+      return null;
+    }
+  );
+  capture.sources.set(key, source);
+}
+async function detach(page, cdp) {
+  try {
+    await internalCall(page, () => cdp.detach());
+  } catch {
+  }
+}
 async function startCodeReach(page) {
-  if (!isChromiumPage(page) || !page.coverage) return false;
+  if (!isChromiumPage(page) || captures.has(page)) return false;
+  let cdp = null;
   try {
+    cdp = await internalCall(page, () => page.context().newCDPSession(page));
+    const capture = { cdp, scripts: /* @__PURE__ */ new Map(), sources: /* @__PURE__ */ new Map() };
+    cdp.on("Debugger.scriptParsed", (event) => onScriptParsed(page, capture, event));
+    cdp.on("Debugger.paused", () => {
+      internalCall(page, () => capture.cdp.send("Debugger.resume")).catch(() => {
+      });
+    });
     await internalCall(
       page,
-      () => page.coverage.startJSCoverage({ resetOnNavigation: false, reportAnonymousScripts: false })
+      () => Promise.all([
+        capture.cdp.send("Debugger.enable"),
+        capture.cdp.send("Debugger.setSkipAllPauses", { skip: true }),
+        capture.cdp.send("Profiler.enable"),
+        capture.cdp.send("Profiler.startPreciseCoverage", { callCount: false, detailed: false })
+      ])
     );
+    captures.set(page, capture);
     return true;
   } catch {
+    if (cdp) await detach(page, cdp);
     return false;
   }
 }
 async function stopCodeReach(page) {
+  const capture = captures.get(page);
+  if (!capture) return null;
+  captures.delete(page);
+  const { cdp } = capture;
   try {
-    return await internalCall(page, () => page.coverage.stopJSCoverage());
+    const coverage = await internalCall(page, async () => {
+      const taken = await cdp.send("Profiler.takePreciseCoverage");
+      await cdp.send("Profiler.stopPreciseCoverage");
+      return taken;
+    });
+    const entries = [];
+    for (const script of coverage.result) {
+      const parsed2 = capture.scripts.get(script.scriptId);
+      if (!parsed2) continue;
+      const entry = { url: parsed2.url, hash: parsed2.hash, functions: script.functions };
+      const source = await capture.sources.get(versionKey(parsed2.url, parsed2.hash));
+      if (source != null) entry.source = source;
+      entries.push(entry);
+    }
+    return entries;
   } catch {
     return null;
+  } finally {
+    await detach(page, cdp);
   }
 }
 
@@ -5258,6 +5425,243 @@ async function recordResourceCensus(testInfo) {
   if (ledger.leakCheck === "fail" && leaks.length > 0) throw new Error(leakFailureMessage(leaks));
 }
 
+// src/internal/capture/page-interaction.ts
+function readPageInteraction() {
+  const doc = globalThis.document;
+  const SKIPPED_TEXT = ["SCRIPT", "STYLE", "NOSCRIPT", "TEMPLATE"];
+  const pathOf = (el) => {
+    const levels = [];
+    for (let node = el; node; ) {
+      const steps = [];
+      let root = null;
+      for (let cur = node; cur; cur = cur.parentElement) {
+        let position = 1;
+        for (let s = cur.previousElementSibling; s; s = s.previousElementSibling) {
+          if (s.localName === cur.localName) position++;
+        }
+        steps.unshift(`${cur.localName}:${position}`);
+        if (!cur.parentElement) root = cur.parentNode;
+      }
+      levels.unshift(steps.join("/"));
+      node = root && root.host ? root.host : null;
+    }
+    return levels.join("|");
+  };
+  const isField = (el) => /^(input|textarea|select)$/.test(el.localName) || !!el.isContentEditable;
+  const label = (el) => {
+    const tag = el.localName;
+    if (el.id) return `${tag}#${el.id}`;
+    for (const attr2 of ["name", "aria-label"]) {
+      const value = el.getAttribute(attr2);
+      if (value) return `${tag}[${attr2}="${value}"]`;
+    }
+    const text = isField(el) ? "" : String(el.textContent || "").replace(/\s+/g, " ").trim();
+    return text ? `${tag} "${text.length > 40 ? `${text.slice(0, 40)}\u2026` : text}"` : tag;
+  };
+  const ref = (el) => ({ path: pathOf(el), label: label(el) });
+  const textOffset = (el, stop, extra) => {
+    const walker = doc.createTreeWalker(el, 4);
+    let offset = 0;
+    for (let text = walker.nextNode(); text; text = walker.nextNode()) {
+      if (stop && (text === stop || stop.contains(text) || stop.compareDocumentPosition(text) & 4)) break;
+      if (!SKIPPED_TEXT.includes(text.parentElement?.tagName)) offset += text.data.length;
+    }
+    return offset + extra;
+  };
+  const textPoint2 = (node, offset) => {
+    if (node.nodeType === 3)
+      return { path: pathOf(node.parentElement), offset: textOffset(node.parentElement, node, offset) };
+    return { path: pathOf(node), offset: textOffset(node, node.childNodes[offset] ?? null, 0) };
+  };
+  const out = {};
+  let active = doc.activeElement;
+  while (active?.shadowRoot?.activeElement) active = active.shadowRoot.activeElement;
+  if (active && active !== doc.body && active !== doc.documentElement) {
+    let visible = false;
+    try {
+      visible = active.matches(":focus-visible");
+    } catch {
+    }
+    out.focus = { element: ref(active), visible };
+    try {
+      if (typeof active.selectionStart === "number" && typeof active.selectionEnd === "number") {
+        out.focus.selection = [active.selectionStart, active.selectionEnd];
+      }
+    } catch {
+    }
+  }
+  let scope = doc;
+  for (; ; ) {
+    const chain = scope.querySelectorAll(":hover");
+    const innermost = chain[chain.length - 1];
+    if (!innermost) break;
+    out.hover = ref(innermost);
+    if (!innermost.shadowRoot) break;
+    scope = innermost.shadowRoot;
+  }
+  const selection = doc.getSelection?.();
+  if (selection && selection.rangeCount > 0 && !selection.isCollapsed && !(active && isField(active))) {
+    const range = selection.getRangeAt(0);
+    const start = range.startContainer.nodeType === 3 ? range.startContainer.parentElement : range.startContainer;
+    const end = range.endContainer.nodeType === 3 ? range.endContainer.parentElement : range.endContainer;
+    if (start?.nodeType === 1 && end?.nodeType === 1) {
+      out.selection = {
+        start: textPoint2(range.startContainer, range.startOffset),
+        end: textPoint2(range.endContainer, range.endOffset),
+        length: String(selection).length
+      };
+    }
+  }
+  const boxes = [];
+  const roots = [doc];
+  for (let i = 0; i < roots.length && boxes.length < 20; i++) {
+    for (const el of roots[i].querySelectorAll("*")) {
+      if (el.shadowRoot) roots.push(el.shadowRoot);
+      if (el.localName === "input" && el.type === "checkbox" && el.indeterminate && boxes.length < 20)
+        boxes.push(ref(el));
+    }
+  }
+  if (boxes.length) out.indeterminate = boxes;
+  return out;
+}
+
+// src/internal/capture/api-requests.ts
+var SENDING_METHODS = /* @__PURE__ */ new Set(["fetch", "get", "post", "put", "patch", "delete", "head"]);
+var PROXIES = /* @__PURE__ */ new WeakMap();
+var OBSERVED = /* @__PURE__ */ new WeakSet();
+var PATCHED_REQUESTS = /* @__PURE__ */ new WeakSet();
+function observeApiRequests(playwright, recorder) {
+  const apiRequest = playwright?.request;
+  if (!apiRequest || typeof apiRequest !== "object" || typeof apiRequest.newContext !== "function") return;
+  if (PATCHED_REQUESTS.has(apiRequest)) return;
+  PATCHED_REQUESTS.add(apiRequest);
+  const create = apiRequest.newContext.bind(apiRequest);
+  apiRequest.newContext = async function newContext(...args) {
+    const context = await create(...args);
+    return observeApiRequestContext(context, recorder, baseUrlOption(args[0]));
+  };
+}
+function observeApiRequestContext(context, recorder, baseURL = null) {
+  if (!context || typeof context !== "object" || OBSERVED.has(context)) return context;
+  const known = PROXIES.get(context);
+  if (known) return known;
+  const forwarders = /* @__PURE__ */ new Map();
+  const proxy = new Proxy(context, {
+    get(target, prop) {
+      const value = Reflect.get(target, prop);
+      if (typeof value !== "function" || prop === "constructor") return value;
+      const cached = forwarders.get(prop);
+      if (cached?.method === value) return cached.forward;
+      const forward = typeof prop === "string" && SENDING_METHODS.has(prop) ? sendingMethod(target, prop, recorder, baseURL) : value.bind(target);
+      forwarders.set(prop, { method: value, forward });
+      return forward;
+    }
+  });
+  PROXIES.set(context, proxy);
+  OBSERVED.add(proxy);
+  return proxy;
+}
+function sendingMethod(target, prop, recorder, baseURL) {
+  return function send(...args) {
+    const record = recorder();
+    if (!record) return callMethod(target, prop, args);
+    const startedAt = Date.now();
+    const result = callMethod(target, prop, args);
+    if (typeof result?.then !== "function") return result;
+    const report = (response, error) => {
+      try {
+        record({
+          method: methodOf(prop, args),
+          url: urlOf(args[0]),
+          baseURL,
+          startedAt,
+          endedAt: Date.now(),
+          response,
+          error
+        });
+      } catch {
+      }
+    };
+    return result.then(
+      (response) => {
+        report(response);
+        return response;
+      },
+      (error) => {
+        report(null, error);
+        throw error;
+      }
+    );
+  };
+}
+function methodOf(prop, args) {
+  if (prop !== "fetch") return prop.toUpperCase();
+  const option = args[1]?.method;
+  if (typeof option === "string" && option) return option.toUpperCase();
+  const request = args[0];
+  const method = typeof request?.method === "function" ? request.method() : null;
+  return typeof method === "string" && method ? method.toUpperCase() : "GET";
+}
+function urlOf(target) {
+  if (typeof target === "string") return target;
+  const url = typeof target?.url === "function" ? target.url() : null;
+  return typeof url === "string" ? url : null;
+}
+function baseUrlOption(options) {
+  const baseURL = options?.baseURL;
+  return typeof baseURL === "string" && baseURL ? baseURL : null;
+}
+var MAX_FAILURE_LENGTH = 300;
+var API_ERROR_PREFIX = /^apiRequestContext\.\w+: /;
+var STATUS_FAILURE = /^(\d{3}) /;
+function apiCallEntry(call, baseURL) {
+  const response = call.response;
+  if (response) {
+    const timing = responseTiming(response) ?? { startTime: call.startedAt, duration: call.endedAt - call.startedAt };
+    return {
+      method: call.method,
+      url: response.url(),
+      status: response.status(),
+      duration: timing.duration,
+      startTime: timing.startTime
+    };
+  }
+  const url = resolveUrl(call.url, call.baseURL ?? baseURL);
+  if (!url) return null;
+  const failure = failureText(call.error);
+  const status = STATUS_FAILURE.exec(failure);
+  return {
+    method: call.method,
+    url,
+    status: status ? Number(status[1]) : 0,
+    duration: Math.max(0, call.endedAt - call.startedAt),
+    startTime: call.startedAt,
+    ...status ? {} : { failure }
+  };
+}
+function responseTiming(response) {
+  if (typeof response.timing !== "function") return null;
+  const timing = response.timing();
+  if (!(timing.startTime > 0) || !(timing.responseEnd >= 0)) return null;
+  return {
+    startTime: timing.startTime,
+    duration: Math.max(0, Math.round(timing.responseEnd - Math.max(0, timing.requestStart)))
+  };
+}
+function resolveUrl(url, baseURL) {
+  if (!url) return null;
+  try {
+    return new URL(url, baseURL ?? void 0).toString();
+  } catch {
+    return url;
+  }
+}
+function failureText(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const line = message.split("\n", 1)[0].replace(API_ERROR_PREFIX, "").trim();
+  return (line || "failed").slice(0, MAX_FAILURE_LENGTH);
+}
+
 // src/internal/capture/capture-fixtures.ts
 function computeCoreVitals(lcpEntries, shiftEntries, eventEntries) {
   const lastLcp = lcpEntries && lcpEntries.length > 0 ? lcpEntries[lcpEntries.length - 1] : null;
@@ -5291,6 +5695,7 @@ function computeCoreVitals(lcpEntries, shiftEntries, eventEntries) {
 function createSink() {
   return {
     networkRequests: [],
+    openResponses: /* @__PURE__ */ new Map(),
     consoleEntries: [],
     dialogs: [],
     pendingHandlers: [],
@@ -5304,6 +5709,8 @@ function createSink() {
     stashedPageState: null,
     stashedAria: null,
     stashedAriaJson: null,
+    failureScreenshot: null,
+    stashedScreenshot: null,
     pageInventories: [],
     probeItem: null,
     probePageErrors: 0,
@@ -5314,12 +5721,14 @@ function createSink() {
     userPick: null,
     pause: null,
     locatorPages: new LocatorPageLog(),
-    codeReach: null
+    codeReach: null,
+    serverCoverage: /* @__PURE__ */ new Map(),
+    baseURL: null
   };
 }
 function maybeStartCodeReach(page) {
   const sink = currentSink;
-  if (!sink || process.env.PIWI_CAPTURE_CODE_REACH !== "true") return Promise.resolve(false);
+  if (!sink || !browserCoverageInWorker()) return Promise.resolve(false);
   if (sink.codeReach) return sink.codeReach.page === page ? sink.codeReach.started : Promise.resolve(false);
   const started = startCodeReach(page);
   sink.codeReach = { page, started, stopped: false, files: null };
@@ -5460,7 +5869,7 @@ var PAGE_STATE_MAX_STORAGE_KEYS = 50;
 var PAGE_STATE_MAX_COOKIES = 30;
 var PAGE_STATE_HISTORY_CAP = 2048;
 var TOKEN_MASK_RES = [/\beyJ[\w-]{10,}\.[\w-]{5,}\.[\w-]{5,}\b/g, /\b[0-9a-f]{32,}\b/gi];
-function buildPageState(raw, cookies) {
+function buildPageState(raw, cookies, interaction) {
   let historyState = raw.historyState;
   if (historyState) {
     for (const re of TOKEN_MASK_RES) historyState = historyState.replace(re, "[masked]");
@@ -5486,7 +5895,8 @@ function buildPageState(raw, cookies) {
       secure: Boolean(c.secure),
       ...c.sameSite !== void 0 ? { sameSite: String(c.sameSite) } : {},
       ...typeof c.expires === "number" ? { expires: c.expires } : {}
-    }))
+    })),
+    ...sanitizePageInteraction(interaction)
   };
 }
 async function readPageState(page) {
@@ -5524,7 +5934,8 @@ async function readPageState(page) {
     } catch {
       cookies = null;
     }
-    return buildPageState(raw, cookies);
+    const interaction = await page.evaluate(readPageInteraction).catch(() => null);
+    return buildPageState(raw, cookies, interaction);
   } catch {
     return null;
   }
@@ -5616,6 +6027,8 @@ async function readPageBeforeClose(sink, page) {
   };
   if (status === "failed" || status === "timedOut" || status === "interrupted") {
     await sampleAria();
+    if (sink.failureScreenshot)
+      sink.stashedScreenshot = await readFailureScreenshot(page, sink.failureScreenshot) ?? sink.stashedScreenshot;
   } else if (status === "passed" && process.env.PIWI_SAMPLE_ARIA_ON_PASS !== "false" && sink.testInfo && isDueForAriaSample(sink.testInfo)) {
     await sampleAria();
   }
@@ -5765,9 +6178,6 @@ function startElementCapture(sink, page, target, seq, callerLocation, used) {
   })();
   sink.capturePromises.push(resolveAttrs);
 }
-function callMethod(target, prop, args) {
-  return target[prop](...args);
-}
 function recordLocatorPage(sink, page, locator, location, arrival) {
   try {
     sink.locatorPages.record({ location, locator: String(locator), url: page.url(), arrival });
@@ -5934,6 +6344,7 @@ function instrumentPage(page) {
   if (!page || INSTRUMENTED_PAGES.has(page)) return;
   INSTRUMENTED_PAGES.add(page);
   void maybeStartCodeReach(page);
+  observeOwnApiRequests(page);
   const probeSink = currentSink;
   if (probeSink?.probeItem && !probeSink.probeInterception) {
     void installProbeInterception(page, probeSink.probeItem).then((interception) => {
@@ -6040,59 +6451,115 @@ function instrumentPage(page) {
     } catch {
     }
   }
-  const recordRequest = (request, failed) => {
+  page.on("response", (response) => {
     const sink = currentSink;
     if (!sink) return;
+    try {
+      const request = response.request();
+      if (isTrackedRequest(request.url(), request.resourceType())) sink.openResponses.set(request, response);
+    } catch {
+    }
+  });
+  const onRequestEnd = (request, failed) => {
+    const sink = currentSink;
+    if (!sink || RECORDED_OPEN.has(request)) return;
     sink.lastActivePage = page;
-    const p = (async () => {
-      try {
-        const url = request.url();
-        if (url.startsWith("data:") || url.startsWith("blob:")) return;
-        const resourceType = request.resourceType();
-        if (!TRACKED_REQUEST_TYPES.includes(resourceType)) return;
-        const failure = failed ? request.failure()?.errorText ?? "failed" : null;
-        if (failure && CANCELLED_REQUEST.test(failure)) return;
-        const timing = request.timing();
-        const response = failed ? null : await request.response();
-        const entry = {
-          method: request.method(),
-          url,
-          status: response ? response.status() : 0,
-          duration: requestDuration(timing, failed),
-          startTime: timing.startTime,
-          resourceType
-        };
-        if (failure) entry.failure = failure;
-        if (response) {
-          if (timing.requestStart < 0 && typeof response.serverAddr === "function") {
-            if (await response.serverAddr().catch(() => void 0) === null) entry.fulfilled = true;
-          }
-          const headers = response.headers();
-          const contentType = headers["content-type"];
-          if (contentType) entry.contentType = contentType.split(";")[0].trim();
-          const logHeader = headers["x-piwi-logs"];
-          if (logHeader) {
-            try {
-              entry.serverLogs = JSON.parse((0, import_node_zlib2.gunzipSync)(Buffer.from(logHeader, "base64")).toString("utf-8"));
-            } catch {
-            }
-          }
-          const traceHeader = headers["x-piwi-trace"];
-          if (traceHeader && process.env.PIWI_CAPTURE_SERVER_TRACES !== "false") {
-            try {
-              entry.serverTraces = JSON.parse((0, import_node_zlib2.gunzipSync)(Buffer.from(traceHeader, "base64")).toString("utf-8"));
-            } catch {
-            }
-          }
+    const response = sink.openResponses.get(request) ?? null;
+    sink.openResponses.delete(request);
+    recordRequest(sink, request, failed ? "failed" : "finished", response);
+  };
+  page.on("requestfinished", (request) => onRequestEnd(request, false));
+  page.on("requestfailed", (request) => onRequestEnd(request, true));
+}
+var RECORDED_OPEN = /* @__PURE__ */ new WeakSet();
+function isTrackedRequest(url, resourceType) {
+  if (url.startsWith("data:") || url.startsWith("blob:")) return false;
+  return TRACKED_REQUEST_TYPES.includes(resourceType);
+}
+function recordRequest(sink, request, end, response) {
+  const p = (async () => {
+    try {
+      const url = request.url();
+      const resourceType = request.resourceType();
+      if (!isTrackedRequest(url, resourceType)) return;
+      let failure = end === "failed" ? request.failure()?.errorText ?? "failed" : null;
+      if (failure && CANCELLED_REQUEST.test(failure)) {
+        if (!response) return;
+        failure = null;
+        end = "unfinished";
+      }
+      const timing = request.timing();
+      if (end === "failed") response = null;
+      else if (end === "finished") response ??= await request.response();
+      const entry = {
+        method: request.method(),
+        url,
+        status: response ? response.status() : 0,
+        duration: requestDuration(timing, end),
+        startTime: timing.startTime,
+        resourceType
+      };
+      if (failure) entry.failure = failure;
+      if (response) {
+        if (timing.requestStart < 0 && typeof response.serverAddr === "function") {
+          if (await response.serverAddr().catch(() => void 0) === null) entry.fulfilled = true;
         }
-        sink.networkRequests.push(entry);
-      } catch {
+        readResponseHeaders(sink, entry, url, response.headers());
       }
-    })();
-    sink.pendingHandlers.push(p);
-  };
-  page.on("requestfinished", (request) => recordRequest(request, false));
-  page.on("requestfailed", (request) => recordRequest(request, true));
+      sink.networkRequests.push(entry);
+    } catch {
+    }
+  })();
+  sink.pendingHandlers.push(p);
+}
+function readResponseHeaders(sink, entry, url, headers) {
+  const contentType = headers["content-type"];
+  if (contentType) entry.contentType = contentType.split(";")[0].trim();
+  const logHeader = headers["x-piwi-logs"];
+  if (logHeader) {
+    try {
+      entry.serverLogs = JSON.parse((0, import_node_zlib2.gunzipSync)(Buffer.from(logHeader, "base64")).toString("utf-8"));
+    } catch {
+    }
+  }
+  const coverageHeader = headers["x-piwi-coverage"];
+  if (coverageHeader && serverCoverageInWorker()) recordServerCoverageIds(sink, url, coverageHeader);
+  const traceHeader = headers["x-piwi-trace"];
+  if (traceHeader && process.env.PIWI_CAPTURE_SERVER_TRACES !== "false") {
+    try {
+      entry.serverTraces = JSON.parse((0, import_node_zlib2.gunzipSync)(Buffer.from(traceHeader, "base64")).toString("utf-8"));
+    } catch {
+    }
+  }
+}
+function recordApiCall(sink, call) {
+  try {
+    const entry = apiCallEntry(call, sink.baseURL);
+    if (!entry) return;
+    if (call.response) readResponseHeaders(sink, entry, String(entry.url), call.response.headers());
+    sink.networkRequests.push(entry);
+  } catch {
+  }
+}
+function apiCallRecorder() {
+  const sink = currentSink;
+  return sink ? (call) => recordApiCall(sink, call) : null;
+}
+function observeOwnApiRequests(owner) {
+  try {
+    const holder = owner;
+    if (holder.request && typeof holder.request === "object") {
+      holder.request = observeApiRequestContext(holder.request, apiCallRecorder);
+    }
+  } catch {
+  }
+}
+function recordOpenRequests(sink) {
+  for (const [request, response] of sink.openResponses) {
+    RECORDED_OPEN.add(request);
+    recordRequest(sink, request, "unfinished", response);
+  }
+  sink.openResponses.clear();
 }
 async function awaitFlakeConditions() {
   await currentSink?.flake?.conditions;
@@ -6100,6 +6567,7 @@ async function awaitFlakeConditions() {
 function instrumentContext(context) {
   if (!context || INSTRUMENTED_CONTEXTS.has(context)) return;
   INSTRUMENTED_CONTEXTS.add(context);
+  observeOwnApiRequests(context);
   if (process.env.PIWI_CAPTURE_LOCATORS !== "false" && typeof context.addInitScript === "function") {
     void Promise.resolve(context.addInitScript({ content: PROBE_INIT_SCRIPT })).catch(() => {
     });
@@ -6159,12 +6627,36 @@ function readRootAriaJson(page) {
   return internalCall(page, () => ariaSnapshotJSONBestEffort(page.locator(":root")));
 }
 var TRACKED_REQUEST_TYPES = ["fetch", "xhr", "document", "other"];
-function requestDuration(timing, failed) {
+var SERVER_COVERAGE_ID = /^[\x21-\x7e]{1,128}$/;
+function recordServerCoverageIds(sink, url, value) {
+  let origin;
+  try {
+    const parsed2 = new URL(url);
+    if (parsed2.protocol !== "http:" && parsed2.protocol !== "https:") return;
+    origin = parsed2.origin;
+  } catch {
+    return;
+  }
+  for (const id of value.split(/[\s,]+/)) {
+    if (!SERVER_COVERAGE_ID.test(id)) continue;
+    let ids = sink.serverCoverage.get(origin);
+    if (!ids) {
+      ids = /* @__PURE__ */ new Set();
+      sink.serverCoverage.set(origin, ids);
+    }
+    ids.add(id);
+  }
+}
+function requestDuration(timing, end) {
+  if (end === "unfinished") {
+    return timing.responseStart >= 0 ? Math.max(0, Math.round(timing.responseStart - timing.requestStart)) : 0;
+  }
   if (timing.responseEnd > 0) return Math.round(timing.responseEnd - timing.requestStart);
-  if (failed && timing.startTime > 0) return Math.max(0, Math.round(Date.now() - timing.startTime));
+  if (end === "failed" && timing.startTime > 0) return Math.max(0, Math.round(Date.now() - timing.startTime));
   return 0;
 }
 async function flushSink(sink, testInfo) {
+  recordOpenRequests(sink);
   await Promise.allSettled(sink.pendingHandlers);
   let drainDeadline;
   await Promise.race([
@@ -6193,6 +6685,14 @@ async function flushSink(sink, testInfo) {
       body: Buffer.from(JSON.stringify(sink.codeReach.files))
     });
   }
+  if (sink.serverCoverage.size > 0) {
+    const requests = {};
+    for (const [origin, ids] of sink.serverCoverage) requests[origin] = [...ids];
+    await testInfo.attach(ATTACHMENT_NAMES.serverCoverageRequests, {
+      contentType: "application/json",
+      body: Buffer.from(JSON.stringify(requests))
+    });
+  }
   if (sink.locatorPages.size > 0) {
     await testInfo.attach(ATTACHMENT_NAMES.locatorPages, {
       contentType: "application/json",
@@ -6230,6 +6730,16 @@ async function flushSink(sink, testInfo) {
     } catch {
     }
   }
+  if (testInfo.status !== "passed" && testInfo.status !== "skipped" && sink.failureScreenshot) {
+    const option = sink.failureScreenshot;
+    const shot = (pageReadable ? await internalCall(page, () => readFailureScreenshot(page, option)) : null) ?? sink.stashedScreenshot;
+    if (shot) {
+      try {
+        await testInfo.attach(FAILURE_SCREENSHOT_ATTACHMENT, { contentType: "image/png", body: shot });
+      } catch {
+      }
+    }
+  }
   if (testInfo.status === "passed" && process.env.PIWI_SAMPLE_ARIA_ON_PASS !== "false" && isDueForAriaSample(testInfo)) {
     try {
       const snapshot = (pageReadable ? await readRootAria(page) : null) ?? sink.stashedAria;
@@ -6312,14 +6822,17 @@ async function flushSink(sink, testInfo) {
   }
 }
 var piwiFixtures = {
-  // Auto, worker-scoped: the worker's resource ledger. Set up before any hook
-  // (worker fixtures come first), so a `beforeAll` context is in it too, and
-  // torn down after the browser closed, so its census sees what only the
-  // worker's shutdown closed. Depends on `playwright` alone, which launches nothing.
+  // Auto, worker-scoped: the worker's resource ledger, and the API request
+  // contexts its tests create, handed out behind the call proxy. Set up before
+  // any hook (worker fixtures come first), so a `beforeAll` context is in the
+  // ledger and records the calls the tests make through it, and torn down after
+  // the browser closed, so its census sees what only the worker's shutdown
+  // closed. Depends on `playwright` alone, which launches nothing.
   piwiResources: [
     async ({ playwright }, use, workerInfo) => {
       boxCaptureFrames();
       startResourceLedger(playwright, workerInfo.workerIndex);
+      observeApiRequests(playwright, apiCallRecorder);
       try {
         await use();
       } finally {
@@ -6350,12 +6863,14 @@ var piwiFixtures = {
   // (attach the collected data) at teardown. Runs for every test without being
   // requested, so suites that never destructure `page` are still captured.
   piwiCapture: [
-    async ({}, use, testInfo) => {
+    async ({ screenshot, baseURL }, use, testInfo) => {
       boxCaptureFrames();
       const conflict = labModeConflict();
       if (conflict) throw new Error(conflict);
       const sink = createSink();
       sink.testInfo = testInfo;
+      sink.baseURL = baseURL ?? null;
+      if (keepsFailureScreenshots(screenshot, testInfo.retry)) sink.failureScreenshot = screenshot;
       const pauseSet = currentPauseSet();
       if (pauseSet.size) {
         const reason = pauseSkipReason(pauseGateFromTestInfo(testInfo));
@@ -6461,6 +6976,7 @@ function extendPiwiFixtures(test) {
   pageMapFetcher,
   piwiFixtures,
   probeElementAttrs,
+  readPageInteraction,
   recordResourceCensus,
   resolveCodeReach,
   startCodeReach,