@piwitests/reporter 0.53.0 → 0.55.0

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

@@ -2037,6 +2037,8 @@ var ATTACHMENT_NAMES = {
   pageInventory: "piwi-page-inventory",
   locatorPages: "piwi-locator-pages",
   codeReach: "piwi-code-reach",
+  browserCoverage: "piwi-browser-coverage",
+  browserFunctions: "piwi-browser-functions",
   serverCoverageRequests: "piwi-server-coverage-requests",
   webVitals: "piwi-web-vitals",
   locatorSuggestion: "piwi-locator-suggestion",
@@ -3501,6 +3503,438 @@ function joinErrorMessages(errors) {
   return parts.join("\n---\n") || null;
 }
 
+// ../core/src/coverage.ts
+var MAX_COVERAGE_FILES = 2e3;
+var MAX_COVERAGE_RANGES = 1e4;
+var MAX_LINE = 1e6;
+var MAX_PATH_LENGTH = 500;
+var BLOB_ID = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRuntime(value) {
+  return value === "browser" || value === "server";
+}
+function isLine(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= MAX_LINE;
+}
+function validRanges(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const item of raw) {
+    if (!Array.isArray(item) || item.length !== 2) continue;
+    const [start, end] = item;
+    if (isLine(start) && isLine(end) && start <= end) out.push([start, end]);
+  }
+  return out.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+}
+function normalizeLineRanges(ranges) {
+  const out = [];
+  for (const range of validRanges(ranges)) {
+    const last = out[out.length - 1];
+    if (last && range[0] <= last[1] + 1) last[1] = Math.max(last[1], range[1]);
+    else out.push(range);
+  }
+  return out;
+}
+function normalizeFunctionRanges(ranges) {
+  const out = [];
+  for (const range of validRanges(ranges)) {
+    const last = out[out.length - 1];
+    if (!last || last[0] !== range[0] || last[1] !== range[1]) out.push(range);
+  }
+  return out;
+}
+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;
+}
+function fileEntry(path14, runtime, blob, functions = [], lines = []) {
+  const file = { path: path14, runtime };
+  if (blob && (functions.length > 0 || lines.length > 0)) file.blob = blob;
+  if (functions.length > 0) file.functions = functions;
+  if (lines.length > 0) file.lines = lines;
+  return file;
+}
+function captureOf(files, incomplete) {
+  return incomplete ? { v: 1, files, incomplete: true } : { v: 1, files };
+}
+function compareFiles(a, b) {
+  if (a.path !== b.path) return a.path < b.path ? -1 : 1;
+  if (a.runtime !== b.runtime) return a.runtime < b.runtime ? -1 : 1;
+  return 0;
+}
+function sanitizeCoverage(raw) {
+  if (!isRecord(raw) || raw.v !== 1 || !Array.isArray(raw.files)) return null;
+  const files = [];
+  for (const item of raw.files) {
+    if (!isRecord(item) || !isRuntime(item.runtime)) continue;
+    const path14 = normalizeCoveragePath(item.path);
+    if (path14 === null) continue;
+    const blob = typeof item.blob === "string" && BLOB_ID.test(item.blob) ? item.blob : void 0;
+    files.push(
+      fileEntry(path14, item.runtime, blob, normalizeFunctionRanges(item.functions), normalizeLineRanges(item.lines))
+    );
+  }
+  const merged = mergeCoverage(captureOf(files, raw.incomplete === true));
+  if (!merged) return null;
+  let incomplete = merged.incomplete === true || merged.files.length > MAX_COVERAGE_FILES;
+  let budget = MAX_COVERAGE_RANGES;
+  const capped = merged.files.slice(0, MAX_COVERAGE_FILES).map((file) => {
+    const count = (file.functions?.length ?? 0) + (file.lines?.length ?? 0);
+    if (count <= budget) {
+      budget -= count;
+      return file;
+    }
+    incomplete = true;
+    return fileEntry(file.path, file.runtime);
+  });
+  return captureOf(capped, incomplete);
+}
+function mergeCoverage(...captures2) {
+  const entries = /* @__PURE__ */ new Map();
+  let incomplete = false;
+  for (const capture of captures2) {
+    if (!capture) continue;
+    if (capture.incomplete) incomplete = true;
+    for (const file of capture.files) {
+      const key = `${file.runtime}:${file.path}`;
+      let entry = entries.get(key);
+      if (!entry) {
+        entry = { path: file.path, runtime: file.runtime, blobs: /* @__PURE__ */ new Set(), functions: [], lines: [] };
+        entries.set(key, entry);
+      }
+      if (file.blob) entry.blobs.add(file.blob);
+      for (const range of file.functions ?? []) entry.functions.push(range);
+      for (const range of file.lines ?? []) entry.lines.push(range);
+    }
+  }
+  if (entries.size === 0) return null;
+  const files = [...entries.values()].map((entry) => {
+    if (entry.blobs.size > 1) incomplete = true;
+    const blob = entry.blobs.size === 1 ? [...entry.blobs][0] : void 0;
+    return fileEntry(
+      entry.path,
+      entry.runtime,
+      blob,
+      normalizeFunctionRanges(entry.functions),
+      normalizeLineRanges(entry.lines)
+    );
+  });
+  return captureOf(files.sort(compareFiles), incomplete);
+}
+
+// ../core/src/source-map.ts
+var BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var BASE64_VALUE = new Int8Array(128).fill(-1);
+for (let i = 0; i < BASE64.length; i++) BASE64_VALUE[BASE64.charCodeAt(i)] = i;
+function decodeMappings(mappings, sourceBase) {
+  const lines = [];
+  let current = { columns: [], sources: [], originalLines: [] };
+  let column = 0;
+  let source = 0;
+  let originalLine = 0;
+  const fields = [];
+  let value = 0;
+  let shift = 0;
+  const flush = () => {
+    if (fields.length === 0) return;
+    column += fields[0];
+    if (fields.length >= 4) {
+      source += fields[1];
+      originalLine += fields[2];
+      current.columns.push(column);
+      current.sources.push(sourceBase + source);
+      current.originalLines.push(originalLine);
+    } else {
+      current.columns.push(column);
+      current.sources.push(-1);
+      current.originalLines.push(-1);
+    }
+    fields.length = 0;
+  };
+  for (let i = 0; i <= mappings.length; i++) {
+    const ch = i < mappings.length ? mappings.charCodeAt(i) : 59;
+    if (ch === 59 || ch === 44) {
+      flush();
+      if (ch === 59) {
+        lines.push(current);
+        current = { columns: [], sources: [], originalLines: [] };
+        column = 0;
+      }
+      continue;
+    }
+    const digit = ch < 128 ? BASE64_VALUE[ch] : -1;
+    if (digit < 0) continue;
+    value += (digit & 31) << shift;
+    if (digit & 32) {
+      shift += 5;
+      continue;
+    }
+    fields.push(value & 1 ? -(value >>> 1) : value >>> 1);
+    value = 0;
+    shift = 0;
+  }
+  for (const line of lines) {
+    if (line.columns.every((c, i) => i === 0 || c >= line.columns[i - 1])) continue;
+    const order = line.columns.map((_, i) => i).sort((a, b) => line.columns[a] - line.columns[b]);
+    line.columns = order.map((i) => line.columns[i]);
+    line.sources = order.map((i) => line.sources[i]);
+    line.originalLines = order.map((i) => line.originalLines[i]);
+  }
+  return lines;
+}
+function joinRoot(root, source) {
+  if (!root || /^[a-z][\w+.-]*:/i.test(source) || source.startsWith("/")) return source;
+  return root.endsWith("/") ? root + source : `${root}/${source}`;
+}
+function decodeLines(raw) {
+  const sources = [];
+  const decoded = [];
+  const add = (map, lineOffset, columnOffset) => {
+    if (map.sections) {
+      for (const section of map.sections) {
+        if (!add(section.map, section.offset.line, section.offset.column)) return false;
+      }
+      return true;
+    }
+    if (typeof map.mappings !== "string" || !Array.isArray(map.sources)) return false;
+    const base = sources.length;
+    for (const s of map.sources) sources.push(joinRoot(map.sourceRoot, s ?? ""));
+    decodeMappings(map.mappings, base).forEach((segments, i) => {
+      const at = lineOffset + i;
+      const shifted = i === 0 && columnOffset ? segments.columns.map((c) => c + columnOffset) : segments.columns;
+      const existing = decoded[at];
+      if (!existing)
+        decoded[at] = { columns: shifted, sources: segments.sources, originalLines: segments.originalLines };
+      else {
+        existing.columns.push(...shifted);
+        existing.sources.push(...segments.sources);
+        existing.originalLines.push(...segments.originalLines);
+      }
+    });
+    return true;
+  };
+  return add(raw, 0, 0) ? { sources, lines: decoded } : null;
+}
+function compactSegments(lines) {
+  let total = 0;
+  for (const line of lines) total += line?.columns.length ?? 0;
+  const segments = {
+    lineStarts: new Int32Array(lines.length + 1),
+    columns: new Int32Array(total),
+    sources: new Int32Array(total),
+    originalLines: new Int32Array(total)
+  };
+  let at = 0;
+  for (let n = 0; n < lines.length; n++) {
+    segments.lineStarts[n] = at;
+    const line = lines[n];
+    if (!line) continue;
+    segments.columns.set(line.columns, at);
+    segments.sources.set(line.sources, at);
+    segments.originalLines.set(line.originalLines, at);
+    at += line.columns.length;
+  }
+  segments.lineStarts[lines.length] = at;
+  return segments;
+}
+function decodeSourceMap(raw) {
+  if (raw.version !== void 0 && raw.version !== 3) return null;
+  const decoded = decodeLines(raw);
+  if (!decoded) return null;
+  const { sources } = decoded;
+  const segments = compactSegments(decoded.lines);
+  const lineCount = segments.lineStarts.length - 1;
+  const originalAt = (line, column) => {
+    if (line < 0 || line >= lineCount) return null;
+    let lo = segments.lineStarts[line];
+    let hi = segments.lineStarts[line + 1] - 1;
+    if (lo > hi || segments.columns[lo] > column) return null;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (segments.columns[mid] <= column) lo = mid;
+      else hi = mid - 1;
+    }
+    const source = segments.sources[lo];
+    return source < 0 ? null : { source, line: segments.originalLines[lo] };
+  };
+  return {
+    sources,
+    sourceAt(line, column) {
+      return originalAt(line, column)?.source ?? null;
+    },
+    originalAt,
+    mapsBetween(source, start, end) {
+      let found = false;
+      eachSegmentBetween(segments, start, end, (i) => {
+        found = segments.sources[i] === source;
+        return found;
+      });
+      return found;
+    },
+    firstOriginalLineBetween(source, start, end) {
+      let first = null;
+      eachSegmentBetween(segments, start, end, (i) => {
+        if (segments.sources[i] !== source || segments.originalLines[i] < 0) return false;
+        first = segments.originalLines[i];
+        return true;
+      });
+      return first;
+    },
+    originalLinesBetween(source, start, end, fromLine = 0) {
+      let first = Number.POSITIVE_INFINITY;
+      let last = -1;
+      eachSegmentBetween(segments, start, end, (i) => {
+        const line = segments.originalLines[i];
+        if (segments.sources[i] === source && line >= fromLine) {
+          if (line < first) first = line;
+          if (line > last) last = line;
+        }
+        return false;
+      });
+      return last < 0 ? null : [first, last];
+    }
+  };
+}
+function eachSegmentBetween(segments, start, end, visit) {
+  const lineCount = segments.lineStarts.length - 1;
+  for (let line = Math.max(start.line, 0); line <= end.line && line < lineCount; line++) {
+    let i = segments.lineStarts[line];
+    const stop = segments.lineStarts[line + 1];
+    if (line === start.line) {
+      let hi = stop;
+      while (i < hi) {
+        const mid = i + hi >> 1;
+        if (segments.columns[mid] < start.column) i = mid + 1;
+        else hi = mid;
+      }
+    }
+    for (; i < stop; i++) {
+      if (line === end.line && segments.columns[i] >= end.column) return;
+      if (visit(i)) return;
+    }
+  }
+}
+function lineStarts(text) {
+  const starts = [0];
+  for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) starts.push(i + 1);
+  return starts;
+}
+function offsetToPosition(starts, offset) {
+  let lo = 0;
+  let hi = starts.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (starts[mid] <= offset) lo = mid;
+    else hi = mid - 1;
+  }
+  return { line: lo, column: offset - starts[lo] };
+}
+function sourceMappingUrl(script) {
+  const tail = script.slice(-4096);
+  const matches = [...tail.matchAll(/(?:\/\/|\/\*)[#@]\s*sourceMappingURL=([^\s*'"]+)/g)];
+  return matches.length ? matches[matches.length - 1][1] : null;
+}
+function decodeDataUrl(url) {
+  const m = /^data:([^,]*?)(;base64)?,(.*)$/s.exec(url);
+  if (!m) return null;
+  try {
+    if (!m[2]) return decodeURIComponent(m[3]);
+    const binary = globalThis.atob(m[3]);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+    return new TextDecoder().decode(bytes);
+  } catch {
+    return null;
+  }
+}
+function normalizeSourcePath(source) {
+  let s = source.replace(/[?#].*$/, "");
+  s = s.replace(/^webpack:\/\/[^/]*\//, "").replace(/^webpack:\/\//, "");
+  s = s.replace(/^(?:vite|rollup|turbopack|ng):\/*/, "");
+  s = s.replace(/^\[project\]\//, "");
+  s = s.replace(/^file:\/\//, "");
+  s = s.replace(/^\/@fs\//, "/");
+  s = s.replace(/^\/@id\//, "");
+  try {
+    s = decodeURIComponent(s);
+  } catch {
+  }
+  s = s.replace(/\\/g, "/");
+  if (/^\/[A-Za-z]:\//.test(s)) s = s.slice(1);
+  s = s.replace(/(^|\/)\.\//g, "$1");
+  return s;
+}
+
+// ../core/src/code-reach.ts
+var MAX_CODE_REACH_FILES = 2e3;
+function scriptText(source) {
+  return { length: source.length, starts: Uint32Array.from(lineStarts(source)) };
+}
+var textOf = (entry, text) => text ?? (entry.source === void 0 ? void 0 : scriptText(entry.source));
+function executedFunctionRanges(entry, length, all = false) {
+  length ??= entry.source?.length ?? Number.POSITIVE_INFINITY;
+  const out = [];
+  entry.functions.forEach((fn, i) => {
+    const whole = fn.ranges[0];
+    if (!whole || !all && whole.count <= 0) return;
+    const topLevel = whole.startOffset === 0 && (whole.endOffset >= length || i === 0 && fn.functionName === "");
+    if (topLevel) return;
+    out.push({ start: whole.startOffset, end: whole.endOffset });
+  });
+  return out;
+}
+function scriptRan(entry, text) {
+  return executedFunctionRanges(entry, text?.length).length > 0;
+}
+function reachedFunctionLines(entry, map, text) {
+  return functionLines(entry, map, text, false);
+}
+function knownFunctionLines(entry, map, text) {
+  return functionLines(entry, map, text, true);
+}
+function functionLines(entry, map, text, all) {
+  const out = /* @__PURE__ */ new Map();
+  const read = textOf(entry, text);
+  const ranges = executedFunctionRanges(entry, read?.length, all);
+  if (!ranges.length || !read) return out;
+  const add = (source, range) => {
+    const list = out.get(source);
+    if (list) list.push(range);
+    else out.set(source, [range]);
+  };
+  const starts = read.starts;
+  for (const range of ranges) {
+    const start = offsetToPosition(starts, range.start);
+    if (!map) {
+      const last = offsetToPosition(starts, Math.max(range.start, range.end - 1));
+      add(-1, [start.line + 1, last.line + 1]);
+      continue;
+    }
+    const at = map.originalAt(start.line, start.column);
+    if (at === null) continue;
+    const end = offsetToPosition(starts, range.end);
+    const first = map.firstOriginalLineBetween(at.source, start, end);
+    if (first === null) continue;
+    const header = first === at.line || first === at.line + 1 ? at.line : first;
+    const lines = map.originalLinesBetween(at.source, start, end, header);
+    if (lines) add(at.source, [header + 1, lines[1] + 1]);
+  }
+  return out;
+}
+function finalizeCodeReach(files) {
+  const out = /* @__PURE__ */ new Set();
+  for (const raw of files) {
+    const file = normalizeCoveragePath(raw);
+    if (file !== null) out.add(file);
+  }
+  return [...out].sort().slice(0, MAX_CODE_REACH_FILES);
+}
+
 // src/internal/capture/inspect-on-failure.ts
 function isCi(ci) {
   return ci !== void 0 && ci !== "" && ci !== "false";
@@ -3909,7 +4343,45 @@ 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";
+  const browser = process.env[PIWI_ENV_KEYS.coverageBrowser];
+  return process.env[PIWI_ENV_KEYS.captureCodeReach] === "true" || browser === "files" || browser === "functions";
+}
+function browserFunctionsInWorker() {
+  return process.env[PIWI_ENV_KEYS.coverageBrowser] === "functions";
+}
+function browserFunctionCoverage(files) {
+  return sanitizeCoverage({
+    v: 1,
+    files: [...files].map(([path14, functions]) => ({ path: path14, runtime: "browser", functions }))
+  });
+}
+function newKnownFunctions(known, sent) {
+  const parts = [];
+  let files = [];
+  let budget = MAX_COVERAGE_RANGES;
+  const close = () => {
+    if (files.length > 0) parts.push({ v: 1, files: files.sort((a, b) => a.path < b.path ? -1 : 1) });
+    files = [];
+    budget = MAX_COVERAGE_RANGES;
+  };
+  for (const [raw, ranges] of known) {
+    const path14 = normalizeCoveragePath(raw);
+    if (path14 === null) continue;
+    let named = sent.get(path14);
+    let fresh = normalizeFunctionRanges(ranges).filter((range) => !named?.has(`${range[0]}:${range[1]}`));
+    if (fresh.length === 0) continue;
+    if (!named) sent.set(path14, named = /* @__PURE__ */ new Set());
+    for (const range of fresh) named.add(`${range[0]}:${range[1]}`);
+    while (fresh.length > 0) {
+      if (budget === 0 || files.length >= MAX_COVERAGE_FILES) close();
+      const part = fresh.slice(0, budget);
+      fresh = fresh.slice(part.length);
+      budget -= part.length;
+      files.push({ path: path14, allFunctions: part });
+    }
+  }
+  close();
+  return parts;
 }
 function serverCoverageInWorker() {
   return isServerGranularity(process.env[PIWI_ENV_KEYS.coverageServer]);
@@ -3971,320 +4443,95 @@ var path8 = __toESM(require("path"));
 var CANDIDATE_OFFSETS = ["..", "../../.."];
 function findOwnPackageJson(fromDir) {
   for (const offset of CANDIDATE_OFFSETS) {
-    try {
-      const pkgPath = path8.resolve(fromDir, offset, "package.json");
-      const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
-      const { name, version } = pkg;
-      if (name === "@piwitests/reporter" && typeof version === "string")
-        return { version, root: path8.dirname(pkgPath) };
-    } catch {
-    }
-  }
-  return void 0;
-}
-
-// src/internal/capture/quiet-capture.ts
-var BOXED_PREFIX_EXPORTS = [
-  [
-    "playwright-core/lib/coreBundle",
-    (mod) => mod?.utils?.setBoxedStackPrefixes
-  ],
-  ["playwright-core/lib/utils", (mod) => mod?.setBoxedStackPrefixes]
-];
-var boxing;
-var resolvedPlaywrightPackageJson;
-function resolvePlaywrightPackageJson() {
-  if (resolvedPlaywrightPackageJson !== void 0) return resolvedPlaywrightPackageJson;
-  try {
-    const testPackageJson = (0, import_node_module.createRequire)(__filename).resolve("@playwright/test/package.json");
-    resolvedPlaywrightPackageJson = (0, import_node_module.createRequire)(testPackageJson).resolve("playwright/package.json");
-  } catch {
-    resolvedPlaywrightPackageJson = null;
-  }
-  return resolvedPlaywrightPackageJson;
-}
-function resolveBoxing() {
-  try {
-    const root = findOwnPackageJson(__dirname)?.root;
-    if (!root) return null;
-    const playwrightPackageJson = resolvePlaywrightPackageJson();
-    if (!playwrightPackageJson) return null;
-    const requireFromPlaywright = (0, import_node_module.createRequire)(playwrightPackageJson);
-    for (const [moduleId, pick] of BOXED_PREFIX_EXPORTS) {
-      let set;
-      try {
-        set = pick(requireFromPlaywright(moduleId));
-      } catch {
-        continue;
-      }
-      if (typeof set !== "function") continue;
-      return {
-        set,
-        prefixes: [path9.dirname(playwrightPackageJson), path9.join(root, "dist") + path9.sep]
-      };
-    }
-  } catch {
-  }
-  return null;
-}
-function boxCaptureFrames(extraPrefixes = []) {
-  const first = boxing === void 0;
-  if (first) boxing = resolveBoxing();
-  if (!boxing) return;
-  const added = extraPrefixes.filter((prefix) => !boxing.prefixes.includes(prefix));
-  if (!first && added.length === 0) return;
-  boxing.prefixes.push(...added);
-  try {
-    boxing.set([...boxing.prefixes]);
-  } catch {
-  }
-}
-function internalCall(owner, run) {
-  const wrap = owner?._wrapApiCall;
-  if (typeof wrap !== "function") return run();
-  return wrap.call(owner, run, { internal: true, title: "Piwi capture" });
-}
-
-// src/internal/capture/code-reach.ts
-var crypto2 = __toESM(require("crypto"));
-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);
-for (let i = 0; i < BASE64.length; i++) BASE64_VALUE[BASE64.charCodeAt(i)] = i;
-function decodeMappings(mappings, sourceBase) {
-  const lines = [];
-  let current = { columns: [], sources: [] };
-  let column = 0;
-  let source = 0;
-  const fields = [];
-  let value = 0;
-  let shift = 0;
-  const flush = () => {
-    if (fields.length === 0) return;
-    column += fields[0];
-    if (fields.length >= 4) {
-      source += fields[1];
-      current.columns.push(column);
-      current.sources.push(sourceBase + source);
-    } else {
-      current.columns.push(column);
-      current.sources.push(-1);
-    }
-    fields.length = 0;
-  };
-  for (let i = 0; i <= mappings.length; i++) {
-    const ch = i < mappings.length ? mappings.charCodeAt(i) : 59;
-    if (ch === 59 || ch === 44) {
-      flush();
-      if (ch === 59) {
-        lines.push(current);
-        current = { columns: [], sources: [] };
-        column = 0;
-      }
-      continue;
-    }
-    const digit = ch < 128 ? BASE64_VALUE[ch] : -1;
-    if (digit < 0) continue;
-    value += (digit & 31) << shift;
-    if (digit & 32) {
-      shift += 5;
-      continue;
-    }
-    fields.push(value & 1 ? -(value >>> 1) : value >>> 1);
-    value = 0;
-    shift = 0;
-  }
-  for (const line of lines) {
-    if (line.columns.every((c, i) => i === 0 || c >= line.columns[i - 1])) continue;
-    const order = line.columns.map((_, i) => i).sort((a, b) => line.columns[a] - line.columns[b]);
-    line.columns = order.map((i) => line.columns[i]);
-    line.sources = order.map((i) => line.sources[i]);
-  }
-  return lines;
-}
-function joinRoot(root, source) {
-  if (!root || /^[a-z][\w+.-]*:/i.test(source) || source.startsWith("/")) return source;
-  return root.endsWith("/") ? root + source : `${root}/${source}`;
-}
-function decodeSourceMap(raw) {
-  const sources = [];
-  const lines = [];
-  const add = (map, lineOffset, columnOffset) => {
-    if (map.sections) {
-      for (const section of map.sections) {
-        if (!add(section.map, section.offset.line, section.offset.column)) return false;
-      }
-      return true;
-    }
-    if (typeof map.mappings !== "string" || !Array.isArray(map.sources)) return false;
-    const base = sources.length;
-    for (const s of map.sources) sources.push(joinRoot(map.sourceRoot, s ?? ""));
-    decodeMappings(map.mappings, base).forEach((segments, i) => {
-      const at = lineOffset + i;
-      const shifted = i === 0 && columnOffset ? segments.columns.map((c) => c + columnOffset) : segments.columns;
-      const existing = lines[at];
-      if (!existing) lines[at] = { columns: shifted, sources: segments.sources };
-      else {
-        existing.columns.push(...shifted);
-        existing.sources.push(...segments.sources);
-      }
-    });
-    return true;
-  };
-  if (raw.version !== void 0 && raw.version !== 3) return null;
-  if (!add(raw, 0, 0)) return null;
-  return {
-    sources,
-    sourceAt(line, column) {
-      const segments = lines[line];
-      if (!segments || segments.columns.length === 0) return null;
-      let lo = 0;
-      let hi = segments.columns.length - 1;
-      if (segments.columns[0] > column) return null;
-      while (lo < hi) {
-        const mid = lo + hi + 1 >> 1;
-        if (segments.columns[mid] <= column) lo = mid;
-        else hi = mid - 1;
-      }
-      const source = segments.sources[lo];
-      return source < 0 ? null : source;
-    },
-    mapsBetween(source, start, end) {
-      for (let line = start.line; line <= end.line && line < lines.length; line++) {
-        const segments = lines[line];
-        if (!segments) continue;
-        let i = 0;
-        if (line === start.line) {
-          let hi = segments.columns.length;
-          while (i < hi) {
-            const mid = i + hi >> 1;
-            if (segments.columns[mid] < start.column) i = mid + 1;
-            else hi = mid;
-          }
-        }
-        for (; i < segments.columns.length; i++) {
-          if (line === end.line && segments.columns[i] >= end.column) return false;
-          if (segments.sources[i] === source) return true;
-        }
-      }
-      return false;
-    }
-  };
-}
-function lineStarts(text) {
-  const starts = [0];
-  for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) starts.push(i + 1);
-  return starts;
-}
-function offsetToPosition(starts, offset) {
-  let lo = 0;
-  let hi = starts.length - 1;
-  while (lo < hi) {
-    const mid = lo + hi + 1 >> 1;
-    if (starts[mid] <= offset) lo = mid;
-    else hi = mid - 1;
+    try {
+      const pkgPath = path8.resolve(fromDir, offset, "package.json");
+      const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
+      const { name, version } = pkg;
+      if (name === "@piwitests/reporter" && typeof version === "string")
+        return { version, root: path8.dirname(pkgPath) };
+    } catch {
+    }
   }
-  return { line: lo, column: offset - starts[lo] };
-}
-function sourceMappingUrl(script) {
-  const tail = script.slice(-4096);
-  const matches = [...tail.matchAll(/(?:\/\/|\/\*)[#@]\s*sourceMappingURL=([^\s*'"]+)/g)];
-  return matches.length ? matches[matches.length - 1][1] : null;
+  return void 0;
 }
-function decodeDataUrl(url) {
-  const m = /^data:([^,]*?)(;base64)?,(.*)$/s.exec(url);
-  if (!m) return null;
+
+// src/internal/capture/quiet-capture.ts
+var BOXED_PREFIX_EXPORTS = [
+  [
+    "playwright-core/lib/coreBundle",
+    (mod) => mod?.utils?.setBoxedStackPrefixes
+  ],
+  ["playwright-core/lib/utils", (mod) => mod?.setBoxedStackPrefixes]
+];
+var boxing;
+var resolvedPlaywrightPackageJson;
+function resolvePlaywrightPackageJson() {
+  if (resolvedPlaywrightPackageJson !== void 0) return resolvedPlaywrightPackageJson;
   try {
-    if (!m[2]) return decodeURIComponent(m[3]);
-    const binary = globalThis.atob(m[3]);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
-    return new TextDecoder().decode(bytes);
+    const testPackageJson = (0, import_node_module.createRequire)(__filename).resolve("@playwright/test/package.json");
+    resolvedPlaywrightPackageJson = (0, import_node_module.createRequire)(testPackageJson).resolve("playwright/package.json");
   } catch {
-    return null;
+    resolvedPlaywrightPackageJson = null;
   }
+  return resolvedPlaywrightPackageJson;
 }
-function normalizeSourcePath(source) {
-  let s = source.replace(/[?#].*$/, "");
-  s = s.replace(/^webpack:\/\/[^/]*\//, "").replace(/^webpack:\/\//, "");
-  s = s.replace(/^(?:vite|rollup|turbopack|ng):\/*/, "");
-  s = s.replace(/^\[project\]\//, "");
-  s = s.replace(/^file:\/\//, "");
-  s = s.replace(/^\/@fs\//, "/");
-  s = s.replace(/^\/@id\//, "");
+function resolveBoxing() {
   try {
-    s = decodeURIComponent(s);
+    const root = findOwnPackageJson(__dirname)?.root;
+    if (!root) return null;
+    const playwrightPackageJson = resolvePlaywrightPackageJson();
+    if (!playwrightPackageJson) return null;
+    const requireFromPlaywright = (0, import_node_module.createRequire)(playwrightPackageJson);
+    for (const [moduleId, pick] of BOXED_PREFIX_EXPORTS) {
+      let set;
+      try {
+        set = pick(requireFromPlaywright(moduleId));
+      } catch {
+        continue;
+      }
+      if (typeof set !== "function") continue;
+      return {
+        set,
+        prefixes: [path9.dirname(playwrightPackageJson), path9.join(root, "dist") + path9.sep]
+      };
+    }
   } catch {
   }
-  s = s.replace(/\\/g, "/");
-  if (/^\/[A-Za-z]:\//.test(s)) s = s.slice(1);
-  s = s.replace(/(^|\/)\.\//g, "$1");
-  return s;
-}
-
-// ../core/src/code-reach.ts
-var MAX_CODE_REACH_FILES = 2e3;
-function executedFunctionRanges(entry) {
-  const length = entry.source?.length ?? Number.POSITIVE_INFINITY;
-  const out = [];
-  entry.functions.forEach((fn, i) => {
-    const whole = fn.ranges[0];
-    if (!whole || whole.count <= 0) return;
-    const topLevel = whole.startOffset === 0 && (whole.endOffset >= length || i === 0 && fn.functionName === "");
-    if (topLevel) return;
-    out.push({ start: whole.startOffset, end: whole.endOffset });
-  });
-  return out;
-}
-function executedFunctionOffsets(entry) {
-  return executedFunctionRanges(entry).map((range) => range.start);
-}
-function scriptRan(entry) {
-  return executedFunctionOffsets(entry).length > 0;
+  return null;
 }
-function reachedSources(entry, map) {
-  const ranges = executedFunctionRanges(entry);
-  const reached = /* @__PURE__ */ new Set();
-  if (!ranges.length || entry.source === void 0) return reached;
-  const starts = lineStarts(entry.source);
-  for (const range of ranges) {
-    const start = offsetToPosition(starts, range.start);
-    const source = map.sourceAt(start.line, start.column);
-    if (source === null || reached.has(source)) continue;
-    if (map.mapsBetween(source, start, offsetToPosition(starts, range.end))) reached.add(source);
+function boxCaptureFrames(extraPrefixes = []) {
+  const first = boxing === void 0;
+  if (first) boxing = resolveBoxing();
+  if (!boxing) return;
+  const added = extraPrefixes.filter((prefix) => !boxing.prefixes.includes(prefix));
+  if (!first && added.length === 0) return;
+  boxing.prefixes.push(...added);
+  try {
+    boxing.set([...boxing.prefixes]);
+  } catch {
   }
-  return reached;
 }
-function finalizeCodeReach(files) {
-  const out = /* @__PURE__ */ new Set();
-  for (const raw of files) {
-    const file = normalizeCoveragePath(raw);
-    if (file !== null) out.add(file);
-  }
-  return [...out].sort().slice(0, MAX_CODE_REACH_FILES);
+function callMethod(target, prop, args) {
+  return target[prop](...args);
+}
+function internalCall(owner, run) {
+  const wrap = owner?._wrapApiCall;
+  if (typeof wrap !== "function") return run();
+  return wrap.call(owner, run, { internal: true, title: "Piwi capture" });
 }
 
 // src/internal/capture/code-reach.ts
+var crypto2 = __toESM(require("crypto"));
+var fs6 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
+var import_node_child_process = require("child_process");
 var MAX_MAP_BYTES = 20 * 1024 * 1024;
 var MAP_TIMEOUT_MS = 5e3;
 var SOURCE_EXTENSIONS = /\.(?:[cm]?[jt]sx?|vue|svelte|astro|marko|html?)$/i;
 var REPLAYED_SCRIPT = /^(?:about|rsc):/i;
+var NEVER_REACHED = /\/node_modules\/|\/@vite\//;
 var BUILD_DIRS = /(?:^|\/)(?:dist|build|out|\.output|\.next|\.nuxt|\.svelte-kit|public|static|wwwroot)\//;
-var MAX_CACHED_SCRIPTS = 500;
+var MAX_CACHED_SCRIPTS = 4e3;
 var LatestByUrl = class {
   constructor() {
     this.entries = /* @__PURE__ */ new Map();
@@ -4324,8 +4571,32 @@ function repositoryRoot(from) {
 }
 function codeReachRoots(configDir, configured) {
   const repoRoot = repositoryRoot(configDir);
-  const roots = configured?.length ? configured.map((r) => path10.resolve(configDir, r)) : [configDir];
-  return { roots: [.../* @__PURE__ */ new Set([...roots, repoRoot])], repoRoot };
+  const resolve3 = (dirs) => (Array.isArray(dirs) ? dirs : dirs ? [dirs] : []).filter(Boolean).map((r) => path10.resolve(configDir, r));
+  const global = Array.isArray(configured) ? resolve3(configured) : resolve3(configured?.["*"]);
+  const byOrigin = /* @__PURE__ */ new Map();
+  if (configured && !Array.isArray(configured)) {
+    for (const [key, dirs] of Object.entries(configured)) {
+      const origin = key === "*" ? null : originOf2(key);
+      const resolved = resolve3(dirs);
+      if (origin && resolved.length) byOrigin.set(origin, resolved);
+    }
+  }
+  const roots = global.length ? global : [configDir];
+  return { roots: [.../* @__PURE__ */ new Set([...roots, repoRoot])], byOrigin, repoRoot };
+}
+function originOf2(url) {
+  if (!url) return null;
+  try {
+    const origin = new URL(url).origin;
+    return origin === "null" ? null : origin;
+  } catch {
+    return null;
+  }
+}
+function scriptRoots(roots, scriptUrl, pageUrl) {
+  if (!roots.byOrigin?.size) return roots.roots;
+  const own = roots.byOrigin.get(originOf2(scriptUrl) ?? "") ?? roots.byOrigin.get(originOf2(pageUrl) ?? "");
+  return own ? [.../* @__PURE__ */ new Set([...own, ...roots.roots])] : roots.roots;
 }
 function isFile(file) {
   try {
@@ -4409,50 +4680,96 @@ async function resolveScript(entry, roots, bases, fetchMap) {
   const version = scriptVersion(entry);
   const cached = scriptCache.get(entry.url, version);
   if (cached) return cached;
-  const file = fileForUrl(entry.url, roots.roots, bases);
+  const file = fileForUrl(entry.url, roots, bases);
   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);
+  const text = entry.source === void 0 ? void 0 : scriptText(entry.source);
+  if (file) resolution = { kind: "file", file, lookup, text };
+  else resolution = lookup ? { kind: "map", lookup, files: [], text } : { kind: "none" };
+  if (text) 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 };
+function textOf2(entry, resolution) {
+  return resolution.text ?? (entry.source === void 0 ? void 0 : scriptText(entry.source));
+}
+async function resolveCodeReach(entries, roots, fetchMap, pageUrl) {
+  return finalizeCodeReach((await resolveReach(entries, roots, fetchMap, pageUrl)).keys());
 }
-async function resolveCodeReach(entries, roots, fetchMap) {
-  const files = /* @__PURE__ */ new Set();
+async function resolveCodeReachFunctions(entries, roots, fetchMap, pageUrl, options = {}) {
+  return resolveFunctions(entries, roots, fetchMap, pageUrl, options.known === true);
+}
+async function resolveReach(entries, roots, fetchMap, pageUrl) {
+  return (await resolveFunctions(entries, roots, fetchMap, pageUrl, false)).reached;
+}
+var knownCache = new LatestByUrl();
+async function resolveFunctions(entries, roots, fetchMap, pageUrl, withKnown) {
+  const files = /* @__PURE__ */ new Map();
+  const known = /* @__PURE__ */ new Map();
+  const addTo = (into, file, functions) => {
+    const path14 = relativeToRepo(file, roots.repoRoot);
+    const listed = into.get(path14);
+    if (listed) listed.push(...functions);
+    else into.set(path14, [...functions]);
+  };
+  const add = (file, functions) => addTo(files, file, functions);
   const bases = viteBases(entries);
   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)));
+  const cached = 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);
+    const dirs = scriptRoots(roots, covered.url, covered.pageUrl ?? pageUrl);
+    const resolution = cached[i] ?? await resolveScript(covered, dirs, bases, fetchMap);
+    const mapFile = (resolved, index) => {
+      if (resolved.files[index] === void 0) {
+        const source = resolved.lookup.sources[index] ?? "";
+        let absolute = resolveSourcePath(source, dirs);
+        if (!absolute && !/^[a-z][\w+.-]*:/i.test(source)) {
+          try {
+            absolute = fileForUrl(new URL(source, covered.url).href, dirs, bases);
+          } catch {
+            absolute = null;
+          }
+        }
+        resolved.files[index] = absolute;
+      }
+      return resolved.files[index] ?? null;
+    };
     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));
+      if (!resolution.file) continue;
+      const text = textOf2(covered, resolution);
+      if (resolution.lookup) {
+        const reached = reachedFunctionLines(covered, resolution.lookup, text);
+        if (reached.size > 0) add(resolution.file, [...reached.values()].flat());
+      } else if (scriptRan(covered, text)) {
+        add(resolution.file, reachedFunctionLines(covered, null, text).get(-1) ?? []);
+      }
     } 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] ?? "";
-          let absolute = resolveSourcePath(source, roots.roots);
-          if (!absolute && !/^[a-z][\w+.-]*:/i.test(source)) {
-            try {
-              absolute = fileForUrl(new URL(source, entry.url).href, roots.roots, bases);
-            } catch {
-              absolute = null;
-            }
-          }
-          resolution.files[index] = absolute;
+      for (const [index, functions] of reachedFunctionLines(covered, resolution.lookup, textOf2(covered, resolution))) {
+        const file = mapFile(resolution, index);
+        if (file) add(file, functions);
+      }
+    }
+    if (!withKnown || resolution.kind === "none") continue;
+    const version = scriptVersion(covered);
+    let listed = knownCache.get(covered.url, version);
+    if (!listed || listed.count < covered.functions.length) {
+      const byFile = /* @__PURE__ */ new Map();
+      const text = textOf2(covered, resolution);
+      if (resolution.kind === "file" && resolution.file) {
+        const lines = knownFunctionLines(covered, resolution.lookup, text);
+        const all = resolution.lookup ? [...lines.values()].flat() : lines.get(-1) ?? [];
+        if (all.length > 0) byFile.set(resolution.file, all);
+      } else if (resolution.kind === "map") {
+        for (const [index, functions] of knownFunctionLines(covered, resolution.lookup, text)) {
+          const file = mapFile(resolution, index);
+          if (file) byFile.set(file, [...byFile.get(file) ?? [], ...functions]);
         }
-        const file = resolution.files[index];
-        if (file) files.add(relativeToRepo(file, roots.repoRoot));
       }
+      listed = { count: covered.functions.length, files: byFile };
+      knownCache.set(covered.url, version, listed);
     }
+    for (const [file, functions] of listed.files) addTo(known, file, functions);
   }
-  return finalizeCodeReach(files);
+  return { reached: files, known };
 }
 function pageMapFetcher(page) {
   return async (url) => {
@@ -4476,12 +4793,57 @@ function isChromiumPage(page) {
   }
 }
 var captures = /* @__PURE__ */ new WeakMap();
+var MARK_WORLD = "piwi-code-reach";
+var MARK_FUNCTION = "piwiCodeReachMark";
+var MARK_SOURCE = `addEventListener('beforeunload', function ${MARK_FUNCTION}() {});`;
+var markedDocuments = /* @__PURE__ */ new WeakMap();
+function marksOf(page) {
+  let marks = markedDocuments.get(page);
+  if (!marks) {
+    marks = /* @__PURE__ */ new Set();
+    markedDocuments.set(page, marks);
+  }
+  return marks;
+}
+async function markCurrentDocument(page, cdp) {
+  try {
+    const { frameTree } = await internalCall(page, () => cdp.send("Page.getFrameTree"));
+    const marks = marksOf(page);
+    if (marks.has(frameTree.frame.loaderId)) return;
+    const world = await internalCall(
+      page,
+      () => cdp.send("Page.createIsolatedWorld", { frameId: frameTree.frame.id, worldName: MARK_WORLD })
+    );
+    await internalCall(
+      page,
+      () => cdp.send("Runtime.evaluate", { expression: MARK_SOURCE, contextId: world.executionContextId })
+    );
+    marks.add(frameTree.frame.loaderId);
+  } catch {
+  }
+}
+function onPaused(page, capture, event) {
+  const leaving = event.reason === "EventListener" && event.data?.eventName === "listener:beforeunload" && (event.callFrames?.[0]?.functionName ?? MARK_FUNCTION) === MARK_FUNCTION;
+  const read = leaving ? readCoverage(page, capture.cdp) : null;
+  if (read) {
+    const merging = read.then(
+      (coverage) => mergeCoverageRead(capture.ran, capture.scripts, coverage, capture.keepIdle)
+    );
+    capture.reading.add(merging);
+    void merging.finally(() => capture.reading.delete(merging));
+  }
+  void (read ?? Promise.resolve()).finally(() => {
+    internalCall(page, () => capture.cdp.send("Debugger.resume")).catch(() => {
+    });
+  });
+}
 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 });
+  capture.scripts.set(event.scriptId, { url: event.url, hash: event.hash, pageUrl: capture.pageUrl });
+  if (NEVER_REACHED.test(event.url)) return;
   const key = versionKey(event.url, event.hash);
   if (capture.sources.has(key) || scriptCache.get(event.url, event.hash)) return;
   const source = internalCall(
@@ -4496,6 +4858,44 @@ function onScriptParsed(page, capture, event) {
   );
   capture.sources.set(key, source);
 }
+var READ_WAIT_MS = 5e3;
+function readCoverage(page, cdp) {
+  let timer;
+  const late = new Promise((resolve3) => {
+    timer = setTimeout(() => resolve3([]), READ_WAIT_MS);
+  });
+  const taken = internalCall(page, () => cdp.send("Profiler.takePreciseCoverage")).then(
+    (answer) => answer.result,
+    () => []
+  );
+  return Promise.race([taken, late]).finally(() => clearTimeout(timer));
+}
+function mergeCoverageRead(ran, scripts, read, keepIdle = true) {
+  for (const covered of read) {
+    const script = scripts.get(covered.scriptId);
+    if (!script) continue;
+    const key = versionKey(script.url, script.hash);
+    let known = ran.get(key);
+    if (!known) {
+      known = { script, functions: [], byRange: /* @__PURE__ */ new Map() };
+      ran.set(key, known);
+    }
+    for (const fn of covered.functions) {
+      const whole = fn.ranges[0];
+      if (!whole) continue;
+      if (!keepIdle && whole.count <= 0) continue;
+      const range = `${whole.startOffset}:${whole.endOffset}`;
+      const seen = known.byRange.get(range);
+      if (seen) {
+        if (whole.count > 0 && seen.ranges[0].count <= 0) seen.ranges[0].count = whole.count;
+        continue;
+      }
+      const copy = { ...fn, ranges: fn.ranges.map((r) => ({ ...r })) };
+      known.byRange.set(range, copy);
+      known.functions.push(copy);
+    }
+  }
+}
 async function detach(page, cdp) {
   try {
     await internalCall(page, () => cdp.detach());
@@ -4507,21 +4907,35 @@ async function startCodeReach(page) {
   let cdp = null;
   try {
     cdp = await internalCall(page, () => page.context().newCDPSession(page));
-    const capture = { cdp, scripts: /* @__PURE__ */ new Map(), sources: /* @__PURE__ */ new Map() };
+    const capture = {
+      cdp,
+      scripts: /* @__PURE__ */ new Map(),
+      sources: /* @__PURE__ */ new Map(),
+      ran: /* @__PURE__ */ new Map(),
+      keepIdle: browserFunctionsInWorker(),
+      reading: /* @__PURE__ */ new Set(),
+      pageUrl: page.url()
+    };
+    const marks = marksOf(page);
     cdp.on("Debugger.scriptParsed", (event) => onScriptParsed(page, capture, event));
-    cdp.on("Debugger.paused", () => {
-      internalCall(page, () => capture.cdp.send("Debugger.resume")).catch(() => {
-      });
+    cdp.on("Debugger.paused", (event) => onPaused(page, capture, event));
+    cdp.on("Page.frameNavigated", (event) => {
+      if (event.frame.parentId) return;
+      marks.add(event.frame.loaderId);
+      capture.pageUrl = event.frame.url;
     });
     await internalCall(
       page,
       () => 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 })
+        capture.cdp.send("Profiler.startPreciseCoverage", { callCount: false, detailed: false }),
+        capture.cdp.send("Page.enable"),
+        capture.cdp.send("Page.addScriptToEvaluateOnNewDocument", { source: MARK_SOURCE, worldName: MARK_WORLD }),
+        capture.cdp.send("DOMDebugger.setEventListenerBreakpoint", { eventName: "beforeunload" })
       ])
     );
+    await markCurrentDocument(page, capture.cdp);
     captures.set(page, capture);
     return true;
   } catch {
@@ -4535,17 +4949,17 @@ async function stopCodeReach(page) {
   captures.delete(page);
   const { cdp } = capture;
   try {
-    const coverage = await internalCall(page, async () => {
+    const last = await internalCall(page, async () => {
       const taken = await cdp.send("Profiler.takePreciseCoverage");
       await cdp.send("Profiler.stopPreciseCoverage");
-      return taken;
+      return taken.result;
     });
+    await Promise.all(capture.reading);
+    mergeCoverageRead(capture.ran, capture.scripts, last, capture.keepIdle);
     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));
+    for (const [key, { script, functions }] of capture.ran) {
+      const entry = { url: script.url, hash: script.hash, functions, pageUrl: script.pageUrl };
+      const source = await capture.sources.get(key);
       if (source != null) entry.source = source;
       entries.push(entry);
     }
@@ -5522,6 +5936,143 @@ function readPageInteraction() {
   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;
@@ -5581,51 +6132,89 @@ function createSink() {
     userPick: null,
     pause: null,
     locatorPages: new LocatorPageLog(),
-    codeReach: null,
-    serverCoverage: /* @__PURE__ */ new Map()
+    codeReach: { sessions: /* @__PURE__ */ new Map(), files: /* @__PURE__ */ new Map(), known: /* @__PURE__ */ new Map() },
+    serverCoverage: /* @__PURE__ */ new Map(),
+    baseURL: null
   };
 }
-function maybeStartCodeReach(page) {
+var MAX_CODE_REACH_PAGES = 16;
+var CODE_REACH_START_WAIT_MS = 2e3;
+function maybeStartCodeReach(page, alreadyOpen = false) {
   const sink = currentSink;
-  if (!sink || !browserCoverageInWorker()) return Promise.resolve(false);
-  if (sink.codeReach) return sink.codeReach.page === page ? sink.codeReach.started : Promise.resolve(false);
+  if (!sink || !browserCoverageInWorker() || isPageClosed(page)) return Promise.resolve(false);
+  const known = sink.codeReach.sessions.get(page);
+  if (known) return known.started;
+  if (alreadyOpen) {
+    let recording = 0;
+    for (const [other, session] of sink.codeReach.sessions) if (!session.stopped && !isPageClosed(other)) recording++;
+    if (recording >= MAX_CODE_REACH_PAGES) return Promise.resolve(false);
+  }
   const started = startCodeReach(page);
-  sink.codeReach = { page, started, stopped: false, files: null };
+  sink.codeReach.sessions.set(page, { started, stopped: false });
   return started;
 }
+async function startCodeReachOnOpenPages() {
+  if (!browserCoverageInWorker() || OPEN_PAGES.size === 0) return;
+  const started = Promise.all([...OPEN_PAGES].map((page) => maybeStartCodeReach(page, true)));
+  await Promise.race([started, new Promise((resolve3) => setTimeout(resolve3, CODE_REACH_START_WAIT_MS).unref())]);
+}
 function configuredCodeReachRoots() {
   const raw = process.env.PIWI_CODE_REACH_ROOTS?.trim();
   if (!raw) return null;
+  const dirs = (value) => (Array.isArray(value) ? value : [value]).filter((r) => typeof r === "string" && r !== "");
   try {
     const parsed2 = JSON.parse(raw);
-    if (Array.isArray(parsed2)) return parsed2.filter((r) => typeof r === "string" && r !== "");
+    if (Array.isArray(parsed2)) return dirs(parsed2);
+    if (parsed2 && typeof parsed2 === "object") {
+      return Object.fromEntries(Object.entries(parsed2).map(([origin, value]) => [origin, dirs(value)]));
+    }
   } catch {
   }
   return raw.split(path13.delimiter).filter(Boolean);
 }
 async function stopSinkCodeReach(sink, closing) {
-  const session = sink.codeReach;
-  if (!session || session.stopped) return;
-  if (closing && closing.page !== session.page && (!closing.context || pageContext(session.page) !== closing.context)) {
-    return;
+  const stopping = [];
+  const underway = [];
+  for (const [page, session] of sink.codeReach.sessions) {
+    if (session.stopped) {
+      if (!closing && session.stopping) underway.push(session.stopping);
+      continue;
+    }
+    if (closing && closing.page !== page && (!closing.context || pageContext(page) !== closing.context)) continue;
+    session.stopped = true;
+    stopping.push([page, session]);
   }
-  session.stopped = true;
-  try {
-    if (!await session.started || isPageClosed(session.page)) return;
-    const entries = await stopCodeReach(session.page);
-    if (!entries) return;
+  if (stopping.length > 0) {
     const info = sink.testInfo;
     const configFile = info?.config.configFile;
     const configDir = configFile ? path13.dirname(configFile) : info?.config.rootDir ?? process.cwd();
-    session.files = await resolveCodeReach(
-      entries,
-      codeReachRoots(configDir, configuredCodeReachRoots()),
-      pageMapFetcher(session.page)
-    );
+    const roots = codeReachRoots(configDir, configuredCodeReachRoots());
+    for (const [page, session] of stopping) {
+      session.stopping = stopPageCodeReach(sink, page, session, roots);
+      underway.push(session.stopping);
+    }
+  }
+  await Promise.all(underway);
+}
+async function stopPageCodeReach(sink, page, session, roots) {
+  try {
+    if (!await session.started || isPageClosed(page)) return;
+    const entries = await stopCodeReach(page);
+    if (!entries) return;
+    const { reached, known } = await resolveCodeReachFunctions(entries, roots, pageMapFetcher(page), page.url(), {
+      known: browserFunctionsInWorker()
+    });
+    for (const [file, functions] of reached) {
+      sink.codeReach.files.set(file, [...sink.codeReach.files.get(file) ?? [], ...functions]);
+    }
+    for (const [file, functions] of known) {
+      sink.codeReach.known.set(file, [...sink.codeReach.known.get(file) ?? [], ...functions]);
+    }
   } catch {
   }
 }
 var currentSink = null;
+var KNOWN_FUNCTIONS_SENT = /* @__PURE__ */ new Map();
 var PENDING_PROBES = /* @__PURE__ */ new Set();
 async function drainPendingProbes(capMs) {
   if (PENDING_PROBES.size === 0) return;
@@ -5922,6 +6511,7 @@ async function maybeOpenPicker(sink, closing) {
   applyPickToSnapshots(sink.capturedLocators, pick);
 }
 var INSTRUMENTED_PAGES = /* @__PURE__ */ new WeakSet();
+var OPEN_PAGES = /* @__PURE__ */ new Set();
 var INSTRUMENTED_CONTEXTS = /* @__PURE__ */ new WeakSet();
 var PATCHED_BROWSERS = /* @__PURE__ */ new WeakSet();
 var CHAIN_METHOD_SET = new Set(CHAIN_METHODS);
@@ -6037,9 +6627,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 });
@@ -6205,7 +6792,12 @@ var CANCELLED_REQUEST = /^net::ERR_ABORTED$|^NS_BINDING_ABORTED$|^NS_ERROR_ABORT
 function instrumentPage(page) {
   if (!page || INSTRUMENTED_PAGES.has(page)) return;
   INSTRUMENTED_PAGES.add(page);
+  if (typeof page.once === "function") {
+    OPEN_PAGES.add(page);
+    page.once("close", () => OPEN_PAGES.delete(page));
+  }
   void maybeStartCodeReach(page);
+  observeOwnApiRequests(page);
   const probeSink = currentSink;
   if (probeSink?.probeItem && !probeSink.probeInterception) {
     void installProbeInterception(page, probeSink.probeItem).then((interception) => {
@@ -6365,25 +6957,7 @@ function recordRequest(sink, request, end, 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 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 {
-          }
-        }
+        readResponseHeaders(sink, entry, url, response.headers());
       }
       sink.networkRequests.push(entry);
     } catch {
@@ -6391,6 +6965,48 @@ function recordRequest(sink, request, end, response) {
   })();
   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);
@@ -6404,6 +7020,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(() => {
     });
@@ -6515,10 +7132,24 @@ async function flushSink(sink, testInfo) {
     });
   }
   await stopSinkCodeReach(sink);
-  if (sink.codeReach?.files?.length) {
+  if (sink.codeReach.files.size > 0) {
     await testInfo.attach(ATTACHMENT_NAMES.codeReach, {
       contentType: "application/json",
-      body: Buffer.from(JSON.stringify(sink.codeReach.files))
+      body: Buffer.from(JSON.stringify(finalizeCodeReach(sink.codeReach.files.keys())))
+    });
+    const functions = browserFunctionsInWorker() ? browserFunctionCoverage(sink.codeReach.files) : null;
+    if (functions) {
+      await testInfo.attach(ATTACHMENT_NAMES.browserCoverage, {
+        contentType: "application/json",
+        body: Buffer.from(JSON.stringify(functions))
+      });
+    }
+  }
+  const known = browserFunctionsInWorker() ? newKnownFunctions(sink.codeReach.known, KNOWN_FUNCTIONS_SENT) : [];
+  for (const part of known) {
+    await testInfo.attach(ATTACHMENT_NAMES.browserFunctions, {
+      contentType: "application/json",
+      body: Buffer.from(JSON.stringify(part))
     });
   }
   if (sink.serverCoverage.size > 0) {
@@ -6658,14 +7289,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 {
@@ -6696,12 +7330,13 @@ 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 ({ screenshot }, 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) {
@@ -6731,6 +7366,7 @@ var piwiFixtures = {
       activeResourceLedger()?.testStarted(testInfo);
       currentSink = sink;
       try {
+        await startCodeReachOnOpenPages();
         await use();
       } finally {
         currentSink = null;