@piwitests/reporter 0.43.0 → 0.45.0

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

@@ -32,6 +32,7 @@ var capture_fixtures_exports = {};
 __export(capture_fixtures_exports, {
   CAPTURED_ATTRS_ARG: () => CAPTURED_ATTRS_ARG,
   LocatorPageLog: () => LocatorPageLog,
+  activeResourceLedger: () => activeResourceLedger,
   ariaSnapshotBestEffort: () => ariaSnapshotBestEffort,
   ariaSnapshotJSONBestEffort: () => ariaSnapshotJSONBestEffort,
   boxCaptureFrames: () => boxCaptureFrames,
@@ -44,15 +45,19 @@ __export(capture_fixtures_exports, {
   internalCall: () => internalCall,
   noteLocatorCall: () => noteLocatorCall,
   noteNavigation: () => noteNavigation,
+  noteResourceUse: () => noteResourceUse,
   pageMapFetcher: () => pageMapFetcher,
   piwiFixtures: () => piwiFixtures,
   probeElementAttrs: () => probeElementAttrs,
+  recordResourceCensus: () => recordResourceCensus,
   resolveCodeReach: () => resolveCodeReach,
   startCodeReach: () => startCodeReach,
-  stopCodeReach: () => stopCodeReach
+  startResourceLedger: () => startResourceLedger,
+  stopCodeReach: () => stopCodeReach,
+  stopResourceLedger: () => stopResourceLedger
 });
 module.exports = __toCommonJS(capture_fixtures_exports);
-var path10 = __toESM(require("path"));
+var path12 = __toESM(require("path"));
 var import_node_zlib2 = require("zlib");
 
 // ../picker-dom/src/probe.ts
@@ -134,7 +139,7 @@ function probeElementAttrs(el, arg) {
       };
       const roleMemo = /* @__PURE__ */ new Map();
       const textMemo = /* @__PURE__ */ new Map();
-      const roleOf = (n) => {
+      const roleOf2 = (n) => {
         const cached = roleMemo.get(n);
         if (cached !== void 0) return cached;
         let role;
@@ -157,7 +162,7 @@ function probeElementAttrs(el, arg) {
         const al = n.getAttribute("aria-level");
         return al && /^\d+$/.test(al) ? Number(al) : null;
       };
-      const targetRole = roleOf(el);
+      const targetRole = roleOf2(el);
       const targetLevel = targetRole === "heading" ? levelOf(el) : null;
       const nameOf = (n) => {
         const labelledBy = !!n.getAttribute("aria-labelledby");
@@ -217,7 +222,7 @@ function probeElementAttrs(el, arg) {
         let visibleRoleNameCount = 0;
         for (let i = 0; i < nodes.length; i++) {
           const n = nodes[i];
-          if (roleOf(n) !== targetRole) continue;
+          if (roleOf2(n) !== targetRole) continue;
           if (n === el) index = roleCountAll;
           roleCountAll++;
           if (targetLevel != null && levelOf(n) === targetLevel) levelCount++;
@@ -270,7 +275,7 @@ function probeElementAttrs(el, arg) {
         };
         const docRoleCount = (role) => {
           let c = 0;
-          for (let i = 0; i < nodes.length; i++) if (roleOf(nodes[i]) === role) c++;
+          for (let i = 0; i < nodes.length; i++) if (roleOf2(nodes[i]) === role) c++;
           return c;
         };
         const rawText = (n) => (n.textContent || "").replace(/\s+/g, " ").trim();
@@ -302,7 +307,7 @@ function probeElementAttrs(el, arg) {
           const needle = text.toLowerCase();
           let c = 0;
           for (let i = 0; i < nodes.length; i++) {
-            if (roleOf(nodes[i]) !== role) continue;
+            if (roleOf2(nodes[i]) !== role) continue;
             if (normText(nodes[i]).indexOf(needle) !== -1) c++;
           }
           return c;
@@ -327,7 +332,7 @@ function probeElementAttrs(el, arg) {
                 scopedRoleCount = 0;
                 for (let i = 0; i < scoped.length; i++) {
                   const n = scoped[i];
-                  if (roleOf(n) !== targetRole) continue;
+                  if (roleOf2(n) !== targetRole) continue;
                   if (targetLevel != null && levelOf(n) !== targetLevel) continue;
                   scopedRoleCount++;
                 }
@@ -675,7 +680,7 @@ function showAnchorPicker(arg) {
   }
   const Z = 2147483600;
   const { tagRoles, inputRoles, roleSources, leafRole, leafLevel, leafTestId } = arg;
-  const roleOf = (n) => {
+  const roleOf2 = (n) => {
     const explicit = n.getAttribute && n.getAttribute("role");
     if (explicit) return explicit;
     const tag = (n.tagName || "").toLowerCase();
@@ -698,7 +703,7 @@ function showAnchorPicker(arg) {
       let matched = 0;
       for (let i = 0; i < nodes.length; i++) {
         const n = nodes[i];
-        if (roleOf(n) !== leafRole) continue;
+        if (roleOf2(n) !== leafRole) continue;
         if (leafLevel != null && levelOf(n) !== leafLevel) continue;
         matched++;
       }
@@ -731,7 +736,7 @@ function showAnchorPicker(arg) {
     const testId = node.getAttribute("data-testid");
     const id = node.getAttribute("id");
     const ariaLabel = node.getAttribute("aria-label");
-    const role = roleOf(node);
+    const role = roleOf2(node);
     const info = { tag, depth, testId: testId || null, id: id || null, ariaLabel: ariaLabel || null, role };
     if (testId) info.testIdCount = count(`[data-testid=${JSON.stringify(testId)}]`);
     if (id) {
@@ -744,7 +749,7 @@ function showAnchorPicker(arg) {
       let roleCount = 0;
       let labeledCount = 0;
       for (const n of roleNodes) {
-        if (roleOf(n) !== role) continue;
+        if (roleOf2(n) !== role) continue;
         roleCount++;
         if (ariaLabel && n.getAttribute && n.getAttribute("aria-label") === ariaLabel) labeledCount++;
       }
@@ -793,7 +798,7 @@ function showAnchorPicker(arg) {
       const nodes = Array.from(scope.querySelectorAll(roleSources));
       if (nodes.length > 2e3) return [];
       return nodes.filter(
-        (n) => roleOf(n) === info.role && (!info.ariaLabel || n.getAttribute && n.getAttribute("aria-label") === info.ariaLabel)
+        (n) => roleOf2(n) === info.role && (!info.ariaLabel || n.getAttribute && n.getAttribute("aria-label") === info.ariaLabel)
       );
     } catch {
       return [];
@@ -1798,7 +1803,8 @@ var ATTACHMENT_NAMES = {
   pageState: "piwi-page-state",
   userPick: "piwi-user-pick",
   aiUsage: "piwi-ai-usage",
-  aiMeta: "piwi-ai-meta"
+  aiMeta: "piwi-ai-meta",
+  resources: "piwi-resources"
 };
 var INTERNAL_ATTACHMENT_NAMES = new Set(Object.values(ATTACHMENT_NAMES));
 var LOCATOR_SUGGESTION_ANNOTATION = ATTACHMENT_NAMES.locatorSuggestion;
@@ -1811,7 +1817,7 @@ function collectPageInventoryInPage(maxEntries) {
   const doc = g.document;
   if (!doc || !g.location) return null;
   const clean = (s) => (s || "").replace(/\s+/g, " ").trim().slice(0, 120);
-  const roleOf = (el) => {
+  const roleOf2 = (el) => {
     const explicit = el.getAttribute("role");
     if (explicit) return explicit.toLowerCase();
     const tag = (el.tagName || "").toLowerCase();
@@ -1865,7 +1871,7 @@ function collectPageInventoryInPage(maxEntries) {
     return text;
   };
   const nameOf = (el) => {
-    const role = roleOf(el);
+    const role = roleOf2(el);
     const chain = [el.getAttribute("aria-label"), labelledByText(el), labelText(el)];
     if (!holdsValue(el, role)) chain.push(el.textContent);
     chain.push(el.getAttribute("placeholder"), el.getAttribute("title"), el.getAttribute("alt"));
@@ -1883,7 +1889,7 @@ function collectPageInventoryInPage(maxEntries) {
   const controlSelector = 'button, [role="button"], input, select, textarea, [role="checkbox"], [role="radio"], [role="tab"], [role="menuitem"], [role="combobox"], [role="switch"], [role="slider"], [role="searchbox"], [role="spinbutton"], [role="textbox"], [role="listbox"]';
   for (const el of Array.from(doc.querySelectorAll(controlSelector))) {
     if (budget <= 0) break;
-    const role = roleOf(el);
+    const role = roleOf2(el);
     const name = nameOf(el);
     if (!name) continue;
     const key = `${role}\0${name}`;
@@ -2038,6 +2044,8 @@ var DEFAULTS = {
   // Off by default: JavaScript coverage slows the page, so a scheduled job opts in.
   captureCodeReach: false,
   captureServerTraces: true,
+  captureResources: true,
+  leakCheck: "report",
   sampleAriaOnPass: true,
   uploadManifest: true,
   defaultCapture: true,
@@ -2078,6 +2086,8 @@ var PIWI_ENV_KEYS = {
   captureCodeReach: "PIWI_CAPTURE_CODE_REACH",
   codeReachRoots: "PIWI_CODE_REACH_ROOTS",
   captureServerTraces: "PIWI_CAPTURE_SERVER_TRACES",
+  captureResources: "PIWI_CAPTURE_RESOURCES",
+  leakCheck: "PIWI_LEAK_CHECK",
   sampleAriaOnPass: "PIWI_SAMPLE_ARIA_ON_PASS",
   uploadManifest: "PIWI_UPLOAD_MANIFEST",
   defaultCapture: "PIWI_DEFAULT_CAPTURE",
@@ -2103,6 +2113,7 @@ var PIWI_FLAKE_ENV = {
   plan: "PIWI_FLAKE_PLAN",
   results: "PIWI_FLAKE_RESULTS"
 };
+var PIWI_RESOURCES_RESULTS_ENV = "PIWI_RESOURCES_RESULTS";
 var ENV_FALLBACK_SPECS = [
   { option: "serverUrl", env: PIWI_ENV_KEYS.serverUrl, kind: "string" },
   { option: "projectName", env: PIWI_ENV_KEYS.projectName, kind: "string" },
@@ -2127,6 +2138,8 @@ var ENV_FALLBACK_SPECS = [
   { option: "capturePageInventory", env: PIWI_ENV_KEYS.capturePageInventory, kind: "bool" },
   { option: "captureCodeReach", env: PIWI_ENV_KEYS.captureCodeReach, kind: "bool" },
   { option: "captureServerTraces", env: PIWI_ENV_KEYS.captureServerTraces, kind: "bool" },
+  { option: "captureResources", env: PIWI_ENV_KEYS.captureResources, kind: "bool" },
+  { option: "leakCheck", env: PIWI_ENV_KEYS.leakCheck, kind: "string" },
   { option: "sampleAriaOnPass", env: PIWI_ENV_KEYS.sampleAriaOnPass, kind: "bool" },
   { option: "uploadManifest", env: PIWI_ENV_KEYS.uploadManifest, kind: "bool" },
   { option: "defaultCapture", env: PIWI_ENV_KEYS.defaultCapture, kind: "bool" },
@@ -2142,8 +2155,8 @@ function parseRouteKey(routeKey2) {
   return { method: routeKey2.slice(0, space).toUpperCase(), pattern: routeKey2.slice(space + 1) };
 }
 function patternToRegex(pattern) {
-  const path11 = pattern.split("?")[0] ?? pattern;
-  const escaped = path11.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:[A-Za-z0-9_]+/g, "[^/]+");
+  const path13 = pattern.split("?")[0] ?? pattern;
+  const escaped = path13.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:[A-Za-z0-9_]+/g, "[^/]+");
   return new RegExp(`^${escaped}$`);
 }
 function suitePathEqual(a, b) {
@@ -2166,13 +2179,13 @@ function matchProbeItem(plan, test) {
 function requestMatchesRoute(method, url, routeKey2) {
   const { method: rm, pattern } = parseRouteKey(routeKey2);
   if (rm && rm !== method.toUpperCase()) return false;
-  let path11;
+  let path13;
   try {
-    path11 = new URL(url).pathname;
+    path13 = new URL(url).pathname;
   } catch {
-    path11 = url.split("?")[0] ?? url;
+    path13 = url.split("?")[0] ?? url;
   }
-  return patternToRegex(pattern).test(path11);
+  return patternToRegex(pattern).test(path13);
 }
 function createProbeState() {
   return { navigated: false, matches: 0 };
@@ -2194,10 +2207,10 @@ function isProbeMode() {
 function loadPlan() {
   if (planCache !== void 0) return planCache;
   planCache = null;
-  const path11 = process.env[PIWI_PROBE_ENV.plan];
-  if (path11) {
+  const path13 = process.env[PIWI_PROBE_ENV.plan];
+  if (path13) {
     try {
-      planCache = JSON.parse(fs2.readFileSync(path11, "utf8"));
+      planCache = JSON.parse(fs2.readFileSync(path13, "utf8"));
     } catch {
       planCache = null;
     }
@@ -2219,10 +2232,10 @@ function outcomeFromStatus(status, applied) {
   return status === "failed" || status === "timedOut" || status === "interrupted" ? "noticed" : "not-noticed";
 }
 function recordProbeOutcome(line) {
-  const path11 = process.env[PIWI_PROBE_ENV.results];
-  if (!path11) return;
+  const path13 = process.env[PIWI_PROBE_ENV.results];
+  if (!path13) return;
   try {
-    fs2.appendFileSync(path11, `${JSON.stringify(line)}
+    fs2.appendFileSync(path13, `${JSON.stringify(line)}
 `);
   } catch {
   }
@@ -3496,12 +3509,23 @@ var BOXED_PREFIX_EXPORTS = [
   ["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 testPackageJson = (0, import_node_module.createRequire)(__filename).resolve("@playwright/test/package.json");
-    const playwrightPackageJson = (0, import_node_module.createRequire)(testPackageJson).resolve("playwright/package.json");
+    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;
@@ -3823,9 +3847,9 @@ function resolveSourcePath(source, roots) {
   const normalized = normalizeSourcePath(source);
   if (!normalized || /(?:^|\/)node_modules\//.test(normalized)) return null;
   if (path9.isAbsolute(normalized) && isFile(normalized)) return path9.resolve(normalized);
-  const relative7 = normalized.replace(/^\/+/, "");
+  const relative8 = normalized.replace(/^\/+/, "");
   for (const root of roots) {
-    const candidate = path9.resolve(root, relative7);
+    const candidate = path9.resolve(root, relative8);
     if (isFile(candidate)) return candidate;
   }
   return null;
@@ -3975,6 +3999,871 @@ async function stopCodeReach(page) {
   }
 }
 
+// src/internal/capture/resource-ledger.ts
+var fs8 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
+var import_node_module2 = require("module");
+
+// src/internal/capture/worker-metrics.ts
+var import_node_perf_hooks = require("perf_hooks");
+
+// src/internal/support/system-readers.ts
+var fs7 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
+var CLK_TCK = 100;
+function readText(file) {
+  try {
+    return fs7.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+function parseProcStat(pid, text) {
+  const open = text.indexOf("(");
+  const close = text.lastIndexOf(")");
+  if (open < 0 || close < open) return null;
+  const fields = text.slice(close + 2).trim().split(/\s+/);
+  const ppid = Number(fields[1]);
+  const utime = Number(fields[11]);
+  const stime = Number(fields[12]);
+  const start = Number(fields[19]);
+  if (![ppid, utime, stime, start].every(Number.isFinite)) return null;
+  return { pid, ppid, comm: text.slice(open + 1, close), cpuMs: (utime + stime) * 1e3 / CLK_TCK, start };
+}
+function parseSchedstat(text) {
+  const waitNs = Number(text.trim().split(/\s+/)[1]);
+  return Number.isFinite(waitNs) ? waitNs / 1e6 : null;
+}
+function parseKbField(text, key) {
+  const match = new RegExp(`^${key}:\\s+(\\d+)`, "m").exec(text);
+  return match ? Number(match[1]) : null;
+}
+function parseCpuTicks(text) {
+  const line = text.split("\n", 1)[0] ?? "";
+  if (!line.startsWith("cpu ")) return null;
+  const v = line.trim().split(/\s+/).slice(1, 9).map(Number);
+  if (v.length < 8 || v.some((n) => !Number.isFinite(n))) return null;
+  const [user, nice, system, idle, iowait, irq, softirq, steal] = v;
+  return { busy: user + nice + system + irq + softirq, idle, iowait, steal, total: v.reduce((sum, n) => sum + n, 0) };
+}
+function parsePsiTotal(text) {
+  const match = /^some\b.*\btotal=(\d+)/m.exec(text);
+  return match ? Number(match[1]) : null;
+}
+function roleOf(comm, cmdline) {
+  const command = `${comm} ${cmdline}`;
+  if (/workerProcessEntry/.test(cmdline)) return "worker";
+  if (/loaderProcessEntry/.test(cmdline)) return "runner";
+  if (/(^|[\s/])ffmpeg/.test(command)) return "ffmpeg";
+  const type = /--type=([\w-]+)/.exec(cmdline)?.[1];
+  if (/chrom|headless_shell|msedge|Google Chrome/i.test(command)) {
+    if (!type) return "browser";
+    if (type === "renderer") return "renderer";
+    if (type === "gpu-process") return "gpu";
+    return "utility";
+  }
+  if (/firefox/i.test(command)) return /-contentproc/.test(cmdline) ? "renderer" : "browser";
+  if (/WebKitWebProcess/.test(command)) return "renderer";
+  if (/WebKitGPUProcess/.test(command)) return "gpu";
+  if (/WebKitNetworkProcess/.test(command)) return "utility";
+  if (/MiniBrowser|pw_run\.sh/.test(command)) return "browser";
+  return null;
+}
+function descendantsOf(root, table) {
+  const children = /* @__PURE__ */ new Map();
+  for (const proc of table) {
+    const list = children.get(proc.ppid) ?? [];
+    list.push(proc);
+    children.set(proc.ppid, list);
+  }
+  const out = [];
+  const stack = [root];
+  const seen = /* @__PURE__ */ new Set([root]);
+  while (stack.length > 0) {
+    for (const child of children.get(stack.pop()) ?? []) {
+      if (seen.has(child.pid)) continue;
+      seen.add(child.pid);
+      out.push(child);
+      stack.push(child.pid);
+    }
+  }
+  return out;
+}
+var ProcFs = class {
+  constructor(root = "/proc") {
+    this.root = root;
+  }
+  /** Whether this looks like a Linux `/proc` at all. */
+  available() {
+    return fs7.existsSync(path10.join(this.root, "stat"));
+  }
+  /** Every process, keyed by pid. */
+  table() {
+    const out = /* @__PURE__ */ new Map();
+    let names;
+    try {
+      names = fs7.readdirSync(this.root);
+    } catch {
+      return out;
+    }
+    for (const name of names) {
+      if (!/^\d+$/.test(name)) continue;
+      const text = readText(path10.join(this.root, name, "stat"));
+      const stat = text ? parseProcStat(Number(name), text) : null;
+      if (stat) out.set(stat.pid, stat);
+    }
+    return out;
+  }
+  stat(pid) {
+    const text = readText(path10.join(this.root, String(pid), "stat"));
+    return text ? parseProcStat(pid, text) : null;
+  }
+  runWaitMs(pid) {
+    const text = readText(path10.join(this.root, String(pid), "schedstat"));
+    return text ? parseSchedstat(text) : null;
+  }
+  cmdline(pid) {
+    return (readText(path10.join(this.root, String(pid), "cmdline")) ?? "").split("\0").join(" ").trim();
+  }
+  /** A field of `/proc/<pid>/status`, in kB: `VmRSS`, `VmHWM`. */
+  statusKb(pid, key) {
+    const text = readText(path10.join(this.root, String(pid), "status"));
+    return text ? parseKbField(text, key) : null;
+  }
+  /** Proportional set size: shared pages split between the processes sharing them, so a sum counts them once. */
+  async pssKb(pid) {
+    try {
+      return parseKbField(await fs7.promises.readFile(path10.join(this.root, String(pid), "smaps_rollup"), "utf8"), "Pss");
+    } catch {
+      return null;
+    }
+  }
+  /** Reset a process's peak RSS (`VmHWM`) to its current RSS. */
+  resetPeakRss(pid) {
+    try {
+      fs7.writeFileSync(path10.join(this.root, String(pid), "clear_refs"), "5");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  cpuTicks() {
+    const text = readText(path10.join(this.root, "stat"));
+    return text ? parseCpuTicks(text) : null;
+  }
+  /** Total stall time of a resource's pressure file, in µs. */
+  pressureUs(resource) {
+    const text = readText(path10.join(this.root, "pressure", resource));
+    return text ? parsePsiTotal(text) : null;
+  }
+  memAvailableKb() {
+    const text = readText(path10.join(this.root, "meminfo"));
+    return text ? parseKbField(text, "MemAvailable") : null;
+  }
+  /** Open file descriptors of a process. */
+  fdCount(pid) {
+    try {
+      return fs7.readdirSync(path10.join(this.root, String(pid), "fd")).length;
+    } catch {
+      return null;
+    }
+  }
+};
+var UNLIMITED = 2 ** 60;
+
+// src/internal/capture/worker-metrics.ts
+var MB = 1024 * 1024;
+function round1(value) {
+  return Math.round(value * 10) / 10;
+}
+var WorkerMetrics = class {
+  constructor(proc = new ProcFs(), pid = process.pid, platform = process.platform) {
+    this.proc = proc;
+    this.pid = pid;
+    this.loop = null;
+    this.usage = null;
+    /** Each process's CPU and wait at the start of the current window; null before the first. */
+    this.subtree = null;
+    this.roles = /* @__PURE__ */ new Map();
+    this.linux = platform === "linux" && proc.available();
+    let histogram = null;
+    try {
+      histogram = (0, import_node_perf_hooks.monitorEventLoopDelay)({ resolution: 20 });
+      histogram.enable();
+    } catch {
+      histogram = null;
+    }
+    this.histogram = histogram;
+  }
+  /** The worker's processes under it, keyed by pid and start time. */
+  tree() {
+    const table = this.proc.table();
+    return descendantsOf(this.pid, table.values()).map((stat) => {
+      const key = `${stat.pid}:${stat.start}`;
+      let role = this.roles.get(key);
+      if (!role) {
+        role = roleOf(stat.comm, this.proc.cmdline(stat.pid)) ?? "other";
+        this.roles.set(key, role);
+      }
+      return { key, pid: stat.pid, cpuMs: stat.cpuMs, role };
+    });
+  }
+  /**
+   * The processes under the worker now, and the reset of their peak memory: the
+   * start of the next window. Taken once per test, at its end, so the time
+   * between two tests counts toward the next one.
+   */
+  snapshot() {
+    this.subtree = /* @__PURE__ */ new Map();
+    for (const proc of this.tree()) {
+      this.subtree.set(proc.key, { cpuMs: proc.cpuMs, waitMs: this.proc.runWaitMs(proc.pid) });
+      this.proc.resetPeakRss(proc.pid);
+    }
+  }
+  /**
+   * Start a test's window. `processes` says whether the worker has started any
+   * browser to read; a worker that never did skips the process tree.
+   */
+  start(processes = true) {
+    try {
+      this.histogram?.reset();
+      this.loop = import_node_perf_hooks.performance.eventLoopUtilization();
+      this.usage = process.resourceUsage();
+      if (this.linux && processes && !this.subtree) this.snapshot();
+    } catch {
+    }
+  }
+  /** Close the window. Null when the test's start was never read. */
+  end(processes = true) {
+    if (!this.usage || !this.loop) return null;
+    try {
+      const usage = process.resourceUsage();
+      const loop = import_node_perf_hooks.performance.eventLoopUtilization(this.loop);
+      const metrics = {
+        worker: {
+          cpuMs: Math.round(
+            (usage.userCPUTime - this.usage.userCPUTime + usage.systemCPUTime - this.usage.systemCPUTime) / 1e3
+          ),
+          involuntarySwitches: usage.involuntaryContextSwitches - this.usage.involuntaryContextSwitches,
+          loopUtilization: Math.round(loop.utilization * 1e3) / 1e3,
+          loopDelayP99Ms: this.histogram ? round1(this.histogram.percentile(99) / 1e6) : 0,
+          loopDelayMaxMs: this.histogram ? round1(this.histogram.max / 1e6) : 0,
+          heapUsedMb: round1(process.memoryUsage().heapUsed / MB),
+          fds: this.linux ? this.proc.fdCount(this.pid) : null
+        }
+      };
+      this.usage = null;
+      this.loop = null;
+      if (this.linux && processes) metrics.roles = this.roleCosts();
+      return metrics;
+    } catch {
+      return null;
+    }
+  }
+  /** The window's cost by role; what it reads becomes the start of the next window. */
+  roleCosts() {
+    const roles = {};
+    const start = this.subtree ?? /* @__PURE__ */ new Map();
+    const next = /* @__PURE__ */ new Map();
+    for (const proc of this.tree()) {
+      const from = start.get(proc.key) ?? { cpuMs: 0, waitMs: 0 };
+      const waitMs = this.proc.runWaitMs(proc.pid);
+      const peakKb = this.proc.statusKb(proc.pid, "VmHWM");
+      const cost = roles[proc.role] ??= { cpuMs: 0, runWaitMs: null, peakRssMb: null, processes: 0 };
+      cost.cpuMs += Math.max(0, proc.cpuMs - from.cpuMs);
+      if (waitMs !== null && from.waitMs !== null)
+        cost.runWaitMs = round1((cost.runWaitMs ?? 0) + Math.max(0, waitMs - from.waitMs));
+      if (peakKb !== null) cost.peakRssMb = Math.max(cost.peakRssMb ?? 0, round1(peakKb / 1024));
+      cost.processes++;
+      next.set(proc.key, { cpuMs: proc.cpuMs, waitMs });
+      this.proc.resetPeakRss(proc.pid);
+    }
+    this.subtree = next;
+    return roles;
+  }
+  dispose() {
+    this.histogram?.disable();
+  }
+};
+var PageReader = class {
+  constructor() {
+    this.sessions = /* @__PURE__ */ new WeakMap();
+  }
+  async read(page) {
+    let session = this.sessions.get(page);
+    if (!session) {
+      session = internalCall(page, async () => {
+        const opened2 = await page.context().newCDPSession(page);
+        await opened2.send("Performance.enable", { timeDomain: "threadTicks" });
+        return opened2;
+      }).catch(() => null);
+      this.sessions.set(page, session);
+    }
+    const opened = await session;
+    if (!opened) return null;
+    try {
+      const result = await internalCall(page, () => opened.send("Performance.getMetrics"));
+      const values = new Map((result.metrics ?? []).map((metric) => [metric.name, metric.value]));
+      return {
+        cpuMs: Math.round((values.get("TaskDuration") ?? 0) * 1e3),
+        heapMb: round1((values.get("JSHeapUsedSize") ?? 0) / MB),
+        nodes: values.get("Nodes") ?? 0,
+        listeners: values.get("JSEventListeners") ?? 0
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/internal/capture/resource-ledger.ts
+var TRACKED_HANDLE_TYPES = ["TCPServerWrap", "FSEventWrap", "StatWatcher"];
+var USE_METHODS = ["evaluate", "evaluateHandle", "$eval", "$$eval", "waitForFunction", "addScriptTag", "addStyleTag"];
+var CLOSE_TIMEOUT_MS = 5e3;
+var PAGE_READ_CAP = 50;
+var PAGE_READ_TIMEOUT_MS = 1e3;
+var HOOK_PHASES = /* @__PURE__ */ new Set(["beforeAll", "afterAll", "beforeEach", "afterEach"]);
+var KIND_ORDER = { browser: 0, context: 1, page: 2, request: 3 };
+function relativePath(file) {
+  return path11.relative(process.cwd(), file.replace(/^file:\/\//, "")).split(path11.sep).join("/");
+}
+function isLibraryFile(file) {
+  return file.startsWith("node:") || file.startsWith("internal/") || file.includes(`${path11.sep}node_modules${path11.sep}`) || file.includes("/node_modules/") || file === __filename;
+}
+function userSite(stack) {
+  for (const line of (stack ?? "").split("\n").slice(1)) {
+    const match = /^\s*at\s+(?:.*?\s+\()?(.+?):(\d+):\d+\)?$/.exec(line);
+    if (!match) continue;
+    const file = match[1].replace(/^file:\/\//, "");
+    if (isLibraryFile(file) || !/\.[a-z]+$/i.test(file)) continue;
+    return `${relativePath(file)}:${match[2]}`;
+  }
+  return null;
+}
+function zoneSite(zone) {
+  for (const frame of zone?.frames ?? []) {
+    if (!frame?.file || isLibraryFile(frame.file)) continue;
+    return `${relativePath(frame.file)}:${frame.line ?? 0}`;
+  }
+  return null;
+}
+function testRef2(info) {
+  if (!info?.testId) return null;
+  const titlePath = Array.isArray(info.titlePath) ? info.titlePath : [];
+  return {
+    id: info.testId,
+    file: info.file ? relativePath(info.file) : "",
+    suite: titlePath.slice(1, -1).map(String)
+  };
+}
+function runnableOf(info) {
+  if (!info) return { phase: "worker", fixture: null };
+  const runnable = info._timeoutManager?._running?.runnable;
+  const type = typeof runnable?.type === "string" ? runnable.type : "test";
+  const phase = HOOK_PHASES.has(type) ? type : type === "teardown" ? "worker" : "test";
+  const raw = runnable?.fixture;
+  const fixture = raw && typeof raw.title === "string" ? {
+    title: raw.title,
+    location: raw.location?.file ? `${relativePath(raw.location.file)}:${raw.location.line ?? 0}` : null,
+    worker: raw.slot !== void 0 && raw.slot !== null
+  } : null;
+  return { phase, fixture };
+}
+function fallbackRunnable(window) {
+  return { phase: window ? "test" : "worker", fixture: null };
+}
+function playwrightTestInfoSource() {
+  try {
+    const packageJson = resolvePlaywrightPackageJson();
+    if (!packageJson) return () => null;
+    const globals = (0, import_node_module2.createRequire)(packageJson)(path11.join(path11.dirname(packageJson), "lib", "globals.js"));
+    const read = globals.currentTestInfo;
+    if (typeof read !== "function") return () => null;
+    return () => {
+      try {
+        return read() ?? null;
+      } catch {
+        return null;
+      }
+    };
+  } catch {
+    return () => null;
+  }
+}
+function readLeakCheck(value = process.env[PIWI_ENV_KEYS.leakCheck]) {
+  return value === "fail" || value === "close" ? value : "report";
+}
+function countHandles() {
+  const counts = {};
+  const read = process.getActiveResourcesInfo;
+  if (typeof read !== "function") return counts;
+  for (const type of read.call(process)) {
+    if (TRACKED_HANDLE_TYPES.includes(type)) counts[type] = (counts[type] ?? 0) + 1;
+  }
+  return counts;
+}
+async function settledHandles(start) {
+  const end = countHandles();
+  if (!Object.entries(end).some(([type, n]) => n > (start[type] ?? 0))) return end;
+  await new Promise((resolve3) => setTimeout(resolve3, 0));
+  return countHandles();
+}
+function settleWithin(promise, ms) {
+  let timer;
+  return Promise.race([
+    promise.catch(() => void 0),
+    new Promise((resolve3) => {
+      timer = setTimeout(resolve3, ms);
+    })
+  ]).finally(() => clearTimeout(timer));
+}
+var ResourceLedger = class {
+  constructor(playwright, workerIndex, leakCheck = readLeakCheck(), resultsFile = process.env[PIWI_RESOURCES_RESULTS_ENV] || null, testInfoSource = playwrightTestInfoSource(), now = Date.now, readers = {}) {
+    this.playwright = playwright;
+    this.workerIndex = workerIndex;
+    this.leakCheck = leakCheck;
+    this.resultsFile = resultsFile;
+    this.testInfoSource = testInfoSource;
+    this.now = now;
+    this.readers = readers;
+    this.nextId = 1;
+    this.entries = /* @__PURE__ */ new Map();
+    this.byObject = /* @__PURE__ */ new WeakMap();
+    this.pendingCalls = /* @__PURE__ */ new Set();
+    this.lastCall = null;
+    /** The page a wrapped page method is calling into: its first reported API call marks it used. */
+    this.usingPage = null;
+    this.born = [];
+    this.closed = [];
+    this.handlesAtStart = {};
+    this.openAtStart = { contexts: 0, pages: 0 };
+    /** The test between `testStarted` and `testEnded`, for when Playwright's own test info cannot be read. */
+    this.window = null;
+    this.listener = null;
+    /** A browser or a context was opened in this worker: there are browser processes for the metrics to read. */
+    this.sawBrowser = false;
+  }
+  /** Listen to the worker's Playwright and wrap its browser types. False when the instrumentation is missing. */
+  install() {
+    const instrumentation = this.playwright?._instrumentation;
+    if (!instrumentation || typeof instrumentation.addListener !== "function") return false;
+    this.listener = {
+      onApiCallBegin: (zone) => {
+        if (this.pendingCalls.size > 1e3) this.pendingCalls.clear();
+        this.pendingCalls.add(zone);
+        this.lastCall = zone;
+        if (this.usingPage) {
+          this.usingPage.used = true;
+          this.usingPage = null;
+        }
+      },
+      onApiCallEnd: (zone) => {
+        this.pendingCalls.delete(zone);
+      },
+      runAfterCreateBrowserContext: async (context) => {
+        this.guard(() => this.onContext(context, userSite(new Error().stack)));
+      },
+      runAfterCreateRequestContext: async (request) => {
+        this.guard(() => this.track(request, "request", null, userSite(new Error().stack)));
+      },
+      runBeforeCloseRequestContext: async (request) => {
+        this.guard(() => this.onClosed(request));
+      }
+    };
+    instrumentation.addListener(this.listener);
+    for (const type of [this.playwright.chromium, this.playwright.firefox, this.playwright.webkit]) {
+      if (type) this.wrapBrowserType(type);
+    }
+    return true;
+  }
+  /** Stop listening; the objects already tracked stay in the ledger. */
+  uninstall() {
+    const remove = this.playwright?._instrumentation?.removeListener;
+    if (this.listener && typeof remove === "function") remove.call(this.playwright._instrumentation, this.listener);
+    this.listener = null;
+  }
+  /** Mark a page used: a locator was built on it. */
+  notePageUse(page) {
+    const entry = this.byObject.get(page);
+    if (entry) entry.used = true;
+  }
+  /** Open the census window of a test. */
+  testStarted(info) {
+    this.window = testRef2(info);
+    this.handlesAtStart = countHandles();
+    this.openAtStart = { contexts: 0, pages: 0 };
+    for (const entry of this.openEntries()) {
+      if (entry.birth.kind === "page") this.openAtStart.pages++;
+      else if (entry.birth.kind === "context") this.openAtStart.contexts++;
+    }
+    this.readers.metrics?.start(this.sawBrowser);
+  }
+  /**
+   * Close the census window of a test: apply `PIWI_LEAK_CHECK=close` to what the
+   * test left open, then take the census. Called after the test-scoped fixtures
+   * tore down, so what the test opened through them is closed by now.
+   */
+  async testEnded(info) {
+    const test = testRef2(info) ?? this.window;
+    const failed = typeof info.status === "string" && typeof info.expectedStatus === "string" && info.status !== info.expectedStatus;
+    const leaks = test && !failed ? this.leaksOf(test.id) : [];
+    if (this.leakCheck === "close" && leaks.length > 0) await this.closeLeaks(leaks);
+    const ref = test ? { ...test, title: typeof info.title === "string" ? info.title : "", ...failed ? { failed: true } : {} } : null;
+    const metrics = this.readers.metrics?.end(this.sawBrowser) ?? null;
+    const handles = { start: this.handlesAtStart, end: await settledHandles(this.handlesAtStart) };
+    const census = this.census(ref, handles, await this.readPages());
+    if (metrics) census.metrics = metrics;
+    if (test) {
+      census.openAtStart = this.openAtStart;
+      if (!failed) census.leftOpen = leaks.length;
+    }
+    this.window = null;
+    return { census, leaks };
+  }
+  /** The open pages' main thread and weight, over CDP, within a deadline. */
+  async readPages() {
+    const out = /* @__PURE__ */ new Map();
+    const reader = this.readers.pages;
+    if (!reader) return out;
+    const pages = this.openEntries().filter((entry) => entry.birth.kind === "page").slice(0, PAGE_READ_CAP);
+    await settleWithin(
+      Promise.all(
+        pages.map(async (entry) => {
+          const main = entry.object ? await reader.read(entry.object) : null;
+          if (main) out.set(entry.birth.id, main);
+        })
+      ),
+      PAGE_READ_TIMEOUT_MS
+    );
+    return out;
+  }
+  /** The census a worker takes as it shuts down, appended to the results file when the reporter set one. */
+  workerEnded() {
+    const census = this.census(null);
+    if (this.resultsFile) {
+      try {
+        fs8.appendFileSync(this.resultsFile, `${JSON.stringify(census)}
+`);
+      } catch {
+      }
+    }
+    this.readers.metrics?.dispose();
+    this.uninstall();
+    return census;
+  }
+  guard(run) {
+    try {
+      run();
+    } catch {
+    }
+  }
+  wrapBrowserType(type) {
+    for (const method of ["launch", "connect", "connectOverCDP"]) {
+      const original = type[method];
+      if (typeof original !== "function") continue;
+      const bound = original.bind(type);
+      type[method] = async (...args) => {
+        const site = userSite(new Error().stack);
+        const browser = await bound(...args);
+        this.guard(() => this.onBrowser(browser, site));
+        return browser;
+      };
+    }
+  }
+  track(object, kind, parent, site) {
+    const existing = this.byObject.get(object);
+    if (existing) return existing;
+    const info = this.testInfoSource();
+    const { phase, fixture } = info ? runnableOf(info) : fallbackRunnable(this.window);
+    const birth = {
+      id: this.nextId++,
+      kind,
+      parent: parent ? this.byObject.get(parent)?.birth.id ?? null : null,
+      at: this.now(),
+      phase,
+      fixture,
+      test: testRef2(info) ?? this.window,
+      site
+    };
+    const entry = { birth, object, closed: null, used: false };
+    if (kind === "browser" || kind === "context") this.sawBrowser = true;
+    this.entries.set(birth.id, entry);
+    this.byObject.set(object, entry);
+    this.born.push(birth);
+    return entry;
+  }
+  onBrowser(browser, site) {
+    const known = this.byObject.get(browser);
+    if (known) return known;
+    const entry = this.track(browser, "browser", null, site);
+    browser.on("disconnected", () => this.guard(() => this.onClosed(browser)));
+    return entry;
+  }
+  onContext(context, site) {
+    if (this.byObject.has(context)) return;
+    const browser = context.browser();
+    if (browser) this.onBrowser(browser, site);
+    const entry = this.track(context, "context", browser, site);
+    const zone = this.latestPendingCall();
+    if (zone?.apiName?.endsWith(".newPage")) entry.birth.implicit = true;
+    if (context._forReuse) entry.birth.reused = true;
+    context.on("close", () => this.guard(() => this.onClosed(context)));
+    context.on("page", (page) => this.guard(() => this.onPage(page, context)));
+    for (const page of context.pages()) this.onPage(page, context, { site });
+  }
+  /** `initial` is set for a page that came with its context (a persistent context's), which is no popup. */
+  onPage(page, context, initial) {
+    if (this.byObject.has(page)) return;
+    const zone = this.latestPendingCall();
+    const viaNewPage = !!zone?.apiName?.endsWith(".newPage");
+    const popup = !viaNewPage && !initial;
+    const site = viaNewPage ? zoneSite(zone) : initial ? initial.site : zoneSite(this.lastCall);
+    const entry = this.track(page, "page", context, site);
+    if (popup) {
+      const opener = page._opener;
+      const openerEntry = opener ? this.byObject.get(opener) : void 0;
+      if (openerEntry) entry.birth.opener = openerEntry.birth.id;
+      if (this.lastCall?.apiName) entry.birth.trigger = this.lastCall.apiName;
+    }
+    const markUsed = () => {
+      entry.used = true;
+    };
+    page.on("load", markUsed);
+    page.on("domcontentloaded", markUsed);
+    page.on("framenavigated", (frame) => {
+      try {
+        if (frame === page.mainFrame() && frame.url() !== "about:blank") entry.used = true;
+      } catch {
+      }
+    });
+    page.on("close", () => this.guard(() => this.onClosed(page)));
+    const methods = page;
+    for (const method of USE_METHODS) {
+      const original = methods[method];
+      if (typeof original !== "function") continue;
+      const bound = original.bind(page);
+      methods[method] = (...args) => {
+        const previous = this.usingPage;
+        this.usingPage = entry;
+        try {
+          return bound(...args);
+        } finally {
+          this.usingPage = previous;
+        }
+      };
+    }
+  }
+  onClosed(object, byPiwi = false) {
+    const entry = this.byObject.get(object);
+    if (!entry || entry.closed) return;
+    const info = this.testInfoSource();
+    const { phase } = info ? runnableOf(info) : fallbackRunnable(this.window);
+    const close = {
+      id: entry.birth.id,
+      at: this.now(),
+      phase,
+      test: testRef2(info) ?? this.window
+    };
+    if (entry.birth.kind === "page") close.used = entry.used;
+    if (byPiwi) close.byPiwi = true;
+    entry.closed = close;
+    entry.object = null;
+    this.closed.push(close);
+  }
+  latestPendingCall() {
+    let latest = null;
+    for (const zone of this.pendingCalls) latest = zone;
+    return latest;
+  }
+  openEntries() {
+    return [...this.entries.values()].filter((entry) => !entry.closed && entry.object);
+  }
+  /**
+   * Objects a test opened itself, by its body or its each-hooks, and left open.
+   * A page in a leaked context, or a context in a leaked browser, goes with it;
+   * the context `browser.newPage()` opened for its page goes with the page.
+   */
+  leaksOf(testId) {
+    const open = this.openEntries().filter(
+      (entry) => entry.birth.test?.id === testId && entry.birth.fixture === null && (entry.birth.phase === "test" || entry.birth.phase === "beforeEach" || entry.birth.phase === "afterEach") && !entry.birth.reused
+    );
+    const openIds = new Set(open.map((entry) => entry.birth.id));
+    const foldsIntoLeak = (entry) => {
+      let parentId = entry.birth.parent;
+      while (parentId !== null) {
+        if (!this.isImplicit(parentId)) return openIds.has(parentId);
+        parentId = this.entries.get(parentId)?.birth.parent ?? null;
+      }
+      return false;
+    };
+    return open.filter((entry) => !(entry.birth.kind === "context" && this.isImplicit(entry.birth.id))).filter((entry) => !foldsIntoLeak(entry)).map((entry) => ({
+      id: entry.birth.id,
+      kind: entry.birth.kind,
+      site: entry.birth.site,
+      pages: entry.birth.kind === "page" ? 0 : this.pagesUnder(entry.birth.id),
+      implicit: false,
+      ...entry.birth.opener !== void 0 ? { trigger: entry.birth.trigger ?? "a click" } : {}
+    })).sort((a, b) => KIND_ORDER[a.kind] - KIND_ORDER[b.kind]);
+  }
+  /** Open pages under a context, or under any context of a browser. */
+  pagesUnder(id) {
+    let count = 0;
+    for (const entry of this.openEntries()) {
+      if (entry.birth.kind !== "page" || entry.birth.parent === null) continue;
+      const context = this.entries.get(entry.birth.parent);
+      if (entry.birth.parent === id || context?.birth.parent === id) count++;
+    }
+    return count;
+  }
+  isImplicit(id) {
+    const entry = this.entries.get(id);
+    if (!entry || entry.birth.kind !== "context") return false;
+    if (entry.birth.implicit) return true;
+    const owner = entry.object ? entry.object._ownerPage : void 0;
+    if (owner) entry.birth.implicit = true;
+    return !!owner;
+  }
+  openPagesOf(contextId) {
+    let count = 0;
+    for (const entry of this.openEntries())
+      if (entry.birth.kind === "page" && entry.birth.parent === contextId) count++;
+    return count;
+  }
+  async closeLeaks(leaks) {
+    for (const leak of leaks) {
+      const entry = this.entries.get(leak.id);
+      const object = entry?.object;
+      if (!entry || entry.closed || !object) continue;
+      const close = leak.kind === "request" ? () => object.dispose() : () => object.close();
+      await settleWithin(internalCall(object, close), CLOSE_TIMEOUT_MS);
+      const closedMeanwhile = entry.closed;
+      if (closedMeanwhile) closedMeanwhile.byPiwi = true;
+      else this.onClosed(object, true);
+    }
+  }
+  census(test, handles, mains = /* @__PURE__ */ new Map()) {
+    const open = [];
+    for (const entry of this.openEntries()) {
+      const object = entry.object;
+      if (entry.birth.kind === "page") {
+        const main = mains.get(entry.birth.id);
+        open.push({
+          id: entry.birth.id,
+          used: entry.used,
+          url: this.pageUrl(object),
+          listeners: this.listenerCount(object),
+          routes: this.routeCount(object),
+          ...main ? { main } : {}
+        });
+      } else if (entry.birth.kind === "context") {
+        this.isImplicit(entry.birth.id);
+        open.push({ id: entry.birth.id, pages: this.openPagesOf(entry.birth.id), routes: this.routeCount(object) });
+      } else {
+        open.push({ id: entry.birth.id });
+      }
+    }
+    const census = {
+      v: 1,
+      worker: this.workerIndex,
+      pid: process.pid,
+      at: this.now(),
+      test,
+      born: this.born,
+      closed: this.closed,
+      open
+    };
+    if (handles) census.handles = handles;
+    this.born = [];
+    this.closed = [];
+    return census;
+  }
+  pageUrl(page) {
+    try {
+      const url = typeof page.url === "function" ? String(page.url()) : "";
+      return url ? url.split(/[?#]/)[0] : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  listenerCount(emitter) {
+    try {
+      if (typeof emitter.eventNames !== "function" || typeof emitter.listenerCount !== "function") return void 0;
+      const names = emitter.eventNames();
+      return names.reduce((sum, name) => sum + emitter.listenerCount(name), 0);
+    } catch {
+      return void 0;
+    }
+  }
+  routeCount(object) {
+    const routes = object._routes;
+    return Array.isArray(routes) ? routes.length : void 0;
+  }
+};
+var activeLedger = null;
+function startResourceLedger(playwright, workerIndex) {
+  if (process.env[PIWI_ENV_KEYS.captureResources] === "false") return null;
+  if (activeLedger) return activeLedger;
+  const metrics = new WorkerMetrics();
+  const ledger = new ResourceLedger(
+    playwright,
+    workerIndex,
+    readLeakCheck(),
+    process.env[PIWI_RESOURCES_RESULTS_ENV] || null,
+    playwrightTestInfoSource(),
+    Date.now,
+    { metrics, pages: new PageReader() }
+  );
+  if (!ledger.install()) {
+    metrics.dispose();
+    return null;
+  }
+  activeLedger = ledger;
+  return ledger;
+}
+function activeResourceLedger() {
+  return activeLedger;
+}
+function stopResourceLedger() {
+  const ledger = activeLedger;
+  activeLedger = null;
+  return ledger ? ledger.workerEnded() : null;
+}
+function noteResourceUse(page) {
+  activeLedger?.notePageUse(page);
+}
+var ARTICLE = {
+  browser: "a browser",
+  context: "a context",
+  page: "a page",
+  request: "an API request context"
+};
+function leakFailureMessage(leaks) {
+  const lines = leaks.map((leak) => {
+    const what = leak.trigger ? `a popup opened by ${leak.trigger}` : ARTICLE[leak.kind];
+    const where = leak.site ? `${leak.trigger ? "" : " opened"} at ${leak.site}` : "";
+    const pages = leak.pages > 0 ? `, with ${leak.pages} page${leak.pages === 1 ? "" : "s"}` : "";
+    return `  - ${what}${where}${pages}`;
+  });
+  return [
+    `Piwi: this test left ${leaks.length === 1 ? "one object" : `${leaks.length} objects`} open:`,
+    ...lines,
+    "Close each before the test ends (await using, close() or dispose()), or set PIWI_LEAK_CHECK=report to only list them."
+  ].join("\n");
+}
+async function recordResourceCensus(testInfo) {
+  const ledger = activeLedger;
+  if (!ledger) return;
+  const { census, leaks } = await ledger.testEnded(testInfo);
+  try {
+    await testInfo.attach(ATTACHMENT_NAMES.resources, {
+      contentType: "application/json",
+      body: Buffer.from(JSON.stringify(census))
+    });
+  } catch {
+  }
+  if (ledger.leakCheck === "fail" && leaks.length > 0) throw new Error(leakFailureMessage(leaks));
+}
+
 // src/internal/capture/capture-fixtures.ts
 function computeCoreVitals(lcpEntries, shiftEntries, eventEntries) {
   const lastLcp = lcpEntries && lcpEntries.length > 0 ? lcpEntries[lcpEntries.length - 1] : null;
@@ -4047,7 +4936,7 @@ function configuredCodeReachRoots() {
     if (Array.isArray(parsed)) return parsed.filter((r) => typeof r === "string" && r !== "");
   } catch {
   }
-  return raw.split(path10.delimiter).filter(Boolean);
+  return raw.split(path12.delimiter).filter(Boolean);
 }
 async function stopSinkCodeReach(sink, closing) {
   const session = sink.codeReach;
@@ -4062,7 +4951,7 @@ async function stopSinkCodeReach(sink, closing) {
     if (!entries) return;
     const info = sink.testInfo;
     const configFile = info?.config.configFile;
-    const configDir = configFile ? path10.dirname(configFile) : info?.config.rootDir ?? process.cwd();
+    const configDir = configFile ? path12.dirname(configFile) : info?.config.rootDir ?? process.cwd();
     session.files = await resolveCodeReach(
       entries,
       codeReachRoots(configDir, configuredCodeReachRoots()),
@@ -4626,6 +5515,7 @@ function instrumentPage(page) {
       const original = factories[method].bind(page);
       factories[method] = (...args) => {
         if (currentSink) currentSink.lastActivePage = page;
+        noteResourceUse(page);
         return wrapLocator(page, original(...args), method, args);
       };
     }
@@ -4955,6 +5845,22 @@ 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.
+  piwiResources: [
+    async ({ playwright }, use, workerInfo) => {
+      boxCaptureFrames();
+      startResourceLedger(playwright, workerInfo.workerIndex);
+      try {
+        await use();
+      } finally {
+        stopResourceLedger();
+      }
+    },
+    { scope: "worker", auto: true }
+  ],
   // Worker-scoped: patch the shared browser so every page/context created from
   // it — including by user fixtures that take `browser` directly — is captured.
   browser: [
@@ -5002,6 +5908,7 @@ var piwiFixtures = {
           file: testInfo.file,
           titlePath: testInfo.titlePath
         });
+      activeResourceLedger()?.testStarted(testInfo);
       currentSink = sink;
       try {
         await use();
@@ -5028,6 +5935,7 @@ var piwiFixtures = {
         }
         if (sink.flake) await recordFlakeAttempt(sink.flake, testInfo);
         await flushSink(sink, testInfo);
+        await recordResourceCensus(testInfo);
       }
     },
     { auto: true }
@@ -5061,6 +5969,7 @@ function extendPiwiFixtures(test) {
 0 && (module.exports = {
   CAPTURED_ATTRS_ARG,
   LocatorPageLog,
+  activeResourceLedger,
   ariaSnapshotBestEffort,
   ariaSnapshotJSONBestEffort,
   boxCaptureFrames,
@@ -5073,10 +5982,14 @@ function extendPiwiFixtures(test) {
   internalCall,
   noteLocatorCall,
   noteNavigation,
+  noteResourceUse,
   pageMapFetcher,
   piwiFixtures,
   probeElementAttrs,
+  recordResourceCensus,
   resolveCodeReach,
   startCodeReach,
-  stopCodeReach
+  startResourceLedger,
+  stopCodeReach,
+  stopResourceLedger
 });