@piwitests/reporter 0.62.0 → 0.63.0

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

@@ -41,6 +41,7 @@ __export(capture_fixtures_exports, {
   codeReachRoots: () => codeReachRoots,
   computeCoreVitals: () => computeCoreVitals,
   configuredCodeReachRoots: () => configuredCodeReachRoots,
+  errorPlace: () => errorPlace,
   extendPiwiFixtures: () => extendPiwiFixtures,
   failureError: () => failureError,
   intentAt: () => intentAt,
@@ -60,7 +61,7 @@ __export(capture_fixtures_exports, {
   stopResourceLedger: () => stopResourceLedger
 });
 module.exports = __toCommonJS(capture_fixtures_exports);
-var path14 = __toESM(require("path"));
+var path15 = __toESM(require("path"));
 var import_node_zlib2 = require("zlib");
 
 // ../picker-dom/src/probe.ts
@@ -519,8 +520,8 @@ function installPickerOverlay(arg) {
     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;
+    const path16 = typeof e.composedPath === "function" ? e.composedPath() : null;
+    const first = path16 && path16.length ? path16[0] : null;
     return first && first.nodeType === 1 ? first : e.target;
   };
   const buildChain = (raw) => {
@@ -825,14 +826,14 @@ function showAnchorPicker(arg) {
   } catch {
     shadowRoots.length = 0;
   }
-  const within2 = (node2, scope) => {
+  const within3 = (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 (within2(sr.host, scope)) found.push(...Array.from(sr.querySelectorAll(sel)));
+    for (const sr of shadowRoots) if (within3(sr.host, scope)) found.push(...Array.from(sr.querySelectorAll(sel)));
     return found;
   };
   const leafCountable = !!leafTestId || roleOf2(el) === leafRole;
@@ -914,13 +915,17 @@ function showAnchorPicker(arg) {
   }
   const MONO = "ui-monospace,SFMono-Regular,Menlo,Consolas,monospace";
   const outline2 = doc.createElement("div");
+  outline2.id = "__piwi_anchor_outline";
   outline2.style.cssText = `position:fixed;pointer-events:none;z-index:${Z};box-sizing:border-box;border:2px solid #22c55e;background:rgba(34,197,94,.10);border-radius:4px;display:none;box-shadow:0 0 0 1px rgba(255,255,255,.9),0 0 0 3px rgba(5,46,22,.5);`;
   const outlineLabel = doc.createElement("div");
+  outlineLabel.id = "__piwi_anchor_label";
   outlineLabel.style.cssText = `position:fixed;pointer-events:none;z-index:${Z + 1};display:none;box-sizing:border-box;max-width:min(420px,90vw);background:#0b1120;color:#f9fafb;border:1px solid #22c55e;border-radius:6px;padding:3px 7px;font:12px/1.45 ${MONO};white-space:nowrap;overflow:hidden;text-overflow:ellipsis;box-shadow:0 4px 18px rgba(0,0,0,.5);`;
   const pickedOutline = doc.createElement("div");
+  pickedOutline.id = "__piwi_anchor_picked";
   const pr = el.getBoundingClientRect();
   pickedOutline.style.cssText = `position:fixed;pointer-events:none;z-index:${Z};box-sizing:border-box;border:2px solid #a855f7;background:rgba(168,85,247,.14);border-radius:4px;box-shadow:0 0 0 1px rgba(255,255,255,.9),0 0 0 3px rgba(59,7,100,.55);left:${pr.left}px;top:${pr.top}px;width:${pr.width}px;height:${pr.height}px;`;
   const panel = doc.createElement("div");
+  panel.id = "__piwi_anchor_panel";
   panel.style.cssText = `position:fixed;top:12px;right:12px;z-index:${Z + 3};width:min(340px,calc(100vw - 56px));max-height:82vh;overflow:auto;background:#111827;color:#f9fafb;border-radius:10px;padding:16px;font:12px/1.5 system-ui,sans-serif;box-shadow:0 8px 40px rgba(0,0,0,.5);`;
   const title = doc.createElement("div");
   title.style.cssText = "font-weight:600;font-size:13px;margin-bottom:2px;";
@@ -1109,6 +1114,7 @@ function showPickerChoices(arg) {
   }
   const Z = 2147483600;
   const wrap = doc.createElement("div");
+  wrap.id = "__piwi_picker_choices";
   wrap.style.cssText = `position:fixed;inset:0;z-index:${Z + 3};background:rgba(0,0,0,.45);display:flex;align-items:center;justify-content:center;font:13px/1.5 system-ui,sans-serif;`;
   const panel = doc.createElement("div");
   panel.style.cssText = "background:#111827;color:#f9fafb;border-radius:10px;padding:20px;max-width:640px;width:90vw;max-height:70vh;overflow:auto;box-shadow:0 8px 40px rgba(0,0,0,.5);";
@@ -1139,10 +1145,14 @@ function showPickerChoices(arg) {
   }
   panel.appendChild(title);
   panel.appendChild(sub);
-  const done = (choice) => {
-    g.__piwiPickChoice = choice;
+  const cleanup = () => {
     doc.removeEventListener("keydown", onKey, true);
     wrap.remove();
+    if (g.__piwiChoiceCleanup === cleanup) delete g.__piwiChoiceCleanup;
+  };
+  const done = (choice) => {
+    g.__piwiPickChoice = choice;
+    cleanup();
   };
   const onKey = (e) => {
     if (e.key !== "Escape") return;
@@ -1178,6 +1188,7 @@ function showPickerChoices(arg) {
   });
   panel.appendChild(skip);
   doc.addEventListener("keydown", onKey, true);
+  g.__piwiChoiceCleanup = cleanup;
   wrap.appendChild(panel);
   doc.body.appendChild(wrap);
 }
@@ -1229,7 +1240,10 @@ 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 on and pause no more in this test", false]],
+    ...arg.end && !arg.failure ? [
+      ["End the test", "end", "Skip the rest of this test: it is reported as skipped", false]
+    ] : []
   ];
   for (const [label, choice, hint, primary] of buttons) {
     const btn = doc.createElement("button");
@@ -1990,21 +2004,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(path15) {
-  return typeof path15 === "string" && path15.length <= ELEMENT_PATH_MAX_CHARS && ELEMENT_PATH_RE.test(path15);
+function isElementPath(path16) {
+  return typeof path16 === "string" && path16.length <= ELEMENT_PATH_MAX_CHARS && ELEMENT_PATH_RE.test(path16);
 }
 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: path15, label } = v;
-  if (!isElementPath(path15)) return null;
-  return { path: path15, label: typeof label === "string" ? label.slice(0, ELEMENT_LABEL_MAX_CHARS) : "" };
+  const { path: path16, label } = v;
+  if (!isElementPath(path16)) return null;
+  return { path: path16, label: typeof label === "string" ? label.slice(0, ELEMENT_LABEL_MAX_CHARS) : "" };
 }
 function textPoint(v) {
   if (!v || typeof v !== "object") return null;
-  const { path: path15, offset } = v;
+  const { path: path16, offset } = v;
   const at = offsetOf(offset);
-  return isElementPath(path15) && at !== null ? { path: path15, offset: at } : null;
+  return isElementPath(path16) && at !== null ? { path: path16, offset: at } : null;
 }
 function sanitizePageInteraction(raw) {
   if (!raw || typeof raw !== "object") return {};
@@ -2036,6 +2050,7 @@ function sanitizePageInteraction(raw) {
 
 // src/internal/capture/locator-healing.ts
 var path = __toESM(require("path"));
+var import_node_url = require("url");
 
 // ../core/src/locator-fingerprint.ts
 var PRESENT_SIMILARITY = 0.8;
@@ -2286,23 +2301,23 @@ var SUGG_TEXT_ROLES = /* @__PURE__ */ new Set([
   "switch"
 ]);
 var SUGG_FIELD_ROLES = /* @__PURE__ */ new Set(["textbox", "combobox", "searchbox", "spinbutton", "slider"]);
-function failedNameAndRole(failed) {
-  if (failed.method === "getByRole") {
-    const role = typeof failed.args[0] === "string" ? failed.args[0] : null;
-    const opts = failed.args[1];
+function failedNameAndRole(failed2) {
+  if (failed2.method === "getByRole") {
+    const role = typeof failed2.args[0] === "string" ? failed2.args[0] : null;
+    const opts = failed2.args[1];
     const name = opts && typeof opts.name === "string" ? opts.name : null;
     const level = opts && typeof opts.level === "number" ? opts.level : null;
     return { role, name, level };
   }
-  const first = failed.args.find((a) => typeof a === "string");
+  const first = failed2.args.find((a) => typeof a === "string");
   return { role: null, name: typeof first === "string" ? first : null, level: null };
 }
-function renderFailing(failed) {
-  const { role, name } = failedNameAndRole(failed);
-  if (failed.method === "getByRole") {
+function renderFailing(failed2) {
+  const { role, name } = failedNameAndRole(failed2);
+  if (failed2.method === "getByRole") {
     return name ? `getByRole(${quoteJsString(role ?? "")}, { name: ${quoteJsString(name)} })` : `getByRole(${quoteJsString(role ?? "")})`;
   }
-  return `${failed.method}(${quoteJsString(name ?? "")})`;
+  return `${failed2.method}(${quoteJsString(name ?? "")})`;
 }
 function freshSuggestions(candidate, failedMethod) {
   const out = [];
@@ -2322,9 +2337,9 @@ function freshSuggestions(candidate, failedMethod) {
   else if (SUGG_FIELD_ROLES.has(role)) push(labelLoc);
   return out;
 }
-function suggestLocatorsFromAria(failed, ariaSnapshot) {
-  if (!ariaSnapshot || !NAME_BASED_METHODS.has(failed.method)) return null;
-  const { role, name, level } = failedNameAndRole(failed);
+function suggestLocatorsFromAria(failed2, ariaSnapshot) {
+  if (!ariaSnapshot || !NAME_BASED_METHODS.has(failed2.method)) return null;
+  const { role, name, level } = failedNameAndRole(failed2);
   if (!name) return null;
   const candidates = parseAriaCandidates(ariaSnapshot);
   if (candidates.length === 0) return null;
@@ -2332,9 +2347,23 @@ function suggestLocatorsFromAria(failed, ariaSnapshot) {
   if (fingerprintPresent(fingerprint, candidates)) return null;
   const best = matchRenamedElement(fingerprint, candidates)?.candidate;
   if (!best || !best.name) return null;
-  const suggestions = freshSuggestions({ role: best.role, name: best.name, level: best.level }, failed.method);
+  const suggestions = freshSuggestions({ role: best.role, name: best.name, level: best.level }, failed2.method);
   if (suggestions.length === 0) return null;
-  return { failing: renderFailing(failed), suggestions };
+  return { failing: renderFailing(failed2), suggestions };
+}
+function framePath(file, windows = process.platform === "win32") {
+  if (!file.startsWith("file://")) return file;
+  try {
+    return (0, import_node_url.fileURLToPath)(file, { windows });
+  } catch {
+    return null;
+  }
+}
+function callSitePath(file, cwd = process.cwd(), windows = process.platform === "win32") {
+  const local = framePath(file, windows);
+  if (local === null) return null;
+  const paths = windows ? path.win32 : path.posix;
+  return paths.relative(cwd, local).split(paths.sep).join("/");
 }
 function captureCallerLocation(stack = new Error().stack ?? "") {
   const lines = stack.split("\n");
@@ -2348,13 +2377,8 @@ function captureCallerLocation(stack = new Error().stack ?? "") {
       prevWasCaptureModule = false;
       continue;
     }
-    let file = m[2];
-    if (!file || file.startsWith("node:")) {
-      prevWasCaptureModule = false;
-      continue;
-    }
-    file = file.replace(/^file:\/\/\/?/, "");
-    if (!/\.[a-z]+$/i.test(file)) {
+    const file = m[2] ? framePath(m[2]) : null;
+    if (!file || file.startsWith("node:") || !/\.[a-z]+$/i.test(file)) {
       prevWasCaptureModule = false;
       continue;
     }
@@ -2377,11 +2401,9 @@ function captureCallerLocation(stack = new Error().stack ?? "") {
     }
     let rel = file;
     try {
-      rel = path.relative(process.cwd(), file);
+      rel = callSitePath(file) ?? file;
     } catch {
     }
-    rel = rel.split(path.sep).join("/");
-    if (rel.startsWith("./")) rel = rel.slice(2);
     return `${rel}:${m[3]}:${m[4]}`;
   }
   return null;
@@ -2661,6 +2683,13 @@ var path2 = __toESM(require("path"));
 // src/internal/config/dotenv.ts
 var fs2 = __toESM(require("fs"));
 
+// src/internal/support/ci.ts
+function detectCi(env) {
+  return Boolean(
+    env.JENKINS_URL || env.GITHUB_ACTIONS || env.GITLAB_CI || env.CIRCLECI || env.TRAVIS || env.TF_BUILD || env.BITBUCKET_BUILD_NUMBER || env.TEAMCITY_VERSION || env.CODEBUILD_BUILD_ID || env.bamboo_buildKey || env.CI && env.CI.toLowerCase() !== "false" && env.CI !== "0"
+  );
+}
+
 // src/internal/config/env.ts
 var DEFAULTS = {
   projectName: "default-project",
@@ -2753,6 +2782,7 @@ var PIWI_ORIGIN_ENV = {
   kind: "PIWI_ORIGIN",
   ref: "PIWI_ORIGIN_REF"
 };
+var PIWI_SHARD_ENV = "PIWI_SHARD";
 var PIWI_PROBE_ENV = {
   flag: "PIWI_PROBE",
   plan: "PIWI_PROBE_PLAN",
@@ -2817,8 +2847,8 @@ function parseRouteKey(routeKey2) {
   return { method: routeKey2.slice(0, space).toUpperCase(), pattern: routeKey2.slice(space + 1) };
 }
 function patternToRegex(pattern) {
-  const path15 = pattern.split("?")[0] ?? pattern;
-  const escaped = path15.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:[A-Za-z0-9_]+/g, "[^/]+");
+  const path16 = pattern.split("?")[0] ?? pattern;
+  const escaped = path16.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:[A-Za-z0-9_]+/g, "[^/]+");
   return new RegExp(`^${escaped}$`);
 }
 function suitePathEqual(a, b) {
@@ -2841,13 +2871,13 @@ function matchProbeItem(plan, test) {
 function requestMatchesRoute(method, url, routeKey2) {
   const { method: rm, pattern } = parseRouteKey(routeKey2);
   if (rm && rm !== method.toUpperCase()) return false;
-  let path15;
+  let path16;
   try {
-    path15 = new URL(url).pathname;
+    path16 = new URL(url).pathname;
   } catch {
-    path15 = url.split("?")[0] ?? url;
+    path16 = url.split("?")[0] ?? url;
   }
-  return patternToRegex(pattern).test(path15);
+  return patternToRegex(pattern).test(path16);
 }
 function createProbeState() {
   return { navigated: false, matches: 0 };
@@ -2869,10 +2899,10 @@ function isProbeMode() {
 function loadPlan() {
   if (planCache !== void 0) return planCache;
   planCache = null;
-  const path15 = process.env[PIWI_PROBE_ENV.plan];
-  if (path15) {
+  const path16 = process.env[PIWI_PROBE_ENV.plan];
+  if (path16) {
     try {
-      planCache = JSON.parse(fs3.readFileSync(path15, "utf8"));
+      planCache = JSON.parse(fs3.readFileSync(path16, "utf8"));
     } catch {
       planCache = null;
     }
@@ -2896,10 +2926,10 @@ function outcomeFromStatus(status, applied) {
   return status === "failed" || status === "timedOut" || status === "interrupted" ? "noticed" : "not-noticed";
 }
 function recordProbeOutcome(line) {
-  const path15 = process.env[PIWI_PROBE_ENV.results];
-  if (!path15) return;
+  const path16 = process.env[PIWI_PROBE_ENV.results];
+  if (!path16) return;
   try {
-    fs3.appendFileSync(path15, `${JSON.stringify(line)}
+    fs3.appendFileSync(path16, `${JSON.stringify(line)}
 `);
   } catch {
   }
@@ -2954,26 +2984,26 @@ function dropOneField(body) {
   }
   return body;
 }
-function computeFault(fault, input) {
+function computeFault(fault, input2) {
   const base = {
-    status: input.status,
-    body: input.body,
-    contentType: input.contentType ?? null,
+    status: input2.status,
+    body: input2.body,
+    contentType: input2.contentType ?? null,
     delayMs: 0,
     changed: false
   };
   switch (fault) {
     case "status-500":
-      return { ...base, status: 500, changed: input.status !== 500 };
+      return { ...base, status: 500, changed: input2.status !== 500 };
     case "empty-body":
-      return { ...base, body: "", changed: input.body.length > 0 };
+      return { ...base, body: "", changed: input2.body.length > 0 };
     case "drop-field": {
-      const body = dropOneField(input.body);
-      return { ...base, body, changed: body !== input.body };
+      const body = dropOneField(input2.body);
+      return { ...base, body, changed: body !== input2.body };
     }
     case "stale-value": {
-      const body = input.priorBody ?? input.body;
-      return { ...base, body, changed: body !== input.body };
+      const body = input2.priorBody ?? input2.body;
+      return { ...base, body, changed: body !== input2.body };
     }
     case "slow":
       return { ...base, delayMs: SLOW_FAULT_DELAY_MS, changed: true };
@@ -3467,16 +3497,16 @@ function relativeTestFile(file, base = process.cwd()) {
   return file ? relativeTestPath(file, base) : null;
 }
 function flakeRoleForTest(plan, test) {
-  const running = {
+  const running2 = {
     file: relativeTestFile(test.file, test.base),
     title: test.title,
     suite: test.titlePath ? test.titlePath.slice(1, -1) : void 0
   };
-  if (flakeTestMatches(plan.test, running) && (plan.test.project === null || plan.test.project === test.project)) {
+  if (flakeTestMatches(plan.test, running2) && (plan.test.project === null || plan.test.project === test.project)) {
     return "target";
   }
   const companion = plan.arm.conditions.some(
-    (c) => (c.kind === "alongside" || c.kind === "after") && flakeTestMatches(c.test, running)
+    (c) => (c.kind === "alongside" || c.kind === "after") && flakeTestMatches(c.test, running2)
   );
   return companion ? "companion" : null;
 }
@@ -3577,8 +3607,8 @@ async function installFlakeConditions(page, plan) {
 }
 var FAILED_STATUSES = /* @__PURE__ */ new Set(["failed", "timedOut", "interrupted"]);
 function flakeResultLine(plan, attempt) {
-  const failed = FAILED_STATUSES.has(attempt.status);
-  const errorSignature = failed && attempt.errorText ? flakeErrorSignature(attempt.errorText) : null;
+  const failed2 = FAILED_STATUSES.has(attempt.status);
+  const errorSignature = failed2 && attempt.errorText ? flakeErrorSignature(attempt.errorText) : null;
   return {
     version: FLAKE_PLAN_VERSION,
     experimentId: plan.experimentId,
@@ -3670,13 +3700,13 @@ function normalizeFunctionRanges(ranges) {
 }
 function normalizeCoveragePath(raw) {
   if (typeof raw !== "string" || raw.length > MAX_PATH_LENGTH || raw.includes("\0")) return null;
-  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;
+  const path16 = raw.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (!path16 || path16.startsWith("../") || path16.startsWith("/") || /^[A-Za-z]:\//.test(path16)) return null;
+  if (/(^|\/)node_modules\//.test(path16)) return null;
+  return path16;
 }
-function fileEntry(path15, runtime, blob, functions = [], lines = []) {
-  const file = { path: path15, runtime };
+function fileEntry(path16, runtime, blob, functions = [], lines = []) {
+  const file = { path: path16, 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;
@@ -3695,11 +3725,11 @@ function sanitizeCoverage(raw) {
   const files = [];
   for (const item of raw.files) {
     if (!isRecord(item) || !isRuntime(item.runtime)) continue;
-    const path15 = normalizeCoveragePath(item.path);
-    if (path15 === null) continue;
+    const path16 = normalizeCoveragePath(item.path);
+    if (path16 === null) continue;
     const blob = typeof item.blob === "string" && BLOB_ID.test(item.blob) ? item.blob : void 0;
     files.push(
-      fileEntry(path15, item.runtime, blob, normalizeFunctionRanges(item.functions), normalizeLineRanges(item.lines))
+      fileEntry(path16, item.runtime, blob, normalizeFunctionRanges(item.functions), normalizeLineRanges(item.lines))
     );
   }
   const merged = mergeCoverage(captureOf(files, raw.incomplete === true));
@@ -4241,9 +4271,9 @@ function hideParams(params, count) {
     return isSecretName(decodeSafe(name)) || isSecretValue(decoded) ? `${name}=${hide()}` : part;
   }).join("");
 }
-function hidePath(path15, count) {
+function hidePath(path16, count) {
   const hide = hider(count);
-  return path15.split("/").map((segment) => {
+  return path16.split("/").map((segment) => {
     const [own = "", ...params] = segment.split(";");
     const decoded = decodeSafe(own);
     const kept = decoded !== HIDDEN_VALUE && isSecretValue(decoded) ? hide() : own;
@@ -4253,14 +4283,14 @@ function hidePath(path15, count) {
 function hideSecretsInUrl(url, count = { n: 0 }) {
   const parts = URL_PARTS.exec(url);
   if (!parts) return url;
-  const [, scheme = "", authority, path15 = "", query = "", fragment = ""] = parts;
+  const [, scheme = "", authority, path16 = "", 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(path15, count);
+  out += hidePath(path16, count);
   if (query) out += `?${hideParams(query.slice(1), count)}`;
   if (fragment) {
     const body = fragment.slice(1);
@@ -4291,10 +4321,10 @@ function hideInText(text, count) {
   if (text.length < 4 || !/[A-Za-z0-9]/.test(text)) return text;
   const hide = hider(count);
   let out = hidePem(text, hide);
-  out = out.replace(QUERY_PAIR, (all, sep9, name, value) => {
+  out = out.replace(QUERY_PAIR, (all, sep7, name, value) => {
     const decoded = decodeSafe(value);
     if (!value || decoded === HIDDEN_VALUE) return all;
-    return isSecretName(name) || isSecretValue(decoded) ? `${sep9}${name}=${hide()}` : all;
+    return isSecretName(name) || isSecretValue(decoded) ? `${sep7}${name}=${hide()}` : all;
   });
   out = out.replace(URL_PASSWORD, (_all, before, _password, at) => `${before}${hide()}${at}`);
   out = out.replace(SET_COOKIE, (_all, before) => `${before}${hide()}`);
@@ -4390,8 +4420,10 @@ async function cleanupPicker(page, ended = false) {
         const g = globalThis;
         if (typeof g.__piwiPickCleanup === "function") g.__piwiPickCleanup();
         if (typeof g.__piwiAnchorCleanup === "function") g.__piwiAnchorCleanup();
+        if (typeof g.__piwiChoiceCleanup === "function") g.__piwiChoiceCleanup();
         delete g.__piwiPickCleanup;
         delete g.__piwiAnchorCleanup;
+        delete g.__piwiChoiceCleanup;
         delete g.__piwiPickState;
         delete g.__piwiPickChoice;
         delete g.__piwiPickedElement;
@@ -4417,13 +4449,24 @@ function unlessEnded(run, ended) {
   ]);
 }
 async function pickLocator(page, probe, failing, ended) {
+  let polling = false;
   const answered = async (name) => {
     const wait = page.waitForFunction(
-      ([key, endedKey]) => globalThis[key] !== void 0 || globalThis[endedKey] === true,
+      ([key, endedKey]) => {
+        const g = globalThis;
+        if (g[endedKey] !== true) return g[key] !== void 0;
+        delete g[endedKey];
+        return true;
+      },
       [name, PICK_ENDED],
       { timeout: 0, polling: 250 }
     );
-    await unlessEnded(wait, ended);
+    polling = true;
+    const done = await unlessEnded(
+      wait.then(() => true),
+      ended
+    );
+    if (done) polling = false;
     return !ended?.aborted;
   };
   try {
@@ -4461,25 +4504,25 @@ async function pickLocator(page, probe, failing, ended) {
         chainLeafCount = anchorResult.chainCount;
       }
     }
-    const ranked = mergeCandidates(
+    const ranked2 = mergeCandidates(
       generateAlternatives({ ...attrs, accessibleName }),
       generateAnchoredAlternatives({ role, level }, anchors, chainLeafCount)
     );
-    if (ranked.length === 0) {
+    if (ranked2.length === 0) {
       console.log("[piwi] No stable locator could be generated for the picked element \u2014 nothing recorded.");
       return null;
     }
     await page.evaluate(showPickerChoices, {
       failing,
-      choices: ranked.map((r) => ({ locator: r.locator, score: r.score }))
+      choices: ranked2.map((r) => ({ locator: r.locator, score: r.score }))
     });
     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 };
+    if (typeof choice !== "number" || choice < 0 || choice >= ranked2.length) return null;
+    const picked = { ...ranked2[choice], pickedByUser: true };
     return {
       picked,
-      alternatives: [picked, ...ranked.filter((_, i) => i !== choice)],
+      alternatives: [picked, ...ranked2.filter((_, i) => i !== choice)],
       element: {
         tagName: attrs.tagName,
         attributes: attrs.attributes,
@@ -4492,27 +4535,27 @@ async function pickLocator(page, probe, failing, ended) {
       ...anchors.length > 0 ? { anchors } : {}
     };
   } finally {
-    await cleanupPicker(page, ended?.aborted);
+    await cleanupPicker(page, polling);
   }
 }
-async function runLocatorPicker(page, testInfo, failed, probe) {
+async function runLocatorPicker(page, testInfo, failed2, probe) {
   try {
     testInfo.setTimeout(0);
-    const rendered = failed ? renderFailing(failed) : null;
+    const rendered = failed2 ? renderFailing(failed2) : null;
     console.log(
       `
 [piwi] "${testInfo.title}" ${testInfo.status} \u2014 ${rendered ? "locator picker" : "inspector"} open in the browser: ${rendered ? `click the element that should replace ${rendered}` : "click any element to generate locators for it"} (\u2191/\u2193 to select a parent/child, Esc to skip).`
     );
     const pick = await pickLocator(page, probe, rendered);
     if (!pick) return null;
-    const location = failed?.location ?? null;
+    const location = failed2?.location ?? null;
     console.log(
-      failed ? `[piwi] Replacement picked for ${rendered}${location ? ` at ${location}` : ""}:
+      failed2 ? `[piwi] Replacement picked for ${rendered}${location ? ` at ${location}` : ""}:
 [piwi]   ${pick.picked.locator}` : `[piwi] Locator picked while inspecting:
 [piwi]   ${pick.picked.locator}`
     );
     return {
-      failing: failed ? { method: failed.method, args: failed.args, rendered, location } : null,
+      failing: failed2 ? { method: failed2.method, args: failed2.args, rendered, location } : null,
       ...pick
     };
   } catch {
@@ -4800,8 +4843,39 @@ function askAgain(state, asked) {
 function goOn(state, answer) {
   if (answer === "step") state.step = true;
   else if (answer === "finish") state.finished = true;
+  else if (answer === "end") {
+    state.finished = true;
+    stopShown(state);
+  }
   return wantsStops(state) ? "next" : "resume";
 }
+var ENDED_REASON = "Ended from Piwi";
+var OPTIONS_AT = {
+  fill: 1,
+  selectOption: 1,
+  press: 1,
+  type: 1,
+  pressSequentially: 1,
+  setInputFiles: 1,
+  dragTo: 1,
+  dispatchEvent: 2,
+  _expect: 1
+};
+function withEndSignal(method, args, signal) {
+  const at = OPTIONS_AT[method] ?? 0;
+  const given = args[at];
+  if (given !== void 0 && (typeof given !== "object" || given === null || Array.isArray(given))) return null;
+  const options = given ?? {};
+  let combined = signal;
+  if (options.signal !== void 0) {
+    if (!(options.signal instanceof AbortSignal) || typeof AbortSignal.any !== "function") return null;
+    combined = AbortSignal.any([options.signal, signal]);
+  }
+  const next = [...args];
+  while (next.length < at) next.push(void 0);
+  next[at] = { ...options, signal: combined };
+  return next;
+}
 function contextDebugger(context) {
   const dbg = context.debugger;
   return typeof dbg?.requestPause === "function" && typeof dbg.on === "function" ? dbg : null;
@@ -4901,12 +4975,12 @@ function pickPayload(locator, callerLocation) {
   return at ? { kind: "locator", text: locator, at } : { kind: "locator", text: locator };
 }
 var postFailureLogged = false;
-async function postPickToEditor(pairingAddress, payload, fetchImpl = fetch) {
+async function postPickToEditor(pairingAddress, payload, fetchImpl = fetch, host2 = "the editor") {
   if (!pairingAddress) return false;
   const logOnce = (why) => {
     if (postFailureLogged) return;
     postFailureLogged = true;
-    console.log(`[piwi] Could not send the picked locator to the editor: ${why}.`);
+    console.log(`[piwi] Could not send the picked locator to ${host2}: ${why}.`);
   };
   const pairing = parsePairing(pairingAddress);
   if (!pairing) {
@@ -4921,7 +4995,7 @@ async function postPickToEditor(pairingAddress, payload, fetchImpl = fetch) {
       signal: AbortSignal.timeout(5e3)
     });
     if (response.ok) return true;
-    logOnce(`the editor answered ${response.status}`);
+    logOnce(`${host2} answered ${response.status}`);
   } catch (error) {
     logOnce(error instanceof Error ? error.message : String(error));
   }
@@ -4979,6 +5053,33 @@ async function within(run, ms) {
     clearTimeout(timer);
   }
 }
+function eitherSignal(a, b) {
+  const either = new AbortController();
+  const abort = () => either.abort();
+  if (a.aborted || b.aborted) abort();
+  a.addEventListener("abort", abort, { once: true });
+  b.addEventListener("abort", abort, { once: true });
+  return either.signal;
+}
+async function viewHere(page, probe, onPick, onRecord, ended, intents, onIntent, viewEnded2) {
+  for (; ; ) {
+    const intent = await unlessEnded(intents.wait(), ended);
+    intents.answered();
+    if (!intent || ended.aborted) return;
+    const signal = eitherSignal(ended, viewEnded2());
+    try {
+      if (intent === "pick") {
+        const picked = await pickLocator(page, probe, null, signal).catch(() => null);
+        if (picked && !signal.aborted) await onPick(picked);
+      } else if (intent === "record") {
+        await onRecord?.(signal);
+      } else {
+        await onIntent?.(intent, signal);
+      }
+    } catch {
+    }
+  }
+}
 async function pauseHere(page, point, probe, onPick, onRecord, ended, intents, onIntent) {
   let shown2 = null;
   try {
@@ -4993,10 +5094,11 @@ async function pauseHere(page, point, probe, onPick, onRecord, ended, intents, o
       action: point.call,
       locator: null,
       record: !!onRecord,
-      ...point.failure ? { failure: true } : {}
+      ...point.failure ? { failure: true } : {},
+      ...point.end ? { end: true } : {}
     };
     console.log(
-      point.failure ? `[piwi] The test failed at ${callSiteLine(point.location)}: Resume, Pick a locator${onRecord ? " or Record here" : ""} in the browser (Esc resumes, and the test ends as it failed).` : `[piwi] Paused at ${callSiteLine(point.location)} before ${point.call}: Resume, Step, Pick a locator${onRecord ? ", Record here" : ""} or Finish in the browser (Esc resumes).`
+      point.failure ? `[piwi] The test failed at ${callSiteLine(point.location)}: Resume, Pick a locator${onRecord ? " or Record here" : ""} in the browser (Esc resumes, and the test ends as it failed).` : `[piwi] Paused at ${callSiteLine(point.location)} before ${point.call}: Resume, Step, Pick a locator${onRecord ? ", Record here" : ""}, Finish${point.end ? " or End the test" : ""} in the browser (Esc resumes).`
     );
     let navigated = 0;
     for (; ; ) {
@@ -5014,7 +5116,7 @@ async function pauseHere(page, point, probe, onPick, onRecord, ended, intents, o
         if (raised) await unlessEnded(raised, ended);
         if (ended?.aborted) return "resume";
         navigated = 0;
-        if (choice === "resume" || choice === "step" || choice === "finish") return choice;
+        if (choice === "resume" || choice === "step" || choice === "finish" || choice === "end") return choice;
         if (choice === "record" && onRecord) {
           await unlessEnded(
             onRecord(ended).catch(() => void 0),
@@ -5099,52 +5201,504 @@ function locatorOn(page, source) {
   }
 }
 
-// src/internal/capture/region-snapshot.ts
-function regionSnapshotWithoutSecrets(snapshot, secrets) {
-  const hidden = new Set(secrets.filter(Boolean));
-  const kept = [];
+// src/internal/capture/pick-at.ts
+var LINE = /^(\s*)- ([a-z][\w-]*)(?: "(?:[^"\\]|\\.)*")?((?: \[[^\]\n]*\])*)(?::.*)?$/;
+var REF = /\[ref=(e\d+)\]/;
+var NUMBER = "(-?\\d+(?:\\.\\d+)?)";
+var BOX = new RegExp(`\\[box=${NUMBER},${NUMBER},${NUMBER},${NUMBER}\\]`);
+function snapshotBoxes(snapshot) {
+  const boxes = [];
+  const open = [];
+  let unit = 0;
   for (const line of snapshot.split("\n")) {
-    const box = /^(\s*- textbox(?: "(?:[^"\\]|\\.)*")?(?: \[[^\]]*\])*): (.*)$/.exec(line);
-    if (box && hidden.size && hidden.has(yamlScalar(box[2]))) {
-      kept.push({ line: box[1], lostChild: false });
-      continue;
+    const m = LINE.exec(line);
+    if (!m) continue;
+    const indent = m[1].length;
+    if (indent > 0 && unit === 0) unit = indent;
+    while (open.length && open[open.length - 1].indent >= indent) open.pop();
+    const attrs = m[3] ?? "";
+    const ref = REF.exec(attrs)?.[1];
+    const box = BOX.exec(attrs);
+    if (!ref || !box) continue;
+    const [x, y, width, height] = box.slice(1).map(Number);
+    if (!(width > 0) || !(height > 0)) continue;
+    const depth = unit ? Math.round(indent / unit) : 0;
+    boxes.push({ ref, role: m[2], x, y, width, height, depth, ancestors: open.map((o) => o.ref) });
+    open.push({ indent, ref });
+  }
+  return boxes;
+}
+function boxesAt(boxes, x, y) {
+  const under = boxes.filter((box) => x >= box.x && x < box.x + box.width && y >= box.y && y < box.y + box.height);
+  const holding = new Set(under.flatMap((box) => box.ancestors));
+  const area = (box) => box.width * box.height;
+  return under.sort(
+    (a, b) => Number(holding.has(a.ref)) - Number(holding.has(b.ref)) || area(a) - area(b) || b.depth - a.depth
+  );
+}
+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 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));
+    if (!top) break;
+    hit = top;
+    scope = top.shadowRoot ?? null;
+  }
+  if (!hit) return null;
+  for (let node = hit; node; ) {
+    const at = elements.indexOf(node);
+    if (at >= 0) return at;
+    node = node.assignedSlot ?? node.parentElement ?? node.parentNode?.host ?? null;
+  }
+  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)
+    )
+  );
+  try {
+    const hit = await page.evaluate(hitIn, { x, y, overlay: PIWI_OVERLAY, elements: handles });
+    const tested = hit !== null && hit >= 0;
+    for (const [i, box] of under.entries()) {
+      if (tested && i !== hit) continue;
+      if (box.role === "iframe") return { refusal: IN_IFRAME };
+      if (box.depth === 0 && box.role === "generic") return { refusal: NO_ELEMENT };
+      const handle = handles[i];
+      if (!handle) continue;
+      const piwi = !tested && await handle.evaluate(
+        // A browser-side element, hence the cast: this package has no DOM types.
+        (el, overlay) => !!el.closest(overlay),
+        PIWI_OVERLAY
+      );
+      if (!piwi) return await rank(page, probe, byRef2(box.ref), handle);
     }
-    const url = /^\s*- \/url: (.*)$/.exec(line);
-    if (url && hideSecretsInUrl(yamlScalar(url[1])) !== yamlScalar(url[1])) {
-      let parent = kept.length - 1;
-      while (parent >= 0 && indentOf(kept[parent].line) >= indentOf(line)) parent--;
-      if (parent >= 0) kept[parent].lostChild = true;
-      continue;
+    return { refusal: NO_ELEMENT };
+  } finally {
+    await Promise.all(handles.map((handle) => handle?.dispose().catch(() => void 0)));
+  }
+}
+async function rankedCandidates(probe, locator, handle, testIdAttribute = null) {
+  const attrs = await handle.evaluate(probe.fn, probe.arg);
+  const accessibleName = approximateAccessibleName({ ...attrs, accessibleName: null });
+  const candidates = generateAlternatives({ ...attrs, accessibleName }, { testIdAttribute });
+  const normalize2 = locator.normalize;
+  const normalized = typeof normalize2 === "function" ? await normalize2.call(locator).then(String, () => null) : null;
+  if (normalized && !candidates.some((c) => c.locator === normalized)) {
+    const leaf = parseLeafLocatorCall(normalized);
+    candidates.push({ locator: normalized, method: leaf?.method ?? "locator", args: {}, score: NORMALIZED_SCORE });
+    candidates.sort((a, b) => b.score - a.score);
+  }
+  return { attrs, accessibleName, candidates };
+}
+async function findsAlone(page, candidate, handle) {
+  const built = locatorOn(page, candidate);
+  if (!built || await built.count().catch(() => 0) !== 1) return false;
+  return built.evaluate((el, target) => el === target, handle, { timeout: 2e3 }).catch(() => false);
+}
+async function rank(page, probe, locator, handle) {
+  const { attrs, accessibleName, candidates } = await rankedCandidates(probe, locator, handle);
+  let found = null;
+  for (const candidate of candidates.slice(0, MAX_CHECKED)) {
+    if (await findsAlone(page, candidate.locator, handle)) {
+      found = candidate;
+      break;
     }
-    kept.push({ line, lostChild: false });
   }
-  return kept.map(({ line, lostChild }, i) => {
-    const next = kept[i + 1];
-    const childless = !next || indentOf(next.line) <= indentOf(line);
-    return lostChild && childless && line.endsWith(":") ? line.slice(0, -1) : line;
-  }).join("\n");
+  if (!found) return { refusal: "Piwi found no locator that finds that element alone on the page." };
+  const picked = { ...found, pickedByUser: true };
+  const 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 } : {}
+  };
+  return { picked: { picked, alternatives: [picked, ...candidates.filter((c) => c !== found)], element } };
 }
-function indentOf(line) {
-  return line.length - line.trimStart().length;
+
+// ../core/src/run-view.ts
+var MAX_VIEW_WIDTH = 1280;
+var MAX_VIEW_HEIGHT = 800;
+var VIEW_QUALITY = 60;
+var MAX_VIEW_FRAME = 384 * 1024;
+var MAX_VIEW_FRAME_BASE64 = 4 * Math.ceil(MAX_VIEW_FRAME / 3);
+var MAX_VIEW_FPS = 10;
+var MAX_VIEW_EVENTS = 50;
+var MAX_VIEW_EVENT_RATE = 200;
+var MAX_VIEW_TEXT = 1e3;
+var MAX_VIEW_COORD = 1e4;
+var MAX_VIEW_WHEEL = 1e4;
+var MAX_COMBO_KEYS = 5;
+var KEY_NAMES = /* @__PURE__ */ new Set([
+  "Escape",
+  "F1",
+  "F2",
+  "F3",
+  "F4",
+  "F5",
+  "F6",
+  "F7",
+  "F8",
+  "F9",
+  "F10",
+  "F11",
+  "F12",
+  "Backquote",
+  "Digit1",
+  "Digit2",
+  "Digit3",
+  "Digit4",
+  "Digit5",
+  "Digit6",
+  "Digit7",
+  "Digit8",
+  "Digit9",
+  "Digit0",
+  "Minus",
+  "Equal",
+  "Backslash",
+  "Backspace",
+  "Tab",
+  "KeyQ",
+  "KeyW",
+  "KeyE",
+  "KeyR",
+  "KeyT",
+  "KeyY",
+  "KeyU",
+  "KeyI",
+  "KeyO",
+  "KeyP",
+  "BracketLeft",
+  "BracketRight",
+  "CapsLock",
+  "KeyA",
+  "KeyS",
+  "KeyD",
+  "KeyF",
+  "KeyG",
+  "KeyH",
+  "KeyJ",
+  "KeyK",
+  "KeyL",
+  "Semicolon",
+  "Quote",
+  "Enter",
+  "ShiftLeft",
+  "Shift",
+  "KeyZ",
+  "KeyX",
+  "KeyC",
+  "KeyV",
+  "KeyB",
+  "KeyN",
+  "KeyM",
+  "Comma",
+  "Period",
+  "Slash",
+  "ShiftRight",
+  "ControlLeft",
+  "Control",
+  "MetaLeft",
+  "Meta",
+  "AltLeft",
+  "Alt",
+  "Space",
+  "AltRight",
+  "AltGraph",
+  "MetaRight",
+  "ContextMenu",
+  "ControlRight",
+  "PrintScreen",
+  "ScrollLock",
+  "Pause",
+  "PageUp",
+  "PageDown",
+  "Insert",
+  "Delete",
+  "Home",
+  "End",
+  "ArrowLeft",
+  "ArrowUp",
+  "ArrowRight",
+  "ArrowDown",
+  "AudioVolumeMute",
+  "AudioVolumeDown",
+  "AudioVolumeUp",
+  "MediaTrackNext",
+  "MediaTrackPrevious",
+  "MediaPlayPause",
+  "NumLock",
+  "NumpadDivide",
+  "NumpadMultiply",
+  "NumpadSubtract",
+  "Numpad7",
+  "Numpad8",
+  "Numpad9",
+  "Numpad4",
+  "Numpad5",
+  "Numpad6",
+  "NumpadAdd",
+  "Numpad1",
+  "Numpad2",
+  "Numpad3",
+  "Numpad0",
+  "NumpadDecimal",
+  "NumpadEnter",
+  "ControlOrMeta"
+]);
+var MODIFIERS = /* @__PURE__ */ new Set(["Alt", "Control", "Meta", "Shift", "ControlOrMeta"]);
+function isViewTextControl(char) {
+  const code = char.charCodeAt(0);
+  return code < 32 && code !== 9 && code !== 10 || code === 127;
+}
+function isViewKey(key) {
+  if (typeof key !== "string") return false;
+  if (key.length === 1) return key >= " " && key <= "~";
+  return KEY_NAMES.has(key);
+}
+function isViewKeyCombo(combo) {
+  if (typeof combo !== "string" || !combo || combo.length > 64) return false;
+  const keys = [];
+  let building = "";
+  for (const char of combo) {
+    if (char === "+" && building) {
+      keys.push(building);
+      building = "";
+    } else {
+      building += char;
+    }
+  }
+  keys.push(building);
+  if (keys.length > MAX_COMBO_KEYS) return false;
+  const key = keys.pop();
+  return isViewKey(key) && keys.every((modifier) => MODIFIERS.has(modifier));
 }
-function yamlScalar(text) {
-  const value = text.trim();
-  if (value.startsWith('"')) {
-    try {
-      return String(JSON.parse(value));
-    } catch {
-      return value;
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNumber(value, min, max) {
+  return typeof value === "number" && Number.isFinite(value) && value >= min && value <= max;
+}
+function isViewPoint(x, y) {
+  return isNumber(x, 0, MAX_VIEW_COORD) && isNumber(y, 0, MAX_VIEW_COORD);
+}
+var BUTTONS = ["left", "right", "middle"];
+function readEvent(value) {
+  if (!isObject2(value)) return "is not an event.";
+  const { type, action } = value;
+  if (type === "mouse" || type === "wheel") {
+    const { x, y } = value;
+    if (!isViewPoint(x, y)) return `needs x and y, CSS pixels from 0 to ${MAX_VIEW_COORD}.`;
+    const at = { x, y };
+    if (type === "wheel") {
+      const { deltaX, deltaY } = value;
+      if (!isNumber(deltaX, -MAX_VIEW_WHEEL, MAX_VIEW_WHEEL) || !isNumber(deltaY, -MAX_VIEW_WHEEL, MAX_VIEW_WHEEL)) {
+        return `needs deltaX and deltaY, pixels from -${MAX_VIEW_WHEEL} to ${MAX_VIEW_WHEEL}.`;
+      }
+      return { type, ...at, deltaX, deltaY };
+    }
+    if (action === "move") return { type, action, ...at };
+    if (action !== "down" && action !== "up" && action !== "click") {
+      return "is a mouse event whose action is not move, down, up or click.";
+    }
+    const button = value.button === void 0 ? "left" : value.button;
+    if (typeof button !== "string" || !BUTTONS.includes(button))
+      return "names a button other than left, right or middle.";
+    const clickCount = value.clickCount === void 0 && action !== "click" ? void 0 : value.clickCount ?? 1;
+    if (clickCount !== void 0 && (!isNumber(clickCount, 1, 3) || !Number.isInteger(clickCount))) {
+      return "needs a clickCount from 1 to 3.";
+    }
+    if (action !== "click") {
+      return { type, action, ...at, button, ...clickCount === void 0 ? {} : { clickCount } };
     }
+    return { type, action, ...at, button, clickCount };
   }
-  if (value.startsWith("'") && value.endsWith("'") && value.length > 1) return value.slice(1, -1).replace(/''/g, "'");
-  return value;
+  if (type === "key") {
+    if (action !== "down" && action !== "up" && action !== "press") {
+      return "is a key event whose action is not down, up or press.";
+    }
+    const { key } = value;
+    const known = action === "press" ? isViewKeyCombo(key) : isViewKey(key);
+    return known ? { type, action, key } : `names a key Playwright does not play: ${JSON.stringify(String(key).slice(0, 64))}.`;
+  }
+  if (type === "text") {
+    const { text } = value;
+    if (typeof text !== "string" || !text || text.length > MAX_VIEW_TEXT || [...text].some(isViewTextControl)) {
+      return `needs a text of 1 to ${MAX_VIEW_TEXT} characters, with no control character but a tab or a line break.`;
+    }
+    return { type, text };
+  }
+  return "is of a type other than mouse, wheel, key or text.";
+}
+function readViewInput(value) {
+  if (!Array.isArray(value) || value.length === 0) return "The input needs its events.";
+  if (value.length > MAX_VIEW_EVENTS) return `The input carries ${MAX_VIEW_EVENTS} events at most.`;
+  const events = [];
+  for (const [i, raw] of value.entries()) {
+    const event = readEvent(raw);
+    if (typeof event === "string") return `Event ${i + 1} ${event}`;
+    events.push(event);
+  }
+  return events;
 }
+function isViewSize(width, height) {
+  return isNumber(width, 1, MAX_VIEW_COORD) && Number.isInteger(width) && isNumber(height, 1, MAX_VIEW_COORD) && Number.isInteger(height);
+}
+function viewSize(viewport) {
+  return fitViewSize(viewport, MAX_VIEW_WIDTH, MAX_VIEW_HEIGHT);
+}
+function fitViewSize(viewport, maxWidth, maxHeight) {
+  const width = Math.max(2, Math.round(viewport.width));
+  const height = Math.max(2, Math.round(viewport.height));
+  const scale = Math.min(1, maxWidth / width, maxHeight / height);
+  return { width: Math.max(2, Math.floor(width * scale)), height: Math.max(2, Math.floor(height * scale)) };
+}
+var RateWindow = class {
+  constructor(limit, now = Date.now) {
+    this.limit = limit;
+    this.now = now;
+    this.start = -Infinity;
+    this.used = 0;
+  }
+  take(n) {
+    const at = this.now();
+    if (at - this.start >= 1e3) {
+      this.start = at;
+      this.used = 0;
+    }
+    if (this.used + n > this.limit) return false;
+    this.used += n;
+    return true;
+  }
+};
+var LatestPacer = class {
+  constructor(options) {
+    this.options = options;
+    this.pending = null;
+    this.timer = null;
+    this.last = -Infinity;
+    this.closed = false;
+    this.gap = options.intervalMs;
+  }
+  offer(item) {
+    if (this.closed) return;
+    this.pending = { item };
+    this.pump();
+  }
+  /** Whether an item waits. */
+  get waiting() {
+    return this.pending !== null;
+  }
+  /** Send the item waiting when its time came and the way out is free; else try again later. */
+  pump() {
+    if (this.closed || !this.pending || this.timer) return;
+    const now = this.options.now?.() ?? Date.now();
+    const wait = this.last + this.gap - now;
+    const busy = wait <= 0 && !!this.options.busy?.();
+    if (wait > 0 || busy) {
+      this.timer = setTimeout(
+        () => {
+          this.timer = null;
+          this.pump();
+        },
+        busy ? this.options.intervalMs : wait
+      );
+      this.timer.unref?.();
+      return;
+    }
+    const { item } = this.pending;
+    this.pending = null;
+    this.last = now;
+    this.gap = Math.max(this.options.intervalMs, this.options.spacing?.(item) ?? 0);
+    this.options.send(item);
+  }
+  /** Nothing more is sent: the item waiting is dropped. */
+  close() {
+    this.closed = true;
+    this.pending = null;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+  }
+};
+var FrameAcks = class {
+  constructor(intervalMs, now = Date.now) {
+    this.intervalMs = intervalMs;
+    this.now = now;
+    this.due = -Infinity;
+    this.waiting = null;
+    this.closed = false;
+  }
+  next() {
+    if (this.closed || this.waiting) return void 0;
+    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((resolve5) => {
+      const timer = setTimeout(() => this.release(), this.due - now);
+      timer.unref?.();
+      this.waiting = { timer, resolve: resolve5 };
+    });
+  }
+  /** Whether a frame waits for its acknowledgment. */
+  get holding() {
+    return this.waiting !== null;
+  }
+  /** The frame waiting is acknowledged now, and every later one at once. */
+  close() {
+    this.closed = true;
+    this.release();
+  }
+  release() {
+    const waiting = this.waiting;
+    this.waiting = null;
+    if (!waiting) return;
+    clearTimeout(waiting.timer);
+    waiting.resolve();
+  }
+};
 
 // ../core/src/run-channel.ts
 var RUN_CHANNEL_ENV = "PIWI_RUN_CHANNEL";
+var RUN_REF_ENV = "PIWI_RUN_REF";
 var RUN_HOLDS = ["failure"];
 var RUN_INTENTS = ["pick", "record", "assert", "assert-region"];
-var RUN_TAKES = [...RUN_INTENTS, "requests", "mock", "locator"];
+var RUN_TAKES = [
+  ...RUN_INTENTS,
+  "requests",
+  "mock",
+  "locator",
+  "view",
+  "input",
+  "input-clicks",
+  "pick-at",
+  "agent",
+  "events",
+  "bind",
+  "end",
+  "share"
+];
 var RUN_INTENT_NAMES = {
   pick: "Pick a locator",
   record: "Record here",
@@ -5155,13 +5709,23 @@ var MAX_KEPT_RESPONSES = 50;
 var MAX_KEPT_BODY = 256 * 1024;
 var MAX_REGION_SNAPSHOT = 1024 * 1024;
 var MAX_STOP_ERROR = 1e3;
-function isObject2(value) {
+var MAX_AGENT_SNAPSHOT = 1024 * 1024;
+var MAX_SNAPSHOT_DEPTH = 100;
+var RUN_ACT_ACTIONS = ["click", "fill", "press", "check", "uncheck", "select"];
+var MAX_ACT_VALUE = 1e4;
+function isSnapshotRef(ref) {
+  return typeof ref === "string" && /^(?:f\d{1,6})?e\d{1,9}$/.test(ref);
+}
+var MAX_ELEMENT_TEXT = 1e3;
+var MAX_RUN_EVENT_TEXT = 1e3;
+var MAX_RUN_EVENT_RATE = 50;
+function isObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readJson(line) {
   try {
     const value = JSON.parse(line);
-    return isObject2(value) ? value : null;
+    return isObject3(value) ? value : null;
   } catch {
     return null;
   }
@@ -5173,7 +5737,7 @@ function filePath(value) {
   return typeof value === "string" && value.length > 0 && value.length <= 4096 && !value.includes("\0");
 }
 function readPlace(value) {
-  if (!isObject2(value) || !filePath(value.file) || !isInt(value.line, 1)) return null;
+  if (!isObject3(value) || !filePath(value.file) || !isInt(value.line, 1)) return null;
   if (value.column === void 0) return { file: value.file, line: value.line };
   return isInt(value.column, 1) ? { file: value.file, line: value.line, column: value.column } : null;
 }
@@ -5188,6 +5752,18 @@ function isLocatorText(value) {
   return typeof value === "string" && value.length > 0 && value.length <= 1e3 && !/[\r\n\u2028\u2029]/.test(value);
 }
 var MAX_PLACES = 1e4;
+var QUERIES = [
+  "requests",
+  "mock",
+  "locator",
+  "view",
+  "input",
+  "pick-at",
+  "snapshot",
+  "act",
+  "ref-locator",
+  "bind"
+];
 function parseHubToRun(line) {
   const value = readJson(line);
   if (!value) return null;
@@ -5195,7 +5771,9 @@ function parseHubToRun(line) {
   switch (value.type) {
     case "attached": {
       const holds = readHolds(value.holds);
-      return holds ? { type: "attached", holds } : null;
+      if (!holds) return null;
+      const host2 = typeof value.host === "string" && /^[A-Za-z0-9][\w '.-]{0,63}$/.test(value.host) ? value.host : null;
+      return host2 ? { type: "attached", holds, host: host2 } : { type: "attached", holds };
     }
     case "breakpoints": {
       if (!Array.isArray(value.places) || value.places.length > MAX_PLACES) return null;
@@ -5205,7 +5783,7 @@ function parseHubToRun(line) {
     case "control": {
       const { action, stop } = value;
       if (action === "pause") return { type: "control", action };
-      if (action === "step" || action === "resume" || action === "finish") {
+      if (action === "step" || action === "resume" || action === "finish" || action === "end") {
         return isInt(stop, 1) ? { type: "control", action, stop } : null;
       }
       return typeof action === "string" ? unknown(`control ${action}`) : null;
@@ -5219,95 +5797,331 @@ function parseHubToRun(line) {
       if (!isInt(request, 1)) return null;
       if (what === "image") return { type: "request", request, what: "image" };
       if (typeof what !== "string") return null;
-      if (!isIntent(what) && what !== "requests" && what !== "mock" && what !== "locator") {
-        return unknown(`request ${what}`);
-      }
+      if (!isIntent(what) && !QUERIES.includes(what)) return unknown(`request ${what}`);
       if (!isInt(stop, 1)) return null;
       if (isIntent(what) || what === "requests") return { type: "request", request, what, stop };
       if (what === "mock") return isInt(value.id, 1) ? { type: "request", request, what, stop, id: value.id } : null;
+      if (what === "view")
+        return typeof value.on === "boolean" ? { type: "request", request, what, stop, on: value.on } : null;
+      if (what === "input") {
+        const events = readViewInput(value.events);
+        return typeof events === "string" ? null : { type: "request", request, what, stop, events };
+      }
+      if (what === "pick-at") {
+        const { x, y } = value;
+        return isViewPoint(x, y) ? { type: "request", request, what, stop, x, y } : null;
+      }
+      if (what === "snapshot") {
+        const { depth, image } = value;
+        if (depth !== null && (!isInt(depth, 1) || depth > MAX_SNAPSHOT_DEPTH) || typeof image !== "boolean") {
+          return null;
+        }
+        return { type: "request", request, what, stop, depth, image };
+      }
+      if (what === "act") {
+        const act = readAct(value);
+        return act ? { type: "request", request, what, stop, ...act } : null;
+      }
+      if (what === "ref-locator") {
+        return isSnapshotRef(value.ref) ? { type: "request", request, what, stop, ref: value.ref } : null;
+      }
+      if (what === "bind") {
+        return typeof value.on === "boolean" ? { type: "request", request, what, stop, on: value.on } : null;
+      }
       const { locator } = value;
-      return locator === null || isLocatorText(locator) ? { type: "request", request, what, stop, locator } : null;
+      return locator === null || isLocatorText(locator) ? { type: "request", request, what: "locator", stop, locator } : null;
     }
+    case "events":
+      return typeof value.on === "boolean" ? { type: "events", on: value.on } : null;
+    case "share":
+      return typeof value.on === "boolean" ? { type: "share", on: value.on } : null;
     default:
       return typeof value.type === "string" && value.type ? unknown(value.type) : null;
   }
 }
+function readAct(value) {
+  if (!isObject3(value) || !isSnapshotRef(value.ref)) return null;
+  const action = value.action;
+  if (typeof action !== "string" || !RUN_ACT_ACTIONS.includes(action)) return null;
+  const given = value.value;
+  switch (action) {
+    case "fill":
+      return typeof given === "string" && given.length <= MAX_ACT_VALUE ? { ref: value.ref, action: "fill", value: given } : null;
+    case "press":
+      return isViewKeyCombo(given) ? { ref: value.ref, action: "press", value: given } : null;
+    case "select":
+      return typeof given === "string" && given.length <= MAX_ACT_VALUE && !/[\r\n\0]/.test(given) ? { ref: value.ref, action: "select", value: given } : null;
+    default:
+      return given === null || given === void 0 ? { ref: value.ref, action, value: null } : null;
+  }
+}
 
-// src/internal/capture/kept-responses.ts
-var keeping = null;
-var TEXT_TYPE = /^(?:text\/[\w.+-]+|application\/(?:[\w.+-]+\+)?(?:json|xml)|application\/(?:javascript|x-www-form-urlencoded|graphql))$/i;
-function mimeOf(contentType) {
-  return (contentType ?? "").split(";")[0].trim().toLowerCase();
+// 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 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;
+async function fieldSecrets(page) {
+  const values = await Promise.all(
+    page.frames().slice(0, MAX_FRAMES).map(
+      (frame) => frame.locator(SECRET_FIELDS).evaluateAll((fields) => fields.map((field) => field.value)).catch(() => [])
+    )
+  );
+  return [...new Set(values.flat().filter((v) => typeof v === "string" && v.length > 0))];
+}
+var VALUED_NODE = /^(\s*- [\w-]+(?: "(?:[^"\\]|\\.)*")?(?: \[[^\]]*\])*): (.+)$/;
+var ESCAPES = {
+  "\\": "\\\\",
+  '"': '\\"',
+  "\b": "\\b",
+  "\f": "\\f",
+  "\n": "\\n",
+  "\r": "\\r",
+  "	": "\\t"
+};
+function escapedInQuotes(value) {
+  let out = "";
+  for (const c of value) {
+    const code = c.charCodeAt(0);
+    const control2 = code < 32 || code >= 127 && code <= 159;
+    out += ESCAPES[c] ?? (control2 ? `\\x${code.toString(16).padStart(2, "0")}` : c);
+  }
+  return out;
 }
-function textOf2(body) {
+function withoutFieldSecrets(snapshot, secrets) {
+  const values = [...new Set(secrets.filter(Boolean))];
+  if (!values.length) return snapshot;
+  const shown2 = new Set(values.flatMap((value) => [value, `"${escapedInQuotes(value)}"`]));
+  let out = snapshot.split("\n").map((line) => {
+    const node = VALUED_NODE.exec(line);
+    return node && shown2.has(node[2].trim()) ? `${node[1]}: ${HIDDEN_VALUE}` : line;
+  }).join("\n");
+  for (const value of values) {
+    if (value.length < 8) continue;
+    for (const written of /* @__PURE__ */ new Set([value, escapedInQuotes(value)])) out = out.split(written).join(HIDDEN_VALUE);
+  }
+  return out;
+}
+async function readSnapshot(page, depth, image) {
+  const none = { url: "", title: "", snapshot: null, cut: false, image: null };
+  if (page.isClosed()) return { ok: false, message: "The stopped page closed.", ...none };
+  const url = hideSecretsInUrl(page.url()).slice(0, 8192);
+  const title = hideSecretsInText(await page.title().catch(() => "")).slice(0, 1e3);
+  let snapshot;
   try {
-    const text = new TextDecoder("utf-8", { fatal: true }).decode(body);
-    return text.includes("\0") ? null : text;
-  } catch {
-    return null;
+    snapshot = await page.ariaSnapshot({ mode: "ai", timeout: ACT_MS, ...depth === null ? {} : { depth } });
+  } catch (error) {
+    return { ok: false, message: failed("The stopped page could not be read", error), ...none, url, title };
+  }
+  const hidden2 = hideSecretsInText(withoutFieldSecrets(snapshot, await fieldSecrets(page)));
+  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 viewport = page.viewportSize();
+    if (data) shot = { mime: "image/jpeg", data: data.toString("base64"), ...viewport };
   }
+  return {
+    ok: true,
+    message: image && !shot ? "The stopped page, without an image: none could be taken." : "The stopped page.",
+    url,
+    title,
+    snapshot: cut ? hidden2.slice(0, MAX_AGENT_SNAPSHOT) : hidden2,
+    cut,
+    image: shot
+  };
 }
-function startKeeping(now = Date.now()) {
-  keeping = { startedAt: now, kept: [], last: 0 };
+var heldIn = (el, args) => {
+  const field = el;
+  const tag = (field.tagName ?? "").toLowerCase();
+  const control2 = tag === "input" || tag === "textarea" || tag === "select";
+  const type = typeof field.type === "string" ? field.type.toLowerCase() : null;
+  const secret = typeof field.matches === "function" && field.matches(args.secretFields);
+  const words = typeof field.textContent === "string" ? field.textContent.replace(/\u200b/g, "").replace(/\s+/g, " ").trim() : "";
+  const value = control2 && !secret && typeof field.value === "string" ? field.value : null;
+  return {
+    secret,
+    text: words ? { read: words.slice(0, args.read), length: words.length } : null,
+    value: value === null ? null : { read: value.slice(0, args.read), length: value.length },
+    checked: tag === "input" && (type === "checkbox" || type === "radio") ? field.checked === true : null
+  };
+};
+var READ_PAST = 1e3;
+function hiddenAndCut(held2, max) {
+  const hidden2 = hideSecretsInText(held2.read);
+  return { text: hidden2.slice(0, max), cut: held2.length > max || hidden2.length > max };
+}
+async function ranked(page, probe, locator, handle, testIdAttribute) {
+  const { attrs, accessibleName, candidates } = await rankedCandidates(probe, locator, handle, testIdAttribute);
+  const held2 = await handle.evaluate(heldIn, { secretFields: SECRET_FIELDS, read: MAX_ACT_VALUE + READ_PAST });
+  const checked = [];
+  for (const candidate of candidates.slice(0, MAX_CHECKED)) {
+    checked.push({
+      locator: candidate.locator,
+      method: candidate.method,
+      score: candidate.score,
+      unique: await findsAlone(page, candidate.locator, handle)
+    });
+  }
+  const locators = [...checked.filter((l) => l.unique), ...checked.filter((l) => !l.unique)];
+  const { secret } = held2;
+  const text = held2.text ? hiddenAndCut(held2.text, MAX_ELEMENT_TEXT) : null;
+  const value = held2.value && !secret ? hiddenAndCut(held2.value, MAX_ACT_VALUE) : null;
+  const role = resolveAriaRole({ ...attrs, accessibleName });
+  return {
+    element: {
+      tagName: attrs.tagName.toLowerCase(),
+      role,
+      name: accessibleName ? hideSecretsInText(accessibleName).slice(0, 1e3) : null,
+      testId: attrs.attributes[testIdAttribute ?? "data-testid"] ?? null,
+      text: text?.text ?? null,
+      textCut: text?.cut ?? false,
+      value: value?.text ?? null,
+      valueCut: value?.cut ?? false,
+      checked: held2.checked,
+      secret
+    },
+    locators
+  };
 }
-function stopKeeping() {
-  keeping = null;
+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);
 }
-async function keepResponse(request, response) {
-  const into = keeping;
-  if (!into || !response) return;
+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 kind = request.resourceType();
-    if (kind !== "fetch" && kind !== "xhr") return;
-    const url = hideSecretsInUrl(request.url());
-    const method = request.method().toUpperCase();
-    if (url.length > 8192 || !/^[A-Z]{1,16}$/.test(method)) return;
-    const headers = response.headers();
-    const type = mimeOf(headers["content-type"]);
-    if (type && !TEXT_TYPE.test(type)) return;
-    const status = response.status();
-    if (status < 100 || status > 599) return;
-    const time = Math.max(0, Math.round(Date.now() - into.startedAt));
-    const size = /^\d+$/.test(headers["content-length"] ?? "") ? Number(headers["content-length"]) : null;
-    if (size !== null && size > MAX_KEPT_BODY) return;
-    into.kept.push({ id: ++into.last, method, url, status, type, size, time, response });
-    if (into.kept.length > MAX_KEPT_RESPONSES) into.kept.splice(0, into.kept.length - MAX_KEPT_RESPONSES);
-  } catch {
+    const { element, locators } = await ranked(page, probe, byRef(page, ref), handle, testIdAttribute);
+    const alone = locators.filter((l) => l.unique).length;
+    return {
+      ok: true,
+      message: alone ? `${alone === 1 ? "1 locator finds" : `${alone} locators find`} that element alone.` : "No locator Piwi tried finds that element alone on the page.",
+      element,
+      locators
+    };
+  } catch (error) {
+    return { ok: false, message: failed("The element could not be read", error), element: null, locators: [] };
+  } finally {
+    await handle.dispose().catch(() => void 0);
+  }
+}
+async function play(locator, action, value) {
+  const options = { timeout: ACT_MS };
+  switch (action) {
+    case "click":
+      return locator.click(options);
+    case "fill":
+      return locator.fill(value ?? "", options);
+    case "press":
+      return locator.press(value ?? "", options);
+    case "check":
+      return locator.check(options);
+    case "uncheck":
+      return locator.uncheck(options);
+    case "select":
+      await locator.selectOption(value ?? "", options);
+  }
+}
+function barLetsThrough(through) {
+  const bar = globalThis.document?.getElementById("__piwi-pause-bar");
+  if (bar) bar.style.pointerEvents = through ? "none" : "";
+}
+var PLAYED = {
+  click: "Clicked",
+  fill: "Filled",
+  press: "Pressed a key on",
+  check: "Checked",
+  uncheck: "Unchecked",
+  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);
+  } catch (error) {
+    return { ok: false, message: failed("The element could not be read", error), element: null, locators: [] };
+  } finally {
+    await handle.dispose().catch(() => void 0);
+  }
+  try {
+    await page.evaluate(barLetsThrough, true).catch(() => void 0);
+    await play(byRef(page, act.ref), act.action, act.value);
+  } catch (error) {
+    return { ok: false, message: failed(`${PLAYED[act.action]} ${act.ref} failed`, error), ...before };
+  } finally {
+    await page.evaluate(barLetsThrough, false).catch(() => void 0);
   }
+  return { ok: true, message: `${PLAYED[act.action]} ${act.ref}.`, ...before };
 }
-function keptRequests() {
-  return (keeping?.kept ?? []).map(({ id, method, url, status, type, size, time }) => ({
-    id,
-    method,
-    url,
-    status,
-    type,
-    size,
-    time
-  }));
+function canBind(browser) {
+  return typeof browser?.bind === "function";
 }
-async function keptResponse(id) {
-  const found = keeping?.kept.find((kept) => kept.id === id);
-  if (!found) return { refusal: "The test kept no such response: it keeps the latest 50." };
-  let body;
+async function bindBrowser(browser, name, workspaceDir, on) {
+  const bindable = browser;
+  if (!bindable || !canBind(browser)) {
+    return {
+      ok: false,
+      message: "Sharing with Playwright tools needs Playwright 1.59 or later (browser.bind): update @playwright/test.",
+      name: null,
+      endpoint: null
+    };
+  }
   try {
-    body = await internalCall(found.response, () => found.response.body());
-  } catch {
+    if (!on) {
+      await bindable.unbind?.();
+      return {
+        ok: true,
+        message: "The browser is no longer shared with Playwright tools.",
+        name: null,
+        endpoint: null
+      };
+    }
+    const { endpoint } = await bindable.bind(name, { workspaceDir });
     return {
-      refusal: "The browser no longer holds this answer's body: mock one the page received since it last loaded."
+      ok: true,
+      message: `The browser is shared with Playwright tools as ${name} until the test ends: any process of yours can drive it.`,
+      name,
+      endpoint: endpoint.slice(0, 4096)
     };
+  } catch (error) {
+    return { ok: false, message: failed("The browser could not be shared", error), name: null, endpoint: null };
   }
-  if (body.length > MAX_KEPT_BODY) return { refusal: "This answer is larger than 256 KB: Piwi mocks a smaller one." };
-  const text = textOf2(body);
-  if (text === null) return { refusal: "This answer is not text: Piwi mocks a text answer." };
-  return { method: found.method, url: found.url, status: found.status, type: found.type, body: text };
 }
 
-// src/internal/capture/record-handoff.ts
-var fs6 = __toESM(require("fs"));
-var net = __toESM(require("net"));
+// src/internal/capture/run-events.ts
 var path9 = __toESM(require("path"));
 
+// src/internal/capture/run-channel.ts
+var net = __toESM(require("net"));
+
 // ../core/src/ide-recorder.ts
 var IDE_RECORDER_BINDING = "__piwiRecorder";
 var IDE_DISPATCH_GLOBAL = "__piwiIdeDispatch";
@@ -5318,10 +6132,10 @@ function parseRecordChannel(value) {
   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;
+  const path16 = text.slice(0, hash);
+  return /^[A-Za-z0-9_-]{16,}$/.test(token) && !path16.includes("\0") ? { path: path16, token } : null;
 }
-function isObject3(value) {
+function isObject4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseHandoffToTest(line) {
@@ -5331,7 +6145,7 @@ function parseHandoffToTest(line) {
   } catch {
     return null;
   }
-  if (!isObject3(value)) return null;
+  if (!isObject4(value)) return null;
   switch (value.type) {
     case "refused":
       return typeof value.message === "string" ? { type: "refused", message: value.message } : null;
@@ -5363,205 +6177,803 @@ function lineReader(onLine, 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 };
+// src/internal/capture/kept-responses.ts
+var keeping = null;
+var TEXT_TYPE = /^(?:text\/[\w.+-]+|application\/(?:[\w.+-]+\+)?(?:json|xml)|application\/(?:javascript|x-www-form-urlencoded|graphql))$/i;
+function mimeOf(contentType) {
+  return (contentType ?? "").split(";")[0].trim().toLowerCase();
+}
+function textOf2(body) {
+  try {
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(body);
+    return text.includes("\0") ? null : text;
+  } catch {
+    return null;
   }
-  return { ok: false, error: "No recording runs in this page." };
 }
-function canRecordFromHere(channel = process.env[RECORD_CHANNEL_ENV]) {
-  return parseRecordChannel(channel) !== null;
+function startKeeping(now = Date.now()) {
+  keeping = { startedAt: now, kept: [], last: 0 };
 }
-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]) };
+function stopKeeping() {
+  keeping = null;
 }
-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 socket2 = net.connect(channel.path);
-    socket2.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 (!socket2.destroyed) socket2.write(`${JSON.stringify(message)}
-`);
-    };
-    const onPage = () => send({ type: "notice", message: NEW_TAB_NOTICE });
-    const onGone = () => {
-      if (attached) send({ type: "closed" });
-      finish("the page closed.");
+async function keepResponse(request, response) {
+  const into = keeping;
+  if (!into || !response) return;
+  try {
+    const kind = request.resourceType();
+    if (kind !== "fetch" && kind !== "xhr") return;
+    const url = hideSecretsInUrl(request.url());
+    const method = request.method().toUpperCase();
+    if (url.length > 8192 || !/^[A-Z]{1,16}$/.test(method)) return;
+    const headers = response.headers();
+    const type = mimeOf(headers["content-type"]);
+    if (type && !TEXT_TYPE.test(type)) return;
+    const status = response.status();
+    if (status < 100 || status > 599) return;
+    const time = Math.max(0, Math.round(Date.now() - into.startedAt));
+    const size = /^\d+$/.test(headers["content-length"] ?? "") ? Number(headers["content-length"]) : null;
+    if (size !== null && size > MAX_KEPT_BODY) return;
+    into.kept.push({ id: ++into.last, method, url, status, type, size, time, response });
+    if (into.kept.length > MAX_KEPT_RESPONSES) into.kept.splice(0, into.kept.length - MAX_KEPT_RESPONSES);
+  } catch {
+  }
+}
+function keptRequests() {
+  return (keeping?.kept ?? []).map(({ id, method, url, status, type, size, time }) => ({
+    id,
+    method,
+    url,
+    status,
+    type,
+    size,
+    time
+  }));
+}
+async function keptResponse(id) {
+  const found = keeping?.kept.find((kept) => kept.id === id);
+  if (!found) return { refusal: "The test kept no such response: it keeps the latest 50." };
+  let body;
+  try {
+    body = await internalCall(found.response, () => found.response.body());
+  } catch {
+    return {
+      refusal: "The browser no longer holds this answer's body: mock one the page received since it last loaded."
     };
-    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 (body.length > MAX_KEPT_BODY) return { refusal: "This answer is larger than 256 KB: Piwi mocks a smaller one." };
+  const text = textOf2(body);
+  if (text === null) return { refusal: "This answer is not text: Piwi mocks a text answer." };
+  return { method: found.method, url: found.url, status: found.status, type: found.type, body: text };
+}
+
+// src/internal/capture/live-view.ts
+var http = __toESM(require("http"));
+var https = __toESM(require("https"));
+
+// ../core/src/live-view.ts
+var LIVE_VIEW_ENV = "PIWI_LIVE_VIEW";
+var LIVE_FRAME_WIDTH = 640;
+var LIVE_FRAME_HEIGHT = 400;
+var LIVE_FRAME_QUALITY = 50;
+var LIVE_FRAME_FPS = 4;
+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 KEY = /^pdl_[A-Za-z0-9_-]{43}$/;
+function isLiveViewKey(value) {
+  return typeof value === "string" && KEY.test(value);
+}
+function parseLiveViewEnv(value) {
+  if (!value || value.length > 4096) return null;
+  const hash = value.lastIndexOf("#");
+  if (hash < 0) return null;
+  const key = value.slice(hash + 1);
+  if (!isLiveViewKey(key)) return null;
+  let url;
+  try {
+    url = new URL(value.slice(0, hash));
+  } catch {
+    return null;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+  if (url.search || url.username || url.password) return null;
+  const run = /\/api\/test-runs\/(\d{1,15})\/live-view$/.exec(url.pathname);
+  if (!run) return null;
+  const runId = Number(run[1]);
+  if (!Number.isSafeInteger(runId) || runId < 1) return null;
+  return { url: url.toString(), runId, key };
+}
+function liveRunPage(address) {
+  const url = new URL(address.url);
+  url.pathname = url.pathname.replace(/\/api\/test-runs\/\d+\/live-view$/, `/test-runs/${address.runId}`);
+  url.hash = "";
+  return url.toString();
+}
+var MISSING = ["no-instance", "unregistered", "off", "local"];
+function parseLiveViewMissing(value) {
+  const why = value?.startsWith("none:") ? value.slice(5) : null;
+  return why && MISSING.includes(why) ? why : null;
+}
+var LIVE_SHARE_MISSING = {
+  "no-instance": "This run cannot be shared live: it reports to no Piwi instance. Name your team's instance in PIWI_DASHBOARD_URL.",
+  unregistered: "This run cannot be shared live: the reporter's global setup did not register it with the instance as it started (wrapConfig adds it).",
+  off: "This run cannot be shared live: its project's live view is off on the instance. A Project admin turns it on in Project \u2192 Settings \u2192 Live view.",
+  local: "This run cannot be shared live: it reports to the Piwi desktop app on this machine, which no teammate reaches. Name your team's instance in PIWI_DASHBOARD_URL to share a run there."
+};
+var LIVE_SHARE_UNKNOWN = "This run cannot be shared live: the Piwi reporter gave its workers no live view key.";
+function liveShareRefusal(status) {
+  switch (status) {
+    case 404:
+      return "Sharing stopped: the project's live view was turned off on the instance.";
+    case 401:
+    case 403:
+      return "Sharing stopped: the instance no longer takes this run's live view key (it started again, or gave the key up).";
+    case 410:
+      return "Sharing stopped: the run is no longer live on the instance.";
+    case 409:
+      return "Sharing stopped: the instance holds the run as interrupted, having heard nothing from it for a while. Share the run again once it reports there again.";
+    default:
+      return "Sharing stopped: the instance did not answer. Share the run again to try once more.";
+  }
+}
+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;
+}
+function parseInstanceToWorker(data) {
+  let value;
+  try {
+    value = JSON.parse(data);
+  } catch {
+    return null;
+  }
+  if (!isObject5(value) || value.type !== "viewers" || !isInt2(value.count, 0, 1e6)) return null;
+  return { type: "viewers", count: value.count };
+}
+
+// src/internal/support/shard-info.ts
+function parseShardSpec(raw) {
+  const match = raw?.trim().match(/^(\d+)\s*\/\s*(\d+)$/);
+  if (!match) return null;
+  const current = Number(match[1]);
+  const total = Number(match[2]);
+  return current >= 1 && current <= total && total > 1 ? { current, total } : null;
+}
+function resolveShardInfo(config, env = process.env) {
+  const pwShard = config.shard;
+  if (pwShard && pwShard.total > 1) return { current: pwShard.current, total: pwShard.total };
+  return parseShardSpec(env[PIWI_SHARD_ENV]);
+}
+
+// src/internal/capture/page-view.ts
+var HOLDERS = /* @__PURE__ */ new WeakMap();
+var TEST_SCREENCASTS = /* @__PURE__ */ new WeakSet();
+var OWN_SCREENCASTS = /* @__PURE__ */ new WeakMap();
+function screencastOf(page) {
+  const seen = page.screencast;
+  return (seen && OWN_SCREENCASTS.get(seen)) ?? seen;
+}
+function yieldToTest(page) {
+  TEST_SCREENCASTS.add(page);
+  const holders = HOLDERS.get(page);
+  if (!holders?.size) return null;
+  return Promise.all([...holders].map((holder) => holder.release()));
+}
+function guardScreencast(page) {
+  const own = page.screencast;
+  if (!own || typeof own !== "object" || OWN_SCREENCASTS.has(own)) return;
+  const guarded = new Proxy(own, {
+    get(target, prop) {
+      const value = Reflect.get(target, prop);
+      if (typeof value !== "function") return value;
+      if (prop !== "start" && prop !== "stop") return (...args) => callMethod(target, prop, args);
+      return (...args) => {
+        const yielded = yieldToTest(page);
+        return yielded ? yielded.then(() => callMethod(target, prop, args)) : callMethod(target, prop, args);
+      };
+    }
+  });
+  OWN_SCREENCASTS.set(guarded, own);
+  try {
+    page.screencast = guarded;
+  } catch {
+  }
+}
+async function viewportOf(page) {
+  const size = page.viewportSize();
+  if (size) return size;
+  const read = await internalCall(
+    page,
+    () => page.evaluate(() => {
+      const { innerWidth, innerHeight } = globalThis;
+      return { width: innerWidth, height: innerHeight };
+    })
+  ).catch(() => null);
+  return read && isViewSize(read.width, read.height) ? read : null;
+}
+async function openPageView(page, options) {
+  const viewport = await viewportOf(page);
+  if (!viewport) return null;
+  let closed = false;
+  let last = null;
+  let sent2 = null;
+  let refused = false;
+  const interval = 1e3 / options.fps;
+  const pacer = new LatestPacer({
+    intervalMs: interval,
+    ...options.spacing ? { spacing: options.spacing } : {},
+    busy: options.busy,
+    send: (frame) => {
+      if (!options.live()) return;
+      refused = false;
+      sent2 = frame;
+      options.send(frame);
+    }
+  });
+  let lighter = null;
+  let lighterAt = -Infinity;
+  const lighten = () => {
+    const now = Date.now();
+    if (lighter || now - lighterAt < options.shotMs) return;
+    lighterAt = now;
+    lighter = internalCall(
+      page,
+      () => page.screenshot({ type: "jpeg", quality: options.lightQuality, scale: "css", caret: "initial", timeout: 5e3 })
+    ).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();
+      },
+      () => void 0
+    ).finally(() => {
+      lighter = null;
+    });
+  };
+  const onFrame = (data, width, height) => {
+    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 });
+  };
+  const screencast = screencastOf(page);
+  let end = null;
+  let shots = null;
+  let shooting = false;
+  const shoot = async () => {
+    shots = null;
+    if (closed || page.isClosed()) return;
+    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 (!closed) {
+      shots = setTimeout(() => void shoot(), options.shotMs);
+      shots.unref?.();
+    }
+  };
+  const takeShots = () => {
+    if (shooting || closed) return;
+    shooting = true;
+    void shoot();
+  };
+  const acks = new FrameAcks(interval);
+  const holders = HOLDERS.get(page) ?? /* @__PURE__ */ new Set();
+  HOLDERS.set(page, holders);
+  let starting = null;
+  const holder = {
+    release: async () => {
+      holders.delete(holder);
+      await starting?.catch(() => void 0);
+      const stop = end;
+      end = null;
+      if (stop && !page.isClosed()) await stop().catch(() => void 0);
+      takeShots();
+    }
+  };
+  if (typeof screencast?.start === "function" && !TEST_SCREENCASTS.has(page)) {
+    holders.add(holder);
+    starting = internalCall(
+      page,
+      () => screencast.start({
+        size: options.size(viewport),
+        quality: options.quality,
+        onFrame: (frame) => {
+          onFrame(frame.data, frame.viewportWidth, frame.viewportHeight);
+          return acks.next();
         }
-        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);
-      socket2.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 });
+      })
+    );
+    try {
+      const started = await starting;
+      end = () => internalCall(page, async () => {
+        if (typeof started?.dispose === "function") await started.dispose();
+        else await screencast.stop?.();
+      });
+    } catch {
+      holders.delete(holder);
+      takeShots();
+    }
+  } else {
+    takeShots();
+  }
+  return {
+    get screencast() {
+      return end !== null;
+    },
+    resend: () => {
+      if (closed || !sent2 || !options.live()) return;
+      if (sent2 === "refused") options.refuse();
+      else options.send(sent2);
+    },
+    close: async () => {
+      closed = true;
+      sent2 = null;
+      acks.close();
+      pacer.close();
+      if (shots) clearTimeout(shots);
+      holders.delete(holder);
+      await lighter;
+      const stop = end;
+      end = null;
+      if (stop && !page.isClosed()) await stop().catch(() => void 0);
+    }
+  };
+}
+
+// src/internal/capture/live-view.ts
+var RETRY_MS = [1e3, 2e3, 4e3, 8e3, 16e3];
+var MAX_RECONNECTS = 20;
+var STEADY_MS = 3e4;
+var STREAM_IDLE_MS = 45e3;
+var POST_TIMEOUT_MS = 1e4;
+var MAX_EVENT_TEXT = 64 * 1024;
+var MAX_STATES_WAITING = 8;
+var LIGHT_QUALITY = 30;
+var SHOT_MS = 1e3;
+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.`;
+var NO_PAGE = "This test has no page to show yet.";
+var NO_TEST = "No test runs on this worker now: the next one shows once it opens its page.";
+var link = null;
+var missing = null;
+var changes = /* @__PURE__ */ new Set();
+var shareTurn = Promise.resolve();
+var running = null;
+var view = null;
+var hidden = null;
+function hideKey(env) {
+  const value = env[LIVE_VIEW_ENV];
+  if (value === void 0 || hidden) return;
+  delete env[LIVE_VIEW_ENV];
+  const onStop = (message) => {
+    if (message?.method !== "__stop__") return;
+    env[LIVE_VIEW_ENV] = value;
+    process.nextTick(() => {
+      if (hidden?.onStop === onStop) delete env[LIVE_VIEW_ENV];
     });
-    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;
+  };
+  process.prependListener("message", onStop);
+  hidden = { env, value, onStop };
+}
+function showKey() {
+  const own = hidden;
+  hidden = null;
+  if (!own) return;
+  process.off("message", own.onStop);
+  own.env[LIVE_VIEW_ENV] = own.value;
+}
+function liveViewOpen() {
+  return link !== null;
+}
+function active(own) {
+  return !own.ended && own.refused === null && own.sharing;
+}
+function changed() {
+  for (const listener of changes) listener();
+}
+function onLiveViewChange(listener) {
+  changes.add(listener);
+  return () => changes.delete(listener);
+}
+function liveViewState() {
+  const own = link;
+  if (!own) return { can: false, on: false, viewers: 0, page: null, why: missing ?? LIVE_SHARE_UNKNOWN };
+  const page = liveRunPage(own.address);
+  if (own.refused) return { can: false, on: false, viewers: 0, page, why: own.refused };
+  const on = active(own);
+  return { can: true, on, viewers: on ? own.viewers : 0, page, why: own.lost };
+}
+function openLiveView(worker, env = process.env, ci = detectCi(env)) {
+  if (link) return false;
+  const value = env[LIVE_VIEW_ENV];
+  const address = parseLiveViewEnv(value);
+  hideKey(env);
+  if (!address) {
+    const why = parseLiveViewMissing(value);
+    missing = why ? LIVE_SHARE_MISSING[why] : LIVE_SHARE_UNKNOWN;
+    changed();
+    return false;
+  }
+  missing = null;
+  const secure = address.url.startsWith("https:");
+  const client = secure ? https : http;
+  link = {
+    address,
+    id: { shard: resolveShardInfo(worker.config, env)?.current ?? null, worker: worker.workerIndex },
+    client,
+    agent: new client.Agent({ keepAlive: true, maxSockets: 2 }),
+    stream: null,
+    timer: null,
+    retries: 0,
+    reconnects: 0,
+    ended: false,
+    refused: null,
+    sharing: ci,
+    lost: null,
+    answered: null,
+    viewers: 0,
+    states: Promise.resolve(),
+    statesWaiting: 0,
+    stop: null,
+    posting: false
+  };
+  if (ci) connect(link);
+  changed();
+  return true;
+}
+function closeLiveView() {
+  const own = link;
+  link = null;
+  running = null;
+  missing = null;
+  showKey();
+  void stopView();
+  if (!own) return;
+  own.ended = true;
+  if (own.timer) clearTimeout(own.timer);
+  own.stream?.destroy();
+  own.agent.destroy();
+}
+function shareLiveView(on) {
+  const turn = shareTurn.then(() => on ? startSharing() : stopSharing());
+  shareTurn = turn.catch(() => void 0);
+  return turn;
+}
+function startSharing() {
+  const own = link;
+  if (!own || own.ended || own.refused || own.sharing) return;
+  own.sharing = true;
+  own.lost = null;
+  own.answered = null;
+  own.retries = 0;
+  own.reconnects = 0;
+  connect(own);
+  changed();
+}
+async function stopSharing() {
+  const own = link;
+  if (!own || own.ended || !own.sharing) return;
+  const streamed = own.stream !== null && own.refused === null;
+  own.sharing = false;
+  own.lost = null;
+  if (own.timer) clearTimeout(own.timer);
+  own.timer = null;
+  await stopView();
+  if (streamed) await send(own, { type: "unshared", ...own.id });
+  own.stream?.destroy();
+  own.stream = null;
+  own.viewers = 0;
+  changed();
+}
+function liveViewTestBegan(title, call) {
+  if (!link) return;
+  running = { title, page: null, call };
+}
+function liveViewPage(page) {
+  if (!link || !running || running.page) return;
+  running.page = page;
+  if (link.viewers > 0 && active(link)) startView();
+}
+async function liveViewTestEnded() {
+  if (!running) return;
+  running = null;
+  await stopView();
+  const own = link;
+  if (own && own.viewers > 0 && active(own)) void post(own, { type: "ended", ...own.id });
+}
+function liveViewStopped(stop) {
+  const own = link;
+  if (!own || own.ended) return () => void 0;
+  const shown2 = { ...stop, call: hideCallSecrets(stop.call) };
+  own.stop = shown2;
+  postState(own, { type: "stop", ...own.id, stop: shown2 });
+  return () => {
+    if (own.stop === shown2) own.stop = null;
+    postState(own, { type: "stop", ...own.id, stop: null });
+  };
+}
+function hideCallSecrets(call) {
+  return { ...call, title: hideSecretsInText(call.title) };
+}
+function postState(own, message) {
+  if (!active(own) || own.statesWaiting >= MAX_STATES_WAITING) return;
+  own.statesWaiting++;
+  own.states = own.states.then(() => post(own, message)).finally(() => {
+    own.statesWaiting--;
+  });
+}
+function connect(own) {
+  if (!active(own)) return;
+  const url = new URL(own.address.url);
+  url.searchParams.set("worker", String(own.id.worker));
+  if (own.id.shard !== null) url.searchParams.set("shard", String(own.id.shard));
+  let openedAt = null;
+  let dropped = false;
+  const drop = (status) => {
+    if (dropped) return;
+    dropped = true;
+    if (own.stream !== request) return;
+    own.stream = null;
+    setViewers(own, 0);
+    if (!active(own)) return;
+    if (openedAt !== null && Date.now() - openedAt >= STEADY_MS) own.retries = 0;
+    if (status !== null) own.answered = status;
+    if (status !== null && GIVE_UP.has(status)) return void refuse(own, status);
+    if (own.retries >= RETRY_MS.length || own.reconnects >= MAX_RECONNECTS) return void giveUp(own);
+    const wait = RETRY_MS[own.retries++];
+    own.reconnects++;
+    own.timer = setTimeout(() => {
+      own.timer = null;
+      connect(own);
+    }, wait);
+    own.timer.unref?.();
+  };
+  const request = own.client.request(url, {
+    method: "GET",
+    agent: own.agent,
+    headers: {
+      Accept: "text/event-stream",
+      Authorization: `Bearer ${own.address.key}`,
+      "Cache-Control": "no-cache"
+    }
+  });
+  own.stream = request;
+  request.on("socket", (socket2) => socket2.unref());
+  request.setTimeout(STREAM_IDLE_MS, () => request.destroy());
+  request.on("error", () => drop(null));
+  request.on("close", () => drop(null));
+  request.on("response", (response) => {
+    if (response.statusCode !== 200) {
+      response.resume();
+      return drop(response.statusCode ?? null);
+    }
+    openedAt = Date.now();
+    own.answered = null;
+    if (own.stop) postState(own, { type: "stop", ...own.id, stop: own.stop });
+    response.setEncoding("utf8");
+    let text = "";
+    response.on("data", (chunk) => {
+      text += chunk;
+      if (text.length > MAX_EVENT_TEXT && !text.includes("\n\n")) return void request.destroy();
+      let end;
+      while ((end = text.indexOf("\n\n")) >= 0) {
+        const block = text.slice(0, end);
+        text = text.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 (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" });
-    };
-    socket2.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,
-        ...options.mode === "check" ? { mode: "check", stop: options.stop ?? null } : {}
-      });
     });
-    socket2.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.")
-      )
-    );
-    socket2.on("error", (error) => finish(`the editor could not be reached: ${error.message}`));
-    socket2.on("close", () => finish("the editor closed the recording."));
+    response.on("error", () => drop(null));
+    response.on("close", () => drop(null));
+  });
+  request.end();
+}
+function refuse(own, status) {
+  if (own.refused !== null) return;
+  own.refused = liveShareRefusal(status);
+  own.viewers = 0;
+  own.stream?.destroy();
+  own.agent.destroy();
+  void stopView();
+  changed();
+}
+function giveUp(own) {
+  own.sharing = false;
+  own.lost = liveShareRefusal(own.answered);
+  own.viewers = 0;
+  if (own.timer) clearTimeout(own.timer);
+  own.timer = null;
+  own.stream?.destroy();
+  own.stream = null;
+  void stopView();
+  changed();
+}
+function setViewers(own, count) {
+  const before = own.viewers;
+  own.viewers = count;
+  if (own !== link) return;
+  if (count !== before) changed();
+  if (count === 0) return void stopView();
+  if (!active(own)) return;
+  if (!running) {
+    if (count > before) void post(own, { type: "frame", ...own.id, refused: NO_TEST });
+    return;
+  }
+  if (view) {
+    if (count > before) void view.opened.then((opened) => opened?.resend());
+    return;
+  }
+  startView();
+}
+function startView() {
+  const own = link;
+  const page = running?.page ?? null;
+  if (!own || !active(own) || view) return;
+  if (!page || page.isClosed()) {
+    void post(own, { type: "frame", ...own.id, refused: NO_PAGE });
+    return;
+  }
+  const live = () => view?.page === page && link === own && active(own) && own.viewers > 0;
+  const opened = openPageView(page, {
+    size: (viewport) => fitViewSize(viewport, LIVE_FRAME_WIDTH, LIVE_FRAME_HEIGHT),
+    quality: LIVE_FRAME_QUALITY,
+    fps: LIVE_FRAME_FPS,
+    spacing: (frame) => frame.data.length * 1e3 / LIVE_FRAME_BYTE_RATE,
+    maxFrameBytes: MAX_LIVE_FRAME,
+    lightQuality: LIGHT_QUALITY,
+    shotMs: SHOT_MS,
+    busy: () => own.posting,
+    live,
+    send: (frame) => postFrame(own, frame),
+    refuse: () => void post(own, { type: "frame", ...own.id, refused: TOO_HEAVY })
+  }).catch(() => null);
+  const onClose = () => {
+    if (view?.page === page) void stopView();
+  };
+  page.once("close", onClose);
+  view = { page, opened, onClose };
+}
+async function stopView() {
+  const shown2 = view;
+  view = null;
+  if (!shown2) return;
+  shown2.page.off("close", shown2.onClose);
+  const closed = shown2.opened.then((opened) => opened?.close());
+  let timer;
+  await Promise.race([
+    closed.catch(() => void 0),
+    new Promise((resolve5) => {
+      timer = setTimeout(resolve5, VIEW_END_MS);
+      timer.unref?.();
+    })
+  ]);
+  clearTimeout(timer);
+}
+function postFrame(own, frame) {
+  if (!active(own)) return;
+  own.posting = true;
+  const call = running?.call() ?? null;
+  const data = frame.data.toString("base64");
+  void post(own, {
+    type: "frame",
+    ...own.id,
+    data,
+    call: call && hideCallSecrets(call),
+    test: running?.title ?? null
+  }).catch(() => void 0).finally(() => {
+    own.posting = false;
+  });
+}
+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((resolve5) => {
+    let settled = false;
+    const settle = (status) => {
+      if (settled) return;
+      settled = true;
+      if (status !== null && GIVE_UP.has(status)) refuse(own, status);
+      resolve5(status);
+    };
+    const request = own.client.request(own.address.url, {
+      method: "POST",
+      agent: own.agent,
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(body),
+        Authorization: `Bearer ${own.address.key}`
+      }
+    });
+    request.on("socket", (socket2) => socket2.unref());
+    request.setTimeout(POST_TIMEOUT_MS, () => request.destroy());
+    request.on("error", () => settle(null));
+    request.on("close", () => settle(null));
+    request.on("response", (response) => {
+      response.resume();
+      response.on("end", () => settle(response.statusCode ?? null));
+      response.on("error", () => settle(null));
+    });
+    request.end(body);
   });
 }
 
 // src/internal/capture/run-channel.ts
-var net2 = __toESM(require("net"));
 var CONNECT_MS = 2e3;
-var BAR_HIDDEN = "#__piwi-pause-bar { display: none !important; }";
+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;
+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 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;
+var NEEDS_VIEW = "The input needs the live view of this stop: watch it first.";
+var NO_PAGE2 = "This stop has no page to show: its call does not name one among its context's pages. Use the pause bar in the test's window.";
 var socket = null;
 var control = null;
 var shown = /* @__PURE__ */ new Set();
+var host = null;
 var stops = 0;
 var held = null;
 var outline = null;
 var counting = Promise.resolve();
+var view2 = null;
+var viewStarting = null;
+var viewTurn = Promise.resolve();
+var viewEnds = /* @__PURE__ */ new Set();
+function freshInput() {
+  return {
+    rate: new RateWindow(MAX_VIEW_EVENT_RATE),
+    playing: Promise.resolve(),
+    waiting: 0,
+    buttons: /* @__PURE__ */ new Set(),
+    keys: /* @__PURE__ */ new Set()
+  };
+}
+var input = freshInput();
+var pickingAt = false;
+var runName = "";
+var eventsOn = false;
+var testRunning = false;
+var eventRate = new RateWindow(MAX_RUN_EVENT_RATE);
+var droppedEvents = 0;
+var agentTurn = Promise.resolve();
+var bound = null;
+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) {
+  const pairing = !!env[PIWI_LOCAL_DEBUG_ENV.editorSend];
+  const recorder = parseRecordChannel(env[RECORD_CHANNEL_ENV]) !== null;
+  return RUN_TAKES.filter(
+    (take) => take === "pick" ? pairing : take === "record" || take === "assert" ? recorder : true
+  );
+}
 async function openRunChannel(worker, handlers, env = process.env) {
   const channel = parseRecordChannel(env[RUN_CHANNEL_ENV]);
-  const ref = env[PIWI_ORIGIN_ENV.ref];
+  const ref = env[RUN_REF_ENV] ?? env[PIWI_ORIGIN_ENV.ref];
   if (socket || !channel || !ref || !/^[\w-]{1,64}$/.test(ref)) return false;
-  const opening = net2.connect(channel.path);
+  const opening = net.connect(channel.path);
   opening.setEncoding("utf8");
   const opened = await new Promise((resolve5) => {
     const timer = setTimeout(() => resolve5(false), CONNECT_MS);
@@ -5581,6 +6993,9 @@ async function openRunChannel(worker, handlers, env = process.env) {
   socket = opening;
   control = handlers;
   shown = /* @__PURE__ */ new Set();
+  runName = `piwi-${ref}-w${worker.workerIndex}`;
+  eventsOn = false;
+  host = null;
   opening.unref();
   opening.on(
     "data",
@@ -5592,8 +7007,13 @@ async function openRunChannel(worker, handlers, env = process.env) {
   opening.on("error", () => opening.destroy());
   opening.on("close", () => {
     if (socket === opening) socket = null;
+    unhearLive?.();
+    unhearLive = null;
+    if (sharedHere) void shareLiveView(false);
+    sharedHere = false;
+    if (view2) void stopView2();
     if (!held || held.bar) return;
-    console.log("[piwi] The connection to the editor closed: the test goes on.");
+    console.log(`[piwi] The connection to ${runHost()} closed: the test goes on.`);
     held.answer("resume");
   });
   tellHub({
@@ -5606,25 +7026,40 @@ async function openRunChannel(worker, handlers, env = process.env) {
     pid: process.pid,
     playwright: worker.config.version,
     reporter: getReporterVersion(),
-    takes: [...RUN_TAKES],
+    takes: workerTakes(env),
     holds: [...RUN_HOLDS]
   });
+  liveSaid = "";
+  tellLive();
+  unhearLive?.();
+  unhearLive = onLiveViewChange(tellLive);
   return true;
 }
+function tellLive() {
+  if (!runChannelOpen()) return;
+  const state = liveViewState();
+  const said = JSON.stringify(state);
+  if (said === liveSaid) return;
+  liveSaid = said;
+  tellHub({ type: "live", ...state });
+}
 function editorShows(what) {
   return runChannelOpen() && shown.has(what);
 }
+function runHost() {
+  return host ?? "the editor";
+}
 var HIDDEN_ENV = [RUN_CHANNEL_ENV, PIWI_LOCAL_DEBUG_ENV.editorSend];
 var hiddenEditorSend;
 function hideRunChannel(env = process.env) {
-  const hidden = HIDDEN_ENV.flatMap((name) => {
+  const hidden2 = HIDDEN_ENV.flatMap((name) => {
     const value = env[name];
     return value === void 0 ? [] : [{ name, value }];
   });
-  for (const { name } of hidden) delete env[name];
-  hiddenEditorSend = hidden.find(({ name }) => name === PIWI_LOCAL_DEBUG_ENV.editorSend)?.value;
+  for (const { name } of hidden2) delete env[name];
+  hiddenEditorSend = hidden2.find(({ name }) => name === PIWI_LOCAL_DEBUG_ENV.editorSend)?.value;
   return () => {
-    for (const { name, value } of hidden) env[name] = value;
+    for (const { name, value } of hidden2) env[name] = value;
     hiddenEditorSend = void 0;
   };
 }
@@ -5640,12 +7075,44 @@ function runChannelOpen() {
   return !!socket && !socket.destroyed;
 }
 function tellHub(message) {
+  if (message.type === "test-begin") testRunning = true;
+  if (message.type === "test-end") {
+    testRunning = false;
+    void unbind();
+  }
   if (socket && !socket.destroyed) socket.write(`${JSON.stringify(message)}
 `);
 }
+function runEventsWanted() {
+  return eventsOn && testRunning && runChannelOpen();
+}
+function tellEvent(event) {
+  if (!runEventsWanted()) return;
+  if (!eventRate.take(droppedEvents ? 2 : 1)) {
+    droppedEvents++;
+    return;
+  }
+  if (droppedEvents) tellHub({ type: "event", event: { kind: "dropped", count: droppedEvents } });
+  droppedEvents = 0;
+  tellHub({ type: "event", event });
+}
+async function unbind() {
+  const shared = bound?.browser;
+  bound = null;
+  if (shared?.isConnected()) {
+    await within2(
+      internalCall(shared, () => bindBrowser(shared, runName, process.cwd(), false)),
+      VIEW_END_MS2
+    );
+  }
+}
 function holdStop(stop, onAnswer) {
   const id = ++stops;
   let answered = false;
+  const needsBar = (what) => ({
+    ok: false,
+    message: `${RUN_INTENT_NAMES[what]} needs the pause bar in the test's window, and this stop shows none: run the test headed.`
+  });
   const holding = {
     stop: id,
     page: stop.page,
@@ -5655,10 +7122,13 @@ function holdStop(stop, onAnswer) {
       answered = true;
       onAnswer(choice);
     },
-    intent: (what) => answered ? { ok: false, message: WENT_ON } : stop.intent?.(what) ?? {
-      ok: false,
-      message: `${RUN_INTENT_NAMES[what]} needs the pause bar in the test's window, and this stop shows none: run the test headed.`
-    }
+    intent: (what) => answered ? { ok: false, message: WENT_ON } : (
+      // A stop no bar shows takes an intent only while its live view is watched, which drives it.
+      !stop.bar && view2?.stop !== id ? needsBar(what) : stop.intent?.(what) ?? needsBar(what)
+    ),
+    ...stop.pickAt ? { pickAt: stop.pickAt } : {},
+    ...stop.agent ? { agent: stop.agent } : {},
+    browser: stop.browser ?? null
   };
   held = holding;
   tellHub({
@@ -5679,10 +7149,193 @@ function holdStop(stop, onAnswer) {
       if (held === holding) held = null;
       await counting;
       if (outline?.stop === id) await removeOutline();
+      await endView(id, stop.page);
       tellHub({ type: "running", stop: id });
     }
   };
 }
+function viewEnded(stop) {
+  const ended = new AbortController();
+  if (view2?.stop !== stop) ended.abort();
+  else viewEnds.add(() => ended.abort());
+  return ended.signal;
+}
+async function within2(run, ms) {
+  await answerWithin(run, ms, void 0);
+}
+async function answerWithin(run, ms, late) {
+  let timer;
+  try {
+    return await Promise.race([
+      run.catch(() => late),
+      new Promise((resolve5) => timer = setTimeout(() => resolve5(late), ms))
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function endView(stop, page) {
+  if (viewStarting?.stop === stop) await within2(viewStarting.started, VIEW_END_MS2);
+  if (view2?.stop === stop) await stopView2();
+  const own = input;
+  input = freshInput();
+  await within2(own.playing, VIEW_END_MS2);
+  if (page && !page.isClosed() && (own.buttons.size || own.keys.size)) {
+    await within2(
+      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);
+      }),
+      VIEW_END_MS2
+    );
+  }
+}
+async function stopView2() {
+  const shown2 = view2;
+  view2 = null;
+  for (const end of viewEnds) end();
+  viewEnds.clear();
+  if (shown2) await within2(shown2.close(), VIEW_END_MS2);
+}
+function startView2(holding) {
+  if (view2?.stop === holding.stop) {
+    view2.resend();
+    return Promise.resolve({ ok: true, message: "The live view is on." });
+  }
+  if (viewStarting?.stop === holding.stop) return viewStarting.started;
+  const page = holding.page;
+  if (!page || page.isClosed()) return Promise.resolve({ ok: false, message: NO_PAGE2 });
+  const started = (async () => {
+    if (view2) await stopView2();
+    const opening = openView(page, holding.stop);
+    const opened = await answerWithin(opening, PAGE_ANSWER_MS, "late");
+    if (opened === "late") {
+      void opening.then((late) => late?.close());
+      return { ok: false, message: NO_ANSWER };
+    }
+    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);
+      return { ok: false, message: WENT_ON };
+    }
+    view2 = opened;
+    return {
+      ok: true,
+      message: opened.screencast ? "The live view is on." : "The live view is on, as images of the page twice a second: the page's screencast is in use."
+    };
+  })().finally(() => {
+    if (viewStarting?.started === started) viewStarting = null;
+  });
+  viewStarting = { stop: holding.stop, started };
+  return started;
+}
+async function openView(page, stop) {
+  const opened = await openPageView(page, {
+    size: viewSize,
+    quality: VIEW_QUALITY,
+    fps: MAX_VIEW_FPS,
+    maxFrameBytes: MAX_VIEW_FRAME,
+    lightQuality: LIGHT_QUALITY2,
+    shotMs: SHOT_MS2,
+    busy: () => !!socket && socket.writableLength > MAX_FRAME_BACKLOG,
+    // Once its stop began to end, no frame of it goes.
+    live: () => held?.stop === stop,
+    send: (frame) => tellHub({ type: "frame", stop, width: frame.width, height: frame.height, data: frame.data.toString("base64") }),
+    refuse: () => tellHub({ type: "frame", stop, refused: TOO_HEAVY2 })
+  });
+  if (!opened) return null;
+  const onClose = () => {
+    if (view2?.stop === stop) void stopView2();
+  };
+  page.once("close", onClose);
+  return {
+    stop,
+    screencast: opened.screencast,
+    resend: opened.resend,
+    close: async () => {
+      page.off("close", onClose);
+      await opened.close();
+    }
+  };
+}
+async function stopViewOf(holding) {
+  if (viewStarting?.stop === holding.stop) await within2(viewStarting.started, VIEW_END_MS2);
+  if (view2?.stop === holding.stop) await stopView2();
+  return { ok: true, message: "The live view is off." };
+}
+function playInput(holding, events) {
+  const page = holding.page;
+  if (!page || view2?.stop !== holding.stop) return Promise.resolve({ ok: false, message: NEEDS_VIEW });
+  const own = input;
+  if (own.waiting >= MAX_INPUT_WAITING) {
+    return Promise.resolve({ ok: false, message: "The page still plays the input sent before: send less at once." });
+  }
+  if (!own.rate.take(events.length)) {
+    return Promise.resolve({ ok: false, message: `Too much input: ${MAX_VIEW_EVENT_RATE} events a second at most.` });
+  }
+  own.waiting++;
+  const played = own.playing.then(async () => {
+    for (const [i, event] of events.entries()) {
+      if (held !== holding || input !== own || view2?.stop !== holding.stop || page.isClosed()) {
+        return { ok: false, message: i ? `The stop ended after ${i} of the events.` : WENT_ON };
+      }
+      try {
+        await internalCall(page, () => playEvent(page, event, own));
+      } catch (error) {
+        return {
+          ok: false,
+          message: hideSecretsInText(`Event ${i + 1} could not be played: ${errorMessage(error)}`)
+        };
+      }
+    }
+    return { ok: true, message: events.length === 1 ? "Played 1 event." : `Played ${events.length} events.` };
+  }).finally(() => own.waiting--);
+  own.playing = played.catch(() => void 0);
+  return played;
+}
+async function playEvent(page, event, own) {
+  switch (event.type) {
+    case "mouse":
+      if (event.action === "move") return page.mouse.move(event.x, event.y);
+      if (event.action === "click") {
+        return page.mouse.click(event.x, event.y, { button: event.button, clickCount: event.clickCount });
+      }
+      await page.mouse.move(event.x, event.y);
+      const pressed = {
+        button: event.button,
+        ...event.clickCount === void 0 ? {} : { clickCount: event.clickCount }
+      };
+      if (event.action === "down") {
+        own.buttons.add(event.button);
+        return page.mouse.down(pressed);
+      }
+      own.buttons.delete(event.button);
+      return page.mouse.up(pressed);
+    case "wheel":
+      await page.mouse.move(event.x, event.y);
+      return page.mouse.wheel(event.deltaX, event.deltaY);
+    case "key":
+      if (event.action === "press") return page.keyboard.press(event.key);
+      if (event.action === "down") {
+        own.keys.add(event.key);
+        return page.keyboard.down(event.key);
+      }
+      own.keys.delete(event.key);
+      return page.keyboard.up(event.key);
+    case "text":
+      return page.keyboard.insertText(event.text);
+  }
+}
+async function pickAtStop(holding, x, y) {
+  if (!holding.pickAt) return { ok: false, message: NO_PAGE2, locator: null };
+  if (pickingAt) return { ok: false, message: "A pick on the image runs: wait for its answer.", locator: null };
+  pickingAt = true;
+  try {
+    return await answerWithin(holding.pickAt(x, y), PAGE_ANSWER_MS, { ok: false, message: NO_ANSWER, locator: null });
+  } finally {
+    pickingAt = false;
+  }
+}
 async function removeOutline() {
   const shown2 = outline;
   outline = null;
@@ -5714,78 +7367,514 @@ async function countLocator(holding, source) {
     return { ok: false, message: `The locator could not be counted: ${errorMessage(error)}`, count: null };
   }
 }
-function onMessage(message) {
-  if (!message) return;
-  switch (message.type) {
-    case "attached":
-      shown = new Set(message.holds);
-      return;
-    case "breakpoints":
-      control?.breakpoints(message.places);
-      return;
-    case "control":
-      if (message.action === "pause") {
-        if (!held) control?.pause();
-      } else if (held?.stop === message.stop) held.answer(message.action);
-      return;
-    case "run-to":
-      if (held?.stop !== message.stop) return;
-      control?.runTo(message.place);
-      held.answer("resume");
-      return;
-    case "request": {
-      const { request } = message;
-      const at = message.what !== "image" && held?.stop === message.stop ? held : null;
-      switch (message.what) {
-        case "image":
-          void imageOf(held?.page ?? null).then((value) => tellHub({ type: "answer", request, what: "image", value }));
-          return;
-        case "requests": {
-          const requests = at ? keptRequests() : [];
-          const said = !at ? WENT_ON : requests.length ? `The test kept ${requests.length === 1 ? "1 response" : `${requests.length} responses`}.` : "The test kept no response yet: Piwi keeps the text answers of its fetch and XHR requests.";
-          tellHub({ type: "answer", request, what: "requests", value: { ok: !!at, message: said, requests } });
-          return;
-        }
-        case "mock": {
-          void (at ? keptResponse(message.id) : Promise.resolve({ refusal: WENT_ON })).then((found) => {
-            const value = "refusal" in found ? { ok: false, message: found.refusal, response: null } : { ok: true, message: `${found.method} ${found.url}`, response: found };
-            tellHub({ type: "answer", request, what: "mock", value });
-          });
-          return;
-        }
-        case "locator": {
-          const counted = at ? counting.then(
-            () => held === at ? countLocator(at, message.locator) : { ok: false, message: WENT_ON, count: null }
-          ) : Promise.resolve({ ok: false, message: WENT_ON, count: null });
-          counting = counted.catch(() => void 0);
-          void counted.then((value) => tellHub({ type: "answer", request, what: "locator", value }));
-          return;
-        }
-        default: {
-          const value = at ? at.intent(message.what) : { ok: false, message: WENT_ON };
-          tellHub({ type: "answer", request, what: message.what, value });
-          return;
+function onMessage(message) {
+  if (!message) return;
+  switch (message.type) {
+    case "attached":
+      shown = new Set(message.holds);
+      host = message.host ?? null;
+      return;
+    case "events":
+      eventsOn = message.on;
+      eventRate = new RateWindow(MAX_RUN_EVENT_RATE);
+      droppedEvents = 0;
+      return;
+    case "share":
+      sharedHere = message.on;
+      void shareLiveView(message.on).then(tellLive);
+      return;
+    case "breakpoints":
+      control?.breakpoints(message.places);
+      return;
+    case "control":
+      if (message.action === "pause") {
+        if (!held) control?.pause();
+      } else if (held?.stop === message.stop) held.answer(message.action);
+      return;
+    case "run-to":
+      if (held?.stop !== message.stop) return;
+      control?.runTo(message.place);
+      held.answer("resume");
+      return;
+    case "request": {
+      const { request } = message;
+      const at = message.what !== "image" && held?.stop === message.stop ? held : null;
+      switch (message.what) {
+        case "image":
+          void imageOf(held?.page ?? null).then((value) => tellHub({ type: "answer", request, what: "image", value }));
+          return;
+        case "requests": {
+          const requests = at ? keptRequests() : [];
+          const said = !at ? WENT_ON : requests.length ? `The test kept ${requests.length === 1 ? "1 response" : `${requests.length} responses`}.` : "The test kept no response yet: Piwi keeps the text answers of its fetch and XHR requests.";
+          tellHub({ type: "answer", request, what: "requests", value: { ok: !!at, message: said, requests } });
+          return;
+        }
+        case "mock": {
+          void (at ? keptResponse(message.id) : Promise.resolve({ refusal: WENT_ON })).then((found) => {
+            const value = "refusal" in found ? { ok: false, message: found.refusal, response: null } : { ok: true, message: `${found.method} ${found.url}`, response: found };
+            tellHub({ type: "answer", request, what: "mock", value });
+          });
+          return;
+        }
+        case "locator": {
+          const counted = at ? counting.then(
+            () => held === at ? countLocator(at, message.locator) : { ok: false, message: WENT_ON, count: null }
+          ) : Promise.resolve({ ok: false, message: WENT_ON, count: null });
+          counting = counted.catch(() => void 0);
+          void counted.then((value) => tellHub({ type: "answer", request, what: "locator", value }));
+          return;
+        }
+        case "view": {
+          const on = message.on;
+          const answered = viewTurn.then(
+            () => !at ? Promise.resolve({ ok: false, message: WENT_ON }) : on ? startView2(at) : stopViewOf(at)
+          );
+          viewTurn = answered.catch(() => void 0);
+          void answered.then((value) => tellHub({ type: "answer", request, what: "view", value }));
+          return;
+        }
+        case "input": {
+          const played = at ? playInput(at, message.events) : Promise.resolve({ ok: false, message: WENT_ON });
+          void played.then((value) => tellHub({ type: "answer", request, what: "input", value }));
+          return;
+        }
+        case "pick-at": {
+          const picked = at ? pickAtStop(at, message.x, message.y) : Promise.resolve({ ok: false, message: WENT_ON, locator: null });
+          void picked.then((value) => tellHub({ type: "answer", request, what: "pick-at", value }));
+          return;
+        }
+        case "snapshot": {
+          const { depth, image } = message;
+          const none = { url: "", title: "", snapshot: null, cut: false, image: null };
+          void agentAt(
+            at,
+            (agent) => agent.snapshot(depth, image),
+            (refused) => ({ ...refused, ...none })
+          ).then((value) => tellHub({ type: "answer", request, what: "snapshot", value }));
+          return;
+        }
+        case "ref-locator": {
+          const { ref } = message;
+          void agentAt(
+            at,
+            (agent) => agent.refLocator(ref),
+            (refused) => ({ ...refused, element: null, locators: [] })
+          ).then((value) => tellHub({ type: "answer", request, what: "ref-locator", value }));
+          return;
+        }
+        case "act": {
+          const { ref, action, value: given } = message;
+          const answer = (value) => tellHub({ type: "answer", request, what: "act", value });
+          void agentAt(
+            at,
+            (agent) => agent.act({ ref, action, value: given }),
+            (refused) => ({ ...refused, element: null, locators: [] }),
+            { answer: { ok: false, message: LATE_ACT, element: null, locators: [], late: true }, again: answer }
+          ).then(answer);
+          return;
+        }
+        case "bind": {
+          void bindAt(at, message.on).then((value) => tellHub({ type: "answer", request, what: "bind", value }));
+          return;
+        }
+        default: {
+          const value = at ? at.intent(message.what) : { ok: false, message: WENT_ON };
+          tellHub({ type: "answer", request, what: message.what, value });
+          return;
+        }
+      }
+    }
+    case "unknown":
+      tellHub({
+        type: "notice",
+        message: `@piwitests/reporter ${getReporterVersion()} does not take the editor's ${message.what}: update it.`
+      });
+  }
+}
+function agentAt(at, run, refuse2, late) {
+  if (!at) return Promise.resolve(refuse2({ ok: false, message: WENT_ON }));
+  const agent = at.agent;
+  if (!agent) return Promise.resolve(refuse2({ ok: false, message: NO_AGENT_PAGE }));
+  const answered = agentTurn.then(async () => {
+    if (held !== at) return refuse2({ ok: false, message: WENT_ON });
+    const running2 = run(agent);
+    const settled = running2.then(
+      (value) => ({ value }),
+      () => ({ value: refuse2({ ok: false, message: NO_ANSWER }) })
+    );
+    const said = await answerWithin(settled, PAGE_ANSWER_MS, null);
+    if (said) return said.value;
+    if (!late) return refuse2({ ok: false, message: NO_ANSWER });
+    void running2.then((value) => value.ok && held === at && late.again(value)).catch(() => void 0);
+    return late.answer;
+  });
+  agentTurn = answered.catch(() => void 0);
+  return answered;
+}
+async function bindAt(at, on) {
+  if (!at) return { ok: false, message: WENT_ON, name: null, endpoint: null };
+  const browser = at.browser;
+  if (!on) {
+    await unbind();
+    return { ok: true, message: "The browser is no longer shared with Playwright tools.", name: null, endpoint: null };
+  }
+  if (!browser) return { ok: false, message: NO_AGENT_PAGE, name: null, endpoint: null };
+  if (bound?.browser === browser) {
+    return {
+      ok: true,
+      message: `The browser is shared with Playwright tools as ${runName} until the test ends: any process of yours can drive it.`,
+      name: runName,
+      endpoint: bound.endpoint
+    };
+  }
+  if (bound) await unbind();
+  const answer = await internalCall(browser, () => bindBrowser(browser, runName, process.cwd(), true));
+  if (answer.ok) bound = { browser, endpoint: answer.endpoint };
+  return answer;
+}
+async function imageOf(page) {
+  if (!page || page.isClosed()) return null;
+  try {
+    const shot = await internalCall(
+      page,
+      () => page.screenshot({ type: "jpeg", quality: 60, style: BAR_HIDDEN2, timeout: 5e3 })
+    );
+    const viewport = await viewportOf(page);
+    return { mime: "image/jpeg", data: shot.toString("base64"), ...viewport };
+  } catch {
+    return null;
+  }
+}
+
+// src/internal/capture/run-events.ts
+var begun = /* @__PURE__ */ new WeakMap();
+var heard = /* @__PURE__ */ new WeakSet();
+var watched = /* @__PURE__ */ new WeakSet();
+function userFile(file, cwd, windows) {
+  if (!file || /[\\/]node_modules[\\/]/.test(file)) return null;
+  const relative6 = callSitePath(file, cwd, windows);
+  if (!relative6 || (windows ? path9.win32 : path9.posix).isAbsolute(relative6) || relative6.startsWith("..")) return null;
+  return relative6;
+}
+function callPlace(frames, cwd = process.cwd(), windows = process.platform === "win32") {
+  for (const frame of frames ?? []) {
+    const file = userFile(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 } : {} };
+  }
+  return null;
+}
+function callTitle(zone, channel) {
+  const selector = typeof channel?.params?.selector === "string" ? ` ${channel.params.selector}` : "";
+  const title = zone.title || `${zone.apiName || "call"}${selector}`;
+  return hideSecretsInText(title).slice(0, 300);
+}
+function errorText(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return hideSecretsInText(message.split("\n").slice(0, 4).join("\n")).slice(0, MAX_RUN_EVENT_TEXT);
+}
+function watchCalls(playwright) {
+  const instrumentation = playwright?._instrumentation;
+  if (!playwright || heard.has(playwright)) return true;
+  if (!instrumentation || typeof instrumentation.addListener !== "function") return false;
+  heard.add(playwright);
+  const titles = /* @__PURE__ */ new WeakMap();
+  instrumentation.addListener({
+    onApiCallBegin: (zone, channel) => {
+      if (!runEventsWanted()) return;
+      begun.set(zone, Date.now());
+      titles.set(zone, callTitle(zone, channel));
+    },
+    onApiCallEnd: (zone) => {
+      const start = begun.get(zone);
+      if (start === void 0) return;
+      begun.delete(zone);
+      if (!runEventsWanted()) return;
+      tellEvent({
+        kind: "call",
+        title: titles.get(zone) ?? callTitle(zone, void 0),
+        place: callPlace(zone.frames),
+        ok: zone.error === void 0,
+        error: zone.error === void 0 ? null : errorText(zone.error),
+        ms: Date.now() - start
+      });
+    }
+  });
+  return true;
+}
+function watchPageEvents(page) {
+  if (watched.has(page) || typeof page.on !== "function") return;
+  watched.add(page);
+  const text = (value) => hideSecretsInText(value).slice(0, MAX_RUN_EVENT_TEXT);
+  const url = (value) => hideSecretsInUrl(value).slice(0, 8192);
+  const guard = (tell) => {
+    if (!runEventsWanted()) return;
+    try {
+      tell();
+    } catch {
+    }
+  };
+  page.on(
+    "framenavigated",
+    (frame) => guard(() => {
+      if (frame === page.mainFrame()) tellEvent({ kind: "navigation", url: url(frame.url()) });
+    })
+  );
+  page.on(
+    "console",
+    (message) => guard(() => {
+      const type = message.type();
+      if (type === "error" || type === "warning")
+        tellEvent({ kind: "console", level: type, text: text(message.text()) });
+    })
+  );
+  page.on("pageerror", (error) => guard(() => tellEvent({ kind: "page-error", text: text(errorText(error)) })));
+  page.on(
+    "requestfailed",
+    (request) => guard(
+      () => tellEvent({
+        kind: "request-failed",
+        method: request.method(),
+        url: url(request.url()),
+        status: null,
+        failure: request.failure()?.errorText ? text(request.failure().errorText).slice(0, 500) : null
+      })
+    )
+  );
+  page.on(
+    "response",
+    (response) => guard(() => {
+      const status = response.status();
+      if (status < 400 || status > 599) return;
+      const request = response.request();
+      tellEvent({ kind: "request-failed", method: request.method(), url: url(response.url()), status, failure: null });
+    })
+  );
+}
+
+// src/internal/capture/region-snapshot.ts
+function regionSnapshotWithoutSecrets(snapshot, secrets) {
+  const hidden2 = new Set(secrets.filter(Boolean));
+  const kept = [];
+  for (const line of snapshot.split("\n")) {
+    const box = /^(\s*- textbox(?: "(?:[^"\\]|\\.)*")?(?: \[[^\]]*\])*): (.*)$/.exec(line);
+    if (box && hidden2.size && hidden2.has(yamlScalar(box[2]))) {
+      kept.push({ line: box[1], lostChild: false });
+      continue;
+    }
+    const url = /^\s*- \/url: (.*)$/.exec(line);
+    if (url && hideSecretsInUrl(yamlScalar(url[1])) !== yamlScalar(url[1])) {
+      let parent = kept.length - 1;
+      while (parent >= 0 && indentOf(kept[parent].line) >= indentOf(line)) parent--;
+      if (parent >= 0) kept[parent].lostChild = true;
+      continue;
+    }
+    kept.push({ line, lostChild: false });
+  }
+  return kept.map(({ line, lostChild }, i) => {
+    const next = kept[i + 1];
+    const childless = !next || indentOf(next.line) <= indentOf(line);
+    return lostChild && childless && line.endsWith(":") ? line.slice(0, -1) : line;
+  }).join("\n");
+}
+function indentOf(line) {
+  return line.length - line.trimStart().length;
+}
+function yamlScalar(text) {
+  const value = text.trim();
+  if (value.startsWith('"')) {
+    try {
+      return String(JSON.parse(value));
+    } catch {
+      return value;
+    }
+  }
+  if (value.startsWith("'") && value.endsWith("'") && value.length > 1) return value.slice(1, -1).replace(/''/g, "'");
+  return value;
+}
+
+// src/internal/capture/record-handoff.ts
+var fs6 = __toESM(require("fs"));
+var net2 = __toESM(require("net"));
+var path10 = __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();
+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: path10.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 socket2 = net2.connect(channel.path);
+    socket2.setEncoding("utf8");
+    const answers = /* @__PURE__ */ new Map();
+    let calls = 0;
+    let attached = false;
+    let recording = false;
+    let settled = false;
+    let initScript;
+    const send2 = (message) => {
+      if (!socket2.destroyed) socket2.write(`${JSON.stringify(message)}
+`);
+    };
+    const onPage = () => send2({ type: "notice", message: NEW_TAB_NOTICE });
+    const onGone = () => {
+      if (attached) send2({ 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) send2({ type: "closed" });
+        finish("the test ended.");
+      } catch {
       }
-    }
-    case "unknown":
-      tellHub({
-        type: "notice",
-        message: `@piwitests/reporter ${getReporterVersion()} does not take the editor's ${message.what}: update it.`
+    };
+    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);
+      socket2.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();
+      send2({ 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"}.`;
+        send2({ 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);
+      send2({ type: "loaded" });
+    };
+    socket2.on("connect", () => {
+      attached = true;
+      send2({
+        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,
+        ...options.mode === "check" ? { mode: "check", stop: options.stop ?? null } : {}
       });
-  }
-}
-async function imageOf(page) {
-  if (!page || page.isClosed()) return null;
-  try {
-    const shot = await internalCall(
-      page,
-      () => page.screenshot({ type: "jpeg", quality: 60, style: BAR_HIDDEN, timeout: 5e3 })
+    });
+    socket2.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.")
+      )
     );
-    return { mime: "image/jpeg", data: shot.toString("base64") };
-  } catch {
-    return null;
-  }
+    socket2.on("error", (error) => finish(`the editor could not be reached: ${error.message}`));
+    socket2.on("close", () => finish("the editor closed the recording."));
+  });
 }
 
 // src/internal/collect/coverage-settings.ts
@@ -5806,7 +7895,7 @@ function browserFunctionsInWorker() {
 function browserFunctionCoverage(files) {
   return sanitizeCoverage({
     v: 1,
-    files: [...files].map(([path15, functions]) => ({ path: path15, runtime: "browser", functions }))
+    files: [...files].map(([path16, functions]) => ({ path: path16, runtime: "browser", functions }))
   });
 }
 function newKnownFunctions(known, sent2) {
@@ -5819,19 +7908,19 @@ function newKnownFunctions(known, sent2) {
     budget = MAX_COVERAGE_RANGES;
   };
   for (const [raw, ranges] of known) {
-    const path15 = normalizeCoveragePath(raw);
-    if (path15 === null) continue;
-    let named = sent2.get(path15);
+    const path16 = normalizeCoveragePath(raw);
+    if (path16 === null) continue;
+    let named = sent2.get(path16);
     let fresh = normalizeFunctionRanges(ranges).filter((range) => !named?.has(`${range[0]}:${range[1]}`));
     if (fresh.length === 0) continue;
-    if (!named) sent2.set(path15, named = /* @__PURE__ */ new Set());
+    if (!named) sent2.set(path16, 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: path15, allFunctions: part });
+      files.push({ path: path16, allFunctions: part });
     }
   }
   close();
@@ -5842,7 +7931,7 @@ function serverCoverageInWorker() {
 }
 
 // src/internal/support/aria-sampling.ts
-var path10 = __toESM(require("path"));
+var path11 = __toESM(require("path"));
 var os3 = __toESM(require("os"));
 var fs7 = __toESM(require("fs"));
 
@@ -5858,7 +7947,7 @@ function ariaSampleIdentity(filePath2, title) {
   return `${filePath2}\0${title}`;
 }
 function getAriaSampleFilePath(projectName) {
-  return path10.join(os3.tmpdir(), `piwi-dashboard-aria-sample-${hashForProject(projectName)}.json`);
+  return path11.join(os3.tmpdir(), `piwi-dashboard-aria-sample-${hashForProject(projectName)}.json`);
 }
 var cachedSets = /* @__PURE__ */ new Map();
 function loadAriaSampleSet(projectName) {
@@ -5889,7 +7978,7 @@ function isDueForAriaSample(testInfo) {
 // src/internal/capture/code-reach.ts
 var crypto3 = __toESM(require("crypto"));
 var fs8 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
+var path12 = __toESM(require("path"));
 var import_node_child_process = require("child_process");
 var MAX_MAP_BYTES = 20 * 1024 * 1024;
 var MAP_TIMEOUT_MS = 5e3;
@@ -5932,12 +8021,12 @@ function repositoryRoot(from) {
     }).trim();
   } catch {
   }
-  cachedRepoRoot = { from, root: path11.resolve(root) };
+  cachedRepoRoot = { from, root: path12.resolve(root) };
   return cachedRepoRoot.root;
 }
 function codeReachRoots(configDir, configured) {
   const repoRoot = repositoryRoot(configDir);
-  const resolve5 = (dirs) => (Array.isArray(dirs) ? dirs : dirs ? [dirs] : []).filter(Boolean).map((r) => path11.resolve(configDir, r));
+  const resolve5 = (dirs) => (Array.isArray(dirs) ? dirs : dirs ? [dirs] : []).filter(Boolean).map((r) => path12.resolve(configDir, r));
   const global = Array.isArray(configured) ? resolve5(configured) : resolve5(configured?.["*"]);
   const byOrigin = /* @__PURE__ */ new Map();
   if (configured && !Array.isArray(configured)) {
@@ -5974,10 +8063,10 @@ function isFile(file) {
 function resolveSourcePath(source, roots) {
   const normalized = normalizeSourcePath(source);
   if (!normalized || /(?:^|\/)node_modules\//.test(normalized)) return null;
-  if (path11.isAbsolute(normalized) && isFile(normalized)) return path11.resolve(normalized);
-  const relative8 = normalized.replace(/^\/+/, "");
+  if (path12.isAbsolute(normalized) && isFile(normalized)) return path12.resolve(normalized);
+  const relative6 = normalized.replace(/^\/+/, "");
   for (const root of roots) {
-    const candidate = path11.resolve(root, relative8);
+    const candidate = path12.resolve(root, relative6);
     if (isFile(candidate)) return candidate;
   }
   return null;
@@ -6009,7 +8098,7 @@ function fileForUrl(url, roots, bases) {
   return file;
 }
 function relativeToRepo(file, repoRoot) {
-  return path11.relative(repoRoot, file).split(path11.sep).join("/");
+  return path12.relative(repoRoot, file).split(path12.sep).join("/");
 }
 function scriptVersion(entry) {
   return entry.hash ?? crypto3.createHash("sha1").update(entry.source ?? "").digest("hex");
@@ -6072,10 +8161,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 path15 = relativeToRepo(file, roots.repoRoot);
-    const listed = into.get(path15);
+    const path16 = relativeToRepo(file, roots.repoRoot);
+    const listed = into.get(path16);
     if (listed) listed.push(...functions);
-    else into.set(path15, [...functions]);
+    else into.set(path16, [...functions]);
   };
   const add2 = (file, functions) => addTo(files, file, functions);
   const bases = viteBases(entries);
@@ -6682,7 +8771,7 @@ async function resolveCssCoverage(sheets, roots, fetchMap) {
 var childProcess = __toESM(require("child_process"));
 var fs11 = __toESM(require("fs"));
 var net3 = __toESM(require("net"));
-var path13 = __toESM(require("path"));
+var path14 = __toESM(require("path"));
 var import_node_module2 = require("module");
 
 // src/internal/capture/worker-metrics.ts
@@ -6690,7 +8779,7 @@ var import_node_perf_hooks = require("perf_hooks");
 
 // src/internal/support/system-readers.ts
 var fs10 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var path13 = __toESM(require("path"));
 var CLK_TCK = 100;
 function readText(file) {
   try {
@@ -6776,7 +8865,7 @@ var ProcFs = class {
   }
   /** Whether this looks like a Linux `/proc` at all. */
   available() {
-    return fs10.existsSync(path12.join(this.root, "stat"));
+    return fs10.existsSync(path13.join(this.root, "stat"));
   }
   /** Every process, keyed by pid. */
   table() {
@@ -6789,32 +8878,32 @@ var ProcFs = class {
     }
     for (const name of names) {
       if (!/^\d+$/.test(name)) continue;
-      const text = readText(path12.join(this.root, name, "stat"));
+      const text = readText(path13.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(path12.join(this.root, String(pid), "stat"));
+    const text = readText(path13.join(this.root, String(pid), "stat"));
     return text ? parseProcStat(pid, text) : null;
   }
   runWaitMs(pid) {
-    const text = readText(path12.join(this.root, String(pid), "schedstat"));
+    const text = readText(path13.join(this.root, String(pid), "schedstat"));
     return text ? parseSchedstat(text) : null;
   }
   cmdline(pid) {
-    return (readText(path12.join(this.root, String(pid), "cmdline")) ?? "").split("\0").join(" ").trim();
+    return (readText(path13.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(path12.join(this.root, String(pid), "status"));
+    const text = readText(path13.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 fs10.promises.readFile(path12.join(this.root, String(pid), "smaps_rollup"), "utf8"), "Pss");
+      return parseKbField(await fs10.promises.readFile(path13.join(this.root, String(pid), "smaps_rollup"), "utf8"), "Pss");
     } catch {
       return null;
     }
@@ -6822,29 +8911,29 @@ var ProcFs = class {
   /** Reset a process's peak RSS (`VmHWM`) to its current RSS. */
   resetPeakRss(pid) {
     try {
-      fs10.writeFileSync(path12.join(this.root, String(pid), "clear_refs"), "5");
+      fs10.writeFileSync(path13.join(this.root, String(pid), "clear_refs"), "5");
       return true;
     } catch {
       return false;
     }
   }
   cpuTicks() {
-    const text = readText(path12.join(this.root, "stat"));
+    const text = readText(path13.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(path12.join(this.root, "pressure", resource));
+    const text = readText(path13.join(this.root, "pressure", resource));
     return text ? parsePsiTotal(text) : null;
   }
   memAvailableKb() {
-    const text = readText(path12.join(this.root, "meminfo"));
+    const text = readText(path13.join(this.root, "meminfo"));
     return text ? parseKbField(text, "MemAvailable") : null;
   }
   /** Open file descriptors of a process. */
   fdCount(pid) {
     try {
-      return fs10.readdirSync(path12.join(this.root, String(pid), "fd")).length;
+      return fs10.readdirSync(path13.join(this.root, String(pid), "fd")).length;
     } catch {
       return null;
     }
@@ -7059,19 +9148,19 @@ var PAGE_READ_CAP = 50;
 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 path13.relative(process.cwd(), file.replace(/^file:\/\//, "")).split(path13.sep).join("/");
+function relativePath(file, cwd = process.cwd(), windows = process.platform === "win32") {
+  return callSitePath(file, cwd, windows) ?? file;
 }
 function isLibraryFile(file) {
-  return file.startsWith("node:") || file.startsWith("internal/") || file.includes(`${path13.sep}node_modules${path13.sep}`) || file.includes("/node_modules/") || file === __filename;
+  return file.startsWith("node:") || file.startsWith("internal/") || /[\\/]node_modules[\\/]/.test(file) || file === __filename;
 }
-function userSite(stack) {
+function userSite(stack, cwd = process.cwd(), windows = process.platform === "win32") {
   for (const line of (stack ?? "").split("\n").slice(1)) {
     const match = /^\s*at\s+(?:.*?\s+\()?(.+?):(\d+):\d+\)?$/.exec(line);
     if (!match) continue;
-    const file = match[1].replace(/^file:\/\//, "");
-    if (isLibraryFile(file) || !/\.[a-z]+$/i.test(file)) continue;
-    return `${relativePath(file)}:${match[2]}`;
+    const file = framePath(match[1], windows);
+    if (!file || isLibraryFile(file) || !/\.[a-z]+$/i.test(file)) continue;
+    return `${relativePath(file, cwd, windows)}:${match[2]}`;
   }
   return null;
 }
@@ -7111,7 +9200,7 @@ function playwrightTestInfoSource() {
   try {
     const packageJson = resolvePlaywrightPackageJson();
     if (!packageJson) return () => null;
-    const globals = (0, import_node_module2.createRequire)(packageJson)(path13.join(path13.dirname(packageJson), "lib", "globals.js"));
+    const globals = (0, import_node_module2.createRequire)(packageJson)(path14.join(path14.dirname(packageJson), "lib", "globals.js"));
     const read = globals.currentTestInfo;
     if (typeof read !== "function") return () => null;
     return () => {
@@ -7154,7 +9243,7 @@ function deepUserSite() {
 }
 var SHELLS = /^(?:sh|bash|dash|zsh|cmd|cmd\.exe|powershell|powershell\.exe|pwsh)$/i;
 function commandOf(spawnfile, spawnargs) {
-  const name = (file) => path13.basename(file.replace(/\\/g, "/").replace(/^["']|["']$/g, ""));
+  const name = (file) => path14.basename(file.replace(/\\/g, "/").replace(/^["']|["']$/g, ""));
   const program = typeof spawnfile === "string" ? name(spawnfile) : "";
   const args = Array.isArray(spawnargs) ? spawnargs.map(String) : [];
   const script = args.findIndex((arg) => arg === "-c" || /^\/c$/i.test(arg));
@@ -7297,17 +9386,17 @@ var ResourceLedger = class {
   onServer(server, site) {
     const known = this.byHandle.get(server);
     if (known && this.handles.has(known)) return;
-    let bound = false;
+    let bound2 = false;
     let closed = false;
     const entry = this.trackHandle(server, {
       type: "TCPServerWrap",
       site,
       // `close()` unbinds at once, while its 'close' event waits for open connections.
       running: () => server.listening,
-      pending: () => !bound && !closed && !server.listening
+      pending: () => !bound2 && !closed && !server.listening
     });
     server.once("listening", () => {
-      bound = true;
+      bound2 = true;
     });
     server.once("close", () => {
       closed = true;
@@ -7361,22 +9450,22 @@ var ResourceLedger = class {
    */
   async testEnded(info) {
     const test = testRef2(info) ?? this.window;
-    const failed = typeof info.status === "string" && typeof info.expectedStatus === "string" && info.status !== info.expectedStatus;
-    const leaks = test && !failed ? this.leaksOf(test.id) : [];
+    const failed2 = typeof info.status === "string" && typeof info.expectedStatus === "string" && info.status !== info.expectedStatus;
+    const leaks = test && !failed2 ? this.leaksOf(test.id) : [];
     if (this.leakCheck === "close" && leaks.length > 0) await this.closeLeaks(leaks);
-    const ref = test ? { ...test, title: typeof info.title === "string" ? info.title : "", ...failed ? { failed: true } : {} } : null;
+    const ref = test ? { ...test, title: typeof info.title === "string" ? info.title : "", ...failed2 ? { failed: true } : {} } : null;
     const metrics = this.readers.metrics?.end(this.sawBrowser) ?? null;
     const handles = {
       start: this.handlesAtStart,
       end: await settledHandles(this.handlesAtStart, this.countedHandleTypes())
     };
-    const running = this.trackingHandles && test ? await this.runningOf(test.id) : null;
+    const running2 = this.trackingHandles && test ? await this.runningOf(test.id) : null;
     const census = this.census(ref, handles, await this.readPages());
     if (metrics) census.metrics = metrics;
-    if (running) census.running = running;
+    if (running2) census.running = running2;
     if (test) {
       census.openAtStart = this.openAtStart;
-      if (!failed) census.leftOpen = leaks.length;
+      if (!failed2) census.leftOpen = leaks.length;
     }
     this.window = null;
     return { census, leaks };
@@ -7426,10 +9515,10 @@ var ResourceLedger = class {
     for (const method of ["launch", "connect", "connectOverCDP"]) {
       const original = type[method];
       if (typeof original !== "function") continue;
-      const bound = original.bind(type);
+      const bound2 = original.bind(type);
       type[method] = async (...args) => {
         const site = userSite(new Error().stack);
-        const browser = await bound(...args);
+        const browser = await bound2(...args);
         this.guard(() => this.onBrowser(browser, site));
         return browser;
       };
@@ -7506,12 +9595,12 @@ var ResourceLedger = class {
     for (const method of USE_METHODS) {
       const original = methods[method];
       if (typeof original !== "function") continue;
-      const bound = original.bind(page);
+      const bound2 = original.bind(page);
       methods[method] = (...args) => {
         const previous = this.usingPage;
         this.usingPage = entry;
         try {
-          return bound(...args);
+          return bound2(...args);
         } finally {
           this.usingPage = previous;
         }
@@ -7780,18 +9869,18 @@ function readPageInteraction() {
     return { path: pathOf(node), offset: textOffset(node, node.childNodes[offset] ?? null, 0) };
   };
   const out = {};
-  let active = doc.activeElement;
-  while (active?.shadowRoot?.activeElement) active = active.shadowRoot.activeElement;
-  if (active && active !== doc.body && active !== doc.documentElement) {
+  let active2 = doc.activeElement;
+  while (active2?.shadowRoot?.activeElement) active2 = active2.shadowRoot.activeElement;
+  if (active2 && active2 !== doc.body && active2 !== doc.documentElement) {
     let visible = false;
     try {
-      visible = active.matches(":focus-visible");
+      visible = active2.matches(":focus-visible");
     } catch {
     }
-    out.focus = { element: ref(active), visible };
+    out.focus = { element: ref(active2), visible };
     try {
-      if (typeof active.selectionStart === "number" && typeof active.selectionEnd === "number") {
-        out.focus.selection = [active.selectionStart, active.selectionEnd];
+      if (typeof active2.selectionStart === "number" && typeof active2.selectionEnd === "number") {
+        out.focus.selection = [active2.selectionStart, active2.selectionEnd];
       }
     } catch {
     }
@@ -7806,7 +9895,7 @@ function readPageInteraction() {
     scope = innermost.shadowRoot;
   }
   const selection = doc.getSelection?.();
-  if (selection && selection.rangeCount > 0 && !selection.isCollapsed && !(active && isField(active))) {
+  if (selection && selection.rangeCount > 0 && !selection.isCollapsed && !(active2 && isField(active2))) {
     const range = selection.getRangeAt(0);
     const start = range.startContainer.nodeType === 3 ? range.startContainer.parentElement : range.startContainer;
     const end = range.endContainer.nodeType === 3 ? range.endContainer.parentElement : range.endContainer;
@@ -7868,7 +9957,7 @@ function observeApiRequestContext(context, recorder, baseURL = null) {
   return proxy;
 }
 function sendingMethod(target, prop, recorder, baseURL) {
-  return function send(...args) {
+  return function send2(...args) {
     const record = recorder();
     if (!record) return callMethod(target, prop, args);
     const startedAt = Date.now();
@@ -8033,6 +10122,10 @@ function createSink() {
     frozenAt: null,
     stopEnds: 0,
     ending: false,
+    functionEnded: false,
+    ended: false,
+    end: new AbortController(),
+    skip: void 0,
     released: [],
     releasedRequests: /* @__PURE__ */ new Set(),
     onReleasedRequestsEnded: null,
@@ -8080,7 +10173,7 @@ function configuredCodeReachRoots() {
     }
   } catch {
   }
-  return raw.split(path14.delimiter).filter(Boolean);
+  return raw.split(path15.delimiter).filter(Boolean);
 }
 async function stopSinkCodeReach(sink, closing) {
   const stopping = [];
@@ -8431,14 +10524,14 @@ async function maybeOpenPicker(sink, closing) {
   const inspectGate = shouldInspectOnFailure(inspectionGateFromTestInfo(testInfo, process.env.PIWI_INSPECT_ON_FAIL));
   if (!pickGate && !inspectGate) return;
   sink.pickOffered = true;
-  const failed = sink.failedLocators[sink.failedLocators.length - 1] ?? deriveFailedLocator(testInfo);
-  if (!failed && !inspectGate) {
+  const failed2 = sink.failedLocators[sink.failedLocators.length - 1] ?? deriveFailedLocator(testInfo);
+  if (!failed2 && !inspectGate) {
     console.log("[piwi] locator picker: no failing locator could be identified in this failure \u2014 nothing to replace.");
     return;
   }
   const pick = await internalCall(
     page,
-    () => runLocatorPicker(page, testInfo, failed, { fn: probeElementAttrs, arg: CAPTURED_ATTRS_ARG })
+    () => runLocatorPicker(page, testInfo, failed2, { fn: probeElementAttrs, arg: CAPTURED_ATTRS_ARG })
   );
   if (!pick) return;
   sink.userPick = pick;
@@ -8573,7 +10666,7 @@ function knowLocatorCall(sink, page, target, location, origin) {
   let settle = () => {
   };
   const settled = new Promise((resolve5) => settle = resolve5);
-  const call = { page, target, location, origin, picked: false, settled, settle };
+  const call = { page, target, location, origin, picked: false, endable: false, settled, settle };
   sink.locatorCalls.set(callSiteLine(location), call);
   return call;
 }
@@ -8640,6 +10733,10 @@ function onDebuggerStop(context) {
         return;
       }
       if (pagePause) stopShown(state);
+      if (sink.ended) {
+        how = goOn(state, "end");
+        return;
+      }
       if (sink.ending || CLOSING_CONTEXTS.has(context)) {
         askAgain(state, asked);
         how = goOn(state, sink.ending ? endedWaiting(sink, call) : void 0);
@@ -8648,6 +10745,7 @@ function onDebuggerStop(context) {
       const of = stopPageOf(context, call, pagePause?.page);
       const ends = sink.stopEnds;
       const shown2 = stopTurn.then(async () => {
+        if (sink.ended) return "end";
         const ended = currentSink !== sink || sink.ending || sink.stopEnds !== ends;
         const gone = decided.show === "breakpoint" && !atBreakpoint(state, callSite);
         if (!ended && !gone && stopCanShow(context, of)) {
@@ -8675,7 +10773,7 @@ function endedWaiting(sink, call) {
   return "finish";
 }
 function stopSite(sink, location) {
-  if (path14.dirname(path14.resolve(location.file)) !== __dirname) return stopCallSite(location);
+  if (path15.dirname(path15.resolve(location.file)) !== __dirname) return stopCallSite(location);
   return inFlightCallSite([...sink.locatorCalls.values()].map((call) => call.location));
 }
 function stopBarPage(sink, context, of) {
@@ -8694,7 +10792,7 @@ async function showStop(sink, context, title, location, reason, call, of, failur
   const place = runChannelOpen() ? callSitePlace(location) : null;
   if (!bar && !place) return void 0;
   const failing = failure?.failed ?? null;
-  const onPick = async (picked) => {
+  const pickTaken = async (picked) => {
     if (call) {
       call.picked = true;
       const { method, args } = call.origin;
@@ -8713,17 +10811,50 @@ async function showStop(sink, context, title, location, reason, call, of, failur
       applyPickToSnapshots(sink.capturedLocators, pick);
     }
     console.log(`[piwi] Locator picked at ${callSiteLine(location)}: ${picked.picked.locator}`);
-    await postPickToEditor(editorSendAddress(), pickPayload(picked.picked.locator, location));
+    return postPickToEditor(editorSendAddress(), pickPayload(picked.picked.locator, location), fetch, runHost());
   };
+  const onPick = async (picked) => void await pickTaken(picked);
+  const probe = { fn: probeElementAttrs, arg: CAPTURED_ATTRS_ARG };
   const handoffReason = reason === "page-pause" ? "pause" : "breakpoint";
-  const onRecord = bar && page ? recorderAt(page, testInfo, location, handoffReason) : void 0;
-  const intents = bar && page ? new BarIntents() : null;
+  const onRecord = page ? recorderAt(page, testInfo, location, handoffReason) : void 0;
+  const intents = page ? new BarIntents() : null;
   const record = { title, location, reason, startedAt: Date.now(), duration: 0 };
   sink.stops.push(record);
+  const stoppedAt = callSitePlace(location);
+  const goneOn = liveViewStopped({
+    reason,
+    call: { title, file: stoppedAt?.file ?? null, line: stoppedAt?.line ?? null },
+    test: testInfo.title
+  });
   const end = new AbortController();
   const over = new AbortController();
   end.signal.addEventListener("abort", () => over.abort(), { once: true });
   let fromEditor;
+  const pickAt = page && !guessed ? async (x, y) => {
+    try {
+      const found = await internalCall(page, () => pickAtPoint(page, probe, x, y));
+      if ("refusal" in found) return { ok: false, message: found.refusal, locator: null };
+      if (over.signal.aborted) return { ok: false, message: "The test went on.", locator: null };
+      const locator = found.picked.picked.locator;
+      const sent2 = await pickTaken(found.picked);
+      return {
+        ok: true,
+        message: sent2 ? `${locator} went to the editor, in place of the locator on the stopped line.` : `${locator}: no editor took it, as this run names no Send to editor pairing that answers.`,
+        locator
+      };
+    } catch (error) {
+      const message = hideSecretsInText(`The stopped page could not be read: ${errorMessage(error)}`);
+      return { ok: false, message, locator: null };
+    }
+  } : void 0;
+  const use = testInfo.project?.use ?? {};
+  const testIdAttribute = typeof use.testIdAttribute === "string" ? use.testIdAttribute : null;
+  const agentProbe = { fn: probeElementAttrs, arg: { ...CAPTURED_ATTRS_ARG, testIdAttribute } };
+  const agent = page && !guessed ? {
+    snapshot: (depth, image) => internalCall(page, () => readSnapshot(page, depth, image)),
+    refLocator: (ref) => internalCall(page, () => refLocators(page, agentProbe, ref, testIdAttribute)),
+    act: (act) => internalCall(page, () => actOnRef(page, agentProbe, act, testIdAttribute))
+  } : void 0;
   const held2 = place ? holdStop(
     {
       reason,
@@ -8738,20 +10869,31 @@ async function showStop(sink, context, title, location, reason, call, of, failur
         guessed,
         // A failure's stop is held in the teardown it ends with.
         holds: () => !over.signal.aborted && (!!failure || !sink.ending && stopCanShow(context, of))
-      }) : void 0
+      }) : void 0,
+      ...pickAt ? { pickAt } : {},
+      ...agent ? { agent } : {},
+      browser: context.browser()
     },
     (answer2) => {
       fromEditor = answer2;
       over.abort();
     }
   ) : null;
-  const onIntent = bar && page && held2 ? (intent, ended) => intent === "assert" ? checkAt(page, testInfo, location, handoffReason, held2.stop, ended) : regionAt(page, location, held2.stop, ended) : void 0;
+  const onIntent = page && held2 ? (intent, ended) => intent === "assert" ? checkAt(page, testInfo, location, handoffReason, held2.stop, ended) : regionAt(page, location, held2.stop, ended) : void 0;
   const shown2 = withTestTimeoutHeld(testInfo, async () => {
     if (!bar || !page) {
       console.log(
-        failure ? `[piwi] The test failed at ${callSiteLine(location)}: Resume in the editor lets it end as it failed.` : `[piwi] Paused at ${callSiteLine(location)} before ${title}: Resume, Step or Finish in the editor.`
+        failure ? `[piwi] The test failed at ${callSiteLine(location)}: Resume in ${runHost()} lets it end as it failed.` : `[piwi] Paused at ${callSiteLine(location)} before ${title}: Resume, Step or Finish in ${runHost()}.`
       );
-      await abortion(over.signal);
+      if (page && intents && held2) {
+        const stop2 = held2.stop;
+        await internalCall(
+          page,
+          () => viewHere(page, probe, onPick, onRecord, over.signal, intents, onIntent, () => viewEnded(stop2))
+        );
+      } else {
+        await abortion(over.signal);
+      }
       return "resume";
     }
     return internalCall(
@@ -8763,9 +10905,9 @@ async function showStop(sink, context, title, location, reason, call, of, failur
           call: title,
           attempt: testInfo.retry > 0 ? testInfo.retry + 1 : null,
           target: call?.page === page ? call.target : null,
-          ...failure ? { failure: true } : {}
+          ...failure ? { failure: true } : sink.functionEnded ? {} : { end: true }
         },
-        { fn: probeElementAttrs, arg: CAPTURED_ATTRS_ARG },
+        probe,
         onPick,
         onRecord,
         over.signal,
@@ -8777,17 +10919,65 @@ async function showStop(sink, context, title, location, reason, call, of, failur
     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);
+    goneOn();
     await held2?.release();
   });
   const heldAt = testTimeSlot(testInfo)?.elapsed ?? null;
   const stop = { page, guessed, context, record, done: shown2.catch(() => void 0), heldAt, after: null };
   if (!failure) sink.shownStops.set(end, stop);
   const answer = await shown2;
-  if (!end.signal.aborted) return fromEditor ?? answer;
+  if (!end.signal.aborted) {
+    const chosen = fromEditor ?? answer;
+    return chosen === "end" ? endTest(sink, call, title, location, reason) : chosen;
+  }
   if (end.signal.reason === "ended") return "finish";
   await settledWithin(stop.after ? [stop.after] : [], END_STOP_MS);
   return "resume";
 }
+function endTest(sink, call, title, location, reason) {
+  const line = callSiteLine(location);
+  if (reason === "failure" || sink.functionEnded || !sink.testInfo) {
+    const said2 = reason === "failure" ? `The test failed at ${line}: End the test lets it end as it failed.` : `The test function already ended: End the test at ${line} lets it end as it is.`;
+    console.log(`[piwi] ${said2}`);
+    if (reason !== "failure") tellHub({ type: "notice", message: said2 });
+    return "finish";
+  }
+  sink.ended = true;
+  skipAtFunctionEnd(sink);
+  sink.end.abort(new Error(ENDED_REASON));
+  if (reason === "page-pause" || call?.endable) {
+    const what = reason === "page-pause" ? "nothing after its page.pause() runs" : `${title} never runs`;
+    console.log(`[piwi] Ended the test at ${line}: ${what}, and the test is skipped.`);
+    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.`
+  );
+  console.log(`[piwi] ${said}`);
+  tellHub({ type: "notice", message: said });
+  return "end";
+}
+function endsNow(sink) {
+  return sink.ended && !sink.functionEnded;
+}
+function skipOf(sink) {
+  if (sink.skip === void 0) {
+    try {
+      sink.testInfo?.skip(true, ENDED_REASON);
+      sink.skip = new Error(`Test is skipped: ${ENDED_REASON}`);
+    } catch (error) {
+      sink.skip = error;
+    }
+  }
+  return sink.skip;
+}
+function skipAtFunctionEnd(sink) {
+  const callbacks = sink.testInfo?._onDidFinishTestFunctionCallbacks;
+  if (!(callbacks instanceof Set)) return;
+  callbacks.add(() => {
+    if (sink.testInfo?.status === "passed") throw skipOf(sink);
+  });
+}
 function intentAt(intents, what, stop) {
   if (!stop.holds()) return { ok: false, message: "The test went on." };
   if (stop.guessed) {
@@ -8879,7 +11069,7 @@ async function holdFailure(sink, fallback) {
   const context = page ? pageContext(page) : null;
   if (!page || !context) return;
   sink.failureHeld = true;
-  const failed = sink.failedLocators[sink.failedLocators.length - 1] ?? deriveFailedLocator(testInfo);
+  const failed2 = sink.failedLocators[sink.failedLocators.length - 1] ?? deriveFailedLocator(testInfo);
   const errors = testInfo.errors.length ? testInfo.errors : testInfo.error ? [testInfo.error] : [];
   const declared = (place2) => place2.file === testInfo.file && place2.line === testInfo.line;
   const placed = errors.flatMap((error2) => {
@@ -8887,8 +11077,8 @@ async function holdFailure(sink, fallback) {
     return place2 && !declared(place2) ? [{ error: error2, place: place2 }] : [];
   })[0];
   const error = placed?.error ?? errors[0];
-  const place = placed?.place ?? (failed?.location ? null : stepInProgress(testInfo));
-  const location = (place ? stopCallSite(place) : null) ?? failed?.location ?? stopCallSite({ file: testInfo.file, line: testInfo.line, column: testInfo.column });
+  const place = placed?.place ?? (failed2?.location ? null : stepInProgress(testInfo));
+  const location = (place ? stopCallSite(place) : null) ?? failed2?.location ?? stopCallSite({ file: testInfo.file, line: testInfo.line, column: testInfo.column });
   if (!location) return;
   const said = stripAnsi(error?.message ?? "").split("\n").find((line) => line.trim()) ?? status;
   if (page === sink.lastActivePage)
@@ -8896,9 +11086,9 @@ async function holdFailure(sink, fallback) {
   sink.frozenAt = Date.now();
   await stopSinkCodeReach(sink, { context });
   const title = hideSecretsInText(`Failed: ${said.trim().slice(0, 300)}`).slice(0, 1e3);
-  const errorText = failureError(error?.message ?? error?.value);
-  const named = errorText === null ? null : hideSecretsInText(errorText).slice(0, MAX_STOP_ERROR);
-  await showStop(sink, context, title, location, "failure", void 0, { page }, { failed, error: named });
+  const errorText2 = failureError(error?.message ?? error?.value);
+  const named = errorText2 === null ? null : hideSecretsInText(errorText2).slice(0, MAX_STOP_ERROR);
+  await showStop(sink, context, title, location, "failure", void 0, { page }, { failed: failed2, error: named });
 }
 var FAILURE_ERROR_LINES = 4;
 function failureError(message) {
@@ -8911,22 +11101,22 @@ function failureError(message) {
   const text = lines.join("\n").slice(0, MAX_STOP_ERROR);
   return text.trim() ? text : null;
 }
-function errorPlace(error) {
+function errorPlace(error, windows = process.platform === "win32") {
   const given = error?.location;
   if (typeof given?.file === "string" && typeof given.line === "number") {
     return { file: given.file, line: given.line, column: given.column ?? 0 };
   }
   const stack = error?.stack;
   for (const line of typeof stack === "string" ? stack.split("\n") : []) {
-    const frame = /^\s*at\s+(?:.*?\s+\()?(?:file:\/\/)?(\/[^():]+|[A-Za-z]:[\\/][^():]+):(\d+):(\d+)\)?$/.exec(line);
-    if (!frame) continue;
-    const file = frame[1];
-    if (/[\\/]node_modules[\\/]/.test(file) || path14.dirname(path14.resolve(file)) === __dirname) continue;
+    const frame = /^\s*at\s+(?:.*?\s+\()?(.+?):(\d+):(\d+)\)?$/.exec(line);
+    const file = frame ? framePath(frame[1], windows) : null;
+    if (!frame || !file || !(windows ? path15.win32 : path15.posix).isAbsolute(file)) continue;
+    if (/[\\/]node_modules[\\/]/.test(file) || path15.dirname(path15.resolve(file)) === __dirname) continue;
     return { file, line: Number(frame[2]), column: Number(frame[3]) };
   }
   return null;
 }
-function stepInProgress(testInfo) {
+function callInProgress(testInfo) {
   let found = null;
   const visit = (steps) => {
     if (!Array.isArray(steps)) return;
@@ -8935,7 +11125,10 @@ function stepInProgress(testInfo) {
       const at = step.stack?.[0];
       const called = step.category === "pw:api" || step.category === "expect" || step.category === "test.step";
       if (called && typeof at?.file === "string" && typeof at.line === "number") {
-        found = { file: at.file, line: at.line, column: typeof at.column === "number" ? at.column : 0 };
+        found = {
+          title: typeof step.title === "string" ? step.title : null,
+          place: { file: at.file, line: at.line, column: typeof at.column === "number" ? at.column : 0 }
+        };
       }
       visit(step.steps);
     }
@@ -8943,6 +11136,15 @@ function stepInProgress(testInfo) {
   visit(testInfo._steps);
   return found;
 }
+function stepInProgress(testInfo) {
+  return callInProgress(testInfo)?.place ?? null;
+}
+function runningCall(testInfo) {
+  const call = callInProgress(testInfo);
+  if (!call?.title) return null;
+  const file = path15.relative(process.cwd(), call.place.file).split(path15.sep).join("/");
+  return { title: call.title, file, line: call.place.line };
+}
 function abortion(signal) {
   return new Promise((resolve5) => {
     if (signal.aborted) resolve5();
@@ -9008,7 +11210,10 @@ function endStopsWithTestFunction(testInfo, sink) {
   if (!(callbacks instanceof Set)) return;
   const theirs = [...callbacks];
   callbacks.clear();
-  callbacks.add(() => endShownStops(sink, "ended"));
+  callbacks.add(() => {
+    sink.functionEnded = true;
+    return endShownStops(sink, "ended");
+  });
   for (const callback of theirs) callbacks.add(callback);
 }
 function recorderAt(page, testInfo, location, reason) {
@@ -9042,6 +11247,7 @@ async function pauseInPlace(page, playwrightPause, location) {
   } finally {
     PAGE_PAUSES.delete(context);
   }
+  if (endsNow(sink)) throw skipOf(sink);
 }
 async function leaveToPlaywright(context, playwrightPause) {
   if (context) PLAYWRIGHT_PAUSES.set(context, (PLAYWRIGHT_PAUSES.get(context) ?? 0) + 1);
@@ -9091,14 +11297,20 @@ function wrapLocator(page, locator, originMethod, originArgs) {
       if (prop === EXPECT_METHOD) {
         return async (...callArgs) => {
           const sink = currentSink;
+          if (sink && endsNow(sink)) throw skipOf(sink);
           const expression = typeof callArgs[0] === "string" ? callArgs[0] : "";
           const isNot = Boolean(callArgs[1]?.isNot);
           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;
+          if (call && ending) call.endable = true;
+          const expectArgs = ending ?? callArgs;
           try {
             if (!sink || isNot || !EXPECT_CAPTURE_EXPRESSIONS.has(expression)) {
-              return await callMethod(target, prop, callArgs);
+              const result2 = await callMethod(target, prop, expectArgs);
+              if (sink && endsNow(sink)) throw skipOf(sink);
+              return result2;
             }
             sink.lastActivePage = page;
             const used = {
@@ -9112,7 +11324,8 @@ function wrapLocator(page, locator, originMethod, originArgs) {
               seq = sink.capturedLocators.length;
               sink.capturedLocators.push({ location: callerLocation, used, element: null, alternatives: [] });
             }
-            const result = await callMethod(target, prop, callArgs);
+            const result = await callMethod(target, prop, expectArgs);
+            if (endsNow(sink)) throw skipOf(sink);
             const matches = result?.matches;
             if (matches === true && !alreadyProbed && !call?.picked) {
               if (callerLocation) sink.probedLocations.add(callerLocation);
@@ -9121,6 +11334,9 @@ function wrapLocator(page, locator, originMethod, originArgs) {
               sink.failedLocators.push({ method: originMethod, args: originArgs, location: callerLocation });
             }
             return result;
+          } catch (error) {
+            if (sink && endsNow(sink)) throw skipOf(sink);
+            throw error;
           } finally {
             forgetLocatorCall(sink, call);
           }
@@ -9130,6 +11346,7 @@ function wrapLocator(page, locator, originMethod, originArgs) {
       return async (...callArgs) => {
         const sink = currentSink;
         if (!sink) return callMethod(target, prop, callArgs);
+        if (endsNow(sink)) throw skipOf(sink);
         sink.lastActivePage = page;
         const callerLocation = captureCallerLocation();
         recordLocatorPage(sink, page, target, callerLocation, noteLocatorCall(page, String(prop)));
@@ -9139,6 +11356,8 @@ 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;
+        if (call && ending) call.endable = true;
         const alreadyProbed = callerLocation !== null && sink.probedLocations.has(callerLocation);
         let seq = -1;
         if (!alreadyProbed) {
@@ -9152,13 +11371,15 @@ function wrapLocator(page, locator, originMethod, originArgs) {
         }
         let result;
         try {
-          result = await callMethod(target, prop, callArgs);
+          result = await callMethod(target, prop, ending ?? callArgs);
         } catch (error) {
+          if (endsNow(sink)) throw skipOf(sink);
           sink.failedLocators.push({ method: originMethod, args: originArgs, location: callerLocation });
           throw error;
         } finally {
           forgetLocatorCall(sink, call);
         }
+        if (endsNow(sink)) throw skipOf(sink);
         if (!alreadyProbed && !call?.picked) {
           if (callerLocation) sink.probedLocations.add(callerLocation);
           startElementCapture(sink, page, target, seq, callerLocation, used);
@@ -9191,6 +11412,7 @@ function instrumentPage(page) {
   }
   void maybeStartCodeReach(page);
   observeOwnApiRequests(page);
+  watchPageEvents(page);
   const probeSink = currentSink;
   if (probeSink?.probeItem && !probeSink.probeInterception) {
     void installProbeInterception(page, probeSink.probeItem).then((interception) => {
@@ -9216,6 +11438,7 @@ function instrumentPage(page) {
   if (playwrightPause) {
     page.pause = () => pauseInPlace(page, playwrightPause, captureCallerLocation());
   }
+  if (runChannelOpen() || liveViewOpen()) guardScreencast(page);
   if (typeof page.close === "function") {
     const originalClose = page.close.bind(page);
     page.close = async (...args) => {
@@ -9319,7 +11542,7 @@ function instrumentPage(page) {
     sink.releasedRequests.add(request);
     sink.releasedQuietSince = Date.now();
   });
-  const onRequestEnd = (request, failed) => {
+  const onRequestEnd = (request, failed2) => {
     const sink = currentSink;
     if (sink?.releasedRequests.delete(request)) {
       sink.releasedQuietSince = Date.now();
@@ -9329,8 +11552,8 @@ function instrumentPage(page) {
     sink.lastActivePage = page;
     const response = sink.openResponses.get(request) ?? null;
     sink.openResponses.delete(request);
-    recordRequest(sink, request, failed ? "failed" : "finished", response);
-    if (!failed) void keepResponse(request, response);
+    recordRequest(sink, request, failed2 ? "failed" : "finished", response);
+    if (!failed2) void keepResponse(request, response);
   };
   page.on("requestfinished", (request) => onRequestEnd(request, false));
   page.on("requestfailed", (request) => onRequestEnd(request, true));
@@ -9625,8 +11848,8 @@ async function flushSink(sink, testInfo) {
             body: snapshotJson
           });
         }
-        const failed = sink.failedLocators[sink.failedLocators.length - 1];
-        const suggestion = failed ? suggestLocatorsFromAria(failed, snapshot) : null;
+        const failed2 = sink.failedLocators[sink.failedLocators.length - 1];
+        const suggestion = failed2 ? suggestLocatorsFromAria(failed2, snapshot) : null;
         if (suggestion) {
           testInfo.annotations.push({
             type: LOCATOR_SUGGESTION_ANNOTATION,
@@ -9763,7 +11986,7 @@ var runControl = {
   }
 };
 function runFile(file) {
-  return path14.relative(process.cwd(), file).split(path14.sep).join("/") || file;
+  return path15.relative(process.cwd(), file).split(path15.sep).join("/") || file;
 }
 function testBegin(testInfo, cannotPause) {
   const title = testInfo.titlePath.slice(1);
@@ -9793,17 +12016,21 @@ var piwiFixtures = {
   // ledger and records the calls the tests make through it, and torn down after
   // the browser closed, so its census sees what only the worker's shutdown
   // closed. Depends on `playwright` alone, which launches nothing. The worker's
-  // run connection to the editor (`PIWI_RUN_CHANNEL`) opens here, before the
-  // first test, and closes as the worker ends.
+  // connection to the instance's live view (`PIWI_LIVE_VIEW`) and its run
+  // connection to the editor (`PIWI_RUN_CHANNEL`), which says how the first
+  // stands and shares it, open here, before the first test, and close as the
+  // worker ends.
   piwiResources: [
     async ({ playwright }, use, workerInfo) => {
       boxCaptureFrames();
       startResourceLedger(playwright, workerInfo.workerIndex);
       observeApiRequests(playwright, apiCallRecorder);
-      await openRunChannel(workerInfo, runControl);
+      openLiveView(workerInfo);
+      if (await openRunChannel(workerInfo, runControl)) watchCalls(playwright);
       try {
         await use();
       } finally {
+        closeLiveView();
         closeRunChannel();
         stopResourceLedger();
       }
@@ -9827,6 +12054,7 @@ var piwiFixtures = {
     await armStops([pageContext(page)]);
     await awaitFlakeConditions();
     await maybeStartCodeReach(page);
+    liveViewPage(page);
     await use(page);
     const sink = currentSink;
     if (sink) await holdFailure(sink, page);
@@ -9877,6 +12105,7 @@ var piwiFixtures = {
         });
       activeResourceLedger()?.testStarted(testInfo);
       currentSink = sink;
+      liveViewTestBegan(testInfo.title, () => runningCall(testInfo));
       const showRunChannel = hideRunChannel();
       try {
         await armStops(OPEN_CONTEXTS);
@@ -9886,6 +12115,7 @@ var piwiFixtures = {
         sink.ending = true;
         await endShownStops(sink, "ended");
         await awaitReleasedCalls(sink);
+        await liveViewTestEnded();
         showRunChannel();
         currentSink = null;
         if (sink.pause?.pause) pauseNextTest = true;
@@ -9961,6 +12191,7 @@ function extendPiwiFixtures(test) {
   codeReachRoots,
   computeCoreVitals,
   configuredCodeReachRoots,
+  errorPlace,
   extendPiwiFixtures,
   failureError,
   intentAt,