@wdio/nightwatch-devtools 1.8.2 → 2.1.0

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

@@ -12,10 +12,15 @@ var RUNNER_ENV = {
   WDIO_CONFIG: "DEVTOOLS_WDIO_CONFIG",
   NIGHTWATCH_CONFIG: "DEVTOOLS_NIGHTWATCH_CONFIG",
   WDIO_INITIAL_SPECS: "DEVTOOLS_WDIO_INITIAL_SPECS",
+  // The selection the Nightwatch run was launched with (specs, --tag, --env, ...), without --config; see encodeInitialArgs.
+  NIGHTWATCH_INITIAL_ARGS: "DEVTOOLS_NIGHTWATCH_INITIAL_ARGS",
   RUNNER_CWD: "DEVTOOLS_RUNNER_CWD",
   WDIO_BIN: "DEVTOOLS_WDIO_BIN",
   NIGHTWATCH_BIN: "DEVTOOLS_NIGHTWATCH_BIN"
 };
+function encodeInitialArgs(args) {
+  return JSON.stringify(args);
+}
 
 // ../core/src/error.ts
 function toError(value) {
@@ -30,7 +35,11 @@ function toError(value) {
     }
     return e;
   }
-  return new Error(String(value));
+  try {
+    return new Error(String(value));
+  } catch {
+    return new Error(Object.prototype.toString.call(value));
+  }
 }
 function errorMessage(value) {
   if (value instanceof Error) {
@@ -248,6 +257,9 @@ import fs2 from "fs/promises";
 import path2 from "path";
 
 // ../shared/src/trace-actions.ts
+function isWaitAction(action) {
+  return action?.method.startsWith("waitFor") ?? false;
+}
 var ASSERT_ACTION_CLASS = "Assert";
 var TRACKED_ASSERT_METHODS = [
   "equal",
@@ -334,6 +346,8 @@ var ACTION_MAP = {
   waitForElementNotVisible: { class: "Element", method: "waitForHidden" },
   waitForElementPresent: { class: "Element", method: "waitForExist" },
   waitForElementNotPresent: { class: "Element", method: "waitForNotExist" },
+  // A Selenium wait on an element locator (`until.elementLocated`, `presence_of_element_located`), named by its adapter.
+  waitForElementLocated: { class: "Element", method: "waitForExist" },
   // WDIO page/browser reads
   getTitle: { class: "Page", method: "getTitle" },
   getUrl: { class: "Page", method: "getUrl" },
@@ -344,6 +358,8 @@ var ACTION_MAP = {
   getCssValue: { class: "Element", method: "getCSSProperty" },
   getRect: { class: "Element", method: "getRect" },
   getCurrentUrl: { class: "Page", method: "getUrl" },
+  // A Selenium wait on any condition other than an element locator.
+  wait: { class: "Browser", method: "waitForFunction" },
   // Raw W3C protocol names. The JS adapters wrap a client library and report
   // its method names, but an adapter that patches the protocol chokepoint —
   // the Python one, and any future language binding — reports what WebDriver
@@ -420,6 +436,9 @@ function isInputDispatchingCommand(command) {
 function mapCommandToAction(command) {
   return ACTION_MAP[command] ?? mapAssertCommand(command);
 }
+function isWaitCommand(command) {
+  return isWaitAction(mapCommandToAction(command));
+}
 var ASSERT_TITLE_VALUE_MAX = 40;
 function formatAssertValue(value) {
   let text;
@@ -452,6 +471,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;
@@ -503,16 +545,6 @@ function detectLogLevel(text) {
 function createConsoleLogEntry(type, args, source = LOG_SOURCES.TEST) {
   return { timestamp: Date.now(), type, args, source };
 }
-function mapChromeBrowserLogs(entries) {
-  return entries.map((entry) => ({
-    timestamp: entry.timestamp,
-    type: chromeLogLevelToLogLevel(
-      entry.level
-    ),
-    args: [entry.message],
-    source: LOG_SOURCES.BROWSER
-  }));
-}
 function chromeLogLevelToLogLevel(level) {
   const levelName = (typeof level === "object" ? level?.name ?? "" : level ?? "").toUpperCase();
   switch (levelName) {
@@ -561,6 +593,9 @@ function namesAnAutomation(caps) {
     deepCapString(caps, "appium:automationName") ?? deepCapString(caps, "automationName")
   );
 }
+function isCapabilityBag(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
 function firstCapString(caps, keys, reject = () => false) {
   for (const key of keys) {
     const value = deepCapString(caps, key);
@@ -571,7 +606,7 @@ function firstCapString(caps, keys, reject = () => false) {
   return void 0;
 }
 function deviceFromCapabilities(capabilities) {
-  if (!capabilities || typeof capabilities !== "object") {
+  if (!isCapabilityBag(capabilities)) {
     return void 0;
   }
   const caps = capabilities;
@@ -595,7 +630,7 @@ function deviceFromCapabilities(capabilities) {
   };
 }
 function isNativeAppSession(capabilities) {
-  if (!capabilities || typeof capabilities !== "object") {
+  if (!isCapabilityBag(capabilities)) {
     return false;
   }
   const caps = capabilities;
@@ -1045,12 +1080,201 @@ function elementsScript(includeBounds, inViewportOnly, runner) {
   })()`;
 }
 
+// ../shared/src/page-scripts.ts
+var COLLECTOR_READY_EXPRESSION = 'typeof window.wdioTraceCollector !== "undefined"';
+var COLLECTOR_READY_SCRIPT = `return ${COLLECTOR_READY_EXPRESSION};`;
+var COLLECTOR_INJECT_SCRIPT = `var s=document.createElement('script');s.textContent=arguments[0];document.head.appendChild(s);${COLLECTOR_READY_SCRIPT}`;
+function collectorDrainExpression(forceAnchor = false) {
+  const call = forceAnchor ? "window.wdioTraceCollector.captureCurrentDom();" : "";
+  return `if (!(${COLLECTOR_READY_EXPRESSION})) { return null; } ${call} return window.wdioTraceCollector.getTraceData();`;
+}
+var CAPTURE_PERFORMANCE_SCRIPT = `
+  return (function() {
+    const performance = window.performance;
+    const navigation = performance.getEntriesByType?.('navigation')?.[0];
+    const resources = performance.getEntriesByType?.('resource') || [];
+
+    return {
+      navigation: navigation ? {
+        url: window.location.href,
+        timing: {
+          loadTime: navigation.loadEventEnd - navigation.fetchStart,
+          domReady: navigation.domContentLoadedEventEnd - navigation.fetchStart,
+          responseTime: navigation.responseEnd - navigation.requestStart,
+          dnsLookup: navigation.domainLookupEnd - navigation.domainLookupStart,
+          tcpConnection: navigation.connectEnd - navigation.connectStart,
+          serverResponse: navigation.responseEnd - navigation.responseStart
+        }
+      } : undefined,
+      resources: resources.map(function(resource) {
+        return {
+          url: resource.name,
+          duration: resource.duration,
+          size: resource.transferSize || 0,
+          type: resource.initiatorType,
+          startTime: resource.startTime,
+          responseEnd: resource.responseEnd
+        };
+      }),
+      cookies: (function() {
+        try { return document.cookie; } catch (e) { return ''; }
+      })(),
+      documentInfo: {
+        url: window.location.href,
+        title: document.title,
+        headers: {
+          userAgent: navigator.userAgent,
+          language: navigator.language,
+          platform: navigator.platform
+        },
+        documentInfo: {
+          readyState: document.readyState,
+          referrer: document.referrer,
+          characterSet: document.characterSet
+        }
+      }
+    };
+  })()
+`;
+
+// ../shared/src/command-tree.ts
+function nestCommands(commands) {
+  const nodes = commands.map((command) => ({
+    command,
+    children: []
+  }));
+  const byId = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const { id } = node.command;
+    if (typeof id === "number" && !byId.has(id)) {
+      byId.set(id, node);
+    }
+  }
+  const parentOf = (node) => {
+    const { parentId } = node.command;
+    return typeof parentId === "number" ? byId.get(parentId) : void 0;
+  };
+  const roots = [];
+  for (const node of nodes) {
+    const parent = parentOf(node);
+    if (parent && !closesCycle(node, parentOf)) {
+      parent.children.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+  return roots;
+}
+function closesCycle(node, parentOf) {
+  const seen = /* @__PURE__ */ new Set();
+  for (let at = parentOf(node); at && !seen.has(at); at = parentOf(at)) {
+    if (at === node) {
+      return true;
+    }
+    seen.add(at);
+  }
+  return false;
+}
+
+// ../shared/src/command-failure.ts
+function collapsedAssertResult(result) {
+  if (typeof result === "object" && result !== null && "passed" in result) {
+    return result;
+  }
+  return void 0;
+}
+function commandFailure(cmd, action) {
+  if (cmd.error) {
+    return errorFailure(cmd.error);
+  }
+  const collapsed = collapsedAssertResult(cmd.result);
+  if (collapsed && collapsed.passed === false) {
+    const isAssert = action.class === ASSERT_ACTION_CLASS;
+    return {
+      message: String(
+        collapsed.message ?? (isAssert ? "Assertion failed" : `${cmd.command} failed`)
+      )
+    };
+  }
+  if (cmd.result === false && isWaitAction(action)) {
+    const target = cmd.args?.find((a) => typeof a === "string");
+    return {
+      message: target ? `${cmd.command} timed out waiting for ${String(target)}` : `${cmd.command} timed out`
+    };
+  }
+  return void 0;
+}
+function errorFailure(error) {
+  return { message: error.message ?? String(error) };
+}
+function rowFailure(cmd) {
+  const action = mapCommandToAction(cmd.command);
+  if (action) {
+    return commandFailure(cmd, action);
+  }
+  return cmd.error ? errorFailure(cmd.error) : void 0;
+}
+function retriedRows(commands) {
+  const retried = /* @__PURE__ */ new Set();
+  const walk = (nodes, underPassing) => {
+    for (const { command, children } of nodes) {
+      const failed = Boolean(rowFailure(command));
+      if (underPassing && failed) {
+        retried.add(command);
+      }
+      walk(children, underPassing || !failed);
+    }
+  };
+  walk(nestCommands(commands), false);
+  return retried;
+}
+
 // ../shared/src/image.ts
 var PNG_BASE64_MAGIC = "iVBOR";
 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 +1371,9 @@ var TEST_STATE = {
   FAILED: "failed",
   SKIPPED: "skipped"
 };
+var NETWORK_CAPTURE_SOURCE = {
+  RESOURCE_TIMING: "resource-timing"
+};
 var SCREENCAST_DEFAULTS = {
   enabled: false,
   captureFormat: "jpeg",
@@ -1518,7 +1745,7 @@ function splitNumericSuffix(value) {
   return { rest: value.slice(0, sep), num: Number(digits) };
 }
 function callSourceToStack(callSource) {
-  if (!callSource || callSource === "unknown:0") {
+  if (!callSource) {
     return void 0;
   }
   const last = splitNumericSuffix(callSource);
@@ -1551,28 +1778,28 @@ function ownTitle(title, parent) {
   return title.slice(parent.title.length).trim() || title;
 }
 function buildGroupPath(cmd, testMetadata) {
-  const path10 = [];
+  const path11 = [];
   if (cmd.testUid) {
     const entry = testMetadata?.get(cmd.testUid);
     for (const ancestor of entry?.ancestry ?? []) {
-      path10.push({
+      path11.push({
         uid: ancestor.uid,
-        title: ownTitle(ancestor.title, path10[path10.length - 1])
+        title: ownTitle(ancestor.title, path11[path11.length - 1])
       });
     }
-    path10.push({
+    path11.push({
       uid: cmd.testUid,
-      title: ownTitle(entry?.title ?? cmd.testUid, path10[path10.length - 1])
+      title: ownTitle(entry?.title ?? cmd.testUid, path11[path11.length - 1])
     });
   }
   if (cmd.stepUid) {
     const stepEntry = testMetadata?.get(cmd.stepUid);
-    path10.push({
+    path11.push({
       uid: cmd.stepUid,
-      title: ownTitle(stepEntry?.title ?? cmd.stepUid, path10[path10.length - 1])
+      title: ownTitle(stepEntry?.title ?? cmd.stepUid, path11[path11.length - 1])
     });
   }
-  return path10;
+  return path11;
 }
 
 // ../trace/src/trace-action-events.ts
@@ -1591,12 +1818,6 @@ function serializableResult(result) {
     return void 0;
   }
 }
-function collapsedAssertResult(result) {
-  if (typeof result === "object" && result !== null && "passed" in result) {
-    return result;
-  }
-  return void 0;
-}
 function buildAssertParams(cmd) {
   const params = Object.fromEntries(
     cmd.args.map((arg, index) => [String(index), arg])
@@ -1689,28 +1910,6 @@ function buildParamsAndTitle(action, cmd) {
     )
   };
 }
-function actionError(cmd, action) {
-  if (cmd.error) {
-    const err = cmd.error;
-    return { message: err.message ?? String(cmd.error) };
-  }
-  const isAssert = action.class === ASSERT_ACTION_CLASS;
-  const collapsed = collapsedAssertResult(cmd.result);
-  if (collapsed && collapsed.passed === false) {
-    return {
-      message: String(
-        collapsed.message ?? (isAssert ? "Assertion failed" : `${cmd.command} failed`)
-      )
-    };
-  }
-  if (cmd.result === false && action.method.startsWith("waitFor")) {
-    const target = cmd.args?.find((a) => typeof a === "string");
-    return {
-      message: target ? `${cmd.command} timed out waiting for ${String(target)}` : `${cmd.command} timed out`
-    };
-  }
-  return void 0;
-}
 function resolveActionPoint(action, cmd, snapshotIndex) {
   if (action.class !== "Element" || !POINTABLE_METHODS.has(action.method)) {
     return void 0;
@@ -1729,10 +1928,13 @@ function resolveActionPoint(action, cmd, snapshotIndex) {
   }
   return void 0;
 }
-function buildAfterEvent(cmd, action, callId, endMs, snapshotIndex) {
+function buildAfterEvent(cmd, action, callId, endMs, ctx) {
+  const { snapshotIndex } = ctx;
   const afterEvent = { type: "after", callId, endTime: endMs };
-  const error = actionError(cmd, action);
-  if (error) {
+  const error = commandFailure(cmd, action);
+  if (error && ctx.retried.has(cmd)) {
+    afterEvent.retriedError = error;
+  } else if (error) {
     afterEvent.error = error;
   }
   const result = serializableResult(cmd.result);
@@ -1749,13 +1951,11 @@ function buildAfterEvent(cmd, action, callId, endMs, snapshotIndex) {
   }
   return afterEvent;
 }
-function pushActionPair(stream, cmd, action, pageId, wallTime, snapshotIndex) {
+function pushBefore(stream, cmd, action, pageId, wallTime, parentCallId, snapshotIndex) {
   stream.callCounter++;
   const callId = `call@${stream.callCounter}`;
   const rawStartMs = (cmd.startTime ?? cmd.timestamp) - wallTime;
-  const rawEndMs = cmd.timestamp - wallTime;
   const startMs = Math.max(stream.prevEndMs, rawStartMs);
-  const endMs = Math.max(startMs + 1, rawEndMs);
   const { params, title } = buildParamsAndTitle(action, cmd);
   const beforeEvent = {
     type: "before",
@@ -1767,7 +1967,7 @@ function pushActionPair(stream, cmd, action, pageId, wallTime, snapshotIndex) {
     params,
     title,
     apiName: `${action.class.toLowerCase()}.${action.method}`,
-    parentId: stream.openGroups[stream.openGroups.length - 1]?.callId
+    parentId: parentCallId ?? stream.openGroups[stream.openGroups.length - 1]?.callId
   };
   const stack = callSourceToStack(cmd.callSource);
   if (stack) {
@@ -1778,7 +1978,38 @@ function pushActionPair(stream, cmd, action, pageId, wallTime, snapshotIndex) {
     beforeEvent.beforeSnapshot = beforeName;
   }
   stream.events.push(beforeEvent);
-  stream.events.push(buildAfterEvent(cmd, action, callId, endMs, snapshotIndex));
+  return { callId, startMs };
+}
+function emitNode(stream, node, ctx, parentCallId) {
+  const cmd = node.command;
+  const action = mapCommandToAction(cmd.command);
+  if (!action) {
+    for (const child of node.children) {
+      emitNode(stream, child, ctx, parentCallId);
+    }
+    return;
+  }
+  const { callId, startMs } = pushBefore(
+    stream,
+    cmd,
+    action,
+    ctx.pageId,
+    ctx.wallTime,
+    parentCallId,
+    ctx.snapshotIndex
+  );
+  if (node.children.length) {
+    stream.prevEndMs = startMs;
+    for (const child of node.children) {
+      emitNode(stream, child, ctx, callId);
+    }
+  }
+  const endMs = Math.max(
+    startMs + 1,
+    cmd.timestamp - ctx.wallTime,
+    node.children.length ? stream.prevEndMs : 0
+  );
+  stream.events.push(buildAfterEvent(cmd, action, callId, endMs, ctx));
   stream.prevEndMs = endMs;
 }
 function buildActionEvents(commands, pageId, wallTime, testMetadata, snapshotIndex) {
@@ -1791,20 +2022,42 @@ function buildActionEvents(commands, pageId, wallTime, testMetadata, snapshotInd
   const ordered = [...commands].sort(
     (a, b) => (a.startTime ?? a.timestamp) - (b.startTime ?? b.timestamp) || (a.sequence ?? 0) - (b.sequence ?? 0)
   );
-  for (const cmd of ordered) {
-    const action = mapCommandToAction(cmd.command);
-    if (!action) {
-      continue;
+  const ctx = {
+    pageId,
+    wallTime,
+    snapshotIndex,
+    retried: retriedRows(ordered)
+  };
+  for (const node of nestCommands(ordered)) {
+    if (hasAction(node)) {
+      syncGroups(stream, node.command, pageId, wallTime, testMetadata);
     }
-    syncGroups(stream, cmd, pageId, wallTime, testMetadata);
-    pushActionPair(stream, cmd, action, pageId, wallTime, snapshotIndex);
+    emitNode(stream, node, ctx);
   }
   closeGroupsFrom(stream, 0);
   return stream.events;
 }
+function hasAction(node) {
+  return Boolean(mapCommandToAction(node.command.command)) || node.children.some(hasAction);
+}
 
 // ../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 +2121,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 } : {}
     }
   };
 }
@@ -1989,6 +2240,7 @@ function capturedSteps(commands) {
 function generateTranscript(commands, startWallTime, title) {
   const wallTimeISO = new Date(startWallTime).toISOString();
   const lines = [`# ${title ?? "Session"} \u2014 ${wallTimeISO}`, ""];
+  const retried = retriedRows(commands);
   capturedSteps(commands).forEach(({ entry, action }, idx) => {
     const rawArgs = entry.args;
     const parts = [stripAnsi(formatActionTitle(action, rawArgs))];
@@ -1999,7 +2251,8 @@ function generateTranscript(commands, startWallTime, title) {
       }
     }
     if (entry.error) {
-      parts.push(`ERROR: ${errorMessage2(entry.error)}`);
+      const label = retried.has(entry) ? "RETRIED" : "ERROR";
+      parts.push(`${label}: ${errorMessage2(entry.error)}`);
     }
     lines.push(asNumberedItem(`${idx + 1}. `, parts.join("  ")));
   });
@@ -2741,7 +2994,7 @@ async function maybeWriteManifest(ctx, fanOutArtifacts) {
   }
   const artifacts = ctx.collectedArtifacts ?? fanOutArtifacts;
   try {
-    const path10 = await writeArtifactsManifest(
+    const path11 = await writeArtifactsManifest(
       ctx.resolveOutputDir(),
       buildArtifactsManifest({
         sessionId: ctx.sessionId,
@@ -2750,7 +3003,7 @@ async function maybeWriteManifest(ctx, fanOutArtifacts) {
         testMetadata: ctx.testMetadata
       })
     );
-    ctx.log?.("info", `Artifacts manifest written to ${path10}`);
+    ctx.log?.("info", `Artifacts manifest written to ${path11}`);
   } catch (err) {
     ctx.log?.(
       "warn",
@@ -2764,48 +3017,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 +3104,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(
@@ -2935,25 +3168,78 @@ function handleBidiResponseCompleted(rawEvent, pending, sinks, log) {
       responseHeaders: arrayHeadersToObject(event?.response?.headers),
       type: getRequestType(previous.url, event?.response?.mimeType),
       endTime,
-      time,
-      size: Number(event?.response?.bytesReceived) || void 0
+      time,
+      size: Number(event?.response?.bytesReceived) || void 0
+    };
+    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
     };
-    pending.delete(requestId);
+    remember(rows, requestId, finalized);
     sinks.replaceNetworkRequest(requestId, finalized);
   } catch (err) {
-    log("warn", `responseCompleted threw: ${errorMessage(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) {
@@ -3036,7 +3322,7 @@ function resolveBaseDir(input) {
     if (!dir) {
       continue;
     }
-    if (dir.includes(NODE_MODULES_SEGMENT)) {
+    if (`${dir}${path4.sep}`.includes(NODE_MODULES_SEGMENT)) {
       continue;
     }
     if (isWritable(dir)) {
@@ -3111,6 +3397,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) {
@@ -3134,14 +3558,14 @@ function translateRecursively(domNode, parentPath = "", index = null) {
       }
     }
   }
-  const path10 = index === null ? "" : `${parentPath ? parentPath + "." : ""}${index}`;
+  const path11 = index === null ? "" : `${parentPath ? parentPath + "." : ""}${index}`;
   return {
     children: childNodesOf(domNode).map(
-      (childNode, childIndex) => translateRecursively(childNode, path10, childIndex)
+      (childNode, childIndex) => translateRecursively(childNode, path11, childIndex)
     ),
     tagName: domNode.nodeName,
     attributes,
-    path: path10
+    path: path11
   };
 }
 function isSameElement(node1, node2) {
@@ -3240,6 +3664,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;
@@ -3278,11 +3706,11 @@ function checkXPathUniqueness(doc, xpathExpr, targetNode) {
     return { isUnique: false };
   }
 }
-function findDOMNodeByPath(doc, path10) {
-  if (!path10) {
+function findDOMNodeByPath(doc, path11) {
+  if (!path11) {
     return doc.documentElement;
   }
-  const indices = path10.split(".").map(Number);
+  const indices = path11.split(".").map(Number);
   let current = doc.documentElement;
   for (const index of indices) {
     if (!current) {
@@ -4488,7 +4916,7 @@ function generateAllElementLocators(sourceXML, options) {
     results: [],
     parsedDOM
   };
-  traverseTree(sourceJSON, ctx);
+  withXPathIndex(parsedDOM, () => traverseTree(sourceJSON, ctx));
   return ctx.results;
 }
 
@@ -4832,21 +5260,21 @@ async function captureAndAttachVideo(input) {
 import http from "http";
 import https from "https";
 var WEBDRIVER_REQUEST_TIMEOUT_MS = 5e3;
-function basePrefix(path10) {
-  if (!path10 || path10 === "/") {
+function basePrefix(path11) {
+  if (!path11 || path11 === "/") {
     return "";
   }
-  return path10.endsWith("/") ? path10.slice(0, -1) : path10;
+  return path11.endsWith("/") ? path11.slice(0, -1) : path11;
 }
 function formatHost(hostname) {
   const isIpv6Literal = hostname.includes(":") && !hostname.startsWith("[");
   return isIpv6Literal ? `[${hostname}]` : hostname;
 }
-function sessionEndpoint(address, sessionId, path10) {
+function sessionEndpoint(address, sessionId, path11) {
   const protocol = address.protocol ?? "http";
   const prefix = basePrefix(address.path);
   const host = formatHost(address.hostname);
-  return `${protocol}://${host}:${address.port}${prefix}/session/${sessionId}/${path10}`;
+  return `${protocol}://${host}:${address.port}${prefix}/session/${sessionId}/${path11}`;
 }
 function authHeaders(address) {
   if (!address.user || !address.key) {
@@ -4930,21 +5358,222 @@ function webdriverRequest(address, endpoint, method, body) {
     req.end();
   });
 }
-function webdriverGet(address, sessionId, path10) {
+function webdriverGet(address, sessionId, path11) {
   return webdriverRequest(
     address,
-    sessionEndpoint(address, sessionId, path10),
+    sessionEndpoint(address, sessionId, path11),
     "GET"
   );
 }
-function webdriverPost(address, sessionId, path10, body) {
+function webdriverPost(address, sessionId, path11, body) {
   return webdriverRequest(
     address,
-    sessionEndpoint(address, sessionId, path10),
+    sessionEndpoint(address, sessionId, path11),
     "POST",
     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 = `
@@ -4999,10 +5628,60 @@ async function resolveViewport(capabilities, probes) {
 import { createRequire as createRequire3 } from "module";
 
 // ../core/src/stack.ts
+import { existsSync, readFileSync } from "fs";
+import path8 from "path";
+import { fileURLToPath } from "url";
 import { parse as parseStackTrace } from "stacktrace-parser";
+var WORKSPACE_ROOT_NAME = "devtools-monorepo";
+function findOwnPackagesDir(fromDir) {
+  for (let dir = fromDir; ; dir = path8.dirname(dir)) {
+    if (existsSync(path8.join(dir, "pnpm-workspace.yaml"))) {
+      return readPackageName(dir) === WORKSPACE_ROOT_NAME ? path8.join(dir, "packages") : void 0;
+    }
+    if (path8.dirname(dir) === dir) {
+      return void 0;
+    }
+  }
+}
+function readPackageName(dir) {
+  try {
+    const pkg = JSON.parse(
+      readFileSync(path8.join(dir, "package.json"), "utf8")
+    );
+    return typeof pkg.name === "string" ? pkg.name : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var ownPackagesDir;
+function resolveOwnPackagesDir() {
+  if (ownPackagesDir === void 0) {
+    try {
+      ownPackagesDir = findOwnPackagesDir(path8.dirname(fileURLToPath(import.meta.url))) ?? null;
+    } catch {
+      ownPackagesDir = null;
+    }
+  }
+  return ownPackagesDir ?? void 0;
+}
+function isPackageSource(file, packagesDir) {
+  if (!packagesDir) {
+    return false;
+  }
+  try {
+    const filePath = file.startsWith("file://") ? fileURLToPath(file) : file;
+    const relative = path8.relative(packagesDir, filePath);
+    if (relative.startsWith("..") || path8.isAbsolute(relative)) {
+      return false;
+    }
+    return relative.split(path8.sep)[1] === "src";
+  } catch {
+    return false;
+  }
+}
 function isUserCodeFrame(frame) {
   const { file } = frame;
-  return !!(file && !file.includes("/node_modules/") && !file.includes("<anonymous>") && !file.includes("node:internal") && !file.includes("/dist/") && !file.endsWith("/index.js"));
+  return !!(file && !file.includes("/node_modules/") && !file.includes("<anonymous>") && !file.includes("node:internal") && !file.includes("/dist/") && !file.endsWith("/index.js") && !isPackageSource(file, resolveOwnPackagesDir()));
 }
 function normalizeFilePath(filePath) {
   const stripped = filePath.replace(/^file:\/\//, "").split(":")[0];
@@ -5019,16 +5698,24 @@ function isAssertFromUserCode(stack) {
   const caller = parseStackTrace(stack)[1];
   return !!caller && isUserCodeFrame(caller);
 }
+var NO_CALL_SOURCE = {
+  filePath: void 0,
+  callSource: void 0
+};
 function getCallSourceFromStack(stack = new Error().stack) {
   if (!stack) {
-    return { filePath: void 0, callSource: "unknown:0" };
+    return NO_CALL_SOURCE;
   }
-  const frame = parseStackTrace(stack).find(isUserCodeFrame);
-  if (!frame?.file) {
-    return { filePath: void 0, callSource: "unknown:0" };
+  try {
+    const frame = parseStackTrace(stack).find(isUserCodeFrame);
+    if (!frame?.file) {
+      return NO_CALL_SOURCE;
+    }
+    const filePath = normalizeFilePath(frame.file);
+    return { filePath, callSource: `${filePath}:${frame.lineNumber ?? 0}` };
+  } catch {
+    return NO_CALL_SOURCE;
   }
-  const filePath = normalizeFilePath(frame.file);
-  return { filePath, callSource: `${filePath}:${frame.lineNumber ?? 0}` };
 }
 
 // ../core/src/assert-patcher.ts
@@ -5250,19 +5937,14 @@ function patchNodeAssert(onCommand, onLog, resolveAssertTarget) {
 
 // ../core/src/script-loader.ts
 import fs8 from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 import { createRequire as createRequire4 } from "module";
 var require4 = createRequire4(import.meta.url);
-var COLLECTOR_READY_EXPRESSION = 'typeof window.wdioTraceCollector !== "undefined"';
-function collectorDrainExpression(forceAnchor = false) {
-  const call = forceAnchor ? "window.wdioTraceCollector.captureCurrentDom();" : "";
-  return `if (!(${COLLECTOR_READY_EXPRESSION})) { return null; } ${call} return window.wdioTraceCollector.getTraceData();`;
-}
 function collectorSourceCandidates(entry) {
-  const dir = path8.dirname(entry);
+  const dir = path9.dirname(entry);
   return [
-    path8.join(dir, "script.js"),
-    path8.join(dir, "..", "dist", "script.js")
+    path9.join(dir, "script.js"),
+    path9.join(dir, "..", "dist", "script.js")
   ];
 }
 async function loadCollectorSource() {
@@ -5284,20 +5966,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 +5999,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()) {
@@ -5402,7 +6075,7 @@ var TerminalLineThrottle = class {
 // ../core/src/finalize-screencast.ts
 import fs9 from "fs";
 import os2 from "os";
-import path9 from "path";
+import path10 from "path";
 async function finalizeScreencast({
   recorder,
   sessionId,
@@ -5426,12 +6099,12 @@ async function finalizeScreencast({
   }
   const fileName = `${filenamePrefix}-${sessionId}.webm`;
   const candidate = outputDir || process.cwd();
-  let videoPath = path9.join(candidate, fileName);
+  let videoPath = path10.join(candidate, fileName);
   try {
     fs9.mkdirSync(candidate, { recursive: true });
     fs9.accessSync(candidate, fs9.constants.W_OK);
   } catch {
-    videoPath = path9.join(os2.tmpdir(), fileName);
+    videoPath = path10.join(os2.tmpdir(), fileName);
   }
   try {
     await encodeToVideo(frames, videoPath, { captureFormat });
@@ -5499,54 +6172,9 @@ function isInputDispatchInFlight() {
 }
 
 // ../core/src/performance-capture.ts
-var CAPTURE_PERFORMANCE_SCRIPT = `
-  (function() {
-    const performance = window.performance;
-    const navigation = performance.getEntriesByType?.('navigation')?.[0];
-    const resources = performance.getEntriesByType?.('resource') || [];
-
-    return {
-      navigation: navigation ? {
-        url: window.location.href,
-        timing: {
-          loadTime: navigation.loadEventEnd - navigation.fetchStart,
-          domReady: navigation.domContentLoadedEventEnd - navigation.fetchStart,
-          responseTime: navigation.responseEnd - navigation.requestStart,
-          dnsLookup: navigation.domainLookupEnd - navigation.domainLookupStart,
-          tcpConnection: navigation.connectEnd - navigation.connectStart,
-          serverResponse: navigation.responseEnd - navigation.responseStart
-        }
-      } : undefined,
-      resources: resources.map(function(resource) {
-        return {
-          url: resource.name,
-          duration: resource.duration,
-          size: resource.transferSize || 0,
-          type: resource.initiatorType,
-          startTime: resource.startTime,
-          responseEnd: resource.responseEnd
-        };
-      }),
-      cookies: (function() {
-        try { return document.cookie; } catch (e) { return ''; }
-      })(),
-      documentInfo: {
-        url: window.location.href,
-        title: document.title,
-        headers: {
-          userAgent: navigator.userAgent,
-          language: navigator.language,
-          platform: navigator.platform
-        },
-        documentInfo: {
-          readyState: document.readyState,
-          referrer: document.referrer,
-          characterSet: document.characterSet
-        }
-      }
-    };
-  })()
-`;
+function formatMilliseconds(ms) {
+  return typeof ms === "number" && Number.isFinite(ms) ? `${ms.toFixed(2)} ms` : void 0;
+}
 function applyPerformanceData(command, payload, navigatedUrl) {
   if (!payload || !payload.navigation) {
     return false;
@@ -5559,7 +6187,7 @@ function applyPerformanceData(command, payload, navigatedUrl) {
   command.documentInfo = payload.documentInfo;
   command.result = {
     url: navigatedUrl,
-    loadTime: payload.navigation?.timing?.loadTime,
+    loadTime: formatMilliseconds(payload.navigation?.timing?.loadTime),
     resources: payload.resources,
     resourceCount: payload.resources?.length,
     cookies: payload.cookies,
@@ -5591,14 +6219,17 @@ function rememberReadValue(value, selector) {
     }
   }
 }
-function selectorForReadValue(value) {
-  return selectorByReadValue.get(value) ?? void 0;
+function clearReadValues() {
+  selectorByReadValue.clear();
 }
 function resolveAssertTargetFromArgs(args, fromHandle) {
   for (const arg of args) {
-    const selector = fromHandle?.(arg) ?? selectorForReadValue(arg);
-    if (selector) {
-      return selector;
+    const handle = fromHandle?.(arg);
+    if (handle) {
+      return handle;
+    }
+    if (selectorByReadValue.has(arg)) {
+      return selectorByReadValue.get(arg) ?? void 0;
     }
   }
   return void 0;
@@ -5919,7 +6550,33 @@ 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 { randomInt } from "crypto";
 import fs10 from "fs/promises";
 import { WebSocket } from "ws";
 var SessionCapturerBase = class _SessionCapturerBase {
@@ -5952,7 +6609,8 @@ var SessionCapturerBase = class _SessionCapturerBase {
   // (WDIO owns the command lifecycle), so this state is harmless overhead.
   // `protected` (not `#`) so subclasses can override the send/replace flow
   // while still sharing the counter and de-dup set with base helpers.
-  commandCounter = 0;
+  // A row's public `id` must not repeat across processes: a rerun child's rows join its parent's in the backend's accumulator, and test workers share one dashboard.
+  commandCounter = randomInt(2 ** 32) * 2 ** 20;
   sentCommandIds = /* @__PURE__ */ new Set();
   // Map of file path → source text. Populated by `captureSource` (also
   // accessed by adapter-specific source-discovery flows, e.g. service's
@@ -6267,26 +6925,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 +6959,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
@@ -6711,11 +7411,20 @@ var TestReporterBase = class {
 
 export {
   mapCommandToAction,
+  isWaitCommand,
   stripAnsi,
-  mapChromeBrowserLogs,
+  COLLECTOR_READY_SCRIPT,
+  COLLECTOR_INJECT_SCRIPT,
+  collectorDrainExpression,
+  CAPTURE_PERFORMANCE_SCRIPT,
+  commandFailure,
+  getRequestType,
   WS_SCOPE,
   REUSE_ENV,
+  RUNNER_ENV,
+  encodeInitialArgs,
   TEST_STATE,
+  NETWORK_CAPTURE_SOURCE,
   SCREENCAST_DEFAULTS,
   captureActionSnapshot,
   toError,
@@ -6728,6 +7437,9 @@ export {
   TestAttemptTracker,
   webdriverGet,
   webdriverPost,
+  webdriverExecute,
+  requestsInterceptedNetwork,
+  NativeNetworkCapture,
   resolveViewport,
   isUserCodeFrame,
   normalizeFilePath,
@@ -6744,11 +7456,8 @@ export {
   recordSpecBoundary,
   flushRangeLogged,
   finalizeTraceExport,
-  getRequestType,
   findFreePort,
   attachBidiHandlers,
-  COLLECTOR_READY_EXPRESSION,
-  collectorDrainExpression,
   loadInjectableScript,
   drainCollectorWithRecovery,
   pollUntilReady,
@@ -6756,12 +7465,13 @@ export {
   finalizeScreencast,
   beginInputDispatch,
   resolveAdapterOutputDir,
-  CAPTURE_PERFORMANCE_SCRIPT,
   applyPerformanceData,
   rememberReadValue,
+  clearReadValues,
   resolveAssertTargetFromArgs,
   RetryTracker,
   ScreencastRecorderBase,
+  restoreBrowserFocus,
   SessionCapturerBase,
   createSuiteStats,
   createTestStats,
@@ -6773,4 +7483,4 @@ export {
   findTestDefinitions,
   TestReporterBase
 };
-//# sourceMappingURL=chunk-DM4FCAIJ.js.map
+//# sourceMappingURL=chunk-DRZC45YG.js.map