webdriver 9.3.1 → 9.4.0

package/build/index.js

@@ -1,131 +1,301 @@
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+
 // src/index.ts
-import logger5 from "@wdio/logger";
+import logger4 from "@wdio/logger";
 import { webdriverMonad, sessionEnvironmentDetector, startWebDriver, isBidi } from "@wdio/utils";
 import { validateConfig } from "@wdio/config";
 
 // src/command.ts
-import logger4 from "@wdio/logger";
+import logger from "@wdio/logger";
 import { commandCallStructure, isValidParameter, getArgumentType } from "@wdio/utils";
-import { WebDriverBidiProtocol as WebDriverBidiProtocol2 } from "@wdio/protocols";
-
-// src/request/request.ts
-import { performance } from "node:perf_hooks";
-import dns from "node:dns";
-
-// src/request/index.ts
-import path from "node:path";
-import { EventEmitter } from "node:events";
-import { WebDriverProtocol as WebDriverProtocol2 } from "@wdio/protocols";
-import { URL } from "node:url";
-import logger3 from "@wdio/logger";
-import { transformCommandLogResult as transformCommandLogResult2, sleep } from "@wdio/utils";
-
-// src/request/error.ts
-import { transformCommandLogResult } from "@wdio/utils";
-
-// src/request/constants.ts
-var RETRYABLE_STATUS_CODES = [408, 413, 429, 500, 502, 503, 504];
-var RETRYABLE_ERROR_CODES = [
-  "ETIMEDOUT",
-  "ECONNRESET",
-  "EADDRINUSE",
-  "ECONNREFUSED",
-  "EPIPE",
-  "ENOTFOUND",
-  "ENETUNREACH",
-  "EAI_AGAIN",
-  // additional error codes we like to retry
-  "UND_ERR_CONNECT_TIMEOUT",
-  "UND_ERR_SOCKET"
-];
-var REG_EXPS = {
-  commandName: /.*\/session\/[0-9a-f-]+\/(.*)/,
-  execFn: /return \(([\s\S]*)\)\.apply\(null, arguments\)/
-};
+import { WebDriverBidiProtocol } from "@wdio/protocols";
 
