@piwitests/reporter 0.63.0 → 0.64.0

package/dist/index.js

@@ -255,7 +255,19 @@ var PIWI_FLAKE_ENV = {
 var PIWI_RESOURCES_RESULTS_ENV = "PIWI_RESOURCES_RESULTS";
 function readBool(val) {
   if (val === void 0) return void 0;
-  return val === "true";
+  return ["true", "1", "yes", "on"].includes(val.trim().toLowerCase());
+}
+function normalizeBoolEnv(env = process.env) {
+  const keys = [
+    ...ENV_FALLBACK_SPECS.filter((spec) => spec.kind === "bool").map((spec) => spec.env),
+    PIWI_ENV_KEYS.verbose,
+    PIWI_ENV_KEYS.aiScreenshotFallback,
+    "PIWI_AI_UPDATE"
+  ];
+  for (const key of keys) {
+    const value = env[key];
+    if (value !== void 0) env[key] = readBool(value) ? "true" : "false";
+  }
 }
 var ENV_FALLBACK_SPECS = [
   { option: "serverUrl", env: PIWI_ENV_KEYS.serverUrl, kind: "string" },
@@ -374,7 +386,7 @@ function resolveOptions(raw, configDir) {
     externalId.onDuplicate = externalIdOnDuplicate;
   if (Object.keys(externalId).length > 0) mergedRaw.externalId = externalId;
   const opts = { ...DEFAULTS, ...mergedRaw };
-  if (env[PIWI_ENV_KEYS.verbose] !== void 0) opts.verbose = env[PIWI_ENV_KEYS.verbose] === "true";
+  if (env[PIWI_ENV_KEYS.verbose] !== void 0) opts.verbose = readBool(env[PIWI_ENV_KEYS.verbose]);
   return opts;
 }
 function applyOptionsToEnv(options) {
@@ -469,8 +481,8 @@ function readHub(value) {
 }
 function readChannel(value) {
   if (!isObject(value)) return null;
-  const path36 = text(value.path, 4096);
-  return path36 && typeof value.token === "string" && TOKEN.test(value.token) ? { path: path36, token: value.token } : null;
+  const path37 = text(value.path, 4096);
+  return path37 && typeof value.token === "string" && TOKEN.test(value.token) ? { path: path37, token: value.token } : null;
 }
 function parseEditorDiscovery(content) {
   let value;
@@ -549,8 +561,8 @@ function parseRecordChannel(value) {
   const hash = text2.lastIndexOf("#");
   if (hash <= 0) return null;
   const token = text2.slice(hash + 1);
-  const path36 = text2.slice(0, hash);
-  return /^[A-Za-z0-9_-]{16,}$/.test(token) && !path36.includes("\0") ? { path: path36, token } : null;
+  const path37 = text2.slice(0, hash);
+  return /^[A-Za-z0-9_-]{16,}$/.test(token) && !path37.includes("\0") ? { path: path37, token } : null;
 }
 function isObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -912,10 +924,10 @@ var FrameAcks = class {
     const now = this.now();
     this.due = Math.min(Math.max(now, this.due + this.intervalMs), now + this.intervalMs);
     if (this.due <= now) return void 0;
-    return new Promise((resolve11) => {
+    return new Promise((resolve12) => {
       const timer = setTimeout(() => this.release(), this.due - now);
       timer.unref?.();
-      this.waiting = { timer, resolve: resolve11 };
+      this.waiting = { timer, resolve: resolve12 };
     });
   }
   /** Whether a frame waits for its acknowledgment. */
@@ -1116,10 +1128,15 @@ function readAct(value) {
 
 // src/internal/config/editors.ts
 var PIWI_EDITOR_ENV = "PIWI_EDITOR";
+var TEST_RUNNER_REPORTER_ENV = "PW_TEST_REPORTER";
+function startedByTestRunner(env) {
+  const reporter = env[TEST_RUNNER_REPORTER_ENV]?.trim();
+  return !!reporter && /[\\/]/.test(reporter);
+}
 function terminalRunSkip(gate) {
   const { env, argv } = gate;
   const editor = env[PIWI_EDITOR_ENV]?.trim().toLowerCase();
-  if (editor === "off") return `${PIWI_EDITOR_ENV}=off`;
+  if (editor && ["off", "false", "0", "no"].includes(editor)) return `${PIWI_EDITOR_ENV}=${editor}`;
   if (env[RUN_CHANNEL_ENV] !== void 0) return `the run names its ${RUN_CHANNEL_ENV}`;
   if (env[PIWI_ORIGIN_ENV.kind]) return "a launcher started the run";
   if (detectCi(env)) return "running under CI";
@@ -1129,7 +1146,8 @@ function terminalRunSkip(gate) {
     return "Playwright's debugger or UI mode runs it";
   }
   if (argv.slice(2).includes("merge-reports")) return "it merges reports, running no test";
-  if (!gate.terminal && editor !== "on") return "its output goes to no terminal";
+  const forced = !!editor && ["on", "true", "1", "yes"].includes(editor);
+  if (!gate.terminal && !forced && !startedByTestRunner(env)) return "its output goes to no terminal";
   return null;
 }
 function editorsFolder(env = process.env) {
@@ -1445,7 +1463,7 @@ var HttpClient = class {
   }
   /** Unified request core: transport, headers, auth, response accumulation, timeout. */
   request(method, pathname, opts) {
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       if (this.closedReason !== null) {
         reject(new Error(this.closedReason));
         return;
@@ -1468,7 +1486,7 @@ var HttpClient = class {
             data += chunk;
           });
           res.on("end", () => {
-            resolve11({ status: res.statusCode ?? 0, text: data, headers: res.headers });
+            resolve12({ status: res.statusCode ?? 0, text: data, headers: res.headers });
           });
           res.on("error", reject);
           res.on("close", () => {
@@ -1511,6 +1529,87 @@ var fs4 = __toESM(require("fs"));
 var path4 = __toESM(require("path"));
 var import_form_data2 = __toESM(require("form-data"));
 
+// ../core/src/status-classify.ts
+function mergeAnnotations(test, result) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const list of [test.annotations, result.annotations]) {
+    for (const a of list ?? []) {
+      const key = `${a.type}\0${a.description ?? ""}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push(a.description === void 0 ? { type: a.type } : { type: a.type, description: a.description });
+    }
+  }
+  return out;
+}
+function expectsFailure(annotations) {
+  if (annotations.some((a) => a.type === "skip" || a.type === "fixme")) return false;
+  return annotations.some((a) => a.type === "fail");
+}
+var EXPECTED_FAILURE_PASSED_MESSAGE = "Expected to fail, but passed.";
+function expectedFailureError(rawStatus, annotations) {
+  return rawStatus === "passed" && expectsFailure(annotations) ? EXPECTED_FAILURE_PASSED_MESSAGE : null;
+}
+function isUnexpectedStatus(status) {
+  return status === "failed" || status === "timedout" || status === "timedOut";
+}
+function isFlakyResult(lastStatus, earlierStatuses) {
+  if (lastStatus !== "passed") return false;
+  for (const status of earlierStatuses) if (isUnexpectedStatus(status)) return true;
+  return false;
+}
+function classifyStatus(rawStatus, annotations) {
+  if (rawStatus === "skipped") {
+    const intentional = annotations.some((a) => a.type === "skip" || a.type === "fixme");
+    return intentional ? "skipped" : "didnotrun";
+  }
+  if (expectsFailure(annotations)) {
+    if (rawStatus === "failed") return "passed";
+    if (rawStatus === "passed") return "failed";
+  }
+  return rawStatus;
+}
+function resolveUnrunReason(runStatus, opts) {
+  if (runStatus === "timedout") return "global-timeout";
+  if (opts.maxFailures > 0 && opts.failures >= opts.maxFailures) return "max-failures";
+  return "interrupted";
+}
+function fileOf(location) {
+  return location.replace(/:\d+:\d+$/, "");
+}
+function suiteKey(suitePath) {
+  return (suitePath ?? []).join("");
+}
+function sharedPrefixDepth(a, b) {
+  let depth = 0;
+  while (depth < a.length && depth < b.length && a[depth] === b[depth]) depth++;
+  return depth;
+}
+function linkBlockedTests(cases) {
+  const blockers = cases.filter((c) => c.status === "failed" || c.status === "timedOut" || c.status === "timedout");
+  if (blockers.length === 0) return;
+  for (const c of cases) {
+    if (c.didNotRunReason !== "previous-failure") continue;
+    const file = fileOf(c.location);
+    const inFile = blockers.filter((b) => fileOf(b.location) === file);
+    if (inFile.length === 0) continue;
+    const key = suiteKey(c.suitePath);
+    let blocker = inFile.find((b) => suiteKey(b.suitePath) === key);
+    if (!blocker) {
+      let bestDepth = 0;
+      for (const b of inFile) {
+        const depth = sharedPrefixDepth(c.suitePath ?? [], b.suitePath ?? []);
+        if (depth > bestDepth) {
+          bestDepth = depth;
+          blocker = b;
+        }
+      }
+    }
+    if (blocker) c.blockedBy = blocker.location;
+  }
+}
+
 // src/internal/submit/serializer.ts
 function resolveOverallStatus(result, counters) {
   const STATUS_MAP = {
@@ -1586,6 +1685,7 @@ function isFailingStatus(status) {
 }
 function computeDistinctRunCounts(testCases) {
   const final = /* @__PURE__ */ new Map();
+  const attemptsOf = /* @__PURE__ */ new Map();
   for (const tc of testCases) {
     const key = tc.testId ?? [
       tc.title,
@@ -1596,6 +1696,9 @@ function computeDistinctRunCounts(testCases) {
     ].join("\0");
     const status = tc.status ?? "";
     const retries = tc.retries ?? 0;
+    const attempts = attemptsOf.get(key);
+    if (attempts) attempts.push({ status, retries });
+    else attemptsOf.set(key, [{ status, retries }]);
     const prev = final.get(key);
     const decides = !prev || retries > prev.retries || retries === prev.retries && (isFailingStatus(status) || !isFailingStatus(prev.status));
     if (decides) final.set(key, { status, retries });
@@ -1606,11 +1709,15 @@ function computeDistinctRunCounts(testCases) {
     failedTests: 0,
     timedOutTests: 0,
     skippedTests: 0,
-    didNotRunTests: 0
+    didNotRunTests: 0,
+    flakyTests: 0
   };
-  for (const { status } of final.values()) {
-    if (status === "passed") counts.passedTests++;
-    else if (status === "failed") counts.failedTests++;
+  for (const [key, { status, retries }] of final) {
+    if (status === "passed") {
+      counts.passedTests++;
+      const earlier = (attemptsOf.get(key) ?? []).filter((a) => a.retries < retries).map((a) => a.status);
+      if (isFlakyResult(status, earlier)) counts.flakyTests++;
+    } else if (status === "failed") counts.failedTests++;
     else if (status === "timedOut" || status === "timedout") counts.timedOutTests++;
     else if (status === "skipped") counts.skippedTests++;
     else if (status === "didnotrun") counts.didNotRunTests++;
@@ -1686,12 +1793,12 @@ var Uploader = class {
     await this.appendReportsToForm(form, reportOptions.reports, reportOptions.uploadReport);
     await this.appendFilesToForm(form, payload.testCases, reportOptions.uploadTraces);
     const response = await this.httpClient.postFormData("/api/test-runs/upload", form, auth);
-    this.logger.info(`Successfully uploaded test results with files`);
+    this.logger.debug(`Successfully uploaded test results with files`);
     if (response.runId) {
-      this.logger.info(`Test Run ID: ${response.runId}, Project ID: ${response.projectId}`);
+      this.logger.debug(`Test Run ID: ${response.runId}, Project ID: ${response.projectId}`);
     }
     if (response.reports) {
-      for (const r of response.reports) this.logger.info(`${r.label}: ${r.path}`);
+      for (const r of response.reports) this.logger.debug(`${r.label}: ${r.path}`);
     }
     return response;
   }
@@ -1716,9 +1823,9 @@ var Uploader = class {
     form.append("testCases", JSON.stringify([]));
     await this.appendReportsToForm(form, reportOptions.reports, reportOptions.uploadReport);
     const response = await this.httpClient.postFormData("/api/test-runs/upload", form, auth);
-    this.logger.info(`Successfully uploaded reports for streaming run #${runId}`);
+    this.logger.debug(`Successfully uploaded reports for streaming run #${runId}`);
     if (response.reports) {
-      for (const r of response.reports) this.logger.info(`${r.label}: ${r.path}`);
+      for (const r of response.reports) this.logger.debug(`${r.label}: ${r.path}`);
     }
   }
   /**
@@ -1839,7 +1946,7 @@ var Uploader = class {
         }
       }
     }
-    this.logger.info(`Found ${traceCount} trace files`);
+    this.logger.debug(`Found ${traceCount} trace files`);
   }
 };
 
@@ -1959,7 +2066,7 @@ var CrashRecovery = class {
     try {
       fs6.writeFileSync(temp, JSON.stringify(file), { encoding: "utf8", flag: "wx", mode: 384 });
       fs6.renameSync(temp, this.filePath);
-      this.logger.info("Saved recovery data for later upload");
+      this.logger.debug("Saved recovery data for later upload");
     } catch (error) {
       fs6.rmSync(temp, { force: true });
       this.logger.error(`Failed to save recovery data: ${errorMessage(error)}`);
@@ -2342,8 +2449,8 @@ var FileHandler = class {
     }
     if (!lastPath) return null;
     const hash = crypto4.createHash("sha256");
-    await new Promise((resolve11, reject) => {
-      fs8.createReadStream(lastPath).on("data", (chunk) => hash.update(chunk)).on("end", resolve11).on("error", reject);
+    await new Promise((resolve12, reject) => {
+      fs8.createReadStream(lastPath).on("data", (chunk) => hash.update(chunk)).on("end", resolve12).on("error", reject);
     });
     return {
       tracePath: lastPath,
@@ -2819,10 +2926,10 @@ function createLimiter(maxConcurrent) {
     if (run) run();
   };
   return function limit(fn) {
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       const run = () => {
         active2++;
-        Promise.resolve().then(fn).then(resolve11, reject).finally(next);
+        Promise.resolve().then(fn).then(resolve12, reject).finally(next);
       };
       if (active2 < limitValue) run();
       else queue.push(run);
@@ -2871,6 +2978,7 @@ var SERVER_MAX_EVENT_BATCH_BYTES = 10 * 1024 * 1024;
 var EVENT_ENVELOPE_BYTES = 1024;
 var MAX_EVENT_REQUEST_BYTES = 4 * 1024 * 1024;
 var MAX_UPLOAD_CONNECTION_FAILURES = 3;
+var MIN_HEARTBEAT_WAIT_MS = 250;
 var StreamManager = class {
   /**
    * @param httpClient  HTTP client for server communication.
@@ -3066,7 +3174,7 @@ var StreamManager = class {
         this.streamBuffer.bindRun(response.runId);
         this.logger.info(`Streaming enabled. Run ID: ${response.runId}`);
         if (this.options.serverUrl) {
-          this.logger.info(`Watch live: ${runUrl(this.options.serverUrl, response.runId)}`);
+          this.logger.info(`View live progress: ${runUrl(this.options.serverUrl, response.runId)}`);
         }
         this.lastActivityAt = Date.now();
         this.scheduleHeartbeat();
@@ -3233,12 +3341,12 @@ var StreamManager = class {
     return this.watched === false ? this.unwatchedHeartbeatInterval : this.heartbeatInterval;
   }
   // Schedule the next idle heartbeat. Self-rescheduling; cleared by stopHeartbeat.
-  scheduleHeartbeat() {
+  scheduleHeartbeat(delay = this.heartbeatDelay()) {
     if (this.heartbeatStopped || this.heartbeatTimer) return;
     this.heartbeatTimer = setTimeout(() => {
       this.heartbeatTimer = null;
       void this.sendHeartbeat();
-    }, this.heartbeatDelay());
+    }, delay);
   }
   // Ping the server only when the run has actually been idle. Real event traffic
   // already bumps the server's activity timestamp, so a recent flush (or pending
@@ -3247,7 +3355,7 @@ var StreamManager = class {
     if (this.heartbeatStopped || !this._enabled || !this._runId || !this._token) return;
     const idleFor = Date.now() - this.lastActivityAt;
     if (idleFor < this.heartbeatDelay() || this.pendingEvents.length > 0) {
-      this.scheduleHeartbeat();
+      this.scheduleHeartbeat(Math.max(this.heartbeatDelay() - idleFor, MIN_HEARTBEAT_WAIT_MS));
       return;
     }
     try {
@@ -3320,7 +3428,7 @@ var StreamManager = class {
         this.logger.debugError(
           `${this.pendingEvents.length} events pending, retrying (attempt ${attempt + 1}/${MAX_ATTEMPTS})...`
         );
-        await new Promise((resolve11) => setTimeout(resolve11, Math.min(1e3 * Math.pow(2, attempt), 1e4)));
+        await new Promise((resolve12) => setTimeout(resolve12, Math.min(1e3 * Math.pow(2, attempt), 1e4)));
       }
       if (!this.pendingEvents.isEmpty) {
         const remaining = this.pendingEvents.takeAll();
@@ -3377,7 +3485,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((resolve11) => setTimeout(resolve11, delays[attempt]));
+        if (delays[attempt]) await new Promise((resolve12) => setTimeout(resolve12, delays[attempt]));
         try {
           await this.limitLiveUpload(
             () => this.uploader.uploadCaseFiles(
@@ -4198,6 +4306,13 @@ var SECRET_AUTOCOMPLETE = [
   "cc-number",
   "cc-csc"
 ];
+var SECRET_FIELD_SELECTOR = [
+  'input[type="password" i]',
+  ...SECRET_AUTOCOMPLETE.flatMap((token) => [
+    `input[autocomplete~="${token}" i]`,
+    `textarea[autocomplete~="${token}" i]`
+  ])
+].join(", ");
 var SECRET_WORDS = /* @__PURE__ */ new Set([
   "pass",
   "password",
@@ -4234,7 +4349,7 @@ var SECRET_WORDS = /* @__PURE__ */ new Set([
 ]);
 var SECRET_NAMES = /* @__PURE__ */ new Set(["code", "pin"]);
 function nameWords(name) {
-  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z])(?=[A-Z][a-z])/g, "$1 ").toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
 }
 function isSecretName(name) {
   let secret = namesRead.get(name);
@@ -4358,9 +4473,9 @@ function hideParams(params, count) {
     return isSecretName(decodeSafe(name)) || isSecretValue(decoded) ? `${name}=${hide()}` : part;
   }).join("");
 }
-function hidePath(path36, count) {
+function hidePath(path37, count) {
   const hide = hider(count);
-  return path36.split("/").map((segment) => {
+  return path37.split("/").map((segment) => {
     const [own = "", ...params] = segment.split(";");
     const decoded = decodeSafe(own);
     const kept = decoded !== HIDDEN_VALUE && isSecretValue(decoded) ? hide() : own;
@@ -4370,14 +4485,14 @@ function hidePath(path36, count) {
 function hideSecretsInUrl(url, count = { n: 0 }) {
   const parts = URL_PARTS.exec(url);
   if (!parts) return url;
-  const [, scheme = "", authority, path36 = "", query = "", fragment = ""] = parts;
+  const [, scheme = "", authority, path37 = "", query = "", fragment = ""] = parts;
   let out = "";
   if (authority !== void 0) {
     const at = authority.lastIndexOf("@");
     const colon = at >= 0 ? authority.slice(0, at).indexOf(":") : -1;
     out += colon >= 0 && colon < at - 1 ? `${scheme}//${authority.slice(0, colon + 1)}${hider(count)()}${authority.slice(at)}` : `${scheme}//${authority}`;
   }
-  out += hidePath(path36, count);
+  out += hidePath(path37, count);
   if (query) out += `?${hideParams(query.slice(1), count)}`;
   if (fragment) {
     const body = fragment.slice(1);
@@ -4408,10 +4523,10 @@ function hideInText(text2, count) {
   if (text2.length < 4 || !/[A-Za-z0-9]/.test(text2)) return text2;
   const hide = hider(count);
   let out = hidePem(text2, hide);
-  out = out.replace(QUERY_PAIR, (all, sep11, name, value) => {
+  out = out.replace(QUERY_PAIR, (all, sep12, name, value) => {
     const decoded = decodeSafe(value);
     if (!value || decoded === HIDDEN_VALUE) return all;
-    return isSecretName(name) || isSecretValue(decoded) ? `${sep11}${name}=${hide()}` : all;
+    return isSecretName(name) || isSecretValue(decoded) ? `${sep12}${name}=${hide()}` : all;
   });
   out = out.replace(URL_PASSWORD, (_all, before, _password, at) => `${before}${hide()}${at}`);
   out = out.replace(SET_COOKIE, (_all, before) => `${before}${hide()}`);
@@ -4442,9 +4557,149 @@ function hideSecretsInText(text2, count = { n: 0 }) {
   }
   return out + hideInText(text2.slice(last), count);
 }
+var TYPED_TITLE = /^(?:Fill|Type|Insert) "/;
+function hideTypedText(title) {
+  const typing = TYPED_TITLE.exec(title);
+  if (!typing) return title;
+  const start = typing[0].length;
+  const end = title.endsWith('"') ? title.length - 1 : title.lastIndexOf('" ');
+  return end >= start ? `${title.slice(0, start)}${HIDDEN_VALUE}${title.slice(end)}` : `${typing[0]}${HIDDEN_VALUE}"`;
+}
+var SECRET_FIELD_WORDS = /* @__PURE__ */ new Set([
+  "passe",
+  "mdp",
+  "passwort",
+  "kennwort",
+  "contrasena",
+  "clave",
+  "senha",
+  "cvv",
+  "cvc",
+  "csc",
+  "pin",
+  "pw",
+  "totp",
+  "mfa",
+  "2fa"
+]);
+var SECRET_STEMS = ["password", "passwd", "passwort", "kennwort", "contrasena", "senha", "motdepasse"];
+var SECRET_CODE_KINDS = /* @__PURE__ */ new Set([
+  "verification",
+  "security",
+  "confirmation",
+  "auth",
+  "authentication",
+  "access",
+  "time",
+  "otp",
+  "sms",
+  "login",
+  "mfa",
+  "2fa"
+]);
+function isSecretLocator(locator) {
+  const plain = locator.normalize("NFD").replace(/[̀-ͯ]/g, "");
+  if (/type\s*=\s*["']?password\b/i.test(plain)) return true;
+  for (const quoted of plain.matchAll(/(['"])((?:(?!\1)[^\\]|\\.)*)\1/g)) if (isSecretName(quoted[2])) return true;
+  const words = nameWords(plain);
+  return words.some(
+    (word) => SECRET_WORDS.has(word) || SECRET_FIELD_WORDS.has(word) || SECRET_STEMS.some((stem) => word.includes(stem))
+  ) || words.includes("code") && words.some((word) => SECRET_CODE_KINDS.has(word));
+}
+var TYPED_CALL = (
+  // eslint-disable-next-line no-control-regex -- matches the ESC byte of a color code
+  /^((?:\u001b\[[\d;]*m)*[ \t]*(?:(?:-|\d+ ×)[ \t]+)?(?:\w+\.)?)(fill|type|insertText)\("/gm
+);
+var TYPED_END = /"\)(?=(?:\u001b\[[\d;]*m|[ \t])*(?:\r?\n|$))/g;
+function hideTypedTextInLog(text2) {
+  let out = "";
+  let from = 0;
+  TYPED_CALL.lastIndex = 0;
+  for (let call = TYPED_CALL.exec(text2); call; call = TYPED_CALL.exec(text2)) {
+    out += `${text2.slice(from, call.index)}${call[1]}${call[2]}("${HIDDEN_VALUE}")`;
+    TYPED_END.lastIndex = call.index + call[0].length;
+    const end = TYPED_END.exec(text2);
+    if (!end) return out;
+    from = end.index + 2;
+    TYPED_CALL.lastIndex = from;
+  }
+  return out + text2.slice(from);
+}
+var READ_LOCATOR = /(?:waiting for|Locator:)[ \t]+(.*)$/gm;
+var RESOLVED_PASSWORD = /resolved to <input\b[^>\n]*\btype="password"/i;
+var READ_VALUE = (
+  // eslint-disable-next-line no-control-regex -- matches the ESC byte of a color code
+  /(unexpected value |(?:Expected|Received)(?: string)?:[ \t]*(?:\u001b\[[\d;]*m)*(?:not[ \t]+)?)"(?:.*"|.*)/g
+);
+var RESOLVED_ELEMENT = /resolved to <[^>\n]*/g;
+var VALUE_ATTRIBUTE = /\bvalue="[^"\n]*"/g;
+var COLOR = /\u001b\[[\d;]*m/g;
+function namesSecretField(text2) {
+  if (RESOLVED_PASSWORD.test(text2)) return true;
+  for (const named of text2.matchAll(READ_LOCATOR))
+    if (isSecretLocator(named[1].replace(COLOR, "").trim())) return true;
+  return false;
+}
+function hideReadValues(text2) {
+  return text2.replace(READ_VALUE, (_, before) => `${before}"${HIDDEN_VALUE}"`);
+}
+function hideResolvedValues(text2, secretField) {
+  if (!text2.includes("resolved to <")) return text2;
+  return text2.replace(
+    RESOLVED_ELEMENT,
+    (element) => secretField || /\btype="password"/i.test(element) ? element.replace(VALUE_ATTRIBUTE, `value="${HIDDEN_VALUE}"`) : element
+  );
+}
+var LOGGED_HEADER = (
+  // eslint-disable-next-line no-control-regex -- matches the ESC byte of a color code
+  /^(?:\u001b\[[\d;]*m)*(?:[ \t]+(?:(?:-|\d+ ×)[ \t]+)?|(?:-|\d+ ×)[ \t]+)([A-Za-z][\w-]*): /
+);
+function colorsAtEnd(line) {
+  let end = line.length;
+  while (end > 0 && line[end - 1] === "m") {
+    const start = line.lastIndexOf("\x1B[", end - 1);
+    if (start < 0 || !/^[\d;]*$/.test(line.slice(start + 2, end - 1))) break;
+    end = start;
+  }
+  return end;
+}
+function hideSecretHeaders(text2) {
+  if (!text2.includes(": ")) return text2;
+  return text2.split("\n").map((line) => {
+    const header = LOGGED_HEADER.exec(line);
+    if (!header || !isSecretName(header[1])) return line;
+    const rest = line.slice(header[0].length);
+    const end = colorsAtEnd(rest);
+    return end === 0 ? line : `${header[0]}${HIDDEN_VALUE}${rest.slice(end)}`;
+  }).join("\n");
+}
+function hideSecretsInLog(text2, secretField = false) {
+  const secret = secretField || namesSecretField(text2);
+  let hidden2 = hideResolvedValues(hideTypedTextInLog(text2), secret);
+  if (secret) hidden2 = hideReadValues(hidden2);
+  return hideSecretHeaders(hidden2);
+}
+var CALL_LOG = "\nCall log:";
+var CALL_LOG_END = /\n(?:---\n|[ \t]+at )/g;
+function hideSecretsInError(text2) {
+  const secretField = namesSecretField(text2);
+  let out = "";
+  let from = 0;
+  for (; ; ) {
+    const log = text2.indexOf(CALL_LOG, from);
+    const message = text2.slice(from, log === -1 ? text2.length : log);
+    out += secretField ? hideReadValues(message) : message;
+    if (log === -1) return out;
+    const start = log + CALL_LOG.length;
+    CALL_LOG_END.lastIndex = start;
+    const end = CALL_LOG_END.exec(text2)?.index ?? text2.length;
+    out += CALL_LOG + hideSecretsInLog(text2.slice(start, end), secretField);
+    from = end;
+  }
+}
 
 // ../core/src/locator-break.ts
-var filePath2 = (path36) => path36.replace(/\\/g, "/").replace(/^\.\//, "");
+var filePath2 = (path37) => path37.replace(/\\/g, "/").replace(/^\.\//, "");
 function sameFilePath(a, b) {
   const x = filePath2(a);
   const y = filePath2(b);
@@ -4713,20 +4968,47 @@ function markRecoveredSteps(steps, errors) {
 function firstErrorLine(message) {
   return stripAnsi(typeof message === "string" ? message : "").split("\n")[0].trim();
 }
+var TYPED_PARAMS = ["value", "text"];
+var BARE_TYPED_TITLE = /^(?:Fill|Type|Insert)$/;
+var OWN_CATEGORIES = /* @__PURE__ */ new Set(["test.step", "hook", "fixture"]);
+function withoutTypedText(title, params, subtitle, category) {
+  if (category && OWN_CATEGORIES.has(category)) return { title, params };
+  const hidden2 = hideTypedText(title);
+  const bare = BARE_TYPED_TITLE.test(title.trim());
+  if (hidden2 === title && !bare) return { title, params };
+  const named = bare ? "" : hidden2.slice(hidden2.indexOf(`${HIDDEN_VALUE}"`) + HIDDEN_VALUE.length + 1).trim();
+  const locators = [params?.locator, subtitle, named].filter(
+    (locator) => typeof locator === "string" && locator.length > 0
+  );
+  if (locators.length && !locators.some(isSecretLocator)) return { title, params };
+  if (!params) return { title: hidden2, params };
+  const out = { ...params };
+  for (const key of TYPED_PARAMS) if (typeof out[key] === "string") out[key] = HIDDEN_VALUE;
+  return { title: hidden2, params: out };
+}
+function hideTypedStepTitle(title, category) {
+  return category && OWN_CATEGORIES.has(category) ? title : hideTypedText(title);
+}
 function flattenSteps(steps, depth = 0) {
   const result = [];
   for (const step of steps) {
+    const named = [step.subtitle, step.params?.locator].filter((v) => typeof v === "string" && v).join(" ");
+    const typed = withoutTypedText(
+      typeof step.title === "string" ? step.title : "",
+      normalizeStepParams(step.params),
+      named || null,
+      step.category
+    );
     const flat = {
-      title: step.title,
+      title: typed.title,
       duration: step.duration,
       category: categorizeStep(step.title, step.category, step.params),
       depth
     };
     if (typeof step.subtitle === "string" && step.subtitle.length > 0) flat.subtitle = maskTokenLike(step.subtitle);
-    const params = normalizeStepParams(step.params);
-    if (params) flat.params = params;
+    if (typed.params) flat.params = typed.params;
     if (step.error?.message) {
-      flat.error = { message: step.error.message };
+      flat.error = { message: hideSecretsInError(step.error.message) };
       const thrownAt = locationText(step.error.location);
       if (thrownAt) flat.error.location = thrownAt;
       flat.failed = true;
@@ -4989,7 +5271,7 @@ function collectSourceFrames(errorText2, testFile2, declLine, opts = {}) {
       if (picked.length >= maxFrames) break;
       let abs;
       try {
-        abs = path12.resolve(frame.file);
+        abs = path12.resolve(projectRoot, frame.file);
       } catch {
         continue;
       }
@@ -5000,7 +5282,7 @@ function collectSourceFrames(errorText2, testFile2, declLine, opts = {}) {
   }
   const absTest = path12.resolve(testFile2);
   if (!picked.some((p) => p.absFile === absTest)) {
-    add2(absTest, extractFailingLine(errorText2, testFile2, declLine));
+    add2(absTest, extractFailingLine(errorText2, testFile2, declLine, projectRoot));
   }
   const frames = [];
   for (const p of picked.slice(0, maxFrames)) {
@@ -5011,12 +5293,12 @@ function collectSourceFrames(errorText2, testFile2, declLine, opts = {}) {
   }
   return frames;
 }
-function extractFailingLine(errorText2, testFile2, declarationLine) {
+function extractFailingLine(errorText2, testFile2, declarationLine, base = process.cwd()) {
   if (!errorText2) return declarationLine;
   const expectedFile = path12.resolve(testFile2);
   for (const frame of stackFrames(errorText2)) {
     try {
-      if (path12.resolve(frame.file) === expectedFile && !isNaN(frame.line)) return frame.line;
+      if (path12.resolve(base, frame.file) === expectedFile && !isNaN(frame.line)) return frame.line;
     } catch {
     }
   }
@@ -5030,40 +5312,87 @@ function workerIndexOf(result) {
 }
 
 // src/internal/support/cli-filters.ts
-var PW_VALUE_FLAGS = /* @__PURE__ */ new Set([
+var REQUIRED_VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "--add-reporter",
+  "--browser",
   "-c",
   "--config",
-  "-j",
-  "--workers",
+  "--global-timeout",
   "-g",
   "--grep",
+  "-G",
   "--grep-invert",
-  "--global-timeout",
+  "--last-failed-file",
   "--max-failures",
   "--output",
   "-p",
-  "--project",
   "--repeat-each",
   "--reporter",
   "--retries",
+  "--run-agents",
   "--shard",
+  "--test-list",
+  "--test-list-invert",
   "--timeout",
-  "--trace"
+  "--trace",
+  "--tsconfig",
+  "--ui-host",
+  "--ui-port",
+  "--update-source-method",
+  "-j",
+  "--workers"
 ]);
-function detectCliFileFilters(argv = process.argv) {
+var OPTIONAL_VALUE_FLAGS = /* @__PURE__ */ new Set(["--debug", "--only-changed", "--shuffle", "-u", "--update-snapshots"]);
+var VARIADIC_FLAGS = /* @__PURE__ */ new Set(["--project"]);
+var NARROWING_FLAGS = ["--last-failed", "--only-changed", "--test-list", "--test-list-invert"];
+function parseTestArguments(argv) {
   const args = argv.slice(2);
+  const files = [];
+  const options = /* @__PURE__ */ new Map();
+  if (args.find((arg) => !arg.startsWith("-")) === "merge-reports") return { files, options };
   const testIdx = args.indexOf("test");
   const rest = testIdx >= 0 ? args.slice(testIdx + 1) : args;
-  const files = [];
   for (let i = 0; i < rest.length; i++) {
     const tok = rest[i];
-    if (tok.startsWith("-")) {
-      if (!tok.includes("=") && PW_VALUE_FLAGS.has(tok)) i++;
+    if (!tok.startsWith("-")) {
+      files.push(tok);
       continue;
     }
-    files.push(tok);
+    const eq = tok.indexOf("=");
+    if (eq > 0) {
+      options.set(tok.slice(0, eq), tok.slice(eq + 1));
+      continue;
+    }
+    const next = rest[i + 1];
+    if (REQUIRED_VALUE_FLAGS.has(tok) && next !== void 0) {
+      options.set(tok, next);
+      i++;
+    } else if (OPTIONAL_VALUE_FLAGS.has(tok) && next !== void 0 && !next.startsWith("-")) {
+      options.set(tok, next);
+      i++;
+    } else if (VARIADIC_FLAGS.has(tok)) {
+      const values = [];
+      while (rest[i + 1] !== void 0 && !rest[i + 1].startsWith("-")) values.push(rest[++i]);
+      options.set(tok, values.join(","));
+    } else {
+      options.set(tok, true);
+    }
   }
-  return files;
+  return { files, options };
+}
+function detectCliFileFilters(argv = process.argv) {
+  return parseTestArguments(argv).files;
+}
+function detectCliNarrowingFlags(argv = process.argv) {
+  const { options } = parseTestArguments(argv);
+  return [...options.keys()].filter((flag) => NARROWING_FLAGS.includes(flag)).map((flag) => flag.slice(2));
+}
+function detectCliGrep(argv = process.argv) {
+  const { options } = parseTestArguments(argv);
+  const valueOf = (...names) => names.map((name) => options.get(name)).find((v) => typeof v === "string" && v.length > 0);
+  const grep = valueOf("--grep", "-g");
+  const grepInvert = valueOf("--grep-invert", "-G");
+  return { ...grep ? { grep } : {}, ...grepInvert ? { grepInvert } : {} };
 }
 
 // src/internal/support/selection-env.ts
@@ -5117,6 +5446,8 @@ var LIVE_FRAME_BYTE_RATE = 256 * 1024;
 var MAX_LIVE_FRAME = 192 * 1024;
 var MAX_LIVE_FRAME_BASE64 = 4 * Math.ceil(MAX_LIVE_FRAME / 3);
 var MAX_LIVE_MESSAGE = MAX_LIVE_FRAME_BASE64 + 8 * 1024;
+var MAX_LIVE_CALL_LOG_LINES = 20;
+var LIVE_CALL_LOGS_PER_SECOND = 4;
 var KEY = /^pdl_[A-Za-z0-9_-]{43}$/;
 function isLiveViewKey(value) {
   return typeof value === "string" && KEY.test(value);
@@ -5180,12 +5511,68 @@ function liveShareRefusal(status) {
       return "Sharing stopped: the instance did not answer. Share the run again to try once more.";
   }
 }
+var MAX_LIVE_MASKS = 20;
+var MAX_LIVE_MASK_LENGTH = 200;
+var FRAME_CALLS = /* @__PURE__ */ new Set(["frameLocator", "contentFrame", "owner"]);
+var NARROWING_CALLS = /* @__PURE__ */ new Set(["filter", "and", "or", "visible", "first", "last", "nth"]);
+function liveMaskProblem(locator) {
+  if (!locator.trim()) return "A masked element needs a locator.";
+  if (locator.length > MAX_LIVE_MASK_LENGTH) return `A locator is ${MAX_LIVE_MASK_LENGTH} characters at most.`;
+  const source = locator.trim();
+  const chain = tryParseLocatorChain(source);
+  if (!chain?.calls.length || NARROWING_CALLS.has(chain.calls[0].method)) {
+    return `\`${source}\` is not a Playwright locator, such as getByLabel('IBAN').`;
+  }
+  if (chain.calls.some((call) => FRAME_CALLS.has(call.method))) {
+    return `\`${source}\` enters a frame: masks are looked for in every frame of the page, so name the element alone, such as getByLabel('Card number'), or the iframe, such as locator('iframe#card').`;
+  }
+  return null;
+}
+function parseLiveMasks(value) {
+  if (!Array.isArray(value) || value.length > MAX_LIVE_MASKS) return null;
+  const locators = [];
+  for (const locator of value) {
+    if (typeof locator !== "string" || liveMaskProblem(locator)) return null;
+    if (!locators.includes(locator.trim())) locators.push(locator.trim());
+  }
+  return locators;
+}
 function isObject5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isInt2(value, min, max) {
   return typeof value === "number" && Number.isInteger(value) && value >= min && value <= max;
 }
+var LONGEST_REPEAT = 12;
+function sameLines(lines, a, b, size) {
+  for (let k = 0; k < size; k++) if (lines[a + k] !== lines[b + k]) return false;
+  return true;
+}
+function compressCallLog(lines) {
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    let size = 1;
+    let count = 1;
+    for (let length = 1; length <= LONGEST_REPEAT && i + length * 2 <= lines.length; length++) {
+      let times = 1;
+      while (i + length * (times + 1) <= lines.length && sameLines(lines, i, i + length * times, length)) times++;
+      if (times > 1 && times * length > count * size) {
+        size = length;
+        count = times;
+      }
+    }
+    for (let k = 0; k < size; k++) {
+      const line = lines[i + k];
+      const indent = /^\s*/.exec(line)[0];
+      if (count === 1) out.push(`${indent}- ${line.trim()}`);
+      else if (k === 0) out.push(`${indent}${count} \xD7 ${line.trim()}`);
+      else out.push(`${indent}${" ".repeat(`${count} \xD7 `.length - 2)}- ${line.trim()}`);
+    }
+    i += size * count;
+  }
+  return out;
+}
 function parseInstanceToWorker(data) {
   let value;
   try {
@@ -5193,10 +5580,24 @@ function parseInstanceToWorker(data) {
   } catch {
     return null;
   }
-  if (!isObject5(value) || value.type !== "viewers" || !isInt2(value.count, 0, 1e6)) return null;
+  if (!isObject5(value)) return null;
+  if (value.type === "masks") return { type: "masks", locators: parseLiveMasks(value.locators) };
+  if (value.type !== "viewers" || !isInt2(value.count, 0, 1e6)) return null;
   return { type: "viewers", count: value.count };
 }
 
+// src/internal/streaming/live-view-note.ts
+function ciLiveViewNote(why) {
+  switch (why) {
+    case "off":
+      return "Live view off: nobody can watch this run's tests on the dashboard while it runs. A Project admin turns it on in Project \u2192 Settings \u2192 Live view, for the runs that start after.";
+    case "unregistered":
+      return "Live view unavailable: the reporter's global setup did not register this run as it started (wrapConfig adds it), so nobody can watch its tests on the dashboard while it runs.";
+    case "streaming-off":
+      return "Live view unavailable: this run does not stream its results (streaming: false), so nobody can watch its tests on the dashboard while it runs.";
+  }
+}
+
 // src/public/global-setup.ts
 var path16 = __toESM(require("path"));
 
@@ -5393,7 +5794,7 @@ async function checkBaseUrl(target, options = {}) {
     } else {
       reason = outcome.error;
     }
-    if (attempt < attempts) await new Promise((resolve11) => setTimeout(resolve11, delayMs));
+    if (attempt < attempts) await new Promise((resolve12) => setTimeout(resolve12, delayMs));
   }
   return `${reason} (${attempts} ${attempts === 1 ? "attempt" : "attempts"})`;
 }
@@ -5431,7 +5832,7 @@ var path14 = __toESM(require("path"));
 var http2 = __toESM(require("http"));
 var https2 = __toESM(require("https"));
 function backendRequest(url, init) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     const target = new URL(url);
     const headers = { ...init.headers };
     if (init.body !== void 0) headers["Content-Length"] = Buffer.byteLength(init.body);
@@ -5446,7 +5847,7 @@ function backendRequest(url, init) {
       });
       res.on(
         "end",
-        () => resolve11({ status: res.statusCode ?? 0, headers: res.headers, text: Buffer.concat(chunks).toString("utf8") })
+        () => resolve12({ status: res.statusCode ?? 0, headers: res.headers, text: Buffer.concat(chunks).toString("utf8") })
       );
       res.on("error", reject);
       res.on("close", () => {
@@ -5520,8 +5921,8 @@ function backendManifestFetch(insecure) {
 function instrumentationManifestUrls(baseUrl) {
   const base = new URL(baseUrl);
   const root = new URL(INSTRUMENTATION_MANIFEST_PATH, base).toString();
-  const path36 = base.pathname.replace(/\/+$/, "");
-  return path36 ? [new URL(`${path36}${INSTRUMENTATION_MANIFEST_PATH}`, base).toString(), root] : [root];
+  const path37 = base.pathname.replace(/\/+$/, "");
+  return path37 ? [new URL(`${path37}${INSTRUMENTATION_MANIFEST_PATH}`, base).toString(), root] : [root];
 }
 async function fetchInstrumentationManifest(baseUrl, fetchImpl = fetch) {
   try {
@@ -5659,13 +6060,13 @@ function normalizeFunctionRanges(ranges) {
 }
 function normalizeCoveragePath(raw) {
   if (typeof raw !== "string" || raw.length > MAX_PATH_LENGTH || raw.includes("\0")) return null;
-  const path36 = raw.replace(/\\/g, "/").replace(/^\.\//, "");
-  if (!path36 || path36.startsWith("../") || path36.startsWith("/") || /^[A-Za-z]:\//.test(path36)) return null;
-  if (/(^|\/)node_modules\//.test(path36)) return null;
-  return path36;
+  const path37 = raw.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (!path37 || path37.startsWith("../") || path37.startsWith("/") || /^[A-Za-z]:\//.test(path37)) return null;
+  if (/(^|\/)node_modules\//.test(path37)) return null;
+  return path37;
 }
-function fileEntry(path36, runtime, blob, functions = [], lines = []) {
-  const file = { path: path36, runtime };
+function fileEntry(path37, runtime, blob, functions = [], lines = []) {
+  const file = { path: path37, 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;
@@ -5684,11 +6085,11 @@ function sanitizeCoverage(raw) {
   const files = [];
   for (const item of raw.files) {
     if (!isRecord(item) || !isRuntime(item.runtime)) continue;
-    const path36 = normalizeCoveragePath(item.path);
-    if (path36 === null) continue;
+    const path37 = normalizeCoveragePath(item.path);
+    if (path37 === null) continue;
     const blob = typeof item.blob === "string" && BLOB_ID.test(item.blob) ? item.blob : void 0;
     files.push(
-      fileEntry(path36, item.runtime, blob, normalizeFunctionRanges(item.functions), normalizeLineRanges(item.lines))
+      fileEntry(path37, item.runtime, blob, normalizeFunctionRanges(item.functions), normalizeLineRanges(item.lines))
     );
   }
   const merged = mergeCoverage(captureOf(files, raw.incomplete === true));
@@ -5967,13 +6368,13 @@ var ServerCoverageCollector = class {
     if (parts.length === 0 || this.closer.signal.aborted) {
       return Promise.resolve({ files: [], incomplete: truncated || parts.length > 0 });
     }
-    return new Promise((resolve11) => {
+    return new Promise((resolve12) => {
       const entry = {
         pending: parts.length,
         captures: [],
         checksums: /* @__PURE__ */ new Map(),
         incomplete: truncated,
-        resolve: resolve11
+        resolve: resolve12
       };
       for (const [origin, ids] of parts) this.enqueue(origin, { entry, ids });
     });
@@ -6458,8 +6859,8 @@ function parseRouteKey(routeKey2) {
   return { method: routeKey2.slice(0, space).toUpperCase(), pattern: routeKey2.slice(space + 1) };
 }
 function patternToRegex(pattern) {
-  const path36 = pattern.split("?")[0] ?? pattern;
-  const escaped = path36.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:[A-Za-z0-9_]+/g, "[^/]+");
+  const path37 = pattern.split("?")[0] ?? pattern;
+  const escaped = path37.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:[A-Za-z0-9_]+/g, "[^/]+");
   return new RegExp(`^${escaped}$`);
 }
 function suitePathEqual(a, b) {
@@ -6482,13 +6883,13 @@ function matchProbeItem(plan, test) {
 function requestMatchesRoute(method, url, routeKey2) {
   const { method: rm, pattern } = parseRouteKey(routeKey2);
   if (rm && rm !== method.toUpperCase()) return false;
-  let path36;
+  let path37;
   try {
-    path36 = new URL(url).pathname;
+    path37 = new URL(url).pathname;
   } catch {
-    path36 = url.split("?")[0] ?? url;
+    path37 = url.split("?")[0] ?? url;
   }
-  return patternToRegex(pattern).test(path36);
+  return patternToRegex(pattern).test(path37);
 }
 function createProbeState() {
   return { navigated: false, matches: 0 };
@@ -6510,10 +6911,10 @@ function isProbeMode() {
 function loadPlan() {
   if (planCache !== void 0) return planCache;
   planCache = null;
-  const path36 = process.env[PIWI_PROBE_ENV.plan];
-  if (path36) {
+  const path37 = process.env[PIWI_PROBE_ENV.plan];
+  if (path37) {
     try {
-      planCache = JSON.parse(fs16.readFileSync(path36, "utf8"));
+      planCache = JSON.parse(fs16.readFileSync(path37, "utf8"));
     } catch {
       planCache = null;
     }
@@ -6530,17 +6931,27 @@ function probeItemForTest(test) {
 function classifyProbeHandled(signals) {
   const blank = signals.blankPage === true;
   if ((signals.pageErrors ?? 0) > 0 || signals.backendError && blank) return "unhandled";
-  return signals.consoleErrors > 0 || signals.dialogs > 0 || signals.backendError || blank ? "degraded" : "graceful";
+  const backendDegraded = signals.backendError && signals.faultIsTheError !== true;
+  return signals.consoleErrors > 0 || signals.dialogs > 0 || backendDegraded || blank ? "degraded" : "graceful";
+}
+var SELF_ERROR_FAULTS = /* @__PURE__ */ new Set(["throw", "status"]);
+function faultIsTheError(fault) {
+  return SELF_ERROR_FAULTS.has(fault);
+}
+var RESOURCE_ERROR_TEXT = /^Failed to load resource\b/;
+function probeConsoleErrors(entries) {
+  return entries.filter((e) => e.type === "error" && !(typeof e.text === "string" && RESOURCE_ERROR_TEXT.test(e.text))).length;
 }
 function outcomeFromStatus(status, applied) {
   if (!applied) return "inconclusive";
-  return status === "failed" || status === "timedOut" || status === "interrupted" ? "noticed" : "not-noticed";
+  if (status === "failed" || status === "timedOut") return "noticed";
+  return status === "passed" ? "not-noticed" : "inconclusive";
 }
 function recordProbeOutcome(line) {
-  const path36 = process.env[PIWI_PROBE_ENV.results];
-  if (!path36) return;
+  const path37 = process.env[PIWI_PROBE_ENV.results];
+  if (!path37) return;
   try {
-    fs16.appendFileSync(path36, `${JSON.stringify(line)}
+    fs16.appendFileSync(path37, `${JSON.stringify(line)}
 `);
   } catch {
   }
@@ -6830,23 +7241,26 @@ function dropOneField(body) {
   } catch {
     return body;
   }
+  let dropped = false;
   if (Array.isArray(parsed2)) {
     let key;
     for (const el of parsed2) {
       if (el && typeof el === "object" && !Array.isArray(el)) {
         key ??= Object.keys(el)[0];
-        if (key) delete el[key];
+        if (key && Object.prototype.hasOwnProperty.call(el, key)) {
+          delete el[key];
+          dropped = true;
+        }
       }
     }
-    return JSON.stringify(parsed2);
-  }
-  if (parsed2 && typeof parsed2 === "object") {
-    const obj = parsed2;
-    const key = Object.keys(obj)[0];
-    if (key) delete obj[key];
-    return JSON.stringify(obj);
+  } else if (parsed2 && typeof parsed2 === "object") {
+    const key = Object.keys(parsed2)[0];
+    if (key) {
+      delete parsed2[key];
+      dropped = true;
+    }
   }
-  return body;
+  return dropped ? JSON.stringify(parsed2) : body;
 }
 function computeFault(fault, input2) {
   const base = {
@@ -6923,7 +7337,7 @@ function originOf2(url) {
     return null;
   }
 }
-var sleep = (ms) => new Promise((resolve11) => setTimeout(resolve11, Math.max(0, ms)));
+var sleep = (ms) => new Promise((resolve12) => setTimeout(resolve12, Math.max(0, ms)));
 async function performRouteAction(route, action, startedAt) {
   switch (action.kind) {
     case "abort":
@@ -7214,13 +7628,23 @@ function recordFlakeResult(line) {
   }
 }
 
+// src/internal/support/playwright-version.ts
+function playwrightVersionAtLeast(version, minimum) {
+  const have = version ? /^(\d+)\.(\d+)/.exec(version) : null;
+  const want = /^(\d+)\.(\d+)/.exec(minimum);
+  if (!have || !want) return false;
+  const major = Number(have[1]);
+  const wantMajor = Number(want[1]);
+  return major > wantMajor || major === wantMajor && Number(have[2]) >= Number(want[2]);
+}
+
 // src/public/config-wrapper.ts
 var PIWI_MODULE = "@piwitests/reporter";
 var CAPTURE_DEFAULTS = {
   screenshot: "only-on-failure",
   trace: "retain-on-failure"
 };
-var TRACE_SNAPSHOTS_MIN = { major: 1, minor: 63 };
+var TRACE_SNAPSHOTS_MIN = "1.63";
 function installedPlaywrightVersion() {
   try {
     const nodeRequire = require;
@@ -7230,18 +7654,11 @@ function installedPlaywrightVersion() {
   }
 }
 var readPlaywrightVersion = installedPlaywrightVersion;
-function supportsTraceSnapshots(version) {
-  const match = version ? /^(\d+)\.(\d+)/.exec(version) : null;
-  if (!match) return false;
-  const major = Number(match[1]);
-  const minor = Number(match[2]);
-  return major > TRACE_SNAPSHOTS_MIN.major || major === TRACE_SNAPSHOTS_MIN.major && minor >= TRACE_SNAPSHOTS_MIN.minor;
-}
 function applyCaptureDefaults(use, piwiOptions) {
   delete process.env[PIWI_DEFAULTED_CAPTURE_ENV];
   const enabled = piwiOptions?.defaultCapture ?? readBool(process.env[PIWI_ENV_KEYS.defaultCapture]) ?? true;
   if (!enabled) return use;
-  const ariaSnapshots = supportsTraceSnapshots(readPlaywrightVersion());
+  const ariaSnapshots = playwrightVersionAtLeast(readPlaywrightVersion(), TRACE_SNAPSHOTS_MIN);
   const traceValue = ariaSnapshots ? { mode: CAPTURE_DEFAULTS.trace, snapshots: { dom: true, aria: true } } : CAPTURE_DEFAULTS.trace;
   const defaults = [
     { key: "screenshot", value: CAPTURE_DEFAULTS.screenshot, display: `screenshot: '${CAPTURE_DEFAULTS.screenshot}'` },
@@ -7308,79 +7725,6 @@ function wrapConfig(config, piwiOptions) {
   };
 }
 
-// ../core/src/status-classify.ts
-function mergeAnnotations(test, result) {
-  const out = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const list of [test.annotations, result.annotations]) {
-    for (const a of list ?? []) {
-      const key = `${a.type}\0${a.description ?? ""}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      out.push(a.description === void 0 ? { type: a.type } : { type: a.type, description: a.description });
-    }
-  }
-  return out;
-}
-function expectsFailure(annotations) {
-  if (annotations.some((a) => a.type === "skip" || a.type === "fixme")) return false;
-  return annotations.some((a) => a.type === "fail");
-}
-var EXPECTED_FAILURE_PASSED_MESSAGE = "Expected to fail, but passed.";
-function expectedFailureError(rawStatus, annotations) {
-  return rawStatus === "passed" && expectsFailure(annotations) ? EXPECTED_FAILURE_PASSED_MESSAGE : null;
-}
-function classifyStatus(rawStatus, annotations) {
-  if (rawStatus === "skipped") {
-    const intentional = annotations.some((a) => a.type === "skip" || a.type === "fixme");
-    return intentional ? "skipped" : "didnotrun";
-  }
-  if (expectsFailure(annotations)) {
-    if (rawStatus === "failed") return "passed";
-    if (rawStatus === "passed") return "failed";
-  }
-  return rawStatus;
-}
-function resolveUnrunReason(runStatus, opts) {
-  if (runStatus === "timedout") return "global-timeout";
-  if (opts.maxFailures > 0 && opts.failures >= opts.maxFailures) return "max-failures";
-  return "interrupted";
-}
-function fileOf(location) {
-  return location.replace(/:\d+:\d+$/, "");
-}
-function suiteKey(suitePath) {
-  return (suitePath ?? []).join("");
-}
-function sharedPrefixDepth(a, b) {
-  let depth = 0;
-  while (depth < a.length && depth < b.length && a[depth] === b[depth]) depth++;
-  return depth;
-}
-function linkBlockedTests(cases) {
-  const blockers = cases.filter((c) => c.status === "failed" || c.status === "timedOut" || c.status === "timedout");
-  if (blockers.length === 0) return;
-  for (const c of cases) {
-    if (c.didNotRunReason !== "previous-failure") continue;
-    const file = fileOf(c.location);
-    const inFile = blockers.filter((b) => fileOf(b.location) === file);
-    if (inFile.length === 0) continue;
-    const key = suiteKey(c.suitePath);
-    let blocker = inFile.find((b) => suiteKey(b.suitePath) === key);
-    if (!blocker) {
-      let bestDepth = 0;
-      for (const b of inFile) {
-        const depth = sharedPrefixDepth(c.suitePath ?? [], b.suitePath ?? []);
-        if (depth > bestDepth) {
-          bestDepth = depth;
-          blocker = b;
-        }
-      }
-    }
-    if (blocker) c.blockedBy = blocker.location;
-  }
-}
-
 // ../core/src/test-meta.ts
 var PIWI_ANNOTATION_PREFIX = "piwi:";
 var TEST_PRIORITIES = ["critical", "high", "medium", "low"];
@@ -7656,10 +8000,17 @@ function joinErrorMessages(errors) {
     const dedupeKey = msg.trim().slice(0, 200);
     if (seen.has(dedupeKey)) continue;
     seen.add(dedupeKey);
-    parts.push(msg);
+    parts.push(hideSecretsInError(msg));
   }
   return parts.join("\n---\n") || null;
 }
+function locatedError(errors) {
+  for (const error of errors ?? []) {
+    const file = error?.location?.file;
+    if (error && typeof file === "string" && file.length > 0) return error;
+  }
+  return void 0;
+}
 function appendErrorLocation(text2, location) {
   if (!location?.file || /\n[ \t]+at\s/.test(text2)) return text2;
   return `${text2}
@@ -7670,7 +8021,7 @@ function appendErrorLocation(text2, location) {
 function buildErrorText(result, base = process.cwd()) {
   const text2 = joinErrorMessages(result.errors);
   if (!text2) return null;
-  const loc = result.error?.location;
+  const loc = locatedError([result.error, ...result.errors ?? []])?.location;
   if (!loc?.file) return text2;
   return appendErrorLocation(text2, { file: relativeTestPath(loc.file, base), line: loc.line, column: loc.column });
 }
@@ -7802,8 +8153,8 @@ function ciBuildUrlFromMetadata(metadata) {
 
 // src/internal/submit/run-submitter.ts
 var MAX_TIMER_DELAY_MS = 2 ** 31 - 1;
-function markSubmitFallback(run, path36, reason) {
-  run.metadata.ingestHealth = { submitFallback: { path: path36, reason } };
+function markSubmitFallback(run, path37, reason) {
+  run.metadata.ingestHealth = { submitFallback: { path: path37, reason } };
 }
 var RunSubmitter = class {
   /**
@@ -7888,7 +8239,7 @@ var RunSubmitter = class {
     if (sm?.enabled && sm?.runId != null) {
       if (sm.lostResults) fallbackReason = "results-lost";
       else {
-        outcome = await this.tryFinishStreaming(run, overallStatus, duration, auth);
+        outcome = await this.tryFinishStreaming(run, overallStatus, duration, auth, counts.flakyTests);
         if (!outcome.done) fallbackReason = "finish-failed";
       }
     }
@@ -7958,15 +8309,16 @@ var RunSubmitter = class {
       deliveryKey: this.deliveryKey
     };
   }
-  async tryFinishStreaming(run, overallStatus, duration, auth) {
+  async tryFinishStreaming(run, overallStatus, duration, auth, flakyTests) {
     const sm = this.streamManager;
     try {
-      const flakyTests = run.testCases.filter((tc) => tc.status === "passed" && (tc.retries || 0) > 0).length;
       const durations = run.testCases.filter((tc) => tc.duration != null).map((tc) => tc.duration);
       await sm.uploadRemaining(run.testCases);
       const finishBody = {
         streamToken: sm.token,
         status: overallStatus,
+        // With `duration`, the span the run of a shard covers in its sharded run.
+        startTime: run.startTime ?? void 0,
         duration,
         totalTests: run.totalTests,
         passedTests: run.passedTests,
@@ -7992,7 +8344,7 @@ var RunSubmitter = class {
         finishBody.shardTotal = run.shardInfo.total;
       }
       await this.httpClient.postJSON(`/api/test-runs/${sm.runId}/finish`, finishBody, auth);
-      this.logger.info(`Successfully finalized streaming run #${sm.runId}`);
+      this.logger.debug(`Successfully finalized streaming run #${sm.runId}`);
       this.dropLocalCopies();
       if (this.hasReports(run)) {
         try {
@@ -8022,8 +8374,7 @@ var RunSubmitter = class {
       return { done: true, output: this.buildOutput(response?.runId, response?.projectId, run, overallStatus) };
     } catch (error) {
       if (error instanceof HttpError && error.status === 401 && !auth) return this.stopForMissingAuth(run, payload);
-      this.logger.warn(`Failed to upload with files: ${errorMessage(error)}`);
-      this.logger.info("Falling back to JSON upload...");
+      this.logger.warn(`Could not upload the run's files (${errorMessage(error)}): sending its results alone.`);
       return { done: false, output: null };
     }
   }
@@ -9016,7 +9367,7 @@ function parseWindowsProcesses(text2) {
 }
 function roleOf(comm, cmdline) {
   const command = `${comm} ${cmdline}`;
-  if (/workerProcessEntry/.test(cmdline)) return "worker";
+  if (/workerProcessEntry|[\\/]playwright[\\/]lib[\\/]common[\\/]process\.js/.test(cmdline)) return "worker";
   if (/loaderProcessEntry/.test(cmdline)) return "runner";
   if (/(^|[\s/])ffmpeg/.test(command)) return "ffmpeg";
   const type = /--type=([\w-]+)/.exec(cmdline)?.[1];
@@ -9469,11 +9820,21 @@ function runnableOf(info) {
 function fallbackRunnable(window) {
   return { phase: window ? "test" : "worker", fixture: null };
 }
+var GLOBALS_FILES = [
+  ["lib", "globals.js"],
+  ["lib", "common", "globals.js"]
+];
+function playwrightGlobalsFile() {
+  const packageJson = resolvePlaywrightPackageJson();
+  if (!packageJson) return null;
+  const root = path22.dirname(packageJson);
+  return GLOBALS_FILES.map((parts) => path22.join(root, ...parts)).find((file) => fs21.existsSync(file)) ?? null;
+}
 function playwrightTestInfoSource() {
   try {
-    const packageJson = resolvePlaywrightPackageJson();
-    if (!packageJson) return () => null;
-    const globals = (0, import_node_module2.createRequire)(packageJson)(path22.join(path22.dirname(packageJson), "lib", "globals.js"));
+    const file = playwrightGlobalsFile();
+    if (!file) return () => null;
+    const globals = (0, import_node_module2.createRequire)(file)(file);
     const read = globals.currentTestInfo;
     if (typeof read !== "function") return () => null;
     return () => {
@@ -9502,7 +9863,7 @@ function countHandles(types = TRACKED_HANDLE_TYPES) {
 async function settledHandles(start, types = TRACKED_HANDLE_TYPES) {
   const end = countHandles(types);
   if (!Object.entries(end).some(([type, n]) => n > (start[type] ?? 0))) return end;
-  await new Promise((resolve11) => setTimeout(resolve11, 0));
+  await new Promise((resolve12) => setTimeout(resolve12, 0));
   return countHandles(types);
 }
 function deepUserSite() {
@@ -9530,8 +9891,8 @@ function settleWithin(promise, ms) {
   let timer;
   return Promise.race([
     promise.catch(() => void 0),
-    new Promise((resolve11) => {
-      timer = setTimeout(resolve11, ms);
+    new Promise((resolve12) => {
+      timer = setTimeout(resolve12, ms);
     })
   ]).finally(() => clearTimeout(timer));
 }
@@ -9651,10 +10012,10 @@ var ResourceLedger = class {
   trackHandle(object, entry) {
     const info = this.testInfoSource();
     const { phase, fixture } = info ? runnableOf(info) : fallbackRunnable(this.window);
-    const tracked = { ...entry, phase, fixture, test: testRef2(info) ?? this.window };
-    this.handles.add(tracked);
-    this.byHandle.set(object, tracked);
-    return tracked;
+    const tracked2 = { ...entry, phase, fixture, test: testRef2(info) ?? this.window };
+    this.handles.add(tracked2);
+    this.byHandle.set(object, tracked2);
+    return tracked2;
   }
   onServer(server, site) {
     const known = this.byHandle.get(server);
@@ -9697,7 +10058,7 @@ var ResourceLedger = class {
     const own = () => [...this.handles].filter(
       (entry) => entry.test?.id === testId && !entry.fixture?.worker && (entry.phase === "test" || entry.phase === "beforeEach" || entry.phase === "afterEach")
     );
-    if (own().some((entry) => entry.pending?.())) await new Promise((resolve11) => setTimeout(resolve11, 0));
+    if (own().some((entry) => entry.pending?.())) await new Promise((resolve12) => setTimeout(resolve12, 0));
     return own().filter((entry) => entry.running()).map((entry) => ({ type: entry.type, site: entry.site, ...entry.command ? { command: entry.command } : {} }));
   }
   /** Mark a page used: a locator was built on it. */
@@ -10174,10 +10535,10 @@ function buildResourceReport(input2) {
   const all = [];
   for (const censuses of byWorker.values()) {
     censuses.sort((a, b) => a.at - b.at);
-    const tracked = /* @__PURE__ */ new Map();
+    const tracked2 = /* @__PURE__ */ new Map();
     for (const census of censuses) {
       for (const birth of census.born) {
-        tracked.set(birth.id, {
+        tracked2.set(birth.id, {
           worker: census.worker,
           birth,
           bornCensus: census,
@@ -10189,13 +10550,13 @@ function buildResourceReport(input2) {
         });
       }
       for (const close of census.closed) {
-        const entry = tracked.get(close.id);
+        const entry = tracked2.get(close.id);
         if (!entry) continue;
         entry.close = close;
         if (close.used !== void 0) entry.used = close.used;
       }
       for (const open of census.open) {
-        const entry = tracked.get(open.id);
+        const entry = tracked2.get(open.id);
         if (!entry) continue;
         entry.lastOpenAt = census.at;
         if (open.used !== void 0) entry.used = open.used;
@@ -10213,7 +10574,7 @@ function buildResourceReport(input2) {
     }
     const testCensuses = censuses.filter((census) => census.test !== null);
     const workerEnded = censuses.some((census) => census.test === null);
-    for (const entry of tracked.values()) {
+    for (const entry of tracked2.values()) {
       all.push(entry);
       if (entry.birth.kind === "page" && entry.used === false && !entry.bornCensus.test?.failed) idle.push(entry);
       const verdict = leakVerdict(entry, testCensuses, workerEnded);
@@ -10282,13 +10643,13 @@ function siteOf(birth) {
 var keyOf = (worker, id) => `${worker}:${id}`;
 function groupLeaks(leaked, all) {
   const leaks = new Map(leaked.map((leak) => [keyOf(leak.tracked.worker, leak.tracked.birth.id), leak]));
-  const tracked = new Map(all.map((entry) => [keyOf(entry.worker, entry.birth.id), entry]));
+  const tracked2 = new Map(all.map((entry) => [keyOf(entry.worker, entry.birth.id), entry]));
   const groups = /* @__PURE__ */ new Map();
   const groupKey = (leak) => `${leak.scope}|${leak.tracked.birth.kind}|${whereOf(leak.tracked.birth)}`;
   for (const leak of leaked) {
     const { birth } = leak.tracked;
     if (birth.kind === "context" && birth.implicit) continue;
-    if (foldTarget(leak.tracked, leaks, tracked)) continue;
+    if (foldTarget(leak.tracked, leaks, tracked2)) continue;
     const key = groupKey(leak);
     const group = groups.get(key) ?? {
       verdict: "leaked",
@@ -10314,7 +10675,7 @@ function groupLeaks(leaked, all) {
   }
   for (const leak of leaked) {
     if (leak.tracked.birth.kind !== "page") continue;
-    const root = foldTarget(leak.tracked, leaks, tracked);
+    const root = foldTarget(leak.tracked, leaks, tracked2);
     const group = root ? groups.get(groupKey(root)) : void 0;
     if (!group) continue;
     group.pages = (group.pages ?? 0) + 1;
@@ -10325,11 +10686,11 @@ function groupLeaks(leaked, all) {
 function addCpu(group, cpuMs) {
   if (cpuMs > 0) group.afterTestCpuMs = (group.afterTestCpuMs ?? 0) + cpuMs;
 }
-function foldTarget(entry, leaks, tracked) {
+function foldTarget(entry, leaks, tracked2) {
   let parentId = entry.birth.parent;
   while (parentId !== null) {
     const key = keyOf(entry.worker, parentId);
-    const parent = tracked.get(key);
+    const parent = tracked2.get(key);
     if (!parent) return null;
     if (!(parent.birth.kind === "context" && parent.birth.implicit)) return leaks.get(key) ?? null;
     parentId = parent.birth.parent;
@@ -10667,17 +11028,17 @@ function nodeCpuTicks() {
   return { busy, idle, iowait: 0, steal: 0, total: busy + idle };
 }
 function defaultPs() {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, 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) : resolve11(stdout)
+      (error, stdout) => error ? reject(error) : resolve12(stdout)
     );
   });
 }
 function defaultWindowsQuery() {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     (0, import_node_child_process2.execFile)(
       "powershell.exe",
       [
@@ -10687,7 +11048,7 @@ 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) : resolve11(stdout)
+      (error, stdout) => error ? reject(error) : resolve12(stdout)
     );
   });
 }
@@ -11452,7 +11813,7 @@ function resourceTimeline(samples, censuses) {
   let startedAt = hasSamples ? samples.startedAt : Infinity;
   for (const { events } of workers) startedAt = Math.min(startedAt, events[0][0]);
   const shift = hasSamples ? samples.startedAt - startedAt : 0;
-  const relative10 = (points, by) => points.map(([at, value]) => [Math.round(at + by), value]);
+  const relative11 = (points, by) => points.map(([at, value]) => [Math.round(at + by), value]);
   const trees = hasSamples ? workerTreesByIndex(samples, censuses) : [];
   const perWorker = Math.max(
     60,
@@ -11460,17 +11821,17 @@ function resourceTimeline(samples, censuses) {
   );
   return {
     startedAt,
-    cpuPct: hasSamples ? downsamplePoints(relative10(samples.cpuPct, shift), TIMELINE_SERIES_CAP, "mean") : [],
-    memoryBytes: hasSamples ? downsamplePoints(relative10(samples.memoryBytes, shift), TIMELINE_SERIES_CAP, "max") : [],
+    cpuPct: hasSamples ? downsamplePoints(relative11(samples.cpuPct, shift), TIMELINE_SERIES_CAP, "mean") : [],
+    memoryBytes: hasSamples ? downsamplePoints(relative11(samples.memoryBytes, shift), TIMELINE_SERIES_CAP, "max") : [],
     pages: workers.map(({ worker, events }) => {
-      const points = relative10(events, -startedAt);
+      const points = relative11(events, -startedAt);
       const last = points.pop();
       return { worker, points: [...downsamplePoints(points, TIMELINE_WORKER_POINTS_CAP - 1, "max"), last] };
     }),
     workers: trees.map((tree) => ({
       worker: tree.worker,
-      cpuCores: downsamplePoints(relative10(tree.cpuCores, shift), perWorker, "mean"),
-      memoryBytes: downsamplePoints(relative10(tree.memoryBytes, shift), perWorker, "max")
+      cpuCores: downsamplePoints(relative11(tree.cpuCores, shift), perWorker, "mean"),
+      memoryBytes: downsamplePoints(relative11(tree.memoryBytes, shift), perWorker, "max")
     }))
   };
 }
@@ -11550,7 +11911,7 @@ var LiveResources = class {
     const cursors = this.reset ? /* @__PURE__ */ new Map() : this.sent;
     const sent2 = new Map(cursors);
     let fresh = false;
-    const take = (key, points, cap, merge) => {
+    const take2 = (key, points, cap, merge) => {
       const out = since(points, cursors.get(key), cap, merge);
       const last = points[points.length - 1];
       if (out.length > 0 && last) {
@@ -11561,11 +11922,11 @@ var LiveResources = class {
     };
     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");
+      timeline.cpuPct = take2("cpu", samples.cpuPct, TIMELINE_SERIES_CAP, "mean");
+      timeline.memoryBytes = take2("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");
+        const cpuCores = take2(`cores:${tree.worker}`, tree.cpuCores, TIMELINE_WORKER_POINTS_CAP, "mean");
+        const memoryBytes = take2(`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 });
         }
@@ -12175,7 +12536,7 @@ function browserFunctionsInWorker() {
 function browserFunctionCoverage(files) {
   return sanitizeCoverage({
     v: 1,
-    files: [...files].map(([path36, functions]) => ({ path: path36, runtime: "browser", functions }))
+    files: [...files].map(([path37, functions]) => ({ path: path37, runtime: "browser", functions }))
   });
 }
 function newKnownFunctions(known, sent2) {
@@ -12188,19 +12549,19 @@ function newKnownFunctions(known, sent2) {
     budget = MAX_COVERAGE_RANGES;
   };
   for (const [raw, ranges] of known) {
-    const path36 = normalizeCoveragePath(raw);
-    if (path36 === null) continue;
-    let named = sent2.get(path36);
+    const path37 = normalizeCoveragePath(raw);
+    if (path37 === null) continue;
+    let named = sent2.get(path37);
     let fresh = normalizeFunctionRanges(ranges).filter((range) => !named?.has(`${range[0]}:${range[1]}`));
     if (fresh.length === 0) continue;
-    if (!named) sent2.set(path36, named = /* @__PURE__ */ new Set());
+    if (!named) sent2.set(path37, 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: path36, allFunctions: part });
+      files.push({ path: path37, allFunctions: part });
     }
   }
   close();
@@ -12563,13 +12924,13 @@ function repositoryRoot(from) {
 }
 function codeReachRoots(configDir, configured) {
   const repoRoot = repositoryRoot(configDir);
-  const resolve11 = (dirs) => (Array.isArray(dirs) ? dirs : dirs ? [dirs] : []).filter(Boolean).map((r) => path25.resolve(configDir, r));
-  const global = Array.isArray(configured) ? resolve11(configured) : resolve11(configured?.["*"]);
+  const resolve12 = (dirs) => (Array.isArray(dirs) ? dirs : dirs ? [dirs] : []).filter(Boolean).map((r) => path25.resolve(configDir, r));
+  const global = Array.isArray(configured) ? resolve12(configured) : resolve12(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 = resolve11(dirs);
+      const resolved = resolve12(dirs);
       if (origin && resolved.length) byOrigin.set(origin, resolved);
     }
   }
@@ -12601,9 +12962,9 @@ function resolveSourcePath(source, roots) {
   const normalized = normalizeSourcePath(source);
   if (!normalized || /(?:^|\/)node_modules\//.test(normalized)) return null;
   if (path25.isAbsolute(normalized) && isFile(normalized)) return path25.resolve(normalized);
-  const relative10 = normalized.replace(/^\/+/, "");
+  const relative11 = normalized.replace(/^\/+/, "");
   for (const root of roots) {
-    const candidate = path25.resolve(root, relative10);
+    const candidate = path25.resolve(root, relative11);
     if (isFile(candidate)) return candidate;
   }
   return null;
@@ -12692,10 +13053,10 @@ async function resolveFunctions(entries, roots, fetchMap, pageUrl, withKnown) {
   const files = /* @__PURE__ */ new Map();
   const known = /* @__PURE__ */ new Map();
   const addTo = (into, file, functions) => {
-    const path36 = relativeToRepo(file, roots.repoRoot);
-    const listed = into.get(path36);
+    const path37 = relativeToRepo(file, roots.repoRoot);
+    const listed = into.get(path37);
     if (listed) listed.push(...functions);
-    else into.set(path36, [...functions]);
+    else into.set(path37, [...functions]);
   };
   const add2 = (file, functions) => addTo(files, file, functions);
   const bases = viteBases(entries);
@@ -12850,8 +13211,8 @@ function onScriptParsed(page, capture, event) {
 var READ_WAIT_MS = 5e3;
 function readCoverage(page, cdp) {
   let timer;
-  const late = new Promise((resolve11) => {
-    timer = setTimeout(() => resolve11([]), READ_WAIT_MS);
+  const late = new Promise((resolve12) => {
+    timer = setTimeout(() => resolve12([]), READ_WAIT_MS);
   });
   const taken = internalCall(page, () => cdp.send("Profiler.takePreciseCoverage")).then(
     (answer) => answer.result,
@@ -13047,14 +13408,14 @@ function namesLines(file) {
 }
 var GIT_BATCH = 500;
 function gitHashObjects(root, paths) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     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);
-        resolve11(ids.length === paths.length ? ids : null);
+        resolve12(ids.length === paths.length ? ids : null);
       }
     );
     child.stdin?.on("error", () => {
@@ -13352,7 +13713,7 @@ var CoverageCollection = class {
     }
     let timer;
     let finish;
-    const done = new Promise((resolve11) => {
+    const done = new Promise((resolve12) => {
       let settled = false;
       finish = (server) => {
         if (settled) return;
@@ -13361,7 +13722,7 @@ var CoverageCollection = class {
         this.pending.delete(entry);
         void Promise.resolve(browser).then((side) => {
           this.assign(testCase, composeTestCoverage(server, side.files, this.options.settings, side.css));
-          resolve11();
+          resolve12();
         });
       };
     });
@@ -13393,8 +13754,8 @@ var CoverageCollection = class {
       let timer;
       await Promise.race([
         Promise.all(waiting),
-        new Promise((resolve11) => {
-          timer = setTimeout(resolve11, boundMs);
+        new Promise((resolve12) => {
+          timer = setTimeout(resolve12, boundMs);
         })
       ]);
       clearTimeout(timer);
@@ -13457,6 +13818,15 @@ function testLocation(test, base) {
 function testFile(test, base) {
   return relativeTestPath(test.location.file, base);
 }
+function uncapturedCalls(steps) {
+  let calls = false;
+  const captured = (list, inHook) => list.some((step) => {
+    if (step.category === "pw:api" && !inHook) calls = true;
+    return step.category === "fixture" && /\bpiwiCapture\b/.test(step.title) || captured(step.steps, inHook || step.category === "hook");
+  });
+  return !captured(steps, false) && calls;
+}
+var MAX_UNCAPTURED_NAMED = 5;
 var PiwiDashboardReporter = class _PiwiDashboardReporter {
   constructor(rawOptions = {}) {
     this.testCases = [];
@@ -13473,6 +13843,10 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
     this.plannedTests = [];
     /** Ids of tests that actually reported via `onTestEnd`, to find the ones that never ran. */
     this.reportedTestIds = /* @__PURE__ */ new Set();
+    /** The spec files said to have run without the capture fixtures in a run that can stop (`noteUncaptured`). */
+    this.uncapturedSpecs = /* @__PURE__ */ new Set();
+    /** The live steps begun and not ended, by step, sent again when someone opens the run (`onWatched`). */
+    this.openSteps = /* @__PURE__ */ new Map();
     /** Per-test attempt history, keyed by `test.id`; snapshotted onto every attempt's payload. */
     this.attemptsByTest = /* @__PURE__ */ new Map();
     /** The folder test files are named relative to: the Playwright config's, set in `onBegin`. */
@@ -13573,13 +13947,14 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
       this.logger.debug("List mode (--list) detected \u2014 no run registered or report uploaded.");
       return;
     }
-    const followed = followEditor([configDirFromConfig(config), process.cwd()], {
+    normalizeBoolEnv(process.env);
+    const followed2 = followEditor([configDirFromConfig(config), process.cwd()], {
       env: process.env,
       argv: process.argv,
       terminal: !!process.stdout.isTTY || !!process.stderr.isTTY
     });
-    if (followed) {
-      const { editor } = followed;
+    if (followed2) {
+      const { editor } = followed2;
       this.logger.info(
         `Following this run in ${editor.client ?? "the editor"} (pid ${editor.pid}), whose breakpoints stop it: ${PIWI_EDITOR_ENV}=off runs it alone.`
       );
@@ -13622,11 +13997,13 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
     const rawConfig = config;
     const grepRe = rawConfig.grep instanceof RegExp ? rawConfig.grep : void 0;
     const grepInvertRe = rawConfig.grepInvert instanceof RegExp ? rawConfig.grepInvert : void 0;
-    const grep = grepRe && grepRe.source !== ".*" ? grepRe.source : void 0;
-    const grepInvert = grepInvertRe?.source;
+    const cliGrep = detectCliGrep();
+    const grep = (grepRe && grepRe.source !== ".*" ? grepRe.source : void 0) ?? cliGrep.grep;
+    const grepInvert = grepInvertRe?.source ?? cliGrep.grepInvert;
     const fileFilters = detectCliFileFilters();
+    const narrowed = detectCliNarrowingFlags().length > 0;
     const selection = readSelectionStamp();
-    if (grep || grepInvert || fileFilters.length > 0 || selection) {
+    if (grep || grepInvert || fileFilters.length > 0 || selection || narrowed) {
       this.isFullRun = false;
       this.filterDetails = {
         ...grep ? { grep } : {},
@@ -13634,7 +14011,7 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
         ...fileFilters.length > 0 ? { files: fileFilters } : {},
         ...selection ? { selection } : {}
       };
-      this.logger.info(
+      this.logger.debug(
         selection ? `Selection run detected (${selection.key})` : "Partial run detected (filter active)"
       );
     }
@@ -13697,6 +14074,12 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
       // the dashboard shows the real total from the first render.
       this.plannedTests.length
     );
+    if (this.streamManager) {
+      this.streamManager.onWatched = () => {
+        void this.liveResources?.tick();
+        for (const event of this.openSteps.values()) this.streamManager?.queueEvent(event);
+      };
+    }
     if (this.streamManager && this.options.captureResources !== false) {
       const live = new LiveResources(
         this.streamManager,
@@ -13709,7 +14092,6 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
         },
         this.logger
       );
-      this.streamManager.onWatched = () => void live.tick();
       live.start();
       this.liveResources = live;
     }
@@ -13718,18 +14100,16 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
    * Name the run's live view on the instance for the workers, which Playwright starts after this hook with this
    * environment: the key the instance gave the global setup, for a project that turned its live view on, for this run
    * alone. A CI run's workers stream with it at once; a run outside CI's hold it until a person shares the run (Share
-   * live), and such a run without a key names why instead, for the surfaces that would share it. Read before the
-   * stream starts, which takes the setup file.
+   * live), and such a run without a key names why instead, for the surfaces that would share it; a CI run without one
+   * says why in its log (`ciLiveViewNote`). Read before the stream starts, which takes the setup file.
    */
   shareLiveView() {
     const ci = detectCi(process.env);
     const setup = this.streamManager ? peekSetupInfo(this.options.projectName) : null;
     if (!setup?.liveViewKey) {
-      if (!ci) {
-        process.env[LIVE_VIEW_ENV] = formatLiveViewMissing(
-          setup?.liveViewLocal ? "local" : setup ? "off" : "unregistered"
-        );
-      }
+      const why = setup?.liveViewLocal ? "local" : setup ? "off" : "unregistered";
+      if (!ci) process.env[LIVE_VIEW_ENV] = formatLiveViewMissing(why);
+      else if (why !== "local") this.logger.info(ciLiveViewNote(this.streamManager ? why : "streaming-off"));
       return;
     }
     process.env[LIVE_VIEW_ENV] = formatLiveViewEnv(this.httpClient.baseUrl, setup.runId, setup.liveViewKey);
@@ -13817,6 +14197,33 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
     }
     return true;
   }
+  /**
+   * In a run that can stop (breakpoints, or a run channel to an editor or the desktop app), say of the first spec file
+   * whose test made Playwright calls without the capture fixtures, where the stops happen, that it never stops at a
+   * breakpoint nor at Pause, which nothing else says; the others are named in one line as the run ends
+   * (`noteOtherUncaptured`).
+   */
+  noteUncaptured(test, result) {
+    if (!process.env.PIWI_PAUSE_AT && !process.env[RUN_CHANNEL_ENV]) return;
+    if (!uncapturedCalls(result.steps)) return;
+    const file = testFile(test, this.testPathBase);
+    if (this.uncapturedSpecs.has(file)) return;
+    this.uncapturedSpecs.add(file);
+    if (this.uncapturedSpecs.size > 1) return;
+    this.logger.warn(
+      `${file} ran without Piwi's capture fixtures, so its tests never stop at a breakpoint or at Pause: import \`test\` from your fixtures file (the one that extends piwiFixtures) instead of '@playwright/test'.`
+    );
+  }
+  /** The spec files past the first that ran without the capture fixtures, in one line (`noteUncaptured`). */
+  noteOtherUncaptured() {
+    const others = [...this.uncapturedSpecs].slice(1);
+    if (!others.length) return;
+    const named = others.slice(0, MAX_UNCAPTURED_NAMED).join(", ");
+    const more = others.length > MAX_UNCAPTURED_NAMED ? `, and ${others.length - MAX_UNCAPTURED_NAMED} more` : "";
+    this.logger.warn(
+      `${others.length} more spec file${others.length === 1 ? "" : "s"} ran without Piwi's capture fixtures, so their tests never stop at a breakpoint or at Pause either: ${named}${more}.`
+    );
+  }
   /** Playwright reporter hook: called when a step (including hook/fixture) begins */
   onStepBegin(test, _result, step) {
     if (!this.enabled || !this.streamManager) return;
@@ -13824,7 +14231,7 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
     const cat = step.category;
     const event = {
       type: "step-begin",
-      title: step.title,
+      title: hideTypedStepTitle(step.title, cat),
       subtitle: typeof step.subtitle === "string" && step.subtitle.length > 0 ? step.subtitle : null,
       location: step.location ? `${step.location.file}:${step.location.line}:${step.location.column}` : "unknown",
       stepCategory: cat,
@@ -13832,18 +14239,20 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
       workerIndex: workerIndexOf(_result),
       startedAt: step.startTime instanceof Date ? step.startTime.getTime() : null
     };
+    this.openSteps.set(step, event);
     this.streamManager?.queueBeginEvent(event);
   }
   /** Playwright reporter hook: called when a step (including hook/fixture) ends */
   onStepEnd(test, _result, step) {
     if (!this.enabled || !this.streamManager) return;
     if (!_PiwiDashboardReporter.isLiveStep(step)) return;
+    this.openSteps.delete(step);
     const cat = step.category;
     const workerIndex = workerIndexOf(_result);
     const startedAt = step.startTime instanceof Date ? step.startTime.getTime() : null;
     const event = {
       type: "step-end",
-      title: step.title,
+      title: hideTypedStepTitle(step.title, cat),
       subtitle: typeof step.subtitle === "string" && step.subtitle.length > 0 ? step.subtitle : null,
       location: step.location ? `${step.location.file}:${step.location.line}:${step.location.column}` : "unknown",
       status: step.error ? "failed" : "passed",
@@ -13869,7 +14278,10 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
   /** Playwright reporter hook: called when an individual test finishes */
   onTestEnd(test, result) {
     this.totalTests++;
+    const worker = workerIndexOf(result);
+    for (const [step, event] of this.openSteps) if (event.workerIndex === worker) this.openSteps.delete(step);
     this.reportedTestIds.add(test.id);
+    this.noteUncaptured(test, result);
     const { suitePath, suiteConfig } = this.metadataCollector.getSuiteInfo(test);
     const annotations = mergeAnnotations(test, result);
     const status = classifyStatus(result.status, annotations);
@@ -13918,10 +14330,12 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
       expectedStatus: test.expectedStatus ?? null
     };
     if (result.status === "failed" || result.status === "timedOut") {
-      const failingLine = extractFailingLine(testCase.error, test.location.file, test.location.line);
+      const failingLine = extractFailingLine(testCase.error, test.location.file, test.location.line, this.testPathBase);
       const snippet = readSourceSnippet(test.location.file, test.location.line, 30, failingLine);
       if (snippet) testCase.testSource = snippet;
-      const frames = collectSourceFrames(testCase.error, test.location.file, test.location.line);
+      const frames = collectSourceFrames(testCase.error, test.location.file, test.location.line, {
+        projectRoot: this.testPathBase
+      });
       if (frames.length) testCase.testSourceFrames = frames;
     }
     if (this.options.collectPerformanceMetrics && result.steps?.length > 0) {
@@ -14136,6 +14550,7 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
    * ID and `externalId.onDuplicate` is `'fail'`.
    */
   async onEnd(result) {
+    this.noteOtherUncaptured();
     const duplicates = this.externalIds?.duplicates.length ?? 0;
     const failsOnDuplicates = duplicates > 0 && resolveOnDuplicate(this.options.externalId?.onDuplicate).onDuplicate === "fail";
     const overridden = failsOnDuplicates && result?.status === "passed";
@@ -14278,7 +14693,7 @@ async function resolveSelection(options = {}) {
 }
 
 // src/internal/capture/capture-fixtures.ts
-var path32 = __toESM(require("path"));
+var path33 = __toESM(require("path"));
 var import_node_zlib2 = require("zlib");
 
 // ../picker-dom/src/probe.ts
@@ -14737,8 +15152,8 @@ function installPickerOverlay(arg) {
     return root && root !== doc && root.host ? root.host : null;
   };
   const targetOf = (e) => {
-    const path36 = typeof e.composedPath === "function" ? e.composedPath() : null;
-    const first = path36 && path36.length ? path36[0] : null;
+    const path37 = typeof e.composedPath === "function" ? e.composedPath() : null;
+    const first = path37 && path37.length ? path37[0] : null;
     return first && first.nodeType === 1 ? first : e.target;
   };
   const buildChain = (raw) => {
@@ -15043,14 +15458,14 @@ function showAnchorPicker(arg) {
   } catch {
     shadowRoots.length = 0;
   }
-  const within3 = (node2, scope) => {
+  const within4 = (node2, scope) => {
     if (scope === doc) return true;
     for (let n = node2; n; n = parentOf(n)) if (n === scope) return true;
     return false;
   };
   const queryAll = (scope, sel) => {
     const found = Array.from(scope.querySelectorAll(sel));
-    for (const sr of shadowRoots) if (within3(sr.host, scope)) found.push(...Array.from(sr.querySelectorAll(sel)));
+    for (const sr of shadowRoots) if (within4(sr.host, scope)) found.push(...Array.from(sr.querySelectorAll(sel)));
     return found;
   };
   const leafCountable = !!leafTestId || roleOf2(el) === leafRole;
@@ -15439,8 +15854,22 @@ function showPauseBar(arg) {
     cleanup();
     g.__piwiPauseState = choice;
   };
+  const pageTakesEscape = (e) => {
+    const path37 = typeof e.composedPath === "function" ? e.composedPath() : [e.target];
+    const el = path37.find((node) => node && node.nodeType === 1);
+    if (el && !bar.contains(el) && typeof el.closest === "function") {
+      if (el.closest('dialog[open],[role="dialog"],[role="alertdialog"],[role="listbox"],[role="menu"]')) return true;
+      const popup = '[aria-expanded="true"]:is([role="combobox"],[aria-haspopup]:not([aria-haspopup="false"]))';
+      if (el.matches(popup)) return true;
+    }
+    try {
+      return !!doc.querySelector("dialog:modal");
+    } catch {
+      return false;
+    }
+  };
   const onKey = (e) => {
-    if (e.key !== "Escape") return;
+    if (e.key !== "Escape" || pageTakesEscape(e)) return;
     e.preventDefault();
     e.stopImmediatePropagation();
     done("resume");
@@ -15457,7 +15886,9 @@ function showPauseBar(arg) {
     ...arg.record ? [
       ["Record here", "record", "Record steps in this page: the editor writes them before this line", false]
     ] : [],
-    ...arg.failure ? [] : [["Finish", "finish", "Run on and pause no more in this test", false]],
+    ...arg.failure ? [] : [
+      ["Finish", "finish", "Run the test on without stopping at a breakpoint again in this attempt", false]
+    ],
     ...arg.end && !arg.failure ? [
       ["End the test", "end", "Skip the rest of this test: it is reported as skipped", false]
     ] : []
@@ -15493,6 +15924,102 @@ function takePauseState() {
   return typeof state === "string" ? state : null;
 }
 
+// ../picker-dom/src/overlay-stop.ts
+function showStopHighlight(elements, arg) {
+  const g = globalThis;
+  const doc = g.document;
+  const gone = g.__piwiStopHighlightsGone instanceof Set ? g.__piwiStopHighlightsGone : /* @__PURE__ */ new Set();
+  g.__piwiStopHighlightsGone = gone;
+  if (!doc || !doc.documentElement) return 0;
+  const drawn = doc.getElementById(`__piwi_stop_highlight_${arg.id}`);
+  const targets = gone.has(arg.id) ? [] : elements.slice(0, 500);
+  const shownIn = (layer2) => Array.from(layer2.children).filter((box) => box.dataset.box && box.style.display !== "none").length;
+  const raise = (layer2) => {
+    if (!layer2.hasAttribute("popover")) return;
+    try {
+      if (layer2.matches(":popover-open")) layer2.hidePopover();
+      layer2.showPopover();
+    } catch {
+      layer2.removeAttribute("popover");
+    }
+  };
+  const before = drawn?.__piwiTargets;
+  if (drawn && before && before.length === targets.length && before.every((el, i) => el === targets[i])) {
+    if (targets.length) raise(drawn);
+    drawn.__piwiPlace?.();
+    return shownIn(drawn);
+  }
+  drawn?.remove();
+  if (!targets.length) return 0;
+  const Z = 2147483600;
+  const MONO = "ui-monospace,SFMono-Regular,Menlo,Consolas,monospace";
+  const layer = doc.createElement("div");
+  layer.id = `__piwi_stop_highlight_${arg.id}`;
+  layer.setAttribute("data-piwi-stop-highlight", arg.kind);
+  layer.setAttribute("aria-hidden", "true");
+  layer.setAttribute("popover", "manual");
+  layer.style.cssText = `position:fixed;inset:auto;top:0;left:0;width:0;height:0;margin:0;padding:0;border:0;background:transparent;overflow:visible;pointer-events:none;z-index:${Z - 1};`;
+  layer.__piwiTargets = targets;
+  const look = arg.kind === "call" ? "border:2px solid #a855f7;background:rgba(168,85,247,.14);border-radius:4px;box-shadow:0 0 0 1px rgba(255,255,255,.9),0 0 0 3px rgba(59,7,100,.55);" : "border:2px dashed #a78bfa;background:rgba(167,139,250,.15);border-radius:3px;box-shadow:0 0 0 1px rgba(255,255,255,.8);";
+  const boxes = targets.map(() => {
+    const box = doc.createElement("div");
+    box.dataset.box = "1";
+    box.style.cssText = `position:fixed;display:none;box-sizing:border-box;pointer-events:none;${look}`;
+    layer.appendChild(box);
+    return box;
+  });
+  const label = doc.createElement("div");
+  label.style.cssText = `position:fixed;display:none;pointer-events:none;box-sizing:border-box;max-width:min(620px,92vw);background:#0b1120;color:#f9fafb;border:1px solid #7c3aed;border-radius:6px;padding:2px 7px;font:12px/1.45 ${MONO};white-space:nowrap;overflow:hidden;text-overflow:ellipsis;box-shadow:0 2px 10px rgba(0,0,0,.4);`;
+  label.textContent = arg.label;
+  layer.appendChild(label);
+  doc.documentElement.appendChild(layer);
+  raise(layer);
+  const place = () => {
+    let first = null;
+    targets.forEach((el, i) => {
+      const box = boxes[i];
+      const rect = el && el.isConnected && typeof el.getBoundingClientRect === "function" ? el.getBoundingClientRect() : null;
+      if (!rect || rect.width === 0 && rect.height === 0) {
+        box.style.display = "none";
+        return;
+      }
+      box.style.display = "block";
+      box.style.left = `${rect.left - 2}px`;
+      box.style.top = `${rect.top - 2}px`;
+      box.style.width = `${rect.width + 4}px`;
+      box.style.height = `${rect.height + 4}px`;
+      first ??= rect;
+    });
+    if (first && arg.label) {
+      label.style.display = "block";
+      const height = label.offsetHeight || 20;
+      const above = first.top - 2 - height - 4;
+      label.style.left = `${Math.max(4, first.left - 2)}px`;
+      label.style.top = `${above >= 4 ? above : first.bottom + 6}px`;
+    } else {
+      label.style.display = "none";
+    }
+  };
+  layer.__piwiPlace = place;
+  const follow = () => {
+    if (!layer.isConnected) return;
+    place();
+    g.requestAnimationFrame(follow);
+  };
+  follow();
+  return shownIn(layer);
+}
+function removeStopHighlight(id) {
+  const g = globalThis;
+  const gone = g.__piwiStopHighlightsGone instanceof Set ? g.__piwiStopHighlightsGone : /* @__PURE__ */ new Set();
+  g.__piwiStopHighlightsGone = gone;
+  gone.add(id);
+  const layer = g.document?.getElementById(`__piwi_stop_highlight_${id}`);
+  if (!layer) return false;
+  layer.remove();
+  return true;
+}
+
 // ../picker-dom/src/anchor-alternatives.ts
 var cssIdSelector = (id) => /^[A-Za-z_][A-Za-z0-9_-]*$/.test(id) ? `#${id}` : `[id="${id.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"]`;
 var ANCHOR_KIND_SCORES = { testid: 80, id: 74, labeledRole: 68, role: 62 };
@@ -15575,21 +16102,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(path36) {
-  return typeof path36 === "string" && path36.length <= ELEMENT_PATH_MAX_CHARS && ELEMENT_PATH_RE.test(path36);
+function isElementPath(path37) {
+  return typeof path37 === "string" && path37.length <= ELEMENT_PATH_MAX_CHARS && ELEMENT_PATH_RE.test(path37);
 }
 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: path36, label } = v;
-  if (!isElementPath(path36)) return null;
-  return { path: path36, label: typeof label === "string" ? label.slice(0, ELEMENT_LABEL_MAX_CHARS) : "" };
+  const { path: path37, label } = v;
+  if (!isElementPath(path37)) return null;
+  return { path: path37, label: typeof label === "string" ? label.slice(0, ELEMENT_LABEL_MAX_CHARS) : "" };
 }
 function textPoint(v) {
   if (!v || typeof v !== "object") return null;
-  const { path: path36, offset } = v;
+  const { path: path37, offset } = v;
   const at = offsetOf(offset);
-  return isElementPath(path36) && at !== null ? { path: path36, offset: at } : null;
+  return isElementPath(path37) && at !== null ? { path: path37, offset: at } : null;
 }
 function sanitizePageInteraction(raw) {
   if (!raw || typeof raw !== "object") return {};
@@ -15892,9 +16419,9 @@ 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 });
+    new Promise((resolve12) => {
+      if (ended.aborted) resolve12(void 0);
+      else ended.addEventListener("abort", () => resolve12(void 0), { once: true });
     })
   ]);
 }
@@ -16040,6 +16567,7 @@ function applyPickToSnapshots(snapshots, pick) {
 }
 
 // src/internal/capture/pause-at.ts
+var fs26 = __toESM(require("fs"));
 var path29 = __toESM(require("path"));
 
 // ../core/src/editor-send.ts
@@ -16067,9 +16595,12 @@ function isInsidePath(file) {
 }
 
 // src/internal/capture/pause-at.ts
+function lineKey(line, windows = process.platform === "win32") {
+  return windows ? line.toLowerCase() : line;
+}
 var PauseSet = class {
   constructor(lines) {
-    this.lines = lines;
+    this.lines = new Set([...lines].map((line) => lineKey(line)));
   }
   get size() {
     return this.lines.size;
@@ -16078,18 +16609,27 @@ var PauseSet = class {
   matches(callerLocation) {
     if (!callerLocation) return false;
     const col = callerLocation.lastIndexOf(":");
-    return col > 0 && this.lines.has(callerLocation.slice(0, col));
+    return col > 0 && this.lines.has(lineKey(callerLocation.slice(0, col)));
   }
 };
 var NO_BREAKPOINTS = new PauseSet(/* @__PURE__ */ new Set());
 function callSiteFile(file, cwd) {
   const slashed = file.replace(/\\/g, "/");
   const absolute = path29.isAbsolute(file) || path29.isAbsolute(slashed) || /^[A-Za-z]:\//.test(slashed);
-  let rel = absolute ? path29.relative(cwd, file) : path29.normalize(slashed);
+  const resolved = path29.resolve(cwd, absolute ? file : slashed);
+  const real = realPath(resolved);
+  let rel = real !== null && real !== resolved ? path29.relative(realPath(cwd) ?? cwd, real) : absolute ? path29.relative(cwd, file) : path29.normalize(slashed);
   rel = rel.split(path29.sep).join("/").replace(/\\/g, "/");
   if (rel.startsWith("./")) rel = rel.slice(2);
   return rel;
 }
+function realPath(file) {
+  try {
+    return fs26.realpathSync(file);
+  } catch {
+    return null;
+  }
+}
 function stopCallSite(location, cwd = process.cwd()) {
   if (!location.line) return null;
   return `${callSiteFile(location.file, cwd)}:${location.line}:${location.column ?? 0}`;
@@ -16150,10 +16690,20 @@ function callSitePlace(callSite) {
 function placeLine(place, cwd = process.cwd()) {
   return `${callSiteFile(place.file, cwd)}:${place.line}`;
 }
-function pauseGateFromTestInfo(testInfo) {
+function pauseGateFromTestInfo(testInfo, headless) {
   const use = testInfo.project?.use ?? {};
   const debug = testInfo._configInternal?.configCLIOverrides?.debug;
-  return { ci: process.env.CI, headless: use.headless, pwdebug: process.env.PWDEBUG, debug };
+  return {
+    ci: process.env.CI,
+    headless: headless !== void 0 ? headless : use.headless,
+    pwdebug: process.env.PWDEBUG,
+    debug
+  };
+}
+function mayPause(gate) {
+  if (process.env.PIWI_PAUSE_AT) return true;
+  if (gate.pwdebug && !["0", "false", "console"].includes(gate.pwdebug)) return true;
+  return typeof gate.debug === "string" && gate.debug.length > 0;
 }
 function pauseSkipReason(gate) {
   if (isCi(gate.ci)) return "running under CI \u2014 breakpoints pause local runs only";
@@ -16176,7 +16726,7 @@ function atBreakpoint(state, callSite) {
 }
 function atStop(state, callSite) {
   if (callSite) {
-    const reason = state.step ? "step" : state.pause ? "pause" : state.runTo !== null && callSiteLine(callSite) === state.runTo ? "run-to" : atBreakpoint(state, callSite) ? "breakpoint" : null;
+    const reason = state.step ? "step" : state.pause ? "pause" : state.runTo !== null && lineKey(callSiteLine(callSite)) === lineKey(state.runTo) ? "run-to" : atBreakpoint(state, callSite) ? "breakpoint" : null;
     if (reason) {
       stopShown(state);
       return { show: reason };
@@ -16207,6 +16757,9 @@ function goOn(state, answer) {
   return wantsStops(state) ? "next" : "resume";
 }
 var ENDED_REASON = "Ended from Piwi";
+function takesEndSignal(version) {
+  return playwrightVersionAtLeast(version, "1.62");
+}
 var OPTIONS_AT = {
   fill: 1,
   selectOption: 1,
@@ -16264,11 +16817,23 @@ function syncInspectorSwitch() {
   if (closed && process.env[NO_INSPECTOR_ENV] === void 0) {
     process.env[NO_INSPECTOR_ENV] = "1";
     inspectorSwitch.set = true;
+    clearSwitchAtStop();
   } else if (!closed && inspectorSwitch.set) {
-    if (process.env[NO_INSPECTOR_ENV] === "1") delete process.env[NO_INSPECTOR_ENV];
-    inspectorSwitch.set = false;
+    clearSwitch();
   }
 }
+function clearSwitch() {
+  if (inspectorSwitch.set && process.env[NO_INSPECTOR_ENV] === "1") delete process.env[NO_INSPECTOR_ENV];
+  inspectorSwitch.set = false;
+}
+var clearsAtStop = false;
+function clearSwitchAtStop() {
+  if (clearsAtStop) return;
+  clearsAtStop = true;
+  process.prependListener("message", (message) => {
+    if (message?.method === "__stop__") clearSwitch();
+  });
+}
 function markPausesWrapped() {
   inspectorSwitch.wrapped = true;
   syncInspectorSwitch();
@@ -16376,9 +16941,9 @@ var BarIntents = class {
   /** Hand the bar an intent; false while it runs one, or holds one already. */
   offer(intent) {
     if (this.busy || this.queued) return false;
-    const take = this.take;
+    const take2 = this.take;
     this.take = null;
-    if (take) take(intent);
+    if (take2) take2(intent);
     else this.queued = intent;
     return true;
   }
@@ -16388,8 +16953,8 @@ var BarIntents = class {
     const queued = this.queued;
     this.queued = null;
     if (queued) return Promise.resolve(queued);
-    return new Promise((resolve11) => {
-      this.take = resolve11;
+    return new Promise((resolve12) => {
+      this.take = resolve12;
     });
   }
   /** The bar got its answer: it takes no intent until it waits again. */
@@ -16404,7 +16969,7 @@ async function within(run, ms) {
   try {
     return await Promise.race([
       run,
-      new Promise((resolve11) => timer = setTimeout(() => resolve11(void 0), ms))
+      new Promise((resolve12) => timer = setTimeout(() => resolve12(void 0), ms))
     ]);
   } finally {
     clearTimeout(timer);
@@ -16437,13 +17002,68 @@ async function viewHere(page, probe, onPick, onRecord, ended, intents, onIntent,
     }
   }
 }
+var REDRAW_MS = 500;
+var stopHighlights = 0;
+var FRAME_HOP = " >> internal:control=enter-frame >> ";
+async function frameOf(locator) {
+  const own = locator;
+  if (!own._frame || typeof own._selector !== "string") return null;
+  const at = own._selector.lastIndexOf(FRAME_HOP);
+  if (at < 0) return { frame: own._frame, selector: own._selector };
+  const [iframe] = await own._frame.locator(own._selector.slice(0, at)).first().elementHandles();
+  if (!iframe) return null;
+  try {
+    const frame = await iframe.contentFrame();
+    return frame ? { frame, selector: own._selector.slice(at + FRAME_HOP.length) } : null;
+  } finally {
+    await iframe.dispose().catch(() => void 0);
+  }
+}
+function highlightAtStop(page, locator, what, label) {
+  const id = `${what}-${++stopHighlights}`;
+  const arg = { id, kind: what, label };
+  const drawnIn = /* @__PURE__ */ new Set();
+  let hidden2 = false;
+  let timer;
+  const draw = async () => {
+    const target = await frameOf(locator);
+    if (hidden2) return 0;
+    if (!target) return locator.evaluateAll(showStopHighlight, arg);
+    drawnIn.add(target.frame);
+    return target.frame.locator(target.selector).evaluateAll(showStopHighlight, arg);
+  };
+  const again = () => {
+    if (hidden2 || page.isClosed?.()) return;
+    timer = setTimeout(
+      () => void internalCall(page, draw).catch(() => 0).then(again),
+      REDRAW_MS
+    );
+    timer.unref?.();
+  };
+  const first = internalCall(page, draw).catch(() => 0);
+  void first.then(again);
+  const removeIn = (frame) => internalCall(page, async () => frame.evaluate(removeStopHighlight, id)).catch(() => false);
+  return {
+    shown: first.then((boxes) => boxes > 0),
+    hide: async () => {
+      hidden2 = true;
+      clearTimeout(timer);
+      try {
+        const frames = drawnIn.size ? [...drawnIn] : [page.mainFrame()];
+        const removed = await within(Promise.all(frames.map(removeIn)), TAKE_DOWN_MS);
+        return removed?.includes(true) ?? false;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
 async function pauseHere(page, point, probe, onPick, onRecord, ended, intents, onIntent) {
-  let shown2 = null;
+  let highlight = null;
   try {
-    const highlight = point.target?.highlight;
-    if (typeof highlight === "function") {
-      const highlighted = Promise.resolve().then(() => highlight.call(point.target)).catch(() => null);
-      shown2 = await within(highlighted, HIGHLIGHT_MS) ?? null;
+    if (point.target) {
+      highlight = point.target.highlight();
+      await within(highlight.shown, HIGHLIGHT_MS);
     }
     const arg = {
       place: pausePlace(point.location),
@@ -16502,17 +17122,10 @@ async function pauseHere(page, point, probe, onPick, onRecord, ended, intents, o
   } catch {
     return "resume";
   } finally {
-    const takeDown = async () => {
-      try {
-        if (ended?.aborted) await page.evaluate(takePauseState);
-        const dispose = shown2?.dispose;
-        const hide = page.hideHighlight;
-        if (typeof dispose === "function") await dispose.call(shown2);
-        else if (typeof hide === "function") await hide.call(page);
-      } catch {
-      }
-    };
-    await within(takeDown(), TAKE_DOWN_MS);
+    await Promise.all([
+      ended?.aborted ? within(page.evaluate(takePauseState), TAKE_DOWN_MS).catch(() => void 0) : void 0,
+      highlight?.hide()
+    ]);
   }
 }
 
@@ -16558,6 +17171,12 @@ function locatorOn(page, source) {
   }
 }
 
+// src/internal/capture/aria-ref.ts
+function locatorOfRef(page, ref) {
+  const getByRef = page.getByRef;
+  return typeof getByRef === "function" ? getByRef.call(page, ref) : page.locator(`aria-ref=${ref}`);
+}
+
 // src/internal/capture/pick-at.ts
 var LINE = /^(\s*)- ([a-z][\w-]*)(?: "(?:[^"\\]|\\.)*")?((?: \[[^\]\n]*\])*)(?::.*)?$/;
 var REF = /\[ref=(e\d+)\]/;
@@ -16597,18 +17216,16 @@ var PIWI_OVERLAY = '[id^="__piwi"], [id^="piwi-"][id$="-host"]';
 var MAX_UNDER = 24;
 var MAX_CHECKED = 8;
 var NORMALIZED_SCORE = 60;
-var PICK_AT_NEEDS = "Pick on the image needs Playwright 1.64 or later (page.getByRef and the boxes of page.ariaSnapshot): update @playwright/test.";
+var PICK_AT_SINCE = "1.60";
+var PICK_AT_NEEDS = "Pick on the image needs Playwright 1.60 or later (the boxes of page.ariaSnapshot): update @playwright/test.";
 var NO_ELEMENT = "No element there: pick an element of the page, not its background.";
 var IN_IFRAME = "That point is in an iframe, whose elements Pick on the image does not reach: use Pick in the test's window.";
-function canPickAt(page) {
-  return typeof page.getByRef === "function";
-}
 var hitIn = ({ x, y, overlay, elements }) => {
   let scope = globalThis.document;
   let hit = null;
   for (let depth = 0; scope && depth < 32; depth++) {
-    const within3 = scope;
-    const top = within3.elementsFromPoint(x, y).find((el) => el.getRootNode?.() === within3 && !el.closest?.(overlay));
+    const within4 = scope;
+    const top = within4.elementsFromPoint(x, y).find((el) => el.getRootNode?.() === within4 && !el.closest?.(overlay));
     if (!top) break;
     hit = top;
     scope = top.shadowRoot ?? null;
@@ -16622,14 +17239,12 @@ var hitIn = ({ x, y, overlay, elements }) => {
   return -1;
 };
 async function pickAtPoint(page, probe, x, y) {
-  if (!canPickAt(page)) return { refusal: PICK_AT_NEEDS };
   const snapshot = await page.ariaSnapshot({ mode: "ai", boxes: true, timeout: 5e3 });
   if (!/\[box=/.test(snapshot)) return { refusal: PICK_AT_NEEDS };
   const under = boxesAt(snapshotBoxes(snapshot), x, y).slice(0, MAX_UNDER);
-  const byRef2 = (ref) => page.getByRef(ref);
   const handles = await Promise.all(
     under.map(
-      (box) => byRef2(box.ref).elementHandle({ timeout: 2e3 }).catch(() => null)
+      (box) => locatorOfRef(page, box.ref).elementHandle({ timeout: 2e3 }).catch(() => null)
     )
   );
   try {
@@ -16646,7 +17261,7 @@ async function pickAtPoint(page, probe, x, y) {
         (el, overlay) => !!el.closest(overlay),
         PIWI_OVERLAY
       );
-      if (!piwi) return await rank(page, probe, byRef2(box.ref), handle);
+      if (!piwi) return await rank(page, probe, locatorOfRef(page, box.ref), handle);
     }
     return { refusal: NO_ELEMENT };
   } finally {
@@ -16694,31 +17309,360 @@ async function rank(page, probe, locator, handle) {
   return { picked: { picked, alternatives: [picked, ...candidates.filter((c) => c !== found)], element } };
 }
 
+// src/internal/capture/live-mask.ts
+var import_node_module3 = require("module");
+var MASKED_SPACING_MS = 500;
+var FRESH_MS = 1e3;
+var READS_KEPT = 4;
+var MAX_FRAMES = 32;
+var PAD = 2;
+var SAME_WITHIN = 1;
+var FRAME_READ_MS = 1e3;
+var MAX_FAILED_READS = 3;
+var MASK_RGB = [96, 96, 96];
+var TOO_MANY_FRAMES = `This page has more than ${MAX_FRAMES} frames: the live view cannot check them all for secret fields, so no image of it goes.`;
+var NO_CODEC = "A secret field shows on this page, and this Playwright gives the reporter nothing to mask it with: no image goes while it shows.";
+var UNREAD = "The live view cannot read where the secret fields of this page are, so no image of it goes until it can.";
+var ZOOMED = "This page is zoomed in: no image of it goes until it is not, its secret fields shown larger than read.";
+var UNREADABLE_MASKS = "The project masks elements this reporter cannot read: no image goes. Update @piwitests/reporter.";
+var codec;
+function jpegCodec() {
+  if (codec !== void 0) return codec;
+  codec = null;
+  try {
+    const playwright = resolvePlaywrightPackageJson();
+    const bundle = playwright ? (0, import_node_module3.createRequire)(playwright)("playwright-core/lib/utilsBundle") : null;
+    const found = bundle?.jpegjs;
+    if (typeof found?.decode === "function" && typeof found.encode === "function") codec = found;
+  } catch {
+  }
+  return codec;
+}
+function maskedIn(frame, masks) {
+  let locator = frame.locator(SECRET_FIELD_SELECTOR);
+  for (const source of masks) {
+    const own = locatorOn(frame, source);
+    if (!own) throw new Error(`The locator ${source} cannot be built.`);
+    locator = locator.or(own);
+  }
+  return locator;
+}
+var unbuilt = (source) => `The project masks ${source}, which this Playwright cannot find elements by: no image of the page goes.`;
+var near = (a, b) => Math.abs(a - b) <= SAME_WITHIN;
+function readFrameRects(page, frame, masks) {
+  return internalCall(
+    page,
+    () => maskedIn(frame, masks).evaluateAll((elements) => {
+      const view3 = globalThis;
+      const visual = view3.visualViewport;
+      const layout = view3.document.scrollingElement;
+      const zoomed = !!visual && (Math.abs(visual.offsetLeft) > 0.5 || Math.abs(visual.offsetTop) > 0.5 || (layout ? visual.width < layout.clientWidth - 1 || visual.height < layout.clientHeight - 1 : visual.scale > 1.001));
+      return {
+        rects: elements.map((element) => {
+          const rect = element.getBoundingClientRect();
+          return [rect.x, rect.y, rect.width, rect.height];
+        }).filter(([, , width, height]) => width > 0 && height > 0),
+        width: view3.innerWidth,
+        height: view3.innerHeight,
+        zoomed
+      };
+    })
+  );
+}
+async function childOrigin(page, frame, inner) {
+  return internalCall(page, async () => {
+    const element = await frame.frameElement();
+    try {
+      const outer = await element.boundingBox();
+      if (!outer) return null;
+      const own = await element.evaluate((iframe) => {
+        const el = iframe;
+        const style = globalThis.getComputedStyle(iframe);
+        const pad = (side) => parseFloat(side) || 0;
+        return {
+          left: el.clientLeft + pad(style.paddingLeft),
+          top: el.clientTop + pad(style.paddingTop),
+          width: el.clientWidth - pad(style.paddingLeft) - pad(style.paddingRight),
+          height: el.clientHeight - pad(style.paddingTop) - pad(style.paddingBottom),
+          offsetWidth: el.offsetWidth,
+          offsetHeight: el.offsetHeight
+        };
+      });
+      const drawnAsLaidOut = near(outer.width, own.offsetWidth) && near(outer.height, own.offsetHeight);
+      const contentIsViewport = near(own.width, inner.width) && near(own.height, inner.height);
+      if (!drawnAsLaidOut || !contentIsViewport) return { whole: outer };
+      return { x: outer.x + own.left, y: outer.y + own.top };
+    } finally {
+      await element.dispose();
+    }
+  });
+}
+async function within2(run, ms) {
+  let timer;
+  try {
+    return await Promise.race([
+      run,
+      new Promise((resolve12) => timer = setTimeout(() => resolve12(void 0), ms))
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function wholeFrame(page, frame) {
+  const box = await within2(
+    internalCall(page, async () => {
+      const element = await frame.frameElement();
+      try {
+        return await element.boundingBox();
+      } finally {
+        await element.dispose();
+      }
+    }),
+    FRAME_READ_MS
+  ).catch(() => void 0);
+  if (box === void 0) return null;
+  return { rects: box ? [[box.x, box.y, box.width, box.height]] : [], width: 0, height: 0 };
+}
+async function readFrame(page, frame, masks) {
+  try {
+    const read = await within2(readFrameRects(page, frame, masks), FRAME_READ_MS);
+    if (!read) return frame === page.mainFrame() ? null : await wholeFrame(page, frame);
+    if (!read.rects.length || frame === page.mainFrame()) return read;
+    const origin = await childOrigin(page, frame, read);
+    if (!origin) return { ...read, rects: [] };
+    if ("whole" in origin) {
+      const { x, y, width, height } = origin.whole;
+      return { ...read, rects: [[x, y, width, height]] };
+    }
+    return {
+      ...read,
+      rects: read.rects.map(([left, top, width, height]) => [origin.x + left, origin.y + top, width, height])
+    };
+  } catch {
+    return frame.isDetached() ? { rects: [], width: 0, height: 0 } : null;
+  }
+}
+async function readBoxes(page, masks) {
+  if (!masks) return UNREADABLE_MASKS;
+  const frames = page.frames();
+  if (frames.length > MAX_FRAMES) return TOO_MANY_FRAMES;
+  for (const source of masks) if (!locatorOn(page.mainFrame(), source)) return unbuilt(source);
+  const main = page.mainFrame();
+  const read = await Promise.all(frames.map((frame) => readFrame(page, frame, masks)));
+  if (read.some((frame) => frame === null)) return null;
+  const top = read[frames.indexOf(main)];
+  if (!top) return null;
+  if (top.zoomed) return ZOOMED;
+  return {
+    boxes: read.flatMap(
+      (frame) => frame.rects.map(([x, y, width, height]) => ({ x, y, width, height }))
+    ),
+    viewport: { width: top.width, height: top.height }
+  };
+}
+function sameBoxes(a, b) {
+  return a.length === b.length && a.every((box, i) => {
+    const other = b[i];
+    return Math.abs(box.x - other.x) <= SAME_WITHIN && Math.abs(box.y - other.y) <= SAME_WITHIN && Math.abs(box.width - other.width) <= SAME_WITHIN && Math.abs(box.height - other.height) <= SAME_WITHIN;
+  });
+}
+function jpegSize(data) {
+  for (let i = 2; i + 9 < data.length; ) {
+    if (data[i] !== 255) return null;
+    const marker2 = data[i + 1];
+    if (marker2 >= 192 && marker2 <= 195) return { height: data.readUInt16BE(i + 5), width: data.readUInt16BE(i + 7) };
+    i += 2 + data.readUInt16BE(i + 2);
+  }
+  return null;
+}
+function shrink(image, width, height) {
+  const data = new Uint8Array(width * height * 4);
+  const sx = image.width / width;
+  const sy = image.height / height;
+  for (let y = 0; y < height; y++) {
+    const y0 = Math.floor(y * sy);
+    const y1 = Math.max(y0 + 1, Math.min(image.height, Math.floor((y + 1) * sy)));
+    for (let x = 0; x < width; x++) {
+      const x0 = Math.floor(x * sx);
+      const x1 = Math.max(x0 + 1, Math.min(image.width, Math.floor((x + 1) * sx)));
+      let r = 0;
+      let g = 0;
+      let b = 0;
+      for (let yy = y0; yy < y1; yy++) {
+        for (let xx = x0; xx < x1; xx++) {
+          const i = (yy * image.width + xx) * 4;
+          r += image.data[i];
+          g += image.data[i + 1];
+          b += image.data[i + 2];
+        }
+      }
+      const n = (y1 - y0) * (x1 - x0);
+      const o = (y * width + x) * 4;
+      data[o] = r / n;
+      data[o + 1] = g / n;
+      data[o + 2] = b / n;
+      data[o + 3] = 255;
+    }
+  }
+  return { width, height, data };
+}
+function paintBoxes(jpeg, frame, boxes, size, quality) {
+  const image = jpeg.decode(frame.data, { useTArray: true, formatAsRGBA: true });
+  const sx = image.width / frame.width;
+  const sy = image.height / frame.height;
+  for (const box of boxes) {
+    const x0 = Math.max(0, Math.floor((box.x - PAD) * sx));
+    const y0 = Math.max(0, Math.floor((box.y - PAD) * sy));
+    const x1 = Math.min(image.width, Math.ceil((box.x + box.width + PAD) * sx));
+    const y1 = Math.min(image.height, Math.ceil((box.y + box.height + PAD) * sy));
+    for (let y = y0; y < y1; y++) {
+      for (let x = x0; x < x1; x++) {
+        const i = (y * image.width + x) * 4;
+        image.data[i] = MASK_RGB[0];
+        image.data[i + 1] = MASK_RGB[1];
+        image.data[i + 2] = MASK_RGB[2];
+        image.data[i + 3] = 255;
+      }
+    }
+  }
+  const fits = image.width <= size.width && image.height <= size.height;
+  return jpeg.encode(fits ? image : shrink(image, size.width, size.height), quality).data;
+}
+async function measureFrame(page, frame) {
+  try {
+    const measured = await within2(
+      internalCall(page, async () => {
+        const fields = await frame.locator(SECRET_FIELD_SELECTOR).elementHandles();
+        try {
+          return await Promise.all(fields.map((field) => field.boundingBox()));
+        } finally {
+          await Promise.all(fields.map((field) => field.dispose().catch(() => void 0)));
+        }
+      }),
+      FRAME_READ_MS
+    );
+    if (measured) return measured.filter((box) => !!box && box.width > 0 && box.height > 0);
+    const whole = frame === page.mainFrame() ? null : await wholeFrame(page, frame);
+    return whole && whole.rects.map(([x, y, width, height]) => ({ x, y, width, height }));
+  } catch {
+    return frame.isDetached() ? [] : null;
+  }
+}
+async function secretBoxes(page) {
+  const [read, measured] = await Promise.all([
+    readBoxes(page, []),
+    Promise.all(
+      page.frames().slice(0, MAX_FRAMES).map((frame) => measureFrame(page, frame))
+    )
+  ]);
+  if (!read || typeof read === "string" || measured.some((boxes) => !boxes)) return null;
+  return { ...read, boxes: [...read.boxes, ...measured.flat()] };
+}
+async function maskedImage(page, options) {
+  const before = await secretBoxes(page);
+  if (!before) return null;
+  const shot = await internalCall(
+    page,
+    () => page.screenshot({
+      type: "jpeg",
+      quality: options.quality,
+      timeout: options.timeout,
+      ...options.style ? { style: options.style } : {}
+    })
+  ).catch(() => null);
+  if (!shot) return null;
+  const after = await secretBoxes(page);
+  if (!after || !sameBoxes(before.boxes, after.boxes)) return null;
+  const { width, height } = after.viewport;
+  if (!near(width, before.viewport.width) || !near(height, before.viewport.height)) return null;
+  if (!after.boxes.length) return shot;
+  const jpeg = jpegCodec();
+  const size = jpegSize(shot);
+  if (!jpeg || !size) return null;
+  try {
+    return paintBoxes(jpeg, { data: shot, width, height, at: Date.now() }, after.boxes, size, options.quality);
+  } catch {
+    return null;
+  }
+}
+function maskSecretFields(page, options) {
+  const reads = [];
+  let maskedAt = -Infinity;
+  let failed2 = 0;
+  const read = async () => {
+    const began = Date.now();
+    const found = await readBoxes(page, options.masks());
+    if (typeof found === "string") return found;
+    if (!found) return ++failed2 >= MAX_FAILED_READS ? UNREAD : null;
+    failed2 = 0;
+    const done = { began, ended: Date.now(), ...found };
+    reads.push(done);
+    if (reads.length > READS_KEPT) reads.shift();
+    return done;
+  };
+  const showsViewportOf = (frame, read2) => near(frame.width, read2.viewport.width) && near(frame.height, read2.viewport.height);
+  const shown2 = (frame, boxes, size) => {
+    const own = jpegSize(frame.data);
+    const fits = own === null || own.width <= size.width && own.height <= size.height;
+    const jpeg = jpegCodec();
+    if (!boxes.length && (fits || !jpeg)) return frame.data.length <= options.maxBytes ? frame : null;
+    if (!jpeg) return NO_CODEC;
+    let data;
+    try {
+      data = paintBoxes(jpeg, frame, boxes, size, options.quality);
+    } catch {
+      return null;
+    }
+    if (!boxes.length) return data.length <= options.maxBytes ? { ...frame, data } : null;
+    if (data.length > options.maxBytes) return null;
+    maskedAt = Date.now();
+    return { ...frame, data };
+  };
+  return {
+    get resting() {
+      return Date.now() - maskedAt < MASKED_SPACING_MS;
+    },
+    async screen(frame) {
+      const before = [...reads].reverse().find((r) => r.ended <= frame.at && r.ended >= frame.at - FRESH_MS) ?? null;
+      const after = await read();
+      if (typeof after === "string" || !after) return after;
+      const size = jpegSize(frame.data) ?? frame;
+      if (before && sameBoxes(before.boxes, after.boxes) && showsViewportOf(frame, before) && showsViewportOf(frame, after)) {
+        return shown2(frame, after.boxes, size);
+      }
+      if (page.isClosed()) return null;
+      const at = Date.now();
+      const shot = await internalCall(
+        page,
+        () => page.screenshot({ type: "jpeg", quality: options.quality, scale: "css", caret: "initial", timeout: 5e3 })
+      ).catch(() => null);
+      if (!shot) return null;
+      const again = await read();
+      if (typeof again === "string" || !again) return again;
+      if (!sameBoxes(after.boxes, again.boxes)) return null;
+      const { width, height } = again.viewport;
+      if (!near(width, after.viewport.width) || !near(height, after.viewport.height)) return null;
+      return shown2(
+        { data: shot, width, height, at },
+        again.boxes,
+        fitViewSize({ width, height }, size.width, size.height)
+      );
+    }
+  };
+}
+
 // src/internal/capture/agent-page.ts
 var ACT_MS = 5e3;
-var SECRET_FIELDS = [
-  'input[type="password" i]',
-  ...SECRET_AUTOCOMPLETE.flatMap((token) => [
-    `input[autocomplete~="${token}" i]`,
-    `textarea[autocomplete~="${token}" i]`
-  ])
-].join(", ");
+var SECRET_FIELDS = SECRET_FIELD_SELECTOR;
 var BAR_HIDDEN = "#__piwi-pause-bar { display: none !important; }";
-var AGENT_NEEDS = "An agent reads and acts on a stopped page with Playwright 1.64 or later (page.getByRef and the AI snapshot): update @playwright/test.";
-function canActByRef(page) {
-  return typeof page.getByRef === "function";
-}
-function byRef(page, ref) {
-  return page.getByRef(ref);
-}
 function failed(prefix, error) {
   const first = errorMessage(error).split("\n")[0].trim();
   return hideSecretsInText(`${prefix}: ${first}`).slice(0, 300);
 }
-var MAX_FRAMES = 32;
+var MAX_FRAMES2 = 32;
 async function fieldSecrets(page) {
   const values = await Promise.all(
-    page.frames().slice(0, MAX_FRAMES).map(
+    page.frames().slice(0, MAX_FRAMES2).map(
       (frame) => frame.locator(SECRET_FIELDS).evaluateAll((fields) => fields.map((field) => field.value)).catch(() => [])
     )
   );
@@ -16772,13 +17716,7 @@ async function readSnapshot(page, depth, image) {
   const cut = hidden2.length > MAX_AGENT_SNAPSHOT;
   let shot = null;
   if (image) {
-    const data = await page.screenshot({
-      type: "jpeg",
-      quality: 60,
-      style: BAR_HIDDEN,
-      mask: page.frames().slice(0, MAX_FRAMES).map((frame) => frame.locator(SECRET_FIELDS)),
-      timeout: ACT_MS
-    }).catch(() => null);
+    const data = await maskedImage(page, { quality: 60, style: BAR_HIDDEN, timeout: ACT_MS });
     const viewport = page.viewportSize();
     if (data) shot = { mime: "image/jpeg", data: data.toString("base64"), ...viewport };
   }
@@ -16847,14 +17785,13 @@ async function ranked(page, probe, locator, handle, testIdAttribute) {
 }
 var NO_REF = (ref) => `No element of the stopped page has the ref ${ref}: take the page's snapshot again, its refs may have changed.`;
 async function handleOf(page, ref) {
-  return byRef(page, ref).elementHandle({ timeout: 2e3 }).catch(() => null);
+  return locatorOfRef(page, ref).elementHandle({ timeout: 2e3 }).catch(() => null);
 }
 async function refLocators(page, probe, ref, testIdAttribute) {
-  if (!canActByRef(page)) return { ok: false, message: AGENT_NEEDS, element: null, locators: [] };
   const handle = await handleOf(page, ref);
   if (!handle) return { ok: false, message: NO_REF(ref), element: null, locators: [] };
   try {
-    const { element, locators } = await ranked(page, probe, byRef(page, ref), handle, testIdAttribute);
+    const { element, locators } = await ranked(page, probe, locatorOfRef(page, ref), handle, testIdAttribute);
     const alone = locators.filter((l) => l.unique).length;
     return {
       ok: true,
@@ -16898,12 +17835,11 @@ var PLAYED = {
   select: "Selected an option of"
 };
 async function actOnRef(page, probe, act, testIdAttribute) {
-  if (!canActByRef(page)) return { ok: false, message: AGENT_NEEDS, element: null, locators: [] };
   const handle = await handleOf(page, act.ref);
   if (!handle) return { ok: false, message: NO_REF(act.ref), element: null, locators: [] };
   let before;
   try {
-    before = await ranked(page, probe, byRef(page, act.ref), handle, testIdAttribute);
+    before = await ranked(page, probe, locatorOfRef(page, act.ref), handle, testIdAttribute);
   } catch (error) {
     return { ok: false, message: failed("The element could not be read", error), element: null, locators: [] };
   } finally {
@@ -16911,7 +17847,7 @@ async function actOnRef(page, probe, act, testIdAttribute) {
   }
   try {
     await page.evaluate(barLetsThrough, true).catch(() => void 0);
-    await play(byRef(page, act.ref), act.action, act.value);
+    await play(locatorOfRef(page, act.ref), act.action, act.value);
   } catch (error) {
     return { ok: false, message: failed(`${PLAYED[act.action]} ${act.ref} failed`, error), ...before };
   } finally {
@@ -16955,7 +17891,7 @@ async function bindBrowser(browser, name, workspaceDir, on) {
 }
 
 // src/internal/capture/run-events.ts
-var path30 = __toESM(require("path"));
+var path31 = __toESM(require("path"));
 
 // src/internal/capture/run-channel.ts
 var net3 = __toESM(require("net"));
@@ -17034,7 +17970,198 @@ async function keptResponse(id) {
 var http3 = __toESM(require("http"));
 var https3 = __toESM(require("https"));
 
+// src/internal/capture/live-call-log.ts
+var path30 = __toESM(require("path"));
+var TARGET_EVERY_MS = 1e3;
+var KEPT_LINES = 1e3;
+var MAX_LINE2 = 600;
+var MAX_TITLE = 500;
+var MAX_HEARD = 200;
+function callStreamOf(context) {
+  const dbg = context.debugger;
+  return typeof dbg?._enable === "function" && typeof dbg.on === "function" && typeof dbg.off === "function" ? dbg : null;
+}
+var heard = /* @__PURE__ */ new Map();
+var tracked = /* @__PURE__ */ new WeakSet();
+function trackCalls(playwright) {
+  const instrumentation = playwright?._instrumentation;
+  if (!playwright || tracked.has(playwright) || typeof instrumentation?.addListener !== "function") return;
+  tracked.add(playwright);
+  instrumentation.addListener({
+    onApiCallBegin: (zone, channel) => {
+      if (channel?.method === "__waitInfo__") return;
+      const selector = channel?.params?.selector;
+      heard.set(zone, {
+        zone,
+        selector: typeof selector === "string" && selector ? selector : null,
+        began: Date.now()
+      });
+      if (heard.size > MAX_HEARD) heard.delete(heard.keys().next().value);
+    },
+    onApiCallEnd: (zone) => {
+      heard.delete(zone);
+    }
+  });
+}
+function heardAs(id) {
+  for (const call of heard.values()) if (call.zone.callId === id) return call;
+  return null;
+}
+function userFile(file) {
+  if (typeof file !== "string" || !file || /[\\/]node_modules[\\/]/.test(file)) return null;
+  const relative11 = path30.relative(process.cwd(), file).split(path30.sep).join("/");
+  return relative11 && !relative11.startsWith("..") && !path30.isAbsolute(relative11) ? relative11 : null;
+}
+var followed = /* @__PURE__ */ new WeakMap();
+function take(state, update) {
+  if (typeof update?.id !== "string" || typeof update.title !== "string") return;
+  const status = update.status === "running" ? "running" : update.status === "error" ? "failed" : "passed";
+  let call = state.calls.get(update.id);
+  if (!call) {
+    const heardOne = heardAs(update.id);
+    call = {
+      id: update.id,
+      title: hideSecretsInText(hideTypedText(update.title)).slice(0, MAX_TITLE),
+      file: userFile(update.location?.file),
+      line: typeof update.location?.line === "number" ? update.location.line : null,
+      status,
+      lines: [],
+      point: null,
+      error: null,
+      began: heardOne?.began ?? Date.now(),
+      ended: null,
+      order: ++state.told,
+      selector: heardOne?.selector ?? null,
+      secretField: heardOne?.selector ? isSecretLocator(heardOne.selector) : false
+    };
+    state.calls.set(update.id, call);
+  }
+  if (Array.isArray(update.newLogEntries)) {
+    for (const entry of update.newLogEntries) {
+      if (typeof entry !== "string") continue;
+      call.secretField ||= namesSecretField(entry);
+      call.lines.push(hideSecretsInText(hideSecretsInLog(entry, call.secretField)).slice(0, MAX_LINE2));
+    }
+    if (call.lines.length > KEPT_LINES) call.lines.splice(0, call.lines.length - KEPT_LINES);
+  }
+  const point = update.actionPoint;
+  if (point && Number.isFinite(point.x) && Number.isFinite(point.y)) {
+    call.point = { x: point.x, y: point.y };
+  }
+  if (typeof update.error === "string" && update.error) {
+    const first = update.error.split("\n")[0];
+    call.error = hideSecretsInText(hideSecretsInLog(first, call.secretField)).slice(0, MAX_LINE2);
+  }
+  call.status = status;
+  if (status !== "running" && call.ended === null) call.ended = Date.now();
+}
+function shownCall(state, since2) {
+  let shown2 = null;
+  for (const call of state.calls.values()) {
+    if (call.ended !== null && call.ended < since2) continue;
+    if (!shown2) {
+      shown2 = call;
+      continue;
+    }
+    const running2 = call.status === "running";
+    if (running2 !== (shown2.status === "running") ? running2 : call.order > shown2.order) shown2 = call;
+  }
+  return shown2;
+}
+function prune(state) {
+  let last = null;
+  for (const call of state.calls.values()) if (!last || call.order > last.order) last = call;
+  for (const [id, call] of state.calls) if (call.status !== "running" && call !== last) state.calls.delete(id);
+}
+async function followContext(context) {
+  const stream = callStreamOf(context);
+  if (!stream) return null;
+  const state = { calls: /* @__PURE__ */ new Map(), told: 0, views: /* @__PURE__ */ new Set() };
+  const listener = (updates) => {
+    if (!Array.isArray(updates)) return;
+    for (const update of updates) take(state, update);
+    prune(state);
+    for (const view3 of state.views) view3();
+  };
+  stream.on("apicallsupdated", listener);
+  try {
+    await internalCall(context, () => stream._enable());
+  } catch {
+    stream.off("apicallsupdated", listener);
+    return null;
+  }
+  return state;
+}
+async function followCallLog(page, since2, onLog) {
+  const context = page.context();
+  let state = followed.get(context);
+  if (!state) {
+    state = followContext(context);
+    followed.set(context, state);
+  }
+  const calls = await state;
+  if (!calls) return null;
+  let stopped = false;
+  let reading = false;
+  let target = null;
+  const onThisPage = () => !page.isClosed() && context.pages().length === 1;
+  const tell = () => {
+    const shown2 = shownCall(calls, since2);
+    if (stopped || !shown2) return;
+    const here = onThisPage();
+    onLog({
+      id: shown2.id,
+      call: { title: shown2.title, file: shown2.file, line: shown2.line },
+      status: shown2.status,
+      lines: compressCallLog(shown2.lines).slice(-MAX_LIVE_CALL_LOG_LINES),
+      point: here ? shown2.point : null,
+      target: here && shown2.status === "running" && target?.id === shown2.id ? target.matches : null,
+      viewport: page.viewportSize(),
+      ms: (shown2.ended ?? Date.now()) - shown2.began,
+      error: shown2.error
+    });
+  };
+  calls.views.add(tell);
+  tell();
+  const timer = setInterval(() => {
+    const shown2 = shownCall(calls, since2);
+    const selector = shown2?.selector;
+    if (stopped || reading || !shown2 || shown2.status !== "running" || !selector || !onThisPage()) return;
+    if (Date.now() - shown2.began < TARGET_EVERY_MS) return;
+    reading = true;
+    const framed = selector.includes("internal:control=enter-frame");
+    void internalCall(
+      page,
+      () => page.locator(selector).evaluateAll((elements) => {
+        const first = elements[0];
+        if (!first) return { count: 0, box: null, enabled: null };
+        const rect = first.getBoundingClientRect();
+        const disabled = first.disabled === true || first.getAttribute("aria-disabled") === "true";
+        return {
+          count: elements.length,
+          box: rect.width || rect.height ? { x: rect.x, y: rect.y, width: rect.width, height: rect.height } : null,
+          enabled: !disabled
+        };
+      })
+    ).then((matches) => {
+      if (stopped || shownCall(calls, since2) !== shown2 || shown2.status !== "running") return;
+      if (!matches.count && shown2.lines.some((line) => line.includes("locator resolved to"))) return;
+      target = { id: shown2.id, matches: framed ? { ...matches, box: null } : matches };
+      tell();
+    }).catch(() => void 0).finally(() => {
+      reading = false;
+    });
+  }, TARGET_EVERY_MS);
+  timer.unref?.();
+  return () => {
+    stopped = true;
+    clearInterval(timer);
+    calls.views.delete(tell);
+  };
+}
+
 // src/internal/capture/page-view.ts
+var SCREENCAST_LAG_MS = 100;
 var HOLDERS = /* @__PURE__ */ new WeakMap();
 var TEST_SCREENCASTS = /* @__PURE__ */ new WeakSet();
 var OWN_SCREENCASTS = /* @__PURE__ */ new WeakMap();
@@ -17087,16 +18214,39 @@ async function openPageView(page, options) {
   let last = null;
   let sent2 = null;
   let refused = false;
+  let screening = false;
+  let screened = null;
   const interval = 1e3 / options.fps;
+  const deliver = (frame) => {
+    if (closed || !options.live()) return;
+    refused = false;
+    sent2 = frame;
+    options.send(frame);
+  };
+  const refuse2 = (why) => {
+    if (closed || refused || !options.live()) return;
+    refused = true;
+    sent2 = { refused: why };
+    options.refuse(why);
+  };
   const pacer = new LatestPacer({
     intervalMs: interval,
     ...options.spacing ? { spacing: options.spacing } : {},
-    busy: options.busy,
+    busy: () => screening || options.busy(),
     send: (frame) => {
       if (!options.live()) return;
-      refused = false;
-      sent2 = frame;
-      options.send(frame);
+      if (!options.screen) return deliver(frame);
+      screening = true;
+      screened = options.screen(frame).then(
+        (shown2) => {
+          if (typeof shown2 === "string") refuse2(shown2);
+          else if (shown2) deliver(shown2);
+        },
+        () => void 0
+      ).finally(() => {
+        screening = false;
+        screened = null;
+      });
     }
   });
   let lighter = null;
@@ -17111,23 +18261,20 @@ async function openPageView(page, options) {
     ).then(
       (shot) => {
         if (closed) return;
-        if (shot.length <= options.maxFrameBytes) return pacer.offer({ data: shot, ...viewport });
-        if (refused || !options.live()) return;
-        refused = true;
-        sent2 = "refused";
-        options.refuse();
+        if (shot.length <= options.maxFrameBytes) return pacer.offer({ data: shot, ...viewport, at: now });
+        refuse2();
       },
       () => void 0
     ).finally(() => {
       lighter = null;
     });
   };
-  const onFrame = (data, width, height) => {
+  const onFrame = (data, width, height, at) => {
     if (closed || last?.equals(data)) return;
     last = data;
     if (data.length > options.maxFrameBytes) return lighten();
     const named = isViewSize(width, height);
-    pacer.offer({ data, width: named ? width : viewport.width, height: named ? height : viewport.height });
+    pacer.offer({ data, width: named ? width : viewport.width, height: named ? height : viewport.height, at });
   };
   const screencast = screencastOf(page);
   let end = null;
@@ -17136,11 +18283,12 @@ async function openPageView(page, options) {
   const shoot = async () => {
     shots = null;
     if (closed || page.isClosed()) return;
+    const at = Date.now();
     const shot = await internalCall(
       page,
       () => page.screenshot({ type: "jpeg", quality: options.quality, scale: "css", caret: "initial", timeout: 5e3 })
     ).catch(() => null);
-    if (shot) onFrame(shot, viewport.width, viewport.height);
+    if (shot) onFrame(shot, viewport.width, viewport.height, at);
     if (!closed) {
       shots = setTimeout(() => void shoot(), options.shotMs);
       shots.unref?.();
@@ -17173,7 +18321,9 @@ async function openPageView(page, options) {
         size: options.size(viewport),
         quality: options.quality,
         onFrame: (frame) => {
-          onFrame(frame.data, frame.viewportWidth, frame.viewportHeight);
+          const now = Date.now();
+          const at = typeof frame.timestamp === "number" && Number.isFinite(frame.timestamp) ? Math.min(frame.timestamp, now) - SCREENCAST_LAG_MS : Number.NEGATIVE_INFINITY;
+          onFrame(frame.data, frame.viewportWidth, frame.viewportHeight, at);
           return acks.next();
         }
       })
@@ -17197,9 +18347,22 @@ async function openPageView(page, options) {
     },
     resend: () => {
       if (closed || !sent2 || !options.live()) return;
-      if (sent2 === "refused") options.refuse();
+      if ("refused" in sent2) options.refuse(sent2.refused);
       else options.send(sent2);
     },
+    refresh: () => {
+      if (closed) return;
+      sent2 = null;
+      last = null;
+      const at = Date.now();
+      void internalCall(
+        page,
+        () => page.screenshot({ type: "jpeg", quality: options.quality, scale: "css", caret: "initial", timeout: 5e3 })
+      ).then(
+        (shot) => onFrame(shot, viewport.width, viewport.height, at),
+        () => void 0
+      );
+    },
     close: async () => {
       closed = true;
       sent2 = null;
@@ -17207,7 +18370,7 @@ async function openPageView(page, options) {
       pacer.close();
       if (shots) clearTimeout(shots);
       holders.delete(holder);
-      await lighter;
+      await Promise.all([lighter, screened]);
       const stop = end;
       end = null;
       if (stop && !page.isClosed()) await stop().catch(() => void 0);
@@ -17225,6 +18388,7 @@ var MAX_EVENT_TEXT = 64 * 1024;
 var MAX_STATES_WAITING = 8;
 var LIGHT_QUALITY = 30;
 var SHOT_MS = 1e3;
+var LOG_SPACING_MS = Math.ceil(1e3 / LIVE_CALL_LOGS_PER_SECOND);
 var VIEW_END_MS = 1e3;
 var GIVE_UP = /* @__PURE__ */ new Set([401, 403, 404, 410]);
 var TOO_HEAVY = `This page is too heavy for the live view: each image of it is over ${MAX_LIVE_FRAME / 1024} KB, a lighter one included.`;
@@ -17297,7 +18461,8 @@ function openLiveView(worker, env = process.env, ci = detectCi(env)) {
     address,
     id: { shard: resolveShardInfo(worker.config, env)?.current ?? null, worker: worker.workerIndex },
     client,
-    agent: new client.Agent({ keepAlive: true, maxSockets: 2 }),
+    // The stream, and a frame, a call log and a stop or an end in flight at once: none waits behind another.
+    agent: new client.Agent({ keepAlive: true, maxSockets: 4 }),
     stream: null,
     timer: null,
     retries: 0,
@@ -17305,13 +18470,20 @@ function openLiveView(worker, env = process.env, ci = detectCi(env)) {
     ended: false,
     refused: null,
     sharing: ci,
+    ci,
     lost: null,
     answered: null,
     viewers: 0,
     states: Promise.resolve(),
     statesWaiting: 0,
     stop: null,
-    posting: false
+    posting: false,
+    log: null,
+    logPosting: false,
+    logSentAt: 0,
+    logTimer: null,
+    logRefused: false,
+    masks: []
   };
   if (ci) connect(link);
   changed();
@@ -17361,9 +18533,9 @@ async function stopSharing() {
   own.viewers = 0;
   changed();
 }
-function liveViewTestBegan(title, call) {
+function liveViewTestBegan(title, call, mayPause2 = false) {
   if (!link) return;
-  running = { title, page: null, call };
+  running = { title, page: null, call, mayPause: mayPause2, began: Date.now() };
 }
 function liveViewPage(page) {
   if (!link || !running || running.page) return;
@@ -17389,7 +18561,7 @@ function liveViewStopped(stop) {
   };
 }
 function hideCallSecrets(call) {
-  return { ...call, title: hideSecretsInText(call.title) };
+  return { ...call, title: hideSecretsInText(hideTypedText(call.title)) };
 }
 function postState(own, message) {
   if (!active(own) || own.statesWaiting >= MAX_STATES_WAITING) return;
@@ -17457,7 +18629,8 @@ function connect(own) {
         text2 = text2.slice(end + 2);
         const data = block.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
         const message = data ? parseInstanceToWorker(data) : null;
-        if (message) setViewers(own, message.count);
+        if (message?.type === "masks") setMasks(own, message.locators);
+        else if (message) setViewers(own, message.count);
       }
     });
     response.on("error", () => drop(null));
@@ -17497,11 +18670,19 @@ function setViewers(own, count) {
     return;
   }
   if (view) {
-    if (count > before) void view.opened.then((opened) => opened?.resend());
+    if (count > before) {
+      void view.opened.then((opened) => opened?.resend());
+      if (own.log) postLog(own, own.log);
+    }
     return;
   }
   startView();
 }
+function setMasks(own, locators) {
+  if (JSON.stringify(locators) === JSON.stringify(own.masks)) return;
+  own.masks = locators;
+  if (own === link) void view?.opened.then((opened) => opened?.refresh());
+}
 function startView() {
   const own = link;
   const page = running?.page ?? null;
@@ -17511,6 +18692,11 @@ function startView() {
     return;
   }
   const live = () => view?.page === page && link === own && active(own) && own.viewers > 0;
+  const mask = maskSecretFields(page, {
+    masks: () => own.masks,
+    quality: LIVE_FRAME_QUALITY,
+    maxBytes: MAX_LIVE_FRAME
+  });
   const opened = openPageView(page, {
     size: (viewport) => fitViewSize(viewport, LIVE_FRAME_WIDTH, LIVE_FRAME_HEIGHT),
     quality: LIVE_FRAME_QUALITY,
@@ -17519,28 +18705,39 @@ function startView() {
     maxFrameBytes: MAX_LIVE_FRAME,
     lightQuality: LIGHT_QUALITY,
     shotMs: SHOT_MS,
-    busy: () => own.posting,
+    busy: () => own.posting || mask.resting,
     live,
+    screen: (frame) => mask.screen(frame),
     send: (frame) => postFrame(own, frame),
-    refuse: () => void post(own, { type: "frame", ...own.id, refused: TOO_HEAVY })
+    refuse: (why) => void post(own, { type: "frame", ...own.id, refused: why ?? TOO_HEAVY })
   }).catch(() => null);
   const onClose = () => {
     if (view?.page === page) void stopView();
   };
   page.once("close", onClose);
-  view = { page, opened, onClose };
+  const following = own.ci && running && !running.mayPause && !own.logRefused ? followCallLog(page, running.began, (log) => {
+    if (live()) postLog(own, log);
+  }).catch(() => null) : null;
+  view = { page, opened, onClose, following };
 }
 async function stopView() {
   const shown2 = view;
   view = null;
   if (!shown2) return;
   shown2.page.off("close", shown2.onClose);
+  void shown2.following?.then((stop) => stop?.());
+  const own = link;
+  if (own) {
+    own.log = null;
+    if (own.logTimer) clearTimeout(own.logTimer);
+    own.logTimer = null;
+  }
   const closed = shown2.opened.then((opened) => opened?.close());
   let timer;
   await Promise.race([
     closed.catch(() => void 0),
-    new Promise((resolve11) => {
-      timer = setTimeout(resolve11, VIEW_END_MS);
+    new Promise((resolve12) => {
+      timer = setTimeout(resolve12, VIEW_END_MS);
       timer.unref?.();
     })
   ]);
@@ -17561,19 +18758,47 @@ function postFrame(own, frame) {
     own.posting = false;
   });
 }
+function postLog(own, log) {
+  own.log = log;
+  nextLog(own);
+}
+function nextLog(own) {
+  if (own.logPosting || own.logTimer) return;
+  const wait = LOG_SPACING_MS - (Date.now() - own.logSentAt);
+  if (wait > 0) {
+    own.logTimer = setTimeout(() => {
+      own.logTimer = null;
+      nextLog(own);
+    }, wait);
+    own.logTimer.unref?.();
+    return;
+  }
+  const log = own.log;
+  if (!active(own) || !view || !log || own.logRefused) return;
+  own.logPosting = true;
+  own.logSentAt = Date.now();
+  let again = false;
+  void post(own, { type: "call-log", ...own.id, log, test: running?.title ?? null }).then((status) => {
+    if (status === 400) own.logRefused = true;
+    again = status === 429;
+  }).catch(() => void 0).finally(() => {
+    own.logPosting = false;
+    if (own.log && (own.log !== log || again)) nextLog(own);
+  });
+}
 function post(own, message) {
   return active(own) ? send(own, message) : Promise.resolve(null);
 }
 function send(own, message) {
   if (own.ended || own.refused !== null) return Promise.resolve(null);
   const body = JSON.stringify(message);
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     let settled = false;
     const settle = (status) => {
       if (settled) return;
       settled = true;
       if (status !== null && GIVE_UP.has(status)) refuse(own, status);
-      resolve11(status);
+      resolve12(status);
     };
     const request3 = own.client.request(own.address.url, {
       method: "POST",
@@ -17600,7 +18825,6 @@ function send(own, message) {
 // src/internal/capture/run-channel.ts
 var CONNECT_MS = 2e3;
 var BAR_HIDDEN2 = "#__piwi-pause-bar { display: none !important; }";
-var OUTLINE_STYLE = "outline: 2px dashed #a78bfa; outline-offset: 2px; background: rgba(167, 139, 250, 0.15);";
 var WENT_ON = "The test went on.";
 var MAX_FRAME_BACKLOG = 1024 * 1024;
 var SHOT_MS2 = 500;
@@ -17608,6 +18832,7 @@ var LIGHT_QUALITY2 = 30;
 var TOO_HEAVY2 = `This page is too heavy for the live view: each image of it is over ${MAX_VIEW_FRAME / 1024} KB, a lighter one included. The image of the stop still shows it.`;
 var VIEW_END_MS2 = 1e3;
 var PAGE_ANSWER_MS = 1e4;
+var OUTLINE_MS = 2e3;
 var NO_ANSWER = "The page did not answer in time.";
 var LATE_ACT = "The page did not answer in time: the action may still take effect, and is told when it does.";
 var MAX_INPUT_WAITING = 4;
@@ -17647,11 +18872,12 @@ var sharedHere = false;
 var liveSaid = "";
 var unhearLive = null;
 var NO_AGENT_PAGE = "This stop has no page an agent can read: its call does not name one among its context's pages.";
-function workerTakes(env = process.env) {
+function workerTakes(env = process.env, playwright) {
   const pairing = !!env[PIWI_LOCAL_DEBUG_ENV.editorSend];
   const recorder = parseRecordChannel(env[RECORD_CHANNEL_ENV]) !== null;
+  const boxes = playwright === void 0 || playwrightVersionAtLeast(playwright, PICK_AT_SINCE);
   return RUN_TAKES.filter(
-    (take) => take === "pick" ? pairing : take === "record" || take === "assert" ? recorder : true
+    (take2) => take2 === "pick" ? pairing : take2 === "record" || take2 === "assert" ? recorder : take2 === "pick-at" ? boxes : true
   );
 }
 async function openRunChannel(worker, handlers, env = process.env) {
@@ -17660,15 +18886,15 @@ async function openRunChannel(worker, handlers, env = process.env) {
   if (socket || !channel || !ref || !/^[\w-]{1,64}$/.test(ref)) return false;
   const opening = net3.connect(channel.path);
   opening.setEncoding("utf8");
-  const opened = await new Promise((resolve11) => {
-    const timer = setTimeout(() => resolve11(false), CONNECT_MS);
+  const opened = await new Promise((resolve12) => {
+    const timer = setTimeout(() => resolve12(false), CONNECT_MS);
     opening.once("connect", () => {
       clearTimeout(timer);
-      resolve11(true);
+      resolve12(true);
     });
     opening.once("error", () => {
       clearTimeout(timer);
-      resolve11(false);
+      resolve12(false);
     });
   });
   if (!opened || opening.destroyed) {
@@ -17711,8 +18937,10 @@ async function openRunChannel(worker, handlers, env = process.env) {
     pid: process.pid,
     playwright: worker.config.version,
     reporter: getReporterVersion(),
-    takes: workerTakes(env),
-    holds: [...RUN_HOLDS]
+    takes: workerTakes(env, worker.config.version),
+    holds: [...RUN_HOLDS],
+    // A run the reporter follows from outside the editor, which its own test runner started.
+    ...ref.startsWith(TERMINAL_REF_PREFIX) && startedByTestRunner(env) ? { runner: true } : {}
   });
   liveSaid = "";
   tellLive();
@@ -17785,7 +19013,7 @@ async function unbind() {
   const shared = bound?.browser;
   bound = null;
   if (shared?.isConnected()) {
-    await within2(
+    await within3(
       internalCall(shared, () => bindBrowser(shared, runName, process.cwd(), false)),
       VIEW_END_MS2
     );
@@ -17845,7 +19073,7 @@ function viewEnded(stop) {
   else viewEnds.add(() => ended.abort());
   return ended.signal;
 }
-async function within2(run, ms) {
+async function within3(run, ms) {
   await answerWithin(run, ms, void 0);
 }
 async function answerWithin(run, ms, late) {
@@ -17853,20 +19081,20 @@ async function answerWithin(run, ms, late) {
   try {
     return await Promise.race([
       run.catch(() => late),
-      new Promise((resolve11) => timer = setTimeout(() => resolve11(late), ms))
+      new Promise((resolve12) => timer = setTimeout(() => resolve12(late), ms))
     ]);
   } finally {
     clearTimeout(timer);
   }
 }
 async function endView(stop, page) {
-  if (viewStarting?.stop === stop) await within2(viewStarting.started, VIEW_END_MS2);
+  if (viewStarting?.stop === stop) await within3(viewStarting.started, VIEW_END_MS2);
   if (view2?.stop === stop) await stopView2();
   const own = input;
   input = freshInput();
-  await within2(own.playing, VIEW_END_MS2);
+  await within3(own.playing, VIEW_END_MS2);
   if (page && !page.isClosed() && (own.buttons.size || own.keys.size)) {
-    await within2(
+    await within3(
       internalCall(page, async () => {
         for (const button of own.buttons) await page.mouse.up({ button });
         for (const key of own.keys) await page.keyboard.up(key);
@@ -17880,7 +19108,7 @@ async function stopView2() {
   view2 = null;
   for (const end of viewEnds) end();
   viewEnds.clear();
-  if (shown2) await within2(shown2.close(), VIEW_END_MS2);
+  if (shown2) await within3(shown2.close(), VIEW_END_MS2);
 }
 function startView2(holding) {
   if (view2?.stop === holding.stop) {
@@ -17900,7 +19128,7 @@ function startView2(holding) {
     }
     if (!opened) return { ok: false, message: "The page could not be shown: it closed, or does not answer." };
     if (held !== holding || page.isClosed()) {
-      await within2(opened.close(), VIEW_END_MS2);
+      await within3(opened.close(), VIEW_END_MS2);
       return { ok: false, message: WENT_ON };
     }
     view2 = opened;
@@ -17944,7 +19172,7 @@ async function openView(page, stop) {
   };
 }
 async function stopViewOf(holding) {
-  if (viewStarting?.stop === holding.stop) await within2(viewStarting.started, VIEW_END_MS2);
+  if (viewStarting?.stop === holding.stop) await within3(viewStarting.started, VIEW_END_MS2);
   if (view2?.stop === holding.stop) await stopView2();
   return { ok: true, message: "The live view is off." };
 }
@@ -18035,18 +19263,17 @@ async function countLocator(holding, source) {
   if (!locator) return { ok: false, message: `${source} is not a locator Piwi can build.`, count: null };
   try {
     const count = await internalCall(page, () => locator.count());
+    let outlined = false;
     if (holding.bar && count > 0 && held === holding) {
-      const shown2 = await internalCall(page, () => locator.highlight({ style: OUTLINE_STYLE }));
-      const dispose = shown2?.dispose;
-      outline = {
-        stop: holding.stop,
-        remove: () => internalCall(page, () => typeof dispose === "function" ? dispose.call(shown2) : page.hideHighlight())
-      };
+      const shown2 = highlightAtStop(page, locator, "count", source);
+      outline = { stop: holding.stop, remove: async () => void await shown2.hide() };
+      outlined = await answerWithin(shown2.shown, OUTLINE_MS, false);
     }
     return {
       ok: true,
       message: count === 0 ? "No element matches." : count === 1 ? "1 element matches." : `${count} elements match.`,
-      count
+      count,
+      outlined
     };
   } catch (error) {
     return { ok: false, message: `The locator could not be counted: ${errorMessage(error)}`, count: null };
@@ -18233,17 +19460,17 @@ async function imageOf(page) {
 
 // src/internal/capture/run-events.ts
 var begun = /* @__PURE__ */ new WeakMap();
-var heard = /* @__PURE__ */ new WeakSet();
+var heard2 = /* @__PURE__ */ new WeakSet();
 var watched = /* @__PURE__ */ new WeakSet();
-function userFile(file, cwd, windows) {
+function userFile2(file, cwd, windows) {
   if (!file || /[\\/]node_modules[\\/]/.test(file)) return null;
-  const relative10 = callSitePath(file, cwd, windows);
-  if (!relative10 || (windows ? path30.win32 : path30.posix).isAbsolute(relative10) || relative10.startsWith("..")) return null;
-  return relative10;
+  const relative11 = callSitePath(file, cwd, windows);
+  if (!relative11 || (windows ? path31.win32 : path31.posix).isAbsolute(relative11) || relative11.startsWith("..")) return null;
+  return relative11;
 }
 function callPlace(frames, cwd = process.cwd(), windows = process.platform === "win32") {
   for (const frame of frames ?? []) {
-    const file = userFile(frame.file, cwd, windows);
+    const file = userFile2(frame.file, cwd, windows);
     if (!file || !frame.line || frame.line < 1) continue;
     return { file, line: frame.line, ...frame.column && frame.column > 0 ? { column: frame.column } : {} };
   }
@@ -18260,9 +19487,9 @@ function errorText(error) {
 }
 function watchCalls(playwright) {
   const instrumentation = playwright?._instrumentation;
-  if (!playwright || heard.has(playwright)) return true;
+  if (!playwright || heard2.has(playwright)) return true;
   if (!instrumentation || typeof instrumentation.addListener !== "function") return false;
-  heard.add(playwright);
+  heard2.add(playwright);
   const titles = /* @__PURE__ */ new WeakMap();
   instrumentation.addListener({
     onApiCallBegin: (zone, channel) => {
@@ -18379,9 +19606,9 @@ function yamlScalar(text2) {
 }
 
 // src/internal/capture/record-handoff.ts
-var fs26 = __toESM(require("fs"));
+var fs27 = __toESM(require("fs"));
 var net4 = __toESM(require("net"));
-var path31 = __toESM(require("path"));
+var path32 = __toESM(require("path"));
 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();
@@ -18401,7 +19628,7 @@ function canRecordFromHere(channel = process.env[RECORD_CHANNEL_ENV]) {
 function handoffPlace(location, cwd = process.cwd()) {
   const m = /^(.+):(\d+):\d+$/.exec(location);
   if (!m) return null;
-  return { file: path31.resolve(cwd, m[1]), line: Number(m[2]) };
+  return { file: path32.resolve(cwd, m[1]), line: Number(m[2]) };
 }
 async function recordFromHere(options) {
   const channel = parseRecordChannel(options.channel ?? process.env[RECORD_CHANNEL_ENV]);
@@ -18411,7 +19638,7 @@ async function recordFromHere(options) {
   if (ended?.aborted) return "the test ended.";
   const use = testInfo.project?.use ?? {};
   const context = page.context();
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const socket2 = net4.connect(channel.path);
     socket2.setEncoding("utf8");
     const answers = /* @__PURE__ */ new Map();
@@ -18472,7 +19699,7 @@ async function recordFromHere(options) {
       page.off("crash", onGone);
       ended?.removeEventListener("abort", onEnded);
       socket2.end();
-      resolve11(recording ? null : said);
+      resolve12(recording ? null : said);
     };
     const relayed = (source, payload) => new Promise((answer) => {
       const call = ++calls;
@@ -18504,7 +19731,7 @@ async function recordFromHere(options) {
         if (typeof initScript?.dispose !== "function") relay.lingering = true;
       }
       if (settled) return release();
-      await page.evaluate(fs26.readFileSync(bundle, "utf-8"));
+      await page.evaluate(fs27.readFileSync(bundle, "utf-8"));
       if (settled) return release();
       recording = true;
       clearTimeout(startWait);
@@ -18564,7 +19791,7 @@ async function recordFromHere(options) {
 
 // src/internal/capture/css-coverage.ts
 var crypto8 = __toESM(require("crypto"));
-var fs27 = __toESM(require("fs"));
+var fs28 = __toESM(require("fs"));
 
 // ../core/src/css-rules.ts
 var GROUPING = /* @__PURE__ */ new Set(["media", "supports", "layer", "container", "scope", "starting-style", "document"]);
@@ -18704,7 +19931,7 @@ function sourceFile(source, roots) {
 function styleBlockLine(file, index) {
   let text2;
   try {
-    text2 = fs27.readFileSync(file, "utf-8");
+    text2 = fs28.readFileSync(file, "utf-8");
   } catch {
     return 0;
   }
@@ -18732,10 +19959,10 @@ async function sheetMap(sheet, text2, fetchMap) {
     return null;
   }
 }
-function sameLines(text2, rules, file, lineOffset) {
+function sameLines2(text2, rules, file, lineOffset) {
   let source;
   try {
-    source = fs27.readFileSync(file, "utf-8");
+    source = fs28.readFileSync(file, "utf-8");
   } catch {
     return false;
   }
@@ -18770,12 +19997,12 @@ async function resolveSheet(sheet, text2, dirs, fetchMap) {
     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(text2, rules, file2, lineOffset2) };
+    return { rules, lookup: null, file: file2, lineOffset: lineOffset2, sources: [], exact: sameLines2(text2, 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(text2, rules, file, lineOffset) };
+  return { rules, lookup: null, file, lineOffset, sources: [], exact: sameLines2(text2, rules, file, lineOffset) };
 }
 function cachedResolution(sheet, text2, dirs, fetchMap) {
   const version = crypto8.createHash("sha1").update(text2).digest("hex");
@@ -19137,7 +20364,8 @@ function createSink() {
     locatorPages: new LocatorPageLog(),
     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
+    baseURL: null,
+    headless: void 0
   };
 }
 var MAX_CODE_REACH_PAGES = 16;
@@ -19162,7 +20390,7 @@ function maybeStartCodeReach(page, alreadyOpen = false) {
 async function startCodeReachOnOpenPages() {
   if (!pageCoverageInWorker() || OPEN_PAGES.size === 0) return;
   const started = Promise.all([...OPEN_PAGES].map((page) => maybeStartCodeReach(page, true)));
-  await Promise.race([started, new Promise((resolve11) => setTimeout(resolve11, CODE_REACH_START_WAIT_MS).unref())]);
+  await Promise.race([started, new Promise((resolve12) => setTimeout(resolve12, CODE_REACH_START_WAIT_MS).unref())]);
 }
 function configuredCodeReachRoots() {
   const raw = process.env.PIWI_CODE_REACH_ROOTS?.trim();
@@ -19176,7 +20404,7 @@ function configuredCodeReachRoots() {
     }
   } catch {
   }
-  return raw.split(path32.delimiter).filter(Boolean);
+  return raw.split(path33.delimiter).filter(Boolean);
 }
 async function stopSinkCodeReach(sink, closing) {
   const stopping = [];
@@ -19231,8 +20459,8 @@ async function drainPendingProbes(capMs) {
   let cap;
   await Promise.race([
     Promise.allSettled(PENDING_PROBES),
-    new Promise((resolve11) => {
-      cap = setTimeout(resolve11, capMs);
+    new Promise((resolve12) => {
+      cap = setTimeout(resolve12, capMs);
     })
   ]);
   clearTimeout(cap);
@@ -19291,10 +20519,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((resolve11) => {
+      const readBuffered = (type, extra) => new Promise((resolve12) => {
         try {
           const PO = globalThis.PerformanceObserver;
-          if (!PO || !(PO.supportedEntryTypes || []).includes(type)) return resolve11(null);
+          if (!PO || !(PO.supportedEntryTypes || []).includes(type)) return resolve12(null);
           const out = [];
           const po = new PO((list) => out.push(...list.getEntries()));
           po.observe({ type, buffered: true, ...extra });
@@ -19304,10 +20532,10 @@ async function readWebVitals(page) {
               po.disconnect();
             } catch {
             }
-            resolve11(out);
+            resolve12(out);
           }, 0);
         } catch {
-          resolve11(null);
+          resolve12(null);
         }
       });
       const [lcpRaw, shiftRaw, eventRaw, firstInputRaw] = await Promise.all([
@@ -19424,12 +20652,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((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     const timer = setTimeout(() => reject(new Error("page inventory read timed out")), ms);
     promise.then(
       (value) => {
         clearTimeout(timer);
-        resolve11(value);
+        resolve12(value);
       },
       (error) => {
         clearTimeout(timer);
@@ -19548,6 +20776,20 @@ var PATCHED_BROWSERS = /* @__PURE__ */ new WeakSet();
 var CHAIN_METHOD_SET = new Set(CHAIN_METHODS);
 var ACTION_METHOD_SET = new Set(ACTION_METHODS);
 var LOCATOR_METHOD_SET = new Set(LOCATOR_METHODS);
+var EARLY_READ_ACTIONS = /* @__PURE__ */ new Set([
+  "click",
+  "dblclick",
+  "tap",
+  "press",
+  "pressSequentially",
+  "type",
+  "check",
+  "uncheck",
+  "selectOption",
+  "dispatchEvent"
+]);
+var CAPTURE_DEADLINE_MS = 500;
+var EARLY_READ_TRUSTED_MS = 250;
 var CAPTURED_ATTRS_ARG = {
   keep: [...CAPTURED_ATTRIBUTES],
   tagRoles: TAG_TO_ROLE,
@@ -19566,15 +20808,36 @@ var PROBE_INIT_SCRIPT = `(() => {
   globalThis[${JSON.stringify(PROBE_GLOBAL)}] = (el) => probe(el, arg);
 })();`;
 var PROBE_UNSEEDED_PAGES = /* @__PURE__ */ new WeakSet();
-function probeElement(page, target) {
-  const shipSource = () => target.evaluate(probeElementAttrs, CAPTURED_ATTRS_ARG);
+var PAGE_NAVIGATIONS = /* @__PURE__ */ new WeakMap();
+function readyProbeWorld(page) {
+  if (!currentSink) return;
+  try {
+    const ready = internalCall(
+      page,
+      () => page.mainFrame().locator(":root").evaluate(() => 0, void 0, { timeout: CAPTURE_DEADLINE_MS })
+    ).then(
+      () => void 0,
+      () => void 0
+    );
+    PENDING_PROBES.add(ready);
+    void ready.then(() => PENDING_PROBES.delete(ready));
+  } catch {
+  }
+}
+function probeElement(page, target, timeout) {
+  const options = timeout != null ? { timeout } : void 0;
+  const shipSource = () => target.evaluate(probeElementAttrs, CAPTURED_ATTRS_ARG, options);
   if (!page || PROBE_UNSEEDED_PAGES.has(page)) return internalCall(page, shipSource);
   return internalCall(
     page,
-    () => target.evaluate((el, name) => {
-      const seeded = globalThis[name];
-      return typeof seeded === "function" ? seeded(el) : null;
-    }, PROBE_GLOBAL).then((attrs) => {
+    () => target.evaluate(
+      (el, name) => {
+        const seeded = globalThis[name];
+        return typeof seeded === "function" ? seeded(el) : null;
+      },
+      PROBE_GLOBAL,
+      options
+    ).then((attrs) => {
       if (attrs) return attrs;
       PROBE_UNSEEDED_PAGES.add(page);
       return shipSource();
@@ -19609,54 +20872,60 @@ async function ariaSnapshotJSONBestEffort(target, timeout) {
     return null;
   }
 }
-function startElementCapture(sink, page, target, seq, callerLocation, used) {
-  const probe = probeElement(page, target);
-  const settledProbe = probe.then(
-    () => void 0,
-    () => void 0
-  );
-  PENDING_PROBES.add(settledProbe);
-  settledProbe.then(() => PENDING_PROBES.delete(settledProbe));
-  sink.capturePromises.push(settledProbe);
-  const resolveAttrs = (async () => {
-    let deadline;
-    try {
-      const attrs = await Promise.race([
-        probe,
-        new Promise((_, reject) => {
-          deadline = setTimeout(() => reject(new Error("locator capture timeout")), 500);
-        })
-      ]);
-      const role = resolveAriaRole({ ...attrs, accessibleName: null });
-      const isFormField = FORM_FIELD_TAGS.has(attrs.tagName);
-      const exactName = exactAccessibleName(attrs, role);
-      const aria = exactName === null && (role || isFormField) ? await internalCall(page, () => ariaSnapshotBestEffort(target, 500)) : null;
-      const accessibleName = exactName ?? (extractAccessibleName(aria) || approximateAccessibleName({ ...attrs, accessibleName: null }));
-      sink.capturedLocators[seq] = {
-        location: callerLocation,
-        used,
-        // hasLabel/selectorCounts inform alternative generation only —
-        // keep the stored element to the wire shape. rolePosition and
-        // ancestors ARE wire fields: the server's renamed-element match
-        // uses them at heal time.
-        element: {
-          tagName: attrs.tagName,
-          attributes: attrs.attributes,
-          textContent: attrs.textContent,
-          accessibleName,
-          center: attrs.center,
-          ...attrs.rolePosition ? { rolePosition: attrs.rolePosition } : {},
-          ...attrs.ancestors && attrs.ancestors.length > 0 ? { ancestors: attrs.ancestors } : {}
-        },
-        alternatives: generateAlternatives({ ...attrs, accessibleName })
-      };
-    } catch {
-      if (callerLocation) sink.probedLocations.delete(callerLocation);
-    } finally {
-      clearTimeout(deadline);
-    }
+async function readElementSnapshot(sink, page, target, callerLocation, used) {
+  let deadline;
+  try {
+    const probe = probeElement(page, target, CAPTURE_DEADLINE_MS);
+    const settledProbe = probe.then(
+      () => void 0,
+      () => void 0
+    );
+    PENDING_PROBES.add(settledProbe);
+    settledProbe.then(() => PENDING_PROBES.delete(settledProbe));
+    sink.capturePromises.push(settledProbe);
+    const attrs = await Promise.race([
+      probe,
+      new Promise((_, reject) => {
+        deadline = setTimeout(() => reject(new Error("locator capture timeout")), CAPTURE_DEADLINE_MS);
+      })
+    ]);
+    const role = resolveAriaRole({ ...attrs, accessibleName: null });
+    const isFormField = FORM_FIELD_TAGS.has(attrs.tagName);
+    const exactName = exactAccessibleName(attrs, role);
+    const aria = exactName === null && (role || isFormField) ? await internalCall(page, () => ariaSnapshotBestEffort(target, CAPTURE_DEADLINE_MS)) : null;
+    const accessibleName = exactName ?? (extractAccessibleName(aria) || approximateAccessibleName({ ...attrs, accessibleName: null }));
+    return {
+      location: callerLocation,
+      used,
+      // hasLabel/selectorCounts inform alternative generation only —
+      // keep the stored element to the wire shape. rolePosition and
+      // ancestors ARE wire fields: the server's renamed-element match
+      // uses them at heal time.
+      element: {
+        tagName: attrs.tagName,
+        attributes: attrs.attributes,
+        textContent: attrs.textContent,
+        accessibleName,
+        center: attrs.center,
+        ...attrs.rolePosition ? { rolePosition: attrs.rolePosition } : {},
+        ...attrs.ancestors && attrs.ancestors.length > 0 ? { ancestors: attrs.ancestors } : {}
+      },
+      alternatives: generateAlternatives({ ...attrs, accessibleName })
+    };
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(deadline);
+  }
+}
+function startElementCapture(sink, page, target, seq, callerLocation, used, early = null, earlyFirst = false) {
+  const capture = (async () => {
+    const readNow = () => readElementSnapshot(sink, page, target, callerLocation, used);
+    const snapshot = earlyFirst ? await early ?? await readNow() : await readNow() ?? await early;
+    if (snapshot) sink.capturedLocators[seq] = snapshot;
+    else if (callerLocation) sink.probedLocations.delete(callerLocation);
   })();
-  sink.capturePromises.push(resolveAttrs);
+  sink.capturePromises.push(capture);
 }
 function recordLocatorPage(sink, page, locator, location, arrival) {
   try {
@@ -19668,7 +20937,7 @@ function knowLocatorCall(sink, page, target, location, origin) {
   if (!sink?.pause || !location) return null;
   let settle = () => {
   };
-  const settled = new Promise((resolve11) => settle = resolve11);
+  const settled = new Promise((resolve12) => settle = resolve12);
   const call = { page, target, location, origin, picked: false, endable: false, settled, settle };
   sink.locatorCalls.set(callSiteLine(location), call);
   return call;
@@ -19776,7 +21045,7 @@ function endedWaiting(sink, call) {
   return "finish";
 }
 function stopSite(sink, location) {
-  if (path32.dirname(path32.resolve(location.file)) !== __dirname) return stopCallSite(location);
+  if (path33.dirname(path33.resolve(location.file)) !== __dirname) return stopCallSite(location);
   return inFlightCallSite([...sink.locatorCalls.values()].map((call) => call.location));
 }
 function stopBarPage(sink, context, of) {
@@ -19791,7 +21060,7 @@ async function showStop(sink, context, title, location, reason, call, of, failur
   const page = stopBarPage(sink, context, of);
   const guessed = !("page" in of);
   if (!testInfo) return void 0;
-  const bar = !!page && testInfo.project?.use?.headless === false;
+  const bar = !!page && pauseGateFromTestInfo(testInfo, sink.headless).headless === false;
   const place = runChannelOpen() ? callSitePlace(location) : null;
   if (!bar && !place) return void 0;
   const failing = failure?.failed ?? null;
@@ -19899,6 +21168,7 @@ async function showStop(sink, context, title, location, reason, call, of, failur
       }
       return "resume";
     }
+    const stoppedOn = call?.page === page ? call : null;
     return internalCall(
       page,
       () => pauseHere(
@@ -19907,7 +21177,14 @@ async function showStop(sink, context, title, location, reason, call, of, failur
           location,
           call: title,
           attempt: testInfo.retry > 0 ? testInfo.retry + 1 : null,
-          target: call?.page === page ? call.target : null,
+          target: stoppedOn ? {
+            highlight: () => highlightAtStop(
+              page,
+              stoppedOn.target,
+              "call",
+              locatorSource(stoppedOn.target, stoppedOn.origin.method, stoppedOn.origin.args)
+            )
+          } : null,
           ...failure ? { failure: true } : sink.functionEnded ? {} : { end: true }
         },
         probe,
@@ -19954,7 +21231,7 @@ function endTest(sink, call, title, location, reason) {
     return "end";
   }
   const said = hideSecretsInText(
-    `${title} at ${line} runs before the test ends: Piwi holds no locator call there. The test is skipped at its next locator call, or as it ends.`
+    call && !takesEndSignal(sink.testInfo.config?.version) ? `${title} at ${line} runs before the test ends: a locator call is given up from Playwright 1.62 on. The test is skipped as the call returns.` : `${title} at ${line} runs before the test ends: Piwi holds no locator call there. The test is skipped at its next locator call, or as it ends.`
   );
   console.log(`[piwi] ${said}`);
   tellHub({ type: "notice", message: said });
@@ -20113,8 +21390,8 @@ function errorPlace(error, windows = process.platform === "win32") {
   for (const line of typeof stack === "string" ? stack.split("\n") : []) {
     const frame = /^\s*at\s+(?:.*?\s+\()?(.+?):(\d+):(\d+)\)?$/.exec(line);
     const file = frame ? framePath(frame[1], windows) : null;
-    if (!frame || !file || !(windows ? path32.win32 : path32.posix).isAbsolute(file)) continue;
-    if (/[\\/]node_modules[\\/]/.test(file) || path32.dirname(path32.resolve(file)) === __dirname) continue;
+    if (!frame || !file || !(windows ? path33.win32 : path33.posix).isAbsolute(file)) continue;
+    if (/[\\/]node_modules[\\/]/.test(file) || path33.dirname(path33.resolve(file)) === __dirname) continue;
     return { file, line: Number(frame[2]), column: Number(frame[3]) };
   }
   return null;
@@ -20125,7 +21402,7 @@ function callInProgress(testInfo) {
     if (!Array.isArray(steps)) return;
     for (const step of steps) {
       if (step.endWallTime) continue;
-      const at = step.stack?.[0];
+      const at = step.stack?.[0] ?? step.location;
       const called = step.category === "pw:api" || step.category === "expect" || step.category === "test.step";
       if (called && typeof at?.file === "string" && typeof at.line === "number") {
         found = {
@@ -20145,13 +21422,13 @@ function stepInProgress(testInfo) {
 function runningCall(testInfo) {
   const call = callInProgress(testInfo);
   if (!call?.title) return null;
-  const file = path32.relative(process.cwd(), call.place.file).split(path32.sep).join("/");
+  const file = path33.relative(process.cwd(), call.place.file).split(path33.sep).join("/");
   return { title: call.title, file, line: call.place.line };
 }
 function abortion(signal) {
-  return new Promise((resolve11) => {
-    if (signal.aborted) resolve11();
-    else signal.addEventListener("abort", () => resolve11(), { once: true });
+  return new Promise((resolve12) => {
+    if (signal.aborted) resolve12();
+    else signal.addEventListener("abort", () => resolve12(), { once: true });
   });
 }
 var END_STOP_MS = 2e3;
@@ -20186,7 +21463,7 @@ function releaseCall(sink, settled) {
 }
 function releasedRequestsEnded(sink) {
   if (sink.releasedRequests.size === 0) return Promise.resolve();
-  return new Promise((resolve11) => sink.onReleasedRequestsEnded = resolve11);
+  return new Promise((resolve12) => sink.onReleasedRequestsEnded = resolve12);
 }
 async function awaitReleasedCalls(sink) {
   if (sink.released.length === 0) return;
@@ -20199,13 +21476,13 @@ async function awaitReleasedCalls(sink) {
     }
     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)));
+    await new Promise((resolve12) => setTimeout(resolve12, 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))]);
+  await Promise.race([Promise.allSettled(pending), new Promise((resolve12) => timer = setTimeout(resolve12, ms))]);
   clearTimeout(timer);
 }
 function endStopsWithTestFunction(testInfo, sink) {
@@ -20238,7 +21515,7 @@ async function pauseInPlace(page, playwrightPause, location) {
   if (!sink || !testInfo || !location || !context || !contextDebugger(context)) {
     return leaveToPlaywright(context, playwrightPause);
   }
-  if (!sink.pause && (!canRecordFromHere() || pauseSkipReason(pauseGateFromTestInfo(testInfo)))) {
+  if (!sink.pause && (!canRecordFromHere() || pauseSkipReason(pauseGateFromTestInfo(testInfo, sink.headless)))) {
     return leaveToPlaywright(context, playwrightPause);
   }
   sink.pause ??= pauseState(NO_BREAKPOINTS);
@@ -20306,7 +21583,7 @@ function wrapLocator(page, locator, originMethod, originArgs) {
           const callerLocation = sink ? captureCallerLocation() : null;
           if (sink) recordLocatorPage(sink, page, target, callerLocation, noteLocatorCall(page, EXPECT_METHOD, true));
           const call = knowLocatorCall(sink, page, target, callerLocation, { method: originMethod, args: originArgs });
-          const ending = sink?.pause && !sink.ended ? withEndSignal(EXPECT_METHOD, callArgs, sink.end.signal) : null;
+          const ending = sink?.pause && !sink.ended && takesEndSignal(sink.testInfo?.config?.version) ? withEndSignal(EXPECT_METHOD, callArgs, sink.end.signal) : null;
           if (call && ending) call.endable = true;
           const expectArgs = ending ?? callArgs;
           try {
@@ -20359,7 +21636,7 @@ function wrapLocator(page, locator, originMethod, originArgs) {
           raw: `${originMethod}(${JSON.stringify(originArgs)})`
         };
         const call = knowLocatorCall(sink, page, target, callerLocation, used);
-        const ending = sink.pause && !sink.ended ? withEndSignal(String(prop), callArgs, sink.end.signal) : null;
+        const ending = sink.pause && !sink.ended && takesEndSignal(sink.testInfo?.config?.version) ? withEndSignal(String(prop), callArgs, sink.end.signal) : null;
         if (call && ending) call.endable = true;
         const alreadyProbed = callerLocation !== null && sink.probedLocations.has(callerLocation);
         let seq = -1;
@@ -20372,7 +21649,10 @@ function wrapLocator(page, locator, originMethod, originArgs) {
             alternatives: []
           });
         }
+        const early = !alreadyProbed && EARLY_READ_ACTIONS.has(prop) ? readElementSnapshot(sink, page, target, callerLocation, used) : null;
         let result;
+        const startedAt = Date.now();
+        const navigations = PAGE_NAVIGATIONS.get(page) ?? 0;
         try {
           result = await callMethod(target, prop, ending ?? callArgs);
         } catch (error) {
@@ -20385,7 +21665,8 @@ function wrapLocator(page, locator, originMethod, originArgs) {
         if (endsNow(sink)) throw skipOf(sink);
         if (!alreadyProbed && !call?.picked) {
           if (callerLocation) sink.probedLocations.add(callerLocation);
-          startElementCapture(sink, page, target, seq, callerLocation, used);
+          const earlyFirst = (PAGE_NAVIGATIONS.get(page) ?? 0) !== navigations || Date.now() - startedAt < EARLY_READ_TRUSTED_MS;
+          startElementCapture(sink, page, target, seq, callerLocation, used, early, earlyFirst);
         }
         return result;
       };
@@ -20447,7 +21728,7 @@ function instrumentPage(page) {
     page.close = async (...args) => {
       let closed = () => {
       };
-      CLOSING_PAGES.set(page, new Promise((resolve11) => closed = resolve11));
+      CLOSING_PAGES.set(page, new Promise((resolve12) => closed = resolve12));
       try {
         await settleBeforeClose({ page });
         return await originalClose(...args);
@@ -20475,10 +21756,14 @@ function instrumentPage(page) {
       };
     }
     if (typeof page.on === "function") {
+      page.on("domcontentloaded", () => readyProbeWorld(page));
       page.on("framenavigated", (frame) => {
         PROBE_UNSEEDED_PAGES.delete(page);
         try {
-          if (frame === page.mainFrame()) noteNavigation(page);
+          if (frame === page.mainFrame()) {
+            PAGE_NAVIGATIONS.set(page, (PAGE_NAVIGATIONS.get(page) ?? 0) + 1);
+            noteNavigation(page);
+          }
         } catch {
         }
       });
@@ -20759,8 +22044,8 @@ async function flushSink(sink, testInfo) {
   let drainDeadline;
   await Promise.race([
     Promise.allSettled(sink.capturePromises),
-    new Promise((resolve11) => {
-      drainDeadline = setTimeout(resolve11, 2e3);
+    new Promise((resolve12) => {
+      drainDeadline = setTimeout(resolve12, 2e3);
     })
   ]);
   clearTimeout(drainDeadline);
@@ -20967,7 +22252,7 @@ var runControl = {
       return;
     }
     if (!sink.pause) {
-      const why = sink.testInfo ? pauseSkipReason({ ...pauseGateFromTestInfo(sink.testInfo), channel: true }) : null;
+      const why = sink.testInfo ? pauseSkipReason({ ...pauseGateFromTestInfo(sink.testInfo, sink.headless), channel: true }) : null;
       tellHub({ type: "notice", message: `This test does not stop${why ? `: ${why}` : ""}.` });
       return;
     }
@@ -20989,7 +22274,7 @@ var runControl = {
   }
 };
 function runFile(file) {
-  return path32.relative(process.cwd(), file).split(path32.sep).join("/") || file;
+  return path33.relative(process.cwd(), file).split(path33.sep).join("/") || file;
 }
 function testBegin(testInfo, cannotPause) {
   const title = testInfo.titlePath.slice(1);
@@ -21029,6 +22314,7 @@ var piwiFixtures = {
       startResourceLedger(playwright, workerInfo.workerIndex);
       observeApiRequests(playwright, apiCallRecorder);
       openLiveView(workerInfo);
+      if (liveViewOpen()) trackCalls(playwright);
       if (await openRunChannel(workerInfo, runControl)) watchCalls(playwright);
       try {
         await use();
@@ -21066,17 +22352,18 @@ var piwiFixtures = {
   // (attach the collected data) at teardown. Runs for every test without being
   // requested, so suites that never destructure `page` are still captured.
   piwiCapture: [
-    async ({ screenshot, baseURL }, use, testInfo) => {
+    async ({ screenshot, baseURL, headless }, use, testInfo) => {
       boxCaptureFrames();
       const conflict = labModeConflict();
       if (conflict) throw new Error(conflict);
       const sink = createSink();
       sink.testInfo = testInfo;
       sink.baseURL = baseURL ?? null;
+      sink.headless = headless;
       if (keepsFailureScreenshots(screenshot, testInfo.retry)) sink.failureScreenshot = screenshot;
       const pauseSet = currentPauseSet();
       const channel = runChannelOpen();
-      const cannotPause = pauseSkipReason({ ...pauseGateFromTestInfo(testInfo), channel });
+      const cannotPause = pauseSkipReason({ ...pauseGateFromTestInfo(testInfo, headless), channel });
       if (pauseSet.size || channel) {
         if (!cannotPause) sink.pause = pauseState(pauseSet, pauseNextTest);
         else if (pauseSet.size) logPauseSkipOnce(cannotPause);
@@ -21108,7 +22395,7 @@ var piwiFixtures = {
         });
       activeResourceLedger()?.testStarted(testInfo);
       currentSink = sink;
-      liveViewTestBegan(testInfo.title, () => runningCall(testInfo));
+      liveViewTestBegan(testInfo.title, () => runningCall(testInfo), mayPause(pauseGateFromTestInfo(testInfo)));
       const showRunChannel = hideRunChannel();
       try {
         await armStops(OPEN_CONTEXTS);
@@ -21126,9 +22413,10 @@ var piwiFixtures = {
           const applied = sink.probeInterception?.applied() ?? false;
           const level = sink.probeItem.level ?? "client";
           const handled = level === "server" && applied ? classifyProbeHandled({
-            consoleErrors: sink.consoleEntries.filter((e) => e.type === "error").length,
+            consoleErrors: probeConsoleErrors(sink.consoleEntries),
             dialogs: sink.dialogs.length,
             backendError: sink.probeInterception?.serverError() ?? false,
+            faultIsTheError: faultIsTheError(sink.probeItem.fault),
             pageErrors: sink.probePageErrors,
             blankPage: sink.probeBlankPage
           }) : "n/a";
@@ -21183,13 +22471,13 @@ function extendPiwiFixtures(test) {
 }
 
 // src/internal/ai/ai-fixtures.ts
-var fs29 = __toESM(require("fs"));
-var path35 = __toESM(require("path"));
+var fs30 = __toESM(require("fs"));
+var path36 = __toESM(require("path"));
 var import_test = require("@playwright/test");
 
 // src/internal/ai/artifact.ts
-var fs28 = __toESM(require("fs"));
-var path33 = __toESM(require("path"));
+var fs29 = __toESM(require("fs"));
+var path34 = __toESM(require("path"));
 var ARTIFACT_VERSION = 1;
 var LOCATOR_METHOD_SET2 = new Set(LOCATOR_METHODS);
 var ACTION_METHOD_SET2 = new Set(ACTION_METHODS);
@@ -21282,7 +22570,7 @@ function parseEntry(text2) {
 function readEntry(file) {
   let text2;
   try {
-    text2 = fs28.readFileSync(file, "utf8");
+    text2 = fs29.readFileSync(file, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw error;
@@ -21292,28 +22580,28 @@ function readEntry(file) {
 function writeEntry(file, entry) {
   const canonical = serializeEntry(entry);
   return withEntryLock(file, () => {
-    if (fs28.existsSync(file) && fs28.readFileSync(file, "utf8") === canonical) return { written: false };
-    fs28.mkdirSync(path33.dirname(file), { recursive: true });
+    if (fs29.existsSync(file) && fs29.readFileSync(file, "utf8") === canonical) return { written: false };
+    fs29.mkdirSync(path34.dirname(file), { recursive: true });
     const tmp = `${file}.${process.pid}.tmp`;
-    fs28.writeFileSync(tmp, canonical);
-    fs28.renameSync(tmp, file);
+    fs29.writeFileSync(tmp, canonical);
+    fs29.renameSync(tmp, file);
     return { written: true };
   });
 }
 function withEntryLock(file, fn) {
   const lock = `${file}.lock`;
-  fs28.mkdirSync(path33.dirname(file), { recursive: true });
+  fs29.mkdirSync(path34.dirname(file), { recursive: true });
   const deadline = Date.now() + 5e3;
   for (; ; ) {
     try {
-      const fd = fs28.openSync(lock, "wx");
-      fs28.closeSync(fd);
+      const fd = fs29.openSync(lock, "wx");
+      fs29.closeSync(fd);
       break;
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
       if (Date.now() > deadline) {
         try {
-          fs28.unlinkSync(lock);
+          fs29.unlinkSync(lock);
         } catch {
         }
       }
@@ -21323,7 +22611,7 @@ function withEntryLock(file, fn) {
     return fn();
   } finally {
     try {
-      fs28.unlinkSync(lock);
+      fs29.unlinkSync(lock);
     } catch {
     }
   }
@@ -21331,7 +22619,7 @@ function withEntryLock(file, fn) {
 
 // src/internal/ai/keys.ts
 var crypto9 = __toESM(require("crypto"));
-var path34 = __toESM(require("path"));
+var path35 = __toESM(require("path"));
 var DEFAULT_AI_DIR = "__piwi__";
 function normalizeTemplate(template) {
   return template.trim().replace(/\s+/g, " ").toLowerCase();
@@ -21345,13 +22633,13 @@ function slug(text2, maxLength = 40) {
   return (base || "x").slice(0, maxLength).replace(/-+$/g, "") || "x";
 }
 function entryDir(specFile, dir = DEFAULT_AI_DIR) {
-  return path34.join(path34.dirname(specFile), dir, path34.basename(specFile));
+  return path35.join(path35.dirname(specFile), dir, path35.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 path34.join(entryDir(params.specFile, params.dir), name);
+  return path35.join(entryDir(params.specFile, params.dir), name);
 }
 function parseLocation2(location) {
   const match = /:(\d+):(\d+)$/.exec(location);
@@ -21668,9 +22956,8 @@ function compileFromCandidate(candidate) {
 var GROUNDED_METHODS = new Set(LOCATOR_METHODS.filter((method) => method !== "locator"));
 async function refLocator(page, ref) {
   if (!/^[a-z0-9]+$/i.test(ref)) return null;
-  const getByRef = page.getByRef;
   try {
-    const target = typeof getByRef === "function" ? getByRef.call(page, ref) : page.locator(`aria-ref=${ref}`);
+    const target = locatorOfRef(page, ref);
     return await target.count() === 1 ? target : null;
   } catch {
     return null;
@@ -21954,7 +23241,7 @@ function testIdentity(testInfo) {
   return titles.length > 0 ? titles.join(" \u203A ") : testInfo.title;
 }
 function relativeToCwd(file) {
-  return path35.relative(process.cwd(), file).split(path35.sep).join("/");
+  return path36.relative(process.cwd(), file).split(path36.sep).join("/");
 }
 function recordIntents(intents, entry) {
   const add2 = (locator, kind) => {
@@ -21981,7 +23268,7 @@ function createAiApi(page, testInfo, config, used, intents) {
   const readSource = () => {
     if (source === null) {
       try {
-        source = fs29.readFileSync(testInfo.file, "utf8");
+        source = fs30.readFileSync(testInfo.file, "utf8");
       } catch {
         source = "";
       }