@wdio/runner 9.0.0-alpha.78 → 9.0.0

package/build/index.js

@@ -1,448 +1,890 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { EventEmitter } from 'node:events';
-import logger from '@wdio/logger';
-import { initializeWorkerService, initializePlugin, executeHooksWithArgs } from '@wdio/utils';
-import { ConfigParser } from '@wdio/config/node';
-import { _setGlobal } from '@wdio/globals';
-import { expect, setOptions, SnapshotService } from 'expect-webdriverio';
-import { attach } from 'webdriverio';
-import BrowserFramework from './browser.js';
-import BaseReporter from './reporter.js';
-import { initializeInstance, filterLogTypes, getInstancesData } from './utils.js';
-const log = logger('@wdio/runner');
-export default class Runner extends EventEmitter {
-    _browser;
-    _configParser;
-    _sigintWasCalled = false;
-    _isMultiremote = false;
-    _specFileRetryAttempts = 0;
-    _reporter;
-    _framework;
-    _config;
-    _cid;
-    _specs;
-    _caps;
+// src/index.ts
+import { EventEmitter } from "node:events";
+import logger4 from "@wdio/logger";
+import { initializeWorkerService, initializePlugin as initializePlugin2, executeHooksWithArgs as executeHooksWithArgs2 } from "@wdio/utils";
+import { ConfigParser } from "@wdio/config/node";
+import { _setGlobal } from "@wdio/globals";
+import { expect as expect2, setOptions, SnapshotService } from "expect-webdriverio";
+import { attach as attach2 } from "webdriverio";
+
+// src/browser.ts
+import url from "node:url";
+import path from "node:path";
+import logger2 from "@wdio/logger";
+import { browser } from "@wdio/globals";
+import { executeHooksWithArgs } from "@wdio/utils";
+import { matchers } from "expect-webdriverio";
+import { ELEMENT_KEY } from "webdriver";
+import { MESSAGE_TYPES } from "@wdio/types";
+
+// src/utils.ts
+import { deepmerge } from "deepmerge-ts";
+import logger from "@wdio/logger";
+import { remote, multiremote, attach } from "webdriverio";
+import { DEFAULTS } from "webdriver";
+import { DEFAULT_CONFIGS } from "@wdio/config";
+import { enableFileLogging } from "@wdio/utils";
+var log = logger("@wdio/runner");
+function sanitizeCaps(capabilities, filterOut) {
+  const caps = "alwaysMatch" in capabilities ? capabilities.alwaysMatch : capabilities;
+  const defaultConfigsKeys = [
+    // WDIO config keys
+    ...Object.keys(DEFAULT_CONFIGS()),
+    // WebDriver config keys
+    ...Object.keys(DEFAULTS)
+  ];
+  return Object.keys(caps).filter((key) => (
     /**
-     * run test suite
-     * @param  {string}    cid            worker id (e.g. `0-0`)
-     * @param  {Object}    args           config arguments passed into worker process
-     * @param  {string[]}  specs          list of spec files to run
-     * @param  {Object}    caps           capabilities to run session with
-     * @param  {string}    configFile      path to config file to get config from
-     * @param  {number}    retries        number of retries remaining
-     * @return {Promise}                  resolves in number of failures for testrun
+     * filter out all wdio config keys
      */
-    async run({ cid, args, specs, caps, configFile, retries }) {
-        this._configParser = new ConfigParser(configFile, args);
-        this._cid = cid;
-        this._specs = specs;
-        this._caps = caps;
-        /**
-         * add config file
-         */
-        try {
-            await this._configParser.initialize(args);
-        }
-        catch (err) {
-            log.error(`Failed to read config file: ${err.stack}`);
-            return this._shutdown(1, retries, true);
-        }
-        this._config = this._configParser.getConfig();
-        this._specFileRetryAttempts = (this._config.specFileRetries || 0) - (retries || 0);
-        logger.setLogLevelsConfig(this._config.logLevels, this._config.logLevel);
-        const capabilities = this._configParser.getCapabilities();
-        const isMultiremote = this._isMultiremote = !Array.isArray(capabilities) ||
-            (Object.values(caps).length > 0 && Object.values(caps).every(c => typeof c === 'object' && c.capabilities));
-        /**
-         * add built-in services
-         */
-        const snapshotService = SnapshotService.initiate({
-            updateState: this._config.updateSnapshots,
-            resolveSnapshotPath: this._config.resolveSnapshotPath
-        });
-        // ToDo(Christian): resolve type incompatibility between v8 and v9
-        this._configParser.addService(snapshotService);
-        /**
-         * create `browser` stub only if `specFiltering` feature is enabled
-         */
-        let browser = await this._startSession({
-            ...this._config,
-            // @ts-ignore used in `/packages/webdriverio/src/protocol-stub.ts`
-            _automationProtocol: this._config.automationProtocol,
-            automationProtocol: './protocol-stub.js'
-        }, caps);
-        (await initializeWorkerService(this._config, caps, args.ignoredWorkerServices)).map(this._configParser.addService.bind(this._configParser));
-        const beforeSessionParams = [this._config, this._caps, this._specs, this._cid];
-        await executeHooksWithArgs('beforeSession', this._config.beforeSession, beforeSessionParams);
-        this._reporter = new BaseReporter(this._config, this._cid, { ...caps });
-        await this._reporter.initReporters();
-        /**
-         * initialize framework
-         */
-        this._framework = await this.#initFramework(cid, this._config, caps, this._reporter, specs);
-        process.send({ name: 'testFrameworkInit', content: { cid, caps, specs, hasTests: this._framework.hasTests() } });
-        if (!this._framework.hasTests()) {
-            return this._shutdown(0, retries, true);
-        }
-        browser = await this._initSession(this._config, this._caps);
-        /**
-         * return if session initialization failed
-         */
-        if (!browser) {
-            const afterArgs = [1, this._caps, this._specs];
-            await executeHooksWithArgs('after', this._config.after, afterArgs);
-            return this._shutdown(1, retries, true);
-        }
-        this._reporter.caps = browser.capabilities;
-        const beforeArgs = [this._caps, this._specs, browser];
-        await executeHooksWithArgs('before', this._config.before, beforeArgs);
-        /**
-         * kill session of SIGINT signal showed up while trying to
-         * get a session ID
-         */
-        if (this._sigintWasCalled) {
-            log.info('SIGINT signal detected while starting session, shutting down...');
-            await this.endSession();
-            return this._shutdown(0, retries, true);
-        }
-        /**
-         * initialization successful, send start message
-         */
-        const multiRemoteBrowser = browser;
-        this._reporter.emit('runner:start', {
-            cid,
-            specs,
-            config: browser.options,
-            isMultiremote,
-            instanceOptions: isMultiremote
-                ? multiRemoteBrowser.instances.reduce((prev, browserName) => {
-                    prev[multiRemoteBrowser.getInstance(browserName).sessionId] = multiRemoteBrowser.getInstance(browserName).options;
-                    return prev;
-                }, {})
-                : {
-                    [browser.sessionId]: browser.options
-                },
-            sessionId: browser.sessionId,
-            capabilities: isMultiremote
-                ? multiRemoteBrowser.instances.reduce((caps, browserName) => {
-                    caps[browserName] = multiRemoteBrowser.getInstance(browserName).capabilities;
-                    caps[browserName].sessionId = multiRemoteBrowser.getInstance(browserName).sessionId;
-                    return caps;
-                }, {})
-                : { ...browser.capabilities, sessionId: browser.sessionId },
-            retry: this._specFileRetryAttempts
-        });
-        /**
-         * report sessionId and target connection information to worker
-         */
-        const { protocol, hostname, port, path, queryParams, automationProtocol, headers } = browser.options;
-        const { isW3C, sessionId } = browser;
-        const instances = getInstancesData(browser, isMultiremote);
-        process.send({
-            origin: 'worker',
-            name: 'sessionStarted',
-            content: {
-                automationProtocol, sessionId, isW3C, protocol, hostname, port, path, queryParams, isMultiremote, instances,
-                capabilities: browser.capabilities,
-                injectGlobals: this._config.injectGlobals,
-                headers
-            }
-        });
-        /**
-         * kick off tests in framework
-         */
-        let failures = 0;
-        try {
-            failures = await this._framework.run();
-            await this._fetchDriverLogs(this._config, caps.excludeDriverLogs);
-        }
-        catch (err) {
-            log.error(err);
-            this.emit('error', err);
-            failures = 1;
-        }
-        /**
-         * in watch mode we don't close the session and leave current page opened
-         */
-        if (!args.watch) {
-            await this.endSession();
-        }
-        /**
-         * send snapshot result upstream
-         */
-        process.send({
-            origin: 'worker',
-            name: 'snapshot',
-            content: snapshotService.results
-        });
-        return this._shutdown(failures, retries);
-    }
-    async #initFramework(cid, config, capabilities, reporter, specs) {
-        const runner = Array.isArray(config.runner) ? config.runner[0] : config.runner;
-        /**
-         * initialize framework adapter when running remote browser tests
-         */
-        if (runner === 'local') {
-            const framework = (await initializePlugin(config.framework, 'framework')).default;
-            return framework.init(cid, config, specs, capabilities, reporter);
-        }
-        /**
-         * for embedded browser tests the `@wdio/browser-runner` already has the environment
-         * setup so we can just run through the tests
-         */
-        if (runner === 'browser') {
-            return BrowserFramework.init(cid, config, specs, capabilities, reporter);
-        }
-        throw new Error(`Unknown runner "${runner}"`);
+    !defaultConfigsKeys.includes(key) === !filterOut
+  )).reduce((obj, key) => {
+    obj[key] = caps[key];
+    return obj;
+  }, {});
+}
+async function initializeInstance(config, capabilities, isMultiremote) {
+  await enableFileLogging(config.outputDir);
+  if ("sessionId" in config) {
+    log.debug(`attach to session with id ${config.sessionId}`);
+    config.capabilities = sanitizeCaps(capabilities);
+    const caps = capabilities;
+    const connectionProps = {
+      protocol: caps.protocol || config.protocol,
+      hostname: caps.hostname || config.hostname,
+      port: caps.port || config.port,
+      path: caps.path || config.path
+    };
+    const params = { ...config, ...connectionProps, capabilities };
+    return attach({ ...params, options: params });
+  }
+  if (!isMultiremote) {
+    log.debug("init remote session");
+    const sessionConfig = {
+      ...config,
+      /**
+       * allow to overwrite connection details by user through capabilities
+       */
+      ...sanitizeCaps(capabilities, true),
+      capabilities: sanitizeCaps(capabilities)
+    };
+    return remote(sessionConfig);
+  }
+  const options = {};
+  log.debug("init multiremote session");
+  delete config.capabilities;
+  for (const browserName of Object.keys(capabilities)) {
+    options[browserName] = deepmerge(
+      config,
+      capabilities[browserName]
+    );
+  }
+  const browser2 = await multiremote(options, config);
+  const browserNames = config.injectGlobals ? Object.keys(capabilities) : [];
+  for (const browserName of browserNames) {
+    global[browserName] = browser2[browserName];
+  }
+  return browser2;
+}
+function getInstancesData(browser2, isMultiremote) {
+  if (!isMultiremote) {
+    return;
+  }
+  const multiRemoteBrowser = browser2;
+  const instances = {};
+  multiRemoteBrowser.instances.forEach((browserName) => {
+    const { protocol, hostname, port, path: path3, queryParams } = multiRemoteBrowser.getInstance(browserName).options;
+    const { isW3C, sessionId } = multiRemoteBrowser.getInstance(browserName);
+    instances[browserName] = { sessionId, isW3C, protocol, hostname, port, path: path3, queryParams };
+  });
+  return instances;
+}
+var SUPPORTED_ASYMMETRIC_MATCHER = {
+  Any: "any",
+  Anything: "anything",
+  ArrayContaining: "arrayContaining",
+  ObjectContaining: "objectContaining",
+  StringContaining: "stringContaining",
+  StringMatching: "stringMatching",
+  CloseTo: "closeTo"
+};
+function transformExpectArgs(arg) {
+  if (typeof arg === "object" && "$$typeof" in arg && Object.keys(SUPPORTED_ASYMMETRIC_MATCHER).includes(arg.$$typeof)) {
+    const matcherKey = SUPPORTED_ASYMMETRIC_MATCHER[arg.$$typeof];
+    const matcher = arg.inverse ? expect.not[matcherKey] : expect[matcherKey];
+    if (!matcher) {
+      throw new Error(`Matcher "${matcherKey}" is not supported by expect-webdriverio`);
     }
-    /**
-     * init protocol session
-     * @param  {object}  config        configuration of sessions
-     * @param  {Object}  caps          desired capabilities of session
-     * @param  {Object}  browserStub   stubbed `browser` object with only capabilities, config and env flags
-     * @return {Promise}               resolves with browser object or null if session couldn't get established
-     */
-    async _initSession(config, caps) {
-        const browser = await this._startSession(config, caps);
-        // return null if session couldn't get established
-        if (!browser) {
-            return;
-        }
-        /**
-         * register global helper method to fetch elements
-         */
-        _setGlobal('$', (selector) => browser.$(selector), config.injectGlobals);
-        _setGlobal('$$', (selector) => browser.$$(selector), config.injectGlobals);
-        /**
-         * register command event
-         */
-        browser.on('command', (command) => this._reporter?.emit('client:beforeCommand', Object.assign(command, { sessionId: browser.sessionId })));
-        /**
-         * register result event
-         */
-        browser.on('result', (result) => this._reporter?.emit('client:afterCommand', Object.assign(result, { sessionId: browser.sessionId })));
-        return browser;
+    return matcher(arg.sample);
+  }
+  return arg;
+}
+
+// src/browser.ts
+var log2 = logger2("@wdio/runner");
+var sep = "\n  - ";
+var ERROR_CHECK_INTERVAL = 500;
+var DEFAULT_TIMEOUT = 60 * 1e3;
+var BrowserFramework = class _BrowserFramework {
+  constructor(_cid, _config, _specs, _reporter) {
+    this._cid = _cid;
+    this._config = _config;
+    this._specs = _specs;
+    this._reporter = _reporter;
+    process.on("message", this.#processMessage.bind(this));
+    const [, runnerOptions] = Array.isArray(_config.runner) ? _config.runner : [];
+    this.#runnerOptions = runnerOptions || {};
+  }
+  #retryOutdatedOptimizeDep = false;
+  #runnerOptions;
+  // `any` here because we don't want to create a dependency to @wdio/browser-runner
+  #resolveTestStatePromise;
+  /**
+   * always return true as it is irrelevant for component testing
+   */
+  hasTests() {
+    return true;
+  }
+  init() {
+    return void 0;
+  }
+  async run() {
+    try {
+      const failures = await this.#loop();
+      return failures;
+    } catch (err) {
+      if (err.message.includes("net::ERR_CONNECTION_REFUSE")) {
+        err.message = `Failed to load test page to run tests, make sure your browser can access "${browser.options.baseUrl}"`;
+      }
+      log2.error(`Failed to run browser tests with cid ${this._cid}: ${err.stack}`);
+      process.send({
+        origin: "worker",
+        name: "error",
+        content: { name: err.name, message: err.message, stack: err.stack }
+      });
+      return 1;
     }
-    /**
-     * start protocol session
-     * @param  {object}  config        configuration of sessions
-     * @param  {Object}  caps          desired capabilities of session
-     * @return {Promise}               resolves with browser object or null if session couldn't get established
-     */
-    async _startSession(config, caps) {
-        try {
-            /**
-             * get all custom or overwritten commands users tried to register before the
-             * test started, e.g. after all imports
-             */
-            const customStubCommands = this._browser?.customCommands || [];
-            const overwrittenCommands = this._browser?.overwrittenCommands || [];
-            this._browser = await initializeInstance(config, caps, this._isMultiremote);
-            _setGlobal('browser', this._browser, config.injectGlobals);
-            _setGlobal('driver', this._browser, config.injectGlobals);
-            /**
-             * for Jasmine we extend the Jasmine matchers instead of injecting the assertion
-             * library ourselves
-             */
-            if (config.framework !== 'jasmine') {
-                _setGlobal('expect', expect, config.injectGlobals);
-            }
-            /**
-             * re-assign previously registered custom commands to the actual instance
-             */
-            for (const params of customStubCommands) {
-                this._browser.addCommand(...params);
-            }
-            for (const params of overwrittenCommands) {
-                this._browser.overwriteCommand(...params);
-            }
-            /**
-             * import and set options for `expect-webdriverio` assertion lib once
-             * the browser was initiated
-             */
-            setOptions({
-                wait: config.waitforTimeout, // ms to wait for expectation to succeed
-                interval: config.waitforInterval, // interval between attempts
-                beforeAssertion: async (params) => {
-                    await Promise.all([
-                        this._reporter?.emit('client:beforeAssertion', { ...params, sessionId: this._browser?.sessionId }),
-                        executeHooksWithArgs('beforeAssertion', config.beforeAssertion, [params])
-                    ]);
-                },
-                afterAssertion: async (params) => {
-                    await Promise.all([
-                        this._reporter?.emit('client:afterAssertion', { ...params, sessionId: this._browser?.sessionId }),
-                        executeHooksWithArgs('afterAssertion', config.afterAssertion, [params])
-                    ]);
-                }
-            });
-            /**
-             * attach browser to `multiremotebrowser` so user have better typing support
-             */
-            if (this._isMultiremote) {
-                _setGlobal('multiremotebrowser', this._browser, config.injectGlobals);
-            }
-        }
-        catch (err) {
-            log.error(err);
-            return;
-        }
-        return this._browser;
+  }
+  async #loop() {
+    let failures = 0;
+    for (const spec of this._specs) {
+      failures += await this.#runSpec(spec);
     }
-    /**
-     * fetch logs provided by browser driver
-     */
-    async _fetchDriverLogs(config, excludeDriverLogs) {
-        /**
-         * only fetch logs if
-         */
-        if (
-        /**
-         * a log directory is given in config
-         */
-        !config.outputDir ||
-            /**
-             * the session wasn't killed during start up phase
-             */
-            !this._browser?.sessionId ||
-            /**
-             * driver supports it
-             */
-            typeof this._browser?.getLogs === 'undefined') {
-            return;
-        }
-        let logTypes;
-        try {
-            logTypes = await this._browser.getLogTypes();
-        }
-        catch (errIgnored) {
-            /**
-             * getLogTypes is not supported by browser
-             */
-            return;
-        }
-        logTypes = filterLogTypes(excludeDriverLogs, logTypes);
-        log.debug(`Fetching logs for ${logTypes.join(', ')}`);
-        return Promise.all(logTypes.map(async (logType) => {
-            let logs;
-            try {
-                logs = await this._browser?.getLogs(logType);
-            }
-            catch (e) {
-                return log.warn(`Couldn't fetch logs for ${logType}: ${e.message}`);
-            }
-            /**
-             * don't write to file if no logs were captured
-             */
-            if (!Array.isArray(logs) || logs.length === 0) {
-                return;
-            }
-            const stringLogs = logs.map((log) => JSON.stringify(log)).join('\n');
-            return fs.writeFile(path.join(config.outputDir, `wdio-${this._cid}-${logType}.log`), stringLogs, 'utf-8');
-        }));
+    return failures;
+  }
+  async #runSpec(spec, retried = false) {
+    this.#retryOutdatedOptimizeDep = false;
+    const timeout = this._config.mochaOpts?.timeout || DEFAULT_TIMEOUT;
+    log2.info(`Run spec file ${spec} for cid ${this._cid}`);
+    const testStatePromise = new Promise((resolve) => {
+      this.#resolveTestStatePromise = resolve;
+    });
+    if (!this._config.sessionId) {
+      await browser.url(`/?cid=${this._cid}&spec=${new URL(spec).pathname}`);
     }
-    /**
-     * kill worker session
-     */
-    async _shutdown(failures, retries, initiationFailed = false) {
-        /**
-         * In case of initialization failed, the sessionId is undefined and the runner:start is not triggered.
-         * So, to be able to perform the runner:end into the reporters, we need to launch the runner:start just before the runner:end.
-         */
-        if (this._reporter && initiationFailed) {
-            this._reporter.emit('runner:start', {
-                cid: this._cid,
-                specs: this._specs,
-                config: this._config,
-                isMultiremote: this._isMultiremote,
-                instanceOptions: {},
-                capabilities: { ...this._configParser.getCapabilities() },
-                retry: this._specFileRetryAttempts
-            });
-        }
-        this._reporter.emit('runner:end', {
-            failures,
-            cid: this._cid,
-            retries
-        });
-        try {
-            await this._reporter.waitForSync();
+    await browser.setCookies([
+      { name: "WDIO_SPEC", value: url.fileURLToPath(spec) },
+      { name: "WDIO_CID", value: this._cid }
+    ]);
+    const testTimeout = setTimeout(
+      () => this.#onTestTimeout(`Timed out after ${timeout / 1e3}s waiting for test results`),
+      timeout
+    );
+    const errorInterval = setInterval(
+      this.#checkForTestError.bind(this),
+      ERROR_CHECK_INTERVAL
+    );
+    const state = await testStatePromise;
+    clearTimeout(testTimeout);
+    clearInterval(errorInterval);
+    if (this.#runnerOptions.coverage?.enabled && process.send) {
+      const coverageMap = await browser.execute(
+        () => window.__coverage__ || {}
+      );
+      const workerEvent = {
+        origin: "worker",
+        name: "workerEvent",
+        args: {
+          type: MESSAGE_TYPES.coverageMap,
+          value: coverageMap
         }
-        catch (err) {
-            log.error(err);
+      };
+      process.send(workerEvent);
+    }
+    if (state.errors?.length) {
+      const errors = state.errors.map((ev) => state.hasViteError ? `${ev.message}
+${ev.error ? ev.error.split("\n").slice(1).join("\n") : ""}` : `${path.basename(ev.filename || spec)}: ${ev.message}
+${ev.error ? ev.error.split("\n").slice(1).join("\n") : ""}`);
+      if (!retried && errors.some((err) => err.includes("Failed to fetch dynamically imported module") || err.includes("the server responded with a status of 504 (Outdated Optimize Dep)"))) {
+        log2.info("Retry test run due to dynamic import error");
+        return this.#runSpec(spec, true);
+      }
+      const { name, message, stack } = new Error(state.hasViteError ? `Test failed due to the following error: ${errors.join("\n\n")}` : `Test failed due to following error(s):${sep}${errors.join(sep)}`);
+      process.send({
+        origin: "worker",
+        name: "error",
+        content: { name, message, stack }
+      });
+      return 1;
+    }
+    for (const ev of state.events || []) {
+      if ((ev.type === "suite:start" || ev.type === "suite:end") && ev.title === "") {
+        continue;
+      }
+      this._reporter.emit(ev.type, {
+        ...ev,
+        file: spec,
+        uid: `${this._cid}-${Buffer.from(ev.fullTitle).toString("base64")}`,
+        cid: this._cid
+      });
+    }
+    return state.failures || 0;
+  }
+  async #processMessage(cmd) {
+    if (cmd.command !== "workerRequest" || !process.send) {
+      return;
+    }
+    const { message, id } = cmd.args;
+    if (message.type === MESSAGE_TYPES.hookTriggerMessage) {
+      return this.#handleHook(id, message.value);
+    }
+    if (message.type === MESSAGE_TYPES.consoleMessage) {
+      return this.#handleConsole(message.value);
+    }
+    if (message.type === MESSAGE_TYPES.commandRequestMessage) {
+      return this.#handleCommand(id, message.value);
+    }
+    if (message.type === MESSAGE_TYPES.expectRequestMessage) {
+      return this.#handleExpectation(id, message.value);
+    }
+    if (message.type === MESSAGE_TYPES.browserTestResult) {
+      return this.#handleTestFinish(message.value);
+    }
+    if (message.type === MESSAGE_TYPES.expectMatchersRequest) {
+      return this.#sendWorkerResponse(
+        id,
+        this.#expectMatcherResponse({ matchers: Array.from(matchers.keys()) })
+      );
+    }
+  }
+  async #handleHook(id, payload) {
+    const error = await executeHooksWithArgs(
+      payload.name,
+      this._config[payload.name],
+      payload.args
+    ).then(() => void 0, (err) => err);
+    if (error) {
+      log2.warn(`Failed running "${payload.name}" hook for cid ${payload.cid}: ${error.message}`);
+    }
+    return this.#sendWorkerResponse(id, this.#hookResponse({ id: payload.id, error }));
+  }
+  #expectMatcherResponse(value) {
+    return {
+      type: MESSAGE_TYPES.expectMatchersResponse,
+      value
+    };
+  }
+  #hookResponse(value) {
+    return {
+      type: MESSAGE_TYPES.hookResultMessage,
+      value
+    };
+  }
+  #sendWorkerResponse(id, message) {
+    if (!process.send) {
+      return;
+    }
+    const response = {
+      origin: "worker",
+      name: "workerResponse",
+      args: { id, message }
+    };
+    process.send(response);
+  }
+  /**
+   * Print console message executed in browser to the terminal
+   * @param message console.log message args
+   * @returns void
+   */
+  #handleConsole(message) {
+    const isWDIOLog = Boolean(typeof message.args[0] === "string" && message.args[0].startsWith("[WDIO]") && message.type !== "error");
+    if (message.name !== "consoleEvent" || isWDIOLog) {
+      return;
+    }
+    console[message.type](...message.args || []);
+  }
+  async #handleCommand(id, payload) {
+    log2.debug(`Received browser message: ${JSON.stringify(payload)}`);
+    const cid = payload.cid;
+    if (typeof cid !== "string") {
+      const { message, stack } = new Error(`No "cid" property passed into command message with id "${payload.id}"`);
+      const error = { message, stack, name: "Error" };
+      return this.#sendWorkerResponse(id, this.#commandResponse({ id: payload.id, error }));
+    }
+    try {
+      const scope = payload.scope ? await browser.$({ [ELEMENT_KEY]: payload.scope }) : browser;
+      if (typeof scope[payload.commandName] !== "function") {
+        throw new Error(`${payload.scope ? "element" : "browser"}.${payload.commandName} is not a function`);
+      }
+      let result = await scope[payload.commandName](...payload.args);
+      if (result?.constructor?.name === "Element") {
+        result = result.elementId ? { [ELEMENT_KEY]: result.elementId } : result.error ? { message: result.error.message, stack: result.error.stack, name: result.error.name } : void 0;
+      } else if (result?.foundWith) {
+        result = (await result.map((res) => ({
+          [ELEMENT_KEY]: res.elementId
+        }))).filter(Boolean);
+      }
+      const resultMsg = this.#commandResponse({ id: payload.id, result });
+      log2.debug(`Return command result: ${resultMsg}`);
+      return this.#sendWorkerResponse(id, resultMsg);
+    } catch (error) {
+      const { message, stack, name } = error;
+      return this.#sendWorkerResponse(id, this.#commandResponse({ id: payload.id, error: { message, stack, name } }));
+    }
+  }
+  #commandResponse(value) {
+    return {
+      type: MESSAGE_TYPES.commandResponseMessage,
+      value
+    };
+  }
+  /**
+   * handle expectation assertions within the worker process
+   * @param id message id from communicator
+   * @param payload information about the expectation to run
+   * @returns void
+   */
+  async #handleExpectation(id, payload) {
+    log2.debug(`Received expectation message: ${JSON.stringify(payload)}`);
+    const cid = payload.cid;
+    if (typeof cid !== "string") {
+      const message = `No "cid" property passed into expect request message with id "${payload.id}"`;
+      return this.#sendWorkerResponse(id, this.#expectResponse({ id: payload.id, pass: false, message }));
+    }
+    const matcher = matchers.get(payload.matcherName);
+    if (!matcher) {
+      const message = `Couldn't find matcher with name "${payload.matcherName}"`;
+      return this.#sendWorkerResponse(id, this.#expectResponse({ id: payload.id, pass: false, message }));
+    }
+    try {
+      const context = payload.element ? Array.isArray(payload.element) ? await browser.$$(payload.element) : payload.element.elementId ? await browser.$(payload.element) : await browser.$(payload.element.selector) : payload.context || browser;
+      const result = await matcher.apply(payload.scope, [context, ...payload.args.map(transformExpectArgs)]);
+      return this.#sendWorkerResponse(id, this.#expectResponse({
+        id: payload.id,
+        pass: result.pass,
+        message: result.message()
+      }));
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.stack : err;
+      const message = `Failed to execute expect command "${payload.matcherName}": ${errorMessage}`;
+      return this.#sendWorkerResponse(id, this.#expectResponse({ id: payload.id, pass: false, message }));
+    }
+  }
+  #expectResponse(value) {
+    return {
+      type: MESSAGE_TYPES.expectResponseMessage,
+      value
+    };
+  }
+  #handleTestFinish(payload) {
+    this.#resolveTestStatePromise({ failures: payload.failures, events: payload.events });
+  }
+  #onTestTimeout(message) {
+    return this.#resolveTestStatePromise?.({
+      events: [],
+      failures: 1,
+      errors: [{ message }]
+    });
+  }
+  async #checkForTestError() {
+    const testError = await browser.execute(function fetchExecutionState() {
+      let viteError;
+      const viteErrorElem = document.querySelector("vite-error-overlay");
+      if (viteErrorElem && viteErrorElem.shadowRoot) {
+        const errorElements = Array.from(viteErrorElem.shadowRoot.querySelectorAll("pre"));
+        if (errorElements.length) {
+          viteError = [{ message: errorElements.map((elem) => elem.innerText).join("\n") }];
         }
-        this.emit('exit', failures === 0 ? 0 : 1);
-        return failures;
+      }
+      const loadError = typeof window.__wdioErrors__ === "undefined" && document.title !== "WebdriverIO Browser Test" && !document.querySelector("mocha-framework") ? [{ message: `Failed to load test page (title = "${document.title}", source: ${document.documentElement.innerHTML})` }] : null;
+      const errors = viteError || window.__wdioErrors__ || loadError;
+      return { errors, hasViteError: Boolean(viteError) };
+    }).catch((err) => {
+      if (err.message.includes("Cannot find context with specified id")) {
+        return;
+      }
+      throw err;
+    });
+    if (!testError) {
+      return;
     }
