@piwitests/reporter 0.45.0 → 0.47.0

package/dist/index.js

@@ -89,6 +89,7 @@ var DEFAULTS = {
   sampleAriaOnPass: true,
   uploadManifest: true,
   defaultCapture: true,
+  checkBaseUrl: false,
   streaming: true,
   streamingBatchSize: 5,
   streamingBatchDelay: 2e3,
@@ -131,6 +132,7 @@ var PIWI_ENV_KEYS = {
   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",
@@ -151,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",
@@ -196,6 +202,7 @@ var ENV_FALLBACK_SPECS = [
   { 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" }
@@ -243,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";
@@ -1008,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");
@@ -1322,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) => {
@@ -1366,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\//, "");
 }
@@ -1375,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;
@@ -1552,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;
@@ -3700,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"));
@@ -3799,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);
@@ -3906,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(" ");
@@ -4515,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;
@@ -5099,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.
@@ -5174,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) {
@@ -5490,6 +5699,35 @@ function parsePsOutput(text) {
   }
   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";
@@ -6813,10 +7051,27 @@ 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;
 }
@@ -6841,6 +7096,21 @@ function defaultPs() {
     );
   });
 }
+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 (; ; ) {
@@ -6888,6 +7158,12 @@ var RunSampler = class {
     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;
@@ -6907,8 +7183,10 @@ var RunSampler = class {
     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. */
@@ -6931,11 +7209,24 @@ var RunSampler = class {
     this.timer = null;
     try {
       await this.running;
-      await this.sample(true);
+      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;
@@ -6946,18 +7237,22 @@ var RunSampler = class {
   cpuTicks() {
     return this.linux ? this.proc.cpuTicks() : nodeCpuTicks();
   }
-  async sample(heavy) {
+  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);
-    else if (this.platform === "darwin" && heavy) await this.samplePsTree();
+    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) {
@@ -6977,6 +7272,49 @@ var RunSampler = class {
       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"]]);
@@ -6987,7 +7325,7 @@ var RunSampler = class {
     }
     return roles;
   }
-  async sampleLinuxTree(heavy) {
+  async sampleLinuxTree(heavy, at) {
     const table = this.proc.table();
     const root = table.get(this.rootPid);
     if (!root) return;
@@ -6998,12 +7336,22 @@ var RunSampler = class {
       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(`${proc.pid}:${proc.start}`, roles.get(proc.pid) ?? "other", proc.cpuMs, waitMs);
+      this.track(key, roles.get(proc.pid) ?? "other", proc.cpuMs, waitMs);
+    }
+    if (!heavy) {
+      this.noteWorkers(workers, cpuMsByWorker, null, at);
+      return;
     }
-    if (!heavy) return;
     let total = 0;
     let largest = null;
     const memory = await Promise.all(
@@ -7013,42 +7361,67 @@ var RunSampler = class {
         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);
+    this.notePeak(total, largest, at);
+    this.noteWorkers(workers, cpuMsByWorker, bytesByWorker, at);
   }
-  async samplePsTree() {
+  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),
-      (proc) => roleOf(path22.basename(proc.command.split(" ")[0] ?? ""), proc.command)
-    );
+    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 role = roles.get(proc.pid) ?? "other";
-      this.track(String(proc.pid), role, proc.cpuMs, null);
+      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, bytes: proc.rssKb * 1024 };
+      if (!largest || proc.rssKb * 1024 > largest.bytes) largest = { role: procRole, bytes: proc.rssKb * 1024 };
     }
     this.memoryKind = "rss";
-    this.notePeak(total, largest);
+    this.notePeak(total, largest, at);
+    this.noteWorkers(workers, cpuMsByWorker, bytesByWorker, at);
   }
-  notePeak(total, largest) {
+  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;
@@ -7252,8 +7625,8 @@ function sparkline(series, width = 24) {
       Math.floor(i * series.length / buckets),
       Math.floor((i + 1) * series.length / buckets)
     );
-    const mean = slice.reduce((sum, v) => sum + v, 0) / Math.max(1, slice.length);
-    out += BARS[Math.min(BARS.length - 1, Math.max(0, Math.floor(mean / 100 * BARS.length)))];
+    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;
 }
@@ -7357,6 +7730,9 @@ function formatMachinePanel(profile, extras) {
 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 = [];
@@ -7366,6 +7742,18 @@ function downsample(series, cap) {
   }
   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;
@@ -7405,6 +7793,93 @@ function openPagesByWorker(censuses) {
   }
   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 {
@@ -7415,7 +7890,8 @@ function resourceReportWire(input) {
     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)
+    workerHealth: workerHealthOf(input.censuses),
+    timeline: resourceTimeline(input.samples ?? null, input.censuses)
   };
 }
 
@@ -8366,6 +8842,7 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
   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) {
@@ -8388,6 +8865,7 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
         this.resourceReport = resourceReportWire({
           report,
           profile,
+          samples,
           censuses,
           artifacts: this.artifactBytes,
           shardIndex: this.shardInfo?.current ?? null
@@ -8448,6 +8926,10 @@ 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
@@ -8564,6 +9046,8 @@ 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 "";
@@ -8588,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 = [];
@@ -8712,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;
@@ -8747,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;
         };
@@ -8787,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);
@@ -8819,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");
@@ -8839,10 +9333,10 @@ function probeElementAttrs(el, arg) {
                 }
               }
             }
-            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;
             }
@@ -8855,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;
@@ -8897,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);`;
@@ -8921,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);
@@ -8976,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;
   };
@@ -9032,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;
@@ -9095,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";
@@ -9105,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 = () => {
@@ -9159,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);
@@ -9181,6 +9721,26 @@ function showAnchorPicker(arg) {
   }
   const Z = 2147483600;
   const { tagRoles, inputRoles, roleSources, leafRole, leafLevel, leafTestId } = arg;
+  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;
@@ -9196,9 +9756,11 @@ 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;
@@ -9234,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 = 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)}`);
@@ -9258,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,
@@ -9280,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();
@@ -9294,7 +9856,7 @@ 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 [];
@@ -9318,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;
@@ -9333,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";
     }
   };
@@ -9353,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);
@@ -9391,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) : [];
@@ -9407,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();
@@ -9415,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();
@@ -9427,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
@@ -9646,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) => {
@@ -9657,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)}')`,
@@ -9721,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)}')`,
@@ -9731,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)}')`,
@@ -9776,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({
@@ -9786,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)}"]`;