@piwitests/reporter 0.44.0 → 0.45.0

package/dist/index.js

@@ -43,7 +43,9 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/public/reporter.ts
-var path18 = __toESM(require("path"));
+var fs21 = __toESM(require("fs"));
+var os9 = __toESM(require("os"));
+var path23 = __toESM(require("path"));
 
 // src/internal/config/desktop.ts
 var fs = __toESM(require("fs"));
@@ -82,6 +84,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,
@@ -122,6 +126,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",
@@ -156,6 +162,7 @@ var PIWI_FLAKE_ENV = {
   plan: "PIWI_FLAKE_PLAN",
   results: "PIWI_FLAKE_RESULTS"
 };
+var PIWI_RESOURCES_RESULTS_ENV = "PIWI_RESOURCES_RESULTS";
 function readBool(val) {
   if (val === void 0) return void 0;
   return val === "true";
@@ -184,6 +191,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" },
@@ -250,6 +259,8 @@ function applyOptionsToEnv(options) {
   if (options.captureServerTraces === false || options.collectPerformanceMetrics === false)
     env[PIWI_ENV_KEYS.captureServerTraces] = "false";
   else if (options.captureServerTraces === true) env[PIWI_ENV_KEYS.captureServerTraces] = "true";
+  if (options.captureResources !== void 0) env[PIWI_ENV_KEYS.captureResources] = String(options.captureResources);
+  if (options.leakCheck !== void 0) env[PIWI_ENV_KEYS.leakCheck] = options.leakCheck;
   if (options.sampleAriaOnPass === false) env[PIWI_ENV_KEYS.sampleAriaOnPass] = "false";
   else if (options.sampleAriaOnPass === true) env[PIWI_ENV_KEYS.sampleAriaOnPass] = "true";
   if (options.inspectOnFailure !== void 0) env[PIWI_ENV_KEYS.inspectOnFailure] = String(options.inspectOnFailure);
@@ -490,7 +501,7 @@ var HttpClient = class {
   }
   /** Unified request core: transport, headers, auth, response accumulation, timeout. */
   request(method, pathname, opts) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       if (this.closedReason !== null) {
         reject(new Error(this.closedReason));
         return;
@@ -513,7 +524,7 @@ var HttpClient = class {
             data += chunk;
           });
           res.on("end", () => {
-            resolve6({ status: res.statusCode ?? 0, text: data, headers: res.headers });
+            resolve7({ status: res.statusCode ?? 0, text: data, headers: res.headers });
           });
           res.on("error", reject);
           res.on("close", () => {
@@ -608,6 +619,7 @@ function toWireTestCase(tc) {
     locatorSnapshots: rest.locatorSnapshots || null,
     locatorPages: rest.locatorPages || null,
     codeReach: rest.codeReach || null,
+    resources: rest.resources ?? null,
     didNotRunReason: rest.didNotRunReason ?? null,
     expectedStatus: rest.expectedStatus ?? null,
     blockedBy: rest.blockedBy ?? null
@@ -674,6 +686,7 @@ function serializeRun(payload, opts) {
     isFullRun: payload.isFullRun ?? true,
     filterDetails: payload.filterDetails ?? null
   };
+  if (payload.resourceReport) body.resourceReport = payload.resourceReport;
   if (opts.includeTestCases) {
     body.testCases = payload.testCases.map((tc) => toWireTestCase(tc));
   }
@@ -1056,7 +1069,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;
@@ -1277,8 +1291,8 @@ var FileHandler = class {
     }
     if (!lastPath) return null;
     const hash = crypto2.createHash("sha256");
-    await new Promise((resolve6, reject) => {
-      fs6.createReadStream(lastPath).on("data", (chunk) => hash.update(chunk)).on("end", resolve6).on("error", reject);
+    await new Promise((resolve7, reject) => {
+      fs6.createReadStream(lastPath).on("data", (chunk) => hash.update(chunk)).on("end", resolve7).on("error", reject);
     });
     return {
       tracePath: lastPath,
@@ -1709,10 +1723,10 @@ function createLimiter(maxConcurrent) {
     if (run) run();
   };
   return function limit(fn) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       const run = () => {
         active++;
-        Promise.resolve().then(fn).then(resolve6, reject).finally(next);
+        Promise.resolve().then(fn).then(resolve7, reject).finally(next);
       };
       if (active < limitValue) run();
       else queue.push(run);
@@ -2151,7 +2165,7 @@ var StreamManager = class {
         this.logger.debugError(
           `${this.pendingEvents.length} events pending, retrying (attempt ${attempt + 1}/${MAX_ATTEMPTS})...`
         );
-        await new Promise((resolve6) => setTimeout(resolve6, Math.min(1e3 * Math.pow(2, attempt), 1e4)));
+        await new Promise((resolve7) => setTimeout(resolve7, Math.min(1e3 * Math.pow(2, attempt), 1e4)));
       }
       if (!this.pendingEvents.isEmpty) {
         const remaining = this.pendingEvents.takeAll();
@@ -2208,7 +2222,7 @@ var StreamManager = class {
       if (flush) await flush;
       const delays = [0, 1e3, 3e3];
       for (let attempt = 0; attempt < delays.length; attempt++) {
-        if (delays[attempt]) await new Promise((resolve6) => setTimeout(resolve6, delays[attempt]));
+        if (delays[attempt]) await new Promise((resolve7) => setTimeout(resolve7, delays[attempt]));
         try {
           await this.limitLiveUpload(
             () => this.uploader.uploadCaseFiles(
@@ -3900,8 +3914,8 @@ function parseRouteKey(routeKey2) {
   return { method: routeKey2.slice(0, space).toUpperCase(), pattern: routeKey2.slice(space + 1) };
 }
 function patternToRegex(pattern) {
-  const path27 = pattern.split("?")[0] ?? pattern;
-  const escaped = path27.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:[A-Za-z0-9_]+/g, "[^/]+");
+  const path31 = pattern.split("?")[0] ?? pattern;
+  const escaped = path31.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:[A-Za-z0-9_]+/g, "[^/]+");
   return new RegExp(`^${escaped}$`);
 }
 function suitePathEqual(a, b) {
@@ -3924,13 +3938,13 @@ function matchProbeItem(plan, test) {
 function requestMatchesRoute(method, url, routeKey2) {
   const { method: rm, pattern } = parseRouteKey(routeKey2);
   if (rm && rm !== method.toUpperCase()) return false;
-  let path27;
+  let path31;
   try {
-    path27 = new URL(url).pathname;
+    path31 = new URL(url).pathname;
   } catch {
-    path27 = url.split("?")[0] ?? url;
+    path31 = url.split("?")[0] ?? url;
   }
-  return patternToRegex(pattern).test(path27);
+  return patternToRegex(pattern).test(path31);
 }
 function createProbeState() {
   return { navigated: false, matches: 0 };
@@ -3952,10 +3966,10 @@ function isProbeMode() {
 function loadPlan() {
   if (planCache !== void 0) return planCache;
   planCache = null;
-  const path27 = process.env[PIWI_PROBE_ENV.plan];
-  if (path27) {
+  const path31 = process.env[PIWI_PROBE_ENV.plan];
+  if (path31) {
     try {
-      planCache = JSON.parse(fs14.readFileSync(path27, "utf8"));
+      planCache = JSON.parse(fs14.readFileSync(path31, "utf8"));
     } catch {
       planCache = null;
     }
@@ -3977,10 +3991,10 @@ function outcomeFromStatus(status, applied) {
   return status === "failed" || status === "timedOut" || status === "interrupted" ? "noticed" : "not-noticed";
 }
 function recordProbeOutcome(line) {
-  const path27 = process.env[PIWI_PROBE_ENV.results];
-  if (!path27) return;
+  const path31 = process.env[PIWI_PROBE_ENV.results];
+  if (!path31) return;
   try {
-    fs14.appendFileSync(path27, `${JSON.stringify(line)}
+    fs14.appendFileSync(path31, `${JSON.stringify(line)}
 `);
   } catch {
   }
@@ -4364,7 +4378,7 @@ function originOf(url) {
     return null;
   }
 }
-var sleep = (ms) => new Promise((resolve6) => setTimeout(resolve6, Math.max(0, ms)));
+var sleep = (ms) => new Promise((resolve7) => setTimeout(resolve7, Math.max(0, ms)));
 async function performRouteAction(route, action, startedAt) {
   switch (action.kind) {
     case "abort":
@@ -5061,6 +5075,15 @@ function emitGitLabDotenv(output, env, logger) {
     logger.warn(`Failed to write GitLab dotenv file '${file}': ${errorMessage(error)}`);
   }
 }
+function emitResourceSummary(lines, logger, env = process.env) {
+  if (!env.GITHUB_ACTIONS || !env.GITHUB_STEP_SUMMARY || lines.length === 0) return;
+  appendFileLines(
+    env.GITHUB_STEP_SUMMARY,
+    ["### Piwi resources", "", "```text", ...lines, "```", ""],
+    logger,
+    "step summary"
+  );
+}
 function appendFileLines(file, lines, logger, label) {
   try {
     fs17.appendFileSync(file, lines.join("\n") + "\n");
@@ -5212,7 +5235,8 @@ var RunSubmitter = class {
       shardIndex: run.shardInfo?.current,
       shardTotal: run.shardInfo?.total,
       isFullRun: run.isFullRun,
-      filterDetails: run.filterDetails
+      filterDetails: run.filterDetails,
+      resourceReport: run.resourceReport ?? null
     };
   }
   async tryFinishStreaming(run, overallStatus, duration, auth) {
@@ -5243,6 +5267,7 @@ var RunSubmitter = class {
         isFullRun: run.isFullRun,
         filterDetails: run.filterDetails ?? null
       };
+      if (run.resourceReport) finishBody.resourceReport = run.resourceReport;
       if (run.shardInfo) {
         finishBody.shardIndex = run.shardInfo.current;
         finishBody.shardTotal = run.shardInfo.total;
@@ -5327,202 +5352,2269 @@ var RunSubmitter = class {
   }
 };
 
-// ../core/src/describe-failure.ts
-var HEADLINE_MAX_CHARS = 120;
-var VALUE_MAX_CHARS = 40;
-var SHORT_VALUE_MAX_CHARS = 20;
-var MASK_TOKEN_RE = /<(?:N|VALUE|URL|STR|UUID|HASH|EMAIL)>/g;
-var ACTION_VERBS = {
-  click: "click",
-  dblclick: "double-click",
-  fill: "fill",
-  type: "type",
-  press: "press",
-  pressSequentially: "type",
-  check: "check",
-  uncheck: "uncheck",
-  hover: "hover",
-  tap: "tap",
-  focus: "focus",
-  blur: "blur",
-  clear: "clear",
-  selectOption: "select",
-  selectText: "select text",
-  setInputFiles: "file upload",
-  setChecked: "check",
-  dragTo: "drag",
-  dragAndDrop: "drag",
-  scrollIntoViewIfNeeded: "scroll",
-  screenshot: "screenshot",
-  waitFor: "wait",
-  waitForSelector: "waitForSelector",
-  waitForLoadState: "waitForLoadState",
-  waitForFunction: "waitForFunction",
-  waitForResponse: "waitForResponse",
-  waitForRequest: "waitForRequest",
-  waitForEvent: "waitForEvent",
-  waitForTimeout: "waitForTimeout",
-  innerText: "read text",
-  textContent: "read text",
-  inputValue: "read value",
-  getAttribute: "read attribute",
-  isVisible: "visibility check",
-  isEnabled: "enabled check",
-  isChecked: "checked check",
-  boundingBox: "measure",
-  evaluate: "evaluate",
-  goto: "navigation"
-};
-var ACTION_GERUNDS = {
-  click: "clicking",
-  dblclick: "double-clicking",
-  fill: "filling",
-  type: "typing into",
-  press: "pressing a key on",
-  pressSequentially: "typing into",
-  check: "checking",
-  uncheck: "unchecking",
-  hover: "hovering",
-  tap: "tapping",
-  focus: "focusing",
-  clear: "clearing",
-  selectOption: "selecting an option in",
-  setInputFiles: "uploading a file to",
-  dragTo: "dragging",
-  waitFor: "waiting for",
-  waitForSelector: "waiting for",
-  evaluate: "evaluating on"
-};
-var STATE_PHRASES = {
-  "not-found": "was not found on the page",
-  hidden: "never became visible",
-  "not-visible": "never became visible",
-  "not-enabled": "never became enabled",
-  "not-editable": "never became editable",
-  "not-stable": "never stopped moving",
-  "outside-viewport": "stayed outside the viewport",
-  "intercepts-pointer": "was covered by another element",
-  detached: "was detached from the DOM",
-  navigating: "was still navigating"
-};
-var STATE_MATCHERS = {
-  toBeVisible: { met: "visible", unmet: "never became visible" },
-  toBeHidden: { met: "hidden", unmet: "never became hidden" },
-  toBeEnabled: { met: "enabled", unmet: "never became enabled" },
-  toBeDisabled: { met: "disabled", unmet: "never became disabled" },
-  toBeChecked: { met: "checked", unmet: "never became checked" },
-  toBeEditable: { met: "editable", unmet: "never became editable" },
-  toBeFocused: { met: "focused", unmet: "never received focus" },
-  toBeAttached: { met: "attached", unmet: "never appeared in the DOM" },
-  toBeDetached: { met: "detached", unmet: "never left the DOM" },
-  toBeInViewport: { met: "in the viewport", unmet: "never entered the viewport" },
-  toBeEmpty: { met: "empty", unmet: "never became empty" }
-};
-var VALUE_MATCHERS = {
-  toHaveText: "text",
-  toContainText: "text containing",
-  toHaveValue: "value",
-  toHaveValues: "values",
-  toHaveAttribute: "attribute",
-  toHaveClass: "class",
-  toContainClass: "class",
-  toHaveId: "id",
-  toHaveCSS: "CSS",
-  toHaveJSProperty: "property",
-  toHaveAccessibleName: "accessible name",
-  toHaveAccessibleDescription: "accessible description",
-  toHaveRole: "role",
-  toHaveURL: "URL",
-  toHaveTitle: "title",
-  toHaveScreenshot: "screenshot",
-  toMatchAriaSnapshot: "ARIA snapshot"
-};
-var NETWORK_ERRORS = {
-  ERR_CONNECTION_REFUSED: "Connection refused loading",
-  ERR_CONNECTION_RESET: "Connection reset loading",
-  ERR_CONNECTION_CLOSED: "Connection closed loading",
-  ERR_CONNECTION_TIMED_OUT: "Connection timed out loading",
-  ERR_TIMED_OUT: "Connection timed out loading",
-  ERR_NAME_NOT_RESOLVED: "DNS lookup failed for",
-  ERR_INTERNET_DISCONNECTED: "No network while loading",
-  ERR_ADDRESS_UNREACHABLE: "Address unreachable loading",
-  ERR_ABORTED: "Navigation aborted loading",
-  ERR_EMPTY_RESPONSE: "Empty response loading",
-  ERR_TOO_MANY_REDIRECTS: "Too many redirects loading",
-  ERR_SSL_PROTOCOL_ERROR: "TLS error loading",
-  ERR_CERT_AUTHORITY_INVALID: "Untrusted certificate loading",
-  ERR_CERT_COMMON_NAME_INVALID: "Certificate name mismatch loading",
-  ERR_CERT_DATE_INVALID: "Expired certificate loading",
-  ERR_BLOCKED_BY_CLIENT: "Request blocked loading",
-  ERR_FAILED: "Request failed loading",
-  ERR_HTTP_RESPONSE_CODE_FAILURE: "HTTP error loading",
-  NS_ERROR_CONNECTION_REFUSED: "Connection refused loading",
-  NS_ERROR_UNKNOWN_HOST: "DNS lookup failed for",
-  NS_ERROR_NET_TIMEOUT: "Connection timed out loading",
-  NS_ERROR_OFFLINE: "No network while loading",
-  NS_ERROR_ABORT: "Navigation aborted loading",
-  NS_BINDING_ABORTED: "Navigation aborted loading"
-};
-function formatTimeout(ms) {
-  if (ms < 1e3) return `${ms} ms`;
-  const seconds = ms / 1e3;
-  const rounded = Math.round(seconds * 10) / 10;
-  return `${Number.isInteger(rounded) ? rounded.toFixed(0) : rounded} s`;
+// src/internal/capture/resource-ledger.ts
+var fs19 = __toESM(require("fs"));
+var path20 = __toESM(require("path"));
+var import_node_module2 = require("module");
+
+// src/internal/capture/quiet-capture.ts
+var import_node_module = require("module");
+var path18 = __toESM(require("path"));
+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 routeOf(url) {
+function resolveBoxing() {
   try {
-    const parsed = new URL(url);
-    return `${parsed.pathname}${parsed.search}` || "/";
+    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: [path18.dirname(playwrightPackageJson), path18.join(root, "dist") + path18.sep]
+      };
+    }
   } catch {
-    return url;
   }
+  return null;
 }
-function truncateValue(value, max) {
-  const flat = value.replace(/\s+/g, " ").trim();
-  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+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 countNoun(locator, count) {
-  const role = locator ? /getByRole\(\s*['"]([a-z]+)['"]/.exec(locator)?.[1] : null;
-  const noun = role ?? "element";
-  if (count === 1) return noun;
-  return noun.endsWith("s") ? noun : noun.endsWith("x") || noun.endsWith("ch") ? `${noun}es` : `${noun}s`;
+function internalCall(owner, run) {
+  const wrap = owner?._wrapApiCall;
+  if (typeof wrap !== "function") return run();
+  return wrap.call(owner, run, { internal: true, title: "Piwi capture" });
 }
-function textOfGetByText(locator) {
-  if (!locator) return null;
-  const m = /^getByText\(\s*(['"`])((?:\\.|(?!\1)[^\\\n\r\u2028\u2029])*)\1\s*(?:,\s*\{[^}]*\})?\s*\)$/.exec(locator);
-  return m ? m[2] : null;
+
+// src/internal/capture/worker-metrics.ts
+var import_node_perf_hooks = require("perf_hooks");
+
+// src/internal/support/system-readers.ts
+var fs18 = __toESM(require("fs"));
+var path19 = __toESM(require("path"));
+var CLK_TCK = 100;
+function readText(file) {
+  try {
+    return fs18.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
 }
-function receivedDisplay(parsed) {
-  const received = parsed.received ?? "";
-  if (parsed.assertion !== "toHaveURL") return received;
-  const m = /^"?(https?:\/\/[^"\s]+)"?$/.exec(received);
-  return m ? `"${routeOf(m[1])}"` : received;
+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 parsePsTime(text) {
+  const match = /^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+(?:\.\d+)?)$/.exec(text.trim());
+  if (!match) return null;
+  const [, days, hours, minutes, seconds] = match;
+  return ((Number(days ?? 0) * 24 + Number(hours ?? 0)) * 3600 + Number(minutes) * 60 + Number(seconds)) * 1e3;
 }
-function firstLineFallback(parsed) {
-  const line = (parsed.messageHead.split("\n")[0] ?? "").replace(/^Error:\s*/, "").replace(MASK_TOKEN_RE, "\u2026");
-  return truncateValue(line || "Unknown error", HEADLINE_MAX_CHARS);
+function parsePsOutput(text) {
+  const out = [];
+  for (const line of text.split("\n")) {
+    const match = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/.exec(line);
+    if (!match) continue;
+    const cpuMs = parsePsTime(match[4]);
+    if (cpuMs === null) continue;
+    out.push({
+      pid: Number(match[1]),
+      ppid: Number(match[2]),
+      rssKb: Number(match[3]),
+      cpuMs,
+      command: match[5].trim()
+    });
+  }
+  return out;
 }
-var Line = class {
-  constructor() {
-    this.parts = [];
+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);
   }
-  text(text) {
-    if (!text) return this;
-    const last = this.parts[this.parts.length - 1];
-    if (last && last.kind === "text") last.text += text;
-    else this.parts.push({ kind: "text", text });
-    return this;
+  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);
+    }
   }
-  locator(text) {
-    this.parts.push({ kind: "locator", text });
-    return this;
+  return out;
+}
+var ProcFs = class {
+  constructor(root = "/proc") {
+    this.root = root;
   }
-  value(text) {
-    this.parts.push({ kind: "value", text });
-    return this;
+  /** Whether this looks like a Linux `/proc` at all. */
+  available() {
+    return fs18.existsSync(path19.join(this.root, "stat"));
   }
-  toString() {
-    return this.parts.map((p) => p.text).join("");
+  /** Every process, keyed by pid. */
+  table() {
+    const out = /* @__PURE__ */ new Map();
+    let names;
+    try {
+      names = fs18.readdirSync(this.root);
+    } catch {
+      return out;
+    }
+    for (const name of names) {
+      if (!/^\d+$/.test(name)) continue;
+      const text = readText(path19.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(path19.join(this.root, String(pid), "stat"));
+    return text ? parseProcStat(pid, text) : null;
+  }
+  runWaitMs(pid) {
+    const text = readText(path19.join(this.root, String(pid), "schedstat"));
+    return text ? parseSchedstat(text) : null;
+  }
+  cmdline(pid) {
+    return (readText(path19.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(path19.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 fs18.promises.readFile(path19.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 {
+      fs18.writeFileSync(path19.join(this.root, String(pid), "clear_refs"), "5");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  cpuTicks() {
+    const text = readText(path19.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(path19.join(this.root, "pressure", resource));
+    return text ? parsePsiTotal(text) : null;
+  }
+  memAvailableKb() {
+    const text = readText(path19.join(this.root, "meminfo"));
+    return text ? parseKbField(text, "MemAvailable") : null;
+  }
+  /** Open file descriptors of a process. */
+  fdCount(pid) {
+    try {
+      return fs18.readdirSync(path19.join(this.root, String(pid), "fd")).length;
+    } catch {
+      return null;
+    }
+  }
+};
+var UNLIMITED = 2 ** 60;
+function numberIn(text, pattern) {
+  if (text === null) return null;
+  const raw = pattern ? pattern.exec(text)?.[1] : text.trim();
+  const value = Number(raw);
+  return raw !== void 0 && raw !== "" && Number.isFinite(value) ? value : null;
+}
+var CgroupFs = class {
+  constructor(procRoot = "/proc", cgroupRoot = "/sys/fs/cgroup", pid = "self") {
+    this.procRoot = procRoot;
+    this.cgroupRoot = cgroupRoot;
+    this.pid = pid;
+  }
+  /** The directory of a controller (v1) or of the unified hierarchy (v2), when it exists. */
+  dirs() {
+    const text = readText(path19.join(this.procRoot, String(this.pid), "cgroup"));
+    if (!text) return null;
+    const v1 = /* @__PURE__ */ new Map();
+    let v2 = null;
+    for (const line of text.split("\n")) {
+      const match = /^\d+:([^:]*):(.*)$/.exec(line.trim());
+      if (!match) continue;
+      if (match[1] === "") v2 = match[2];
+      else for (const controller of match[1].split(",")) v1.set(controller, match[2]);
+    }
+    const pick = (mount, sub) => {
+      const nested = path19.join(mount, sub);
+      if (fs18.existsSync(nested)) return nested;
+      return fs18.existsSync(mount) ? mount : null;
+    };
+    if (v1.has("memory") || v1.has("cpu")) {
+      const memoryPath = v1.get("memory");
+      const cpuPath = v1.get("cpu");
+      const cpuMount = ["cpu,cpuacct", "cpu"].map((name) => path19.join(this.cgroupRoot, name)).find((dir) => fs18.existsSync(dir));
+      return {
+        version: 1,
+        memory: memoryPath !== void 0 ? pick(path19.join(this.cgroupRoot, "memory"), memoryPath) : null,
+        cpu: cpuPath !== void 0 && cpuMount ? pick(cpuMount, cpuPath) : null
+      };
+    }
+    if (v2 !== null && fs18.existsSync(path19.join(this.cgroupRoot, "cgroup.controllers"))) {
+      const dir = pick(this.cgroupRoot, v2);
+      return { version: 2, memory: dir, cpu: dir };
+    }
+    return null;
+  }
+  read() {
+    const dirs = this.dirs();
+    if (!dirs) return null;
+    const file = (dir, name) => dir ? readText(path19.join(dir, name)) : null;
+    if (dirs.version === 2) {
+      const max = file(dirs.memory, "memory.max");
+      const cpuMax = file(dirs.cpu, "cpu.max")?.trim().split(/\s+/);
+      const quota = cpuMax && cpuMax[0] !== "max" ? Number(cpuMax[0]) / Number(cpuMax[1]) : null;
+      const throttledUs = numberIn(file(dirs.cpu, "cpu.stat"), /^throttled_usec (\d+)/m);
+      return {
+        version: 2,
+        memoryLimitBytes: max === null || max.trim() === "max" ? null : numberIn(max),
+        memoryCurrentBytes: numberIn(file(dirs.memory, "memory.current")),
+        memoryPeakBytes: numberIn(file(dirs.memory, "memory.peak")),
+        oomKills: numberIn(file(dirs.memory, "memory.events"), /^oom_kill (\d+)/m),
+        cpuQuotaCores: quota !== null && Number.isFinite(quota) ? quota : null,
+        throttledMs: throttledUs === null ? null : throttledUs / 1e3
+      };
+    }
+    const limit = numberIn(file(dirs.memory, "memory.limit_in_bytes"));
+    const quotaUs = numberIn(file(dirs.cpu, "cpu.cfs_quota_us"));
+    const periodUs = numberIn(file(dirs.cpu, "cpu.cfs_period_us"));
+    const throttledNs = numberIn(file(dirs.cpu, "cpu.stat"), /^throttled_time (\d+)/m);
+    return {
+      version: 1,
+      memoryLimitBytes: limit !== null && limit < UNLIMITED ? limit : null,
+      memoryCurrentBytes: numberIn(file(dirs.memory, "memory.usage_in_bytes")),
+      memoryPeakBytes: numberIn(file(dirs.memory, "memory.max_usage_in_bytes")),
+      oomKills: numberIn(file(dirs.memory, "memory.oom_control"), /^oom_kill (\d+)/m),
+      cpuQuotaCores: quotaUs !== null && quotaUs > 0 && periodUs ? quotaUs / periodUs : null,
+      throttledMs: throttledNs === null ? null : throttledNs / 1e6
+    };
+  }
+};
+
+// 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 path20.relative(process.cwd(), file.replace(/^file:\/\//, "")).split(path20.sep).join("/");
+}
+function isLibraryFile(file) {
+  return file.startsWith("node:") || file.startsWith("internal/") || file.includes(`${path20.sep}node_modules${path20.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)(path20.join(path20.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((resolve7) => setTimeout(resolve7, 0));
+  return countHandles();
+}
+function settleWithin(promise, ms) {
+  let timer;
+  return Promise.race([
+    promise.catch(() => void 0),
+    new Promise((resolve7) => {
+      timer = setTimeout(resolve7, 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 {
+        fs19.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/collect/resource-verdicts.ts
+var path21 = __toESM(require("path"));
+var OPEN_STEP_TITLES = {
+  "Create context": "context",
+  "Launch persistent context": "context",
+  "Launch browser": "browser",
+  "Connect over CDP": "browser"
+};
+var CLOSE_STEP_TITLES = {
+  "Close context": "context",
+  "Close browser": "browser"
+};
+function parseResourceCensus(body) {
+  if (!body) return null;
+  try {
+    const value = JSON.parse(body.toString());
+    if (value?.v !== 1 || !Array.isArray(value.born) || !Array.isArray(value.closed) || !Array.isArray(value.open)) {
+      return null;
+    }
+    if (typeof value.worker !== "number" || typeof value.at !== "number") return null;
+    return value;
+  } catch {
+    return null;
+  }
+}
+function parseResourceResults(text) {
+  return text.split("\n").map((line) => line.trim() ? parseResourceCensus(line) : null).filter((census) => census !== null);
+}
+function userFixturesOf(steps) {
+  const out = [];
+  const walk = (list) => {
+    for (const step of list) {
+      const file = step.location?.file;
+      if (step.category === "fixture" && file && !file.includes(`${path21.sep}node_modules${path21.sep}`)) {
+        const name = step.title.replace(/^(?:Fixture\s+|fixture:\s*)/, "").replace(/^"(.*)"$/, "$1");
+        if (!name.startsWith("piwi")) out.push(`${name} (${relativeFile(file)}:${step.location.line})`);
+      }
+      walk(step.steps ?? []);
+    }
+  };
+  walk(steps);
+  return [...new Set(out)];
+}
+function tallyLifecycleSteps(file, steps) {
+  const tally = { file, opened: [], closed: { context: 0, browser: 0 } };
+  const walk = (list) => {
+    for (const step of list) {
+      if (step.category === "fixture") continue;
+      if (step.category === "pw:api") {
+        const opened = OPEN_STEP_TITLES[step.title];
+        const closed = CLOSE_STEP_TITLES[step.title];
+        if (opened) {
+          tally.opened.push({
+            kind: opened,
+            site: step.location ? `${relativeFile(step.location.file)}:${step.location.line}` : null
+          });
+        }
+        if (closed) tally.closed[closed]++;
+      }
+      walk(step.steps ?? []);
+    }
+  };
+  walk(steps);
+  return tally;
+}
+function relativeFile(file) {
+  return path21.relative(process.cwd(), file).split(path21.sep).join("/");
+}
+function buildResourceReport(input) {
+  const findings = [];
+  const byWorker = /* @__PURE__ */ new Map();
+  for (const census of input.censuses) {
+    const list = byWorker.get(census.worker) ?? [];
+    list.push(census);
+    byWorker.set(census.worker, list);
+  }
+  const leaked = [];
+  const idle = [];
+  const all = [];
+  for (const censuses of byWorker.values()) {
+    censuses.sort((a, b) => a.at - b.at);
+    const tracked = /* @__PURE__ */ new Map();
+    for (const census of censuses) {
+      for (const birth of census.born) {
+        tracked.set(birth.id, {
+          worker: census.worker,
+          birth,
+          bornCensus: census,
+          close: null,
+          lastOpenAt: null,
+          used: void 0,
+          series: [],
+          mainCpu: []
+        });
+      }
+      for (const close of census.closed) {
+        const entry = tracked.get(close.id);
+        if (!entry) continue;
+        entry.close = close;
+        if (close.used !== void 0) entry.used = close.used;
+      }
+      for (const open of census.open) {
+        const entry = tracked.get(open.id);
+        if (!entry) continue;
+        entry.lastOpenAt = census.at;
+        if (open.used !== void 0) entry.used = open.used;
+        if (census.test) entry.series.push({ pages: open.pages, listeners: open.listeners, routes: open.routes });
+        if (open.main) entry.mainCpu.push({ at: census.at, cpuMs: open.main.cpuMs });
+      }
+    }
+    const testCensuses = censuses.filter((census) => census.test !== null);
+    const workerEnded = censuses.some((census) => census.test === null);
+    for (const entry of tracked.values()) {
+      all.push(entry);
+      if (entry.birth.kind === "page" && entry.used === false && !entry.bornCensus.test?.failed) idle.push(entry);
+      const verdict = leakVerdict(entry, testCensuses, workerEnded);
+      if (verdict) leaked.push({ tracked: entry, ...verdict });
+    }
+  }
+  findings.push(...groupLeaks(leaked, all));
+  findings.push(...pilingFindings(all));
+  findings.push(...handleFindings(byWorker));
+  findings.push(...groupIdle(idle, input.fixturesByTest ?? /* @__PURE__ */ new Map()));
+  findings.push(...probableFindings(input.tallies ?? []));
+  const counts = { leaked: 0, idle: 0, piling: 0, handle: 0, probable: 0 };
+  for (const finding of findings) counts[finding.verdict] += finding.verdict === "idle" ? finding.count : 1;
+  return { findings, counts };
+}
+function sameFile(birth, ref) {
+  return !!ref && !!birth.test && ref.file === birth.test.file;
+}
+function insideBlock(birth, ref) {
+  if (!ref || !sameFile(birth, ref)) return false;
+  return birth.test.suite.every((title, index) => ref.suite[index] === title);
+}
+function leakVerdict(entry, testCensuses, workerEnded) {
+  const { birth, close, bornCensus } = entry;
+  if (birth.reused || birth.phase === "worker" || birth.fixture?.worker || !birth.test) return null;
+  if (birth.kind === "context" && birth.implicit) return null;
+  if (close?.byPiwi) return { scope: "test", heldMs: 0, untilWorkerEnd: false };
+  const closedByShutdown = !!close && (close.phase === "worker" || close.test === null);
+  if (birth.phase === "beforeAll" || birth.phase === "afterAll") {
+    if (close && !closedByShutdown && sameFile(birth, close.test)) return null;
+    const ended = workerEnded || testCensuses.some((census) => census.at >= bornCensus.at && !insideBlock(birth, census.test));
+    if (!ended) return null;
+    const lastInside = [...testCensuses].reverse().find((census) => insideBlock(birth, census.test));
+    const blockEnd = lastInside?.at ?? bornCensus.at;
+    const end2 = close?.at ?? entry.lastOpenAt ?? blockEnd;
+    return { scope: "describe", heldMs: Math.max(0, end2 - blockEnd), untilWorkerEnd: !close || closedByShutdown };
+  }
+  if (bornCensus.test === null || bornCensus.test.id !== birth.test.id) return null;
+  if (bornCensus.test.failed) return null;
+  const openAtItsEnd = bornCensus.open.some((open) => open.id === birth.id);
+  if (!openAtItsEnd) return null;
+  if (close && !closedByShutdown && (close.test?.id === birth.test.id || sameFile(birth, close.test))) return null;
+  const end = close?.at ?? entry.lastOpenAt ?? bornCensus.at;
+  return { scope: "test", heldMs: Math.max(0, end - bornCensus.at), untilWorkerEnd: !close || closedByShutdown };
+}
+function whereOf(birth) {
+  if (birth.opener !== void 0) {
+    return `popup${birth.trigger ? ` after ${birth.trigger}` : ""}${birth.site ? ` at ${birth.site}` : ""}`;
+  }
+  if (birth.fixture) {
+    const at = birth.site ?? birth.fixture.location;
+    return `fixture "${birth.fixture.title}"${at ? ` at ${at}` : ""}`;
+  }
+  return birth.site ?? "an unknown line";
+}
+function afterTestCpu(entry) {
+  const readings = entry.mainCpu;
+  if (readings.length < 2) return 0;
+  const first = readings.find((reading) => reading.at >= entry.bornCensus.at) ?? readings[0];
+  return Math.max(0, readings[readings.length - 1].cpuMs - first.cpuMs);
+}
+function siteOf(birth) {
+  return birth.site ?? birth.fixture?.location ?? null;
+}
+var keyOf = (worker, id) => `${worker}:${id}`;
+function groupLeaks(leaked, all) {
+  const leaks = new Map(leaked.map((leak) => [keyOf(leak.tracked.worker, leak.tracked.birth.id), leak]));
+  const tracked = new Map(all.map((entry) => [keyOf(entry.worker, entry.birth.id), entry]));
+  const groups = /* @__PURE__ */ new Map();
+  const groupKey = (leak) => `${leak.scope}|${leak.tracked.birth.kind}|${whereOf(leak.tracked.birth)}`;
+  for (const leak of leaked) {
+    const { birth } = leak.tracked;
+    if (birth.kind === "context" && birth.implicit) continue;
+    if (foldTarget(leak.tracked, leaks, tracked)) continue;
+    const key = groupKey(leak);
+    const group = groups.get(key) ?? {
+      verdict: "leaked",
+      kind: birth.kind,
+      where: whereOf(birth),
+      site: siteOf(birth),
+      scope: leak.scope,
+      tests: 0,
+      count: 0,
+      heldMs: 0,
+      untilWorkerEnd: false,
+      pages: 0,
+      testIds: /* @__PURE__ */ new Set(),
+      ...leak.scope === "describe" && birth.test?.suite.length ? { detail: `beforeAll of "${birth.test.suite.join(" \u203A ")}"` } : {}
+    };
+    group.count++;
+    if (birth.test) group.testIds.add(birth.test.id);
+    group.heldMs = Math.max(group.heldMs ?? 0, leak.heldMs);
+    group.untilWorkerEnd = group.untilWorkerEnd || leak.untilWorkerEnd;
+    if (leak.tracked.close?.byPiwi) group.closedByPiwi = true;
+    if (birth.kind === "page" && leak.scope === "test") addCpu(group, afterTestCpu(leak.tracked));
+    groups.set(key, group);
+  }
+  for (const leak of leaked) {
+    if (leak.tracked.birth.kind !== "page") continue;
+    const root = foldTarget(leak.tracked, leaks, tracked);
+    const group = root ? groups.get(groupKey(root)) : void 0;
+    if (!group) continue;
+    group.pages = (group.pages ?? 0) + 1;
+    if (root.scope === "test") addCpu(group, afterTestCpu(leak.tracked));
+  }
+  return [...groups.values()].map(({ testIds, ...finding }) => ({ ...finding, tests: testIds.size })).sort((a, b) => a.scope === b.scope ? b.count - a.count : a.scope === "test" ? -1 : 1);
+}
+function addCpu(group, cpuMs) {
+  if (cpuMs > 0) group.afterTestCpuMs = (group.afterTestCpuMs ?? 0) + cpuMs;
+}
+function foldTarget(entry, leaks, tracked) {
+  let parentId = entry.birth.parent;
+  while (parentId !== null) {
+    const key = keyOf(entry.worker, parentId);
+    const parent = tracked.get(key);
+    if (!parent) return null;
+    if (!(parent.birth.kind === "context" && parent.birth.implicit)) return leaks.get(key) ?? null;
+    parentId = parent.birth.parent;
+  }
+  return null;
+}
+function groupIdle(idle, fixturesByTest) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of idle) {
+    const { birth } = entry;
+    const fixtures = birth.test ? fixturesByTest.get(birth.test.id) ?? [] : [];
+    const detail = birth.fixture && fixtures.length ? `set up with ${fixtures.join(", ")}` : void 0;
+    const where = whereOf(birth);
+    const key = `${where}|${detail ?? ""}`;
+    const group = groups.get(key) ?? {
+      verdict: "idle",
+      kind: "page",
+      where,
+      site: siteOf(birth),
+      tests: 0,
+      count: 0,
+      testIds: /* @__PURE__ */ new Set(),
+      ...detail ? { detail } : {}
+    };
+    group.count++;
+    if (birth.test) group.testIds.add(birth.test.id);
+    groups.set(key, group);
+  }
+  return [...groups.values()].map(({ testIds, ...finding }) => ({ ...finding, tests: testIds.size })).sort((a, b) => b.count - a.count);
+}
+function pilingFindings(all) {
+  const out = [];
+  for (const entry of all) {
+    for (const what of ["pages", "listeners", "routes"]) {
+      const values = entry.series.map((point) => point[what]).filter((v) => typeof v === "number");
+      if (values.length < 3) continue;
+      const rising = values.every((value, i) => i === 0 || value >= values[i - 1]);
+      const from = values[0];
+      const to = values[values.length - 1];
+      if (!rising || to - from < 2) continue;
+      out.push({
+        verdict: "piling",
+        kind: entry.birth.kind,
+        where: whereOf(entry.birth),
+        site: siteOf(entry.birth),
+        tests: values.length,
+        count: 1,
+        growth: { what, from, to, tests: values.length }
+      });
+    }
+  }
+  return out.sort((a, b) => b.growth.to - b.growth.from - (a.growth.to - a.growth.from));
+}
+function handleFindings(byWorker) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const censuses of byWorker.values()) {
+    const ordered = censuses.filter((census) => census.test && census.handles).sort((a, b) => a.at - b.at);
+    for (let i = 0; i < ordered.length - 1; i++) {
+      const census = ordered[i];
+      const next = ordered[i + 1];
+      for (const [type, end] of Object.entries(census.handles.end)) {
+        const grew = end - (census.handles.start[type] ?? 0);
+        if (grew <= 0 || (next.handles.start[type] ?? 0) < end) continue;
+        const test = census.test;
+        const key = `${test.id}|${type}`;
+        const group = groups.get(key) ?? {
+          verdict: "handle",
+          kind: "handle",
+          where: type,
+          tests: 1,
+          count: 0,
+          detail: `"${test.title ?? ""}" (${test.file})`
+        };
+        group.count += grew;
+        groups.set(key, group);
+      }
+    }
+  }
+  return [...groups.values()];
+}
+function probableFindings(tallies) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const tally of tallies) {
+    const merged = byFile.get(tally.file) ?? { file: tally.file, opened: [], closed: { context: 0, browser: 0 } };
+    merged.opened.push(...tally.opened);
+    merged.closed.context += tally.closed.context;
+    merged.closed.browser += tally.closed.browser;
+    byFile.set(tally.file, merged);
+  }
+  const out = [];
+  for (const tally of byFile.values()) {
+    for (const kind of ["browser", "context"]) {
+      const opened = tally.opened.filter((o) => o.kind === kind);
+      if (opened.length <= tally.closed[kind]) continue;
+      const sites = [...new Set(opened.map((o) => o.site ?? tally.file))];
+      out.push({
+        verdict: "probable",
+        kind,
+        where: sites.join(", "),
+        tests: 0,
+        count: opened.length - tally.closed[kind],
+        detail: `${opened.length} opened, ${tally.closed[kind]} closed in ${tally.file}`
+      });
+    }
+  }
+  return out;
+}
+function formatHeld(ms) {
+  if (ms < 1e3) return `${Math.round(ms)} ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)} s`;
+  const minutes = Math.floor(ms / 6e4);
+  const seconds = Math.round(ms % 6e4 / 1e3);
+  return seconds ? `${minutes} min ${seconds} s` : `${minutes} min`;
+}
+var KIND_LABEL = {
+  browser: "browser",
+  context: "context",
+  page: "page",
+  request: "API context",
+  handle: "handle"
+};
+var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+var HANDLE_LABEL = {
+  TCPServerWrap: "server",
+  FSEventWrap: "file watcher",
+  StatWatcher: "file watcher"
+};
+function findingLine(finding) {
+  const verdict = finding.verdict.padEnd(8);
+  const label = finding.verdict === "handle" ? HANDLE_LABEL[finding.where] ?? finding.where : finding.growth ? finding.growth.what : KIND_LABEL[finding.kind];
+  const kind = label.padEnd(11);
+  const parts = finding.verdict === "handle" ? [] : [finding.where];
+  switch (finding.verdict) {
+    case "leaked": {
+      if (finding.count > 1) parts.push(`${finding.count} ${KIND_LABEL[finding.kind]}s`);
+      if (finding.detail) parts.push(finding.detail);
+      if (finding.pages) parts.push(`with ${plural(finding.pages, "page")}`);
+      if (finding.tests) parts.push(plural(finding.tests, "test"));
+      const past = finding.scope === "describe" ? "its describe block" : "its test";
+      if (finding.closedByPiwi) parts.push("closed by Piwi at the end of its test");
+      else if (finding.untilWorkerEnd)
+        parts.push(`open until the worker shut down (${formatHeld(finding.heldMs ?? 0)} past ${past})`);
+      else parts.push(`open ${formatHeld(finding.heldMs ?? 0)} past ${past}`);
+      if ((finding.afterTestCpuMs ?? 0) >= 500)
+        parts.push(`${formatHeld(finding.afterTestCpuMs)} of page CPU after its test`);
+      break;
+    }
+    case "idle":
+      parts.push(plural(finding.count, "page"));
+      if (finding.tests) parts.push(plural(finding.tests, "test"));
+      if (finding.detail) parts.push(finding.detail);
+      break;
+    case "piling": {
+      const growth = finding.growth;
+      const noun = growth.what === "pages" ? "open pages" : growth.what === "routes" ? "route handlers" : "listeners";
+      parts.push(`${growth.from} \u2192 ${growth.to} ${noun} over ${growth.tests} tests`);
+      break;
+    }
+    case "handle":
+      parts.push(`left running in the worker by ${finding.detail ?? "a test"}`);
+      break;
+    case "probable":
+      if (finding.detail) parts.push(finding.detail);
+      break;
+  }
+  return `  ${verdict} ${kind} ${parts.join(" \xB7 ")}`;
+}
+function formatResourceSummary(report, leakCheck, maxLines = 10) {
+  if (report.findings.length === 0) return [];
+  const { counts } = report;
+  const head = [
+    counts.leaked ? plural(counts.leaked, "leak") : "",
+    counts.idle ? `${plural(counts.idle, "idle page")}` : "",
+    counts.piling ? `${counts.piling} piling up` : "",
+    counts.handle ? plural(counts.handle, "handle") + " left in workers" : "",
+    counts.probable ? plural(counts.probable, "probable leak") : ""
+  ].filter(Boolean);
+  const lines = [`Resources: ${head.join(" \xB7 ")}`];
+  for (const finding of report.findings.slice(0, maxLines)) lines.push(findingLine(finding));
+  const rest = report.findings.length - maxLines;
+  if (rest > 0) lines.push(`  \u2026 and ${plural(rest, "more finding")}`);
+  const testLeaks = report.findings.some((f) => f.verdict === "leaked" && f.scope === "test" && !f.closedByPiwi);
+  if (testLeaks && leakCheck === "report") {
+    lines.push(
+      "Set leakCheck: 'fail' (PIWI_LEAK_CHECK=fail) to fail the tests that leave what they open, or 'close' to close it."
+    );
+  }
+  if (counts.probable) {
+    lines.push(
+      "Probable leaks are counted from the steps alone; the capture fixtures (extendPiwiFixtures) make them exact."
+    );
+  }
+  return lines;
+}
+
+// src/internal/collect/process-sampler.ts
+var fs20 = __toESM(require("fs"));
+var os8 = __toESM(require("os"));
+var path22 = __toESM(require("path"));
+var import_node_child_process2 = require("child_process");
+var WALK_FILE_CAP = 1e4;
+var SERIES_CAP = 3600;
+var PLAYWRIGHT_TEMP = /^(playwright_\w+dev_profile-|playwright-artifacts-)/;
+function round12(value) {
+  return Math.round(value * 10) / 10;
+}
+function pct(part, whole) {
+  return whole > 0 ? round12(part / whole * 100) : null;
+}
+function nodeCpuTicks() {
+  const cpus2 = os8.cpus();
+  if (cpus2.length === 0) return null;
+  let busy = 0;
+  let idle = 0;
+  for (const cpu of cpus2) {
+    busy += cpu.times.user + cpu.times.nice + cpu.times.sys + cpu.times.irq;
+    idle += cpu.times.idle;
+  }
+  return { busy, idle, iowait: 0, steal: 0, total: busy + idle };
+}
+function defaultPs() {
+  return new Promise((resolve7, reject) => {
+    (0, import_node_child_process2.execFile)(
+      "ps",
+      ["-A", "-o", "pid=,ppid=,rss=,time=,command="],
+      { timeout: 2e3, maxBuffer: 8 * 1024 * 1024 },
+      (error, stdout) => error ? reject(error) : resolve7(stdout)
+    );
+  });
+}
+function freeBytes(dir) {
+  let current = path22.resolve(dir);
+  for (; ; ) {
+    try {
+      const stats = fs20.statfsSync(current);
+      return stats.bavail * stats.bsize;
+    } catch {
+      const parent = path22.dirname(current);
+      if (parent === current) return null;
+      current = parent;
+    }
+  }
+}
+async function dirBytes(dir, budget) {
+  let bytes = 0;
+  let entries;
+  try {
+    entries = await fs20.promises.readdir(dir, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  for (const entry of entries) {
+    if (budget.files <= 0) return bytes;
+    const full = path22.join(dir, entry.name);
+    if (entry.isDirectory()) bytes += await dirBytes(full, budget);
+    else if (entry.isFile()) {
+      budget.files--;
+      try {
+        bytes += (await fs20.promises.lstat(full)).size;
+      } catch {
+      }
+    }
+  }
+  return bytes;
+}
+var RunSampler = class {
+  constructor(options = {}) {
+    this.timer = null;
+    this.running = null;
+    this.samples = 0;
+    this.startedAt = 0;
+    this.tracked = /* @__PURE__ */ new Map();
+    this.treeMeasured = false;
+    this.waitMeasured = false;
+    this.cpuStart = null;
+    this.cpuPrevious = null;
+    this.series = [];
+    this.pressureStart = { cpu: null, memory: null };
+    this.containerStart = null;
+    this.memoryKind = null;
+    this.peakBytes = null;
+    this.peakAtMs = null;
+    this.largest = null;
+    this.rssFallbackPids = /* @__PURE__ */ new Set();
+    this.lowestAvailableKb = null;
+    this.peakInUse = null;
+    this.peakInUseIsLowerBound = false;
+    this.lowestFree = null;
+    this.rootPid = options.rootPid ?? process.pid;
+    this.platform = options.platform ?? process.platform;
+    this.proc = new ProcFs(options.procRoot);
+    this.cgroup = new CgroupFs(options.procRoot, options.cgroupRoot);
+    this.outputDirs = [...new Set((options.outputDirs ?? []).map((dir) => path22.resolve(dir)))];
+    this.tmpDir = options.tmpDir ?? os8.tmpdir();
+    this.intervalMs = options.intervalMs ?? 1e3;
+    this.heavyEvery = Math.max(1, options.heavyEvery ?? 5);
+    this.now = options.now ?? Date.now;
+    this.runPs = options.runPs ?? defaultPs;
+    this.linux = this.platform === "linux" && this.proc.available();
+  }
+  /** Take the first sample and sample on a timer that never keeps the process alive. */
+  start() {
+    if (this.timer) return;
+    this.startedAt = this.now();
+    this.cpuStart = this.cpuTicks();
+    this.cpuPrevious = this.cpuStart;
+    if (this.linux) {
+      this.pressureStart = { cpu: this.proc.pressureUs("cpu"), memory: this.proc.pressureUs("memory") };
+      this.containerStart = this.cgroup.read();
+    }
+    this.schedule();
+    this.timer = setInterval(() => this.schedule(), this.intervalMs);
+    this.timer.unref?.();
+  }
+  /** Take the last sample and return the run's profile. Never throws. */
+  async stop() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    try {
+      await this.running;
+      await this.sample(true);
+    } catch {
+    }
+    return this.profile(await this.leftoverBytes());
+  }
+  schedule() {
+    if (this.running) return;
+    const heavy = this.samples % this.heavyEvery === 0;
+    this.running = this.sample(heavy).catch(() => void 0).finally(() => {
+      this.running = null;
+    });
+  }
+  cpuTicks() {
+    return this.linux ? this.proc.cpuTicks() : nodeCpuTicks();
+  }
+  async sample(heavy) {
+    this.samples++;
+    const ticks = this.cpuTicks();
+    if (ticks && this.cpuPrevious) {
+      const busy = pct(ticks.busy - this.cpuPrevious.busy, ticks.total - this.cpuPrevious.total);
+      if (busy !== null && this.series.length < SERIES_CAP) this.series.push(busy);
+    }
+    if (ticks) this.cpuPrevious = ticks;
+    const availableKb = this.linux ? this.proc.memAvailableKb() : Math.round(os8.freemem() / 1024);
+    if (availableKb !== null) this.lowestAvailableKb = Math.min(this.lowestAvailableKb ?? Infinity, availableKb);
+    if (this.linux) await this.sampleLinuxTree(heavy);
+    else if (this.platform === "darwin" && heavy) await this.samplePsTree();
+    if (heavy) await this.sampleDisk();
+  }
+  track(key, role, cpuMs, waitMs) {
+    const known = this.tracked.get(key);
+    if (known) {
+      known.lastCpuMs = cpuMs;
+      known.lastWaitMs = waitMs;
+      if (role) known.role = role;
+      return;
+    }
+    const first = this.samples === 1;
+    this.tracked.set(key, {
+      role,
+      firstCpuMs: first ? cpuMs : 0,
+      firstWaitMs: first ? waitMs : waitMs === null ? null : 0,
+      lastCpuMs: cpuMs,
+      lastWaitMs: waitMs
+    });
+  }
+  /** The role of each process of the tree, a child of the runner being the web server unless it says otherwise. */
+  resolveRoles(tree, explicit) {
+    const roles = /* @__PURE__ */ new Map([[this.rootPid, "runner"]]);
+    for (const proc of tree) {
+      const parent = roles.get(proc.ppid);
+      const inherited = parent === "runner" || parent === "webServer" ? "webServer" : "other";
+      roles.set(proc.pid, explicit(proc) ?? inherited);
+    }
+    return roles;
+  }
+  async sampleLinuxTree(heavy) {
+    const table = this.proc.table();
+    const root = table.get(this.rootPid);
+    if (!root) return;
+    this.treeMeasured = true;
+    const tree = [root, ...descendantsOf(this.rootPid, table.values())];
+    const roles = this.resolveRoles(tree.slice(1), (proc) => {
+      const key = `${proc.pid}:${proc.start}`;
+      const known = this.tracked.get(key)?.role;
+      return known && !heavy ? known : roleOf(proc.comm, this.proc.cmdline(proc.pid));
+    });
+    for (const proc of tree) {
+      const waitMs = this.proc.runWaitMs(proc.pid);
+      if (waitMs !== null) this.waitMeasured = true;
+      this.track(`${proc.pid}:${proc.start}`, roles.get(proc.pid) ?? "other", proc.cpuMs, waitMs);
+    }
+    if (!heavy) return;
+    let total = 0;
+    let largest = null;
+    const memory = await Promise.all(
+      tree.map(async (proc) => {
+        const pss = await this.proc.pssKb(proc.pid);
+        if (pss !== null) return { proc, kb: pss, fallback: false };
+        return { proc, kb: this.proc.statusKb(proc.pid, "VmRSS"), fallback: true };
+      })
+    );
+    for (const { proc, kb, fallback } of memory) {
+      if (kb === null) continue;
+      if (fallback) this.rssFallbackPids.add(`${proc.pid}:${proc.start}`);
+      total += kb * 1024;
+      if (!largest || kb * 1024 > largest.bytes) largest = { role: roles.get(proc.pid) ?? "other", bytes: kb * 1024 };
+    }
+    this.memoryKind = memory.some((m) => m.kb !== null && !m.fallback) ? "pss" : memory.length ? "rss" : null;
+    this.notePeak(total, largest);
+  }
+  async samplePsTree() {
+    let list;
+    try {
+      list = parsePsOutput(await this.runPs());
+    } catch {
+      return;
+    }
+    const root = list.find((proc) => proc.pid === this.rootPid);
+    if (!root) return;
+    this.treeMeasured = true;
+    const tree = [root, ...descendantsOf(this.rootPid, list)];
+    const roles = this.resolveRoles(
+      tree.slice(1),
+      (proc) => roleOf(path22.basename(proc.command.split(" ")[0] ?? ""), proc.command)
+    );
+    let total = 0;
+    let largest = null;
+    for (const proc of tree) {
+      const role = roles.get(proc.pid) ?? "other";
+      this.track(String(proc.pid), role, proc.cpuMs, null);
+      total += proc.rssKb * 1024;
+      if (!largest || proc.rssKb * 1024 > largest.bytes) largest = { role, bytes: proc.rssKb * 1024 };
+    }
+    this.memoryKind = "rss";
+    this.notePeak(total, largest);
+  }
+  notePeak(total, largest) {
+    if (this.peakBytes === null || total > this.peakBytes) {
+      this.peakBytes = total;
+      this.peakAtMs = this.now() - this.startedAt;
+    }
+    if (largest && (!this.largest || largest.bytes > this.largest.bytes)) this.largest = largest;
+  }
+  async sampleDisk() {
+    for (const dir of [...this.outputDirs, this.tmpDir]) {
+      const free = freeBytes(dir);
+      if (free !== null) this.lowestFree = Math.min(this.lowestFree ?? Infinity, free);
+    }
+    const budget = { files: WALK_FILE_CAP };
+    let bytes = 0;
+    for (const dir of this.outputDirs) bytes += await dirBytes(dir, budget);
+    for (const name of await this.playwrightTempEntries((mtimeMs) => mtimeMs >= this.startedAt - 1e3)) {
+      bytes += await dirBytes(path22.join(this.tmpDir, name), budget);
+    }
+    if (budget.files <= 0) this.peakInUseIsLowerBound = true;
+    this.peakInUse = Math.max(this.peakInUse ?? 0, bytes);
+  }
+  /** Playwright's folders in the temp directory whose modification time passes `keep`. */
+  async playwrightTempEntries(keep) {
+    let names;
+    try {
+      names = await fs20.promises.readdir(this.tmpDir);
+    } catch {
+      return [];
+    }
+    const out = [];
+    for (const name of names) {
+      if (!PLAYWRIGHT_TEMP.test(name)) continue;
+      try {
+        if (keep((await fs20.promises.stat(path22.join(this.tmpDir, name))).mtimeMs)) out.push(name);
+      } catch {
+      }
+    }
+    return out;
+  }
+  async leftoverBytes() {
+    try {
+      const budget = { files: WALK_FILE_CAP };
+      let bytes = 0;
+      for (const name of await this.playwrightTempEntries((mtimeMs) => mtimeMs < this.startedAt - 1e3)) {
+        bytes += await dirBytes(path22.join(this.tmpDir, name), budget);
+      }
+      return bytes;
+    } catch {
+      return null;
+    }
+  }
+  profile(leftoverBytes) {
+    const wallMs = Math.max(0, this.now() - this.startedAt);
+    const notMeasured = [];
+    let byRole = null;
+    if (this.treeMeasured) {
+      byRole = {};
+      for (const entry of this.tracked.values()) {
+        const role = entry.role ?? "other";
+        const usage = byRole[role] ??= { cpuMs: 0, runWaitMs: this.waitMeasured ? 0 : null, processes: 0 };
+        usage.cpuMs += Math.max(0, entry.lastCpuMs - entry.firstCpuMs);
+        if (usage.runWaitMs !== null && entry.lastWaitMs !== null && entry.firstWaitMs !== null) {
+          usage.runWaitMs += Math.max(0, entry.lastWaitMs - entry.firstWaitMs);
+        }
+        usage.processes++;
+      }
+    } else {
+      notMeasured.push("CPU and memory of the run\u2019s processes");
+    }
+    if (this.treeMeasured && !this.waitMeasured) notMeasured.push("time waiting for a CPU");
+    const end = this.cpuTicks();
+    const start = this.cpuStart;
+    const total = end && start ? end.total - start.total : 0;
+    const machineCpu = {
+      busyPct: end && start ? pct(end.busy - start.busy, total) : null,
+      iowaitPct: this.linux && end && start ? pct(end.iowait - start.iowait, total) : null,
+      stealPct: this.linux && end && start ? pct(end.steal - start.steal, total) : null
+    };
+    if (!this.linux) notMeasured.push("steal");
+    const pressure = (resource, from) => {
+      if (!this.linux || from === null) return null;
+      const to = this.proc.pressureUs(resource);
+      return to === null || wallMs === 0 ? null : Math.min(100, round12((to - from) / 1e3 / wallMs * 100));
+    };
+    const cpuPressure = pressure("cpu", this.pressureStart.cpu);
+    const memoryPressure = pressure("memory", this.pressureStart.memory);
+    if (cpuPressure === null) notMeasured.push("CPU pressure");
+    const container = this.linux ? this.cgroup.read() : null;
+    const startContainer = this.containerStart;
+    const totalMemory = os8.totalmem();
+    const constrained = typeof process.constrainedMemory === "function" ? process.constrainedMemory() : void 0;
+    const limit = container?.memoryLimitBytes ?? (constrained && constrained > 0 ? constrained : null);
+    const raisedPeak = container?.memoryPeakBytes != null && startContainer?.memoryPeakBytes != null && container.memoryPeakBytes > startContainer.memoryPeakBytes ? container.memoryPeakBytes : null;
+    const delta = (to, from) => to != null && from != null ? Math.max(0, to - from) : null;
+    return {
+      platform: this.platform,
+      wallMs,
+      machine: {
+        cores: typeof os8.availableParallelism === "function" ? os8.availableParallelism() : os8.cpus().length,
+        memoryBytes: totalMemory,
+        memoryLimitBytes: limit !== null && limit < totalMemory ? limit : null,
+        cpuQuotaCores: container?.cpuQuotaCores ?? null
+      },
+      cpu: {
+        ...machineCpu,
+        pressurePct: cpuPressure,
+        series: this.series,
+        byRole,
+        throttledMs: delta(container?.throttledMs, startContainer?.throttledMs)
+      },
+      memory: {
+        kind: this.memoryKind,
+        peakBytes: this.peakBytes,
+        peakAtMs: this.peakAtMs,
+        largest: this.largest,
+        rssFallbacks: this.memoryKind === "pss" ? this.rssFallbackPids.size : 0,
+        pressurePct: memoryPressure,
+        lowestAvailableBytes: this.lowestAvailableKb === null ? null : this.lowestAvailableKb * 1024,
+        containerPeakBytes: raisedPeak,
+        oomKills: delta(container?.oomKills, startContainer?.oomKills)
+      },
+      disk: {
+        peakInUseBytes: this.peakInUse,
+        peakInUseIsLowerBound: this.peakInUseIsLowerBound,
+        lowestFreeBytes: this.lowestFree,
+        leftoverBytes
+      },
+      notMeasured
+    };
+  }
+};
+
+// src/internal/collect/machine-panel.ts
+function workerHealthOf(censuses) {
+  const measured = censuses.filter((census) => census.test && census.metrics);
+  if (measured.length === 0) return null;
+  let utilization = 0;
+  let switches = 0;
+  let worstP99 = 0;
+  for (const census of measured) {
+    const worker = census.metrics.worker;
+    utilization += worker.loopUtilization;
+    switches += worker.involuntarySwitches;
+    worstP99 = Math.max(worstP99, worker.loopDelayP99Ms);
+  }
+  return {
+    tests: measured.length,
+    loopUtilization: utilization / measured.length,
+    loopDelayP99Ms: worstP99,
+    involuntarySwitchesPerTest: switches / measured.length
+  };
+}
+function artifactKind(name, contentType) {
+  if (name === "trace") return "trace";
+  if (name === "video" || contentType.startsWith("video/")) return "video";
+  if (name === "screenshot" || contentType.startsWith("image/")) return "screenshot";
+  return "other";
+}
+function emptyArtifacts() {
+  return { trace: 0, video: 0, screenshot: 0, other: 0 };
+}
+var ROLE_LABEL = {
+  renderer: "renderers",
+  browser: "browsers",
+  worker: "workers",
+  gpu: "GPU",
+  utility: "browser utilities",
+  ffmpeg: "ffmpeg",
+  webServer: "web server",
+  runner: "runner",
+  other: "other"
+};
+var ROLE_SINGULAR = {
+  renderer: "renderer",
+  browser: "browser",
+  worker: "worker",
+  gpu: "GPU",
+  utility: "browser utility",
+  ffmpeg: "ffmpeg",
+  webServer: "web server",
+  runner: "runner",
+  other: "other"
+};
+var ARTIFACT_LABEL = {
+  trace: "traces",
+  video: "videos",
+  screenshot: "screenshots",
+  other: "other"
+};
+var BARS = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+function formatBytes(bytes) {
+  if (bytes >= 1024 ** 3) return `${(bytes / 1024 ** 3).toFixed(1)} GB`;
+  if (bytes >= 1024 ** 2) return `${Math.round(bytes / 1024 ** 2)} MB`;
+  return `${Math.max(0, Math.round(bytes / 1024))} kB`;
+}
+function sparkline(series, width = 24) {
+  if (series.length < 3) return "";
+  const buckets = Math.min(width, series.length);
+  let out = "";
+  for (let i = 0; i < buckets; i++) {
+    const slice = series.slice(
+      Math.floor(i * series.length / buckets),
+      Math.floor((i + 1) * series.length / buckets)
+    );
+    const mean = slice.reduce((sum, v) => sum + v, 0) / Math.max(1, slice.length);
+    out += BARS[Math.min(BARS.length - 1, Math.max(0, Math.floor(mean / 100 * BARS.length)))];
+  }
+  return out;
+}
+function clock(ms) {
+  const seconds = Math.round(ms / 1e3);
+  return `${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, "0")}`;
+}
+function cpuLine(profile) {
+  const parts = [];
+  const spark = sparkline(profile.cpu.series);
+  if (profile.cpu.busyPct !== null) parts.push(`${spark ? `${spark} ` : ""}${Math.round(profile.cpu.busyPct)}% busy`);
+  if (profile.cpu.pressurePct !== null) {
+    parts.push(`a task waited for a CPU ${Math.round(profile.cpu.pressurePct)}% of the time`);
+  }
+  const roles = Object.entries(profile.cpu.byRole ?? {});
+  const total = roles.reduce((sum, [, usage]) => sum + (usage?.cpuMs ?? 0), 0);
+  if (total > 0) {
+    const top = roles.filter(([, usage]) => (usage?.cpuMs ?? 0) >= total * 0.02).sort((a, b) => (b[1]?.cpuMs ?? 0) - (a[1]?.cpuMs ?? 0)).slice(0, 5).map(([role, usage]) => `${ROLE_LABEL[role]} ${formatHeld(usage.cpuMs)}`);
+    parts.push(`${formatHeld(total)} of CPU: ${top.join(" \xB7 ")}`);
+    const waiting = roles.filter(([, usage]) => (usage?.runWaitMs ?? 0) >= 1e3).sort((a, b) => (b[1]?.runWaitMs ?? 0) - (a[1]?.runWaitMs ?? 0))[0];
+    if (waiting) parts.push(`${ROLE_LABEL[waiting[0]]} waited ${formatHeld(waiting[1].runWaitMs)} for a CPU`);
+  }
+  if (profile.cpu.throttledMs)
+    parts.push(`the container's CPU quota held it back ${formatHeld(profile.cpu.throttledMs)}`);
+  return parts.length ? `  CPU      ${parts.join(" \xB7 ")}` : null;
+}
+function memoryLine(profile) {
+  const { memory, machine } = profile;
+  const parts = [];
+  if (memory.kind && memory.peakBytes !== null) {
+    const fallbacks = memory.rssFallbacks ? `, ${memory.rssFallbacks} by RSS` : "";
+    const at = memory.peakAtMs !== null ? ` at ${clock(memory.peakAtMs)}` : "";
+    parts.push(`peak ${formatBytes(memory.peakBytes)} (${memory.kind.toUpperCase()}${fallbacks})${at}`);
+    const limit = machine.memoryLimitBytes;
+    const whole = limit ?? machine.memoryBytes;
+    if (whole > 0)
+      parts.push(`${Math.round(memory.peakBytes / whole * 100)}% of the ${limit ? "limit" : "machine's memory"}`);
+    if (memory.largest)
+      parts.push(`largest process: ${ROLE_SINGULAR[memory.largest.role]} ${formatBytes(memory.largest.bytes)}`);
+  }
+  if (memory.containerPeakBytes !== null)
+    parts.push(`the container peaked at ${formatBytes(memory.containerPeakBytes)}`);
+  if (memory.oomKills) parts.push(`${memory.oomKills} process${memory.oomKills === 1 ? "" : "es"} killed for memory`);
+  if (memory.pressurePct !== null) {
+    parts.push(
+      memory.pressurePct >= 0.1 ? `a task waited for memory ${memory.pressurePct}% of the time` : "no memory pressure"
+    );
+  }
+  if (memory.lowestAvailableBytes !== null && memory.lowestAvailableBytes < machine.memoryBytes * 0.1) {
+    parts.push(`${formatBytes(memory.lowestAvailableBytes)} available at the low point`);
+  }
+  return parts.length ? `  Memory   ${parts.join(" \xB7 ")}` : null;
+}
+function diskLine(profile, artifacts) {
+  const parts = [];
+  if (artifacts) {
+    const kinds = Object.entries(artifacts).filter(([, bytes]) => bytes > 0);
+    const total = kinds.reduce((sum, [, bytes]) => sum + bytes, 0);
+    parts.push(
+      total > 0 ? `${formatBytes(total)} of artifacts (${kinds.sort((a, b) => b[1] - a[1]).map(([kind, bytes]) => `${ARTIFACT_LABEL[kind]} ${formatBytes(bytes)}`).join(" \xB7 ")})` : "no artifacts"
+    );
+  }
+  const { disk } = profile;
+  if (disk.peakInUseBytes !== null && disk.peakInUseBytes > 0) {
+    parts.push(
+      `${disk.peakInUseIsLowerBound ? "at least " : ""}${formatBytes(disk.peakInUseBytes)} in use at the peak`
+    );
+  }
+  if (disk.lowestFreeBytes !== null) parts.push(`${formatBytes(disk.lowestFreeBytes)} free at the low point`);
+  if (disk.leftoverBytes !== null && disk.leftoverBytes >= 10 * 1024 ** 2) {
+    parts.push(`${formatBytes(disk.leftoverBytes)} left in the temp folder by earlier runs`);
+  }
+  return parts.length ? `  Disk     ${parts.join(" \xB7 ")}` : null;
+}
+function workersLine(workers) {
+  if (!workers || workers.tests === 0) return null;
+  return `  Workers  event loop busy ${Math.round(workers.loopUtilization * 100)}% \xB7 p99 delay ${Math.round(
+    workers.loopDelayP99Ms
+  )} ms at worst \xB7 ${Math.round(workers.involuntarySwitchesPerTest).toLocaleString("en-US")} involuntary context switches per test`;
+}
+function formatMachinePanel(profile, extras) {
+  const { machine, cpu } = profile;
+  const head = [
+    `${machine.cores} cores${machine.cpuQuotaCores ? ` (a quota of ${machine.cpuQuotaCores})` : ""}`,
+    formatBytes(machine.memoryBytes)
+  ];
+  if (machine.memoryLimitBytes) head.push(`container limit ${formatBytes(machine.memoryLimitBytes)}`);
+  if (cpu.stealPct !== null && cpu.stealPct >= 1) head.push(`steal ${cpu.stealPct}%`);
+  const lines = [
+    `Machine: ${head.join(" \xB7 ")}`,
+    cpuLine(profile),
+    memoryLine(profile),
+    diskLine(profile, extras.artifacts),
+    workersLine(extras.workers)
+  ].filter((line) => line !== null);
+  if (profile.notMeasured.length) lines.push(`  Not measured here: ${profile.notMeasured.join(", ")}`);
+  return lines;
+}
+
+// src/internal/collect/resource-wire.ts
+var REPORT_FINDINGS_CAP = 100;
+var REPORT_SERIES_CAP = 240;
+var REPORT_WORKER_POINTS_CAP = 200;
+function downsample(series, cap) {
+  if (series.length <= cap) return series;
+  const out = [];
+  for (let i = 0; i < cap; i++) {
+    const slice = series.slice(Math.floor(i * series.length / cap), Math.floor((i + 1) * series.length / cap));
+    out.push(Math.round(slice.reduce((sum, v) => sum + v, 0) / Math.max(1, slice.length) * 10) / 10);
+  }
+  return out;
+}
+function nonZero(bytes) {
+  const out = Object.fromEntries(Object.entries(bytes).filter(([, n]) => (n ?? 0) > 0));
+  return Object.keys(out).length > 0 ? out : null;
+}
+function executionResources(census, artifacts) {
+  const metrics = census.metrics;
+  if (!metrics) return null;
+  return {
+    workerCpuMs: metrics.worker.cpuMs,
+    roles: metrics.roles ?? null,
+    loopUtilization: metrics.worker.loopUtilization,
+    loopDelayP99Ms: metrics.worker.loopDelayP99Ms,
+    involuntarySwitches: metrics.worker.involuntarySwitches,
+    heapUsedMb: metrics.worker.heapUsedMb,
+    openAtStart: census.openAtStart ?? null,
+    leftOpen: census.leftOpen ?? null,
+    artifactBytes: nonZero(artifacts)
+  };
+}
+function openPagesByWorker(censuses) {
+  const byWorker = /* @__PURE__ */ new Map();
+  for (const census of censuses) {
+    const list = byWorker.get(census.worker) ?? [];
+    list.push(census);
+    byWorker.set(census.worker, list);
+  }
+  const out = [];
+  for (const [worker, list] of [...byWorker.entries()].sort((a, b) => a[0] - b[0])) {
+    list.sort((a, b) => a.at - b.at);
+    const kinds = /* @__PURE__ */ new Map();
+    const points = [];
+    for (const census of list) {
+      for (const birth of census.born) kinds.set(birth.id, birth.kind);
+      if (census.test) points.push(census.open.filter((open) => kinds.get(open.id) === "page").length);
+    }
+    if (points.length > 0) out.push({ worker, openPages: downsample(points, REPORT_WORKER_POINTS_CAP) });
+  }
+  return out;
+}
+function resourceReportWire(input) {
+  const { report, profile } = input;
+  return {
+    v: 1,
+    shardIndex: input.shardIndex,
+    findings: (report?.findings ?? []).slice(0, REPORT_FINDINGS_CAP),
+    counts: report?.counts ?? { leaked: 0, idle: 0, piling: 0, handle: 0, probable: 0 },
+    profile: profile ? { ...profile, cpu: { ...profile.cpu, series: downsample(profile.cpu.series, REPORT_SERIES_CAP) } } : null,
+    workers: openPagesByWorker(input.censuses),
+    artifactBytes: nonZero(input.artifacts) ?? {},
+    workerHealth: workerHealthOf(input.censuses)
+  };
+}
+
+// ../core/src/describe-failure.ts
+var HEADLINE_MAX_CHARS = 120;
+var VALUE_MAX_CHARS = 40;
+var SHORT_VALUE_MAX_CHARS = 20;
+var MASK_TOKEN_RE = /<(?:N|VALUE|URL|STR|UUID|HASH|EMAIL)>/g;
+var ACTION_VERBS = {
+  click: "click",
+  dblclick: "double-click",
+  fill: "fill",
+  type: "type",
+  press: "press",
+  pressSequentially: "type",
+  check: "check",
+  uncheck: "uncheck",
+  hover: "hover",
+  tap: "tap",
+  focus: "focus",
+  blur: "blur",
+  clear: "clear",
+  selectOption: "select",
+  selectText: "select text",
+  setInputFiles: "file upload",
+  setChecked: "check",
+  dragTo: "drag",
+  dragAndDrop: "drag",
+  scrollIntoViewIfNeeded: "scroll",
+  screenshot: "screenshot",
+  waitFor: "wait",
+  waitForSelector: "waitForSelector",
+  waitForLoadState: "waitForLoadState",
+  waitForFunction: "waitForFunction",
+  waitForResponse: "waitForResponse",
+  waitForRequest: "waitForRequest",
+  waitForEvent: "waitForEvent",
+  waitForTimeout: "waitForTimeout",
+  innerText: "read text",
+  textContent: "read text",
+  inputValue: "read value",
+  getAttribute: "read attribute",
+  isVisible: "visibility check",
+  isEnabled: "enabled check",
+  isChecked: "checked check",
+  boundingBox: "measure",
+  evaluate: "evaluate",
+  goto: "navigation"
+};
+var ACTION_GERUNDS = {
+  click: "clicking",
+  dblclick: "double-clicking",
+  fill: "filling",
+  type: "typing into",
+  press: "pressing a key on",
+  pressSequentially: "typing into",
+  check: "checking",
+  uncheck: "unchecking",
+  hover: "hovering",
+  tap: "tapping",
+  focus: "focusing",
+  clear: "clearing",
+  selectOption: "selecting an option in",
+  setInputFiles: "uploading a file to",
+  dragTo: "dragging",
+  waitFor: "waiting for",
+  waitForSelector: "waiting for",
+  evaluate: "evaluating on"
+};
+var STATE_PHRASES = {
+  "not-found": "was not found on the page",
+  hidden: "never became visible",
+  "not-visible": "never became visible",
+  "not-enabled": "never became enabled",
+  "not-editable": "never became editable",
+  "not-stable": "never stopped moving",
+  "outside-viewport": "stayed outside the viewport",
+  "intercepts-pointer": "was covered by another element",
+  detached: "was detached from the DOM",
+  navigating: "was still navigating"
+};
+var STATE_MATCHERS = {
+  toBeVisible: { met: "visible", unmet: "never became visible" },
+  toBeHidden: { met: "hidden", unmet: "never became hidden" },
+  toBeEnabled: { met: "enabled", unmet: "never became enabled" },
+  toBeDisabled: { met: "disabled", unmet: "never became disabled" },
+  toBeChecked: { met: "checked", unmet: "never became checked" },
+  toBeEditable: { met: "editable", unmet: "never became editable" },
+  toBeFocused: { met: "focused", unmet: "never received focus" },
+  toBeAttached: { met: "attached", unmet: "never appeared in the DOM" },
+  toBeDetached: { met: "detached", unmet: "never left the DOM" },
+  toBeInViewport: { met: "in the viewport", unmet: "never entered the viewport" },
+  toBeEmpty: { met: "empty", unmet: "never became empty" }
+};
+var VALUE_MATCHERS = {
+  toHaveText: "text",
+  toContainText: "text containing",
+  toHaveValue: "value",
+  toHaveValues: "values",
+  toHaveAttribute: "attribute",
+  toHaveClass: "class",
+  toContainClass: "class",
+  toHaveId: "id",
+  toHaveCSS: "CSS",
+  toHaveJSProperty: "property",
+  toHaveAccessibleName: "accessible name",
+  toHaveAccessibleDescription: "accessible description",
+  toHaveRole: "role",
+  toHaveURL: "URL",
+  toHaveTitle: "title",
+  toHaveScreenshot: "screenshot",
+  toMatchAriaSnapshot: "ARIA snapshot"
+};
+var NETWORK_ERRORS = {
+  ERR_CONNECTION_REFUSED: "Connection refused loading",
+  ERR_CONNECTION_RESET: "Connection reset loading",
+  ERR_CONNECTION_CLOSED: "Connection closed loading",
+  ERR_CONNECTION_TIMED_OUT: "Connection timed out loading",
+  ERR_TIMED_OUT: "Connection timed out loading",
+  ERR_NAME_NOT_RESOLVED: "DNS lookup failed for",
+  ERR_INTERNET_DISCONNECTED: "No network while loading",
+  ERR_ADDRESS_UNREACHABLE: "Address unreachable loading",
+  ERR_ABORTED: "Navigation aborted loading",
+  ERR_EMPTY_RESPONSE: "Empty response loading",
+  ERR_TOO_MANY_REDIRECTS: "Too many redirects loading",
+  ERR_SSL_PROTOCOL_ERROR: "TLS error loading",
+  ERR_CERT_AUTHORITY_INVALID: "Untrusted certificate loading",
+  ERR_CERT_COMMON_NAME_INVALID: "Certificate name mismatch loading",
+  ERR_CERT_DATE_INVALID: "Expired certificate loading",
+  ERR_BLOCKED_BY_CLIENT: "Request blocked loading",
+  ERR_FAILED: "Request failed loading",
+  ERR_HTTP_RESPONSE_CODE_FAILURE: "HTTP error loading",
+  NS_ERROR_CONNECTION_REFUSED: "Connection refused loading",
+  NS_ERROR_UNKNOWN_HOST: "DNS lookup failed for",
+  NS_ERROR_NET_TIMEOUT: "Connection timed out loading",
+  NS_ERROR_OFFLINE: "No network while loading",
+  NS_ERROR_ABORT: "Navigation aborted loading",
+  NS_BINDING_ABORTED: "Navigation aborted loading"
+};
+function formatTimeout(ms) {
+  if (ms < 1e3) return `${ms} ms`;
+  const seconds = ms / 1e3;
+  const rounded = Math.round(seconds * 10) / 10;
+  return `${Number.isInteger(rounded) ? rounded.toFixed(0) : rounded} s`;
+}
+function routeOf(url) {
+  try {
+    const parsed = new URL(url);
+    return `${parsed.pathname}${parsed.search}` || "/";
+  } catch {
+    return url;
+  }
+}
+function truncateValue(value, max) {
+  const flat = value.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+}
+function countNoun(locator, count) {
+  const role = locator ? /getByRole\(\s*['"]([a-z]+)['"]/.exec(locator)?.[1] : null;
+  const noun = role ?? "element";
+  if (count === 1) return noun;
+  return noun.endsWith("s") ? noun : noun.endsWith("x") || noun.endsWith("ch") ? `${noun}es` : `${noun}s`;
+}
+function textOfGetByText(locator) {
+  if (!locator) return null;
+  const m = /^getByText\(\s*(['"`])((?:\\.|(?!\1)[^\\\n\r\u2028\u2029])*)\1\s*(?:,\s*\{[^}]*\})?\s*\)$/.exec(locator);
+  return m ? m[2] : null;
+}
+function receivedDisplay(parsed) {
+  const received = parsed.received ?? "";
+  if (parsed.assertion !== "toHaveURL") return received;
+  const m = /^"?(https?:\/\/[^"\s]+)"?$/.exec(received);
+  return m ? `"${routeOf(m[1])}"` : received;
+}
+function firstLineFallback(parsed) {
+  const line = (parsed.messageHead.split("\n")[0] ?? "").replace(/^Error:\s*/, "").replace(MASK_TOKEN_RE, "\u2026");
+  return truncateValue(line || "Unknown error", HEADLINE_MAX_CHARS);
+}
+var Line = class {
+  constructor() {
+    this.parts = [];
+  }
+  text(text) {
+    if (!text) return this;
+    const last = this.parts[this.parts.length - 1];
+    if (last && last.kind === "text") last.text += text;
+    else this.parts.push({ kind: "text", text });
+    return this;
+  }
+  locator(text) {
+    this.parts.push({ kind: "locator", text });
+    return this;
+  }
+  value(text) {
+    this.parts.push({ kind: "value", text });
+    return this;
+  }
+  toString() {
+    return this.parts.map((p) => p.text).join("");
   }
 };
 function subject(line, locator, opts) {
@@ -5854,7 +7946,7 @@ function testLocation(test) {
   return `${testFile(test)}:${test.location.line}:${test.location.column}`;
 }
 function testFile(test) {
-  return path18.relative(process.cwd(), test.location.file).split(path18.sep).join("/");
+  return path23.relative(process.cwd(), test.location.file).split(path23.sep).join("/");
 }
 var PiwiDashboardReporter = class _PiwiDashboardReporter {
   constructor(rawOptions = {}) {
@@ -5882,6 +7974,20 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
     this.filterDetails = null;
     /** Configured `maxFailures` (0 = unlimited) — disambiguates an interrupted run's unrun reason. */
     this.maxFailures = 0;
+    /** The resource censuses the capture fixtures attached, one per test attempt. */
+    this.resourceCensuses = [];
+    /** Lifecycle steps of the tests that ran without the fixtures. */
+    this.lifecycleTallies = [];
+    /** The user fixtures set up by the tests that left a page unused, by test id. */
+    this.fixturesByTest = /* @__PURE__ */ new Map();
+    /** The file workers append their shutdown census to, set in `onBegin`. */
+    this.resourcesFile = null;
+    /** Samples the run's processes and the machine from `onBegin` to `onEnd`. */
+    this.sampler = null;
+    /** Bytes of the files the tests attached, by kind. */
+    this.artifactBytes = emptyArtifacts();
+    /** The run's resource report for the dashboard, built in `onEnd`. */
+    this.resourceReport = null;
     this.streamManager = null;
     /** Track suite-level setup steps (beforeAll/afterAll) not tied to any test */
     this.setupSteps = [];
@@ -5941,6 +8047,17 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
     this.startTime = (/* @__PURE__ */ new Date()).toISOString();
     this.playwrightVersion = config.version;
     this.maxFailures = config.maxFailures ?? 0;
+    if (this.options.captureResources !== false) {
+      this.resourcesFile = path23.join(os9.tmpdir(), `piwi-resources-${process.pid}-${Date.now()}.jsonl`);
+      process.env[PIWI_RESOURCES_RESULTS_ENV] = this.resourcesFile;
+      try {
+        this.sampler = new RunSampler({ outputDirs: (config.projects ?? []).map((project) => project.outputDir) });
+        this.sampler.start();
+      } catch (error) {
+        this.sampler = null;
+        this.logger.debug(`Run sampler not started: ${errorMessage(error)}`);
+      }
+    }
     this.logger.info(
       `Starting test run for project: ${this.options.projectName} (Playwright v${this.playwrightVersion})`
     );
@@ -6165,6 +8282,7 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
         }
       }
     }
+    if (this.enabled && this.options.captureResources !== false) this.collectResources(test, result, testCase);
     const reachAttachment = this.options.captureCodeReach === true && this.options.collectPerformanceMetrics !== false ? result.attachments.find((a) => a.name === ATTACHMENT_NAMES.codeReach) : void 0;
     if (reachAttachment?.body) {
       try {
@@ -6209,6 +8327,78 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
       if (this.options.liveFileUploads) this.streamManager.scheduleLiveUpload(testCase);
     }
   }
+  /**
+   * Add up the files a test attached, and keep its resource census; for a test
+   * that ran without the capture fixtures, tally the browsers and contexts its
+   * steps opened and closed.
+   */
+  collectResources(test, result, testCase) {
+    const artifacts = emptyArtifacts();
+    for (const file of result.attachments ?? []) {
+      if (!file.path || INTERNAL_ATTACHMENT_NAMES.has(file.name)) continue;
+      try {
+        const kind = artifactKind(file.name, file.contentType);
+        const bytes = fs21.statSync(file.path).size;
+        artifacts[kind] += bytes;
+        this.artifactBytes[kind] += bytes;
+      } catch {
+      }
+    }
+    const attachment = result.attachments?.find((a) => a.name === ATTACHMENT_NAMES.resources);
+    const census = parseResourceCensus(attachment?.body);
+    if (census) {
+      this.resourceCensuses.push(census);
+      const resources = executionResources(census, artifacts);
+      if (resources) testCase.resources = resources;
+      const leftIdle = census.closed.some((c) => c.used === false) || census.open.some((o) => o.used === false);
+      if (leftIdle) this.fixturesByTest.set(test.id, userFixturesOf(result.steps ?? []));
+      return;
+    }
+    if (!result.steps?.length) return;
+    const tally = tallyLifecycleSteps(testFile(test), result.steps);
+    if (tally.opened.length > 0 || tally.closed.context > 0 || tally.closed.browser > 0)
+      this.lifecycleTallies.push(tally);
+  }
+  /**
+   * Print what the run left open or opened for nothing, from the censuses and
+   * the workers' shutdown file, then what the run cost the machine.
+   */
+  async reportResources() {
+    if (this.options.captureResources === false) return;
+    const profile = this.sampler ? await this.sampler.stop() : null;
+    this.sampler = null;
+    const censuses = [...this.resourceCensuses];
+    if (this.resourcesFile) {
+      try {
+        censuses.push(...parseResourceResults(fs21.readFileSync(this.resourcesFile, "utf8")));
+        fs21.rmSync(this.resourcesFile, { force: true });
+      } catch {
+      }
+    }
+    const lines = [];
+    try {
+      const report = censuses.length > 0 || this.lifecycleTallies.length > 0 ? buildResourceReport({ censuses, fixturesByTest: this.fixturesByTest, tallies: this.lifecycleTallies }) : null;
+      if (report) lines.push(...formatResourceSummary(report, readLeakCheck(this.options.leakCheck)));
+      if (profile) {
+        lines.push(
+          ...formatMachinePanel(profile, { artifacts: this.artifactBytes, workers: workerHealthOf(censuses) })
+        );
+      }
+      if (report || profile) {
+        this.resourceReport = resourceReportWire({
+          report,
+          profile,
+          censuses,
+          artifacts: this.artifactBytes,
+          shardIndex: this.shardInfo?.current ?? null
+        });
+      }
+    } catch (error) {
+      this.logger.debug(`Resource summary skipped: ${errorMessage(error)}`);
+    }
+    for (const line of lines) this.logger.info(line);
+    emitResourceSummary(lines, this.logger);
+  }
   /**
    * Synthesize `didnotrun` cases for tests Playwright planned but never reported
    * (no `onTestEnd`) — typically because `maxFailures` cut the run short. These
@@ -6263,6 +8453,7 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
       failures: this.failedTests + this.timedOutTests
     });
     this.materializeUnrunTests(unrunReason);
+    await this.reportResources();
     try {
       await this.submitter.submit(
         {
@@ -6282,7 +8473,8 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
           shardInfo: this.shardInfo,
           setupSteps: this.setupSteps,
           isFullRun: this.isFullRun,
-          filterDetails: this.filterDetails
+          filterDetails: this.filterDetails,
+          resourceReport: this.resourceReport
         },
         result
       );
@@ -6366,7 +8558,7 @@ async function resolveSelection(options = {}) {
 }
 
 // src/internal/capture/capture-fixtures.ts
-var path23 = __toESM(require("path"));
+var path27 = __toESM(require("path"));
 var import_node_zlib2 = require("zlib");
 
 // ../picker-dom/src/probe.ts
@@ -6448,7 +8640,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;
@@ -6471,7 +8663,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");
@@ -6531,7 +8723,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++;
@@ -6584,7 +8776,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();
@@ -6616,7 +8808,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;
@@ -6641,7 +8833,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++;
                 }
@@ -6989,7 +9181,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();
@@ -7012,7 +9204,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++;
       }
@@ -7045,7 +9237,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) {
@@ -7058,7 +9250,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++;
       }
@@ -7107,7 +9299,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 [];
@@ -7760,7 +9952,7 @@ function mergeCandidates(base, extra) {
 }
 
 // src/internal/capture/locator-healing.ts
-var path19 = __toESM(require("path"));
+var path24 = __toESM(require("path"));
 
 // ../core/src/locator-fingerprint.ts
 var ELEMENT_MATCH_SCORES = { role: 60, text: 55, label: 50 };
@@ -8130,10 +10322,10 @@ function captureCallerLocation(stack = new Error().stack ?? "") {
     }
     let rel = file;
     try {
-      rel = path19.relative(process.cwd(), file);
+      rel = path24.relative(process.cwd(), file);
     } catch {
     }
-    rel = rel.split(path19.sep).join("/");
+    rel = rel.split(path24.sep).join("/");
     if (rel.startsWith("./")) rel = rel.slice(2);
     return `${rel}:${m[3]}:${m[4]}`;
   }
@@ -8147,7 +10339,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();
@@ -8201,7 +10393,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"));
@@ -8219,7 +10411,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}`;
@@ -8344,7 +10536,7 @@ function inspectionGateFromTestInfo(testInfo, enabled = process.env.PIWI_INSPECT
 }
 
 // src/internal/capture/pick-on-failure.ts
-var path20 = __toESM(require("path"));
+var path25 = __toESM(require("path"));
 var ANSI_RE2 = /\x1b\[[0-9;]*m/g;
 function parseLeafLocatorExpression(rawExpr) {
   const leaf = parseLeafLocatorCall(rawExpr);
@@ -8361,7 +10553,7 @@ ${err.stack ?? ""}`.replace(ANSI_RE2, "");
     const parsed = parseLeafLocatorExpression(line[1].trim());
     if (!parsed) continue;
     const loc = err.location;
-    const location = loc ? `${path20.relative(process.cwd(), loc.file).split(path20.sep).join("/")}:${loc.line}:${loc.column}` : null;
+    const location = loc ? `${path25.relative(process.cwd(), loc.file).split(path25.sep).join("/")}:${loc.line}:${loc.column}` : null;
     return { method: parsed.method, args: parsed.args, location };
   }
   return null;
@@ -8509,64 +10701,11 @@ function applyPickToSnapshots(snapshots, pick) {
   return true;
 }
 
-// src/internal/capture/quiet-capture.ts
-var import_node_module = require("module");
-var path21 = __toESM(require("path"));
-var BOXED_PREFIX_EXPORTS = [
-  [
-    "playwright-core/lib/coreBundle",
-    (mod) => mod?.utils?.setBoxedStackPrefixes
-  ],
-  ["playwright-core/lib/utils", (mod) => mod?.setBoxedStackPrefixes]
-];
-var boxing;
-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 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: [path21.dirname(playwrightPackageJson), path21.join(root, "dist") + path21.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 crypto3 = __toESM(require("crypto"));
-var fs18 = __toESM(require("fs"));
-var path22 = __toESM(require("path"));
-var import_node_child_process2 = require("child_process");
+var fs22 = __toESM(require("fs"));
+var path26 = __toESM(require("path"));
+var import_node_child_process3 = require("child_process");
 
 // ../core/src/source-map.ts
 var BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -8821,24 +10960,24 @@ function repositoryRoot(from) {
   if (cachedRepoRoot?.from === from) return cachedRepoRoot.root;
   let root = from;
   try {
-    root = (0, import_node_child_process2.execFileSync)("git", ["rev-parse", "--show-toplevel"], {
+    root = (0, import_node_child_process3.execFileSync)("git", ["rev-parse", "--show-toplevel"], {
       cwd: from,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
   } catch {
   }
-  cachedRepoRoot = { from, root: path22.resolve(root) };
+  cachedRepoRoot = { from, root: path26.resolve(root) };
   return cachedRepoRoot.root;
 }
 function codeReachRoots(configDir, configured) {
   const repoRoot = repositoryRoot(configDir);
-  const roots = configured?.length ? configured.map((r) => path22.resolve(configDir, r)) : [configDir];
+  const roots = configured?.length ? configured.map((r) => path26.resolve(configDir, r)) : [configDir];
   return { roots: [.../* @__PURE__ */ new Set([...roots, repoRoot])], repoRoot };
 }
 function isFile(file) {
   try {
-    return fs18.statSync(file).isFile();
+    return fs22.statSync(file).isFile();
   } catch {
     return false;
   }
@@ -8846,10 +10985,10 @@ function isFile(file) {
 function resolveSourcePath(source, roots) {
   const normalized = normalizeSourcePath(source);
   if (!normalized || /(?:^|\/)node_modules\//.test(normalized)) return null;
-  if (path22.isAbsolute(normalized) && isFile(normalized)) return path22.resolve(normalized);
-  const relative11 = normalized.replace(/^\/+/, "");
+  if (path26.isAbsolute(normalized) && isFile(normalized)) return path26.resolve(normalized);
+  const relative13 = normalized.replace(/^\/+/, "");
   for (const root of roots) {
-    const candidate = path22.resolve(root, relative11);
+    const candidate = path26.resolve(root, relative13);
     if (isFile(candidate)) return candidate;
   }
   return null;
@@ -8881,7 +11020,7 @@ function fileForUrl(url, roots, bases) {
   return file;
 }
 function relativeToRepo(file, repoRoot) {
-  return path22.relative(repoRoot, file).split(path22.sep).join("/");
+  return path26.relative(repoRoot, file).split(path26.sep).join("/");
 }
 function scriptHash(entry) {
   return crypto3.createHash("sha1").update(entry.source ?? "").digest("hex");
@@ -9071,7 +11210,7 @@ function configuredCodeReachRoots() {
     if (Array.isArray(parsed)) return parsed.filter((r) => typeof r === "string" && r !== "");
   } catch {
   }
-  return raw.split(path23.delimiter).filter(Boolean);
+  return raw.split(path27.delimiter).filter(Boolean);
 }
 async function stopSinkCodeReach(sink, closing) {
   const session = sink.codeReach;
@@ -9086,7 +11225,7 @@ async function stopSinkCodeReach(sink, closing) {
     if (!entries) return;
     const info = sink.testInfo;
     const configFile = info?.config.configFile;
-    const configDir = configFile ? path23.dirname(configFile) : info?.config.rootDir ?? process.cwd();
+    const configDir = configFile ? path27.dirname(configFile) : info?.config.rootDir ?? process.cwd();
     session.files = await resolveCodeReach(
       entries,
       codeReachRoots(configDir, configuredCodeReachRoots()),
@@ -9102,8 +11241,8 @@ async function drainPendingProbes(capMs) {
   let cap;
   await Promise.race([
     Promise.allSettled(PENDING_PROBES),
-    new Promise((resolve6) => {
-      cap = setTimeout(resolve6, capMs);
+    new Promise((resolve7) => {
+      cap = setTimeout(resolve7, capMs);
     })
   ]);
   clearTimeout(cap);
@@ -9143,10 +11282,10 @@ async function readWebVitals(page) {
         const key = entry.name.replace(/-([a-z])/g, (_, l) => l.toUpperCase());
         paint[key] = Math.round(entry.startTime);
       }
-      const readBuffered = (type, extra) => new Promise((resolve6) => {
+      const readBuffered = (type, extra) => new Promise((resolve7) => {
         try {
           const PO = globalThis.PerformanceObserver;
-          if (!PO || !(PO.supportedEntryTypes || []).includes(type)) return resolve6(null);
+          if (!PO || !(PO.supportedEntryTypes || []).includes(type)) return resolve7(null);
           const out = [];
           const po = new PO((list) => out.push(...list.getEntries()));
           po.observe({ type, buffered: true, ...extra });
@@ -9156,10 +11295,10 @@ async function readWebVitals(page) {
               po.disconnect();
             } catch {
             }
-            resolve6(out);
+            resolve7(out);
           }, 0);
         } catch {
-          resolve6(null);
+          resolve7(null);
         }
       });
       const [lcpRaw, shiftRaw, eventRaw, firstInputRaw] = await Promise.all([
@@ -9272,12 +11411,12 @@ var PAGE_INVENTORY_IN_PAGE_CAP = 2e3;
 var PAGE_INVENTORY_EVAL_TIMEOUT_MS = 2e3;
 var MAX_PAGE_INVENTORY_WINDOWS = 64;
 function withTimeout(promise, ms) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const timer = setTimeout(() => reject(new Error("page inventory read timed out")), ms);
     promise.then(
       (value) => {
         clearTimeout(timer);
-        resolve6(value);
+        resolve7(value);
       },
       (error) => {
         clearTimeout(timer);
@@ -9650,6 +11789,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);
       };
     }
@@ -9836,8 +11976,8 @@ async function flushSink(sink, testInfo) {
   let drainDeadline;
   await Promise.race([
     Promise.allSettled(sink.capturePromises),
-    new Promise((resolve6) => {
-      drainDeadline = setTimeout(resolve6, 2e3);
+    new Promise((resolve7) => {
+      drainDeadline = setTimeout(resolve7, 2e3);
     })
   ]);
   clearTimeout(drainDeadline);
@@ -9979,6 +12119,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: [
@@ -10026,6 +12182,7 @@ var piwiFixtures = {
           file: testInfo.file,
           titlePath: testInfo.titlePath
         });
+      activeResourceLedger()?.testStarted(testInfo);
       currentSink = sink;
       try {
         await use();
@@ -10052,6 +12209,7 @@ var piwiFixtures = {
         }
         if (sink.flake) await recordFlakeAttempt(sink.flake, testInfo);
         await flushSink(sink, testInfo);
+        await recordResourceCensus(testInfo);
       }
     },
     { auto: true }
@@ -10083,13 +12241,13 @@ function extendPiwiFixtures(test) {
 }
 
 // src/internal/ai/ai-fixtures.ts
-var fs20 = __toESM(require("fs"));
-var path26 = __toESM(require("path"));
+var fs24 = __toESM(require("fs"));
+var path30 = __toESM(require("path"));
 var import_test = require("@playwright/test");
 
 // src/internal/ai/artifact.ts
-var fs19 = __toESM(require("fs"));
-var path24 = __toESM(require("path"));
+var fs23 = __toESM(require("fs"));
+var path28 = __toESM(require("path"));
 var ARTIFACT_VERSION = 1;
 var LOCATOR_METHOD_SET2 = new Set(LOCATOR_METHODS);
 var ACTION_METHOD_SET2 = new Set(ACTION_METHODS);
@@ -10182,7 +12340,7 @@ function parseEntry(text) {
 function readEntry(file) {
   let text;
   try {
-    text = fs19.readFileSync(file, "utf8");
+    text = fs23.readFileSync(file, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw error;
@@ -10192,28 +12350,28 @@ function readEntry(file) {
 function writeEntry(file, entry) {
   const canonical = serializeEntry(entry);
   return withEntryLock(file, () => {
-    if (fs19.existsSync(file) && fs19.readFileSync(file, "utf8") === canonical) return { written: false };
-    fs19.mkdirSync(path24.dirname(file), { recursive: true });
+    if (fs23.existsSync(file) && fs23.readFileSync(file, "utf8") === canonical) return { written: false };
+    fs23.mkdirSync(path28.dirname(file), { recursive: true });
     const tmp = `${file}.${process.pid}.tmp`;
-    fs19.writeFileSync(tmp, canonical);
-    fs19.renameSync(tmp, file);
+    fs23.writeFileSync(tmp, canonical);
+    fs23.renameSync(tmp, file);
     return { written: true };
   });
 }
 function withEntryLock(file, fn) {
   const lock = `${file}.lock`;
-  fs19.mkdirSync(path24.dirname(file), { recursive: true });
+  fs23.mkdirSync(path28.dirname(file), { recursive: true });
   const deadline = Date.now() + 5e3;
   for (; ; ) {
     try {
-      const fd = fs19.openSync(lock, "wx");
-      fs19.closeSync(fd);
+      const fd = fs23.openSync(lock, "wx");
+      fs23.closeSync(fd);
       break;
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
       if (Date.now() > deadline) {
         try {
-          fs19.unlinkSync(lock);
+          fs23.unlinkSync(lock);
         } catch {
         }
       }
@@ -10223,7 +12381,7 @@ function withEntryLock(file, fn) {
     return fn();
   } finally {
     try {
-      fs19.unlinkSync(lock);
+      fs23.unlinkSync(lock);
     } catch {
     }
   }
@@ -10231,7 +12389,7 @@ function withEntryLock(file, fn) {
 
 // src/internal/ai/keys.ts
 var crypto4 = __toESM(require("crypto"));
-var path25 = __toESM(require("path"));
+var path29 = __toESM(require("path"));
 var DEFAULT_AI_DIR = "__piwi__";
 function normalizeTemplate(template) {
   return template.trim().replace(/\s+/g, " ").toLowerCase();
@@ -10245,13 +12403,13 @@ function slug(text, maxLength = 40) {
   return (base || "x").slice(0, maxLength).replace(/-+$/g, "") || "x";
 }
 function entryDir(specFile, dir = DEFAULT_AI_DIR) {
-  return path25.join(path25.dirname(specFile), dir, path25.basename(specFile));
+  return path29.join(path29.dirname(specFile), dir, path29.basename(specFile));
 }
 function entryPath(params) {
   const basis = `${normalizeTemplate(params.testTitle)}::${normalizeTemplate(params.template)}`;
   const hash = hashTemplate(basis, params.ordinal ?? 0);
   const name = `${slug(params.testTitle)}.${slug(params.template)}.${hash}.json`;
-  return path25.join(entryDir(params.specFile, params.dir), name);
+  return path29.join(entryDir(params.specFile, params.dir), name);
 }
 function parseLocation2(location) {
   const match = /:(\d+):(\d+)$/.exec(location);
@@ -10765,7 +12923,7 @@ function testIdentity(testInfo) {
   return titles.length > 0 ? titles.join(" \u203A ") : testInfo.title;
 }
 function relativeToCwd(file) {
-  return path26.relative(process.cwd(), file).split(path26.sep).join("/");
+  return path30.relative(process.cwd(), file).split(path30.sep).join("/");
 }
 function recordIntents(intents, entry) {
   const add = (locator, kind) => {
@@ -10792,7 +12950,7 @@ function createAiApi(page, testInfo, config, used, intents) {
   const readSource = () => {
     if (source === null) {
       try {
-        source = fs20.readFileSync(testInfo.file, "utf8");
+        source = fs24.readFileSync(testInfo.file, "utf8");
       } catch {
         source = "";
       }