@piwitests/reporter 0.60.0 → 0.62.0

package/dist/index.js

@@ -65,9 +65,9 @@ function processAlive(pid) {
     return error.code === "EPERM";
   }
 }
-function readDesktopConfig(filePath2) {
+function readDesktopConfig(filePath3) {
   try {
-    const parsed2 = JSON.parse(fs.readFileSync(filePath2, "utf8"));
+    const parsed2 = JSON.parse(fs.readFileSync(filePath3, "utf8"));
     const url = parsed2?.url;
     const token = parsed2?.token;
     if (typeof url !== "string" || !url) return null;
@@ -102,9 +102,9 @@ function parseDotEnv(text) {
 }
 
 // src/internal/config/dotenv.ts
-function readDotEnv(filePath2) {
+function readDotEnv(filePath3) {
   try {
-    return parseDotEnv(fs2.readFileSync(filePath2, "utf-8"));
+    return parseDotEnv(fs2.readFileSync(filePath3, "utf-8"));
   } catch {
     return {};
   }
@@ -203,6 +203,7 @@ var PIWI_ENV_KEYS = {
   codeReachRoots: "PIWI_CODE_REACH_ROOTS",
   coverageBrowser: "PIWI_COVERAGE_BROWSER",
   coverageServer: "PIWI_COVERAGE_SERVER",
+  coverageCss: "PIWI_COVERAGE_CSS",
   externalIdPattern: "PIWI_EXTERNAL_ID_PATTERN",
   externalIdOnDuplicate: "PIWI_EXTERNAL_ID_ON_DUPLICATE",
   captureServerTraces: "PIWI_CAPTURE_SERVER_TRACES",
@@ -357,10 +358,14 @@ function resolveOptions(raw, configDir) {
   const coverage = { ...mergedRaw.coverage };
   const coverageBrowser = env[PIWI_ENV_KEYS.coverageBrowser];
   const coverageServer = env[PIWI_ENV_KEYS.coverageServer];
+  const coverageCss = env[PIWI_ENV_KEYS.coverageCss];
   if (coverage.browser === void 0 && coverageBrowser)
     coverage.browser = coverageBrowser;
   if (coverage.server === void 0 && coverageServer) coverage.server = coverageServer;
-  if (coverage.browser !== void 0 || coverage.server !== void 0) mergedRaw.coverage = coverage;
+  if (coverage.css === void 0 && coverageCss) coverage.css = coverageCss;
+  if (coverage.browser !== void 0 || coverage.server !== void 0 || coverage.css !== void 0) {
+    mergedRaw.coverage = coverage;
+  }
   const externalId = { ...mergedRaw.externalId };
   const externalIdPattern = env[PIWI_ENV_KEYS.externalIdPattern];
   const externalIdOnDuplicate = env[PIWI_ENV_KEYS.externalIdOnDuplicate];
@@ -406,9 +411,11 @@ function applyOptionsToEnv(options) {
   if (options.collectPerformanceMetrics === false) {
     env[PIWI_ENV_KEYS.coverageBrowser] = "off";
     env[PIWI_ENV_KEYS.coverageServer] = "off";
+    env[PIWI_ENV_KEYS.coverageCss] = "off";
   } else {
     if (options.coverage?.browser !== void 0) env[PIWI_ENV_KEYS.coverageBrowser] = options.coverage.browser;
     if (options.coverage?.server !== void 0) env[PIWI_ENV_KEYS.coverageServer] = options.coverage.server;
+    if (options.coverage?.css !== void 0) env[PIWI_ENV_KEYS.coverageCss] = options.coverage.css;
   }
   if (options.captureServerTraces === false || options.collectPerformanceMetrics === false)
     env[PIWI_ENV_KEYS.captureServerTraces] = "false";
@@ -1063,14 +1070,14 @@ var os3 = __toESM(require("os"));
 var fs4 = __toESM(require("fs"));
 
 // src/internal/support/instance-id.ts
-var crypto = __toESM(require("crypto"));
+var crypto2 = __toESM(require("crypto"));
 var os2 = __toESM(require("os"));
 function hashForProject(projectName) {
-  return crypto.createHash("sha1").update(projectName).digest("hex").slice(0, 16);
+  return crypto2.createHash("sha1").update(projectName).digest("hex").slice(0, 16);
 }
 function computeInstanceId(projectName, runLabel) {
   const seed = runLabel ? `${projectName}|${runLabel}` : `${os2.hostname()}|${projectName}`;
-  return crypto.createHash("sha256").update(seed).digest("hex").slice(0, 16);
+  return crypto2.createHash("sha256").update(seed).digest("hex").slice(0, 16);
 }
 
 // src/internal/streaming/stream-buffer.ts
@@ -1132,7 +1139,7 @@ var StreamBuffer = class {
 };
 
 // src/internal/streaming/crash-recovery.ts
-var crypto2 = __toESM(require("crypto"));
+var crypto3 = __toESM(require("crypto"));
 var fs5 = __toESM(require("fs"));
 var os4 = __toESM(require("os"));
 var path5 = __toESM(require("path"));
@@ -1148,7 +1155,7 @@ function recoveryServer(serverUrl) {
   return serverUrl.replace(/\/+$/, "");
 }
 function recoveryFilePath(serverUrl, projectName) {
-  const key = crypto2.createHash("sha256").update(`${recoveryServer(serverUrl)}
+  const key = crypto3.createHash("sha256").update(`${recoveryServer(serverUrl)}
 ${projectName}`).digest("hex").slice(0, 16);
   return path5.join(os4.tmpdir(), `piwi-dashboard-recovery-${key}.json`);
 }
@@ -1169,7 +1176,7 @@ var CrashRecovery = class {
   /** Write the payload for a later retry, owner-only, replacing the file in one step. */
   save(payload) {
     const file = { v: 1, serverUrl: this.serverUrl, payload };
-    const temp = `${this.filePath}.${process.pid}.${crypto2.randomBytes(6).toString("hex")}.tmp`;
+    const temp = `${this.filePath}.${process.pid}.${crypto3.randomBytes(6).toString("hex")}.tmp`;
     try {
       fs5.writeFileSync(temp, JSON.stringify(file), { encoding: "utf8", flag: "wx", mode: 384 });
       fs5.renameSync(temp, this.filePath);
@@ -1240,7 +1247,7 @@ var CrashRecovery = class {
 var fs7 = __toESM(require("fs"));
 var os5 = __toESM(require("os"));
 var path7 = __toESM(require("path"));
-var crypto3 = __toESM(require("crypto"));
+var crypto4 = __toESM(require("crypto"));
 
 // src/internal/files/compression.ts
 var fs6 = __toESM(require("fs"));
@@ -1312,6 +1319,8 @@ var ATTACHMENT_NAMES = {
   codeReach: "piwi-code-reach",
   browserCoverage: "piwi-browser-coverage",
   browserFunctions: "piwi-browser-functions",
+  cssCoverage: "piwi-css-coverage",
+  cssRules: "piwi-css-rules",
   serverCoverageRequests: "piwi-server-coverage-requests",
   webVitals: "piwi-web-vitals",
   locatorSuggestion: "piwi-locator-suggestion",
@@ -1323,6 +1332,19 @@ var ATTACHMENT_NAMES = {
   pauses: "piwi-pauses"
 };
 var INTERNAL_ATTACHMENT_NAMES = new Set(Object.values(ATTACHMENT_NAMES));
+var ARIA_SNAPSHOT_CONTENT_TYPE = "text/plain; charset=utf-8";
+function contentTypeOf(name) {
+  return name === ATTACHMENT_NAMES.ariaSnapshot ? ARIA_SNAPSHOT_CONTENT_TYPE : "application/json";
+}
+function isPiwiAttachment(attachment, name) {
+  return attachment.name === name && attachment.contentType === contentTypeOf(name);
+}
+function findPiwiAttachment(attachments, name) {
+  for (let i = (attachments?.length ?? 0) - 1; i >= 0; i--) {
+    if (isPiwiAttachment(attachments[i], name)) return attachments[i];
+  }
+  return void 0;
+}
 var LOCATOR_SUGGESTION_ANNOTATION = ATTACHMENT_NAMES.locatorSuggestion;
 var USER_PICK_ANNOTATION = ATTACHMENT_NAMES.userPick;
 
@@ -1441,18 +1463,18 @@ var FileHandler = class {
     }
     const contentType = a.contentType || "application/octet-stream";
     const originalName = `${safeFileName(a.name || "attachment")}${BODY_EXTENSIONS[contentType] ?? ""}`;
-    let filePath2 = this.bodyFiles.get(a);
-    if (!filePath2) {
+    let filePath3 = this.bodyFiles.get(a);
+    if (!filePath3) {
       try {
-        filePath2 = path7.join(this.bodyAttachmentDir(), `${++this.bodyFileCount}-${originalName}`);
-        fs7.writeFileSync(filePath2, body);
-        this.bodyFiles.set(a, filePath2);
+        filePath3 = path7.join(this.bodyAttachmentDir(), `${++this.bodyFileCount}-${originalName}`);
+        fs7.writeFileSync(filePath3, body);
+        this.bodyFiles.set(a, filePath3);
       } catch (error) {
         this.logger.warn(`Could not stage attachment "${a.name}" for upload: ${errorMessage(error)}`);
         return null;
       }
     }
-    return { name: a.name || "attachment", path: filePath2, contentType, originalName };
+    return { name: a.name || "attachment", path: filePath3, contentType, originalName };
   }
   bodyAttachmentDir() {
     if (!this.bodyDir) this.bodyDir = fs7.mkdtempSync(path7.join(os5.tmpdir(), "piwi-dashboard-attachments-"));
@@ -1477,11 +1499,11 @@ var FileHandler = class {
   }
   /** Parse Piwi-internal attachment bodies (`piwi-network`, `piwi-web-vitals`, `piwi-console`, `piwi-aria-snapshot`, `piwi-aria-snapshot-json`) into structured fields on the test case */
   parsePerformanceAttachments(testCase, attachments) {
-    const find = (name) => attachments.find((a) => a.name === name);
-    const net2 = find(ATTACHMENT_NAMES.network);
-    if (net2?.body) {
+    const find = (name) => findPiwiAttachment(attachments, name);
+    const net5 = find(ATTACHMENT_NAMES.network);
+    if (net5?.body) {
       try {
-        testCase.networkRequests = JSON.parse(net2.body.toString());
+        testCase.networkRequests = JSON.parse(net5.body.toString());
       } catch {
       }
     }
@@ -1540,7 +1562,7 @@ var FileHandler = class {
       if (fs7.existsSync(tp)) lastPath = tp;
     }
     if (!lastPath) return null;
-    const hash = crypto3.createHash("sha256");
+    const hash = crypto4.createHash("sha256");
     await new Promise((resolve11, reject) => {
       fs7.createReadStream(lastPath).on("data", (chunk) => hash.update(chunk)).on("end", resolve11).on("error", reject);
     });
@@ -2119,6 +2141,8 @@ var StreamManager = class {
     this._token = null;
     this._auth = null;
     this._startPromise = null;
+    /** Called when the dashboard says someone opened the run. */
+    this.onWatched = null;
     const maxBytes = this.options.maxStreamBufferBytes ?? 0;
     this.pendingEvents = new BoundedEventQueue(maxBytes);
     this.pendingBeginEvents = new BoundedEventQueue(maxBytes);
@@ -2143,6 +2167,10 @@ var StreamManager = class {
   get startPromise() {
     return this._startPromise;
   }
+  /** Whether anyone has the run open live, as the dashboard last said; `null` until it says. */
+  get isWatched() {
+    return this.watched;
+  }
   /**
    * Whether a test-result (`complete`) event never reached the server through
    * the live stream: shed under buffer pressure, too large for any request the
@@ -2393,8 +2421,11 @@ var StreamManager = class {
       if (this.pendingEvents.length > 0) this.flush();
     }, delay);
   }
-  // Take the dashboard's answer on whether anyone watches the run. An answer
-  // without the flag (an older dashboard) keeps step events flowing.
+  /**
+   * Take the dashboard's answer on whether anyone watches the run, from any
+   * request of the stream. An answer without the flag (an older dashboard)
+   * keeps step events flowing.
+   */
   noteWatched(response) {
     const watched = response?.watched;
     const next = typeof watched === "boolean" ? watched : null;
@@ -2403,7 +2434,9 @@ var StreamManager = class {
         next ? "The run is open on the dashboard: streaming live steps." : "Nobody is watching the run: live steps are not sent."
       );
     }
+    const opened = next === true && this.watched !== true;
     this.watched = next;
+    if (opened) this.onWatched?.();
   }
   // Idle time after which a heartbeat goes out.
   heartbeatDelay() {
@@ -3367,6 +3400,258 @@ function maskUrlFragment(hash) {
   const out = maskTokenLike(route) + (masked === null ? "" : query >= 0 ? `?${masked}` : masked);
   return hash.startsWith("#") ? `#${out}` : out;
 }
+var HIDDEN_VALUE = "<hidden>";
+var SECRET_AUTOCOMPLETE = [
+  "current-password",
+  "new-password",
+  "one-time-code",
+  "cc-number",
+  "cc-csc"
+];
+var SECRET_WORDS = /* @__PURE__ */ new Set([
+  "pass",
+  "password",
+  "passwd",
+  "passphrase",
+  "passcode",
+  "pwd",
+  "secret",
+  "secrets",
+  "token",
+  "tokens",
+  "jwt",
+  "bearer",
+  "sig",
+  "signature",
+  "key",
+  "keys",
+  "apikey",
+  "auth",
+  "oauth",
+  "authorization",
+  "session",
+  "sessionid",
+  "jsessionid",
+  "sid",
+  "cookie",
+  "cookies",
+  "credential",
+  "credentials",
+  "otp",
+  "refresh",
+  "csrf",
+  "xsrf"
+]);
+var SECRET_NAMES = /* @__PURE__ */ new Set(["code", "pin"]);
+function nameWords(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+}
+function isSecretName(name) {
+  let secret = namesRead.get(name);
+  if (secret === void 0) {
+    secret = SECRET_NAMES.has(name.trim().toLowerCase()) || nameWords(name).some((word) => SECRET_WORDS.has(word));
+    if (namesRead.size >= 1024) namesRead.clear();
+    namesRead.set(name, secret);
+  }
+  return secret;
+}
+var namesRead = /* @__PURE__ */ new Map();
+var SECRET_SHAPES = [
+  /\beyJ[\w-]{5,}\.[\w-]{5,}\.[\w-]*/g,
+  /\bBearer(?:\s+|%20)[\w.~+/-]{8,}=*/gi,
+  /\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{8,}/g,
+  /\bwhsec_[A-Za-z0-9]{20,}/g,
+  /\bsk-(?=[\w-]{0,200}\d)(?=[\w-]{0,200}[A-Z])[\w-]{32,}/g,
+  /\bglpat-[\w-]{20,}/g,
+  /\bnpm_[A-Za-z0-9]{36}\b/g,
+  /\bSK[0-9a-f]{32}\b/g,
+  /\bAKIA[0-9A-Z]{16}\b/g,
+  /\bAIza[\w-]{30,}/g,
+  /\bgh[opsu]_[A-Za-z0-9]{20,}/g,
+  /\bgithub_pat_\w{20,}/g,
+  /\bxox[abprs]-[\w-]{8,}/g
+];
+var WHOLE_SHAPES = SECRET_SHAPES.map(
+  (re) => new RegExp(`^(?:${re.source})$`, re.flags.replace("g", ""))
+);
+var BASIC = /\bBasic\s+([A-Za-z0-9+/]{4,}={0,2})(?![\w+/=])/g;
+var PEM_BEGIN = /-----BEGIN ([A-Z0-9 ]{0,40}PRIVATE KEY)-----/g;
+var SET_COOKIE = /(\bSet-Cookie:[ \t]*[^=;\s]{1,256}=)([^;\r\n]{1,4096})/gi;
+var COOKIE_LINE = /((?<![\w-])Cookie:[ \t]*)([^\r\n]{1,16384})/gi;
+var JSON_FIELD = /("((?:[^"\\\r\n]|\\.){1,256})"\s*:\s*")((?:[^"\\\r\n]|\\.){1,4096})"/g;
+var TOKEN_RUN = /[A-Za-z0-9+/_-]{40,}={0,2}/g;
+var MIN_RANDOM = 40;
+var BASE64_DIGITS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function base64OfText(run) {
+  let bits = 0;
+  let acc = 0;
+  let bytes = 0;
+  let printable = 0;
+  for (const c of run.replace(/=+$/, "")) {
+    const digit = BASE64_DIGITS.indexOf(c === "-" ? "+" : c === "_" ? "/" : c);
+    if (digit < 0) return false;
+    acc = (acc << 6 | digit) & 65535;
+    bits += 6;
+    if (bits < 8) continue;
+    bits -= 8;
+    const byte = acc >> bits & 255;
+    bytes++;
+    if (byte >= 32 && byte < 127 || byte === 9 || byte === 10 || byte === 13) printable++;
+  }
+  return bytes > 0 && printable * 10 >= bytes * 9;
+}
+function bitsPerChar(text) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const c of text) counts.set(c, (counts.get(c) ?? 0) + 1);
+  let bits = 0;
+  for (const n of counts.values()) bits -= n / text.length * Math.log2(n / text.length);
+  return bits;
+}
+function looksRandom(text) {
+  if (text.length < MIN_RANDOM || !/[A-Z]/.test(text) || !/[a-z]/.test(text) || !/\d/.test(text)) return false;
+  let letters = 0;
+  for (const c of text) if (c >= "a" && c <= "z" || c >= "A" && c <= "Z") letters++;
+  let wordy = 0;
+  for (const run of text.matchAll(/[a-z]{6,}|[A-Z]{6,}/g)) wordy += run[0].length;
+  return wordy * 5 <= letters && bitsPerChar(text) >= 4 && !base64OfText(text);
+}
+function isBasicCredential(encoded) {
+  const text = encoded.replace(/=+$/, "");
+  if (text.length % 4 === 1) return false;
+  let decoded = "";
+  let bits = 0;
+  let acc = 0;
+  for (const c of text) {
+    const digit = BASE64_DIGITS.indexOf(c);
+    if (digit < 0) return false;
+    acc = (acc << 6 | digit) & 65535;
+    bits += 6;
+    if (bits < 8) continue;
+    bits -= 8;
+    decoded += String.fromCharCode(acc >> bits & 255);
+  }
+  return /^[\x20-\x7e]+:[\x20-\x7e]*$/.test(decoded);
+}
+function isSecretValue(value) {
+  const text = value.trim();
+  if (text.length < 10 || text.length > 4096) return false;
+  if (WHOLE_SHAPES.some((re) => re.test(text))) return true;
+  const basic = /^Basic\s+([A-Za-z0-9+/]{4,}={0,2})$/.exec(text);
+  if (basic && isBasicCredential(basic[1])) return true;
+  if (/^-----BEGIN [A-Z0-9 ]{0,40}PRIVATE KEY-----/.test(text)) return true;
+  return /^[A-Za-z0-9+/_-]{40,}={0,2}$/.test(text) && looksRandom(text);
+}
+var URL_IN_TEXT = /\b[a-z][a-z0-9+.-]{0,31}:\/\/[^\s"'<>`]+/gi;
+var URL_PARTS = /^(?:([a-z][a-z0-9+.-]*:)?\/\/([^/?#]*))?([^?#]*)(\?[^#]*)?(#[\s\S]*)?$/i;
+function decodeSafe(text) {
+  try {
+    return decodeURIComponent(text);
+  } catch {
+    return text;
+  }
+}
+function hider(count) {
+  return () => {
+    count.n++;
+    return HIDDEN_VALUE;
+  };
+}
+function hideParams(params, count) {
+  const hide = hider(count);
+  return params.split(/([&;])/).map((part, i) => {
+    const eq = part.indexOf("=");
+    if (i % 2 === 1 || eq < 0) return part;
+    const name = part.slice(0, eq);
+    const value = part.slice(eq + 1);
+    const decoded = decodeSafe(value);
+    if (!value || decoded === HIDDEN_VALUE) return part;
+    return isSecretName(decodeSafe(name)) || isSecretValue(decoded) ? `${name}=${hide()}` : part;
+  }).join("");
+}
+function hidePath(path34, count) {
+  const hide = hider(count);
+  return path34.split("/").map((segment) => {
+    const [own = "", ...params] = segment.split(";");
+    const decoded = decodeSafe(own);
+    const kept = decoded !== HIDDEN_VALUE && isSecretValue(decoded) ? hide() : own;
+    return params.length ? `${kept};${hideParams(params.join(";"), count)}` : kept;
+  }).join("/");
+}
+function hideSecretsInUrl(url, count = { n: 0 }) {
+  const parts = URL_PARTS.exec(url);
+  if (!parts) return url;
+  const [, scheme = "", authority, path34 = "", query = "", fragment = ""] = parts;
+  let out = "";
+  if (authority !== void 0) {
+    const at = authority.lastIndexOf("@");
+    const colon = at >= 0 ? authority.slice(0, at).indexOf(":") : -1;
+    out += colon >= 0 && colon < at - 1 ? `${scheme}//${authority.slice(0, colon + 1)}${hider(count)()}${authority.slice(at)}` : `${scheme}//${authority}`;
+  }
+  out += hidePath(path34, count);
+  if (query) out += `?${hideParams(query.slice(1), count)}`;
+  if (fragment) {
+    const body = fragment.slice(1);
+    const ask = body.indexOf("?");
+    out += `#${ask >= 0 ? `${hidePath(body.slice(0, ask), count)}?${hideParams(body.slice(ask + 1), count)}` : body.includes("=") ? hideParams(body, count) : hidePath(body, count)}`;
+  }
+  return out;
+}
+var QUERY_PAIR = /([?&;#])([^=&#?;\s"'<>]{1,256})=([^&;#\s"'<>]*)/g;
+var URL_PASSWORD = /(\/\/[^/:@\s"'<>]{1,256}:)([^@/\s"'<>]{1,256})(@)/g;
+function hidePem(text, hide) {
+  let out = "";
+  let last = 0;
+  let nextEnd = -2;
+  PEM_BEGIN.lastIndex = 0;
+  for (let begin = PEM_BEGIN.exec(text); begin; begin = PEM_BEGIN.exec(text)) {
+    if (begin.index < last) continue;
+    if (nextEnd !== -1 && nextEnd < begin.index) nextEnd = text.indexOf("-----END ", begin.index);
+    const footer = nextEnd >= 0 ? /^-----END [A-Z0-9 ]{0,40}-----/.exec(text.slice(nextEnd, nextEnd + 60)) : null;
+    const until = footer ? nextEnd + footer[0].length : begin.index + begin[0].length + (/^(?:\s*[A-Za-z0-9+/=]+)*/.exec(text.slice(begin.index + begin[0].length))?.[0].length ?? 0);
+    out += `${text.slice(last, begin.index)}${hide()}`;
+    last = until;
+    PEM_BEGIN.lastIndex = until;
+  }
+  return out + text.slice(last);
+}
+function hideInText(text, count) {
+  if (text.length < 4 || !/[A-Za-z0-9]/.test(text)) return text;
+  const hide = hider(count);
+  let out = hidePem(text, hide);
+  out = out.replace(QUERY_PAIR, (all, sep13, name, value) => {
+    const decoded = decodeSafe(value);
+    if (!value || decoded === HIDDEN_VALUE) return all;
+    return isSecretName(name) || isSecretValue(decoded) ? `${sep13}${name}=${hide()}` : all;
+  });
+  out = out.replace(URL_PASSWORD, (_all, before, _password, at) => `${before}${hide()}${at}`);
+  out = out.replace(SET_COOKIE, (_all, before) => `${before}${hide()}`);
+  out = out.replace(COOKIE_LINE, (_all, before, pairs) => {
+    const values = pairs.replace(
+      /([^=;\s]{1,256}=)([^;]*)/g,
+      (pair, name, value) => value.trim() && value.trim() !== HIDDEN_VALUE ? `${name}${hide()}` : pair
+    );
+    return `${before}${values}`;
+  });
+  out = out.replace(
+    JSON_FIELD,
+    (all, before, name, value) => isSecretName(name) && value !== HIDDEN_VALUE ? `${before}${hide()}"` : all
+  );
+  out = out.replace(BASIC, (all, encoded) => isBasicCredential(encoded) ? hide() : all);
+  for (const shape of SECRET_SHAPES) out = out.replace(shape, () => hide());
+  return out.replace(
+    TOKEN_RUN,
+    (run) => run.includes("/") && !/[+=]/.test(run) ? run.split("/").map((part) => looksRandom(part) ? hide() : part).join("/") : looksRandom(run) ? hide() : run
+  );
+}
+function hideSecretsInText(text, count = { n: 0 }) {
+  let out = "";
+  let last = 0;
+  for (const url of text.matchAll(URL_IN_TEXT)) {
+    out += hideInText(text.slice(last, url.index), count) + hideSecretsInUrl(url[0], count);
+    last = url.index + url[0].length;
+  }
+  return out + hideInText(text.slice(last), count);
+}
 
 // ../core/src/locator-break.ts
 var filePath = (path34) => path34.replace(/\\/g, "/").replace(/^\.\//, "");
@@ -3903,7 +4188,7 @@ function collectSourceFrames(errorText, testFile2, declLine, opts = {}) {
   const maxFrames = opts.maxFrames ?? 4;
   const picked = [];
   const seen = /* @__PURE__ */ new Set();
-  const add = (absFile, line) => {
+  const add2 = (absFile, line) => {
     const key = `${absFile}:${line}`;
     if (seen.has(key)) return;
     seen.add(key);
@@ -3920,12 +4205,12 @@ function collectSourceFrames(errorText, testFile2, declLine, opts = {}) {
       }
       const rel = path11.relative(projectRoot, abs);
       if (rel.startsWith("..") || path11.isAbsolute(rel)) continue;
-      if (!isNaN(frame.line)) add(abs, frame.line);
+      if (!isNaN(frame.line)) add2(abs, frame.line);
     }
   }
   const absTest = path11.resolve(testFile2);
   if (!picked.some((p) => p.absFile === absTest)) {
-    add(absTest, extractFailingLine(errorText, testFile2, declLine));
+    add2(absTest, extractFailingLine(errorText, testFile2, declLine));
   }
   const frames = [];
   for (const p of picked.slice(0, maxFrames)) {
@@ -4040,8 +4325,8 @@ var fs15 = __toESM(require("fs"));
 var path12 = __toESM(require("path"));
 var os7 = __toESM(require("os"));
 var fs12 = __toESM(require("fs"));
-function ariaSampleIdentity(filePath2, title) {
-  return `${filePath2}\0${title}`;
+function ariaSampleIdentity(filePath3, title) {
+  return `${filePath3}\0${title}`;
 }
 function getAriaSampleFilePath(projectName) {
   return path12.join(os7.tmpdir(), `piwi-dashboard-aria-sample-${hashForProject(projectName)}.json`);
@@ -4085,6 +4370,7 @@ function isDueForAriaSample(testInfo) {
 }
 
 // src/internal/support/base-url-check.ts
+var net = __toESM(require("net"));
 var BASE_URL_CHECK_ATTEMPTS = 3;
 var BASE_URL_CHECK_TIMEOUT_MS = 1e4;
 var BASE_URL_CHECK_DELAY_MS = 2e3;
@@ -4106,9 +4392,9 @@ function cliProjectNames(argv = process.argv) {
   }
   return names;
 }
-function wildcard(pattern) {
+function wildcard(pattern, flags = "i") {
   const escaped = pattern.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
-  return new RegExp(`^${escaped.join(".*")}$`, "i");
+  return new RegExp(`^${escaped.join(".*")}$`, flags);
 }
 function selectedProjects(projects, argv = process.argv, filtered) {
   let chosen;
@@ -4118,7 +4404,7 @@ function selectedProjects(projects, argv = process.argv, filtered) {
   } else {
     const names = cliProjectNames(argv);
     if (!names || names.length === 0) return projects;
-    const patterns = names.map(wildcard);
+    const patterns = names.map((name) => wildcard(name));
     chosen = new Set(projects.filter((p) => patterns.some((re) => re.test(p.name ?? ""))));
   }
   if (!argv.includes("--no-deps")) {
@@ -4140,23 +4426,58 @@ function asProxy(value) {
   const proxy = value;
   return proxy && typeof proxy === "object" && typeof proxy.server === "string" ? proxy : void 0;
 }
-function baseUrlTargets(config, argv = process.argv) {
+function exposeNetworkCovers(rule, url) {
+  if (!rule) return false;
+  let parsed2;
+  try {
+    parsed2 = new URL(url);
+  } catch {
+    return false;
+  }
+  const host = parsed2.hostname;
+  const port = parsed2.port ? Number(parsed2.port) : parsed2.protocol === "https:" ? 443 : 80;
+  return rule.split(",").some((token) => {
+    const match = token.match(/^(.*?)(?::(\d+))?$/);
+    if (!match) return false;
+    if (match[2] !== void 0 && Number(match[2]) !== port) return false;
+    const tokenHost = match[1];
+    if (tokenHost === "<loopback>") {
+      return host === "localhost" || host.endsWith(".localhost") || host === "127.0.0.1" || host === "[::1]";
+    }
+    if (tokenHost === "*") return true;
+    if (net.isIP(tokenHost)) return host === tokenHost;
+    if (net.isIP(host)) return false;
+    return wildcard(tokenHost.startsWith(".") ? `*${tokenHost}` : tokenHost, "").test(host);
+  });
+}
+function reachedRemotely(use, url, env) {
+  if (use?.connectOptions === void 0) {
+    return !!env.PW_TEST_CONNECT_WS_ENDPOINT && !exposeNetworkCovers(env.PW_TEST_CONNECT_EXPOSE_NETWORK, url);
+  }
+  const connect3 = use.connectOptions;
+  if (!connect3 || typeof connect3 !== "object" || typeof connect3.wsEndpoint !== "string") return false;
+  return !exposeNetworkCovers(typeof connect3.exposeNetwork === "string" ? connect3.exposeNetwork : void 0, url);
+}
+function baseUrlTargets(config, argv = process.argv, env = process.env) {
   const projects = config.projects?.length ? config.projects : [{ name: "", use: config.use }];
   const filtered = config.projects?.length ? config.filteredProjects : void 0;
   const targets = /* @__PURE__ */ new Map();
   for (const project of selectedProjects(projects, argv, filtered)) {
     const url = project.use?.baseURL;
     if (typeof url !== "string" || !/^https?:\/\//i.test(url)) continue;
+    const remoteBrowser = reachedRemotely(project.use, url, env);
     const target = targets.get(url);
     if (target) {
       if (project.name) target.projects.push(project.name);
+      target.remoteBrowser ||= remoteBrowser;
       continue;
     }
     targets.set(url, {
       url,
       projects: project.name ? [project.name] : [],
       ignoreHTTPSErrors: project.use?.ignoreHTTPSErrors === true,
-      proxy: asProxy(project.use?.proxy)
+      proxy: asProxy(project.use?.proxy),
+      remoteBrowser
     });
   }
   return [...targets.values()];
@@ -4197,14 +4518,21 @@ async function checkBaseUrl(target, options = {}) {
   }
   return `${reason} (${attempts} ${attempts === 1 ? "attempt" : "attempts"})`;
 }
+function remoteBrowserNote(target) {
+  if (!target.remoteBrowser) return null;
+  const { host } = new URL(target.url);
+  return `The check ran from this machine's network, but a project's remote browser reaches ${host} from its own, since its exposeNetwork rule does not cover that address.`;
+}
 async function checkBaseUrls(config, options = {}) {
-  const targets = baseUrlTargets(config, options.argv);
+  const targets = baseUrlTargets(config, options.argv, options.env);
   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 note = remoteBrowserNote(target);
+    return `  ${target.url}${used}: ${reason}${note ? `
+    ${note}` : ""}`;
   });
   const message = [
     `[Piwi Dashboard] The app under test did not answer, so no test ran:`,
@@ -4545,7 +4873,7 @@ function reduceCoverage(capture, granularity) {
 }
 
 // src/internal/collect/source-checksums.ts
-var crypto4 = __toESM(require("crypto"));
+var crypto5 = __toESM(require("crypto"));
 var fs14 = __toESM(require("fs"));
 var path14 = __toESM(require("path"));
 var CHECKSUM = /^(sha1|sha256):[0-9a-f]{40,64}$/;
@@ -4563,7 +4891,7 @@ function contentChecksums(content) {
   const out = /* @__PURE__ */ new Set();
   for (const form of lineEndingForms(content)) {
     for (const algorithm of ["sha1", "sha256"]) {
-      out.add(`${algorithm}:${crypto4.createHash(algorithm).update(form).digest("hex")}`);
+      out.add(`${algorithm}:${crypto5.createHash(algorithm).update(form).digest("hex")}`);
     }
   }
   return out;
@@ -4675,10 +5003,10 @@ function fileChecksums(files, into = /* @__PURE__ */ new Map()) {
   if (!Array.isArray(files)) return into;
   for (const item of files) {
     if (!isRecord2(item)) continue;
-    const filePath2 = normalizeCoveragePath(item.path);
+    const filePath3 = normalizeCoveragePath(item.path);
     const checksums = checksumsOf(item.checksums);
-    if (filePath2 === null || checksums.length === 0) continue;
-    into.set(filePath2, [.../* @__PURE__ */ new Set([...into.get(filePath2) ?? [], ...checksums])]);
+    if (filePath3 === null || checksums.length === 0) continue;
+    into.set(filePath3, [.../* @__PURE__ */ new Set([...into.get(filePath3) ?? [], ...checksums])]);
   }
   return into;
 }
@@ -4687,9 +5015,9 @@ function runFilesOf(answer) {
   const files = [];
   for (const item of answer.files) {
     if (!isRecord2(item) || item.runtime !== "server" && item.runtime !== "browser") continue;
-    const filePath2 = normalizeCoveragePath(item.path);
-    if (filePath2 === null) continue;
-    const file = { path: filePath2, runtime: item.runtime };
+    const filePath3 = normalizeCoveragePath(item.path);
+    if (filePath3 === null) continue;
+    const file = { path: filePath3, runtime: item.runtime };
     const functions = normalizeFunctionRanges(item.functions);
     const lines = normalizeLineRanges(item.lines);
     const executable = normalizeLineRanges(item.executable);
@@ -4709,7 +5037,7 @@ function instanceOf(answer) {
   return { id: instance.id, startedAt };
 }
 function processKeyOf(id) {
-  const dot = id.lastIndexOf(".");
+  const dot = id.indexOf(".");
   return dot > 0 ? id.slice(0, dot) : null;
 }
 function withTestCoverage(files, tests) {
@@ -5127,7 +5455,16 @@ function createGlobalSetup(options, userSetup) {
     }
     if (opts.checkBaseUrl === true) {
       const checked = await checkBaseUrls(config ?? {});
-      for (const target of checked) logger.debug(`Base URL answered: ${target.url}`);
+      for (const target of checked) {
+        const note = remoteBrowserNote(target);
+        if (note) {
+          logger.info(
+            `Base URL answered: ${target.url}. ${note} A navigation failure from that browser can mean its machine cannot reach the app, not that the app is down.`
+          );
+        } else {
+          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.");
@@ -5303,9 +5640,9 @@ function loadPlan() {
 function probeItemForTest(test) {
   const plan = loadPlan();
   if (!plan) return null;
-  const filePath2 = test.file ? relativeTestPath(test.file, test.base ?? process.cwd()) : null;
+  const filePath3 = test.file ? relativeTestPath(test.file, test.base ?? process.cwd()) : null;
   const suitePath = test.titlePath ? test.titlePath.slice(1, -1) : void 0;
-  return matchProbeItem(plan, { title: test.title, filePath: filePath2, suitePath });
+  return matchProbeItem(plan, { title: test.title, filePath: filePath3, suitePath });
 }
 function classifyProbeHandled(signals) {
   const blank = signals.blankPage === true;
@@ -6300,9 +6637,9 @@ function duplicateTestKey(test) {
 }
 function readDuplicateTest(raw) {
   if (!raw || typeof raw !== "object") return null;
-  const { filePath: filePath2, suitePath, title, line } = raw;
-  if (typeof filePath2 !== "string" || typeof title !== "string") return null;
-  const test = { filePath: filePath2, title };
+  const { filePath: filePath3, suitePath, title, line } = raw;
+  if (typeof filePath3 !== "string" || typeof title !== "string") return null;
+  const test = { filePath: filePath3, title };
   if (Array.isArray(suitePath) && suitePath.every((s) => typeof s === "string") && suitePath.length > 0)
     test.suitePath = suitePath;
   if (typeof line === "number" && Number.isFinite(line)) test.line = line;
@@ -6859,7 +7196,9 @@ var RunSubmitter = class {
 };
 
 // src/internal/capture/resource-ledger.ts
+var childProcess = __toESM(require("child_process"));
 var fs21 = __toESM(require("fs"));
+var net2 = __toESM(require("net"));
 var path20 = __toESM(require("path"));
 var import_node_module2 = require("module");
 
@@ -7237,6 +7576,8 @@ var WorkerMetrics = class {
   constructor(proc = new ProcFs(), pid = process.pid, platform = process.platform) {
     this.proc = proc;
     this.pid = pid;
+    /** The lowest heap read right after a full garbage collection in the current window. */
+    this.heapAfterGc = null;
     this.loop = null;
     this.usage = null;
     /** Each process's CPU and wait at the start of the current window; null before the first. */
@@ -7251,6 +7592,28 @@ var WorkerMetrics = class {
       histogram = null;
     }
     this.histogram = histogram;
+    this.gcObserver = this.observeFullCollections();
+  }
+  /**
+   * Read the heap after each full (major) garbage collection V8 runs on its
+   * own: nothing is forced, so a test that triggers none reads null.
+   */
+  observeFullCollections() {
+    try {
+      const observer = new import_node_perf_hooks.PerformanceObserver((list) => {
+        for (const entry of list.getEntries()) {
+          const detail = entry.detail;
+          const kind = detail?.kind ?? entry.kind;
+          if (kind !== import_node_perf_hooks.constants.NODE_PERFORMANCE_GC_MAJOR) continue;
+          const heap = process.memoryUsage().heapUsed;
+          this.heapAfterGc = Math.min(this.heapAfterGc ?? Infinity, heap);
+        }
+      });
+      observer.observe({ entryTypes: ["gc"] });
+      return observer;
+    } catch {
+      return null;
+    }
   }
   /** The worker's processes under it, keyed by pid and start time. */
   tree() {
@@ -7284,6 +7647,7 @@ var WorkerMetrics = class {
   start(processes = true) {
     try {
       this.histogram?.reset();
+      this.heapAfterGc = null;
       this.loop = import_node_perf_hooks.performance.eventLoopUtilization();
       this.usage = process.resourceUsage();
       if (this.linux && processes && !this.subtree) this.snapshot();
@@ -7306,6 +7670,7 @@ var WorkerMetrics = class {
           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),
+          heapAfterGcMb: this.heapAfterGc === null ? null : round1(this.heapAfterGc / MB),
           fds: this.linux ? this.proc.fdCount(this.pid) : null
         }
       };
@@ -7340,6 +7705,7 @@ var WorkerMetrics = class {
   }
   dispose() {
     this.histogram?.disable();
+    this.gcObserver?.disconnect();
   }
 };
 var PageReader = class {
@@ -7361,12 +7727,36 @@ var PageReader = class {
     try {
       const result = await internalCall(page, () => opened.send("Performance.getMetrics"));
       const values = new Map((result.metrics ?? []).map((metric) => [metric.name, metric.value]));
-      return {
+      const main = {
         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
       };
+      const elements = await this.countElements(page, opened);
+      if (elements !== null) main.elements = elements;
+      return main;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * The elements attached to the page's main document, through the page's own
+   * DevTools session: no Playwright call, so no step and no trace action. The
+   * count runs in the page's main world and changes nothing in it.
+   */
+  async countElements(page, session) {
+    try {
+      const result = await internalCall(
+        page,
+        () => session.send("Runtime.evaluate", {
+          expression: "document.getElementsByTagName('*').length",
+          returnByValue: true,
+          silent: true
+        })
+      );
+      const value = result.result?.value;
+      return typeof value === "number" && Number.isFinite(value) ? value : null;
     } catch {
       return null;
     }
@@ -7375,6 +7765,9 @@ var PageReader = class {
 
 // src/internal/capture/resource-ledger.ts
 var TRACKED_HANDLE_TYPES = ["TCPServerWrap", "FSEventWrap", "StatWatcher"];
+var COUNTED_WITH_RUNNING = ["FSEventWrap", "StatWatcher"];
+var PLAYWRIGHT_ROLES = /* @__PURE__ */ new Set(["worker", "runner", "browser", "renderer", "gpu", "utility", "ffmpeg"]);
+var HANDLE_STACK_LIMIT = 40;
 var USE_METHODS = ["evaluate", "evaluateHandle", "$eval", "$$eval", "waitForFunction", "addScriptTag", "addStyleTag"];
 var CLOSE_TIMEOUT_MS = 5e3;
 var PAGE_READ_CAP = 50;
@@ -7450,20 +7843,41 @@ function playwrightTestInfoSource() {
 function readLeakCheck(value = process.env[PIWI_ENV_KEYS.leakCheck]) {
   return value === "fail" || value === "close" ? value : "report";
 }
-function countHandles() {
+function countHandles(types = TRACKED_HANDLE_TYPES) {
   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;
+    if (types.includes(type)) counts[type] = (counts[type] ?? 0) + 1;
   }
   return counts;
 }
-async function settledHandles(start) {
-  const end = countHandles();
+async function settledHandles(start, types = TRACKED_HANDLE_TYPES) {
+  const end = countHandles(types);
   if (!Object.entries(end).some(([type, n]) => n > (start[type] ?? 0))) return end;
   await new Promise((resolve11) => setTimeout(resolve11, 0));
-  return countHandles();
+  return countHandles(types);
+}
+function deepUserSite() {
+  const limit = Error.stackTraceLimit;
+  Error.stackTraceLimit = HANDLE_STACK_LIMIT;
+  try {
+    return userSite(new Error().stack);
+  } finally {
+    Error.stackTraceLimit = limit;
+  }
+}
+var SHELLS = /^(?:sh|bash|dash|zsh|cmd|cmd\.exe|powershell|powershell\.exe|pwsh)$/i;
+function commandOf(spawnfile, spawnargs) {
+  const name = (file) => path20.basename(file.replace(/\\/g, "/").replace(/^["']|["']$/g, ""));
+  const program = typeof spawnfile === "string" ? name(spawnfile) : "";
+  const args = Array.isArray(spawnargs) ? spawnargs.map(String) : [];
+  const script = args.findIndex((arg) => arg === "-c" || /^\/c$/i.test(arg));
+  if (SHELLS.test(program) && script >= 0 && args[script + 1]) {
+    const first = args[script + 1].trim().split(/\s+/)[0];
+    if (first) return name(first);
+  }
+  return program || "a child process";
 }
 function settleWithin(promise, ms) {
   let timer;
@@ -7475,7 +7889,7 @@ function settleWithin(promise, 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 = {}) {
+  constructor(playwright, workerIndex, leakCheck = readLeakCheck(), resultsFile = process.env[PIWI_RESOURCES_RESULTS_ENV] || null, testInfoSource = playwrightTestInfoSource(), now = Date.now, readers = {}, nodeHandles = false) {
     this.playwright = playwright;
     this.workerIndex = workerIndex;
     this.leakCheck = leakCheck;
@@ -7483,6 +7897,7 @@ var ResourceLedger = class {
     this.testInfoSource = testInfoSource;
     this.now = now;
     this.readers = readers;
+    this.nodeHandles = nodeHandles;
     this.nextId = 1;
     this.entries = /* @__PURE__ */ new Map();
     this.byObject = /* @__PURE__ */ new WeakMap();
@@ -7499,6 +7914,11 @@ var ResourceLedger = class {
     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;
+    /** The servers and child processes still running, while the ledger tracks them. */
+    this.handles = /* @__PURE__ */ new Set();
+    this.byHandle = /* @__PURE__ */ new WeakMap();
+    this.trackingHandles = false;
+    this.restores = [];
   }
   /** Listen to the worker's Playwright and wrap its browser types. False when the instrumentation is missing. */
   install() {
@@ -7531,13 +7951,107 @@ var ResourceLedger = class {
     for (const type of [this.playwright.chromium, this.playwright.firefox, this.playwright.webkit]) {
       if (type) this.wrapBrowserType(type);
     }
+    if (this.nodeHandles) this.guard(() => this.wrapNodeHandles());
     return true;
   }
-  /** Stop listening; the objects already tracked stay in the ledger. */
+  /** Stop listening, and put Node's `listen` and `spawn` back; 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;
+    for (const restore of this.restores.splice(0)) restore();
+    this.trackingHandles = false;
+  }
+  /**
+   * Wrap `net.Server.prototype.listen` (every HTTP, HTTPS and TCP server) and
+   * `ChildProcess.prototype.spawn` (`spawn`, `exec`, `execFile` and `fork`), so
+   * each server and child process the worker starts carries the line and the
+   * runnable that started it, as a context does. A worker-scoped fixture's
+   * server is then the worker's, never the first test's. Each wrapper calls the
+   * original on its receiver and only records; it never throws.
+   */
+  wrapNodeHandles() {
+    const onServer = (server2, site) => this.guard(() => this.onServer(server2, site));
+    const onChild = (child2, site) => this.guard(() => this.onChild(child2, site));
+    const server = net2.Server.prototype;
+    const listen = server.listen;
+    if (typeof listen === "function") {
+      const wrapped = function(...args) {
+        onServer(this, deepUserSite());
+        return listen.apply(this, args);
+      };
+      server.listen = wrapped;
+      this.restores.push(() => {
+        if (server.listen === wrapped) server.listen = listen;
+      });
+    }
+    const child = childProcess.ChildProcess?.prototype;
+    const spawn = child?.spawn;
+    if (child && typeof spawn === "function") {
+      const wrapped = function(...args) {
+        const site = deepUserSite();
+        const result = spawn.apply(this, args);
+        onChild(this, site);
+        return result;
+      };
+      child.spawn = wrapped;
+      this.restores.push(() => {
+        if (child.spawn === wrapped) child.spawn = spawn;
+      });
+    }
+    this.trackingHandles = true;
+  }
+  trackHandle(object, entry) {
+    const info = this.testInfoSource();
+    const { phase, fixture } = info ? runnableOf(info) : fallbackRunnable(this.window);
+    const tracked = { ...entry, phase, fixture, test: testRef2(info) ?? this.window };
+    this.handles.add(tracked);
+    this.byHandle.set(object, tracked);
+    return tracked;
+  }
+  onServer(server, site) {
+    const known = this.byHandle.get(server);
+    if (known && this.handles.has(known)) return;
+    let bound = false;
+    let closed = false;
+    const entry = this.trackHandle(server, {
+      type: "TCPServerWrap",
+      site,
+      // `close()` unbinds at once, while its 'close' event waits for open connections.
+      running: () => server.listening,
+      pending: () => !bound && !closed && !server.listening
+    });
+    server.once("listening", () => {
+      bound = true;
+    });
+    server.once("close", () => {
+      closed = true;
+      this.handles.delete(entry);
+    });
+  }
+  onChild(child, site) {
+    const command = commandOf(child.spawnfile, child.spawnargs);
+    const role = roleOf(command, (child.spawnargs ?? []).join(" "));
+    if (role && PLAYWRIGHT_ROLES.has(role) || child.pid === void 0) return;
+    const entry = this.trackHandle(child, {
+      type: "ChildProcess",
+      site,
+      command,
+      running: () => child.exitCode === null && child.signalCode === null
+    });
+    child.once("exit", () => this.handles.delete(entry));
+  }
+  /**
+   * The servers and child processes a test started (its body, its each-hooks
+   * or a test-scoped fixture) that still run. A server whose `listen` has not
+   * bound yet is read again one tick later.
+   */
+  async runningOf(testId) {
+    const own = () => [...this.handles].filter(
+      (entry) => entry.test?.id === testId && !entry.fixture?.worker && (entry.phase === "test" || entry.phase === "beforeEach" || entry.phase === "afterEach")
+    );
+    if (own().some((entry) => entry.pending?.())) await new Promise((resolve11) => setTimeout(resolve11, 0));
+    return own().filter((entry) => entry.running()).map((entry) => ({ type: entry.type, site: entry.site, ...entry.command ? { command: entry.command } : {} }));
   }
   /** Mark a page used: a locator was built on it. */
   notePageUse(page) {
@@ -7547,7 +8061,7 @@ var ResourceLedger = class {
   /** Open the census window of a test. */
   testStarted(info) {
     this.window = testRef2(info);
-    this.handlesAtStart = countHandles();
+    this.handlesAtStart = countHandles(this.countedHandleTypes());
     this.openAtStart = { contexts: 0, pages: 0 };
     for (const entry of this.openEntries()) {
       if (entry.birth.kind === "page") this.openAtStart.pages++;
@@ -7567,9 +8081,14 @@ var ResourceLedger = class {
     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 handles = {
+      start: this.handlesAtStart,
+      end: await settledHandles(this.handlesAtStart, this.countedHandleTypes())
+    };
+    const running = this.trackingHandles && test ? await this.runningOf(test.id) : null;
     const census = this.census(ref, handles, await this.readPages());
     if (metrics) census.metrics = metrics;
+    if (running) census.running = running;
     if (test) {
       census.openAtStart = this.openAtStart;
       if (!failed) census.leftOpen = leaks.length;
@@ -7608,6 +8127,10 @@ var ResourceLedger = class {
     this.uninstall();
     return census;
   }
+  /** The handle types counted at each boundary: servers leave the count once they are tracked one by one. */
+  countedHandleTypes() {
+    return this.trackingHandles ? COUNTED_WITH_RUNNING : TRACKED_HANDLE_TYPES;
+  }
   guard(run) {
     try {
       run();
@@ -7830,6 +8353,7 @@ var ResourceLedger = class {
       open
     };
     if (handles) census.handles = handles;
+    for (const close of this.closed) this.entries.delete(close.id);
     this.born = [];
     this.closed = [];
     return census;
@@ -7868,7 +8392,8 @@ function startResourceLedger(playwright, workerIndex) {
     process.env[PIWI_RESOURCES_RESULTS_ENV] || null,
     playwrightTestInfoSource(),
     Date.now,
-    { metrics, pages: new PageReader() }
+    { metrics, pages: new PageReader() },
+    true
   );
   if (!ledger.install()) {
     metrics.dispose();
@@ -8027,7 +8552,15 @@ function buildResourceReport(input) {
         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 (census.test) {
+          entry.series.push({
+            pages: open.pages,
+            listeners: open.listeners,
+            routes: open.routes,
+            elements: open.main?.elements,
+            test: census.test
+          });
+        }
         if (open.main) entry.mainCpu.push({ at: census.at, cpuMs: open.main.cpuMs });
       }
     }
@@ -8042,6 +8575,7 @@ function buildResourceReport(input) {
   }
   findings.push(...groupLeaks(leaked, all));
   findings.push(...pilingFindings(all));
+  findings.push(...workerPilingFindings(byWorker));
   findings.push(...handleFindings(byWorker));
   findings.push(...groupIdle(idle, input.fixturesByTest ?? /* @__PURE__ */ new Map()));
   findings.push(...probableFindings(input.tallies ?? []));
@@ -8179,16 +8713,39 @@ function groupIdle(idle, fixturesByTest) {
   }
   return [...groups.values()].map(({ testIds, ...finding }) => ({ ...finding, tests: testIds.size })).sort((a, b) => b.count - a.count);
 }
+var PILING_RULES = {
+  pages: { min: 2, share: 0, minPoints: 3 },
+  listeners: { min: 2, share: 0, minPoints: 3 },
+  routes: { min: 2, share: 0, minPoints: 3 },
+  elements: { min: 200, share: 0.25, minPoints: 4 },
+  heapMb: { min: 32, share: 0.2, minPoints: 3 },
+  descriptors: { min: 8, share: 0.2, minPoints: 4 }
+};
+function pileUp(values, what) {
+  const rule = PILING_RULES[what];
+  if (values.length < rule.minPoints) return null;
+  const enough = (from, to) => to - from >= Math.max(rule.min, from * rule.share);
+  const first = values[0];
+  const last = values[values.length - 1];
+  if (values.every((value, i) => i === 0 || value >= values[i - 1]) && enough(first, last)) {
+    return { from: first, to: last };
+  }
+  if (values.length < 4) return null;
+  const floor = [...values];
+  for (let i = floor.length - 2; i >= 0; i--) floor[i] = Math.min(floor[i], floor[i + 1]);
+  const start = floor[0];
+  const middle = floor[Math.floor((floor.length - 1) / 2)];
+  const late = floor[Math.floor((floor.length - 1) * 3 / 4)];
+  if (!enough(start, late) || middle - start < (late - start) / 4) return null;
+  return { from: start, to: last };
+}
 function pilingFindings(all) {
   const out = [];
   for (const entry of all) {
-    for (const what of ["pages", "listeners", "routes"]) {
+    for (const what of ["pages", "listeners", "routes", "elements"]) {
       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;
+      const growth = pileUp(values, what);
+      if (!growth) continue;
       out.push({
         verdict: "piling",
         kind: entry.birth.kind,
@@ -8196,34 +8753,91 @@ function pilingFindings(all) {
         site: siteOf(entry.birth),
         tests: values.length,
         count: 1,
-        growth: { what, from, to, tests: values.length }
+        growth: { what, from: Math.round(growth.from), to: Math.round(growth.to), tests: values.length }
       });
     }
   }
   return out.sort((a, b) => b.growth.to - b.growth.from - (a.growth.to - a.growth.from));
 }
+function leftSomethingOpen(census) {
+  if ((census.leftOpen ?? 0) > 0 || (census.running?.length ?? 0) > 0) return true;
+  const handles = census.handles;
+  return !!handles && Object.entries(handles.end).some(([type, n]) => n > (handles.start[type] ?? 0));
+}
+function workerPilingFindings(byWorker) {
+  const best = /* @__PURE__ */ new Map();
+  for (const censuses of byWorker.values()) {
+    const measured = censuses.filter((census) => census.test && !census.test.failed && census.metrics).sort((a, b) => a.at - b.at);
+    const read = [
+      ["heapMb", (census) => census.metrics.worker.heapAfterGcMb],
+      ["descriptors", (census) => census.metrics.worker.fds]
+    ];
+    for (const [what, value] of read) {
+      const points = measured.map((census) => ({ census, value: value(census) })).filter((point) => typeof point.value === "number");
+      const unexplained = [];
+      let top = null;
+      points.forEach((point, i) => {
+        if (i === 0) return void unexplained.push(point.value);
+        const gained = point.value - points[i - 1].value;
+        const counted = leftSomethingOpen(point.census) && gained > 0 ? 0 : gained;
+        unexplained.push(unexplained[i - 1] + counted);
+        if (counted > 0 && (!top || counted > top.gained)) top = { test: point.census.test, gained: counted };
+      });
+      const growth = pileUp(unexplained, what);
+      if (!growth) continue;
+      const lead = points.length === measured.length ? top : null;
+      const span = measured.indexOf(points[points.length - 1].census) - measured.indexOf(points[0].census) + 1;
+      const finding = {
+        verdict: "piling",
+        kind: "worker",
+        where: "worker process",
+        tests: measured.length,
+        count: 1,
+        growth: {
+          what,
+          from: Math.round(Math.min(...points.map((point) => point.value))),
+          to: Math.round(points[points.length - 1].value),
+          tests: span
+        },
+        ...lead ? { detail: `most of it during "${lead.test.title ?? ""}" (${lead.test.file})` } : {},
+        gained: growth.to - growth.from
+      };
+      const seen = best.get(what);
+      if (!seen || finding.gained > seen.gained) best.set(what, finding);
+    }
+  }
+  return [...best.values()].map(({ gained: _gained, ...finding }) => finding);
+}
 function handleFindings(byWorker) {
   const groups = /* @__PURE__ */ new Map();
+  const add2 = (test, type, count, site = null) => {
+    const key = `${test.id}|${type}|${site ?? ""}`;
+    const group = groups.get(key) ?? {
+      verdict: "handle",
+      kind: "handle",
+      where: type,
+      ...site ? { site } : {},
+      tests: 1,
+      count: 0,
+      detail: `"${test.title ?? ""}" (${test.file})`
+    };
+    group.count += count;
+    groups.set(key, group);
+  };
   for (const censuses of byWorker.values()) {
+    for (const census of censuses) {
+      if (!census.test || census.test.failed) continue;
+      for (const handle of census.running ?? []) add2(census.test, handle.type, 1, handle.site);
+    }
     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)) {
+        if (census.running && type === "TCPServerWrap") continue;
         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);
+        add2(census.test, type, grew);
       }
     }
   }
@@ -8268,19 +8882,37 @@ var KIND_LABEL = {
   context: "context",
   page: "page",
   request: "API context",
-  handle: "handle"
+  handle: "handle",
+  worker: "worker"
+};
+var GROWTH_LABEL = {
+  pages: "pages",
+  listeners: "listeners",
+  routes: "routes",
+  elements: "elements",
+  heapMb: "heap",
+  descriptors: "descriptors"
+};
+var GROWTH_NOUN = {
+  pages: "open pages",
+  listeners: "listeners",
+  routes: "route handlers",
+  elements: "DOM elements",
+  heapMb: "MB of heap after garbage collection",
+  descriptors: "open file descriptors"
 };
 var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
 var HANDLE_LABEL = {
   TCPServerWrap: "server",
   FSEventWrap: "file watcher",
-  StatWatcher: "file watcher"
+  StatWatcher: "file watcher",
+  ChildProcess: "process"
 };
 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 label = finding.verdict === "handle" ? HANDLE_LABEL[finding.where] ?? finding.where : finding.growth ? GROWTH_LABEL[finding.growth.what] : KIND_LABEL[finding.kind];
   const kind = label.padEnd(11);
-  const parts = finding.verdict === "handle" ? [] : [finding.where];
+  const parts = finding.verdict === "handle" ? finding.site ? [finding.site] : [] : [finding.where];
   switch (finding.verdict) {
     case "leaked": {
       if (finding.count > 1) parts.push(`${finding.count} ${KIND_LABEL[finding.kind]}s`);
@@ -8303,11 +8935,12 @@ function findingLine(finding) {
       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`);
+      parts.push(`${growth.from} \u2192 ${growth.to} ${GROWTH_NOUN[growth.what]} over ${growth.tests} tests`);
+      if (finding.detail) parts.push(finding.detail);
       break;
     }
     case "handle":
+      if (finding.count > 1) parts.push(`${finding.count} ${label}${label.endsWith("s") ? "es" : "s"}`);
       parts.push(`left running in the worker by ${finding.detail ?? "a test"}`);
       break;
     case "probable":
@@ -8446,6 +9079,12 @@ async function dirBytes(dir, budget) {
   }
   return bytes;
 }
+function memoryOf(container) {
+  const totalMemory = os8.totalmem();
+  const constrained = typeof process.constrainedMemory === "function" ? process.constrainedMemory() : void 0;
+  const limit = container?.memoryLimitBytes ?? (constrained && constrained > 0 ? constrained : null);
+  return { memoryBytes: totalMemory, memoryLimitBytes: limit !== null && limit < totalMemory ? limit : null };
+}
 var RunSampler = class {
   constructor(options = {}) {
     this.timer = null;
@@ -8514,6 +9153,18 @@ var RunSampler = class {
     }
     return this.profile(await this.leftoverBytes());
   }
+  /**
+   * What a live run's memory is drawn against: the machine's memory, or its
+   * container's limit when lower, read once, and how the run's memory is
+   * measured so far.
+   */
+  liveMemory() {
+    if (this.capacityBytes === void 0) {
+      const machine = memoryOf(this.linux ? this.cgroup.read() : null);
+      this.capacityBytes = machine.memoryLimitBytes ?? machine.memoryBytes;
+    }
+    return { capacityBytes: this.capacityBytes || null, kind: this.memoryKind };
+  }
   /** The series read so far, each point at the time it was read. */
   timedSeries() {
     return {
@@ -8810,9 +9461,6 @@ var RunSampler = class {
     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 {
@@ -8820,8 +9468,7 @@ var RunSampler = class {
       wallMs,
       machine: {
         cores: typeof os8.availableParallelism === "function" ? os8.availableParallelism() : os8.cpus().length,
-        memoryBytes: totalMemory,
-        memoryLimitBytes: limit !== null && limit < totalMemory ? limit : null,
+        ...memoryOf(container),
         cpuQuotaCores: container?.cpuQuotaCores ?? null
       },
       cpu: {
@@ -9093,7 +9740,7 @@ function openPagesByWorker(censuses) {
   }
   return out;
 }
-function pagesOverTime(censuses) {
+function pagesOverTime(censuses, live = false) {
   const byWorker = /* @__PURE__ */ new Map();
   for (const census of censuses) {
     const list = byWorker.get(census.worker) ?? [];
@@ -9126,7 +9773,7 @@ function pagesOverTime(censuses) {
       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]);
+    if (!live && open > 0 && lastAt >= events[events.length - 1][0]) events.push([lastAt, 0]);
     out.push({ worker, events });
   }
   return out;
@@ -9158,7 +9805,7 @@ function resourceTimeline(samples, censuses) {
   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 relative11 = (points, by) => points.map(([at, value]) => [Math.round(at + by), value]);
+  const relative12 = (points, by) => points.map(([at, value]) => [Math.round(at + by), value]);
   const trees = hasSamples ? workerTreesByIndex(samples, censuses) : [];
   const perWorker = Math.max(
     60,
@@ -9166,17 +9813,17 @@ function resourceTimeline(samples, censuses) {
   );
   return {
     startedAt,
-    cpuPct: hasSamples ? downsamplePoints(relative11(samples.cpuPct, shift), TIMELINE_SERIES_CAP, "mean") : [],
-    memoryBytes: hasSamples ? downsamplePoints(relative11(samples.memoryBytes, shift), TIMELINE_SERIES_CAP, "max") : [],
+    cpuPct: hasSamples ? downsamplePoints(relative12(samples.cpuPct, shift), TIMELINE_SERIES_CAP, "mean") : [],
+    memoryBytes: hasSamples ? downsamplePoints(relative12(samples.memoryBytes, shift), TIMELINE_SERIES_CAP, "max") : [],
     pages: workers.map(({ worker, events }) => {
-      const points = relative11(events, -startedAt);
+      const points = relative12(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(relative11(tree.cpuCores, shift), perWorker, "mean"),
-      memoryBytes: downsamplePoints(relative11(tree.memoryBytes, shift), perWorker, "max")
+      cpuCores: downsamplePoints(relative12(tree.cpuCores, shift), perWorker, "mean"),
+      memoryBytes: downsamplePoints(relative12(tree.memoryBytes, shift), perWorker, "max")
     }))
   };
 }
@@ -9195,6 +9842,144 @@ function resourceReportWire(input) {
   };
 }
 
+// src/internal/streaming/live-resources.ts
+var LIVE_INTERVAL_MS = 5e3;
+function since(points, cursor, cap, merge) {
+  const fresh = cursor === void 0 ? points : points.filter(([at]) => at > cursor);
+  return downsamplePoints(fresh, cap, merge);
+}
+var LiveResources = class {
+  constructor(stream, httpClient, options, logger = new Logger()) {
+    this.stream = stream;
+    this.httpClient = httpClient;
+    this.options = options;
+    this.logger = logger;
+    this.timer = null;
+    this.inFlight = null;
+    this.stopped = false;
+    /** Whether the next post must carry every point: the first one, and after the dashboard lost them. */
+    this.reset = true;
+    /** The time of the last point the dashboard took, per series. */
+    this.sent = /* @__PURE__ */ new Map();
+    /** How many censuses the open pages last posted came from. */
+    this.censusCount = 0;
+  }
+  /** Post on a timer that never keeps the process alive. */
+  start() {
+    if (this.timer || this.stopped) return;
+    this.timer = setInterval(() => this.tick(), this.options.intervalMs ?? LIVE_INTERVAL_MS);
+    this.timer.unref?.();
+  }
+  /** Post nothing more, and wait for a post in flight. */
+  async stop() {
+    this.stopped = true;
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    await this.inFlight;
+  }
+  /** Post now, when the run is watched and no post is in flight: the dashboard says someone just opened it. */
+  tick() {
+    if (this.stopped || this.inFlight) return null;
+    const { enabled, runId, token } = this.stream;
+    if (!enabled || runId === null || !token || this.stream.isWatched !== true) return null;
+    let draft;
+    try {
+      draft = this.draft();
+    } catch (error) {
+      this.logger.debug(`Live resources not read: ${errorMessage(error)}`);
+      return null;
+    }
+    if (!draft) return null;
+    this.inFlight = this.send(runId, token, draft).finally(() => {
+      this.inFlight = null;
+    });
+    return this.inFlight;
+  }
+  /** What is new since the last post the dashboard took; null when nothing is. */
+  draft() {
+    const samples = this.options.sampler?.timedSeries() ?? null;
+    const startedAt = samples?.startedAt || this.options.runStartedAt;
+    const censuses = this.options.censuses();
+    const cursors = this.reset ? /* @__PURE__ */ new Map() : this.sent;
+    const sent2 = new Map(cursors);
+    let fresh = false;
+    const take = (key, points, cap, merge) => {
+      const out = since(points, cursors.get(key), cap, merge);
+      const last = points[points.length - 1];
+      if (out.length > 0 && last) {
+        sent2.set(key, last[0]);
+        fresh = true;
+      }
+      return out;
+    };
+    const timeline = { startedAt, cpuPct: [], memoryBytes: [], pages: [], workers: [] };
+    if (samples) {
+      timeline.cpuPct = take("cpu", samples.cpuPct, TIMELINE_SERIES_CAP, "mean");
+      timeline.memoryBytes = take("memory", samples.memoryBytes, TIMELINE_SERIES_CAP, "max");
+      for (const tree of workerTreesByIndex(samples, censuses)) {
+        const cpuCores = take(`cores:${tree.worker}`, tree.cpuCores, TIMELINE_WORKER_POINTS_CAP, "mean");
+        const memoryBytes = take(`bytes:${tree.worker}`, tree.memoryBytes, TIMELINE_WORKER_POINTS_CAP, "max");
+        if (cpuCores.length > 0 || memoryBytes.length > 0) {
+          timeline.workers.push({ worker: tree.worker, cpuCores, memoryBytes });
+        }
+      }
+    }
+    if (this.reset || censuses.length !== this.censusCount) {
+      for (const { worker, events } of pagesOverTime(censuses, true)) {
+        const points = events.map(([at, open]) => [at - startedAt, open]);
+        const last = points.pop();
+        timeline.pages.push({
+          worker,
+          points: [...downsamplePoints(points, TIMELINE_WORKER_POINTS_CAP - 1, "max"), last]
+        });
+      }
+      fresh ||= timeline.pages.length > 0;
+    }
+    if (!fresh) return null;
+    const memory = this.options.sampler?.liveMemory() ?? { capacityBytes: null, kind: null };
+    return {
+      post: {
+        shardIndex: this.options.shardIndex,
+        reset: this.reset,
+        timeline,
+        memoryCapacityBytes: memory.capacityBytes,
+        memoryKind: memory.kind
+      },
+      sent: sent2,
+      censusCount: censuses.length
+    };
+  }
+  async send(runId, token, draft) {
+    try {
+      const answer = await this.httpClient.postJSON(
+        `/api/test-runs/${runId}/live-resources`,
+        { streamToken: token, ...draft.post },
+        this.stream.auth
+      );
+      if (answer?.declined) {
+        this.logger.debug("The project declined resources: live resources are not sent.");
+        this.stopped = true;
+        return;
+      }
+      this.stream.noteWatched(answer);
+      if (answer?.resync) {
+        this.reset = true;
+        return;
+      }
+      this.sent = draft.sent;
+      this.censusCount = draft.censusCount;
+      this.reset = false;
+    } catch (error) {
+      if (error instanceof HttpError && error.status === 404) {
+        this.logger.debug("The dashboard takes no live resources.");
+        this.stopped = true;
+        return;
+      }
+      this.logger.debug(`Live resources not sent: ${errorMessage(error)}`);
+    }
+  }
+};
+
 // ../core/src/describe-failure.ts
 var HEADLINE_MAX_CHARS = 120;
 var VALUE_MAX_CHARS = 40;
@@ -9592,8 +10377,8 @@ function detailOf(parsed2, headline) {
     case "assertion-timeout": {
       const received = parsed2.received;
       if (received && !/element\(s\) not found/.test(received)) {
-        const shown = truncateValue(receivedDisplay(parsed2), SHORT_VALUE_MAX_CHARS).slice(0, 8);
-        if (!headline.includes(shown)) return truncateValue(`Received: ${received}`, HEADLINE_MAX_CHARS);
+        const shown2 = truncateValue(receivedDisplay(parsed2), SHORT_VALUE_MAX_CHARS).slice(0, 8);
+        if (!headline.includes(shown2)) return truncateValue(`Received: ${received}`, HEADLINE_MAX_CHARS);
       }
       const state = parsed2.lastStateLine;
       if (!state || /^(?:waiting for |unexpected value )/.test(state)) return null;
@@ -9724,10 +10509,14 @@ function isServerGranularity(value) {
   return typeof value === "string" && SERVER_VALUES.has(value);
 }
 function coverageSettings(options) {
-  if (options.collectPerformanceMetrics === false) return { browser: "off", server: "off" };
+  if (options.collectPerformanceMetrics === false) return { browser: "off", server: "off", css: "off" };
   const browser = options.coverage?.browser === "functions" ? "functions" : options.coverage?.browser === "files" || options.captureCodeReach === true ? "files" : "off";
   const server = isServerGranularity(options.coverage?.server) ? options.coverage.server : "off";
-  return { browser, server };
+  const css = options.coverage?.css === "rules" ? "rules" : "off";
+  return { browser, server, css };
+}
+function cssCoverageInWorker() {
+  return process.env[PIWI_ENV_KEYS.coverageCss] === "rules";
 }
 function browserCoverageInWorker() {
   const browser = process.env[PIWI_ENV_KEYS.coverageBrowser];
@@ -9742,7 +10531,7 @@ function browserFunctionCoverage(files) {
     files: [...files].map(([path34, functions]) => ({ path: path34, runtime: "browser", functions }))
   });
 }
-function newKnownFunctions(known, sent) {
+function newKnownFunctions(known, sent2) {
   const parts = [];
   let files = [];
   let budget = MAX_COVERAGE_RANGES;
@@ -9754,10 +10543,10 @@ function newKnownFunctions(known, sent) {
   for (const [raw, ranges] of known) {
     const path34 = normalizeCoveragePath(raw);
     if (path34 === null) continue;
-    let named = sent.get(path34);
+    let named = sent2.get(path34);
     let fresh = normalizeFunctionRanges(ranges).filter((range) => !named?.has(`${range[0]}:${range[1]}`));
     if (fresh.length === 0) continue;
-    if (!named) sent.set(path34, named = /* @__PURE__ */ new Set());
+    if (!named) sent2.set(path34, named = /* @__PURE__ */ new Set());
     for (const range of fresh) named.add(`${range[0]}:${range[1]}`);
     while (fresh.length > 0) {
       if (budget === 0 || files.length >= MAX_COVERAGE_FILES) close();
@@ -9775,7 +10564,7 @@ function serverCoverageInWorker() {
 }
 
 // src/internal/capture/code-reach.ts
-var crypto5 = __toESM(require("crypto"));
+var crypto6 = __toESM(require("crypto"));
 var fs23 = __toESM(require("fs"));
 var path23 = __toESM(require("path"));
 var import_node_child_process3 = require("child_process");
@@ -9847,10 +10636,10 @@ function joinRoot(root, source) {
 function decodeLines(raw) {
   const sources = [];
   const decoded = [];
-  const add = (map, lineOffset, columnOffset) => {
+  const add2 = (map, lineOffset, columnOffset) => {
     if (map.sections) {
       for (const section of map.sections) {
-        if (!add(section.map, section.offset.line, section.offset.column)) return false;
+        if (!add2(section.map, section.offset.line, section.offset.column)) return false;
       }
       return true;
     }
@@ -9871,7 +10660,7 @@ function decodeLines(raw) {
     });
     return true;
   };
-  return add(raw, 0, 0) ? { sources, lines: decoded } : null;
+  return add2(raw, 0, 0) ? { sources, lines: decoded } : null;
 }
 function compactSegments(lines) {
   let total = 0;
@@ -10047,7 +10836,7 @@ function functionLines(entry, map, text, all) {
   const read = textOf(entry, text);
   const ranges = executedFunctionRanges(entry, read?.length, all);
   if (!ranges.length || !read) return out;
-  const add = (source, range) => {
+  const add2 = (source, range) => {
     const list = out.get(source);
     if (list) list.push(range);
     else out.set(source, [range]);
@@ -10057,7 +10846,7 @@ function functionLines(entry, map, text, all) {
     const start = offsetToPosition(starts, range.start);
     if (!map) {
       const last = offsetToPosition(starts, Math.max(range.start, range.end - 1));
-      add(-1, [start.line + 1, last.line + 1]);
+      add2(-1, [start.line + 1, last.line + 1]);
       continue;
     }
     const at = map.originalAt(start.line, start.column);
@@ -10067,7 +10856,7 @@ function functionLines(entry, map, text, all) {
     if (first === null) continue;
     const header = first === at.line || first === at.line + 1 ? at.line : first;
     const lines = map.originalLinesBetween(at.source, start, end, header);
-    if (lines) add(at.source, [header + 1, lines[1] + 1]);
+    if (lines) add2(at.source, [header + 1, lines[1] + 1]);
   }
   return out;
 }
@@ -10165,9 +10954,9 @@ function resolveSourcePath(source, roots) {
   const normalized = normalizeSourcePath(source);
   if (!normalized || /(?:^|\/)node_modules\//.test(normalized)) return null;
   if (path23.isAbsolute(normalized) && isFile(normalized)) return path23.resolve(normalized);
-  const relative11 = normalized.replace(/^\/+/, "");
+  const relative12 = normalized.replace(/^\/+/, "");
   for (const root of roots) {
-    const candidate = path23.resolve(root, relative11);
+    const candidate = path23.resolve(root, relative12);
     if (isFile(candidate)) return candidate;
   }
   return null;
@@ -10202,7 +10991,7 @@ function relativeToRepo(file, repoRoot) {
   return path23.relative(repoRoot, file).split(path23.sep).join("/");
 }
 function scriptVersion(entry) {
-  return entry.hash ?? crypto5.createHash("sha1").update(entry.source ?? "").digest("hex");
+  return entry.hash ?? crypto6.createHash("sha1").update(entry.source ?? "").digest("hex");
 }
 async function loadMap(entry, fetchMap) {
   const ref = entry.source ? sourceMappingUrl(entry.source) : null;
@@ -10261,7 +11050,7 @@ async function resolveFunctions(entries, roots, fetchMap, pageUrl, withKnown) {
     if (listed) listed.push(...functions);
     else into.set(path34, [...functions]);
   };
-  const add = (file, functions) => addTo(files, file, functions);
+  const add2 = (file, functions) => addTo(files, file, functions);
   const bases = viteBases(entries);
   const scripts = entries.filter((entry) => entry.url && entry.functions?.length && !REPLAYED_SCRIPT.test(entry.url));
   const cached = scripts.map((entry) => scriptCache.get(entry.url, scriptVersion(entry)));
@@ -10288,14 +11077,14 @@ async function resolveFunctions(entries, roots, fetchMap, pageUrl, withKnown) {
       const text = textOf2(covered, resolution);
       if (resolution.lookup) {
         const reached = reachedFunctionLines(covered, resolution.lookup, text);
-        if (reached.size > 0) add(resolution.file, [...reached.values()].flat());
+        if (reached.size > 0) add2(resolution.file, [...reached.values()].flat());
       } else if (scriptRan(covered, text)) {
-        add(resolution.file, reachedFunctionLines(covered, null, text).get(-1) ?? []);
+        add2(resolution.file, reachedFunctionLines(covered, null, text).get(-1) ?? []);
       }
     } else if (resolution.kind === "map") {
       for (const [index, functions] of reachedFunctionLines(covered, resolution.lookup, textOf2(covered, resolution))) {
         const file = mapFile(resolution, index);
-        if (file) add(file, functions);
+        if (file) add2(file, functions);
       }
     }
     if (!withKnown || resolution.kind === "none") continue;
@@ -10374,10 +11163,13 @@ async function markCurrentDocument(page, cdp) {
 }
 function onPaused(page, capture, event) {
   const leaving = event.reason === "EventListener" && event.data?.eventName === "listener:beforeunload" && (event.callFrames?.[0]?.functionName ?? MARK_FUNCTION) === MARK_FUNCTION;
-  const read = leaving ? readCoverage(page, capture.cdp) : null;
+  const read = leaving ? Promise.all([
+    capture.js ? readCoverage(page, capture.cdp) : Promise.resolve([]),
+    capture.css ? readCssUsage(page, capture.cdp, capture.css) : Promise.resolve()
+  ]) : null;
   if (read) {
     const merging = read.then(
-      (coverage) => mergeCoverageRead(capture.ran, capture.scripts, coverage, capture.keepIdle)
+      ([coverage]) => mergeCoverageRead(capture.ran, capture.scripts, coverage, capture.keepIdle)
     );
     capture.reading.add(merging);
     void merging.finally(() => capture.reading.delete(merging));
@@ -10391,7 +11183,7 @@ function versionKey(url, hash) {
   return `${hash} ${url}`;
 }
 function onScriptParsed(page, capture, event) {
-  if (!event.url || REPLAYED_SCRIPT.test(event.url)) return;
+  if (!capture.js || !event.url || REPLAYED_SCRIPT.test(event.url)) return;
   capture.scripts.set(event.scriptId, { url: event.url, hash: event.hash, pageUrl: capture.pageUrl });
   if (NEVER_REACHED.test(event.url)) return;
   const key = versionKey(event.url, event.hash);
@@ -10420,6 +11212,53 @@ function readCoverage(page, cdp) {
   );
   return Promise.race([taken, late]).finally(() => clearTimeout(timer));
 }
+function onStyleSheetAdded(page, cdp, css, pageUrl, header) {
+  if (header.isConstructed) return;
+  const sheet = {
+    sourceURL: header.sourceURL,
+    ...header.sourceMapURL ? { sourceMapURL: header.sourceMapURL } : {},
+    isInline: header.isInline,
+    startLine: header.startLine,
+    pageUrl,
+    used: /* @__PURE__ */ new Map()
+  };
+  css.sheets.set(header.styleSheetId, sheet);
+  const reading = (async () => {
+    try {
+      if (header.ownerNode !== void 0 && !/\.css(?:[?#]|$)/i.test(header.sourceURL)) {
+        const { node } = await internalCall(
+          page,
+          () => cdp.send("DOM.describeNode", { backendNodeId: header.ownerNode })
+        );
+        const attributes = node.attributes ?? [];
+        const at = attributes.indexOf("data-vite-dev-id");
+        if (at >= 0 && typeof attributes[at + 1] === "string") sheet.devId = attributes[at + 1];
+      }
+      if (/\/node_modules\//.test(sheet.devId ?? header.sourceURL)) return;
+      const { text } = await internalCall(
+        page,
+        () => cdp.send("CSS.getStyleSheetText", { styleSheetId: header.styleSheetId })
+      );
+      sheet.text = text;
+    } catch {
+    }
+  })();
+  css.reading.add(reading);
+  void reading.finally(() => css.reading.delete(reading));
+}
+async function readCssUsage(page, cdp, css) {
+  try {
+    const { coverage } = await internalCall(page, () => cdp.send("CSS.takeCoverageDelta"));
+    for (const rule of coverage) {
+      if (!rule.used) continue;
+      css.sheets.get(rule.styleSheetId)?.used.set(`${rule.startOffset}:${rule.endOffset}`, {
+        startOffset: rule.startOffset,
+        endOffset: rule.endOffset
+      });
+    }
+  } catch {
+  }
+}
 function mergeCoverageRead(ran, scripts, read, keepIdle = true) {
   for (const covered of read) {
     const script = scripts.get(covered.scriptId);
@@ -10454,11 +11293,15 @@ async function detach(page, cdp) {
 }
 async function startCodeReach(page) {
   if (!isChromiumPage(page) || captures.has(page)) return false;
+  const withCss = cssCoverageInWorker();
+  const js = browserCoverageInWorker() || !withCss;
   let cdp = null;
   try {
     cdp = await internalCall(page, () => page.context().newCDPSession(page));
     const capture = {
       cdp,
+      js,
+      css: withCss ? { sheets: /* @__PURE__ */ new Map(), reading: /* @__PURE__ */ new Set() } : null,
       scripts: /* @__PURE__ */ new Map(),
       sources: /* @__PURE__ */ new Map(),
       ran: /* @__PURE__ */ new Map(),
@@ -10468,6 +11311,9 @@ async function startCodeReach(page) {
     };
     const marks = marksOf(page);
     cdp.on("Debugger.scriptParsed", (event) => onScriptParsed(page, capture, event));
+    const css = capture.css;
+    if (css)
+      cdp.on("CSS.styleSheetAdded", (event) => onStyleSheetAdded(page, cdp, css, capture.pageUrl, event.header));
     cdp.on("Debugger.paused", (event) => onPaused(page, capture, event));
     cdp.on("Page.frameNavigated", (event) => {
       if (event.frame.parentId) return;
@@ -10478,8 +11324,17 @@ async function startCodeReach(page) {
       page,
       () => Promise.all([
         capture.cdp.send("Debugger.enable"),
-        capture.cdp.send("Profiler.enable"),
-        capture.cdp.send("Profiler.startPreciseCoverage", { callCount: false, detailed: false }),
+        ...js ? [
+          capture.cdp.send("Profiler.enable"),
+          capture.cdp.send("Profiler.startPreciseCoverage", { callCount: false, detailed: false })
+        ] : [],
+        // The style sheets' rule usage records nothing without the DOM and CSS domains. A failure there leaves the
+        // scripts' coverage running.
+        ...css ? [
+          capture.cdp.send("DOM.enable").then(() => capture.cdp.send("CSS.enable")).then(() => capture.cdp.send("CSS.startRuleUsageTracking")).catch(() => {
+            capture.css = null;
+          })
+        ] : [],
         capture.cdp.send("Page.enable"),
         capture.cdp.send("Page.addScriptToEvaluateOnNewDocument", { source: MARK_SOURCE, worldName: MARK_WORLD }),
         capture.cdp.send("DOMDebugger.setEventListenerBreakpoint", { eventName: "beforeunload" })
@@ -10493,18 +11348,26 @@ async function startCodeReach(page) {
     return false;
   }
 }
-async function stopCodeReach(page) {
+async function stopPageCoverage(page) {
   const capture = captures.get(page);
-  if (!capture) return null;
+  if (!capture) return { scripts: null, sheets: [] };
   captures.delete(page);
   const { cdp } = capture;
-  try {
+  const sheets = async () => {
+    if (!capture.css) return [];
+    await readCssUsage(page, cdp, capture.css);
+    await Promise.all(capture.css.reading);
+    await internalCall(page, () => cdp.send("CSS.stopRuleUsageTracking")).catch(() => {
+    });
+    return [...capture.css.sheets.values()].filter((sheet) => sheet.used.size > 0 || sheet.text !== void 0);
+  };
+  const scripts = async () => {
+    if (!capture.js) return null;
     const last = await internalCall(page, async () => {
       const taken = await cdp.send("Profiler.takePreciseCoverage");
       await cdp.send("Profiler.stopPreciseCoverage");
       return taken.result;
     });
-    await Promise.all(capture.reading);
     mergeCoverageRead(capture.ran, capture.scripts, last, capture.keepIdle);
     const entries = [];
     for (const [key, { script, functions }] of capture.ran) {
@@ -10514,8 +11377,11 @@ async function stopCodeReach(page) {
       entries.push(entry);
     }
     return entries;
-  } catch {
-    return null;
+  };
+  try {
+    await Promise.all(capture.reading);
+    const [read, styles] = await Promise.all([scripts().catch(() => null), sheets().catch(() => [])]);
+    return { scripts: read, sheets: styles };
   } finally {
     await detach(page, cdp);
   }
@@ -10523,11 +11389,11 @@ async function stopCodeReach(page) {
 
 // src/internal/collect/blob-ids.ts
 var import_node_child_process4 = require("child_process");
-var crypto6 = __toESM(require("crypto"));
+var crypto7 = __toESM(require("crypto"));
 var fs24 = __toESM(require("fs"));
 var path24 = __toESM(require("path"));
 function gitBlobId(content) {
-  return crypto6.createHash("sha1").update(`blob ${content.length}\0`).update(content).digest("hex");
+  return crypto7.createHash("sha1").update(`blob ${content.length}\0`).update(content).digest("hex");
 }
 function namesLines(file) {
   return Boolean(file.functions?.length || file.lines?.length || file.executable?.length || file.allFunctions?.length);
@@ -10632,7 +11498,7 @@ var SETTLE_WAIT_MS = 15e3;
 var RUN_COVERAGE_FILES_PER_REQUEST = 5e3;
 var RUN_COVERAGE_BYTES_PER_REQUEST = 8 * 1024 * 1024;
 var INCOMPLETE = { files: [], incomplete: true };
-function composeTestCoverage(server, browserFiles, settings) {
+function composeTestCoverage(server, browserFiles, settings, cssFiles) {
   const serverCapture = settings.server !== "off" && server ? reduceCoverage(
     {
       v: 1,
@@ -10650,13 +11516,25 @@ function composeTestCoverage(server, browserFiles, settings) {
     },
     settings.browser
   ) : null;
-  const merged = mergeCoverage(serverCapture, browserCapture);
+  const wholeFiles = new Set(
+    settings.browser === "functions" ? [] : (browserFiles ?? []).map((file) => typeof file === "string" ? file : file.path)
+  );
+  const cssCapture = settings.css === "rules" && cssFiles?.length ? reduceCoverage(
+    {
+      v: 1,
+      files: cssFiles.map(
+        (file) => wholeFiles.has(file.path) ? { path: file.path, runtime: "browser" } : { ...file, runtime: "browser" }
+      )
+    },
+    "functions"
+  ) : null;
+  const merged = mergeCoverage(serverCapture, mergeCoverage(browserCapture, cssCapture));
   return merged ? sanitizeCoverage(merged) : null;
 }
-function addRanges(into, filePath2, ranges) {
+function addRanges(into, filePath3, ranges) {
   if (ranges.length === 0) return;
-  let known = into.get(filePath2);
-  if (!known) into.set(filePath2, known = /* @__PURE__ */ new Map());
+  let known = into.get(filePath3);
+  if (!known) into.set(filePath3, known = /* @__PURE__ */ new Map());
   for (const range of ranges) known.set(`${range[0]}:${range[1]}`, range);
 }
 function chunkRunCoverage(files) {
@@ -10710,7 +11588,7 @@ var CoverageCollection = class {
     this.browserKnown = /* @__PURE__ */ new Map();
     this.logger = options.logger ?? new Logger();
     this.waitMs = options.waitMs ?? TEST_COVERAGE_WAIT_MS;
-    this.browserBlobs = options.settings.browser === "functions" ? new BlobIds(() => repositoryRoot(options.configDir)) : null;
+    this.browserBlobs = options.settings.browser === "functions" || options.settings.css === "rules" ? new BlobIds(() => repositoryRoot(options.configDir)) : null;
     const granularity = options.settings.server;
     this.collector = granularity === "off" ? null : new ServerCoverageCollector({
       granularity,
@@ -10727,28 +11605,41 @@ var CoverageCollection = class {
   /**
    * The browser side of a test's coverage: its code reach paths, or, at
    * `functions` granularity, the files of its `piwi-browser-coverage` attachment
-   * with their blob ids, once read. Never rejects.
+   * with their blob ids, once read; with `coverage.css: 'rules'`, the style
+   * sheet files of its `piwi-css-coverage` attachment too. Never rejects.
    */
   browserCoverage(testCase, attachments) {
-    if (this.options.settings.browser === "off") return void 0;
-    const paths = testCase.codeReach;
-    const attachment = this.browserBlobs ? attachments?.find((a) => a.name === ATTACHMENT_NAMES.browserCoverage) : void 0;
-    if (this.browserBlobs) {
-      for (const known of attachments ?? []) {
-        if (known.name === ATTACHMENT_NAMES.browserFunctions) this.addKnownFunctions(known);
-      }
-    }
-    if (!this.browserBlobs || !attachment?.body) return paths;
+    const { browser, css } = this.options.settings;
+    if (browser === "off" && css !== "rules") return {};
+    const paths = browser === "off" ? void 0 : testCase.codeReach;
+    for (const known of attachments ?? []) {
+      if (browser === "functions" && isPiwiAttachment(known, ATTACHMENT_NAMES.browserFunctions))
+        this.addKnownFunctions(known);
+      if (css === "rules" && isPiwiAttachment(known, ATTACHMENT_NAMES.cssRules)) this.addKnownFunctions(known);
+    }
+    const scripts = browser === "functions" ? this.rangedFiles(attachments, ATTACHMENT_NAMES.browserCoverage) : [];
+    const sheets = css === "rules" ? this.rangedFiles(attachments, ATTACHMENT_NAMES.cssCoverage) : [];
+    const blobs = this.browserBlobs;
+    if (!blobs || scripts.length === 0 && sheets.length === 0) return { files: paths };
+    const withBlobs = (files) => blobs.withBlobs(files).catch(() => files);
+    return Promise.all([
+      scripts.length > 0 ? withBlobs(scripts) : Promise.resolve(null),
+      sheets.length > 0 ? withBlobs(sheets) : Promise.resolve([])
+    ]).then(([files, rules]) => ({ files: files ?? paths, css: rules }));
+  }
+  /** The browser files of a test's attachment holding line ranges, added to the run's. */
+  rangedFiles(attachments, name) {
+    const attachment = findPiwiAttachment(attachments, name);
+    if (!attachment?.body) return [];
     let files = [];
     try {
       files = sanitizeCoverage(JSON.parse(attachment.body.toString("utf8")))?.files ?? [];
     } catch {
-      return paths;
+      return [];
     }
     const browser = files.filter((file) => file.runtime === "browser");
-    if (browser.length === 0) return paths;
     for (const file of browser) addRanges(this.browserRan, file.path, file.functions ?? []);
-    return this.browserBlobs.withBlobs(browser).catch(() => browser);
+    return browser;
   }
   /** Add the functions of a `piwi-browser-functions` attachment, one of a test's, to the run's. */
   addKnownFunctions(attachment) {
@@ -10762,8 +11653,8 @@ var CoverageCollection = class {
     const files = parsed2?.v === 1 ? parsed2.files : null;
     if (!Array.isArray(files)) return;
     for (const item of files) {
-      const filePath2 = normalizeCoveragePath(item?.path);
-      if (filePath2 !== null) addRanges(this.browserKnown, filePath2, normalizeFunctionRanges(item.allFunctions));
+      const filePath3 = normalizeCoveragePath(item?.path);
+      if (filePath3 !== null) addRanges(this.browserKnown, filePath3, normalizeFunctionRanges(item.allFunctions));
     }
   }
   /**
@@ -10774,13 +11665,13 @@ var CoverageCollection = class {
   async browserRunFiles() {
     if (!this.browserBlobs) return [];
     const paths = [.../* @__PURE__ */ new Set([...this.browserKnown.keys(), ...this.browserRan.keys()])].sort();
-    const files = paths.map((filePath2) => {
-      const functions = normalizeFunctionRanges([...this.browserRan.get(filePath2)?.values() ?? []]);
+    const files = paths.map((filePath3) => {
+      const functions = normalizeFunctionRanges([...this.browserRan.get(filePath3)?.values() ?? []]);
       const allFunctions = normalizeFunctionRanges([
-        ...this.browserKnown.get(filePath2)?.values() ?? [],
+        ...this.browserKnown.get(filePath3)?.values() ?? [],
         ...functions
       ]);
-      const file = { path: filePath2, runtime: "browser" };
+      const file = { path: filePath3, runtime: "browser" };
       if (functions.length > 0) file.functions = functions;
       if (allFunctions.length > 0) file.allFunctions = allFunctions;
       return file;
@@ -10799,15 +11690,15 @@ var CoverageCollection = class {
    */
   apply(testCase, attachments) {
     const browser = this.browserCoverage(testCase, attachments);
-    const attachment = this.collector ? attachments?.find((a) => a.name === ATTACHMENT_NAMES.serverCoverageRequests) : void 0;
+    const attachment = this.collector ? findPiwiAttachment(attachments, ATTACHMENT_NAMES.serverCoverageRequests) : void 0;
     const requests = attachment?.body ? parseServerCoverageRequests(attachment.body) : null;
     if (!this.collector || !requests) {
       if (!(browser instanceof Promise)) {
-        this.assign(testCase, composeTestCoverage(null, browser, this.options.settings));
+        this.assign(testCase, composeTestCoverage(null, browser.files, this.options.settings, browser.css));
         return null;
       }
       const ready = browser.then(
-        (files) => this.assign(testCase, composeTestCoverage(null, files, this.options.settings))
+        (side) => this.assign(testCase, composeTestCoverage(null, side.files, this.options.settings, side.css))
       );
       this.browserPending.add(ready);
       return ready.finally(() => this.browserPending.delete(ready));
@@ -10821,8 +11712,8 @@ var CoverageCollection = class {
         settled = true;
         clearTimeout(timer);
         this.pending.delete(entry);
-        void Promise.resolve(browser).then((files) => {
-          this.assign(testCase, composeTestCoverage(server, files, this.options.settings));
+        void Promise.resolve(browser).then((side) => {
+          this.assign(testCase, composeTestCoverage(server, side.files, this.options.settings, side.css));
           resolve11();
         });
       };
@@ -10959,6 +11850,8 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
     this.resourcesFile = null;
     /** Samples the run's processes and the machine from `onBegin` to `onEnd`. */
     this.sampler = null;
+    /** Posts what the sampler and the censuses add while someone has the run open on the dashboard. */
+    this.liveResources = null;
     /** Bytes of the files the tests attached, by kind. */
     this.artifactBytes = emptyArtifacts();
     /** The run's resource report for the dashboard, built in `onEnd`. */
@@ -11117,8 +12010,9 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
       );
     }
     if (coverage.server !== "off") this.lastTestWatch = new LastTestWatch(this.plannedTests.length);
-    if (coverage.browser !== "off" || coverage.server !== "off") {
+    if (coverage.browser !== "off" || coverage.server !== "off" || coverage.css === "rules") {
       if (coverage.browser !== "off") process.env[PIWI_ENV_KEYS.coverageBrowser] = coverage.browser;
+      if (coverage.css === "rules") process.env[PIWI_ENV_KEYS.coverageCss] = coverage.css;
       if (coverage.server !== "off") {
         process.env[PIWI_ENV_KEYS.coverageServer] = coverage.server;
       }
@@ -11143,6 +12037,22 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
       // the dashboard shows the real total from the first render.
       this.plannedTests.length
     );
+    if (this.streamManager && this.options.captureResources !== false) {
+      const live = new LiveResources(
+        this.streamManager,
+        this.httpClient,
+        {
+          sampler: this.sampler,
+          censuses: () => this.resourceCensuses,
+          shardIndex: this.shardInfo?.current ?? null,
+          runStartedAt: Date.now()
+        },
+        this.logger
+      );
+      this.streamManager.onWatched = () => void live.tick();
+      live.start();
+      this.liveResources = live;
+    }
   }
   /**
    * Settle each planned test's external ID before any test runs, name the IDs two tests share, and record them on
@@ -11326,7 +12236,7 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
       if (frames.length) testCase.testSourceFrames = frames;
     }
     if (this.options.collectPerformanceMetrics && result.steps?.length > 0) {
-      const pauses = readPauses(result.attachments?.find((a) => a.name === ATTACHMENT_NAMES.pauses)?.body);
+      const pauses = readPauses(findPiwiAttachment(result.attachments, ATTACHMENT_NAMES.pauses)?.body);
       testCase.performanceMetrics = collectStepMetrics(result.steps, result.errors, pauses);
       const stepEvents = extractTestStepEvents(result.steps, result.startTime);
       const waitEvents = extractWaitEvents(result.steps);
@@ -11336,14 +12246,14 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
     if (this.options.collectPerformanceMetrics && result.attachments) {
       this.fileHandler.parsePerformanceAttachments(testCase, result.attachments);
       this.manifests?.note(testCase.networkRequests);
-      const locatorAttachment = this.options.captureLocators !== false ? result.attachments.find((a) => a.name === ATTACHMENT_NAMES.locators) : void 0;
+      const locatorAttachment = this.options.captureLocators !== false ? findPiwiAttachment(result.attachments, ATTACHMENT_NAMES.locators) : void 0;
       if (locatorAttachment?.body) {
         try {
           testCase.locatorSnapshots = JSON.parse(locatorAttachment.body.toString());
         } catch {
         }
       }
-      const pagesAttachment = this.options.captureLocators !== false ? result.attachments.find((a) => a.name === ATTACHMENT_NAMES.locatorPages) : void 0;
+      const pagesAttachment = this.options.captureLocators !== false ? findPiwiAttachment(result.attachments, ATTACHMENT_NAMES.locatorPages) : void 0;
       if (pagesAttachment?.body) {
         try {
           testCase.locatorPages = JSON.parse(pagesAttachment.body.toString());
@@ -11352,7 +12262,7 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
       }
     }
     if (this.enabled && this.options.captureResources !== false) this.collectResources(test, result, testCase);
-    const reachAttachment = this.coverageSettings.browser !== "off" ? result.attachments.find((a) => a.name === ATTACHMENT_NAMES.codeReach) : void 0;
+    const reachAttachment = this.coverageSettings.browser !== "off" ? findPiwiAttachment(result.attachments, ATTACHMENT_NAMES.codeReach) : void 0;
     if (reachAttachment?.body) {
       try {
         const files = JSON.parse(reachAttachment.body.toString());
@@ -11424,7 +12334,7 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
       } catch {
       }
     }
-    const attachment = result.attachments?.find((a) => a.name === ATTACHMENT_NAMES.resources);
+    const attachment = findPiwiAttachment(result.attachments, ATTACHMENT_NAMES.resources);
     const census = parseResourceCensus(attachment?.body);
     if (census) {
       this.resourceCensuses.push(census);
@@ -11445,6 +12355,8 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
    */
   async reportResources() {
     if (this.options.captureResources === false) return;
+    await this.liveResources?.stop();
+    this.liveResources = null;
     const profile = this.sampler ? await this.sampler.stop() : null;
     const samples = this.sampler?.timedSeries() ?? null;
     this.sampler = null;
@@ -12442,14 +13354,14 @@ function showAnchorPicker(arg) {
   } catch {
     shadowRoots.length = 0;
   }
-  const within = (node2, scope) => {
+  const within2 = (node2, scope) => {
     if (scope === doc) return true;
     for (let n = node2; n; n = parentOf(n)) if (n === scope) return true;
     return false;
   };
   const queryAll = (scope, sel) => {
     const found = Array.from(scope.querySelectorAll(sel));
-    for (const sr of shadowRoots) if (within(sr.host, scope)) found.push(...Array.from(sr.querySelectorAll(sel)));
+    for (const sr of shadowRoots) if (within2(sr.host, scope)) found.push(...Array.from(sr.querySelectorAll(sel)));
     return found;
   };
   const leafCountable = !!leafTestId || roleOf2(el) === leafRole;
@@ -12530,8 +13442,8 @@ function showAnchorPicker(arg) {
     return;
   }
   const MONO = "ui-monospace,SFMono-Regular,Menlo,Consolas,monospace";
-  const outline = doc.createElement("div");
-  outline.style.cssText = `position:fixed;pointer-events:none;z-index:${Z};box-sizing:border-box;border:2px solid #22c55e;background:rgba(34,197,94,.10);border-radius:4px;display:none;box-shadow:0 0 0 1px rgba(255,255,255,.9),0 0 0 3px rgba(5,46,22,.5);`;
+  const outline2 = doc.createElement("div");
+  outline2.style.cssText = `position:fixed;pointer-events:none;z-index:${Z};box-sizing:border-box;border:2px solid #22c55e;background:rgba(34,197,94,.10);border-radius:4px;display:none;box-shadow:0 0 0 1px rgba(255,255,255,.9),0 0 0 3px rgba(5,46,22,.5);`;
   const outlineLabel = doc.createElement("div");
   outlineLabel.style.cssText = `position:fixed;pointer-events:none;z-index:${Z + 1};display:none;box-sizing:border-box;max-width:min(420px,90vw);background:#0b1120;color:#f9fafb;border:1px solid #22c55e;border-radius:6px;padding:3px 7px;font:12px/1.45 ${MONO};white-space:nowrap;overflow:hidden;text-overflow:ellipsis;box-shadow:0 4px 18px rgba(0,0,0,.5);`;
   const pickedOutline = doc.createElement("div");
@@ -12620,11 +13532,11 @@ function showAnchorPicker(arg) {
     line.appendChild(text);
     line.addEventListener("mouseenter", () => {
       const r = row.node.getBoundingClientRect();
-      outline.style.display = "block";
-      outline.style.left = r.left + "px";
-      outline.style.top = r.top + "px";
-      outline.style.width = r.width + "px";
-      outline.style.height = r.height + "px";
+      outline2.style.display = "block";
+      outline2.style.left = r.left + "px";
+      outline2.style.top = r.top + "px";
+      outline2.style.width = r.width + "px";
+      outline2.style.height = r.height + "px";
       outlineLabel.textContent = `<${row.info.tag}> ${row.hookLabel}`;
       outlineLabel.style.display = "block";
       const lr = outlineLabel.getBoundingClientRect();
@@ -12634,7 +13546,7 @@ function showAnchorPicker(arg) {
       outlineLabel.style.top = top + "px";
     });
     line.addEventListener("mouseleave", () => {
-      outline.style.display = "none";
+      outline2.style.display = "none";
       outlineLabel.style.display = "none";
     });
     box.addEventListener("change", () => {
@@ -12648,7 +13560,7 @@ function showAnchorPicker(arg) {
   const cleanup = () => {
     doc.removeEventListener("keydown", onKey, true);
     panel.remove();
-    outline.remove();
+    outline2.remove();
     outlineLabel.remove();
     pickedOutline.remove();
     if (g.__piwiAnchorCleanup === cleanup) delete g.__piwiAnchorCleanup;
@@ -12713,7 +13625,7 @@ function showAnchorPicker(arg) {
       );
     }
   };
-  mount(pickedOutline, outline, outlineLabel, panel);
+  mount(pickedOutline, outline2, outlineLabel, panel);
 }
 
 // ../picker-dom/src/overlay-confirm.ts
@@ -12817,7 +13729,7 @@ function showPauseBar(arg) {
   bar.style.cssText = `position:fixed;top:0;left:0;right:0;z-index:${Z + 4};display:flex;align-items:center;gap:12px;flex-wrap:wrap;padding:8px 12px;background:#111827;color:#f9fafb;border-bottom:2px solid #a78bfa;box-shadow:0 4px 20px rgba(0,0,0,.35);font:13px/1.5 system-ui,sans-serif;`;
   const where = doc.createElement("div");
   where.style.cssText = "font-weight:600;white-space:nowrap;";
-  where.textContent = `Paused at ${arg.place}${arg.attempt ? ` \xB7 attempt ${arg.attempt}` : ""}`;
+  where.textContent = `${arg.failure ? "Failed at" : "Paused at"} ${arg.place}${arg.attempt ? ` \xB7 attempt ${arg.attempt}` : ""}`;
   const what = doc.createElement("code");
   what.style.cssText = "flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:#d8b4fe;font:12px/1.5 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;";
   what.textContent = arg.locator ? `${arg.action} \xB7 ${arg.locator}` : arg.action;
@@ -12840,13 +13752,13 @@ function showPauseBar(arg) {
     delete g.__piwiPauseCleanup;
   };
   const buttons = [
-    ["Resume", "resume", "Run on to the next breakpoint (Esc)", true],
-    ["Step", "step", "Pause again before the next call", false],
+    arg.failure ? ["Resume", "resume", "Let the test end as it failed (Esc)", true] : ["Resume", "resume", "Run on to the next breakpoint (Esc)", true],
+    ...arg.failure ? [] : [["Step", "step", "Pause again before the next call", false]],
     ["Pick a locator", "pick", "Pick an element on the page and confirm a locator for it", false],
     ...arg.record ? [
       ["Record here", "record", "Record steps in this page: the editor writes them before this line", false]
     ] : [],
-    ["Finish", "finish", "Run on and pause no more in this test", false]
+    ...arg.failure ? [] : [["Finish", "finish", "Run on and pause no more in this test", false]]
   ];
   for (const [label, choice, hint, primary] of buttons) {
     const btn = doc.createElement("button");
@@ -13011,7 +13923,7 @@ var TEST_DATA_ATTRS = /* @__PURE__ */ new Set(["data-test", "data-test-id", "dat
 function generateAlternatives(attrs, options = {}) {
   const alts = [];
   const seen = /* @__PURE__ */ new Set();
-  const add = (loc) => {
+  const add2 = (loc) => {
     if (!seen.has(loc.locator)) {
       seen.add(loc.locator);
       alts.push(loc);
@@ -13028,7 +13940,7 @@ function generateAlternatives(attrs, options = {}) {
   const selectable = (name2) => name2.toLowerCase() !== testIdAttribute.toLowerCase();
   const testId = attr(attrs, testIdAttribute);
   if (testId && isUnique(counts?.testId)) {
-    add({
+    add2({
       locator: `getByTestId(${quoteJsString(testId)})`,
       method: "getByTestId",
       args: { testId },
@@ -13039,7 +13951,7 @@ function generateAlternatives(attrs, options = {}) {
   const levelPart = level != null ? `, level: ${level}` : "";
   const withLevel = (base) => level != null ? { ...base, level } : base;
   if (role && accessibleName) {
-    add({
+    add2({
       locator: `getByRole(${quoteJsString(role)}, { name: ${quoteJsString(accessibleName)}${levelPart} })`,
       method: "getByRole",
       args: withLevel({ role, name: accessibleName }),
@@ -13048,7 +13960,7 @@ function generateAlternatives(attrs, options = {}) {
   }
   const ariaLabel = attr(attrs, "aria-label");
   if (role && ariaLabel && ariaLabel !== accessibleName) {
-    add({
+    add2({
       locator: `getByRole(${quoteJsString(role)}, { name: ${quoteJsString(ariaLabel)}${levelPart} })`,
       method: "getByRole",
       args: withLevel({ role, name: ariaLabel }),
@@ -13059,7 +13971,7 @@ function generateAlternatives(attrs, options = {}) {
     const label = attr(attrs, "aria-label");
     const labelBacked = attrs.hasLabel === void 0 ? true : attrs.hasLabel === true || label === accessibleName;
     if (labelBacked) {
-      add({
+      add2({
         locator: `getByLabel(${quoteJsString(accessibleName)})`,
         method: "getByLabel",
         args: { label: accessibleName },
@@ -13069,7 +13981,7 @@ function generateAlternatives(attrs, options = {}) {
   }
   const placeholder = attr(attrs, "placeholder");
   if (placeholder) {
-    add({
+    add2({
       locator: `getByPlaceholder(${quoteJsString(placeholder)})`,
       method: "getByPlaceholder",
       args: { placeholder },
@@ -13077,7 +13989,7 @@ function generateAlternatives(attrs, options = {}) {
     });
   }
   if (text && text.length < 80) {
-    add({
+    add2({
       locator: `getByText(${quoteJsString(text)})`,
       method: "getByText",
       args: { text },
@@ -13087,7 +13999,7 @@ function generateAlternatives(attrs, options = {}) {
   const id = attr(attrs, "id");
   if (id && selectable("id") && !isAutoGenerated(id) && isUnique(counts?.id)) {
     const selector = isCssSafeId(id) ? `#${id}` : `[id="${escCssAttrValue(id)}"]`;
-    add({
+    add2({
       locator: `locator(${quoteJsString(selector)})`,
       method: "locator",
       args: { selector },
@@ -13097,7 +14009,7 @@ function generateAlternatives(attrs, options = {}) {
   const name = attr(attrs, "name");
   if (name && selectable("name") && isUnique(counts?.name)) {
     const selector = `[name="${escCssAttrValue(name)}"]`;
-    add({
+    add2({
       locator: `locator(${quoteJsString(selector)})`,
       method: "locator",
       args: { selector },
@@ -13106,7 +14018,7 @@ function generateAlternatives(attrs, options = {}) {
   }
   const alt = attr(attrs, "alt");
   if (alt) {
-    add({
+    add2({
       locator: `getByAltText(${quoteJsString(alt)})`,
       method: "getByAltText",
       args: { text: alt },
@@ -13115,7 +14027,7 @@ function generateAlternatives(attrs, options = {}) {
   }
   const title = attr(attrs, "title");
   if (title) {
-    add({
+    add2({
       locator: `getByTitle(${quoteJsString(title)})`,
       method: "getByTitle",
       args: { title },
@@ -13133,7 +14045,7 @@ function generateAlternatives(attrs, options = {}) {
       if (scopedCount(anc) !== 1) continue;
       if (!testIdAnchorDone && anc.testId && anc.testIdCount === 1) {
         testIdAnchorDone = true;
-        add({
+        add2({
           locator: `getByTestId(${quoteJsString(anc.testId)}).${leaf.expr}`,
           method: leaf.method,
           args: { ...leaf.args, anchorTestId: anc.testId },
@@ -13143,7 +14055,7 @@ function generateAlternatives(attrs, options = {}) {
       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({
+        add2({
           locator: `locator(${quoteJsString(anchorSelector)}).${leaf.expr}`,
           method: leaf.method,
           args: { ...leaf.args, anchorSelector },
@@ -13154,7 +14066,7 @@ function generateAlternatives(attrs, options = {}) {
         dataAnchorDone = true;
         const { name: name2, value } = anc.dataAttr;
         const anchorSelector = `[${name2}="${escCssAttrValue(value)}"]`;
-        add({
+        add2({
           locator: `locator(${quoteJsString(anchorSelector)}).${leaf.expr}`,
           method: leaf.method,
           args: { ...leaf.args, anchorSelector },
@@ -13164,7 +14076,7 @@ function generateAlternatives(attrs, options = {}) {
       const ancestorRole = anc.role || TAG_TO_ROLE[anc.tag] || null;
       if (!roleAnchorDone && ancestorRole && ancestorRole !== leaf.role && anc.roleCount === 1) {
         roleAnchorDone = true;
-        add({
+        add2({
           locator: `getByRole(${quoteJsString(ancestorRole)}).${leaf.expr}`,
           method: leaf.method,
           args: { ...leaf.args, anchorRole: ancestorRole },
@@ -13173,7 +14085,7 @@ function generateAlternatives(attrs, options = {}) {
       }
       if (!filterAnchorDone && ancestorRole && anc.filterText && anc.filterRoleCount === 1) {
         filterAnchorDone = true;
-        add({
+        add2({
           locator: `getByRole(${quoteJsString(ancestorRole)}).filter({ hasText: ${quoteJsString(anc.filterText)} }).${leaf.expr}`,
           method: leaf.method,
           args: { ...leaf.args, anchorRole: ancestorRole, anchorHasText: anc.filterText },
@@ -13192,7 +14104,7 @@ function generateAlternatives(attrs, options = {}) {
     );
     const pos = attrs.rolePosition;
     if (pos && pos.role === role && (pos.count === 1 || level != null && pos.levelCount === 1)) {
-      add({
+      add2({
         locator: `getByRole(${rolePart})`,
         method: "getByRole",
         args: leafArgs,
@@ -13211,7 +14123,7 @@ function generateAlternatives(attrs, options = {}) {
     const countsClasses = counts?.classes;
     const classes = clsStr.split(/\s+/).filter((c) => c.length > 1 && /^[A-Za-z_-][A-Za-z0-9_-]*$/.test(c) && isUnique(countsClasses?.[c])).map((cls) => ({ cls, score: classifyCssStability(cls) })).sort((a, b) => b.score - a.score).slice(0, 3);
     for (const { cls, score } of classes) {
-      add({
+      add2({
         locator: `locator(${quoteJsString(`.${cls}`)})`,
         method: "locator",
         args: { selector: `.${cls}` },
@@ -13268,7 +14180,7 @@ function generateAnchoredAlternatives(leaf, anchors, chainLeafCount) {
   const seen = /* @__PURE__ */ new Set();
   const rolePart = leaf.level != null ? `${quoteJsString(leaf.role)}, { level: ${leaf.level} }` : quoteJsString(leaf.role);
   const leafArgs = leaf.level != null ? { role: leaf.role, level: leaf.level } : { role: leaf.role };
-  const add = (l) => {
+  const add2 = (l) => {
     if (!seen.has(l.locator)) {
       seen.add(l.locator);
       out.push(l);
@@ -13278,7 +14190,7 @@ function generateAnchoredAlternatives(leaf, anchors, chainLeafCount) {
     if (anchor.scopedLeafCount !== 1) continue;
     const seg = anchorSegment(anchor);
     if (!seg) continue;
-    add({
+    add2({
       locator: `${seg.code}.getByRole(${rolePart})`,
       method: "getByRole",
       args: { ...leafArgs, ...seg.flatArgs },
@@ -13291,7 +14203,7 @@ function generateAnchoredAlternatives(leaf, anchors, chainLeafCount) {
     if (segments.every((s) => s !== null)) {
       const innermost = segments[segments.length - 1];
       const score = Math.min(...segments.map((s) => ANCHOR_KIND_SCORES[s.kind]));
-      add({
+      add2({
         locator: `${segments.map((s) => s.code).join(".")}.getByRole(${rolePart})`,
         method: "getByRole",
         // Flat args describe the innermost anchor (what the healing fingerprint
@@ -14254,11 +15166,31 @@ function parsePauseAt(value, cwd = process.cwd()) {
   return lines.size ? new PauseSet(lines) : NO_BREAKPOINTS;
 }
 var parsed = null;
+var sent = null;
 function currentPauseSet() {
+  if (sent) return sent;
   const value = process.env[PIWI_LOCAL_DEBUG_ENV.pauseAt];
   if (!parsed || parsed.value !== value) parsed = { value, set: parsePauseAt(value) };
   return parsed.set;
 }
+function replacePauseSet(places, cwd = process.cwd()) {
+  if (!places) {
+    sent = null;
+    return currentPauseSet();
+  }
+  const lines = new Set(places.map((place) => placeLine(place, cwd)));
+  sent = lines.size ? new PauseSet(lines) : NO_BREAKPOINTS;
+  return sent;
+}
+function callSitePlace(callSite) {
+  const m = /^(.+):(\d+):(\d+)$/.exec(callSite);
+  if (!m || Number(m[2]) < 1) return null;
+  const column = Number(m[3]);
+  return column > 0 ? { file: m[1], line: Number(m[2]), column } : { file: m[1], line: Number(m[2]) };
+}
+function placeLine(place, cwd = process.cwd()) {
+  return `${callSiteFile(place.file, cwd)}:${place.line}`;
+}
 function pauseGateFromTestInfo(testInfo) {
   const use = testInfo.project?.use ?? {};
   const debug = testInfo._configInternal?.configCLIOverrides?.debug;
@@ -14266,7 +15198,7 @@ function pauseGateFromTestInfo(testInfo) {
 }
 function pauseSkipReason(gate) {
   if (isCi(gate.ci)) return "running under CI \u2014 breakpoints pause local runs only";
-  if (gate.headless !== false)
+  if (gate.headless !== false && !gate.channel)
     return "the browser is headless \u2014 re-run with --headed (or set use: { headless: false })";
   if (gate.pwdebug && !["0", "false", "console"].includes(gate.pwdebug))
     return "Playwright's Inspector runs the test (PWDEBUG) \u2014 run without --debug";
@@ -14274,20 +15206,42 @@ function pauseSkipReason(gate) {
     return `Playwright's debugger runs the test (--debug=${gate.debug}) \u2014 run without --debug`;
   return null;
 }
+function pauseState(set, pause = false) {
+  return { set, step: false, finished: false, pause, runTo: null };
+}
+function wantsStops(state) {
+  return state.step || state.pause || state.runTo !== null || !state.finished && state.set.size > 0;
+}
+function atBreakpoint(state, callSite) {
+  return !state.finished && state.set.matches(callSite);
+}
 function atStop(state, callSite) {
-  if (callSite && !state.finished) {
-    if (state.step) {
-      state.step = false;
-      return { show: "step" };
+  if (callSite) {
+    const reason = state.step ? "step" : state.pause ? "pause" : state.runTo !== null && callSiteLine(callSite) === state.runTo ? "run-to" : atBreakpoint(state, callSite) ? "breakpoint" : null;
+    if (reason) {
+      stopShown(state);
+      return { show: reason };
     }
-    if (state.set.matches(callSite)) return { show: "breakpoint" };
   }
   return { go: goOn(state) };
 }
+function stopShown(state) {
+  state.step = false;
+  state.pause = false;
+  state.runTo = null;
+}
+function askedOnce(state) {
+  return { step: state.step, pause: state.pause, runTo: state.runTo };
+}
+function askAgain(state, asked) {
+  state.step ||= asked.step;
+  state.pause ||= asked.pause;
+  state.runTo ??= asked.runTo;
+}
 function goOn(state, answer) {
   if (answer === "step") state.step = true;
   else if (answer === "finish") state.finished = true;
-  return !state.finished && (state.step || state.set.size > 0) ? "next" : "resume";
+  return wantsStops(state) ? "next" : "resume";
 }
 function contextDebugger(context) {
   const dbg = context.debugger;
@@ -14423,38 +15377,83 @@ function logPauseSkipOnce(reason) {
 var NAVIGATED = /Execution context was destroyed|Cannot find context with specified id/;
 var MAX_NAVIGATED = 10;
 var HIGHLIGHT_MS = 2e3;
-async function pauseHere(page, point, probe, onPick, onRecord, ended) {
-  let shown = null;
+var BarIntents = class {
+  constructor() {
+    this.take = null;
+    this.queued = null;
+    this.busy = false;
+  }
+  /** Hand the bar an intent; false while it runs one, or holds one already. */
+  offer(intent) {
+    if (this.busy || this.queued) return false;
+    const take = this.take;
+    this.take = null;
+    if (take) take(intent);
+    else this.queued = intent;
+    return true;
+  }
+  /** The bar waits for its answer: settles with the next intent handed to it. */
+  wait() {
+    this.busy = false;
+    const queued = this.queued;
+    this.queued = null;
+    if (queued) return Promise.resolve(queued);
+    return new Promise((resolve11) => {
+      this.take = resolve11;
+    });
+  }
+  /** The bar got its answer: it takes no intent until it waits again. */
+  answered() {
+    this.take = null;
+    this.busy = true;
+  }
+};
+var TAKE_DOWN_MS = 1e3;
+async function within(run, ms) {
+  let timer;
+  try {
+    return await Promise.race([
+      run,
+      new Promise((resolve11) => timer = setTimeout(() => resolve11(void 0), ms))
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function pauseHere(page, point, probe, onPick, onRecord, ended, intents, onIntent) {
+  let shown2 = null;
   try {
     const highlight = point.target?.highlight;
     if (typeof highlight === "function") {
-      let timer;
-      shown = await Promise.race([
-        Promise.resolve().then(() => highlight.call(point.target)).catch(() => null),
-        new Promise((resolve11) => {
-          timer = setTimeout(() => resolve11(null), HIGHLIGHT_MS);
-        })
-      ]);
-      clearTimeout(timer);
+      const highlighted = Promise.resolve().then(() => highlight.call(point.target)).catch(() => null);
+      shown2 = await within(highlighted, HIGHLIGHT_MS) ?? null;
     }
     const arg = {
       place: pausePlace(point.location),
       attempt: point.attempt,
       action: point.call,
       locator: null,
-      record: !!onRecord
+      record: !!onRecord,
+      ...point.failure ? { failure: true } : {}
     };
     console.log(
-      `[piwi] Paused at ${callSiteLine(point.location)} before ${point.call}: Resume, Step, Pick a locator${onRecord ? ", Record here" : ""} or Finish in the browser (Esc resumes).`
+      point.failure ? `[piwi] The test failed at ${callSiteLine(point.location)}: Resume, Pick a locator${onRecord ? " or Record here" : ""} in the browser (Esc resumes, and the test ends as it failed).` : `[piwi] Paused at ${callSiteLine(point.location)} before ${point.call}: Resume, Step, Pick a locator${onRecord ? ", Record here" : ""} or Finish in the browser (Esc resumes).`
     );
     let navigated = 0;
     for (; ; ) {
       try {
         if (ended?.aborted) return "resume";
-        await page.evaluate(showPauseBar, arg);
-        await unlessEnded(page.waitForFunction(pauseAnswered, void 0, { timeout: 0, polling: 250 }), ended);
+        await unlessEnded(page.evaluate(showPauseBar, arg), ended);
+        const answered = page.waitForFunction(pauseAnswered, void 0, { timeout: 0, polling: 250 }).then(() => null);
+        const intent = await unlessEnded(intents ? Promise.race([answered, intents.wait()]) : answered, ended);
+        intents?.answered();
+        if (ended?.aborted) return "resume";
+        const taken = await unlessEnded(page.evaluate(takePauseState), ended);
+        if (ended?.aborted) return "resume";
+        const choice = taken ?? intent ?? null;
+        const raised = intent && choice === intent ? page.bringToFront().catch(() => void 0) : null;
+        if (raised) await unlessEnded(raised, ended);
         if (ended?.aborted) return "resume";
-        const choice = await page.evaluate(takePauseState);
         navigated = 0;
         if (choice === "resume" || choice === "step" || choice === "finish") return choice;
         if (choice === "record" && onRecord) {
@@ -14464,31 +15463,290 @@ async function pauseHere(page, point, probe, onPick, onRecord, ended) {
           );
           continue;
         }
+        if ((choice === "assert" || choice === "assert-region") && onIntent) {
+          await unlessEnded(
+            onIntent(choice, ended).catch(() => void 0),
+            ended
+          );
+          continue;
+        }
         if (choice !== "pick") continue;
         const picked = await pickLocator(page, probe, null, ended).catch(() => null);
         if (picked && !ended?.aborted) await onPick(picked);
       } catch (error) {
         if (page.isClosed() || !NAVIGATED.test(String(error)) || ++navigated > MAX_NAVIGATED) throw error;
-        await page.waitForLoadState("domcontentloaded").catch(() => void 0);
+        await unlessEnded(
+          page.waitForLoadState("domcontentloaded").catch(() => void 0),
+          ended
+        );
       }
     }
   } catch {
     return "resume";
   } finally {
+    const takeDown = async () => {
+      try {
+        if (ended?.aborted) await page.evaluate(takePauseState);
+        const dispose = shown2?.dispose;
+        const hide = page.hideHighlight;
+        if (typeof dispose === "function") await dispose.call(shown2);
+        else if (typeof hide === "function") await hide.call(page);
+      } catch {
+      }
+    };
+    await within(takeDown(), TAKE_DOWN_MS);
+  }
+}
+
+// src/internal/capture/chain-locator.ts
+function argValue(page, arg) {
+  switch (arg.type) {
+    case "string":
+    case "number":
+    case "boolean":
+      return arg.value;
+    case "regex":
+      return new RegExp(arg.source, arg.flags);
+    case "object":
+      return Object.fromEntries(arg.entries.map(([key, value]) => [key, argValue(page, value)]));
+    case "chain":
+      return chainOn(page, arg.chain);
+  }
+}
+function chainOn(page, chain) {
+  let current = page;
+  for (const call of chain.calls) {
+    if (typeof current[call.method] !== "function") {
+      throw new Error(`${call.method}() cannot be called there.`);
+    }
+    current = callMethod(
+      current,
+      call.method,
+      call.args.map((arg) => argValue(page, arg))
+    );
+  }
+  if (!current || typeof current.count !== "function") {
+    throw new Error("The chain does not end on a locator.");
+  }
+  return current;
+}
+function locatorOn(page, source) {
+  const chain = tryParseLocatorChain(source);
+  if (!chain?.calls.length) return null;
+  try {
+    return chainOn(page, chain);
+  } catch {
+    return null;
+  }
+}
+
+// src/internal/capture/region-snapshot.ts
+function regionSnapshotWithoutSecrets(snapshot, secrets) {
+  const hidden = new Set(secrets.filter(Boolean));
+  const kept = [];
+  for (const line of snapshot.split("\n")) {
+    const box = /^(\s*- textbox(?: "(?:[^"\\]|\\.)*")?(?: \[[^\]]*\])*): (.*)$/.exec(line);
+    if (box && hidden.size && hidden.has(yamlScalar(box[2]))) {
+      kept.push({ line: box[1], lostChild: false });
+      continue;
+    }
+    const url = /^\s*- \/url: (.*)$/.exec(line);
+    if (url && hideSecretsInUrl(yamlScalar(url[1])) !== yamlScalar(url[1])) {
+      let parent = kept.length - 1;
+      while (parent >= 0 && indentOf(kept[parent].line) >= indentOf(line)) parent--;
+      if (parent >= 0) kept[parent].lostChild = true;
+      continue;
+    }
+    kept.push({ line, lostChild: false });
+  }
+  return kept.map(({ line, lostChild }, i) => {
+    const next = kept[i + 1];
+    const childless = !next || indentOf(next.line) <= indentOf(line);
+    return lostChild && childless && line.endsWith(":") ? line.slice(0, -1) : line;
+  }).join("\n");
+}
+function indentOf(line) {
+  return line.length - line.trimStart().length;
+}
+function yamlScalar(text) {
+  const value = text.trim();
+  if (value.startsWith('"')) {
     try {
-      if (ended?.aborted) await page.evaluate(takePauseState);
-      const dispose = shown?.dispose;
-      const hide = page.hideHighlight;
-      if (typeof dispose === "function") await dispose.call(shown);
-      else if (typeof hide === "function") await hide.call(page);
+      return String(JSON.parse(value));
     } catch {
+      return value;
     }
   }
+  if (value.startsWith("'") && value.endsWith("'") && value.length > 1) return value.slice(1, -1).replace(/''/g, "'");
+  return value;
+}
+
+// ../core/src/run-channel.ts
+var RUN_CHANNEL_ENV = "PIWI_RUN_CHANNEL";
+var RUN_HOLDS = ["failure"];
+var RUN_INTENTS = ["pick", "record", "assert", "assert-region"];
+var RUN_TAKES = [...RUN_INTENTS, "requests", "mock", "locator"];
+var RUN_INTENT_NAMES = {
+  pick: "Pick a locator",
+  record: "Record here",
+  assert: "Assert",
+  "assert-region": "Assert a region"
+};
+var MAX_KEPT_RESPONSES = 50;
+var MAX_KEPT_BODY = 256 * 1024;
+var MAX_REGION_SNAPSHOT = 1024 * 1024;
+var MAX_STOP_ERROR = 1e3;
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readJson(line) {
+  try {
+    const value = JSON.parse(line);
+    return isObject2(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function isInt(value, min) {
+  return typeof value === "number" && Number.isInteger(value) && value >= min;
+}
+function filePath2(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 4096 && !value.includes("\0");
+}
+function readPlace(value) {
+  if (!isObject2(value) || !filePath2(value.file) || !isInt(value.line, 1)) return null;
+  if (value.column === void 0) return { file: value.file, line: value.line };
+  return isInt(value.column, 1) ? { file: value.file, line: value.line, column: value.column } : null;
+}
+function isIntent(value) {
+  return RUN_INTENTS.includes(value);
+}
+function readHolds(value) {
+  if (!Array.isArray(value)) return void 0;
+  return value.length > 16 ? [] : RUN_HOLDS.filter((hold) => value.includes(hold));
+}
+function isLocatorText(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 1e3 && !/[\r\n\u2028\u2029]/.test(value);
+}
+var MAX_PLACES = 1e4;
+function parseHubToRun(line) {
+  const value = readJson(line);
+  if (!value) return null;
+  const unknown = (what) => ({ type: "unknown", what: what.slice(0, 64) });
+  switch (value.type) {
+    case "attached": {
+      const holds = readHolds(value.holds);
+      return holds ? { type: "attached", holds } : null;
+    }
+    case "breakpoints": {
+      if (!Array.isArray(value.places) || value.places.length > MAX_PLACES) return null;
+      const places = value.places.map(readPlace);
+      return places.every((p) => p !== null) ? { type: "breakpoints", places } : null;
+    }
+    case "control": {
+      const { action, stop } = value;
+      if (action === "pause") return { type: "control", action };
+      if (action === "step" || action === "resume" || action === "finish") {
+        return isInt(stop, 1) ? { type: "control", action, stop } : null;
+      }
+      return typeof action === "string" ? unknown(`control ${action}`) : null;
+    }
+    case "run-to": {
+      const place = readPlace(value.place);
+      return isInt(value.stop, 1) && place ? { type: "run-to", stop: value.stop, place } : null;
+    }
+    case "request": {
+      const { request: request3, what, stop } = value;
+      if (!isInt(request3, 1)) return null;
+      if (what === "image") return { type: "request", request: request3, what: "image" };
+      if (typeof what !== "string") return null;
+      if (!isIntent(what) && what !== "requests" && what !== "mock" && what !== "locator") {
+        return unknown(`request ${what}`);
+      }
+      if (!isInt(stop, 1)) return null;
+      if (isIntent(what) || what === "requests") return { type: "request", request: request3, what, stop };
+      if (what === "mock") return isInt(value.id, 1) ? { type: "request", request: request3, what, stop, id: value.id } : null;
+      const { locator } = value;
+      return locator === null || isLocatorText(locator) ? { type: "request", request: request3, what, stop, locator } : null;
+    }
+    default:
+      return typeof value.type === "string" && value.type ? unknown(value.type) : null;
+  }
+}
+
+// src/internal/capture/kept-responses.ts
+var keeping = null;
+var TEXT_TYPE = /^(?:text\/[\w.+-]+|application\/(?:[\w.+-]+\+)?(?:json|xml)|application\/(?:javascript|x-www-form-urlencoded|graphql))$/i;
+function mimeOf(contentType) {
+  return (contentType ?? "").split(";")[0].trim().toLowerCase();
+}
+function textOf3(body) {
+  try {
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(body);
+    return text.includes("\0") ? null : text;
+  } catch {
+    return null;
+  }
+}
+function startKeeping(now = Date.now()) {
+  keeping = { startedAt: now, kept: [], last: 0 };
+}
+function stopKeeping() {
+  keeping = null;
+}
+async function keepResponse(request3, response) {
+  const into = keeping;
+  if (!into || !response) return;
+  try {
+    const kind = request3.resourceType();
+    if (kind !== "fetch" && kind !== "xhr") return;
+    const url = hideSecretsInUrl(request3.url());
+    const method = request3.method().toUpperCase();
+    if (url.length > 8192 || !/^[A-Z]{1,16}$/.test(method)) return;
+    const headers = response.headers();
+    const type = mimeOf(headers["content-type"]);
+    if (type && !TEXT_TYPE.test(type)) return;
+    const status = response.status();
+    if (status < 100 || status > 599) return;
+    const time = Math.max(0, Math.round(Date.now() - into.startedAt));
+    const size = /^\d+$/.test(headers["content-length"] ?? "") ? Number(headers["content-length"]) : null;
+    if (size !== null && size > MAX_KEPT_BODY) return;
+    into.kept.push({ id: ++into.last, method, url, status, type, size, time, response });
+    if (into.kept.length > MAX_KEPT_RESPONSES) into.kept.splice(0, into.kept.length - MAX_KEPT_RESPONSES);
+  } catch {
+  }
+}
+function keptRequests() {
+  return (keeping?.kept ?? []).map(({ id, method, url, status, type, size, time }) => ({
+    id,
+    method,
+    url,
+    status,
+    type,
+    size,
+    time
+  }));
+}
+async function keptResponse(id) {
+  const found = keeping?.kept.find((kept) => kept.id === id);
+  if (!found) return { refusal: "The test kept no such response: it keeps the latest 50." };
+  let body;
+  try {
+    body = await internalCall(found.response, () => found.response.body());
+  } catch {
+    return {
+      refusal: "The browser no longer holds this answer's body: mock one the page received since it last loaded."
+    };
+  }
+  if (body.length > MAX_KEPT_BODY) return { refusal: "This answer is larger than 256 KB: Piwi mocks a smaller one." };
+  const text = textOf3(body);
+  if (text === null) return { refusal: "This answer is not text: Piwi mocks a text answer." };
+  return { method: found.method, url: found.url, status: found.status, type: found.type, body: text };
 }
 
 // src/internal/capture/record-handoff.ts
 var fs26 = __toESM(require("fs"));
-var net = __toESM(require("net"));
+var net3 = __toESM(require("net"));
 var path29 = __toESM(require("path"));
 
 // ../core/src/ide-recorder.ts
@@ -14504,7 +15762,7 @@ function parseRecordChannel(value) {
   const path34 = text.slice(0, hash);
   return /^[A-Za-z0-9_-]{16,}$/.test(token) && !path34.includes("\0") ? { path: path34, token } : null;
 }
-function isObject2(value) {
+function isObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseHandoffToTest(line) {
@@ -14514,7 +15772,7 @@ function parseHandoffToTest(line) {
   } catch {
     return null;
   }
-  if (!isObject2(value)) return null;
+  if (!isObject3(value)) return null;
   switch (value.type) {
     case "refused":
       return typeof value.message === "string" ? { type: "refused", message: value.message } : null;
@@ -14577,8 +15835,8 @@ async function recordFromHere(options) {
   const use = testInfo.project?.use ?? {};
   const context = page.context();
   return new Promise((resolve11) => {
-    const socket = net.connect(channel.path);
-    socket.setEncoding("utf8");
+    const socket2 = net3.connect(channel.path);
+    socket2.setEncoding("utf8");
     const answers = /* @__PURE__ */ new Map();
     let calls = 0;
     let attached = false;
@@ -14586,7 +15844,7 @@ async function recordFromHere(options) {
     let settled = false;
     let initScript;
     const send = (message) => {
-      if (!socket.destroyed) socket.write(`${JSON.stringify(message)}
+      if (!socket2.destroyed) socket2.write(`${JSON.stringify(message)}
 `);
     };
     const onPage = () => send({ type: "notice", message: NEW_TAB_NOTICE });
@@ -14636,7 +15894,7 @@ async function recordFromHere(options) {
       page.off("close", onGone);
       page.off("crash", onGone);
       ended?.removeEventListener("abort", onEnded);
-      socket.end();
+      socket2.end();
       resolve11(recording ? null : said);
     };
     const relayed = (source, payload) => new Promise((answer) => {
@@ -14676,7 +15934,7 @@ async function recordFromHere(options) {
       context.on("page", onPage);
       send({ type: "loaded" });
     };
-    socket.on("connect", () => {
+    socket2.on("connect", () => {
       attached = true;
       send({
         type: "attach",
@@ -14685,10 +15943,11 @@ async function recordFromHere(options) {
         line: place.line,
         reason: options.reason,
         testIdAttribute: typeof use.testIdAttribute === "string" ? use.testIdAttribute : null,
-        baseURL: typeof use.baseURL === "string" ? use.baseURL : null
+        baseURL: typeof use.baseURL === "string" ? use.baseURL : null,
+        ...options.mode === "check" ? { mode: "check", stop: options.stop ?? null } : {}
       });
     });
-    socket.on(
+    socket2.on(
       "data",
       lineReader(
         (line) => {
@@ -14721,11 +15980,516 @@ async function recordFromHere(options) {
         () => finish("the editor sent a message too long to read.")
       )
     );
-    socket.on("error", (error) => finish(`the editor could not be reached: ${error.message}`));
-    socket.on("close", () => finish("the editor closed the recording."));
+    socket2.on("error", (error) => finish(`the editor could not be reached: ${error.message}`));
+    socket2.on("close", () => finish("the editor closed the recording."));
   });
 }
 
+// src/internal/capture/run-channel.ts
+var net4 = __toESM(require("net"));
+var CONNECT_MS = 2e3;
+var BAR_HIDDEN = "#__piwi-pause-bar { display: none !important; }";
+var OUTLINE_STYLE = "outline: 2px dashed #a78bfa; outline-offset: 2px; background: rgba(167, 139, 250, 0.15);";
+var WENT_ON = "The test went on.";
+var socket = null;
+var control = null;
+var shown = /* @__PURE__ */ new Set();
+var stops = 0;
+var held = null;
+var outline = null;
+var counting = Promise.resolve();
+async function openRunChannel(worker, handlers, env = process.env) {
+  const channel = parseRecordChannel(env[RUN_CHANNEL_ENV]);
+  const ref = env[PIWI_ORIGIN_ENV.ref];
+  if (socket || !channel || !ref || !/^[\w-]{1,64}$/.test(ref)) return false;
+  const opening = net4.connect(channel.path);
+  opening.setEncoding("utf8");
+  const opened = await new Promise((resolve11) => {
+    const timer = setTimeout(() => resolve11(false), CONNECT_MS);
+    opening.once("connect", () => {
+      clearTimeout(timer);
+      resolve11(true);
+    });
+    opening.once("error", () => {
+      clearTimeout(timer);
+      resolve11(false);
+    });
+  });
+  if (!opened || opening.destroyed) {
+    opening.destroy();
+    return false;
+  }
+  socket = opening;
+  control = handlers;
+  shown = /* @__PURE__ */ new Set();
+  opening.unref();
+  opening.on(
+    "data",
+    lineReader(
+      (line) => onMessage(parseHubToRun(line)),
+      () => opening.destroy()
+    )
+  );
+  opening.on("error", () => opening.destroy());
+  opening.on("close", () => {
+    if (socket === opening) socket = null;
+    if (!held || held.bar) return;
+    console.log("[piwi] The connection to the editor closed: the test goes on.");
+    held.answer("resume");
+  });
+  tellHub({
+    type: "run-attach",
+    token: channel.token,
+    ref,
+    cwd: process.cwd(),
+    workerIndex: worker.workerIndex,
+    parallelIndex: worker.parallelIndex,
+    pid: process.pid,
+    playwright: worker.config.version,
+    reporter: getReporterVersion(),
+    takes: [...RUN_TAKES],
+    holds: [...RUN_HOLDS]
+  });
+  return true;
+}
+function editorShows(what) {
+  return runChannelOpen() && shown.has(what);
+}
+var HIDDEN_ENV = [RUN_CHANNEL_ENV, PIWI_LOCAL_DEBUG_ENV.editorSend];
+var hiddenEditorSend;
+function hideRunChannel(env = process.env) {
+  const hidden = HIDDEN_ENV.flatMap((name) => {
+    const value = env[name];
+    return value === void 0 ? [] : [{ name, value }];
+  });
+  for (const { name } of hidden) delete env[name];
+  hiddenEditorSend = hidden.find(({ name }) => name === PIWI_LOCAL_DEBUG_ENV.editorSend)?.value;
+  return () => {
+    for (const { name, value } of hidden) env[name] = value;
+    hiddenEditorSend = void 0;
+  };
+}
+function editorSendAddress(env = process.env) {
+  return env[PIWI_LOCAL_DEBUG_ENV.editorSend] ?? hiddenEditorSend;
+}
+function closeRunChannel() {
+  socket?.end();
+  socket = null;
+  control = null;
+}
+function runChannelOpen() {
+  return !!socket && !socket.destroyed;
+}
+function tellHub(message) {
+  if (socket && !socket.destroyed) socket.write(`${JSON.stringify(message)}
+`);
+}
+function holdStop(stop, onAnswer) {
+  const id = ++stops;
+  let answered = false;
+  const holding = {
+    stop: id,
+    page: stop.page,
+    bar: stop.bar,
+    answer: (choice) => {
+      if (answered) return;
+      answered = true;
+      onAnswer(choice);
+    },
+    intent: (what) => answered ? { ok: false, message: WENT_ON } : stop.intent?.(what) ?? {
+      ok: false,
+      message: `${RUN_INTENT_NAMES[what]} needs the pause bar in the test's window, and this stop shows none: run the test headed.`
+    }
+  };
+  held = holding;
+  tellHub({
+    type: "stopped",
+    stop: id,
+    reason: stop.reason,
+    title: stop.title,
+    place: stop.place,
+    locator: stop.locator,
+    bar: stop.bar,
+    ...stop.error ? { error: stop.error } : {}
+  });
+  if (!runChannelOpen() && !stop.bar) holding.answer("resume");
+  return {
+    stop: id,
+    release: async () => {
+      answered = true;
+      if (held === holding) held = null;
+      await counting;
+      if (outline?.stop === id) await removeOutline();
+      tellHub({ type: "running", stop: id });
+    }
+  };
+}
+async function removeOutline() {
+  const shown2 = outline;
+  outline = null;
+  await shown2?.remove().catch(() => void 0);
+}
+async function countLocator(holding, source) {
+  await removeOutline();
+  if (source === null) return { ok: true, message: "The outline is gone.", count: null };
+  const page = holding.page;
+  if (!page || page.isClosed()) return { ok: false, message: "This stop has no page to count on.", count: null };
+  const locator = locatorOn(page, source);
+  if (!locator) return { ok: false, message: `${source} is not a locator Piwi can build.`, count: null };
+  try {
+    const count = await internalCall(page, () => locator.count());
+    if (holding.bar && count > 0 && held === holding) {
+      const shown2 = await internalCall(page, () => locator.highlight({ style: OUTLINE_STYLE }));
+      const dispose = shown2?.dispose;
+      outline = {
+        stop: holding.stop,
+        remove: () => internalCall(page, () => typeof dispose === "function" ? dispose.call(shown2) : page.hideHighlight())
+      };
+    }
+    return {
+      ok: true,
+      message: count === 0 ? "No element matches." : count === 1 ? "1 element matches." : `${count} elements match.`,
+      count
+    };
+  } catch (error) {
+    return { ok: false, message: `The locator could not be counted: ${errorMessage(error)}`, count: null };
+  }
+}
+function onMessage(message) {
+  if (!message) return;
+  switch (message.type) {
+    case "attached":
+      shown = new Set(message.holds);
+      return;
+    case "breakpoints":
+      control?.breakpoints(message.places);
+      return;
+    case "control":
+      if (message.action === "pause") {
+        if (!held) control?.pause();
+      } else if (held?.stop === message.stop) held.answer(message.action);
+      return;
+    case "run-to":
+      if (held?.stop !== message.stop) return;
+      control?.runTo(message.place);
+      held.answer("resume");
+      return;
+    case "request": {
+      const { request: request3 } = message;
+      const at = message.what !== "image" && held?.stop === message.stop ? held : null;
+      switch (message.what) {
+        case "image":
+          void imageOf(held?.page ?? null).then((value) => tellHub({ type: "answer", request: request3, what: "image", value }));
+          return;
+        case "requests": {
+          const requests = at ? keptRequests() : [];
+          const said = !at ? WENT_ON : requests.length ? `The test kept ${requests.length === 1 ? "1 response" : `${requests.length} responses`}.` : "The test kept no response yet: Piwi keeps the text answers of its fetch and XHR requests.";
+          tellHub({ type: "answer", request: request3, what: "requests", value: { ok: !!at, message: said, requests } });
+          return;
+        }
+        case "mock": {
+          void (at ? keptResponse(message.id) : Promise.resolve({ refusal: WENT_ON })).then((found) => {
+            const value = "refusal" in found ? { ok: false, message: found.refusal, response: null } : { ok: true, message: `${found.method} ${found.url}`, response: found };
+            tellHub({ type: "answer", request: request3, what: "mock", value });
+          });
+          return;
+        }
+        case "locator": {
+          const counted = at ? counting.then(
+            () => held === at ? countLocator(at, message.locator) : { ok: false, message: WENT_ON, count: null }
+          ) : Promise.resolve({ ok: false, message: WENT_ON, count: null });
+          counting = counted.catch(() => void 0);
+          void counted.then((value) => tellHub({ type: "answer", request: request3, what: "locator", value }));
+          return;
+        }
+        default: {
+          const value = at ? at.intent(message.what) : { ok: false, message: WENT_ON };
+          tellHub({ type: "answer", request: request3, what: message.what, value });
+          return;
+        }
+      }
+    }
+    case "unknown":
+      tellHub({
+        type: "notice",
+        message: `@piwitests/reporter ${getReporterVersion()} does not take the editor's ${message.what}: update it.`
+      });
+  }
+}
+async function imageOf(page) {
+  if (!page || page.isClosed()) return null;
+  try {
+    const shot = await internalCall(
+      page,
+      () => page.screenshot({ type: "jpeg", quality: 60, style: BAR_HIDDEN, timeout: 5e3 })
+    );
+    return { mime: "image/jpeg", data: shot.toString("base64") };
+  } catch {
+    return null;
+  }
+}
+
+// src/internal/capture/css-coverage.ts
+var crypto8 = __toESM(require("crypto"));
+var fs27 = __toESM(require("fs"));
+
+// ../core/src/css-rules.ts
+var GROUPING = /* @__PURE__ */ new Set(["media", "supports", "layer", "container", "scope", "starting-style", "document"]);
+function parseCssRules(text) {
+  const rules = [];
+  const open = [];
+  let preludeStart = -1;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (c === "/" && text[i + 1] === "*") {
+      const end = text.indexOf("*/", i + 2);
+      i = end < 0 ? text.length : end + 1;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      if (preludeStart < 0) preludeStart = i;
+      for (i++; i < text.length && text[i] !== c && text[i] !== "\n"; i++) if (text[i] === "\\") i++;
+      continue;
+    }
+    if (c === "\\") {
+      if (preludeStart < 0) preludeStart = i;
+      i++;
+      continue;
+    }
+    if ((c === "u" || c === "U") && /^url\(/i.test(text.slice(i, i + 4)) && !/[\w-]/.test(text[i - 1] ?? "")) {
+      let j = i + 4;
+      while (j < text.length && /\s/.test(text[j])) j++;
+      if (text[j] !== '"' && text[j] !== "'") {
+        if (preludeStart < 0) preludeStart = i;
+        for (; j < text.length && text[j] !== ")"; j++) if (text[j] === "\\") j++;
+        i = j;
+        continue;
+      }
+    }
+    if (text.startsWith("<!--", i) || text.startsWith("-->", i)) {
+      i += text.startsWith("<!--", i) ? 3 : 2;
+      continue;
+    }
+    if (c === "{") {
+      const start = preludeStart < 0 ? i : preludeStart;
+      const atRule = /^@([\w-]+)/.exec(text.slice(start, i));
+      const parent = open[open.length - 1];
+      const kind = atRule ? GROUPING.has(atRule[1].toLowerCase()) ? "group" : "other" : parent?.kind === "other" ? "other" : "style";
+      open.push({ kind, start, open: i });
+      preludeStart = -1;
+      continue;
+    }
+    if (c === "}") {
+      const block = open.pop();
+      if (block && block.kind !== "other")
+        rules.push({ kind: block.kind, start: block.start, open: block.open, end: i + 1 });
+      preludeStart = -1;
+      continue;
+    }
+    if (c === ";") {
+      preludeStart = -1;
+      continue;
+    }
+    if (preludeStart < 0 && !/\s/.test(c)) preludeStart = i;
+  }
+  for (const block of open) {
+    if (block.kind !== "other")
+      rules.push({ kind: block.kind, start: block.start, open: block.open, end: text.length });
+  }
+  return rules.sort((a, b) => a.start - b.start);
+}
+function usedCssRules(rules, used) {
+  const styleAt = /* @__PURE__ */ new Map();
+  const groups = [];
+  for (const rule of rules) {
+    if (rule.kind === "style") styleAt.set(rule.start, rule);
+    else groups.push(rule);
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const range of used) {
+    const style = styleAt.get(range.startOffset);
+    if (style) {
+      out.set(`${style.start}`, [style.start, style.end]);
+      continue;
+    }
+    const group = groups.find((rule) => rule.start <= range.startOffset && range.startOffset <= rule.open);
+    if (group) out.set(`${group.start}`, [group.start, group.start + 1]);
+  }
+  return [...out.values()].sort((a, b) => a[0] - b[0]);
+}
+function allCssRules(rules) {
+  return rules.map((rule) => rule.kind === "style" ? [rule.start, rule.end] : [rule.start, rule.start + 1]);
+}
+function cssRuleLines(text, offsets, options = {}) {
+  const starts = lineStarts(text);
+  const lineOffset = options.lineOffset ?? 0;
+  const out = /* @__PURE__ */ new Map();
+  const add2 = (source, range) => {
+    const ranges = out.get(source);
+    if (ranges) ranges.push(range);
+    else out.set(source, [range]);
+  };
+  for (const [startOffset, endOffset] of offsets) {
+    const start = offsetToPosition(starts, startOffset);
+    const end = offsetToPosition(starts, Math.max(startOffset, endOffset - 1));
+    if (!options.lookup) {
+      add2(-1, [start.line + lineOffset + 1, end.line + lineOffset + 1]);
+      continue;
+    }
+    const first = options.lookup.originalAt(start.line, start.column);
+    if (!first) continue;
+    const last = options.lookup.originalAt(end.line, end.column);
+    const lastLine = last && last.source === first.source && last.line >= first.line ? last.line : first.line;
+    add2(first.source, [first.line + 1, lastLine + 1]);
+  }
+  return out;
+}
+
+// src/internal/capture/css-coverage.ts
+var STYLE_SOURCES = /\.(?:css|scss|sass|less|styl|stylus|pcss|postcss|vue|svelte|astro|html?)$/i;
+var BUILD_DIRS2 = /(?:^|\/)(?:dist|build|out|\.output|\.next|\.nuxt|\.svelte-kit)\//;
+var resolutions = /* @__PURE__ */ new Map();
+var MAX_CACHED_SHEETS = 2e3;
+function fileForStyleUrl(url, roots) {
+  let pathname;
+  try {
+    const parsed2 = new URL(url);
+    if (parsed2.protocol !== "http:" && parsed2.protocol !== "https:" && parsed2.protocol !== "file:") return null;
+    pathname = parsed2.pathname;
+  } catch {
+    return null;
+  }
+  return sourceFile(decodeURIComponent(pathname), roots);
+}
+function sourceFile(source, roots) {
+  const bare = source.replace(/[?#].*$/, "");
+  if (!STYLE_SOURCES.test(bare) || /(?:^|\/)node_modules\//.test(bare)) return null;
+  const file = resolveSourcePath(bare, roots);
+  if (!file || BUILD_DIRS2.test(file.replace(/\\/g, "/")) || /(?:^|[\\/])node_modules[\\/]/.test(file)) return null;
+  return file;
+}
+function styleBlockLine(file, index) {
+  let text;
+  try {
+    text = fs27.readFileSync(file, "utf-8");
+  } catch {
+    return 0;
+  }
+  const blocks = [...text.matchAll(/^<style\b[^>]*>/gim)];
+  const block = blocks[index];
+  if (!block) return 0;
+  return text.slice(0, block.index + block[0].length).split("\n").length - 1;
+}
+async function sheetMap(sheet, text, fetchMap) {
+  const ref = sourceMappingUrl(text) ?? sheet.sourceMapURL ?? null;
+  if (!ref) return null;
+  let raw;
+  if (ref.startsWith("data:")) raw = decodeDataUrl(ref);
+  else {
+    try {
+      raw = await fetchMap(new URL(ref, sheet.sourceURL).href);
+    } catch {
+      raw = null;
+    }
+  }
+  if (!raw) return null;
+  try {
+    return decodeSourceMap(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+function sameLines(text, rules, file, lineOffset) {
+  let source;
+  try {
+    source = fs27.readFileSync(file, "utf-8");
+  } catch {
+    return false;
+  }
+  const fileLines = source.split(/\r?\n/);
+  const sheetLineStarts = [0];
+  for (let i = 0; i < text.length; i++) if (text[i] === "\n") sheetLineStarts.push(i + 1);
+  let low = 0;
+  for (const rule of rules) {
+    while (low + 1 < sheetLineStarts.length && sheetLineStarts[low + 1] <= rule.start) low++;
+    const head = text.slice(rule.start, rule.open).split("\n")[0].trim();
+    if (head && !(fileLines[low + lineOffset] ?? "").includes(head)) return false;
+  }
+  return true;
+}
+async function resolveSheet(sheet, text, dirs, fetchMap) {
+  const lookup = await sheetMap(sheet, text, fetchMap);
+  const rules = parseCssRules(text);
+  if (lookup) {
+    const sources = lookup.sources.map((source) => {
+      const direct = sourceFile(source, dirs);
+      if (direct) return direct;
+      try {
+        return /^[a-z][\w+.-]*:/i.test(source) ? null : fileForStyleUrl(new URL(source, sheet.sourceURL).href, dirs);
+      } catch {
+        return null;
+      }
+    });
+    return { rules, lookup, file: null, lineOffset: 0, sources, exact: true };
+  }
+  if (sheet.devId) {
+    const file2 = sourceFile(sheet.devId, dirs);
+    if (!file2) return null;
+    const index = /[?&]index=(\d+)/.exec(sheet.devId);
+    const lineOffset2 = /\.(?:vue|svelte|astro)$/i.test(file2) && index ? styleBlockLine(file2, Number(index[1])) : 0;
+    return { rules, lookup: null, file: file2, lineOffset: lineOffset2, sources: [], exact: sameLines(text, rules, file2, lineOffset2) };
+  }
+  const file = fileForStyleUrl(sheet.sourceURL, dirs);
+  if (!file) return null;
+  const lineOffset = sheet.isInline ? sheet.startLine : 0;
+  return { rules, lookup: null, file, lineOffset, sources: [], exact: sameLines(text, rules, file, lineOffset) };
+}
+function cachedResolution(sheet, text, dirs, fetchMap) {
+  const version = crypto8.createHash("sha1").update(text).digest("hex");
+  const key = [sheet.devId ?? sheet.sourceURL, sheet.isInline ? sheet.startLine : "", dirs.join("\0"), version].join(
+    " "
+  );
+  let pending = resolutions.get(key);
+  if (!pending) {
+    pending = resolveSheet(sheet, text, dirs, fetchMap).catch(() => null);
+    resolutions.set(key, pending);
+    if (resolutions.size > MAX_CACHED_SHEETS) resolutions.delete(resolutions.keys().next().value);
+  }
+  return pending;
+}
+function add(into, file, ranges, repoRoot, fileLevel = false) {
+  if (ranges.length === 0 && !fileLevel) return;
+  const key = relativeToRepo(file, repoRoot);
+  into.set(key, [...into.get(key) ?? [], ...ranges]);
+}
+async function resolveCssCoverage(sheets, roots, fetchMap) {
+  const reached = /* @__PURE__ */ new Map();
+  const known = /* @__PURE__ */ new Map();
+  for (const sheet of sheets) {
+    if (sheet.text === void 0) continue;
+    const dirs = scriptRoots(roots, sheet.sourceURL, sheet.pageUrl);
+    const resolution = await cachedResolution(sheet, sheet.text, dirs, fetchMap);
+    if (!resolution) continue;
+    const used = usedCssRules(resolution.rules, [...sheet.used.values()]);
+    if (!resolution.exact) {
+      if (resolution.file && used.length > 0) add(reached, resolution.file, [], roots.repoRoot, true);
+      continue;
+    }
+    const options = { lookup: resolution.lookup, lineOffset: resolution.lineOffset };
+    const fileOf2 = (source) => source === -1 ? resolution.file : resolution.sources[source] ?? null;
+    const matched = cssRuleLines(sheet.text, used, options);
+    for (const [source, ranges] of matched) {
+      const file = fileOf2(source);
+      if (file) add(reached, file, ranges, roots.repoRoot);
+    }
+    for (const [source, ranges] of cssRuleLines(sheet.text, allCssRules(resolution.rules), options)) {
+      const file = fileOf2(source);
+      if (file) add(known, file, ranges, roots.repoRoot);
+    }
+  }
+  return { reached, known };
+}
+
 // src/internal/capture/page-interaction.ts
 function readPageInteraction() {
   const doc = globalThis.document;
@@ -15024,21 +16788,29 @@ function createSink() {
     locatorCalls: /* @__PURE__ */ new Map(),
     stops: [],
     shownStops: /* @__PURE__ */ new Map(),
+    failureHeld: false,
+    frozenAt: null,
+    stopEnds: 0,
+    ending: false,
     released: [],
     releasedRequests: /* @__PURE__ */ new Set(),
     onReleasedRequestsEnded: null,
     releasedQuietSince: 0,
+    releasedUntil: null,
     locatorPages: new LocatorPageLog(),
-    codeReach: { sessions: /* @__PURE__ */ new Map(), files: /* @__PURE__ */ new Map(), known: /* @__PURE__ */ new Map() },
+    codeReach: { sessions: /* @__PURE__ */ new Map(), files: /* @__PURE__ */ new Map(), known: /* @__PURE__ */ new Map(), cssFiles: /* @__PURE__ */ new Map(), cssKnown: /* @__PURE__ */ new Map() },
     serverCoverage: /* @__PURE__ */ new Map(),
     baseURL: null
   };
 }
 var MAX_CODE_REACH_PAGES = 16;
 var CODE_REACH_START_WAIT_MS = 2e3;
+function pageCoverageInWorker() {
+  return browserCoverageInWorker() || cssCoverageInWorker();
+}
 function maybeStartCodeReach(page, alreadyOpen = false) {
   const sink = currentSink;
-  if (!sink || !browserCoverageInWorker() || isPageClosed(page)) return Promise.resolve(false);
+  if (!sink || !pageCoverageInWorker() || isPageClosed(page)) return Promise.resolve(false);
   const known = sink.codeReach.sessions.get(page);
   if (known) return known.started;
   if (alreadyOpen) {
@@ -15051,7 +16823,7 @@ function maybeStartCodeReach(page, alreadyOpen = false) {
   return started;
 }
 async function startCodeReachOnOpenPages() {
-  if (!browserCoverageInWorker() || OPEN_PAGES.size === 0) return;
+  if (!pageCoverageInWorker() || OPEN_PAGES.size === 0) return;
   const started = Promise.all([...OPEN_PAGES].map((page) => maybeStartCodeReach(page, true)));
   await Promise.race([started, new Promise((resolve11) => setTimeout(resolve11, CODE_REACH_START_WAIT_MS).unref())]);
 }
@@ -15094,22 +16866,28 @@ async function stopSinkCodeReach(sink, closing) {
 async function stopPageCodeReach(sink, page, session, roots) {
   try {
     if (!await session.started || isPageClosed(page)) return;
-    const entries = await stopCodeReach(page);
-    if (!entries) return;
-    const { reached, known } = await resolveCodeReachFunctions(entries, roots, pageMapFetcher(page), page.url(), {
+    const { scripts, sheets } = await stopPageCoverage(page);
+    const fetchMap = pageMapFetcher(page);
+    const append = (into, from) => {
+      for (const [file, ranges] of from) into.set(file, [...into.get(file) ?? [], ...ranges]);
+    };
+    if (sheets.length > 0) {
+      const rules = await resolveCssCoverage(sheets, roots, fetchMap);
+      append(sink.codeReach.cssFiles, rules.reached);
+      append(sink.codeReach.cssKnown, rules.known);
+    }
+    if (!scripts) return;
+    const { reached, known } = await resolveCodeReachFunctions(scripts, roots, fetchMap, page.url(), {
       known: browserFunctionsInWorker()
     });
-    for (const [file, functions] of reached) {
-      sink.codeReach.files.set(file, [...sink.codeReach.files.get(file) ?? [], ...functions]);
-    }
-    for (const [file, functions] of known) {
-      sink.codeReach.known.set(file, [...sink.codeReach.known.get(file) ?? [], ...functions]);
-    }
+    append(sink.codeReach.files, reached);
+    append(sink.codeReach.known, known);
   } catch {
   }
 }
 var currentSink = null;
 var KNOWN_FUNCTIONS_SENT = /* @__PURE__ */ new Map();
+var KNOWN_CSS_RULES_SENT = /* @__PURE__ */ new Map();
 var PENDING_PROBES = /* @__PURE__ */ new Set();
 async function drainPendingProbes(capMs) {
   if (PENDING_PROBES.size === 0) return;
@@ -15122,6 +16900,25 @@ async function drainPendingProbes(capMs) {
   ]);
   clearTimeout(cap);
 }
+async function settleBeforeClose(closing) {
+  const drained = drainPendingProbes(1e3);
+  const sink = currentSink;
+  if (sink) {
+    await endShownStops(sink, "closed", closing);
+    await awaitReleasedCalls(sink);
+    await stashPageState(sink, closing);
+  }
+  await drained;
+  if (sink) {
+    await maybeOpenPicker(sink, closing);
+    await stopSinkCodeReach(sink, closing);
+  }
+}
+async function settleContextClose(context) {
+  CLOSING_CONTEXTS.add(context);
+  await settleBeforeClose({ context });
+  if (contextDebugger(context)?.pausedDetails()) await steerDebugger(context, "resume");
+}
 function isPageClosed(page) {
   try {
     return typeof page.isClosed === "function" ? page.isClosed() : false;
@@ -15244,7 +17041,7 @@ function buildPageState(raw, cookies, interaction) {
 }
 async function readPageState(page) {
   try {
-    const raw = await page.evaluate(() => {
+    const readRaw = page.evaluate(() => {
       const listStorage = (s) => {
         const out = [];
         try {
@@ -15270,14 +17067,16 @@ async function readPageState(page) {
         sessionStorage: listStorage(globalThis.sessionStorage)
       };
     });
+    const readCookies = (async () => {
+      try {
+        return await pageContext(page)?.cookies() ?? null;
+      } catch {
+        return null;
+      }
+    })();
+    const readInteraction = page.evaluate(readPageInteraction).catch(() => null);
+    const [raw, cookies, interaction] = await Promise.all([readRaw, readCookies, readInteraction]);
     if (!raw) return null;
-    let cookies = null;
-    try {
-      cookies = await pageContext(page)?.cookies() ?? null;
-    } catch {
-      cookies = null;
-    }
-    const interaction = await page.evaluate(readPageInteraction).catch(() => null);
     return buildPageState(raw, cookies, interaction);
   } catch {
     return null;
@@ -15341,7 +17140,7 @@ async function recordPageWindow(sink, page) {
 }
 async function stashPageState(sink, closing) {
   const page = sink.lastActivePage;
-  if (!page || isPageClosed(page)) return;
+  if (!page || isPageClosed(page) || sink.frozenAt !== null) return;
   const belongsToClosing = closing.page === page || closing.context !== void 0 && pageContext(page) === closing.context;
   if (!belongsToClosing) return;
   await internalCall(page, () => readPageBeforeClose(sink, page));
@@ -15353,13 +17152,12 @@ async function readBlankPage(page) {
   return aria != null && aria.trim() === "";
 }
 async function readPageBeforeClose(sink, page) {
-  const vitals = await readWebVitals(page);
+  const readBlank = sink.probeItem?.level === "server" ? readBlankPage(page).catch(() => null) : null;
+  const readState = process.env.PIWI_CAPTURE_PAGE_STATE !== "false" ? Promise.resolve(readBlank).then(() => readPageState(page)) : null;
+  const [vitals, blankPage, pageState] = await Promise.all([readWebVitals(page), readBlank, readState]);
   if (vitals) sink.stashedWebVitals = vitals;
-  if (sink.probeItem?.level === "server") sink.probeBlankPage = await readBlankPage(page);
-  if (process.env.PIWI_CAPTURE_PAGE_STATE !== "false") {
-    const pageState = await readPageState(page);
-    if (pageState) sink.stashedPageState = pageState;
-  }
+  if (blankPage !== null) sink.probeBlankPage = blankPage;
+  if (pageState) sink.stashedPageState = pageState;
   const status = sink.testInfo?.status;
   const sampleAria = async () => {
     const root = page.locator(":root");
@@ -15553,16 +17351,35 @@ function locatorSource(target, method, args) {
   return renderFailing({ method, args });
 }
 var PAGE_PAUSES = /* @__PURE__ */ new WeakMap();
+var CLOSING_CONTEXTS = /* @__PURE__ */ new WeakSet();
+var CLOSING_PAGES = /* @__PURE__ */ new WeakMap();
 var PLAYWRIGHT_PAUSES = /* @__PURE__ */ new WeakMap();
-async function armBreakpoints(contexts) {
+function stopPageOf(context, call, paused) {
+  const named = [call?.page, paused].find((page) => !!page && pageContext(page) === context);
+  if (named) return { page: named };
+  const open = openPages(context);
+  return open.length === 1 ? { page: open[0] } : { among: open };
+}
+function openPages(context) {
+  return context.pages().filter((page) => !isPageClosed(page));
+}
+function stopPages(of) {
+  return "page" in of ? [of.page] : of.among;
+}
+function stopCanShow(context, of) {
+  if (CLOSING_CONTEXTS.has(context)) return false;
+  return !stopPages(of).some((page) => isPageClosed(page) || CLOSING_PAGES.has(page));
+}
+async function armStops(contexts) {
   const state = currentSink?.pause;
-  if (!state || state.finished || state.set.size === 0) return;
+  if (!state || !wantsStops(state)) return;
   await Promise.all(
     [...contexts].map(
       (context) => context && watchStops(context, onDebuggerStop) ? steerDebugger(context, "pause") : void 0
     )
   );
 }
+var stopTurn = Promise.resolve();
 function onDebuggerStop(context) {
   const details = contextDebugger(context)?.pausedDetails();
   if (!details || PLAYWRIGHT_PAUSES.has(context)) return;
@@ -15573,13 +17390,38 @@ function onDebuggerStop(context) {
     try {
       if (!sink || !state) return;
       const callSite = stopSite(sink, details.location);
+      const call = callSite ? sink.locatorCalls.get(callSiteLine(callSite)) : void 0;
       const pagePause = PAGE_PAUSES.get(context);
+      const asked = askedOnce(state);
       const decided = pagePause ? { show: "page-pause" } : atStop(state, callSite);
       if ("go" in decided) {
         how = decided.go;
         return;
       }
-      how = goOn(state, await showStop(sink, context, details.title, callSite ?? pagePause, decided.show));
+      if (pagePause) stopShown(state);
+      if (sink.ending || CLOSING_CONTEXTS.has(context)) {
+        askAgain(state, asked);
+        how = goOn(state, sink.ending ? endedWaiting(sink, call) : void 0);
+        return;
+      }
+      const of = stopPageOf(context, call, pagePause?.page);
+      const ends = sink.stopEnds;
+      const shown2 = stopTurn.then(async () => {
+        const ended = currentSink !== sink || sink.ending || sink.stopEnds !== ends;
+        const gone = decided.show === "breakpoint" && !atBreakpoint(state, callSite);
+        if (!ended && !gone && stopCanShow(context, of)) {
+          const location = callSite ?? pagePause.location;
+          const answer = await showStop(sink, context, details.title, location, decided.show, call, of);
+          if (answer !== void 0) return answer;
+        }
+        askAgain(state, asked);
+        if (ended) return endedWaiting(sink, call);
+        const closing = stopPages(of).flatMap((page) => CLOSING_PAGES.get(page) ?? []);
+        await settledWithin(closing, END_STOP_MS);
+        return void 0;
+      });
+      stopTurn = shown2.catch(() => void 0);
+      how = goOn(state, await shown2);
     } catch {
       if (state) how = goOn(state);
     } finally {
@@ -15587,22 +17429,30 @@ function onDebuggerStop(context) {
     }
   })();
 }
+function endedWaiting(sink, call) {
+  releaseCall(sink, call?.settled ?? Promise.resolve());
+  return "finish";
+}
 function stopSite(sink, location) {
   if (path30.dirname(path30.resolve(location.file)) !== __dirname) return stopCallSite(location);
   return inFlightCallSite([...sink.locatorCalls.values()].map((call) => call.location));
 }
-function stopPage(sink, context, call) {
-  for (const page of [call?.page, sink.lastActivePage]) {
-    if (page && !isPageClosed(page) && pageContext(page) === context) return page;
-  }
-  const open = context.pages().filter((page) => !isPageClosed(page));
+function stopBarPage(sink, context, of) {
+  if ("page" in of) return of.page;
+  const last = sink.lastActivePage;
+  if (last && !isPageClosed(last) && pageContext(last) === context) return last;
+  const open = openPages(context);
   return open[open.length - 1] ?? null;
 }
-async function showStop(sink, context, title, location, reason) {
+async function showStop(sink, context, title, location, reason, call, of, failure = null) {
   const testInfo = sink.testInfo;
-  const call = sink.locatorCalls.get(callSiteLine(location));
-  const page = stopPage(sink, context, call);
-  if (!testInfo || !page) return void 0;
+  const page = stopBarPage(sink, context, of);
+  const guessed = !("page" in of);
+  if (!testInfo) return void 0;
+  const bar = !!page && testInfo.project?.use?.headless === false;
+  const place = runChannelOpen() ? callSitePlace(location) : null;
+  if (!bar && !place) return void 0;
+  const failing = failure?.failed ?? null;
   const onPick = async (picked) => {
     if (call) {
       call.picked = true;
@@ -15613,16 +17463,57 @@ async function showStop(sink, context, title, location, reason) {
         ...picked
       });
       sink.probedLocations.add(call.location);
+    } else if (failing) {
+      const pick = {
+        failing: { method: failing.method, args: failing.args, rendered: renderFailing(failing), location },
+        ...picked
+      };
+      sink.userPick = pick;
+      applyPickToSnapshots(sink.capturedLocators, pick);
     }
     console.log(`[piwi] Locator picked at ${callSiteLine(location)}: ${picked.picked.locator}`);
-    await postPickToEditor(process.env[PIWI_LOCAL_DEBUG_ENV.editorSend], pickPayload(picked.picked.locator, location));
+    await postPickToEditor(editorSendAddress(), pickPayload(picked.picked.locator, location));
   };
+  const handoffReason = reason === "page-pause" ? "pause" : "breakpoint";
+  const onRecord = bar && page ? recorderAt(page, testInfo, location, handoffReason) : void 0;
+  const intents = bar && page ? new BarIntents() : null;
   const record = { title, location, reason, startedAt: Date.now(), duration: 0 };
   sink.stops.push(record);
   const end = new AbortController();
-  const shown = withTestTimeoutHeld(
-    testInfo,
-    () => internalCall(
+  const over = new AbortController();
+  end.signal.addEventListener("abort", () => over.abort(), { once: true });
+  let fromEditor;
+  const held2 = place ? holdStop(
+    {
+      reason,
+      title,
+      place,
+      locator: call ? locatorSource(call.target, call.origin.method, call.origin.args) : failing ? renderFailing(failing) : null,
+      bar,
+      page: guessed ? null : page,
+      ...failure?.error ? { error: failure.error } : {},
+      intent: intents ? (what) => intentAt(intents, what, {
+        record: !!onRecord,
+        guessed,
+        // A failure's stop is held in the teardown it ends with.
+        holds: () => !over.signal.aborted && (!!failure || !sink.ending && stopCanShow(context, of))
+      }) : void 0
+    },
+    (answer2) => {
+      fromEditor = answer2;
+      over.abort();
+    }
+  ) : null;
+  const onIntent = bar && page && held2 ? (intent, ended) => intent === "assert" ? checkAt(page, testInfo, location, handoffReason, held2.stop, ended) : regionAt(page, location, held2.stop, ended) : void 0;
+  const shown2 = withTestTimeoutHeld(testInfo, async () => {
+    if (!bar || !page) {
+      console.log(
+        failure ? `[piwi] The test failed at ${callSiteLine(location)}: Resume in the editor lets it end as it failed.` : `[piwi] Paused at ${callSiteLine(location)} before ${title}: Resume, Step or Finish in the editor.`
+      );
+      await abortion(over.signal);
+      return "resume";
+    }
+    return internalCall(
       page,
       () => pauseHere(
         page,
@@ -15630,45 +17521,221 @@ async function showStop(sink, context, title, location, reason) {
           location,
           call: title,
           attempt: testInfo.retry > 0 ? testInfo.retry + 1 : null,
-          target: call?.page === page ? call.target : null
+          target: call?.page === page ? call.target : null,
+          ...failure ? { failure: true } : {}
         },
         { fn: probeElementAttrs, arg: CAPTURED_ATTRS_ARG },
         onPick,
-        recorderAt(page, testInfo, location, reason === "page-pause" ? "pause" : "breakpoint"),
-        end.signal
+        onRecord,
+        over.signal,
+        intents ?? void 0,
+        onIntent
       )
-    )
-  ).finally(() => {
+    );
+  }).finally(async () => {
     if (!end.signal.aborted) record.duration = Date.now() - record.startedAt;
     else if (end.signal.reason === "ended") releaseCall(sink, call?.settled ?? Promise.resolve());
     sink.shownStops.delete(end);
+    await held2?.release();
   });
   const heldAt = testTimeSlot(testInfo)?.elapsed ?? null;
-  sink.shownStops.set(end, { page, record, done: shown.catch(() => void 0), heldAt });
-  const answer = await shown;
-  if (!end.signal.aborted) return answer;
-  return end.signal.reason === "closed" ? "resume" : "finish";
+  const stop = { page, guessed, context, record, done: shown2.catch(() => void 0), heldAt, after: null };
+  if (!failure) sink.shownStops.set(end, stop);
+  const answer = await shown2;
+  if (!end.signal.aborted) return fromEditor ?? answer;
+  if (end.signal.reason === "ended") return "finish";
+  await settledWithin(stop.after ? [stop.after] : [], END_STOP_MS);
+  return "resume";
+}
+function intentAt(intents, what, stop) {
+  if (!stop.holds()) return { ok: false, message: "The test went on." };
+  if (stop.guessed) {
+    return {
+      ok: false,
+      message: `${RUN_INTENT_NAMES[what]} needs the page the test stopped in, which this call does not name among its context's pages: use the pause bar in the test's window.`
+    };
+  }
+  if ((what === "record" || what === "assert") && !stop.record) {
+    return {
+      ok: false,
+      message: `${RUN_INTENT_NAMES[what]} needs the editor that started the run: this run names no record channel.`
+    };
+  }
+  if (!intents.offer(what)) {
+    return {
+      ok: false,
+      message: `${RUN_INTENT_NAMES[what]} waits: a pick, a check or a recording runs in the test's window.`
+    };
+  }
+  const started = {
+    pick: "Pick an element in the test's window: the locator goes to the editor.",
+    record: "Recording in the test's window: the editor writes the steps above the stopped line.",
+    assert: "Check an element in the test's window: the editor writes the check above the stopped line.",
+    "assert-region": "Pick the region in the test's window: the editor writes its ARIA snapshot above the stopped line."
+  };
+  return { ok: true, message: started[what] };
+}
+async function checkAt(page, testInfo, location, reason, stop, ended) {
+  const ref = process.env[PIWI_ORIGIN_ENV.ref] ?? "";
+  console.log(`[piwi] Checking an element at ${callSiteLine(location)}: the editor writes the check.`);
+  const why = await recordFromHere({
+    page,
+    testInfo,
+    location,
+    reason,
+    mode: "check",
+    stop: { ref, worker: testInfo.workerIndex, stop },
+    ended
+  });
+  if (ended?.aborted) console.log("[piwi] The check ended with the stop.");
+  else console.log(why ? `[piwi] Nothing was checked: ${why}` : "[piwi] The check ended: the test is paused again.");
+}
+async function regionAt(page, location, stop, ended) {
+  const picked = await pickLocator(page, { fn: probeElementAttrs, arg: CAPTURED_ATTRS_ARG }, null, ended).catch(
+    () => null
+  );
+  if (!picked || ended?.aborted) return;
+  const source = picked.picked.locator;
+  const say = (message) => {
+    console.log(`[piwi] ${message}`);
+    tellHub({ type: "region", stop, refused: message });
+  };
+  const region = locatorOn(page, source);
+  if (!region) return say(`The region's locator, ${source}, is not one Piwi can read.`);
+  const count = await region.count().catch(() => 0);
+  if (count !== 1) return say(`${source} finds ${count} elements: pick a region it finds alone.`);
+  const read = await region.ariaSnapshot({ timeout: 5e3 }).catch(() => null);
+  if (!read?.trim()) return say(`The ARIA snapshot of ${source} could not be read.`);
+  const secrets = await regionSecrets(region).catch(() => null);
+  if (secrets === null) return say(`The fields of ${source} that hold a secret could not be read.`);
+  const snapshot = regionSnapshotWithoutSecrets(read, secrets);
+  if (snapshot.length > MAX_REGION_SNAPSHOT) {
+    return say(
+      `The ARIA snapshot of ${source} is longer than ${MAX_REGION_SNAPSHOT} characters: pick a smaller region.`
+    );
+  }
+  console.log(`[piwi] Region picked at ${callSiteLine(location)}: ${source}, its ARIA snapshot sent to the editor.`);
+  tellHub({ type: "region", stop, locator: source, snapshot });
+}
+function regionSecrets(region) {
+  return region.locator(":scope:is(input, textarea), input, textarea").evaluateAll(
+    (elements, secret) => {
+      return elements.flatMap((field) => {
+        const tokens = (field.getAttribute("autocomplete") ?? "").toLowerCase().split(/\s+/);
+        const password = field.localName === "input" && String(field.type).toLowerCase() === "password";
+        return password || tokens.some((token) => secret.includes(token)) ? [String(field.value ?? "")] : [];
+      });
+    },
+    [...SECRET_AUTOCOMPLETE]
+  );
+}
+async function holdFailure(sink, fallback) {
+  const testInfo = sink.testInfo;
+  if (sink.failureHeld || !sink.pause || !testInfo || !editorShows("failure")) return;
+  const { status, expectedStatus } = testInfo;
+  if (status !== "failed" && status !== "timedOut" || status === expectedStatus) return;
+  const page = [sink.lastActivePage, fallback].find((open) => !!open && !isPageClosed(open));
+  const context = page ? pageContext(page) : null;
+  if (!page || !context) return;
+  sink.failureHeld = true;
+  const failed = sink.failedLocators[sink.failedLocators.length - 1] ?? deriveFailedLocator(testInfo);
+  const errors = testInfo.errors.length ? testInfo.errors : testInfo.error ? [testInfo.error] : [];
+  const declared = (place2) => place2.file === testInfo.file && place2.line === testInfo.line;
+  const placed = errors.flatMap((error2) => {
+    const place2 = errorPlace(error2);
+    return place2 && !declared(place2) ? [{ error: error2, place: place2 }] : [];
+  })[0];
+  const error = placed?.error ?? errors[0];
+  const place = placed?.place ?? (failed?.location ? null : stepInProgress(testInfo));
+  const location = (place ? stopCallSite(place) : null) ?? failed?.location ?? stopCallSite({ file: testInfo.file, line: testInfo.line, column: testInfo.column });
+  if (!location) return;
+  const said = stripAnsi(error?.message ?? "").split("\n").find((line) => line.trim()) ?? status;
+  if (page === sink.lastActivePage)
+    await internalCall(page, () => readPageBeforeClose(sink, page)).catch(() => void 0);
+  sink.frozenAt = Date.now();
+  await stopSinkCodeReach(sink, { context });
+  const title = hideSecretsInText(`Failed: ${said.trim().slice(0, 300)}`).slice(0, 1e3);
+  const errorText = failureError(error?.message ?? error?.value);
+  const named = errorText === null ? null : hideSecretsInText(errorText).slice(0, MAX_STOP_ERROR);
+  await showStop(sink, context, title, location, "failure", void 0, { page }, { failed, error: named });
+}
+var FAILURE_ERROR_LINES = 4;
+function failureError(message) {
+  const lines = [];
+  for (const line of stripAnsi(message ?? "").trimStart().replace(/^Error: /, "").split("\n")) {
+    if (!line.trim() || /^\s*Call log:/.test(line)) break;
+    lines.push(line.trimEnd());
+    if (lines.length === FAILURE_ERROR_LINES) break;
+  }
+  const text = lines.join("\n").slice(0, MAX_STOP_ERROR);
+  return text.trim() ? text : null;
+}
+function errorPlace(error) {
+  const given = error?.location;
+  if (typeof given?.file === "string" && typeof given.line === "number") {
+    return { file: given.file, line: given.line, column: given.column ?? 0 };
+  }
+  const stack = error?.stack;
+  for (const line of typeof stack === "string" ? stack.split("\n") : []) {
+    const frame = /^\s*at\s+(?:.*?\s+\()?(?:file:\/\/)?(\/[^():]+|[A-Za-z]:[\\/][^():]+):(\d+):(\d+)\)?$/.exec(line);
+    if (!frame) continue;
+    const file = frame[1];
+    if (/[\\/]node_modules[\\/]/.test(file) || path30.dirname(path30.resolve(file)) === __dirname) continue;
+    return { file, line: Number(frame[2]), column: Number(frame[3]) };
+  }
+  return null;
+}
+function stepInProgress(testInfo) {
+  let found = null;
+  const visit = (steps) => {
+    if (!Array.isArray(steps)) return;
+    for (const step of steps) {
+      if (step.endWallTime) continue;
+      const at = step.stack?.[0];
+      const called = step.category === "pw:api" || step.category === "expect" || step.category === "test.step";
+      if (called && typeof at?.file === "string" && typeof at.line === "number") {
+        found = { file: at.file, line: at.line, column: typeof at.column === "number" ? at.column : 0 };
+      }
+      visit(step.steps);
+    }
+  };
+  visit(testInfo._steps);
+  return found;
+}
+function abortion(signal) {
+  return new Promise((resolve11) => {
+    if (signal.aborted) resolve11();
+    else signal.addEventListener("abort", () => resolve11(), { once: true });
+  });
 }
 var END_STOP_MS = 2e3;
 var RELEASED_CALL_MS = 2e3;
 var RELEASED_QUIET_MS = 200;
 async function endShownStops(sink, why, closing) {
   const ending = [];
+  if (why === "ended") sink.stopEnds++;
   let heldAt = Infinity;
-  for (const [end, { page, record, done, heldAt: stopHeldAt }] of sink.shownStops) {
-    if (closing && closing.page !== page && (!closing.context || pageContext(page) !== closing.context)) continue;
+  for (const [end, stop] of sink.shownStops) {
+    if (closing && !closesStop(closing, stop)) continue;
     if (!end.signal.aborted) {
-      record.duration = Date.now() - record.startedAt;
+      stop.record.duration = Date.now() - stop.record.startedAt;
+      if (closing?.page) stop.after = CLOSING_PAGES.get(closing.page) ?? null;
       end.abort(why);
-      if (why === "ended" && stopHeldAt !== null) heldAt = Math.min(heldAt, stopHeldAt);
+      if (why === "ended" && stop.heldAt !== null) heldAt = Math.min(heldAt, stop.heldAt);
     }
-    ending.push(done);
+    ending.push(stop.done);
   }
   if (sink.testInfo && heldAt !== Infinity) restoreTestTime(sink.testInfo, heldAt);
   await settledWithin(ending, END_STOP_MS);
 }
+function closesStop(closing, stop) {
+  if (closing.context && stop.context === closing.context) return true;
+  if (!closing.page) return false;
+  return stop.page === closing.page || stop.guessed && pageContext(closing.page) === stop.context;
+}
 function releaseCall(sink, settled) {
   sink.releasedQuietSince = Date.now();
+  sink.releasedUntil = null;
   sink.released.push(settled.then(() => void (sink.releasedQuietSince = Date.now())));
 }
 function releasedRequestsEnded(sink) {
@@ -15677,8 +17744,8 @@ function releasedRequestsEnded(sink) {
 }
 async function awaitReleasedCalls(sink) {
   if (sink.released.length === 0) return;
-  const deadline = Date.now() + RELEASED_CALL_MS;
-  await settledWithin(sink.released, RELEASED_CALL_MS);
+  const deadline = sink.releasedUntil ??= Date.now() + RELEASED_CALL_MS;
+  await settledWithin(sink.released, Math.max(0, deadline - Date.now()));
   for (let now = Date.now(); now < deadline; now = Date.now()) {
     if (sink.releasedRequests.size > 0) {
       await settledWithin([releasedRequestsEnded(sink)], deadline - now);
@@ -15708,7 +17775,7 @@ function recorderAt(page, testInfo, location, reason) {
   return async (ended) => {
     console.log(`[piwi] Recording from ${callSiteLine(location)}: the editor writes the steps.`);
     const why = await recordFromHere({ page, testInfo, location, reason, ended });
-    if (ended?.aborted) console.log("[piwi] The recording ended with the test.");
+    if (ended?.aborted) console.log("[piwi] The recording ended with the stop.");
     else
       console.log(
         why ? `[piwi] Nothing was recorded: ${why}` : "[piwi] The recording ended: the test is paused again."
@@ -15725,10 +17792,10 @@ async function pauseInPlace(page, playwrightPause, location) {
   if (!sink.pause && (!canRecordFromHere() || pauseSkipReason(pauseGateFromTestInfo(testInfo)))) {
     return leaveToPlaywright(context, playwrightPause);
   }
-  sink.pause ??= { set: NO_BREAKPOINTS, step: false, finished: false };
+  sink.pause ??= pauseState(NO_BREAKPOINTS);
   watchStops(context, onDebuggerStop);
   await steerDebugger(context, "pause");
-  PAGE_PAUSES.set(context, location);
+  PAGE_PAUSES.set(context, { location, page });
   try {
     await playwrightPause({ __testHookKeepTestTimeout: true });
   } finally {
@@ -15911,15 +17978,15 @@ function instrumentPage(page) {
   if (typeof page.close === "function") {
     const originalClose = page.close.bind(page);
     page.close = async (...args) => {
-      await drainPendingProbes(1e3);
-      const sink = currentSink;
-      if (sink) {
-        await endShownStops(sink, "closed", { page });
-        await stashPageState(sink, { page });
-        await maybeOpenPicker(sink, { page });
-        await stopSinkCodeReach(sink, { page });
+      let closed = () => {
+      };
+      CLOSING_PAGES.set(page, new Promise((resolve11) => closed = resolve11));
+      try {
+        await settleBeforeClose({ page });
+        return await originalClose(...args);
+      } finally {
+        closed();
       }
-      return originalClose(...args);
     };
   }
   const captureLocators = process.env.PIWI_CAPTURE_LOCATORS !== "false";
@@ -15964,7 +18031,7 @@ function instrumentPage(page) {
   });
   page.on("console", (msg) => {
     const sink = currentSink;
-    if (!sink) return;
+    if (!sink || sink.frozenAt !== null) return;
     const type = msg.type();
     if (["warning", "error", "assert"].includes(type)) {
       const location = msg.location();
@@ -15980,7 +18047,7 @@ function instrumentPage(page) {
     try {
       page.on("dialogclosed", (dialog) => {
         const sink = currentSink;
-        if (!sink) return;
+        if (!sink || sink.frozenAt !== null) return;
         try {
           sink.dialogs.push({
             type: typeof dialog.type === "function" ? dialog.type() : null,
@@ -15999,12 +18066,14 @@ function instrumentPage(page) {
     if (!sink) return;
     try {
       const request3 = response.request();
+      if (HELD_REQUESTS.has(request3)) return;
       if (isTrackedRequest(request3.url(), request3.resourceType())) sink.openResponses.set(request3, response);
     } catch {
     }
   });
   page.on("request", (request3) => {
     const sink = currentSink;
+    if (sink && sink.frozenAt !== null) HELD_REQUESTS.add(request3);
     if (!sink || sink.released.length === 0) return;
     sink.releasedRequests.add(request3);
     sink.releasedQuietSince = Date.now();
@@ -16015,16 +18084,18 @@ function instrumentPage(page) {
       sink.releasedQuietSince = Date.now();
       if (sink.releasedRequests.size === 0) sink.onReleasedRequestsEnded?.();
     }
-    if (!sink || RECORDED_OPEN.has(request3)) return;
+    if (!sink || RECORDED_OPEN.has(request3) || HELD_REQUESTS.has(request3)) return;
     sink.lastActivePage = page;
     const response = sink.openResponses.get(request3) ?? null;
     sink.openResponses.delete(request3);
     recordRequest(sink, request3, failed ? "failed" : "finished", response);
+    if (!failed) void keepResponse(request3, response);
   };
   page.on("requestfinished", (request3) => onRequestEnd(request3, false));
   page.on("requestfailed", (request3) => onRequestEnd(request3, true));
 }
 var RECORDED_OPEN = /* @__PURE__ */ new WeakSet();
+var HELD_REQUESTS = /* @__PURE__ */ new WeakSet();
 function isTrackedRequest(url, resourceType) {
   if (url.startsWith("data:") || url.startsWith("blob:")) return false;
   return TRACKED_REQUEST_TYPES.includes(resourceType);
@@ -16086,6 +18157,7 @@ function readResponseHeaders(sink, entry, url, headers) {
   }
 }
 function recordApiCall(sink, call) {
+  if (sink.frozenAt !== null) return;
   try {
     const entry = apiCallEntry(call, sink.baseURL);
     if (!entry) return;
@@ -16122,7 +18194,10 @@ function instrumentContext(context) {
   INSTRUMENTED_CONTEXTS.add(context);
   if (typeof context.once === "function") {
     OPEN_CONTEXTS.add(context);
-    context.once("close", () => OPEN_CONTEXTS.delete(context));
+    context.once("close", () => {
+      OPEN_CONTEXTS.delete(context);
+      CLOSING_CONTEXTS.add(context);
+    });
   }
   observeOwnApiRequests(context);
   if (process.env.PIWI_CAPTURE_LOCATORS !== "false" && typeof context.addInitScript === "function") {
@@ -16140,14 +18215,7 @@ function instrumentContext(context) {
   if (typeof context.close === "function") {
     const originalClose = context.close.bind(context);
     context.close = async (...args) => {
-      await drainPendingProbes(1e3);
-      const sink = currentSink;
-      if (sink) {
-        await endShownStops(sink, "closed", { context });
-        await stashPageState(sink, { context });
-        await maybeOpenPicker(sink, { context });
-        await stopSinkCodeReach(sink, { context });
-      }
+      await settleContextClose(context);
       return originalClose(...args);
     };
   }
@@ -16160,7 +18228,7 @@ function patchBrowser(browser) {
   browser.newPage = async (...args) => {
     const page = await originalNewPage(...args);
     instrumentPage(page);
-    await armBreakpoints([pageContext(page)]);
+    await armStops([pageContext(page)]);
     await awaitFlakeConditions();
     await maybeStartCodeReach(page);
     return page;
@@ -16169,13 +18237,16 @@ function patchBrowser(browser) {
   browser.newContext = async (...args) => {
     const context = await originalNewContext(...args);
     instrumentContext(context);
-    await armBreakpoints([context]);
+    await armStops([context]);
     return context;
   };
   if (typeof browser.close === "function") {
     const originalClose = browser.close.bind(browser);
     browser.close = async (...args) => {
       await drainPendingProbes(1e3);
+      for (const context of typeof browser.contexts === "function" ? browser.contexts() : []) {
+        await settleContextClose(context);
+      }
       return originalClose(...args);
     };
   }
@@ -16228,7 +18299,11 @@ async function flushSink(sink, testInfo) {
   clearTimeout(drainDeadline);
   const page = sink.lastActivePage;
   const pageReadable = page !== null && !isPageClosed(page);
-  if (pageReadable) await maybeOpenPicker(sink);
+  if (pageReadable) {
+    await holdFailure(sink);
+    await maybeOpenPicker(sink);
+  }
+  const live = pageReadable && sink.frozenAt === null;
   if (sink.stops.length > 0) {
     await testInfo.attach(ATTACHMENT_NAMES.pauses, {
       contentType: "application/json",
@@ -16265,6 +18340,21 @@ async function flushSink(sink, testInfo) {
       body: Buffer.from(JSON.stringify(part))
     });
   }
+  if (cssCoverageInWorker()) {
+    const rules = sink.codeReach.cssFiles.size > 0 ? browserFunctionCoverage(sink.codeReach.cssFiles) : null;
+    if (rules) {
+      await testInfo.attach(ATTACHMENT_NAMES.cssCoverage, {
+        contentType: "application/json",
+        body: Buffer.from(JSON.stringify(rules))
+      });
+    }
+    for (const part of newKnownFunctions(sink.codeReach.cssKnown, KNOWN_CSS_RULES_SENT)) {
+      await testInfo.attach(ATTACHMENT_NAMES.cssRules, {
+        contentType: "application/json",
+        body: Buffer.from(JSON.stringify(part))
+      });
+    }
+  }
   if (sink.serverCoverage.size > 0) {
     const requests = {};
     for (const [origin, ids] of sink.serverCoverage) requests[origin] = [...ids];
@@ -16281,13 +18371,13 @@ async function flushSink(sink, testInfo) {
   }
   if (testInfo.status !== "passed" && testInfo.status !== "skipped") {
     try {
-      const snapshot = (pageReadable ? await readRootAria(page) : null) ?? sink.stashedAria;
+      const snapshot = (live ? await readRootAria(page) : null) ?? sink.stashedAria;
       if (snapshot) {
         await testInfo.attach(ATTACHMENT_NAMES.ariaSnapshot, {
-          contentType: "text/plain",
+          contentType: ARIA_SNAPSHOT_CONTENT_TYPE,
           body: snapshot
         });
-        const snapshotJson = (pageReadable ? await readRootAriaJson(page) : null) ?? sink.stashedAriaJson;
+        const snapshotJson = (live ? await readRootAriaJson(page) : null) ?? sink.stashedAriaJson;
         if (snapshotJson) {
           await testInfo.attach(ATTACHMENT_NAMES.ariaSnapshotJson, {
             contentType: "application/json",
@@ -16312,7 +18402,7 @@ async function flushSink(sink, testInfo) {
   }
   if (testInfo.status !== "passed" && testInfo.status !== "skipped" && sink.failureScreenshot) {
     const option = sink.failureScreenshot;
-    const shot = (pageReadable ? await internalCall(page, () => readFailureScreenshot(page, option)) : null) ?? sink.stashedScreenshot;
+    const shot = (live ? await internalCall(page, () => readFailureScreenshot(page, option)) : null) ?? sink.stashedScreenshot;
     if (shot) {
       try {
         await testInfo.attach(FAILURE_SCREENSHOT_ATTACHMENT, { contentType: "image/png", body: shot });
@@ -16322,13 +18412,13 @@ async function flushSink(sink, testInfo) {
   }
   if (testInfo.status === "passed" && process.env.PIWI_SAMPLE_ARIA_ON_PASS !== "false" && isDueForAriaSample(testInfo)) {
     try {
-      const snapshot = (pageReadable ? await readRootAria(page) : null) ?? sink.stashedAria;
+      const snapshot = (live ? await readRootAria(page) : null) ?? sink.stashedAria;
       if (snapshot) {
         await testInfo.attach(ATTACHMENT_NAMES.ariaSnapshot, {
-          contentType: "text/plain",
+          contentType: ARIA_SNAPSHOT_CONTENT_TYPE,
           body: snapshot
         });
-        const snapshotJson = (pageReadable ? await readRootAriaJson(page) : null) ?? sink.stashedAriaJson;
+        const snapshotJson = (live ? await readRootAriaJson(page) : null) ?? sink.stashedAriaJson;
         if (snapshotJson) {
           await testInfo.attach(ATTACHMENT_NAMES.ariaSnapshotJson, {
             contentType: "application/json",
@@ -16374,7 +18464,7 @@ async function flushSink(sink, testInfo) {
       body: Buffer.from(JSON.stringify(sink.networkRequests))
     });
   }
-  const webVitals = (pageReadable ? await internalCall(page, () => readWebVitals(page)) : null) ?? sink.stashedWebVitals;
+  const webVitals = (live ? await internalCall(page, () => readWebVitals(page)) : null) ?? sink.stashedWebVitals;
   if (webVitals) {
     await testInfo.attach(ATTACHMENT_NAMES.webVitals, {
       contentType: "application/json",
@@ -16382,7 +18472,7 @@ async function flushSink(sink, testInfo) {
     });
   }
   if (process.env.PIWI_CAPTURE_PAGE_STATE !== "false") {
-    const pageState = (pageReadable ? await internalCall(page, () => readPageState(page)) : null) ?? sink.stashedPageState;
+    const pageState = (live ? await internalCall(page, () => readPageState(page)) : null) ?? sink.stashedPageState;
     if (pageState) {
       await testInfo.attach(ATTACHMENT_NAMES.pageState, {
         contentType: "application/json",
@@ -16391,7 +18481,7 @@ async function flushSink(sink, testInfo) {
     }
   }
   if (testInfo.status === "passed" && process.env.PIWI_CAPTURE_PAGE_INVENTORY === "true") {
-    if (pageReadable) await recordPageWindow(sink, page);
+    if (live) await recordPageWindow(sink, page);
     const windows = sink.pageInventories.slice(0, MAX_PAGE_INVENTORY_WINDOWS).map((inv) => capPageInventory(inv));
     if (windows.length > 0) {
       await testInfo.attach(ATTACHMENT_NAMES.pageInventory, {
@@ -16401,21 +18491,79 @@ async function flushSink(sink, testInfo) {
     }
   }
 }
+var pauseNextTest = false;
+var runControl = {
+  pause() {
+    const sink = currentSink;
+    if (!sink) {
+      pauseNextTest = true;
+      return;
+    }
+    if (!sink.pause) {
+      const why = sink.testInfo ? pauseSkipReason({ ...pauseGateFromTestInfo(sink.testInfo), channel: true }) : null;
+      tellHub({ type: "notice", message: `This test does not stop${why ? `: ${why}` : ""}.` });
+      return;
+    }
+    sink.pause.pause = true;
+    void armStops(OPEN_CONTEXTS);
+  },
+  breakpoints(places) {
+    const set = replacePauseSet(places);
+    const state = currentSink?.pause;
+    if (!state) return;
+    state.set = set;
+    void armStops(OPEN_CONTEXTS);
+  },
+  runTo(place) {
+    const state = currentSink?.pause;
+    if (!state) return;
+    state.runTo = placeLine(place);
+    void armStops(OPEN_CONTEXTS);
+  }
+};
+function runFile(file) {
+  return path30.relative(process.cwd(), file).split(path30.sep).join("/") || file;
+}
+function testBegin(testInfo, cannotPause) {
+  const title = testInfo.titlePath.slice(1);
+  return {
+    type: "test-begin",
+    testId: testInfo.testId,
+    title: title.length ? title : [testInfo.title],
+    file: runFile(testInfo.file),
+    line: Math.max(1, testInfo.line),
+    project: testInfo.project.name,
+    retry: testInfo.retry,
+    cannotPause
+  };
+}
+function testEnd(sink, testInfo) {
+  return {
+    type: "test-end",
+    testId: testInfo.testId,
+    status: testInfo.status ?? "passed",
+    pausedMs: sink.stops.reduce((sum, stop) => sum + stop.duration, 0)
+  };
+}
 var piwiFixtures = {
   // Auto, worker-scoped: the worker's resource ledger, and the API request
   // contexts its tests create, handed out behind the call proxy. Set up before
   // any hook (worker fixtures come first), so a `beforeAll` context is in the
   // ledger and records the calls the tests make through it, and torn down after
   // the browser closed, so its census sees what only the worker's shutdown
-  // closed. Depends on `playwright` alone, which launches nothing.
+  // closed. Depends on `playwright` alone, which launches nothing. The worker's
+  // run connection to the editor (`PIWI_RUN_CHANNEL`) opens here, before the
+  // first test, and closes as the worker ends.
   piwiResources: [
     async ({ playwright }, use, workerInfo) => {
       boxCaptureFrames();
       startResourceLedger(playwright, workerInfo.workerIndex);
       observeApiRequests(playwright, apiCallRecorder);
+      await openRunChannel(workerInfo, runControl);
       try {
         await use();
       } finally {
+        closeRunChannel();
         stopResourceLedger();
       }
     },
@@ -16435,10 +18583,12 @@ var piwiFixtures = {
   // never double-wraps a page the browser patch already instrumented.
   page: async ({ page }, use) => {
     instrumentPage(page);
-    await armBreakpoints([pageContext(page)]);
+    await armStops([pageContext(page)]);
     await awaitFlakeConditions();
     await maybeStartCodeReach(page);
     await use(page);
+    const sink = currentSink;
+    if (sink) await holdFailure(sink, page);
   },
   // Auto, test-scoped: open a capture sink for the running test and flush it
   // (attach the collected data) at teardown. Runs for every test without being
@@ -16453,12 +18603,16 @@ var piwiFixtures = {
       sink.baseURL = baseURL ?? null;
       if (keepsFailureScreenshots(screenshot, testInfo.retry)) sink.failureScreenshot = screenshot;
       const pauseSet = currentPauseSet();
-      if (pauseSet.size) {
-        const reason = pauseSkipReason(pauseGateFromTestInfo(testInfo));
-        if (reason) logPauseSkipOnce(reason);
-        else sink.pause = { set: pauseSet, step: false, finished: false };
+      const channel = runChannelOpen();
+      const cannotPause = pauseSkipReason({ ...pauseGateFromTestInfo(testInfo), channel });
+      if (pauseSet.size || channel) {
+        if (!cannotPause) sink.pause = pauseState(pauseSet, pauseNextTest);
+        else if (pauseSet.size) logPauseSkipOnce(cannotPause);
       }
+      pauseNextTest = false;
       if (sink.pause || canRecordFromHere()) endStopsWithTestFunction(testInfo, sink);
+      if (channel) tellHub(testBegin(testInfo, cannotPause));
+      if (channel && sink.pause) startKeeping();
       if (isFlakeMode()) {
         const plan = loadFlakePlan();
         const role = flakeRoleForTest(plan, {
@@ -16482,14 +18636,18 @@ var piwiFixtures = {
         });
       activeResourceLedger()?.testStarted(testInfo);
       currentSink = sink;
+      const showRunChannel = hideRunChannel();
       try {
-        await armBreakpoints(OPEN_CONTEXTS);
+        await armStops(OPEN_CONTEXTS);
         await startCodeReachOnOpenPages();
         await use();
       } finally {
+        sink.ending = true;
         await endShownStops(sink, "ended");
         await awaitReleasedCalls(sink);
+        showRunChannel();
         currentSink = null;
+        if (sink.pause?.pause) pauseNextTest = true;
         if (sink.probeItem) {
           const applied = sink.probeInterception?.applied() ?? false;
           const level = sink.probeItem.level ?? "client";
@@ -16512,7 +18670,12 @@ var piwiFixtures = {
           });
         }
         if (sink.flake) await recordFlakeAttempt(sink.flake, testInfo);
-        await flushSink(sink, testInfo);
+        try {
+          await flushSink(sink, testInfo);
+        } finally {
+          stopKeeping();
+          if (runChannelOpen()) tellHub(testEnd(sink, testInfo));
+        }
         await recordResourceCensus(testInfo);
       }
     },
@@ -16546,12 +18709,12 @@ function extendPiwiFixtures(test) {
 }
 
 // src/internal/ai/ai-fixtures.ts
-var fs28 = __toESM(require("fs"));
+var fs29 = __toESM(require("fs"));
 var path33 = __toESM(require("path"));
 var import_test = require("@playwright/test");
 
 // src/internal/ai/artifact.ts
-var fs27 = __toESM(require("fs"));
+var fs28 = __toESM(require("fs"));
 var path31 = __toESM(require("path"));
 var ARTIFACT_VERSION = 1;
 var LOCATOR_METHOD_SET2 = new Set(LOCATOR_METHODS);
@@ -16645,7 +18808,7 @@ function parseEntry(text) {
 function readEntry(file) {
   let text;
   try {
-    text = fs27.readFileSync(file, "utf8");
+    text = fs28.readFileSync(file, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw error;
@@ -16655,28 +18818,28 @@ function readEntry(file) {
 function writeEntry(file, entry) {
   const canonical = serializeEntry(entry);
   return withEntryLock(file, () => {
-    if (fs27.existsSync(file) && fs27.readFileSync(file, "utf8") === canonical) return { written: false };
-    fs27.mkdirSync(path31.dirname(file), { recursive: true });
+    if (fs28.existsSync(file) && fs28.readFileSync(file, "utf8") === canonical) return { written: false };
+    fs28.mkdirSync(path31.dirname(file), { recursive: true });
     const tmp = `${file}.${process.pid}.tmp`;
-    fs27.writeFileSync(tmp, canonical);
-    fs27.renameSync(tmp, file);
+    fs28.writeFileSync(tmp, canonical);
+    fs28.renameSync(tmp, file);
     return { written: true };
   });
 }
 function withEntryLock(file, fn) {
   const lock = `${file}.lock`;
-  fs27.mkdirSync(path31.dirname(file), { recursive: true });
+  fs28.mkdirSync(path31.dirname(file), { recursive: true });
   const deadline = Date.now() + 5e3;
   for (; ; ) {
     try {
-      const fd = fs27.openSync(lock, "wx");
-      fs27.closeSync(fd);
+      const fd = fs28.openSync(lock, "wx");
+      fs28.closeSync(fd);
       break;
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
       if (Date.now() > deadline) {
         try {
-          fs27.unlinkSync(lock);
+          fs28.unlinkSync(lock);
         } catch {
         }
       }
@@ -16686,14 +18849,14 @@ function withEntryLock(file, fn) {
     return fn();
   } finally {
     try {
-      fs27.unlinkSync(lock);
+      fs28.unlinkSync(lock);
     } catch {
     }
   }
 }
 
 // src/internal/ai/keys.ts
-var crypto7 = __toESM(require("crypto"));
+var crypto9 = __toESM(require("crypto"));
 var path32 = __toESM(require("path"));
 var DEFAULT_AI_DIR = "__piwi__";
 function normalizeTemplate(template) {
@@ -16701,7 +18864,7 @@ function normalizeTemplate(template) {
 }
 function hashTemplate(normalized, ordinal = 0) {
   const input = ordinal > 0 ? `${normalized}#${ordinal}` : normalized;
-  return crypto7.createHash("sha256").update(input).digest("hex").slice(0, 8);
+  return crypto9.createHash("sha256").update(input).digest("hex").slice(0, 8);
 }
 function slug(text, maxLength = 40) {
   const base = text.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -17320,15 +19483,15 @@ function relativeToCwd(file) {
   return path33.relative(process.cwd(), file).split(path33.sep).join("/");
 }
 function recordIntents(intents, entry) {
-  const add = (locator, kind) => {
+  const add2 = (locator, kind) => {
     intents.set(`${entry.template}\0${locator}`, { template: entry.template, locator, kind });
   };
   if (entry.kind === "locator") {
-    add(locatorSource2(entry.locator), "locator");
+    add2(locatorSource2(entry.locator), "locator");
     return;
   }
-  for (const step of entry.steps) add(locatorSource2(step.locator), "run");
-  if (entry.postcondition.locator) add(locatorSource2(entry.postcondition.locator), "run");
+  for (const step of entry.steps) add2(locatorSource2(step.locator), "run");
+  if (entry.postcondition.locator) add2(locatorSource2(entry.postcondition.locator), "run");
 }
 function missMessage(template, testTitle, relPath) {
   return [
@@ -17344,7 +19507,7 @@ function createAiApi(page, testInfo, config, used, intents) {
   const readSource = () => {
     if (source === null) {
       try {
-        source = fs28.readFileSync(testInfo.file, "utf8");
+        source = fs29.readFileSync(testInfo.file, "utf8");
       } catch {
         source = "";
       }