-    /**
-     * end WebDriver session, a config object can be applied if object has changed
-     * within a hook by the user
-     */
-    async endSession(payload) {
-        /**
-         * make sure instance(s) exist and have `sessionId`
-         */
-        const multiremoteBrowser = this._browser;
-        const browser = this._browser;
-        const hasSessionId = Boolean(this._browser) && (this._isMultiremote
-            /**
-             * every multiremote instance should exist and should have `sessionId`
-             */
-            ? !multiremoteBrowser.instances.some((browserName) => (multiremoteBrowser.getInstance(browserName) &&
-                !multiremoteBrowser.getInstance(browserName).sessionId))
-            /**
-             * browser object should have `sessionId` in regular mode
-             */
-            : browser.sessionId);
+    if (testError.errors && testError.errors.length > 0 || testError.hasViteError) {
+      this.#resolveTestStatePromise?.({
+        events: [],
+        failures: 1,
+        ...testError
+      });
+    }
+    const logs = typeof browser.getLogs === "function" ? await browser.getLogs("browser").catch(() => []) : [];
+    const severeLogs = logs.filter((log5) => log5.level === "SEVERE" && log5.source !== "deprecation");
+    if (severeLogs.length) {
+      if (!this.#retryOutdatedOptimizeDep && severeLogs.some((log5) => log5.message?.includes("(Outdated Optimize Dep)"))) {
+        log2.info("Retry test run due to outdated optimize dep");
+        this.#retryOutdatedOptimizeDep = true;
+        return browser.refresh();
+      }
+      this.#resolveTestStatePromise?.({
+        events: [],
+        failures: 1,
+        hasViteError: false,
         /**
-         * in watch mode we create a new child process to kill the
-         * session, see packages/wdio-local-runner/src/index.ts,
-         * therefore we need to attach to the session to kill it
+         * error messages often look like:
+         * "http://localhost:40167/node_modules/.vite/deps/expect.js?v=bca8e2f3 - Failed to load resource: the server responded with a status of 504 (Outdated Optimize Dep)"
          */
-        if (!hasSessionId && payload?.args.config.sessionId) {
-            this._browser = await attach({
-                ...payload.args.config,
-                capabilities: payload?.args.capabilities
-            });
-        }
-        else if (!hasSessionId) {
-            /**
-             * don't do anything if test framework returns after SIGINT
-             * if endSession is called without payload we expect a session id
-             */
-            return;
+        errors: severeLogs.map((log5) => {
+          const [filename, message] = log5.message.split(" - ");
+          return {
+            filename: filename.startsWith("http") ? filename : void 0,
+            message
+          };
+        })
+      });
+    }
+  }
+  static init(cid, config, specs, _, reporter) {
+    const framework = new _BrowserFramework(cid, config, specs, reporter);
+    return framework;
+  }
+};
+
+// src/reporter.ts
+import path2 from "node:path";
+import logger3 from "@wdio/logger";
+import { initializePlugin } from "@wdio/utils";
+var log3 = logger3("@wdio/runner");
+var mochaAllHooks = ['"before all" hook', '"after all" hook'];
+var BaseReporter = class {
+  constructor(_config, _cid, caps) {
+    this._config = _config;
+    this._cid = _cid;
+    this.caps = caps;
+  }
+  _reporters = [];
+  listeners = [];
+  async initReporters() {
+    this._reporters = await Promise.all(
+      this._config.reporters.map(this._loadReporter.bind(this))
+    );
+  }
+  /**
+   * emit events to all registered reporter and wdio launcer
+   *
+   * @param  {string} e       event name
+   * @param  {object} payload event payload
+   */
+  emit(e, payload) {
+    payload.cid = this._cid;
+    const isTestError = e === "test:fail";
+    const isHookError = e === "hook:end" && payload.error && mochaAllHooks.some((hook) => payload.title.startsWith(hook));
+    if (isTestError || isHookError) {
+      this.#emitData({
+        origin: "reporter",
+        name: "printFailureMessage",
+        content: payload
+      });
+    }
+    this._reporters.forEach((reporter) => reporter.emit(e, payload));
+  }
+  onMessage(listener) {
+    this.listeners.push(listener);
+  }
+  getLogFile(name) {
+    const options = Object.assign({}, this._config);
+    let filename = `wdio-${this._cid}-${name}-reporter.log`;
+    const reporterOptions = this._config.reporters.find((reporter) => Array.isArray(reporter) && (reporter[0] === name || typeof reporter[0] === "function" && reporter[0].name === name));
+    if (reporterOptions && Array.isArray(reporterOptions)) {
+      const fileformat = reporterOptions[1].outputFileFormat;
+      options.cid = this._cid;
+      options.capabilities = this.caps;
+      Object.assign(options, reporterOptions[1]);
+      if (fileformat) {
+        if (typeof fileformat !== "function") {
+          throw new Error("outputFileFormat must be a function");
         }
-        /**
-         * store capabilities for afterSession hook
-         */
-        const capabilities = this._browser?.capabilities || {};
-        if (this._isMultiremote) {
-            multiremoteBrowser.instances.forEach((browserName) => {
-                capabilities[browserName] = multiremoteBrowser.getInstance(browserName).capabilities;
-            });
+        filename = fileformat(options);
+      }
+    }
+    if (!options.outputDir) {
+      return;
+    }
+    return path2.join(options.outputDir, filename);
+  }
+  /**
+   * return write stream object based on reporter name
+   */
+  getWriteStreamObject(reporter) {
+    return {
+      write: (
+        /* istanbul ignore next */
+        (content) => this.#emitData({
+          origin: "reporter",
+          name: reporter,
+          content
+        })
+      )
+    };
+  }
+  /**
+   * emit data either through process or listener
+   */
+  #emitData(payload) {
+    if (typeof process.send === "function") {
+      return process.send(payload);
+    }
+    this.listeners.forEach((fn) => fn(payload));
+    return true;
+  }
+  /**
+   * wait for reporter to finish synchronization, e.g. when sending data asynchronous
+   * to a server (e.g. sumo reporter)
+   */
+  waitForSync() {
+    const startTime = Date.now();
+    return new Promise((resolve, reject) => {
+      const interval = setInterval(() => {
+        const unsyncedReporter = this._reporters.filter((reporter) => !reporter.isSynchronised).map((reporter) => reporter.constructor.name);
+        if (Date.now() - startTime > this._config.reporterSyncTimeout && unsyncedReporter.length) {
+          clearInterval(interval);
+          return reject(new Error(`Some reporters are still unsynced: ${unsyncedReporter.join(", ")}`));
         }
-        await this._browser?.deleteSession();
-        process.send({
-            origin: 'worker',
-            name: 'sessionEnded',
-            cid: this._cid
-        });
-        /**
-         * delete session(s)
-         */
-        if (this._isMultiremote) {
-            multiremoteBrowser.instances.forEach((browserName) => {
-                // @ts-ignore sessionId is usually required
-                delete multiremoteBrowser.getInstance(browserName).sessionId;
-            });
+        if (!unsyncedReporter.length) {
+          clearInterval(interval);
+          return resolve(true);
         }
-        else if (browser) {
-            browser.sessionId = undefined;
+        log3.info(`Wait for ${unsyncedReporter.length} reporter to synchronise`);
+      }, this._config.reporterSyncInterval);
+    });
+  }
+  /**
+   * initialize reporters
+   */
+  async _loadReporter(reporter) {
+    let ReporterClass;
+    let options = {};
+    if (Array.isArray(reporter)) {
+      options = Object.assign({}, options, reporter[1]);
+      reporter = reporter[0];
+    }
+    if (typeof reporter === "function") {
+      ReporterClass = reporter;
+      options.logFile = options.setLogFile ? options.setLogFile(this._cid, ReporterClass.name) : typeof options.logFile === "string" ? options.logFile : this.getLogFile(ReporterClass.name);
+      options.writeStream = this.getWriteStreamObject(ReporterClass.name);
+      return new ReporterClass(options);
+    }
+    if (typeof reporter === "string") {
+      ReporterClass = (await initializePlugin(reporter, "reporter")).default;
+      options.logFile = options.setLogFile ? options.setLogFile(this._cid, reporter) : typeof options.logFile === "string" ? options.logFile : this.getLogFile(reporter);
+      options.writeStream = this.getWriteStreamObject(reporter);
+      return new ReporterClass(options);
+    }
+    throw new Error("Invalid reporters config");
+  }
+};
+
+// src/index.ts
+var log4 = logger4("@wdio/runner");
+var Runner = class extends EventEmitter {
+  _browser;
+  _configParser;
+  _sigintWasCalled = false;
+  _isMultiremote = false;
+  _specFileRetryAttempts = 0;
+  _reporter;
+  _framework;
+  _config;
+  _cid;
+  _specs;
+  _caps;
+  /**
+   * run test suite
+   * @param  {string}    cid            worker id (e.g. `0-0`)
+   * @param  {Object}    args           config arguments passed into worker process
+   * @param  {string[]}  specs          list of spec files to run
+   * @param  {Object}    caps           capabilities to run session with
+   * @param  {string}    configFile      path to config file to get config from
+   * @param  {number}    retries        number of retries remaining
+   * @return {Promise}                  resolves in number of failures for testrun
+   */
+  async run({ cid, args, specs, caps, configFile, retries }) {
+    this._configParser = new ConfigParser(configFile, args);
+    this._cid = cid;
+    this._specs = specs;
+    this._caps = caps;
+    try {
+      await this._configParser.initialize(args);
+    } catch (err) {
+      log4.error(`Failed to read config file: ${err.stack}`);
+      return this._shutdown(1, retries, true);
+    }
+    this._config = this._configParser.getConfig();
+    this._specFileRetryAttempts = (this._config.specFileRetries || 0) - (retries || 0);
+    logger4.setLogLevelsConfig(this._config.logLevels, this._config.logLevel);
+    const capabilities = this._configParser.getCapabilities();
+    const isMultiremote = this._isMultiremote = !Array.isArray(capabilities) || Object.values(caps).length > 0 && Object.values(caps).every((c) => typeof c === "object" && c.capabilities);
+    const snapshotService = SnapshotService.initiate({
+      updateState: this._config.updateSnapshots,
+      resolveSnapshotPath: this._config.resolveSnapshotPath
+    });
+    this._configParser.addService(snapshotService);
+    let browser2 = await this._startSession({
+      ...this._config,
+      // @ts-ignore used in `/packages/webdriverio/src/protocol-stub.ts`
+      _automationProtocol: this._config.automationProtocol,
+      automationProtocol: "./protocol-stub.js"
+    }, caps);
+    (await initializeWorkerService(
+      this._config,
+      caps,
+      args.ignoredWorkerServices
+    )).map(this._configParser.addService.bind(this._configParser));
+    const beforeSessionParams = [this._config, this._caps, this._specs, this._cid];
+    await executeHooksWithArgs2("beforeSession", this._config.beforeSession, beforeSessionParams);
+    this._reporter = new BaseReporter(this._config, this._cid, { ...caps });
+    await this._reporter.initReporters();
+    this._framework = await this.#initFramework(cid, this._config, caps, this._reporter, specs);
+    process.send({ name: "testFrameworkInit", content: { cid, caps, specs, hasTests: this._framework.hasTests() } });
+    if (!this._framework.hasTests()) {
+      return this._shutdown(0, retries, true);
+    }
+    browser2 = await this._initSession(this._config, this._caps);
+    if (!browser2) {
+      const afterArgs = [1, this._caps, this._specs];
+      await executeHooksWithArgs2("after", this._config.after, afterArgs);
+      return this._shutdown(1, retries, true);
+    }
+    this._reporter.caps = browser2.capabilities;
+    const beforeArgs = [this._caps, this._specs, browser2];
+    await executeHooksWithArgs2("before", this._config.before, beforeArgs);
+    if (this._sigintWasCalled) {
+      log4.info("SIGINT signal detected while starting session, shutting down...");
+      await this.endSession();
+      return this._shutdown(0, retries, true);
+    }
+    const multiRemoteBrowser = browser2;
+    this._reporter.emit("runner:start", {
+      cid,
+      specs,
+      config: browser2.options,
+      isMultiremote,
+      instanceOptions: isMultiremote ? multiRemoteBrowser.instances.reduce((prev, browserName) => {
+        prev[multiRemoteBrowser.getInstance(browserName).sessionId] = multiRemoteBrowser.getInstance(browserName).options;
+        return prev;
+      }, {}) : {
+        [browser2.sessionId]: browser2.options
+      },
+      sessionId: browser2.sessionId,
+      capabilities: isMultiremote ? multiRemoteBrowser.instances.reduce((caps2, browserName) => {
+        caps2[browserName] = multiRemoteBrowser.getInstance(browserName).capabilities;
+        caps2[browserName].sessionId = multiRemoteBrowser.getInstance(browserName).sessionId;
+        return caps2;
+      }, {}) : { ...browser2.capabilities, sessionId: browser2.sessionId },
+      retry: this._specFileRetryAttempts
+    });
+    const { protocol, hostname, port, path: path3, queryParams, automationProtocol, headers } = browser2.options;
+    const { isW3C, sessionId } = browser2;
+    const instances = getInstancesData(browser2, isMultiremote);
+    process.send({
+      origin: "worker",
+      name: "sessionStarted",
+      content: {
+        automationProtocol,
+        sessionId,
+        isW3C,
+        protocol,
+        hostname,
+        port,
+        path: path3,
+        queryParams,
+        isMultiremote,
+        instances,
+        capabilities: browser2.capabilities,
+        injectGlobals: this._config.injectGlobals,
+        headers
+      }
+    });
+    let failures = 0;
+    try {
+      failures = await this._framework.run();
+    } catch (err) {
+      log4.error(err);
+      this.emit("error", err);
+      failures = 1;
+    }
+    if (!args.watch) {
+      await this.endSession();
+    }
+    process.send({
+      origin: "worker",
+      name: "snapshot",
+      content: snapshotService.results
+    });
+    return this._shutdown(failures, retries);
+  }
+  async #initFramework(cid, config, capabilities, reporter, specs) {
+    const runner = Array.isArray(config.runner) ? config.runner[0] : config.runner;
+    if (runner === "local") {
+      const framework = (await initializePlugin2(config.framework, "framework")).default;
+      return framework.init(cid, config, specs, capabilities, reporter);
+    }
+    if (runner === "browser") {
+      return BrowserFramework.init(cid, config, specs, capabilities, reporter);
+    }
+    throw new Error(`Unknown runner "${runner}"`);
+  }
+  /**
+   * init protocol session
+   * @param  {object}  config        configuration of sessions
+   * @param  {Object}  caps          desired capabilities of session
+   * @param  {Object}  browserStub   stubbed `browser` object with only capabilities, config and env flags
+   * @return {Promise}               resolves with browser object or null if session couldn't get established
+   */
+  async _initSession(config, caps) {
+    const browser2 = await this._startSession(config, caps);
+    if (!browser2) {
+      return;
+    }
+    _setGlobal("$", (selector) => browser2.$(selector), config.injectGlobals);
+    _setGlobal("$$", (selector) => browser2.$$(selector), config.injectGlobals);
+    browser2.on("command", (command) => this._reporter?.emit(
+      "client:beforeCommand",
+      Object.assign(command, { sessionId: browser2.sessionId })
+    ));
+    browser2.on("result", (result) => this._reporter?.emit(
+      "client:afterCommand",
+      Object.assign(result, { sessionId: browser2.sessionId })
+    ));
+    return browser2;
+  }
+  /**
+   * start protocol session
+   * @param  {object}  config        configuration of sessions
+   * @param  {Object}  caps          desired capabilities of session
+   * @return {Promise}               resolves with browser object or null if session couldn't get established
+   */
+  async _startSession(config, caps) {
+    try {
+      const customStubCommands = this._browser?.customCommands || [];
+      const overwrittenCommands = this._browser?.overwrittenCommands || [];
+      this._browser = await initializeInstance(config, caps, this._isMultiremote);
+      _setGlobal("browser", this._browser, config.injectGlobals);
+      _setGlobal("driver", this._browser, config.injectGlobals);
+      if (config.framework !== "jasmine") {
+        _setGlobal("expect", expect2, config.injectGlobals);
+      }
+      for (const params of customStubCommands) {
+        this._browser.addCommand(...params);
+      }
+      for (const params of overwrittenCommands) {
+        this._browser.overwriteCommand(...params);
+      }
+      setOptions({
+        wait: config.waitforTimeout,
+        // ms to wait for expectation to succeed
+        interval: config.waitforInterval,
+        // interval between attempts
+        beforeAssertion: async (params) => {
+          await Promise.all([
+            this._reporter?.emit("client:beforeAssertion", { ...params, sessionId: this._browser?.sessionId }),
+            executeHooksWithArgs2("beforeAssertion", config.beforeAssertion, [params])
+          ]);
+        },
+        afterAssertion: async (params) => {
+          await Promise.all([
+            this._reporter?.emit("client:afterAssertion", { ...params, sessionId: this._browser?.sessionId }),
+            executeHooksWithArgs2("afterAssertion", config.afterAssertion, [params])
+          ]);
         }
-        const afterSessionArgs = [this._config, capabilities, this._specs];
-        await executeHooksWithArgs('afterSession', this._config.afterSession, afterSessionArgs);
+      });
+      if (this._isMultiremote) {
+        _setGlobal("multiremotebrowser", this._browser, config.injectGlobals);
+      }
+    } catch (err) {
+      log4.error(err);
+      return;
     }
-}
-export { default as BaseReporter } from './reporter.js';
-export * from './types.js';
+    return this._browser;
+  }
+  /**
+   * kill worker session
+   */
+  async _shutdown(failures, retries, initiationFailed = false) {
+    if (this._reporter && initiationFailed) {
+      this._reporter.emit("runner:start", {
+        cid: this._cid,
+        specs: this._specs,
+        config: this._config,
+        isMultiremote: this._isMultiremote,
+        instanceOptions: {},
+        capabilities: { ...this._configParser.getCapabilities() },
+        retry: this._specFileRetryAttempts
+      });
+    }
+    this._reporter.emit("runner:end", {
+      failures,
+      cid: this._cid,
+      retries
+    });
+    try {
+      await this._reporter.waitForSync();
+    } catch (err) {
+      log4.error(err);
+    }
+    this.emit("exit", failures === 0 ? 0 : 1);
+    return failures;
+  }
+  /**
+   * end WebDriver session, a config object can be applied if object has changed
+   * within a hook by the user
+   */
+  async endSession(payload) {
+    const multiremoteBrowser = this._browser;
+    const browser2 = this._browser;
+    const hasSessionId = Boolean(this._browser) && (this._isMultiremote ? !multiremoteBrowser.instances.some(
+      (browserName) => multiremoteBrowser.getInstance(browserName) && !multiremoteBrowser.getInstance(browserName).sessionId
+    ) : browser2.sessionId);
+    if (!hasSessionId && payload?.args.config.sessionId) {
+      this._browser = await attach2({
+        ...payload.args.config,
+        capabilities: payload?.args.capabilities
+      });
+    } else if (!hasSessionId) {
+      return;
+    }
+    const capabilities = this._browser?.capabilities || {};
+    if (this._isMultiremote) {
+      const multiremoteBrowser2 = this._browser;
+      multiremoteBrowser2.instances.forEach((browserName) => {
+        capabilities[browserName] = multiremoteBrowser2.getInstance(browserName).capabilities;
+      });
+    }
+    await this._browser?.deleteSession();
+    process.send({
+      origin: "worker",
+      name: "sessionEnded",
+      cid: this._cid
+    });
+    if (this._isMultiremote) {
+      multiremoteBrowser.instances.forEach((browserName) => {
+        delete multiremoteBrowser.getInstance(browserName).sessionId;
+      });
+    } else if (browser2) {
+      browser2.sessionId = void 0;
+    }
+    const afterSessionArgs = [this._config, capabilities, this._specs];
+    await executeHooksWithArgs2("afterSession", this._config.afterSession, afterSessionArgs);
+  }
+};
+export {
+  BaseReporter,
+  Runner as default
+};