@piwitests/reporter 0.59.0 → 0.61.0

package/dist/index.js

@@ -43,9 +43,12 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/public/reporter.ts
-var fs24 = __toESM(require("fs"));
+var fs25 = __toESM(require("fs"));
 var os9 = __toESM(require("os"));
-var path24 = __toESM(require("path"));
+var path25 = __toESM(require("path"));
+
+// src/internal/config/env.ts
+var path2 = __toESM(require("path"));
 
 // src/internal/config/desktop.ts
 var fs = __toESM(require("fs"));
@@ -54,6 +57,14 @@ var path = __toESM(require("path"));
 function defaultDesktopConfigPath() {
   return path.join(os.homedir(), ".piwi", "desktop.json");
 }
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
 function readDesktopConfig(filePath2) {
   try {
     const parsed2 = JSON.parse(fs.readFileSync(filePath2, "utf8"));
@@ -61,12 +72,75 @@ function readDesktopConfig(filePath2) {
     const token = parsed2?.token;
     if (typeof url !== "string" || !url) return null;
     if (typeof token !== "string" || !token) return null;
+    if (Number.isInteger(parsed2?.pid) && parsed2.pid > 0 && !processAlive(parsed2.pid)) return null;
     return { url, token };
   } catch {
     return null;
   }
 }
 
+// src/internal/config/dotenv.ts
+var fs2 = __toESM(require("fs"));
+
+// ../core/src/dotenv.ts
+function parseDotEnv(text) {
+  const out = {};
+  for (const raw of text.split(/\r?\n/)) {
+    const m = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*?)\s*$/.exec(raw);
+    if (!m) continue;
+    let value = m[2];
+    const quote = value[0];
+    if ((quote === '"' || quote === "'") && value.length > 1 && value.endsWith(quote)) {
+      value = value.slice(1, -1);
+      if (quote === '"') value = value.replace(/\\n/g, "\n").replace(/\\"/g, '"');
+    } else {
+      value = value.replace(/\s+#.*$/, "");
+    }
+    out[m[1]] = value;
+  }
+  return out;
+}
+
+// src/internal/config/dotenv.ts
+function readDotEnv(filePath2) {
+  try {
+    return parseDotEnv(fs2.readFileSync(filePath2, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+// src/internal/support/ci.ts
+function detectCi(env) {
+  return Boolean(
+    env.JENKINS_URL || env.GITHUB_ACTIONS || env.GITLAB_CI || env.CIRCLECI || env.TRAVIS || env.TF_BUILD || env.BITBUCKET_BUILD_NUMBER || env.TEAMCITY_VERSION || env.CODEBUILD_BUILD_ID || env.bamboo_buildKey || env.CI && env.CI.toLowerCase() !== "false" && env.CI !== "0"
+  );
+}
+function detectCiIds(env) {
+  if (env.GITHUB_ACTIONS && env.GITHUB_RUN_ID) {
+    const run = env.GITHUB_RUN_ATTEMPT ? `${env.GITHUB_RUN_ID}-${env.GITHUB_RUN_ATTEMPT}` : env.GITHUB_RUN_ID;
+    return { run, job: env.GITHUB_JOB || null };
+  }
+  if (env.GITLAB_CI && env.CI_PIPELINE_ID) return { run: env.CI_PIPELINE_ID, job: env.CI_JOB_ID || null };
+  if (env.CIRCLECI && env.CIRCLE_WORKFLOW_ID) return { run: env.CIRCLE_WORKFLOW_ID, job: env.CIRCLE_BUILD_NUM || null };
+  if (env.TRAVIS && env.TRAVIS_BUILD_ID) return { run: env.TRAVIS_BUILD_ID, job: env.TRAVIS_JOB_ID || null };
+  if (env.TF_BUILD && env.BUILD_BUILDID) return { run: env.BUILD_BUILDID, job: env.SYSTEM_JOBID || null };
+  if (env.JENKINS_URL && env.BUILD_ID) return { run: env.BUILD_ID, job: null };
+  if (env.BUILDKITE_BUILD_ID) return { run: env.BUILDKITE_BUILD_ID, job: env.BUILDKITE_JOB_ID || null };
+  if (env.TEAMCITY_BUILD_ID) return { run: env.TEAMCITY_BUILD_ID, job: null };
+  if (env.BITBUCKET_BUILD_NUMBER) return { run: env.BITBUCKET_BUILD_NUMBER, job: env.BITBUCKET_STEP_UUID || null };
+  if (env.SEMAPHORE_WORKFLOW_ID) return { run: env.SEMAPHORE_WORKFLOW_ID, job: env.SEMAPHORE_JOB_ID || null };
+  if (env.APPVEYOR_BUILD_ID) return { run: env.APPVEYOR_BUILD_ID, job: env.APPVEYOR_JOB_ID || null };
+  if (env.DRONE_BUILD_NUMBER) return { run: env.DRONE_BUILD_NUMBER, job: null };
+  return null;
+}
+function resolveRunLabel(configured, sharded) {
+  if (configured) return configured;
+  const ci = detectCiIds(process.env);
+  if (!ci) return null;
+  return !sharded && ci.job ? `${ci.run}|${ci.job}` : ci.run;
+}
+
 // src/internal/config/env.ts
 var DEFAULTS = {
   projectName: "default-project",
@@ -103,6 +177,7 @@ var DEFAULTS = {
 };
 var PIWI_ENV_KEYS = {
   serverUrl: "PIWI_DASHBOARD_URL",
+  desktopApp: "PIWI_DESKTOP_APP",
   projectName: "PIWI_PROJECT_NAME",
   verbose: "PIWI_VERBOSE",
   apiKey: "PIWI_API_KEY",
@@ -128,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",
@@ -215,11 +291,27 @@ var ENV_FALLBACK_SPECS = [
   { option: "pickLocatorOnFailure", env: PIWI_ENV_KEYS.pickLocatorOnFailure, kind: "bool" },
   { option: "outputFile", env: PIWI_ENV_KEYS.outputFile, kind: "string" }
 ];
+var DOTENV_OPTIONS = ["serverUrl", "apiKey", "projectName"];
+var DESKTOP_APP_MODES = ["prefer", "fallback", "off"];
+function desktopAppMode(option, envValue) {
+  const fromEnv = envValue?.trim().toLowerCase();
+  if (DESKTOP_APP_MODES.includes(fromEnv)) return fromEnv;
+  if (DESKTOP_APP_MODES.includes(option)) return option;
+  return "fallback";
+}
 var desktopDiscovered = false;
+var desktopReplacedServerUrl = null;
+var dotEnvUse = null;
 function usedDesktopDiscovery() {
   return desktopDiscovered;
 }
-function resolveOptions(raw) {
+function desktopReplacedServer() {
+  return desktopReplacedServerUrl;
+}
+function usedDotEnv() {
+  return dotEnvUse;
+}
+function resolveOptions(raw, configDir) {
   const env = process.env;
   const mergedRaw = { ...raw };
   for (const spec of ENV_FALLBACK_SPECS) {
@@ -231,24 +323,49 @@ function resolveOptions(raw) {
       mergedRaw[spec.option] = spec.kind === "number" ? Number(value) : value;
     }
   }
+  dotEnvUse = null;
+  if (configDir) {
+    const file = path2.join(configDir, ".env");
+    const dotEnv = readDotEnv(file);
+    const keys = [];
+    for (const option of DOTENV_OPTIONS) {
+      const value = dotEnv[PIWI_ENV_KEYS[option]];
+      if (mergedRaw[option] !== void 0 || !value) continue;
+      mergedRaw[option] = value;
+      keys.push(PIWI_ENV_KEYS[option]);
+    }
+    if (keys.length > 0) dotEnvUse = { file, keys };
+  }
   desktopDiscovered = false;
+  desktopReplacedServerUrl = null;
+  const mode = desktopAppMode(mergedRaw.desktopApp, env[PIWI_ENV_KEYS.desktopApp]);
+  mergedRaw.desktopApp = mode;
   const serverUrlUnset = mergedRaw.serverUrl === void 0;
   const apiKeyUnset = mergedRaw.apiKey === void 0 || mergedRaw.apiKey === null;
-  if (serverUrlUnset && apiKeyUnset) {
+  const nothingConfigured = serverUrlUnset && apiKeyUnset;
+  const preferLocally = mode === "prefer" && !detectCi(env);
+  if (mode !== "off" && (nothingConfigured || preferLocally)) {
     const desktop = readDesktopConfig(env[PIWI_DESKTOP_CONFIG_ENV] || defaultDesktopConfigPath());
     if (desktop) {
+      if (!serverUrlUnset && mergedRaw.serverUrl !== desktop.url) desktopReplacedServerUrl = mergedRaw.serverUrl;
       mergedRaw.serverUrl = desktop.url;
       mergedRaw.apiKey = desktop.token;
+      mergedRaw.username = null;
+      mergedRaw.password = null;
       desktopDiscovered = true;
     }
   }
   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];
@@ -263,6 +380,8 @@ function resolveOptions(raw) {
 function applyOptionsToEnv(options) {
   const env = process.env;
   if (options.serverUrl !== void 0) env[PIWI_ENV_KEYS.serverUrl] = options.serverUrl;
+  if (options.desktopApp !== void 0 && !env[PIWI_ENV_KEYS.desktopApp])
+    env[PIWI_ENV_KEYS.desktopApp] = options.desktopApp;
   if (options.projectName !== void 0) env[PIWI_ENV_KEYS.projectName] = options.projectName;
   if (options.verbose !== void 0) env[PIWI_ENV_KEYS.verbose] = String(options.verbose);
   if (options.apiKey) env[PIWI_ENV_KEYS.apiKey] = options.apiKey;
@@ -292,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";
@@ -545,7 +666,7 @@ var HttpClient = class {
   }
   /** Unified request core: transport, headers, auth, response accumulation, timeout. */
   request(method, pathname, opts) {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve11, reject) => {
       if (this.closedReason !== null) {
         reject(new Error(this.closedReason));
         return;
@@ -568,7 +689,7 @@ var HttpClient = class {
             data += chunk;
           });
           res.on("end", () => {
-            resolve9({ status: res.statusCode ?? 0, text: data, headers: res.headers });
+            resolve11({ status: res.statusCode ?? 0, text: data, headers: res.headers });
           });
           res.on("error", reject);
           res.on("close", () => {
@@ -607,8 +728,8 @@ var HttpClient = class {
 };
 
 // src/internal/submit/uploader.ts
-var fs2 = __toESM(require("fs"));
-var path2 = __toESM(require("path"));
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
 var import_form_data2 = __toESM(require("form-data"));
 
 // src/internal/submit/serializer.ts
@@ -858,8 +979,8 @@ var Uploader = class {
       if (traceInfo) {
         form.append("trace_hash", traceInfo.hash);
         if (includeTraceFile2) {
-          form.append("trace", fs2.createReadStream(traceInfo.tracePath), {
-            filename: path2.basename(traceInfo.tracePath)
+          form.append("trace", fs3.createReadStream(traceInfo.tracePath), {
+            filename: path3.basename(traceInfo.tracePath)
           });
         }
       }
@@ -871,7 +992,7 @@ var Uploader = class {
           )
         );
         for (const a of attachments) {
-          form.append("attach_file", fs2.createReadStream(a.path), { filename: a.originalName });
+          form.append("attach_file", fs3.createReadStream(a.path), { filename: a.originalName });
         }
       }
       return form;
@@ -924,7 +1045,7 @@ var Uploader = class {
         )
       );
       for (const a of attachments) {
-        form.append(`attach_file_${i}`, fs2.createReadStream(a.path), { filename: a.originalName });
+        form.append(`attach_file_${i}`, fs3.createReadStream(a.path), { filename: a.originalName });
         attachmentCount++;
       }
     }
@@ -933,8 +1054,8 @@ var Uploader = class {
     let traceCount = 0;
     for (const [i, tc] of testCases.entries()) {
       for (const tp of this.fileHandler.findTraceFiles(tc)) {
-        if (fs2.existsSync(tp)) {
-          form.append(`trace_${i}`, fs2.createReadStream(tp), { filename: path2.basename(tp) });
+        if (fs3.existsSync(tp)) {
+          form.append(`trace_${i}`, fs3.createReadStream(tp), { filename: path3.basename(tp) });
           traceCount++;
         }
       }
@@ -944,9 +1065,9 @@ var Uploader = class {
 };
 
 // src/internal/streaming/stream-buffer.ts
-var path3 = __toESM(require("path"));
+var path4 = __toESM(require("path"));
 var os3 = __toESM(require("os"));
-var fs3 = __toESM(require("fs"));
+var fs4 = __toESM(require("fs"));
 
 // src/internal/support/instance-id.ts
 var crypto = __toESM(require("crypto"));
@@ -967,14 +1088,14 @@ var StreamBuffer = class {
   }
   /** Scope the buffer to a run. Until then the buffer is empty and appends are dropped. */
   bindRun(runId) {
-    this.filePath = path3.join(os3.tmpdir(), `${this.prefix}-${runId}.jsonl`);
+    this.filePath = path4.join(os3.tmpdir(), `${this.prefix}-${runId}.jsonl`);
   }
   /** Append one or more events to the on-disk buffer */
   append(events) {
     if (!this.filePath || events.length === 0) return;
     try {
       const lines = events.map((e) => JSON.stringify(e) + "\n").join("");
-      fs3.appendFileSync(this.filePath, lines, "utf8");
+      fs4.appendFileSync(this.filePath, lines, "utf8");
     } catch {
     }
   }
@@ -982,8 +1103,8 @@ var StreamBuffer = class {
   load() {
     if (!this.filePath) return [];
     try {
-      if (fs3.existsSync(this.filePath)) {
-        const content = fs3.readFileSync(this.filePath, "utf8");
+      if (fs4.existsSync(this.filePath)) {
+        const content = fs4.readFileSync(this.filePath, "utf8");
         return content.split("\n").filter(Boolean).map((line) => JSON.parse(line));
       }
     } catch {
@@ -994,7 +1115,7 @@ var StreamBuffer = class {
   clear() {
     if (!this.filePath) return;
     try {
-      if (fs3.existsSync(this.filePath)) fs3.unlinkSync(this.filePath);
+      if (fs4.existsSync(this.filePath)) fs4.unlinkSync(this.filePath);
     } catch {
     }
   }
@@ -1003,14 +1124,14 @@ var StreamBuffer = class {
     const dir = os3.tmpdir();
     let names;
     try {
-      names = fs3.readdirSync(dir).filter((name) => name.startsWith(this.prefix));
+      names = fs4.readdirSync(dir).filter((name) => name.startsWith(this.prefix));
     } catch {
       return;
     }
     for (const name of names) {
       try {
-        const file = path3.join(dir, name);
-        if (Date.now() - fs3.statSync(file).mtimeMs > maxAgeMs) fs3.unlinkSync(file);
+        const file = path4.join(dir, name);
+        if (Date.now() - fs4.statSync(file).mtimeMs > maxAgeMs) fs4.unlinkSync(file);
       } catch {
       }
     }
@@ -1019,9 +1140,9 @@ var StreamBuffer = class {
 
 // src/internal/streaming/crash-recovery.ts
 var crypto2 = __toESM(require("crypto"));
-var fs4 = __toESM(require("fs"));
+var fs5 = __toESM(require("fs"));
 var os4 = __toESM(require("os"));
-var path4 = __toESM(require("path"));
+var path5 = __toESM(require("path"));
 
 // src/internal/support/errors.ts
 function errorMessage(error) {
@@ -1036,7 +1157,7 @@ function recoveryServer(serverUrl) {
 function recoveryFilePath(serverUrl, projectName) {
   const key = crypto2.createHash("sha256").update(`${recoveryServer(serverUrl)}
 ${projectName}`).digest("hex").slice(0, 16);
-  return path4.join(os4.tmpdir(), `piwi-dashboard-recovery-${key}.json`);
+  return path5.join(os4.tmpdir(), `piwi-dashboard-recovery-${key}.json`);
 }
 function refusesRun(error) {
   return error instanceof HttpError && [400, 409, 422].includes(error.status);
@@ -1057,11 +1178,11 @@ var CrashRecovery = class {
     const file = { v: 1, serverUrl: this.serverUrl, payload };
     const temp = `${this.filePath}.${process.pid}.${crypto2.randomBytes(6).toString("hex")}.tmp`;
     try {
-      fs4.writeFileSync(temp, JSON.stringify(file), { encoding: "utf8", flag: "wx", mode: 384 });
-      fs4.renameSync(temp, this.filePath);
+      fs5.writeFileSync(temp, JSON.stringify(file), { encoding: "utf8", flag: "wx", mode: 384 });
+      fs5.renameSync(temp, this.filePath);
       this.logger.info("Saved recovery data for later upload");
     } catch (error) {
-      fs4.rmSync(temp, { force: true });
+      fs5.rmSync(temp, { force: true });
       this.logger.error(`Failed to save recovery data: ${errorMessage(error)}`);
     }
   }
@@ -1072,26 +1193,26 @@ var CrashRecovery = class {
   load() {
     let fd;
     try {
-      fd = fs4.openSync(this.filePath, fs4.constants.O_RDONLY | (fs4.constants.O_NOFOLLOW ?? 0));
+      fd = fs5.openSync(this.filePath, fs5.constants.O_RDONLY | (fs5.constants.O_NOFOLLOW ?? 0));
     } catch {
       return null;
     }
     try {
-      const stat = fs4.fstatSync(fd);
+      const stat = fs5.fstatSync(fd);
       if (!stat.isFile() || typeof process.getuid === "function" && stat.uid !== process.getuid()) return null;
-      const file = JSON.parse(fs4.readFileSync(fd, "utf8"));
+      const file = JSON.parse(fs5.readFileSync(fd, "utf8"));
       if (file?.v !== 1 || file.serverUrl !== this.serverUrl) return null;
       return file.payload && typeof file.payload === "object" ? file.payload : null;
     } catch {
       return null;
     } finally {
-      fs4.closeSync(fd);
+      fs5.closeSync(fd);
     }
   }
   /** Delete the recovery file from disk */
   clear() {
     try {
-      fs4.rmSync(this.filePath, { force: true });
+      fs5.rmSync(this.filePath, { force: true });
     } catch {
     }
   }
@@ -1123,25 +1244,25 @@ var CrashRecovery = class {
 };
 
 // src/internal/files/file-handler.ts
-var fs6 = __toESM(require("fs"));
+var fs7 = __toESM(require("fs"));
 var os5 = __toESM(require("os"));
-var path6 = __toESM(require("path"));
+var path7 = __toESM(require("path"));
 var crypto3 = __toESM(require("crypto"));
 
 // src/internal/files/compression.ts
-var fs5 = __toESM(require("fs"));
-var path5 = __toESM(require("path"));
+var fs6 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
 var zlib = __toESM(require("zlib"));
 var import_node_util = require("util");
 var gzipAsync = (0, import_node_util.promisify)(zlib.gzip);
 async function compressDirectory(sourceDir) {
   const files = [];
   function collect(dir, baseDir = "") {
-    for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
-      const full = path5.join(dir, entry.name);
-      const rel = path5.join(baseDir, entry.name);
+    for (const entry of fs6.readdirSync(dir, { withFileTypes: true })) {
+      const full = path6.join(dir, entry.name);
+      const rel = path6.join(baseDir, entry.name);
       if (entry.isDirectory()) collect(full, rel);
-      else if (entry.isFile()) files.push({ path: rel, content: fs5.readFileSync(full) });
+      else if (entry.isFile()) files.push({ path: rel, content: fs6.readFileSync(full) });
     }
   }
   collect(sourceDir);
@@ -1198,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",
@@ -1205,7 +1328,8 @@ var ATTACHMENT_NAMES = {
   userPick: "piwi-user-pick",
   aiUsage: "piwi-ai-usage",
   aiMeta: "piwi-ai-meta",
-  resources: "piwi-resources"
+  resources: "piwi-resources",
+  pauses: "piwi-pauses"
 };
 var INTERNAL_ATTACHMENT_NAMES = new Set(Object.values(ATTACHMENT_NAMES));
 var LOCATOR_SUGGESTION_ANNOTATION = ATTACHMENT_NAMES.locatorSuggestion;
@@ -1239,19 +1363,19 @@ var FileHandler = class {
   }
   /** Locate a Playwright HTML report directory containing `index.html`. Optionally override the search path. */
   findHTMLReportDirectory(customDir) {
-    const possibleDirs = customDir ? [customDir, path6.join(process.cwd(), customDir)] : ["playwright-report", "./playwright-report", path6.join(process.cwd(), "playwright-report")];
+    const possibleDirs = customDir ? [customDir, path7.join(process.cwd(), customDir)] : ["playwright-report", "./playwright-report", path7.join(process.cwd(), "playwright-report")];
     for (const reportDir of possibleDirs) {
-      if (fs6.existsSync(reportDir) && fs6.statSync(reportDir).isDirectory()) {
-        if (fs6.existsSync(path6.join(reportDir, "index.html"))) return reportDir;
+      if (fs7.existsSync(reportDir) && fs7.statSync(reportDir).isDirectory()) {
+        if (fs7.existsSync(path7.join(reportDir, "index.html"))) return reportDir;
       }
     }
     return null;
   }
   /** Check if `dir` exists and is a directory; also checks `path.join(process.cwd(), dir)` */
   findReportDirectory(dir) {
-    const candidates = [dir, path6.join(process.cwd(), dir)];
+    const candidates = [dir, path7.join(process.cwd(), dir)];
     for (const candidate of candidates) {
-      if (fs6.existsSync(candidate) && fs6.statSync(candidate).isDirectory()) return candidate;
+      if (fs7.existsSync(candidate) && fs7.statSync(candidate).isDirectory()) return candidate;
     }
     return null;
   }
@@ -1269,7 +1393,7 @@ var FileHandler = class {
     const set = /* @__PURE__ */ new Set();
     if (testCase.attachments) {
       for (const a of testCase.attachments) {
-        if (a.name === "trace" && a.path) set.add(path6.resolve(a.path));
+        if (a.name === "trace" && a.path) set.add(path7.resolve(a.path));
       }
     }
     return Array.from(set);
@@ -1297,24 +1421,24 @@ var FileHandler = class {
   cleanupBodyAttachments() {
     if (!this.bodyDir) return;
     try {
-      fs6.rmSync(this.bodyDir, { recursive: true, force: true });
+      fs7.rmSync(this.bodyDir, { recursive: true, force: true });
     } catch (error) {
       this.logger.debug(`Could not remove temp attachments at ${this.bodyDir}: ${errorMessage(error)}`);
     }
     this.bodyDir = null;
   }
   resolvePathAttachment(a, testCase) {
-    if (!a.path || !fs6.existsSync(a.path)) return null;
-    const size = fs6.statSync(a.path).size;
+    if (!a.path || !fs7.existsSync(a.path)) return null;
+    const size = fs7.statSync(a.path).size;
     if (size > this.maxAttachmentBytes) {
       this.warnOversized(a, testCase, size);
       return null;
     }
     return {
       name: a.name || "attachment",
-      path: path6.resolve(a.path),
+      path: path7.resolve(a.path),
       contentType: a.contentType || "application/octet-stream",
-      originalName: path6.basename(a.path)
+      originalName: path7.basename(a.path)
     };
   }
   resolveBodyAttachment(a, testCase) {
@@ -1329,8 +1453,8 @@ var FileHandler = class {
     let filePath2 = this.bodyFiles.get(a);
     if (!filePath2) {
       try {
-        filePath2 = path6.join(this.bodyAttachmentDir(), `${++this.bodyFileCount}-${originalName}`);
-        fs6.writeFileSync(filePath2, body);
+        filePath2 = path7.join(this.bodyAttachmentDir(), `${++this.bodyFileCount}-${originalName}`);
+        fs7.writeFileSync(filePath2, body);
         this.bodyFiles.set(a, filePath2);
       } catch (error) {
         this.logger.warn(`Could not stage attachment "${a.name}" for upload: ${errorMessage(error)}`);
@@ -1340,7 +1464,7 @@ var FileHandler = class {
     return { name: a.name || "attachment", path: filePath2, contentType, originalName };
   }
   bodyAttachmentDir() {
-    if (!this.bodyDir) this.bodyDir = fs6.mkdtempSync(path6.join(os5.tmpdir(), "piwi-dashboard-attachments-"));
+    if (!this.bodyDir) this.bodyDir = fs7.mkdtempSync(path7.join(os5.tmpdir(), "piwi-dashboard-attachments-"));
     return this.bodyDir;
   }
   warnOversized(a, testCase, size) {
@@ -1363,10 +1487,10 @@ 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 net = find(ATTACHMENT_NAMES.network);
-    if (net?.body) {
+    const net3 = find(ATTACHMENT_NAMES.network);
+    if (net3?.body) {
       try {
-        testCase.networkRequests = JSON.parse(net.body.toString());
+        testCase.networkRequests = JSON.parse(net3.body.toString());
       } catch {
       }
     }
@@ -1422,17 +1546,17 @@ var FileHandler = class {
     const tracePaths = this.findTraceFiles(testCase);
     let lastPath = null;
     for (const tp of tracePaths) {
-      if (fs6.existsSync(tp)) lastPath = tp;
+      if (fs7.existsSync(tp)) lastPath = tp;
     }
     if (!lastPath) return null;
     const hash = crypto3.createHash("sha256");
-    await new Promise((resolve9, reject) => {
-      fs6.createReadStream(lastPath).on("data", (chunk) => hash.update(chunk)).on("end", resolve9).on("error", reject);
+    await new Promise((resolve11, reject) => {
+      fs7.createReadStream(lastPath).on("data", (chunk) => hash.update(chunk)).on("end", resolve11).on("error", reject);
     });
     return {
       tracePath: lastPath,
       hash: hash.digest("hex"),
-      size: fs6.statSync(lastPath).size
+      size: fs7.statSync(lastPath).size
     };
   }
   /** Ask the server which trace hashes it already has, returning the set of hashes that are missing */
@@ -1459,14 +1583,14 @@ function formatMiB(bytes) {
 var import_node_child_process = require("child_process");
 
 // src/internal/support/test-paths.ts
-var path7 = __toESM(require("path"));
+var path8 = __toESM(require("path"));
 function configDirFromConfig(config) {
-  if (config?.configFile) return path7.dirname(config.configFile);
+  if (config?.configFile) return path8.dirname(config.configFile);
   if (config?.rootDir) return config.rootDir;
   return process.cwd();
 }
 function relativeTestPath(file, base) {
-  return path7.relative(base, file).split(path7.sep).join("/");
+  return path8.relative(base, file).split(path8.sep).join("/");
 }
 
 // src/internal/collect/metadata-collector.ts
@@ -1526,11 +1650,6 @@ function resolveScmBaseBranch(env) {
   const trimmed = target?.trim();
   return trimmed ? normalizeRef(trimmed) : void 0;
 }
-function detectCi(env) {
-  return Boolean(
-    env.JENKINS_URL || env.GITHUB_ACTIONS || env.GITLAB_CI || env.CIRCLECI || env.TRAVIS || env.TF_BUILD || env.BITBUCKET_BUILD_NUMBER || env.CI && env.CI !== "false" && env.CI !== "0"
-  );
-}
 function resolveRunOrigin(env, warn) {
   const raw = env[PIWI_ORIGIN_ENV.kind]?.trim();
   let kind = detectCi(env) ? "ci" : "local";
@@ -1769,7 +1888,7 @@ var MetadataCollector = class {
 };
 
 // src/internal/streaming/stream-manager.ts
-var fs8 = __toESM(require("fs"));
+var fs9 = __toESM(require("fs"));
 
 // src/internal/streaming/bounded-queue.ts
 var DROP_TIER = {
@@ -1908,10 +2027,10 @@ function createLimiter(maxConcurrent) {
     if (run) run();
   };
   return function limit(fn) {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve11, reject) => {
       const run = () => {
         active++;
-        Promise.resolve().then(fn).then(resolve9, reject).finally(next);
+        Promise.resolve().then(fn).then(resolve11, reject).finally(next);
       };
       if (active < limitValue) run();
       else queue.push(run);
@@ -1920,18 +2039,18 @@ function createLimiter(maxConcurrent) {
 }
 
 // src/internal/support/setup-file.ts
-var path8 = __toESM(require("path"));
+var path9 = __toESM(require("path"));
 var os6 = __toESM(require("os"));
-var fs7 = __toESM(require("fs"));
+var fs8 = __toESM(require("fs"));
 function getSetupFilePath(projectName) {
-  return path8.join(os6.tmpdir(), `piwi-dashboard-setup-${hashForProject(projectName)}.json`);
+  return path9.join(os6.tmpdir(), `piwi-dashboard-setup-${hashForProject(projectName)}.json`);
 }
 function readSetupInfo(projectName) {
   const setupFile = getSetupFilePath(projectName);
   try {
-    if (fs7.existsSync(setupFile)) {
-      const info = JSON.parse(fs7.readFileSync(setupFile, "utf8"));
-      fs7.unlinkSync(setupFile);
+    if (fs8.existsSync(setupFile)) {
+      const info = JSON.parse(fs8.readFileSync(setupFile, "utf8"));
+      fs8.unlinkSync(setupFile);
       if (info.projectName === projectName) return info;
     }
   } catch {
@@ -2009,6 +2128,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);
@@ -2033,6 +2154,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
@@ -2150,7 +2275,7 @@ var StreamManager = class {
     } catch (error) {
       if (error instanceof HttpError && (error.status === 401 || error.status === 403)) {
         this.logger.warn(
-          `Live streaming could not start: the dashboard at ${this.options.serverUrl} requires authentication. Set the reporter's \`apiKey\` option (or PIWI_API_KEY) \u2014 create a key under Settings \u2192 Users on the dashboard. Falling back to batch upload at the end of the run.`
+          `Live streaming could not start: the dashboard at ${this.options.serverUrl} requires authentication. Set the reporter's \`apiKey\` option, or PIWI_API_KEY in the environment or in the .env file next to the Playwright config \u2014 create a key under Settings \u2192 Users on the dashboard. Falling back to batch upload at the end of the run.`
         );
       } else {
         this.logger.warn(
@@ -2283,8 +2408,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;
@@ -2293,7 +2421,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() {
@@ -2387,7 +2517,7 @@ var StreamManager = class {
         this.logger.debugError(
           `${this.pendingEvents.length} events pending, retrying (attempt ${attempt + 1}/${MAX_ATTEMPTS})...`
         );
-        await new Promise((resolve9) => setTimeout(resolve9, Math.min(1e3 * Math.pow(2, attempt), 1e4)));
+        await new Promise((resolve11) => setTimeout(resolve11, Math.min(1e3 * Math.pow(2, attempt), 1e4)));
       }
       if (!this.pendingEvents.isEmpty) {
         const remaining = this.pendingEvents.takeAll();
@@ -2431,7 +2561,7 @@ var StreamManager = class {
   }
   /** Schedule a live upload of trace and attachment files for a test case. Skips cases with no files. Concurrency is limited to 2 simultaneous uploads. */
   scheduleLiveUpload(tc) {
-    const hasTrace = !!this.options.uploadTraces && this.fileHandler.findTraceFiles(tc).some((p) => fs8.existsSync(p));
+    const hasTrace = !!this.options.uploadTraces && this.fileHandler.findTraceFiles(tc).some((p) => fs9.existsSync(p));
     const hasAttachments = this.fileHandler.findAllAttachments(tc).length > 0;
     if (!hasTrace && !hasAttachments) return;
     const promise = (async () => {
@@ -2444,7 +2574,7 @@ var StreamManager = class {
       if (flush) await flush;
       const delays = [0, 1e3, 3e3];
       for (let attempt = 0; attempt < delays.length; attempt++) {
-        if (delays[attempt]) await new Promise((resolve9) => setTimeout(resolve9, delays[attempt]));
+        if (delays[attempt]) await new Promise((resolve11) => setTimeout(resolve11, delays[attempt]));
         try {
           await this.limitLiveUpload(
             () => this.uploader.uploadCaseFiles(
@@ -3259,7 +3389,7 @@ function maskUrlFragment(hash) {
 }
 
 // ../core/src/locator-break.ts
-var filePath = (path32) => path32.replace(/\\/g, "/").replace(/^\.\//, "");
+var filePath = (path34) => path34.replace(/\\/g, "/").replace(/^\.\//, "");
 function sameFilePath(a, b) {
   const x = filePath(a);
   const y = filePath(b);
@@ -3554,23 +3684,48 @@ function flattenSteps(steps, depth = 0) {
   }
   return result;
 }
-function collectStepMetrics(steps, errors) {
+function epochMs(value) {
+  if (value instanceof Date) return value.getTime();
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function pausedOverlap(start, duration, pauses) {
+  const from = epochMs(start);
+  const length = typeof duration === "number" && duration > 0 ? duration : 0;
+  if (from === null || length === 0 || pauses.length === 0) return 0;
+  const to = from + length;
+  const spans = pauses.filter((p) => p.duration > 0).map((p) => [Math.max(from, p.startedAt), Math.min(to, p.startedAt + p.duration)]).filter(([a, b]) => b > a).sort((x, y) => x[0] - y[0]);
+  let ms = 0;
+  let reached = from;
+  for (const [a, b] of spans) {
+    const begin = Math.max(a, reached);
+    if (b > begin) ms += b - begin;
+    reached = Math.max(reached, b);
+  }
+  return ms;
+}
+function unpausedDuration(step, pauses) {
+  const duration = typeof step.duration === "number" && step.duration > 0 ? step.duration : 0;
+  return duration - pausedOverlap(step.startTime, duration, pauses);
+}
+function collectStepMetrics(steps, errors, pauses = []) {
   const flatSteps = flattenSteps(steps);
   if (errors) markRecoveredSteps(flatSteps, errors);
-  const totalStepDuration = steps.reduce((sum, s) => sum + (s.duration || 0), 0);
+  const own = (s) => pauses.length > 0 && s.duration > 0 ? unpausedDuration(s, pauses) : s.duration;
+  const totalStepDuration = steps.reduce((sum, s) => sum + (own(s) || 0), 0);
   let slowestStep = null;
   for (const s of flatSteps) {
-    if (!slowestStep || s.duration > slowestStep.duration) slowestStep = { title: s.title, duration: s.duration };
+    const duration = own(s);
+    if (!slowestStep || duration > slowestStep.duration) slowestStep = { title: s.title, duration };
   }
   const navSteps = flatSteps.filter((s) => s.category === "navigation");
   const waitSteps = flatSteps.filter((s) => s.category === "wait");
-  const waitTotalDuration = waitSteps.reduce((sum, s) => sum + (s.duration || 0), 0);
+  const waitTotalDuration = waitSteps.reduce((sum, s) => sum + (own(s) || 0), 0);
   return {
     steps: flatSteps,
     totalStepDuration,
     slowestStep,
     navigationCount: navSteps.length,
-    navigationTotalDuration: navSteps.reduce((sum, s) => sum + (s.duration || 0), 0),
+    navigationTotalDuration: navSteps.reduce((sum, s) => sum + (own(s) || 0), 0),
     waitTotalDuration,
     waitCount: waitSteps.length
   };
@@ -3686,19 +3841,43 @@ function extractWaitEvents(steps, insideWait = false) {
   return events;
 }
 
+// src/internal/collect/pause-events.ts
+function readPauses(body) {
+  if (!body) return [];
+  try {
+    const value = JSON.parse(body.toString("utf8"));
+    if (!Array.isArray(value)) return [];
+    return value.filter(
+      (p) => !!p && typeof p === "object" && typeof p.location === "string" && typeof p.startedAt === "number" && typeof p.duration === "number"
+    );
+  } catch {
+    return [];
+  }
+}
+function pauseStepEvents(pauses) {
+  return pauses.map((pause) => ({
+    title: typeof pause.title === "string" ? pause.title : "",
+    category: "pause",
+    startedAt: pause.startedAt,
+    duration: Math.max(0, pause.duration),
+    status: typeof pause.reason === "string" ? pause.reason : "breakpoint",
+    location: pause.location
+  }));
+}
+
 // src/internal/support/reporter-version.ts
-var fs9 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
 var cachedVersion = null;
 var CANDIDATE_OFFSETS = ["..", "../../.."];
 function findOwnPackageJson(fromDir) {
   for (const offset of CANDIDATE_OFFSETS) {
     try {
-      const pkgPath = path9.resolve(fromDir, offset, "package.json");
-      const pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
+      const pkgPath = path10.resolve(fromDir, offset, "package.json");
+      const pkg = JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
       const { name, version } = pkg;
       if (name === "@piwitests/reporter" && typeof version === "string")
-        return { version, root: path9.dirname(pkgPath) };
+        return { version, root: path10.dirname(pkgPath) };
     } catch {
     }
   }
@@ -3711,11 +3890,11 @@ function getReporterVersion() {
 }
 
 // src/internal/support/source-snippet.ts
-var fs10 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
 function readSourceSnippet(file, declLine, context, failingLine) {
   try {
-    const content = fs10.readFileSync(file, "utf-8");
+    const content = fs11.readFileSync(file, "utf-8");
     const lines = content.split("\n");
     const anchor = failingLine ?? declLine;
     const start = Math.max(0, anchor - context - 1);
@@ -3744,7 +3923,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);
@@ -3755,66 +3934,40 @@ function collectSourceFrames(errorText, testFile2, declLine, opts = {}) {
       if (picked.length >= maxFrames) break;
       let abs;
       try {
-        abs = path10.resolve(frame.file);
+        abs = path11.resolve(frame.file);
       } catch {
         continue;
       }
-      const rel = path10.relative(projectRoot, abs);
-      if (rel.startsWith("..") || path10.isAbsolute(rel)) continue;
-      if (!isNaN(frame.line)) add(abs, frame.line);
+      const rel = path11.relative(projectRoot, abs);
+      if (rel.startsWith("..") || path11.isAbsolute(rel)) continue;
+      if (!isNaN(frame.line)) add2(abs, frame.line);
     }
   }
-  const absTest = path10.resolve(testFile2);
+  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)) {
     const snippet = readSourceSnippet(p.absFile, p.line, context, p.line);
     if (snippet) {
-      frames.push({ file: path10.relative(projectRoot, p.absFile) || path10.basename(p.absFile), line: p.line, snippet });
+      frames.push({ file: path11.relative(projectRoot, p.absFile) || path11.basename(p.absFile), line: p.line, snippet });
     }
   }
   return frames;
 }
 function extractFailingLine(errorText, testFile2, declarationLine) {
   if (!errorText) return declarationLine;
-  const expectedFile = path10.resolve(testFile2);
+  const expectedFile = path11.resolve(testFile2);
   for (const frame of stackFrames(errorText)) {
     try {
-      if (path10.resolve(frame.file) === expectedFile && !isNaN(frame.line)) return frame.line;
+      if (path11.resolve(frame.file) === expectedFile && !isNaN(frame.line)) return frame.line;
     } catch {
     }
   }
   return declarationLine;
 }
 
-// src/internal/support/ci.ts
-function detectCiIds(env) {
-  if (env.GITHUB_ACTIONS && env.GITHUB_RUN_ID) {
-    const run = env.GITHUB_RUN_ATTEMPT ? `${env.GITHUB_RUN_ID}-${env.GITHUB_RUN_ATTEMPT}` : env.GITHUB_RUN_ID;
-    return { run, job: env.GITHUB_JOB || null };
-  }
-  if (env.GITLAB_CI && env.CI_PIPELINE_ID) return { run: env.CI_PIPELINE_ID, job: env.CI_JOB_ID || null };
-  if (env.CIRCLECI && env.CIRCLE_WORKFLOW_ID) return { run: env.CIRCLE_WORKFLOW_ID, job: env.CIRCLE_BUILD_NUM || null };
-  if (env.TRAVIS && env.TRAVIS_BUILD_ID) return { run: env.TRAVIS_BUILD_ID, job: env.TRAVIS_JOB_ID || null };
-  if (env.TF_BUILD && env.BUILD_BUILDID) return { run: env.BUILD_BUILDID, job: env.SYSTEM_JOBID || null };
-  if (env.JENKINS_URL && env.BUILD_ID) return { run: env.BUILD_ID, job: null };
-  if (env.BUILDKITE_BUILD_ID) return { run: env.BUILDKITE_BUILD_ID, job: env.BUILDKITE_JOB_ID || null };
-  if (env.TEAMCITY_BUILD_ID) return { run: env.TEAMCITY_BUILD_ID, job: null };
-  if (env.BITBUCKET_BUILD_NUMBER) return { run: env.BITBUCKET_BUILD_NUMBER, job: env.BITBUCKET_STEP_UUID || null };
-  if (env.SEMAPHORE_WORKFLOW_ID) return { run: env.SEMAPHORE_WORKFLOW_ID, job: env.SEMAPHORE_JOB_ID || null };
-  if (env.APPVEYOR_BUILD_ID) return { run: env.APPVEYOR_BUILD_ID, job: env.APPVEYOR_JOB_ID || null };
-  if (env.DRONE_BUILD_NUMBER) return { run: env.DRONE_BUILD_NUMBER, job: null };
-  return null;
-}
-function resolveRunLabel(configured, sharded) {
-  if (configured) return configured;
-  const ci = detectCiIds(process.env);
-  if (!ci) return null;
-  return !sharded && ci.job ? `${ci.run}|${ci.job}` : ci.run;
-}
-
 // src/internal/support/worker-index.ts
 function workerIndexOf(result) {
   if (!result) return null;
@@ -3900,28 +4053,28 @@ function isListMode(argv = process.argv) {
 }
 
 // src/public/global-setup.ts
-var path14 = __toESM(require("path"));
-var fs14 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
 
 // src/internal/support/aria-sampling.ts
-var path11 = __toESM(require("path"));
+var path12 = __toESM(require("path"));
 var os7 = __toESM(require("os"));
-var fs11 = __toESM(require("fs"));
+var fs12 = __toESM(require("fs"));
 function ariaSampleIdentity(filePath2, title) {
   return `${filePath2}\0${title}`;
 }
 function getAriaSampleFilePath(projectName) {
-  return path11.join(os7.tmpdir(), `piwi-dashboard-aria-sample-${hashForProject(projectName)}.json`);
+  return path12.join(os7.tmpdir(), `piwi-dashboard-aria-sample-${hashForProject(projectName)}.json`);
 }
 function writeAriaSampleFile(projectName, identities) {
   try {
-    fs11.writeFileSync(getAriaSampleFilePath(projectName), JSON.stringify({ projectName, identities }));
+    fs12.writeFileSync(getAriaSampleFilePath(projectName), JSON.stringify({ projectName, identities }));
   } catch {
   }
 }
 function clearAriaSampleFile(projectName) {
   try {
-    fs11.rmSync(getAriaSampleFilePath(projectName), { force: true });
+    fs12.rmSync(getAriaSampleFilePath(projectName), { force: true });
   } catch {
   }
 }
@@ -3930,7 +4083,7 @@ function loadAriaSampleSet(projectName) {
   if (cachedSets.has(projectName)) return cachedSets.get(projectName);
   let set = null;
   try {
-    const raw = fs11.readFileSync(getAriaSampleFilePath(projectName), "utf8");
+    const raw = fs12.readFileSync(getAriaSampleFilePath(projectName), "utf8");
     const parsed2 = JSON.parse(raw);
     if (parsed2.projectName === projectName && Array.isArray(parsed2.identities)) {
       set = new Set(parsed2.identities.filter((x) => typeof x === "string"));
@@ -3952,6 +4105,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;
@@ -3973,9 +4127,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;
@@ -3985,7 +4139,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")) {
@@ -4007,23 +4161,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 connect2 = use.connectOptions;
+  if (!connect2 || typeof connect2 !== "object" || typeof connect2.wsEndpoint !== "string") return false;
+  return !exposeNetworkCovers(typeof connect2.exposeNetwork === "string" ? connect2.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()];
@@ -4060,18 +4249,25 @@ async function checkBaseUrl(target, options = {}) {
     } else {
       reason = outcome.error;
     }
-    if (attempt < attempts) await new Promise((resolve9) => setTimeout(resolve9, delayMs));
+    if (attempt < attempts) await new Promise((resolve11) => setTimeout(resolve11, delayMs));
   }
   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:`,
@@ -4084,14 +4280,14 @@ async function checkBaseUrls(config, options = {}) {
 }
 
 // src/internal/manifest/collect.ts
-var fs12 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var fs13 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
 
 // src/internal/transport/backend-request.ts
 var http2 = __toESM(require("http"));
 var https2 = __toESM(require("https"));
 function backendRequest(url, init) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve11, reject) => {
     const target = new URL(url);
     const headers = { ...init.headers };
     if (init.body !== void 0) headers["Content-Length"] = Buffer.byteLength(init.body);
@@ -4106,7 +4302,7 @@ function backendRequest(url, init) {
       });
       res.on(
         "end",
-        () => resolve9({ status: res.statusCode ?? 0, headers: res.headers, text: Buffer.concat(chunks).toString("utf8") })
+        () => resolve11({ status: res.statusCode ?? 0, headers: res.headers, text: Buffer.concat(chunks).toString("utf8") })
       );
       res.on("error", reject);
       res.on("close", () => {
@@ -4151,10 +4347,10 @@ function hasInstrumentationHeader(headers) {
   return INSTRUMENTATION_HEADERS.some((h) => get(h) != null && get(h) !== "");
 }
 function readCommittedManifest(configDir) {
-  const file = path12.join(configDir, COMMITTED_MANIFEST_FILE);
+  const file = path13.join(configDir, COMMITTED_MANIFEST_FILE);
   try {
-    if (!fs12.existsSync(file)) return null;
-    return parseManifestJson(fs12.readFileSync(file, "utf8"));
+    if (!fs13.existsSync(file)) return null;
+    return parseManifestJson(fs13.readFileSync(file, "utf8"));
   } catch {
     return null;
   }
@@ -4180,8 +4376,8 @@ function backendManifestFetch(insecure) {
 function instrumentationManifestUrls(baseUrl) {
   const base = new URL(baseUrl);
   const root = new URL(INSTRUMENTATION_MANIFEST_PATH, base).toString();
-  const path32 = base.pathname.replace(/\/+$/, "");
-  return path32 ? [new URL(`${path32}${INSTRUMENTATION_MANIFEST_PATH}`, base).toString(), root] : [root];
+  const path34 = base.pathname.replace(/\/+$/, "");
+  return path34 ? [new URL(`${path34}${INSTRUMENTATION_MANIFEST_PATH}`, base).toString(), root] : [root];
 }
 async function fetchInstrumentationManifest(baseUrl, fetchImpl = fetch) {
   try {
@@ -4319,13 +4515,13 @@ function normalizeFunctionRanges(ranges) {
 }
 function normalizeCoveragePath(raw) {
   if (typeof raw !== "string" || raw.length > MAX_PATH_LENGTH || raw.includes("\0")) return null;
-  const path32 = raw.replace(/\\/g, "/").replace(/^\.\//, "");
-  if (!path32 || path32.startsWith("../") || path32.startsWith("/") || /^[A-Za-z]:\//.test(path32)) return null;
-  if (/(^|\/)node_modules\//.test(path32)) return null;
-  return path32;
+  const path34 = raw.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (!path34 || path34.startsWith("../") || path34.startsWith("/") || /^[A-Za-z]:\//.test(path34)) return null;
+  if (/(^|\/)node_modules\//.test(path34)) return null;
+  return path34;
 }
-function fileEntry(path32, runtime, blob, functions = [], lines = []) {
-  const file = { path: path32, runtime };
+function fileEntry(path34, runtime, blob, functions = [], lines = []) {
+  const file = { path: path34, runtime };
   if (blob && (functions.length > 0 || lines.length > 0)) file.blob = blob;
   if (functions.length > 0) file.functions = functions;
   if (lines.length > 0) file.lines = lines;
@@ -4344,11 +4540,11 @@ function sanitizeCoverage(raw) {
   const files = [];
   for (const item of raw.files) {
     if (!isRecord(item) || !isRuntime(item.runtime)) continue;
-    const path32 = normalizeCoveragePath(item.path);
-    if (path32 === null) continue;
+    const path34 = normalizeCoveragePath(item.path);
+    if (path34 === null) continue;
     const blob = typeof item.blob === "string" && BLOB_ID.test(item.blob) ? item.blob : void 0;
     files.push(
-      fileEntry(path32, item.runtime, blob, normalizeFunctionRanges(item.functions), normalizeLineRanges(item.lines))
+      fileEntry(path34, item.runtime, blob, normalizeFunctionRanges(item.functions), normalizeLineRanges(item.lines))
     );
   }
   const merged = mergeCoverage(captureOf(files, raw.incomplete === true));
@@ -4413,8 +4609,8 @@ function reduceCoverage(capture, granularity) {
 
 // src/internal/collect/source-checksums.ts
 var crypto4 = __toESM(require("crypto"));
-var fs13 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var path14 = __toESM(require("path"));
 var CHECKSUM = /^(sha1|sha256):[0-9a-f]{40,64}$/;
 function checksumsOf(raw) {
   if (!Array.isArray(raw)) return [];
@@ -4479,10 +4675,10 @@ var SourceChecksums = class {
   }
   async read(relativePath2) {
     try {
-      const root = path13.resolve(this.repoRoot());
-      const file = path13.resolve(root, relativePath2);
-      if (!file.startsWith(root + path13.sep)) return null;
-      return contentChecksums(await fs13.promises.readFile(file));
+      const root = path14.resolve(this.repoRoot());
+      const file = path14.resolve(root, relativePath2);
+      if (!file.startsWith(root + path14.sep)) return null;
+      return contentChecksums(await fs14.promises.readFile(file));
     } catch {
       return null;
     }
@@ -4576,7 +4772,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) {
@@ -4627,13 +4823,13 @@ var ServerCoverageCollector = class {
     if (parts.length === 0 || this.closer.signal.aborted) {
       return Promise.resolve({ files: [], incomplete: truncated || parts.length > 0 });
     }
-    return new Promise((resolve9) => {
+    return new Promise((resolve11) => {
       const entry = {
         pending: parts.length,
         captures: [],
         checksums: /* @__PURE__ */ new Map(),
         incomplete: truncated,
-        resolve: resolve9
+        resolve: resolve11
       };
       for (const [origin, ids] of parts) this.enqueue(origin, { entry, ids });
     });
@@ -4959,14 +5155,14 @@ var ServerCoverageCollector = class {
 // src/public/global-setup.ts
 function createGlobalSetup(options, userSetup) {
   return async function globalSetupFn(config) {
-    const piwiReporterPath = path14.resolve(__dirname, "./index.js");
+    const piwiReporterPath = path15.resolve(__dirname, "./index.js");
     let inlineReporterOptions = {};
     if (Array.isArray(config?.reporter)) {
       for (const r of config.reporter) {
         if (!Array.isArray(r) || typeof r[0] !== "string") continue;
         const isPiwi = r[0].toLowerCase().includes("piwi") || (() => {
           try {
-            return path14.resolve(require.resolve(r[0])) === piwiReporterPath;
+            return path15.resolve(require.resolve(r[0])) === piwiReporterPath;
           } catch {
             return false;
           }
@@ -4977,7 +5173,10 @@ function createGlobalSetup(options, userSetup) {
         }
       }
     }
-    const opts = resolveOptions({ ...inlineReporterOptions, ...options });
+    const opts = resolveOptions(
+      { ...inlineReporterOptions, ...options },
+      configDirFromConfig(config)
+    );
     const logger = new Logger(opts.verbose ?? false);
     if (isUiMode()) {
       logger.debug("UI mode detected \u2014 skipping run registration.");
@@ -4991,7 +5190,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.");
@@ -5002,7 +5210,7 @@ function createGlobalSetup(options, userSetup) {
       if (!Array.isArray(r) || typeof r[0] !== "string") return false;
       if (r[0].toLowerCase().includes("piwi")) return true;
       try {
-        return path14.resolve(require.resolve(r[0])) === piwiReporterPath;
+        return path15.resolve(require.resolve(r[0])) === piwiReporterPath;
       } catch {
         return false;
       }
@@ -5032,7 +5240,7 @@ function createGlobalSetup(options, userSetup) {
         auth
       );
       if (response?.runId && response?.setupToken) {
-        fs14.writeFileSync(
+        fs15.writeFileSync(
           getSetupFilePath(opts.projectName),
           JSON.stringify({
             runId: response.runId,
@@ -5086,11 +5294,11 @@ function createGlobalSetup(options, userSetup) {
 }
 
 // src/public/config-wrapper.ts
-var path15 = __toESM(require("path"));
-var fs17 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
+var fs18 = __toESM(require("fs"));
 
 // src/internal/probe/mode.ts
-var fs15 = __toESM(require("fs"));
+var fs16 = __toESM(require("fs"));
 
 // src/internal/probe/plan.ts
 function probeRunMetadata(base = {}) {
@@ -5102,8 +5310,8 @@ function parseRouteKey(routeKey2) {
   return { method: routeKey2.slice(0, space).toUpperCase(), pattern: routeKey2.slice(space + 1) };
 }
 function patternToRegex(pattern) {
-  const path32 = pattern.split("?")[0] ?? pattern;
-  const escaped = path32.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:[A-Za-z0-9_]+/g, "[^/]+");
+  const path34 = pattern.split("?")[0] ?? pattern;
+  const escaped = path34.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:[A-Za-z0-9_]+/g, "[^/]+");
   return new RegExp(`^${escaped}$`);
 }
 function suitePathEqual(a, b) {
@@ -5126,13 +5334,13 @@ function matchProbeItem(plan, test) {
 function requestMatchesRoute(method, url, routeKey2) {
   const { method: rm, pattern } = parseRouteKey(routeKey2);
   if (rm && rm !== method.toUpperCase()) return false;
-  let path32;
+  let path34;
   try {
-    path32 = new URL(url).pathname;
+    path34 = new URL(url).pathname;
   } catch {
-    path32 = url.split("?")[0] ?? url;
+    path34 = url.split("?")[0] ?? url;
   }
-  return patternToRegex(pattern).test(path32);
+  return patternToRegex(pattern).test(path34);
 }
 function createProbeState() {
   return { navigated: false, matches: 0 };
@@ -5154,10 +5362,10 @@ function isProbeMode() {
 function loadPlan() {
   if (planCache !== void 0) return planCache;
   planCache = null;
-  const path32 = process.env[PIWI_PROBE_ENV.plan];
-  if (path32) {
+  const path34 = process.env[PIWI_PROBE_ENV.plan];
+  if (path34) {
     try {
-      planCache = JSON.parse(fs15.readFileSync(path32, "utf8"));
+      planCache = JSON.parse(fs16.readFileSync(path34, "utf8"));
     } catch {
       planCache = null;
     }
@@ -5181,17 +5389,17 @@ function outcomeFromStatus(status, applied) {
   return status === "failed" || status === "timedOut" || status === "interrupted" ? "noticed" : "not-noticed";
 }
 function recordProbeOutcome(line) {
-  const path32 = process.env[PIWI_PROBE_ENV.results];
-  if (!path32) return;
+  const path34 = process.env[PIWI_PROBE_ENV.results];
+  if (!path34) return;
   try {
-    fs15.appendFileSync(path32, `${JSON.stringify(line)}
+    fs16.appendFileSync(path34, `${JSON.stringify(line)}
 `);
   } catch {
   }
 }
 
 // src/internal/flake/mode.ts
-var fs16 = __toESM(require("fs"));
+var fs17 = __toESM(require("fs"));
 
 // ../core/src/error-signature.ts
 var UUID_RE = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi;
@@ -5567,7 +5775,7 @@ function originOf2(url) {
     return null;
   }
 }
-var sleep = (ms) => new Promise((resolve9) => setTimeout(resolve9, Math.max(0, ms)));
+var sleep = (ms) => new Promise((resolve11) => setTimeout(resolve11, Math.max(0, ms)));
 async function performRouteAction(route, action, startedAt) {
   switch (action.kind) {
     case "abort":
@@ -5691,7 +5899,7 @@ function loadFlakePlan() {
   if (planCache2 && planCache2.file === file) return planCache2.plan;
   let text;
   try {
-    text = fs16.readFileSync(file, "utf8");
+    text = fs17.readFileSync(file, "utf8");
   } catch (error) {
     throw new Error(`[Piwi Dashboard] Cannot read the flake plan ${file}: ${errorMessage(error)}`);
   }
@@ -5852,7 +6060,7 @@ function recordFlakeResult(line) {
   const file = process.env[PIWI_FLAKE_ENV.results]?.trim();
   if (!file) return;
   try {
-    fs16.appendFileSync(file, `${JSON.stringify(line)}
+    fs17.appendFileSync(file, `${JSON.stringify(line)}
 `);
   } catch {
   }
@@ -5923,11 +6131,11 @@ function injectReporter(reporter, piwiOptions) {
 }
 function resolveSetupModule() {
   const candidates = [
-    path15.join(__dirname, "global-setup-module.js"),
-    path15.join(__dirname, "..", "global-setup-module.js"),
-    path15.join(__dirname, "..", "global-setup-module.ts")
+    path16.join(__dirname, "global-setup-module.js"),
+    path16.join(__dirname, "..", "global-setup-module.js"),
+    path16.join(__dirname, "..", "global-setup-module.ts")
   ];
-  return candidates.find((candidate) => fs17.existsSync(candidate)) ?? candidates[0];
+  return candidates.find((candidate) => fs18.existsSync(candidate)) ?? candidates[0];
 }
 function wrapConfig(config, piwiOptions) {
   if (piwiOptions) applyOptionsToEnv(piwiOptions);
@@ -6323,8 +6531,8 @@ function buildErrorText(result, base = process.cwd()) {
 var import_node_crypto2 = require("crypto");
 
 // src/internal/support/ci-output.ts
-var fs18 = __toESM(require("fs"));
-var path16 = __toESM(require("path"));
+var fs19 = __toESM(require("fs"));
+var path17 = __toESM(require("path"));
 var SUMMARY_MAX_FAILURES = 20;
 function emitRunOutputs(output, logger, outputFile, env = process.env) {
   logger.info(`View run: ${output.runUrl}`);
@@ -6334,9 +6542,9 @@ function emitRunOutputs(output, logger, outputFile, env = process.env) {
 }
 function writeOutputFile(file, output, logger) {
   try {
-    const dir = path16.dirname(file);
-    if (dir && dir !== ".") fs18.mkdirSync(dir, { recursive: true });
-    fs18.writeFileSync(
+    const dir = path17.dirname(file);
+    if (dir && dir !== ".") fs19.mkdirSync(dir, { recursive: true });
+    fs19.writeFileSync(
       file,
       JSON.stringify(
         {
@@ -6416,7 +6624,7 @@ function emitGitLabDotenv(output, env, logger) {
   if (output.projectId != null) lines.push(`PIWI_PROJECT_ID=${output.projectId}`);
   if (output.ciBuildUrl) lines.push(`PIWI_CI_BUILD_URL=${output.ciBuildUrl}`);
   try {
-    fs18.writeFileSync(file, lines.join("\n") + "\n");
+    fs19.writeFileSync(file, lines.join("\n") + "\n");
     logger.info(`Wrote GitLab dotenv report to ${file} (declare it as artifacts:reports:dotenv)`);
   } catch (error) {
     logger.warn(`Failed to write GitLab dotenv file '${file}': ${errorMessage(error)}`);
@@ -6433,7 +6641,7 @@ function emitResourceSummary(lines, logger, env = process.env) {
 }
 function appendFileLines(file, lines, logger, label) {
   try {
-    fs18.appendFileSync(file, lines.join("\n") + "\n");
+    fs19.appendFileSync(file, lines.join("\n") + "\n");
   } catch (error) {
     logger.warn(`Failed to write GitHub Actions ${label}: ${errorMessage(error)}`);
   }
@@ -6446,8 +6654,8 @@ function ciBuildUrlFromMetadata(metadata) {
 
 // src/internal/submit/run-submitter.ts
 var MAX_TIMER_DELAY_MS = 2 ** 31 - 1;
-function markSubmitFallback(run, path32, reason) {
-  run.metadata.ingestHealth = { submitFallback: { path: path32, reason } };
+function markSubmitFallback(run, path34, reason) {
+  run.metadata.ingestHealth = { submitFallback: { path: path34, reason } };
 }
 var RunSubmitter = class {
   /**
@@ -6708,7 +6916,7 @@ var RunSubmitter = class {
    */
   stopForMissingAuth(run, payload) {
     this.logger.error(
-      `Authentication is required by ${run.options.serverUrl ?? "the dashboard"} but no credentials were configured. Create an API key (Settings \u2192 Users on the dashboard) and set the reporter's \`apiKey\` option or the PIWI_API_KEY environment variable.`
+      `Authentication is required by ${run.options.serverUrl ?? "the dashboard"} but no credentials were configured. Create an API key (Settings \u2192 Users on the dashboard) and set the reporter's \`apiKey\` option, or PIWI_API_KEY in the environment or in the .env file next to the Playwright config.`
     );
     this.logRecoverySaved();
     this.saveRecovery(payload);
@@ -6723,13 +6931,13 @@ var RunSubmitter = class {
 };
 
 // src/internal/capture/resource-ledger.ts
-var fs20 = __toESM(require("fs"));
-var path19 = __toESM(require("path"));
+var fs21 = __toESM(require("fs"));
+var path20 = __toESM(require("path"));
 var import_node_module2 = require("module");
 
 // src/internal/capture/quiet-capture.ts
 var import_node_module = require("module");
-var path17 = __toESM(require("path"));
+var path18 = __toESM(require("path"));
 var BOXED_PREFIX_EXPORTS = [
   [
     "playwright-core/lib/coreBundle",
@@ -6766,7 +6974,7 @@ function resolveBoxing() {
       if (typeof set !== "function") continue;
       return {
         set,
-        prefixes: [path17.dirname(playwrightPackageJson), path17.join(root, "dist") + path17.sep]
+        prefixes: [path18.dirname(playwrightPackageJson), path18.join(root, "dist") + path18.sep]
       };
     }
   } catch {
@@ -6798,12 +7006,12 @@ function internalCall(owner, run) {
 var import_node_perf_hooks = require("perf_hooks");
 
 // src/internal/support/system-readers.ts
-var fs19 = __toESM(require("fs"));
-var path18 = __toESM(require("path"));
+var fs20 = __toESM(require("fs"));
+var path19 = __toESM(require("path"));
 var CLK_TCK = 100;
 function readText(file) {
   try {
-    return fs19.readFileSync(file, "utf8");
+    return fs20.readFileSync(file, "utf8");
   } catch {
     return null;
   }
@@ -6937,45 +7145,45 @@ var ProcFs = class {
   }
   /** Whether this looks like a Linux `/proc` at all. */
   available() {
-    return fs19.existsSync(path18.join(this.root, "stat"));
+    return fs20.existsSync(path19.join(this.root, "stat"));
   }
   /** Every process, keyed by pid. */
   table() {
     const out = /* @__PURE__ */ new Map();
     let names;
     try {
-      names = fs19.readdirSync(this.root);
+      names = fs20.readdirSync(this.root);
     } catch {
       return out;
     }
     for (const name of names) {
       if (!/^\d+$/.test(name)) continue;
-      const text = readText(path18.join(this.root, name, "stat"));
+      const text = readText(path19.join(this.root, name, "stat"));
       const stat = text ? parseProcStat(Number(name), text) : null;
       if (stat) out.set(stat.pid, stat);
     }
     return out;
   }
   stat(pid) {
-    const text = readText(path18.join(this.root, String(pid), "stat"));
+    const text = readText(path19.join(this.root, String(pid), "stat"));
     return text ? parseProcStat(pid, text) : null;
   }
   runWaitMs(pid) {
-    const text = readText(path18.join(this.root, String(pid), "schedstat"));
+    const text = readText(path19.join(this.root, String(pid), "schedstat"));
     return text ? parseSchedstat(text) : null;
   }
   cmdline(pid) {
-    return (readText(path18.join(this.root, String(pid), "cmdline")) ?? "").split("\0").join(" ").trim();
+    return (readText(path19.join(this.root, String(pid), "cmdline")) ?? "").split("\0").join(" ").trim();
   }
   /** A field of `/proc/<pid>/status`, in kB: `VmRSS`, `VmHWM`. */
   statusKb(pid, key) {
-    const text = readText(path18.join(this.root, String(pid), "status"));
+    const text = readText(path19.join(this.root, String(pid), "status"));
     return text ? parseKbField(text, key) : null;
   }
   /** Proportional set size: shared pages split between the processes sharing them, so a sum counts them once. */
   async pssKb(pid) {
     try {
-      return parseKbField(await fs19.promises.readFile(path18.join(this.root, String(pid), "smaps_rollup"), "utf8"), "Pss");
+      return parseKbField(await fs20.promises.readFile(path19.join(this.root, String(pid), "smaps_rollup"), "utf8"), "Pss");
     } catch {
       return null;
     }
@@ -6983,29 +7191,29 @@ var ProcFs = class {
   /** Reset a process's peak RSS (`VmHWM`) to its current RSS. */
   resetPeakRss(pid) {
     try {
-      fs19.writeFileSync(path18.join(this.root, String(pid), "clear_refs"), "5");
+      fs20.writeFileSync(path19.join(this.root, String(pid), "clear_refs"), "5");
       return true;
     } catch {
       return false;
     }
   }
   cpuTicks() {
-    const text = readText(path18.join(this.root, "stat"));
+    const text = readText(path19.join(this.root, "stat"));
     return text ? parseCpuTicks(text) : null;
   }
   /** Total stall time of a resource's pressure file, in µs. */
   pressureUs(resource) {
-    const text = readText(path18.join(this.root, "pressure", resource));
+    const text = readText(path19.join(this.root, "pressure", resource));
     return text ? parsePsiTotal(text) : null;
   }
   memAvailableKb() {
-    const text = readText(path18.join(this.root, "meminfo"));
+    const text = readText(path19.join(this.root, "meminfo"));
     return text ? parseKbField(text, "MemAvailable") : null;
   }
   /** Open file descriptors of a process. */
   fdCount(pid) {
     try {
-      return fs19.readdirSync(path18.join(this.root, String(pid), "fd")).length;
+      return fs20.readdirSync(path19.join(this.root, String(pid), "fd")).length;
     } catch {
       return null;
     }
@@ -7026,7 +7234,7 @@ var CgroupFs = class {
   }
   /** The directory of a controller (v1) or of the unified hierarchy (v2), when it exists. */
   dirs() {
-    const text = readText(path18.join(this.procRoot, String(this.pid), "cgroup"));
+    const text = readText(path19.join(this.procRoot, String(this.pid), "cgroup"));
     if (!text) return null;
     const v1 = /* @__PURE__ */ new Map();
     let v2 = null;
@@ -7037,21 +7245,21 @@ var CgroupFs = class {
       else for (const controller of match[1].split(",")) v1.set(controller, match[2]);
     }
     const pick = (mount, sub) => {
-      const nested = path18.join(mount, sub);
-      if (fs19.existsSync(nested)) return nested;
-      return fs19.existsSync(mount) ? mount : null;
+      const nested = path19.join(mount, sub);
+      if (fs20.existsSync(nested)) return nested;
+      return fs20.existsSync(mount) ? mount : null;
     };
     if (v1.has("memory") || v1.has("cpu")) {
       const memoryPath = v1.get("memory");
       const cpuPath = v1.get("cpu");
-      const cpuMount = ["cpu,cpuacct", "cpu"].map((name) => path18.join(this.cgroupRoot, name)).find((dir) => fs19.existsSync(dir));
+      const cpuMount = ["cpu,cpuacct", "cpu"].map((name) => path19.join(this.cgroupRoot, name)).find((dir) => fs20.existsSync(dir));
       return {
         version: 1,
-        memory: memoryPath !== void 0 ? pick(path18.join(this.cgroupRoot, "memory"), memoryPath) : null,
+        memory: memoryPath !== void 0 ? pick(path19.join(this.cgroupRoot, "memory"), memoryPath) : null,
         cpu: cpuPath !== void 0 && cpuMount ? pick(cpuMount, cpuPath) : null
       };
     }
-    if (v2 !== null && fs19.existsSync(path18.join(this.cgroupRoot, "cgroup.controllers"))) {
+    if (v2 !== null && fs20.existsSync(path19.join(this.cgroupRoot, "cgroup.controllers"))) {
       const dir = pick(this.cgroupRoot, v2);
       return { version: 2, memory: dir, cpu: dir };
     }
@@ -7060,7 +7268,7 @@ var CgroupFs = class {
   read() {
     const dirs = this.dirs();
     if (!dirs) return null;
-    const file = (dir, name) => dir ? readText(path18.join(dir, name)) : null;
+    const file = (dir, name) => dir ? readText(path19.join(dir, name)) : null;
     if (dirs.version === 2) {
       const max = file(dirs.memory, "memory.max");
       const cpuMax = file(dirs.cpu, "cpu.max")?.trim().split(/\s+/);
@@ -7246,10 +7454,10 @@ var PAGE_READ_TIMEOUT_MS = 1e3;
 var HOOK_PHASES = /* @__PURE__ */ new Set(["beforeAll", "afterAll", "beforeEach", "afterEach"]);
 var KIND_ORDER = { browser: 0, context: 1, page: 2, request: 3 };
 function relativePath(file) {
-  return path19.relative(process.cwd(), file.replace(/^file:\/\//, "")).split(path19.sep).join("/");
+  return path20.relative(process.cwd(), file.replace(/^file:\/\//, "")).split(path20.sep).join("/");
 }
 function isLibraryFile(file) {
-  return file.startsWith("node:") || file.startsWith("internal/") || file.includes(`${path19.sep}node_modules${path19.sep}`) || file.includes("/node_modules/") || file === __filename;
+  return file.startsWith("node:") || file.startsWith("internal/") || file.includes(`${path20.sep}node_modules${path20.sep}`) || file.includes("/node_modules/") || file === __filename;
 }
 function userSite(stack) {
   for (const line of (stack ?? "").split("\n").slice(1)) {
@@ -7297,7 +7505,7 @@ function playwrightTestInfoSource() {
   try {
     const packageJson = resolvePlaywrightPackageJson();
     if (!packageJson) return () => null;
-    const globals = (0, import_node_module2.createRequire)(packageJson)(path19.join(path19.dirname(packageJson), "lib", "globals.js"));
+    const globals = (0, import_node_module2.createRequire)(packageJson)(path20.join(path20.dirname(packageJson), "lib", "globals.js"));
     const read = globals.currentTestInfo;
     if (typeof read !== "function") return () => null;
     return () => {
@@ -7326,15 +7534,15 @@ function countHandles() {
 async function settledHandles(start) {
   const end = countHandles();
   if (!Object.entries(end).some(([type, n]) => n > (start[type] ?? 0))) return end;
-  await new Promise((resolve9) => setTimeout(resolve9, 0));
+  await new Promise((resolve11) => setTimeout(resolve11, 0));
   return countHandles();
 }
 function settleWithin(promise, ms) {
   let timer;
   return Promise.race([
     promise.catch(() => void 0),
-    new Promise((resolve9) => {
-      timer = setTimeout(resolve9, ms);
+    new Promise((resolve11) => {
+      timer = setTimeout(resolve11, ms);
     })
   ]).finally(() => clearTimeout(timer));
 }
@@ -7463,7 +7671,7 @@ var ResourceLedger = class {
     const census = this.census(null);
     if (this.resultsFile) {
       try {
-        fs20.appendFileSync(this.resultsFile, `${JSON.stringify(census)}
+        fs21.appendFileSync(this.resultsFile, `${JSON.stringify(census)}
 `);
       } catch {
       }
@@ -7786,7 +7994,7 @@ async function recordResourceCensus(testInfo) {
 }
 
 // src/internal/collect/resource-verdicts.ts
-var path20 = __toESM(require("path"));
+var path21 = __toESM(require("path"));
 var OPEN_STEP_TITLES = {
   "Create context": "context",
   "Launch persistent context": "context",
@@ -7818,7 +8026,7 @@ function userFixturesOf(steps) {
   const walk = (list) => {
     for (const step of list) {
       const file = step.location?.file;
-      if (step.category === "fixture" && file && !file.includes(`${path20.sep}node_modules${path20.sep}`)) {
+      if (step.category === "fixture" && file && !file.includes(`${path21.sep}node_modules${path21.sep}`)) {
         const name = step.title.replace(/^(?:Fixture\s+|fixture:\s*)/, "").replace(/^"(.*)"$/, "$1");
         if (!name.startsWith("piwi")) out.push(`${name} (${relativeFile(file)}:${step.location.line})`);
       }
@@ -7851,7 +8059,7 @@ function tallyLifecycleSteps(file, steps) {
   return tally;
 }
 function relativeFile(file) {
-  return path20.relative(process.cwd(), file).split(path20.sep).join("/");
+  return path21.relative(process.cwd(), file).split(path21.sep).join("/");
 }
 function buildResourceReport(input) {
   const findings = [];
@@ -8209,9 +8417,9 @@ function formatResourceSummary(report, leakCheck, maxLines = 10) {
 }
 
 // src/internal/collect/process-sampler.ts
-var fs21 = __toESM(require("fs"));
+var fs22 = __toESM(require("fs"));
 var os8 = __toESM(require("os"));
-var path21 = __toESM(require("path"));
+var path22 = __toESM(require("path"));
 var import_node_child_process2 = require("child_process");
 var WALK_FILE_CAP = 1e4;
 var SERIES_CAP = 3600;
@@ -8251,17 +8459,17 @@ function nodeCpuTicks() {
   return { busy, idle, iowait: 0, steal: 0, total: busy + idle };
 }
 function defaultPs() {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve11, reject) => {
     (0, import_node_child_process2.execFile)(
       "ps",
       ["-A", "-o", "pid=,ppid=,rss=,time=,command="],
       { timeout: 2e3, maxBuffer: 8 * 1024 * 1024 },
-      (error, stdout) => error ? reject(error) : resolve9(stdout)
+      (error, stdout) => error ? reject(error) : resolve11(stdout)
     );
   });
 }
 function defaultWindowsQuery() {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve11, reject) => {
     (0, import_node_child_process2.execFile)(
       "powershell.exe",
       [
@@ -8271,18 +8479,18 @@ function defaultWindowsQuery() {
         "[Console]::OutputEncoding=[System.Text.Encoding]::UTF8; Get-CimInstance Win32_Process | Where-Object { $_.ProcessId -ne $PID -and $_.ParentProcessId -ne $PID } | Select-Object ProcessId,ParentProcessId,WorkingSetSize,UserModeTime,KernelModeTime,Name,CommandLine | ConvertTo-Json -Compress"
       ],
       { timeout: 1e4, maxBuffer: 8 * 1024 * 1024, windowsHide: true },
-      (error, stdout) => error ? reject(error) : resolve9(stdout)
+      (error, stdout) => error ? reject(error) : resolve11(stdout)
     );
   });
 }
 function freeBytes(dir) {
-  let current = path21.resolve(dir);
+  let current = path22.resolve(dir);
   for (; ; ) {
     try {
-      const stats = fs21.statfsSync(current);
+      const stats = fs22.statfsSync(current);
       return stats.bavail * stats.bsize;
     } catch {
-      const parent = path21.dirname(current);
+      const parent = path22.dirname(current);
       if (parent === current) return null;
       current = parent;
     }
@@ -8292,24 +8500,30 @@ async function dirBytes(dir, budget) {
   let bytes = 0;
   let entries;
   try {
-    entries = await fs21.promises.readdir(dir, { withFileTypes: true });
+    entries = await fs22.promises.readdir(dir, { withFileTypes: true });
   } catch {
     return 0;
   }
   for (const entry of entries) {
     if (budget.files <= 0) return bytes;
-    const full = path21.join(dir, entry.name);
+    const full = path22.join(dir, entry.name);
     if (entry.isDirectory()) bytes += await dirBytes(full, budget);
     else if (entry.isFile()) {
       budget.files--;
       try {
-        bytes += (await fs21.promises.lstat(full)).size;
+        bytes += (await fs22.promises.lstat(full)).size;
       } catch {
       }
     }
   }
   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;
@@ -8343,7 +8557,7 @@ var RunSampler = class {
     this.platform = options.platform ?? process.platform;
     this.proc = new ProcFs(options.procRoot);
     this.cgroup = new CgroupFs(options.procRoot, options.cgroupRoot);
-    this.outputDirs = [...new Set((options.outputDirs ?? []).map((dir) => path21.resolve(dir)))];
+    this.outputDirs = [...new Set((options.outputDirs ?? []).map((dir) => path22.resolve(dir)))];
     this.tmpDir = options.tmpDir ?? os8.tmpdir();
     this.intervalMs = options.intervalMs ?? 1e3;
     this.heavyEvery = Math.max(1, options.heavyEvery ?? 5);
@@ -8378,6 +8592,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 {
@@ -8545,7 +8771,7 @@ var RunSampler = class {
     } catch {
       return;
     }
-    this.noteTree(list, (proc) => roleOf(path21.basename(proc.command.split(" ")[0] ?? ""), proc.command), at);
+    this.noteTree(list, (proc) => roleOf(path22.basename(proc.command.split(" ")[0] ?? ""), proc.command), at);
   }
   async sampleWindowsTree(at) {
     let list;
@@ -8601,7 +8827,7 @@ var RunSampler = class {
     let bytes = 0;
     for (const dir of this.outputDirs) bytes += await dirBytes(dir, budget);
     for (const name of await this.playwrightTempEntries((mtimeMs) => mtimeMs >= this.startedAt - 1e3)) {
-      bytes += await dirBytes(path21.join(this.tmpDir, name), budget);
+      bytes += await dirBytes(path22.join(this.tmpDir, name), budget);
     }
     if (budget.files <= 0) this.peakInUseIsLowerBound = true;
     this.peakInUse = Math.max(this.peakInUse ?? 0, bytes);
@@ -8610,7 +8836,7 @@ var RunSampler = class {
   async playwrightTempEntries(keep) {
     let names;
     try {
-      names = await fs21.promises.readdir(this.tmpDir);
+      names = await fs22.promises.readdir(this.tmpDir);
     } catch {
       return [];
     }
@@ -8618,7 +8844,7 @@ var RunSampler = class {
     for (const name of names) {
       if (!PLAYWRIGHT_TEMP.test(name)) continue;
       try {
-        if (keep((await fs21.promises.stat(path21.join(this.tmpDir, name))).mtimeMs)) out.push(name);
+        if (keep((await fs22.promises.stat(path22.join(this.tmpDir, name))).mtimeMs)) out.push(name);
       } catch {
       }
     }
@@ -8629,7 +8855,7 @@ var RunSampler = class {
       const budget = { files: WALK_FILE_CAP };
       let bytes = 0;
       for (const name of await this.playwrightTempEntries((mtimeMs) => mtimeMs < this.startedAt - 1e3)) {
-        bytes += await dirBytes(path21.join(this.tmpDir, name), budget);
+        bytes += await dirBytes(path22.join(this.tmpDir, name), budget);
       }
       return bytes;
     } catch {
@@ -8674,9 +8900,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 {
@@ -8684,8 +8907,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: {
@@ -8957,7 +9179,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) ?? [];
@@ -8990,7 +9212,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;
@@ -9059,6 +9281,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 sent = 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) {
+        sent.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,
+      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;
@@ -9588,10 +9948,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];
@@ -9603,7 +9967,7 @@ function browserFunctionsInWorker() {
 function browserFunctionCoverage(files) {
   return sanitizeCoverage({
     v: 1,
-    files: [...files].map(([path32, functions]) => ({ path: path32, runtime: "browser", functions }))
+    files: [...files].map(([path34, functions]) => ({ path: path34, runtime: "browser", functions }))
   });
 }
 function newKnownFunctions(known, sent) {
@@ -9616,19 +9980,19 @@ function newKnownFunctions(known, sent) {
     budget = MAX_COVERAGE_RANGES;
   };
   for (const [raw, ranges] of known) {
-    const path32 = normalizeCoveragePath(raw);
-    if (path32 === null) continue;
-    let named = sent.get(path32);
+    const path34 = normalizeCoveragePath(raw);
+    if (path34 === null) continue;
+    let named = sent.get(path34);
     let fresh = normalizeFunctionRanges(ranges).filter((range) => !named?.has(`${range[0]}:${range[1]}`));
     if (fresh.length === 0) continue;
-    if (!named) sent.set(path32, named = /* @__PURE__ */ new Set());
+    if (!named) sent.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();
       const part = fresh.slice(0, budget);
       fresh = fresh.slice(part.length);
       budget -= part.length;
-      files.push({ path: path32, allFunctions: part });
+      files.push({ path: path34, allFunctions: part });
     }
   }
   close();
@@ -9640,8 +10004,8 @@ function serverCoverageInWorker() {
 
 // src/internal/capture/code-reach.ts
 var crypto5 = __toESM(require("crypto"));
-var fs22 = __toESM(require("fs"));
-var path22 = __toESM(require("path"));
+var fs23 = __toESM(require("fs"));
+var path23 = __toESM(require("path"));
 var import_node_child_process3 = require("child_process");
 
 // ../core/src/source-map.ts
@@ -9711,10 +10075,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;
     }
@@ -9735,7 +10099,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;
@@ -9911,7 +10275,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]);
@@ -9921,7 +10285,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);
@@ -9931,7 +10295,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;
 }
@@ -9986,18 +10350,18 @@ function repositoryRoot(from) {
     }).trim();
   } catch {
   }
-  cachedRepoRoot = { from, root: path22.resolve(root) };
+  cachedRepoRoot = { from, root: path23.resolve(root) };
   return cachedRepoRoot.root;
 }
 function codeReachRoots(configDir, configured) {
   const repoRoot = repositoryRoot(configDir);
-  const resolve9 = (dirs) => (Array.isArray(dirs) ? dirs : dirs ? [dirs] : []).filter(Boolean).map((r) => path22.resolve(configDir, r));
-  const global = Array.isArray(configured) ? resolve9(configured) : resolve9(configured?.["*"]);
+  const resolve11 = (dirs) => (Array.isArray(dirs) ? dirs : dirs ? [dirs] : []).filter(Boolean).map((r) => path23.resolve(configDir, r));
+  const global = Array.isArray(configured) ? resolve11(configured) : resolve11(configured?.["*"]);
   const byOrigin = /* @__PURE__ */ new Map();
   if (configured && !Array.isArray(configured)) {
     for (const [key, dirs] of Object.entries(configured)) {
       const origin = key === "*" ? null : originOf3(key);
-      const resolved = resolve9(dirs);
+      const resolved = resolve11(dirs);
       if (origin && resolved.length) byOrigin.set(origin, resolved);
     }
   }
@@ -10020,7 +10384,7 @@ function scriptRoots(roots, scriptUrl, pageUrl) {
 }
 function isFile(file) {
   try {
-    return fs22.statSync(file).isFile();
+    return fs23.statSync(file).isFile();
   } catch {
     return false;
   }
@@ -10028,10 +10392,10 @@ function isFile(file) {
 function resolveSourcePath(source, roots) {
   const normalized = normalizeSourcePath(source);
   if (!normalized || /(?:^|\/)node_modules\//.test(normalized)) return null;
-  if (path22.isAbsolute(normalized) && isFile(normalized)) return path22.resolve(normalized);
+  if (path23.isAbsolute(normalized) && isFile(normalized)) return path23.resolve(normalized);
   const relative11 = normalized.replace(/^\/+/, "");
   for (const root of roots) {
-    const candidate = path22.resolve(root, relative11);
+    const candidate = path23.resolve(root, relative11);
     if (isFile(candidate)) return candidate;
   }
   return null;
@@ -10063,7 +10427,7 @@ function fileForUrl(url, roots, bases) {
   return file;
 }
 function relativeToRepo(file, repoRoot) {
-  return path22.relative(repoRoot, file).split(path22.sep).join("/");
+  return path23.relative(repoRoot, file).split(path23.sep).join("/");
 }
 function scriptVersion(entry) {
   return entry.hash ?? crypto5.createHash("sha1").update(entry.source ?? "").digest("hex");
@@ -10120,12 +10484,12 @@ async function resolveFunctions(entries, roots, fetchMap, pageUrl, withKnown) {
   const files = /* @__PURE__ */ new Map();
   const known = /* @__PURE__ */ new Map();
   const addTo = (into, file, functions) => {
-    const path32 = relativeToRepo(file, roots.repoRoot);
-    const listed = into.get(path32);
+    const path34 = relativeToRepo(file, roots.repoRoot);
+    const listed = into.get(path34);
     if (listed) listed.push(...functions);
-    else into.set(path32, [...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)));
@@ -10152,14 +10516,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;
@@ -10238,10 +10602,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));
@@ -10255,7 +10622,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);
@@ -10275,8 +10642,8 @@ function onScriptParsed(page, capture, event) {
 var READ_WAIT_MS = 5e3;
 function readCoverage(page, cdp) {
   let timer;
-  const late = new Promise((resolve9) => {
-    timer = setTimeout(() => resolve9([]), READ_WAIT_MS);
+  const late = new Promise((resolve11) => {
+    timer = setTimeout(() => resolve11([]), READ_WAIT_MS);
   });
   const taken = internalCall(page, () => cdp.send("Profiler.takePreciseCoverage")).then(
     (answer) => answer.result,
@@ -10284,8 +10651,55 @@ function readCoverage(page, cdp) {
   );
   return Promise.race([taken, late]).finally(() => clearTimeout(timer));
 }
-function mergeCoverageRead(ran, scripts, read, keepIdle = true) {
-  for (const covered of read) {
+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);
     if (!script) continue;
     const key = versionKey(script.url, script.hash);
@@ -10318,11 +10732,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(),
@@ -10332,6 +10750,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;
@@ -10342,8 +10763,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" })
@@ -10357,18 +10787,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) {
@@ -10378,8 +10816,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);
   }
@@ -10388,8 +10829,8 @@ async function stopCodeReach(page) {
 // src/internal/collect/blob-ids.ts
 var import_node_child_process4 = require("child_process");
 var crypto6 = __toESM(require("crypto"));
-var fs23 = __toESM(require("fs"));
-var path23 = __toESM(require("path"));
+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");
 }
@@ -10398,14 +10839,14 @@ function namesLines(file) {
 }
 var GIT_BATCH = 500;
 function gitHashObjects(root, paths) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve11) => {
     const child = (0, import_node_child_process4.execFile)(
       "git",
       ["hash-object", "--stdin-paths"],
       { cwd: root, encoding: "utf8", timeout: 3e4, windowsHide: true },
       (error, stdout) => {
         const ids = error ? [] : stdout.split("\n").filter(Boolean);
-        resolve9(ids.length === paths.length ? ids : null);
+        resolve11(ids.length === paths.length ? ids : null);
       }
     );
     child.stdin?.on("error", () => {
@@ -10456,15 +10897,15 @@ var BlobIds = class {
   async read(relativePaths) {
     let root;
     try {
-      root = path23.resolve(this.repoRoot());
+      root = path24.resolve(this.repoRoot());
     } catch {
       return relativePaths.map(() => null);
     }
     const files = await Promise.all(
       relativePaths.map(async (relativePath2) => {
-        const file = path23.resolve(root, relativePath2);
-        if (!file.startsWith(root + path23.sep)) return null;
-        const stat = await fs23.promises.stat(file).catch(() => null);
+        const file = path24.resolve(root, relativePath2);
+        if (!file.startsWith(root + path24.sep)) return null;
+        const stat = await fs24.promises.stat(file).catch(() => null);
         return stat?.isFile() ? file : null;
       })
     );
@@ -10472,7 +10913,7 @@ var BlobIds = class {
     const fromGit = /* @__PURE__ */ new Map();
     const ids = forGit.length > 0 ? await this.hashObjects(
       root,
-      forGit.map((file) => path23.relative(root, file))
+      forGit.map((file) => path24.relative(root, file))
     ) : null;
     if (ids) forGit.forEach((file, i) => fromGit.set(file, ids[i]));
     return Promise.all(
@@ -10481,7 +10922,7 @@ var BlobIds = class {
         const id = fromGit.get(file);
         if (id) return id;
         try {
-          return gitBlobId(await fs23.promises.readFile(file));
+          return gitBlobId(await fs24.promises.readFile(file));
         } catch {
           return null;
         }
@@ -10496,7 +10937,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,
@@ -10514,7 +10955,19 @@ 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) {
@@ -10574,7 +11027,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,
@@ -10591,28 +11044,40 @@ 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" && known.name === ATTACHMENT_NAMES.browserFunctions) this.addKnownFunctions(known);
+      if (css === "rules" && known.name === 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 = attachments?.find((a) => a.name === 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) {
@@ -10667,27 +11132,27 @@ var CoverageCollection = class {
     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));
     }
     let timer;
     let finish;
-    const done = new Promise((resolve9) => {
+    const done = new Promise((resolve11) => {
       let settled = false;
       finish = (server) => {
         if (settled) return;
         settled = true;
         clearTimeout(timer);
         this.pending.delete(entry);
-        void Promise.resolve(browser).then((files) => {
-          this.assign(testCase, composeTestCoverage(server, files, this.options.settings));
-          resolve9();
+        void Promise.resolve(browser).then((side) => {
+          this.assign(testCase, composeTestCoverage(server, side.files, this.options.settings, side.css));
+          resolve11();
         });
       };
     });
@@ -10719,8 +11184,8 @@ var CoverageCollection = class {
       let timer;
       await Promise.race([
         Promise.all(waiting),
-        new Promise((resolve9) => {
-          timer = setTimeout(resolve9, boundMs);
+        new Promise((resolve11) => {
+          timer = setTimeout(resolve11, boundMs);
         })
       ]);
       clearTimeout(timer);
@@ -10823,6 +11288,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`. */
@@ -10838,10 +11305,13 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
     this.streamManager = null;
     /** Track suite-level setup steps (beforeAll/afterAll) not tied to any test */
     this.setupSteps = [];
-    this.options = resolveOptions(rawOptions);
+    const configDir = typeof rawOptions.configDir === "string" ? rawOptions.configDir : void 0;
+    this.options = resolveOptions(rawOptions, configDir);
     this.enabled = this.options.enabled !== false && !!this.options.serverUrl;
     this.listMode = isListMode();
     this.viaDesktopApp = usedDesktopDiscovery();
+    this.desktopReplaced = desktopReplacedServer();
+    this.viaDotEnv = usedDotEnv();
     this.coverageSettings = coverageSettings(this.options);
     const logger = new Logger(this.options.verbose ?? false);
     this.logger = logger;
@@ -10899,14 +11369,17 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
       return;
     }
     if (this.viaDesktopApp) {
-      this.logger.info(`Using the desktop app running at ${this.options.serverUrl} (no serverUrl configured).`);
+      this.logger.info(
+        this.desktopReplaced ? `Using the desktop app running at ${this.options.serverUrl} instead of ${this.desktopReplaced} (desktopApp: 'prefer', not on CI).` : `Using the desktop app running at ${this.options.serverUrl} (no serverUrl configured).`
+      );
     }
+    if (this.viaDotEnv) this.logger.debug(`Read ${this.viaDotEnv.keys.join(", ")} from ${this.viaDotEnv.file}.`);
     this.startTime = (/* @__PURE__ */ new Date()).toISOString();
     this.testPathBase = configDirFromConfig(config);
     this.playwrightVersion = config.version;
     this.maxFailures = config.maxFailures ?? 0;
     if (this.options.captureResources !== false) {
-      this.resourcesFile = path24.join(os9.tmpdir(), `piwi-resources-${process.pid}-${Date.now()}.jsonl`);
+      this.resourcesFile = path25.join(os9.tmpdir(), `piwi-resources-${process.pid}-${Date.now()}.jsonl`);
       process.env[PIWI_RESOURCES_RESULTS_ENV] = this.resourcesFile;
       try {
         this.sampler = new RunSampler({ outputDirs: (config.projects ?? []).map((project) => project.outputDir) });
@@ -10975,8 +11448,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;
       }
@@ -11001,6 +11475,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
@@ -11184,10 +11674,11 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
       if (frames.length) testCase.testSourceFrames = frames;
     }
     if (this.options.collectPerformanceMetrics && result.steps?.length > 0) {
-      testCase.performanceMetrics = collectStepMetrics(result.steps, result.errors);
+      const pauses = readPauses(result.attachments?.find((a) => a.name === ATTACHMENT_NAMES.pauses)?.body);
+      testCase.performanceMetrics = collectStepMetrics(result.steps, result.errors, pauses);
       const stepEvents = extractTestStepEvents(result.steps, result.startTime);
       const waitEvents = extractWaitEvents(result.steps);
-      const allEvents = [...stepEvents, ...waitEvents];
+      const allEvents = [...stepEvents, ...pauseStepEvents(pauses), ...waitEvents];
       if (allEvents.length > 0) testCase.stepEvents = allEvents;
     }
     if (this.options.collectPerformanceMetrics && result.attachments) {
@@ -11275,7 +11766,7 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
       if (!file.path || INTERNAL_ATTACHMENT_NAMES.has(file.name)) continue;
       try {
         const kind = artifactKind(file.name, file.contentType);
-        const bytes = fs24.statSync(file.path).size;
+        const bytes = fs25.statSync(file.path).size;
         artifacts[kind] += bytes;
         this.artifactBytes[kind] += bytes;
       } catch {
@@ -11302,14 +11793,16 @@ 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;
     const censuses = [...this.resourceCensuses];
     if (this.resourcesFile) {
       try {
-        censuses.push(...parseResourceResults(fs24.readFileSync(this.resourcesFile, "utf8")));
-        fs24.rmSync(this.resourcesFile, { force: true });
+        censuses.push(...parseResourceResults(fs25.readFileSync(this.resourcesFile, "utf8")));
+        fs25.rmSync(this.resourcesFile, { force: true });
       } catch {
       }
     }
@@ -11534,7 +12027,7 @@ async function resolveSelection(options = {}) {
 }
 
 // src/internal/capture/capture-fixtures.ts
-var path28 = __toESM(require("path"));
+var path30 = __toESM(require("path"));
 var import_node_zlib2 = require("zlib");
 
 // ../picker-dom/src/probe.ts
@@ -11993,8 +12486,8 @@ function installPickerOverlay(arg) {
     return root && root !== doc && root.host ? root.host : null;
   };
   const targetOf = (e) => {
-    const path32 = typeof e.composedPath === "function" ? e.composedPath() : null;
-    const first = path32 && path32.length ? path32[0] : null;
+    const path34 = typeof e.composedPath === "function" ? e.composedPath() : null;
+    const first = path34 && path34.length ? path34[0] : null;
     return first && first.nodeType === 1 ? first : e.target;
   };
   const buildChain = (raw) => {
@@ -12698,8 +13191,11 @@ function showPauseBar(arg) {
   };
   const buttons = [
     ["Resume", "resume", "Run on to the next breakpoint (Esc)", true],
-    ["Step", "step", "Pause again at the next action", false],
+    ["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]
   ];
   for (const [label, choice, hint, primary] of buttons) {
@@ -12865,7 +13361,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);
@@ -12882,7 +13378,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 },
@@ -12893,7 +13389,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 }),
@@ -12902,7 +13398,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 }),
@@ -12913,7 +13409,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 },
@@ -12923,7 +13419,7 @@ function generateAlternatives(attrs, options = {}) {
   }
   const placeholder = attr(attrs, "placeholder");
   if (placeholder) {
-    add({
+    add2({
       locator: `getByPlaceholder(${quoteJsString(placeholder)})`,
       method: "getByPlaceholder",
       args: { placeholder },
@@ -12931,7 +13427,7 @@ function generateAlternatives(attrs, options = {}) {
     });
   }
   if (text && text.length < 80) {
-    add({
+    add2({
       locator: `getByText(${quoteJsString(text)})`,
       method: "getByText",
       args: { text },
@@ -12941,7 +13437,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 },
@@ -12951,7 +13447,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 },
@@ -12960,7 +13456,7 @@ function generateAlternatives(attrs, options = {}) {
   }
   const alt = attr(attrs, "alt");
   if (alt) {
-    add({
+    add2({
       locator: `getByAltText(${quoteJsString(alt)})`,
       method: "getByAltText",
       args: { text: alt },
@@ -12969,7 +13465,7 @@ function generateAlternatives(attrs, options = {}) {
   }
   const title = attr(attrs, "title");
   if (title) {
-    add({
+    add2({
       locator: `getByTitle(${quoteJsString(title)})`,
       method: "getByTitle",
       args: { title },
@@ -12987,7 +13483,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 },
@@ -12997,7 +13493,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 },
@@ -13008,7 +13504,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 },
@@ -13018,7 +13514,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 },
@@ -13027,7 +13523,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 },
@@ -13046,7 +13542,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,
@@ -13065,7 +13561,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}` },
@@ -13122,7 +13618,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);
@@ -13132,7 +13628,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 },
@@ -13145,7 +13641,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
@@ -13175,21 +13671,21 @@ var MAX_INDETERMINATE = 20;
 var STEP = String.raw`[a-zA-Z][\w.-]*:[1-9]\d*`;
 var LEVEL = `${STEP}(?:/${STEP})*`;
 var ELEMENT_PATH_RE = new RegExp(`^${LEVEL}(?:\\|${LEVEL})*$`);
-function isElementPath(path32) {
-  return typeof path32 === "string" && path32.length <= ELEMENT_PATH_MAX_CHARS && ELEMENT_PATH_RE.test(path32);
+function isElementPath(path34) {
+  return typeof path34 === "string" && path34.length <= ELEMENT_PATH_MAX_CHARS && ELEMENT_PATH_RE.test(path34);
 }
 var offsetOf = (v) => typeof v === "number" && Number.isInteger(v) && v >= 0 && v <= 1e7 ? v : null;
 function elementRef(v) {
   if (!v || typeof v !== "object") return null;
-  const { path: path32, label } = v;
-  if (!isElementPath(path32)) return null;
-  return { path: path32, label: typeof label === "string" ? label.slice(0, ELEMENT_LABEL_MAX_CHARS) : "" };
+  const { path: path34, label } = v;
+  if (!isElementPath(path34)) return null;
+  return { path: path34, label: typeof label === "string" ? label.slice(0, ELEMENT_LABEL_MAX_CHARS) : "" };
 }
 function textPoint(v) {
   if (!v || typeof v !== "object") return null;
-  const { path: path32, offset } = v;
+  const { path: path34, offset } = v;
   const at = offsetOf(offset);
-  return isElementPath(path32) && at !== null ? { path: path32, offset: at } : null;
+  return isElementPath(path34) && at !== null ? { path: path34, offset: at } : null;
 }
 function sanitizePageInteraction(raw) {
   if (!raw || typeof raw !== "object") return {};
@@ -13220,7 +13716,7 @@ function sanitizePageInteraction(raw) {
 }
 
 // src/internal/capture/locator-healing.ts
-var path25 = __toESM(require("path"));
+var path26 = __toESM(require("path"));
 
 // ../core/src/locator-fingerprint.ts
 var ELEMENT_MATCH_SCORES = { role: 60, text: 55, label: 50 };
@@ -13605,10 +14101,10 @@ function captureCallerLocation(stack = new Error().stack ?? "") {
     }
     let rel = file;
     try {
-      rel = path25.relative(process.cwd(), file);
+      rel = path26.relative(process.cwd(), file);
     } catch {
     }
-    rel = rel.split(path25.sep).join("/");
+    rel = rel.split(path26.sep).join("/");
     if (rel.startsWith("./")) rel = rel.slice(2);
     return `${rel}:${m[3]}:${m[4]}`;
   }
@@ -13838,7 +14334,7 @@ function inspectionGateFromTestInfo(testInfo, enabled = process.env.PIWI_INSPECT
 }
 
 // src/internal/capture/pick-on-failure.ts
-var path26 = __toESM(require("path"));
+var path27 = __toESM(require("path"));
 function parseLeafLocatorExpression(rawExpr) {
   const leaf = parseLeafLocatorCall(rawExpr);
   return leaf ? { method: leaf.method, args: locatorCallValues(leaf) } : null;
@@ -13853,37 +14349,60 @@ ${err.stack ?? ""}`));
     const parsed2 = parseLeafLocatorExpression(header);
     if (!parsed2) continue;
     const loc = err.location;
-    const location = loc ? `${path26.relative(process.cwd(), loc.file).split(path26.sep).join("/")}:${loc.line}:${loc.column}` : null;
+    const location = loc ? `${path27.relative(process.cwd(), loc.file).split(path27.sep).join("/")}:${loc.line}:${loc.column}` : null;
     return { method: parsed2.method, args: parsed2.args, location };
   }
   return null;
 }
-async function cleanupPicker(page) {
+var PICK_ENDED = "__piwiPickEnded";
+async function cleanupPicker(page, ended = false) {
   try {
-    await page.evaluate(() => {
-      const g = globalThis;
-      if (typeof g.__piwiPickCleanup === "function") g.__piwiPickCleanup();
-      if (typeof g.__piwiAnchorCleanup === "function") g.__piwiAnchorCleanup();
-      delete g.__piwiPickCleanup;
-      delete g.__piwiAnchorCleanup;
-      delete g.__piwiPickState;
-      delete g.__piwiPickChoice;
-      delete g.__piwiPickedElement;
-      delete g.__piwiAnchorState;
-      delete g.__piwiPickAnchors;
-      delete g.__piwiPickChainCount;
-    });
+    await page.evaluate(
+      ([endedKey, unanswered]) => {
+        const g = globalThis;
+        if (typeof g.__piwiPickCleanup === "function") g.__piwiPickCleanup();
+        if (typeof g.__piwiAnchorCleanup === "function") g.__piwiAnchorCleanup();
+        delete g.__piwiPickCleanup;
+        delete g.__piwiAnchorCleanup;
+        delete g.__piwiPickState;
+        delete g.__piwiPickChoice;
+        delete g.__piwiPickedElement;
+        delete g.__piwiAnchorState;
+        delete g.__piwiPickAnchors;
+        delete g.__piwiPickChainCount;
+        if (unanswered) g[endedKey] = true;
+        else delete g[endedKey];
+      },
+      [PICK_ENDED, ended]
+    );
   } catch {
   }
 }
-async function pickLocator(page, probe, failing) {
+function unlessEnded(run, ended) {
+  if (!ended) return run;
+  return Promise.race([
+    run,
+    new Promise((resolve11) => {
+      if (ended.aborted) resolve11(void 0);
+      else ended.addEventListener("abort", () => resolve11(void 0), { once: true });
+    })
+  ]);
+}
+async function pickLocator(page, probe, failing, ended) {
+  const answered = async (name) => {
+    const wait = page.waitForFunction(
+      ([key, endedKey]) => globalThis[key] !== void 0 || globalThis[endedKey] === true,
+      [name, PICK_ENDED],
+      { timeout: 0, polling: 250 }
+    );
+    await unlessEnded(wait, ended);
+    return !ended?.aborted;
+  };
   try {
     const overlayArg = { transport: "global", failing };
+    await page.evaluate((endedKey) => delete globalThis[endedKey], PICK_ENDED);
     await page.evaluate(installPickerOverlay, overlayArg);
-    await page.waitForFunction(() => globalThis.__piwiPickState !== void 0, void 0, {
-      timeout: 0,
-      polling: 250
-    });
+    if (!await answered("__piwiPickState")) return null;
     const state = await page.evaluate(() => globalThis.__piwiPickState);
     if (state !== "picked") return null;
     const handle = await page.evaluateHandle(() => globalThis.__piwiPickedElement);
@@ -13904,10 +14423,7 @@ async function pickLocator(page, probe, failing) {
         leafLevel: level,
         leafTestId: attrs.attributes["data-testid"] ?? null
       });
-      await page.waitForFunction(() => globalThis.__piwiAnchorState !== void 0, void 0, {
-        timeout: 0,
-        polling: 250
-      });
+      if (!await answered("__piwiAnchorState")) return null;
       const anchorResult = await page.evaluate(() => {
         const g = globalThis;
         return { state: g.__piwiAnchorState, anchors: g.__piwiPickAnchors ?? [], chainCount: g.__piwiPickChainCount };
@@ -13929,10 +14445,7 @@ async function pickLocator(page, probe, failing) {
       failing,
       choices: ranked.map((r) => ({ locator: r.locator, score: r.score }))
     });
-    await page.waitForFunction(() => globalThis.__piwiPickChoice !== void 0, void 0, {
-      timeout: 0,
-      polling: 250
-    });
+    if (!await answered("__piwiPickChoice")) return null;
     const choice = await page.evaluate(() => globalThis.__piwiPickChoice);
     if (typeof choice !== "number" || choice < 0 || choice >= ranked.length) return null;
     const picked = { ...ranked[choice], pickedByUser: true };
@@ -13951,7 +14464,7 @@ async function pickLocator(page, probe, failing) {
       ...anchors.length > 0 ? { anchors } : {}
     };
   } finally {
-    await cleanupPicker(page);
+    await cleanupPicker(page, ended?.aborted);
   }
 }
 async function runLocatorPicker(page, testInfo, failed, probe) {
@@ -14006,7 +14519,7 @@ function applyPickToSnapshots(snapshots, pick) {
 }
 
 // src/internal/capture/pause-at.ts
-var path27 = __toESM(require("path"));
+var path28 = __toESM(require("path"));
 
 // ../core/src/editor-send.ts
 var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]"]);
@@ -14047,18 +14560,32 @@ var PauseSet = class {
     return col > 0 && this.lines.has(callerLocation.slice(0, col));
   }
 };
-var EMPTY = new PauseSet(/* @__PURE__ */ new Set());
+var NO_BREAKPOINTS = new PauseSet(/* @__PURE__ */ new Set());
 function callSiteFile(file, cwd) {
   const slashed = file.replace(/\\/g, "/");
-  const absolute = path27.isAbsolute(file) || path27.isAbsolute(slashed) || /^[A-Za-z]:\//.test(slashed);
-  let rel = absolute ? path27.relative(cwd, file) : path27.normalize(slashed);
-  rel = rel.split(path27.sep).join("/").replace(/\\/g, "/");
+  const absolute = path28.isAbsolute(file) || path28.isAbsolute(slashed) || /^[A-Za-z]:\//.test(slashed);
+  let rel = absolute ? path28.relative(cwd, file) : path28.normalize(slashed);
+  rel = rel.split(path28.sep).join("/").replace(/\\/g, "/");
   if (rel.startsWith("./")) rel = rel.slice(2);
   return rel;
 }
+function stopCallSite(location, cwd = process.cwd()) {
+  if (!location.line) return null;
+  return `${callSiteFile(location.file, cwd)}:${location.line}:${location.column ?? 0}`;
+}
+function callSiteLine(callSite) {
+  const col = callSite.lastIndexOf(":");
+  return col > 0 ? callSite.slice(0, col) : callSite;
+}
+function inFlightCallSite(inFlight) {
+  const [first] = inFlight;
+  if (first === void 0) return null;
+  const line = callSiteLine(first);
+  return inFlight.every((site) => callSiteLine(site) === line) ? first : null;
+}
 var ignoredLogged = /* @__PURE__ */ new Set();
 function parsePauseAt(value, cwd = process.cwd()) {
-  if (!value?.trim()) return EMPTY;
+  if (!value?.trim()) return NO_BREAKPOINTS;
   const lines = /* @__PURE__ */ new Set();
   for (const raw of value.split(";")) {
     const entry = raw.trim();
@@ -14074,7 +14601,7 @@ function parsePauseAt(value, cwd = process.cwd()) {
     }
     lines.add(`${callSiteFile(m[1], cwd)}:${line}`);
   }
-  return lines.size ? new PauseSet(lines) : EMPTY;
+  return lines.size ? new PauseSet(lines) : NO_BREAKPOINTS;
 }
 var parsed = null;
 function currentPauseSet() {
@@ -14084,27 +14611,121 @@ function currentPauseSet() {
 }
 function pauseGateFromTestInfo(testInfo) {
   const use = testInfo.project?.use ?? {};
-  return { ci: process.env.CI, headless: use.headless };
+  const debug = testInfo._configInternal?.configCLIOverrides?.debug;
+  return { ci: process.env.CI, headless: use.headless, pwdebug: process.env.PWDEBUG, debug };
 }
 function pauseSkipReason(gate) {
   if (isCi(gate.ci)) return "running under CI \u2014 breakpoints pause local runs only";
   if (gate.headless !== false)
     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";
+  if (typeof gate.debug === "string" && gate.debug)
+    return `Playwright's debugger runs the test (--debug=${gate.debug}) \u2014 run without --debug`;
   return null;
 }
-function rearmedTimeout(before, pausedMs) {
-  return before > 0 ? before + Math.max(0, Math.round(pausedMs)) : 0;
+function atStop(state, callSite) {
+  if (callSite && !state.finished) {
+    if (state.step) {
+      state.step = false;
+      return { show: "step" };
+    }
+    if (state.set.matches(callSite)) return { show: "breakpoint" };
+  }
+  return { go: goOn(state) };
+}
+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";
+}
+function contextDebugger(context) {
+  const dbg = context.debugger;
+  return typeof dbg?.requestPause === "function" && typeof dbg.on === "function" ? dbg : null;
+}
+var WATCHED = /* @__PURE__ */ new WeakSet();
+function watchStops(context, onStop) {
+  const dbg = contextDebugger(context);
+  if (!dbg) return false;
+  if (WATCHED.has(context)) return true;
+  WATCHED.add(context);
+  inspectorSwitch.watching = true;
+  syncInspectorSwitch();
+  dbg.on("pausedstatechanged", () => onStop(context));
+  return true;
+}
+var NO_INSPECTOR_ENV = "PW_CODEGEN_NO_INSPECTOR";
+var inspectorSwitch = {
+  /** Set by Piwi, so Piwi's to clear. */
+  set: false,
+  /** Piwi answers the stops of a context in this worker. */
+  watching: false,
+  /** Every `page.pause()` of the worker's Playwright reaches it through Piwi (`markPausesWrapped`). */
+  wrapped: false,
+  /** The `page.pause()` calls left to Playwright that are running (`withInspector`). */
+  open: 0
+};
+function syncInspectorSwitch() {
+  const closed = inspectorSwitch.watching && inspectorSwitch.wrapped && inspectorSwitch.open === 0;
+  if (closed && process.env[NO_INSPECTOR_ENV] === void 0) {
+    process.env[NO_INSPECTOR_ENV] = "1";
+    inspectorSwitch.set = true;
+  } else if (!closed && inspectorSwitch.set) {
+    if (process.env[NO_INSPECTOR_ENV] === "1") delete process.env[NO_INSPECTOR_ENV];
+    inspectorSwitch.set = false;
+  }
+}
+function markPausesWrapped() {
+  inspectorSwitch.wrapped = true;
+  syncInspectorSwitch();
+}
+async function withInspector(run) {
+  inspectorSwitch.open++;
+  syncInspectorSwitch();
+  try {
+    return await run();
+  } finally {
+    inspectorSwitch.open--;
+    syncInspectorSwitch();
+  }
+}
+async function steerDebugger(context, how) {
+  const dbg = contextDebugger(context);
+  if (!dbg) return;
+  try {
+    await internalCall(
+      context,
+      () => how === "pause" ? dbg.requestPause() : how === "next" ? dbg.next() : dbg.resume()
+    );
+  } catch {
+  }
+}
+async function withTestTimeoutHeld(testInfo, run) {
+  const set = testInfo._setIgnoreTimeouts;
+  if (typeof set !== "function") return run();
+  set.call(testInfo, true);
+  try {
+    return await run();
+  } finally {
+    set.call(testInfo, false);
+  }
+}
+function testTimeSlot(testInfo) {
+  try {
+    const slot = testInfo._timeoutManager?.defaultSlot?.();
+    return slot && typeof slot.elapsed === "number" ? slot : null;
+  } catch {
+    return null;
+  }
+}
+function restoreTestTime(testInfo, heldAt) {
+  const slot = testTimeSlot(testInfo);
+  if (slot && Number.isFinite(heldAt) && heldAt >= 0 && heldAt < slot.elapsed) slot.elapsed = heldAt;
 }
 function pausePlace(callerLocation) {
-  const col = callerLocation.lastIndexOf(":");
-  const fileLine = col > 0 ? callerLocation.slice(0, col) : callerLocation;
+  const fileLine = callSiteLine(callerLocation);
   return fileLine.slice(fileLine.lastIndexOf("/") + 1);
 }
-function assertionLabel(expression, isNot) {
-  const [first = "", ...rest] = expression.split(".").filter(Boolean);
-  const name = first + rest.map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
-  return `${isNot ? "not." : ""}${name || "expect"}`;
-}
 function pickPlace(callerLocation) {
   const m = /^(.+):(\d+):\d+$/.exec(callerLocation);
   if (!m) return null;
@@ -14149,57 +14770,571 @@ function logPauseSkipOnce(reason) {
   skipLogged = true;
   console.log(`[piwi] ${PIWI_LOCAL_DEBUG_ENV.pauseAt} is set but breakpoints are skipped: ${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, testInfo, point, probe, onPick) {
-  const before = testInfo.timeout;
-  const started = Date.now();
+async function pauseHere(page, point, probe, onPick, onRecord, ended) {
   let shown = null;
   try {
-    testInfo.setTimeout(0);
     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((resolve9) => {
-          timer = setTimeout(() => resolve9(null), HIGHLIGHT_MS);
+        new Promise((resolve11) => {
+          timer = setTimeout(() => resolve11(null), HIGHLIGHT_MS);
         })
       ]);
       clearTimeout(timer);
     }
     const arg = {
       place: pausePlace(point.location),
-      attempt: testInfo.retry > 0 ? testInfo.retry + 1 : null,
-      action: point.action,
-      locator: point.locator
+      attempt: point.attempt,
+      action: point.call,
+      locator: null,
+      record: !!onRecord
     };
     console.log(
-      `[piwi] Paused at ${point.location} before ${point.locator ? `${point.action} \xB7 ${point.locator}` : point.action}: Resume, Step, Pick a locator or Finish in the browser (Esc resumes).`
+      `[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 (; ; ) {
-      await page.evaluate(showPauseBar, arg);
-      await page.waitForFunction(pauseAnswered, void 0, { timeout: 0, polling: 250 });
-      const choice = await page.evaluate(takePauseState);
-      if (choice === "resume" || choice === "step" || choice === "finish") return choice;
-      if (choice !== "pick") continue;
-      const picked = await pickLocator(page, probe, null).catch(() => null);
-      if (picked) await onPick(picked);
+      try {
+        if (ended?.aborted) return "resume";
+        await page.evaluate(showPauseBar, arg);
+        await unlessEnded(page.waitForFunction(pauseAnswered, void 0, { timeout: 0, polling: 250 }), 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) {
+          await unlessEnded(
+            onRecord(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);
+      }
     }
   } catch {
     return "resume";
   } finally {
     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);
     } catch {
     }
+  }
+}
+
+// src/internal/capture/record-handoff.ts
+var fs26 = __toESM(require("fs"));
+var net2 = __toESM(require("net"));
+var path29 = __toESM(require("path"));
+
+// ../core/src/ide-recorder.ts
+var IDE_RECORDER_BINDING = "__piwiRecorder";
+var IDE_DISPATCH_GLOBAL = "__piwiIdeDispatch";
+var RECORD_CHANNEL_ENV = "PIWI_RECORD_CHANNEL";
+var MAX_HANDOFF_LINE = 64e6;
+function parseRecordChannel(value) {
+  const text = value?.trim() ?? "";
+  const hash = text.lastIndexOf("#");
+  if (hash <= 0) return null;
+  const token = text.slice(hash + 1);
+  const path34 = text.slice(0, hash);
+  return /^[A-Za-z0-9_-]{16,}$/.test(token) && !path34.includes("\0") ? { path: path34, token } : null;
+}
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseHandoffToTest(line) {
+  let value;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!isObject2(value)) return null;
+  switch (value.type) {
+    case "refused":
+      return typeof value.message === "string" ? { type: "refused", message: value.message } : null;
+    case "load":
+      return typeof value.bundle === "string" && value.bundle ? { type: "load", bundle: value.bundle } : null;
+    case "answer":
+      return typeof value.call === "number" ? { type: "answer", call: value.call, value: value.value } : null;
+    case "dispatch":
+      return { type: "dispatch", message: value.message };
+    case "stop":
+      return { type: "stop" };
+    default:
+      return null;
+  }
+}
+function lineReader(onLine, onOverflow) {
+  let buffered = "";
+  return (chunk) => {
+    buffered += chunk;
+    for (let end = buffered.indexOf("\n"); end >= 0; end = buffered.indexOf("\n")) {
+      const line = buffered.slice(0, end);
+      buffered = buffered.slice(end + 1);
+      if (line.trim()) onLine(line);
+    }
+    if (buffered.length > MAX_HANDOFF_LINE) {
+      buffered = "";
+      onOverflow();
+    }
+  };
+}
+
+// src/internal/capture/record-handoff.ts
+var START_WAIT_MS = 6e4;
+var NEW_TAB_NOTICE = "A new tab opened: what you do there is not recorded yet. Record in the first tab.";
+var relays = /* @__PURE__ */ new WeakMap();
+function idleAnswer(payload) {
+  const request3 = payload ?? {};
+  if (request3.kind === "local-get") return {};
+  if (request3.kind !== "message") return null;
+  if (request3.message?.type === "piwi-ping") return { ok: true };
+  if (request3.message?.type === "piwi-session-storage") {
+    return request3.message.op === "get" ? { ok: true, items: {} } : { ok: true };
+  }
+  return { ok: false, error: "No recording runs in this page." };
+}
+function canRecordFromHere(channel = process.env[RECORD_CHANNEL_ENV]) {
+  return parseRecordChannel(channel) !== null;
+}
+function handoffPlace(location, cwd = process.cwd()) {
+  const m = /^(.+):(\d+):\d+$/.exec(location);
+  if (!m) return null;
+  return { file: path29.resolve(cwd, m[1]), line: Number(m[2]) };
+}
+async function recordFromHere(options) {
+  const channel = parseRecordChannel(options.channel ?? process.env[RECORD_CHANNEL_ENV]);
+  const place = handoffPlace(options.location);
+  if (!channel || !place) return "this run names no editor to record into.";
+  const { page, testInfo, ended } = options;
+  if (ended?.aborted) return "the test ended.";
+  const use = testInfo.project?.use ?? {};
+  const context = page.context();
+  return new Promise((resolve11) => {
+    const socket = net2.connect(channel.path);
+    socket.setEncoding("utf8");
+    const answers = /* @__PURE__ */ new Map();
+    let calls = 0;
+    let attached = false;
+    let recording = false;
+    let settled = false;
+    let initScript;
+    const send = (message) => {
+      if (!socket.destroyed) socket.write(`${JSON.stringify(message)}
+`);
+    };
+    const onPage = () => send({ type: "notice", message: NEW_TAB_NOTICE });
+    const onGone = () => {
+      if (attached) send({ type: "closed" });
+      finish("the page closed.");
+    };
+    const onEnded = () => {
+      try {
+        if (recording) {
+          void internalCall(
+            page,
+            () => page.evaluate(
+              ([name, value]) => {
+                const dispatch = globalThis[name];
+                if (typeof dispatch === "function") dispatch(value);
+              },
+              [IDE_DISPATCH_GLOBAL, { type: "piwi-recording-stopped" }]
+            )
+          ).catch(() => void 0);
+        }
+        if (attached) send({ type: "closed" });
+        finish("the test ended.");
+      } catch {
+      }
+    };
+    page.once("close", onGone);
+    page.once("crash", onGone);
+    ended?.addEventListener("abort", onEnded, { once: true });
+    const startWait = setTimeout(() => finish("the editor did not start the recording."), START_WAIT_MS);
+    const release = () => {
+      const relay = relays.get(context);
+      if (relay && relay.recording === relayed) relay.recording = null;
+      void Promise.resolve(initScript?.dispose?.()).catch(() => void 0);
+      initScript = void 0;
+    };
+    const finish = (said) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(startWait);
+      release();
+      for (const [call, answer] of answers) {
+        answers.delete(call);
+        answer(null);
+      }
+      context.off("page", onPage);
+      page.off("close", onGone);
+      page.off("crash", onGone);
+      ended?.removeEventListener("abort", onEnded);
+      socket.end();
+      resolve11(recording ? null : said);
+    };
+    const relayed = (source, payload) => new Promise((answer) => {
+      const call = ++calls;
+      answers.set(call, answer);
+      const outside = source.page !== page || source.frame !== page.mainFrame();
+      send({ type: "binding", call, outside, payload });
+    });
+    const load = async (bundle) => {
+      if (!/^https?:/i.test(page.url())) {
+        const why = `the recorder records http(s) pages only, and this page is ${page.url() || "blank"}.`;
+        send({ type: "notice", message: `Nothing can be recorded here: ${why}` });
+        finish(why);
+        return;
+      }
+      let relay = relays.get(context);
+      if (!relay) {
+        const created = { recording: null, lingering: false };
+        await context.exposeBinding(
+          IDE_RECORDER_BINDING,
+          (source, payload) => created.recording ? created.recording(source, payload) : idleAnswer(payload)
+        );
+        relays.set(context, created);
+        relay = created;
+      }
+      if (settled) return;
+      relay.recording = relayed;
+      if (!relay.lingering) {
+        initScript = await context.addInitScript({ path: bundle });
+        if (typeof initScript?.dispose !== "function") relay.lingering = true;
+      }
+      if (settled) return release();
+      await page.evaluate(fs26.readFileSync(bundle, "utf-8"));
+      if (settled) return release();
+      recording = true;
+      clearTimeout(startWait);
+      context.on("page", onPage);
+      send({ type: "loaded" });
+    };
+    socket.on("connect", () => {
+      attached = true;
+      send({
+        type: "attach",
+        token: channel.token,
+        file: place.file,
+        line: place.line,
+        reason: options.reason,
+        testIdAttribute: typeof use.testIdAttribute === "string" ? use.testIdAttribute : null,
+        baseURL: typeof use.baseURL === "string" ? use.baseURL : null
+      });
+    });
+    socket.on(
+      "data",
+      lineReader(
+        (line) => {
+          const message = parseHandoffToTest(line);
+          if (!message || settled) return;
+          switch (message.type) {
+            case "refused":
+              return finish(message.message);
+            case "load":
+              return void load(message.bundle).catch(
+                (error) => finish(`the recorder could not be loaded: ${error instanceof Error ? error.message : String(error)}`)
+              );
+            case "answer": {
+              const answer = answers.get(message.call);
+              answers.delete(message.call);
+              return answer?.(message.value);
+            }
+            case "dispatch":
+              return void page.evaluate(
+                ([name, value]) => {
+                  const dispatch = globalThis[name];
+                  if (typeof dispatch === "function") dispatch(value);
+                },
+                [IDE_DISPATCH_GLOBAL, message.message]
+              ).catch(() => void 0);
+            case "stop":
+              return finish(null);
+          }
+        },
+        () => 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."));
+  });
+}
+
+// src/internal/capture/css-coverage.ts
+var crypto7 = __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 {
-      testInfo.setTimeout(rearmedTimeout(before, Date.now() - started));
+      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 = crypto7.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
@@ -14497,17 +15632,27 @@ function createSink() {
     pickOffered: false,
     userPick: null,
     pause: null,
+    locatorCalls: /* @__PURE__ */ new Map(),
+    stops: [],
+    shownStops: /* @__PURE__ */ new Map(),
+    released: [],
+    releasedRequests: /* @__PURE__ */ new Set(),
+    onReleasedRequestsEnded: null,
+    releasedQuietSince: 0,
     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) {
@@ -14520,9 +15665,9 @@ 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((resolve9) => setTimeout(resolve9, CODE_REACH_START_WAIT_MS).unref())]);
+  await Promise.race([started, new Promise((resolve11) => setTimeout(resolve11, CODE_REACH_START_WAIT_MS).unref())]);
 }
 function configuredCodeReachRoots() {
   const raw = process.env.PIWI_CODE_REACH_ROOTS?.trim();
@@ -14536,7 +15681,7 @@ function configuredCodeReachRoots() {
     }
   } catch {
   }
-  return raw.split(path28.delimiter).filter(Boolean);
+  return raw.split(path30.delimiter).filter(Boolean);
 }
 async function stopSinkCodeReach(sink, closing) {
   const stopping = [];
@@ -14563,30 +15708,36 @@ 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;
   let cap;
   await Promise.race([
     Promise.allSettled(PENDING_PROBES),
-    new Promise((resolve9) => {
-      cap = setTimeout(resolve9, capMs);
+    new Promise((resolve11) => {
+      cap = setTimeout(resolve11, capMs);
     })
   ]);
   clearTimeout(cap);
@@ -14626,10 +15777,10 @@ async function readWebVitals(page) {
         const key = entry.name.replace(/-([a-z])/g, (_, l) => l.toUpperCase());
         paint[key] = Math.round(entry.startTime);
       }
-      const readBuffered = (type, extra) => new Promise((resolve9) => {
+      const readBuffered = (type, extra) => new Promise((resolve11) => {
         try {
           const PO = globalThis.PerformanceObserver;
-          if (!PO || !(PO.supportedEntryTypes || []).includes(type)) return resolve9(null);
+          if (!PO || !(PO.supportedEntryTypes || []).includes(type)) return resolve11(null);
           const out = [];
           const po = new PO((list) => out.push(...list.getEntries()));
           po.observe({ type, buffered: true, ...extra });
@@ -14639,10 +15790,10 @@ async function readWebVitals(page) {
               po.disconnect();
             } catch {
             }
-            resolve9(out);
+            resolve11(out);
           }, 0);
         } catch {
-          resolve9(null);
+          resolve11(null);
         }
       });
       const [lcpRaw, shiftRaw, eventRaw, firstInputRaw] = await Promise.all([
@@ -14757,12 +15908,12 @@ var PAGE_INVENTORY_IN_PAGE_CAP = 2e3;
 var PAGE_INVENTORY_EVAL_TIMEOUT_MS = 2e3;
 var MAX_PAGE_INVENTORY_WINDOWS = 64;
 function withTimeout(promise, ms) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve11, reject) => {
     const timer = setTimeout(() => reject(new Error("page inventory read timed out")), ms);
     promise.then(
       (value) => {
         clearTimeout(timer);
-        resolve9(value);
+        resolve11(value);
       },
       (error) => {
         clearTimeout(timer);
@@ -14877,6 +16028,7 @@ async function maybeOpenPicker(sink, closing) {
 var INSTRUMENTED_PAGES = /* @__PURE__ */ new WeakSet();
 var OPEN_PAGES = /* @__PURE__ */ new Set();
 var INSTRUMENTED_CONTEXTS = /* @__PURE__ */ new WeakSet();
+var OPEN_CONTEXTS = /* @__PURE__ */ new Set();
 var PATCHED_BROWSERS = /* @__PURE__ */ new WeakSet();
 var CHAIN_METHOD_SET = new Set(CHAIN_METHODS);
 var ACTION_METHOD_SET = new Set(ACTION_METHODS);
@@ -14997,8 +16149,20 @@ function recordLocatorPage(sink, page, locator, location, arrival) {
   } catch {
   }
 }
-function pausesAt(pause, callerLocation) {
-  return !pause.finished && (pause.next || pause.set.matches(callerLocation));
+function knowLocatorCall(sink, page, target, location, origin) {
+  if (!sink?.pause || !location) return null;
+  let settle = () => {
+  };
+  const settled = new Promise((resolve11) => settle = resolve11);
+  const call = { page, target, location, origin, picked: false, settled, settle };
+  sink.locatorCalls.set(callSiteLine(location), call);
+  return call;
+}
+function forgetLocatorCall(sink, call) {
+  if (!sink || !call) return;
+  call.settle();
+  const key = callSiteLine(call.location);
+  if (sink.locatorCalls.get(key) === call) sink.locatorCalls.delete(key);
 }
 function locatorSource(target, method, args) {
   try {
@@ -15008,42 +16172,220 @@ function locatorSource(target, method, args) {
   }
   return renderFailing({ method, args });
 }
-async function pauseBefore(sink, page, target, callerLocation, action, origin) {
-  const pause = sink.pause;
+var PAGE_PAUSES = /* @__PURE__ */ new WeakMap();
+var PLAYWRIGHT_PAUSES = /* @__PURE__ */ new WeakMap();
+async function armBreakpoints(contexts) {
+  const state = currentSink?.pause;
+  if (!state || state.finished || state.set.size === 0) return;
+  await Promise.all(
+    [...contexts].map(
+      (context) => context && watchStops(context, onDebuggerStop) ? steerDebugger(context, "pause") : void 0
+    )
+  );
+}
+function onDebuggerStop(context) {
+  const details = contextDebugger(context)?.pausedDetails();
+  if (!details || PLAYWRIGHT_PAUSES.has(context)) return;
+  const sink = currentSink;
+  const state = sink?.pause ?? null;
+  void (async () => {
+    let how = "resume";
+    try {
+      if (!sink || !state) return;
+      const callSite = stopSite(sink, details.location);
+      const pagePause = PAGE_PAUSES.get(context);
+      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));
+    } catch {
+      if (state) how = goOn(state);
+    } finally {
+      await steerDebugger(context, how);
+    }
+  })();
+}
+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));
+  return open[open.length - 1] ?? null;
+}
+async function showStop(sink, context, title, location, reason) {
   const testInfo = sink.testInfo;
-  if (!pause || !testInfo || !callerLocation) return;
-  pause.next = false;
-  try {
-    const locator = locatorSource(target, origin.method, origin.args);
-    const onPick = async (picked) => {
-      const pick = {
-        failing: { method: origin.method, args: origin.args, rendered: locator, location: callerLocation },
+  const call = sink.locatorCalls.get(callSiteLine(location));
+  const page = stopPage(sink, context, call);
+  if (!testInfo || !page) return void 0;
+  const onPick = async (picked) => {
+    if (call) {
+      call.picked = true;
+      const { method, args } = call.origin;
+      const rendered = locatorSource(call.target, method, args);
+      applyPickToSnapshots(sink.capturedLocators, {
+        failing: { method, args, rendered, location: call.location },
         ...picked
-      };
-      applyPickToSnapshots(sink.capturedLocators, pick);
-      sink.probedLocations.add(callerLocation);
-      const place = callerLocation.slice(0, callerLocation.lastIndexOf(":"));
-      console.log(`[piwi] Locator picked at ${place}: ${picked.picked.locator}`);
-      await postPickToEditor(
-        process.env[PIWI_LOCAL_DEBUG_ENV.editorSend],
-        pickPayload(picked.picked.locator, callerLocation)
-      );
-    };
-    const choice = await internalCall(
+      });
+      sink.probedLocations.add(call.location);
+    }
+    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));
+  };
+  const record = { title, location, reason, startedAt: Date.now(), duration: 0 };
+  sink.stops.push(record);
+  const end = new AbortController();
+  const shown = withTestTimeoutHeld(
+    testInfo,
+    () => internalCall(
       page,
       () => pauseHere(
         page,
-        testInfo,
-        { location: callerLocation, action, locator, target },
+        {
+          location,
+          call: title,
+          attempt: testInfo.retry > 0 ? testInfo.retry + 1 : null,
+          target: call?.page === page ? call.target : null
+        },
         { fn: probeElementAttrs, arg: CAPTURED_ATTRS_ARG },
-        onPick
+        onPick,
+        recorderAt(page, testInfo, location, reason === "page-pause" ? "pause" : "breakpoint"),
+        end.signal
       )
-    );
-    if (choice === "step") pause.next = true;
-    else if (choice === "finish") pause.finished = true;
-  } catch {
+    )
+  ).finally(() => {
+    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);
+  });
+  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";
+}
+var END_STOP_MS = 2e3;
+var RELEASED_CALL_MS = 2e3;
+var RELEASED_QUIET_MS = 200;
+async function endShownStops(sink, why, closing) {
+  const ending = [];
+  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;
+    if (!end.signal.aborted) {
+      record.duration = Date.now() - record.startedAt;
+      end.abort(why);
+      if (why === "ended" && stopHeldAt !== null) heldAt = Math.min(heldAt, stopHeldAt);
+    }
+    ending.push(done);
+  }
+  if (sink.testInfo && heldAt !== Infinity) restoreTestTime(sink.testInfo, heldAt);
+  await settledWithin(ending, END_STOP_MS);
+}
+function releaseCall(sink, settled) {
+  sink.releasedQuietSince = Date.now();
+  sink.released.push(settled.then(() => void (sink.releasedQuietSince = Date.now())));
+}
+function releasedRequestsEnded(sink) {
+  if (sink.releasedRequests.size === 0) return Promise.resolve();
+  return new Promise((resolve11) => sink.onReleasedRequestsEnded = resolve11);
+}
+async function awaitReleasedCalls(sink) {
+  if (sink.released.length === 0) return;
+  const deadline = Date.now() + RELEASED_CALL_MS;
+  await settledWithin(sink.released, RELEASED_CALL_MS);
+  for (let now = Date.now(); now < deadline; now = Date.now()) {
+    if (sink.releasedRequests.size > 0) {
+      await settledWithin([releasedRequestsEnded(sink)], deadline - now);
+      continue;
+    }
+    const quiet = now - sink.releasedQuietSince;
+    if (quiet >= RELEASED_QUIET_MS) return;
+    await new Promise((resolve11) => setTimeout(resolve11, Math.min(RELEASED_QUIET_MS - quiet, deadline - now)));
+  }
+}
+async function settledWithin(pending, ms) {
+  if (pending.length === 0) return;
+  let timer;
+  await Promise.race([Promise.allSettled(pending), new Promise((resolve11) => timer = setTimeout(resolve11, ms))]);
+  clearTimeout(timer);
+}
+function endStopsWithTestFunction(testInfo, sink) {
+  const callbacks = testInfo._onDidFinishTestFunctionCallbacks;
+  if (!(callbacks instanceof Set)) return;
+  const theirs = [...callbacks];
+  callbacks.clear();
+  callbacks.add(() => endShownStops(sink, "ended"));
+  for (const callback of theirs) callbacks.add(callback);
+}
+function recorderAt(page, testInfo, location, reason) {
+  if (!canRecordFromHere()) return void 0;
+  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.");
+    else
+      console.log(
+        why ? `[piwi] Nothing was recorded: ${why}` : "[piwi] The recording ended: the test is paused again."
+      );
+  };
+}
+async function pauseInPlace(page, playwrightPause, location) {
+  const sink = currentSink;
+  const testInfo = sink?.testInfo;
+  const context = pageContext(page);
+  if (!sink || !testInfo || !location || !context || !contextDebugger(context)) {
+    return leaveToPlaywright(context, playwrightPause);
+  }
+  if (!sink.pause && (!canRecordFromHere() || pauseSkipReason(pauseGateFromTestInfo(testInfo)))) {
+    return leaveToPlaywright(context, playwrightPause);
+  }
+  sink.pause ??= { set: NO_BREAKPOINTS, step: false, finished: false };
+  watchStops(context, onDebuggerStop);
+  await steerDebugger(context, "pause");
+  PAGE_PAUSES.set(context, location);
+  try {
+    await playwrightPause({ __testHookKeepTestTimeout: true });
+  } finally {
+    PAGE_PAUSES.delete(context);
   }
 }
+async function leaveToPlaywright(context, playwrightPause) {
+  if (context) PLAYWRIGHT_PAUSES.set(context, (PLAYWRIGHT_PAUSES.get(context) ?? 0) + 1);
+  try {
+    await withInspector(() => playwrightPause());
+  } finally {
+    if (context) {
+      const left = (PLAYWRIGHT_PAUSES.get(context) ?? 1) - 1;
+      if (left > 0) PLAYWRIGHT_PAUSES.set(context, left);
+      else PLAYWRIGHT_PAUSES.delete(context);
+    }
+  }
+}
+var PLAYWRIGHT_PAUSE = /* @__PURE__ */ Symbol.for("@piwitests/reporter:playwright-pause");
+function playwrightPauseOf(page) {
+  const current = page.pause;
+  if (typeof current !== "function") return null;
+  const own = current[PLAYWRIGHT_PAUSE] ?? current;
+  const proto = Object.getPrototypeOf(page);
+  const theirs = proto?.pause;
+  if (proto && typeof theirs === "function") {
+    if (!theirs[PLAYWRIGHT_PAUSE]) {
+      const wrapped = function(options) {
+        return leaveToPlaywright(pageContext(this), () => theirs.call(this, options));
+      };
+      wrapped[PLAYWRIGHT_PAUSE] = theirs;
+      proto.pause = wrapped;
+    }
+    markPausesWrapped();
+  }
+  return (options) => own.call(page, options);
+}
 function wrapLocator(page, locator, originMethod, originArgs) {
   return new Proxy(locator, {
     get(target, prop) {
@@ -15065,36 +16407,35 @@ function wrapLocator(page, locator, originMethod, originArgs) {
           const isNot = Boolean(callArgs[1]?.isNot);
           const callerLocation = sink ? captureCallerLocation() : null;
           if (sink) recordLocatorPage(sink, page, target, callerLocation, noteLocatorCall(page, EXPECT_METHOD, true));
-          if (sink?.pause && pausesAt(sink.pause, callerLocation)) {
-            await pauseBefore(sink, page, target, callerLocation, assertionLabel(expression, isNot), {
+          const call = knowLocatorCall(sink, page, target, callerLocation, { method: originMethod, args: originArgs });
+          try {
+            if (!sink || isNot || !EXPECT_CAPTURE_EXPRESSIONS.has(expression)) {
+              return await callMethod(target, prop, callArgs);
+            }
+            sink.lastActivePage = page;
+            const used = {
               method: originMethod,
-              args: originArgs
-            });
-          }
-          if (!sink || isNot || !EXPECT_CAPTURE_EXPRESSIONS.has(expression)) {
-            return callMethod(target, prop, callArgs);
-          }
-          sink.lastActivePage = page;
-          const used = {
-            method: originMethod,
-            args: originArgs,
-            raw: `${originMethod}(${JSON.stringify(originArgs)})`
-          };
-          const alreadyProbed = callerLocation !== null && sink.probedLocations.has(callerLocation);
-          let seq = -1;
-          if (!alreadyProbed) {
-            seq = sink.capturedLocators.length;
-            sink.capturedLocators.push({ location: callerLocation, used, element: null, alternatives: [] });
-          }
-          const result = await callMethod(target, prop, callArgs);
-          const matches = result?.matches;
-          if (matches === true && !alreadyProbed) {
-            if (callerLocation) sink.probedLocations.add(callerLocation);
-            startElementCapture(sink, page, target, seq, callerLocation, used);
-          } else if (matches === false) {
-            sink.failedLocators.push({ method: originMethod, args: originArgs, location: callerLocation });
+              args: originArgs,
+              raw: `${originMethod}(${JSON.stringify(originArgs)})`
+            };
+            const alreadyProbed = callerLocation !== null && sink.probedLocations.has(callerLocation);
+            let seq = -1;
+            if (!alreadyProbed) {
+              seq = sink.capturedLocators.length;
+              sink.capturedLocators.push({ location: callerLocation, used, element: null, alternatives: [] });
+            }
+            const result = await callMethod(target, prop, callArgs);
+            const matches = result?.matches;
+            if (matches === true && !alreadyProbed && !call?.picked) {
+              if (callerLocation) sink.probedLocations.add(callerLocation);
+              startElementCapture(sink, page, target, seq, callerLocation, used);
+            } else if (matches === false) {
+              sink.failedLocators.push({ method: originMethod, args: originArgs, location: callerLocation });
+            }
+            return result;
+          } finally {
+            forgetLocatorCall(sink, call);
           }
-          return result;
         };
       }
       if (!ACTION_METHOD_SET.has(prop)) return original;
@@ -15109,9 +16450,7 @@ function wrapLocator(page, locator, originMethod, originArgs) {
           args: originArgs,
           raw: `${originMethod}(${JSON.stringify(originArgs)})`
         };
-        if (sink.pause && pausesAt(sink.pause, callerLocation)) {
-          await pauseBefore(sink, page, target, callerLocation, String(prop), used);
-        }
+        const call = knowLocatorCall(sink, page, target, callerLocation, used);
         const alreadyProbed = callerLocation !== null && sink.probedLocations.has(callerLocation);
         let seq = -1;
         if (!alreadyProbed) {
@@ -15129,8 +16468,10 @@ function wrapLocator(page, locator, originMethod, originArgs) {
         } catch (error) {
           sink.failedLocators.push({ method: originMethod, args: originArgs, location: callerLocation });
           throw error;
+        } finally {
+          forgetLocatorCall(sink, call);
         }
-        if (!alreadyProbed) {
+        if (!alreadyProbed && !call?.picked) {
           if (callerLocation) sink.probedLocations.add(callerLocation);
           startElementCapture(sink, page, target, seq, callerLocation, used);
         }
@@ -15183,12 +16524,17 @@ function instrumentPage(page) {
   }
   const ctx = pageContext(page);
   if (ctx) instrumentContext(ctx);
+  const playwrightPause = playwrightPauseOf(page);
+  if (playwrightPause) {
+    page.pause = () => pauseInPlace(page, playwrightPause, captureCallerLocation());
+  }
   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 });
@@ -15277,8 +16623,18 @@ function instrumentPage(page) {
     } catch {
     }
   });
+  page.on("request", (request3) => {
+    const sink = currentSink;
+    if (!sink || sink.released.length === 0) return;
+    sink.releasedRequests.add(request3);
+    sink.releasedQuietSince = Date.now();
+  });
   const onRequestEnd = (request3, failed) => {
     const sink = currentSink;
+    if (sink?.releasedRequests.delete(request3)) {
+      sink.releasedQuietSince = Date.now();
+      if (sink.releasedRequests.size === 0) sink.onReleasedRequestsEnded?.();
+    }
     if (!sink || RECORDED_OPEN.has(request3)) return;
     sink.lastActivePage = page;
     const response = sink.openResponses.get(request3) ?? null;
@@ -15384,6 +16740,10 @@ async function awaitFlakeConditions() {
 function instrumentContext(context) {
   if (!context || INSTRUMENTED_CONTEXTS.has(context)) return;
   INSTRUMENTED_CONTEXTS.add(context);
+  if (typeof context.once === "function") {
+    OPEN_CONTEXTS.add(context);
+    context.once("close", () => OPEN_CONTEXTS.delete(context));
+  }
   observeOwnApiRequests(context);
   if (process.env.PIWI_CAPTURE_LOCATORS !== "false" && typeof context.addInitScript === "function") {
     void Promise.resolve(context.addInitScript({ content: PROBE_INIT_SCRIPT })).catch(() => {
@@ -15403,6 +16763,7 @@ function instrumentContext(context) {
       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 });
@@ -15419,6 +16780,7 @@ function patchBrowser(browser) {
   browser.newPage = async (...args) => {
     const page = await originalNewPage(...args);
     instrumentPage(page);
+    await armBreakpoints([pageContext(page)]);
     await awaitFlakeConditions();
     await maybeStartCodeReach(page);
     return page;
@@ -15427,6 +16789,7 @@ function patchBrowser(browser) {
   browser.newContext = async (...args) => {
     const context = await originalNewContext(...args);
     instrumentContext(context);
+    await armBreakpoints([context]);
     return context;
   };
   if (typeof browser.close === "function") {
@@ -15478,14 +16841,20 @@ async function flushSink(sink, testInfo) {
   let drainDeadline;
   await Promise.race([
     Promise.allSettled(sink.capturePromises),
-    new Promise((resolve9) => {
-      drainDeadline = setTimeout(resolve9, 2e3);
+    new Promise((resolve11) => {
+      drainDeadline = setTimeout(resolve11, 2e3);
     })
   ]);
   clearTimeout(drainDeadline);
   const page = sink.lastActivePage;
   const pageReadable = page !== null && !isPageClosed(page);
   if (pageReadable) await maybeOpenPicker(sink);
+  if (sink.stops.length > 0) {
+    await testInfo.attach(ATTACHMENT_NAMES.pauses, {
+      contentType: "application/json",
+      body: Buffer.from(JSON.stringify(sink.stops))
+    });
+  }
   if (sink.capturedLocators.length > 0) {
     await testInfo.attach(ATTACHMENT_NAMES.locators, {
       contentType: "application/json",
@@ -15516,6 +16885,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];
@@ -15686,6 +17070,7 @@ var piwiFixtures = {
   // never double-wraps a page the browser patch already instrumented.
   page: async ({ page }, use) => {
     instrumentPage(page);
+    await armBreakpoints([pageContext(page)]);
     await awaitFlakeConditions();
     await maybeStartCodeReach(page);
     await use(page);
@@ -15706,8 +17091,9 @@ var piwiFixtures = {
       if (pauseSet.size) {
         const reason = pauseSkipReason(pauseGateFromTestInfo(testInfo));
         if (reason) logPauseSkipOnce(reason);
-        else sink.pause = { set: pauseSet, next: false, finished: false };
+        else sink.pause = { set: pauseSet, step: false, finished: false };
       }
+      if (sink.pause || canRecordFromHere()) endStopsWithTestFunction(testInfo, sink);
       if (isFlakeMode()) {
         const plan = loadFlakePlan();
         const role = flakeRoleForTest(plan, {
@@ -15732,9 +17118,12 @@ var piwiFixtures = {
       activeResourceLedger()?.testStarted(testInfo);
       currentSink = sink;
       try {
+        await armBreakpoints(OPEN_CONTEXTS);
         await startCodeReachOnOpenPages();
         await use();
       } finally {
+        await endShownStops(sink, "ended");
+        await awaitReleasedCalls(sink);
         currentSink = null;
         if (sink.probeItem) {
           const applied = sink.probeInterception?.applied() ?? false;
@@ -15792,13 +17181,13 @@ function extendPiwiFixtures(test) {
 }
 
 // src/internal/ai/ai-fixtures.ts
-var fs26 = __toESM(require("fs"));
-var path31 = __toESM(require("path"));
+var fs29 = __toESM(require("fs"));
+var path33 = __toESM(require("path"));
 var import_test = require("@playwright/test");
 
 // src/internal/ai/artifact.ts
-var fs25 = __toESM(require("fs"));
-var path29 = __toESM(require("path"));
+var fs28 = __toESM(require("fs"));
+var path31 = __toESM(require("path"));
 var ARTIFACT_VERSION = 1;
 var LOCATOR_METHOD_SET2 = new Set(LOCATOR_METHODS);
 var ACTION_METHOD_SET2 = new Set(ACTION_METHODS);
@@ -15891,7 +17280,7 @@ function parseEntry(text) {
 function readEntry(file) {
   let text;
   try {
-    text = fs25.readFileSync(file, "utf8");
+    text = fs28.readFileSync(file, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw error;
@@ -15901,28 +17290,28 @@ function readEntry(file) {
 function writeEntry(file, entry) {
   const canonical = serializeEntry(entry);
   return withEntryLock(file, () => {
-    if (fs25.existsSync(file) && fs25.readFileSync(file, "utf8") === canonical) return { written: false };
-    fs25.mkdirSync(path29.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`;
-    fs25.writeFileSync(tmp, canonical);
-    fs25.renameSync(tmp, file);
+    fs28.writeFileSync(tmp, canonical);
+    fs28.renameSync(tmp, file);
     return { written: true };
   });
 }
 function withEntryLock(file, fn) {
   const lock = `${file}.lock`;
-  fs25.mkdirSync(path29.dirname(file), { recursive: true });
+  fs28.mkdirSync(path31.dirname(file), { recursive: true });
   const deadline = Date.now() + 5e3;
   for (; ; ) {
     try {
-      const fd = fs25.openSync(lock, "wx");
-      fs25.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 {
-          fs25.unlinkSync(lock);
+          fs28.unlinkSync(lock);
         } catch {
         }
       }
@@ -15932,35 +17321,35 @@ function withEntryLock(file, fn) {
     return fn();
   } finally {
     try {
-      fs25.unlinkSync(lock);
+      fs28.unlinkSync(lock);
     } catch {
     }
   }
 }
 
 // src/internal/ai/keys.ts
-var crypto7 = __toESM(require("crypto"));
-var path30 = __toESM(require("path"));
+var crypto8 = __toESM(require("crypto"));
+var path32 = __toESM(require("path"));
 var DEFAULT_AI_DIR = "__piwi__";
 function normalizeTemplate(template) {
   return template.trim().replace(/\s+/g, " ").toLowerCase();
 }
 function hashTemplate(normalized, ordinal = 0) {
   const input = ordinal > 0 ? `${normalized}#${ordinal}` : normalized;
-  return crypto7.createHash("sha256").update(input).digest("hex").slice(0, 8);
+  return crypto8.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, "");
   return (base || "x").slice(0, maxLength).replace(/-+$/g, "") || "x";
 }
 function entryDir(specFile, dir = DEFAULT_AI_DIR) {
-  return path30.join(path30.dirname(specFile), dir, path30.basename(specFile));
+  return path32.join(path32.dirname(specFile), dir, path32.basename(specFile));
 }
 function entryPath(params) {
   const basis = `${normalizeTemplate(params.testTitle)}::${normalizeTemplate(params.template)}`;
   const hash = hashTemplate(basis, params.ordinal ?? 0);
   const name = `${slug(params.testTitle)}.${slug(params.template)}.${hash}.json`;
-  return path30.join(entryDir(params.specFile, params.dir), name);
+  return path32.join(entryDir(params.specFile, params.dir), name);
 }
 function parseLocation2(location) {
   const match = /:(\d+):(\d+)$/.exec(location);
@@ -16563,18 +17952,18 @@ function testIdentity(testInfo) {
   return titles.length > 0 ? titles.join(" \u203A ") : testInfo.title;
 }
 function relativeToCwd(file) {
-  return path31.relative(process.cwd(), file).split(path31.sep).join("/");
+  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 [
@@ -16590,7 +17979,7 @@ function createAiApi(page, testInfo, config, used, intents) {
   const readSource = () => {
     if (source === null) {
       try {
-        source = fs26.readFileSync(testInfo.file, "utf8");
+        source = fs29.readFileSync(testInfo.file, "utf8");
       } catch {
         source = "";
       }