@wdio/nightwatch-devtools 1.8.2 → 2.1.0

package/dist/index.js

@@ -1,7 +1,11 @@
 import {
   CAPTURE_PERFORMANCE_SCRIPT,
-  COLLECTOR_READY_EXPRESSION,
+  COLLECTOR_INJECT_SCRIPT,
+  COLLECTOR_READY_SCRIPT,
+  NETWORK_CAPTURE_SOURCE,
+  NativeNetworkCapture,
   REUSE_ENV,
+  RUNNER_ENV,
   RetryTracker,
   SCREENCAST_DEFAULTS,
   ScreencastRecorderBase,
@@ -16,14 +20,17 @@ import {
   captureActionSnapshot,
   captureAndAttachScreenshot,
   captureAndAttachVideo,
+  clearReadValues,
   collectSuiteTestMetadata,
   collectorDrainExpression,
+  commandFailure,
   computeSuiteFinalStateStrict,
   computeSuiteRunningState,
   createSuiteStats,
   createTestStats,
   deterministicUid,
   drainCollectorWithRecovery,
+  encodeInitialArgs,
   errorMessage,
   finalizeScreencast,
   finalizeTraceExport,
@@ -35,9 +42,9 @@ import {
   getCallSourceFromStack,
   getRequestType,
   isUserCodeFrame,
+  isWaitCommand,
   lastRenderedScreenshot,
   loadInjectableScript,
-  mapChromeBrowserLogs,
   mapCommandToAction,
   matcherAssertionToCommandLog,
   normalizeFilePath,
@@ -47,9 +54,11 @@ import {
   recordSpecBoundary,
   registerCollectorPreload,
   rememberReadValue,
+  requestsInterceptedNetwork,
   resolveAdapterOutputDir,
   resolveAssertTargetFromArgs,
   resolveViewport,
+  restoreBrowserFocus,
   safeSerializeAssertArg,
   serializeError,
   stampSuiteEnd,
@@ -58,9 +67,10 @@ import {
   toError,
   tracePolicyModeWarning,
   upsertRichestSnapshot,
+  webdriverExecute,
   webdriverGet,
   webdriverPost
-} from "./chunk-DM4FCAIJ.js";
+} from "./chunk-DRZC45YG.js";
 
 // src/index.ts
 import { fileURLToPath } from "url";
@@ -164,14 +174,18 @@ async function emitTestArtifacts(input) {
 // src/helpers/assertCapture.ts
 import logger from "@wdio/logger";
 var log = logger("@wdio/nightwatch-devtools:assertCapture");
-function wireAssertCapture(getCapturer, getTestUid) {
+function wireAssertCapture(getCapturer, getTestUid, scopeReadValues = () => {
+}) {
   patchNodeAssert(
     (cmd) => captureAssert(getCapturer(), getTestUid(), cmd),
     (level, message) => log[level](message),
     // No handle resolver: Nightwatch commands take selector strings, so an
     // element object never reaches an assert — only the value's provenance,
     // recorded by the command path (BrowserProxy), can name the target.
-    (args) => resolveAssertTargetFromArgs(args)
+    (args) => {
+      scopeReadValues();
+      return resolveAssertTargetFromArgs(args);
+    }
   );
 }
 function captureAssert(capturer, testUid, cmd) {
@@ -196,7 +210,7 @@ function captureAssert(capturer, testUid, cmd) {
 
 // src/index.ts
 import { stop as stopBackend } from "@wdio/devtools-backend";
-import logger15 from "@wdio/logger";
+import logger16 from "@wdio/logger";
 
 // src/run-lifecycle.ts
 import * as fs2 from "fs";
@@ -253,6 +267,7 @@ var TIMING = {
 };
 var BOOLEAN_COMMAND_PATTERN = /^waitFor|^is[A-Z]|^has[A-Z]|(Visible|Present|Enabled|Selected|NotVisible|NotPresent)$/;
 var NAVIGATION_COMMANDS = ["url", "navigate", "navigateTo"];
+var NIGHTWATCH_CONFIG_FLAGS = ["--config", "-c"];
 var CONFIG_FILENAMES = [
   "nightwatch.conf.cjs",
   "nightwatch.conf.js",
@@ -266,10 +281,13 @@ import * as fs from "fs";
 import * as path from "path";
 import { parse as parseStackTrace } from "stacktrace-parser";
 function determineTestState(testcase) {
-  if (testcase.passed === 0 && testcase.failed === 0) {
+  if (testcase.failed > 0 || testcase.errors > 0) {
+    return "failed";
+  }
+  if (testcase.passed === 0 && testcase.skipped > 0) {
     return "skipped";
   }
-  return testcase.passed > 0 && testcase.failed === 0 ? "passed" : "failed";
+  return "passed";
 }
 function getTestIcon(state) {
   return state === "passed" ? "\u2705" : state === "skipped" ? "\u23ED" : "\u274C";
@@ -290,13 +308,53 @@ function buildPluginMetadataOptions(input) {
   return {
     framework: nightwatchRunnerId(input.isCucumberRunner),
     configFile: input.configPath,
-    baseDir: process.cwd(),
-    runCapabilities: {
-      canRunSuites: true,
-      canRunTests: !input.isCucumberRunner,
-      canRunAll: false
-    }
+    baseDir: process.cwd()
+  };
+}
+function isNightwatchCli(entry) {
+  if (!entry) {
+    return false;
+  }
+  try {
+    const script = fs.realpathSync(entry);
+    const pkgDir = path.dirname(path.dirname(script));
+    const pkg = JSON.parse(
+      fs.readFileSync(path.join(pkgDir, "package.json"), "utf8")
+    );
+    return path.basename(path.dirname(script)) === "bin" && pkg.name === "nightwatch";
+  } catch {
+    return false;
+  }
+}
+function captureNightwatchSelection(argv = process.argv, cwd = process.cwd()) {
+  if (!isNightwatchCli(argv[1])) {
+    return void 0;
+  }
+  const spec = (arg) => {
+    const local = path.resolve(cwd, arg);
+    return fs.existsSync(local) ? local : arg;
   };
+  const args = [];
+  const rest = argv.slice(2);
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === "--") {
+      args.push(arg, ...rest.slice(i + 1).map(spec));
+      break;
+    }
+    if (!arg.startsWith("-")) {
+      args.push(spec(arg));
+      continue;
+    }
+    const next = rest[i + 1];
+    const takesNext = !arg.includes("=") && !arg.startsWith("--no-") && next !== void 0 && !next.startsWith("-");
+    const value = takesNext ? rest[++i] : void 0;
+    if (NIGHTWATCH_CONFIG_FLAGS.includes(arg.split("=")[0])) {
+      continue;
+    }
+    args.push(arg, ...value === void 0 ? [] : [value]);
+  }
+  return args.length ? args : void 0;
 }
 function generateStableUid2(itemOrFile, name) {
   let file, testName;
@@ -517,6 +575,13 @@ async function runPluginBefore(ctx) {
         ctx.options.port,
         ctx.options.hostname
       );
+      const selection = captureNightwatchSelection();
+      if (selection) {
+        process.env[RUNNER_ENV.NIGHTWATCH_INITIAL_ARGS] = encodeInitialArgs(selection);
+      } else {
+        delete process.env[RUNNER_ENV.NIGHTWATCH_INITIAL_ARGS];
+      }
+      process.env[RUNNER_ENV.RUNNER_CWD] ??= process.cwd();
       log2.info("\u{1F680} Starting DevTools backend...");
       const { port } = await start(ctx.options);
       ctx.options.port = port;
@@ -634,7 +699,7 @@ async function waitForDevtoolsBrowserClose(ctx) {
 }
 
 // src/session-init.ts
-import logger10 from "@wdio/logger";
+import logger11 from "@wdio/logger";
 
 // src/helpers/webdriverHttp.ts
 import logger3 from "@wdio/logger";
@@ -654,7 +719,7 @@ var firstDefined = (obj, ...keys) => {
   }
   return void 0;
 };
-function resolveWebDriverAddress(browser) {
+function configuredWebDriver(browser) {
   const transportSettings = getPath(browser, "transport", "settings", "webdriver") || getPath(browser, "queue", "transport", "settings", "webdriver") || getPath(
     browser,
     "nightwatchInstance",
@@ -664,22 +729,47 @@ function resolveWebDriverAddress(browser) {
   ) || {};
   const opts = getProp(browser, "options") ?? {};
   const nightwatchSettings = getPath(browser, "nightwatchInstance", "settings") || getPath(browser, "globals", "nightwatchInstance", "settings") || {};
-  const driverHost = String(
-    firstDefined(transportSettings, "host", "server_address") || firstDefined(getProp(opts, "webdriver"), "host") || firstDefined(getProp(nightwatchSettings, "webdriver"), "host") || "localhost"
-  );
-  const driverPort = Number(
-    firstDefined(transportSettings, "port") || firstDefined(getProp(opts, "webdriver"), "port") || firstDefined(getProp(nightwatchSettings, "webdriver"), "port") || 9515
-  );
-  return { driverHost, driverPort };
+  const sources = [
+    transportSettings,
+    getProp(opts, "webdriver"),
+    getProp(nightwatchSettings, "webdriver")
+  ];
+  const values = (...keys) => sources.map((source) => firstDefined(source, ...keys));
+  const pick = (...keys) => values(...keys).find(Boolean);
+  return {
+    host: pick("host", "server_address"),
+    port: pick("port"),
+    pathPrefix: pick("default_path_prefix"),
+    // `ssl: false` is a setting, not an absence, so it must not fall through to a later source.
+    ssl: values("ssl").find((v) => v !== void 0),
+    username: pick("username"),
+    accessKey: values("access_key").find((v) => v !== void 0)
+  };
 }
-function address(browser) {
-  const { driverHost, driverPort } = resolveWebDriverAddress(browser);
+function connection(configured, hostname, port) {
+  const { pathPrefix, ssl, username, accessKey } = configured;
+  const secure = ssl === void 0 ? port === 443 : Boolean(ssl);
+  const hasCredentials = Boolean(username) && accessKey !== void 0;
   return {
-    hostname: driverHost,
-    port: driverPort,
+    hostname,
+    port,
+    protocol: secure ? "https" : "http",
+    path: typeof pathPrefix === "string" ? pathPrefix : void 0,
+    ...hasCredentials ? { user: String(username), key: String(accessKey) } : {},
     onWarn: (message) => log3.warn(message)
   };
 }
+function resolveWebDriverAddress(browser) {
+  const { host, port } = configuredWebDriver(browser);
+  return {
+    driverHost: String(host || "localhost"),
+    driverPort: Number(port || 9515)
+  };
+}
+function address(browser) {
+  const { driverHost, driverPort } = resolveWebDriverAddress(browser);
+  return connection(configuredWebDriver(browser), driverHost, driverPort);
+}
 function sessionId(browser) {
   return browser.sessionId;
 }
@@ -691,8 +781,21 @@ function webdriverPost2(browser, path5, body) {
   const id = sessionId(browser);
   return id ? webdriverPost(address(browser), id, path5, body) : Promise.resolve(null);
 }
-function webdriverExecute(browser, body) {
-  return webdriverPost2(browser, "execute/sync", { script: body, args: [] });
+function sessionExecutor(browser) {
+  const id = sessionId(browser);
+  const configured = configuredWebDriver(browser);
+  if (!id || !configured.port) {
+    return void 0;
+  }
+  const at = connection(
+    configured,
+    String(configured.host || "localhost"),
+    Number(configured.port)
+  );
+  return (script, args) => webdriverExecute(at, id, script, args);
+}
+function webdriverExecute2(browser, body, args = []) {
+  return webdriverPost2(browser, "execute/sync", { script: body, args });
 }
 
 // src/session.ts
@@ -706,7 +809,7 @@ function captureActionSnapshot2(browser, command, timestamp, runner, native = fa
     runner,
     takeScreenshot: () => webdriverGet2(browser, "screenshot"),
     ...native ? {} : {
-      runScript: (src) => webdriverExecute(browser, `return (${src})`),
+      runScript: (src) => webdriverExecute2(browser, `return (${src})`),
       getUrl: () => webdriverGet2(browser, "url"),
       getTitle: () => webdriverGet2(browser, "title")
     }
@@ -714,6 +817,7 @@ function captureActionSnapshot2(browser, command, timestamp, runner, native = fa
 }
 
 // src/helpers/perfLogs.ts
+var RESOURCE_TIMING_MATCH_MS = 2e3;
 function applyResponseReceived(p, response) {
   const responseHeaders = {};
   for (const [k, v] of Object.entries(response.headers || {})) {
@@ -739,7 +843,9 @@ function startPendingRequest(params, entry, pending) {
     url: req.url,
     method: req.method,
     requestHeaders: req.headers ?? {},
-    timestamp: startTime,
+    // Epoch, from the event's own wall clock: every consumer dates a row by
+    // `timestamp`, and the monotonic `startTime` only diffs within a session.
+    timestamp: typeof params.wallTime === "number" ? Math.round(params.wallTime * 1e3) : entry.timestamp,
     startTime
   });
 }
@@ -797,6 +903,95 @@ function parseNetworkFromPerfLogs(logs) {
   }
   return completed;
 }
+function resourceTimingRowsByUrl(rows) {
+  const byUrl = /* @__PURE__ */ new Map();
+  rows.forEach((row, index) => {
+    if (row.source !== NETWORK_CAPTURE_SOURCE.RESOURCE_TIMING) {
+      return;
+    }
+    const indexes = byUrl.get(row.url);
+    if (indexes) {
+      indexes.push(index);
+    } else {
+      byUrl.set(row.url, [index]);
+    }
+  });
+  return byUrl;
+}
+function takeNearestResourceTimingRow(indexes, rows, at) {
+  let best;
+  let bestDelta = RESOURCE_TIMING_MATCH_MS;
+  for (const index of indexes) {
+    const delta = Math.abs(rows[index].timestamp - at);
+    if (delta <= bestDelta) {
+      best = index;
+      bestDelta = delta;
+    }
+  }
+  if (best !== void 0) {
+    indexes.splice(indexes.indexOf(best), 1);
+  }
+  return best;
+}
+function overlay(row, entry) {
+  const merged = {
+    ...row,
+    method: entry.method,
+    requestHeaders: entry.requestHeaders,
+    type: entry.type ?? row.type,
+    ...entry.status !== void 0 ? { status: entry.status } : {},
+    ...entry.statusText !== void 0 ? { statusText: entry.statusText } : {},
+    ...entry.responseHeaders ? { responseHeaders: entry.responseHeaders } : {},
+    ...entry.size !== void 0 ? { size: entry.size } : {},
+    ...entry.error !== void 0 ? { error: entry.error } : {}
+  };
+  delete merged.source;
+  return merged;
+}
+function withoutLoadsTheLogListed(payload, listed) {
+  const requests = payload.networkRequests;
+  if (!Array.isArray(requests) || listed.length === 0) {
+    return payload;
+  }
+  const rows = requests;
+  const rowsByUrl = resourceTimingRowsByUrl(rows);
+  const taken = /* @__PURE__ */ new Set();
+  for (const load of listed) {
+    const index = takeNearestResourceTimingRow(
+      rowsByUrl.get(load.url) ?? [],
+      rows,
+      load.timestamp
+    );
+    if (index !== void 0) {
+      taken.add(index);
+    }
+  }
+  if (taken.size === 0) {
+    return payload;
+  }
+  return {
+    ...payload,
+    networkRequests: rows.filter((_, index) => !taken.has(index))
+  };
+}
+function upgradeResourceTimingRows(incoming, existing) {
+  const rowsByUrl = resourceTimingRowsByUrl(existing);
+  const upgrades = [];
+  const fresh = [];
+  for (const entry of incoming) {
+    const index = takeNearestResourceTimingRow(
+      rowsByUrl.get(entry.url) ?? [],
+      existing,
+      entry.timestamp
+    );
+    if (index === void 0) {
+      fresh.push(entry);
+      continue;
+    }
+    upgrades.push({ index, request: overlay(existing[index], entry) });
+  }
+  return { upgrades, fresh };
+}
 function dedupeNetworkRequests(incoming, existing) {
   const failedKey = (entry) => {
     try {
@@ -838,17 +1033,14 @@ function dedupeNetworkRequests(incoming, existing) {
 
 // src/session.ts
 var log4 = logger4("@wdio/nightwatch-devtools:SessionCapturer");
-function unwrapDriverValue(result) {
-  if (result && typeof result === "object" && "value" in result) {
-    return result.value;
-  }
-  return result;
-}
 var SessionCapturer = class extends SessionCapturerBase {
   #browser;
   // True once BiDi inspectors are attached — the per-command perf-log network
   // capture path skips when set, so we don't double-emit network requests.
   bidiActive = false;
+  /** Whether BiDi has delivered at least one network event; a subscription
+   *  that delivers nothing is not a source. */
+  bidiNetworkObserved = false;
   /** Whether the session was created with `goog:loggingPrefs.performance`, set
    *  from the capabilities at session init. A perf log exists only because a
    *  session asked for one, so without it every fetch is a round trip that can
@@ -857,6 +1049,10 @@ var SessionCapturer = class extends SessionCapturerBase {
    *  21 of them in a two-test run, where XCUITest lists `performance` among its
    *  supported types and then serves none of it. */
   perfLogsRequested = false;
+  /** Loads the performance log listed before the page's drain could, spent
+   *  at the next drain that reaches the driver, whatever it finds, and
+   *  emptied with the session that listed them. */
+  loadsListedByLog = [];
   /** True once the collector is registered to run at document-start. Every
    *  document then instruments and anchors itself, so the paths that exist to
    *  notice a navigation after the fact — re-injection and the settle poll — have
@@ -869,6 +1065,11 @@ var SessionCapturer = class extends SessionCapturerBase {
   runner = nightwatchRunnerId(false);
   actionSnapshots = [];
   snapshotCaptures = [];
+  /** Native app network from appium-interceptor's proxy; started per session. */
+  nativeNetwork = new NativeNetworkCapture(
+    this,
+    (level, message) => log4[level](message)
+  );
   constructor(devtoolsOptions = {}, browser) {
     super(devtoolsOptions);
     this.#browser = browser;
@@ -895,6 +1096,7 @@ var SessionCapturer = class extends SessionCapturerBase {
     const commandId = this.commandCounter++;
     const commandLogEntry = {
       _id: commandId,
+      id: commandId,
       command,
       args,
       result,
@@ -904,7 +1106,8 @@ var SessionCapturer = class extends SessionCapturerBase {
       sequence: meta.sequence,
       callSource: meta.callSource,
       testUid: meta.testUid,
-      selector: meta.selector
+      selector: meta.selector,
+      parentId: meta.parentId
     };
     this.commandsLog.push(commandLogEntry);
     const isNavigationCommand = NAVIGATION_COMMANDS.some(
@@ -947,15 +1150,18 @@ var SessionCapturer = class extends SessionCapturerBase {
       return;
     }
     await new Promise((resolve2) => setTimeout(resolve2, 500));
-    const raw = await this.#browser.execute(CAPTURE_PERFORMANCE_SCRIPT);
-    const payload = unwrapDriverValue(
-      raw
+    const payload = await webdriverExecute2(
+      this.#browser,
+      CAPTURE_PERFORMANCE_SCRIPT
     );
-    applyPerformanceData(
+    if (applyPerformanceData(
       commandLogEntry,
-      payload,
+      payload ?? void 0,
       typeof args[0] === "string" ? args[0] : void 0
-    );
+    ) && // A retry may have replaced the row meanwhile; replacing it again would bring the old row back.
+    this.commandsLog.includes(commandLogEntry)) {
+      this.sendReplaceCommand(commandLogEntry.timestamp, commandLogEntry);
+    }
   }
   /**
    * Ingest a pre-built assertion entry (native `browser.assert`/`verify`
@@ -985,7 +1191,8 @@ var SessionCapturer = class extends SessionCapturerBase {
     const idx = this.commandsLog.findIndex(
       (c) => c._id === oldId
     );
-    const oldTimestamp = idx !== -1 ? this.commandsLog[idx]?.timestamp ?? 0 : 0;
+    const previous = idx !== -1 ? this.commandsLog[idx] : void 0;
+    const oldTimestamp = previous?.timestamp ?? 0;
     if (idx !== -1) {
       this.commandsLog.splice(idx, 1);
     }
@@ -994,6 +1201,7 @@ var SessionCapturer = class extends SessionCapturerBase {
     const commandId = this.commandCounter++;
     const entry = {
       _id: commandId,
+      id: previous?.id ?? commandId,
       command,
       args,
       result,
@@ -1003,18 +1211,68 @@ var SessionCapturer = class extends SessionCapturerBase {
       sequence: meta.sequence,
       callSource: meta.callSource,
       testUid: meta.testUid,
-      selector: meta.selector
+      selector: meta.selector,
+      parentId: meta.parentId
     };
     this.commandsLog.push(entry);
     return { entry, oldTimestamp };
   }
+  /** Rows {@link openCommand} sent that have not ended yet. */
+  #openRows = /* @__PURE__ */ new Set();
+  /** The newest row that has ended: a row still running has caused nothing yet. */
+  #newestEndedTimestamp() {
+    for (let i = this.commandsLog.length - 1; i >= 0; i--) {
+      if (!this.#openRows.has(this.commandsLog[i])) {
+        return this.commandsLog[i].timestamp;
+      }
+    }
+    return void 0;
+  }
+  /** Send a row that has started and not ended (a wait), so the rows it issues have a row to nest under while it runs. */
+  openCommand(command, args, meta) {
+    const id = this.commandCounter++;
+    const entry = {
+      _id: id,
+      id,
+      command,
+      args,
+      timestamp: meta.startTime ?? Date.now(),
+      startTime: meta.startTime,
+      sequence: meta.sequence,
+      callSource: meta.callSource,
+      testUid: meta.testUid,
+      selector: meta.selector,
+      parentId: meta.parentId
+    };
+    this.commandsLog.push(entry);
+    this.#openRows.add(entry);
+    this.sendCommand(entry);
+    return entry;
+  }
+  /** End a row {@link openCommand} sent, stamped at completion, replaced by its `id` and moved to where it completed; a row that never ran keeps its place. */
+  closeCommand(entry, result, error, timestamp, ran = true) {
+    this.#openRows.delete(entry);
+    const at = this.commandsLog.lastIndexOf(entry);
+    if (ran && at !== -1) {
+      this.commandsLog.splice(at, 1);
+      this.commandsLog.push(entry);
+    }
+    const oldTimestamp = entry.timestamp;
+    entry.result = result;
+    entry.error = serializeError(error);
+    entry.timestamp = timestamp;
+    if (!error) {
+      this.#queueActionSnapshot(entry.command, timestamp);
+    }
+    this.sendReplaceCommand(oldTimestamp, entry);
+  }
   /** Birth time of the document this capturer last observed, so a replacement
    *  is still visible to a poll that starts after the navigation committed. */
   lastDocumentOrigin;
   /** The current document's own birth time, which is what a DOM anchor is
    *  stamped with. Undefined when the session cannot answer. */
   async documentOrigin(browser) {
-    return webdriverExecute(browser, "return performance.timeOrigin;").then((origin) => origin ?? void 0).catch(() => void 0);
+    return webdriverExecute2(browser, "return performance.timeOrigin;").then((origin) => origin ?? void 0).catch(() => void 0);
   }
   /**
    * Wait for a navigation to actually replace the document, then drain with a
@@ -1063,11 +1321,7 @@ var SessionCapturer = class extends SessionCapturerBase {
     if (!replaced) {
       return;
     }
-    await this.captureTrace(
-      browser,
-      true,
-      this.commandsLog[this.commandsLog.length - 1]?.timestamp
-    );
+    await this.captureTrace(browser, true, this.#newestEndedTimestamp());
   }
   /**
    * Take a screenshot by calling the WebDriver HTTP endpoint directly, bypassing
@@ -1097,26 +1351,25 @@ var SessionCapturer = class extends SessionCapturerBase {
       return;
     }
     try {
-      const alreadyPresent = await webdriverExecute(
+      const alreadyPresent = await webdriverExecute2(
         browser,
-        `return ${COLLECTOR_READY_EXPRESSION};`
+        COLLECTOR_READY_SCRIPT
       );
       if (alreadyPresent === true) {
         return;
       }
       const scriptContent = await loadInjectableScript();
-      const injectionScript = `
-        const script = document.createElement('script');
-        script.textContent = ${JSON.stringify(scriptContent)};
-        document.head.appendChild(script);
-        return true;
-      `;
-      await webdriverExecute(browser, injectionScript);
-      const hasCollector = await pollUntilReady(
-        async () => await webdriverExecute(
+      const injected = await webdriverExecute2(
+        browser,
+        COLLECTOR_INJECT_SCRIPT,
+        [scriptContent]
+      );
+      const hasCollector = injected === true || await pollUntilReady(
+        async () => await webdriverExecute2(
           browser,
-          `return ${COLLECTOR_READY_EXPRESSION};`
-        ) === true
+          COLLECTOR_READY_SCRIPT
+        ) === true,
+        { checkFirst: true }
       );
       if (hasCollector) {
         log4.info("\u2713 Script injected and collector ready");
@@ -1128,23 +1381,6 @@ var SessionCapturer = class extends SessionCapturerBase {
       throw err;
     }
   }
-  /**
-   * Capture Chrome DevTools browser console logs via WebDriver log API.
-   * Requires loggingPrefs: { browser: 'ALL' } in Chrome capabilities.
-   */
-  async captureBrowserLogs(browser) {
-    try {
-      const rawLogs = await browser.getLog("browser");
-      const logs = unwrapDriverValue(rawLogs);
-      if (!Array.isArray(logs) || logs.length === 0) {
-        return;
-      }
-      const entries = mapChromeBrowserLogs(logs);
-      this.consoleLogs.push(...entries);
-      this.sendUpstream("consoleLogs", entries);
-    } catch {
-    }
-  }
   /**
    * Parse Chrome performance logs to extract network request entries.
    * Requires loggingPrefs: { performance: 'ALL' } in Chrome capabilities.
@@ -1153,33 +1389,39 @@ var SessionCapturer = class extends SessionCapturerBase {
     if (this.bidiActive || !this.perfLogsRequested) {
       return;
     }
-    try {
-      const rawLogs = await browser.getLog("performance");
-      const logs = unwrapDriverValue(rawLogs);
-      if (!Array.isArray(logs) || logs.length === 0) {
-        return;
-      }
-      const networkEntries = parseNetworkFromPerfLogs(logs);
-      if (networkEntries.length === 0) {
-        return;
-      }
-      const deduped = dedupeNetworkRequests(
-        networkEntries,
-        this.networkRequests
-      );
-      if (deduped.length > 0) {
-        const normalized = deduped.map((d) => ({
-          ...d,
-          type: d.type ?? "other"
-        }));
-        this.networkRequests.push(...normalized);
-        this.sendUpstream("networkRequests", normalized);
-      }
-    } catch (err) {
-      const msg = errorMessage(err) ?? "";
-      if (!msg.includes("log type") && !msg.includes("performance")) {
-        log4.warn(`Performance log capture failed: ${msg}`);
-      }
+    const logs = await webdriverPost2(browser, "se/log", {
+      type: "performance"
+    });
+    if (!Array.isArray(logs) || logs.length === 0) {
+      return;
+    }
+    const networkEntries = parseNetworkFromPerfLogs(logs);
+    if (networkEntries.length > 0) {
+      this.#ingestPerfLogEntries(networkEntries);
+    }
+  }
+  /** A log entry for a load the page already reported replaces that row in
+   *  place, under the row's own id; the rest are appended once. */
+  #ingestPerfLogEntries(entries) {
+    const { upgrades, fresh } = upgradeResourceTimingRows(
+      entries,
+      this.networkRequests
+    );
+    for (const { index, request } of upgrades) {
+      this.networkRequests[index] = request;
+    }
+    const deduped = dedupeNetworkRequests(
+      fresh,
+      this.networkRequests
+    );
+    const appended = deduped.map((d) => ({ ...d, type: d.type ?? "other" }));
+    this.networkRequests.push(...appended);
+    this.loadsListedByLog.push(
+      ...appended.map(({ url, timestamp }) => ({ url, timestamp }))
+    );
+    const sent = [...upgrades.map((upgrade) => upgrade.request), ...appended];
+    if (sent.length > 0) {
+      this.sendUpstream("networkRequests", sent);
     }
   }
   /** `forceAnchor` forces a full-DOM anchor of the current document before
@@ -1189,28 +1431,45 @@ var SessionCapturer = class extends SessionCapturerBase {
    *  that command, since it overrides the inference at ingest. */
   async captureTrace(browser, forceAnchor = false, anchorTimestamp) {
     if (this.isNativeAppSession) {
+      await this.nativeNetwork.forward({ throttle: true });
       return;
     }
     await this.drainCollector(browser, forceAnchor, anchorTimestamp);
     await this.captureNetworkFromPerformanceLogs(browser);
   }
+  /** At a test or scenario end, before its slice is written: the proxy drain there is never throttled. */
+  async captureTraceAtTestEnd(browser) {
+    if (this.isNativeAppSession) {
+      await this.nativeNetwork.forward();
+      return;
+    }
+    await this.captureTrace(browser, true);
+  }
   async drainCollector(browser, forceAnchor, anchorTimestamp) {
     try {
       const traceData = await drainCollectorWithRecovery({
-        drain: () => webdriverExecute(
+        drain: () => webdriverExecute2(
           browser,
           collectorDrainExpression(forceAnchor)
         ),
         injectIntoCurrentDocument: () => this.injectScript(browser),
-        currentUrl: () => webdriverExecute(browser, "return location.href;").then(
+        currentUrl: () => webdriverExecute2(browser, "return location.href;").then(
           (u) => u ?? void 0
         ),
         log: (level, message) => log4[level](message)
       });
+      const listedByLog = this.loadsListedByLog;
+      this.loadsListedByLog = [];
       if (!traceData) {
         return;
       }
-      this.processTracePayload(traceData, { anchorTimestamp });
+      this.processTracePayload(
+        withoutLoadsTheLogListed(traceData, listedByLog),
+        {
+          anchorTimestamp,
+          skipResourceTimingRequests: this.bidiNetworkObserved
+        }
+      );
       const mutationCount = Array.isArray(
         traceData.mutations
       ) ? traceData.mutations.length : 0;
@@ -1613,7 +1872,7 @@ var SuiteManager = class {
 };
 
 // src/helpers/browserProxy.ts
-import logger7 from "@wdio/logger";
+import logger8 from "@wdio/logger";
 
 // src/helpers/callbackError.ts
 function callbackError(result, depth = 0) {
@@ -1624,17 +1883,23 @@ function callbackError(result, depth = 0) {
     return void 0;
   }
   const r = result;
-  if ("value" in r) {
-    return depth < 2 ? callbackError(r.value, depth + 1) : void 0;
-  }
-  if ("passed" in r || !r.error) {
+  if ("passed" in r) {
     return void 0;
   }
-  const err = new Error(String(r.message ?? r.error));
-  if (typeof r.stack === "string") {
-    err.stack = r.stack;
+  if (r.error instanceof Error) {
+    return r.error;
+  }
+  if (r.error) {
+    const err = new Error(String(r.message ?? r.error));
+    if (typeof r.stack === "string") {
+      err.stack = r.stack;
+    }
+    return err;
+  }
+  if ("value" in r) {
+    return depth < 2 ? callbackError(r.value, depth + 1) : void 0;
   }
-  return err;
+  return void 0;
 }
 
 // src/helpers/assertTarget.ts
@@ -2109,8 +2374,126 @@ var NativeAssertRecorder = class {
   }
 };
 
+// src/helpers/waitRows.ts
+import { AsyncLocalStorage } from "async_hooks";
+var NOT_RUN_ERROR = "NotRunError";
+var WaitRows = class {
+  constructor(capturer) {
+    this.capturer = capturer;
+  }
+  capturer;
+  #scope = new AsyncLocalStorage();
+  #open = /* @__PURE__ */ new Set();
+  /** The innermost open wait making this call; a scope outlives its wait, so a closed one defers to its own parent. */
+  enclosing() {
+    let wait = this.#scope.getStore();
+    while (wait?.closed) {
+      wait = wait.parent;
+    }
+    return wait;
+  }
+  /** Send the wait's row running, before the queue runs it, so its condition's commands have a row to name. */
+  open(cmd) {
+    const row = this.capturer.openCommand(cmd.methodName, cmd.logArgs, {
+      testUid: cmd.testUid,
+      callSource: cmd.callSource,
+      startTime: cmd.invokedAt,
+      sequence: cmd.sequence,
+      selector: commandRowSelector(cmd.methodName, cmd.logArgs),
+      parentId: cmd.parent?.row.id
+    });
+    const wait = { row, parent: cmd.parent, children: /* @__PURE__ */ new Map(), closed: false };
+    this.#open.add(wait);
+    return wait;
+  }
+  /** The args a wait is called with: a `waitUntil` condition runs every poll inside the wait's scope. */
+  args(cmd) {
+    const [condition, ...rest] = cmd.logArgs;
+    const wait = cmd.wait;
+    if (!wait || typeof condition !== "function") {
+      return cmd.logArgs;
+    }
+    const scope = this.#scope;
+    const scoped = function(...args) {
+      return scope.run(wait, () => condition.apply(this, args));
+    };
+    return [scoped, ...rest];
+  }
+  /** End the wait's row by `id`, stamped at completion; a wait Nightwatch reports as `false` timed out. */
+  close(wait, result, error, completedAt) {
+    wait.closed = true;
+    this.#open.delete(wait);
+    const { row } = wait;
+    const action = mapCommandToAction(row.command);
+    const timeout = !error && action ? commandFailure({ ...row, result }, action) : void 0;
+    this.capturer.closeCommand(
+      row,
+      result,
+      error ?? (timeout && new Error(timeout.message)),
+      completedAt
+    );
+  }
+  /** Close every wait still open as not run: Nightwatch drops a queued wait, callback and all, when an earlier assert aborts the queue. */
+  closeUnrun() {
+    const unrun = [...this.#open];
+    for (const wait of unrun) {
+      wait.closed = true;
+      this.#open.delete(wait);
+      const error = new Error(
+        `${wait.row.command} did not run: the test ended before Nightwatch reached it`
+      );
+      error.name = NOT_RUN_ERROR;
+      this.capturer.closeCommand(
+        wait.row,
+        void 0,
+        error,
+        wait.row.startTime ?? wait.row.timestamp,
+        false
+      );
+    }
+    return unrun;
+  }
+};
+
+// src/helpers/navigationWrap.ts
+import logger7 from "@wdio/logger";
+var log7 = logger7("@wdio/nightwatch-devtools:navigation");
+function wrapNavigation(browser, sessionCapturer) {
+  const b = browser;
+  const wrapNav = (methodName) => {
+    if (typeof b[methodName] !== "function") {
+      return;
+    }
+    const original = b[methodName].bind(browser);
+    b[methodName] = function(...args) {
+      if (typeof args[0] !== "string") {
+        return original(...args);
+      }
+      const result = original(...args);
+      const injectAndCapture = () => {
+        log7.info(`[nav] ${methodName}(${args[0] ?? ""}) \u2014 injecting script`);
+        return sessionCapturer.injectScript(browser).then(() => sessionCapturer.captureTrace(browser, true)).catch(
+          (err) => log7.error(`Failed to inject script: ${err.message}`)
+        );
+      };
+      const chainable = result;
+      if (chainable && typeof chainable.perform === "function") {
+        void Promise.resolve(result).then(injectAndCapture).catch(() => {
+        });
+        return result;
+      }
+      return Promise.resolve(result).then(injectAndCapture).catch(() => {
+      });
+    };
+  };
+  wrapNav("url");
+  wrapNav("navigate");
+  wrapNav("navigateTo");
+  log7.info("\u2713 Script injection wrapped");
+}
+
 // src/helpers/browserProxy.ts
-var log7 = logger7("@wdio/nightwatch-devtools:browserProxy");
+var log8 = logger8("@wdio/nightwatch-devtools:browserProxy");
 var BrowserProxy = class {
   constructor(sessionCapturer, testManager, getCurrentTest, captureAssertions = true, observeSession) {
     this.sessionCapturer = sessionCapturer;
@@ -2118,6 +2501,7 @@ var BrowserProxy = class {
     this.getCurrentTest = getCurrentTest;
     this.captureAssertions = captureAssertions;
     this.observeSession = observeSession;
+    this.waits = new WaitRows(sessionCapturer);
     this.assertRecorder = new NativeAssertRecorder(
       sessionCapturer,
       () => this.rowTest(),
@@ -2140,6 +2524,7 @@ var BrowserProxy = class {
    * rather than appending, showing only the final execution result.
    */
   retryTracker = new RetryTracker();
+  waits;
   /**
    * Monotonic issue-order counter. Stamped when the test ISSUES a row — a
    * driver command at invocation, an assert at enqueue — which is source order.
@@ -2157,6 +2542,8 @@ var BrowserProxy = class {
    * the assert path, which runs outside any command callback.
    */
   browser = null;
+  /** The test core's value registry currently holds reads for; see {@link scopeReadValuesToRowTest}. */
+  readValueTestUid;
   /**
    * The test a captured row belongs to: the `it` Nightwatch reports as running
    * right now, falling back to the lifecycle test. On the BDD `describe/it`
@@ -2175,6 +2562,19 @@ var BrowserProxy = class {
   rowTestUid() {
     return this.rowTest()?.uid;
   }
+  /**
+   * Forget the values an earlier test read once the running test changes. The
+   * lifecycle reset below fires once per MODULE on the BDD interface, so this
+   * per-`it` live read is what keeps one `it`'s reads from naming another's
+   * assertion target. Called before every record and every lookup.
+   */
+  scopeReadValuesToRowTest() {
+    const uid = this.rowTestUid();
+    if (uid !== this.readValueTestUid) {
+      clearReadValues();
+      this.readValueTestUid = uid;
+    }
+  }
   /** Per-command-scope dedup state only. Cucumber calls this per STEP, so it
    *  must not touch the native-assert buffer — that buffer spans the whole
    *  scenario and is drained once, at the scenario's pre-quit hook. */
@@ -2188,6 +2588,8 @@ var BrowserProxy = class {
   resetTestTracking() {
     this.resetCommandTracking();
     this.assertRecorder.clear();
+    clearReadValues();
+    this.readValueTestUid = void 0;
   }
   /** Hand off this test's recorded native-assertion calls and clear the
    *  buffer so the next test starts fresh. */
@@ -2200,47 +2602,9 @@ var BrowserProxy = class {
   setCurrentTestFullPath(path5) {
     this.currentTestFullPath = path5;
   }
-  /**
-   * Wrap browser navigation methods (url / navigate / navigateTo) to inject
-   * the DevTools script after every navigation.
-   *
-   * Uses `browser` from the closure (not `this` inside perform) so it works
-   * for both standard Nightwatch (chainable API) and Cucumber async/await mode
-   * where `this` inside a perform callback is not the browser.
-   */
+  /** Inject the DevTools script after every navigation; see {@link wrapNavigation}. */
   wrapUrlMethod(browser) {
-    const sessionCapturer = this.sessionCapturer;
-    const b = browser;
-    const wrapNav = (methodName) => {
-      if (typeof b[methodName] !== "function") {
-        return;
-      }
-      const original = b[methodName].bind(browser);
-      b[methodName] = function(...args) {
-        if (typeof args[0] !== "string") {
-          return original(...args);
-        }
-        const result = original(...args);
-        const injectAndCapture = () => {
-          log7.info(`[nav] ${methodName}(${args[0] ?? ""}) \u2014 injecting script`);
-          return sessionCapturer.injectScript(browser).then(() => sessionCapturer.captureTrace(browser, true)).catch(
-            (err) => log7.error(`Failed to inject script: ${err.message}`)
-          );
-        };
-        const chainable = result;
-        if (chainable && typeof chainable.perform === "function") {
-          void Promise.resolve(result).then(injectAndCapture).catch(() => {
-          });
-          return result;
-        }
-        return Promise.resolve(result).then(injectAndCapture).catch(() => {
-        });
-      };
-    };
-    wrapNav("url");
-    wrapNav("navigate");
-    wrapNav("navigateTo");
-    log7.info("\u2713 Script injection wrapped");
+    wrapNavigation(browser, this.sessionCapturer);
   }
   wrapBrowserCommands(browser) {
     this.browser = browser;
@@ -2278,36 +2642,81 @@ var BrowserProxy = class {
       this.assertRecorder.wrapNamespaces(browser);
     }
     this.proxiedBrowsers.add(browser);
-    log7.info(`\u2713 Wrapped ${wrappedMethods.length} browser methods`);
+    log8.info(`\u2713 Wrapped ${wrappedMethods.length} browser methods`);
   }
-  handleRetryReplacement(browser, methodName, logArgs, serializedResult, meta, commandError) {
+  handleRetryReplacement(browser, oldId, methodName, logArgs, serializedResult, meta, commandError) {
     const { entry, oldTimestamp } = this.sessionCapturer.replaceCommand(
-      this.retryTracker.lastId,
+      oldId,
       methodName,
       logArgs,
       serializedResult,
       commandError,
       meta
     );
-    this.retryTracker.setLastId(entry._id ?? null);
     this.sessionCapturer.sendReplaceCommand(oldTimestamp, entry);
     this.attachScreenshot(browser, entry, methodName, " (retry)");
+    return entry._id ?? null;
   }
-  captureFreshCommand(browser, methodName, logArgs, serializedResult, meta, cmdSig, commandError) {
-    this.retryTracker.setLastSig(cmdSig);
-    this.retryTracker.setLastId(null);
+  captureFreshCommand(browser, methodName, logArgs, serializedResult, meta, commandError) {
     this.drainOutgoingPage(browser, methodName);
     this.sessionCapturer.captureCommand(methodName, logArgs, serializedResult, commandError, meta).catch(
-      (err) => log7.error(`Failed to capture ${methodName}: ${err.message}`)
+      (err) => log8.error(`Failed to capture ${methodName}: ${err.message}`)
     );
     const lastCommand = this.sessionCapturer.commandsLog[this.sessionCapturer.commandsLog.length - 1];
     if (lastCommand) {
-      this.retryTracker.setLastId(lastCommand._id ?? null);
       this.sessionCapturer.sendCommand(lastCommand);
-      log7.info(`[command] ${methodName}`);
+      log8.info(`[command] ${methodName}`);
       this.attachScreenshot(browser, lastCommand, methodName);
     }
     this.anchorDestination(browser, methodName);
+    if (!this.isDomMutating(methodName)) {
+      void this.sessionCapturer.nativeNetwork.forward({ throttle: true });
+    }
+    return lastCommand?._id ?? null;
+  }
+  /**
+   * Record a completed command. A poll folds into the row of the previous
+   * identical call: the last row captured, or, inside a wait, the row of the
+   * same call its condition already issued, since a condition with two reads
+   * alternates them and never repeats the last one.
+   */
+  recordCompleted(browser, cmd, meta, serializedResult, commandError) {
+    const { methodName, logArgs, cmdSig, parent } = cmd;
+    const foldInto = parent ? parent.children.get(cmdSig) : this.retryTracker.isRetry(cmdSig) ? this.retryTracker.lastId : void 0;
+    const id = foldInto === void 0 ? this.captureFreshCommand(
+      browser,
+      methodName,
+      logArgs,
+      serializedResult,
+      meta,
+      commandError
+    ) : this.handleRetryReplacement(
+      browser,
+      foldInto,
+      methodName,
+      logArgs,
+      serializedResult,
+      meta,
+      commandError
+    );
+    if (!parent) {
+      this.retryTracker.recordCapture(cmdSig, id);
+    } else if (id !== null) {
+      parent.children.set(cmdSig, id);
+    }
+  }
+  /** Close the waits an aborted queue never ran, before the test unit's rows are read. */
+  closeUnrunWaits() {
+    if (this.waits.closeUnrun().length > 0) {
+      this.retryTracker.reset();
+    }
+  }
+  /** End a wait's row; whatever is captured next is not a poll of what ran before it. */
+  closeWait(browser, wait, result, error, completedAt) {
+    this.retryTracker.reset();
+    this.waits.close(wait, result, error, completedAt);
+    this.attachScreenshot(browser, wait.row, wait.row.command);
+    void this.sessionCapturer.nativeNetwork.forward({ throttle: true });
   }
   isDomMutating(methodName) {
     return NAVIGATION_COMMANDS.includes(methodName) || [
@@ -2377,47 +2786,44 @@ var BrowserProxy = class {
    *  into one call because `makeCaptureCallback` is already over the line cap. */
   serializeAndAttributeResult(methodName, logArgs, callbackResult) {
     const result = serializeCommandResult(callbackResult, methodName);
+    this.scopeReadValuesToRowTest();
     rememberReadValue(result, commandTargetSelector(methodName, logArgs));
     return result;
   }
   // Result-capturing callback factory — called by Nightwatch's async queue
   // when the command completes. This is where we get the *actual* result.
-  makeCaptureCallback(browser, methodName, logArgs, cmdSig, callSource, hasUserSource, invokedAt, sequence, testUid, userCallback) {
+  makeCaptureCallback(browser, cmd) {
+    const { methodName, logArgs, cmdSig, userCallback } = cmd;
     return (callbackResult) => {
       const commandTimestamp = Date.now();
       this.popCommandStackIfMatches(methodName, cmdSig);
       const commandError = callbackError(callbackResult);
       const serializedResult = commandError ? void 0 : this.serializeAndAttributeResult(methodName, logArgs, callbackResult);
-      const effectiveUid = this.rowTestUid() ?? testUid;
-      if (effectiveUid && hasUserSource) {
-        const meta = {
-          testUid: effectiveUid,
-          callSource,
-          timestamp: commandTimestamp,
-          startTime: invokedAt,
-          sequence,
-          selector: commandRowSelector(methodName, logArgs)
-        };
-        if (this.retryTracker.isRetry(cmdSig)) {
-          this.handleRetryReplacement(
-            browser,
-            methodName,
-            logArgs,
-            serializedResult,
-            meta,
-            commandError
-          );
-        } else {
-          this.captureFreshCommand(
-            browser,
-            methodName,
-            logArgs,
-            serializedResult,
-            meta,
-            cmdSig,
-            commandError
-          );
-        }
+      const effectiveUid = this.rowTestUid() ?? cmd.testUid;
+      if (cmd.wait) {
+        this.closeWait(
+          browser,
+          cmd.wait,
+          serializedResult,
+          commandError,
+          commandTimestamp
+        );
+      } else if (effectiveUid && cmd.hasUserSource) {
+        this.recordCompleted(
+          browser,
+          cmd,
+          {
+            testUid: effectiveUid,
+            callSource: cmd.callSource,
+            timestamp: commandTimestamp,
+            startTime: cmd.invokedAt,
+            sequence: cmd.sequence,
+            selector: commandRowSelector(methodName, logArgs),
+            parentId: cmd.parent?.row.id
+          },
+          serializedResult,
+          commandError
+        );
       }
       if (userCallback) {
         return userCallback(callbackResult);
@@ -2441,7 +2847,7 @@ var BrowserProxy = class {
       this.currentTestFullPath = callInfo.filePath;
     }
     const lastArg = args[args.length - 1];
-    const hasUserCallback = typeof lastArg === "function";
+    const hasUserCallback = typeof lastArg === "function" && !(methodName === "waitUntil" && args.length === 1);
     const logArgs = hasUserCallback ? args.slice(0, -1) : args;
     const cmdSig = JSON.stringify({
       command: methodName,
@@ -2464,49 +2870,59 @@ var BrowserProxy = class {
         browserAny.currentTest
       )
     );
-    const { userCallback, logArgs, cmdSig, callSource, hasUserSource } = this.describeInvocation(methodName, args);
-    const invokedAt = Date.now();
-    const sequence = this.issueCounter++;
-    const captureCallback = this.makeCaptureCallback(
-      browser,
-      methodName,
-      logArgs,
-      cmdSig,
-      callSource,
-      hasUserSource,
-      invokedAt,
-      sequence,
-      this.rowTestUid(),
-      userCallback
-    );
+    const cmd = this.pendingCommand(methodName, args);
+    const captureCallback = this.makeCaptureCallback(browser, cmd);
     const closeInputWindow = beginInputDispatch(methodName);
     const gatedCallback = (callbackResult) => {
       closeInputWindow();
       return captureCallback(callbackResult);
     };
-    const modifiedArgs = [...logArgs, gatedCallback];
+    const modifiedArgs = [...this.waits.args(cmd), gatedCallback];
     try {
       return originalMethod(...modifiedArgs);
     } catch (error) {
       closeInputWindow();
-      this.popCommandStackIfMatches(methodName, cmdSig);
-      this.captureCommandError(methodName, logArgs, error, callSource);
+      this.popCommandStackIfMatches(methodName, cmd.cmdSig);
+      if (cmd.wait) {
+        this.closeWait(browser, cmd.wait, void 0, toError(error), Date.now());
+      } else {
+        this.captureCommandError(methodName, cmd.logArgs, error, cmd.callSource);
+      }
       throw error;
     }
   }
+  /** Describe the call, and send its row now when it is a wait. */
+  pendingCommand(methodName, args) {
+    const cmd = {
+      ...this.describeInvocation(methodName, args),
+      methodName,
+      // Invocation time only: the row's real completion stamp is taken inside
+      // the capture callback (see makeCaptureCallback).
+      invokedAt: Date.now(),
+      sequence: this.issueCounter++,
+      testUid: this.rowTestUid(),
+      parent: this.waits.enclosing()
+    };
+    if (isWaitCommand(methodName) && cmd.testUid && cmd.hasUserSource) {
+      this.retryTracker.reset();
+      cmd.wait = this.waits.open(cmd);
+      log8.info(`[command] ${methodName} (running)`);
+    }
+    return cmd;
+  }
   captureCommandError(methodName, args, error, callSource) {
     const currentTest = this.rowTest();
     if (!currentTest) {
       return;
     }
     const normalizedError = toError(error);
-    log7.error(`[command error] ${methodName}: ${normalizedError.message}`);
+    log8.error(`[command error] ${methodName}: ${normalizedError.message}`);
     this.sessionCapturer.captureCommand(methodName, args, void 0, normalizedError, {
       testUid: currentTest.uid,
       callSource,
       selector: commandRowSelector(methodName, args)
     }).catch(
-      (err) => log7.error(`Failed to capture ${methodName}: ${err.message}`)
+      (err) => log8.error(`Failed to capture ${methodName}: ${err.message}`)
     );
     const lastCommand = this.sessionCapturer.commandsLog[this.sessionCapturer.commandsLog.length - 1];
     if (lastCommand) {
@@ -2526,10 +2942,10 @@ var BrowserProxy = class {
   attachScreenshot(browser, entry, methodName, suffix = "") {
     const ts = entry.timestamp ?? 0;
     this.sessionCapturer.takeScreenshotViaHttp(browser).then((screenshot) => {
-      if (screenshot) {
+      if (screenshot && this.sessionCapturer.commandsLog.includes(entry)) {
         entry.screenshot = screenshot;
         this.sessionCapturer.sendReplaceCommand(ts, entry);
-        log7.info(`[screenshot] Attached to ${methodName}${suffix}`);
+        log8.info(`[screenshot] Attached to ${methodName}${suffix}`);
       }
     }).catch(() => {
     });
@@ -2537,11 +2953,11 @@ var BrowserProxy = class {
 };
 
 // src/screencast-session.ts
-import logger9 from "@wdio/logger";
+import logger10 from "@wdio/logger";
 
 // src/screencast.ts
-import logger8 from "@wdio/logger";
-var log8 = logger8("@wdio/nightwatch-devtools:ScreencastRecorder");
+import logger9 from "@wdio/logger";
+var log9 = logger9("@wdio/nightwatch-devtools:ScreencastRecorder");
 var ScreencastRecorder = class extends ScreencastRecorderBase {
   #sessionCapturer;
   constructor(sessionCapturer, options) {
@@ -2549,15 +2965,15 @@ var ScreencastRecorder = class extends ScreencastRecorderBase {
     this.#sessionCapturer = sessionCapturer;
   }
   onPollingStarted(intervalMs) {
-    log8.info(
+    log9.info(
       `\u2713 Screencast recording started (polling mode, ${intervalMs} ms interval)`
     );
   }
   onPollingStopped(frameCount) {
-    log8.info(`\u2713 Screencast stopped \u2014 ${frameCount} frame(s) collected`);
+    log9.info(`\u2713 Screencast stopped \u2014 ${frameCount} frame(s) collected`);
   }
   onUnavailable(err) {
-    log8.warn(
+    log9.warn(
       `Screencast unavailable (${errorMessage(err)}). Recording skipped.`
     );
   }
@@ -2571,7 +2987,7 @@ var ScreencastRecorder = class extends ScreencastRecorderBase {
 };
 
 // src/screencast-session.ts
-var log9 = logger9("@wdio/nightwatch-devtools:screencast-session");
+var log10 = logger10("@wdio/nightwatch-devtools:screencast-session");
 async function startScreencast(ctx, browser, sessionId2) {
   if (!ctx.screencastOptions.enabled || ctx.screencastRecorder || !sessionId2) {
     return;
@@ -2581,7 +2997,7 @@ async function startScreencast(ctx, browser, sessionId2) {
     ctx.screencastOptions
   );
   ctx.screencastSessionId = sessionId2;
-  log9.info(`\u{1F3AC} Starting screencast for session ${sessionId2}`);
+  log10.info(`\u{1F3AC} Starting screencast for session ${sessionId2}`);
   await ctx.screencastRecorder.start(browser);
 }
 function needsScreencastRotation(ctx, sessionId2) {
@@ -2595,16 +3011,16 @@ function rotateScreencastForSession(ctx, browser) {
   if (!needsScreencastRotation(ctx, sessionId2)) {
     return;
   }
-  log9.info(`\u{1F3AC} Session replaced \u2014 rotating screencast to ${sessionId2}`);
+  log10.info(`\u{1F3AC} Session replaced \u2014 rotating screencast to ${sessionId2}`);
   ctx.screencastRotation = ctx.finalizeCurrentScreencast().then(() => startScreencast(ctx, browser, sessionId2)).catch(
-    (err) => log9.warn(`Screencast rotation failed: ${errorMessage(err)}`)
+    (err) => log10.warn(`Screencast rotation failed: ${errorMessage(err)}`)
   ).finally(() => {
     ctx.screencastRotation = void 0;
   });
 }
 
 // src/session-init.ts
-var log10 = logger10("@wdio/nightwatch-devtools:session-init");
+var log11 = logger11("@wdio/nightwatch-devtools:session-init");
 function initReporterChain(ctx) {
   ctx.testReporter = new TestReporter(
     (suitesData) => {
@@ -2636,9 +3052,9 @@ function initReporterChain(ctx) {
 }
 function readViewport(browser) {
   return resolveViewport(browser.capabilities || {}, {
-    runScript: (body) => webdriverExecute(browser, body),
+    runScript: (body) => webdriverExecute2(browser, body),
     getWindowSize: () => webdriverGet2(browser, "window/rect"),
-    onWarn: (message) => log10.warn(message)
+    onWarn: (message) => log11.warn(message)
   });
 }
 function wantsPerformanceLog(capabilities, desiredCapabilities) {
@@ -2671,17 +3087,29 @@ async function broadcastSessionMetadata(ctx, browser) {
   ctx.sessionCapturer.sendUpstream("metadata", metadata);
   const browserName = capabilities.browserName || desiredCapabilities.browserName || "unknown";
   const browserVersion = capabilities.browserVersion || capabilities.version || "";
-  log10.info(
+  log11.info(
     `\u2713 Browser: ${browserName}${browserVersion ? " " + browserVersion : ""} (session: ${sessionId2})`
   );
+  if (ctx.mode === "live" && restoreBrowserFocus({
+    browserName: String(browserName),
+    platformName: String(
+      capabilities.platformName || desiredCapabilities.platformName || ""
+    ),
+    host: resolveWebDriverAddress(browser).driverHost,
+    onError: (message) => log11.warn(message)
+  })) {
+    log11.info(
+      "\u2713 Safari brought back to the front (it delivers clicks only there)"
+    );
+  }
   const wantsPerfLog = wantsPerformanceLog(
     capabilities,
     desiredCapabilities
   );
   ctx.sessionCapturer.perfLogsRequested = wantsPerfLog;
   if (!wantsPerfLog && !ctx.bidiEnabled) {
-    log10.warn(
-      "\u26A0  Network tab will be empty \u2014 add 'goog:loggingPrefs': { performance: 'ALL' } to your capabilities (or enable bidi:true)"
+    log11.warn(
+      "\u26A0  Network tab will carry the page's own Resource Timing only (no headers, no bodies). Add 'goog:loggingPrefs': { performance: 'ALL' } to your capabilities (or enable bidi:true) for full requests"
     );
   }
 }
@@ -2691,17 +3119,17 @@ async function tryAttachBidi(ctx, browser) {
   }
   const driver = browser.driver;
   if (!driver) {
-    log10.warn("bidi:true set but browser.driver unavailable \u2014 skipping");
+    log11.warn("bidi:true set but browser.driver unavailable \u2014 skipping");
     return;
   }
-  const { attachBidiHandlers, buildBidiSinks } = await import("./bidi-WNZOXX5X.js");
+  const { attachBidiHandlers, buildBidiSinks } = await import("./bidi-C67DYUCA.js");
   const ok = await attachBidiHandlers(
     driver,
     buildBidiSinks(ctx.sessionCapturer)
   );
   if (ok) {
     ctx.sessionCapturer.bidiActive = true;
-    log10.info("\u2713 BiDi attached \u2014 perf-log network capture disabled");
+    log11.info("\u2713 BiDi attached \u2014 perf-log network capture disabled");
   }
 }
 async function tryRegisterPreload(ctx, browser) {
@@ -2711,13 +3139,19 @@ async function tryRegisterPreload(ctx, browser) {
   }
   ctx.sessionCapturer.preloadRegistered = await registerCollectorPreload(
     driver,
-    (level, message) => log10[level](message)
+    (level, message) => log11[level](message)
   );
 }
 async function armCaptureForSession(ctx, browser) {
   ctx.armedSessionId = browser.sessionId ?? void 0;
   await tryRegisterPreload(ctx, browser);
   await tryAttachBidi(ctx, browser);
+  await ctx.sessionCapturer.nativeNetwork.start({
+    requested: requestsInterceptedNetwork(browser.desiredCapabilities),
+    capabilities: browser.capabilities,
+    execute: sessionExecutor(browser),
+    unavailableReason: "the session id or the configured WebDriver port is unknown"
+  });
 }
 function needsCaptureRearm(ctx, sessionId2) {
   return Boolean(ctx.sessionCapturer) && sessionId2 !== void 0 && ctx.armedSessionId !== void 0 && ctx.armedSessionId !== sessionId2;
@@ -2729,16 +3163,19 @@ async function armReplacedSession(ctx, browser) {
   }
   ctx.sessionCapturer.preloadRegistered = false;
   ctx.sessionCapturer.bidiActive = false;
-  log10.info(`Session replaced \u2014 re-arming capture for ${sessionId2}`);
+  ctx.sessionCapturer.bidiNetworkObserved = false;
+  ctx.sessionCapturer.loadsListedByLog = [];
+  ctx.sessionCapturer.nativeNetwork.stop();
+  log11.info(`Session replaced \u2014 re-arming capture for ${sessionId2}`);
   await armCaptureForSession(ctx, browser);
 }
 function rearmCaptureForSession(ctx, browser) {
   void armReplacedSession(ctx, browser).catch(
-    (err) => log10.warn(`Capture re-arm failed: ${errorMessage(err)}`)
+    (err) => log11.warn(`Capture re-arm failed: ${errorMessage(err)}`)
   );
 }
 async function rebindSessionToBrowser(ctx, browser) {
-  log10.info("Browser session changed \u2014 re-targeting the run capturer");
+  log11.info("Browser session changed \u2014 re-targeting the run capturer");
   ctx.isScriptInjected = false;
   await broadcastSessionMetadata(ctx, browser);
   await armReplacedSession(ctx, browser);
@@ -2768,7 +3205,7 @@ async function ensureSessionInitialized(ctx, browser) {
   if (ctx.mode !== "trace") {
     const connected = await ctx.sessionCapturer.waitForConnection(3e3);
     if (!connected) {
-      log10.error("\u274C Worker WebSocket failed to connect!");
+      log11.error("\u274C Worker WebSocket failed to connect!");
     }
   }
   initReporterChain(ctx);
@@ -2793,7 +3230,7 @@ async function finalizeCurrentScreencast(ctx) {
       }),
       captureFormat: ctx.screencastOptions.captureFormat,
       sendUpstream: (scope, data) => ctx.sessionCapturer?.sendUpstream(scope, data),
-      onLog: (level, message) => log10[level](message)
+      onLog: (level, message) => log11[level](message)
     });
   }
   ctx.screencastRecorder = void 0;
@@ -2851,8 +3288,8 @@ var PluginScreencast = class {
 };
 
 // src/event-hub.ts
-import logger11 from "@wdio/logger";
-var log11 = logger11("@wdio/nightwatch-devtools:event-hub");
+import logger12 from "@wdio/logger";
+var log12 = logger12("@wdio/nightwatch-devtools:event-hub");
 function makeSessionMetadataHandler(bindings) {
   return (data) => {
     try {
@@ -2873,23 +3310,23 @@ function makeSessionMetadataHandler(bindings) {
         options: bindings.buildMetadataOptions()
       });
     } catch (err) {
-      log11.error(`Error in event handler: ${errorMessage(err)}`);
+      log12.error(`Error in event handler: ${errorMessage(err)}`);
     }
   };
 }
 function registerEventHandlers(eventHub, bindings) {
   bindings.setCucumberRunner(eventHub.runner === "cucumber");
   if (eventHub.runner === "cucumber") {
-    log11.info("\u2713 Cucumber runner detected via NightwatchEventHub");
+    log12.info("\u2713 Cucumber runner detected via NightwatchEventHub");
   }
-  log11.info("\u2713 NightwatchEventHub registered \u2014 enriched metadata enabled");
+  log12.info("\u2713 NightwatchEventHub registered \u2014 enriched metadata enabled");
   const handler = makeSessionMetadataHandler(bindings);
   eventHub.on("TestSuiteStarted", handler);
   eventHub.on("TestRunStarted", handler);
 }
 
 // src/cucumber-lifecycle.ts
-import logger12 from "@wdio/logger";
+import logger13 from "@wdio/logger";
 
 // src/helpers/cucumberResult.ts
 function cucumberResultToTestState(result) {
@@ -3084,7 +3521,7 @@ function flushTestSlice(ctx) {
 }
 
 // src/cucumber-lifecycle.ts
-var log12 = logger12("@wdio/nightwatch-devtools:cucumber");
+var log13 = logger13("@wdio/nightwatch-devtools:cucumber");
 function attachScenarioToFeature(ctx, featureSuite, scenarioSuite) {
   const existingIdx = featureSuite.suites.findIndex(
     (s) => s.uid === scenarioSuite.uid
@@ -3168,7 +3605,7 @@ async function initCucumberScenario(ctx, browser, pickle) {
   ctx.setCurrentTest(null);
   ctx.testReporter.updateSuites();
   ctx.wrapBrowserOnce(browser);
-  log12.info(`\u{1F952} Scenario: ${scenarioName}`);
+  log13.info(`\u{1F952} Scenario: ${scenarioName}`);
 }
 async function finalizeCucumberScenario(ctx, _browser, result, pickle) {
   try {
@@ -3190,7 +3627,7 @@ async function finalizeCucumberScenario(ctx, _browser, result, pickle) {
       }
       ctx.incrementCount(scenarioState);
       const icon = ctx.testIcon(scenarioState);
-      log12.info(
+      log13.info(
         `  ${icon} ${pickle?.name ?? "Unknown"} (${(duration / 1e3).toFixed(2)}s)`
       );
       ctx.testReporter.updateSuites();
@@ -3199,12 +3636,13 @@ async function finalizeCucumberScenario(ctx, _browser, result, pickle) {
       ctx.setCurrentTest(null);
     }
   } catch (err) {
-    log12.error(`Failed to finalize Cucumber scenario: ${errorMessage(err)}`);
+    log13.error(`Failed to finalize Cucumber scenario: ${errorMessage(err)}`);
   }
 }
 async function captureCucumberScenarioBeforeQuit(ctx, browser, result) {
   const scenario = ctx.getCurrentScenarioSuite();
   try {
+    ctx.browserProxy?.closeUnrunWaits();
     const assertCalls = ctx.browserProxy?.drainNativeAssertCalls() ?? [];
     if (assertCalls.length > 0) {
       await captureNativeAssertions(
@@ -3215,14 +3653,14 @@ async function captureCucumberScenarioBeforeQuit(ctx, browser, result) {
         assertCalls
       );
     }
-    await ctx.sessionCapturer.captureTrace(browser, true);
+    await ctx.sessionCapturer.captureTraceAtTestEnd(browser);
     flushTestSlice(ctx);
     await ctx.emitTestArtifacts(
       scenario?.uid,
       cucumberResultToTestState(result) === TEST_STATE.FAILED
     );
   } catch (err) {
-    log12.error(
+    log13.error(
       `Failed to capture Cucumber scenario before quit: ${errorMessage(err)}`
     );
   }
@@ -3268,7 +3706,7 @@ async function cucumberAfter(ctx, browser, result, pickle) {
 }
 
 // src/test-lifecycle.ts
-import logger14 from "@wdio/logger";
+import logger15 from "@wdio/logger";
 
 // src/helpers/specFileResolver.ts
 import fs4 from "fs";
@@ -3316,8 +3754,8 @@ function resolveSpecFilePath(testFile, modulePath, srcFolders, cachedPath) {
 }
 
 // src/helpers/closePreviousTest.ts
-import logger13 from "@wdio/logger";
-var log13 = logger13("@wdio/nightwatch-devtools:closePreviousTest");
+import logger14 from "@wdio/logger";
+var log14 = logger14("@wdio/nightwatch-devtools:closePreviousTest");
 async function closePreviousTest(input) {
   const {
     runningTest,
@@ -3336,7 +3774,7 @@ async function closePreviousTest(input) {
     testManager.updateTestState(runningTest, testState);
     testManager.markTestAsProcessed(testFile, runningTest.title);
     incrementCount(testState);
-    log13.info(
+    log14.info(
       `  ${testIcon(testState)} ${runningTest.title} (${(runningTest._duration / 1e3).toFixed(2)}s)`
     );
   } else {
@@ -3350,13 +3788,13 @@ async function closePreviousTest(input) {
     );
     testManager.markTestAsProcessed(testFile, runningTest.title);
     incrementCount(TEST_STATE.PASSED);
-    log13.info(`  \u2705 ${runningTest.title} (${(duration / 1e3).toFixed(2)}s)`);
+    log14.info(`  \u2705 ${runningTest.title} (${(duration / 1e3).toFixed(2)}s)`);
   }
   await new Promise((resolve2) => setTimeout(resolve2, TIMING.UI_RENDER_DELAY));
 }
 
 // src/test-lifecycle.ts
-var log14 = logger14("@wdio/nightwatch-devtools:test-lifecycle");
+var log15 = logger15("@wdio/nightwatch-devtools:test-lifecycle");
 function resolveSuiteMetadata(ctx, currentTest) {
   const moduleName = currentTest.module ?? "";
   const testFile = moduleName.split("/").pop() || moduleName || DEFAULTS.FILE_NAME;
@@ -3367,7 +3805,7 @@ function resolveSuiteMetadata(ctx, currentTest) {
     ctx.browserProxy.getCurrentTestFullPath() || void 0
   );
   if (!fullPath) {
-    log14.warn(
+    log15.warn(
       `[beforeEach] Could not resolve file path for "${testFile}" \u2014 source view will be unavailable`
     );
   }
@@ -3412,10 +3850,10 @@ async function startNextTest(ctx, currentSuite, currentTestName, processedTests,
     test.end = null;
     ctx.testReporter.onTestStart(test);
     ctx.setCurrentTest(test);
-    log14.info(`  \u25B6 ${currentTestName}`);
+    log15.info(`  \u25B6 ${currentTestName}`);
     await new Promise((resolve2) => setTimeout(resolve2, TIMING.TEST_START_DELAY));
   } else {
-    log14.warn(
+    log15.warn(
       `Test "${currentTestName}" not found in suite "${currentSuite.title}"`
     );
     ctx.setCurrentTest(null);
@@ -3460,7 +3898,7 @@ function closeUnreportedRunningTest(ctx, currentSuite, testFile, results, proces
   ctx.testManager.markTestAsProcessed(testFile, runningTest.title);
   ctx.incrementCount(testState);
   const icon = ctx.testIcon(testState);
-  log14.info(`  ${icon} ${runningTest.title} (${(duration / 1e3).toFixed(2)}s)`);
+  log15.info(`  ${icon} ${runningTest.title} (${(duration / 1e3).toFixed(2)}s)`);
 }
 async function closeReportedTestcases(ctx, currentSuite, testFile, testcases, processedTests) {
   const testcaseNames = Object.keys(testcases);
@@ -3476,7 +3914,7 @@ async function closeReportedTestcases(ctx, currentSuite, testFile, testcases, pr
       ctx.testManager.updateTestState(test, testState, /* @__PURE__ */ new Date(), dur);
       ctx.incrementCount(testState);
       const icon = ctx.testIcon(testState);
-      log14.info(`  ${icon} ${currentTestName} (${(dur / 1e3).toFixed(2)}s)`);
+      log15.info(`  ${icon} ${currentTestName} (${(dur / 1e3).toFixed(2)}s)`);
     }
     ctx.testManager.markTestAsProcessed(testFile, currentTestName);
   }
@@ -3518,7 +3956,7 @@ async function closeOutTestcases(ctx, browser) {
 }
 
 // src/index.ts
-var log15 = logger15("@wdio/nightwatch-devtools");
+var log16 = logger16("@wdio/nightwatch-devtools");
 var NightwatchDevToolsPlugin = class {
   options;
   sessionCapturer;
@@ -3572,7 +4010,7 @@ var NightwatchDevToolsPlugin = class {
       screencast: options.screencast
     });
     if (screencast.warning) {
-      log15.warn(screencast.warning);
+      log16.warn(screencast.warning);
     }
     this.options = {
       port: options.port ?? 3e3,
@@ -3593,7 +4031,7 @@ var NightwatchDevToolsPlugin = class {
     };
     const policyWarning = tracePolicyModeWarning(options.tracePolicy, mode);
     if (policyWarning) {
-      log15.warn(policyWarning);
+      log16.warn(policyWarning);
     }
     this.#screencast = new PluginScreencast(
       screencast.options,
@@ -3814,7 +4252,8 @@ var NightwatchDevToolsPlugin = class {
         // Rows are tagged per-`it` (BrowserProxy.rowTestUid); `#currentTestUid`
         // — the lifecycle test, which the BDD interface pins to the module's
         // first `it` — is only the fallback, and stays the artifact/slice key.
-        () => this.browserProxy?.rowTestUid() ?? this.#currentTestUid()
+        () => this.browserProxy?.rowTestUid() ?? this.#currentTestUid(),
+        () => this.browserProxy?.scopeReadValuesToRowTest()
       );
     }
   }
@@ -3926,6 +4365,7 @@ var NightwatchDevToolsPlugin = class {
     }
     if (browser && this.sessionCapturer) {
       try {
+        this.browserProxy.closeUnrunWaits();
         await this.#closeOutTestcases(browser);
         if (this.options.captureAssertions) {
           await captureNativeAssertions(
@@ -3936,13 +4376,13 @@ var NightwatchDevToolsPlugin = class {
             this.browserProxy.drainNativeAssertCalls()
           );
         }
-        await this.sessionCapturer.captureTrace(browser, true);
+        await this.sessionCapturer.captureTraceAtTestEnd(browser);
         flushTestSlice(this.#getInternals());
         const results = browser.currentTest?.results;
         const failed = !!results && ((results.errors ?? 0) > 0 || (results.failed ?? 0) > 0);
         await this.#emitTestArtifacts(this.#currentTestUid(), failed);
       } catch (err) {
-        log15.error(`Failed to capture trace: ${errorMessage(err)}`);
+        log16.error(`Failed to capture trace: ${errorMessage(err)}`);
       }
     }
   }
@@ -3978,10 +4418,12 @@ var NightwatchDevToolsPlugin = class {
       outputDir: this.#outputDir,
       captureFormat: this.#screencast.options.captureFormat,
       onArtifact: (a) => this.#artifacts.push(a),
-      onLog: (level, msg) => log15[level](msg)
+      onLog: (level, msg) => log16[level](msg)
     });
   }
   async after(browser) {
+    this.sessionCapturer?.nativeNetwork.stop();
+    this.browserProxy?.closeUnrunWaits();
     await this.#screencast.rotation;
     await this.#finalizeCurrentScreencast();
     try {
@@ -3995,14 +4437,14 @@ var NightwatchDevToolsPlugin = class {
       }
       if (!this.#devtoolsBrowser) {
         this.testReporter?.updateSuites();
-        log15.info("\u267B  Rerun complete \u2014 flushing WebSocket...");
+        log16.info("\u267B  Rerun complete \u2014 flushing WebSocket...");
         await this.sessionCapturer?.closeWebSocket();
         return;
       }
-      log15.info("\u{1F4A1} Please close the DevTools browser window to finish...");
+      log16.info("\u{1F4A1} Please close the DevTools browser window to finish...");
       await this.#waitForDevtoolsBrowserClose();
     } catch (err) {
-      log15.error(`Failed to stop backend: ${errorMessage(err)}`);
+      log16.error(`Failed to stop backend: ${errorMessage(err)}`);
     }
   }
   async #finalizeAllSuites(browser) {
@@ -4043,7 +4485,7 @@ var NightwatchDevToolsPlugin = class {
         screencastFrames: this.options.filmstrip ? this.#screencast.frames : void 0,
         configPath: this.#configPath,
         testFilePath: this.browserProxy?.getCurrentTestFullPath?.() ?? void 0,
-        log: (level, msg) => log15[level](msg)
+        log: (level, msg) => log16[level](msg)
       },
       sessionId2
     );