@piwitests/reporter 0.44.0 → 0.46.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,9 +84,12 @@ 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,
+  checkBaseUrl: false,
   streaming: true,
   streamingBatchSize: 5,
   streamingBatchDelay: 2e3,
@@ -122,9 +127,12 @@ 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",
+  checkBaseUrl: "PIWI_CHECK_BASE_URL",
   inspectOnFailure: "PIWI_INSPECT_ON_FAIL",
   pickLocatorOnFailure: "PIWI_PICK_LOCATOR_ON_FAIL",
   outputFile: "PIWI_OUTPUT_FILE",
@@ -145,6 +153,10 @@ var PIWI_SELECTION_ENV = {
   hash: "PIWI_SELECTION_HASH",
   count: "PIWI_SELECTION_COUNT"
 };
+var PIWI_ORIGIN_ENV = {
+  kind: "PIWI_ORIGIN",
+  ref: "PIWI_ORIGIN_REF"
+};
 var PIWI_SHARD_ENV = "PIWI_SHARD";
 var PIWI_PROBE_ENV = {
   flag: "PIWI_PROBE",
@@ -156,6 +168,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,9 +197,12 @@ 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" },
+  { option: "checkBaseUrl", env: PIWI_ENV_KEYS.checkBaseUrl, kind: "bool" },
   { option: "inspectOnFailure", env: PIWI_ENV_KEYS.inspectOnFailure, kind: "bool" },
   { option: "pickLocatorOnFailure", env: PIWI_ENV_KEYS.pickLocatorOnFailure, kind: "bool" },
   { option: "outputFile", env: PIWI_ENV_KEYS.outputFile, kind: "string" }
@@ -234,6 +250,7 @@ function applyOptionsToEnv(options) {
   if (options.label) env[PIWI_ENV_KEYS.label] = options.label;
   if (options.runLabel) env[PIWI_ENV_KEYS.runLabel] = options.runLabel;
   if (options.keep) env[PIWI_ENV_KEYS.keep] = "true";
+  if (options.checkBaseUrl !== void 0) env[PIWI_ENV_KEYS.checkBaseUrl] = String(options.checkBaseUrl);
   if (options.captureLocators === false || options.collectPerformanceMetrics === false)
     env[PIWI_ENV_KEYS.captureLocators] = "false";
   else if (options.captureLocators === true) env[PIWI_ENV_KEYS.captureLocators] = "true";
@@ -250,6 +267,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 +509,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 +532,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 +627,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 +694,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));
   }
