@piwitests/reporter 0.58.0 → 0.60.0

package/dist/internal/capture/capture-fixtures.js

@@ -58,7 +58,7 @@ __export(capture_fixtures_exports, {
   stopResourceLedger: () => stopResourceLedger
 });
 module.exports = __toCommonJS(capture_fixtures_exports);
-var path12 = __toESM(require("path"));
+var path14 = __toESM(require("path"));
 var import_node_zlib2 = require("zlib");
 
 // ../picker-dom/src/probe.ts
@@ -412,10 +412,11 @@ function installPickerOverlay(arg) {
   }
   const Z = 2147483600;
   const testIdAttr = arg.testIdAttribute || "data-testid";
+  const enterReaches = arg.transport === "global";
   const words = {
     banner: "Piwi inspector \u2014 click any element to generate locators for it",
-    keys: "\u2191 parent \xB7 \u2193 child \xB7 Esc skip",
-    keysHovering: "click to pick \xB7 \u2191 parent \xB7 \u2193 child \xB7 Esc skip",
+    keys: enterReaches ? "Enter picks the focused element \xB7 \u2191 parent \xB7 \u2193 child \xB7 Esc skip" : "\u2191 parent \xB7 \u2193 child \xB7 Esc skip",
+    keysHovering: enterReaches ? "click or Enter to pick \xB7 \u2191 parent \xB7 \u2193 child \xB7 Esc skip" : "click to pick \xB7 \u2191 parent \xB7 \u2193 child \xB7 Esc skip",
     analyzing: "Analyzing element\u2026"
   };
   for (const key of Object.keys(words)) {
@@ -510,6 +511,16 @@ function installPickerOverlay(arg) {
     const cls = (el.getAttribute && el.getAttribute("class") || "").split(/\s+/).find((c) => c.length > 1);
     return cls ? `locator(${quoteJs(`.${cls}`)})` : tag;
   };
+  const parentOf = (node) => {
+    if (node.parentElement) return node.parentElement;
+    const root = node.getRootNode ? node.getRootNode() : null;
+    return root && root !== doc && root.host ? root.host : null;
+  };
+  const targetOf = (e) => {
+    const path15 = typeof e.composedPath === "function" ? e.composedPath() : null;
+    const first = path15 && path15.length ? path15[0] : null;
+    return first && first.nodeType === 1 ? first : e.target;
+  };
   const buildChain = (raw) => {
     const chain2 = [];
     let node = raw;
@@ -517,7 +528,7 @@ function installPickerOverlay(arg) {
       const tag = (node.tagName || "").toLowerCase();
       if (tag === "body" || tag === "html") break;
       chain2.push(node);
-      node = node.parentElement;
+      node = parentOf(node);
     }
     return chain2.length ? chain2 : [raw];
   };
@@ -608,10 +619,14 @@ function installPickerOverlay(arg) {
     }
   };
   const onMove = (e) => {
-    const raw = e.target;
+    const raw = targetOf(e);
     if (!raw || isOwn(raw)) {
+      chain = [];
+      idx = 0;
+      lastRaw = null;
       highlight.style.display = "none";
       label.style.display = "none";
+      foot.textContent = words.keys;
       return;
     }
     if (raw !== lastRaw) {
@@ -690,17 +705,30 @@ function installPickerOverlay(arg) {
   const onClick = (e) => {
     stop(e);
     const el = current();
-    if (!el || isOwn(e.target)) return;
+    if (!el || isOwn(targetOf(e))) return;
     reportPicked(el);
   };
+  const focused = () => {
+    let el = doc.activeElement;
+    while (el && el.shadowRoot && el.shadowRoot.activeElement) el = el.shadowRoot.activeElement;
+    const tag = (el && el.tagName || "").toLowerCase();
+    return !el || tag === "body" || tag === "html" || isOwn(el) ? null : el;
+  };
   const onKey = (e) => {
     if (e.key === "Escape") {
       stop(e);
       reportSkipped();
       return;
     }
+    if (e.key === "Enter" && !e.isComposing) {
+      stop(e);
+      const el = current() || focused();
+      if (el) reportPicked(el);
+      return;
+    }
     if (e.key === "ArrowUp" || e.key === "ArrowDown") {
       stop(e);
+      if (!chain.length) return;
       if (e.key === "ArrowUp") idx = Math.min(idx + 1, chain.length - 1);
       else idx = Math.max(idx - 1, 0);
       refresh();
@@ -774,12 +802,43 @@ function showAnchorPicker(arg) {
     const al = n.getAttribute && n.getAttribute("aria-level");
     return al && /^\d+$/.test(al) ? Number(al) : null;
   };
+  const parentOf = (n) => {
+    if (n.parentElement) return n.parentElement;
+    const root = n.getRootNode ? n.getRootNode() : null;
+    return root && root !== doc && root.host ? root.host : null;
+  };
+  const shadowRoots = [];
+  const collectRoots = (root) => {
+    const all = root.querySelectorAll("*");
+    for (let i = 0; i < all.length; i++) {
+      const sr = all[i].shadowRoot;
+      if (sr) {
+        shadowRoots.push(sr);
+        collectRoots(sr);
+      }
+    }
+  };
+  try {
+    collectRoots(doc);
+  } catch {
+    shadowRoots.length = 0;
+  }
+  const within = (node2, scope) => {
+    if (scope === doc) return true;
+    for (let n = node2; n; n = parentOf(n)) if (n === scope) return true;
+    return false;
+  };
+  const queryAll = (scope, sel) => {
+    const found = Array.from(scope.querySelectorAll(sel));
+    for (const sr of shadowRoots) if (within(sr.host, scope)) found.push(...Array.from(sr.querySelectorAll(sel)));
+    return found;
+  };
   const leafCountable = !!leafTestId || roleOf2(el) === leafRole;
   const leafMatches = (scope) => {
     try {
-      if (leafTestId) return scope.querySelectorAll(`[${testIdAttr}=${JSON.stringify(leafTestId)}]`).length;
+      if (leafTestId) return queryAll(scope, `[${testIdAttr}=${JSON.stringify(leafTestId)}]`).length;
       if (!leafCountable) return -1;
-      const nodes = scope.querySelectorAll(roleSources);
+      const nodes = queryAll(scope, roleSources);
       if (nodes.length > 2e3) return -1;
       let matched = 0;
       for (let i = 0; i < nodes.length; i++) {
@@ -795,20 +854,20 @@ function showAnchorPicker(arg) {
   };
   let roleNodes = [];
   try {
-    const all = doc.querySelectorAll(roleSources);
-    if (all.length <= 4e3) roleNodes = Array.from(all);
+    const all = queryAll(doc, roleSources);
+    if (all.length <= 4e3) roleNodes = all;
   } catch {
     roleNodes = [];
   }
   const count = (sel) => {
     try {
-      return doc.querySelectorAll(sel).length;
+      return queryAll(doc, sel).length;
     } catch {
       return void 0;
     }
   };
   const rows = [];
-  let node = el.parentElement;
+  let node = parentOf(el);
   let depth = 0;
   while (node && depth < 12) {
     depth++;
@@ -845,7 +904,7 @@ function showAnchorPicker(arg) {
       hookLabel,
       selectable: !!(testId || id || role && (ariaLabel || info.roleCount === 1))
     });
-    node = node.parentElement;
+    node = parentOf(node);
   }
   if (rows.length === 0) {
     g.__piwiAnchorState = "skipped";
@@ -874,9 +933,9 @@ function showAnchorPicker(arg) {
   footer.style.cssText = "margin:10px 0;font-weight:600;";
   const segMatches = (scope, info) => {
     try {
-      if (info.testId) return Array.from(scope.querySelectorAll(`[${testIdAttr}=${JSON.stringify(info.testId)}]`));
-      if (info.id) return Array.from(scope.querySelectorAll(`#${doc.defaultView.CSS.escape(info.id)}`));
-      const nodes = Array.from(scope.querySelectorAll(roleSources));
+      if (info.testId) return queryAll(scope, `[${testIdAttr}=${JSON.stringify(info.testId)}]`);
+      if (info.id) return queryAll(scope, `#${doc.defaultView.CSS.escape(info.id)}`);
+      const nodes = queryAll(scope, roleSources);
       if (nodes.length > 2e3) return [];
       return nodes.filter(
         (n) => roleOf2(n) === info.role && (!info.ariaLabel || n.getAttribute && n.getAttribute("aria-label") === info.ariaLabel)
@@ -1163,8 +1222,11 @@ function showPauseBar(arg) {
   };
   const buttons = [
     ["Resume", "resume", "Run on to the next breakpoint (Esc)", true],
-    ["Step", "step", "Pause again at the next action", false],
+    ["Step", "step", "Pause again before the next call", false],
     ["Pick a locator", "pick", "Pick an element on the page and confirm a locator for it", false],
+    ...arg.record ? [
+      ["Record here", "record", "Record steps in this page: the editor writes them before this line", false]
+    ] : [],
     ["Finish", "finish", "Run on and pause no more in this test", false]
   ];
   for (const [label, choice, hint, primary] of buttons) {
@@ -1926,21 +1988,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(path13) {
-  return typeof path13 === "string" && path13.length <= ELEMENT_PATH_MAX_CHARS && ELEMENT_PATH_RE.test(path13);
+function isElementPath(path15) {
+  return typeof path15 === "string" && path15.length <= ELEMENT_PATH_MAX_CHARS && ELEMENT_PATH_RE.test(path15);
 }
 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: path13, label } = v;
-  if (!isElementPath(path13)) return null;
-  return { path: path13, label: typeof label === "string" ? label.slice(0, ELEMENT_LABEL_MAX_CHARS) : "" };
+  const { path: path15, label } = v;
+  if (!isElementPath(path15)) return null;
+  return { path: path15, label: typeof label === "string" ? label.slice(0, ELEMENT_LABEL_MAX_CHARS) : "" };
 }
 function textPoint(v) {
   if (!v || typeof v !== "object") return null;
-  const { path: path13, offset } = v;
+  const { path: path15, offset } = v;
   const at = offsetOf(offset);
-  return isElementPath(path13) && at !== null ? { path: path13, offset: at } : null;
+  return isElementPath(path15) && at !== null ? { path: path15, offset: at } : null;
 }
 function sanitizePageInteraction(raw) {
   if (!raw || typeof raw !== "object") return {};
@@ -2346,7 +2408,8 @@ var ATTACHMENT_NAMES = {
   userPick: "piwi-user-pick",
   aiUsage: "piwi-ai-usage",
   aiMeta: "piwi-ai-meta",
-  resources: "piwi-resources"
+  resources: "piwi-resources",
+  pauses: "piwi-pauses"
 };
 var INTERNAL_ATTACHMENT_NAMES = new Set(Object.values(ATTACHMENT_NAMES));
 var LOCATOR_SUGGESTION_ANNOTATION = ATTACHMENT_NAMES.locatorSuggestion;
@@ -2580,13 +2643,19 @@ var LocatorPageLog = class {
 };
 
 // src/internal/probe/mode.ts
-var fs2 = __toESM(require("fs"));
+var fs3 = __toESM(require("fs"));
+
+// src/internal/config/env.ts
+var path3 = __toESM(require("path"));
 
 // src/internal/config/desktop.ts
 var fs = __toESM(require("fs"));
 var os = __toESM(require("os"));
 var path2 = __toESM(require("path"));
 
+// src/internal/config/dotenv.ts
+var fs2 = __toESM(require("fs"));
+
 // src/internal/config/env.ts
 var DEFAULTS = {
   projectName: "default-project",
@@ -2623,6 +2692,7 @@ var DEFAULTS = {
 };
 var PIWI_ENV_KEYS = {
   serverUrl: "PIWI_DASHBOARD_URL",
+  desktopApp: "PIWI_DESKTOP_APP",
   projectName: "PIWI_PROJECT_NAME",
   verbose: "PIWI_VERBOSE",
   apiKey: "PIWI_API_KEY",
@@ -2720,14 +2790,14 @@ var ENV_FALLBACK_SPECS = [
 ];
 
 // src/internal/support/test-paths.ts
-var path3 = __toESM(require("path"));
+var path4 = __toESM(require("path"));
 function configDirFromConfig(config) {
-  if (config?.configFile) return path3.dirname(config.configFile);
+  if (config?.configFile) return path4.dirname(config.configFile);
   if (config?.rootDir) return config.rootDir;
   return process.cwd();
 }
 function relativeTestPath(file, base) {
-  return path3.relative(base, file).split(path3.sep).join("/");
+  return path4.relative(base, file).split(path4.sep).join("/");
 }
 
 // src/internal/probe/plan.ts
@@ -2737,8 +2807,8 @@ function parseRouteKey(routeKey2) {
   return { method: routeKey2.slice(0, space).toUpperCase(), pattern: routeKey2.slice(space + 1) };
 }
 function patternToRegex(pattern) {
-  const path13 = pattern.split("?")[0] ?? pattern;
-  const escaped = path13.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:[A-Za-z0-9_]+/g, "[^/]+");
+  const path15 = pattern.split("?")[0] ?? pattern;
+  const escaped = path15.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:[A-Za-z0-9_]+/g, "[^/]+");
   return new RegExp(`^${escaped}$`);
 }
 function suitePathEqual(a, b) {
@@ -2761,13 +2831,13 @@ function matchProbeItem(plan, test) {
 function requestMatchesRoute(method, url, routeKey2) {
   const { method: rm, pattern } = parseRouteKey(routeKey2);
   if (rm && rm !== method.toUpperCase()) return false;
-  let path13;
+  let path15;
   try {
-    path13 = new URL(url).pathname;
+    path15 = new URL(url).pathname;
   } catch {
-    path13 = url.split("?")[0] ?? url;
+    path15 = url.split("?")[0] ?? url;
   }
-  return patternToRegex(pattern).test(path13);
+  return patternToRegex(pattern).test(path15);
 }
 function createProbeState() {
   return { navigated: false, matches: 0 };
@@ -2789,10 +2859,10 @@ function isProbeMode() {
 function loadPlan() {
   if (planCache !== void 0) return planCache;
   planCache = null;
-  const path13 = process.env[PIWI_PROBE_ENV.plan];
-  if (path13) {
+  const path15 = process.env[PIWI_PROBE_ENV.plan];
+  if (path15) {
     try {
-      planCache = JSON.parse(fs2.readFileSync(path13, "utf8"));
+      planCache = JSON.parse(fs3.readFileSync(path15, "utf8"));
     } catch {
       planCache = null;
     }
@@ -2816,10 +2886,10 @@ function outcomeFromStatus(status, applied) {
   return status === "failed" || status === "timedOut" || status === "interrupted" ? "noticed" : "not-noticed";
 }
 function recordProbeOutcome(line) {
-  const path13 = process.env[PIWI_PROBE_ENV.results];
-  if (!path13) return;
+  const path15 = process.env[PIWI_PROBE_ENV.results];
+  if (!path15) return;
   try {
-    fs2.appendFileSync(path13, `${JSON.stringify(line)}
+    fs3.appendFileSync(path15, `${JSON.stringify(line)}
 `);
   } catch {
   }
@@ -2949,7 +3019,7 @@ function originOf(url) {
     return null;
   }
 }
-var sleep = (ms) => new Promise((resolve3) => setTimeout(resolve3, Math.max(0, ms)));
+var sleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, Math.max(0, ms)));
 async function performRouteAction(route, action, startedAt) {
   switch (action.kind) {
     case "abort":
@@ -3060,7 +3130,7 @@ async function installProbeInterception(page, item) {
 }
 
 // src/internal/flake/mode.ts
-var fs3 = __toESM(require("fs"));
+var fs4 = __toESM(require("fs"));
 
 // ../core/src/error-parse.ts
 var ANSI_RE = new RegExp("\\u001B\\[[0-9;]*m", "g");
@@ -3371,7 +3441,7 @@ function loadFlakePlan() {
   if (planCache2 && planCache2.file === file) return planCache2.plan;
   let text;
   try {
-    text = fs3.readFileSync(file, "utf8");
+    text = fs4.readFileSync(file, "utf8");
   } catch (error) {
     throw new Error(`[Piwi Dashboard] Cannot read the flake plan ${file}: ${errorMessage(error)}`);
   }
@@ -3524,7 +3594,7 @@ function recordFlakeResult(line) {
   const file = process.env[PIWI_FLAKE_ENV.results]?.trim();
   if (!file) return;
   try {
-    fs3.appendFileSync(file, `${JSON.stringify(line)}
+    fs4.appendFileSync(file, `${JSON.stringify(line)}
 `);
   } catch {
   }
@@ -3590,13 +3660,13 @@ function normalizeFunctionRanges(ranges) {
 }
 function normalizeCoveragePath(raw) {
   if (typeof raw !== "string" || raw.length > MAX_PATH_LENGTH || raw.includes("\0")) return null;
-  const path13 = raw.replace(/\\/g, "/").replace(/^\.\//, "");
-  if (!path13 || path13.startsWith("../") || path13.startsWith("/") || /^[A-Za-z]:\//.test(path13)) return null;
-  if (/(^|\/)node_modules\//.test(path13)) return null;
-  return path13;
+  const path15 = raw.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (!path15 || path15.startsWith("../") || path15.startsWith("/") || /^[A-Za-z]:\//.test(path15)) return null;
+  if (/(^|\/)node_modules\//.test(path15)) return null;
+  return path15;
 }
-function fileEntry(path13, runtime, blob, functions = [], lines = []) {
-  const file = { path: path13, runtime };
+function fileEntry(path15, runtime, blob, functions = [], lines = []) {
+  const file = { path: path15, 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;
@@ -3615,11 +3685,11 @@ function sanitizeCoverage(raw) {
   const files = [];
   for (const item of raw.files) {
     if (!isRecord(item) || !isRuntime(item.runtime)) continue;
-    const path13 = normalizeCoveragePath(item.path);
-    if (path13 === null) continue;
+    const path15 = normalizeCoveragePath(item.path);
+    if (path15 === null) continue;
     const blob = typeof item.blob === "string" && BLOB_ID.test(item.blob) ? item.blob : void 0;
     files.push(
-      fileEntry(path13, item.runtime, blob, normalizeFunctionRanges(item.functions), normalizeLineRanges(item.lines))
+      fileEntry(path15, item.runtime, blob, normalizeFunctionRanges(item.functions), normalizeLineRanges(item.lines))
     );
   }
   const merged = mergeCoverage(captureOf(files, raw.incomplete === true));
@@ -4030,7 +4100,7 @@ function inspectionGateFromTestInfo(testInfo, enabled = process.env.PIWI_INSPECT
 }
 
 // src/internal/capture/pick-on-failure.ts
-var path4 = __toESM(require("path"));
+var path5 = __toESM(require("path"));
 function parseLeafLocatorExpression(rawExpr) {
   const leaf = parseLeafLocatorCall(rawExpr);
   return leaf ? { method: leaf.method, args: locatorCallValues(leaf) } : null;
@@ -4045,37 +4115,60 @@ ${err.stack ?? ""}`));
     const parsed2 = parseLeafLocatorExpression(header);
     if (!parsed2) continue;
     const loc = err.location;
-    const location = loc ? `${path4.relative(process.cwd(), loc.file).split(path4.sep).join("/")}:${loc.line}:${loc.column}` : null;
+    const location = loc ? `${path5.relative(process.cwd(), loc.file).split(path5.sep).join("/")}:${loc.line}:${loc.column}` : null;
     return { method: parsed2.method, args: parsed2.args, location };
   }
   return null;
 }
-async function cleanupPicker(page) {
+var PICK_ENDED = "__piwiPickEnded";
+async function cleanupPicker(page, ended = false) {
   try {
-    await page.evaluate(() => {
-      const g = globalThis;
-      if (typeof g.__piwiPickCleanup === "function") g.__piwiPickCleanup();
-      if (typeof g.__piwiAnchorCleanup === "function") g.__piwiAnchorCleanup();
-      delete g.__piwiPickCleanup;
-      delete g.__piwiAnchorCleanup;
-      delete g.__piwiPickState;
-      delete g.__piwiPickChoice;
-      delete g.__piwiPickedElement;
-      delete g.__piwiAnchorState;
-      delete g.__piwiPickAnchors;
-      delete g.__piwiPickChainCount;
-    });
+    await page.evaluate(
+      ([endedKey, unanswered]) => {
+        const g = globalThis;
+        if (typeof g.__piwiPickCleanup === "function") g.__piwiPickCleanup();
+        if (typeof g.__piwiAnchorCleanup === "function") g.__piwiAnchorCleanup();
+        delete g.__piwiPickCleanup;
+        delete g.__piwiAnchorCleanup;
+        delete g.__piwiPickState;
+        delete g.__piwiPickChoice;
+        delete g.__piwiPickedElement;
+        delete g.__piwiAnchorState;
+        delete g.__piwiPickAnchors;
+        delete g.__piwiPickChainCount;
+        if (unanswered) g[endedKey] = true;
+        else delete g[endedKey];
+      },
+      [PICK_ENDED, ended]
+    );
   } catch {
   }
 }
-async function pickLocator(page, probe, failing) {
+function unlessEnded(run, ended) {
+  if (!ended) return run;
+  return Promise.race([
+    run,
+    new Promise((resolve5) => {
+      if (ended.aborted) resolve5(void 0);
+      else ended.addEventListener("abort", () => resolve5(void 0), { once: true });
+    })
+  ]);
+}
+async function pickLocator(page, probe, failing, ended) {
+  const answered = async (name) => {
+    const wait = page.waitForFunction(
+      ([key, endedKey]) => globalThis[key] !== void 0 || globalThis[endedKey] === true,
+      [name, PICK_ENDED],
+      { timeout: 0, polling: 250 }
+    );
+    await unlessEnded(wait, ended);
+    return !ended?.aborted;
+  };
   try {
     const overlayArg = { transport: "global", failing };
+    await page.evaluate((endedKey) => delete globalThis[endedKey], PICK_ENDED);
     await page.evaluate(installPickerOverlay, overlayArg);
-    await page.waitForFunction(() => globalThis.__piwiPickState !== void 0, void 0, {
-      timeout: 0,
-      polling: 250
-    });
+    if (!await answered("__piwiPickState")) return null;
     const state = await page.evaluate(() => globalThis.__piwiPickState);
     if (state !== "picked") return null;
     const handle = await page.evaluateHandle(() => globalThis.__piwiPickedElement);
@@ -4096,10 +4189,7 @@ async function pickLocator(page, probe, failing) {
         leafLevel: level,
         leafTestId: attrs.attributes["data-testid"] ?? null
       });
-      await page.waitForFunction(() => globalThis.__piwiAnchorState !== void 0, void 0, {
-        timeout: 0,
-        polling: 250
-      });
+      if (!await answered("__piwiAnchorState")) return null;
       const anchorResult = await page.evaluate(() => {
         const g = globalThis;
         return { state: g.__piwiAnchorState, anchors: g.__piwiPickAnchors ?? [], chainCount: g.__piwiPickChainCount };
@@ -4121,10 +4211,7 @@ async function pickLocator(page, probe, failing) {
       failing,
       choices: ranked.map((r) => ({ locator: r.locator, score: r.score }))
     });
-    await page.waitForFunction(() => globalThis.__piwiPickChoice !== void 0, void 0, {
-      timeout: 0,
-      polling: 250
-    });
+    if (!await answered("__piwiPickChoice")) return null;
     const choice = await page.evaluate(() => globalThis.__piwiPickChoice);
     if (typeof choice !== "number" || choice < 0 || choice >= ranked.length) return null;
     const picked = { ...ranked[choice], pickedByUser: true };
@@ -4143,7 +4230,7 @@ async function pickLocator(page, probe, failing) {
       ...anchors.length > 0 ? { anchors } : {}
     };
   } finally {
-    await cleanupPicker(page);
+    await cleanupPicker(page, ended?.aborted);
   }
 }
 async function runLocatorPicker(page, testInfo, failed, probe) {
@@ -4198,7 +4285,7 @@ function applyPickToSnapshots(snapshots, pick) {
 }
 
 // src/internal/capture/pause-at.ts
-var path5 = __toESM(require("path"));
+var path8 = __toESM(require("path"));
 
 // ../core/src/editor-send.ts
 var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]"]);
@@ -4224,6 +4311,93 @@ function isInsidePath(file) {
   return file.split(/[\\/]/).every((part) => part !== "..");
 }
 
+// src/internal/capture/quiet-capture.ts
+var import_node_module = require("module");
+var path7 = __toESM(require("path"));
+
+// src/internal/support/reporter-version.ts
+var fs5 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
+var CANDIDATE_OFFSETS = ["..", "../../.."];
+function findOwnPackageJson(fromDir) {
+  for (const offset of CANDIDATE_OFFSETS) {
+    try {
+      const pkgPath = path6.resolve(fromDir, offset, "package.json");
+      const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
+      const { name, version } = pkg;
+      if (name === "@piwitests/reporter" && typeof version === "string")
+        return { version, root: path6.dirname(pkgPath) };
+    } catch {
+    }
+  }
+  return void 0;
+}
+
+// src/internal/capture/quiet-capture.ts
+var BOXED_PREFIX_EXPORTS = [
+  [
+    "playwright-core/lib/coreBundle",
+    (mod) => mod?.utils?.setBoxedStackPrefixes
+  ],
+  ["playwright-core/lib/utils", (mod) => mod?.setBoxedStackPrefixes]
+];
+var boxing;
+var resolvedPlaywrightPackageJson;
+function resolvePlaywrightPackageJson() {
+  if (resolvedPlaywrightPackageJson !== void 0) return resolvedPlaywrightPackageJson;
+  try {
+    const testPackageJson = (0, import_node_module.createRequire)(__filename).resolve("@playwright/test/package.json");
+    resolvedPlaywrightPackageJson = (0, import_node_module.createRequire)(testPackageJson).resolve("playwright/package.json");
+  } catch {
+    resolvedPlaywrightPackageJson = null;
+  }
+  return resolvedPlaywrightPackageJson;
+}
+function resolveBoxing() {
+  try {
+    const root = findOwnPackageJson(__dirname)?.root;
+    if (!root) return null;
+    const playwrightPackageJson = resolvePlaywrightPackageJson();
+    if (!playwrightPackageJson) return null;
+    const requireFromPlaywright = (0, import_node_module.createRequire)(playwrightPackageJson);
+    for (const [moduleId, pick] of BOXED_PREFIX_EXPORTS) {
+      let set;
+      try {
+        set = pick(requireFromPlaywright(moduleId));
+      } catch {
+        continue;
+      }
+      if (typeof set !== "function") continue;
+      return {
+        set,
+        prefixes: [path7.dirname(playwrightPackageJson), path7.join(root, "dist") + path7.sep]
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+function boxCaptureFrames(extraPrefixes = []) {
+  const first = boxing === void 0;
+  if (first) boxing = resolveBoxing();
+  if (!boxing) return;
+  const added = extraPrefixes.filter((prefix) => !boxing.prefixes.includes(prefix));
+  if (!first && added.length === 0) return;
+  boxing.prefixes.push(...added);
+  try {
+    boxing.set([...boxing.prefixes]);
+  } catch {
+  }
+}
+function callMethod(target, prop, args) {
+  return target[prop](...args);
+}
+function internalCall(owner, run) {
+  const wrap = owner?._wrapApiCall;
+  if (typeof wrap !== "function") return run();
+  return wrap.call(owner, run, { internal: true, title: "Piwi capture" });
+}
+
 // src/internal/capture/pause-at.ts
 var PauseSet = class {
   constructor(lines) {
@@ -4239,18 +4413,32 @@ var PauseSet = class {
     return col > 0 && this.lines.has(callerLocation.slice(0, col));
   }
 };
-var EMPTY = new PauseSet(/* @__PURE__ */ new Set());
+var NO_BREAKPOINTS = new PauseSet(/* @__PURE__ */ new Set());
 function callSiteFile(file, cwd) {
   const slashed = file.replace(/\\/g, "/");
-  const absolute = path5.isAbsolute(file) || path5.isAbsolute(slashed) || /^[A-Za-z]:\//.test(slashed);
-  let rel = absolute ? path5.relative(cwd, file) : path5.normalize(slashed);
-  rel = rel.split(path5.sep).join("/").replace(/\\/g, "/");
+  const absolute = path8.isAbsolute(file) || path8.isAbsolute(slashed) || /^[A-Za-z]:\//.test(slashed);
+  let rel = absolute ? path8.relative(cwd, file) : path8.normalize(slashed);
+  rel = rel.split(path8.sep).join("/").replace(/\\/g, "/");
   if (rel.startsWith("./")) rel = rel.slice(2);
   return rel;
 }
+function stopCallSite(location, cwd = process.cwd()) {
+  if (!location.line) return null;
+  return `${callSiteFile(location.file, cwd)}:${location.line}:${location.column ?? 0}`;
+}
+function callSiteLine(callSite) {
+  const col = callSite.lastIndexOf(":");
+  return col > 0 ? callSite.slice(0, col) : callSite;
+}
+function inFlightCallSite(inFlight) {
+  const [first] = inFlight;
+  if (first === void 0) return null;
+  const line = callSiteLine(first);
+  return inFlight.every((site) => callSiteLine(site) === line) ? first : null;
+}
 var ignoredLogged = /* @__PURE__ */ new Set();
 function parsePauseAt(value, cwd = process.cwd()) {
-  if (!value?.trim()) return EMPTY;
+  if (!value?.trim()) return NO_BREAKPOINTS;
   const lines = /* @__PURE__ */ new Set();
   for (const raw of value.split(";")) {
     const entry = raw.trim();
@@ -4266,7 +4454,7 @@ function parsePauseAt(value, cwd = process.cwd()) {
     }
     lines.add(`${callSiteFile(m[1], cwd)}:${line}`);
   }
-  return lines.size ? new PauseSet(lines) : EMPTY;
+  return lines.size ? new PauseSet(lines) : NO_BREAKPOINTS;
 }
 var parsed = null;
 function currentPauseSet() {
@@ -4276,27 +4464,121 @@ function currentPauseSet() {
 }
 function pauseGateFromTestInfo(testInfo) {
   const use = testInfo.project?.use ?? {};
-  return { ci: process.env.CI, headless: use.headless };
+  const debug = testInfo._configInternal?.configCLIOverrides?.debug;
+  return { ci: process.env.CI, headless: use.headless, pwdebug: process.env.PWDEBUG, debug };
 }
 function pauseSkipReason(gate) {
   if (isCi(gate.ci)) return "running under CI \u2014 breakpoints pause local runs only";
   if (gate.headless !== false)
     return "the browser is headless \u2014 re-run with --headed (or set use: { headless: false })";
+  if (gate.pwdebug && !["0", "false", "console"].includes(gate.pwdebug))
+    return "Playwright's Inspector runs the test (PWDEBUG) \u2014 run without --debug";
+  if (typeof gate.debug === "string" && gate.debug)
+    return `Playwright's debugger runs the test (--debug=${gate.debug}) \u2014 run without --debug`;
   return null;
 }
-function rearmedTimeout(before, pausedMs) {
-  return before > 0 ? before + Math.max(0, Math.round(pausedMs)) : 0;
+function atStop(state, callSite) {
+  if (callSite && !state.finished) {
+    if (state.step) {
+      state.step = false;
+      return { show: "step" };
+    }
+    if (state.set.matches(callSite)) return { show: "breakpoint" };
+  }
+  return { go: goOn(state) };
+}
+function goOn(state, answer) {
+  if (answer === "step") state.step = true;
+  else if (answer === "finish") state.finished = true;
+  return !state.finished && (state.step || state.set.size > 0) ? "next" : "resume";
+}
+function contextDebugger(context) {
+  const dbg = context.debugger;
+  return typeof dbg?.requestPause === "function" && typeof dbg.on === "function" ? dbg : null;
+}
+var WATCHED = /* @__PURE__ */ new WeakSet();
+function watchStops(context, onStop) {
+  const dbg = contextDebugger(context);
+  if (!dbg) return false;
+  if (WATCHED.has(context)) return true;
+  WATCHED.add(context);
+  inspectorSwitch.watching = true;
+  syncInspectorSwitch();
+  dbg.on("pausedstatechanged", () => onStop(context));
+  return true;
+}
+var NO_INSPECTOR_ENV = "PW_CODEGEN_NO_INSPECTOR";
+var inspectorSwitch = {
+  /** Set by Piwi, so Piwi's to clear. */
+  set: false,
+  /** Piwi answers the stops of a context in this worker. */
+  watching: false,
+  /** Every `page.pause()` of the worker's Playwright reaches it through Piwi (`markPausesWrapped`). */
+  wrapped: false,
+  /** The `page.pause()` calls left to Playwright that are running (`withInspector`). */
+  open: 0
+};
+function syncInspectorSwitch() {
+  const closed = inspectorSwitch.watching && inspectorSwitch.wrapped && inspectorSwitch.open === 0;
+  if (closed && process.env[NO_INSPECTOR_ENV] === void 0) {
+    process.env[NO_INSPECTOR_ENV] = "1";
+    inspectorSwitch.set = true;
+  } else if (!closed && inspectorSwitch.set) {
+    if (process.env[NO_INSPECTOR_ENV] === "1") delete process.env[NO_INSPECTOR_ENV];
+    inspectorSwitch.set = false;
+  }
+}
+function markPausesWrapped() {
+  inspectorSwitch.wrapped = true;
+  syncInspectorSwitch();
+}
+async function withInspector(run) {
+  inspectorSwitch.open++;
+  syncInspectorSwitch();
+  try {
+    return await run();
+  } finally {
+    inspectorSwitch.open--;
+    syncInspectorSwitch();
+  }
+}
+async function steerDebugger(context, how) {
+  const dbg = contextDebugger(context);
+  if (!dbg) return;
+  try {
+    await internalCall(
+      context,
+      () => how === "pause" ? dbg.requestPause() : how === "next" ? dbg.next() : dbg.resume()
+    );
+  } catch {
+  }
+}
+async function withTestTimeoutHeld(testInfo, run) {
+  const set = testInfo._setIgnoreTimeouts;
+  if (typeof set !== "function") return run();
+  set.call(testInfo, true);
+  try {
+    return await run();
+  } finally {
+    set.call(testInfo, false);
+  }
+}
+function testTimeSlot(testInfo) {
+  try {
+    const slot = testInfo._timeoutManager?.defaultSlot?.();
+    return slot && typeof slot.elapsed === "number" ? slot : null;
+  } catch {
+    return null;
+  }
+}
+function restoreTestTime(testInfo, heldAt) {
+  const slot = testTimeSlot(testInfo);
+  if (slot && Number.isFinite(heldAt) && heldAt >= 0 && heldAt < slot.elapsed) slot.elapsed = heldAt;
 }
 function pausePlace(callerLocation) {
-  const col = callerLocation.lastIndexOf(":");
-  const fileLine = col > 0 ? callerLocation.slice(0, col) : callerLocation;
+  const fileLine = callSiteLine(callerLocation);
   return fileLine.slice(fileLine.lastIndexOf("/") + 1);
 }
-function assertionLabel(expression, isNot) {
-  const [first = "", ...rest] = expression.split(".").filter(Boolean);
-  const name = first + rest.map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
-  return `${isNot ? "not." : ""}${name || "expect"}`;
-}
 function pickPlace(callerLocation) {
   const m = /^(.+):(\d+):\d+$/.exec(callerLocation);
   if (!m) return null;
@@ -4341,59 +4623,312 @@ function logPauseSkipOnce(reason) {
   skipLogged = true;
   console.log(`[piwi] ${PIWI_LOCAL_DEBUG_ENV.pauseAt} is set but breakpoints are skipped: ${reason}`);
 }
+var NAVIGATED = /Execution context was destroyed|Cannot find context with specified id/;
+var MAX_NAVIGATED = 10;
 var HIGHLIGHT_MS = 2e3;
-async function pauseHere(page, testInfo, point, probe, onPick) {
-  const before = testInfo.timeout;
-  const started = Date.now();
+async function pauseHere(page, point, probe, onPick, onRecord, ended) {
   let shown = null;
   try {
-    testInfo.setTimeout(0);
     const highlight = point.target?.highlight;
     if (typeof highlight === "function") {
       let timer;
       shown = await Promise.race([
         Promise.resolve().then(() => highlight.call(point.target)).catch(() => null),
-        new Promise((resolve3) => {
-          timer = setTimeout(() => resolve3(null), HIGHLIGHT_MS);
+        new Promise((resolve5) => {
+          timer = setTimeout(() => resolve5(null), HIGHLIGHT_MS);
         })
       ]);
       clearTimeout(timer);
     }
     const arg = {
       place: pausePlace(point.location),
-      attempt: testInfo.retry > 0 ? testInfo.retry + 1 : null,
-      action: point.action,
-      locator: point.locator
+      attempt: point.attempt,
+      action: point.call,
+      locator: null,
+      record: !!onRecord
     };
     console.log(
-      `[piwi] Paused at ${point.location} before ${point.locator ? `${point.action} \xB7 ${point.locator}` : point.action}: Resume, Step, Pick a locator or Finish in the browser (Esc resumes).`
+      `[piwi] Paused at ${callSiteLine(point.location)} before ${point.call}: Resume, Step, Pick a locator${onRecord ? ", Record here" : ""} or Finish in the browser (Esc resumes).`
     );
+    let navigated = 0;
     for (; ; ) {
-      await page.evaluate(showPauseBar, arg);
-      await page.waitForFunction(pauseAnswered, void 0, { timeout: 0, polling: 250 });
-      const choice = await page.evaluate(takePauseState);
-      if (choice === "resume" || choice === "step" || choice === "finish") return choice;
-      if (choice !== "pick") continue;
-      const picked = await pickLocator(page, probe, null).catch(() => null);
-      if (picked) await onPick(picked);
+      try {
+        if (ended?.aborted) return "resume";
+        await page.evaluate(showPauseBar, arg);
+        await unlessEnded(page.waitForFunction(pauseAnswered, void 0, { timeout: 0, polling: 250 }), ended);
+        if (ended?.aborted) return "resume";
+        const choice = await page.evaluate(takePauseState);
+        navigated = 0;
+        if (choice === "resume" || choice === "step" || choice === "finish") return choice;
+        if (choice === "record" && onRecord) {
+          await unlessEnded(
+            onRecord(ended).catch(() => void 0),
+            ended
+          );
+          continue;
+        }
+        if (choice !== "pick") continue;
+        const picked = await pickLocator(page, probe, null, ended).catch(() => null);
+        if (picked && !ended?.aborted) await onPick(picked);
+      } catch (error) {
+        if (page.isClosed() || !NAVIGATED.test(String(error)) || ++navigated > MAX_NAVIGATED) throw error;
+        await page.waitForLoadState("domcontentloaded").catch(() => void 0);
+      }
     }
   } catch {
     return "resume";
   } finally {
     try {
+      if (ended?.aborted) await page.evaluate(takePauseState);
       const dispose = shown?.dispose;
       const hide = page.hideHighlight;
       if (typeof dispose === "function") await dispose.call(shown);
       else if (typeof hide === "function") await hide.call(page);
     } catch {
     }
-    try {
-      testInfo.setTimeout(rearmedTimeout(before, Date.now() - started));
-    } catch {
-    }
   }
 }
 
+// src/internal/capture/record-handoff.ts
+var fs6 = __toESM(require("fs"));
+var net = __toESM(require("net"));
+var path9 = __toESM(require("path"));
+
+// ../core/src/ide-recorder.ts
+var IDE_RECORDER_BINDING = "__piwiRecorder";
+var IDE_DISPATCH_GLOBAL = "__piwiIdeDispatch";
+var RECORD_CHANNEL_ENV = "PIWI_RECORD_CHANNEL";
+var MAX_HANDOFF_LINE = 64e6;
+function parseRecordChannel(value) {
+  const text = value?.trim() ?? "";
+  const hash = text.lastIndexOf("#");
+  if (hash <= 0) return null;
+  const token = text.slice(hash + 1);
+  const path15 = text.slice(0, hash);
+  return /^[A-Za-z0-9_-]{16,}$/.test(token) && !path15.includes("\0") ? { path: path15, token } : null;
+}
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseHandoffToTest(line) {
+  let value;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!isObject2(value)) return null;
+  switch (value.type) {
+    case "refused":
+      return typeof value.message === "string" ? { type: "refused", message: value.message } : null;
+    case "load":
+      return typeof value.bundle === "string" && value.bundle ? { type: "load", bundle: value.bundle } : null;
+    case "answer":
+      return typeof value.call === "number" ? { type: "answer", call: value.call, value: value.value } : null;
+    case "dispatch":
+      return { type: "dispatch", message: value.message };
+    case "stop":
+      return { type: "stop" };
+    default:
+      return null;
+  }
+}
+function lineReader(onLine, onOverflow) {
+  let buffered = "";
+  return (chunk) => {
+    buffered += chunk;
+    for (let end = buffered.indexOf("\n"); end >= 0; end = buffered.indexOf("\n")) {
+      const line = buffered.slice(0, end);
+      buffered = buffered.slice(end + 1);
+      if (line.trim()) onLine(line);
+    }
+    if (buffered.length > MAX_HANDOFF_LINE) {
+      buffered = "";
+      onOverflow();
+    }
+  };
+}
+
+// src/internal/capture/record-handoff.ts
+var START_WAIT_MS = 6e4;
+var NEW_TAB_NOTICE = "A new tab opened: what you do there is not recorded yet. Record in the first tab.";
+var relays = /* @__PURE__ */ new WeakMap();
+function idleAnswer(payload) {
+  const request = payload ?? {};
+  if (request.kind === "local-get") return {};
+  if (request.kind !== "message") return null;
+  if (request.message?.type === "piwi-ping") return { ok: true };
+  if (request.message?.type === "piwi-session-storage") {
+    return request.message.op === "get" ? { ok: true, items: {} } : { ok: true };
+  }
+  return { ok: false, error: "No recording runs in this page." };
+}
+function canRecordFromHere(channel = process.env[RECORD_CHANNEL_ENV]) {
+  return parseRecordChannel(channel) !== null;
+}
+function handoffPlace(location, cwd = process.cwd()) {
+  const m = /^(.+):(\d+):\d+$/.exec(location);
+  if (!m) return null;
+  return { file: path9.resolve(cwd, m[1]), line: Number(m[2]) };
+}
+async function recordFromHere(options) {
+  const channel = parseRecordChannel(options.channel ?? process.env[RECORD_CHANNEL_ENV]);
+  const place = handoffPlace(options.location);
+  if (!channel || !place) return "this run names no editor to record into.";
+  const { page, testInfo, ended } = options;
+  if (ended?.aborted) return "the test ended.";
+  const use = testInfo.project?.use ?? {};
+  const context = page.context();
+  return new Promise((resolve5) => {
+    const socket = net.connect(channel.path);
+    socket.setEncoding("utf8");
+    const answers = /* @__PURE__ */ new Map();
+    let calls = 0;
+    let attached = false;
+    let recording = false;
+    let settled = false;
+    let initScript;
+    const send = (message) => {
+      if (!socket.destroyed) socket.write(`${JSON.stringify(message)}
+`);
+    };
+    const onPage = () => send({ type: "notice", message: NEW_TAB_NOTICE });
+    const onGone = () => {
+      if (attached) send({ type: "closed" });
+      finish("the page closed.");
+    };
+    const onEnded = () => {
+      try {
+        if (recording) {
+          void internalCall(
+            page,
+            () => page.evaluate(
+              ([name, value]) => {
+                const dispatch = globalThis[name];
+                if (typeof dispatch === "function") dispatch(value);
+              },
+              [IDE_DISPATCH_GLOBAL, { type: "piwi-recording-stopped" }]
+            )
+          ).catch(() => void 0);
+        }
+        if (attached) send({ type: "closed" });
+        finish("the test ended.");
+      } catch {
+      }
+    };
+    page.once("close", onGone);
+    page.once("crash", onGone);
+    ended?.addEventListener("abort", onEnded, { once: true });
+    const startWait = setTimeout(() => finish("the editor did not start the recording."), START_WAIT_MS);
+    const release = () => {
+      const relay = relays.get(context);
+      if (relay && relay.recording === relayed) relay.recording = null;
+      void Promise.resolve(initScript?.dispose?.()).catch(() => void 0);
+      initScript = void 0;
+    };
+    const finish = (said) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(startWait);
+      release();
+      for (const [call, answer] of answers) {
+        answers.delete(call);
+        answer(null);
+      }
+      context.off("page", onPage);
+      page.off("close", onGone);
+      page.off("crash", onGone);
+      ended?.removeEventListener("abort", onEnded);
+      socket.end();
+      resolve5(recording ? null : said);
+    };
+    const relayed = (source, payload) => new Promise((answer) => {
+      const call = ++calls;
+      answers.set(call, answer);
+      const outside = source.page !== page || source.frame !== page.mainFrame();
+      send({ type: "binding", call, outside, payload });
+    });
+    const load = async (bundle) => {
+      if (!/^https?:/i.test(page.url())) {
+        const why = `the recorder records http(s) pages only, and this page is ${page.url() || "blank"}.`;
+        send({ type: "notice", message: `Nothing can be recorded here: ${why}` });
+        finish(why);
+        return;
+      }
+      let relay = relays.get(context);
+      if (!relay) {
+        const created = { recording: null, lingering: false };
+        await context.exposeBinding(
+          IDE_RECORDER_BINDING,
+          (source, payload) => created.recording ? created.recording(source, payload) : idleAnswer(payload)
+        );
+        relays.set(context, created);
+        relay = created;
+      }
+      if (settled) return;
+      relay.recording = relayed;
+      if (!relay.lingering) {
+        initScript = await context.addInitScript({ path: bundle });
+        if (typeof initScript?.dispose !== "function") relay.lingering = true;
+      }
+      if (settled) return release();
+      await page.evaluate(fs6.readFileSync(bundle, "utf-8"));
+      if (settled) return release();
+      recording = true;
+      clearTimeout(startWait);
+      context.on("page", onPage);
+      send({ type: "loaded" });
+    };
+    socket.on("connect", () => {
+      attached = true;
+      send({
+        type: "attach",
+        token: channel.token,
+        file: place.file,
+        line: place.line,
+        reason: options.reason,
+        testIdAttribute: typeof use.testIdAttribute === "string" ? use.testIdAttribute : null,
+        baseURL: typeof use.baseURL === "string" ? use.baseURL : null
+      });
+    });
+    socket.on(
+      "data",
+      lineReader(
+        (line) => {
+          const message = parseHandoffToTest(line);
+          if (!message || settled) return;
+          switch (message.type) {
+            case "refused":
+              return finish(message.message);
+            case "load":
+              return void load(message.bundle).catch(
+                (error) => finish(`the recorder could not be loaded: ${error instanceof Error ? error.message : String(error)}`)
+              );
+            case "answer": {
+              const answer = answers.get(message.call);
+              answers.delete(message.call);
+              return answer?.(message.value);
+            }
+            case "dispatch":
+              return void page.evaluate(
+                ([name, value]) => {
+                  const dispatch = globalThis[name];
+                  if (typeof dispatch === "function") dispatch(value);
+                },
+                [IDE_DISPATCH_GLOBAL, message.message]
+              ).catch(() => void 0);
+            case "stop":
+              return finish(null);
+          }
+        },
+        () => finish("the editor sent a message too long to read.")
+      )
+    );
+    socket.on("error", (error) => finish(`the editor could not be reached: ${error.message}`));
+    socket.on("close", () => finish("the editor closed the recording."));
+  });
+}
+
 // src/internal/collect/coverage-settings.ts
 var SERVER_VALUES = /* @__PURE__ */ new Set(["files", "functions", "lines"]);
 function isServerGranularity(value) {
@@ -4409,7 +4944,7 @@ function browserFunctionsInWorker() {
 function browserFunctionCoverage(files) {
   return sanitizeCoverage({
     v: 1,
-    files: [...files].map(([path13, functions]) => ({ path: path13, runtime: "browser", functions }))
+    files: [...files].map(([path15, functions]) => ({ path: path15, runtime: "browser", functions }))
   });
 }
 function newKnownFunctions(known, sent) {
@@ -4422,19 +4957,19 @@ function newKnownFunctions(known, sent) {
     budget = MAX_COVERAGE_RANGES;
   };
   for (const [raw, ranges] of known) {
-    const path13 = normalizeCoveragePath(raw);
-    if (path13 === null) continue;
-    let named = sent.get(path13);
+    const path15 = normalizeCoveragePath(raw);
+    if (path15 === null) continue;
+    let named = sent.get(path15);
     let fresh = normalizeFunctionRanges(ranges).filter((range) => !named?.has(`${range[0]}:${range[1]}`));
     if (fresh.length === 0) continue;
-    if (!named) sent.set(path13, named = /* @__PURE__ */ new Set());
+    if (!named) sent.set(path15, 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: path13, allFunctions: part });
+      files.push({ path: path15, allFunctions: part });
     }
   }
   close();
@@ -4445,9 +4980,9 @@ function serverCoverageInWorker() {
 }
 
 // src/internal/support/aria-sampling.ts
-var path6 = __toESM(require("path"));
+var path10 = __toESM(require("path"));
 var os3 = __toESM(require("os"));
-var fs4 = __toESM(require("fs"));
+var fs7 = __toESM(require("fs"));
 
 // src/internal/support/instance-id.ts
 var crypto = __toESM(require("crypto"));
@@ -4461,14 +4996,14 @@ function ariaSampleIdentity(filePath, title) {
   return `${filePath}\0${title}`;
 }
 function getAriaSampleFilePath(projectName) {
-  return path6.join(os3.tmpdir(), `piwi-dashboard-aria-sample-${hashForProject(projectName)}.json`);
+  return path10.join(os3.tmpdir(), `piwi-dashboard-aria-sample-${hashForProject(projectName)}.json`);
 }
 var cachedSets = /* @__PURE__ */ new Map();
 function loadAriaSampleSet(projectName) {
   if (cachedSets.has(projectName)) return cachedSets.get(projectName);
   let set = null;
   try {
-    const raw = fs4.readFileSync(getAriaSampleFilePath(projectName), "utf8");
+    const raw = fs7.readFileSync(getAriaSampleFilePath(projectName), "utf8");
     const parsed2 = JSON.parse(raw);
     if (parsed2.projectName === projectName && Array.isArray(parsed2.identities)) {
       set = new Set(parsed2.identities.filter((x) => typeof x === "string"));
@@ -4489,97 +5024,10 @@ function isDueForAriaSample(testInfo) {
   );
 }
 
-// src/internal/capture/quiet-capture.ts
-var import_node_module = require("module");
-var path8 = __toESM(require("path"));
-
-// src/internal/support/reporter-version.ts
-var fs5 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
-var CANDIDATE_OFFSETS = ["..", "../../.."];
-function findOwnPackageJson(fromDir) {
-  for (const offset of CANDIDATE_OFFSETS) {
-    try {
-      const pkgPath = path7.resolve(fromDir, offset, "package.json");
-      const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
-      const { name, version } = pkg;
-      if (name === "@piwitests/reporter" && typeof version === "string")
-        return { version, root: path7.dirname(pkgPath) };
-    } catch {
-    }
-  }
-  return void 0;
-}
-
-// src/internal/capture/quiet-capture.ts
-var BOXED_PREFIX_EXPORTS = [
-  [
-    "playwright-core/lib/coreBundle",
-    (mod) => mod?.utils?.setBoxedStackPrefixes
-  ],
-  ["playwright-core/lib/utils", (mod) => mod?.setBoxedStackPrefixes]
-];
-var boxing;
-var resolvedPlaywrightPackageJson;
-function resolvePlaywrightPackageJson() {
-  if (resolvedPlaywrightPackageJson !== void 0) return resolvedPlaywrightPackageJson;
-  try {
-    const testPackageJson = (0, import_node_module.createRequire)(__filename).resolve("@playwright/test/package.json");
-    resolvedPlaywrightPackageJson = (0, import_node_module.createRequire)(testPackageJson).resolve("playwright/package.json");
-  } catch {
-    resolvedPlaywrightPackageJson = null;
-  }
-  return resolvedPlaywrightPackageJson;
-}
-function resolveBoxing() {
-  try {
-    const root = findOwnPackageJson(__dirname)?.root;
-    if (!root) return null;
-    const playwrightPackageJson = resolvePlaywrightPackageJson();
-    if (!playwrightPackageJson) return null;
-    const requireFromPlaywright = (0, import_node_module.createRequire)(playwrightPackageJson);
-    for (const [moduleId, pick] of BOXED_PREFIX_EXPORTS) {
-      let set;
-      try {
-        set = pick(requireFromPlaywright(moduleId));
-      } catch {
-        continue;
-      }
-      if (typeof set !== "function") continue;
-      return {
-        set,
-        prefixes: [path8.dirname(playwrightPackageJson), path8.join(root, "dist") + path8.sep]
-      };
-    }
-  } catch {
-  }
-  return null;
-}
-function boxCaptureFrames(extraPrefixes = []) {
-  const first = boxing === void 0;
-  if (first) boxing = resolveBoxing();
-  if (!boxing) return;
-  const added = extraPrefixes.filter((prefix) => !boxing.prefixes.includes(prefix));
-  if (!first && added.length === 0) return;
-  boxing.prefixes.push(...added);
-  try {
-    boxing.set([...boxing.prefixes]);
-  } catch {
-  }
-}
-function callMethod(target, prop, args) {
-  return target[prop](...args);
-}
-function internalCall(owner, run) {
-  const wrap = owner?._wrapApiCall;
-  if (typeof wrap !== "function") return run();
-  return wrap.call(owner, run, { internal: true, title: "Piwi capture" });
-}
-
 // src/internal/capture/code-reach.ts
 var crypto2 = __toESM(require("crypto"));
-var fs6 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
+var fs8 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
 var import_node_child_process = require("child_process");
 var MAX_MAP_BYTES = 20 * 1024 * 1024;
 var MAP_TIMEOUT_MS = 5e3;
@@ -4622,18 +5070,18 @@ function repositoryRoot(from) {
     }).trim();
   } catch {
   }
-  cachedRepoRoot = { from, root: path9.resolve(root) };
+  cachedRepoRoot = { from, root: path11.resolve(root) };
   return cachedRepoRoot.root;
 }
 function codeReachRoots(configDir, configured) {
   const repoRoot = repositoryRoot(configDir);
-  const resolve3 = (dirs) => (Array.isArray(dirs) ? dirs : dirs ? [dirs] : []).filter(Boolean).map((r) => path9.resolve(configDir, r));
-  const global = Array.isArray(configured) ? resolve3(configured) : resolve3(configured?.["*"]);
+  const resolve5 = (dirs) => (Array.isArray(dirs) ? dirs : dirs ? [dirs] : []).filter(Boolean).map((r) => path11.resolve(configDir, r));
+  const global = Array.isArray(configured) ? resolve5(configured) : resolve5(configured?.["*"]);
   const byOrigin = /* @__PURE__ */ new Map();
   if (configured && !Array.isArray(configured)) {
     for (const [key, dirs] of Object.entries(configured)) {
       const origin = key === "*" ? null : originOf2(key);
-      const resolved = resolve3(dirs);
+      const resolved = resolve5(dirs);
       if (origin && resolved.length) byOrigin.set(origin, resolved);
     }
   }
@@ -4656,7 +5104,7 @@ function scriptRoots(roots, scriptUrl, pageUrl) {
 }
 function isFile(file) {
   try {
-    return fs6.statSync(file).isFile();
+    return fs8.statSync(file).isFile();
   } catch {
     return false;
   }
@@ -4664,10 +5112,10 @@ function isFile(file) {
 function resolveSourcePath(source, roots) {
   const normalized = normalizeSourcePath(source);
   if (!normalized || /(?:^|\/)node_modules\//.test(normalized)) return null;
-  if (path9.isAbsolute(normalized) && isFile(normalized)) return path9.resolve(normalized);
+  if (path11.isAbsolute(normalized) && isFile(normalized)) return path11.resolve(normalized);
   const relative7 = normalized.replace(/^\/+/, "");
   for (const root of roots) {
-    const candidate = path9.resolve(root, relative7);
+    const candidate = path11.resolve(root, relative7);
     if (isFile(candidate)) return candidate;
   }
   return null;
@@ -4699,7 +5147,7 @@ function fileForUrl(url, roots, bases) {
   return file;
 }
 function relativeToRepo(file, repoRoot) {
-  return path9.relative(repoRoot, file).split(path9.sep).join("/");
+  return path11.relative(repoRoot, file).split(path11.sep).join("/");
 }
 function scriptVersion(entry) {
   return entry.hash ?? crypto2.createHash("sha1").update(entry.source ?? "").digest("hex");
@@ -4762,10 +5210,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 path13 = relativeToRepo(file, roots.repoRoot);
-    const listed = into.get(path13);
+    const path15 = relativeToRepo(file, roots.repoRoot);
+    const listed = into.get(path15);
     if (listed) listed.push(...functions);
-    else into.set(path13, [...functions]);
+    else into.set(path15, [...functions]);
   };
   const add = (file, functions) => addTo(files, file, functions);
   const bases = viteBases(entries);
@@ -4917,8 +5365,8 @@ function onScriptParsed(page, capture, event) {
 var READ_WAIT_MS = 5e3;
 function readCoverage(page, cdp) {
   let timer;
-  const late = new Promise((resolve3) => {
-    timer = setTimeout(() => resolve3([]), READ_WAIT_MS);
+  const late = new Promise((resolve5) => {
+    timer = setTimeout(() => resolve5([]), READ_WAIT_MS);
   });
   const taken = internalCall(page, () => cdp.send("Profiler.takePreciseCoverage")).then(
     (answer) => answer.result,
@@ -5028,20 +5476,20 @@ async function stopCodeReach(page) {
 }
 
 // src/internal/capture/resource-ledger.ts
-var fs8 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
 var import_node_module2 = require("module");
 
 // src/internal/capture/worker-metrics.ts
 var import_node_perf_hooks = require("perf_hooks");
 
 // src/internal/support/system-readers.ts
-var fs7 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
+var fs9 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
 var CLK_TCK = 100;
 function readText(file) {
   try {
-    return fs7.readFileSync(file, "utf8");
+    return fs9.readFileSync(file, "utf8");
   } catch {
     return null;
   }
@@ -5123,45 +5571,45 @@ var ProcFs = class {
   }
   /** Whether this looks like a Linux `/proc` at all. */
   available() {
-    return fs7.existsSync(path10.join(this.root, "stat"));
+    return fs9.existsSync(path12.join(this.root, "stat"));
   }
   /** Every process, keyed by pid. */
   table() {
     const out = /* @__PURE__ */ new Map();
     let names;
     try {
-      names = fs7.readdirSync(this.root);
+      names = fs9.readdirSync(this.root);
     } catch {
       return out;
     }
     for (const name of names) {
       if (!/^\d+$/.test(name)) continue;
-      const text = readText(path10.join(this.root, name, "stat"));
+      const text = readText(path12.join(this.root, name, "stat"));
       const stat = text ? parseProcStat(Number(name), text) : null;
       if (stat) out.set(stat.pid, stat);
     }
     return out;
   }
   stat(pid) {
-    const text = readText(path10.join(this.root, String(pid), "stat"));
+    const text = readText(path12.join(this.root, String(pid), "stat"));
     return text ? parseProcStat(pid, text) : null;
   }
   runWaitMs(pid) {
-    const text = readText(path10.join(this.root, String(pid), "schedstat"));
+    const text = readText(path12.join(this.root, String(pid), "schedstat"));
     return text ? parseSchedstat(text) : null;
   }
   cmdline(pid) {
-    return (readText(path10.join(this.root, String(pid), "cmdline")) ?? "").split("\0").join(" ").trim();
+    return (readText(path12.join(this.root, String(pid), "cmdline")) ?? "").split("\0").join(" ").trim();
   }
   /** A field of `/proc/<pid>/status`, in kB: `VmRSS`, `VmHWM`. */
   statusKb(pid, key) {
-    const text = readText(path10.join(this.root, String(pid), "status"));
+    const text = readText(path12.join(this.root, String(pid), "status"));
     return text ? parseKbField(text, key) : null;
   }
   /** Proportional set size: shared pages split between the processes sharing them, so a sum counts them once. */
   async pssKb(pid) {
     try {
-      return parseKbField(await fs7.promises.readFile(path10.join(this.root, String(pid), "smaps_rollup"), "utf8"), "Pss");
+      return parseKbField(await fs9.promises.readFile(path12.join(this.root, String(pid), "smaps_rollup"), "utf8"), "Pss");
     } catch {
       return null;
     }
@@ -5169,29 +5617,29 @@ var ProcFs = class {
   /** Reset a process's peak RSS (`VmHWM`) to its current RSS. */
   resetPeakRss(pid) {
     try {
-      fs7.writeFileSync(path10.join(this.root, String(pid), "clear_refs"), "5");
+      fs9.writeFileSync(path12.join(this.root, String(pid), "clear_refs"), "5");
       return true;
     } catch {
       return false;
     }
   }
   cpuTicks() {
-    const text = readText(path10.join(this.root, "stat"));
+    const text = readText(path12.join(this.root, "stat"));
     return text ? parseCpuTicks(text) : null;
   }
   /** Total stall time of a resource's pressure file, in µs. */
   pressureUs(resource) {
-    const text = readText(path10.join(this.root, "pressure", resource));
+    const text = readText(path12.join(this.root, "pressure", resource));
     return text ? parsePsiTotal(text) : null;
   }
   memAvailableKb() {
-    const text = readText(path10.join(this.root, "meminfo"));
+    const text = readText(path12.join(this.root, "meminfo"));
     return text ? parseKbField(text, "MemAvailable") : null;
   }
   /** Open file descriptors of a process. */
   fdCount(pid) {
     try {
-      return fs7.readdirSync(path10.join(this.root, String(pid), "fd")).length;
+      return fs9.readdirSync(path12.join(this.root, String(pid), "fd")).length;
     } catch {
       return null;
     }
@@ -5353,10 +5801,10 @@ var PAGE_READ_TIMEOUT_MS = 1e3;
 var HOOK_PHASES = /* @__PURE__ */ new Set(["beforeAll", "afterAll", "beforeEach", "afterEach"]);
 var KIND_ORDER = { browser: 0, context: 1, page: 2, request: 3 };
 function relativePath(file) {
-  return path11.relative(process.cwd(), file.replace(/^file:\/\//, "")).split(path11.sep).join("/");
+  return path13.relative(process.cwd(), file.replace(/^file:\/\//, "")).split(path13.sep).join("/");
 }
 function isLibraryFile(file) {
-  return file.startsWith("node:") || file.startsWith("internal/") || file.includes(`${path11.sep}node_modules${path11.sep}`) || file.includes("/node_modules/") || file === __filename;
+  return file.startsWith("node:") || file.startsWith("internal/") || file.includes(`${path13.sep}node_modules${path13.sep}`) || file.includes("/node_modules/") || file === __filename;
 }
 function userSite(stack) {
   for (const line of (stack ?? "").split("\n").slice(1)) {
@@ -5404,7 +5852,7 @@ function playwrightTestInfoSource() {
   try {
     const packageJson = resolvePlaywrightPackageJson();
     if (!packageJson) return () => null;
-    const globals = (0, import_node_module2.createRequire)(packageJson)(path11.join(path11.dirname(packageJson), "lib", "globals.js"));
+    const globals = (0, import_node_module2.createRequire)(packageJson)(path13.join(path13.dirname(packageJson), "lib", "globals.js"));
     const read = globals.currentTestInfo;
     if (typeof read !== "function") return () => null;
     return () => {
@@ -5433,15 +5881,15 @@ function countHandles() {
 async function settledHandles(start) {
   const end = countHandles();
   if (!Object.entries(end).some(([type, n]) => n > (start[type] ?? 0))) return end;
-  await new Promise((resolve3) => setTimeout(resolve3, 0));
+  await new Promise((resolve5) => setTimeout(resolve5, 0));
   return countHandles();
 }
 function settleWithin(promise, ms) {
   let timer;
   return Promise.race([
     promise.catch(() => void 0),
-    new Promise((resolve3) => {
-      timer = setTimeout(resolve3, ms);
+    new Promise((resolve5) => {
+      timer = setTimeout(resolve5, ms);
     })
   ]).finally(() => clearTimeout(timer));
 }
@@ -5570,7 +6018,7 @@ var ResourceLedger = class {
     const census = this.census(null);
     if (this.resultsFile) {
       try {
-        fs8.appendFileSync(this.resultsFile, `${JSON.stringify(census)}
+        fs10.appendFileSync(this.resultsFile, `${JSON.stringify(census)}
 `);
       } catch {
       }
@@ -6187,6 +6635,13 @@ function createSink() {
     pickOffered: false,
     userPick: null,
     pause: null,
+    locatorCalls: /* @__PURE__ */ new Map(),
+    stops: [],
+    shownStops: /* @__PURE__ */ new Map(),
+    released: [],
+    releasedRequests: /* @__PURE__ */ new Set(),
+    onReleasedRequestsEnded: null,
+    releasedQuietSince: 0,
     locatorPages: new LocatorPageLog(),
     codeReach: { sessions: /* @__PURE__ */ new Map(), files: /* @__PURE__ */ new Map(), known: /* @__PURE__ */ new Map() },
     serverCoverage: /* @__PURE__ */ new Map(),
@@ -6212,7 +6667,7 @@ function maybeStartCodeReach(page, alreadyOpen = false) {
 async function startCodeReachOnOpenPages() {
   if (!browserCoverageInWorker() || OPEN_PAGES.size === 0) return;
   const started = Promise.all([...OPEN_PAGES].map((page) => maybeStartCodeReach(page, true)));
-  await Promise.race([started, new Promise((resolve3) => setTimeout(resolve3, CODE_REACH_START_WAIT_MS).unref())]);
+  await Promise.race([started, new Promise((resolve5) => setTimeout(resolve5, CODE_REACH_START_WAIT_MS).unref())]);
 }
 function configuredCodeReachRoots() {
   const raw = process.env.PIWI_CODE_REACH_ROOTS?.trim();
@@ -6226,7 +6681,7 @@ function configuredCodeReachRoots() {
     }
   } catch {
   }
-  return raw.split(path12.delimiter).filter(Boolean);
+  return raw.split(path14.delimiter).filter(Boolean);
 }
 async function stopSinkCodeReach(sink, closing) {
   const stopping = [];
@@ -6275,8 +6730,8 @@ async function drainPendingProbes(capMs) {
   let cap;
   await Promise.race([
     Promise.allSettled(PENDING_PROBES),
-    new Promise((resolve3) => {
-      cap = setTimeout(resolve3, capMs);
+    new Promise((resolve5) => {
+      cap = setTimeout(resolve5, capMs);
     })
   ]);
   clearTimeout(cap);
@@ -6316,10 +6771,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((resolve3) => {
+      const readBuffered = (type, extra) => new Promise((resolve5) => {
         try {
           const PO = globalThis.PerformanceObserver;
-          if (!PO || !(PO.supportedEntryTypes || []).includes(type)) return resolve3(null);
+          if (!PO || !(PO.supportedEntryTypes || []).includes(type)) return resolve5(null);
           const out = [];
           const po = new PO((list) => out.push(...list.getEntries()));
           po.observe({ type, buffered: true, ...extra });
@@ -6329,10 +6784,10 @@ async function readWebVitals(page) {
               po.disconnect();
             } catch {
             }
-            resolve3(out);
+            resolve5(out);
           }, 0);
         } catch {
-          resolve3(null);
+          resolve5(null);
         }
       });
       const [lcpRaw, shiftRaw, eventRaw, firstInputRaw] = await Promise.all([
@@ -6447,12 +6902,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((resolve3, reject) => {
+  return new Promise((resolve5, reject) => {
     const timer = setTimeout(() => reject(new Error("page inventory read timed out")), ms);
     promise.then(
       (value) => {
         clearTimeout(timer);
-        resolve3(value);
+        resolve5(value);
       },
       (error) => {
         clearTimeout(timer);
@@ -6567,6 +7022,7 @@ async function maybeOpenPicker(sink, closing) {
 var INSTRUMENTED_PAGES = /* @__PURE__ */ new WeakSet();
 var OPEN_PAGES = /* @__PURE__ */ new Set();
 var INSTRUMENTED_CONTEXTS = /* @__PURE__ */ new WeakSet();
+var OPEN_CONTEXTS = /* @__PURE__ */ new Set();
 var PATCHED_BROWSERS = /* @__PURE__ */ new WeakSet();
 var CHAIN_METHOD_SET = new Set(CHAIN_METHODS);
 var ACTION_METHOD_SET = new Set(ACTION_METHODS);
@@ -6687,8 +7143,20 @@ function recordLocatorPage(sink, page, locator, location, arrival) {
   } catch {
   }
 }
-function pausesAt(pause, callerLocation) {
-  return !pause.finished && (pause.next || pause.set.matches(callerLocation));
+function knowLocatorCall(sink, page, target, location, origin) {
+  if (!sink?.pause || !location) return null;
+  let settle = () => {
+  };
+  const settled = new Promise((resolve5) => settle = resolve5);
+  const call = { page, target, location, origin, picked: false, settled, settle };
+  sink.locatorCalls.set(callSiteLine(location), call);
+  return call;
+}
+function forgetLocatorCall(sink, call) {
+  if (!sink || !call) return;
+  call.settle();
+  const key = callSiteLine(call.location);
+  if (sink.locatorCalls.get(key) === call) sink.locatorCalls.delete(key);
 }
 function locatorSource(target, method, args) {
   try {
@@ -6698,41 +7166,219 @@ function locatorSource(target, method, args) {
   }
   return renderFailing({ method, args });
 }
-async function pauseBefore(sink, page, target, callerLocation, action, origin) {
-  const pause = sink.pause;
+var PAGE_PAUSES = /* @__PURE__ */ new WeakMap();
+var PLAYWRIGHT_PAUSES = /* @__PURE__ */ new WeakMap();
+async function armBreakpoints(contexts) {
+  const state = currentSink?.pause;
+  if (!state || state.finished || state.set.size === 0) return;
+  await Promise.all(
+    [...contexts].map(
+      (context) => context && watchStops(context, onDebuggerStop) ? steerDebugger(context, "pause") : void 0
+    )
+  );
+}
+function onDebuggerStop(context) {
+  const details = contextDebugger(context)?.pausedDetails();
+  if (!details || PLAYWRIGHT_PAUSES.has(context)) return;
+  const sink = currentSink;
+  const state = sink?.pause ?? null;
+  void (async () => {
+    let how = "resume";
+    try {
+      if (!sink || !state) return;
+      const callSite = stopSite(sink, details.location);
+      const pagePause = PAGE_PAUSES.get(context);
+      const decided = pagePause ? { show: "page-pause" } : atStop(state, callSite);
+      if ("go" in decided) {
+        how = decided.go;
+        return;
+      }
+      how = goOn(state, await showStop(sink, context, details.title, callSite ?? pagePause, decided.show));
+    } catch {
+      if (state) how = goOn(state);
+    } finally {
+      await steerDebugger(context, how);
+    }
+  })();
+}
+function stopSite(sink, location) {
+  if (path14.dirname(path14.resolve(location.file)) !== __dirname) return stopCallSite(location);
+  return inFlightCallSite([...sink.locatorCalls.values()].map((call) => call.location));
+}
+function stopPage(sink, context, call) {
+  for (const page of [call?.page, sink.lastActivePage]) {
+    if (page && !isPageClosed(page) && pageContext(page) === context) return page;
+  }
+  const open = context.pages().filter((page) => !isPageClosed(page));
+  return open[open.length - 1] ?? null;
+}
+async function showStop(sink, context, title, location, reason) {
   const testInfo = sink.testInfo;
-  if (!pause || !testInfo || !callerLocation) return;
-  pause.next = false;
-  try {
-    const locator = locatorSource(target, origin.method, origin.args);
-    const onPick = async (picked) => {
-      const pick = {
-        failing: { method: origin.method, args: origin.args, rendered: locator, location: callerLocation },
+  const call = sink.locatorCalls.get(callSiteLine(location));
+  const page = stopPage(sink, context, call);
+  if (!testInfo || !page) return void 0;
+  const onPick = async (picked) => {
+    if (call) {
+      call.picked = true;
+      const { method, args } = call.origin;
+      const rendered = locatorSource(call.target, method, args);
+      applyPickToSnapshots(sink.capturedLocators, {
+        failing: { method, args, rendered, location: call.location },
         ...picked
-      };
-      applyPickToSnapshots(sink.capturedLocators, pick);
-      sink.probedLocations.add(callerLocation);
-      const place = callerLocation.slice(0, callerLocation.lastIndexOf(":"));
-      console.log(`[piwi] Locator picked at ${place}: ${picked.picked.locator}`);
-      await postPickToEditor(
-        process.env[PIWI_LOCAL_DEBUG_ENV.editorSend],
-        pickPayload(picked.picked.locator, callerLocation)
-      );
-    };
-    const choice = await internalCall(
+      });
+      sink.probedLocations.add(call.location);
+    }
+    console.log(`[piwi] Locator picked at ${callSiteLine(location)}: ${picked.picked.locator}`);
+    await postPickToEditor(process.env[PIWI_LOCAL_DEBUG_ENV.editorSend], pickPayload(picked.picked.locator, location));
+  };
+  const record = { title, location, reason, startedAt: Date.now(), duration: 0 };
+  sink.stops.push(record);
+  const end = new AbortController();
+  const shown = withTestTimeoutHeld(
+    testInfo,
+    () => internalCall(
       page,
       () => pauseHere(
         page,
-        testInfo,
-        { location: callerLocation, action, locator, target },
+        {
+          location,
+          call: title,
+          attempt: testInfo.retry > 0 ? testInfo.retry + 1 : null,
+          target: call?.page === page ? call.target : null
+        },
         { fn: probeElementAttrs, arg: CAPTURED_ATTRS_ARG },
-        onPick
+        onPick,
+        recorderAt(page, testInfo, location, reason === "page-pause" ? "pause" : "breakpoint"),
+        end.signal
       )
-    );
-    if (choice === "step") pause.next = true;
-    else if (choice === "finish") pause.finished = true;
-  } catch {
+    )
+  ).finally(() => {
+    if (!end.signal.aborted) record.duration = Date.now() - record.startedAt;
+    else if (end.signal.reason === "ended") releaseCall(sink, call?.settled ?? Promise.resolve());
+    sink.shownStops.delete(end);
+  });
+  const heldAt = testTimeSlot(testInfo)?.elapsed ?? null;
+  sink.shownStops.set(end, { page, record, done: shown.catch(() => void 0), heldAt });
+  const answer = await shown;
+  if (!end.signal.aborted) return answer;
+  return end.signal.reason === "closed" ? "resume" : "finish";
+}
+var END_STOP_MS = 2e3;
+var RELEASED_CALL_MS = 2e3;
+var RELEASED_QUIET_MS = 200;
+async function endShownStops(sink, why, closing) {
+  const ending = [];
+  let heldAt = Infinity;
+  for (const [end, { page, record, done, heldAt: stopHeldAt }] of sink.shownStops) {
+    if (closing && closing.page !== page && (!closing.context || pageContext(page) !== closing.context)) continue;
+    if (!end.signal.aborted) {
+      record.duration = Date.now() - record.startedAt;
+      end.abort(why);
+      if (why === "ended" && stopHeldAt !== null) heldAt = Math.min(heldAt, stopHeldAt);
+    }
+    ending.push(done);
+  }
+  if (sink.testInfo && heldAt !== Infinity) restoreTestTime(sink.testInfo, heldAt);
+  await settledWithin(ending, END_STOP_MS);
+}
+function releaseCall(sink, settled) {
+  sink.releasedQuietSince = Date.now();
+  sink.released.push(settled.then(() => void (sink.releasedQuietSince = Date.now())));
+}
+function releasedRequestsEnded(sink) {
+  if (sink.releasedRequests.size === 0) return Promise.resolve();
+  return new Promise((resolve5) => sink.onReleasedRequestsEnded = resolve5);
+}
+async function awaitReleasedCalls(sink) {
+  if (sink.released.length === 0) return;
+  const deadline = Date.now() + RELEASED_CALL_MS;
+  await settledWithin(sink.released, RELEASED_CALL_MS);
+  for (let now = Date.now(); now < deadline; now = Date.now()) {
+    if (sink.releasedRequests.size > 0) {
+      await settledWithin([releasedRequestsEnded(sink)], deadline - now);
+      continue;
+    }
+    const quiet = now - sink.releasedQuietSince;
+    if (quiet >= RELEASED_QUIET_MS) return;
+    await new Promise((resolve5) => setTimeout(resolve5, 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((resolve5) => timer = setTimeout(resolve5, ms))]);
+  clearTimeout(timer);
+}
+function endStopsWithTestFunction(testInfo, sink) {
+  const callbacks = testInfo._onDidFinishTestFunctionCallbacks;
+  if (!(callbacks instanceof Set)) return;
+  const theirs = [...callbacks];
+  callbacks.clear();
+  callbacks.add(() => endShownStops(sink, "ended"));
+  for (const callback of theirs) callbacks.add(callback);
+}
+function recorderAt(page, testInfo, location, reason) {
+  if (!canRecordFromHere()) return void 0;
+  return async (ended) => {
+    console.log(`[piwi] Recording from ${callSiteLine(location)}: the editor writes the steps.`);
+    const why = await recordFromHere({ page, testInfo, location, reason, ended });
+    if (ended?.aborted) console.log("[piwi] The recording ended with the test.");
+    else
+      console.log(
+        why ? `[piwi] Nothing was recorded: ${why}` : "[piwi] The recording ended: the test is paused again."
+      );
+  };
+}
+async function pauseInPlace(page, playwrightPause, location) {
+  const sink = currentSink;
+  const testInfo = sink?.testInfo;
+  const context = pageContext(page);
+  if (!sink || !testInfo || !location || !context || !contextDebugger(context)) {
+    return leaveToPlaywright(context, playwrightPause);
+  }
+  if (!sink.pause && (!canRecordFromHere() || pauseSkipReason(pauseGateFromTestInfo(testInfo)))) {
+    return leaveToPlaywright(context, playwrightPause);
+  }
+  sink.pause ??= { set: NO_BREAKPOINTS, step: false, finished: false };
+  watchStops(context, onDebuggerStop);
+  await steerDebugger(context, "pause");
+  PAGE_PAUSES.set(context, location);
+  try {
+    await playwrightPause({ __testHookKeepTestTimeout: true });
+  } finally {
+    PAGE_PAUSES.delete(context);
+  }
+}
+async function leaveToPlaywright(context, playwrightPause) {
+  if (context) PLAYWRIGHT_PAUSES.set(context, (PLAYWRIGHT_PAUSES.get(context) ?? 0) + 1);
+  try {
+    await withInspector(() => playwrightPause());
+  } finally {
+    if (context) {
+      const left = (PLAYWRIGHT_PAUSES.get(context) ?? 1) - 1;
+      if (left > 0) PLAYWRIGHT_PAUSES.set(context, left);
+      else PLAYWRIGHT_PAUSES.delete(context);
+    }
+  }
+}
+var PLAYWRIGHT_PAUSE = /* @__PURE__ */ Symbol.for("@piwitests/reporter:playwright-pause");
+function playwrightPauseOf(page) {
+  const current = page.pause;
+  if (typeof current !== "function") return null;
+  const own = current[PLAYWRIGHT_PAUSE] ?? current;
+  const proto = Object.getPrototypeOf(page);
+  const theirs = proto?.pause;
+  if (proto && typeof theirs === "function") {
+    if (!theirs[PLAYWRIGHT_PAUSE]) {
+      const wrapped = function(options) {
+        return leaveToPlaywright(pageContext(this), () => theirs.call(this, options));
+      };
+      wrapped[PLAYWRIGHT_PAUSE] = theirs;
+      proto.pause = wrapped;
+    }
+    markPausesWrapped();
   }
+  return (options) => own.call(page, options);
 }
 function wrapLocator(page, locator, originMethod, originArgs) {
   return new Proxy(locator, {
@@ -6755,36 +7401,35 @@ function wrapLocator(page, locator, originMethod, originArgs) {
           const isNot = Boolean(callArgs[1]?.isNot);
           const callerLocation = sink ? captureCallerLocation() : null;
           if (sink) recordLocatorPage(sink, page, target, callerLocation, noteLocatorCall(page, EXPECT_METHOD, true));
-          if (sink?.pause && pausesAt(sink.pause, callerLocation)) {
-            await pauseBefore(sink, page, target, callerLocation, assertionLabel(expression, isNot), {
+          const call = knowLocatorCall(sink, page, target, callerLocation, { method: originMethod, args: originArgs });
+          try {
+            if (!sink || isNot || !EXPECT_CAPTURE_EXPRESSIONS.has(expression)) {
+              return await callMethod(target, prop, callArgs);
+            }
+            sink.lastActivePage = page;
+            const used = {
               method: originMethod,
-              args: originArgs
-            });
-          }
-          if (!sink || isNot || !EXPECT_CAPTURE_EXPRESSIONS.has(expression)) {
-            return callMethod(target, prop, callArgs);
-          }
-          sink.lastActivePage = page;
-          const used = {
-            method: originMethod,
-            args: originArgs,
-            raw: `${originMethod}(${JSON.stringify(originArgs)})`
-          };
-          const alreadyProbed = callerLocation !== null && sink.probedLocations.has(callerLocation);
-          let seq = -1;
-          if (!alreadyProbed) {
-            seq = sink.capturedLocators.length;
-            sink.capturedLocators.push({ location: callerLocation, used, element: null, alternatives: [] });
-          }
-          const result = await callMethod(target, prop, callArgs);
-          const matches = result?.matches;
-          if (matches === true && !alreadyProbed) {
-            if (callerLocation) sink.probedLocations.add(callerLocation);
-            startElementCapture(sink, page, target, seq, callerLocation, used);
-          } else if (matches === false) {
-            sink.failedLocators.push({ method: originMethod, args: originArgs, location: callerLocation });
+              args: originArgs,
+              raw: `${originMethod}(${JSON.stringify(originArgs)})`
+            };
+            const alreadyProbed = callerLocation !== null && sink.probedLocations.has(callerLocation);
+            let seq = -1;
+            if (!alreadyProbed) {
+              seq = sink.capturedLocators.length;
+              sink.capturedLocators.push({ location: callerLocation, used, element: null, alternatives: [] });
+            }
+            const result = await callMethod(target, prop, callArgs);
+            const matches = result?.matches;
+            if (matches === true && !alreadyProbed && !call?.picked) {
+              if (callerLocation) sink.probedLocations.add(callerLocation);
+              startElementCapture(sink, page, target, seq, callerLocation, used);
+            } else if (matches === false) {
+              sink.failedLocators.push({ method: originMethod, args: originArgs, location: callerLocation });
+            }
+            return result;
+          } finally {
+            forgetLocatorCall(sink, call);
           }
-          return result;
         };
       }
       if (!ACTION_METHOD_SET.has(prop)) return original;
@@ -6799,9 +7444,7 @@ function wrapLocator(page, locator, originMethod, originArgs) {
           args: originArgs,
           raw: `${originMethod}(${JSON.stringify(originArgs)})`
         };
-        if (sink.pause && pausesAt(sink.pause, callerLocation)) {
-          await pauseBefore(sink, page, target, callerLocation, String(prop), used);
-        }
+        const call = knowLocatorCall(sink, page, target, callerLocation, used);
         const alreadyProbed = callerLocation !== null && sink.probedLocations.has(callerLocation);
         let seq = -1;
         if (!alreadyProbed) {
@@ -6819,8 +7462,10 @@ function wrapLocator(page, locator, originMethod, originArgs) {
         } catch (error) {
           sink.failedLocators.push({ method: originMethod, args: originArgs, location: callerLocation });
           throw error;
+        } finally {
+          forgetLocatorCall(sink, call);
         }
-        if (!alreadyProbed) {
+        if (!alreadyProbed && !call?.picked) {
           if (callerLocation) sink.probedLocations.add(callerLocation);
           startElementCapture(sink, page, target, seq, callerLocation, used);
         }
@@ -6873,12 +7518,17 @@ function instrumentPage(page) {
   }
   const ctx = pageContext(page);
   if (ctx) instrumentContext(ctx);
+  const playwrightPause = playwrightPauseOf(page);
+  if (playwrightPause) {
+    page.pause = () => pauseInPlace(page, playwrightPause, captureCallerLocation());
+  }
   if (typeof page.close === "function") {
     const originalClose = page.close.bind(page);
     page.close = async (...args) => {
       await drainPendingProbes(1e3);
       const sink = currentSink;
       if (sink) {
+        await endShownStops(sink, "closed", { page });
         await stashPageState(sink, { page });
         await maybeOpenPicker(sink, { page });
         await stopSinkCodeReach(sink, { page });
@@ -6967,8 +7617,18 @@ function instrumentPage(page) {
     } catch {
     }
   });
+  page.on("request", (request) => {
+    const sink = currentSink;
+    if (!sink || sink.released.length === 0) return;
+    sink.releasedRequests.add(request);
+    sink.releasedQuietSince = Date.now();
+  });
   const onRequestEnd = (request, failed) => {
     const sink = currentSink;
+    if (sink?.releasedRequests.delete(request)) {
+      sink.releasedQuietSince = Date.now();
+      if (sink.releasedRequests.size === 0) sink.onReleasedRequestsEnded?.();
+    }
     if (!sink || RECORDED_OPEN.has(request)) return;
     sink.lastActivePage = page;
     const response = sink.openResponses.get(request) ?? null;
@@ -7074,6 +7734,10 @@ async function awaitFlakeConditions() {
 function instrumentContext(context) {
   if (!context || INSTRUMENTED_CONTEXTS.has(context)) return;
   INSTRUMENTED_CONTEXTS.add(context);
+  if (typeof context.once === "function") {
+    OPEN_CONTEXTS.add(context);
+    context.once("close", () => OPEN_CONTEXTS.delete(context));
+  }
   observeOwnApiRequests(context);
   if (process.env.PIWI_CAPTURE_LOCATORS !== "false" && typeof context.addInitScript === "function") {
     void Promise.resolve(context.addInitScript({ content: PROBE_INIT_SCRIPT })).catch(() => {
@@ -7093,6 +7757,7 @@ function instrumentContext(context) {
       await drainPendingProbes(1e3);
       const sink = currentSink;
       if (sink) {
+        await endShownStops(sink, "closed", { context });
         await stashPageState(sink, { context });
         await maybeOpenPicker(sink, { context });
         await stopSinkCodeReach(sink, { context });
@@ -7109,6 +7774,7 @@ function patchBrowser(browser) {
   browser.newPage = async (...args) => {
     const page = await originalNewPage(...args);
     instrumentPage(page);
+    await armBreakpoints([pageContext(page)]);
     await awaitFlakeConditions();
     await maybeStartCodeReach(page);
     return page;
@@ -7117,6 +7783,7 @@ function patchBrowser(browser) {
   browser.newContext = async (...args) => {
     const context = await originalNewContext(...args);
     instrumentContext(context);
+    await armBreakpoints([context]);
     return context;
   };
   if (typeof browser.close === "function") {
@@ -7168,14 +7835,20 @@ async function flushSink(sink, testInfo) {
   let drainDeadline;
   await Promise.race([
     Promise.allSettled(sink.capturePromises),
-    new Promise((resolve3) => {
-      drainDeadline = setTimeout(resolve3, 2e3);
+    new Promise((resolve5) => {
+      drainDeadline = setTimeout(resolve5, 2e3);
     })
   ]);
   clearTimeout(drainDeadline);
   const page = sink.lastActivePage;
   const pageReadable = page !== null && !isPageClosed(page);
   if (pageReadable) await maybeOpenPicker(sink);
+  if (sink.stops.length > 0) {
+    await testInfo.attach(ATTACHMENT_NAMES.pauses, {
+      contentType: "application/json",
+      body: Buffer.from(JSON.stringify(sink.stops))
+    });
+  }
   if (sink.capturedLocators.length > 0) {
     await testInfo.attach(ATTACHMENT_NAMES.locators, {
       contentType: "application/json",
@@ -7376,6 +8049,7 @@ var piwiFixtures = {
   // never double-wraps a page the browser patch already instrumented.
   page: async ({ page }, use) => {
     instrumentPage(page);
+    await armBreakpoints([pageContext(page)]);
     await awaitFlakeConditions();
     await maybeStartCodeReach(page);
     await use(page);
@@ -7396,8 +8070,9 @@ var piwiFixtures = {
       if (pauseSet.size) {
         const reason = pauseSkipReason(pauseGateFromTestInfo(testInfo));
         if (reason) logPauseSkipOnce(reason);
-        else sink.pause = { set: pauseSet, next: false, finished: false };
+        else sink.pause = { set: pauseSet, step: false, finished: false };
       }
+      if (sink.pause || canRecordFromHere()) endStopsWithTestFunction(testInfo, sink);
       if (isFlakeMode()) {
         const plan = loadFlakePlan();
         const role = flakeRoleForTest(plan, {
@@ -7422,9 +8097,12 @@ var piwiFixtures = {
       activeResourceLedger()?.testStarted(testInfo);
       currentSink = sink;
       try {
+        await armBreakpoints(OPEN_CONTEXTS);
         await startCodeReachOnOpenPages();
         await use();
       } finally {
+        await endShownStops(sink, "ended");
+        await awaitReleasedCalls(sink);
         currentSink = null;
         if (sink.probeItem) {
           const applied = sink.probeInterception?.applied() ?? false;