@wdio/nightwatch-devtools 1.8.1 → 2.0.0

package/dist/{chunk-DM4FCAIJ.js → chunk-TUK7ZLQI.js}

@@ -452,6 +452,29 @@ function formatActionTitle(action, args, params, command) {
 }
 var FILL_METHODS = /* @__PURE__ */ new Set(["fill", "selectOption"]);
 
+// ../shared/src/browser-schemes.ts
+var BROWSER_INTERNAL_SCHEMES = /* @__PURE__ */ new Set([
+  "about",
+  "chrome",
+  "chrome-error",
+  "chrome-extension",
+  "chrome-native",
+  "chrome-search",
+  "chrome-untrusted",
+  "devtools",
+  "edge",
+  "moz-extension",
+  "safari-web-extension"
+]);
+var SCHEME = /^([a-z][a-z0-9+.-]*):/;
+function schemeOf(url) {
+  return SCHEME.exec(url.toLowerCase())?.[1];
+}
+function isBrowserInternalUrl(url) {
+  const scheme = schemeOf(url);
+  return scheme !== void 0 && (BROWSER_INTERNAL_SCHEMES.has(scheme) || scheme.startsWith("chrome-"));
+}
+
 // ../shared/src/console.ts
 var CONSOLE_METHODS = ["log", "info", "warn", "error"];
 var ANSI_REGEX = /\x1b\[[?]?[0-9;]*[A-Za-z]/g;
@@ -1051,6 +1074,46 @@ function imageMime(base64) {
   return base64.startsWith(PNG_BASE64_MAGIC) ? "image/png" : "image/jpeg";
 }
 
+// ../shared/src/request-type.ts
+function getRequestType(url, mimeType) {
+  const contentType = mimeType?.toLowerCase() ?? "";
+  const urlLower = url.toLowerCase();
+  if (contentType.includes("text/html")) {
+    return "document";
+  }
+  if (contentType.includes("text/css")) {
+    return "stylesheet";
+  }
+  if (contentType.includes("javascript") || contentType.includes("ecmascript")) {
+    return "script";
+  }
+  if (contentType.includes("image/")) {
+    return "image";
+  }
+  if (contentType.includes("font/") || contentType.includes("woff")) {
+    return "font";
+  }
+  if (contentType.includes("application/json")) {
+    return "fetch";
+  }
+  if (urlLower.endsWith(".html") || urlLower.endsWith(".htm")) {
+    return "document";
+  }
+  if (urlLower.endsWith(".css")) {
+    return "stylesheet";
+  }
+  if (urlLower.endsWith(".js") || urlLower.endsWith(".mjs")) {
+    return "script";
+  }
+  if (/\.(png|jpg|jpeg|gif|svg|webp|ico)$/.test(urlLower)) {
+    return "image";
+  }
+  if (/\.(woff|woff2|ttf|eot|otf)$/.test(urlLower)) {
+    return "font";
+  }
+  return "xhr";
+}
+
 // ../shared/src/routes.ts
 var WS_PATHS = {
   /** Adapter session upgrade endpoint. One socket per running adapter. */
@@ -1147,6 +1210,9 @@ var TEST_STATE = {
   FAILED: "failed",
   SKIPPED: "skipped"
 };
+var NETWORK_CAPTURE_SOURCE = {
+  RESOURCE_TIMING: "resource-timing"
+};
 var SCREENCAST_DEFAULTS = {
   enabled: false,
   captureFormat: "jpeg",
@@ -1805,6 +1871,21 @@ function buildActionEvents(commands, pageId, wallTime, testMetadata, snapshotInd
 
 // ../trace/src/trace-har.ts
 var INLINE_BODY_TEXT_MAX_BYTES = 8 * 1024;
+var HAR_PHASE_NOT_APPLICABLE = -1;
+function toHarTimings(timings, duration) {
+  if (!timings) {
+    return { send: 0, wait: Math.max(0, duration), receive: 0 };
+  }
+  return {
+    blocked: timings.blocked ?? HAR_PHASE_NOT_APPLICABLE,
+    dns: timings.dns ?? HAR_PHASE_NOT_APPLICABLE,
+    connect: timings.connect ?? HAR_PHASE_NOT_APPLICABLE,
+    ssl: timings.ssl ?? HAR_PHASE_NOT_APPLICABLE,
+    send: timings.send ?? 0,
+    wait: timings.wait ?? 0,
+    receive: timings.receive ?? 0
+  };
+}
 function toHeaderArray(h) {
   if (!h) {
     return [];
@@ -1868,11 +1949,9 @@ function networkRequestToHar(entry, opts = {}) {
         bodySize: entry.size ?? -1
       },
       cache: {},
-      timings: {
-        send: 0,
-        wait: Math.max(0, duration),
-        receive: 0
-      }
+      timings: toHarTimings(entry.timings, duration),
+      _resourceType: entry.type,
+      ...entry.source ? { _source: entry.source } : {}
     }
   };
 }
@@ -2764,48 +2843,6 @@ import { createRequire } from "module";
 
 // ../core/src/net.ts
 import * as net from "net";
-
-// ../core/src/request-type.ts
-function getRequestType(url, mimeType) {
-  const contentType = mimeType?.toLowerCase() ?? "";
-  const urlLower = url.toLowerCase();
-  if (contentType.includes("text/html")) {
-    return "document";
-  }
-  if (contentType.includes("text/css")) {
-    return "stylesheet";
-  }
-  if (contentType.includes("javascript") || contentType.includes("ecmascript")) {
-    return "script";
-  }
-  if (contentType.includes("image/")) {
-    return "image";
-  }
-  if (contentType.includes("font/") || contentType.includes("woff")) {
-    return "font";
-  }
-  if (contentType.includes("application/json")) {
-    return "fetch";
-  }
-  if (urlLower.endsWith(".html") || urlLower.endsWith(".htm")) {
-    return "document";
-  }
-  if (urlLower.endsWith(".css")) {
-    return "stylesheet";
-  }
-  if (urlLower.endsWith(".js") || urlLower.endsWith(".mjs")) {
-    return "script";
-  }
-  if (/\.(png|jpg|jpeg|gif|svg|webp|ico)$/.test(urlLower)) {
-    return "image";
-  }
-  if (/\.(woff|woff2|ttf|eot|otf)$/.test(urlLower)) {
-    return "font";
-  }
-  return "xhr";
-}
-
-// ../core/src/net.ts
 function isPortInUse(port, hostname) {
   return new Promise((resolve) => {
     const server = net.createServer();
@@ -2893,34 +2930,56 @@ function bidiResponseTiming(timings, startTime, timestamp) {
   const endTime = Number(timestamp ?? Date.now());
   return { endTime, time: Math.max(0, endTime - startTime) };
 }
-function handleBidiRequestSent(rawEvent, pending, sinks, log) {
+var MAX_TRACKED_REQUESTS = 5e3;
+function remember(rows, id, entry) {
+  rows.set(id, entry);
+  if (rows.size <= MAX_TRACKED_REQUESTS) {
+    return;
+  }
+  for (const [key, row] of rows) {
+    if (row.status !== void 0) {
+      rows.delete(key);
+      return;
+    }
+  }
+  rows.delete(rows.keys().next().value);
+}
+function handleBidiRequestSent(rawEvent, rows, sinks, log) {
   const event = rawEvent;
   try {
     const requestId = String(event?.request?.request ?? event?.id ?? "");
-    if (!requestId) {
+    const shape = rawEvent;
+    if (!requestId || shape?.response || shape?.errorText) {
       return;
     }
+    const previous = rows.get(requestId);
     const entry = {
       id: requestId,
       url: event?.request?.url ?? "",
       method: event?.request?.method ?? "GET",
       requestHeaders: arrayHeadersToObject(event?.request?.headers),
-      timestamp: Date.now(),
-      startTime: Number(event?.timestamp ?? Date.now()),
+      // A redirect hop re-sends the request under the same id: one row, which
+      // keeps the clock of the hop it follows and reopens for the next answer.
+      timestamp: previous?.timestamp ?? Date.now(),
+      startTime: previous?.startTime ?? Number(event?.timestamp ?? Date.now()),
       type: getRequestType(event?.request?.url ?? "")
     };
-    pending.set(requestId, entry);
-    sinks.pushNetworkRequest(entry);
+    remember(rows, requestId, entry);
+    if (previous) {
+      sinks.replaceNetworkRequest(requestId, entry);
+    } else {
+      sinks.pushNetworkRequest(entry);
+    }
   } catch (err) {
     log("warn", `beforeRequestSent threw: ${errorMessage(err)}`);
   }
 }
-function handleBidiResponseCompleted(rawEvent, pending, sinks, log) {
+function handleBidiResponseCompleted(rawEvent, rows, sinks, log) {
   const event = rawEvent;
   try {
     const requestId = String(event?.request?.request ?? event?.id ?? "");
-    const previous = pending.get(requestId);
-    if (!previous) {
+    const previous = rows.get(requestId);
+    if (!previous || !event?.response) {
       return;
     }
     const { endTime, time } = bidiResponseTiming(
@@ -2938,22 +2997,75 @@ function handleBidiResponseCompleted(rawEvent, pending, sinks, log) {
       time,
       size: Number(event?.response?.bytesReceived) || void 0
     };
-    pending.delete(requestId);
+    remember(rows, requestId, finalized);
     sinks.replaceNetworkRequest(requestId, finalized);
   } catch (err) {
     log("warn", `responseCompleted threw: ${errorMessage(err)}`);
   }
 }
+function handleBidiFetchError(rawEvent, rows, sinks, log) {
+  const event = rawEvent;
+  try {
+    const requestId = String(event?.request?.request ?? event?.id ?? "");
+    const previous = rows.get(requestId);
+    if (!previous || typeof event?.errorText !== "string") {
+      return;
+    }
+    const { endTime, time } = bidiResponseTiming(
+      event?.request?.timings,
+      previous.startTime,
+      event?.timestamp
+    );
+    const errorText = event?.errorText ?? "Failed";
+    const finalized = {
+      ...previous,
+      status: 0,
+      statusText: errorText,
+      error: errorText,
+      endTime,
+      time
+    };
+    remember(rows, requestId, finalized);
+    sinks.replaceNetworkRequest(requestId, finalized);
+  } catch (err) {
+    log("warn", `fetchError threw: ${errorMessage(err)}`);
+  }
+}
+async function subscribeFetchErrors(inspector, rows, sinks, log) {
+  if (typeof inspector.fetchError === "function") {
+    await inspector.fetchError((e) => handleBidiFetchError(e, rows, sinks, log));
+    return;
+  }
+  const bidi = inspector.bidi;
+  if (typeof bidi?.subscribe !== "function" || !bidi.socket?.on) {
+    return;
+  }
+  await bidi.subscribe("network.fetchError");
+  bidi.socket.on("message", (raw) => {
+    try {
+      const { method, params } = JSON.parse(String(raw));
+      if (method === "network.fetchError") {
+        handleBidiFetchError(params, rows, sinks, log);
+      }
+    } catch {
+    }
+  });
+}
 async function attachNetworkInspector(driver, factory, sinks, log) {
   try {
     const inspector = await factory(driver);
-    const pending = /* @__PURE__ */ new Map();
+    const rows = /* @__PURE__ */ new Map();
     await inspector.beforeRequestSent(
-      (e) => handleBidiRequestSent(e, pending, sinks, log)
+      (e) => handleBidiRequestSent(e, rows, sinks, log)
     );
     await inspector.responseCompleted(
-      (e) => handleBidiResponseCompleted(e, pending, sinks, log)
+      (e) => handleBidiResponseCompleted(e, rows, sinks, log)
     );
+    try {
+      await subscribeFetchErrors(inspector, rows, sinks, log);
+    } catch (err) {
+      log("warn", `BiDi network.fetchError unavailable: ${errorMessage(err)}`);
+    }
     log("info", "\u2713 BiDi NetworkInspector attached (request + response)");
     return true;
   } catch (err) {
@@ -3111,6 +3223,144 @@ function serializeWebSnapshot(nodes, context, options = {}) {
 // ../core/src/locators/xml-parsing.ts
 import { DOMParser } from "@xmldom/xmldom";
 import xpath from "xpath";
+
+// ../core/src/locators/xpath-index.ts
+var NAME = /[A-Za-z_][\w.-]*/y;
+var active = null;
+function parseSimpleXPath(expr) {
+  if (!expr.startsWith("//")) {
+    return null;
+  }
+  let pos = 2;
+  let tag;
+  if (expr[pos] === "*") {
+    tag = "*";
+    pos++;
+  } else {
+    NAME.lastIndex = pos;
+    const m = NAME.exec(expr);
+    if (!m) {
+      return null;
+    }
+    tag = m[0];
+    pos = NAME.lastIndex;
+  }
+  if (pos === expr.length) {
+    return { tag, conditions: [] };
+  }
+  if (expr[pos] !== "[" || !expr.endsWith("]")) {
+    return null;
+  }
+  const conditions = parseConditions(expr.slice(pos + 1, -1));
+  return conditions ? { tag, conditions } : null;
+}
+function parseConditions(body) {
+  const conditions = [];
+  let pos = 0;
+  for (; ; ) {
+    if (body[pos] !== "@") {
+      return null;
+    }
+    NAME.lastIndex = pos + 1;
+    const m = NAME.exec(body);
+    if (!m || body[NAME.lastIndex] !== "=") {
+      return null;
+    }
+    const quote = body[NAME.lastIndex + 1];
+    if (quote !== '"' && quote !== "'") {
+      return null;
+    }
+    const start = NAME.lastIndex + 2;
+    const end = body.indexOf(quote, start);
+    if (end === -1) {
+      return null;
+    }
+    conditions.push({ name: m[0], value: body.slice(start, end) });
+    pos = end + 1;
+    if (pos === body.length) {
+      return conditions;
+    }
+    if (!body.startsWith(" and ", pos)) {
+      return null;
+    }
+    pos += 5;
+  }
+}
+function append(map, key, value) {
+  const list = map.get(key);
+  if (list) {
+    list.push(value);
+  } else {
+    map.set(key, [value]);
+  }
+}
+function buildIndex(doc) {
+  const index = {
+    doc,
+    all: [],
+    byTag: /* @__PURE__ */ new Map(),
+    byAttr: /* @__PURE__ */ new Map()
+  };
+  const stack = doc.documentElement ? [doc.documentElement] : [];
+  const ordered = [];
+  while (stack.length > 0) {
+    const el = stack.pop();
+    if (el.namespaceURI || el.nodeName.includes(":")) {
+      return null;
+    }
+    ordered.push(el);
+    for (let i = el.childNodes.length - 1; i >= 0; i--) {
+      const child = el.childNodes.item(i);
+      if (child?.nodeType === 1) {
+        stack.push(child);
+      }
+    }
+  }
+  for (const el of ordered) {
+    index.all.push(el);
+    append(index.byTag, el.nodeName, el);
+    for (let i = 0; i < el.attributes.length; i++) {
+      const { name, value } = el.attributes.item(i);
+      if (name === "xmlns" || name.includes(":")) {
+        return null;
+      }
+      let byValue = index.byAttr.get(name);
+      if (!byValue) {
+        byValue = /* @__PURE__ */ new Map();
+        index.byAttr.set(name, byValue);
+      }
+      append(byValue, value, el);
+    }
+  }
+  return index;
+}
+function withXPathIndex(doc, walk) {
+  const previous = active;
+  active = doc ? buildIndex(doc) : null;
+  try {
+    return walk();
+  } finally {
+    active = previous;
+  }
+}
+function selectIndexed(doc, expr) {
+  if (active?.doc !== doc) {
+    return null;
+  }
+  const query = parseSimpleXPath(expr);
+  if (!query) {
+    return null;
+  }
+  const [first, ...rest] = query.conditions;
+  const candidates = first ? active.byAttr.get(first.name)?.get(first.value) ?? [] : query.tag === "*" ? active.all : active.byTag.get(query.tag) ?? [];
+  return candidates.filter(
+    (el) => (query.tag === "*" || el.nodeName === query.tag) && rest.every(
+      (c) => el.hasAttribute(c.name) && el.getAttribute(c.name) === c.value
+    )
+  );
+}
+
+// ../core/src/locators/xml-parsing.ts
 function childNodesOf(node) {
   const children = [];
   if (node.childNodes) {
@@ -3240,6 +3490,10 @@ function xmlToDOM(sourceXML) {
 }
 function evaluateXPath(doc, xpathExpr) {
   try {
+    const indexed = selectIndexed(doc, xpathExpr);
+    if (indexed) {
+      return indexed;
+    }
     const nodes = xpath.select(xpathExpr, doc);
     if (Array.isArray(nodes)) {
       return nodes;
@@ -4488,7 +4742,7 @@ function generateAllElementLocators(sourceXML, options) {
     results: [],
     parsedDOM
   };
-  traverseTree(sourceJSON, ctx);
+  withXPathIndex(parsedDOM, () => traverseTree(sourceJSON, ctx));
   return ctx.results;
 }
 
@@ -4945,6 +5199,207 @@ function webdriverPost(address, sessionId, path10, body) {
     body
   );
 }
+function webdriverExecute(address, sessionId, body, args = []) {
+  return webdriverPost(address, sessionId, "execute/sync", {
+    script: body,
+    args
+  });
+}
+
+// ../core/src/appium-interceptor.ts
+var INTERCEPT_CAPABILITY = "appium:intercept";
+var APPIUM_OPTIONS = "appium:options";
+var NATIVE_NETWORK_DRAIN_INTERVAL_MS = 2e3;
+function flattenInterceptedHeaders(headers) {
+  const flat = {};
+  for (const [name, value] of Object.entries(headers ?? {})) {
+    if (/\s/.test(name)) {
+      continue;
+    }
+    flat[name.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+  }
+  return flat;
+}
+function interceptedBodyText(body) {
+  if (body === void 0 || body === null || body === "") {
+    return void 0;
+  }
+  return typeof body === "string" ? body : JSON.stringify(body);
+}
+function interceptedToNetworkRequest(entry, id, observedAt) {
+  const responseHeaders = flattenInterceptedHeaders(entry.responseHeaders);
+  const responseBody = interceptedBodyText(entry.responseBody);
+  return {
+    id,
+    url: entry.url,
+    method: entry.method,
+    status: entry.statusCode,
+    type: getRequestType(entry.url, responseHeaders["content-type"]),
+    timestamp: observedAt.timestamp,
+    startTime: observedAt.startTime,
+    endTime: observedAt.startTime,
+    requestHeaders: flattenInterceptedHeaders(entry.requestHeaders),
+    responseHeaders,
+    response: {
+      fromCache: false,
+      headers: responseHeaders,
+      mimeType: responseHeaders["content-type"]?.split(";")[0]?.trim() ?? "",
+      status: entry.statusCode
+    },
+    requestBody: interceptedBodyText(entry.requestBody),
+    responseBody,
+    size: responseBody === void 0 ? void 0 : Buffer.byteLength(responseBody)
+  };
+}
+var InterceptorNetworkPoller = class {
+  #execute;
+  #listenerId;
+  #seen = 0;
+  // Drains are chained: two overlapping reads would both list the entries past the same `#seen`.
+  #tail = Promise.resolve([]);
+  constructor(execute) {
+    this.#execute = execute;
+  }
+  async start() {
+    const id = await this.#execute("interceptor: startListening", [{}]);
+    this.#listenerId = typeof id === "string" ? id : void 0;
+    return this.#listenerId !== void 0;
+  }
+  drain() {
+    this.#tail = this.#tail.catch(() => []).then(() => this.#readFresh());
+    return this.#tail;
+  }
+  async #readFresh() {
+    const listenerId = this.#listenerId;
+    if (!listenerId) {
+      return [];
+    }
+    const data = await this.#execute("interceptor: getInterceptedData", [
+      { id: listenerId }
+    ]);
+    if (!Array.isArray(data)) {
+      throw new Error("the plugin returned no intercepted data");
+    }
+    if (data.length <= this.#seen) {
+      return [];
+    }
+    const observedAt = { timestamp: Date.now(), startTime: performance.now() };
+    const fresh = data.slice(this.#seen).map(
+      (entry, offset) => interceptedToNetworkRequest(
+        entry,
+        `interceptor-${listenerId}-${this.#seen + offset}`,
+        observedAt
+      )
+    );
+    this.#seen = data.length;
+    return fresh;
+  }
+};
+function asksForIntercept(caps) {
+  if (!caps || typeof caps !== "object") {
+    return false;
+  }
+  const map = caps;
+  const read = (key) => typeof map.get === "function" ? map.get(key) : map[key];
+  if (read(INTERCEPT_CAPABILITY) === true) {
+    return true;
+  }
+  const grouped = read(APPIUM_OPTIONS);
+  return !!grouped && typeof grouped === "object" && grouped.intercept === true;
+}
+function requestsInterceptedNetwork(capabilities) {
+  if (asksForIntercept(capabilities)) {
+    return true;
+  }
+  if (!capabilities || typeof capabilities !== "object") {
+    return false;
+  }
+  const { alwaysMatch, firstMatch } = capabilities;
+  return [alwaysMatch, ...Array.isArray(firstMatch) ? firstMatch : []].some(
+    asksForIntercept
+  );
+}
+var NativeNetworkCapture = class {
+  #sink;
+  #onLog;
+  #now;
+  #lastDrainAt = Number.NEGATIVE_INFINITY;
+  #poller;
+  // A start superseded by a later one (session replaced mid-handshake) must not install its poller.
+  #generation = 0;
+  constructor(sink, onLog, now = Date.now) {
+    this.#sink = sink;
+    this.#onLog = onLog;
+    this.#now = now;
+  }
+  /** Called per session: a listener dies with its session. */
+  async start(target) {
+    const generation = ++this.#generation;
+    this.#poller = void 0;
+    if (!target?.requested || !isNativeAppSession(target.capabilities)) {
+      return;
+    }
+    if (!target.execute) {
+      this.#onLog(
+        "warn",
+        `${INTERCEPT_CAPABILITY} is set but ${target.unavailableReason ?? "the driver cannot be reached outside the command path"}; native network is not captured`
+      );
+      return;
+    }
+    const poller = new InterceptorNetworkPoller(target.execute);
+    const started = await poller.start().catch((err) => {
+      this.#onLog(
+        "warn",
+        `appium-interceptor listener failed to start: ${errorMessage(err)}`
+      );
+      return false;
+    });
+    if (generation !== this.#generation) {
+      return;
+    }
+    if (!started) {
+      this.#onLog(
+        "warn",
+        `${INTERCEPT_CAPABILITY} is set but the interceptor listener did not start; is Appium running with --use-plugins=appium-interceptor?`
+      );
+      return;
+    }
+    this.#onLog("info", "Native network capture active via appium-interceptor");
+    this.#poller = poller;
+    this.#lastDrainAt = Number.NEGATIVE_INFINITY;
+  }
+  /** Whether a listener is running, so a caller can skip a drain that cannot find anything. */
+  get active() {
+    return this.#poller !== void 0;
+  }
+  /** At session end, so a drain after the driver quit does not reach a dead session. */
+  stop() {
+    this.#generation++;
+    this.#poller = void 0;
+  }
+  /** Lists what the proxy recorded since the last call. A test or session boundary must not pass `throttle`. */
+  async forward(options = {}) {
+    const poller = this.#poller;
+    if (!poller) {
+      return;
+    }
+    const now = this.#now();
+    if (options.throttle && now - this.#lastDrainAt < NATIVE_NETWORK_DRAIN_INTERVAL_MS) {
+      return;
+    }
+    this.#lastDrainAt = now;
+    const requests = await poller.drain().catch((err) => {
+      this.#onLog(
+        "warn",
+        `Reading appium-interceptor data failed: ${errorMessage(err)}`
+      );
+      return [];
+    });
+    if (requests.length > 0) {
+      this.#sink.recordNetworkRequests(requests);
+    }
+  }
+};
 
 // ../core/src/viewport.ts
 var VISUAL_VIEWPORT_SCRIPT = `
@@ -5284,20 +5739,8 @@ async function loadCollectorSource() {
 async function loadInjectableScript() {
   return `(async function() { ${await loadCollectorSource()} })()`;
 }
-var NON_INSTRUMENTABLE_SCHEMES = [
-  "about:",
-  "data:",
-  "chrome:",
-  "chrome-error:",
-  "edge:",
-  "moz-extension:",
-  "chrome-extension:"
-];
 function isInstrumentableDocument(url) {
-  if (!url) {
-    return false;
-  }
-  return !NON_INSTRUMENTABLE_SCHEMES.some((scheme) => url.startsWith(scheme));
+  return Boolean(url) && !isBrowserInternalUrl(url) && schemeOf(url) !== "data";
 }
 async function drainCollectorWithRecovery(opts) {
   const payload = await opts.drain();
@@ -5329,6 +5772,9 @@ async function drainCollectorWithRecovery(opts) {
 async function pollUntilReady(check, opts = {}) {
   const attempts = opts.attempts ?? 5;
   const intervalMs = opts.intervalMs ?? 200;
+  if (opts.checkFirst && await check()) {
+    return true;
+  }
   for (let i = 0; i < attempts; i++) {
     await new Promise((resolve) => setTimeout(resolve, intervalMs));
     if (await check()) {
@@ -5605,18 +6051,28 @@ function resolveAssertTargetFromArgs(args, fromHandle) {
 }
 
 // ../core/src/retry-tracker.ts
-var RetryTracker = class {
+var RetryTracker = class _RetryTracker {
   #lastSig = null;
+  #lastBareSig = null;
   #lastId = null;
   /** Build the canonical signature used for retry-equality checks. */
   static signature(command, args, callSource) {
     return JSON.stringify({ command, args, src: callSource ?? null });
   }
+  /** The signature without the call site: a framework's own repeat of a call
+   *  (a `wait()` poll from a timer) has no user frame on its stack. */
+  static bareSignature(command, args) {
+    return JSON.stringify({ command, args });
+  }
   /** True when the incoming signature matches the last captured one AND we
    *  have an id to replace (otherwise there's nothing to replace yet). */
   isRetry(sig) {
     return sig === this.#lastSig && this.#lastId !== null;
   }
+  /** As `isRetry`, for a repeat that carries no call site of its own. */
+  isRetryIgnoringSource(bareSig) {
+    return bareSig === this.#lastBareSig && this.#lastId !== null;
+  }
   /** The id of the last captured command, if any (for the replace-in-place
    *  flow). */
   get lastId() {
@@ -5625,8 +6081,17 @@ var RetryTracker = class {
   /** Record a fresh capture — sets both sig and id together. */
   recordCapture(sig, id) {
     this.#lastSig = sig;
+    this.#lastBareSig = _RetryTracker.bareOf(sig);
     this.#lastId = id;
   }
+  static bareOf(sig) {
+    try {
+      const { command, args } = JSON.parse(sig);
+      return _RetryTracker.bareSignature(command, args);
+    } catch {
+      return null;
+    }
+  }
   /** Record only the id (used by adapters that compute the sig but defer the
    *  id assignment to after an async capture call). */
   setLastId(id) {
@@ -5637,10 +6102,12 @@ var RetryTracker = class {
    *  commands). Pair with {@link setLastId} once the capture resolves. */
   setLastSig(sig) {
     this.#lastSig = sig;
+    this.#lastBareSig = _RetryTracker.bareOf(sig);
   }
   /** Reset at test/scenario boundaries so the next capture is "fresh". */
   reset() {
     this.#lastSig = null;
+    this.#lastBareSig = null;
     this.#lastId = null;
   }
 };
@@ -5919,6 +6386,31 @@ var ScreencastRecorderBase = class {
   }
 };
 
+// ../core/src/browser-focus.ts
+import { spawn } from "child_process";
+var LOCAL_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
+function restoreBrowserFocus(target, platform = process.platform, launch = spawn) {
+  const local = !target.host || LOCAL_HOSTS.has(target.host);
+  if (platform !== "darwin" || !local || !/safari/i.test(target.browserName ?? "") || /ios/i.test(target.platformName ?? "")) {
+    return false;
+  }
+  try {
+    const child = launch("open", ["-a", "Safari"], {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.on?.(
+      "error",
+      (err) => target.onError?.(`Could not bring Safari to the front: ${err.message}`)
+    );
+    child.unref?.();
+    return true;
+  } catch (err) {
+    target.onError?.(`Could not bring Safari to the front: ${String(err)}`);
+    return false;
+  }
+}
+
 // ../core/src/session-capturer.ts
 import fs10 from "fs/promises";
 import { WebSocket } from "ws";
@@ -6267,26 +6759,24 @@ var SessionCapturerBase = class _SessionCapturerBase {
    *
    * `skipConsoleLogs` / `skipNetworkRequests` opt out when an out-of-band
    * channel (BiDi) is already delivering those streams — without the gate
-   * the dashboard would see each entry twice.
+   * the dashboard would see each entry twice. `skipResourceTimingRequests`
+   * drops only the page's Resource Timing entries: a driver-side source
+   * reports the same loads with their headers, while the collector's patched
+   * fetch/XHR rows still carry the bodies nothing else captures.
    */
   processTracePayload(payload, opts = {}) {
     const { mutations, traceLogs, consoleLogs, networkRequests, metadata } = payload;
     if (metadata && typeof metadata === "object") {
       this.mergeMetadata(metadata);
     }
-    if (!opts.skipConsoleLogs && Array.isArray(consoleLogs) && consoleLogs.length > 0) {
-      const tagged = consoleLogs.map((entry) => ({
-        ...entry,
-        source: LOG_SOURCES.BROWSER
-      }));
+    const tagged = opts.skipConsoleLogs ? [] : this.#tagBrowserConsoleLogs(consoleLogs);
+    if (tagged.length > 0) {
       this.consoleLogs.push(...tagged);
       this.sendUpstream("consoleLogs", tagged);
     }
-    if (!opts.skipNetworkRequests && Array.isArray(networkRequests) && networkRequests.length > 0) {
-      const reqs = networkRequests;
-      this.networkRequests.push(...reqs);
-      this.sendUpstream("networkRequests", reqs);
-    }
+    this.recordNetworkRequests(
+      this.#acceptedNetworkRequests(networkRequests, opts)
+    );
     if (Array.isArray(mutations) && mutations.length > 0) {
       const batch = mutations;
       reattributeDomAnchors(
@@ -6303,6 +6793,50 @@ var SessionCapturerBase = class _SessionCapturerBase {
       this.sendUpstream("logs", logs);
     }
   }
+  #tagBrowserConsoleLogs(consoleLogs) {
+    if (!Array.isArray(consoleLogs)) {
+      return [];
+    }
+    return consoleLogs.map((entry) => ({
+      ...entry,
+      source: LOG_SOURCES.BROWSER
+    }));
+  }
+  /** Lists network rows and sends them in one message; a re-sent id replaces its row, as the dashboard does. */
+  recordNetworkRequests(reqs) {
+    if (reqs.length === 0) {
+      return;
+    }
+    for (const req of reqs) {
+      this.#upsertNetworkRequest(req);
+    }
+    this.sendUpstream("networkRequests", reqs);
+  }
+  /** Row index by request id; checked against the row before use, since adapters also write rows by index. */
+  #networkRequestIndex = /* @__PURE__ */ new Map();
+  #upsertNetworkRequest(req) {
+    let at = req.id ? this.#networkRequestIndex.get(req.id) : void 0;
+    if (at !== void 0 && this.networkRequests[at]?.id !== req.id) {
+      at = this.networkRequests.findIndex((r) => r.id === req.id);
+    }
+    if (at !== void 0 && at !== -1) {
+      this.networkRequests[at] = req;
+      this.#networkRequestIndex.set(req.id, at);
+      return;
+    }
+    if (req.id) {
+      this.#networkRequestIndex.set(req.id, this.networkRequests.length);
+    }
+    this.networkRequests.push(req);
+  }
+  #acceptedNetworkRequests(networkRequests, opts) {
+    if (opts.skipNetworkRequests || !Array.isArray(networkRequests)) {
+      return [];
+    }
+    return networkRequests.filter(
+      (req) => !opts.skipResourceTimingRequests || req.source !== NETWORK_CAPTURE_SOURCE.RESOURCE_TIMING
+    );
+  }
   /**
    * Resolve when the WS reaches OPEN state, or `false` on timeout / error.
    * Returns immediately if already open. Used by adapters that need a
@@ -6713,9 +7247,11 @@ export {
   mapCommandToAction,
   stripAnsi,
   mapChromeBrowserLogs,
+  getRequestType,
   WS_SCOPE,
   REUSE_ENV,
   TEST_STATE,
+  NETWORK_CAPTURE_SOURCE,
   SCREENCAST_DEFAULTS,
   captureActionSnapshot,
   toError,
@@ -6728,6 +7264,9 @@ export {
   TestAttemptTracker,
   webdriverGet,
   webdriverPost,
+  webdriverExecute,
+  requestsInterceptedNetwork,
+  NativeNetworkCapture,
   resolveViewport,
   isUserCodeFrame,
   normalizeFilePath,
@@ -6744,7 +7283,6 @@ export {
   recordSpecBoundary,
   flushRangeLogged,
   finalizeTraceExport,
-  getRequestType,
   findFreePort,
   attachBidiHandlers,
   COLLECTOR_READY_EXPRESSION,
@@ -6762,6 +7300,7 @@ export {
   resolveAssertTargetFromArgs,
   RetryTracker,
   ScreencastRecorderBase,
+  restoreBrowserFocus,
   SessionCapturerBase,
   createSuiteStats,
   createTestStats,
@@ -6773,4 +7312,4 @@ export {
   findTestDefinitions,
   TestReporterBase
 };
-//# sourceMappingURL=chunk-DM4FCAIJ.js.map
+//# sourceMappingURL=chunk-TUK7ZLQI.js.map