-// src/request/error.ts
-var WebDriverError = class extends Error {
-  /**
-   * return timeout error with information about the executing command on which the test hangs
-   */
-  computeErrorMessage() {
-    const cmdName = this.#getExecCmdName();
-    const cmdArgs = this.#getExecCmdArgs(this.opts);
-    const cmdInfoMsg = `when running "${cmdName}" with method "${this.opts.method}"`;
-    const cmdArgsMsg = cmdArgs ? ` and args ${cmdArgs}` : "";
-    return `WebDriverError: ${this.message} ${cmdInfoMsg}${cmdArgsMsg}`;
-  }
-  #getExecCmdName() {
-    const { href } = this.url;
-    const res = href.match(REG_EXPS.commandName) || [];
-    return res[1] || href;
-  }
-  #getExecCmdArgs(requestOptions) {
-    const { body: cmdJson } = requestOptions;
-    if (typeof cmdJson !== "object") {
-      return "";
-    }
-    const transformedRes = transformCommandLogResult(cmdJson);
-    if (typeof transformedRes === "string") {
-      return transformedRes;
-    }
-    if (typeof cmdJson.script === "string") {
-      const scriptRes = cmdJson.script.match(REG_EXPS.execFn) || [];
-      return `"${scriptRes[1] || cmdJson.script}"`;
+// src/environment.ts
+var isNode = !!(typeof process !== "undefined" && process.version);
+var environment = {
+  value: {
+    get Request() {
+      throw new Error("Request is not available in this environment");
+    },
+    get Socket() {
+      throw new Error("Socket is not available in this environment");
+    },
+    get variables() {
+      return {};
     }
-    return Object.keys(cmdJson).length ? `"${JSON.stringify(cmdJson)}"` : "";
   }
 };
-var WebDriverRequestError = class extends WebDriverError {
-  url;
-  opts;
-  statusCode;
-  body;
-  code;
-  constructor(err, url, opts) {
-    let message = err.message;
-    if (err.message === "fetch failed") {
-      message = `Failed to fetch [${opts.method}] ${url.href}: please make sure you have a WebDriver compatible server running on ${url.origin}`;
+
+// src/command.ts
+var log = logger("webdriver");
+var BIDI_COMMANDS = Object.values(WebDriverBidiProtocol).map((def) => def.socket.command);
+function command_default(method, endpointUri, commandInfo, doubleEncodeVariables = false) {
+  const { command, deprecated, ref, parameters, variables = [], isHubCommand = false } = commandInfo;
+  return async function protocolCommand(...args) {
+    const isBidiCommand = BIDI_COMMANDS.includes(command);
+    let endpoint = endpointUri;
+    const commandParams = [...variables.map((v) => Object.assign(v, {
+      /**
+       * url variables are:
+       */
+      required: true,
+      // always required as they are part of the endpoint
+      type: "string"
+      // have to be always type of string
+    })), ...parameters];
+    const commandUsage = "".concat(command, "(").concat(commandParams.map((p) => p.name).join(", "), ")");
+    const moreInfo = "\n\nFor more info see ".concat(ref, "\n");
+    const body = {};
+    if (typeof deprecated === "string" && !process.env.DISABLE_WEBDRIVERIO_DEPRECATION_WARNINGS) {
+      const warning = deprecated.replace("This command", 'The "'.concat(command, '" command'));
+      log.warn(warning);
+      console.warn("\u26A0\uFE0F [WEBDRIVERIO DEPRECATION NOTICE] ".concat(warning));
     }
-    super(message);
-    this.url = url;
-    this.opts = opts;
-    const errorCode = typeof err.cause === "object" && err.cause && "code" in err.cause && typeof err.cause.code === "string" ? err.cause.code : "code" in err && typeof err.code === "string" ? err.code : void 0;
-    if (errorCode) {
-      this.code = errorCode;
-      this.message = errorCode === "UND_ERR_CONNECT_TIMEOUT" ? 'Request timed out! Consider increasing the "connectionRetryTimeout" option.' : "Request failed with error code " + errorCode;
+    if (isBidiCommand) {
+      throw new Error(
+        'Failed to execute WebDriver Bidi command "'.concat(command, '" as no Bidi session ') + 'was established. Make sure you enable it by setting "webSocketUrl: true" in your capabilities and verify that your environment and browser supports it.'
+      );
     }
-    this.message = this.computeErrorMessage();
-  }
-};
-var WebDriverResponseError = class _WebDriverResponseError extends WebDriverError {
-  url;
-  opts;
-  constructor(response, url, opts) {
-    const errorObj = !response.body ? new Error("Response has empty body") : typeof response.body === "string" && response.body.length ? new Error(response.body) : typeof response.body !== "object" ? new Error("Unknown error") : response.body.value || response.body;
-    let errorMessage = errorObj.message || errorObj.error || errorObj.class || "unknown error";
-    if (typeof errorMessage === "string" && errorMessage.includes("invalid locator")) {
-      const requestOptions = opts.body;
-      errorMessage = `The selector "${requestOptions.value}" used with strategy "${requestOptions.using}" is invalid!`;
+    const minAllowedParams = commandParams.filter((param) => param.required).length;
+    if (args.length < minAllowedParams || args.length > commandParams.length) {
+      const parameterDescription = commandParams.length ? "\n\nProperty Description:\n".concat(commandParams.map((p) => '  "'.concat(p.name, '" (').concat(p.type, "): ").concat(p.description)).join("\n")) : "";
+      throw new Error(
+        "Wrong parameters applied for ".concat(command, "\n") + "Usage: ".concat(commandUsage) + parameterDescription + moreInfo
+      );
     }
-    super(errorMessage);
-    if (errorObj.error) {
-      this.name = errorObj.error;
-    } else if (errorMessage && errorMessage.includes("stale element reference")) {
-      this.name = "stale element reference";
-    } else {
-      this.name = errorObj.name || "WebDriver Error";
+    for (const [it, arg] of Object.entries(args)) {
+      if (isBidiCommand) {
+        break;
+      }
+      const i = parseInt(it, 10);
+      const commandParam = commandParams[i];
+      if (!isValidParameter(arg, commandParam.type)) {
+        if (typeof arg === "undefined" && !commandParam.required) {
+          continue;
+        }
+        const actual = commandParam.type.endsWith("[]") ? "(".concat((Array.isArray(arg) ? arg : [arg]).map((a) => getArgumentType(a)), ")[]") : getArgumentType(arg);
+        throw new Error(
+          'Malformed type for "'.concat(commandParam.name, '" parameter of command ').concat(command, "\n") + "Expected: ".concat(commandParam.type, "\n") + "Actual: ".concat(actual) + moreInfo
+        );
+      }
+      if (i < variables.length) {
+        const encodedArg = doubleEncodeVariables ? encodeURIComponent(encodeURIComponent(arg)) : encodeURIComponent(arg);
+        endpoint = endpoint.replace(":".concat(commandParams[i].name), encodedArg);
+        continue;
+      }
+      body[commandParams[i].name] = arg;
     }
-    Error.captureStackTrace(this, _WebDriverResponseError);
-    this.url = url;
-    this.opts = opts;
-    this.message = this.computeErrorMessage();
+    const request = new environment.value.Request(method, endpoint, body, isHubCommand);
+    request.on("performance", (...args2) => this.emit("request.performance", ...args2));
+    this.emit("command", { command, method, endpoint, body });
+    log.info("COMMAND", commandCallStructure(command, args));
+    return request.makeRequest(this.options, this.sessionId).then((result) => {
+      var _a, _b;
+      if (typeof result.value !== "undefined") {
+        let resultLog = result.value;
+        if (/screenshot|recording/i.test(command) && typeof result.value === "string" && result.value.length > 64) {
+          resultLog = "".concat(result.value.slice(0, 61), "...");
+        } else if (command === "executeScript" && body.script && body.script.includes("(() => window.__wdioEvents__)")) {
+          resultLog = "[".concat(result.value.length, " framework events captured]");
+        }
+        log.info("RESULT", resultLog);
+      }
+      this.emit("result", { command, method, endpoint, body, result });
+      if (command === "deleteSession") {
+        const browser = this;
+        (_a = browser._bidiHandler) == null ? void 0 : _a.close();
+        const shutdownDriver = ((_b = body.deleteSessionOpts) == null ? void 0 : _b.shutdownDriver) !== false;
+        if (shutdownDriver && "wdio:driverPID" in this.capabilities && this.capabilities["wdio:driverPID"]) {
+          log.info("Kill driver process with PID ".concat(this.capabilities["wdio:driverPID"]));
+          try {
+            const killedSuccessfully = process.kill(this.capabilities["wdio:driverPID"], "SIGKILL");
+            if (!killedSuccessfully) {
+              log.warn("Failed to kill driver process, manually clean-up might be required");
+            }
+          } catch (err) {
+            log.warn("Failed to kill driver process", err);
+          }
+          setTimeout(() => {
+            for (const handle of process._getActiveHandles()) {
+              if (handle.servername && handle.servername.includes("edgedl.me")) {
+                handle.destroy();
+              }
+            }
+          }, 10);
+        }
+        if (!process.env.WDIO_WORKER_ID) {
+          logger.clearLogger();
+        }
+      }
+      return result.value;
+    });
+  };
+}
+
+// src/constants.ts
+var DEFAULTS = {
+  /**
+   * protocol of automation driver
+   */
+  protocol: {
+    type: "string",
+    default: "http",
+    match: /(http|https)/
+  },
+  /**
+   * hostname of automation driver
+   */
+  hostname: {
+    type: "string",
+    default: "localhost"
+  },
+  /**
+   * port of automation driver
+   */
+  port: {
+    type: "number"
+  },
+  /**
+   * path to WebDriver endpoints
+   */
+  path: {
+    type: "string",
+    validate: (path2) => {
+      if (!path2.startsWith("/")) {
+        throw new TypeError('The option "path" needs to start with a "/"');
+      }
+      return true;
+    },
+    default: "/"
+  },
+  /**
+   * A key-value store of query parameters to be added to every selenium request
+   */
+  queryParams: {
+    type: "object"
+  },
+  /**
+   * cloud user if applicable
+   */
+  user: {
+    type: "string"
+  },
+  /**
+   * access key to user
+   */
+  key: {
+    type: "string"
+  },
+  /**
+   * capability of WebDriver session
+   */
+  capabilities: {
+    type: "object",
+    required: true
+  },
+  /**
+   * Level of logging verbosity
+   */
+  logLevel: {
+    type: "string",
+    default: "info",
+    match: /(trace|debug|info|warn|error|silent)/
+  },
+  /**
+   * directory for log files
+   */
+  outputDir: {
+    type: "string"
+  },
+  /**
+   * Timeout for any WebDriver request to a driver or grid
+   */
+  connectionRetryTimeout: {
+    type: "number",
+    default: 12e4
+  },
+  /**
+   * Count of request retries to the Selenium server
+   */
+  connectionRetryCount: {
+    type: "number",
+    default: 3
+  },
+  /**
+   * Override default agent
+   */
+  logLevels: {
+    type: "object"
+  },
+  /**
+   * Pass custom headers
+   */
+  headers: {
+    type: "object"
+  },
+  /**
+   * Function transforming the request options before the request is made
+   */
+  transformRequest: {
+    type: "function",
+    default: (requestOptions) => requestOptions
+  },
+  /**
+   * Function transforming the response object after it is received
+   */
+  transformResponse: {
+    type: "function",
+    default: (response) => response
+  },
+  /**
+   * Appium direct connect options server (https://appiumpro.com/editions/86-connecting-directly-to-appium-hosts-in-distributed-environments)
+   * Whether to allow direct connect caps to adjust endpoint details (Appium only)
+   */
+  enableDirectConnect: {
+    type: "boolean",
+    default: true
+  },
+  /**
+   * Whether it requires SSL certificates to be valid in HTTP/s requests
+   * for an environment which cannot get process environment well.
+   */
+  strictSSL: {
+    type: "boolean",
+    default: true
+  },
+  /**
+   * The path to the root of the cache directory. This directory is used to store all drivers that are downloaded
+   * when attempting to start a session.
+   */
+  cacheDir: {
+    type: "string",
+    default: environment.value.variables.WEBDRIVER_CACHE_DIR
   }
 };
+var ELEMENT_KEY = "element-6066-11e4-a52e-4f735466cecf";
+var SHADOW_ELEMENT_KEY = "shadow-6066-11e4-a52e-4f735466cecf";
 
 // src/utils.ts
 import { deepmergeCustom } from "deepmerge-ts";
-import logger2 from "@wdio/logger";
+import logger3 from "@wdio/logger";
 import {
   WebDriverProtocol,
   MJsonWProtocol,
@@ -134,71 +304,32 @@ import {
   SauceLabsProtocol,
   SeleniumProtocol,
   GeckoProtocol,
-  WebDriverBidiProtocol
+  WebDriverBidiProtocol as WebDriverBidiProtocol2
 } from "@wdio/protocols";
 import { CAPABILITY_KEYS } from "@wdio/protocols";
 
 // src/bidi/core.ts
-import logger from "@wdio/logger";
-
-// src/bidi/socket.ts
-var BrowserSocket = class {
-  #callbacks = /* @__PURE__ */ new Set();
-  #ws;
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  constructor(wsUrl, opts) {
-    this.#ws = new globalThis.WebSocket(wsUrl);
-    this.#ws.onmessage = this.handleMessage.bind(this);
-  }
-  handleMessage(event) {
-    for (const callback of this.#callbacks) {
-      callback(event.data);
-    }
-  }
-  send(data) {
-    this.#ws.send(data);
-  }
-  on(event, callback) {
-    if (event === "open") {
-      this.#ws.onopen = callback;
-    } else if (event === "close") {
-      this.#ws.onclose = callback;
-    } else if (event === "error") {
-      this.#ws.onerror = callback;
-    } else {
-      this.#callbacks.add(callback);
-    }
-    return this;
-  }
-  off(event, callback) {
-    this.#callbacks.delete(callback);
-    return this;
-  }
-  close() {
-    this.#ws.close();
-  }
-};
-var socket_default = globalThis.window ? BrowserSocket : (await import("ws")).default;
-
-// src/bidi/core.ts
-var log = logger("webdriver");
+import logger2 from "@wdio/logger";
+var log2 = logger2("webdriver");
 var RESPONSE_TIMEOUT = 1e3 * 60;
+var _id, _ws, _waitForConnected, _webSocketUrl, _pendingCommands, _BidiCore_instances, handleResponse_fn;
 var BidiCore = class {
-  #id = 0;
-  #ws;
-  #waitForConnected = Promise.resolve(false);
-  #webSocketUrl;
-  #pendingCommands = /* @__PURE__ */ new Map();
-  client;
-  /**
-   * @private
-   */
-  _isConnected = false;
   constructor(webSocketUrl, opts) {
-    this.#webSocketUrl = webSocketUrl;
-    log.info(`Connect to webSocketUrl ${this.#webSocketUrl}`);
-    this.#ws = new socket_default(this.#webSocketUrl, opts);
-    this.#ws.on("message", this.#handleResponse.bind(this));
+    __privateAdd(this, _BidiCore_instances);
+    __privateAdd(this, _id, 0);
+    __privateAdd(this, _ws);
+    __privateAdd(this, _waitForConnected, Promise.resolve(false));
+    __privateAdd(this, _webSocketUrl);
+    __privateAdd(this, _pendingCommands, /* @__PURE__ */ new Map());
+    __publicField(this, "client");
+    /**
+     * @private
+     */
+    __publicField(this, "_isConnected", false);
+    __privateSet(this, _webSocketUrl, webSocketUrl);
+    log2.info("Connect to webSocketUrl ".concat(__privateGet(this, _webSocketUrl)));
+    __privateSet(this, _ws, new environment.value.Socket(__privateGet(this, _webSocketUrl), opts));
+    __privateGet(this, _ws).on("message", __privateMethod(this, _BidiCore_instances, handleResponse_fn).bind(this));
   }
   /**
    * We initiate the Bidi instance before a WebdriverIO instance is created.
@@ -213,36 +344,36 @@ var BidiCore = class {
       this._isConnected = true;
       return;
     }
-    this.#waitForConnected = new Promise((resolve) => {
-      this.#ws.on("open", () => {
-        log.info("Connected session to Bidi protocol");
+    __privateSet(this, _waitForConnected, new Promise((resolve) => {
+      __privateGet(this, _ws).on("open", () => {
+        log2.info("Connected session to Bidi protocol");
         this._isConnected = true;
         resolve(this._isConnected);
       });
-      this.#ws.on("error", (err) => {
-        log.warn(`Couldn't connect to Bidi protocol: ${err.message}`);
+      __privateGet(this, _ws).on("error", (err) => {
+        log2.warn("Couldn't connect to Bidi protocol: ".concat(err.message));
         this._isConnected = false;
         resolve(this._isConnected);
       });
-    });
-    return this.#waitForConnected;
+    }));
+    return __privateGet(this, _waitForConnected);
   }
   close() {
     if (!this._isConnected) {
       return;
     }
-    log.info(`Close Bidi connection to ${this.#webSocketUrl}`);
+    log2.info("Close Bidi connection to ".concat(__privateGet(this, _webSocketUrl)));
     this._isConnected = false;
-    this.#ws.off("message", this.#handleResponse.bind(this));
-    this.#ws.close();
-    this.#ws.terminate();
+    __privateGet(this, _ws).off("message", __privateMethod(this, _BidiCore_instances, handleResponse_fn).bind(this));
+    __privateGet(this, _ws).close();
+    __privateGet(this, _ws).terminate();
   }
   reconnect(webSocketUrl, opts) {
-    log.info(`Reconnect to new Bidi session at ${webSocketUrl}`);
+    log2.info("Reconnect to new Bidi session at ".concat(webSocketUrl));
     this.close();
-    this.#webSocketUrl = webSocketUrl;
-    this.#ws = new socket_default(this.#webSocketUrl, opts);
-    this.#ws.on("message", this.#handleResponse.bind(this));
+    __privateSet(this, _webSocketUrl, webSocketUrl);
+    __privateSet(this, _ws, new environment.value.Socket(__privateGet(this, _webSocketUrl), opts));
+    __privateGet(this, _ws).on("message", __privateMethod(this, _BidiCore_instances, handleResponse_fn).bind(this));
     return this.connect();
   }
   /**
@@ -250,10 +381,10 @@ var BidiCore = class {
    * @returns a promise that resolves once the connection to WebDriver Bidi protocol was established
    */
   waitForConnected() {
-    return this.#waitForConnected;
+    return __privateGet(this, _waitForConnected);
   }
   get socket() {
-    return this.#ws;
+    return __privateGet(this, _ws);
   }
   get isConnected() {
     return this._isConnected;
@@ -263,76 +394,81 @@ var BidiCore = class {
    * @internal
    */
   get __handleResponse() {
-    return this.#handleResponse.bind(this);
-  }
-  #handleResponse(data) {
-    try {
-      const payload = JSON.parse(data.toString());
-      if (!payload.id) {
-        return;
-      }
-      log.info("BIDI RESULT", data.toString());
-      this.client?.emit("bidiResult", payload);
-      const resolve = this.#pendingCommands.get(payload.id);
-      if (!resolve) {
-        log.error(`Couldn't resolve command with id ${payload.id}`);
-        return;
-      }
-      this.#pendingCommands.delete(payload.id);
-      resolve(payload);
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(`Failed parse message: ${String(err)}`);
-      log.error(`Failed parse message: ${error.message}`);
-    }
+    return __privateMethod(this, _BidiCore_instances, handleResponse_fn).bind(this);
   }
   async send(params) {
     const id = this.sendAsync(params);
-    const failError = new Error(`WebDriver Bidi command "${params.method}" failed`);
+    const failError = new Error('WebDriver Bidi command "'.concat(params.method, '" failed'));
     const payload = await new Promise((resolve, reject) => {
       const t = setTimeout(() => {
-        reject(new Error(`Command ${params.method} with id ${id} (with the following parameter: ${JSON.stringify(params.params)}) timed out`));
-        this.#pendingCommands.delete(id);
+        reject(new Error("Command ".concat(params.method, " with id ").concat(id, " (with the following parameter: ").concat(JSON.stringify(params.params), ") timed out")));
+        __privateGet(this, _pendingCommands).delete(id);
       }, RESPONSE_TIMEOUT);
-      this.#pendingCommands.set(id, (payload2) => {
+      __privateGet(this, _pendingCommands).set(id, (payload2) => {
         clearTimeout(t);
         resolve(payload2);
       });
     });
     if (payload.error) {
-      failError.message += ` with error: ${payload.error} - ${payload.message}`;
+      failError.message += " with error: ".concat(payload.error, " - ").concat(payload.message);
       if (payload.stacktrace) {
-        const driverStack = payload.stacktrace.split("\n").filter(Boolean).map((line) => `    at ${line}`).join("\n");
-        failError.stack += `
-
-Driver Stack:
-${driverStack}`;
+        const driverStack = payload.stacktrace.split("\n").filter(Boolean).map((line) => "    at ".concat(line)).join("\n");
+        failError.stack += "\n\nDriver Stack:\n".concat(driverStack);
       }
       throw failError;
     }
     return payload;
   }
   sendAsync(params) {
+    var _a;
     if (!this._isConnected) {
       throw new Error("No connection to WebDriver Bidi was established");
     }
-    log.info("BIDI COMMAND", ...parseBidiCommand(params));
-    const id = ++this.#id;
-    this.client?.emit("bidiCommand", params);
-    this.#ws.send(JSON.stringify({ id, ...params }));
+    log2.info("BIDI COMMAND", ...parseBidiCommand(params));
+    const id = ++__privateWrapper(this, _id)._;
+    (_a = this.client) == null ? void 0 : _a.emit("bidiCommand", params);
+    __privateGet(this, _ws).send(JSON.stringify({ id, ...params }));
     return id;
   }
 };
+_id = new WeakMap();
+_ws = new WeakMap();
+_waitForConnected = new WeakMap();
+_webSocketUrl = new WeakMap();
+_pendingCommands = new WeakMap();
+_BidiCore_instances = new WeakSet();
+handleResponse_fn = function(data) {
+  var _a;
+  try {
+    const payload = JSON.parse(data.toString());
+    if (!payload.id) {
+      return;
+    }
+    log2.info("BIDI RESULT", data.toString());
+    (_a = this.client) == null ? void 0 : _a.emit("bidiResult", payload);
+    const resolve = __privateGet(this, _pendingCommands).get(payload.id);
+    if (!resolve) {
+      log2.error("Couldn't resolve command with id ".concat(payload.id));
+      return;
+    }
+    __privateGet(this, _pendingCommands).delete(payload.id);
+    resolve(payload);
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error("Failed parse message: ".concat(String(err)));
+    log2.error("Failed parse message: ".concat(error.message));
+  }
+};
 function parseBidiCommand(params) {
   const commandName = params.method;
   if (commandName === "script.addPreloadScript") {
     const param = params.params;
-    const logString = `{ functionDeclaration: <PreloadScript[${new TextEncoder().encode(param.functionDeclaration).length} bytes]>, contexts: ${JSON.stringify(param.contexts)} }`;
+    const logString = "{ functionDeclaration: <PreloadScript[".concat(new TextEncoder().encode(param.functionDeclaration).length, " bytes]>, contexts: ").concat(JSON.stringify(param.contexts), " }");
     return [commandName, logString];
   } else if (commandName === "script.callFunction") {
     const param = params.params;
     const logString = JSON.stringify({
       ...param,
-      functionDeclaration: `<Function[${new TextEncoder().encode(param.functionDeclaration).length} bytes]>`
+      functionDeclaration: "<Function[".concat(new TextEncoder().encode(param.functionDeclaration).length, " bytes]>")
     });
     return [commandName, logString];
   }
@@ -864,7 +1000,7 @@ var BidiHandler = class extends BidiCore {
 };
 
 // src/utils.ts
-var log2 = logger2("webdriver");
+var log3 = logger3("webdriver");
 var deepmerge = deepmergeCustom({ mergeArrays: false });
 var BROWSER_DRIVER_ERRORS = [
   "unknown command: wd/hub/session",
@@ -891,7 +1027,7 @@ async function startWebDriverSession(params) {
     capabilities.alwaysMatch.unhandledPromptBehavior = "ignore";
   }
   validateCapabilities(capabilities.alwaysMatch);
-  const sessionRequest = new FetchRequest(
+  const sessionRequest = new environment.value.Request(
     "POST",
     "/session",
     { capabilities }
@@ -900,7 +1036,7 @@ async function startWebDriverSession(params) {
   try {
     response = await sessionRequest.makeRequest(params);
   } catch (err) {
-    log2.error(err);
+    log3.error(err);
     const message = getSessionError(err, params);
     throw new Error("Failed to create session.\n" + message);
   }
@@ -909,7 +1045,8 @@ async function startWebDriverSession(params) {
   return { sessionId, capabilities: params.capabilities };
 }
 function validateCapabilities(capabilities) {
-  const chromeArgs = capabilities["goog:chromeOptions"]?.args || [];
+  var _a;
+  const chromeArgs = ((_a = capabilities["goog:chromeOptions"]) == null ? void 0 : _a.args) || [];
   if (chromeArgs.includes("incognito") || chromeArgs.includes("--incognito")) {
     throw new Error(
       'Please remove "incognito" from `"goog:chromeOptions".args` as it is not supported running Chrome with WebDriver. WebDriver sessions are always incognito mode and do not persist across browser sessions.'
@@ -920,14 +1057,14 @@ function validateCapabilities(capabilities) {
     const invalidWebDriverCaps = Object.keys(capabilities).filter((cap) => !CAPABILITY_KEYS.includes(cap) && !cap.includes(":"));
     if (extensionCaps.length && invalidWebDriverCaps.length) {
       throw new Error(
-        `Invalid or unsupported WebDriver capabilities found ("${invalidWebDriverCaps.join('", "')}"). Ensure to only use valid W3C WebDriver capabilities (see https://w3c.github.io/webdriver/#capabilities).If you run your tests on a remote vendor, like Sauce Labs or BrowserStack, make sure that you put them into vendor specific capabilities, e.g. "sauce:options" or "bstack:options". Please reach out to your vendor support team if you have further questions.`
+        'Invalid or unsupported WebDriver capabilities found ("'.concat(invalidWebDriverCaps.join('", "'), '"). ') + 'Ensure to only use valid W3C WebDriver capabilities (see https://w3c.github.io/webdriver/#capabilities).If you run your tests on a remote vendor, like Sauce Labs or BrowserStack, make sure that you put them into vendor specific capabilities, e.g. "sauce:options" or "bstack:options". Please reach out to your vendor support team if you have further questions.'
       );
     }
   }
 }
 function isSuccessfulResponse(statusCode, body) {
   if (!body || typeof body.value === "undefined") {
-    log2.debug("request failed due to missing body");
+    log3.debug("request failed due to missing body");
     return false;
   }
   if (body.status === 7 && body.value && body.value.message && (body.value.message.toLowerCase().startsWith("no such element") || // Appium
@@ -936,7 +1073,7 @@ function isSuccessfulResponse(statusCode, body) {
     return true;
   }
   if (body.status && body.status !== 0) {
-    log2.debug(`request failed due to status ${body.status}`);
+    log3.debug("request failed due to status ".concat(body.status));
     return false;
   }
   const hasErrorResponse = body.value && (body.value.error || body.value.stackTrace || body.value.stacktrace);
@@ -947,7 +1084,7 @@ function isSuccessfulResponse(statusCode, body) {
     return true;
   }
   if (hasErrorResponse) {
-    log2.debug("request failed due to response error:", body.value.error);
+    log3.debug("request failed due to response error:", body.value.error);
     return false;
   }
   return true;
@@ -964,7 +1101,7 @@ function getPrototype({ isW3C, isChromium, isFirefox, isMobile, isSauce, isSelen
     /**
      * enable Bidi protocol for W3C sessions
      */
-    isW3C ? WebDriverBidiProtocol : {},
+    isW3C ? WebDriverBidiProtocol2 : {},
     /**
      * only apply mobile protocol if session is actually for mobile
      */
@@ -1011,7 +1148,8 @@ function getEnvironmentVars({ isW3C, isMobile, isIOS, isAndroid, isFirefox, isSa
        * by the session response.
        */
       get: function() {
-        return Boolean(this._bidiHandler?.isConnected);
+        var _a;
+        return Boolean((_a = this._bidiHandler) == null ? void 0 : _a.isConnected);
       }
     },
     isChromium: { value: isChromium }
@@ -1024,7 +1162,7 @@ function setupDirectConnect(client) {
   const directConnectPath = capabilities["appium:directConnectPath"];
   const directConnectPort = capabilities["appium:directConnectPort"];
   if (directConnectProtocol && directConnectHost && directConnectPort && (directConnectPath || directConnectPath === "")) {
-    log2.info(`Found direct connect information in new session response. Will connect to server at ${directConnectProtocol}://${directConnectHost}:${directConnectPort}${directConnectPath}`);
+    log3.info("Found direct connect information in new session response. " + "Will connect to server at ".concat(directConnectProtocol, "://") + "".concat(directConnectHost, ":").concat(directConnectPort).concat(directConnectPath));
     client.options.protocol = directConnectProtocol;
     client.options.hostname = directConnectHost;
     client.options.port = directConnectPort;
@@ -1032,228 +1170,380 @@ function setupDirectConnect(client) {
   }
 }
 var getSessionError = (err, params = {}) => {
+  var _a;
   if (err.code === "ECONNREFUSED") {
-    return `Unable to connect to "${params.protocol}://${params.hostname}:${params.port}${params.path}", make sure browser driver is running on that address.
-It seems like the service failed to start or is rejecting any connections.`;
+    return 'Unable to connect to "'.concat(params.protocol, "://").concat(params.hostname, ":").concat(params.port).concat(params.path, '", make sure browser driver is running on that address.') + "\nIt seems like the service failed to start or is rejecting any connections.";
   }
   if (err.message === "unhandled request") {
-    return `The browser driver couldn't start the session. Make sure you have set the "path" correctly!`;
+    return 'The browser driver couldn\'t start the session. Make sure you have set the "path" correctly!';
   }
   if (!err.message) {
     return "See wdio.* logs for more information.";
   }
-  if (err.message.includes("Whoops! The URL specified routes to this help page.")) {
-    return "It seems you are running a Selenium Standalone server and point to a wrong path. Please set `path: '/wd/hub'` in your wdio.conf.js!";
+  if (err.message.includes("Whoops! The URL specified routes to this help page.")) {
+    return "It seems you are running a Selenium Standalone server and point to a wrong path. Please set `path: '/wd/hub'` in your wdio.conf.js!";
+  }
+  if (BROWSER_DRIVER_ERRORS.some((m) => err && err.message && err.message.includes(m))) {
+    return "Make sure to set `path: '/'` in your wdio.conf.js!";
+  }
+  if (err.message.includes("Bad Request - Invalid Hostname") && err.message.includes("HTTP Error 400")) {
+    return "Run edge driver on 127.0.0.1 instead of localhost, ex: --host=127.0.0.1, or set `hostname: 'localhost'` in your wdio.conf.js";
+  }
+  const w3cCapMessage = '\nMake sure to add vendor prefix like "goog:", "appium:", "moz:", etc to non W3C capabilities.\nSee more https://www.w3.org/TR/webdriver/#capabilities';
+  if (err.message.includes("Illegal key values seen in w3c capabilities")) {
+    return err.message + w3cCapMessage;
+  }
+  if (err.message === "Response has empty body") {
+    return "Make sure to connect to valid hostname:port or the port is not in use.\nIf you use a grid server " + w3cCapMessage;
+  }
+  if (err.message.includes("failed serving request POST /wd/hub/session: Unauthorized") && ((_a = params.hostname) == null ? void 0 : _a.endsWith("saucelabs.com"))) {
+    return "Session request was not authorized because you either did provide a wrong access key or tried to run in a region that has not been enabled for your user. If have registered a free trial account it is connected to a specific region. Ensure this region is set in your configuration (https://webdriver.io/docs/options.html#region).";
+  }
+  return err.message;
+};
+function initiateBidi(socketUrl, strictSSL = true) {
+  socketUrl = socketUrl.replace("localhost", "127.0.0.1");
+  const bidiReqOpts = strictSSL ? {} : { rejectUnauthorized: false };
+  const handler = new BidiHandler(socketUrl, bidiReqOpts);
+  handler.connect().then((isConnected) => isConnected && log3.info("Connected to WebDriver Bidi interface at ".concat(socketUrl)));
+  return {
+    _bidiHandler: { value: handler },
+    ...Object.values(WebDriverBidiProtocol2).map((def) => def.socket).reduce((acc, cur) => {
+      acc[cur.command] = {
+        value: function(...args) {
+          const bidiFn = handler[cur.command];
+          handler.attachClient(this);
+          this.emit(cur.command, args);
+          return bidiFn == null ? void 0 : bidiFn.apply(handler, args);
+        }
+      };
+      return acc;
+    }, {})
+  };
+}
+function parseBidiMessage(data) {
+  try {
+    const payload = JSON.parse(data.toString());
+    if (payload.type !== "event") {
+      return;
+    }
+    this.emit(payload.method, payload.params);
+  } catch (err) {
+    log3.error("Failed parse WebDriver Bidi message: ".concat(err.message));
+  }
+}
+
+// src/bidi/localTypes.ts
+var localTypes_exports = {};
+
+// src/bidi/remoteTypes.ts
+var remoteTypes_exports = {};
+
+// src/index.ts
+var log4 = logger4("webdriver");
+var WebDriver = class _WebDriver {
+  static async newSession(options, modifier, userPrototype = {}, customCommandWrapper) {
+    const envLogLevel = process.env.WDIO_LOG_LEVEL;
+    options.logLevel = envLogLevel != null ? envLogLevel : options.logLevel;
+    const params = validateConfig(DEFAULTS, options);
+    if (params.logLevel && (!options.logLevels || !options.logLevels.webdriver)) {
+      logger4.setLevel("webdriver", params.logLevel);
+    }
+    log4.info("Initiate new session using the WebDriver protocol");
+    const driverProcess = await startWebDriver(params);
+    const requestedCapabilities = { ...params.capabilities };
+    const { sessionId, capabilities } = await startWebDriverSession(params);
+    const environment2 = sessionEnvironmentDetector({ capabilities, requestedCapabilities });
+    const environmentPrototype = getEnvironmentVars(environment2);
+    const protocolCommands = getPrototype(environment2);
+    if (driverProcess == null ? void 0 : driverProcess.pid) {
+      capabilities["wdio:driverPID"] = driverProcess.pid;
+    }
+    const bidiPrototype = {};
+    if (isBidi(requestedCapabilities, capabilities)) {
+      log4.info("Register BiDi handler for session with id ".concat(sessionId));
+      Object.assign(bidiPrototype, initiateBidi(capabilities.webSocketUrl, options.strictSSL));
+    }
+    const monad = webdriverMonad(
+      { ...params, requestedCapabilities },
+      modifier,
+      {
+        ...protocolCommands,
+        ...environmentPrototype,
+        ...userPrototype,
+        ...bidiPrototype
+      }
+    );
+    const client = monad(sessionId, customCommandWrapper);
+    if (isBidi(requestedCapabilities, capabilities)) {
+      await client._bidiHandler.waitForConnected();
+      client._bidiHandler.socket.on("message", parseBidiMessage.bind(client));
+    }
+    if (params.enableDirectConnect) {
+      setupDirectConnect(client);
+    }
+    return client;
+  }
+  /**
+   * allows user to attach to existing sessions
+   */
+  static attachToSession(options, modifier, userPrototype = {}, commandWrapper) {
+    var _a, _b;
+    if (!options || typeof options.sessionId !== "string") {
+      throw new Error("sessionId is required to attach to existing session");
+    }
+    if (options.logLevel) {
+      logger4.setLevel("webdriver", options.logLevel);
+    }
+    options.capabilities = options.capabilities || {};
+    options.isW3C = options.isW3C === false ? false : true;
+    options.protocol = options.protocol || DEFAULTS.protocol.default;
+    options.hostname = options.hostname || DEFAULTS.hostname.default;
+    options.port = options.port || DEFAULTS.port.default;
+    options.path = options.path || DEFAULTS.path.default;
+    const environment2 = sessionEnvironmentDetector({ capabilities: options.capabilities, requestedCapabilities: options.capabilities });
+    options = Object.assign(environment2, options);
+    const environmentPrototype = getEnvironmentVars(options);
+    const protocolCommands = getPrototype(options);
+    const bidiPrototype = {};
+    if (isBidi(options.requestedCapabilities || {}, options.capabilities || {})) {
+      const webSocketUrl = (_a = options.capabilities) == null ? void 0 : _a.webSocketUrl;
+      log4.info("Register BiDi handler for session with id ".concat(options.sessionId));
+      Object.assign(bidiPrototype, initiateBidi(webSocketUrl, options.strictSSL));
+    }
+    const prototype = { ...protocolCommands, ...environmentPrototype, ...userPrototype, ...bidiPrototype };
+    const monad = webdriverMonad(options, modifier, prototype);
+    const client = monad(options.sessionId, commandWrapper);
+    if (isBidi(options.requestedCapabilities || {}, options.capabilities || {})) {
+      (_b = client._bidiHandler) == null ? void 0 : _b.socket.on("message", parseBidiMessage.bind(client));
+    }
+    return client;
+  }
+  /**
+   * Changes The instance session id and browser capabilities for the new session
+   * directly into the passed in browser object
+   *
+   * @param   {object} instance  the object we get from a new browser session.
+   * @returns {string}           the new session id of the browser
+   */
+  static async reloadSession(instance, newCapabilities) {
+    var _a;
+    const capabilities = newCapabilities ? newCapabilities : Object.assign({}, instance.requestedCapabilities);
+    let params = { ...instance.options, capabilities };
+    for (const prop of ["protocol", "hostname", "port", "path", "queryParams", "user", "key"]) {
+      if (prop in capabilities) {
+        params = { ...params, [prop]: capabilities[prop] };
+        delete capabilities[prop];
+      }
+    }
+    let driverProcess;
+    if (params.hostname === "localhost" && (newCapabilities == null ? void 0 : newCapabilities.browserName)) {
+      delete params.port;
+      delete params.hostname;
+      driverProcess = await startWebDriver(params);
+    }
+    const { sessionId, capabilities: newSessionCapabilities } = await startWebDriverSession(params);
+    if (driverProcess == null ? void 0 : driverProcess.pid) {
+      newSessionCapabilities["wdio:driverPID"] = driverProcess.pid;
+    }
+    for (const prop of ["protocol", "hostname", "port", "path", "queryParams", "user", "key"]) {
+      if (prop in params) {
+        instance.options[prop] = params[prop];
+      }
+    }
+    for (const prop in instance.requestedCapabilities) {
+      delete instance.requestedCapabilities[prop];
+    }
+    const driverPid = instance.capabilities["wdio:driverPID"];
+    instance.sessionId = sessionId;
+    instance.capabilities = newSessionCapabilities;
+    instance.capabilities["wdio:driverPID"] = driverPid;
+    Object.assign(instance.requestedCapabilities, capabilities);
+    if (isBidi(instance.requestedCapabilities || {}, instance.capabilities || {})) {
+      const bidiReqOpts = instance.options.strictSSL ? {} : { rejectUnauthorized: false };
+      await ((_a = instance._bidiHandler) == null ? void 0 : _a.reconnect(newSessionCapabilities.webSocketUrl, bidiReqOpts));
+    }
+    return sessionId;
+  }
+  static get WebDriver() {
+    return _WebDriver;
+  }
+};
+
+// src/bidi/socket.ts
+var _callbacks, _ws2;
+var BrowserSocket = class {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  constructor(wsUrl, opts) {
+    __privateAdd(this, _callbacks, /* @__PURE__ */ new Set());
+    __privateAdd(this, _ws2);
+    __privateSet(this, _ws2, new WebSocket(wsUrl));
+    __privateGet(this, _ws2).onmessage = this.handleMessage.bind(this);
+  }
+  handleMessage(event) {
+    for (const callback of __privateGet(this, _callbacks)) {
+      callback(event.data);
+    }
+  }
+  send(data) {
+    __privateGet(this, _ws2).send(data);
+  }
+  on(event, callback) {
+    if (event === "open") {
+      __privateGet(this, _ws2).onopen = callback;
+    } else if (event === "close") {
+      __privateGet(this, _ws2).onclose = callback;
+    } else if (event === "error") {
+      __privateGet(this, _ws2).onerror = callback;
+    } else {
+      __privateGet(this, _callbacks).add(callback);
+    }
+    return this;
+  }
+  off(event, callback) {
+    __privateGet(this, _callbacks).delete(callback);
+    return this;
+  }
+  close() {
+    __privateGet(this, _ws2).close();
   }
-  if (BROWSER_DRIVER_ERRORS.some((m) => err && err.message && err.message.includes(m))) {
-    return "Make sure to set `path: '/'` in your wdio.conf.js!";
+};
+_callbacks = new WeakMap();
+_ws2 = new WeakMap();
+
+// src/request/request.ts
+import path from "node:path";
+import { EventEmitter } from "node:events";
+import logger5 from "@wdio/logger";
+import { transformCommandLogResult as transformCommandLogResult2, sleep } from "@wdio/utils";
+
+// src/request/error.ts
+import { transformCommandLogResult } from "@wdio/utils";
+
+// src/request/constants.ts
+var RETRYABLE_STATUS_CODES = [408, 413, 429, 500, 502, 503, 504];
+var RETRYABLE_ERROR_CODES = [
+  "ETIMEDOUT",
+  "ECONNRESET",
+  "EADDRINUSE",
+  "ECONNREFUSED",
+  "EPIPE",
+  "ENOTFOUND",
+  "ENETUNREACH",
+  "EAI_AGAIN",
+  // additional error codes we like to retry
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_SOCKET"
+];
+var REG_EXPS = {
+  commandName: /.*\/session\/[0-9a-f-]+\/(.*)/,
+  execFn: /return \(([\s\S]*)\)\.apply\(null, arguments\)/
+};
+
+// src/request/error.ts
+var _WebDriverError_instances, getExecCmdName_fn, getExecCmdArgs_fn;
+var WebDriverError = class extends Error {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _WebDriverError_instances);
   }
-  if (err.message.includes("Bad Request - Invalid Hostname") && err.message.includes("HTTP Error 400")) {
-    return "Run edge driver on 127.0.0.1 instead of localhost, ex: --host=127.0.0.1, or set `hostname: 'localhost'` in your wdio.conf.js";
+  /**
+   * return timeout error with information about the executing command on which the test hangs
+   */
+  computeErrorMessage() {
+    const cmdName = __privateMethod(this, _WebDriverError_instances, getExecCmdName_fn).call(this);
+    const cmdArgs = __privateMethod(this, _WebDriverError_instances, getExecCmdArgs_fn).call(this, this.opts);
+    const cmdInfoMsg = 'when running "'.concat(cmdName, '" with method "').concat(this.opts.method, '"');
+    const cmdArgsMsg = cmdArgs ? " and args ".concat(cmdArgs) : "";
+    return "WebDriverError: ".concat(this.message, " ").concat(cmdInfoMsg).concat(cmdArgsMsg);
   }
-  const w3cCapMessage = '\nMake sure to add vendor prefix like "goog:", "appium:", "moz:", etc to non W3C capabilities.\nSee more https://www.w3.org/TR/webdriver/#capabilities';
-  if (err.message.includes("Illegal key values seen in w3c capabilities")) {
-    return err.message + w3cCapMessage;
+};
+_WebDriverError_instances = new WeakSet();
+getExecCmdName_fn = function() {
+  const { href } = this.url;
+  const res = href.match(REG_EXPS.commandName) || [];
+  return res[1] || href;
+};
+getExecCmdArgs_fn = function(requestOptions) {
+  const { body: cmdJson } = requestOptions;
+  if (typeof cmdJson !== "object") {
+    return "";
   }
-  if (err.message === "Response has empty body") {
-    return "Make sure to connect to valid hostname:port or the port is not in use.\nIf you use a grid server " + w3cCapMessage;
+  const transformedRes = transformCommandLogResult(cmdJson);
+  if (typeof transformedRes === "string") {
+    return transformedRes;
   }
-  if (err.message.includes("failed serving request POST /wd/hub/session: Unauthorized") && params.hostname?.endsWith("saucelabs.com")) {
-    return "Session request was not authorized because you either did provide a wrong access key or tried to run in a region that has not been enabled for your user. If have registered a free trial account it is connected to a specific region. Ensure this region is set in your configuration (https://webdriver.io/docs/options.html#region).";
+  if (typeof cmdJson.script === "string") {
+    const scriptRes = cmdJson.script.match(REG_EXPS.execFn) || [];
+    return '"'.concat(scriptRes[1] || cmdJson.script, '"');
   }
-  return err.message;
+  return Object.keys(cmdJson).length ? '"'.concat(JSON.stringify(cmdJson), '"') : "";
 };
-function initiateBidi(socketUrl, strictSSL = true) {
-  socketUrl = socketUrl.replace("localhost", "127.0.0.1");
-  const bidiReqOpts = strictSSL ? {} : { rejectUnauthorized: false };
-  const handler = new BidiHandler(socketUrl, bidiReqOpts);
-  handler.connect().then((isConnected) => isConnected && log2.info(`Connected to WebDriver Bidi interface at ${socketUrl}`));
-  return {
-    _bidiHandler: { value: handler },
-    ...Object.values(WebDriverBidiProtocol).map((def) => def.socket).reduce((acc, cur) => {
-      acc[cur.command] = {
-        value: function(...args) {
-          const bidiFn = handler[cur.command];
-          handler.attachClient(this);
-          this.emit(cur.command, args);
-          return bidiFn?.apply(handler, args);
-        }
-      };
-      return acc;
-    }, {})
-  };
-}
-function parseBidiMessage(data) {
-  try {
-    const payload = JSON.parse(data.toString());
-    if (payload.type !== "event") {
-      return;
+var WebDriverRequestError = class extends WebDriverError {
+  constructor(err, url, opts) {
+    let message = err.message;
+    if (err.message === "fetch failed") {
+      message = "Failed to fetch [".concat(opts.method, "] ").concat(url.href, ": please make sure you have a WebDriver compatible server running on ").concat(url.origin);
     }
-    this.emit(payload.method, payload.params);
-  } catch (err) {
-    log2.error(`Failed parse WebDriver Bidi message: ${err.message}`);
+    super(message);
+    __publicField(this, "url");
+    __publicField(this, "opts");
+    __publicField(this, "statusCode");
+    __publicField(this, "body");
+    __publicField(this, "code");
+    this.url = url;
+    this.opts = opts;
+    const errorCode = typeof err.cause === "object" && err.cause && "code" in err.cause && typeof err.cause.code === "string" ? err.cause.code : "code" in err && typeof err.code === "string" ? err.code : void 0;
+    if (errorCode) {
+      this.code = errorCode;
+      this.message = errorCode === "UND_ERR_CONNECT_TIMEOUT" ? 'Request timed out! Consider increasing the "connectionRetryTimeout" option.' : "Request failed with error code " + errorCode;
+    }
+    this.message = this.computeErrorMessage();
   }
-}
-
-// src/constants.ts
-import os from "node:os";
-var DEFAULTS = {
-  /**
-   * protocol of automation driver
-   */
-  protocol: {
-    type: "string",
-    default: "http",
-    match: /(http|https)/
-  },
-  /**
-   * hostname of automation driver
-   */
-  hostname: {
-    type: "string",
-    default: "localhost"
-  },
-  /**
-   * port of automation driver
-   */
-  port: {
-    type: "number"
-  },
-  /**
-   * path to WebDriver endpoints
-   */
-  path: {
-    type: "string",
-    validate: (path2) => {
-      if (!path2.startsWith("/")) {
-        throw new TypeError('The option "path" needs to start with a "/"');
-      }
-      return true;
-    },
-    default: "/"
-  },
-  /**
-   * A key-value store of query parameters to be added to every selenium request
-   */
-  queryParams: {
-    type: "object"
-  },
-  /**
-   * cloud user if applicable
-   */
-  user: {
-    type: "string"
-  },
-  /**
-   * access key to user
-   */
-  key: {
-    type: "string"
-  },
-  /**
-   * capability of WebDriver session
-   */
-  capabilities: {
-    type: "object",
-    required: true
-  },
-  /**
-   * Level of logging verbosity
-   */
-  logLevel: {
-    type: "string",
-    default: "info",
-    match: /(trace|debug|info|warn|error|silent)/
-  },
-  /**
-   * directory for log files
-   */
-  outputDir: {
-    type: "string"
-  },
-  /**
-   * Timeout for any WebDriver request to a driver or grid
-   */
-  connectionRetryTimeout: {
-    type: "number",
-    default: 12e4
-  },
-  /**
-   * Count of request retries to the Selenium server
-   */
-  connectionRetryCount: {
-    type: "number",
-    default: 3
-  },
-  /**
-   * Override default agent
-   */
-  logLevels: {
-    type: "object"
-  },
-  /**
-   * Pass custom headers
-   */
-  headers: {
-    type: "object"
-  },
-  /**
-   * Function transforming the request options before the request is made
-   */
-  transformRequest: {
-    type: "function",
-    default: (requestOptions) => requestOptions
-  },
-  /**
-   * Function transforming the response object after it is received
-   */
-  transformResponse: {
-    type: "function",
-    default: (response) => response
-  },
-  /**
-   * Appium direct connect options server (https://appiumpro.com/editions/86-connecting-directly-to-appium-hosts-in-distributed-environments)
-   * Whether to allow direct connect caps to adjust endpoint details (Appium only)
-   */
-  enableDirectConnect: {
-    type: "boolean",
-    default: true
-  },
-  /**
-   * Whether it requires SSL certificates to be valid in HTTP/s requests
-   * for an environment which cannot get process environment well.
-   */
-  strictSSL: {
-    type: "boolean",
-    default: true
-  },
-  /**
-   * The path to the root of the cache directory. This directory is used to store all drivers that are downloaded
-   * when attempting to start a session.
-   */
-  cacheDir: {
-    type: "string",
-    default: process.env.WEBDRIVER_CACHE_DIR || os.tmpdir()
+};
+var WebDriverResponseError = class _WebDriverResponseError extends WebDriverError {
+  constructor(response, url, opts) {
+    const errorObj = !response.body ? new Error("Response has empty body") : typeof response.body === "string" && response.body.length ? new Error(response.body) : typeof response.body !== "object" ? new Error("Unknown error") : response.body.value || response.body;
+    let errorMessage = errorObj.message || errorObj.error || errorObj.class || "unknown error";
+    if (typeof errorMessage === "string" && errorMessage.includes("invalid locator")) {
+      const requestOptions = opts.body;
+      errorMessage = 'The selector "'.concat(requestOptions.value, '" used with strategy "').concat(requestOptions.using, '" is invalid!');
+    }
+    super(errorMessage);
+    __publicField(this, "url");
+    __publicField(this, "opts");
+    if (errorObj.error) {
+      this.name = errorObj.error;
+    } else if (errorMessage && errorMessage.includes("stale element reference")) {
+      this.name = "stale element reference";
+    } else {
+      this.name = errorObj.name || "WebDriver Error";
+    }
+    Error.captureStackTrace(this, _WebDriverResponseError);
+    this.url = url;
+    this.opts = opts;
+    this.message = this.computeErrorMessage();
   }
 };
-var ELEMENT_KEY = "element-6066-11e4-a52e-4f735466cecf";
-var SHADOW_ELEMENT_KEY = "shadow-6066-11e4-a52e-4f735466cecf";
 
 // package.json
 var package_default = {
   name: "webdriver",
-  version: "9.3.0",
+  version: "9.3.1",
   description: "A Node.js bindings implementation for the W3C WebDriver and Mobile JSONWire Protocol",
   author: "Christian Bromann <mail@bromann.dev>",
   homepage: "https://github.com/webdriverio/webdriverio/tree/main/packages/webdriver",
   license: "MIT",
-  main: "./build/index.cjs",
   type: "module",
+  main: "./build/index.cjs",
   module: "./build/index.js",
   exports: {
     ".": {
       types: "./build/index.d.ts",
-      import: "./build/index.js",
+      browserSource: "./src/browser.js",
+      browser: "./build/index.js",
+      importSource: "./src/node.ts",
+      import: "./build/node.js",
       requireSource: "./src/index.cts",
       require: "./build/index.cjs"
     }
@@ -1283,34 +1573,31 @@ var package_default = {
     "@wdio/types": "workspace:*",
     "@wdio/utils": "workspace:*",
     "deepmerge-ts": "^7.0.3",
+    undici: "^6.20.1",
     ws: "^8.8.0"
   }
 };
 
-// src/request/index.ts
+// src/request/request.ts
 var ERRORS_TO_EXCLUDE_FROM_RETRY = [
   "detached shadow root",
   "move target out of bounds"
 ];
-var COMMANDS_WITHOUT_RETRY = [
-  findCommandPathByName("performActions")
-];
 var DEFAULT_HEADERS = {
   "Content-Type": "application/json; charset=utf-8",
   "Connection": "keep-alive",
   "Accept": "application/json",
   "User-Agent": "webdriver/" + package_default.version
 };
-var log3 = logger3("webdriver");
+var log5 = logger5("webdriver");
 var WebDriverRequest = class extends EventEmitter {
-  #requestTimeout;
-  body;
-  method;
-  endpoint;
-  isHubCommand;
-  requiresSessionId;
   constructor(method, endpoint, body, isHubCommand = false) {
     super();
+    __publicField(this, "body");
+    __publicField(this, "method");
+    __publicField(this, "endpoint");
+    __publicField(this, "isHubCommand");
+    __publicField(this, "requiresSessionId");
     this.body = body;
     this.method = method;
     this.endpoint = endpoint;
@@ -1318,25 +1605,15 @@ var WebDriverRequest = class extends EventEmitter {
     this.requiresSessionId = Boolean(this.endpoint.match(/:sessionId/));
   }
   async makeRequest(options, sessionId) {
-    const { url, requestOptions } = await this._createOptions(options, sessionId);
-    let fullRequestOptions = Object.assign(
-      { method: this.method },
-      requestOptions
-    );
-    if (typeof options.transformRequest === "function") {
-      fullRequestOptions = options.transformRequest(fullRequestOptions);
-    }
-    this.emit("request", fullRequestOptions);
-    return this._request(url, fullRequestOptions, options.transformResponse, options.connectionRetryCount, 0);
-  }
-  async _createOptions(options, sessionId, isBrowser = false) {
-    const controller = new AbortController();
-    this.#requestTimeout = setTimeout(
-      () => controller.abort(),
-      options.connectionRetryTimeout || DEFAULTS.connectionRetryTimeout.default
-    );
+    const { url, requestOptions } = await this.createOptions(options, sessionId);
+    this.emit("request", requestOptions);
+    return this._request(url, requestOptions, options.transformResponse, options.connectionRetryCount, 0);
+  }
+  async createOptions(options, sessionId, isBrowser = false) {
+    const timeout = options.connectionRetryTimeout || DEFAULTS.connectionRetryTimeout.default;
     const requestOptions = {
-      signal: controller.signal
+      method: this.method,
+      signal: AbortSignal.timeout(timeout)
     };
     const requestHeaders = new Headers({
       ...DEFAULT_HEADERS,
@@ -1346,7 +1623,7 @@ var WebDriverRequest = class extends EventEmitter {
     if (this.body && (Object.keys(this.body).length || this.method === "POST")) {
       const contentLength = Buffer.byteLength(JSON.stringify(this.body), "utf8");
       requestOptions.body = this.body;
-      requestHeaders.set("Content-Length", `${contentLength}`);
+      requestHeaders.set("Content-Length", "".concat(contentLength));
     }
     let endpoint = this.endpoint;
     if (this.requiresSessionId) {
@@ -1355,7 +1632,7 @@ var WebDriverRequest = class extends EventEmitter {
       }
       endpoint = endpoint.replace(":sessionId", sessionId);
     }
-    const url = new URL(`${options.protocol}://${options.hostname}:${options.port}${this.isHubCommand ? this.endpoint : path.join(options.path || "", endpoint)}`);
+    const url = new URL("".concat(options.protocol, "://").concat(options.hostname, ":").concat(options.port).concat(this.isHubCommand ? this.endpoint : path.join(options.path || "", endpoint)));
     if (searchParams) {
       url.search = new URLSearchParams(searchParams).toString();
     }
@@ -1363,29 +1640,48 @@ var WebDriverRequest = class extends EventEmitter {
       requestHeaders.set("Authorization", "Basic " + btoa(options.user + ":" + options.key));
     }
     requestOptions.headers = requestHeaders;
-    return { url, requestOptions };
-  }
-  async _libRequest(url, options) {
-    throw new Error("This function must be implemented");
+    return {
+      url,
+      requestOptions: typeof options.transformRequest === "function" ? options.transformRequest(requestOptions) : requestOptions
+    };
   }
-  _libPerformanceNow() {
-    throw new Error("This function must be implemented");
+  async _libRequest(url, opts) {
+    var _a;
+    try {
+      const response = await this.fetch(url, {
+        method: opts.method,
+        body: JSON.stringify(opts.body),
+        headers: opts.headers,
+        signal: opts.signal
+      });
+      const resp = response.clone();
+      return {
+        statusCode: resp.status,
+        body: (_a = await resp.json()) != null ? _a : {}
+      };
+    } catch (err) {
+      if (!(err instanceof Error)) {
+        throw new WebDriverRequestError(
+          new Error("Failed to fetch ".concat(url.href, ": ").concat(err.message || err || "Unknown error")),
+          url,
+          opts
+        );
+      }
+      throw new WebDriverRequestError(err, url, opts);
+    }
   }
   async _request(url, fullRequestOptions, transformResponse, totalRetryCount = 0, retryCount = 0) {
-    log3.info(`[${fullRequestOptions.method}] ${url.href}`);
+    log5.info("[".concat(fullRequestOptions.method, "] ").concat(url.href));
     if (fullRequestOptions.body && Object.keys(fullRequestOptions.body).length) {
-      log3.info("DATA", transformCommandLogResult2(fullRequestOptions.body));
+      log5.info("DATA", transformCommandLogResult2(fullRequestOptions.body));
     }
     const { ...requestLibOptions } = fullRequestOptions;
-    const startTime = this._libPerformanceNow();
+    const startTime = performance.now();
     let response = await this._libRequest(url, requestLibOptions).catch((err) => err);
-    const durationMillisecond = this._libPerformanceNow() - startTime;
-    if (this.#requestTimeout) {
-      clearTimeout(this.#requestTimeout);
-    }
+    const durationMillisecond = performance.now() - startTime;
     const retry = async (error2) => {
       if (retryCount >= totalRetryCount || error2.message.includes("invalid session id")) {
-        log3.error(error2.message);
+        log5.error(error2.message);
         this.emit("response", { error: error2 });
         this.emit("performance", { request: fullRequestOptions, durationMillisecond, success: false, error: error2, retryCount });
         throw error2;
@@ -1396,8 +1692,8 @@ var WebDriverRequest = class extends EventEmitter {
       ++retryCount;
       this.emit("retry", { error: error2, retryCount });
       this.emit("performance", { request: fullRequestOptions, durationMillisecond, success: false, error: error2, retryCount });
-      log3.warn(error2.message);
-      log3.info(`Retrying ${retryCount}/${totalRetryCount}`);
+      log5.warn(error2.message);
+      log5.info("Retrying ".concat(retryCount, "/").concat(totalRetryCount));
       return this._request(url, fullRequestOptions, transformResponse, totalRetryCount, retryCount);
     };
     if (response instanceof Error) {
@@ -1425,7 +1721,7 @@ var WebDriverRequest = class extends EventEmitter {
       return { value: response.body || null };
     }
     if (error.name === "stale element reference") {
-      log3.warn("Request encountered a stale element - terminating request");
+      log5.warn("Request encountered a stale element - terminating request");
       this.emit("response", { error });
       this.emit("performance", { request: fullRequestOptions, durationMillisecond, success: false, error, retryCount });
       throw error;
@@ -1436,310 +1732,29 @@ var WebDriverRequest = class extends EventEmitter {
     return retry(error);
   }
 };
-function findCommandPathByName(commandName) {
-  const command = Object.entries(WebDriverProtocol2).find(
-    ([, command2]) => Object.values(command2).find(
-      (cmd) => cmd.command === commandName
-    )
-  );
-  if (!command) {
-    throw new Error(`Couldn't find command "${commandName}"`);
-  }
-  return command[0];
-}
 
-// src/request/request.ts
-if ("process" in globalThis && globalThis.process.versions?.node) {
-  dns.setDefaultResultOrder("ipv4first");
-}
+// src/request/web.ts
 var FetchRequest = class extends WebDriverRequest {
-  constructor(method, endpoint, body, isHubCommand = false) {
-    super(method, endpoint, body, isHubCommand);
-  }
-  async _libRequest(url, opts) {
-    try {
-      const response = await fetch(url, {
-        method: opts.method,
-        body: JSON.stringify(opts.body),
-        headers: opts.headers,
-        signal: opts.signal
-      });
-      const resp = response.clone();
-      return {
-        statusCode: resp.status,
-        body: await resp.json() ?? {}
-      };
-    } catch (err) {
-      if (!(err instanceof Error)) {
-        throw new WebDriverRequestError(
-          new Error(`Failed to fetch ${url.href}: ${err.message || err || "Unknown error"}`),
-          url,
-          opts
-        );
-      }
-      throw new WebDriverRequestError(err, url, opts);
-    }
-  }
-  _libPerformanceNow() {
-    return performance.now();
+  fetch(url, opts) {
+    return fetch(url, opts);
   }
 };
 
-// src/command.ts
-var log4 = logger4("webdriver");
-var BIDI_COMMANDS = Object.values(WebDriverBidiProtocol2).map((def) => def.socket.command);
-function command_default(method, endpointUri, commandInfo, doubleEncodeVariables = false) {
-  const { command, deprecated, ref, parameters, variables = [], isHubCommand = false } = commandInfo;
-  return async function protocolCommand(...args) {
-    const isBidiCommand = BIDI_COMMANDS.includes(command);
-    let endpoint = endpointUri;
-    const commandParams = [...variables.map((v) => Object.assign(v, {
-      /**
-       * url variables are:
-       */
-      required: true,
-      // always required as they are part of the endpoint
-      type: "string"
-      // have to be always type of string
-    })), ...parameters];
-    const commandUsage = `${command}(${commandParams.map((p) => p.name).join(", ")})`;
-    const moreInfo = `
-
-For more info see ${ref}
-`;
-    const body = {};
-    if (typeof deprecated === "string" && !process.env.DISABLE_WEBDRIVERIO_DEPRECATION_WARNINGS) {
-      const warning = deprecated.replace("This command", `The "${command}" command`);
-      log4.warn(warning);
-      console.warn(`\u26A0\uFE0F [WEBDRIVERIO DEPRECATION NOTICE] ${warning}`);
-    }
-    if (isBidiCommand) {
-      throw new Error(
-        `Failed to execute WebDriver Bidi command "${command}" as no Bidi session was established. Make sure you enable it by setting "webSocketUrl: true" in your capabilities and verify that your environment and browser supports it.`
-      );
-    }
-    const minAllowedParams = commandParams.filter((param) => param.required).length;
-    if (args.length < minAllowedParams || args.length > commandParams.length) {
-      const parameterDescription = commandParams.length ? `
-
-Property Description:
-${commandParams.map((p) => `  "${p.name}" (${p.type}): ${p.description}`).join("\n")}` : "";
-      throw new Error(
-        `Wrong parameters applied for ${command}
-Usage: ${commandUsage}` + parameterDescription + moreInfo
-      );
-    }
-    for (const [it, arg] of Object.entries(args)) {
-      if (isBidiCommand) {
-        break;
-      }
-      const i = parseInt(it, 10);
-      const commandParam = commandParams[i];
-      if (!isValidParameter(arg, commandParam.type)) {
-        if (typeof arg === "undefined" && !commandParam.required) {
-          continue;
-        }
-        const actual = commandParam.type.endsWith("[]") ? `(${(Array.isArray(arg) ? arg : [arg]).map((a) => getArgumentType(a))})[]` : getArgumentType(arg);
-        throw new Error(
-          `Malformed type for "${commandParam.name}" parameter of command ${command}
-Expected: ${commandParam.type}
-Actual: ${actual}` + moreInfo
-        );
-      }
-      if (i < variables.length) {
-        const encodedArg = doubleEncodeVariables ? encodeURIComponent(encodeURIComponent(arg)) : encodeURIComponent(arg);
-        endpoint = endpoint.replace(`:${commandParams[i].name}`, encodedArg);
-        continue;
-      }
-      body[commandParams[i].name] = arg;
-    }
-    const request = new FetchRequest(method, endpoint, body, isHubCommand);
-    request.on("performance", (...args2) => this.emit("request.performance", ...args2));
-    this.emit("command", { command, method, endpoint, body });
-    log4.info("COMMAND", commandCallStructure(command, args));
-    return request.makeRequest(this.options, this.sessionId).then((result) => {
-      if (typeof result.value !== "undefined") {
-        let resultLog = result.value;
-        if (/screenshot|recording/i.test(command) && typeof result.value === "string" && result.value.length > 64) {
-          resultLog = `${result.value.slice(0, 61)}...`;
-        } else if (command === "executeScript" && body.script && body.script.includes("(() => window.__wdioEvents__)")) {
-          resultLog = `[${result.value.length} framework events captured]`;
-        }
-        log4.info("RESULT", resultLog);
-      }
-      this.emit("result", { command, method, endpoint, body, result });
-      if (command === "deleteSession") {
-        const browser = this;
-        browser._bidiHandler?.close();
-        const shutdownDriver = body.deleteSessionOpts?.shutdownDriver !== false;
-        if (shutdownDriver && "wdio:driverPID" in this.capabilities && this.capabilities["wdio:driverPID"]) {
-          log4.info(`Kill driver process with PID ${this.capabilities["wdio:driverPID"]}`);
-          try {
-            const killedSuccessfully = process.kill(this.capabilities["wdio:driverPID"], "SIGKILL");
-            if (!killedSuccessfully) {
-              log4.warn("Failed to kill driver process, manually clean-up might be required");
-            }
-          } catch (err) {
-            log4.warn("Failed to kill driver process", err);
-          }
-          setTimeout(() => {
-            for (const handle of process._getActiveHandles()) {
-              if (handle.servername && handle.servername.includes("edgedl.me")) {
-                handle.destroy();
-              }
-            }
-          }, 10);
-        }
-        if (!process.env.WDIO_WORKER_ID) {
-          logger4.clearLogger();
-        }
-      }
-      return result.value;
-    });
-  };
-}
-
-// src/bidi/localTypes.ts
-var localTypes_exports = {};
-
-// src/bidi/remoteTypes.ts
-var remoteTypes_exports = {};
-
-// src/index.ts
-var log5 = logger5("webdriver");
-var WebDriver = class _WebDriver {
-  static async newSession(options, modifier, userPrototype = {}, customCommandWrapper) {
-    const envLogLevel = process.env.WDIO_LOG_LEVEL;
-    options.logLevel = envLogLevel ?? options.logLevel;
-    const params = validateConfig(DEFAULTS, options);
-    if (params.logLevel && (!options.logLevels || !options.logLevels.webdriver)) {
-      logger5.setLevel("webdriver", params.logLevel);
-    }
-    log5.info("Initiate new session using the WebDriver protocol");
-    const driverProcess = await startWebDriver(params);
-    const requestedCapabilities = { ...params.capabilities };
-    const { sessionId, capabilities } = await startWebDriverSession(params);
-    const environment = sessionEnvironmentDetector({ capabilities, requestedCapabilities });
-    const environmentPrototype = getEnvironmentVars(environment);
-    const protocolCommands = getPrototype(environment);
-    if (driverProcess?.pid) {
-      capabilities["wdio:driverPID"] = driverProcess.pid;
-    }
-    const bidiPrototype = {};
-    if (isBidi(requestedCapabilities, capabilities)) {
-      log5.info(`Register BiDi handler for session with id ${sessionId}`);
-      Object.assign(bidiPrototype, initiateBidi(capabilities.webSocketUrl, options.strictSSL));
-    }
-    const monad = webdriverMonad(
-      { ...params, requestedCapabilities },
-      modifier,
-      {
-        ...protocolCommands,
-        ...environmentPrototype,
-        ...userPrototype,
-        ...bidiPrototype
-      }
-    );
-    const client = monad(sessionId, customCommandWrapper);
-    if (isBidi(requestedCapabilities, capabilities)) {
-      await client._bidiHandler.waitForConnected();
-      client._bidiHandler.socket.on("message", parseBidiMessage.bind(client));
-    }
-    if (params.enableDirectConnect) {
-      setupDirectConnect(client);
-    }
-    return client;
-  }
-  /**
-   * allows user to attach to existing sessions
-   */
-  static attachToSession(options, modifier, userPrototype = {}, commandWrapper) {
-    if (!options || typeof options.sessionId !== "string") {
-      throw new Error("sessionId is required to attach to existing session");
-    }
-    if (options.logLevel) {
-      logger5.setLevel("webdriver", options.logLevel);
-    }
-    options.capabilities = options.capabilities || {};
-    options.isW3C = options.isW3C === false ? false : true;
-    options.protocol = options.protocol || DEFAULTS.protocol.default;
-    options.hostname = options.hostname || DEFAULTS.hostname.default;
-    options.port = options.port || DEFAULTS.port.default;
-    options.path = options.path || DEFAULTS.path.default;
-    const environment = sessionEnvironmentDetector({ capabilities: options.capabilities, requestedCapabilities: options.capabilities });
-    options = Object.assign(environment, options);
-    const environmentPrototype = getEnvironmentVars(options);
-    const protocolCommands = getPrototype(options);
-    const bidiPrototype = {};
-    if (isBidi(options.requestedCapabilities || {}, options.capabilities || {})) {
-      const webSocketUrl = options.capabilities?.webSocketUrl;
-      log5.info(`Register BiDi handler for session with id ${options.sessionId}`);
-      Object.assign(bidiPrototype, initiateBidi(webSocketUrl, options.strictSSL));
-    }
-    const prototype = { ...protocolCommands, ...environmentPrototype, ...userPrototype, ...bidiPrototype };
-    const monad = webdriverMonad(options, modifier, prototype);
-    const client = monad(options.sessionId, commandWrapper);
-    if (isBidi(options.requestedCapabilities || {}, options.capabilities || {})) {
-      client._bidiHandler?.socket.on("message", parseBidiMessage.bind(client));
-    }
-    return client;
-  }
-  /**
-   * Changes The instance session id and browser capabilities for the new session
-   * directly into the passed in browser object
-   *
-   * @param   {object} instance  the object we get from a new browser session.
-   * @returns {string}           the new session id of the browser
-   */
-  static async reloadSession(instance, newCapabilities) {
-    const capabilities = newCapabilities ? newCapabilities : Object.assign({}, instance.requestedCapabilities);
-    let params = { ...instance.options, capabilities };
-    for (const prop of ["protocol", "hostname", "port", "path", "queryParams", "user", "key"]) {
-      if (prop in capabilities) {
-        params = { ...params, [prop]: capabilities[prop] };
-        delete capabilities[prop];
-      }
-    }
-    let driverProcess;
-    if (params.hostname === "localhost" && newCapabilities?.browserName) {
-      delete params.port;
-      delete params.hostname;
-      driverProcess = await startWebDriver(params);
-    }
-    const { sessionId, capabilities: newSessionCapabilities } = await startWebDriverSession(params);
-    if (driverProcess?.pid) {
-      newSessionCapabilities["wdio:driverPID"] = driverProcess.pid;
-    }
-    for (const prop of ["protocol", "hostname", "port", "path", "queryParams", "user", "key"]) {
-      if (prop in params) {
-        instance.options[prop] = params[prop];
-      }
-    }
-    for (const prop in instance.requestedCapabilities) {
-      delete instance.requestedCapabilities[prop];
-    }
-    const driverPid = instance.capabilities["wdio:driverPID"];
-    instance.sessionId = sessionId;
-    instance.capabilities = newSessionCapabilities;
-    instance.capabilities["wdio:driverPID"] = driverPid;
-    Object.assign(instance.requestedCapabilities, capabilities);
-    if (isBidi(instance.requestedCapabilities || {}, instance.capabilities || {})) {
-      const bidiReqOpts = instance.options.strictSSL ? {} : { rejectUnauthorized: false };
-      await instance._bidiHandler?.reconnect(newSessionCapabilities.webSocketUrl, bidiReqOpts);
-    }
-    return sessionId;
-  }
-  static get WebDriver() {
-    return _WebDriver;
-  }
+// src/browser.ts
+var browser_default = WebDriver;
+environment.value = {
+  Request: FetchRequest,
+  Socket: BrowserSocket,
+  variables: {}
 };
 export {
   BidiHandler,
   DEFAULTS,
   ELEMENT_KEY,
   SHADOW_ELEMENT_KEY,
+  WebDriver,
   command_default as command,
-  WebDriver as default,
+  browser_default as default,
   getEnvironmentVars,
   getPrototype,
   initiateBidi,