@@ -995,6 +1016,8 @@ var CrashRecovery = class {
     if (!data) return;
     this.logger.info("Found saved test data from a previous run, uploading...");
     delete data.instanceId;
+    const metadata = data.metadata && typeof data.metadata === "object" ? data.metadata : {};
+    data.metadata = { ...metadata, ingestHealth: { submitFallback: { path: "recovery" } } };
     try {
       await httpClient.postJSON("/api/test-runs/submit", data, auth);
       this.logger.info("Successfully uploaded saved test data");
@@ -1056,7 +1079,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 +1301,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,
@@ -1308,6 +1332,35 @@ function formatMiB(bytes) {
 
 // src/internal/collect/metadata-collector.ts
 var import_node_child_process = require("child_process");
+
+// ../core/src/wire.ts
+var RUN_ORIGIN_KINDS = [
+  "ci",
+  "ci-rerun",
+  "local",
+  "desktop",
+  "editor",
+  "preflight",
+  "bug",
+  "flake-lab",
+  "probe",
+  "bisect",
+  "reproduce",
+  "import"
+];
+var RUN_ORIGIN_METADATA_KEY = "piwiOrigin";
+var RUN_ORIGIN_REF_MAX_LENGTH = 200;
+var RUN_ORIGIN_REF = /^[A-Za-z0-9._:/#@-]+$/;
+function isRunOriginKind(value) {
+  return typeof value === "string" && RUN_ORIGIN_KINDS.includes(value);
+}
+function parseRunOriginRef(value) {
+  if (typeof value !== "string" && typeof value !== "number") return void 0;
+  const ref = String(value).trim();
+  return ref && ref.length <= RUN_ORIGIN_REF_MAX_LENGTH && RUN_ORIGIN_REF.test(ref) ? ref : void 0;
+}
+
+// src/internal/collect/metadata-collector.ts
 var DETACHED_HEAD = "HEAD";
 function resolveScmBranch(env, gitBranch) {
   const pick = (...names) => {
@@ -1352,6 +1405,19 @@ function resolveScmBaseBranch(env) {
   const trimmed = target?.trim();
   return trimmed ? normalizeRef(trimmed) : void 0;
 }
+function detectCi(env) {
+  return Boolean(
+    env.JENKINS_URL || env.GITHUB_ACTIONS || env.GITLAB_CI || env.CIRCLECI || env.TRAVIS || env.TF_BUILD || env.BITBUCKET_BUILD_NUMBER || env.CI && env.CI !== "false" && env.CI !== "0"
+  );
+}
+function resolveRunOrigin(env, warn) {
+  const raw = env[PIWI_ORIGIN_ENV.kind]?.trim();
+  let kind = detectCi(env) ? "ci" : "local";
+  if (raw && isRunOriginKind(raw)) kind = raw;
+  else if (raw) warn?.(`Ignoring ${PIWI_ORIGIN_ENV.kind}=${raw}: not a known run origin, recording "${kind}"`);
+  const ref = parseRunOriginRef(env[PIWI_ORIGIN_ENV.ref]);
+  return ref === void 0 ? { kind } : { kind, ref };
+}
 function normalizeRef(ref) {
   return ref.replace(/^refs\/heads\//, "");
 }
@@ -1361,7 +1427,10 @@ var MetadataCollector = class {
   }
   /** Collect all available metadata from the environment, config, and suite */
   collect(config, suite, options) {
-    const metadata = { workingDir: process.cwd() };
+    const metadata = {
+      workingDir: process.cwd(),
+      [RUN_ORIGIN_METADATA_KEY]: resolveRunOrigin(process.env, (message) => this.logger.warn(message))
+    };
     if (options.projectDescription) metadata.projectDescription = options.projectDescription;
     if (options.relatedIssue) metadata.relatedIssue = options.relatedIssue;
     if (options.ciInfo) metadata.ciInfo = options.ciInfo;
@@ -1538,6 +1607,15 @@ var MetadataCollector = class {
         ci.buildUrl = `${env.SYSTEM_TEAMFOUNDATIONSERVERURI}${env.SYSTEM_TEAMPROJECT}/_build/results?buildId=${env.BUILD_BUILDID}`;
       }
       ci.jobName = env.AGENT_JOBNAME;
+    } else if (env.BITBUCKET_BUILD_NUMBER) {
+      ci.provider = "Bitbucket Pipelines";
+      ci.buildNumber = env.BITBUCKET_BUILD_NUMBER;
+      ci.pipelineId = env.BITBUCKET_PIPELINE_UUID;
+      ci.jobId = env.BITBUCKET_STEP_UUID;
+      ci.repository = env.BITBUCKET_REPO_FULL_NAME;
+      if (env.BITBUCKET_REPO_FULL_NAME) {
+        ci.buildUrl = `https://bitbucket.org/${env.BITBUCKET_REPO_FULL_NAME}/pipelines/results/${env.BITBUCKET_BUILD_NUMBER}`;
+      }
     } else if (env.CI) {
       ci.provider = "Unknown CI";
       ci.detected = true;
@@ -1709,10 +1787,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 +2229,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 +2286,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(
@@ -3686,6 +3764,131 @@ function isDueForAriaSample(testInfo) {
   return set.has(ariaSampleIdentity(relativeTestFile(testInfo.file), testInfo.title));
 }
 
+// src/internal/support/base-url-check.ts
+var BASE_URL_CHECK_ATTEMPTS = 3;
+var BASE_URL_CHECK_TIMEOUT_MS = 1e4;
+var BASE_URL_CHECK_DELAY_MS = 2e3;
+var GATEWAY_ANSWERS = {
+  502: "bad gateway",
+  503: "service unavailable",
+  504: "gateway timeout"
+};
+function cliProjectNames(argv = process.argv) {
+  let names = null;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--project=")) {
+      (names ??= []).push(arg.slice("--project=".length));
+    } else if (arg === "--project") {
+      names ??= [];
+      while (i + 1 < argv.length && !argv[i + 1].startsWith("-")) names.push(argv[++i]);
+    }
+  }
+  return names;
+}
+function wildcard(pattern) {
+  const escaped = pattern.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  return new RegExp(`^${escaped.join(".*")}$`, "i");
+}
+function selectedProjects(projects, argv = process.argv) {
+  const names = cliProjectNames(argv);
+  if (!names || names.length === 0) return projects;
+  const patterns = names.map(wildcard);
+  const chosen = new Set(projects.filter((p) => patterns.some((re) => re.test(p.name ?? ""))));
+  if (!argv.includes("--no-deps")) {
+    const byName = new Map(projects.map((p) => [p.name ?? "", p]));
+    const queue = [...chosen];
+    while (queue.length > 0) {
+      for (const dep of queue.shift().dependencies ?? []) {
+        const project = byName.get(dep);
+        if (project && !chosen.has(project)) {
+          chosen.add(project);
+          queue.push(project);
+        }
+      }
+    }
+  }
+  return projects.filter((p) => chosen.has(p));
+}
+function asProxy(value) {
+  const proxy = value;
+  return proxy && typeof proxy === "object" && typeof proxy.server === "string" ? proxy : void 0;
+}
+function baseUrlTargets(config, argv = process.argv) {
+  const projects = config.projects?.length ? config.projects : [{ name: "", use: config.use }];
+  const targets = /* @__PURE__ */ new Map();
+  for (const project of selectedProjects(projects, argv)) {
+    const url = project.use?.baseURL;
+    if (typeof url !== "string" || !/^https?:\/\//i.test(url)) continue;
+    const target = targets.get(url);
+    if (target) {
+      if (project.name) target.projects.push(project.name);
+      continue;
+    }
+    targets.set(url, {
+      url,
+      projects: project.name ? [project.name] : [],
+      ignoreHTTPSErrors: project.use?.ignoreHTTPSErrors === true,
+      proxy: asProxy(project.use?.proxy)
+    });
+  }
+  return [...targets.values()];
+}
+function requestError(error) {
+  const first = errorMessage(error).split("\n")[0].trim();
+  return first.replace(/^apiRequestContext\.\w+:\s*/, "");
+}
+var playwrightProbe = async (target, timeoutMs) => {
+  const { request } = await import("@playwright/test");
+  const context = await request.newContext({ ignoreHTTPSErrors: target.ignoreHTTPSErrors, proxy: target.proxy });
+  try {
+    const response = await context.get(target.url, { timeout: timeoutMs, maxRedirects: 0, failOnStatusCode: false });
+    return { status: response.status() };
+  } catch (error) {
+    return { error: requestError(error) };
+  } finally {
+    await context.dispose().catch(() => {
+    });
+  }
+};
+async function checkBaseUrl(target, options = {}) {
+  const attempts = Math.max(1, options.attempts ?? BASE_URL_CHECK_ATTEMPTS);
+  const timeoutMs = options.timeoutMs ?? BASE_URL_CHECK_TIMEOUT_MS;
+  const delayMs = options.delayMs ?? BASE_URL_CHECK_DELAY_MS;
+  const probe = options.probe ?? playwrightProbe;
+  let reason = "";
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    const outcome = await probe(target, timeoutMs);
+    if ("status" in outcome) {
+      const gateway = GATEWAY_ANSWERS[outcome.status];
+      if (!gateway) return null;
+      reason = `${outcome.status} ${gateway}`;
+    } else {
+      reason = outcome.error;
+    }
+    if (attempt < attempts) await new Promise((resolve7) => setTimeout(resolve7, delayMs));
+  }
+  return `${reason} (${attempts} ${attempts === 1 ? "attempt" : "attempts"})`;
+}
+async function checkBaseUrls(config, options = {}) {
+  const targets = baseUrlTargets(config, options.argv);
+  const reasons = await Promise.all(targets.map((target) => checkBaseUrl(target, options)));
+  const down = targets.flatMap((target, i) => reasons[i] ? [{ target, reason: reasons[i] }] : []);
+  if (down.length === 0) return targets;
+  const lines = down.map(({ target, reason }) => {
+    const used = target.projects.length > 0 ? ` (${target.projects.join(", ")})` : "";
+    return `  ${target.url}${used}: ${reason}`;
+  });
+  const message = [
+    `[Piwi Dashboard] The app under test did not answer, so no test ran:`,
+    ...lines,
+    `Bring the environment back and run again, or set checkBaseUrl: false (PIWI_CHECK_BASE_URL=false) to run the tests anyway.`
+  ].join("\n");
+  const error = new Error(message);
+  error.stack = message;
+  throw error;
+}
+
 // src/internal/manifest/collect.ts
 var fs12 = __toESM(require("fs"));
 var path11 = __toESM(require("path"));
@@ -3785,6 +3988,10 @@ function createGlobalSetup(options, userSetup) {
       if (userSetup) return userSetup(config);
       return;
     }
+    if (opts.checkBaseUrl === true) {
+      const checked = await checkBaseUrls(config ?? {});
+      for (const target of checked) logger.debug(`Base URL answered: ${target.url}`);
+    }
     if (opts.enabled === false || !opts.serverUrl) {
       logger.info("Not enabled \u2014 set PIWI_DASHBOARD_URL or serverUrl to enable.");
       if (userSetup) return userSetup(config);
@@ -3892,7 +4099,7 @@ var path13 = __toESM(require("path"));
 
 // src/internal/probe/plan.ts
 function probeRunMetadata(base = {}) {
-  return { ...base, piwiProbe: true };
+  return { ...base, piwiProbe: true, [RUN_ORIGIN_METADATA_KEY]: { kind: "probe" } };
 }
 function parseRouteKey(routeKey2) {
   const space = routeKey2.indexOf(" ");
@@ -3900,8 +4107,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 +4131,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 +4159,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 +4184,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 +4571,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":
@@ -4501,7 +4708,12 @@ function loadFlakePlan() {
   }
 }
 function flakeRunMetadata(stamp, base = {}) {
-  return { ...base, [FLAKE_LAB_RUN_METADATA_KEY]: { experimentId: stamp.experimentId, armId: stamp.armId } };
+  const ref = parseRunOriginRef(stamp.experimentId);
+  return {
+    ...base,
+    [FLAKE_LAB_RUN_METADATA_KEY]: { experimentId: stamp.experimentId, armId: stamp.armId },
+    [RUN_ORIGIN_METADATA_KEY]: ref === void 0 ? { kind: "flake-lab" } : { kind: "flake-lab", ref }
+  };
 }
 function relativeTestFile2(file) {
   return file ? path14.relative(process.cwd(), file).split(path14.sep).join("/") : null;
@@ -5061,6 +5273,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");
@@ -5076,6 +5297,9 @@ function ciBuildUrlFromMetadata(metadata) {
 
 // src/internal/submit/run-submitter.ts
 var MAX_TIMER_DELAY_MS = 2 ** 31 - 1;
+function markSubmitFallback(run, path31, reason) {
+  run.metadata.ingestHealth = { submitFallback: { path: path31, reason } };
+}
 var RunSubmitter = class {
   /**
    * @param httpClient    HTTP client for auth resolution and the finish call.
@@ -5151,13 +5375,21 @@ var RunSubmitter = class {
     }
     if (!sm) await this.recovery.tryUpload(this.httpClient, auth);
     let outcome = { done: false, output: null };
-    if (sm?.enabled && sm?.runId != null && !sm.lostResults) {
-      outcome = await this.tryFinishStreaming(run, overallStatus, duration, auth);
+    let fallbackReason = null;
+    if (sm?.enabled && sm?.runId != null) {
+      if (sm.lostResults) fallbackReason = "results-lost";
+      else {
+        outcome = await this.tryFinishStreaming(run, overallStatus, duration, auth);
+        if (!outcome.done) fallbackReason = "finish-failed";
+      }
     }
     if (!outcome.done && !this.httpClient.closed && (this.hasReports(run) || run.options.uploadTraces)) {
+      if (fallbackReason) markSubmitFallback(run, "upload", fallbackReason);
       outcome = await this.tryUploadWithFiles(run, overallStatus, duration, auth);
+      if (!outcome.done) fallbackReason = "upload-failed";
     }
     if (!outcome.done) {
+      if (fallbackReason) markSubmitFallback(run, "submit", fallbackReason);
       outcome = await this.tryUploadJSON(run, overallStatus, duration, auth);
     }
     if (outcome.output) {
@@ -5212,7 +5444,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 +5476,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,165 +5561,2499 @@ 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" });
+}
+
+// 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 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 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;
+}
+function parseWindowsProcesses(text) {
+  let data;
+  try {
+    data = JSON.parse(text.replace(/^\uFEFF/, ""));
+  } catch {
+    return [];
+  }
+  const rows = Array.isArray(data) ? data : [data];
+  const out = [];
+  for (const row of rows) {
+    if (typeof row !== "object" || row === null) continue;
+    const record = row;
+    const pid = Number(record.ProcessId);
+    const ppid = Number(record.ParentProcessId);
+    if (!Number.isFinite(pid) || !Number.isFinite(ppid)) continue;
+    const workingSet = Number(record.WorkingSetSize);
+    const user = Number(record.UserModeTime);
+    const kernel = Number(record.KernelModeTime);
+    out.push({
+      pid,
+      ppid,
+      rssKb: Number.isFinite(workingSet) ? Math.round(workingSet / 1024) : 0,
+      cpuMs: ((Number.isFinite(user) ? user : 0) + (Number.isFinite(kernel) ? kernel : 0)) / 1e4,
+      name: typeof record.Name === "string" ? record.Name : "",
+      commandLine: typeof record.CommandLine === "string" ? record.CommandLine : ""
+    });
+  }
+  return out;
+}
+function roleOf(comm, cmdline) {
+  const command = `${comm} ${cmdline}`;
+  if (/workerProcessEntry/.test(cmdline)) return "worker";
+  if (/loaderProcessEntry/.test(cmdline)) return "runner";
+  if (/(^|[\s/])ffmpeg/.test(command)) return "ffmpeg";
+  const type = /--type=([\w-]+)/.exec(cmdline)?.[1];
+  if (/chrom|headless_shell|msedge|Google Chrome/i.test(command)) {
+    if (!type) return "browser";
+    if (type === "renderer") return "renderer";
+    if (type === "gpu-process") return "gpu";
+    return "utility";
+  }
+  if (/firefox/i.test(command)) return /-contentproc/.test(cmdline) ? "renderer" : "browser";
+  if (/WebKitWebProcess/.test(command)) return "renderer";
+  if (/WebKitGPUProcess/.test(command)) return "gpu";
+  if (/WebKitNetworkProcess/.test(command)) return "utility";
+  if (/MiniBrowser|pw_run\.sh/.test(command)) return "browser";
+  return null;
+}
+function descendantsOf(root, table) {
+  const children = /* @__PURE__ */ new Map();
+  for (const proc of table) {
+    const list = children.get(proc.ppid) ?? [];
+    list.push(proc);
+    children.set(proc.ppid, list);
+  }
+  const out = [];
+  const stack = [root];
+  const seen = /* @__PURE__ */ new Set([root]);
+  while (stack.length > 0) {
+    for (const child of children.get(stack.pop()) ?? []) {
+      if (seen.has(child.pid)) continue;
+      seen.add(child.pid);
+      out.push(child);
+      stack.push(child.pid);
+    }
+  }
+  return out;
+}
+var ProcFs = class {
+  constructor(root = "/proc") {
+    this.root = root;
+  }
+  /** Whether this looks like a Linux `/proc` at all. */
+  available() {
+    return fs18.existsSync(path19.join(this.root, "stat"));
+  }
+  /** 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 TIMED_CAP = 3600;
+var PLAYWRIGHT_TEMP = /^(playwright_\w+dev_profile-|playwright-artifacts-)/;
+function round12(value) {
+  return Math.round(value * 10) / 10;
+}
+function mean(a, b) {
+  return round12((a + b) / 2);
+}
+function mean2(a, b) {
+  return Math.round((a + b) / 2 * 100) / 100;
+}
+function pushTimed(points, point, merge) {
+  points.push(point);
+  if (points.length <= TIMED_CAP) return points;
+  const merged = [];
+  for (let i = 0; i < points.length; i += 2) {
+    const next = points[i + 1];
+    merged.push(next ? [points[i][0], merge(points[i][1], next[1])] : points[i]);
+  }
+  return merged;
+}
+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 defaultWindowsQuery() {
+  return new Promise((resolve7, reject) => {
+    (0, import_node_child_process2.execFile)(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        "[Console]::OutputEncoding=[System.Text.Encoding]::UTF8; Get-CimInstance Win32_Process | Where-Object { $_.ProcessId -ne $PID -and $_.ParentProcessId -ne $PID } | Select-Object ProcessId,ParentProcessId,WorkingSetSize,UserModeTime,KernelModeTime,Name,CommandLine | ConvertTo-Json -Compress"
+      ],
+      { timeout: 1e4, maxBuffer: 8 * 1024 * 1024, windowsHide: true },
+      (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.cpuPoints = [];
+    this.memoryPoints = [];
+    /** Each worker process's tree, by the worker's process key. */
+    this.workerTrees = /* @__PURE__ */ new Map();
+    /** When the workers' CPU was last read, for the cores they used since. */
+    this.workersReadAt = null;
+    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.windowsTreeEvery = Math.max(1, options.windowsTreeEvery ?? 3);
+    this.now = options.now ?? Date.now;
+    this.runPs = options.runPs ?? defaultPs;
+    this.runWindows = options.runWindows ?? defaultWindowsQuery;
+    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, true);
+    } catch {
+    }
+    return this.profile(await this.leftoverBytes());
+  }
+  /** The series read so far, each point at the time it was read. */
+  timedSeries() {
+    return {
+      startedAt: this.startedAt,
+      cpuPct: [...this.cpuPoints],
+      memoryBytes: [...this.memoryPoints],
+      workers: [...this.workerTrees.values()].map((tree) => ({
+        pid: tree.pid,
+        cpuCores: [...tree.cpuCores],
+        memoryBytes: [...tree.memoryBytes]
+      }))
+    };
+  }
+  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, forceTree = false) {
+    const treeDue = forceTree || this.samples % (this.heavyEvery * this.windowsTreeEvery) === 0;
+    this.samples++;
+    const at = this.now() - this.startedAt;
+    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 (busy !== null) this.cpuPoints = pushTimed(this.cpuPoints, [at, busy], mean);
+    }
+    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, at);
+    else if (this.platform === "darwin" && heavy) await this.samplePsTree(at);
+    else if (this.platform === "win32" && treeDue) await this.sampleWindowsTree(at);
+    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 worker each process of the tree belongs to: a worker process itself,
+   * or the worker it descends from (its browsers and their children). The
+   * runner and the web server belong to none. The tree lists parents first.
+   */
+  workersOf(tree, roles, keyOf2) {
+    const out = /* @__PURE__ */ new Map();
+    for (const proc of tree) {
+      if (roles.get(proc.pid) === "worker") out.set(proc.pid, { key: keyOf2(proc), pid: proc.pid });
+      else {
+        const parent = out.get(proc.ppid);
+        if (parent) out.set(proc.pid, parent);
+      }
+    }
+    return out;
+  }
+  /** The CPU a process used since the previous sample: all of it for one born since, none at the first sample. */
+  cpuSince(key, cpuMs) {
+    const known = this.tracked.get(key);
+    if (known) return Math.max(0, cpuMs - known.lastCpuMs);
+    return this.samples === 1 ? 0 : cpuMs;
+  }
+  /**
+   * Add a reading to each worker's tree: the cores its processes used since
+   * the previous reading, and on heavy samples their memory.
+   */
+  noteWorkers(workers, cpuMsByWorker, bytesByWorker, at) {
+    const elapsed = this.workersReadAt === null ? 0 : at - this.workersReadAt;
+    for (const { key, pid } of new Map([...workers.values()].map((w) => [w.key, w])).values()) {
+      let tree = this.workerTrees.get(key);
+      if (!tree) {
+        tree = { pid, cpuCores: [], memoryBytes: [] };
+        this.workerTrees.set(key, tree);
+      }
+      if (elapsed > 0) {
+        const cores = Math.round((cpuMsByWorker.get(key) ?? 0) / elapsed * 100) / 100;
+        tree.cpuCores = pushTimed(tree.cpuCores, [at, cores], mean2);
+      }
+      const bytes = bytesByWorker?.get(key);
+      if (bytes !== void 0) tree.memoryBytes = pushTimed(tree.memoryBytes, [at, bytes], Math.max);
+    }
+    this.workersReadAt = at;
+  }
+  /** 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, at) {
+    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));
+    });
+    const workers = this.workersOf(tree, roles, (proc) => `${proc.pid}:${proc.start}`);
+    const cpuMsByWorker = /* @__PURE__ */ new Map();
+    for (const proc of tree) {
+      const key = `${proc.pid}:${proc.start}`;
+      const worker = workers.get(proc.pid);
+      if (worker) {
+        cpuMsByWorker.set(worker.key, (cpuMsByWorker.get(worker.key) ?? 0) + this.cpuSince(key, proc.cpuMs));
+      }
+      const waitMs = this.proc.runWaitMs(proc.pid);
+      if (waitMs !== null) this.waitMeasured = true;
+      this.track(key, roles.get(proc.pid) ?? "other", proc.cpuMs, waitMs);
+    }
+    if (!heavy) {
+      this.noteWorkers(workers, cpuMsByWorker, null, at);
+      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 };
+      })
+    );
+    const bytesByWorker = /* @__PURE__ */ new Map();
+    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 };
+      const worker = workers.get(proc.pid);
+      if (worker) bytesByWorker.set(worker.key, (bytesByWorker.get(worker.key) ?? 0) + kb * 1024);
+    }
+    this.memoryKind = memory.some((m) => m.kb !== null && !m.fallback) ? "pss" : memory.length ? "rss" : null;
+    this.notePeak(total, largest, at);
+    this.noteWorkers(workers, cpuMsByWorker, bytesByWorker, at);
+  }
+  async samplePsTree(at) {
+    let list;
+    try {
+      list = parsePsOutput(await this.runPs());
+    } catch {
+      return;
+    }
+    this.noteTree(list, (proc) => roleOf(path22.basename(proc.command.split(" ")[0] ?? ""), proc.command), at);
+  }
+  async sampleWindowsTree(at) {
+    let list;
+    try {
+      list = parseWindowsProcesses(await this.runWindows());
+    } catch {
+      return;
+    }
+    this.noteTree(list, (proc) => roleOf(proc.name, proc.commandLine), at);
+  }
+  /** One reading of the run's tree: each process's role, CPU time and memory, and each worker's share of both. */
+  noteTree(list, role, at) {
+    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), role);
+    let total = 0;
+    let largest = null;
+    const workers = this.workersOf(tree, roles, (proc) => String(proc.pid));
+    const cpuMsByWorker = /* @__PURE__ */ new Map();
+    const bytesByWorker = /* @__PURE__ */ new Map();
+    for (const proc of tree) {
+      const procRole = roles.get(proc.pid) ?? "other";
+      const worker = workers.get(proc.pid);
+      if (worker) {
+        const cpuMs = this.cpuSince(String(proc.pid), proc.cpuMs);
+        cpuMsByWorker.set(worker.key, (cpuMsByWorker.get(worker.key) ?? 0) + cpuMs);
+        bytesByWorker.set(worker.key, (bytesByWorker.get(worker.key) ?? 0) + proc.rssKb * 1024);
+      }
+      this.track(String(proc.pid), procRole, proc.cpuMs, null);
+      total += proc.rssKb * 1024;
+      if (!largest || proc.rssKb * 1024 > largest.bytes) largest = { role: procRole, bytes: proc.rssKb * 1024 };
+    }
+    this.memoryKind = "rss";
+    this.notePeak(total, largest, at);
+    this.noteWorkers(workers, cpuMsByWorker, bytesByWorker, at);
+  }
+  notePeak(total, largest, at) {
+    this.memoryPoints = pushTimed(this.memoryPoints, [at, total], Math.max);
+    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 mean3 = slice.reduce((sum, v) => sum + v, 0) / Math.max(1, slice.length);
+    out += BARS[Math.min(BARS.length - 1, Math.max(0, Math.floor(mean3 / 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;
+var TIMELINE_SERIES_CAP = 600;
+var TIMELINE_WORKER_POINTS_CAP = 300;
+var TIMELINE_WORKERS_BUDGET = 6e3;
+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 downsamplePoints(points, cap, merge) {
+  if (points.length <= cap) return points;
+  const out = [];
+  for (let i = 0; i < cap; i++) {
+    const slice = points.slice(Math.floor(i * points.length / cap), Math.floor((i + 1) * points.length / cap));
+    if (slice.length === 0) continue;
+    const values = slice.map((point) => point[1]);
+    const value = merge === "max" ? Math.max(...values) : Math.round(values.reduce((sum, v) => sum + v, 0) / values.length * 10) / 10;
+    out.push([slice[0][0], value]);
+  }
+  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 pagesOverTime(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])) {
+    const pages = /* @__PURE__ */ new Set();
+    const changes = [];
+    let lastAt = -Infinity;
+    for (const census of list) {
+      lastAt = Math.max(lastAt, census.at);
+      for (const birth of census.born) {
+        if (birth.kind !== "page") continue;
+        pages.add(birth.id);
+        changes.push([birth.at, 1]);
+      }
+    }
+    for (const census of list) {
+      for (const close of census.closed) if (pages.has(close.id)) changes.push([close.at, -1]);
+    }
+    if (changes.length === 0) continue;
+    changes.sort((a, b) => a[0] - b[0] || b[1] - a[1]);
+    const events = [];
+    let open = 0;
+    for (const [at, delta] of changes) {
+      open = Math.max(0, open + delta);
+      const last = events[events.length - 1];
+      if (last && last[0] === at) last[1] = open;
+      else events.push([at, open]);
+    }
+    if (open > 0 && lastAt >= events[events.length - 1][0]) events.push([lastAt, 0]);
+    out.push({ worker, events });
+  }
+  return out;
+}
+function workerTreesByIndex(samples, censuses) {
+  const byPid = /* @__PURE__ */ new Map();
+  for (const census of censuses) {
+    const list = byPid.get(census.pid) ?? [];
+    list.push({ worker: census.worker, at: census.at });
+    byPid.set(census.pid, list);
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const tree of samples.workers) {
+    const candidates = byPid.get(tree.pid);
+    const times = [...tree.cpuCores, ...tree.memoryBytes].map(([at]) => samples.startedAt + at);
+    if (!candidates || times.length === 0) continue;
+    const from = Math.min(...times);
+    const to = Math.max(...times);
+    const distance = (at) => at < from ? from - at : at > to ? at - to : 0;
+    const nearest = candidates.reduce((best, c) => distance(c.at) < distance(best.at) ? c : best);
+    if (!out.has(nearest.worker)) out.set(nearest.worker, { worker: nearest.worker, ...tree });
+  }
+  return [...out.values()].sort((a, b) => a.worker - b.worker);
+}
+function resourceTimeline(samples, censuses) {
+  const workers = pagesOverTime(censuses);
+  const hasSamples = samples !== null && (samples.cpuPct.length > 0 || samples.memoryBytes.length > 0);
+  if (!hasSamples && workers.length === 0) return null;
+  let startedAt = hasSamples ? samples.startedAt : Infinity;
+  for (const { events } of workers) startedAt = Math.min(startedAt, events[0][0]);
+  const shift = hasSamples ? samples.startedAt - startedAt : 0;
+  const relative13 = (points, by) => points.map(([at, value]) => [Math.round(at + by), value]);
+  const trees = hasSamples ? workerTreesByIndex(samples, censuses) : [];
+  const perWorker = Math.max(
+    60,
+    Math.min(TIMELINE_WORKER_POINTS_CAP, Math.floor(TIMELINE_WORKERS_BUDGET / Math.max(1, 2 * trees.length)))
+  );
+  return {
+    startedAt,
+    cpuPct: hasSamples ? downsamplePoints(relative13(samples.cpuPct, shift), TIMELINE_SERIES_CAP, "mean") : [],
+    memoryBytes: hasSamples ? downsamplePoints(relative13(samples.memoryBytes, shift), TIMELINE_SERIES_CAP, "max") : [],
+    pages: workers.map(({ worker, events }) => {
+      const points = relative13(events, -startedAt);
+      const last = points.pop();
+      return { worker, points: [...downsamplePoints(points, TIMELINE_WORKER_POINTS_CAP - 1, "max"), last] };
+    }),
+    workers: trees.map((tree) => ({
+      worker: tree.worker,
+      cpuCores: downsamplePoints(relative13(tree.cpuCores, shift), perWorker, "mean"),
+      memoryBytes: downsamplePoints(relative13(tree.memoryBytes, shift), perWorker, "max")
+    }))
+  };
+}
+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),
+    timeline: resourceTimeline(input.samples ?? null, 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;
@@ -5854,7 +8422,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 +8450,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 +8523,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 +8758,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 +8803,80 @@ 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;
+    const samples = this.sampler?.timedSeries() ?? 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,
+          samples,
+          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
@@ -6258,11 +8926,16 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
   /** Playwright reporter hook: called when the full test run finishes */
   async onEnd(result) {
     if (this.listMode || !this.enabled) return;
+    if (this.startTime === null) {
+      this.logger.debug("The run stopped before any test began \u2014 nothing to report.");
+      return;
+    }
     const unrunReason = resolveUnrunReason(result?.status, {
       maxFailures: this.maxFailures,
       failures: this.failedTests + this.timedOutTests
     });
     this.materializeUnrunTests(unrunReason);
+    await this.reportResources();
     try {
       await this.submitter.submit(
         {
@@ -6282,7 +8955,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,12 +9040,14 @@ 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
 function probeElementAttrs(el, arg) {
   const { keep, tagRoles, inputRoles, roleSources, includeStructural } = arg;
+  const countMatches = arg.countMatches !== false;
+  const testIdAttr = arg.testIdAttribute || "data-testid";
   const FIELD_TAGS = ["input", "select", "textarea"];
   const textWithout = (root, skip) => {
     if (root === skip) return "";
@@ -6396,42 +9072,45 @@ function probeElementAttrs(el, arg) {
     }
   };
   const attrMap = {};
-  for (const key of keep) {
+  const keys = arg.testIdAttribute && keep.indexOf(arg.testIdAttribute) === -1 ? [...keep, arg.testIdAttribute] : keep;
+  for (const key of keys) {
     const v = el.getAttribute(key) ?? el[key];
     attrMap[key] = typeof v === "string" ? v.slice(0, 200) : v ? String(v).slice(0, 200) : null;
   }
   const r = el.getBoundingClientRect();
   const selectorCounts = {};
-  try {
-    const doc = el.ownerDocument;
-    const cssEsc = (s) => doc.defaultView.CSS.escape(s);
-    const count = (sel) => {
-      try {
-        return doc.querySelectorAll(sel).length;
-      } catch {
-        return void 0;
-      }
-    };
-    if (attrMap["data-testid"]) {
-      selectorCounts.testId = count(`[data-testid=${JSON.stringify(attrMap["data-testid"])}]`);
-    }
-    if (attrMap["id"]) selectorCounts.id = count(`#${cssEsc(attrMap["id"])}`);
-    if (attrMap["name"]) selectorCounts.name = count(`[name=${JSON.stringify(attrMap["name"])}]`);
-    if (attrMap["placeholder"]) {
-      selectorCounts.placeholder = count(`[placeholder=${JSON.stringify(attrMap["placeholder"])}]`);
-    }
-    if (attrMap["alt"]) selectorCounts.alt = count(`[alt=${JSON.stringify(attrMap["alt"])}]`);
-    if (attrMap["title"]) selectorCounts.title = count(`[title=${JSON.stringify(attrMap["title"])}]`);
-    const classList = (attrMap["class"] || "").split(/\s+/).filter((c) => c.length > 1).slice(0, 10);
-    if (classList.length > 0) {
-      const classCounts = {};
-      for (const cls of classList) {
-        const n = count(`.${cssEsc(cls)}`);
-        if (n !== void 0) classCounts[cls] = n;
+  if (countMatches) {
+    try {
+      const doc = el.ownerDocument;
+      const cssEsc = (s) => doc.defaultView.CSS.escape(s);
+      const count = (sel) => {
+        try {
+          return doc.querySelectorAll(sel).length;
+        } catch {
+          return void 0;
+        }
+      };
+      if (attrMap[testIdAttr]) {
+        selectorCounts.testId = count(`[${testIdAttr}=${JSON.stringify(attrMap[testIdAttr])}]`);
+      }
+      if (attrMap["id"]) selectorCounts.id = count(`#${cssEsc(attrMap["id"])}`);
+      if (attrMap["name"]) selectorCounts.name = count(`[name=${JSON.stringify(attrMap["name"])}]`);
+      if (attrMap["placeholder"]) {
+        selectorCounts.placeholder = count(`[placeholder=${JSON.stringify(attrMap["placeholder"])}]`);
+      }
+      if (attrMap["alt"]) selectorCounts.alt = count(`[alt=${JSON.stringify(attrMap["alt"])}]`);
+      if (attrMap["title"]) selectorCounts.title = count(`[title=${JSON.stringify(attrMap["title"])}]`);
+      const classList = (attrMap["class"] || "").split(/\s+/).filter((c) => c.length > 1).slice(0, 10);
+      if (classList.length > 0) {
+        const classCounts = {};
+        for (const cls of classList) {
+          const n = count(`.${cssEsc(cls)}`);
+          if (n !== void 0) classCounts[cls] = n;
+        }
+        selectorCounts.classes = classCounts;
       }
-      selectorCounts.classes = classCounts;
+    } catch {
     }
-  } catch {
   }
   let rolePosition = null;
   const ancestors = [];
@@ -6448,7 +9127,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 +9150,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");
@@ -6520,8 +9199,8 @@ function probeElementAttrs(el, arg) {
         }
         return total;
       };
-      const nodes = doc.querySelectorAll(roleSources);
-      const nodesUsable = nodes.length <= 4e3;
+      const nodes = countMatches ? doc.querySelectorAll(roleSources) : [];
+      const nodesUsable = countMatches && nodes.length <= 4e3;
       const rolesUsable = !!targetRole && nodesUsable;
       if (rolesUsable) {
         let roleCountAll = 0;
@@ -6531,7 +9210,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++;
@@ -6555,17 +9234,18 @@ function probeElementAttrs(el, arg) {
           };
         }
       }
-      if (textNeedle) {
+      if (textNeedle && countMatches) {
         const textCount = countTextOwners(doc.body || doc.documentElement, 4e3);
         if (textCount >= 0) selectorCounts.text = textCount;
       }
-      if (rolesUsable || textNeedle) {
+      if (rolesUsable || textNeedle || !countMatches) {
         const CONTAINER_TAGS = ["form", "nav", "main", "article", "section", "dialog", "table", "li", "tr"];
         const NOISY_DATA_ATTR = /^data-(v-[0-9a-f]+|reactid|react-checksum|svelte-\w+|ng-\w+|ember\w*)$/i;
         const POSITIONAL_DATA_ATTR = /^data-(index|idx|i|key|row|rownum|col|column|position|pos|order|sort|offset|page)$/i;
         const TEST_DATA_ATTRS2 = ["data-test", "data-test-id", "data-qa", "data-qa-id", "data-cy", "data-e2e"];
+        const testIdName = testIdAttr.toLowerCase();
         const usableDataAttr = (name, value) => {
-          if (!name || name.slice(0, 5) !== "data-" || name === "data-testid") return false;
+          if (!name || name.slice(0, 5) !== "data-" || name.toLowerCase() === testIdName) return false;
           if (NOISY_DATA_ATTR.test(name) || POSITIONAL_DATA_ATTR.test(name)) return false;
           return !!value && value.length <= 120;
         };
@@ -6584,7 +9264,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();
@@ -6595,7 +9275,13 @@ function probeElementAttrs(el, arg) {
           return digits <= letters;
         };
         const usableDiscriminator = (t) => !!t && t.length <= 60 && t !== targetText && namesRatherThanReports(t);
+        const hasAtMost = (root, cap) => {
+          const walker = doc.createTreeWalker(root, 1);
+          for (let n = 0; walker.nextNode(); n++) if (n >= cap) return false;
+          return true;
+        };
         const discriminatingText = (anc) => {
+          if (!countMatches && !hasAtMost(anc, 200)) return null;
           const heading = anc.querySelector('h1,h2,h3,h4,h5,h6,[role="heading"]');
           if (heading) {
             const t = rawText(heading);
@@ -6616,7 +9302,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;
@@ -6627,7 +9313,7 @@ function probeElementAttrs(el, arg) {
           depth++;
           const tag = (node.tagName || "").toLowerCase();
           if (tag === "body" || tag === "html") break;
-          const testId = node.getAttribute("data-testid");
+          const testId = node.getAttribute(testIdAttr);
           const id = node.getAttribute("id");
           const explicitRole = node.getAttribute("role");
           const ariaLabel = node.getAttribute("aria-label");
@@ -6641,16 +9327,16 @@ 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++;
                 }
               }
             }
-            const scopedTextCount = countTextOwners(node, 2e3);
+            const scopedTextCount = countMatches ? countTextOwners(node, 2e3) : -1;
             let filterText = null;
             try {
-              if (anchorRole && nodesUsable) filterText = discriminatingText(node);
+              if (anchorRole && (nodesUsable || !countMatches)) filterText = discriminatingText(node);
             } catch {
               filterText = null;
             }
@@ -6663,11 +9349,13 @@ function probeElementAttrs(el, arg) {
               ariaLabel: ariaLabel || null,
               ...scopedRoleCount >= 0 ? { scopedRoleCount } : {},
               ...scopedTextCount >= 0 ? { scopedTextCount } : {},
-              ...testId ? { testIdCount: count(`[data-testid=${JSON.stringify(testId)}]`) } : {},
-              ...id ? { idCount: count(`#${cssEsc(id)}`) } : {},
+              ...testId && countMatches ? { testIdCount: count(`[${testIdAttr}=${JSON.stringify(testId)}]`) } : {},
+              ...id && countMatches ? { idCount: count(`#${cssEsc(id)}`) } : {},
               ...anchorRole && nodesUsable ? { roleCount: docRoleCount(anchorRole) } : {},
-              ...filterText ? { filterText, filterRoleCount: filterMatchCount(anchorRole, filterText) } : {},
-              ...dataAttr ? { dataAttr, dataAttrCount: count(`[${dataAttr.name}=${JSON.stringify(dataAttr.value)}]`) } : {}
+              ...filterText ? { filterText } : {},
+              ...filterText && countMatches ? { filterRoleCount: filterMatchCount(anchorRole, filterText) } : {},
+              ...dataAttr ? { dataAttr } : {},
+              ...dataAttr && countMatches ? { dataAttrCount: count(`[${dataAttr.name}=${JSON.stringify(dataAttr.value)}]`) } : {}
             });
           }
           node = node.parentElement;
@@ -6705,6 +9393,17 @@ function installPickerOverlay(arg) {
     return;
   }
   const Z = 2147483600;
+  const testIdAttr = arg.testIdAttribute || "data-testid";
+  const words = {
+    banner: "Piwi inspector \u2014 click any element to generate locators for it",
+    keys: "\u2191 parent \xB7 \u2193 child \xB7 Esc skip",
+    keysHovering: "click to pick \xB7 \u2191 parent \xB7 \u2193 child \xB7 Esc skip",
+    analyzing: "Analyzing element\u2026"
+  };
+  for (const key of Object.keys(words)) {
+    const given = arg.strings?.[key];
+    if (typeof given === "string" && given) words[key] = given;
+  }
   const highlight = doc.createElement("div");
   highlight.id = "__piwi_picker_highlight";
   highlight.style.cssText = `position:fixed;pointer-events:none;z-index:${Z};display:none;box-sizing:border-box;border:2px solid #a855f7;background:rgba(168,85,247,.14);border-radius:4px;box-shadow:0 0 0 1px rgba(255,255,255,.9),0 0 0 3px rgba(59,7,100,.55),inset 0 0 0 1px rgba(255,255,255,.5);`;
@@ -6729,27 +9428,53 @@ function installPickerOverlay(arg) {
   const MONO = "ui-monospace,SFMono-Regular,Menlo,Consolas,monospace";
   const hlLocator = (expr) => `<code style="font-family:${MONO}">${hlTokens(expr)}</code>`;
   const head = doc.createElement("div");
-  head.innerHTML = arg.transport === "postMessage" ? "Click an element to generate locators" : arg.failing ? `Piwi locator picker \u2014 click the element that should replace ${hlLocator(arg.failing)}` : "Piwi inspector \u2014 click any element to generate locators for it";
+  if (arg.transport === "postMessage") head.textContent = "Click an element to generate locators";
+  else if (arg.failing)
+    head.innerHTML = `Piwi locator picker \u2014 click the element that should replace ${hlLocator(arg.failing)}`;
+  else head.textContent = words.banner;
   const locatorLine = doc.createElement("div");
   locatorLine.id = "__piwi_picker_locator";
   locatorLine.style.cssText = `display:none;margin-top:7px;padding:5px 9px;border-radius:7px;background:#0b1120;border:1px solid #4c1d95;font:13.5px/1.55 ${MONO};word-break:break-word;overflow-wrap:anywhere;`;
   const foot = doc.createElement("div");
   foot.id = "__piwi_picker_foot";
   foot.style.cssText = "color:#9ca3af;margin-top:6px;font-size:12px;";
-  foot.textContent = "\u2191 parent \xB7 \u2193 child \xB7 Esc skip";
+  foot.textContent = words.keys;
   banner.appendChild(head);
   banner.appendChild(locatorLine);
   banner.appendChild(foot);
   const label = doc.createElement("div");
   label.id = "__piwi_picker_label";
   label.style.cssText = `position:fixed;pointer-events:none;z-index:${Z + 1};display:none;box-sizing:border-box;max-width:min(620px,92vw);background:#0b1120;color:#f9fafb;border:1px solid #7c3aed;border-radius:7px;padding:4px 8px;font:12.5px/1.45 ${MONO};white-space:nowrap;overflow:hidden;text-overflow:ellipsis;box-shadow:0 4px 18px rgba(0,0,0,.5);`;
-  doc.body.appendChild(highlight);
-  doc.body.appendChild(label);
-  doc.body.appendChild(banner);
+  const mountParent = () => {
+    let modal = null;
+    try {
+      modal = doc.querySelector("dialog:modal");
+    } catch {
+      modal = null;
+    }
+    if (!modal) return doc.body;
+    const s = g.getComputedStyle(modal);
+    const holdsFixed = s.transform !== "none" || s.perspective !== "none" || s.filter !== "none" || /\b(paint|layout|strict|content)\b/.test(s.contain) || /\b(transform|perspective|filter)\b/.test(s.willChange);
+    return holdsFixed ? doc.body : modal;
+  };
+  const mount = (...nodes) => {
+    const parent = mountParent();
+    for (const node of nodes) parent.appendChild(node);
+    if (parent !== doc.body) {
+      parent.addEventListener(
+        "close",
+        () => {
+          for (const node of nodes) if (node.parentNode === parent) doc.body.appendChild(node);
+        },
+        { once: true }
+      );
+    }
+  };
+  mount(highlight, label, banner);
   const escJs = (s) => s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
   const describe = (el) => {
     const tag = (el.tagName || "?").toLowerCase();
-    const testId = el.getAttribute && el.getAttribute("data-testid");
+    const testId = el.getAttribute && el.getAttribute(testIdAttr);
     if (testId) return `getByTestId('${escJs(testId)}')`;
     if (el.labels && el.labels.length > 0) {
       const labelText = (el.labels[0].textContent || "").replace(/\s+/g, " ").trim().slice(0, 80);
@@ -6784,7 +9509,7 @@ function installPickerOverlay(arg) {
       const el = chain2[i];
       const tag = (el.tagName || "").toLowerCase();
       if (ACTIONABLE_TAGS.includes(tag)) return i;
-      if (el.getAttribute && (el.getAttribute("role") || el.getAttribute("data-testid"))) return i;
+      if (el.getAttribute && (el.getAttribute("role") || el.getAttribute(testIdAttr))) return i;
     }
     return 0;
   };
@@ -6840,7 +9565,7 @@ function installPickerOverlay(arg) {
       locatorLine.style.display = "block";
     }
     placeLabel(r);
-    foot.textContent = "click to pick \xB7 \u2191 parent \xB7 \u2193 child \xB7 Esc skip";
+    foot.textContent = words.keysHovering;
   };
   const redescribe = () => {
     labeled = null;
@@ -6903,6 +9628,13 @@ function installPickerOverlay(arg) {
     banner.remove();
     if (g.__piwiRedescribe === redescribe) delete g.__piwiRedescribe;
   };
+  const teardown = () => {
+    removePickingListeners();
+    removeSuppressed();
+    doc.removeEventListener("click", stop, true);
+    doc.removeEventListener("keydown", stop, true);
+    cleanup();
+  };
   const reportPicked = (el) => {
     removePickingListeners();
     highlight.style.display = "none";
@@ -6913,13 +9645,13 @@ function installPickerOverlay(arg) {
       g.__piwiSnapshotExtras?.onPick?.();
       doc.addEventListener("click", stop, true);
       doc.addEventListener("keydown", stop, true);
-      foot.textContent = "Analyzing element\u2026";
+      foot.textContent = words.analyzing;
       g.parent.postMessage({ type: "elementPicked", attrs }, "*");
     } else {
       removeSuppressed();
       g.__piwiPickedElement = el;
       g.__piwiPickState = "picked";
-      foot.textContent = "Analyzing element\u2026";
+      foot.textContent = words.analyzing;
     }
   };
   const reportSkipped = () => {
@@ -6967,7 +9699,7 @@ function installPickerOverlay(arg) {
       }
     });
   };
-  g.__piwiPickCleanup = cleanup;
+  g.__piwiPickCleanup = teardown;
   doc.addEventListener("mousemove", onMove, true);
   doc.addEventListener("click", onClick, true);
   doc.addEventListener("keydown", onKey, true);
@@ -6989,7 +9721,27 @@ function showAnchorPicker(arg) {
   }
   const Z = 2147483600;
   const { tagRoles, inputRoles, roleSources, leafRole, leafLevel, leafTestId } = arg;
-  const roleOf = (n) => {
+  const testIdAttr = arg.testIdAttribute || "data-testid";
+  const words = {
+    title: "Scope to stable parents (optional)",
+    hint: "Pick one or more parents to anchor the locator to. Hover a row to see the parent.",
+    noneSelected: "No parents selected \u2014 standard alternatives only.",
+    matchesOne: "\u2713 Selection matches exactly 1 element",
+    matchesMany: "\u2717 Selection matches {count} elements",
+    countUnavailable: "Match count unavailable",
+    containsOne: "contains exactly 1 matching element",
+    containsMany: "contains {count} matching elements",
+    needsTestId: `add a ${testIdAttr} to make this usable`,
+    noHook: "no stable hook",
+    use: "Use selected parents",
+    skip: "Skip (Esc)"
+  };
+  for (const key of Object.keys(words)) {
+    const given = arg.strings?.[key];
+    if (typeof given === "string" && given) words[key] = given;
+  }
+  const counted = (template, n) => template.replace("{count}", String(n));
+  const roleOf2 = (n) => {
     const explicit = n.getAttribute && n.getAttribute("role");
     if (explicit) return explicit;
     const tag = (n.tagName || "").toLowerCase();
@@ -7004,15 +9756,17 @@ function showAnchorPicker(arg) {
     const al = n.getAttribute && n.getAttribute("aria-level");
     return al && /^\d+$/.test(al) ? Number(al) : null;
   };
+  const leafCountable = !!leafTestId || roleOf2(el) === leafRole;
   const leafMatches = (scope) => {
     try {
-      if (leafTestId) return scope.querySelectorAll(`[data-testid=${JSON.stringify(leafTestId)}]`).length;
+      if (leafTestId) return scope.querySelectorAll(`[${testIdAttr}=${JSON.stringify(leafTestId)}]`).length;
+      if (!leafCountable) return -1;
       const nodes = scope.querySelectorAll(roleSources);
       if (nodes.length > 2e3) return -1;
       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++;
       }
@@ -7042,12 +9796,12 @@ function showAnchorPicker(arg) {
     depth++;
     const tag = (node.tagName || "").toLowerCase();
     if (tag === "body" || tag === "html") break;
-    const testId = node.getAttribute("data-testid");
+    const testId = node.getAttribute(testIdAttr);
     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 (testId) info.testIdCount = count(`[${testIdAttr}=${JSON.stringify(testId)}]`);
     if (id) {
       try {
         info.idCount = count(`#${doc.defaultView.CSS.escape(id)}`);
@@ -7058,7 +9812,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++;
       }
@@ -7066,7 +9820,7 @@ function showAnchorPicker(arg) {
       if (ariaLabel) info.labeledRoleCount = labeledCount;
     }
     info.scopedLeafCount = leafMatches(node);
-    const hookLabel = testId ? `data-testid="${testId}"` : id ? `#${id}` : ariaLabel && role ? `${role} "${ariaLabel}"` : role ? `role ${role}` : "no stable hook";
+    const hookLabel = testId ? `${testIdAttr}="${testId}"` : id ? `#${id}` : ariaLabel && role ? `${role} "${ariaLabel}"` : role ? `role ${role}` : words.noHook;
     rows.push({
       node,
       info,
@@ -7088,13 +9842,13 @@ function showAnchorPicker(arg) {
   const pr = el.getBoundingClientRect();
   pickedOutline.style.cssText = `position:fixed;pointer-events:none;z-index:${Z};box-sizing:border-box;border:2px solid #a855f7;background:rgba(168,85,247,.14);border-radius:4px;box-shadow:0 0 0 1px rgba(255,255,255,.9),0 0 0 3px rgba(59,7,100,.55);left:${pr.left}px;top:${pr.top}px;width:${pr.width}px;height:${pr.height}px;`;
   const panel = doc.createElement("div");
-  panel.style.cssText = `position:fixed;top:12px;right:12px;z-index:${Z + 3};width:340px;max-height:82vh;overflow:auto;background:#111827;color:#f9fafb;border-radius:10px;padding:16px;font:12px/1.5 system-ui,sans-serif;box-shadow:0 8px 40px rgba(0,0,0,.5);`;
+  panel.style.cssText = `position:fixed;top:12px;right:12px;z-index:${Z + 3};width:min(340px,calc(100vw - 56px));max-height:82vh;overflow:auto;background:#111827;color:#f9fafb;border-radius:10px;padding:16px;font:12px/1.5 system-ui,sans-serif;box-shadow:0 8px 40px rgba(0,0,0,.5);`;
   const title = doc.createElement("div");
   title.style.cssText = "font-weight:600;font-size:13px;margin-bottom:2px;";
-  title.textContent = "Scope to stable parents (optional)";
+  title.textContent = words.title;
   const sub = doc.createElement("div");
   sub.style.cssText = "color:#9ca3af;margin-bottom:10px;";
-  sub.textContent = "Pick one or more parents to anchor the locator to. Hover a row to see the parent.";
+  sub.textContent = words.hint;
   panel.appendChild(title);
   panel.appendChild(sub);
   const selected = /* @__PURE__ */ new Set();
@@ -7102,12 +9856,12 @@ function showAnchorPicker(arg) {
   footer.style.cssText = "margin:10px 0;font-weight:600;";
   const segMatches = (scope, info) => {
     try {
-      if (info.testId) return Array.from(scope.querySelectorAll(`[data-testid=${JSON.stringify(info.testId)}]`));
+      if (info.testId) return Array.from(scope.querySelectorAll(`[${testIdAttr}=${JSON.stringify(info.testId)}]`));
       if (info.id) return Array.from(scope.querySelectorAll(`#${doc.defaultView.CSS.escape(info.id)}`));
       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 [];
@@ -7126,14 +9880,15 @@ function showAnchorPicker(arg) {
     let total = 0;
     for (const s of scopes) {
       const c = leafMatches(s);
-      if (c > 0) total += c;
+      if (c < 0) return -1;
+      total += c;
       if (total > 50) return total;
     }
     return total;
   };
   const refreshFooter = () => {
     if (selected.size === 0) {
-      footer.textContent = "No parents selected \u2014 standard alternatives only.";
+      footer.textContent = words.noneSelected;
       footer.style.color = "#9ca3af";
       g.__piwiPickChainCount = void 0;
       return;
@@ -7141,10 +9896,10 @@ function showAnchorPicker(arg) {
     const c = chainCount();
     g.__piwiPickChainCount = c;
     if (c === 1) {
-      footer.textContent = "\u2713 Selection matches exactly 1 element";
+      footer.textContent = words.matchesOne;
       footer.style.color = "#4ade80";
     } else {
-      footer.textContent = c < 0 ? "Match count unavailable" : `\u2717 Selection matches ${c} elements`;
+      footer.textContent = c < 0 ? words.countUnavailable : counted(words.matchesMany, c);
       footer.style.color = "#fbbf24";
     }
   };
@@ -7161,7 +9916,8 @@ function showAnchorPicker(arg) {
     code.textContent = `<${row.info.tag}> ${row.hookLabel}`;
     const hint = doc.createElement("span");
     hint.style.cssText = "color:#9ca3af;";
-    hint.textContent = row.selectable ? row.info.scopedLeafCount === 1 ? "contains exactly 1 matching element" : `contains ${row.info.scopedLeafCount ?? "?"} matching elements` : "add a data-testid to make this usable";
+    const inside = row.info.scopedLeafCount ?? -1;
+    hint.textContent = row.selectable ? inside === 1 ? words.containsOne : inside < 0 ? words.countUnavailable : counted(words.containsMany, inside) : words.needsTestId;
     text.appendChild(code);
     text.appendChild(hint);
     line.appendChild(box);
@@ -7199,6 +9955,7 @@ function showAnchorPicker(arg) {
     outline.remove();
     outlineLabel.remove();
     pickedOutline.remove();
+    if (g.__piwiAnchorCleanup === cleanup) delete g.__piwiAnchorCleanup;
   };
   const done = (state) => {
     g.__piwiPickAnchors = state === "done" ? rows.filter((_, i) => selected.has(i)).map((r) => r.info) : [];
@@ -7215,7 +9972,7 @@ function showAnchorPicker(arg) {
   buttonRow.style.cssText = "display:flex;gap:8px;margin-top:4px;";
   const useBtn = doc.createElement("button");
   useBtn.style.cssText = "flex:1;background:#7c3aed;color:#fff;border:none;border-radius:6px;padding:8px;cursor:pointer;font:600 12px system-ui;";
-  useBtn.textContent = "Use selected parents";
+  useBtn.textContent = words.use;
   useBtn.addEventListener("click", (e) => {
     e.preventDefault();
     e.stopImmediatePropagation();
@@ -7223,7 +9980,7 @@ function showAnchorPicker(arg) {
   });
   const skipBtn = doc.createElement("button");
   skipBtn.style.cssText = "background:none;border:1px solid #374151;color:#9ca3af;border-radius:6px;padding:8px 10px;cursor:pointer;font:12px system-ui;";
-  skipBtn.textContent = "Skip (Esc)";
+  skipBtn.textContent = words.skip;
   skipBtn.addEventListener("click", (e) => {
     e.preventDefault();
     e.stopImmediatePropagation();
@@ -7235,10 +9992,32 @@ function showAnchorPicker(arg) {
   refreshFooter();
   g.__piwiAnchorCleanup = cleanup;
   doc.addEventListener("keydown", onKey, true);
-  doc.body.appendChild(pickedOutline);
-  doc.body.appendChild(outline);
-  doc.body.appendChild(outlineLabel);
-  doc.body.appendChild(panel);
+  const mountParent = () => {
+    let modal = null;
+    try {
+      modal = doc.querySelector("dialog:modal");
+    } catch {
+      modal = null;
+    }
+    if (!modal) return doc.body;
+    const s = g.getComputedStyle(modal);
+    const holdsFixed = s.transform !== "none" || s.perspective !== "none" || s.filter !== "none" || /\b(paint|layout|strict|content)\b/.test(s.contain) || /\b(transform|perspective|filter)\b/.test(s.willChange);
+    return holdsFixed ? doc.body : modal;
+  };
+  const mount = (...nodes) => {
+    const parent = mountParent();
+    for (const node2 of nodes) parent.appendChild(node2);
+    if (parent !== doc.body) {
+      parent.addEventListener(
+        "close",
+        () => {
+          for (const node2 of nodes) if (node2.parentNode === parent) doc.body.appendChild(node2);
+        },
+        { once: true }
+      );
+    }
+  };
+  mount(pickedOutline, outline, outlineLabel, panel);
 }
 
 // ../picker-dom/src/overlay-confirm.ts
@@ -7454,7 +10233,7 @@ function isAutoGenerated(value) {
   return false;
 }
 var TEST_DATA_ATTRS = /* @__PURE__ */ new Set(["data-test", "data-test-id", "data-qa", "data-qa-id", "data-cy", "data-e2e"]);
-function generateAlternatives(attrs) {
+function generateAlternatives(attrs, options = {}) {
   const alts = [];
   const seen = /* @__PURE__ */ new Set();
   const add = (loc) => {
@@ -7465,12 +10244,14 @@ function generateAlternatives(attrs) {
   };
   const { accessibleName } = attrs;
   const tag = attrs.tagName;
-  const role = resolveAriaRole(attrs);
+  const role = options.role !== void 0 ? options.role : resolveAriaRole(attrs);
   const counts = attrs.selectorCounts;
   const isUnique = (n) => n == null || n <= 1;
   const ambiguityPenalty = (n) => n != null && n > 1 ? 45 : 0;
   const text = attrs.textContent ? attrs.textContent.replace(/\s+/g, " ").trim() : null;
-  const testId = attr(attrs, "data-testid");
+  const testIdAttribute = options.testIdAttribute || "data-testid";
+  const selectable = (name2) => name2.toLowerCase() !== testIdAttribute.toLowerCase();
+  const testId = attr(attrs, testIdAttribute);
   if (testId && isUnique(counts?.testId)) {
     add({
       locator: `getByTestId('${esc(testId)}')`,
@@ -7529,7 +10310,7 @@ function generateAlternatives(attrs) {
     });
   }
   const id = attr(attrs, "id");
-  if (id && !isAutoGenerated(id) && isUnique(counts?.id)) {
+  if (id && selectable("id") && !isAutoGenerated(id) && isUnique(counts?.id)) {
     const selector = isCssSafeId(id) ? `#${id}` : `[id="${escCssAttrValue(id)}"]`;
     add({
       locator: `locator('${esc(selector)}')`,
@@ -7539,7 +10320,7 @@ function generateAlternatives(attrs) {
     });
   }
   const name = attr(attrs, "name");
-  if (name && isUnique(counts?.name)) {
+  if (name && selectable("name") && isUnique(counts?.name)) {
     const selector = `[name="${escCssAttrValue(name)}"]`;
     add({
       locator: `locator('${esc(selector)}')`,
@@ -7584,7 +10365,7 @@ function generateAlternatives(attrs) {
           score: scores.testId
         });
       }
-      if (!idAnchorDone && anc.id && !isAutoGenerated(anc.id) && anc.idCount === 1) {
+      if (!idAnchorDone && anc.id && selectable("id") && !isAutoGenerated(anc.id) && anc.idCount === 1) {
         idAnchorDone = true;
         const anchorSelector = isCssSafeId(anc.id) ? `#${anc.id}` : `[id="${escCssAttrValue(anc.id)}"]`;
         add({
@@ -7594,7 +10375,7 @@ function generateAlternatives(attrs) {
           score: scores.id
         });
       }
-      if (!dataAnchorDone && anc.dataAttr && anc.dataAttrCount === 1) {
+      if (!dataAnchorDone && anc.dataAttr && selectable(anc.dataAttr.name) && anc.dataAttrCount === 1) {
         dataAnchorDone = true;
         const { name: name2, value } = anc.dataAttr;
         const anchorSelector = `[${name2}="${escCssAttrValue(value)}"]`;
@@ -7760,7 +10541,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 +10911,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 +10928,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 +10982,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 +11000,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 +11125,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 +11142,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 +11290,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 +11549,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 +11574,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 +11609,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 +11799,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 +11814,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 +11830,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 +11871,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 +11884,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 +12000,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 +12378,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 +12565,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 +12708,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 +12771,7 @@ var piwiFixtures = {
           file: testInfo.file,
           titlePath: testInfo.titlePath
         });
+      activeResourceLedger()?.testStarted(testInfo);
       currentSink = sink;
       try {
         await use();
@@ -10052,6 +12798,7 @@ var piwiFixtures = {
         }
         if (sink.flake) await recordFlakeAttempt(sink.flake, testInfo);
         await flushSink(sink, testInfo);
+        await recordResourceCensus(testInfo);
       }
     },
     { auto: true }
@@ -10083,13 +12830,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 +12929,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 +12939,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 +12970,7 @@ function withEntryLock(file, fn) {
     return fn();
   } finally {
     try {
-      fs19.unlinkSync(lock);
+      fs23.unlinkSync(lock);
     } catch {
     }
   }
@@ -10231,7 +12978,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 +12992,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 +13512,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 +13539,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 = "";
       }