@wdio/nightwatch-devtools 2.0.0 → 2.1.0

package/dist/{chunk-TUK7ZLQI.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;
@@ -526,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) {
@@ -584,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);
@@ -594,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;
@@ -618,7 +630,7 @@ function deviceFromCapabilities(capabilities) {
   };
 }
 function isNativeAppSession(capabilities) {
-  if (!capabilities || typeof capabilities !== "object") {
+  if (!isCapabilityBag(capabilities)) {
     return false;
   }
   const caps = capabilities;
@@ -1068,6 +1080,155 @@ 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) {
@@ -1584,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);
@@ -1617,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
@@ -1657,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])
@@ -1755,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;
@@ -1795,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);
@@ -1815,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",
@@ -1833,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) {
@@ -1844,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) {
@@ -1857,17 +2022,24 @@ 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;
@@ -2068,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))];
@@ -2078,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("  ")));
   });
@@ -2820,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,
@@ -2829,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",
@@ -3148,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)) {
@@ -3384,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) {
@@ -3532,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) {
@@ -5086,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) {
@@ -5184,17 +5358,17 @@ 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
   );
@@ -5454,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];
@@ -5474,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
@@ -5705,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() {
@@ -5848,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,
@@ -5872,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 });
@@ -5945,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;
@@ -6005,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,
@@ -6037,42 +6219,35 @@ 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;
 }
 
 // ../core/src/retry-tracker.ts
-var RetryTracker = class _RetryTracker {
+var RetryTracker = class {
   #lastSig = null;
-  #lastBareSig = null;
   #lastId = null;
   /** Build the canonical signature used for retry-equality checks. */
   static signature(command, args, callSource) {
     return JSON.stringify({ command, args, src: callSource ?? null });
   }
-  /** The signature without the call site: a framework's own repeat of a call
-   *  (a `wait()` poll from a timer) has no user frame on its stack. */
-  static bareSignature(command, args) {
-    return JSON.stringify({ command, args });
-  }
   /** True when the incoming signature matches the last captured one AND we
    *  have an id to replace (otherwise there's nothing to replace yet). */
   isRetry(sig) {
     return sig === this.#lastSig && this.#lastId !== null;
   }
-  /** As `isRetry`, for a repeat that carries no call site of its own. */
-  isRetryIgnoringSource(bareSig) {
-    return bareSig === this.#lastBareSig && this.#lastId !== null;
-  }
   /** The id of the last captured command, if any (for the replace-in-place
    *  flow). */
   get lastId() {
@@ -6081,17 +6256,8 @@ var RetryTracker = class _RetryTracker {
   /** Record a fresh capture — sets both sig and id together. */
   recordCapture(sig, id) {
     this.#lastSig = sig;
-    this.#lastBareSig = _RetryTracker.bareOf(sig);
     this.#lastId = id;
   }
-  static bareOf(sig) {
-    try {
-      const { command, args } = JSON.parse(sig);
-      return _RetryTracker.bareSignature(command, args);
-    } catch {
-      return null;
-    }
-  }
   /** Record only the id (used by adapters that compute the sig but defer the
    *  id assignment to after an async capture call). */
   setLastId(id) {
@@ -6102,12 +6268,10 @@ var RetryTracker = class _RetryTracker {
    *  commands). Pair with {@link setLastId} once the capture resolves. */
   setLastSig(sig) {
     this.#lastSig = sig;
-    this.#lastBareSig = _RetryTracker.bareOf(sig);
   }
   /** Reset at test/scenario boundaries so the next capture is "fresh". */
   reset() {
     this.#lastSig = null;
-    this.#lastBareSig = null;
     this.#lastId = null;
   }
 };
@@ -6412,6 +6576,7 @@ function restoreBrowserFocus(target, platform = process.platform, launch = spawn
 }
 
 // ../core/src/session-capturer.ts
+import { randomInt } from "crypto";
 import fs10 from "fs/promises";
 import { WebSocket } from "ws";
 var SessionCapturerBase = class _SessionCapturerBase {
@@ -6444,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
@@ -7245,11 +7411,18 @@ 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,
@@ -7285,8 +7458,6 @@ export {
   finalizeTraceExport,
   findFreePort,
   attachBidiHandlers,
-  COLLECTOR_READY_EXPRESSION,
-  collectorDrainExpression,
   loadInjectableScript,
   drainCollectorWithRecovery,
   pollUntilReady,
@@ -7294,9 +7465,9 @@ export {
   finalizeScreencast,
   beginInputDispatch,
   resolveAdapterOutputDir,
-  CAPTURE_PERFORMANCE_SCRIPT,
   applyPerformanceData,
   rememberReadValue,
+  clearReadValues,
   resolveAssertTargetFromArgs,
   RetryTracker,
   ScreencastRecorderBase,
@@ -7312,4 +7483,4 @@ export {
   findTestDefinitions,
   TestReporterBase
 };
-//# sourceMappingURL=chunk-TUK7ZLQI.js.map
+//# sourceMappingURL=chunk-DRZC45YG.js.map