@wdio/browserstack-service 9.27.1 → 9.28.0

package/build/index.js

@@ -23,7 +23,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@wdio/browserstack-service",
-      version: "9.27.0",
+      version: "9.27.2",
       description: "WebdriverIO service for better Browserstack integration",
       author: "Adam Bjerstedt <abjerstedt@gmail.com>",
       homepage: "https://github.com/webdriverio/webdriverio/tree/main/packages/wdio-browserstack-service",
@@ -70,7 +70,6 @@ var init_package = __esm({
         "browserstack-local": "^1.5.1",
         chalk: "^5.3.0",
         "csv-writer": "^1.6.0",
-        "formdata-node": "5.0.1",
         "git-repo-info": "^2.1.1",
         gitconfiglocal: "^2.1.0",
         glob: "^11.0.0",
@@ -98,7 +97,7 @@ var init_package = __esm({
 });
 
 // src/constants.ts
-var bstackServiceVersion, BROWSER_DESCRIPTION, VALID_APP_EXTENSION, DEFAULT_OPTIONS, consoleHolder, APP_ALLY_ISSUES_ENDPOINT, APP_ALLY_ISSUES_SUMMARY_ENDPOINT, DATA_EVENT_ENDPOINT, DATA_BATCH_ENDPOINT, DATA_SCREENSHOT_ENDPOINT, DATA_BATCH_SIZE, DATA_BATCH_INTERVAL, DEFAULT_WAIT_TIMEOUT_FOR_PENDING_UPLOADS, DEFAULT_WAIT_INTERVAL_FOR_PENDING_UPLOADS, BSTACK_SERVICE_VERSION, NOT_ALLOWED_KEYS_IN_CAPS, LOGS_FILE, CLI_DEBUG_LOGS_FILE, UPLOAD_LOGS_ENDPOINT, PERCY_LOGS_FILE, PERCY_DOM_CHANGING_COMMANDS_ENDPOINTS, CAPTURE_MODES, LOG_KIND_USAGE_MAP, SUPPORTED_BROWSERS_FOR_AI, TCG_URL, TCG_INFO, SMART_SELECTION_MODE_RELEVANT_FIRST, SMART_SELECTION_MODE_RELEVANT_ONLY, BROWSERSTACK_TESTHUB_JWT, BSTACK_TCG_AUTH_RESULT, TESTOPS_SCREENSHOT_ENV, BROWSERSTACK_TESTHUB_UUID, TEST_ANALYTICS_ID, PERF_MEASUREMENT_ENV, RERUN_TESTS_ENV, RERUN_ENV, TESTOPS_BUILD_COMPLETED_ENV, BROWSERSTACK_PERCY, BROWSERSTACK_ACCESSIBILITY, BROWSERSTACK_OBSERVABILITY, BROWSERSTACK_TEST_REPORTING, TEST_REPORTING_PROJECT_NAME, MAX_GIT_META_DATA_SIZE_IN_BYTES, GIT_META_DATA_TRUNCATED, CLI_STOP_TIMEOUT, WDIO_NAMING_PREFIX, UPDATED_CLI_ENDPOINT;
+var bstackServiceVersion, BROWSER_DESCRIPTION, VALID_APP_EXTENSION, DEFAULT_OPTIONS, consoleHolder, APP_ALLY_ISSUES_ENDPOINT, APP_ALLY_ISSUES_SUMMARY_ENDPOINT, DATA_EVENT_ENDPOINT, DATA_BATCH_ENDPOINT, DATA_SCREENSHOT_ENDPOINT, DATA_BATCH_SIZE, DATA_BATCH_INTERVAL, DEFAULT_WAIT_TIMEOUT_FOR_PENDING_UPLOADS, DEFAULT_WAIT_INTERVAL_FOR_PENDING_UPLOADS, BSTACK_SERVICE_VERSION, NOT_ALLOWED_KEYS_IN_CAPS, BROWSERSTACK_TEST_PLAN_ID, LOGS_FILE, CLI_DEBUG_LOGS_FILE, UPLOAD_LOGS_ENDPOINT, PERCY_LOGS_FILE, PERCY_DOM_CHANGING_COMMANDS_ENDPOINTS, CAPTURE_MODES, LOG_KIND_USAGE_MAP, SUPPORTED_BROWSERS_FOR_AI, SUPPORTED_BROWSERS_FOR_ACCESSIBILITY, MIN_BROWSER_VERSIONS_A11Y, MIN_BROWSER_VERSIONS_A11Y_NON_BSTACK, TCG_URL, TCG_INFO, SMART_SELECTION_MODE_RELEVANT_FIRST, SMART_SELECTION_MODE_RELEVANT_ONLY, BROWSERSTACK_TESTHUB_JWT, BSTACK_TCG_AUTH_RESULT, TESTOPS_SCREENSHOT_ENV, BROWSERSTACK_TESTHUB_UUID, TEST_ANALYTICS_ID, PERF_MEASUREMENT_ENV, RERUN_TESTS_ENV, RERUN_ENV, TESTOPS_BUILD_COMPLETED_ENV, BROWSERSTACK_PERCY, BROWSERSTACK_ACCESSIBILITY, BROWSERSTACK_OBSERVABILITY, BROWSERSTACK_TEST_REPORTING, TEST_REPORTING_PROJECT_NAME, MAX_GIT_META_DATA_SIZE_IN_BYTES, GIT_META_DATA_TRUNCATED, CLI_STOP_TIMEOUT, BINARY_BUSY_ERROR_CODES, MAX_SPAWN_RETRIES, SPAWN_RETRY_DELAY_MS, WDIO_NAMING_PREFIX, UPDATED_CLI_ENDPOINT;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
@@ -122,8 +121,7 @@ var init_constants = __esm({
     DEFAULT_OPTIONS = {
       setSessionName: true,
       setSessionStatus: true,
-      testObservability: true,
-      accessibility: false
+      testObservability: true
     };
     consoleHolder = Object.assign({}, console);
     APP_ALLY_ISSUES_ENDPOINT = "api/v1/issues";
@@ -136,7 +134,8 @@ var init_constants = __esm({
     DEFAULT_WAIT_TIMEOUT_FOR_PENDING_UPLOADS = 5e3;
     DEFAULT_WAIT_INTERVAL_FOR_PENDING_UPLOADS = 100;
     BSTACK_SERVICE_VERSION = bstackServiceVersion;
-    NOT_ALLOWED_KEYS_IN_CAPS = ["includeTagsInTestingScope", "excludeTagsInTestingScope"];
+    NOT_ALLOWED_KEYS_IN_CAPS = ["includeTagsInTestingScope", "excludeTagsInTestingScope", "testManagementOptions"];
+    BROWSERSTACK_TEST_PLAN_ID = "BROWSERSTACK_TEST_PLAN_ID";
     LOGS_FILE = "logs/bstack-wdio-service.log";
     CLI_DEBUG_LOGS_FILE = "log/sdk-cli-debug.log";
     UPLOAD_LOGS_ENDPOINT = "client-logs/upload";
@@ -158,6 +157,17 @@ var init_constants = __esm({
       "HTTP": "http"
     };
     SUPPORTED_BROWSERS_FOR_AI = ["chrome", "microsoftedge", "firefox"];
+    SUPPORTED_BROWSERS_FOR_ACCESSIBILITY = ["chrome", "chromefortesting", "safari"];
+    MIN_BROWSER_VERSIONS_A11Y = {
+      chrome: 95,
+      chromefortesting: 141,
+      safari: 18.4
+    };
+    MIN_BROWSER_VERSIONS_A11Y_NON_BSTACK = {
+      chrome: 100,
+      chromefortesting: 141,
+      safari: 18.4
+    };
     TCG_URL = "https://tcg.browserstack.com";
     TCG_INFO = {
       tcgRegion: "use",
@@ -182,6 +192,9 @@ var init_constants = __esm({
     MAX_GIT_META_DATA_SIZE_IN_BYTES = 64 * 1024;
     GIT_META_DATA_TRUNCATED = "...[TRUNCATED]";
     CLI_STOP_TIMEOUT = 5e3;
+    BINARY_BUSY_ERROR_CODES = ["ETXTBSY", "EBUSY"];
+    MAX_SPAWN_RETRIES = 3;
+    SPAWN_RETRY_DELAY_MS = 1e3;
     WDIO_NAMING_PREFIX = "WebdriverIO-";
     UPDATED_CLI_ENDPOINT = "sdk/v1/update_cli";
   }
@@ -266,34 +279,155 @@ var init_apiUtils = __esm({
   }
 });
 
+// src/caCert.ts
+import { setGlobalDispatcher, Agent } from "undici";
+import tls from "node:tls";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+function derToPem(der) {
+  const b64 = der.toString("base64").replace(/(.{64})/g, "$1\n");
+  return `-----BEGIN CERTIFICATE-----
+${b64}${b64.endsWith("\n") ? "" : "\n"}-----END CERTIFICATE-----
+`;
+}
+function loadCaCertsAsPem(buf) {
+  if (buf.includes("-----BEGIN CERTIFICATE-----")) {
+    return buf.toString("utf8").match(/-----BEGIN CERTIFICATE-----[\s\S]*?-----END CERTIFICATE-----/g) || [];
+  }
+  return [derToPem(buf)];
+}
+function resolveCaCertPath(options) {
+  let p = process.env.BROWSERSTACK_EXTRA_CA_CERTS;
+  if ((!p || !p.trim()) && options?.proxyCaCertificate) {
+    p = options.proxyCaCertificate;
+  }
+  if (!p || !String(p).trim()) {
+    return void 0;
+  }
+  p = String(p).trim();
+  try {
+    if (fs.existsSync(p) && fs.statSync(p).isFile()) {
+      return p;
+    }
+    BStackLogger.warn(`proxyCaCertificate: path does not exist or is not a file, falling back to system trust store: ${p}`);
+  } catch (e) {
+    BStackLogger.warn(`proxyCaCertificate: failed to stat cert path ${p}: ${e.message}`);
+  }
+  return void 0;
+}
+function getMergedCa() {
+  return mergedCa;
+}
+function configureCaCertificate(options) {
+  if (configured) {
+    return;
+  }
+  try {
+    const certPath = resolveCaCertPath(options);
+    if (!certPath) {
+      return;
+    }
+    const buf = fs.readFileSync(certPath);
+    const isPem = buf.includes("-----BEGIN CERTIFICATE-----");
+    const pemCerts = loadCaCertsAsPem(buf);
+    if (!pemCerts.length) {
+      BStackLogger.warn(`proxyCaCertificate: no certificate found in ${certPath}; falling back to system trust store.`);
+      return;
+    }
+    mergedCa = [...tls.rootCertificates, ...pemCerts];
+    setGlobalDispatcher(new Agent({ connect: { ca: mergedCa } }));
+    configured = true;
+    BStackLogger.info(`proxyCaCertificate: trusting custom CA from ${certPath} (merged with system roots).`);
+    try {
+      if (!process.env.NODE_EXTRA_CA_CERTS) {
+        let nodeExtra = certPath;
+        if (!isPem) {
+          const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "browserstack_sdk_ca_"));
+          nodeExtra = path.join(tmpDir, "ca.pem");
+          const fd = fs.openSync(nodeExtra, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | (fs.constants.O_NOFOLLOW || 0), 384);
+          try {
+            fs.writeFileSync(fd, pemCerts.join(""));
+          } finally {
+            fs.closeSync(fd);
+          }
+        }
+        process.env.NODE_EXTRA_CA_CERTS = nodeExtra;
+      }
+    } catch (e) {
+      BStackLogger.warn(`proxyCaCertificate: CA is trusted for this process, but exporting NODE_EXTRA_CA_CERTS for detached child processes failed (children may not trust the custom CA): ${e.message}`);
+    }
+  } catch (e) {
+    BStackLogger.warn(`proxyCaCertificate: setup failed, falling back to system trust store: ${e.message}`);
+  }
+}
+var mergedCa, configured;
+var init_caCert = __esm({
+  "src/caCert.ts"() {
+    "use strict";
+    init_bstackLogger();
+    configured = false;
+  }
+});
+
 // src/fetchWrapper.ts
-import { fetch as undiciFetch, ProxyAgent } from "undici";
-async function fetchWrap(input, init) {
-  const res = await _fetch(input, init);
+import { fetch as undiciFetch, ProxyAgent, Agent as Agent2 } from "undici";
+function getDispatcher(proxyUrl, connectTimeoutMs) {
+  const ca = getMergedCa();
+  const key = `${proxyUrl ?? "direct"}:${connectTimeoutMs ?? "default"}:${ca ? "ca" : "noca"}`;
+  let dispatcher = dispatcherCache.get(key);
+  if (!dispatcher) {
+    const connect = {};
+    if (connectTimeoutMs) {
+      connect.timeout = connectTimeoutMs;
+    }
+    if (proxyUrl) {
+      dispatcher = new ProxyAgent({ uri: proxyUrl, connect, ...ca ? { requestTls: { ca } } : {} });
+    } else {
+      if (ca) {
+        connect.ca = ca;
+      }
+      dispatcher = new Agent2({ connect });
+    }
+    dispatcherCache.set(key, dispatcher);
+  }
+  return dispatcher;
+}
+async function fetchWrap(input, init, options) {
+  const res = await _fetch(input, init, options);
   if (!res.ok) {
     throw new ResponseError(`Error response from server ${res.status}:  ${await res.text()}`, res);
   }
   return res;
 }
-function _fetch(input, init) {
+function _fetch(input, init, options) {
+  const connectTimeoutMs = options?.connectTimeoutMs;
   const proxyUrl = process.env.HTTP_PROXY || process.env.HTTPS_PROXY;
   if (proxyUrl) {
     const noProxy = process.env.NO_PROXY && process.env.NO_PROXY.trim() ? process.env.NO_PROXY.trim().split(/[\s,;]+/) : [];
     const request = new Request(input);
     const url3 = new URL(request.url);
     if (!noProxy.some((str) => url3.hostname.endsWith(str))) {
+      const dispatcher = getDispatcher(proxyUrl, connectTimeoutMs);
       return undiciFetch(
         request.url,
-        { ...init, dispatcher: new ProxyAgent(proxyUrl) }
+        { ...init, dispatcher }
       );
     }
   }
+  if (connectTimeoutMs) {
+    return undiciFetch(
+      new Request(input).url,
+      { ...init, dispatcher: getDispatcher(void 0, connectTimeoutMs) }
+    );
+  }
   return fetch(input, init);
 }
-var ResponseError;
+var ResponseError, dispatcherCache;
 var init_fetchWrapper = __esm({
   "src/fetchWrapper.ts"() {
     "use strict";
+    init_caCert();
     ResponseError = class extends Error {
       response;
       constructor(message, res) {
@@ -301,6 +435,7 @@ var init_fetchWrapper = __esm({
         this.response = res;
       }
     };
+    dispatcherCache = /* @__PURE__ */ new Map();
   }
 });
 
@@ -458,26 +593,26 @@ var init_constants2 = __esm({
 });
 
 // src/cli/cliLogger.ts
-import path from "node:path";
-import fs from "node:fs";
+import path2 from "node:path";
+import fs2 from "node:fs";
 import chalk from "chalk";
 import logger from "@wdio/logger";
-var log, BStackLogger;
+var log, BStackLogger2;
 var init_cliLogger = __esm({
   "src/cli/cliLogger.ts"() {
     "use strict";
     init_constants();
     init_util();
     log = logger("@wdio/browserstack-service/cli");
-    BStackLogger = class {
-      static logFilePath = path.join(process.cwd(), LOGS_FILE);
-      static logFolderPath = path.join(process.cwd(), "logs");
+    BStackLogger2 = class {
+      static logFilePath = path2.join(process.cwd(), LOGS_FILE);
+      static logFolderPath = path2.join(process.cwd(), "logs");
       static logFileStream;
       static logToFile(logMessage, logLevel) {
         try {
           if (!this.logFileStream) {
             this.ensureLogsFolder();
-            this.logFileStream = fs.createWriteStream(this.logFilePath, { flags: "a" });
+            this.logFileStream = fs2.createWriteStream(this.logFilePath, { flags: "a" });
           }
           if (this.logFileStream && this.logFileStream.writable) {
             this.logFileStream.write(this.formatLog(logMessage, logLevel));
@@ -521,13 +656,13 @@ var init_cliLogger = __esm({
         this.logFileStream = null;
       }
       static clearLogFile() {
-        if (fs.existsSync(this.logFilePath)) {
-          fs.truncateSync(this.logFilePath);
+        if (fs2.existsSync(this.logFilePath)) {
+          fs2.truncateSync(this.logFilePath);
         }
       }
       static ensureLogsFolder() {
-        if (!fs.existsSync(this.logFolderPath)) {
-          fs.mkdirSync(this.logFolderPath);
+        if (!fs2.existsSync(this.logFolderPath)) {
+          fs2.mkdirSync(this.logFolderPath);
         }
       }
     };
@@ -585,16 +720,16 @@ var init_testFrameworkConstants = __esm({
 });
 
 // src/cli/cliUtils.ts
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 import fsp from "node:fs/promises";
 import { platform, arch, homedir } from "node:os";
-import path2 from "node:path";
+import path3 from "node:path";
 import util, { promisify } from "node:util";
 import { exec } from "node:child_process";
 import { Readable } from "node:stream";
 import yauzl from "yauzl";
 import { threadId } from "node:worker_threads";
-var CLI_LOCK_TIMEOUT_MS, CLI_LOCK_POLL_MS, CLI_DOWNLOAD_TIMEOUT_MS, CLI_DOWNLOAD_TMP_PREFIX, CLI_DOWNLOAD_TMP_SUFFIX, CLIUtils;
+var CLI_LOCK_TIMEOUT_MS, CLI_LOCK_POLL_MS, CLI_DOWNLOAD_TIMEOUT_MS, CLI_DOWNLOAD_TMP_PREFIX, CLI_DOWNLOAD_TMP_SUFFIX, CLI_CONNECT_TIMEOUT_MS, CLI_FETCH_MAX_ATTEMPTS, CLI_FETCH_RETRY_BASE_DELAY_MS, CLIUtils;
 var init_cliUtils = __esm({
   "src/cli/cliUtils.ts"() {
     "use strict";
@@ -611,6 +746,9 @@ var init_cliUtils = __esm({
     CLI_DOWNLOAD_TIMEOUT_MS = 5 * 60 * 1e3;
     CLI_DOWNLOAD_TMP_PREFIX = "downloaded_file_";
     CLI_DOWNLOAD_TMP_SUFFIX = ".zip";
+    CLI_CONNECT_TIMEOUT_MS = Number(process.env.BROWSERSTACK_CLI_CONNECT_TIMEOUT_MS) || 60 * 1e3;
+    CLI_FETCH_MAX_ATTEMPTS = 3;
+    CLI_FETCH_RETRY_BASE_DELAY_MS = 500;
     CLIUtils = class _CLIUtils {
       static automationFrameworkDetail = {};
       static testFrameworkDetail = {};
@@ -635,6 +773,7 @@ var init_cliUtils = __esm({
           modifiedOpts.browserStackLocalOptions = modifiedOpts.opts;
           delete modifiedOpts.opts;
         }
+        delete modifiedOpts.testManagementOptions;
         modifiedOpts.testContextOptions = {
           skipSessionName: isFalse(modifiedOpts.setSessionName),
           skipSessionStatus: isFalse(modifiedOpts.setSessionStatus),
@@ -653,6 +792,8 @@ var init_cliUtils = __esm({
           options.testObservability
         );
         const observabilityOptions = options.testObservabilityOptions || {};
+        const testManagementOptions = options.testManagementOptions || {};
+        const testPlanId = typeof testManagementOptions.testPlanId === "string" ? testManagementOptions.testPlanId.trim() : "";
         const binconfig = {
           userName: observabilityOptions.user || config.user,
           accessKey: observabilityOptions.key || config.key,
@@ -664,26 +805,26 @@ var init_cliUtils = __esm({
         binconfig.buildName = observabilityOptions.buildName || binconfig.buildName;
         binconfig.projectName = observabilityOptions.projectName || binconfig.projectName;
         binconfig.buildTag = this.getObservabilityBuildTags(observabilityOptions, buildTag) || [];
-        let caps = capabilities;
-        if (capabilities && !Array.isArray(capabilities)) {
-          caps = [capabilities];
-        }
-        if (Array.isArray(caps)) {
-          for (const cap of caps) {
-            const platform4 = {};
-            const capability = cap;
-            Object.keys(capability).filter((key) => key !== "bstack:options").forEach((key) => {
-              platform4[key] = capability[key];
+        if (testPlanId.length > 0) {
+          binconfig.testManagementOptions = {
+            testPlanId
+          };
+        }
+        const caps = Array.isArray(capabilities) ? capabilities : [capabilities];
+        for (const cap of caps) {
+          const platform4 = {};
+          const capability = cap;
+          Object.keys(capability).filter((key) => key !== "bstack:options").forEach((key) => {
+            platform4[key] = capability[key];
+          });
+          if (capability["bstack:options"]) {
+            Object.keys(
+              capability["bstack:options"]
+            ).forEach((key) => {
+              platform4[key] = capability["bstack:options"][key];
             });
-            if (capability["bstack:options"]) {
-              Object.keys(
-                capability["bstack:options"]
-              ).forEach((key) => {
-                platform4[key] = capability["bstack:options"][key];
-              });
-            }
-            binconfig.platforms.push(platform4);
           }
+          binconfig.platforms.push(platform4);
         }
         return JSON.stringify(binconfig);
       }
@@ -694,10 +835,10 @@ var init_cliUtils = __esm({
         return "ECMAScript";
       }
       static async setupCliPath(config) {
-        BStackLogger.debug("Configuring Cli path.");
+        BStackLogger2.debug("Configuring Cli path.");
         const developmentBinaryPath = process.env.SDK_CLI_BIN_PATH || null;
         if (!isNullOrEmpty(developmentBinaryPath)) {
-          BStackLogger.debug(`Development Cli Path: ${developmentBinaryPath}`);
+          BStackLogger2.debug(`Development Cli Path: ${developmentBinaryPath}`);
           return developmentBinaryPath;
         }
         try {
@@ -711,10 +852,10 @@ var init_cliUtils = __esm({
             cliDir,
             config
           );
-          BStackLogger.debug(`Resolved binary path: ${finalBinaryPath}`);
+          BStackLogger2.debug(`Resolved binary path: ${finalBinaryPath}`);
           return finalBinaryPath;
         } catch (err) {
-          BStackLogger.debug(
+          BStackLogger2.warn(
             `Error in setting up cli path directory, Exception: ${util.format(err)}`
           );
         }
@@ -722,18 +863,18 @@ var init_cliUtils = __esm({
       }
       static async checkAndUpdateCli(existingCliPath, cliDir, config) {
         if (process.env.BROWSERSTACK_TESTHUB_JWT) {
-          BStackLogger.debug(
+          BStackLogger2.debug(
             `Worker process detected, skipping CLI update. Using existing: ${existingCliPath}`
           );
-          if (existingCliPath && fs2.existsSync(existingCliPath)) {
+          if (existingCliPath && fs3.existsSync(existingCliPath)) {
             return existingCliPath;
           }
-          BStackLogger.warn(
+          BStackLogger2.warn(
             "Worker process has no existing CLI binary, attempting download as fallback."
           );
         }
         PerformanceTester.start(EVENTS.SDK_CLI_CHECK_UPDATE);
-        BStackLogger.info(`Current CLI Path Found: ${existingCliPath}`);
+        BStackLogger2.info(`Current CLI Path Found: ${existingCliPath}`);
         const queryParams = {
           sdk_version: _CLIUtils.getSdkVersion(),
           os: platform(),
@@ -742,18 +883,29 @@ var init_cliUtils = __esm({
           sdk_language: this.getSdkLanguage()
         };
         if (!isNullOrEmpty(existingCliPath)) {
-          queryParams.cli_version = await this.runShellCommand(
+          if (this.isBinaryBusy(existingCliPath)) {
+            BStackLogger2.warn(`Existing binary is currently in use, skipping update: ${existingCliPath}`);
+            PerformanceTester.end(EVENTS.SDK_CLI_CHECK_UPDATE);
+            return existingCliPath;
+          }
+          const version3 = await this.runShellCommand(
             `${existingCliPath} version`
           );
+          if (version3.toLowerCase().includes("text file busy")) {
+            BStackLogger2.warn(`Binary busy during version check, skipping update: ${existingCliPath}`);
+            PerformanceTester.end(EVENTS.SDK_CLI_CHECK_UPDATE);
+            return existingCliPath;
+          }
+          queryParams.cli_version = version3;
         }
         const response = await this.requestToUpdateCLI(queryParams, config);
         if (nestedKeyValue(response, ["updated_cli_version"])) {
-          BStackLogger.debug(
+          BStackLogger2.debug(
             `Need to update binary, current binary version: ${queryParams.cli_version}`
           );
           const browserStackBinaryUrl = process.env.BROWSERSTACK_BINARY_URL || null;
           if (!isNullOrEmpty(browserStackBinaryUrl)) {
-            BStackLogger.debug(
+            BStackLogger2.debug(
               `Using BROWSERSTACK_BINARY_URL: ${browserStackBinaryUrl}`
             );
             response.url = browserStackBinaryUrl;
@@ -774,13 +926,13 @@ var init_cliUtils = __esm({
           if (isNullOrEmpty(writableDir)) {
             throw new Error("No writable directory available for the CLI");
           }
-          const cliDirPath = path2.join(writableDir, "cli");
-          if (!fs2.existsSync(cliDirPath)) {
+          const cliDirPath = path3.join(writableDir, "cli");
+          if (!fs3.existsSync(cliDirPath)) {
             createDir(cliDirPath);
           }
           return cliDirPath;
         } catch (err) {
-          BStackLogger.error(
+          BStackLogger2.error(
             `Error in getting writable directory, writableDir=${util.format(err)}`
           );
           return "";
@@ -789,39 +941,39 @@ var init_cliUtils = __esm({
       static getWritableDir() {
         const writableDirOptions = [
           process.env.BROWSERSTACK_FILES_DIR,
-          path2.join(homedir(), ".browserstack"),
-          path2.join("tmp", ".browserstack")
+          path3.join(homedir(), ".browserstack"),
+          path3.join("tmp", ".browserstack")
         ];
-        for (const path21 of writableDirOptions) {
-          if (isNullOrEmpty(path21)) {
+        for (const path22 of writableDirOptions) {
+          if (isNullOrEmpty(path22)) {
             continue;
           }
           try {
-            if (fs2.existsSync(path21)) {
-              BStackLogger.debug(`File ${path21} already exist`);
-              if (!isWritable(path21)) {
-                BStackLogger.debug(`Giving write permission to ${path21}`);
-                const success = setReadWriteAccess(path21);
+            if (fs3.existsSync(path22)) {
+              BStackLogger2.debug(`File ${path22} already exist`);
+              if (!isWritable(path22)) {
+                BStackLogger2.debug(`Giving write permission to ${path22}`);
+                const success = setReadWriteAccess(path22);
                 if (!isTrue(success)) {
-                  BStackLogger.warn(
-                    `Unable to provide write permission to ${path21}`
+                  BStackLogger2.warn(
+                    `Unable to provide write permission to ${path22}`
                   );
                 }
               }
             } else {
-              BStackLogger.debug(`File does not exist: ${path21}`);
-              createDir(path21);
-              BStackLogger.debug(`Giving write permission to ${path21}`);
-              const success = setReadWriteAccess(path21);
+              BStackLogger2.debug(`File does not exist: ${path22}`);
+              createDir(path22);
+              BStackLogger2.debug(`Giving write permission to ${path22}`);
+              const success = setReadWriteAccess(path22);
               if (!isTrue(success)) {
-                BStackLogger.warn(
-                  `Unable to provide write permission to ${path21}`
+                BStackLogger2.warn(
+                  `Unable to provide write permission to ${path22}`
                 );
               }
             }
-            return path21;
+            return path22;
           } catch (err) {
-            BStackLogger.error(
+            BStackLogger2.error(
               `Unable to get writable directory, exception ${util.format(err)}`
             );
           }
@@ -830,16 +982,16 @@ var init_cliUtils = __esm({
       }
       static getExistingCliPath(cliDir) {
         try {
-          if (!fs2.existsSync(cliDir) || !fs2.statSync(cliDir).isDirectory()) {
+          if (!fs3.existsSync(cliDir) || !fs3.statSync(cliDir).isDirectory()) {
             return "";
           }
-          const allBinaries = fs2.readdirSync(cliDir).map((file) => path2.join(cliDir, file)).filter(
-            (filePath) => fs2.statSync(filePath).isFile() && path2.basename(filePath).startsWith("binary-")
+          const allBinaries = fs3.readdirSync(cliDir).map((file) => path3.join(cliDir, file)).filter(
+            (filePath) => fs3.statSync(filePath).isFile() && path3.basename(filePath).startsWith("binary-")
           );
           if (allBinaries.length > 0) {
             const latestBinary = allBinaries.map((filePath) => ({
               filePath,
-              mtime: fs2.statSync(filePath).mtime
+              mtime: fs3.statSync(filePath).mtime
             })).reduce(
               (latest, current) => {
                 if (!latest || !latest.mtime) {
@@ -856,10 +1008,62 @@ var init_cliUtils = __esm({
           }
           return "";
         } catch (err) {
-          BStackLogger.error(`Error while reading CLI path: ${util.format(err)}`);
+          BStackLogger2.error(`Error while reading CLI path: ${util.format(err)}`);
           return "";
         }
       }
+      static isBinaryBusy(binaryPath) {
+        if (isNullOrEmpty(binaryPath)) {
+          return false;
+        }
+        if (platform() === "darwin") {
+          return false;
+        }
+        if (!fs3.existsSync(binaryPath)) {
+          return false;
+        }
+        try {
+          const fd = fs3.openSync(binaryPath, "r+");
+          fs3.closeSync(fd);
+          return false;
+        } catch (err) {
+          if (BINARY_BUSY_ERROR_CODES.includes(err.code)) {
+            BStackLogger2.debug(`Binary is busy: ${binaryPath}`);
+            return true;
+          }
+          BStackLogger2.debug(`Error checking if binary is busy: ${err.message}`);
+          return false;
+        }
+      }
+      /**
+       * fetch wrapper for CLI network calls that (a) raises undici's connect timeout
+       * above the non-overridable 10s default of global fetch and (b) retries a few
+       * times with linear backoff on transient connection failures. Both are needed
+       * for reliability in constrained CI/containerised networks (SDK-6152).
+       */
+      static fetchWithRetry = async (input, init, label) => {
+        let lastError;
+        for (let attempt = 1; attempt <= CLI_FETCH_MAX_ATTEMPTS; attempt++) {
+          try {
+            return await _fetch(input, init, { connectTimeoutMs: CLI_CONNECT_TIMEOUT_MS });
+          } catch (err) {
+            lastError = err;
+            const reason = (
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              err?.cause?.code || err?.code || err?.message
+            );
+            BStackLogger2.warn(
+              `${label} attempt ${attempt}/${CLI_FETCH_MAX_ATTEMPTS} failed: ${reason}`
+            );
+            if (attempt < CLI_FETCH_MAX_ATTEMPTS) {
+              await new Promise(
+                (resolve) => setTimeout(resolve, CLI_FETCH_RETRY_BASE_DELAY_MS * attempt)
+              );
+            }
+          }
+        }
+        throw lastError;
+      };
       static requestToUpdateCLI = async (queryParams, config) => {
         const params = new URLSearchParams(queryParams);
         const requestInit = {
@@ -868,12 +1072,13 @@ var init_cliUtils = __esm({
             Authorization: `Basic ${Buffer.from(`${getBrowserStackUser(config)}:${getBrowserStackKey(config)}`).toString("base64")}`
           }
         };
-        const response = await _fetch(
+        const response = await this.fetchWithRetry(
           `${APIUtils.BROWSERSTACK_AUTOMATE_API_URL}/${UPDATED_CLI_ENDPOINT}?${params.toString()}`,
-          requestInit
+          requestInit,
+          "update_cli request"
         );
         const jsonResponse = await response.json();
-        BStackLogger.debug(`response ${JSON.stringify(jsonResponse)}`);
+        BStackLogger2.debug(`response ${JSON.stringify(jsonResponse)}`);
         return jsonResponse;
       };
       static runShellCommand(cmdCommand, workingDir = "") {
@@ -895,11 +1100,11 @@ var init_cliUtils = __esm({
         });
       }
       static downloadLatestBinary = async (binDownloadUrl, cliDir) => {
-        const lockPath = path2.join(cliDir, "download.lock");
+        const lockPath = path3.join(cliDir, "download.lock");
         const sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
         const parseLockFile = () => {
           try {
-            const content = fs2.readFileSync(lockPath, "utf8").trim();
+            const content = fs3.readFileSync(lockPath, "utf8").trim();
             const [pidLine, timestampLine] = content.split("\n");
             const pid = Number.parseInt(pidLine, 10);
             const timestamp = Number.parseInt(timestampLine, 10);
@@ -923,20 +1128,20 @@ var init_cliUtils = __esm({
           const start = Date.now();
           while (true) {
             try {
-              const fd = fs2.openSync(lockPath, "wx");
+              const fd = fs3.openSync(lockPath, "wx");
               try {
-                fs2.writeFileSync(fd, `${process.pid}
+                fs3.writeFileSync(fd, `${process.pid}
 ${Date.now()}
 `);
               } catch {
               }
               return () => {
                 try {
-                  fs2.closeSync(fd);
+                  fs3.closeSync(fd);
                 } catch {
                 }
                 try {
-                  fs2.unlinkSync(lockPath);
+                  fs3.unlinkSync(lockPath);
                 } catch {
                 }
               };
@@ -948,19 +1153,19 @@ ${Date.now()}
                   const lockAge = Date.now() - lockMeta.timestamp;
                   const running = isProcessRunning(lockMeta.pid);
                   if (!running || lockAge > timeoutMs) {
-                    BStackLogger.warn(
+                    BStackLogger2.warn(
                       `Stale CLI download lock detected (pid=${lockMeta.pid}, age=${lockAge}ms). Removing lock.`
                     );
                     try {
-                      fs2.unlinkSync(lockPath);
+                      fs3.unlinkSync(lockPath);
                     } catch {
                     }
                     continue;
                   }
                 }
                 const existingBinary = _CLIUtils.getExistingCliPath(cliDir);
-                if (existingBinary && fs2.existsSync(existingBinary) && fs2.statSync(existingBinary).size > 0) {
-                  BStackLogger.debug(
+                if (existingBinary && fs3.existsSync(existingBinary) && fs3.statSync(existingBinary).size > 0) {
+                  BStackLogger2.debug(
                     `Binary appeared while waiting for lock: ${existingBinary}`
                   );
                   return { alreadyExists: existingBinary };
@@ -980,14 +1185,17 @@ ${Date.now()}
         const cleanupTemporaryDownloads = (maxAgeMs = CLI_LOCK_TIMEOUT_MS) => {
           try {
             const now2 = Date.now();
-            for (const entry of fs2.readdirSync(cliDir)) {
-              if (!entry.startsWith(CLI_DOWNLOAD_TMP_PREFIX) || !entry.endsWith(CLI_DOWNLOAD_TMP_SUFFIX)) {
+            const tmpExtractRe = /\.tmp\.\d+$/;
+            for (const entry of fs3.readdirSync(cliDir)) {
+              const isDownloadZip = entry.startsWith(CLI_DOWNLOAD_TMP_PREFIX) && entry.endsWith(CLI_DOWNLOAD_TMP_SUFFIX);
+              const isExtractTmp = tmpExtractRe.test(entry);
+              if (!isDownloadZip && !isExtractTmp) {
                 continue;
               }
-              const filePath = path2.join(cliDir, entry);
+              const filePath = path3.join(cliDir, entry);
               let stats;
               try {
-                stats = fs2.statSync(filePath);
+                stats = fs3.statSync(filePath);
               } catch {
                 continue;
               }
@@ -995,21 +1203,21 @@ ${Date.now()}
                 continue;
               }
               try {
-                fs2.unlinkSync(filePath);
+                fs3.unlinkSync(filePath);
               } catch (err) {
-                BStackLogger.debug(
-                  `Failed to delete temp CLI zip file ${filePath}: ${util.format(err)}`
+                BStackLogger2.debug(
+                  `Failed to delete temp CLI file ${filePath}: ${util.format(err)}`
                 );
               }
             }
           } catch (err) {
-            BStackLogger.debug(
-              `Failed to scan temp CLI downloads in ${cliDir}: ${util.format(err)}`
+            BStackLogger2.debug(
+              `Failed to scan temp CLI files in ${cliDir}: ${util.format(err)}`
             );
           }
         };
         PerformanceTester.start(EVENTS.SDK_CLI_DOWNLOAD);
-        BStackLogger.debug(`Downloading SDK binary from: ${binDownloadUrl}`);
+        BStackLogger2.debug(`Downloading SDK binary from: ${binDownloadUrl}`);
         let downloadEnded = false;
         const endDownload = (success = true, errMsg) => {
           if (downloadEnded) {
@@ -1035,8 +1243,8 @@ ${Date.now()}
           }
           releaseLock = lockResult;
           const existingBinary = _CLIUtils.getExistingCliPath(cliDir);
-          if (existingBinary && fs2.existsSync(existingBinary) && fs2.statSync(existingBinary).size > 0) {
-            BStackLogger.debug(
+          if (existingBinary && fs3.existsSync(existingBinary) && fs3.statSync(existingBinary).size > 0) {
+            BStackLogger2.debug(
               `Binary already exists after acquiring lock: ${existingBinary}`
             );
             endDownload();
@@ -1044,13 +1252,12 @@ ${Date.now()}
             return existingBinary;
           }
           cleanupTemporaryDownloads();
-          const zipFilePath = path2.join(
+          const zipFilePath = path3.join(
             cliDir,
             `${CLI_DOWNLOAD_TMP_PREFIX}${process.pid}_${Date.now()}${CLI_DOWNLOAD_TMP_SUFFIX}`
           );
-          const downloadedFileStream = fs2.createWriteStream(zipFilePath);
+          const downloadedFileStream = fs3.createWriteStream(zipFilePath);
           return new Promise((resolve, reject) => {
-            const binaryName = null;
             const processDownload = async () => {
               const abortController = new AbortController();
               const timeout = setTimeout(
@@ -1059,9 +1266,11 @@ ${Date.now()}
               );
               let response;
               try {
-                response = await _fetch(binDownloadUrl, {
-                  signal: abortController.signal
-                });
+                response = await _fetch(
+                  binDownloadUrl,
+                  { signal: abortController.signal },
+                  { connectTimeoutMs: CLI_CONNECT_TIMEOUT_MS }
+                );
               } finally {
                 clearTimeout(timeout);
               }
@@ -1069,7 +1278,7 @@ ${Date.now()}
                 throw new Error("No response body received");
               }
               downloadedFileStream.on("error", function(err) {
-                BStackLogger.error(
+                BStackLogger2.error(
                   `Got Error while downloading cli binary file: ${err}`
                 );
                 endDownload(false, util.format(err));
@@ -1084,7 +1293,6 @@ ${Date.now()}
                 nodeStream.pipe(downloadedFileStream);
                 _CLIUtils.downloadFileStream(
                   downloadedFileStream,
-                  binaryName,
                   zipFilePath,
                   cliDir,
                   (result) => {
@@ -1099,7 +1307,7 @@ ${Date.now()}
                   }
                 );
               } catch (err) {
-                BStackLogger.error(
+                BStackLogger2.error(
                   `Got Error in cli binary downloading request ${util.format(err)}`
                 );
                 endDownload(false, util.format(err));
@@ -1112,46 +1320,110 @@ ${Date.now()}
         } catch (err) {
           releaseLock?.();
           endDownload(false, util.format(err));
-          BStackLogger.debug(
+          BStackLogger2.debug(
             `Failed to download binary, Exception: ${util.format(err)}`
           );
           return null;
         }
       };
-      static downloadFileStream(downloadedFileStream, binaryName, zipFilePath, cliDir, resolve, reject) {
+      static downloadFileStream(downloadedFileStream, zipFilePath, cliDir, resolve, reject) {
         downloadedFileStream.on("close", async function() {
           const yauzlOpenPromise = promisify(yauzl.open);
           try {
             const zipfile = await yauzlOpenPromise(zipFilePath, {
               lazyEntries: true
             });
+            let resolvedBinaryPath = null;
             zipfile.readEntry();
             zipfile.on("entry", async (entry) => {
-              if (!binaryName) {
-                binaryName = entry.fileName;
-              }
               if (/\/$/.test(entry.fileName)) {
                 zipfile.readEntry();
-              } else {
-                const writeStream = fs2.createWriteStream(
-                  path2.join(cliDir, entry.fileName)
-                );
-                const openReadStreamPromise = promisify(
+                return;
+              }
+              const candidatePath = path3.join(cliDir, entry.fileName);
+              const resolvedCandidate = path3.resolve(candidatePath);
+              const resolvedDir = path3.resolve(cliDir) + path3.sep;
+              if (!resolvedCandidate.startsWith(resolvedDir)) {
+                zipfile.close();
+                reject(new Error(`Zip-slip detected: entry "${entry.fileName}" resolves outside ${cliDir}`));
+                return;
+              }
+              const isBinaryEntry = path3.basename(entry.fileName).startsWith("binary-");
+              if (!isBinaryEntry) {
+                const directStream = fs3.createWriteStream(candidatePath);
+                directStream.on("error", (writeErr) => {
+                  zipfile.close();
+                  reject(writeErr);
+                });
+                const openReadStreamPromise2 = promisify(
                   zipfile.openReadStream
                 ).bind(zipfile);
                 try {
-                  const readStream = await openReadStreamPromise(entry);
+                  const readStream = await openReadStreamPromise2(entry);
                   readStream.on("end", function() {
-                    writeStream.close();
-                    zipfile.readEntry();
+                    directStream.end();
+                    directStream.on("close", () => zipfile.readEntry());
                   });
-                  readStream.pipe(writeStream);
+                  readStream.pipe(directStream);
                 } catch (zipErr) {
+                  zipfile.close();
                   reject(zipErr);
                 }
-                if (entry.fileName === binaryName) {
+                return;
+              }
+              const finalPath = candidatePath;
+              const tempPath = path3.join(cliDir, `${entry.fileName}.tmp.${process.pid}`);
+              const writeStream = fs3.createWriteStream(tempPath);
+              let writeStreamErrored = false;
+              writeStream.on("error", (writeErr) => {
+                writeStreamErrored = true;
+                fsp.unlink(tempPath).catch(() => {
+                });
+                zipfile.close();
+                reject(writeErr);
+              });
+              writeStream.on("close", async () => {
+                if (writeStreamErrored) {
+                  return;
+                }
+                try {
+                  await fsp.chmod(tempPath, "0755");
+                  try {
+                    await fsp.rename(tempPath, finalPath);
+                  } catch (renameErr) {
+                    if (renameErr.code !== "EXDEV") {
+                      throw renameErr;
+                    }
+                    BStackLogger2.warn(`Atomic rename failed (cross-device), falling back to copy: ${renameErr.message}`);
+                    await fsp.copyFile(tempPath, finalPath);
+                    await fsp.unlink(tempPath).catch(() => {
+                    });
+                  }
+                  if (!resolvedBinaryPath) {
+                    resolvedBinaryPath = finalPath;
+                  }
+                  zipfile.readEntry();
+                } catch (err) {
+                  await fsp.unlink(tempPath).catch(() => {
+                  });
                   zipfile.close();
+                  reject(err);
                 }
+              });
+              const openReadStreamPromise = promisify(
+                zipfile.openReadStream
+              ).bind(zipfile);
+              try {
+                const readStream = await openReadStreamPromise(entry);
+                readStream.on("end", function() {
+                  writeStream.end();
+                });
+                readStream.pipe(writeStream);
+              } catch (zipErr) {
+                fsp.unlink(tempPath).catch(() => {
+                });
+                zipfile.close();
+                reject(zipErr);
               }
             });
             zipfile.on("error", (zipErr) => {
@@ -1159,16 +1431,15 @@ ${Date.now()}
             });
             zipfile.once("end", () => {
               fsp.unlink(zipFilePath).catch(() => {
-                BStackLogger.warn(
-                  `Failed to delete zip file: ${zipFilePath}`
-                );
-              });
-              fsp.chmod(`${cliDir}/${binaryName}`, "0755").then(() => {
-                resolve(`${cliDir}/${binaryName}`);
-              }).catch((err) => {
-                reject(err);
+                BStackLogger2.warn(`Failed to delete zip file: ${zipFilePath}`);
               });
+              if (!resolvedBinaryPath) {
+                zipfile.close();
+                reject(new Error("No binary-* entry found in zip; cannot complete CLI binary extraction"));
+                return;
+              }
               zipfile.close();
+              resolve(resolvedBinaryPath);
             });
           } catch (err) {
             reject(err);
@@ -1191,7 +1462,7 @@ ${Date.now()}
       }
       static setFrameworkDetail(testFramework, automationFramework) {
         if (!testFramework || !automationFramework) {
-          BStackLogger.debug(
+          BStackLogger2.debug(
             `Test or Automation framework not provided testFramework=${testFramework}, automationFramework=${automationFramework}`
           );
         }
@@ -1273,12 +1544,12 @@ ${Date.now()}
 
 // src/instrumentation/performance/performance-tester.ts
 import { createObjectCsvWriter } from "csv-writer";
-import fs3 from "node:fs";
+import fs4 from "node:fs";
 import fsPromise from "node:fs/promises";
 import { performance, PerformanceObserver } from "node:perf_hooks";
 import util2 from "node:util";
 import worker from "node:worker_threads";
-import path3 from "node:path";
+import path4 from "node:path";
 import { arch as arch2, hostname, platform as platform2, type, version } from "node:os";
 var PerformanceTester;
 var init_performance_tester = __esm({
@@ -1303,11 +1574,11 @@ var init_performance_tester = __esm({
       static browser;
       static scenarioThatRan;
       static jsonReportDirName = "performance-report";
-      static jsonReportDirPath = path3.join(process.cwd(), "logs", this.jsonReportDirName);
+      static jsonReportDirPath = path4.join(process.cwd(), "logs", this.jsonReportDirName);
       static jsonReportFileName = `${this.jsonReportDirPath}/performance-report-${_PerformanceTester.getProcessId()}.json`;
       static startMonitoring(csvName = "performance-report.csv") {
-        if (!fs3.existsSync(this.jsonReportDirPath)) {
-          fs3.mkdirSync(this.jsonReportDirPath, { recursive: true });
+        if (!fs4.existsSync(this.jsonReportDirPath)) {
+          fs4.mkdirSync(this.jsonReportDirPath, { recursive: true });
         }
         this._observer = new PerformanceObserver((list) => {
           list.getEntries().filter((entry) => entry.entryType === "measure").forEach(
@@ -1317,10 +1588,10 @@ var init_performance_tester = __esm({
                 if (typeof finalEntry.startTime === "number" && typeof performance.timeOrigin === "number") {
                   const originalStartTime = finalEntry.startTime;
                   finalEntry.startTime = performance.timeOrigin + finalEntry.startTime;
-                  BStackLogger2.debug(`Timestamp conversion for ${entry.name}: ${originalStartTime} -> ${finalEntry.startTime} (timeOrigin: ${performance.timeOrigin})`);
+                  BStackLogger.debug(`Timestamp conversion for ${entry.name}: ${originalStartTime} -> ${finalEntry.startTime} (timeOrigin: ${performance.timeOrigin})`);
                 }
               } catch (e) {
-                BStackLogger2.debug(`Error converting startTime to epoch: ${util2.format(e)}`);
+                BStackLogger.debug(`Error converting startTime to epoch: ${util2.format(e)}`);
               }
               if (this.details[entry.name]) {
                 finalEntry = Object.assign(finalEntry, this.details[entry.name]);
@@ -1360,7 +1631,7 @@ var init_performance_tester = __esm({
         const timeTaken = methods.reduce((a, c) => {
           return times[c] + (a || 0);
         }, 0);
-        BStackLogger2.debug(`Time for ${methods} is ${timeTaken}`);
+        BStackLogger.debug(`Time for ${methods} is ${timeTaken}`);
         return timeTaken;
       }
       static async stopAndGenerate(filename = "performance-own.html") {
@@ -1372,7 +1643,7 @@ var init_performance_tester = __esm({
           const finalJSONStr = eventsJson.slice(1, -1) + ",";
           await fsPromise.appendFile(this.jsonReportFileName, finalJSONStr);
         } catch (er) {
-          BStackLogger2.debug(`Failed to write events of the worker to ${this.jsonReportFileName}: ${util2.format(er)}`);
+          BStackLogger.debug(`Failed to write events of the worker to ${this.jsonReportFileName}: ${util2.format(er)}`);
         }
         this._observer.disconnect();
         if (!process.env[PERF_MEASUREMENT_ENV]) {
@@ -1381,12 +1652,12 @@ var init_performance_tester = __esm({
         this.started = false;
         this.generateCSV(this._events);
         const content = this.generateReport(this._events);
-        const dir = path3.join(process.cwd(), filename);
+        const dir = path4.join(process.cwd(), filename);
         try {
           await fsPromise.writeFile(dir, content);
-          BStackLogger2.info(`Performance report is at ${path3}`);
+          BStackLogger.info(`Performance report is at ${path4}`);
         } catch (err) {
-          BStackLogger2.error(`Error in writing html ${util2.format(err)}`);
+          BStackLogger.error(`Error in writing html ${util2.format(err)}`);
         }
       }
       static generateReport(entries) {
@@ -1417,7 +1688,7 @@ var init_performance_tester = __esm({
             time: value
           };
         });
-        this._csvWriter.writeRecords(dat).then(() => BStackLogger2.info("Performance CSV report generated successfully")).catch((error) => console.error(error));
+        this._csvWriter.writeRecords(dat).then(() => BStackLogger.info("Performance CSV report generated successfully")).catch((error) => console.error(error));
       }
       static Measure(label, details = {}) {
         const self = this;
@@ -1525,6 +1796,7 @@ var init_performance_tester = __esm({
       static end(event, success = true, failure, details = {}) {
         performance.mark(event + "-end");
         performance.measure(event, event + "-start", event + "-end");
+        delete this.eventsMap[event + "-start"];
         this.details[event] = Object.assign({ success, failure: util2.format(failure) }, Object.assign(Object.assign({
           clientWorkerId: _PerformanceTester.getClientWorkerId(),
           worker: _PerformanceTester.getProcessId(),
@@ -1550,16 +1822,16 @@ var init_performance_tester = __esm({
         this.start(EVENTS.SDK_SEND_KEY_METRICS);
         try {
           const workerId = `${process.pid}`;
-          BStackLogger2.debug(`[Performance Upload] Starting upload for worker ${workerId}`);
+          BStackLogger.debug(`[Performance Upload] Starting upload for worker ${workerId}`);
           this.start(EVENTS.SDK_KEY_METRICS_PREPARATION);
           let measures = [];
           if (await fsPromise.access(this.jsonReportDirPath).then(() => true).catch(() => false)) {
-            const files = (await fsPromise.readdir(this.jsonReportDirPath)).map((file) => path3.resolve(this.jsonReportDirPath, file));
+            const files = (await fsPromise.readdir(this.jsonReportDirPath)).map((file) => path4.resolve(this.jsonReportDirPath, file));
             measures = (await Promise.all(files.map((file) => fsPromise.readFile(file, "utf-8")))).map((el) => `[${el.slice(0, -1)}]`).map((el) => JSON.parse(el)).flat();
           }
-          BStackLogger2.debug(`[Performance Upload] Total events from files: ${measures.length}`);
+          BStackLogger.debug(`[Performance Upload] Total events from files: ${measures.length}`);
           if (this._measuredEvents.length > 0) {
-            BStackLogger2.debug(`[Performance Upload] Adding ${this._measuredEvents.length} in-memory events`);
+            BStackLogger.debug(`[Performance Upload] Adding ${this._measuredEvents.length} in-memory events`);
             measures = measures.concat(
               this._measuredEvents.map((e) => {
                 if (typeof e.toJSON === "function") {
@@ -1620,10 +1892,10 @@ var init_performance_tester = __esm({
             },
             body: JSON.stringify(payload)
           });
-          BStackLogger2.debug(`[Performance Upload] Successfully uploaded to EDS: ${util2.format(await result.text())}`);
+          BStackLogger.debug(`[Performance Upload] Successfully uploaded to EDS: ${util2.format(await result.text())}`);
           this.end(EVENTS.SDK_SEND_KEY_METRICS, true);
         } catch (er) {
-          BStackLogger2.debug(`[Performance Upload] Failed to upload events: ${util2.format(er)}`);
+          BStackLogger.debug(`[Performance Upload] Failed to upload events: ${util2.format(er)}`);
           this.end(EVENTS.SDK_KEY_METRICS_PREPARATION, false, er);
           this.end(EVENTS.SDK_SEND_KEY_METRICS, false, er);
         }
@@ -1631,12 +1903,12 @@ var init_performance_tester = __esm({
           if (await fsPromise.access(this.jsonReportDirPath).then(() => true, () => false)) {
             const files = await fsPromise.readdir(this.jsonReportDirPath);
             for (const file of files) {
-              await fsPromise.unlink(path3.join(this.jsonReportDirPath, file));
+              await fsPromise.unlink(path4.join(this.jsonReportDirPath, file));
             }
-            BStackLogger2.debug(`[Performance Upload] Cleaned up ${files.length} temporary report files`);
+            BStackLogger.debug(`[Performance Upload] Cleaned up ${files.length} temporary report files`);
           }
         } catch (er) {
-          BStackLogger2.debug(`[Performance Upload] Failed to delete temporary files: ${util2.format(er)}`);
+          BStackLogger.debug(`[Performance Upload] Failed to delete temporary files: ${util2.format(er)}`);
         }
       }
     };
@@ -1644,7 +1916,7 @@ var init_performance_tester = __esm({
 });
 
 // src/testorchestration/testorcherstrationutils.ts
-import fs4 from "node:fs";
+import fs5 from "node:fs";
 var RUN_SMART_SELECTION, ALLOWED_ORCHESTRATION_KEYS, isPlainObject, asString, TestOrdering, OrchestrationUtils;
 var init_testorcherstrationutils = __esm({
   "src/testorchestration/testorcherstrationutils.ts"() {
@@ -1712,7 +1984,7 @@ var init_testorcherstrationutils = __esm({
           for (const service of services) {
             if (Array.isArray(service) && service[0] === "browserstack" && isPlainObject(service[1]) && isPlainObject(service[1].testOrchestrationOptions)) {
               testOrchOptions = service[1].testOrchestrationOptions;
-              BStackLogger2.debug("[constructor] Found testOrchestrationOptions in browserstack service config");
+              BStackLogger.debug("[constructor] Found testOrchestrationOptions in browserstack service config");
               break;
             }
           }
@@ -1741,9 +2013,9 @@ var init_testorcherstrationutils = __esm({
               }
             });
           }
-          BStackLogger2.debug(`[_extractBuildDetails] Extracted - projectName: ${this.projectName}, buildName: ${this.buildName}, buildIdentifier: ${this.buildIdentifier}`);
+          BStackLogger.debug(`[_extractBuildDetails] Extracted - projectName: ${this.projectName}, buildName: ${this.buildName}, buildIdentifier: ${this.buildIdentifier}`);
         } catch (error) {
-          BStackLogger2.error(`[_extractBuildDetails] ${error}`);
+          BStackLogger.error(`[_extractBuildDetails] ${error}`);
         }
       }
       _parseCapability(capability) {
@@ -1841,7 +2113,7 @@ var init_testorcherstrationutils = __esm({
         this.projectName = projectName;
         this.buildName = buildName;
         this.buildIdentifier = buildIdentifier;
-        BStackLogger2.debug(`[setBuildDetails] Set - projectName: ${this.projectName}, buildName: ${this.buildName}, buildIdentifier: ${this.buildIdentifier}`);
+        BStackLogger.debug(`[setBuildDetails] Set - projectName: ${this.projectName}, buildName: ${this.buildName}, buildIdentifier: ${this.buildIdentifier}`);
       }
       /**
        * Set run smart selection
@@ -1851,27 +2123,27 @@ var init_testorcherstrationutils = __esm({
           this.runSmartSelection = isValidEnabledValue(enabled);
           this.smartSelectionMode = mode;
           this.smartSelectionSource = [];
-          BStackLogger2.debug(`Setting runSmartSelection: enabled=${this.runSmartSelection}, mode=${this.smartSelectionMode}`);
+          BStackLogger.debug(`Setting runSmartSelection: enabled=${this.runSmartSelection}, mode=${this.smartSelectionMode}`);
           if (this.runSmartSelection) {
             const validModes = [SMART_SELECTION_MODE_RELEVANT_FIRST, SMART_SELECTION_MODE_RELEVANT_ONLY];
             if (!validModes.includes(this.smartSelectionMode)) {
-              BStackLogger2.warn(`Invalid smart selection mode '${this.smartSelectionMode}' provided. Defaulting to '${SMART_SELECTION_MODE_RELEVANT_FIRST}'.`);
+              BStackLogger.warn(`Invalid smart selection mode '${this.smartSelectionMode}' provided. Defaulting to '${SMART_SELECTION_MODE_RELEVANT_FIRST}'.`);
               this.smartSelectionMode = SMART_SELECTION_MODE_RELEVANT_FIRST;
             }
             if (source === null) {
               this.smartSelectionSource = null;
-              BStackLogger2.debug("No source provided for smart selection; defaulting to null.");
+              BStackLogger.debug("No source provided for smart selection; defaulting to null.");
             } else if (Array.isArray(source)) {
               this.smartSelectionSource = source;
-              BStackLogger2.debug(`Smart selection source set to array: ${JSON.stringify(source)}`);
+              BStackLogger.debug(`Smart selection source set to array: ${JSON.stringify(source)}`);
             } else if (typeof source === "string" && source.endsWith(".json")) {
               this.smartSelectionSource = this._loadSourceFromFile(source) || [];
-              BStackLogger2.debug(`Smart selection source loaded from file: ${source}`);
+              BStackLogger.debug(`Smart selection source loaded from file: ${source}`);
             }
             this._setTestOrdering();
           }
         } catch (e) {
-          BStackLogger2.error(`[_setRunSmartSelection] ${e}`);
+          BStackLogger.error(`[_setRunSmartSelection] ${e}`);
         }
       }
       /**
@@ -1881,17 +2153,17 @@ var init_testorcherstrationutils = __esm({
        * @returns Formatted list of repository configurations
        */
       _loadSourceFromFile(filePath) {
-        if (!fs4.existsSync(filePath)) {
-          BStackLogger2.error(`Source file '${filePath}' does not exist.`);
+        if (!fs5.existsSync(filePath)) {
+          BStackLogger.error(`Source file '${filePath}' does not exist.`);
           return [];
         }
         let data = null;
         try {
-          const fileContent = fs4.readFileSync(filePath, "utf8");
+          const fileContent = fs5.readFileSync(filePath, "utf8");
           data = JSON.parse(fileContent);
         } catch (error) {
           const message = error instanceof Error ? error.message : String(error);
-          BStackLogger2.error(`Error parsing JSON from source file '${filePath}': ${message}`);
+          BStackLogger.error(`Error parsing JSON from source file '${filePath}': ${message}`);
           return [];
         }
         let featureBranchEnvMap = null;
@@ -1907,9 +2179,9 @@ var init_testorcherstrationutils = __esm({
               return acc;
             }, {});
           } catch (error) {
-            BStackLogger2.error(`Error parsing feature branch mappings: ${error}`);
+            BStackLogger.error(`Error parsing feature branch mappings: ${error}`);
           }
-          BStackLogger2.debug(`Feature branch mappings from env: ${JSON.stringify(envMap)}`);
+          BStackLogger.debug(`Feature branch mappings from env: ${JSON.stringify(envMap)}`);
           return envMap;
         };
         featureBranchEnvMap = loadFeatureBranchMaps();
@@ -1931,23 +2203,23 @@ var init_testorcherstrationutils = __esm({
             }
             const typedRepoInfo = repoInfo;
             if (!typedRepoInfo.url || typeof typedRepoInfo.url !== "string") {
-              BStackLogger2.warn(`Repository URL is missing or invalid for source '${name}': ${JSON.stringify(repoInfo)}`);
+              BStackLogger.warn(`Repository URL is missing or invalid for source '${name}': ${JSON.stringify(repoInfo)}`);
               continue;
             }
             if (typedRepoInfo.baseBranch !== void 0 && typeof typedRepoInfo.baseBranch !== "string") {
-              BStackLogger2.warn(`Base branch must be a string for source '${name}': ${JSON.stringify(repoInfo)}`);
+              BStackLogger.warn(`Base branch must be a string for source '${name}': ${JSON.stringify(repoInfo)}`);
               continue;
             }
             if (typedRepoInfo.featureBranch !== void 0 && typeof typedRepoInfo.featureBranch !== "string") {
-              BStackLogger2.warn(`Feature branch must be a string for source '${name}': ${JSON.stringify(repoInfo)}`);
+              BStackLogger.warn(`Feature branch must be a string for source '${name}': ${JSON.stringify(repoInfo)}`);
               continue;
             }
             if (!namePattern.test(name)) {
-              BStackLogger2.warn(`Invalid source identifier format for '${name}': ${JSON.stringify(repoInfo)}`);
+              BStackLogger.warn(`Invalid source identifier format for '${name}': ${JSON.stringify(repoInfo)}`);
               continue;
             }
             if (name.length > 30 || name.length < 1) {
-              BStackLogger2.warn(`Source identifier '${name}' must have a length between 1 and 30 characters.`);
+              BStackLogger.warn(`Source identifier '${name}' must have a length between 1 and 30 characters.`);
               continue;
             }
             const featureBranch = getFeatureBranch(name, typedRepoInfo);
@@ -1960,11 +2232,11 @@ var init_testorcherstrationutils = __esm({
               filteredRepoInfo.baseBranch = typedRepoInfo.baseBranch;
             }
             if (!filteredRepoInfo.featureBranch || filteredRepoInfo.featureBranch === "") {
-              BStackLogger2.warn(`Feature branch not specified for source '${name}': ${JSON.stringify(repoInfo)}`);
+              BStackLogger.warn(`Feature branch not specified for source '${name}': ${JSON.stringify(repoInfo)}`);
               continue;
             }
             if (filteredRepoInfo.baseBranch && filteredRepoInfo.baseBranch === filteredRepoInfo.featureBranch) {
-              BStackLogger2.warn(`Feature branch and base branch cannot be the same for source '${name}': ${JSON.stringify(repoInfo)}`);
+              BStackLogger.warn(`Feature branch and base branch cannot be the same for source '${name}': ${JSON.stringify(repoInfo)}`);
               continue;
             }
             formattedData.push(filteredRepoInfo);
@@ -2074,17 +2346,17 @@ var init_crash_reporter = __esm({
             this.credentialsForCrashReportUpload = process.env.CREDENTIALS_FOR_CRASH_REPORTING !== void 0 ? JSON.parse(process.env.CREDENTIALS_FOR_CRASH_REPORTING) : this.credentialsForCrashReportUpload;
           }
         } catch (error) {
-          return BStackLogger2.error(`[Crash_Report_Upload] Failed to parse user credentials while reporting crash due to ${error}`);
+          return BStackLogger.error(`[Crash_Report_Upload] Failed to parse user credentials while reporting crash due to ${error}`);
         }
         if (!this.credentialsForCrashReportUpload.username || !this.credentialsForCrashReportUpload.password) {
-          return BStackLogger2.error("[Crash_Report_Upload] Failed to parse user credentials while reporting crash");
+          return BStackLogger.error("[Crash_Report_Upload] Failed to parse user credentials while reporting crash");
         }
         try {
           if (Object.keys(this.userConfigForReporting).length === 0) {
             this.userConfigForReporting = process.env.USER_CONFIG_FOR_REPORTING !== void 0 ? JSON.parse(process.env.USER_CONFIG_FOR_REPORTING) : {};
           }
         } catch (error) {
-          BStackLogger2.error(`[Crash_Report_Upload] Failed to parse user config while reporting crash due to ${error}`);
+          BStackLogger.error(`[Crash_Report_Upload] Failed to parse user config while reporting crash due to ${error}`);
           this.userConfigForReporting = {};
         }
         const data = {
@@ -2116,9 +2388,9 @@ var init_crash_reporter = __esm({
             body = JSON.stringify(JSON.parse(body));
           } catch {
           }
-          BStackLogger2.debug(`[Crash_Report_Upload] Success response: ${body}`);
+          BStackLogger.debug(`[Crash_Report_Upload] Success response: ${body}`);
         } else {
-          BStackLogger2.error(`[Crash_Report_Upload] Failed due to ${response.body}`);
+          BStackLogger.error(`[Crash_Report_Upload] Failed due to ${response.body}`);
         }
       }
       static recursivelyRedactKeysFromObject(obj, keys) {
@@ -2178,7 +2450,7 @@ var init_crash_reporter = __esm({
             }
           }
         } catch (err) {
-          BStackLogger2.error(`Error in parsing user config PII with error ${err ? err.stack || err : err}`);
+          BStackLogger.error(`Error in parsing user config PII with error ${err ? err.stack || err : err}`);
           return configWithoutPII;
         }
         configWithoutPII.services = finalServices;
@@ -2213,7 +2485,7 @@ var init_featureStats = __esm({
             this.failed(groupId);
             break;
           default:
-            BStackLogger2.debug("Request to mark usage for unknown status - " + status);
+            BStackLogger.debug("Request to mark usage for unknown status - " + status);
             break;
         }
       }
@@ -2449,7 +2721,7 @@ var init_usageStats = __esm({
         try {
           usage.events = this.getEventsData();
         } catch (e) {
-          BStackLogger2.debug("exception in getFormattedData: " + e);
+          BStackLogger.debug("exception in getFormattedData: " + e);
         }
         return usage;
       }
@@ -2459,7 +2731,7 @@ var init_usageStats = __esm({
             const usageStatsForWorker = _UsageStats.fromJSON(workerData.usageStats);
             this.add(usageStatsForWorker);
           } catch (e) {
-            BStackLogger2.debug("Exception in adding workerData: " + e);
+            BStackLogger.debug("Exception in adding workerData: " + e);
           }
         });
       }
@@ -2513,9 +2785,9 @@ var init_usageStats = __esm({
 });
 
 // src/scripts/accessibility-scripts.ts
-import path4 from "node:path";
-import fs5 from "node:fs";
-import os from "node:os";
+import path5 from "node:path";
+import fs6 from "node:fs";
+import os2 from "node:os";
 var AccessibilityScripts, accessibility_scripts_default;
 var init_accessibility_scripts = __esm({
   "src/scripts/accessibility-scripts.ts"() {
@@ -2533,7 +2805,7 @@ var init_accessibility_scripts = __esm({
       // don't allow to create instances from it other than through `checkAndGetInstance`
       constructor() {
         this.browserstackFolderPath = this.getWritableDir();
-        this.commandsPath = path4.join(this.browserstackFolderPath, "commands.json");
+        this.commandsPath = path5.join(this.browserstackFolderPath, "commands.json");
       }
       static checkAndGetInstance() {
         if (!_AccessibilityScripts.instance) {
@@ -2545,17 +2817,17 @@ var init_accessibility_scripts = __esm({
       /* eslint-disable @typescript-eslint/no-unused-vars */
       getWritableDir() {
         const orderedPaths = [
-          path4.join(os.homedir(), ".browserstack"),
+          path5.join(os2.homedir(), ".browserstack"),
           process.cwd(),
-          os.tmpdir()
+          os2.tmpdir()
         ];
         for (const orderedPath of orderedPaths) {
           try {
-            if (fs5.existsSync(orderedPath)) {
-              fs5.accessSync(orderedPath);
+            if (fs6.existsSync(orderedPath)) {
+              fs6.accessSync(orderedPath);
               return orderedPath;
             }
-            fs5.mkdirSync(orderedPath, { recursive: true });
+            fs6.mkdirSync(orderedPath, { recursive: true });
             return orderedPath;
           } catch (error) {
           }
@@ -2564,8 +2836,8 @@ var init_accessibility_scripts = __esm({
       }
       readFromExistingFile() {
         try {
-          if (fs5.existsSync(this.commandsPath)) {
-            const data = fs5.readFileSync(this.commandsPath, "utf8");
+          if (fs6.existsSync(this.commandsPath)) {
+            const data = fs6.readFileSync(this.commandsPath, "utf8");
             if (data) {
               this.update(JSON.parse(data));
             }
@@ -2588,10 +2860,10 @@ var init_accessibility_scripts = __esm({
         }
       }
       store() {
-        if (!fs5.existsSync(this.browserstackFolderPath)) {
-          fs5.mkdirSync(this.browserstackFolderPath);
+        if (!fs6.existsSync(this.browserstackFolderPath)) {
+          fs6.mkdirSync(this.browserstackFolderPath);
         }
-        fs5.writeFileSync(this.commandsPath, JSON.stringify({
+        fs6.writeFileSync(this.commandsPath, JSON.stringify({
           commands: this.commandsToWrap,
           scripts: {
             scan: this.performScan,
@@ -2610,17 +2882,15 @@ var init_accessibility_scripts = __esm({
 // src/util.ts
 import { hostname as hostname2, platform as platform3, type as type2, version as version2, arch as arch3, tmpdir } from "node:os";
 import crypto from "node:crypto";
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 import zlib from "node:zlib";
 import { format, promisify as promisify2 } from "node:util";
-import path5 from "node:path";
+import path6 from "node:path";
 import util3 from "node:util";
 import gitRepoInfo from "git-repo-info";
 import gitconfig from "gitconfiglocal";
-import { FormData as FormData2 } from "formdata-node";
 import { performance as performance2 } from "node:perf_hooks";
 import { create } from "tar";
-import { fileFromPath } from "formdata-node/file-from-path";
 function getBrowserDescription(cap) {
   cap = cap || {};
   if (cap["bstack:options"]) {
@@ -2656,7 +2926,7 @@ function getParentSuiteName(fullTitle, testSuiteTitle) {
   return parentSuiteName.trim();
 }
 function processError(error, fn, args) {
-  BStackLogger2.error(`Error in executing ${fn.name} with args ${args}: ${error}`);
+  BStackLogger.error(`Error in executing ${fn.name} with args ${args}: ${error}`);
   let argsString;
   try {
     argsString = JSON.stringify(args);
@@ -2694,7 +2964,7 @@ async function nodeRequest(requestType, apiEndpoint, options, apiUrl, timeout =
     clearTimeout(timeoutId);
     return await response.json();
   } catch (error) {
-    BStackLogger2.debug(`Error in firing request ${apiUrl}/${apiEndpoint}: ${format(error)}`);
+    BStackLogger.debug(`Error in firing request ${apiUrl}/${apiEndpoint}: ${format(error)}`);
     const isLogUpload = apiEndpoint === UPLOAD_LOGS_ENDPOINT;
     if (error && error.response) {
       const errorMessageJson = error.response.body ? JSON.parse(error.response.body.toString()) : null;
@@ -2702,9 +2972,9 @@ async function nodeRequest(requestType, apiEndpoint, options, apiUrl, timeout =
       if (errorMessage) {
         const message = `${errorMessage} - ${error.stack}`;
         if (isLogUpload) {
-          BStackLogger2.debug(message);
+          BStackLogger.debug(message);
         } else {
-          BStackLogger2.error(message);
+          BStackLogger.error(message);
         }
       }
       if (isLogUpload) {
@@ -2713,10 +2983,10 @@ async function nodeRequest(requestType, apiEndpoint, options, apiUrl, timeout =
       throw error;
     } else {
       if (isLogUpload) {
-        BStackLogger2.debug(`Failed to fire api request due to ${error} - ${error.stack}`);
+        BStackLogger.debug(`Failed to fire api request due to ${error} - ${error.stack}`);
         return;
       }
-      BStackLogger2.debug(`Failed to fire api request due to ${error} - ${error.stack}`);
+      BStackLogger.debug(`Failed to fire api request due to ${error} - ${error.stack}`);
       throw error;
     }
   }
@@ -3136,9 +3406,9 @@ async function batchAndPostEvents(eventUrl, kind, data) {
       },
       body: JSON.stringify(data)
     });
-    BStackLogger2.debug(`[${kind}] Success response: ${JSON.stringify(await response.json())}`);
+    BStackLogger.debug(`[${kind}] Success response: ${JSON.stringify(await response.json())}`);
   } catch (error) {
-    BStackLogger2.debug(`[${kind}] EXCEPTION IN ${kind} REQUEST TO TEST REPORTING AND ANALYTICS : ${error}`);
+    BStackLogger.debug(`[${kind}] EXCEPTION IN ${kind} REQUEST TO TEST REPORTING AND ANALYTICS : ${error}`);
     throw new Error("Exception in request " + error);
   }
 }
@@ -3176,7 +3446,7 @@ function getObservabilityBuild(options, bstackBuildName) {
   if (options.testObservabilityOptions && options.testObservabilityOptions.buildName) {
     return options.testObservabilityOptions.buildName;
   }
-  return bstackBuildName || path5.basename(path5.resolve(process.cwd()));
+  return bstackBuildName || path6.basename(path6.resolve(process.cwd()));
 }
 function getObservabilityBuildTags(options, bstackBuildTag) {
   if (process.env.TEST_OBSERVABILITY_BUILD_TAG) {
@@ -3190,6 +3460,25 @@ function getObservabilityBuildTags(options, bstackBuildTag) {
   }
   return [];
 }
+function getTestPlanId(options) {
+  if (process.env[BROWSERSTACK_TEST_PLAN_ID]) {
+    return process.env[BROWSERSTACK_TEST_PLAN_ID];
+  }
+  const CLI_ARG = "--browserstack.testManagementOptions.testPlanId";
+  const argIndex = process.argv.indexOf(CLI_ARG);
+  if (argIndex !== -1 && process.argv[argIndex + 1]) {
+    return process.argv[argIndex + 1];
+  }
+  const argWithEquals = process.argv.find((arg) => arg.startsWith(`${CLI_ARG}=`));
+  if (argWithEquals) {
+    return argWithEquals.split("=")[1];
+  }
+  const testPlanId = options.testManagementOptions?.testPlanId;
+  if (typeof testPlanId === "string" && testPlanId.trim().length > 0) {
+    return testPlanId.trim();
+  }
+  return void 0;
+}
 function getBrowserStackUser(config) {
   if (process.env.BROWSERSTACK_USERNAME) {
     return process.env.BROWSERSTACK_USERNAME;
@@ -3235,23 +3524,39 @@ function getFailureObject(error) {
   };
 }
 async function uploadLogs(user, key, clientBuildUuid) {
+  const eventName = EVENTS.SDK_UPLOAD_LOGS;
+  let success = true;
+  let failure;
+  PerformanceTester.start(eventName);
   try {
     if (!user || !key) {
-      BStackLogger2.debug("Uploading logs failed due to no credentials");
+      success = false;
+      failure = "skipped: missing_credentials";
+      BStackLogger.debug("Uploading logs failed due to no credentials");
       return;
     }
     const tmpDir = tmpdir();
-    const tarPath = path5.join(tmpDir, "logs.tar");
-    const tarGzPath = path5.join(tmpDir, "logs.tar.gz");
+    const tarPath = path6.join(tmpDir, "logs.tar");
+    const tarGzPath = path6.join(tmpDir, "logs.tar.gz");
     const filesToArchive = [
-      BStackLogger2.logFilePath,
+      BStackLogger.logFilePath,
       CLI_DEBUG_LOGS_FILE
-    ].filter((f) => fs6.existsSync(f));
+    ].filter((f) => fs7.existsSync(f));
     const copiedFileNames = [];
+    const archiveAddFailures = [];
     for (const f of filesToArchive) {
-      const dest = path5.join(tmpDir, path5.basename(f));
-      fs6.copyFileSync(f, dest);
-      copiedFileNames.push(path5.basename(f));
+      try {
+        const dest = path6.join(tmpDir, path6.basename(f));
+        fs7.copyFileSync(f, dest);
+        copiedFileNames.push(path6.basename(f));
+      } catch (copyErr) {
+        const msg = copyErr?.message || String(copyErr);
+        archiveAddFailures.push(`${path6.basename(f)}: ${msg}`);
+      }
+    }
+    if (archiveAddFailures.length > 0 && failure === void 0) {
+      success = false;
+      failure = `archive_add_failed [${archiveAddFailures.length}]: ${archiveAddFailures.join("; ")}`.substring(0, 300);
     }
     await create(
       {
@@ -3263,15 +3568,15 @@ async function uploadLogs(user, key, clientBuildUuid) {
       copiedFileNames
     );
     await new Promise((resolve, reject) => {
-      const source = fs6.createReadStream(tarPath);
-      const dest = fs6.createWriteStream(tarGzPath);
+      const source = fs7.createReadStream(tarPath);
+      const dest = fs7.createWriteStream(tarGzPath);
       const gzip = zlib.createGzip({ level: 1 });
       source.pipe(gzip).pipe(dest);
       dest.on("finish", resolve);
       dest.on("error", reject);
     });
-    const formData = new FormData2();
-    const file = await fileFromPath(tarGzPath);
+    const formData = new FormData();
+    const file = await fs7.openAsBlob(tarGzPath, { type: "application/x-gzip" });
     formData.append("data", file, "logs.tar.gz");
     formData.append("clientBuildUuid", clientBuildUuid);
     const auth = Buffer.from(`${user}:${key}`).toString("base64");
@@ -3287,21 +3592,32 @@ async function uploadLogs(user, key, clientBuildUuid) {
       requestOptions,
       APIUtils.UPLOAD_LOGS_ADDRESS
     );
-    fs6.unlinkSync(tarPath);
-    fs6.unlinkSync(tarGzPath);
+    fs7.unlinkSync(tarPath);
+    fs7.unlinkSync(tarGzPath);
     for (const f of copiedFileNames) {
-      const filePath = path5.join(tmpDir, f);
-      if (fs6.existsSync(filePath)) {
-        fs6.unlinkSync(filePath);
+      const filePath = path6.join(tmpDir, f);
+      if (fs7.existsSync(filePath)) {
+        fs7.unlinkSync(filePath);
       }
     }
-    if (fs6.existsSync(CLI_DEBUG_LOGS_FILE)) {
-      fs6.unlinkSync(CLI_DEBUG_LOGS_FILE);
+    if (fs7.existsSync(CLI_DEBUG_LOGS_FILE)) {
+      fs7.unlinkSync(CLI_DEBUG_LOGS_FILE);
+    }
+    if (!response) {
+      success = false;
+      failure = "upload_no_response";
+    } else if (response.status && response.status !== "success") {
+      success = false;
+      failure = `upload_status: ${response.status}${response.message ? " - " + String(response.message).slice(0, 200) : ""}`;
     }
     return response;
   } catch (error) {
-    BStackLogger2.error(`Error while uploading logs: ${getErrorString(error)}`);
+    success = false;
+    failure = `uploadLogs exception: ${getErrorString(error)}`;
+    BStackLogger.error(`Error while uploading logs: ${getErrorString(error)}`);
     return null;
+  } finally {
+    PerformanceTester.end(eventName, success, failure);
   }
 }
 function truncateString(field, truncateSizeInBytes) {
@@ -3315,7 +3631,7 @@ function truncateString(field, truncateSizeInBytes) {
       return truncatedString;
     }
   } catch (error) {
-    BStackLogger2.debug(`Error while truncating field, nothing was truncated here: ${error}`);
+    BStackLogger.debug(`Error while truncating field, nothing was truncated here: ${error}`);
   }
   return field;
 }
@@ -3324,7 +3640,7 @@ function getSizeOfJsonObjectInBytes(jsonData) {
     const buffer = Buffer.from(JSON.stringify(jsonData));
     return buffer.length;
   } catch (error) {
-    BStackLogger2.debug(`Something went wrong while calculating size of JSON object: ${error}`);
+    BStackLogger.debug(`Something went wrong while calculating size of JSON object: ${error}`);
   }
   return -1;
 }
@@ -3334,7 +3650,7 @@ function checkAndTruncateVCSInfo(gitMetaData) {
     const truncateSize = gitMetaDataSizeInBytes - MAX_GIT_META_DATA_SIZE_IN_BYTES;
     const truncatedCommitMessage = truncateString(gitMetaData.commit_message, truncateSize);
     gitMetaData.commit_message = truncatedCommitMessage;
-    BStackLogger2.info(`The commit has been truncated. Size of commit after truncation is ${getSizeOfJsonObjectInBytes(gitMetaData) / 1024} KB`);
+    BStackLogger.info(`The commit has been truncated. Size of commit after truncation is ${getSizeOfJsonObjectInBytes(gitMetaData) / 1024} KB`);
   }
   return gitMetaData;
 }
@@ -3346,7 +3662,7 @@ function getObservabilityProduct(options, isAppAutomate) {
 }
 async function pollApi(url3, params, headers, upperLimit, startTime = Date.now()) {
   params.timestamp = Math.round(Date.now() / 1e3);
-  BStackLogger2.debug(`current timestamp ${params.timestamp}`);
+  BStackLogger.debug(`current timestamp ${params.timestamp}`);
   try {
     const response = await makeGetRequest(url3, params, headers);
     const responseData = await response.json();
@@ -3358,9 +3674,9 @@ async function pollApi(url3, params, headers, upperLimit, startTime = Date.now()
   } catch (error) {
     if (error.response && error.response.status === 404) {
       const nextPollTime = parseInt(error.response.headers.get("next_poll_time"), 10) * 1e3;
-      BStackLogger2.debug(`timeInMillis ${nextPollTime}`);
+      BStackLogger.debug(`timeInMillis ${nextPollTime}`);
       if (isNaN(nextPollTime)) {
-        BStackLogger2.warn("Invalid or missing `nextPollTime` header. Stopping polling.");
+        BStackLogger.warn("Invalid or missing `nextPollTime` header. Stopping polling.");
         return {
           data: {},
           headers: error.response.headers,
@@ -3368,18 +3684,18 @@ async function pollApi(url3, params, headers, upperLimit, startTime = Date.now()
         };
       }
       const elapsedTime = nextPollTime - Date.now();
-      BStackLogger2.debug(
+      BStackLogger.debug(
         `elapsedTime ${elapsedTime} timeInMillis ${nextPollTime} upperLimit ${upperLimit}`
       );
       if (nextPollTime > upperLimit) {
-        BStackLogger2.warn("Polling stopped due to upper time limit.");
+        BStackLogger.warn("Polling stopped due to upper time limit.");
         return {
           data: {},
           headers: error.response.headers,
           message: "Polling stopped due to upper time limit."
         };
       }
-      BStackLogger2.debug(`Polling again in ${elapsedTime}ms with params:`, params);
+      BStackLogger.debug(`Polling again in ${elapsedTime}ms with params:`, params);
       await new Promise((resolve) => setTimeout(resolve, elapsedTime));
       return pollApi(url3, params, headers, upperLimit, startTime);
     } else if (error.response) {
@@ -3388,7 +3704,7 @@ async function pollApi(url3, params, headers, upperLimit, startTime = Date.now()
         const parsedError = JSON.parse(error.response.json());
         errorMessage = parsedError.message;
       } catch {
-        BStackLogger2.debug(`Error parsing pollApi request body ${error.response.body}`);
+        BStackLogger.debug(`Error parsing pollApi request body ${error.response.body}`);
         errorMessage = "Unknown error";
       }
       throw {
@@ -3397,7 +3713,7 @@ async function pollApi(url3, params, headers, upperLimit, startTime = Date.now()
         message: errorMessage
       };
     } else {
-      BStackLogger2.error(`Unexpected error occurred: ${error}`);
+      BStackLogger.error(`Unexpected error occurred: ${error}`);
       return { data: {}, headers: {}, message: "Unexpected error occurred." };
     }
   }
@@ -3506,28 +3822,28 @@ function nestedKeyValue(hash, keys) {
   return keys.reduce((hash2, key) => isHash(hash2) ? hash2[key] : void 0, hash);
 }
 function removeDir(dir) {
-  const list = fs6.readdirSync(dir);
+  const list = fs7.readdirSync(dir);
   for (let i = 0; i < list.length; i++) {
-    const filename = path5.join(dir, list[i]);
-    const stat = fs6.statSync(filename);
+    const filename = path6.join(dir, list[i]);
+    const stat = fs7.statSync(filename);
     if (filename === "." || filename === "..") {
     } else if (stat.isDirectory()) {
       removeDir(filename);
     } else {
-      fs6.unlinkSync(filename);
+      fs7.unlinkSync(filename);
     }
   }
-  fs6.rmdirSync(dir);
+  fs7.rmdirSync(dir);
 }
 function createDir(dir) {
-  if (fs6.existsSync(dir)) {
+  if (fs7.existsSync(dir)) {
     removeDir(dir);
   }
-  fs6.mkdirSync(dir, { recursive: true });
+  fs7.mkdirSync(dir, { recursive: true });
 }
 function isWritable(dirPath) {
   try {
-    fs6.accessSync(dirPath, fs6.constants.W_OK);
+    fs7.accessSync(dirPath, fs7.constants.W_OK);
     return true;
   } catch {
     return false;
@@ -3535,10 +3851,10 @@ function isWritable(dirPath) {
 }
 function setReadWriteAccess(dirPath) {
   try {
-    fs6.chmodSync(dirPath, 438);
-    BStackLogger2.debug(`Directory ${dirPath} is now read/write accessible.`);
+    fs7.chmodSync(dirPath, 438);
+    BStackLogger.debug(`Directory ${dirPath} is now read/write accessible.`);
   } catch (err) {
-    BStackLogger2.error(`Failed to set directory access: ${err.stack}`);
+    BStackLogger.error(`Failed to set directory access: ${err.stack}`);
   }
 }
 function getMochaTestHierarchy(test) {
@@ -3566,7 +3882,7 @@ function isMultiRemoteCaps(capabilities) {
     (cap) => Object.values(cap).length > 0 && Object.values(cap).every((c) => c !== null && typeof c === "object" && c.capabilities)
   );
 }
-var pGitconfig, DEFAULT_REQUEST_CONFIG, COLORS, processTestObservabilityResponse, jsonifyAccessibilityArray, processAccessibilityResponse, processLaunchBuildResponse, launchTestSession, validateCapsWithAppA11y, validateCapsWithA11y, validateCapsWithNonBstackA11y, shouldScanTestForAccessibility, isAccessibilityAutomationSession, isAppAccessibilityAutomationSession, formatString, _getParamsForAppAccessibility, performA11yScan, getA11yResults, getAppA11yResults, getAppA11yResultsSummary, getAppA11yResultResponse, getA11yResultsSummary, stopBuildUpstream, patchConsoleLogs, sleep, isObject, ObjectsAreEqual, getPlatformVersion, getBasicAuthHeader, isObjectEmpty, getErrorString, hasBrowserName, isValidCapsForHealing, performO11ySync;
+var pGitconfig, DEFAULT_REQUEST_CONFIG, COLORS, processTestObservabilityResponse, jsonifyAccessibilityArray, processAccessibilityResponse, processLaunchBuildResponse, launchTestSession, validateCapsWithAppA11y, validateCapsWithA11y, validateCapsWithNonBstackA11y, shouldScanTestForAccessibility, isAccessibilityAutomationSession, isAppAccessibilityAutomationSession, formatString, _getParamsForAppAccessibility, performA11yScan, getA11yResults, getAppA11yResults, getAppA11yResultsSummary, getAppA11yResultResponse, getA11yResultsSummary, stopBuildUpstream, patchConsoleLogs, sleep, isObject, ObjectsAreEqual, getPlatformVersion, getResolvedDeviceName, getBasicAuthHeader, isObjectEmpty, getErrorString, hasBrowserName, isValidCapsForHealing, performO11ySync;
 var init_util = __esm({
   "src/util.ts"() {
     "use strict";
@@ -3640,7 +3956,7 @@ var init_util = __esm({
         };
         if (scannerVersion) {
           process.env.BSTACK_A11Y_SCANNER_VERSION = scannerVersion;
-          BStackLogger2.debug(`Accessibility scannerVersion ${scannerVersion}`);
+          BStackLogger.debug(`Accessibility scannerVersion ${scannerVersion}`);
         }
         if (accessibilityToken) {
           process.env.BSTACK_A11Y_JWT = accessibilityToken;
@@ -3698,7 +4014,10 @@ var init_util = __esm({
         },
         product_map: getProductMapForBuildStartCall(bStackConfig, accessibilityAutomation),
         config: {},
-        test_orchestration: OrchestrationUtils.getInstance(config)?.getBuildStartData() || {}
+        test_orchestration: OrchestrationUtils.getInstance(config)?.getBuildStartData() || {},
+        test_management: {
+          test_plan_id: getTestPlanId(options)
+        }
       };
       if (accessibilityAutomation && (isTurboScale(options) || data.browserstackAutomation === false)) {
         data.accessibility.settings ??= {};
@@ -3709,7 +4028,7 @@ var init_util = __esm({
           CrashReporter.userConfigForReporting = process.env.USER_CONFIG_FOR_REPORTING !== void 0 ? JSON.parse(process.env.USER_CONFIG_FOR_REPORTING) : {};
         }
       } catch (error) {
-        return BStackLogger2.error(`[Crash_Report_Upload] Failed to parse user config while sending build start event due to ${error}`);
+        return BStackLogger.error(`[Crash_Report_Upload] Failed to parse user config while sending build start event due to ${error}`);
       }
       data.config = CrashReporter.userConfigForReporting;
       try {
@@ -3726,7 +4045,8 @@ var init_util = __esm({
         });
         const jsonResponse = await response.json();
         delete data?.accessibility?.settings?.includeEncodedExtension;
-        BStackLogger2.debug(`[Start_Build] Success response: ${JSON.stringify(jsonResponse)}`);
+        BStackLogger.debug(`[Start_Build] Success response: ${JSON.stringify(jsonResponse)}`);
+        BStackLogger.debug(`Test Plan Id sent in request: ${getTestPlanId(options)}`);
         process.env[TESTOPS_BUILD_COMPLETED_ENV] = "true";
         if (jsonResponse.jwt) {
           process.env[BROWSERSTACK_TESTHUB_JWT] = jsonResponse.jwt;
@@ -3734,13 +4054,13 @@ var init_util = __esm({
         if (jsonResponse.build_hashed_id) {
           process.env[BROWSERSTACK_TESTHUB_UUID] = jsonResponse.build_hashed_id;
           testOpsConfig_default.getInstance().buildHashedId = jsonResponse.build_hashed_id;
-          BStackLogger2.info(`Testhub started with id: ${testOpsConfig_default.getInstance()?.buildHashedId}`);
+          BStackLogger.info(`Testhub started with id: ${testOpsConfig_default.getInstance()?.buildHashedId}`);
         }
         processLaunchBuildResponse(jsonResponse, options);
         launchBuildUsage.success();
         return jsonResponse;
       } catch (error) {
-        BStackLogger2.debug(`TestHub build start failed: ${format(error)}`);
+        BStackLogger.debug(`TestHub build start failed: ${format(error)}`);
         if (!error.success) {
           launchBuildUsage.failed(error);
           logBuildError(error);
@@ -3750,7 +4070,7 @@ var init_util = __esm({
     }));
     validateCapsWithAppA11y = (platformMeta) => {
       if (platformMeta?.platform_name && String(platformMeta?.platform_name).toLowerCase() === "android" && (platformMeta?.platform_version && parseInt(platformMeta?.platform_version?.toString()) < 11)) {
-        BStackLogger2.warn("App Accessibility Automation tests are supported on OS version 11 and above for Android devices.");
+        BStackLogger.warn("App Accessibility Automation tests are supported on OS version 11 and above for Android devices.");
         return false;
       }
       return true;
@@ -3758,38 +4078,79 @@ var init_util = __esm({
     validateCapsWithA11y = (deviceName, platformMeta, chromeOptions) => {
       try {
         if (deviceName) {
-          BStackLogger2.warn("Accessibility Automation will run only on Desktop browsers.");
-          return false;
-        }
-        if (platformMeta?.browser_name?.toLowerCase() !== "chrome") {
-          BStackLogger2.warn("Accessibility Automation will run only on Chrome browsers.");
+          BStackLogger.warn("Accessibility Automation will run only on Desktop browsers.");
           return false;
         }
+        const browserName = platformMeta?.browser_name?.toLowerCase();
         const browserVersion = platformMeta?.browser_version;
-        if (!isUndefined(browserVersion) && !(browserVersion === "latest" || parseFloat(browserVersion + "") > 94)) {
-          BStackLogger2.warn("Accessibility Automation will run only on Chrome browser version greater than 94.");
+        const validBrowsers = SUPPORTED_BROWSERS_FOR_ACCESSIBILITY;
+        if (!browserName || !validBrowsers.includes(browserName)) {
+          BStackLogger.warn(`Accessibility Automation supports Chrome 95+, Chrome for Testing 141+, and Safari 18.4+. Current browser: ${browserName}`);
           return false;
         }
-        if (chromeOptions?.args?.includes("--headless")) {
-          BStackLogger2.warn("Accessibility Automation will not run on legacy headless mode. Switch to new headless mode or avoid using headless mode.");
-          return false;
+        if (browserName === "chrome" || browserName === "chromefortesting") {
+          const minVersion = MIN_BROWSER_VERSIONS_A11Y[browserName];
+          if (browserVersion && browserVersion !== "latest") {
+            const version3 = parseInt(browserVersion.toString().split(".")[0] || "0", 10);
+            if (version3 < minVersion) {
+              BStackLogger.warn(`Accessibility Automation requires ${browserName === "chrome" ? "Chrome" : "Chrome for Testing"} version ${minVersion} or higher.`);
+              return false;
+            }
+          }
+          if (chromeOptions?.args?.includes("--headless")) {
+            BStackLogger.warn("Accessibility Automation will not run on legacy headless mode. Switch to new headless mode or avoid using headless mode.");
+            return false;
+          }
+        }
+        if (browserName === "safari") {
+          if (browserVersion && browserVersion !== "latest") {
+            const [currentMajor = 0, currentMinor = 0] = browserVersion.toString().split(".").map(Number);
+            const [requiredMajor = 0, requiredMinor = 0] = MIN_BROWSER_VERSIONS_A11Y.safari.toString().split(".").map(Number);
+            if (currentMajor < requiredMajor || currentMajor === requiredMajor && currentMinor < requiredMinor) {
+              BStackLogger.warn(`Accessibility Automation requires Safari version ${MIN_BROWSER_VERSIONS_A11Y.safari} or higher.`);
+              return false;
+            }
+          }
         }
         return true;
       } catch (error) {
-        BStackLogger2.debug(`Exception in checking capabilities compatibility with Accessibility. Error: ${error}`);
+        BStackLogger.debug(`Exception in checking capabilities compatibility with Accessibility. Error: ${error}`);
       }
       return false;
     };
     validateCapsWithNonBstackA11y = (browserName, browserVersion) => {
-      if (browserName?.toLowerCase() !== "chrome") {
-        BStackLogger2.warn("Accessibility Automation will run only on Chrome browsers.");
-        return false;
-      }
-      if (!isUndefined(browserVersion) && !(browserVersion === "latest" || parseFloat(browserVersion + "") > 100)) {
-        BStackLogger2.warn("Accessibility Automation will run only on Chrome browser version greater than 100.");
-        return false;
+      try {
+        const browser = browserName?.toLowerCase();
+        const validBrowsers = ["chrome", "chromefortesting", "safari"];
+        if (!browser || !validBrowsers.includes(browser)) {
+          BStackLogger.warn("Accessibility Automation on non-BrowserStack infrastructure supports Chrome 100+, Chrome for Testing 141+, and Safari 18.4+.");
+          return false;
+        }
+        if (browser === "chrome" || browser === "chromefortesting") {
+          const minVersion = MIN_BROWSER_VERSIONS_A11Y_NON_BSTACK[browser];
+          if (browserVersion && browserVersion !== "latest") {
+            const version3 = parseInt(browserVersion.toString().split(".")[0] || "0", 10);
+            if (version3 < minVersion) {
+              BStackLogger.warn(`Accessibility Automation requires ${browser === "chrome" ? "Chrome" : "Chrome for Testing"} version ${minVersion}+ on non-BrowserStack infrastructure.`);
+              return false;
+            }
+          }
+        }
+        if (browser === "safari") {
+          if (browserVersion && browserVersion !== "latest") {
+            const [currentMajor = 0, currentMinor = 0] = browserVersion.toString().split(".").map(Number);
+            const [requiredMajor = 0, requiredMinor = 0] = MIN_BROWSER_VERSIONS_A11Y_NON_BSTACK.safari.toString().split(".").map(Number);
+            if (currentMajor < requiredMajor || currentMajor === requiredMajor && currentMinor < requiredMinor) {
+              BStackLogger.warn(`Accessibility Automation requires Safari version ${MIN_BROWSER_VERSIONS_A11Y_NON_BSTACK.safari}+ on non-BrowserStack infrastructure.`);
+              return false;
+            }
+          }
+        }
+        return true;
+      } catch (error) {
+        BStackLogger.debug(`Exception in checking capabilities compatibility with Accessibility. Error: ${error}`);
       }
-      return true;
+      return false;
     };
     shouldScanTestForAccessibility = (suiteTitle, testTitle, accessibilityOptions, world, isCucumber) => {
       try {
@@ -3807,7 +4168,7 @@ var init_util = __esm({
         const included = includeTags?.length === 0 || includeTags?.some((include) => fullTestName.includes(include));
         return !excluded && included;
       } catch (error) {
-        BStackLogger2.debug(`Error while validating test case for accessibility before scanning. Error : ${error}`);
+        BStackLogger.debug(`Error while validating test case for accessibility before scanning. Error : ${error}`);
       }
       return false;
     };
@@ -3816,7 +4177,7 @@ var init_util = __esm({
         const hasA11yJwtToken = typeof process.env.BSTACK_A11Y_JWT === "string" && process.env.BSTACK_A11Y_JWT.length > 0 && process.env.BSTACK_A11Y_JWT !== "null" && process.env.BSTACK_A11Y_JWT !== "undefined";
         return accessibilityFlag && hasA11yJwtToken;
       } catch (error) {
-        BStackLogger2.debug(`Exception in verifying the Accessibility session with error : ${error}`);
+        BStackLogger.debug(`Exception in verifying the Accessibility session with error : ${error}`);
       }
       return false;
     };
@@ -3847,43 +4208,43 @@ var init_util = __esm({
     };
     performA11yScan = async (isAppAutomate, browser, isBrowserStackSession, isAccessibility, commandName, testName) => {
       if (!isAccessibilityAutomationSession(isAccessibility)) {
-        BStackLogger2.warn("Not an Accessibility Automation session, cannot perform Accessibility scan.");
+        BStackLogger.warn("Not an Accessibility Automation session, cannot perform Accessibility scan.");
         return;
       }
       try {
         if (isAppAccessibilityAutomationSession(isAccessibility, isAppAutomate)) {
           const results = await browser.execute(formatString(accessibility_scripts_default.performScan, JSON.stringify(_getParamsForAppAccessibility(commandName, testName))), {});
-          BStackLogger2.debug(util3.format(results));
+          BStackLogger.debug(util3.format(results));
           return results;
         }
         if (accessibility_scripts_default.performScan) {
           const results = await executeAccessibilityScript(browser, accessibility_scripts_default.performScan, { method: commandName || "" });
           return results;
         }
-        BStackLogger2.error("AccessibilityScripts.performScan is null");
+        BStackLogger.error("AccessibilityScripts.performScan is null");
         return;
       } catch (err) {
-        BStackLogger2.error("Accessibility Scan could not be performed : " + err);
+        BStackLogger.error("Accessibility Scan could not be performed : " + err);
         return;
       }
     };
     getA11yResults = PerformanceTester.measureWrapper(A11Y_EVENTS.GET_RESULTS, async (isAppAutomate, browser, isBrowserStackSession, isAccessibility) => {
       if (!isAccessibilityAutomationSession(isAccessibility)) {
-        BStackLogger2.warn("Not an Accessibility Automation session, cannot retrieve Accessibility results.");
+        BStackLogger.warn("Not an Accessibility Automation session, cannot retrieve Accessibility results.");
         return [];
       }
       try {
-        BStackLogger2.debug("Performing scan before getting results");
+        BStackLogger.debug("Performing scan before getting results");
         await performA11yScan(isAppAutomate, browser, isBrowserStackSession, isAccessibility);
         if (accessibility_scripts_default.getResults) {
           const results = await executeAccessibilityScript(browser, accessibility_scripts_default.getResults);
           return results;
         }
-        BStackLogger2.error("AccessibilityScripts.getResults is null");
+        BStackLogger.error("AccessibilityScripts.getResults is null");
         return [];
       } catch (error) {
-        BStackLogger2.error("No accessibility results were found.");
-        BStackLogger2.debug(`getA11yResults Failed. Error: ${error}`);
+        BStackLogger.error("No accessibility results were found.");
+        BStackLogger.debug(`getA11yResults Failed. Error: ${error}`);
         return [];
       }
     });
@@ -3892,18 +4253,18 @@ var init_util = __esm({
         return [];
       }
       if (!isAppAccessibilityAutomationSession(isAccessibility, isAppAutomate)) {
-        BStackLogger2.warn("Not an Accessibility Automation session, cannot retrieve Accessibility results summary.");
+        BStackLogger.warn("Not an Accessibility Automation session, cannot retrieve Accessibility results summary.");
         return [];
       }
       try {
         const apiUrl = `${APIUtils.APP_ALLY_ENDPOINT}/${APP_ALLY_ISSUES_ENDPOINT}`;
         const apiRespone = await getAppA11yResultResponse(apiUrl, isAppAutomate, browser, testName, isBrowserStackSession, isAccessibility, sessionId);
         const result = apiRespone?.data?.data?.issues;
-        BStackLogger2.debug(`Polling Result: ${JSON.stringify(result)}`);
+        BStackLogger.debug(`Polling Result: ${JSON.stringify(result)}`);
         return result;
       } catch (error) {
-        BStackLogger2.error("No accessibility summary was found.");
-        BStackLogger2.debug(`getAppA11yResults Failed. Error: ${error}`);
+        BStackLogger.error("No accessibility summary was found.");
+        BStackLogger.debug(`getAppA11yResults Failed. Error: ${error}`);
         return [];
       }
     });
@@ -3912,46 +4273,46 @@ var init_util = __esm({
         return {};
       }
       if (!isAppAccessibilityAutomationSession(isAccessibility, isAppAutomate)) {
-        BStackLogger2.warn("Not an Accessibility Automation session, cannot retrieve Accessibility results summary.");
+        BStackLogger.warn("Not an Accessibility Automation session, cannot retrieve Accessibility results summary.");
         return {};
       }
       try {
         const apiUrl = `${APIUtils.APP_ALLY_ENDPOINT}/${APP_ALLY_ISSUES_SUMMARY_ENDPOINT}`;
         const apiRespone = await getAppA11yResultResponse(apiUrl, isAppAutomate, browser, testName, isBrowserStackSession, isAccessibility, sessionId);
         const result = apiRespone?.data?.data?.summary;
-        BStackLogger2.debug(`Polling Result: ${JSON.stringify(result)}`);
+        BStackLogger.debug(`Polling Result: ${JSON.stringify(result)}`);
         return result;
       } catch {
-        BStackLogger2.error("No accessibility summary was found.");
+        BStackLogger.error("No accessibility summary was found.");
         return {};
       }
     });
     getAppA11yResultResponse = async (apiUrl, isAppAutomate, browser, testName, isBrowserStackSession, isAccessibility, sessionId) => {
-      BStackLogger2.debug("Performing scan before getting results summary");
+      BStackLogger.debug("Performing scan before getting results summary");
       await performA11yScan(isAppAutomate, browser, isBrowserStackSession, isAccessibility, void 0, testName);
       const upperTimeLimit = process.env.BSTACK_A11Y_POLLING_TIMEOUT ? Date.now() + parseInt(process.env.BSTACK_A11Y_POLLING_TIMEOUT) * 1e3 : Date.now() + 3e4;
       const params = { test_run_uuid: process.env.TEST_ANALYTICS_ID, session_id: sessionId, timestamp: Date.now() };
       const header = { Authorization: `Bearer ${process.env.BSTACK_A11Y_JWT}` };
       const apiRespone = await pollApi(apiUrl, params, header, upperTimeLimit);
-      BStackLogger2.debug(`Polling Result: ${JSON.stringify(apiRespone)}`);
+      BStackLogger.debug(`Polling Result: ${JSON.stringify(apiRespone)}`);
       return apiRespone;
     };
     getA11yResultsSummary = PerformanceTester.measureWrapper(A11Y_EVENTS.GET_RESULTS_SUMMARY, async (isAppAutomate, browser, isBrowserStackSession, isAccessibility) => {
       if (!isAccessibilityAutomationSession(isAccessibility)) {
-        BStackLogger2.warn("Not an Accessibility Automation session, cannot retrieve Accessibility results summary.");
+        BStackLogger.warn("Not an Accessibility Automation session, cannot retrieve Accessibility results summary.");
         return {};
       }
       try {
-        BStackLogger2.debug("Performing scan before getting results summary");
+        BStackLogger.debug("Performing scan before getting results summary");
         await performA11yScan(isAppAutomate, browser, isBrowserStackSession, isAccessibility);
         if (accessibility_scripts_default.getResultsSummary) {
           const summaryResults = await executeAccessibilityScript(browser, accessibility_scripts_default.getResultsSummary);
           return summaryResults;
         }
-        BStackLogger2.error("AccessibilityScripts.getResultsSummary is null");
+        BStackLogger.error("AccessibilityScripts.getResultsSummary is null");
         return {};
       } catch {
-        BStackLogger2.error("No accessibility summary was found.");
+        BStackLogger.error("No accessibility summary was found.");
         return {};
       }
     });
@@ -3967,7 +4328,7 @@ var init_util = __esm({
       }
       if (!process.env[BROWSERSTACK_TESTHUB_JWT]) {
         stopBuildUsage.failed("Token/buildID is undefined, build creation might have failed");
-        BStackLogger2.debug("[STOP_BUILD] Missing Authentication Token/ Build ID");
+        BStackLogger.debug("[STOP_BUILD] Missing Authentication Token/ Build ID");
         return {
           status: "error",
           message: "Token/buildID is undefined, build creation might have failed"
@@ -3986,7 +4347,7 @@ var init_util = __esm({
           },
           body: JSON.stringify(data)
         });
-        BStackLogger2.debug(`[STOP_BUILD] Success response: ${await response.text()}`);
+        BStackLogger.debug(`[STOP_BUILD] Success response: ${await response.text()}`);
         stopBuildUsage.success();
         return {
           status: "success",
@@ -3994,7 +4355,7 @@ var init_util = __esm({
         };
       } catch (error) {
         stopBuildUsage.failed(error);
-        BStackLogger2.debug(`[STOP_BUILD] Failed. Error: ${error}`);
+        BStackLogger.debug(`[STOP_BUILD] Failed. Error: ${error}`);
         return {
           status: "error",
           message: error.message
@@ -4005,7 +4366,7 @@ var init_util = __esm({
       const BSTestOpsPatcher = new logPatcher_default({});
       Object.keys(consoleHolder).forEach((method) => {
         if (!(method in console) || method === "Console" || typeof console[method] !== "function") {
-          BStackLogger2.debug(`Skipping method: ${method}, exists: ${method in console}, type: ${typeof console[method]}`);
+          BStackLogger.debug(`Skipping method: ${method}, exists: ${method in console}, type: ${typeof console[method]}`);
           return;
         }
         const origMethod = console[method].bind(console);
@@ -4018,7 +4379,7 @@ var init_util = __esm({
               BSTestOpsPatcher[method](...args);
             }
           } catch (error) {
-            BStackLogger2.debug(`Error while patching console logs : ${error}`);
+            BStackLogger.debug(`Error while patching console logs : ${error}`);
             origMethod(...args);
           }
         };
@@ -4052,18 +4413,57 @@ var init_util = __esm({
       const keys = ["platformVersion", "platform_version", "osVersion", "os_version"];
       for (const key of keys) {
         if (caps?.[key]) {
-          BStackLogger2.debug(`Got ${key} from driver caps`);
+          BStackLogger.debug(`Got ${key} from driver caps`);
           return String(caps?.[key]);
         } else if (bstackOptions && bstackOptions?.[key]) {
-          BStackLogger2.debug(`Got ${key} from user bstack options`);
+          BStackLogger.debug(`Got ${key} from user bstack options`);
           return String(bstackOptions?.[key]);
         } else if (userCaps[key]) {
-          BStackLogger2.debug(`Got ${key} from user caps`);
+          BStackLogger.debug(`Got ${key} from user caps`);
           return String(userCaps[key]);
         }
       }
       return void 0;
     });
+    getResolvedDeviceName = o11yErrorHandler(function getResolvedDeviceName2(driverCaps, requestedCaps) {
+      const flattenMultiremote = (caps) => {
+        if (!caps) {
+          return [];
+        }
+        const obj = caps;
+        if (obj["deviceModel"] || obj["appium:deviceModel"] || obj["deviceName"] || obj["bstack:options"]) {
+          return [caps];
+        }
+        return Object.values(obj).filter((v) => v !== null && typeof v === "object" && "capabilities" in v).map((v) => v.capabilities).filter(Boolean);
+      };
+      const sources = [
+        ...flattenMultiremote(driverCaps),
+        ...flattenMultiremote(requestedCaps)
+      ];
+      if (!sources.length) {
+        return void 0;
+      }
+      const pickString = (obj, key) => {
+        const v = obj?.[key];
+        return typeof v === "string" && v.length > 0 ? v : void 0;
+      };
+      const paths = [
+        (c) => pickString(c, "deviceModel"),
+        (c) => pickString(c, "appium:deviceModel"),
+        (c) => pickString(c["bstack:options"], "deviceName"),
+        (c) => pickString(c, "appium:deviceName"),
+        (c) => pickString(c, "deviceName")
+      ];
+      for (const path22 of paths) {
+        for (const src of sources) {
+          const v = path22(src);
+          if (v) {
+            return v;
+          }
+        }
+      }
+      return void 0;
+    });
     getBasicAuthHeader = (username, password) => {
       const encodedAuth = Buffer.from(`${username}:${password}`, "utf8").toString("base64");
       return `Basic ${encodedAuth}`;
@@ -4107,20 +4507,20 @@ var init_util = __esm({
 });
 
 // src/bstackLogger.ts
-import path6 from "node:path";
-import fs7 from "node:fs";
+import path7 from "node:path";
+import fs8 from "node:fs";
 import chalk2 from "chalk";
 import logger2 from "@wdio/logger";
-var log2, BStackLogger2;
+var log2, BStackLogger;
 var init_bstackLogger = __esm({
   "src/bstackLogger.ts"() {
     "use strict";
     init_constants();
     init_util();
     log2 = logger2("@wdio/browserstack-service");
-    BStackLogger2 = class {
-      static logFilePath = path6.join(process.cwd(), LOGS_FILE);
-      static logFolderPath = path6.join(process.cwd(), "logs");
+    BStackLogger = class {
+      static logFilePath = path7.join(process.cwd(), LOGS_FILE);
+      static logFolderPath = path7.join(process.cwd(), "logs");
       static logFileStream;
       static redactCredentials(logMessage) {
         return logMessage.replace(/(["']?(?:username|userName|accesskey|accessKey|user|key)["']?\s*[:=]\s*["']?)([^"'\s,}]+)/gi, "$1").replace(/([?&](?:username|userName|access_key|accesskey|accessKey|user|key)=)([^&#\s]+)/gi, "$1");
@@ -4130,7 +4530,7 @@ var init_bstackLogger = __esm({
           const redactedMessage = this.redactCredentials(logMessage);
           if (!this.logFileStream) {
             this.ensureLogsFolder();
-            this.logFileStream = fs7.createWriteStream(this.logFilePath, { flags: "a" });
+            this.logFileStream = fs8.createWriteStream(this.logFilePath, { flags: "a" });
           }
           if (this.logFileStream && this.logFileStream.writable) {
             this.logFileStream.write(this.formatLog(redactedMessage, logLevel));
@@ -4179,13 +4579,13 @@ var init_bstackLogger = __esm({
         this.logFileStream = null;
       }
       static clearLogFile() {
-        if (fs7.existsSync(this.logFilePath)) {
-          fs7.truncateSync(this.logFilePath);
+        if (fs8.existsSync(this.logFilePath)) {
+          fs8.truncateSync(this.logFilePath);
         }
       }
       static ensureLogsFolder() {
-        if (!fs7.existsSync(this.logFolderPath)) {
-          fs7.mkdirSync(this.logFolderPath);
+        if (!fs8.existsSync(this.logFolderPath)) {
+          fs8.mkdirSync(this.logFolderPath);
         }
       }
     };
@@ -4201,13 +4601,14 @@ var init_utils = __esm({
     init_bstackLogger();
     init_util();
     getProductMap = (config) => {
-      return {
-        observability: config.testObservability.enabled,
-        accessibility: config.accessibility,
-        percy: config.percy,
-        automate: config.automate,
-        app_automate: config.appAutomate
-      };
+      const entries = [
+        ["observability", config.testObservability.enabled],
+        ["accessibility", !!config.accessibility],
+        ["percy", config.percy],
+        ["automate", config.automate],
+        ["app_automate", config.appAutomate]
+      ];
+      return Object.fromEntries(entries.filter(([, v]) => v !== null));
     };
     shouldProcessEventForTesthub = (eventType) => {
       if (isTrue(process.env[BROWSERSTACK_OBSERVABILITY])) {
@@ -4231,7 +4632,7 @@ var init_utils = __esm({
     };
     logBuildError = (error, product = "") => {
       if (!error || !error.errors) {
-        BStackLogger2.error(`${product.toUpperCase()} Build creation failed ${error}`);
+        BStackLogger.error(`${product.toUpperCase()} Build creation failed ${error}`);
         return;
       }
       for (const errorJson of error.errors) {
@@ -4240,35 +4641,36 @@ var init_utils = __esm({
         if (errorMessage) {
           switch (errorType) {
             case "ERROR_INVALID_CREDENTIALS":
-              BStackLogger2.error(errorMessage);
+              BStackLogger.error(errorMessage);
               break;
             case "ERROR_ACCESS_DENIED":
-              BStackLogger2.info(errorMessage);
+              BStackLogger.info(errorMessage);
               break;
             case "ERROR_SDK_DEPRECATED":
-              BStackLogger2.error(errorMessage);
+              BStackLogger.error(errorMessage);
               break;
             default:
-              BStackLogger2.error(errorMessage);
+              BStackLogger.error(errorMessage);
           }
         }
       }
     };
     getProductMapForBuildStartCall = (config, accessibilityAutomation) => {
-      return {
-        observability: config.testObservability.enabled,
-        accessibility: accessibilityAutomation,
-        percy: config.percy,
-        automate: config.automate,
-        app_automate: config.appAutomate
-      };
+      const entries = [
+        ["observability", config.testObservability.enabled],
+        ["accessibility", accessibilityAutomation],
+        ["percy", config.percy],
+        ["automate", config.automate],
+        ["app_automate", config.appAutomate]
+      ];
+      return Object.fromEntries(entries.filter(([, v]) => v !== null));
     };
   }
 });
 
 // src/Percy/PercyLogger.ts
-import path7 from "node:path";
-import fs8 from "node:fs";
+import path8 from "node:path";
+import fs9 from "node:fs";
 import chalk3 from "chalk";
 import logger3 from "@wdio/logger";
 var log3, PercyLogger;
@@ -4279,16 +4681,16 @@ var init_PercyLogger = __esm({
     init_util();
     log3 = logger3("@wdio/browserstack-service");
     PercyLogger = class {
-      static logFilePath = path7.join(process.cwd(), PERCY_LOGS_FILE);
-      static logFolderPath = path7.join(process.cwd(), "logs");
+      static logFilePath = path8.join(process.cwd(), PERCY_LOGS_FILE);
+      static logFolderPath = path8.join(process.cwd(), "logs");
       static logFileStream;
       static logToFile(logMessage, logLevel) {
         try {
           if (!this.logFileStream) {
-            if (!fs8.existsSync(this.logFolderPath)) {
-              fs8.mkdirSync(this.logFolderPath);
+            if (!fs9.existsSync(this.logFolderPath)) {
+              fs9.mkdirSync(this.logFolderPath);
             }
-            this.logFileStream = fs8.createWriteStream(this.logFilePath, { flags: "a" });
+            this.logFileStream = fs9.createWriteStream(this.logFilePath, { flags: "a" });
           }
           if (this.logFileStream && this.logFileStream.writable) {
             this.logFileStream.write(this.formatLog(logMessage, logLevel));
@@ -4332,8 +4734,8 @@ var init_PercyLogger = __esm({
         this.logFileStream = null;
       }
       static clearLogFile() {
-        if (fs8.existsSync(this.logFilePath)) {
-          fs8.truncateSync(this.logFilePath);
+        if (fs9.existsSync(this.logFilePath)) {
+          fs9.truncateSync(this.logFilePath);
         }
       }
     };
@@ -4341,7 +4743,7 @@ var init_PercyLogger = __esm({
 });
 
 // src/cli/grpcClient.ts
-import path12 from "node:path";
+import path13 from "node:path";
 import util5, { promisify as promisify3 } from "node:util";
 import {
   SDKClient,
@@ -4359,7 +4761,7 @@ import {
   DriverInitRequestConstructor,
   FetchDriverExecuteParamsEventRequestConstructor
 } from "@browserstack/wdio-browserstack-service";
-var GrpcClient;
+var GRPC_MESSAGE_LIMIT, GrpcClient;
 var init_grpcClient = __esm({
   "src/cli/grpcClient.ts"() {
     "use strict";
@@ -4367,13 +4769,14 @@ var init_grpcClient = __esm({
     init_performance_tester();
     init_constants2();
     init_cliLogger();
+    GRPC_MESSAGE_LIMIT = 20 * 1024 * 1024;
     GrpcClient = class _GrpcClient {
       static #instance = null;
       binSessionId;
       listenAddress;
       channel = null;
       client = null;
-      logger = BStackLogger;
+      logger = BStackLogger2;
       constructor() {
       }
       /**
@@ -4428,17 +4831,20 @@ var init_grpcClient = __esm({
         if (!listenAddress) {
           throw new Error("Unable to determine gRPC server listen address");
         }
+        const channelOptions = {
+          "grpc.keepalive_time_ms": 1e4,
+          "grpc.max_send_message_length": GRPC_MESSAGE_LIMIT,
+          "grpc.max_receive_message_length": GRPC_MESSAGE_LIMIT
+        };
         this.channel = new grpcChannel(
           listenAddress,
           grpcCredentials.createInsecure(),
-          {
-            "grpc.keepalive_time_ms": 1e4
-          }
+          channelOptions
         );
         this.client = new SDKClient(
           listenAddress,
           grpcCredentials.createInsecure(),
-          {}
+          channelOptions
         );
         this.logger.info(`Connected to gRPC server at ${listenAddress}`);
       }
@@ -4462,7 +4868,7 @@ var init_grpcClient = __esm({
             sdkLanguage: CLIUtils.getSdkLanguage(),
             sdkVersion: packageVersion,
             pathProject: process.cwd(),
-            pathConfig: path12.resolve(process.cwd(), "browserstack.yml"),
+            pathConfig: path13.resolve(process.cwd(), "browserstack.yml"),
             cliArgs: process.argv.slice(2),
             frameworks: [automationFrameworkDetail.name, testFrameworkDetail.name],
             frameworkVersions,
@@ -4908,7 +5314,7 @@ var init_baseModule = __esm({
         this.platformIndex = platformIndex;
         this.client = client;
         this.config = config;
-        BStackLogger.debug(`Configured module ${this.getModuleName()} with binSessionId=${binSessionId}, platformIndex=${platformIndex}`);
+        BStackLogger2.debug(`Configured module ${this.getModuleName()} with binSessionId=${binSessionId}, platformIndex=${platformIndex}`);
       }
     };
   }
@@ -5179,7 +5585,7 @@ var init_testFramework = __esm({
       * @returns {void}
       */
       trackEvent(testFrameworkState, hookState, args = {}) {
-        BStackLogger.info(`trackEvent: testFrameworkState=${testFrameworkState}; hookState=${hookState}; args=${args}`);
+        BStackLogger2.info(`trackEvent: testFrameworkState=${testFrameworkState}; hookState=${hookState}; args=${args}`);
       }
       /**
       * run test hooks
@@ -5189,7 +5595,7 @@ var init_testFramework = __esm({
       * @param {*} args
       */
       async runHooks(instance, testFrameworkState, hookState, args = {}) {
-        BStackLogger.info(`runHooks: instance=${instance} automationFrameworkState=${testFrameworkState} hookState=${hookState}`);
+        BStackLogger2.info(`runHooks: instance=${instance} automationFrameworkState=${testFrameworkState} hookState=${hookState}`);
         const hookRegistryKey = CLIUtils.getHookRegistryKey(testFrameworkState, hookState);
         await eventDispatcher.notifyObserver(hookRegistryKey, args);
       }
@@ -5453,7 +5859,7 @@ var init_automationFramework = __esm({
       * @returns {void}
       */
       async trackEvent(automationFrameworkState, hookState, args = {}) {
-        BStackLogger.info(`trackEvent: automationFrameworkState=${automationFrameworkState} hookState=${hookState} args=${args}`);
+        BStackLogger2.info(`trackEvent: automationFrameworkState=${automationFrameworkState} hookState=${hookState} args=${args}`);
       }
       /**
       *
@@ -5463,7 +5869,7 @@ var init_automationFramework = __esm({
       * @param {*} args
       */
       async runHooks(instance, automationFrameworkState, hookState, args = {}) {
-        BStackLogger.info(`runHooks: automationFrameworkState=${automationFrameworkState} hookState=${hookState}`);
+        BStackLogger2.info(`runHooks: automationFrameworkState=${automationFrameworkState} hookState=${hookState}`);
         const hookRegistryKey = CLIUtils.getHookRegistryKey(automationFrameworkState, hookState);
         await eventDispatcher.notifyObserver(hookRegistryKey, args);
       }
@@ -5481,7 +5887,7 @@ var init_automationFramework = __esm({
       * @returns {void}
       */
       static setTrackedInstance(context, instance) {
-        BStackLogger.debug(`setTrackedInstance: ${context.getId()}`);
+        BStackLogger2.debug(`setTrackedInstance: ${context.getId()}`);
         _AutomationFramework.instances.set(context.getId(), instance);
       }
       /**
@@ -5489,7 +5895,7 @@ var init_automationFramework = __esm({
       * @returns {TrackedInstance} The tracked instance
       */
       static getTrackedInstance() {
-        BStackLogger.debug(`getTrackedInstance: ${CLIUtils.getCurrentInstanceName()}`);
+        BStackLogger2.debug(`getTrackedInstance: ${CLIUtils.getCurrentInstanceName()}`);
         const context = TrackedInstance.createContext(CLIUtils.getCurrentInstanceName());
         return _AutomationFramework.instances.get(context.getId());
       }
@@ -5617,7 +6023,7 @@ var init_automateModule = __esm({
     init_automationFrameworkState();
     init_fetchWrapper();
     AutomateModule = class _AutomateModule extends BaseModule {
-      logger = BStackLogger;
+      logger = BStackLogger2;
       browserStackConfig;
       sessionMap = /* @__PURE__ */ new Map();
       static MODULE_NAME = "AutomateModule";
@@ -5678,12 +6084,12 @@ var init_automateModule = __esm({
       async onAfterTest(args) {
         this.logger.debug("onAfterTest: inside automate module after test hook!");
         const instace = args.instance;
-        const { error, passed } = args.result;
+        const { error, passed, skipped } = args.result;
         const _failReasons = [];
-        if (!passed) {
+        if (!passed && !skipped) {
           _failReasons.push(error && error.message || "Unknown Error");
         }
-        const status = passed ? "passed" : "failed";
+        const status = passed || skipped ? "passed" : "failed";
         const reason = _failReasons.length > 0 ? _failReasons.join("\n") : void 0;
         const autoInstance = AutomationFramework.getTrackedInstance();
         const sessionId = AutomationFramework.getState(autoInstance, AutomationFrameworkConstants.KEY_FRAMEWORK_SESSION_ID);
@@ -5933,7 +6339,7 @@ var init_testFrameworkInstance = __esm({
 
 // src/cli/frameworks/wdioMochaTestFramework.ts
 import { v4 as uuidv42 } from "uuid";
-import path13 from "node:path";
+import path14 from "node:path";
 var WdioMochaTestFramework;
 var init_wdioMochaTestFramework = __esm({
   "src/cli/frameworks/wdioMochaTestFramework.ts"() {
@@ -5967,11 +6373,11 @@ var init_wdioMochaTestFramework = __esm({
          * @param {*} args
       */
       async trackEvent(testFrameworkState, hookState, args = {}) {
-        BStackLogger.info(`trackEvent: testFrameworkState=${testFrameworkState} hookState=${hookState}`);
+        BStackLogger2.info(`trackEvent: testFrameworkState=${testFrameworkState} hookState=${hookState}`);
         await super.trackEvent(testFrameworkState, hookState, args);
         const instance = this.resolveInstance(testFrameworkState, hookState, args);
         if (instance === null) {
-          BStackLogger.error(`trackEvent: instance not found for testFrameworkState=${testFrameworkState} hookState=${hookState}`);
+          BStackLogger2.error(`trackEvent: instance not found for testFrameworkState=${testFrameworkState} hookState=${hookState}`);
           return;
         }
         try {
@@ -5983,7 +6389,7 @@ var init_wdioMochaTestFramework = __esm({
           if (!TestFramework.getState(instance, TestFrameworkConstants.KEY_TEST_ID) && hookState === HookState.PRE && testFrameworkState === TestFrameworkState.TEST) {
             const test = args.test;
             const testData = await this.getTestData(instance, test);
-            BStackLogger.info(`trackEvent: instanceData=${JSON.stringify(Object.fromEntries(instance.getAllData()))}`);
+            BStackLogger2.info(`trackEvent: instanceData=${JSON.stringify(Object.fromEntries(instance.getAllData()))}`);
             instance.updateMultipleEntries(testData);
           }
           if (testFrameworkState === TestFrameworkState.TEST) {
@@ -6001,13 +6407,13 @@ var init_wdioMochaTestFramework = __esm({
             logEntry.uuid = TestFramework.getState(instance, TestFrameworkConstants.KEY_HOOK_ID);
             this.loadLogEntries(instance, testFrameworkState, hookState, logEntry);
           } else if (testFrameworkState === TestFrameworkState.LOG_REPORT && hookState === HookState.POST) {
-            BStackLogger.info("trackEvent: load test results");
+            BStackLogger2.info("trackEvent: load test results");
             this.loadTestResult(instance, args);
           }
           await this.trackHookEvents(instance, testFrameworkState, hookState, args);
-          BStackLogger.debug(`trackEvent: tracked instance data=${JSON.stringify(Object.fromEntries(instance.getAllData()))}`);
+          BStackLogger2.debug(`trackEvent: tracked instance data=${JSON.stringify(Object.fromEntries(instance.getAllData()))}`);
         } catch (error) {
-          BStackLogger.error(`trackEvent: Error in tracking events: ${error} hookState=${hookState} testFrameworkState=${testFrameworkState}`);
+          BStackLogger2.error(`trackEvent: Error in tracking events: ${error} hookState=${hookState} testFrameworkState=${testFrameworkState}`);
         }
         args.instance = instance;
         await this.runHooks(instance, testFrameworkState, hookState, args);
@@ -6021,7 +6427,7 @@ var init_wdioMochaTestFramework = __esm({
       */
       resolveInstance(testFrameworkState, hookState, args = {}) {
         let instance = null;
-        BStackLogger.info(`resolveInstance: resolving instance for testFrameworkState=${testFrameworkState} hookState=${hookState}`);
+        BStackLogger2.info(`resolveInstance: resolving instance for testFrameworkState=${testFrameworkState} hookState=${hookState}`);
         if (testFrameworkState === TestFrameworkState.INIT_TEST || testFrameworkState === TestFrameworkState.NONE) {
           this.trackWdioMochaInstance(testFrameworkState, args);
         }
@@ -6038,7 +6444,7 @@ var init_wdioMochaTestFramework = __esm({
         const target = CLIUtils.getCurrentInstanceName();
         const trackedContext = TrackedInstance.createContext(target);
         let instance = null;
-        BStackLogger.info(`trackWdioMochaInstance: created instance for target=${target}, state=${testFrameworkState}, args=${args}`);
+        BStackLogger2.info(`trackWdioMochaInstance: created instance for target=${target}, state=${testFrameworkState}, args=${args}`);
         instance = new TestFrameworkInstance(
           trackedContext,
           this.getTestFrameworks(),
@@ -6061,7 +6467,7 @@ var init_wdioMochaTestFramework = __esm({
         process.env[TEST_ANALYTICS_ID] = instanceEntries[TestFrameworkConstants.KEY_TEST_UUID];
         instance.updateMultipleEntries(instanceEntries);
         TestFramework.setTrackedInstance(trackedContext, instance);
-        BStackLogger.info(`trackWdioMochaInstance: saved instance contextId=${trackedContext.getId()} target=${target}`);
+        BStackLogger2.info(`trackWdioMochaInstance: saved instance contextId=${trackedContext.getId()} target=${target}`);
       }
       async getTestData(instance, test) {
         const framework = TestFramework.getState(instance, TestFrameworkConstants.KEY_TEST_FRAMEWORK_NAME);
@@ -6072,8 +6478,8 @@ var init_wdioMochaTestFramework = __esm({
           [TestFrameworkConstants.KEY_TEST_ID]: getUniqueIdentifier(test, framework),
           [TestFrameworkConstants.KEY_TEST_NAME]: test.title || test.description,
           [TestFrameworkConstants.KEY_TEST_CODE]: test.body || "",
-          [TestFrameworkConstants.KEY_TEST_FILE_PATH]: gitConfig?.root && filename ? path13.relative(gitConfig.root, filename) : void 0,
-          [TestFrameworkConstants.KEY_TEST_LOCATION]: filename ? path13.relative(process.cwd(), filename) : void 0,
+          [TestFrameworkConstants.KEY_TEST_FILE_PATH]: gitConfig?.root && filename ? path14.relative(gitConfig.root, filename) : void 0,
+          [TestFrameworkConstants.KEY_TEST_LOCATION]: filename ? path14.relative(process.cwd(), filename) : void 0,
           [TestFrameworkConstants.KEY_TEST_SCOPE]: fullTitle,
           [TestFrameworkConstants.KEY_TEST_SCOPES]: getMochaTestHierarchy(test)
         };
@@ -6081,13 +6487,17 @@ var init_wdioMochaTestFramework = __esm({
       }
       loadTestResult(instance, args) {
         const results = args.result;
-        const { error, passed } = results;
+        const { error, passed, skipped } = results;
         let result = "passed";
         let failure = null;
         let failureReason = null;
         let failureType = null;
         if (!passed) {
-          result = error && error.message && error.message.includes("sync skip; aborting execution") ? "ignore" : "failed";
+          if (skipped) {
+            result = "skipped";
+          } else {
+            result = error && error.message && error.message.includes("sync skip; aborting execution") ? "ignore" : "failed";
+          }
           if (error && result !== "skipped") {
             failure = [{ backtrace: [removeAnsiColors(error.message), removeAnsiColors(error.stack || "")] }];
             failureReason = removeAnsiColors(error.message);
@@ -6122,7 +6532,7 @@ var init_wdioMochaTestFramework = __esm({
         if (lastActiveHook) {
           const hookLogs = lastActiveHook[TestFrameworkConstants.KEY_HOOK_LOGS];
           hookLogs.push(logRecord);
-          BStackLogger.debug(`hooks after update logs ${TestFramework.getState(instance, TestFrameworkConstants.KEY_HOOKS_STARTED)} ${TestFramework.getState(instance, TestFrameworkConstants.KEY_HOOKS_FINISHED)}`);
+          BStackLogger2.debug(`hooks after update logs ${TestFramework.getState(instance, TestFrameworkConstants.KEY_HOOKS_STARTED)} ${TestFramework.getState(instance, TestFrameworkConstants.KEY_HOOKS_FINISHED)}`);
           return;
         }
         const entries = TestFramework.getState(instance, TestFrameworkConstants.KEY_TEST_LOGS);
@@ -6223,15 +6633,15 @@ var init_wdioMochaTestFramework = __esm({
             [TestFrameworkConstants.KEY_EVENT_STARTED_AT]: (/* @__PURE__ */ new Date()).toISOString(),
             [TestFrameworkConstants.KEY_HOOK_LOGS]: [],
             [TestFrameworkConstants.KEY_HOOK_NAME]: test.title || test.description,
-            [TestFrameworkConstants.KEY_TEST_FILE_PATH]: gitConfig?.root && filename ? path13.relative(gitConfig.root, filename) : void 0,
-            [TestFrameworkConstants.KEY_TEST_LOCATION]: filename ? path13.relative(process.cwd(), filename) : void 0
+            [TestFrameworkConstants.KEY_TEST_FILE_PATH]: gitConfig?.root && filename ? path14.relative(gitConfig.root, filename) : void 0,
+            [TestFrameworkConstants.KEY_TEST_LOCATION]: filename ? path14.relative(process.cwd(), filename) : void 0
           };
           hooksStarted.get(key)?.push(hook);
           updates[_WdioMochaTestFramework.KEY_HOOK_LAST_STARTED] = key;
-          BStackLogger.info(`Hook Started in PRE key = ${key} & hook = ${JSON.stringify(hook)}`);
+          BStackLogger2.info(`Hook Started in PRE key = ${key} & hook = ${JSON.stringify(hook)}`);
         } else if (hookState === HookState.POST) {
           const hooksList = hooksStarted.get(key) || [];
-          BStackLogger.info(`Hook List in Post ${JSON.stringify(hooksList)}`);
+          BStackLogger2.info(`Hook List in Post ${JSON.stringify(hooksList)}`);
           if (hooksList.length > 0) {
             const hook = hooksList.pop();
             const result = testResult.status;
@@ -6244,7 +6654,7 @@ var init_wdioMochaTestFramework = __esm({
           }
         }
         instance.updateMultipleEntries(updates);
-        BStackLogger.info(`trackHookEvents: hook state=${key}.${hookState}, hooks started=${JSON.stringify(hooksStarted)}, hooks finished=${JSON.stringify(hooksFinished)}`);
+        BStackLogger2.info(`trackHookEvents: hook state=${key}.${hookState}, hooks started=${JSON.stringify(hooksStarted)}, hooks finished=${JSON.stringify(hooksFinished)}`);
       }
     };
   }
@@ -6268,7 +6678,7 @@ var init_testHubModule = __esm({
     init_automationFramework();
     init_automationFrameworkConstants();
     TestHubModule = class _TestHubModule extends BaseModule {
-      logger = BStackLogger;
+      logger = BStackLogger2;
       testhubConfig;
       name;
       static MODULE_NAME = "TestHubModule";
@@ -6541,11 +6951,11 @@ var init_wdioAutomationFramework = __esm({
        * @param {*} args
        */
       async trackEvent(automationFrameworkState, hookState, args = {}) {
-        BStackLogger.info(`trackEvent: automationFrameworkState=${automationFrameworkState} hookState=${hookState}`);
+        BStackLogger2.info(`trackEvent: automationFrameworkState=${automationFrameworkState} hookState=${hookState}`);
         await super.trackEvent(automationFrameworkState, hookState, args);
         const instance = this.resolveInstance(automationFrameworkState, hookState, args);
         if (instance === null) {
-          BStackLogger.error(`trackEvent: instance not found for automationFrameworkState=${automationFrameworkState} hookState=${hookState}`);
+          BStackLogger2.error(`trackEvent: instance not found for automationFrameworkState=${automationFrameworkState} hookState=${hookState}`);
           return;
         }
         args.instance = instance;
@@ -6560,7 +6970,7 @@ var init_wdioAutomationFramework = __esm({
        */
       resolveInstance(automationFrameworkState, hookState, args = {}) {
         let instance = null;
-        BStackLogger.info(`resolveInstance: resolving instance for automationFrameworkState=${automationFrameworkState} hookState=${hookState}`);
+        BStackLogger2.info(`resolveInstance: resolving instance for automationFrameworkState=${automationFrameworkState} hookState=${hookState}`);
         if (automationFrameworkState === AutomationFrameworkState.CREATE || automationFrameworkState === AutomationFrameworkState.NONE) {
           this.trackWebdriverIOInstance(automationFrameworkState, args);
         }
@@ -6576,13 +6986,13 @@ var init_wdioAutomationFramework = __esm({
           // !args.browser &&
           AutomationFramework.getTrackedInstance()
         ) {
-          BStackLogger.info("trackWebdriverIOInstance: instance already exists");
+          BStackLogger2.info("trackWebdriverIOInstance: instance already exists");
           return;
         }
         const target = CLIUtils.getCurrentInstanceName();
         const trackedContext = TrackedInstance.createContext(target);
         let instance = null;
-        BStackLogger.info(`trackWebdriverIOInstance: created instance for target=${target}, state=${automationFrameworkState}, args=${args}`);
+        BStackLogger2.info(`trackWebdriverIOInstance: created instance for target=${target}, state=${automationFrameworkState}, args=${args}`);
         instance = new AutomationFrameworkInstance(
           trackedContext,
           this.getAutomationFrameworkName(),
@@ -6590,7 +7000,7 @@ var init_wdioAutomationFramework = __esm({
           automationFrameworkState
         );
         AutomationFramework.setTrackedInstance(trackedContext, instance);
-        BStackLogger.info(`trackWebdriverIOInstance: saved instance contextId=${trackedContext.getId()} target=${target}`);
+        BStackLogger2.info(`trackWebdriverIOInstance: saved instance contextId=${trackedContext.getId()} target=${target}`);
       }
     };
   }
@@ -6616,7 +7026,7 @@ var init_webdriverIOModule = __esm({
       browserVersion;
       platforms;
       testRunId;
-      logger = BStackLogger;
+      logger = BStackLogger2;
       static MODULE_NAME = "WebdriverIOModule";
       /**
          * Create a new WebdriverIOModule
@@ -6744,7 +7154,7 @@ var init_accessibilityModule = __esm({
     init_constants2();
     init_grpcClient();
     AccessibilityModule = class extends BaseModule {
-      logger = BStackLogger;
+      logger = BStackLogger2;
       name;
       scriptInstance;
       accessibility = false;
@@ -7028,7 +7438,7 @@ var init_accessibilityModule = __esm({
                   formatString(this.scriptInstance.performScan, JSON.stringify(_getParamsForAppAccessibility(commandName, testName))),
                   {}
                 );
-                BStackLogger.debug(util9.format(results2));
+                BStackLogger2.debug(util9.format(results2));
                 return results2;
               }
               const results = await browser.executeAsync(
@@ -7151,7 +7561,7 @@ var init_observabilityModule = __esm({
     init_cliLogger();
     init_util();
     ObservabilityModule = class _ObservabilityModule extends BaseModule {
-      logger = BStackLogger;
+      logger = BStackLogger2;
       observabilityConfig;
       name;
       static MODULE_NAME = "ObservabilityModule";
@@ -7254,22 +7664,22 @@ var init_request_handler = __esm({
           throw new Error("Test Reporting and Analytics build start not completed yet.");
         }
         this.queue.push(event);
-        BStackLogger2.debug(`Added data to request queue. Queue length = ${this.queue.length}`);
+        BStackLogger.debug(`Added data to request queue. Queue length = ${this.queue.length}`);
         const shouldProceed = this.shouldProceed();
         if (shouldProceed) {
           this.sendBatch().catch((e) => {
-            BStackLogger2.debug("Exception in sending batch: " + e);
+            BStackLogger.debug("Exception in sending batch: " + e);
           });
         }
       }
       async shutdown() {
-        BStackLogger2.debug("shutdown started");
+        BStackLogger.debug("shutdown started");
         this.removeEventBatchPolling("Shutting down");
         while (this.queue.length > 0) {
           const data = this.queue.splice(0, DATA_BATCH_SIZE);
           await this.callCallback(data, "SHUTDOWN_QUEUE");
         }
-        BStackLogger2.debug("shutdown ended");
+        BStackLogger.debug("shutdown ended");
       }
       startEventBatchPolling() {
         this.pollEventBatchInterval = setInterval(this.sendBatch.bind(this), DATA_BATCH_INTERVAL);
@@ -7279,11 +7689,11 @@ var init_request_handler = __esm({
         if (data.length === 0) {
           return;
         }
-        BStackLogger2.debug(`Sending data from request queue. Data length = ${data.length}, Queue length after removal = ${this.queue.length}`);
+        BStackLogger.debug(`Sending data from request queue. Data length = ${data.length}, Queue length after removal = ${this.queue.length}`);
         await this.callCallback(data, "INTERVAL_QUEUE");
       }
       callCallback = async (data, kind) => {
-        BStackLogger2.debug("calling callback with kind " + kind);
+        BStackLogger.debug("calling callback with kind " + kind);
         await this.callback?.(data);
       };
       resetEventBatchPolling() {
@@ -7292,13 +7702,13 @@ var init_request_handler = __esm({
       }
       removeEventBatchPolling(tag) {
         if (this.pollEventBatchInterval) {
-          BStackLogger2.debug(`${tag} request queue`);
+          BStackLogger.debug(`${tag} request queue`);
           clearInterval(this.pollEventBatchInterval);
         }
       }
       shouldProceed() {
         if (_RequestQueueHandler.tearDownInvoked) {
-          BStackLogger2.debug("Force request-queue shutdown, as test run event is received after teardown");
+          BStackLogger.debug("Force request-queue shutdown, as test run event is received after teardown");
           return true;
         }
         return this.queue.length >= DATA_BATCH_SIZE;
@@ -7321,7 +7731,7 @@ async function uploadEventData(eventData, eventUrl = DATA_EVENT_ENDPOINT) {
     throw new Error("Build start not completed yet");
   }
   if (!process.env[BROWSERSTACK_TESTHUB_JWT]) {
-    BStackLogger2.debug(`[${logTag}] Missing Authentication Token/ Build ID`);
+    BStackLogger.debug(`[${logTag}] Missing Authentication Token/ Build ID`);
     throw new Error("Token/buildID is undefined, build creation might have failed");
   }
   try {
@@ -7334,9 +7744,9 @@ async function uploadEventData(eventData, eventUrl = DATA_EVENT_ENDPOINT) {
       },
       body: JSON.stringify(eventData)
     });
-    BStackLogger2.debug(`[${logTag}] Success response: ${JSON.stringify(await data.json())}`);
+    BStackLogger.debug(`[${logTag}] Success response: ${JSON.stringify(await data.json())}`);
   } catch (error) {
-    BStackLogger2.debug(`[${logTag}] Failed. Error: ${format3(error)}`);
+    BStackLogger.debug(`[${logTag}] Failed. Error: ${format3(error)}`);
     throw error;
   }
 }
@@ -7399,7 +7809,7 @@ var init_listener = __esm({
           await this.uploadPending();
           await this.teardown();
         } catch (e) {
-          BStackLogger2.debug("Exception in onWorkerEnd: " + e);
+          BStackLogger.debug("Exception in onWorkerEnd: " + e);
         }
       }
       async uploadPending(waitTimeout = DEFAULT_WAIT_TIMEOUT_FOR_PENDING_UPLOADS, waitInterval = DEFAULT_WAIT_INTERVAL_FOR_PENDING_UPLOADS) {
@@ -7410,10 +7820,10 @@ var init_listener = __esm({
         return this.uploadPending(waitTimeout - waitInterval);
       }
       async teardown() {
-        BStackLogger2.debug("teardown started");
+        BStackLogger.debug("teardown started");
         RequestQueueHandler.tearDownInvoked = true;
         await this.requestBatcher?.shutdown();
-        BStackLogger2.debug("teardown ended");
+        BStackLogger.debug("teardown ended");
       }
       hookStarted(hookData) {
         try {
@@ -7521,7 +7931,7 @@ var init_listener = __esm({
       }
       markLogs(status, data) {
         if (!data) {
-          BStackLogger2.debug("No log data");
+          BStackLogger.debug("No log data");
           return;
         }
         try {
@@ -7530,7 +7940,7 @@ var init_listener = __esm({
             this.logEvents.mark(status, LOG_KIND_USAGE_MAP[kind] || kind);
           }
         } catch (e) {
-          BStackLogger2.debug("Exception in marking logs status " + e);
+          BStackLogger.debug("Exception in marking logs status " + e);
           throw e;
         }
       }
@@ -7548,14 +7958,14 @@ var init_listener = __esm({
         }
         if (!this.requestBatcher) {
           this.requestBatcher = RequestQueueHandler.getInstance(async (data) => {
-            BStackLogger2.debug("callback: called with events " + data.length);
+            BStackLogger.debug("callback: called with events " + data.length);
             try {
               this.pendingUploads += 1;
               await batchAndPostEvents(DATA_BATCH_ENDPOINT, "BATCH_DATA", data);
-              BStackLogger2.debug("callback: marking events success " + data.length);
+              BStackLogger.debug("callback: marking events success " + data.length);
               this.eventsSuccess(data);
             } catch {
-              BStackLogger2.debug("callback: marking events failed " + data.length);
+              BStackLogger.debug("callback: marking events failed " + data.length);
               this.eventsFailed(data);
             } finally {
               this.pendingUploads -= 1;
@@ -7612,7 +8022,7 @@ var init_listener = __esm({
 });
 
 // src/reporter.ts
-import path14 from "node:path";
+import path15 from "node:path";
 import WDIOReporter from "@wdio/reporter";
 import * as url from "node:url";
 import { v4 as uuidv43 } from "uuid";
@@ -7705,7 +8115,7 @@ var init_reporter = __esm({
               filename = this._suiteName || suiteStats.file;
             }
           } catch {
-            BStackLogger2.debug("Error in decoding file name of suite");
+            BStackLogger.debug("Error in decoding file name of suite");
           }
         }
         this._suiteName = filename;
@@ -7835,9 +8245,9 @@ var init_reporter = __esm({
           scope,
           scopes,
           identifier,
-          file_name: suiteFileName ? path14.relative(process.cwd(), suiteFileName) : void 0,
-          location: suiteFileName ? path14.relative(process.cwd(), suiteFileName) : void 0,
-          vc_filepath: this._gitConfigPath && suiteFileName ? path14.relative(this._gitConfigPath, suiteFileName) : void 0,
+          file_name: suiteFileName ? path15.relative(process.cwd(), suiteFileName) : void 0,
+          location: suiteFileName ? path15.relative(process.cwd(), suiteFileName) : void 0,
+          vc_filepath: this._gitConfigPath && suiteFileName ? path15.relative(this._gitConfigPath, suiteFileName) : void 0,
           started_at: testStats.start && testStats.start.toISOString(),
           finished_at: testStats.end && testStats.end.toISOString(),
           framework,
@@ -7850,13 +8260,15 @@ var init_reporter = __esm({
         if (eventType.startsWith("TestRun") || eventType === "HookRunStarted") {
           const cloudProvider = getCloudProvider({ options: { hostname: this._config?.hostname } });
           testData.integrations = {};
+          const liveBrowserCaps = globalThis?.browser?.capabilities;
           testData.integrations[cloudProvider] = {
             capabilities: this._capabilities,
             session_id: this._sessionId,
             browser: this._capabilities?.browserName,
             browser_version: this._capabilities?.browserVersion,
             platform: this._capabilities?.platformName,
-            platform_version: getPlatformVersion(this._capabilities, this._userCaps)
+            platform_version: getPlatformVersion(this._capabilities, this._userCaps),
+            device: getResolvedDeviceName(liveBrowserCaps, this._userCaps)
           };
         }
         if (eventType === "TestRunFinished" || eventType === "HookRunFinished") {
@@ -7886,7 +8298,7 @@ var init_reporter = __esm({
 });
 
 // src/insights-handler.ts
-import path15 from "node:path";
+import path16 from "node:path";
 import { v4 as uuidv44 } from "uuid";
 var _InsightsHandler, InsightsHandler, insights_handler_default;
 var init_insights_handler = __esm({
@@ -8166,9 +8578,9 @@ var init_insights_handler = __esm({
           test_run_id: hookData.testRunId,
           scope: feature?.name,
           scopes: [feature?.name || ""],
-          file_name: uri ? path15.relative(process.cwd(), uri) : void 0,
-          location: uri ? path15.relative(process.cwd(), uri) : void 0,
-          vc_filepath: this._gitConfigPath && uri ? path15.relative(this._gitConfigPath, uri) : void 0,
+          file_name: uri ? path16.relative(process.cwd(), uri) : void 0,
+          location: uri ? path16.relative(process.cwd(), uri) : void 0,
+          vc_filepath: this._gitConfigPath && uri ? path16.relative(this._gitConfigPath, uri) : void 0,
           result: "pending",
           framework: this._framework
         };
@@ -8333,7 +8745,7 @@ var init_insights_handler = __esm({
             this.listener.logCreated([stdLog]);
           }
         } catch (error) {
-          BStackLogger2.debug(`Exception in uploading log data to Test Reporting and Analytics with error : ${error}`);
+          BStackLogger.debug(`Exception in uploading log data to Test Reporting and Analytics with error : ${error}`);
         }
       };
       async browserCommand(commandType, args, test) {
@@ -8466,9 +8878,9 @@ var init_insights_handler = __esm({
           scope: fullTitle,
           scopes: this.getHierarchy(test),
           identifier: fullTitle,
-          file_name: filename ? path15.relative(process.cwd(), filename) : void 0,
-          location: filename ? path15.relative(process.cwd(), filename) : void 0,
-          vc_filepath: this._gitConfigPath && filename ? path15.relative(this._gitConfigPath, filename) : void 0,
+          file_name: filename ? path16.relative(process.cwd(), filename) : void 0,
+          location: filename ? path16.relative(process.cwd(), filename) : void 0,
+          vc_filepath: this._gitConfigPath && filename ? path16.relative(this._gitConfigPath, filename) : void 0,
           started_at: testMetaData.startedAt,
           finished_at: testMetaData.finishedAt,
           result: "pending",
@@ -8578,9 +8990,9 @@ var init_insights_handler = __esm({
           scope: fullNameWithExamples,
           scopes: [feature?.name || ""],
           identifier: scenario?.name,
-          file_name: feature && feature.path ? path15.relative(process.cwd(), feature.path) : void 0,
-          location: feature && feature.path ? path15.relative(process.cwd(), feature.path) : void 0,
-          vc_filepath: this._gitConfigPath && feature?.path ? path15.relative(this._gitConfigPath, feature?.path) : void 0,
+          file_name: feature && feature.path ? path16.relative(process.cwd(), feature.path) : void 0,
+          location: feature && feature.path ? path16.relative(process.cwd(), feature.path) : void 0,
+          vc_filepath: this._gitConfigPath && feature?.path ? path16.relative(this._gitConfigPath, feature?.path) : void 0,
           framework: this._framework,
           result: "pending",
           meta: {
@@ -8633,7 +9045,7 @@ var init_insights_handler = __esm({
         return testData;
       }
       async flushCBTDataQueue() {
-        BStackLogger2.debug(`Flushing CBT Data Queue ${this.currentTestId}`);
+        BStackLogger.debug(`Flushing CBT Data Queue ${this.currentTestId}`);
         if (isUndefined(this.currentTestId)) {
           return;
         }
@@ -8653,7 +9065,7 @@ var init_insights_handler = __esm({
           uuid: "",
           integrations: integrationsData
         };
-        BStackLogger2.debug(`Sending CBT Data ${this.currentTestId} ${JSON.stringify(cbtData)}`);
+        BStackLogger.debug(`Sending CBT Data ${this.currentTestId} ${JSON.stringify(cbtData)}`);
         if (this.currentTestId !== void 0) {
           cbtData.uuid = this.currentTestId;
           this.listener.cbtSessionCreated(cbtData);
@@ -8664,8 +9076,8 @@ var init_insights_handler = __esm({
       getIntegrationsObject() {
         const caps = this._browser?.capabilities;
         const sessionId = this._browser?.sessionId;
-        BStackLogger2.debug(`Driver capabilities used for integration object: ${JSON.stringify(caps)}`);
-        BStackLogger2.debug(`User capabilities used for integration object: ${JSON.stringify(this._userCaps)}`);
+        BStackLogger.debug(`Driver capabilities used for integration object: ${JSON.stringify(caps)}`);
+        BStackLogger.debug(`User capabilities used for integration object: ${JSON.stringify(this._userCaps)}`);
         return {
           capabilities: caps,
           session_id: sessionId,
@@ -8673,7 +9085,8 @@ var init_insights_handler = __esm({
           browser_version: caps?.browserVersion,
           platform: caps?.platformName,
           product: this._platformMeta?.product,
-          platform_version: getPlatformVersion(caps, this._userCaps)
+          platform_version: getPlatformVersion(caps, this._userCaps),
+          device: getResolvedDeviceName(caps, this._userCaps)
         };
       }
       getIdentifier(test) {
@@ -8966,7 +9379,7 @@ var init_percyModule = __esm({
     init_Percy_Handler();
     init_testFrameworkConstants();
     PercyModule = class _PercyModule extends BaseModule {
-      logger = BStackLogger;
+      logger = BStackLogger2;
       browser;
       static MODULE_NAME = "PercyModule";
       percyHandler;
@@ -9087,7 +9500,7 @@ var init_cli = __esm({
       cliParams = null;
       automationFramework = null;
       SDK_CLI_BIN_PATH = null;
-      logger = BStackLogger;
+      logger = BStackLogger2;
       options;
       constructor() {
         this.initialized = false;
@@ -9146,7 +9559,7 @@ var init_cli = __esm({
         const response = await GrpcClient.getInstance().startBinSession(this.wdioConfig);
         const redactedStartResponse = JSON.parse(JSON.stringify(response));
         CrashReporter.recursivelyRedactKeysFromObject(redactedStartResponse, ["user", "username", "key", "accesskey", "password"]);
-        BStackLogger.debug(`start: startBinSession response=${JSON.stringify(redactedStartResponse)}`);
+        BStackLogger2.debug(`start: startBinSession response=${JSON.stringify(redactedStartResponse)}`);
         this.loadModules(response);
         this.isMainConnected = true;
       }
@@ -9158,6 +9571,7 @@ var init_cli = __esm({
         this.binSessionId = startBinResponse.binSessionId;
         this.logger.info(`loadModules: binSessionId=${this.binSessionId}`);
         this.setConfig(startBinResponse);
+        this.logBuildErrors(startBinResponse);
         APIUtils.updateURLSForGRR(this.config.apis);
         this.setupTestFramework();
         this.setupAutomationFramework();
@@ -9193,6 +9607,28 @@ var init_cli = __esm({
         }
         this.configureModules();
       }
+      /**
+       * Log any build errors the binary reported via testhub.errors. The
+       * field is a JSON-encoded { [errorKey]: { message, type } } map. Called
+       * early in loadModules so the user sees the actionable cause (e.g.
+       * invalid credentials) before any downstream bootstrap step that
+       * depends on a fully populated config.
+       */
+      logBuildErrors(startBinResponse) {
+        const rawErrors = startBinResponse.testhub?.errors;
+        if (!rawErrors || !rawErrors.length) {
+          return;
+        }
+        try {
+          const errors = JSON.parse(Buffer.from(rawErrors).toString());
+          for (const [code, detail] of Object.entries(errors)) {
+            const { message } = detail;
+            BStackLogger2.error(`[Build] ${code}: ${message}`);
+          }
+        } catch (e) {
+          BStackLogger2.debug(`Failed to parse testhub errors: ${e}`);
+        }
+      }
       /**
        * Configure modules
        * @returns {Promise<void>}
@@ -9223,12 +9659,61 @@ var init_cli = __esm({
           return Promise.resolve();
         }
         const SDK_CLI_BIN_PATH = await this.getCliBinPath();
+        if (!SDK_CLI_BIN_PATH) {
+          throw new Error("Failed to get CLI binary path. CLI setup failed.");
+        }
         const cmd = [SDK_CLI_BIN_PATH, "sdk"];
         this.logger.debug(`spawning command='${cmd}'`);
-        this.process = spawn3(cmd[0], cmd.slice(1), {
-          env: process.env
-        });
+        for (let attempt = 1; attempt <= MAX_SPAWN_RETRIES; attempt++) {
+          try {
+            await this._spawnAndAwaitReady(cmd);
+            if (attempt > 1) {
+              this.logger.info(`Spawn succeeded on attempt ${attempt}/${MAX_SPAWN_RETRIES}`);
+            }
+            PerformanceTester.end(EVENTS.SDK_CLI_START);
+            return;
+          } catch (err) {
+            const isBusy = BINARY_BUSY_ERROR_CODES.includes(err.code) || err.message && (err.message.toLowerCase().includes("text file busy") || err.message.toLowerCase().includes("being used by another process"));
+            if (isBusy && attempt < MAX_SPAWN_RETRIES) {
+              this.logger.warn(
+                `Spawn attempt ${attempt}/${MAX_SPAWN_RETRIES} failed with busy error, retrying in ${SPAWN_RETRY_DELAY_MS}ms: ${err.message}`
+              );
+              if (this.process) {
+                this.process.removeAllListeners();
+                this.process.stdout?.removeAllListeners();
+                this.process.stderr?.removeAllListeners();
+                this.process = null;
+              }
+              await new Promise((r) => setTimeout(r, SPAWN_RETRY_DELAY_MS));
+            } else {
+              PerformanceTester.end(EVENTS.SDK_CLI_START, false, err);
+              throw err;
+            }
+          }
+        }
+      }
+      /**
+       * Spawn the CLI process and wait until it emits "ready".
+       * Handles both synchronous spawn errors and async error/close events.
+       */
+      _spawnAndAwaitReady(cmd) {
         return new Promise((resolve, reject) => {
+          let settled = false;
+          const settle = (fn, val) => {
+            if (settled) {
+              return;
+            }
+            settled = true;
+            fn(val);
+          };
+          try {
+            this.process = spawn3(cmd[0], cmd.slice(1), {
+              env: process.env
+            });
+          } catch (syncErr) {
+            settle(reject, syncErr);
+            return;
+          }
           const cliOut = {};
           this.process.stdout.on("data", (data) => {
             const lines = data.toString().trim().split("\n");
@@ -9241,8 +9726,7 @@ var init_cli = __esm({
               }
               if (line.toLowerCase().includes("ready")) {
                 this.loadCliParams(cliOut);
-                PerformanceTester.end(EVENTS.SDK_CLI_START);
-                resolve();
+                settle(resolve);
                 return;
               }
             }
@@ -9251,14 +9735,11 @@ var init_cli = __esm({
             this.logger.error(`CLI stderr: ${data.toString().trim()}`);
           });
           this.process.on("error", (err) => {
-            cliOut.error = `Error in start: ${err.message}`;
-            PerformanceTester.end(EVENTS.SDK_CLI_START, false, err);
-            reject(new Error(`Failed to start CLI process: ${err.message}`));
+            settle(reject, err);
           });
           this.process.on("close", (code) => {
-            if (code !== 0) {
-              reject(new Error(`CLI process exited with code ${code}`));
-            }
+            const msg = code !== 0 ? `CLI process exited with code ${code}` : "CLI process exited cleanly before emitting ready";
+            settle(reject, new Error(msg));
           });
         });
       }
@@ -9272,7 +9753,7 @@ var init_cli = __esm({
         try {
           if (this.isMainConnected) {
             const response = await GrpcClient.getInstance().stopBinSession();
-            BStackLogger.debug(`stop: stopBinSession response=${JSON.stringify(response)}`);
+            BStackLogger2.debug(`stop: stopBinSession response=${JSON.stringify(response)}`);
           }
           await this.unConfigureModules();
           if (this.process && this.process.pid) {
@@ -9454,8 +9935,8 @@ var init_cli = __esm({
 });
 
 // src/testorchestration/helpers.ts
-import os5 from "node:os";
-import path18 from "node:path";
+import os6 from "node:os";
+import path19 from "node:path";
 import { spawnSync } from "node:child_process";
 import logger4 from "@wdio/logger";
 function isValidGitRef(ref) {
@@ -9481,11 +9962,11 @@ function safeGitCommand(args, cwd) {
 }
 function getHostInfo() {
   return {
-    hostname: os5.hostname(),
+    hostname: os6.hostname(),
     platform: process.platform,
     architecture: process.arch,
-    release: os5.release(),
-    username: os5.userInfo().username
+    release: os6.release(),
+    username: os6.userInfo().username
   };
 }
 function isValidGitResult(result) {
@@ -9576,7 +10057,7 @@ function getGitMetadataForAISelection(folders = []) {
   if (folders === null) {
     folders = [process.cwd()];
   }
-  const uniqueFolders = [...new Set(folders.map((f) => path18.resolve(f)))];
+  const uniqueFolders = [...new Set(folders.map((f) => path19.resolve(f)))];
   log4.debug(`Processing ${uniqueFolders.length} unique folders out of ${folders.length} total`);
   const results = [];
   for (const folder of uniqueFolders) {
@@ -9733,14 +10214,14 @@ var init_request_utils = __esm({
        * Makes a request to the test orchestration split tests endpoint
        */
       static async testOrchestrationSplitTests(reqEndpoint, data) {
-        BStackLogger2.debug("Processing Request for testOrchestrationSplitTests");
+        BStackLogger.debug("Processing Request for testOrchestrationSplitTests");
         return _RequestUtils.makeOrchestrationRequest("POST", reqEndpoint, { data });
       }
       /**
        * Gets ordered tests from the test orchestration
        */
       static async getTestOrchestrationOrderedTests(reqEndpoint) {
-        BStackLogger2.debug("Processing Request for getTestOrchestrationOrderedTests");
+        BStackLogger.debug("Processing Request for getTestOrchestrationOrderedTests");
         return _RequestUtils.makeOrchestrationRequest("GET", reqEndpoint, {});
       }
       /**
@@ -9777,13 +10258,13 @@ var init_request_utils = __esm({
             throw new Error(`Unsupported HTTP method: ${method}`);
           }
           const response = await fetchWrap(urlObject.toString(), requestInit);
-          BStackLogger2.debug(`Orchestration request made to URL: ${urlObject.toString()} with method: ${method}`);
+          BStackLogger.debug(`Orchestration request made to URL: ${urlObject.toString()} with method: ${method}`);
           const rawBody = await response.text();
           let responseObj = rawBody;
           try {
             responseObj = rawBody ? JSON.parse(rawBody) : {};
           } catch (error) {
-            BStackLogger2.debug(`Failed to parse JSON response: ${error} - ${rawBody}`);
+            BStackLogger.debug(`Failed to parse JSON response: ${error} - ${rawBody}`);
           }
           if (responseObj && typeof responseObj === "object" && !Array.isArray(responseObj)) {
             return {
@@ -9794,7 +10275,7 @@ var init_request_utils = __esm({
           }
           return typeof responseObj === "string" ? responseObj : rawBody;
         } catch (error) {
-          BStackLogger2.error(`Orchestration request failed: ${error} - ${url3}`);
+          BStackLogger.error(`Orchestration request failed: ${error} - ${url3}`);
           return null;
         }
       }
@@ -9803,7 +10284,7 @@ var init_request_utils = __esm({
 });
 
 // src/testorchestration/test-ordering-server.ts
-import path19 from "node:path";
+import path20 from "node:path";
 function isSplitTestsResponse(value) {
   return typeof value === "object" && value !== null;
 }
@@ -9837,7 +10318,7 @@ var init_test_ordering_server = __esm({
        * Initiates the split tests request and stores the response data for polling.
        */
       async splitTests(testFiles, orchestrationStrategy, orchestrationMetadata = "{}") {
-        BStackLogger2.debug(`[splitTests] Initiating split tests with strategy: ${orchestrationStrategy}`);
+        BStackLogger.debug(`[splitTests] Initiating split tests with strategy: ${orchestrationStrategy}`);
         try {
           let prDetails = [];
           const parsedMetadata = JSON.parse(orchestrationMetadata);
@@ -9847,7 +10328,7 @@ var init_test_ordering_server = __esm({
             const multiRepoSource = parsedMetadata.run_smart_selection?.source;
             prDetails = getGitMetadataForAISelection(multiRepoSource);
           }
-          BStackLogger2.debug(`PR Details for AI Selection: ${JSON.stringify(prDetails)}`);
+          BStackLogger.debug(`PR Details for AI Selection: ${JSON.stringify(prDetails)}`);
           const payload = {
             tests: testFiles.map((f) => ({ filePath: f })),
             orchestrationStrategy,
@@ -9855,23 +10336,23 @@ var init_test_ordering_server = __esm({
             nodeIndex: parseInt(process.env.BROWSERSTACK_NODE_INDEX || "0"),
             totalNodes: parseInt(process.env.BROWSERSTACK_TOTAL_NODE_COUNT || "1"),
             projectName: this.config.testObservabilityOptions?.projectName || "",
-            buildName: this.config.testObservabilityOptions?.buildName || path19.basename(process.cwd()),
+            buildName: this.config.testObservabilityOptions?.buildName || path20.basename(process.cwd()),
             buildRunIdentifier: process.env.BROWSERSTACK_BUILD_RUN_IDENTIFIER || "",
             hostInfo: getHostInfo(),
             prDetails
           };
-          BStackLogger2.info(`[splitTests] Split tests payload: ${JSON.stringify(payload)}`);
+          BStackLogger.info(`[splitTests] Split tests payload: ${JSON.stringify(payload)}`);
           const response = await RequestUtils.testOrchestrationSplitTests(this.ORDERING_ENDPOINT, payload);
           if (isSplitTestsResponse(response)) {
             this.requestData = this._processSplitTestsResponse(response);
-            BStackLogger2.debug(`[splitTests] Split tests response: ${JSON.stringify(this.requestData)}`);
+            BStackLogger.debug(`[splitTests] Split tests response: ${JSON.stringify(this.requestData)}`);
           } else if (response) {
-            BStackLogger2.error("[splitTests] Received unexpected response format from split tests request.");
+            BStackLogger.error("[splitTests] Received unexpected response format from split tests request.");
           } else {
-            BStackLogger2.error("[splitTests] Failed to get split tests response.");
+            BStackLogger.error("[splitTests] Failed to get split tests response.");
           }
         } catch (error) {
-          BStackLogger2.error(`[splitTests] Exception in sending test files:: ${error}`);
+          BStackLogger.error(`[splitTests] Exception in sending test files:: ${error}`);
         }
       }
       /**
@@ -9889,7 +10370,7 @@ var init_test_ordering_server = __esm({
         const resultUrl = normalizeUrl(response.resultUrl);
         const timeoutUrl = normalizeUrl(response.timeoutUrl);
         if (response.timeout === void 0 || response.timeoutInterval === void 0 || response.timeoutUrl === void 0 || response.resultUrl === void 0) {
-          BStackLogger2.debug("[process_split_tests_response] Received null value(s) for some attributes in split tests API response");
+          BStackLogger.debug("[process_split_tests_response] Received null value(s) for some attributes in split tests API response");
         }
         return {
           timeout,
@@ -9903,7 +10384,7 @@ var init_test_ordering_server = __esm({
        */
       async getOrderedTestFiles() {
         if (!this.requestData) {
-          BStackLogger2.error("[getOrderedTestFiles] No request data available to fetch ordered test files.");
+          BStackLogger.error("[getOrderedTestFiles] No request data available to fetch ordered test files.");
           return null;
         }
         let testFilesJsonList = null;
@@ -9927,10 +10408,10 @@ var init_test_ordering_server = __esm({
               break;
             }
             await new Promise((resolve) => setTimeout(resolve, timeoutInterval * 1e3));
-            BStackLogger2.debug(`[getOrderedTestFiles] Fetching ordered tests from result URL after waiting for ${timeoutInterval} seconds.`);
+            BStackLogger.debug(`[getOrderedTestFiles] Fetching ordered tests from result URL after waiting for ${timeoutInterval} seconds.`);
           }
           if (timeoutUrl && !testFilesJsonList) {
-            BStackLogger2.debug("[getOrderedTestFiles] Fetching ordered tests from timeout URL");
+            BStackLogger.debug("[getOrderedTestFiles] Fetching ordered tests from timeout URL");
             const response = await RequestUtils.getTestOrchestrationOrderedTests(timeoutUrl);
             if (isSplitTestsResponse(response) && Array.isArray(response.tests)) {
               testFilesJsonList = response.tests;
@@ -9947,10 +10428,10 @@ var init_test_ordering_server = __esm({
           if (!testFilesJsonList) {
             return null;
           }
-          BStackLogger2.debug(`[getOrderedTestFiles] Ordered test files received: ${JSON.stringify(testFiles)}`);
+          BStackLogger.debug(`[getOrderedTestFiles] Ordered test files received: ${JSON.stringify(testFiles)}`);
           return testFiles;
         } catch (error) {
-          BStackLogger2.error(`[getOrderedTestFiles] Exception in fetching ordered test files: ${error}`);
+          BStackLogger.error(`[getOrderedTestFiles] Exception in fetching ordered test files: ${error}`);
           return null;
         }
       }
@@ -10042,10 +10523,10 @@ var init_testorcherstrationhandler = __esm({
           return;
         }
         if (this.config.projectName === void 0 || this.config.buildName === void 0) {
-          BStackLogger2.info("Test Reordering can't work as buildName or projectName is null. Please set a non-null value.");
+          BStackLogger.info("Test Reordering can't work as buildName or projectName is null. Please set a non-null value.");
         }
         if (!this._isObservabilityEnabled()) {
-          BStackLogger2.info("Test Reordering can't work as testReporting is disabled. Please enable it from browserstack.yml file.");
+          BStackLogger.info("Test Reordering can't work as testReporting is disabled. Please enable it from browserstack.yml file.");
         }
       }
       /**
@@ -10054,7 +10535,7 @@ var init_testorcherstrationhandler = __esm({
       async reorderTestFiles(testFiles) {
         try {
           if (!testFiles || testFiles.length === 0) {
-            BStackLogger2.debug("[reorderTestFiles] No test files provided for ordering.");
+            BStackLogger.debug("[reorderTestFiles] No test files provided for ordering.");
             return null;
           }
           let orchestrationStrategy = null;
@@ -10063,16 +10544,16 @@ var init_testorcherstrationhandler = __esm({
             orchestrationStrategy = this.orchestrationUtils.getTestOrderingName();
           }
           if (orchestrationStrategy === null) {
-            BStackLogger2.error("Orchestration strategy is None. Cannot proceed with test orchestration session.");
+            BStackLogger.error("Orchestration strategy is None. Cannot proceed with test orchestration session.");
             return null;
           }
-          BStackLogger2.info(`Reordering test files with orchestration strategy: ${orchestrationStrategy}`);
+          BStackLogger.info(`Reordering test files with orchestration strategy: ${orchestrationStrategy}`);
           let orderedTestFiles = [];
           if (BrowserstackCLI.getInstance().isRunning()) {
-            BStackLogger2.info("Using CLI flow for test files orchestration.");
+            BStackLogger.info("Using CLI flow for test files orchestration.");
             orderedTestFiles = await GrpcClient.getInstance().testOrchestrationSession(testFiles, orchestrationStrategy, JSON.stringify(orchestrationMetadata)) || [];
           } else {
-            BStackLogger2.info("Using SDK flow for test files orchestration.");
+            BStackLogger.info("Using SDK flow for test files orchestration.");
             await this.testOrderingServerHandler.splitTests(testFiles, orchestrationStrategy, JSON.stringify(orchestrationMetadata));
             orderedTestFiles = await this.testOrderingServerHandler.getOrderedTestFiles() || [];
           }
@@ -10083,7 +10564,7 @@ var init_testorcherstrationhandler = __esm({
           this.addToOrderingInstrumentationData("splitTestsAPICallCount", this.testOrderingServerHandler.getSplitTestsApiCallCount());
           return orderedTestFiles;
         } catch (error) {
-          BStackLogger2.debug(`[reorderTestFiles] Error in ordering test classes: ${error}`);
+          BStackLogger.debug(`[reorderTestFiles] Error in ordering test classes: ${error}`);
         }
         return null;
       }
@@ -10113,22 +10594,22 @@ import { performance as performance3 } from "node:perf_hooks";
 async function applyOrchestrationIfEnabled(specs, config) {
   const orchestrationHandler = TestOrchestrationHandler.getInstance(config);
   if (!orchestrationHandler) {
-    BStackLogger2.debug("Orchestration handler is not initialized. Skipping orchestration.");
+    BStackLogger.debug("Orchestration handler is not initialized. Skipping orchestration.");
     return specs;
   }
   const runSmartSelectionEnabled = isValidEnabledValue(config?.testOrchestrationOptions?.runSmartSelection?.enabled);
   if (!runSmartSelectionEnabled) {
-    BStackLogger2.info("runSmartSelection is not enabled in config. Skipping orchestration.");
+    BStackLogger.info("runSmartSelection is not enabled in config. Skipping orchestration.");
     return specs;
   }
   orchestrationHandler.addToOrderingInstrumentationData("enabled", orchestrationHandler.testOrderingEnabled());
   const startTime = performance3.now();
-  BStackLogger2.info("Test orchestration is enabled. Attempting to reorder test files.");
+  BStackLogger.info("Test orchestration is enabled. Attempting to reorder test files.");
   const testFiles = specs;
-  BStackLogger2.info(`Test files to be reordered: ${testFiles.join(", ")}`);
+  BStackLogger.info(`Test files to be reordered: ${testFiles.join(", ")}`);
   const orderedFiles = await orchestrationHandler.reorderTestFiles(testFiles);
   if (orderedFiles && orderedFiles.length > 0) {
-    BStackLogger2.info(`Tests reordered using orchestration: ${orderedFiles.join(", ")}`);
+    BStackLogger.info(`Tests reordered using orchestration: ${orderedFiles.join(", ")}`);
     orchestrationHandler.addToOrderingInstrumentationData(
       "timeTakenToApply",
       Math.floor(performance3.now() - startTime)
@@ -10136,7 +10617,7 @@ async function applyOrchestrationIfEnabled(specs, config) {
     );
     return orderedFiles;
   }
-  BStackLogger2.info("No test files were reordered by orchestration.");
+  BStackLogger.info("No test files were reordered by orchestration.");
   orchestrationHandler.addToOrderingInstrumentationData(
     "timeTakenToApply",
     Math.floor(performance3.now() - startTime)
@@ -10158,12 +10639,12 @@ var init_apply_orchestration = __esm({
 // src/launcher.ts
 init_utils();
 init_testOpsConfig();
-import fs14 from "node:fs";
+import fs15 from "node:fs";
 import { readFile } from "node:fs/promises";
-import path20 from "node:path";
+import path21 from "node:path";
 import { promisify as promisify4, format as format4 } from "node:util";
 import { performance as performance4, PerformanceObserver as PerformanceObserver2 } from "node:perf_hooks";
-import os6 from "node:os";
+import os7 from "node:os";
 import { SevereServiceError } from "webdriverio";
 import * as BrowserstackLocalLauncher from "browserstack-local";
 
@@ -10173,9 +10654,9 @@ init_PercyLogger();
 // src/Percy/Percy.ts
 init_util();
 init_PercyLogger();
-import fs10 from "node:fs";
-import path9 from "node:path";
-import os3 from "node:os";
+import fs11 from "node:fs";
+import path10 from "node:path";
+import os4 from "node:os";
 import { spawn as spawn2 } from "node:child_process";
 
 // src/Percy/PercyBinary.ts
@@ -10185,20 +10666,20 @@ init_constants2();
 init_bstackLogger();
 init_fetchWrapper();
 import yauzl2 from "yauzl";
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 import fsp2 from "node:fs/promises";
 import { pipeline } from "node:stream/promises";
-import path8 from "node:path";
-import os2 from "node:os";
+import path9 from "node:path";
+import os3 from "node:os";
 import { spawn } from "node:child_process";
 var PercyBinary = class {
   #hostOS = process.platform;
   #httpPath = null;
   #binaryName = "percy";
   #orderedPaths = [
-    path8.join(os2.homedir(), ".browserstack"),
+    path9.join(os3.homedir(), ".browserstack"),
     process.cwd(),
-    os2.tmpdir()
+    os3.tmpdir()
   ];
   constructor() {
     const base = "https://github.com/percy/cli/releases/latest/download";
@@ -10211,15 +10692,15 @@ var PercyBinary = class {
       this.#httpPath = base + "/percy-linux.zip";
     }
   }
-  async #makePath(path21) {
-    if (await this.#checkPath(path21)) {
+  async #makePath(path22) {
+    if (await this.#checkPath(path22)) {
       return true;
     }
-    return fsp2.mkdir(path21).then(() => true).catch(() => false);
+    return fsp2.mkdir(path22).then(() => true).catch(() => false);
   }
-  async #checkPath(path21) {
+  async #checkPath(path22) {
     try {
-      const hasDir = await fsp2.access(path21).then(() => true, () => false);
+      const hasDir = await fsp2.access(path22).then(() => true, () => false);
       if (hasDir) {
         return true;
       }
@@ -10229,7 +10710,7 @@ var PercyBinary = class {
   }
   // Get the path for storing the ETag
   #getETagPath(destParentDir) {
-    return path8.join(destParentDir, `${this.#binaryName}.etag`);
+    return path9.join(destParentDir, `${this.#binaryName}.etag`);
   }
   // Load the stored ETag if it exists
   async #loadETag(destParentDir) {
@@ -10239,7 +10720,7 @@ var PercyBinary = class {
         const data = await fsp2.readFile(etagPath, "utf8");
         return data.trim();
       } catch (err) {
-        BStackLogger2.warn(`Failed to read ETag file ${err}`);
+        BStackLogger.warn(`Failed to read ETag file ${err}`);
       }
     }
     return null;
@@ -10252,23 +10733,23 @@ var PercyBinary = class {
     try {
       const etagPath = this.#getETagPath(destParentDir);
       await fsp2.writeFile(etagPath, etag);
-      BStackLogger2.debug("Saved new ETag for percy binary");
+      BStackLogger.debug("Saved new ETag for percy binary");
     } catch (err) {
-      BStackLogger2.error(`Failed to save ETag file ${err}`);
+      BStackLogger.error(`Failed to save ETag file ${err}`);
     }
   }
   async #getAvailableDirs() {
     for (let i = 0; i < this.#orderedPaths.length; i++) {
-      const path21 = this.#orderedPaths[i];
-      if (await this.#makePath(path21)) {
-        return path21;
+      const path22 = this.#orderedPaths[i];
+      if (await this.#makePath(path22)) {
+        return path22;
       }
     }
     throw new Error("Error trying to download percy binary");
   }
   async getBinaryPath() {
     const destParentDir = await this.#getAvailableDirs();
-    const binaryPath = path8.join(destParentDir, this.#binaryName);
+    const binaryPath = path9.join(destParentDir, this.#binaryName);
     let response;
     if (await this.#checkPath(binaryPath)) {
       const currentETag = await this.#loadETag(destParentDir);
@@ -10276,13 +10757,13 @@ var PercyBinary = class {
         try {
           const result = await this.#checkForUpdate(currentETag);
           if (!result.needsUpdate) {
-            BStackLogger2.debug("Percy binary is up to date (ETag unchanged)");
+            BStackLogger.debug("Percy binary is up to date (ETag unchanged)");
             return binaryPath;
           }
           response = result.response;
-          BStackLogger2.debug("New Percy binary version available, downloading update");
+          BStackLogger.debug("New Percy binary version available, downloading update");
         } catch (err) {
-          BStackLogger2.warn(`Failed to check for binary updates, using existing binary ${err}`);
+          BStackLogger.warn(`Failed to check for binary updates, using existing binary ${err}`);
           return binaryPath;
         }
       }
@@ -10310,11 +10791,11 @@ var PercyBinary = class {
       }
       const newETag = response.headers.get("eTag");
       if (newETag) {
-        await this.#saveETag(path8.dirname(this.#getETagPath(await this.#getAvailableDirs())), newETag);
+        await this.#saveETag(path9.dirname(this.#getETagPath(await this.#getAvailableDirs())), newETag);
       }
       return { needsUpdate: true, response };
     } catch (error) {
-      BStackLogger2.warn(`Error checking for Percy binary updates: ${error}`);
+      BStackLogger.warn(`Error checking for Percy binary updates: ${error}`);
       throw error;
     }
   }
@@ -10337,9 +10818,9 @@ var PercyBinary = class {
       await fsp2.mkdir(destParentDir);
     }
     const binaryName = this.#binaryName;
-    const zipFilePath = path8.join(destParentDir, binaryName + ".zip");
-    const binaryPath = path8.join(destParentDir, binaryName);
-    const downloadedFileStream = fs9.createWriteStream(zipFilePath);
+    const zipFilePath = path9.join(destParentDir, binaryName + ".zip");
+    const binaryPath = path9.join(destParentDir, binaryName);
+    const downloadedFileStream = fs10.createWriteStream(zipFilePath);
     if (!response) {
       response = await _fetch(this.#httpPath);
     }
@@ -10358,8 +10839,8 @@ var PercyBinary = class {
           if (/\/$/.test(entry.fileName)) {
             zipfile.readEntry();
           } else {
-            const writeStream = fs9.createWriteStream(
-              path8.join(destParentDir, entry.fileName)
+            const writeStream = fs10.createWriteStream(
+              path9.join(destParentDir, entry.fileName)
             );
             zipfile.openReadStream(entry, function(zipErr, readStream) {
               if (zipErr) {
@@ -10380,7 +10861,7 @@ var PercyBinary = class {
           reject(zipErr);
         });
         zipfile.once("end", () => {
-          fs9.chmod(binaryPath, "0755", function(zipErr) {
+          fs10.chmod(binaryPath, "0755", function(zipErr) {
             if (zipErr) {
               reject(zipErr);
             }
@@ -10404,7 +10885,7 @@ init_constants2();
 init_apiUtils();
 var logDir = "logs";
 var Percy = class {
-  #logfile = path9.join(logDir, "percy.log");
+  #logfile = path10.join(logDir, "percy.log");
   #address = process.env.PERCY_SERVER_ADDRESS || "http://127.0.0.1:5338";
   #binaryPath = null;
   #options;
@@ -10445,7 +10926,7 @@ var Percy = class {
   }
   async start() {
     const binaryPath = await this.#getBinaryPath();
-    const logStream = fs10.createWriteStream(this.#logfile, { flags: "a" });
+    const logStream = fs11.createWriteStream(this.#logfile, { flags: "a" });
     const token = await this.fetchPercyToken();
     const configPath = await this.createPercyConfig();
     if (!token) {
@@ -10532,13 +11013,13 @@ var Percy = class {
     if (!this.#options.percyOptions) {
       return null;
     }
-    const configPath = path9.join(os3.tmpdir(), "percy.json");
+    const configPath = path10.join(os4.tmpdir(), "percy.json");
     const percyOptions = this.#options.percyOptions;
     if (!percyOptions.version) {
       percyOptions.version = "2";
     }
     return new Promise((resolve) => {
-      fs10.writeFile(
+      fs11.writeFile(
         configPath,
         JSON.stringify(
           percyOptions
@@ -10632,6 +11113,7 @@ init_constants();
 init_util();
 init_crash_reporter();
 init_bstackLogger();
+init_caCert();
 init_PercyLogger();
 
 // src/config.ts
@@ -10639,10 +11121,62 @@ init_testOpsConfig();
 init_util();
 init_bstackLogger();
 import { v4 as uuidv4 } from "uuid";
+var APP_AUTOMATE_CAP_KEYS = ["appium:app", "appium:bundleId", "appium:appPackage", "appium:appActivity"];
+function hasAppCap(cap) {
+  if (!cap || typeof cap !== "object") {
+    return false;
+  }
+  const record = cap;
+  if (APP_AUTOMATE_CAP_KEYS.some((key) => !isUndefined(record[key]))) {
+    return true;
+  }
+  const appiumOptions = record["appium:options"];
+  return !!(appiumOptions && !isUndefined(appiumOptions.app));
+}
+function detectAppAutomate(capabilities) {
+  if (!capabilities) {
+    return false;
+  }
+  const flat = [];
+  if (Array.isArray(capabilities)) {
+    for (const entry of capabilities) {
+      if (!entry || typeof entry !== "object") {
+        continue;
+      }
+      if ("alwaysMatch" in entry) {
+        const w3c = entry;
+        flat.push(w3c.alwaysMatch);
+        if (Array.isArray(w3c.firstMatch)) {
+          flat.push(...w3c.firstMatch);
+        }
+        continue;
+      }
+      const values = Object.values(entry);
+      const isParallelMultiremote = values.length > 0 && values.every(
+        (v) => v !== null && typeof v === "object" && v.capabilities
+      );
+      if (isParallelMultiremote) {
+        for (const v of values) {
+          flat.push(v.capabilities);
+        }
+      } else {
+        flat.push(entry);
+      }
+    }
+  } else {
+    for (const v of Object.values(capabilities)) {
+      const inner = v.capabilities;
+      if (inner) {
+        flat.push(inner);
+      }
+    }
+  }
+  return flat.some(hasAppCap);
+}
 var BrowserStackConfig = class _BrowserStackConfig {
-  static getInstance(options, config) {
+  static getInstance(options, config, capabilities, isBrowserStackInfra) {
     if (!this._instance && options && config) {
-      this._instance = new _BrowserStackConfig(options, config);
+      this._instance = new _BrowserStackConfig(options, config, capabilities, isBrowserStackInfra);
     }
     return this._instance;
   }
@@ -10663,19 +11197,19 @@ var BrowserStackConfig = class _BrowserStackConfig {
   percyBuildId;
   isPercyAutoEnabled = false;
   sdkRunID;
-  constructor(options, config) {
+  constructor(options, config, capabilities, isBrowserStackInfra = true) {
     this.framework = config.framework;
     this.userName = config.user;
     this.accessKey = config.key;
     this.testObservability = new testOpsConfig_default(options.testObservability !== false, !isUndefined(options.testObservability));
     this.percy = options.percy || false;
-    this.accessibility = options.accessibility !== void 0 ? options.accessibility : null;
+    this.accessibility = options.accessibility;
     this.app = options.app;
-    this.appAutomate = !isUndefined(options.app);
-    this.automate = !this.appAutomate;
+    this.appAutomate = isBrowserStackInfra && (!isUndefined(options.app) || detectAppAutomate(capabilities));
+    this.automate = isBrowserStackInfra && !this.appAutomate;
     this.buildIdentifier = options.buildIdentifier;
     this.sdkRunID = uuidv4();
-    BStackLogger2.info(`BrowserStack service started with id: ${this.sdkRunID}`);
+    BStackLogger.info(`BrowserStack service started with id: ${this.sdkRunID}`);
   }
   sentFunnelData() {
     this.funnelDataSent = true;
@@ -10685,32 +11219,32 @@ var config_default = BrowserStackConfig;
 
 // src/exitHandler.ts
 import { spawn as spawn4 } from "node:child_process";
-import path16 from "node:path";
+import path17 from "node:path";
 
 // src/instrumentation/funnelInstrumentation.ts
 init_usageStats();
 init_bstackLogger();
 init_constants();
-import os4 from "node:os";
+import os5 from "node:os";
 import util4, { format as format2 } from "node:util";
-import path11 from "node:path";
-import fs12 from "node:fs";
+import path12 from "node:path";
+import fs13 from "node:fs";
 
 // src/data-store.ts
 init_bstackLogger();
-import path10 from "node:path";
-import fs11 from "node:fs";
-var workersDataDirPath = path10.join(process.cwd(), "logs", "worker_data");
+import path11 from "node:path";
+import fs12 from "node:fs";
+var workersDataDirPath = path11.join(process.cwd(), "logs", "worker_data");
 function getDataFromWorkers() {
   const workersData = [];
-  if (!fs11.existsSync(workersDataDirPath)) {
+  if (!fs12.existsSync(workersDataDirPath)) {
     return workersData;
   }
-  const files = fs11.readdirSync(workersDataDirPath);
+  const files = fs12.readdirSync(workersDataDirPath);
   files.forEach((file) => {
-    BStackLogger2.debug("Reading worker file " + file);
-    const filePath = path10.join(workersDataDirPath, file);
-    const fileContent = fs11.readFileSync(filePath, "utf8");
+    BStackLogger.debug("Reading worker file " + file);
+    const filePath = path11.join(workersDataDirPath, file);
+    const fileContent = fs12.readFileSync(filePath, "utf8");
     const workerData = JSON.parse(fileContent);
     workersData.push(workerData);
   });
@@ -10718,21 +11252,21 @@ function getDataFromWorkers() {
   return workersData;
 }
 function saveWorkerData(data) {
-  const filePath = path10.join(workersDataDirPath, "worker-data-" + process.pid + ".json");
+  const filePath = path11.join(workersDataDirPath, "worker-data-" + process.pid + ".json");
   try {
     createWorkersDataDir();
-    fs11.writeFileSync(filePath, JSON.stringify(data));
+    fs12.writeFileSync(filePath, JSON.stringify(data));
   } catch (e) {
-    BStackLogger2.debug("Exception in saving worker data: " + e);
+    BStackLogger.debug("Exception in saving worker data: " + e);
   }
 }
 function removeWorkersDataDir() {
-  fs11.rmSync(workersDataDirPath, { recursive: true, force: true });
+  fs12.rmSync(workersDataDirPath, { recursive: true, force: true });
   return true;
 }
 function createWorkersDataDir() {
-  if (!fs11.existsSync(workersDataDirPath)) {
-    fs11.mkdirSync(workersDataDirPath, { recursive: true });
+  if (!fs12.existsSync(workersDataDirPath)) {
+    fs12.mkdirSync(workersDataDirPath, { recursive: true });
   }
   return true;
 }
@@ -10746,16 +11280,16 @@ init_performance_tester();
 init_constants2();
 async function fireFunnelTestEvent(eventType, config, isCLIEnabled = false) {
   if (!config.userName || !config.accessKey) {
-    BStackLogger2.debug("username/accesskey not passed");
+    BStackLogger.debug("username/accesskey not passed");
     return;
   }
   try {
     const data = buildEventData(eventType, config, isCLIEnabled);
     await fireFunnelRequest(data);
-    BStackLogger2.debug("Funnel event success");
+    BStackLogger.debug("Funnel event success");
     config.sentFunnelData();
   } catch (error) {
-    BStackLogger2.debug(`Exception in sending funnel data: ${format2(error)}`);
+    BStackLogger.debug(`Exception in sending funnel data: ${format2(error)}`);
   }
 }
 async function sendStart(config) {
@@ -10780,9 +11314,9 @@ async function sendFinish(config, isCLIEnabled = false) {
 }
 function saveFunnelData(eventType, config, isCLIEnabled = false) {
   const data = buildEventData(eventType, config, isCLIEnabled);
-  BStackLogger2.ensureLogsFolder();
-  const filePath = path11.join(BStackLogger2.logFolderPath, "funnelData.json");
-  fs12.writeFileSync(filePath, JSON.stringify(data));
+  BStackLogger.ensureLogsFolder();
+  const filePath = path12.join(BStackLogger.logFolderPath, "funnelData.json");
+  fs13.writeFileSync(filePath, JSON.stringify(data));
   return filePath;
 }
 function redactCredentialsFromFunnelData(data) {
@@ -10799,7 +11333,7 @@ function redactCredentialsFromFunnelData(data) {
 async function fireFunnelRequest(data) {
   const { userName, accessKey } = data;
   redactCredentialsFromFunnelData(data);
-  BStackLogger2.debug("Sending SDK event with data " + util4.inspect(data, { depth: 6 }));
+  BStackLogger.debug("Sending SDK event with data " + util4.inspect(data, { depth: 6 }));
   const encodedAuth = Buffer.from(`${userName}:${accessKey}`, "utf8").toString("base64");
   const response = await fetchWrap(APIUtils.FUNNEL_INSTRUMENTATION_URL, {
     method: "POST",
@@ -10809,7 +11343,7 @@ async function fireFunnelRequest(data) {
     },
     body: JSON.stringify(data)
   });
-  BStackLogger2.debug("Funnel Event Response: " + JSON.stringify(await response.text()));
+  BStackLogger.debug("Funnel Event Response: " + JSON.stringify(await response.text()));
 }
 function getProductList(config) {
   const products = [];
@@ -10843,8 +11377,8 @@ function buildEventData(eventType, config, isCLIEnabled = false) {
     buildName: config.buildName || "undefined",
     buildIdentifier: String(config.buildIdentifier),
     // Host details
-    os: os4.type() || "unknown",
-    hostname: os4.hostname() || "unknown",
+    os: os5.type() || "unknown",
+    hostname: os5.hostname() || "unknown",
     // Product Details
     productMap: getProductMap(config),
     product: getProductList(config),
@@ -10894,30 +11428,30 @@ function isProxyError(authResult) {
 function handleProxyError(config, isSelfHealEnabled) {
   sendEvent.tcgProxyFailure(config);
   if (isSelfHealEnabled) {
-    BStackLogger2.warn("Proxy Error. Disabling Healing for this session.");
+    BStackLogger.warn("Proxy Error. Disabling Healing for this session.");
   }
 }
 function handleUpgradeRequired(isSelfHealEnabled) {
   if (isSelfHealEnabled) {
-    BStackLogger2.warn("Please upgrade Browserstack Service to the latest version to use the self-healing feature.");
+    BStackLogger.warn("Please upgrade Browserstack Service to the latest version to use the self-healing feature.");
   }
 }
 function handleAuthenticationFailure(status, config, isSelfHealEnabled) {
   if (status >= 500) {
     if (isSelfHealEnabled) {
-      BStackLogger2.warn("Something went wrong. Disabling healing for this session. Please try again later.");
+      BStackLogger.warn("Something went wrong. Disabling healing for this session. Please try again later.");
     }
     sendEvent.tcgDown(config);
   } else {
     if (isSelfHealEnabled) {
-      BStackLogger2.warn("Authentication Failed. Disabling Healing for this session.");
+      BStackLogger.warn("Authentication Failed. Disabling Healing for this session.");
     }
     sendEvent.tcgAuthFailure(config);
   }
 }
 function handleAuthenticationSuccess(isHealingEnabledForUser, userId, config, isSelfHealEnabled) {
   if (!isHealingEnabledForUser && isSelfHealEnabled) {
-    BStackLogger2.warn("Healing is not enabled for your group, please contact the admin");
+    BStackLogger.warn("Healing is not enabled for your group, please contact the admin");
   } else if (userId && isHealingEnabledForUser) {
     sendEvent.tcgtInitSuccessful(config);
   }
@@ -10929,7 +11463,7 @@ function handleInitializationFailure(status, config, isSelfHealEnabled) {
     sendEvent.invalidTcgAuth(config);
   }
   if (isSelfHealEnabled) {
-    BStackLogger2.warn("Authentication Failed. Healing will be disabled for this session.");
+    BStackLogger.warn("Authentication Failed. Healing will be disabled for this session.");
   }
 }
 function handleHealingInstrumentation(authResult, config, isSelfHealEnabled) {
@@ -10956,7 +11490,7 @@ function handleHealingInstrumentation(authResult, config, isSelfHealEnabled) {
       return;
     }
   } catch (err) {
-    BStackLogger2.debug("Error in handling healing instrumentation: " + err);
+    BStackLogger.debug("Error in handling healing instrumentation: " + err);
   }
 }
 
@@ -10968,36 +11502,36 @@ init_bstackLogger();
 init_cli();
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var __filename = fileURLToPath2(import.meta.url);
-var __dirname = path16.dirname(__filename);
+var __dirname = path17.dirname(__filename);
 function setupExitHandlers() {
   const handleCLICleanup = () => {
-    BStackLogger2.debug("Handling CLI cleanup in exit handler");
+    BStackLogger.debug("Handling CLI cleanup in exit handler");
     try {
       const cliProcess = BrowserstackCLI.getInstance()?.process;
       if (cliProcess && cliProcess.pid && cliProcess.exitCode === null) {
-        BStackLogger2.debug(`Found CLI process with PID ${cliProcess.pid}, terminating`);
+        BStackLogger.debug(`Found CLI process with PID ${cliProcess.pid}, terminating`);
         try {
           if (process.platform === "win32") {
             cliProcess.kill("SIGTERM");
-            BStackLogger2.debug("CLI process terminated successfully with SIGTERM (Windows)");
+            BStackLogger.debug("CLI process terminated successfully with SIGTERM (Windows)");
           } else {
             cliProcess.kill("SIGINT");
-            BStackLogger2.debug("CLI process terminated successfully with SIGINT (Unix)");
+            BStackLogger.debug("CLI process terminated successfully with SIGINT (Unix)");
           }
         } catch (processError2) {
-          BStackLogger2.debug(`CLI process termination error: ${processError2}`);
+          BStackLogger.debug(`CLI process termination error: ${processError2}`);
           try {
             cliProcess.kill();
-            BStackLogger2.debug("CLI process terminated with default signal (fallback)");
+            BStackLogger.debug("CLI process terminated with default signal (fallback)");
           } catch (fallbackError) {
-            BStackLogger2.debug(`CLI process fallback termination error: ${fallbackError}`);
+            BStackLogger.debug(`CLI process fallback termination error: ${fallbackError}`);
           }
         }
       } else {
-        BStackLogger2.debug("No CLI process found to terminate");
+        BStackLogger.debug("No CLI process found to terminate");
       }
     } catch (error) {
-      BStackLogger2.debug(`Error in CLI cleanup: ${error}`);
+      BStackLogger.debug(`Error in CLI cleanup: ${error}`);
     }
   };
   process.on("exit", () => {
@@ -11005,8 +11539,8 @@ function setupExitHandlers() {
     handleCLICleanup();
     const args = shouldCallCleanup(config_default.getInstance(), isCLIEnabled);
     if (Array.isArray(args) && args.length) {
-      BStackLogger2.debug(`Spawning cleanup.js with args: ${args.join(", ")}`);
-      const childProcess = spawn4("node", [`${path16.join(__dirname, "cleanup.js")}`, ...args], { detached: true, stdio: "inherit", env: { ...process.env } });
+      BStackLogger.debug(`Spawning cleanup.js with args: ${args.join(", ")}`);
+      const childProcess = spawn4("node", [`${path17.join(__dirname, "cleanup.js")}`, ...args], { detached: true, stdio: "inherit", env: { ...process.env } });
       childProcess.unref();
     }
   });
@@ -11032,8 +11566,8 @@ function shouldCallCleanup(config, isCLIEnabled = false) {
 // src/ai-handler.ts
 init_bstackLogger();
 init_constants();
-import path17 from "node:path";
-import fs13 from "node:fs";
+import path18 from "node:path";
+import fs14 from "node:fs";
 import url2 from "node:url";
 import aiSDK from "@browserstack/ai-sdk-node";
 init_util();
@@ -11060,7 +11594,7 @@ var AiHandler = class {
       }
     } else if (options.selfHeal === true) {
       const healingWarnMessage = authResult.message;
-      BStackLogger2.warn(`Healing Auth failed. Disabling healing for this session. Reason: ${healingWarnMessage}`);
+      BStackLogger.warn(`Healing Auth failed. Disabling healing for this session. Reason: ${healingWarnMessage}`);
     }
     return caps;
   }
@@ -11069,8 +11603,8 @@ var AiHandler = class {
   }
   async installFirefoxExtension(browser) {
     const __dirname2 = url2.fileURLToPath(new URL(".", import.meta.url));
-    const extensionPath = path17.resolve(__dirname2, aiSDK.BrowserstackHealing.getFirefoxAddonPath());
-    const extFile = fs13.readFileSync(extensionPath);
+    const extensionPath = path18.resolve(__dirname2, aiSDK.BrowserstackHealing.getFirefoxAddonPath());
+    const extFile = fs14.readFileSync(extensionPath);
     await browser.installAddOn(extFile.toString("base64"), true);
   }
   async handleHealing(orginalFunc, using, value, browser, options) {
@@ -11097,7 +11631,7 @@ var AiHandler = class {
         return result;
       }
       if (options.selfHeal === true && this.authResult.isHealingEnabled) {
-        BStackLogger2.info("findElement failed, trying to heal");
+        BStackLogger.info("findElement failed, trying to heal");
         PerformanceTester.start(AI_EVENTS.SELF_HEAL_STEP);
         const script = await aiSDK.BrowserstackHealing.healFailure(locatorType, locatorValue, void 0, void 0, this.authResult.userId, this.authResult.groupId, sessionId, void 0, void 0, this.authResult.isGroupAIEnabled, tcgDetails);
         if (script) {
@@ -11107,7 +11641,7 @@ var AiHandler = class {
           PerformanceTester.end(AI_EVENTS.SELF_HEAL_GET_RESULT);
           if (tcgData && tcgData.selector && tcgData.value) {
             const healedResult = await orginalFunc(tcgData.selector, tcgData.value);
-            BStackLogger2.info("Healing worked, element found: " + tcgData.selector + ": " + tcgData.value);
+            BStackLogger.info("Healing worked, element found: " + tcgData.selector + ": " + tcgData.value);
             PerformanceTester.end(AI_EVENTS.SELF_HEAL_STEP);
             return healedResult.error ? result : healedResult;
           }
@@ -11119,9 +11653,9 @@ var AiHandler = class {
     } catch (err) {
       PerformanceTester.end(AI_EVENTS.SELF_HEAL_STEP, false, String(err));
       if (options.selfHeal === true) {
-        BStackLogger2.warn("Something went wrong while healing. Disabling healing for this command");
+        BStackLogger.warn("Something went wrong while healing. Disabling healing for this command");
       } else {
-        BStackLogger2.warn("Error in findElement: " + err + "using: " + using + "value: " + value);
+        BStackLogger.warn("Error in findElement: " + err + "using: " + using + "value: " + value);
       }
     }
     return await orginalFunc(using, value);
@@ -11157,7 +11691,7 @@ var AiHandler = class {
       }
     } catch (err) {
       if (options.selfHeal === true) {
-        BStackLogger2.warn(`Error while initiliazing Browserstack healing Extension ${err}`);
+        BStackLogger.warn(`Error while initiliazing Browserstack healing Extension ${err}`);
       }
     }
     return caps;
@@ -11166,7 +11700,7 @@ var AiHandler = class {
     if (SUPPORTED_BROWSERS_FOR_AI.includes(browser.capabilities?.browserName?.toLowerCase())) {
       const authInfo = this.authResult;
       if (Object.keys(authInfo).length === 0 && options.selfHeal === true) {
-        BStackLogger2.debug("TCG Auth result is empty");
+        BStackLogger.debug("TCG Auth result is empty");
         return;
       }
       const { isAuthenticated, sessionToken, defaultLogDataEnabled } = authInfo;
@@ -11194,7 +11728,7 @@ var AiHandler = class {
       }
     } catch (err) {
       if (options.selfHeal === true) {
-        BStackLogger2.warn(`Error while setting up self-healing: ${err}. Disabling healing for this session.`);
+        BStackLogger.warn(`Error while setting up self-healing: ${err}. Disabling healing for this session.`);
       }
     }
   }
@@ -11212,9 +11746,10 @@ var BrowserstackLauncherService = class {
   constructor(_options, capabilities, _config) {
     this._options = _options;
     this._config = _config;
-    BStackLogger2.clearLogFile();
+    BStackLogger.clearLogFile();
     PercyLogger.clearLogFile();
     setupExitHandlers();
+    configureCaCertificate(this._options);
     if (!this._config) {
       this._config = _options;
     }
@@ -11236,12 +11771,13 @@ var BrowserstackLauncherService = class {
     if (!isUndefined(process.env.TEST_REPORTING_BUILD_TAG)) {
       process.env.TEST_OBSERVABILITY_BUILD_TAG = process.env.TEST_REPORTING_BUILD_TAG;
     }
-    this.browserStackConfig = config_default.getInstance(_options, _config);
-    BStackLogger2.debug(`_options data: ${JSON.stringify(_options)}`);
-    BStackLogger2.debug(`webdriver capabilities data: ${JSON.stringify(capabilities)}`);
+    const isBrowserStackInfra = isBrowserstackInfra(_config, capabilities);
+    this.browserStackConfig = config_default.getInstance(_options, _config, capabilities, isBrowserStackInfra);
+    BStackLogger.debug(`_options data: ${JSON.stringify(_options)}`);
+    BStackLogger.debug(`webdriver capabilities data: ${JSON.stringify(capabilities)}`);
     const configCopy = JSON.parse(JSON.stringify(_config));
     CrashReporter.recursivelyRedactKeysFromObject(configCopy, ["user", "username", "key", "accesskey", "password"]);
-    BStackLogger2.debug(`_config data: ${JSON.stringify(configCopy)}`);
+    BStackLogger.debug(`_config data: ${JSON.stringify(configCopy)}`);
     if (Array.isArray(capabilities)) {
       capabilities.flatMap((c) => {
         if ("alwaysMatch" in c) {
@@ -11328,7 +11864,7 @@ var BrowserstackLauncherService = class {
     try {
       CrashReporter.setConfigDetails(this._config, capabilities, this._options);
     } catch (error) {
-      BStackLogger2.error(`[Crash_Report_Upload] Config processing failed due to ${error}`);
+      BStackLogger.error(`[Crash_Report_Upload] Config processing failed due to ${error}`);
     }
   }
   browserstackLocal;
@@ -11336,7 +11872,7 @@ var BrowserstackLauncherService = class {
   _projectName;
   _buildTag;
   _buildIdentifier;
-  _accessibilityAutomation = null;
+  _accessibilityAutomation;
   _percy;
   _percyBestPlatformCaps;
   browserStackConfig;
@@ -11358,7 +11894,7 @@ var BrowserstackLauncherService = class {
     if (config.specs && Array.isArray(config.specs) && isValidEnabledValue(this._options.testOrchestrationOptions?.runSmartSelection?.enabled)) {
       try {
         const glob = (await import("glob")).sync;
-        const path21 = await import("node:path");
+        const path22 = await import("node:path");
         const expandedSpecs = [];
         for (const specPattern of config.specs) {
           if (typeof specPattern === "string") {
@@ -11375,21 +11911,21 @@ var BrowserstackLauncherService = class {
             }) || [];
             filenames.forEach((filename) => {
               let absolutePath = filename;
-              if (!path21.isAbsolute(filename)) {
-                absolutePath = path21.resolve(rootDir, filename);
+              if (!path22.isAbsolute(filename)) {
+                absolutePath = path22.resolve(rootDir, filename);
               }
-              let relativePath = path21.relative(cwd, absolutePath);
+              let relativePath = path22.relative(cwd, absolutePath);
               relativePath = relativePath.replace(/\\/g, "/");
               expandedSpecs.push(relativePath);
             });
           }
         }
         if (expandedSpecs.length > 0) {
-          BStackLogger2.info(`Expanded specs from glob patterns to ${expandedSpecs.length} files`);
+          BStackLogger.info(`Expanded specs from glob patterns to ${expandedSpecs.length} files`);
           config.specs = expandedSpecs;
         }
       } catch (error) {
-        BStackLogger2.error(`Failed to expand spec patterns: ${error}`);
+        BStackLogger.error(`Failed to expand spec patterns: ${error}`);
       }
     }
     try {
@@ -11400,11 +11936,11 @@ var BrowserstackLauncherService = class {
         CLIUtils.setFrameworkDetail(WDIO_NAMING_PREFIX + config.framework, "WebdriverIO");
         const binconfig = CLIUtils.getBinConfig(config, capabilities, this._options, this._buildTag);
         await BrowserstackCLI.getInstance().bootstrap(this._options, config, binconfig);
-        BStackLogger2.debug(`Is CLI running ${BrowserstackCLI.getInstance().isRunning()}`);
+        BStackLogger.debug(`Is CLI running ${BrowserstackCLI.getInstance().isRunning()}`);
         PerformanceTester.end(FRAMEWORK_EVENTS.START);
       }
     } catch (err) {
-      BStackLogger2.error(`Error while starting CLI ${err}`);
+      BStackLogger.error(`Error while starting CLI ${err}`);
       PerformanceTester.end(FRAMEWORK_EVENTS.START, false, format4(err));
     }
     PerformanceTester.end(FRAMEWORK_EVENTS.INIT);
@@ -11423,13 +11959,13 @@ var BrowserstackLauncherService = class {
         }
       } catch (err) {
         if (this._options.selfHeal === true) {
-          BStackLogger2.warn(`Error while setting up Browserstack healing Extension ${err}. Disabling healing for this session.`);
+          BStackLogger.warn(`Error while setting up Browserstack healing Extension ${err}. Disabling healing for this session.`);
         }
       }
     }
     if (!BrowserstackCLI.getInstance().isRunning()) {
       if (!this._options.app) {
-        BStackLogger2.debug("app is not defined in browserstack-service config, skipping ...");
+        BStackLogger.debug("app is not defined in browserstack-service config, skipping ...");
       } else {
         let app = {};
         const appConfig = this._options.app;
@@ -11438,10 +11974,10 @@ var BrowserstackLauncherService = class {
         } catch (error) {
           throw new SevereServiceError(error.message);
         }
-        if (VALID_APP_EXTENSION.includes(path20.extname(app.app))) {
-          if (fs14.existsSync(app.app)) {
+        if (VALID_APP_EXTENSION.includes(path21.extname(app.app))) {
+          if (fs15.existsSync(app.app)) {
             const data = await this._uploadApp(app);
-            BStackLogger2.info(`app upload completed: ${JSON.stringify(data)}`);
+            BStackLogger.info(`app upload completed: ${JSON.stringify(data)}`);
             app.app = data.app_url;
           } else if (app.customId) {
             app.app = app.customId;
@@ -11449,7 +11985,7 @@ var BrowserstackLauncherService = class {
             throw new SevereServiceError(`[Invalid app path] app path ${app.app} is not correct, Provide correct path to app under test`);
           }
         }
-        BStackLogger2.info(`Using app: ${app.app}`);
+        BStackLogger.info(`Using app: ${app.app}`);
         this._updateCaps(capabilities, "app", app.app);
       }
     }
@@ -11462,7 +11998,7 @@ var BrowserstackLauncherService = class {
     const shouldSetupPercy = this._options.percy || isUndefined(this._options.percy) && this._options.app;
     let buildStartResponse = null;
     if (!BrowserstackCLI.getInstance().isRunning() && (this._options.testObservability || this._accessibilityAutomation || shouldSetupPercy)) {
-      BStackLogger2.debug("Sending launch start event");
+      BStackLogger.debug("Sending launch start event");
       buildStartResponse = await launchTestSession(this._options, this._config, {
         projectName: this._projectName,
         buildName: this._buildName,
@@ -11476,7 +12012,7 @@ var BrowserstackLauncherService = class {
       this._updateObjectTypeCaps(capabilities, "goog:chromeOptions", overrideOptions);
     }
     if (buildStartResponse?.accessibility) {
-      if (this._accessibilityAutomation === null) {
+      if (isUndefined(this._accessibilityAutomation)) {
         this.browserStackConfig.accessibility = buildStartResponse.accessibility.success;
         this._accessibilityAutomation = buildStartResponse.accessibility.success;
         this._options.accessibility = buildStartResponse.accessibility.success;
@@ -11497,6 +12033,7 @@ var BrowserstackLauncherService = class {
     } else if (isAccessibilityAutomationSession(this._accessibilityAutomation)) {
       this._updateObjectTypeCaps(capabilities, "accessibilityOptions", {});
     }
+    this._removeCliOnlyCapabilityOptions(capabilities);
     if (shouldSetupPercy) {
       try {
         const bestPlatformPercyCaps = getBestPlatformForPercySnapshot(capabilities);
@@ -11520,15 +12057,15 @@ var BrowserstackLauncherService = class {
           if (typeof spec !== "string") {
             return spec;
           }
-          const absolutePath = path20.isAbsolute(spec) ? spec : path20.resolve(cwd, spec);
-          const relativePath = path20.relative(rootDir, absolutePath);
+          const absolutePath = path21.isAbsolute(spec) ? spec : path21.resolve(cwd, spec);
+          const relativePath = path21.relative(rootDir, absolutePath);
           return relativePath.replace(/\\/g, "/");
         });
       };
       try {
         const { applyOrchestrationIfEnabled: applyOrchestrationIfEnabled2 } = await Promise.resolve().then(() => (init_apply_orchestration(), apply_orchestration_exports));
         if (config.specs && config.specs.length > 0 && this._options.testObservability && isValidEnabledValue(this._options.testOrchestrationOptions?.runSmartSelection?.enabled)) {
-          BStackLogger2.info("Applying test orchestration");
+          BStackLogger.info("Applying test orchestration");
           const specs = config.specs.filter((spec) => typeof spec === "string");
           console.log(`Specs before orchestration: ${specs}`);
           const orderedSpecs = await applyOrchestrationIfEnabled2(specs, this._options);
@@ -11536,14 +12073,14 @@ var BrowserstackLauncherService = class {
           const specsToConvert = orderedSpecs && orderedSpecs.length > 0 ? orderedSpecs : specs;
           config.specs = convertToRootDirRelative(specsToConvert);
           console.log(`Specs after orchestration: ${config.specs}`);
-          BStackLogger2.info("Test specs updated with orchestrated order");
+          BStackLogger.info("Test specs updated with orchestrated order");
         }
       } catch (error) {
-        BStackLogger2.error(`Error applying test orchestration: ${error}`);
+        BStackLogger.error(`Error applying test orchestration: ${error}`);
         if (config.specs && config.specs.length > 0) {
           const specs = config.specs.filter((spec) => typeof spec === "string");
           config.specs = convertToRootDirRelative(specs);
-          BStackLogger2.debug(`Specs converted back to rootDir-relative after error: ${config.specs}`);
+          BStackLogger.debug(`Specs converted back to rootDir-relative after error: ${config.specs}`);
         }
       }
     }
@@ -11551,7 +12088,7 @@ var BrowserstackLauncherService = class {
       return;
     }
     if (!this._options.browserstackLocal) {
-      return BStackLogger2.info("browserstackLocal is not enabled - skipping...");
+      return BStackLogger.info("browserstackLocal is not enabled - skipping...");
     }
     const opts = {
       key: this._config.key,
@@ -11564,7 +12101,7 @@ var BrowserstackLauncherService = class {
     }
     const obs = new PerformanceObserver2((list) => {
       const entry = list.getEntries()[0];
-      BStackLogger2.info(`Browserstack Local successfully started after ${entry.duration}ms`);
+      BStackLogger.info(`Browserstack Local successfully started after ${entry.duration}ms`);
     });
     obs.observe({ entryTypes: ["measure"] });
     let timer;
@@ -11597,13 +12134,13 @@ var BrowserstackLauncherService = class {
     PerformanceTester.start(FRAMEWORK_EVENTS.STOP);
     try {
       const isCLIEnabled = BrowserstackCLI.getInstance().isRunning();
-      BStackLogger2.debug("Inside OnComplete hook..");
-      BStackLogger2.debug("Sending stop launch event");
+      BStackLogger.debug("Inside OnComplete hook..");
+      BStackLogger.debug("Sending stop launch event");
       try {
         await (isCLIEnabled ? BrowserstackCLI.getInstance().stop() : stopBuildUpstream());
         PerformanceTester.end(FRAMEWORK_EVENTS.STOP);
       } catch (err) {
-        BStackLogger2.error(`Error while stopping CLI ${err}`);
+        BStackLogger.error(`Error while stopping CLI ${err}`);
         PerformanceTester.end(FRAMEWORK_EVENTS.STOP, false, format4(err));
       }
       if (process.env[BROWSERSTACK_OBSERVABILITY] && process.env[BROWSERSTACK_TESTHUB_UUID]) {
@@ -11619,16 +12156,16 @@ Visit https://automation.browserstack.com/builds/${process.env[BROWSERSTACK_TEST
           return;
         }
         const duration = (/* @__PURE__ */ new Date()).getTime() - new Date(process.env.START_TIME).getTime();
-        BStackLogger2.info(`Total duration is ${duration / 1e3} s`);
+        BStackLogger.info(`Total duration is ${duration / 1e3} s`);
       }
-      BStackLogger2.info(`BrowserStack service run ended for id: ${this.browserStackConfig?.sdkRunID} testhub id: ${testOpsConfig_default.getInstance()?.buildHashedId}`);
+      BStackLogger.info(`BrowserStack service run ended for id: ${this.browserStackConfig?.sdkRunID} testhub id: ${testOpsConfig_default.getInstance()?.buildHashedId}`);
       await sendFinish(this.browserStackConfig, isCLIEnabled);
       try {
         PerformanceTester.start(EVENTS.SDK_SEND_LOGS);
         await this._uploadServiceLogs();
         PerformanceTester.end(EVENTS.SDK_SEND_LOGS);
       } catch (error) {
-        BStackLogger2.debug(`Failed to upload BrowserStack WDIO Service logs ${error}`);
+        BStackLogger.debug(`Failed to upload BrowserStack WDIO Service logs ${error}`);
         PerformanceTester.end(EVENTS.SDK_SEND_LOGS, false, format4(error));
       }
       PerformanceTester.end(EVENTS.SDK_ON_STOP);
@@ -11638,9 +12175,9 @@ Visit https://automation.browserstack.com/builds/${process.env[BROWSERSTACK_TEST
       PerformanceTester.end(EVENTS.SDK_ON_STOP, false, format4(error));
       PerformanceTester.end(EVENTS.SDK_CLEANUP, false, format4(error));
       await PerformanceTester.stopAndGenerate("performance-launcher.html");
-      BStackLogger2.error(`Error in onComplete hook: ${error}`);
+      BStackLogger.error(`Error in onComplete hook: ${error}`);
     }
-    BStackLogger2.clearLogger();
+    BStackLogger.clearLogger();
     if (this._options.percy) {
       await this.stopPercy();
       PercyLogger.clearLogger();
@@ -11724,10 +12261,10 @@ Visit https://automation.browserstack.com/builds/${process.env[BROWSERSTACK_TEST
     }
   }
   async _uploadApp(app) {
-    BStackLogger2.info(`uploading app ${app.app} ${app.customId ? `and custom_id: ${app.customId}` : ""} to browserstack`);
+    BStackLogger.info(`uploading app ${app.app} ${app.customId ? `and custom_id: ${app.customId}` : ""} to browserstack`);
     const form = new FormData();
     if (app.app) {
-      const fileName = path20.basename(app.app);
+      const fileName = path21.basename(app.app);
       const fileBuffer = await readFile(app.app);
       const fileBlob = new Blob([new Uint8Array(fileBuffer)]);
       form.append("file", fileBlob, fileName);
@@ -11774,13 +12311,40 @@ Visit https://automation.browserstack.com/builds/${process.env[BROWSERSTACK_TEST
   }
   async _uploadServiceLogs() {
     const clientBuildUuid = this._getClientBuildUuid();
-    await PerformanceTester.measureWrapper(EVENTS.SDK_UPLOAD_LOGS, async () => {
-      const response = await uploadLogs(getBrowserStackUser(this._config), getBrowserStackKey(this._config), clientBuildUuid);
-      if (response) {
-        BStackLogger2.info(`Upload response: ${JSON.stringify(response, null, 2)}`);
-        BStackLogger2.logToFile(`Response - ${format4(response)}`, "debug");
+    const response = await uploadLogs(getBrowserStackUser(this._config), getBrowserStackKey(this._config), clientBuildUuid);
+    if (response) {
+      BStackLogger.info(`Upload response: ${JSON.stringify(response, null, 2)}`);
+      BStackLogger.logToFile(`Response - ${format4(response)}`, "debug");
+    }
+  }
+  _removeCliOnlyCapabilityOptions(capabilities) {
+    if (!capabilities || typeof capabilities !== "object") {
+      return;
+    }
+    const strip = (capability) => {
+      const capabilityRecord = capability;
+      const bstackOptions = capabilityRecord["bstack:options"];
+      if (bstackOptions && typeof bstackOptions === "object") {
+        NOT_ALLOWED_KEYS_IN_CAPS.forEach((key) => delete bstackOptions[key]);
       }
-    });
+      NOT_ALLOWED_KEYS_IN_CAPS.forEach((key) => delete capabilityRecord[`browserstack.${key}`]);
+      const alwaysMatch = capability.alwaysMatch;
+      if (alwaysMatch && typeof alwaysMatch === "object") {
+        strip(alwaysMatch);
+      }
+    };
+    if (Array.isArray(capabilities)) {
+      capabilities.flatMap((c) => {
+        if (Object.values(c).length > 0 && Object.values(c).every((c2) => typeof c2 === "object" && c2.capabilities)) {
+          return Object.values(c).map((o) => o.capabilities);
+        }
+        return c;
+      }).forEach(strip);
+    } else {
+      Object.entries(capabilities).forEach(([, caps]) => {
+        strip(caps.capabilities);
+      });
+    }
   }
   _updateObjectTypeCaps(capabilities, capType, value) {
     try {
@@ -11883,7 +12447,7 @@ Visit https://automation.browserstack.com/builds/${process.env[BROWSERSTACK_TEST
         });
       }
     } catch (error) {
-      BStackLogger2.debug(`Exception while retrieving capability value. Error - ${error}`);
+      BStackLogger.debug(`Exception while retrieving capability value. Error - ${error}`);
     }
   }
   _updateCaps(capabilities, capType, value) {
@@ -12019,7 +12583,7 @@ Visit https://automation.browserstack.com/builds/${process.env[BROWSERSTACK_TEST
     }
     if ((!this._buildName || process.env.BROWSERSTACK_BUILD_NAME) && this._buildIdentifier) {
       this._updateCaps(capabilities, "buildIdentifier");
-      BStackLogger2.warn("Skipping buildIdentifier as buildName is not passed.");
+      BStackLogger.warn("Skipping buildIdentifier as buildName is not passed.");
       return;
     }
     if (this._buildIdentifier && this._buildIdentifier.includes("${DATE_TIME}")) {
@@ -12062,16 +12626,16 @@ Visit https://automation.browserstack.com/builds/${process.env[BROWSERSTACK_TEST
    *                  else returns corresponding value in json file (e.g. { "wdio-build": { "identifier" : 2 } } => 2 in this case)
    */
   _getLocalBuildNumber() {
-    const browserstackFolderPath = path20.join(os6.homedir(), ".browserstack");
+    const browserstackFolderPath = path21.join(os7.homedir(), ".browserstack");
     try {
-      if (!fs14.existsSync(browserstackFolderPath)) {
-        fs14.mkdirSync(browserstackFolderPath);
+      if (!fs15.existsSync(browserstackFolderPath)) {
+        fs15.mkdirSync(browserstackFolderPath);
       }
-      const filePath = path20.join(browserstackFolderPath, ".build-name-cache.json");
-      if (!fs14.existsSync(filePath)) {
-        fs14.appendFileSync(filePath, JSON.stringify({}));
+      const filePath = path21.join(browserstackFolderPath, ".build-name-cache.json");
+      if (!fs15.existsSync(filePath)) {
+        fs15.appendFileSync(filePath, JSON.stringify({}));
       }
-      const buildCacheFileData = fs14.readFileSync(filePath);
+      const buildCacheFileData = fs15.readFileSync(filePath);
       const parsedBuildCacheFileData = JSON.parse(buildCacheFileData.toString());
       if (this._buildName && this._buildName in parsedBuildCacheFileData) {
         const prevIdentifier = parseInt(parsedBuildCacheFileData[this._buildName].identifier);
@@ -12090,16 +12654,16 @@ Visit https://automation.browserstack.com/builds/${process.env[BROWSERSTACK_TEST
     if (!buildName || !filePath) {
       return;
     }
-    const jsonContent = JSON.parse(fs14.readFileSync(filePath).toString());
+    const jsonContent = JSON.parse(fs15.readFileSync(filePath).toString());
     jsonContent[buildName] = { "identifier": buildIdentifier };
-    fs14.writeFileSync(filePath, JSON.stringify(jsonContent));
+    fs15.writeFileSync(filePath, JSON.stringify(jsonContent));
   }
   _getClientBuildUuid() {
     if (process.env[BROWSERSTACK_TESTHUB_UUID]) {
       return process.env[BROWSERSTACK_TESTHUB_UUID];
     }
     const uuid = this.browserStackConfig?.sdkRunID;
-    BStackLogger2.logToFile(`If facing any issues, please contact BrowserStack support with the Build Run Id - ${uuid}`, "info");
+    BStackLogger.logToFile(`If facing any issues, please contact BrowserStack support with the Build Run Id - ${uuid}`, "info");
     return uuid;
   }
 };
@@ -12121,6 +12685,7 @@ init_util();
 init_insights_handler();
 init_reporter();
 init_constants();
+init_caCert();
 init_crash_reporter();
 
 // src/accessibility-handler.ts
@@ -12244,7 +12809,7 @@ var _AccessibilityHandler = class {
     };
     browserWithA11y.startA11yScanning = async () => {
       if (this._testIdentifier === null) {
-        BStackLogger2.warn("Accessibility scanning cannot be started from outside the test");
+        BStackLogger.warn("Accessibility scanning cannot be started from outside the test");
         return;
       }
       AccessibilityHandler._a11yScanSessionMap[sessionId] = true;
@@ -12256,7 +12821,7 @@ var _AccessibilityHandler = class {
     };
     browserWithA11y.stopA11yScanning = async () => {
       if (this._testIdentifier === null) {
-        BStackLogger2.warn("Accessibility scanning cannot be stopped from outside the test");
+        BStackLogger.warn("Accessibility scanning cannot be stopped from outside the test");
         return;
       }
       AccessibilityHandler._a11yScanSessionMap[sessionId] = false;
@@ -12275,7 +12840,7 @@ var _AccessibilityHandler = class {
         const prevImpl = orig ? orig.bind(browser) : void 0;
         browser.overwriteCommand(command.name, this.commandWrapper.bind(this, command, prevImpl), command.class === "Element");
       } catch (error) {
-        BStackLogger2.debug(`Exception in overwrite command ${command.name} - ${error}`);
+        BStackLogger.debug(`Exception in overwrite command ${command.name} - ${error}`);
       }
     });
     PerformanceTester.end(CONFIG_EVENTS.ACCESSIBILITY);
@@ -12299,14 +12864,14 @@ var _AccessibilityHandler = class {
       };
       this._testMetadata[testIdentifier].accessibilityScanStarted = shouldScanTest;
       if (shouldScanTest) {
-        BStackLogger2.info("Automate test case execution has started.");
+        BStackLogger.info("Automate test case execution has started.");
       }
     } catch (error) {
-      BStackLogger2.error(`Exception in starting accessibility automation scan for this test case ${error}`);
+      BStackLogger.error(`Exception in starting accessibility automation scan for this test case ${error}`);
     }
   }
   async afterTest(suiteTitle, test) {
-    BStackLogger2.debug("Accessibility after test hook. Before sending test stop event");
+    BStackLogger.debug("Accessibility after test hook. Before sending test stop event");
     if (this._framework !== "mocha" || !this.shouldRunTestHooks(this._browser, this._accessibility)) {
       return;
     }
@@ -12318,17 +12883,17 @@ var _AccessibilityHandler = class {
         return;
       }
       if (shouldScanTestForAccessibility2) {
-        BStackLogger2.info("Automate test case execution has ended. Processing for accessibility testing is underway. ");
+        BStackLogger.info("Automate test case execution has ended. Processing for accessibility testing is underway. ");
         const dataForExtension = {
           "thTestRunUuid": process.env.TEST_ANALYTICS_ID,
           "thBuildUuid": process.env.BROWSERSTACK_TESTHUB_UUID,
           "thJwtToken": process.env.BROWSERSTACK_TESTHUB_JWT
         };
         await this.sendTestStopEvent(this._browser, dataForExtension);
-        BStackLogger2.info("Accessibility testing for this test case has ended.");
+        BStackLogger.info("Accessibility testing for this test case has ended.");
       }
     } catch (error) {
-      BStackLogger2.error(`Accessibility results could not be processed for the test case ${test.title}. Error : ${error}`);
+      BStackLogger.error(`Accessibility results could not be processed for the test case ${test.title}. Error : ${error}`);
     }
   }
   /**
@@ -12356,14 +12921,14 @@ var _AccessibilityHandler = class {
       }
       listener_default.setTestRunAccessibilityVar(this._accessibility && shouldScanScenario);
       if (shouldScanScenario) {
-        BStackLogger2.info("Automate test case execution has started.");
+        BStackLogger.info("Automate test case execution has started.");
       }
     } catch (error) {
-      BStackLogger2.error(`Exception in starting accessibility automation scan for this test case ${error}`);
+      BStackLogger.error(`Exception in starting accessibility automation scan for this test case ${error}`);
     }
   }
   async afterScenario(world) {
-    BStackLogger2.debug("Accessibility after scenario hook. Before sending test stop event");
+    BStackLogger.debug("Accessibility after scenario hook. Before sending test stop event");
     if (!this.shouldRunTestHooks(this._browser, this._accessibility)) {
       return;
     }
@@ -12376,17 +12941,17 @@ var _AccessibilityHandler = class {
         return;
       }
       if (shouldScanTestForAccessibility2) {
-        BStackLogger2.info("Automate test case execution has ended. Processing for accessibility testing is underway. ");
+        BStackLogger.info("Automate test case execution has ended. Processing for accessibility testing is underway. ");
         const dataForExtension = {
           "thTestRunUuid": process.env.TEST_ANALYTICS_ID,
           "thBuildUuid": process.env.BROWSERSTACK_TESTHUB_UUID,
           "thJwtToken": process.env.BROWSERSTACK_TESTHUB_JWT
         };
         await this.sendTestStopEvent(this._browser, dataForExtension);
-        BStackLogger2.info("Accessibility testing for this test case has ended.");
+        BStackLogger.info("Accessibility testing for this test case has ended.");
       }
     } catch (error) {
-      BStackLogger2.error(`Accessibility results could not be processed for the test case ${pickleData.name}. Error : ${error}`);
+      BStackLogger.error(`Accessibility results could not be processed for the test case ${pickleData.name}. Error : ${error}`);
     }
   }
   /*
@@ -12394,14 +12959,14 @@ var _AccessibilityHandler = class {
    */
   async commandWrapper(command, prevImpl, origFunction, ...args) {
     if (this._sessionId && AccessibilityHandler._a11yScanSessionMap[this._sessionId] && (!command.name.includes("execute") || !AccessibilityHandler.shouldPatchExecuteScript(args.length ? args[0] : null))) {
-      BStackLogger2.debug(`Performing scan for ${command.class} ${command.name}`);
+      BStackLogger.debug(`Performing scan for ${command.class} ${command.name}`);
       await performA11yScan(this.isAppAutomate, this._browser, true, true, command.name);
     }
     const impl = prevImpl || origFunction;
     return impl(...args);
   }
   async sendTestStopEvent(browser, dataForExtension) {
-    BStackLogger2.debug("Performing scan before saving results");
+    BStackLogger.debug("Performing scan before saving results");
     if (AccessibilityHandler._a11yScanSessionMap[this._sessionId]) {
       await PerformanceTester.measureWrapper(A11Y_EVENTS.PERFORM_SCAN, async () => {
         await performA11yScan(this.isAppAutomate, browser, true, true);
@@ -12413,9 +12978,9 @@ var _AccessibilityHandler = class {
     await PerformanceTester.measureWrapper(A11Y_EVENTS.SAVE_RESULTS, async () => {
       if (accessibility_scripts_default.saveTestResults) {
         const results = await executeAccessibilityScript(browser, accessibility_scripts_default.saveTestResults, dataForExtension);
-        BStackLogger2.debug(util11.format(results));
+        BStackLogger.debug(util11.format(results));
       } else {
-        BStackLogger2.error("saveTestResults script is null or undefined");
+        BStackLogger.error("saveTestResults script is null or undefined");
       }
     })();
   }
@@ -12492,6 +13057,7 @@ var BrowserstackService = class {
     this._caps = _caps;
     this._config = _config;
     this._options = { ...DEFAULT_OPTIONS, ...options };
+    configureCaCertificate(this._options);
     if (!this._config) {
       this._config = this._options;
     }
@@ -12571,24 +13137,33 @@ var BrowserstackService = class {
           PerformanceTester.end(EVENTS.SDK_FIND_NEAREST_HUB, false, "Hub URL not found");
         }
       }
-      if (BrowserstackCLI.getInstance().isRunning()) {
-        await BrowserstackCLI.getInstance().getAutomationFramework().trackEvent(AutomationFrameworkState.CREATE, HookState.PRE, { caps: capabilities });
-        const instance = AutomationFramework.getTrackedInstance();
-        const caps = AutomationFramework.getState(instance, AutomationFrameworkConstants.KEY_CAPABILITIES);
-        Object.assign(capabilities, caps);
+      try {
+        if (BrowserstackCLI.getInstance().isRunning()) {
+          await BrowserstackCLI.getInstance().getAutomationFramework().trackEvent(AutomationFrameworkState.CREATE, HookState.PRE, { caps: capabilities });
+          const instance = AutomationFramework.getTrackedInstance();
+          const caps = AutomationFramework.getState(instance, AutomationFrameworkConstants.KEY_CAPABILITIES);
+          Object.assign(capabilities, caps);
+          const bstackOptions = capabilities["bstack:options"];
+          if (bstackOptions && typeof bstackOptions === "object") {
+            NOT_ALLOWED_KEYS_IN_CAPS.forEach((key) => delete bstackOptions[key]);
+          }
+          NOT_ALLOWED_KEYS_IN_CAPS.forEach((key) => delete capabilities[`browserstack.${key}`]);
+        }
+      } catch (err) {
+        BStackLogger.error(`Error while tracking automation framework event: ${err}`);
       }
     } catch (err) {
-      BStackLogger2.error(`Error while connecting to Browserstack CLI: ${err}`);
+      BStackLogger.error(`Error while connecting to Browserstack CLI: ${err}`);
       PerformanceTester.end(DRIVER_EVENT.INIT, false, util12.format(err));
       throw err;
     }
     PerformanceTester.end(DRIVER_EVENT.INIT);
     PerformanceTester.start(EVENTS.SDK_DEVICE_ALLOCATION);
-    BStackLogger2.debug("Device allocation tracking started - waiting for WebDriverIO to create remote session");
+    BStackLogger.debug("Device allocation tracking started - waiting for WebDriverIO to create remote session");
   }
   async before(caps, specs, browser) {
     PerformanceTester.end(EVENTS.SDK_DEVICE_ALLOCATION, true, "Device allocated and session created");
-    BStackLogger2.debug("Device allocation tracking ended - remote session created successfully");
+    BStackLogger.debug("Device allocation tracking ended - remote session created successfully");
     PerformanceTester.start(DRIVER_EVENT.PRE_INITIALIZE);
     this._browser = browser ? browser : globalThis.browser;
     PerformanceTester.browser = this._browser;
@@ -12597,7 +13172,7 @@ var BrowserstackService = class {
         await ai_handler_default.selfHeal(this._options, caps, this._browser);
       } catch (err) {
         if (this._options.selfHeal === true) {
-          BStackLogger2.warn(`Error while setting up self-healing: ${err}. Disabling healing for this session.`);
+          BStackLogger.warn(`Error while setting up self-healing: ${err}. Disabling healing for this session.`);
         }
       }
     }
@@ -12627,13 +13202,13 @@ var BrowserstackService = class {
             this._options.accessibilityOptions
           );
           if (isBrowserstackSession(this._browser) && BrowserstackCLI.getInstance().isRunning()) {
-            BStackLogger2.info(`CLI is running, tracking accessibility event for before: ${sessionId}`);
+            BStackLogger.info(`CLI is running, tracking accessibility event for before: ${sessionId}`);
           } else {
             await this._accessibilityHandler.before(sessionId);
           }
           listener_default.setAccessibilityOptions(this._options.accessibilityOptions);
         } catch (err) {
-          BStackLogger2.error(`[Accessibility Test Run] Error in service class before function: ${err}`);
+          BStackLogger.error(`[Accessibility Test Run] Error in service class before function: ${err}`);
         }
         if (shouldProcessEventForTesthub("")) {
           patchConsoleLogs();
@@ -12644,7 +13219,7 @@ var BrowserstackService = class {
             this._options
           );
           if (BrowserstackCLI.getInstance().isRunning()) {
-            BStackLogger2.info(`CLI is running, tracking insights event for before: ${sessionId}`);
+            BStackLogger.info(`CLI is running, tracking insights event for before: ${sessionId}`);
             await BrowserstackCLI.getInstance().getAutomationFramework().trackEvent(AutomationFrameworkState.CREATE, HookState.POST, { browser: this._browser, hubUrl: this._config.hostname });
             this._insightsHandler.setGitConfigPath();
             PerformanceTester.end(DRIVER_EVENT.PRE_INITIALIZE);
@@ -12679,7 +13254,7 @@ var BrowserstackService = class {
           });
         }
       } catch (err) {
-        BStackLogger2.error(`Error in service class before function: ${err}`);
+        BStackLogger.error(`Error in service class before function: ${err}`);
         if (shouldProcessEventForTesthub("")) {
           CrashReporter.uploadCrashReport(`Error in service class before function: ${err}`, err ? err.stack : "unknown error");
         }
@@ -12752,8 +13327,8 @@ var BrowserstackService = class {
   }
   async afterTest(test, context, results) {
     this._specsRan = true;
-    const { error, passed } = results;
-    if (!passed) {
+    const { error, passed, skipped } = results;
+    if (!passed && !skipped) {
       const testError = error && error.message || "Unknown Error";
       this._failReasons.push(testError);
       this._pureTestFailReasons.push(testError);
@@ -12863,7 +13438,7 @@ var BrowserstackService = class {
         return;
       }
     } catch (error) {
-      BStackLogger2.error(`Error in after hook: ${error}`);
+      BStackLogger.error(`Error in after hook: ${error}`);
       PerformanceTester.end(DRIVER_EVENT.QUIT, false, util12.format(error));
       PerformanceTester.end(HOOK_EVENTS.AFTER, false, util12.format(error));
       await PerformanceTester.stopAndGenerate("performance-service.html");
@@ -12934,14 +13509,14 @@ var BrowserstackService = class {
       failureReason = hasReasons ? this._failReasons.join("\n") : void 0;
     }
     if (!this._browser.isMultiremote) {
-      BStackLogger2.info(`Update (reloaded) job with sessionId ${oldSessionId}, ${sessionStatus}`);
+      BStackLogger.info(`Update (reloaded) job with sessionId ${oldSessionId}, ${sessionStatus}`);
     } else {
       const browserName = this._browser.instances.filter(
         (browserName2) => this._browser && this._browser.getInstance(browserName2).sessionId === newSessionId
       )[0];
-      BStackLogger2.info(`Update (reloaded) multiremote job for browser "${browserName}" and sessionId ${oldSessionId}, ${sessionStatus}`);
+      BStackLogger.info(`Update (reloaded) multiremote job for browser "${browserName}" and sessionId ${oldSessionId}, ${sessionStatus}`);
     }
-    BStackLogger2.warn(`Session Reloaded: Old Session Id: ${oldSessionId}, New Session Id: ${newSessionId}`);
+    BStackLogger.warn(`Session Reloaded: Old Session Id: ${oldSessionId}, New Session Id: ${newSessionId}`);
     await this._insightsHandler?.sendCBTInfo();
     if (setSessionStatus) {
       await this._update(oldSessionId, {
@@ -12967,7 +13542,7 @@ var BrowserstackService = class {
   }
   _updateJob(requestBody) {
     return this._multiRemoteAction((sessionId, browserName) => {
-      BStackLogger2.info(
+      BStackLogger.info(
         browserName ? `Update multiremote job for browser "${browserName}" and sessionId ${sessionId}` : `Update job with sessionId ${sessionId}`
       );
       return this._update(sessionId, requestBody);
@@ -12993,7 +13568,7 @@ var BrowserstackService = class {
       return Promise.resolve();
     }
     const sessionUrl = `${this._sessionBaseUrl}/${sessionId}.json`;
-    BStackLogger2.debug(`Updating Browserstack session at ${sessionUrl} with request body: `, requestBody);
+    BStackLogger.debug(`Updating Browserstack session at ${sessionUrl} with request body: `, requestBody);
     const encodedAuth = Buffer.from(`${this._config.user}:${this._config.key}`, "utf8").toString("base64");
     const headers = {
       "Content-Type": "application/json; charset=utf-8",
@@ -13018,7 +13593,7 @@ var BrowserstackService = class {
     }
     await this._multiRemoteAction(async (sessionId, browserName) => {
       const sessionUrl = `${this._sessionBaseUrl}/${sessionId}.json`;
-      BStackLogger2.debug(`Requesting Browserstack session URL at ${sessionUrl}`);
+      BStackLogger.debug(`Requesting Browserstack session URL at ${sessionUrl}`);
       let browserUrl;
       const encodedAuth = Buffer.from(`${this._config.user}:${this._config.key}`, "utf8").toString("base64");
       const headers = {
@@ -13045,7 +13620,7 @@ var BrowserstackService = class {
       }
       const capabilities = getBrowserCapabilities(this._browser, this._caps, browserName);
       const browserString = getBrowserDescription(capabilities);
-      BStackLogger2.info(`${browserString} session: ${browserUrl}`);
+      BStackLogger.info(`${browserString} session: ${browserUrl}`);
     });
   }
   async _setSessionName(suiteTitle, test) {