system-testing 1.0.103 → 1.0.104

package/README.md

@@ -449,6 +449,14 @@ await systemTest.reinitialize()
 
 This tears down the browser, servers, and sockets, then starts them again so subsequent steps run against a fresh app instance.
 
+`SystemTest.run(...)` does this automatically after a failed callback or teardown by default. Disable it only for tests that intentionally inspect the broken session after failure:
+
+```js
+await SystemTest.run({reinitializeAfterFailure: false}, async (systemTest) => {
+  await systemTest.findByTestID("brokenState")
+})
+```
+
 ## Dummy Expo app
 
 A ready-to-run Expo Router dummy app that uses `system-testing` lives in `spec/dummy`.

package/build/drivers/webdriver-driver.d.ts

@@ -171,6 +171,55 @@ export default class WebDriverDriver {
      * @returns {Promise<void>}
      */
     scrollElementIntoView(element: import("selenium-webdriver").WebElement): Promise<void>;
+    /**
+     * @param {string|import("selenium-webdriver").WebElement|({selector: string} & FindArgs & {withFallback?: boolean})} elementOrIdentifier
+     * @param {FindArgs} [args]
+     * @returns {Promise<import("selenium-webdriver").WebElement>}
+     */
+    findScrollTarget(elementOrIdentifier: string | import("selenium-webdriver").WebElement | ({
+        selector: string;
+    } & FindArgs & {
+        withFallback?: boolean;
+    }), args?: FindArgs): Promise<import("selenium-webdriver").WebElement>;
+    /**
+     * @param {string|import("selenium-webdriver").WebElement|({selector: string} & FindArgs & {withFallback?: boolean})} elementOrIdentifier
+     * @param {FindArgs} [args]
+     * @returns {boolean}
+     */
+    hasExplicitVisibleScrollLookup(elementOrIdentifier: string | import("selenium-webdriver").WebElement | ({
+        selector: string;
+    } & FindArgs & {
+        withFallback?: boolean;
+    }), args?: FindArgs): boolean;
+    /**
+     * @param {string|import("selenium-webdriver").WebElement|({selector: string} & FindArgs & {withFallback?: boolean})} elementOrIdentifier
+     * @param {FindArgs | undefined} args
+     * @param {unknown} originalError
+     * @returns {Promise<import("selenium-webdriver").WebElement>}
+     */
+    findRenderedScrollTarget(elementOrIdentifier: string | import("selenium-webdriver").WebElement | ({
+        selector: string;
+    } & FindArgs & {
+        withFallback?: boolean;
+    }), args: FindArgs | undefined, originalError: unknown): Promise<import("selenium-webdriver").WebElement>;
+    /**
+     * @param {string|import("selenium-webdriver").WebElement|({selector: string} & FindArgs & {withFallback?: boolean})} elementOrIdentifier
+     * @param {FindArgs} [args]
+     * @returns {{selector: string, findArgs: FindArgs} | undefined}
+     */
+    getSelectorScrollLookupArgs(elementOrIdentifier: string | import("selenium-webdriver").WebElement | ({
+        selector: string;
+    } & FindArgs & {
+        withFallback?: boolean;
+    }), args?: FindArgs): {
+        selector: string;
+        findArgs: FindArgs;
+    } | undefined;
+    /**
+     * @param {import("selenium-webdriver").WebElement} element
+     * @returns {Promise<boolean>}
+     */
+    isRenderedScrollTarget(element: import("selenium-webdriver").WebElement): Promise<boolean>;
     /**
      * Scrolls an element into view.
      * @param {string|import("selenium-webdriver").WebElement|({selector: string} & FindArgs & {withFallback?: boolean})} elementOrIdentifier

package/build/drivers/webdriver-driver.js

@@ -100,6 +100,53 @@ function shouldIgnoreBrowserLogEntry(entry, message) {
 class ElementNotFoundError extends Error {
 }
 const { WebDriverError } = SeleniumError;
+/**
+ * @param {Record<string, any> | undefined} args
+ * @param {string} key
+ * @returns {boolean}
+ */
+function hasOwnArg(args, key) {
+    return Boolean(args && Object.prototype.hasOwnProperty.call(args, key));
+}
+/**
+ * @param {unknown} error
+ * @returns {boolean}
+ */
+function isElementNotFoundError(error) {
+    let currentError = error;
+    while (currentError) {
+        if (currentError instanceof ElementNotFoundError)
+            return true;
+        if (!(currentError instanceof Error) || !("cause" in currentError)) {
+            return false;
+        }
+        currentError = currentError.cause;
+    }
+    return false;
+}
+/**
+ * @param {unknown} error
+ * @returns {boolean}
+ */
+function isElementLookupTimeoutError(error) {
+    let currentError = error;
+    while (currentError) {
+        if (currentError instanceof SeleniumError.TimeoutError)
+            return true;
+        if (!(currentError instanceof Error) || !("cause" in currentError)) {
+            return false;
+        }
+        currentError = currentError.cause;
+    }
+    return false;
+}
+/**
+ * @param {unknown} error
+ * @returns {boolean}
+ */
+function isElementUnavailableForScrollError(error) {
+    return isElementNotFoundError(error) || isElementLookupTimeoutError(error);
+}
 /**
  * Base driver using selenium-webdriver sessions.
  */
@@ -548,6 +595,97 @@ export default class WebDriverDriver {
     async scrollElementIntoView(element) {
         await this.getWebDriver().actions({ async: true }).move({ origin: element }).perform();
     }
+    /**
+     * @param {string|import("selenium-webdriver").WebElement|({selector: string} & FindArgs & {withFallback?: boolean})} elementOrIdentifier
+     * @param {FindArgs} [args]
+     * @returns {Promise<import("selenium-webdriver").WebElement>}
+     */
+    async findScrollTarget(elementOrIdentifier, args) {
+        try {
+            return await this._findElement(elementOrIdentifier, args);
+        }
+        catch (error) {
+            if (!isElementUnavailableForScrollError(error) || this.hasExplicitVisibleScrollLookup(elementOrIdentifier, args)) {
+                throw error;
+            }
+            return await this.findRenderedScrollTarget(elementOrIdentifier, args, error);
+        }
+    }
+    /**
+     * @param {string|import("selenium-webdriver").WebElement|({selector: string} & FindArgs & {withFallback?: boolean})} elementOrIdentifier
+     * @param {FindArgs} [args]
+     * @returns {boolean}
+     */
+    hasExplicitVisibleScrollLookup(elementOrIdentifier, args) {
+        if (hasOwnArg(args, "visible"))
+            return true;
+        return Boolean(typeof elementOrIdentifier == "object" &&
+            elementOrIdentifier !== null &&
+            "selector" in elementOrIdentifier &&
+            hasOwnArg(elementOrIdentifier, "visible"));
+    }
+    /**
+     * @param {string|import("selenium-webdriver").WebElement|({selector: string} & FindArgs & {withFallback?: boolean})} elementOrIdentifier
+     * @param {FindArgs | undefined} args
+     * @param {unknown} originalError
+     * @returns {Promise<import("selenium-webdriver").WebElement>}
+     */
+    async findRenderedScrollTarget(elementOrIdentifier, args, originalError) {
+        const selectorAndArgs = this.getSelectorScrollLookupArgs(elementOrIdentifier, args);
+        if (!selectorAndArgs)
+            throw originalError;
+        const { selector, findArgs } = selectorAndArgs;
+        const renderedElements = [];
+        const foundElements = await this.all(selector, { ...findArgs, scrollTo: false, timeout: 0, visible: null });
+        for (const element of foundElements) {
+            if (await this.isRenderedScrollTarget(element)) {
+                renderedElements.push(element);
+            }
+        }
+        if (renderedElements.length === 1)
+            return renderedElements[0];
+        if (renderedElements.length > 1) {
+            throw new Error(`More than 1 rendered elements (${renderedElements.length}) was found by CSS: ${this.getSelector(selector)}`);
+        }
+        throw originalError;
+    }
+    /**
+     * @param {string|import("selenium-webdriver").WebElement|({selector: string} & FindArgs & {withFallback?: boolean})} elementOrIdentifier
+     * @param {FindArgs} [args]
+     * @returns {{selector: string, findArgs: FindArgs} | undefined}
+     */
+    getSelectorScrollLookupArgs(elementOrIdentifier, args) {
+        if (typeof elementOrIdentifier == "string") {
+            return { selector: elementOrIdentifier, findArgs: args || {} };
+        }
+        if (typeof elementOrIdentifier == "object" && elementOrIdentifier !== null && "selector" in elementOrIdentifier) {
+            const { selector, ...restArgs } = elementOrIdentifier;
+            delete restArgs.withFallback;
+            return { selector, findArgs: restArgs };
+        }
+        return undefined;
+    }
+    /**
+     * @param {import("selenium-webdriver").WebElement} element
+     * @returns {Promise<boolean>}
+     */
+    async isRenderedScrollTarget(element) {
+        return Boolean(await this.getWebDriver().executeScript(`
+      const element = arguments[0]
+      if (!(element instanceof Element)) return false
+
+      for (let current = element; current; current = current.parentElement) {
+        const style = window.getComputedStyle(current)
+        if (current.hidden) return false
+        if (current.getAttribute("aria-hidden") === "true") return false
+        if (style.display === "none") return false
+        if (style.visibility === "hidden" || style.visibility === "collapse") return false
+        if (style.opacity === "0") return false
+      }
+
+      return Array.from(element.getClientRects()).some((rect) => rect.width > 0 && rect.height > 0)
+    `, element));
+    }
     /**
      * Scrolls an element into view.
      * @param {string|import("selenium-webdriver").WebElement|({selector: string} & FindArgs & {withFallback?: boolean})} elementOrIdentifier
@@ -555,7 +693,7 @@ export default class WebDriverDriver {
      * @returns {Promise<void>}
      */
     async scrollIntoView(elementOrIdentifier, args) {
-        const element = await this._findElement(elementOrIdentifier, args);
+        const element = await this.findScrollTarget(elementOrIdentifier, args);
         await this.scrollElementIntoView(element);
     }
     /**
@@ -565,7 +703,7 @@ export default class WebDriverDriver {
      * @returns {Promise<void>}
      */
     async scrollTestIdIntoView(testID, args) {
-        const element = await this.findByTestID(testID, args);
+        const element = await this.findScrollTarget(`[data-testid='${testID}']`, args);
         await this.scrollElementIntoView(element);
     }
     /**
@@ -783,4 +921,4 @@ export default class WebDriverDriver {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"webdriver-driver.js","sourceRoot":"","sources":["../../src/drivers/webdriver-driver.js"],"names":[],"mappings":"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","sourcesContent":["import {By, error as SeleniumError} from \"selenium-webdriver\"\nimport logging from \"selenium-webdriver/lib/logging.js\"\nimport {wait} from \"awaitery\"\nimport timeout from \"awaitery/build/timeout.js\"\n\n/**\n * @param {string} message\n * @param {unknown} cause\n * @returns {Error & {cause: unknown}}\n */\nfunction errorWithCause(message, cause) {\n  const error = /** @type {Error & {cause: unknown}} */ (new Error(message))\n  error.cause = cause\n  return error\n}\n\n/**\n * @param {unknown} element\n * @returns {element is import(\"selenium-webdriver\").WebElement}\n */\nfunction isWebDriverElement(element) {\n  return Boolean(\n    element &&\n    typeof element === \"object\" &&\n    \"getId\" in element &&\n    typeof element.getId === \"function\"\n  )\n}\n\n/**\n * @param {unknown} error\n * @returns {string | undefined}\n */\nfunction getErrorName(error) {\n  if (error instanceof Error) {\n    return error.constructor.name\n  }\n\n  return undefined\n}\n\n/**\n * @param {unknown} error\n * @returns {string | undefined}\n */\nfunction getRetryableInteractErrorName(error) {\n  let currentError = error\n\n  while (currentError) {\n    const errorName = getErrorName(currentError)\n\n    if (errorName === \"ElementNotInteractableError\" || errorName === \"ElementClickInterceptedError\" || errorName === \"StaleElementReferenceError\") {\n      return errorName\n    }\n\n    if (!(currentError instanceof Error) || !(\"cause\" in currentError)) {\n      return undefined\n    }\n\n    currentError = currentError.cause\n  }\n\n  return undefined\n}\n\n/**\n * @param {...any} args\n * @returns {string}\n */\nfunction getSendKeysTextAppend(...args) {\n  return args\n    .map((arg) => {\n      const stringArg = String(arg)\n\n      if (/[\\uE009\\uE03D]a\\uE000/i.test(stringArg)) {\n        return \"\"\n      }\n\n      return stringArg.replace(/[\\uE000-\\uF8FF]/g, \"\")\n    })\n    .join(\"\")\n}\n\n/**\n * @param {...any} args\n * @returns {boolean}\n */\nfunction getSendKeysUsesSelectAllAndDelete(...args) {\n  return args.some((arg) => /[\\uE009\\uE03D]a\\uE000/i.test(String(arg))) &&\n    args.some((arg) => String(arg).includes(\"\\uE003\") || String(arg).includes(\"\\uE017\"))\n}\n\n/**\n * @param {{level: {name: string}, message: string}} entry\n * @param {string} message\n * @returns {boolean}\n */\nfunction shouldIgnoreBrowserLogEntry(entry, message) {\n  return entry.level.name === \"DEBUG\" &&\n    /(?:^|\\s-\\s)\\[DOM\\] Password field is not contained in a form:/i.test(message)\n}\n\n/**\n * @typedef {object} FindArgs\n * @property {number} [timeout] Override timeout for lookup.\n * @property {boolean | null} [visible] Whether to require elements to be visible (`true`) or hidden (`false`). Use `null` to disable visibility filtering.\n * @property {\"actions\" | \"js\"} [method] Override the click path. `\"actions\"` uses the Selenium Actions API (real pointer move + click); `\"js\"` dispatches `element.click()` via `executeScript` inside the page's JS context (skips WebDriver's pointer synthesis entirely — useful when the default click is dropped by a framework responder that refuses synthetic WebDriver pointer events).\n * @property {boolean} [scrollTo] Whether to scroll found elements into view before returning them.\n * @property {boolean} [useBaseSelector] Whether to scope by the base selector.\n */\n/**\n * @typedef {FindArgs & {withFallback?: boolean}} InteractArgs\n */\n/**\n * @typedef {object} WaitForNoSelectorArgs\n * @property {boolean} [useBaseSelector] Whether to scope by the base selector.\n */\n\nclass ElementNotFoundError extends Error { }\nconst {WebDriverError} = SeleniumError\n\n/**\n * Base driver using selenium-webdriver sessions.\n */\nexport default class WebDriverDriver {\n  /**\n   * @param {object} args\n   * @param {import(\"../browser.js\").default} args.browser\n   * @param {Record<string, any>} [args.options]\n   */\n  constructor({browser, options = {}}) {\n    this.browser = browser\n    this.options = options\n    this.baseUrl = undefined\n    this.webDriver = undefined\n    this._driverTimeouts = 5000\n    this._timeouts = 5000\n    /**\n     * Process-exit handlers installed while a WebDriver session is alive.\n     * Retained so `stop()` can deregister them before removing the\n     * WebDriver reference.\n     * @type {{sigint: () => void, sigterm: () => void, beforeExit: () => void} | null}\n     */\n    this._exitHandlers = null\n  }\n\n  /**\n   * @param {string} baseUrl\n   * @returns {void}\n   */\n  setBaseUrl(baseUrl) {\n    this.baseUrl = baseUrl\n  }\n\n  /** @returns {string} */\n  getBaseUrl() {\n    if (!this.baseUrl) {\n      throw new Error(\"Driver base URL has not been set\")\n    }\n\n    return this.baseUrl\n  }\n\n  /** @returns {number} */\n  getTimeouts() { return this._timeouts }\n\n  /**\n   * @returns {import(\"selenium-webdriver\").WebDriver}\n   */\n  getWebDriver() {\n    if (!this.webDriver) throw new Error(\"Driver hasn't been initialized yet\")\n    this.browser.throwIfHttpServerError()\n\n    return this.webDriver\n  }\n\n  /**\n   * @param {import(\"selenium-webdriver\").WebDriver} webDriver\n   * @returns {void}\n   */\n  setWebDriver(webDriver) {\n    this.webDriver = webDriver\n    this.browser.driver = webDriver\n  }\n\n  /**\n   * Installs process-level handlers that terminate the WebDriver session\n   * if the Node process exits without an explicit `stop()` call. Without\n   * this, the chromedriver-spawned Chrome is orphaned to init (PPID=1)\n   * when the test runner exits — each `npx velocious test` run that\n   * skips explicit cleanup leaves a Chrome plus thousands of\n   * `/tmp/org.chromium.Chromium.scoped_dir.*` behind. Driver subclass\n   * `start()` implementations must call this after setting the\n   * WebDriver on a fresh session; tests that stub `setWebDriver`\n   * directly deliberately bypass it.\n   * @returns {void}\n   */\n  installExitHandlers() {\n    if (this._exitHandlers) return\n    const sigint = () => { void this._onExitSignal(\"SIGINT\") }\n    const sigterm = () => { void this._onExitSignal(\"SIGTERM\") }\n    const beforeExit = () => { void this._onExitSignal(\"beforeExit\") }\n    process.once(\"SIGINT\", sigint)\n    process.once(\"SIGTERM\", sigterm)\n    process.once(\"beforeExit\", beforeExit)\n    this._exitHandlers = {sigint, sigterm, beforeExit}\n  }\n\n  /** @returns {void} */\n  _removeExitHandlers() {\n    const handlers = this._exitHandlers\n    if (!handlers) return\n    this._exitHandlers = null\n    process.off(\"SIGINT\", handlers.sigint)\n    process.off(\"SIGTERM\", handlers.sigterm)\n    process.off(\"beforeExit\", handlers.beforeExit)\n  }\n\n  /**\n   * @param {\"SIGINT\" | \"SIGTERM\" | \"beforeExit\"} signal\n   * @returns {Promise<void>}\n   */\n  async _onExitSignal(signal) {\n    this._removeExitHandlers()\n    try {\n      await this.stop()\n    } catch {\n      // Best-effort — the process is going down anyway, and we'd rather\n      // orphan a browser than throw from a signal handler.\n    }\n    // Preserve the conventional signal-exit status (128 + signal number)\n    // so CI / wrapper scripts can still tell interrupted runs apart\n    // from a clean pass. Plain `process.exit(0)` would misreport a\n    // cancelled run as successful.\n    if (signal === \"SIGINT\") process.exit(130)\n    if (signal === \"SIGTERM\") process.exit(143)\n  }\n\n  /**\n   * @returns {Promise<void>}\n   */\n  async start() {\n    throw new Error(\"start() must be implemented by the driver\")\n  }\n\n  /**\n   * @returns {Promise<void>}\n   */\n  async stop() {\n    this._removeExitHandlers()\n    if (this.webDriver) {\n      await timeout({timeout: this.getTimeouts(), errorMessage: \"timeout while quitting WebDriver\"}, async () => await /** @type {NonNullable<typeof this.webDriver>} */ (this.webDriver).quit())\n    }\n\n    this.webDriver = undefined\n    this.browser.driver = undefined\n  }\n\n  /**\n   * @param {number} newTimeout\n   * @returns {Promise<void>}\n   */\n  async driverSetTimeouts(newTimeout) {\n    this._driverTimeouts = newTimeout\n    await this.getWebDriver().manage().setTimeouts({implicit: newTimeout})\n  }\n\n  /**\n   * @returns {Promise<void>}\n   */\n  async restoreTimeouts() {\n    if (!this.getTimeouts()) {\n      throw new Error(\"Timeouts haven't previously been set\")\n    }\n\n    await this.driverSetTimeouts(this.getTimeouts())\n  }\n\n  /**\n   * @param {number} newTimeout\n   * @returns {Promise<void>}\n   */\n  async setTimeouts(newTimeout) {\n    this._timeouts = newTimeout\n    await this.restoreTimeouts()\n  }\n\n  /**\n   * @param {string} selector\n   * @returns {string}\n   */\n  getSelector(selector) {\n    return this.browser.getSelector(selector)\n  }\n\n  /**\n   * @param {string} path\n   * @returns {Promise<void>}\n   */\n  async driverVisit(path) {\n    const isAbsoluteUrl = /^[a-z]+:\\/\\//i.test(path)\n    const url = isAbsoluteUrl ? path : `${this.getBaseUrl()}${path}`\n\n    await this.getWebDriver().get(url)\n  }\n\n  /**\n   * Deletes all cookies for the current browser session.\n   * @returns {Promise<void>}\n   */\n  async deleteAllCookies() {\n    await this.getWebDriver().manage().deleteAllCookies()\n  }\n\n  /** @returns {Promise<string>} */\n  async getCurrentUrl() {\n    try {\n      return await this.getWebDriver().getCurrentUrl()\n    } catch {\n      return \"\"\n    }\n  }\n\n  /** @returns {Promise<string>} */\n  async getHTML() {\n    return await this.getWebDriver().getPageSource()\n  }\n\n  /** @returns {Promise<string>} */\n  async takeScreenshot() {\n    return await this.getWebDriver().takeScreenshot()\n  }\n\n  /**\n   * Gets browser logs\n   * @returns {Promise<string[]>}\n   */\n  async getBrowserLogs() {\n    let entries\n\n    try {\n      entries = await this.getWebDriver().manage().logs().get(logging.Type.BROWSER)\n    } catch {\n      return []\n    }\n    const browserLogs = []\n\n    for (const entry of entries) {\n      const messageMatch = entry.message.match(/^(.+) (\\d+):(\\d+) (.+)$/)\n      let message\n\n      if (messageMatch) {\n        message = messageMatch[4]\n      } else {\n        message = entry.message\n      }\n\n      if (shouldIgnoreBrowserLogEntry(entry, message)) continue\n\n      browserLogs.push(`${entry.level.name}: ${message}`)\n    }\n\n    return browserLogs\n  }\n\n  /**\n   * Finds all elements by CSS selector\n   * @param {string} selector\n   * @param {FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement[]>}\n   */\n  async all(selector, args = {}) {\n    const {scrollTo = false, visible = true, timeout, useBaseSelector = true, ...restArgs} = args\n    const restArgsKeys = Object.keys(restArgs)\n    let actualTimeout\n\n    if (timeout === undefined) {\n      actualTimeout = this._driverTimeouts\n    } else {\n      actualTimeout = timeout\n    }\n\n    if (restArgsKeys.length > 0) throw new Error(`Unknown arguments: ${restArgsKeys.join(\", \")}`)\n\n    const actualSelector = useBaseSelector ? this.getSelector(selector) : selector\n    const startTime = Date.now()\n    const getTimeLeft = () => Math.max(actualTimeout - (Date.now() - startTime), 0)\n    const getElements = async () => {\n      const foundElements = await this.getWebDriver().findElements(By.css(actualSelector))\n\n      if (visible !== true && visible !== false) {\n        return foundElements\n      }\n\n      const filteredElements = []\n\n      for (const element of foundElements) {\n        const isDisplayed = await element.isDisplayed()\n\n        if (visible && !isDisplayed) continue\n        if (!visible && isDisplayed) continue\n\n        filteredElements.push(element)\n      }\n\n      return filteredElements\n    }\n    /** @type {import(\"selenium-webdriver\").WebElement[]} */\n    let elements = []\n\n    while (true) {\n      const timeLeft = actualTimeout == 0 ? 0 : getTimeLeft()\n\n      try {\n        if (timeLeft == 0) {\n          elements = await getElements()\n        } else {\n          await this.getWebDriver().wait(async () => {\n            elements = await getElements()\n\n            return elements.length > 0\n          }, timeLeft)\n        }\n\n        break\n      } catch (error) {\n        let isStaleElementError = false\n\n        if (error instanceof SeleniumError.StaleElementReferenceError) {\n          isStaleElementError = true\n        } else if (error instanceof WebDriverError && error.message.toLowerCase().includes(\"stale element reference\")) {\n          isStaleElementError = true\n        }\n\n        if (\n          (error instanceof SeleniumError.TimeoutError || isStaleElementError)\n          && getTimeLeft() > 0\n        ) {\n          continue\n        }\n\n        throw errorWithCause(`Couldn't get elements with selector: ${actualSelector}: ${error instanceof Error ? error.message : error}`, error)\n      }\n    }\n    if (scrollTo) {\n      for (const element of elements) {\n        await this.scrollElementIntoView(element)\n      }\n    }\n\n    return elements\n  }\n\n  /**\n   * Finds a single element by CSS selector\n   * @param {string} selector\n   * @param {FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async find(selector, args = {}) {\n    const startTime = Date.now()\n    /** @type {import(\"selenium-webdriver\").WebElement[]} */\n    let elements\n\n    try {\n      elements = await this.all(selector, args)\n    } catch (error) {\n      if (error instanceof Error) {\n        throw errorWithCause(`${error.constructor.name} - ${error.message} (selector: ${this.getSelector(selector)})`, error)\n      }\n\n      throw errorWithCause(`${typeof error} - ${error} (selector: ${this.getSelector(selector)})`, error)\n    }\n\n    if (elements.length > 1) {\n      throw new Error(`More than 1 elements (${elements.length}) was found by CSS: ${this.getSelector(selector)}`)\n    }\n\n    if (!elements[0]) {\n      const elapsedSeconds = (Date.now() - startTime) / 1000\n      throw new ElementNotFoundError(`Element couldn't be found after ${elapsedSeconds.toFixed(2)}s by CSS: ${this.getSelector(selector)}`)\n    }\n\n    return elements[0]\n  }\n\n  /**\n   * Finds a single element by test ID\n   * @param {string} testID\n   * @param {FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async findByTestID(testID, args) {\n    return await this.find(`[data-testid='${testID}']`, args)\n  }\n\n  /**\n   * Checks whether an element with the given test ID is currently rendered.\n   * @param {string} testID\n   * @param {FindArgs} [args]\n   * @returns {Promise<boolean>}\n   */\n  async hasTestID(testID, args) {\n    try {\n      await this.findByTestID(testID, {...args, timeout: 0})\n      return true\n    } catch (error) {\n      if (error instanceof ElementNotFoundError) {\n        return false\n      }\n\n      throw error\n    }\n  }\n\n  /**\n   * @param {string|import(\"selenium-webdriver\").WebElement|({selector: string} & FindArgs & {withFallback?: boolean})} elementOrIdentifier\n   * @param {FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async _findElement(elementOrIdentifier, args) {\n    /** @type {import(\"selenium-webdriver\").WebElement} */\n    let element\n\n    if (typeof elementOrIdentifier == \"string\") {\n      element = await this.find(elementOrIdentifier, args)\n    } else if (typeof elementOrIdentifier == \"object\" && elementOrIdentifier !== null && \"selector\" in elementOrIdentifier) {\n      const {selector, ...restArgs} = elementOrIdentifier\n\n      delete restArgs.withFallback\n\n      element = await this.find(selector, restArgs)\n    } else {\n      element = /** @type {import(\"selenium-webdriver\").WebElement} */ (elementOrIdentifier)\n    }\n\n    return element\n  }\n\n  /**\n   * Finds a single element by CSS selector without waiting\n   * @param {string} selector\n   * @param {FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async findNoWait(selector, args = {}) {\n    await this.driverSetTimeouts(0)\n\n    try {\n      return await this.find(selector, args)\n    } finally {\n      await this.restoreTimeouts()\n    }\n  }\n\n  /**\n   * Clicks an element, allowing selector args when using a CSS selector.\n   * @param {string|import(\"selenium-webdriver\").WebElement} elementOrIdentifier\n   * @param {FindArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async click(elementOrIdentifier, args) {\n    const {method, scrollTo = false, ...findArgs} = args || {}\n    let tries = 0\n\n    while (true) {\n      tries++\n\n      try {\n        const element = await this._findElement(elementOrIdentifier, findArgs)\n\n        if (scrollTo) {\n          await this.scrollElementIntoView(element)\n        }\n\n        if (method === \"actions\") {\n          await this.getWebDriver().actions({async: true}).move({origin: element}).click().perform()\n        } else if (method === \"js\") {\n          await this.getWebDriver().executeScript(\"arguments[0].click()\", element)\n        } else if (method === undefined) {\n          await element.click()\n        } else {\n          throw new Error(`Unknown method: ${method}`)\n        }\n\n        break\n      } catch (error) {\n        if (error instanceof Error) {\n          if (error.constructor.name === \"ElementClickInterceptedError\" || error.constructor.name === \"StaleElementReferenceError\") {\n            throw error\n          } else if (error.constructor.name === \"ElementNotInteractableError\") {\n            if (tries >= 3) {\n              throw errorWithCause(`Element ${elementOrIdentifier.constructor.name} click failed after ${tries} tries - ${error.constructor.name}: ${error.message}`, error)\n            } else {\n              await wait(50)\n            }\n          } else {\n            throw errorWithCause(`Element ${elementOrIdentifier.constructor.name} click failed - ${error.constructor.name}: ${error.message}`, error)\n          }\n        } else {\n          throw errorWithCause(`Element ${elementOrIdentifier.constructor.name} click failed - ${typeof error}: ${error}`, error)\n        }\n      }\n    }\n  }\n\n  /**\n   * @param {import(\"selenium-webdriver\").WebElement} element\n   * @returns {Promise<void>}\n   */\n  async scrollElementIntoView(element) {\n    await this.getWebDriver().actions({async: true}).move({origin: element}).perform()\n  }\n\n  /**\n   * Scrolls an element into view.\n   * @param {string|import(\"selenium-webdriver\").WebElement|({selector: string} & FindArgs & {withFallback?: boolean})} elementOrIdentifier\n   * @param {FindArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async scrollIntoView(elementOrIdentifier, args) {\n    const element = await this._findElement(elementOrIdentifier, args)\n    await this.scrollElementIntoView(element)\n  }\n\n  /**\n   * Scrolls the element with the given test ID into view.\n   * @param {string} testID\n   * @param {FindArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async scrollTestIdIntoView(testID, args) {\n    const element = await this.findByTestID(testID, args)\n    await this.scrollElementIntoView(element)\n  }\n\n  /**\n   * Interacts with an element by calling a method on it with the given arguments.\n   * Retrying on ElementNotInteractableError, ElementClickInterceptedError, or StaleElementReferenceError.\n   * @param {import(\"selenium-webdriver\").WebElement|string|{selector: string} & InteractArgs} elementOrIdentifier The element or a CSS selector to find the element.\n   * @param {string} methodName The method name to call on the element.\n   * @param {...any} args Arguments to pass to the method.\n   * @returns {Promise<any>}\n   */\n  async interact(elementOrIdentifier, methodName, ...args) {\n    let tries = 0\n\n    while (true) {\n      tries++\n\n      /** @type {InteractArgs | undefined} */\n      let interactArgs\n\n      if (typeof elementOrIdentifier === \"object\" && elementOrIdentifier && !isWebDriverElement(elementOrIdentifier)) {\n        interactArgs = elementOrIdentifier\n      }\n\n      /** @type {FindArgs | undefined} */\n      let findArgs\n\n      if (interactArgs) {\n        /** @type {FindArgs & {selector?: string, method?: any, withFallback?: any}} */\n        const sanitizedFindArgs = {...interactArgs}\n\n        delete sanitizedFindArgs.selector\n        delete sanitizedFindArgs.method\n        delete sanitizedFindArgs.withFallback\n        findArgs = sanitizedFindArgs\n      }\n\n      const element = interactArgs\n        ? await this._findElement(/** @type {{selector: string}} */ (interactArgs).selector, findArgs)\n        : await this._findElement(elementOrIdentifier, findArgs)\n\n      try {\n        if (methodName === \"sendKeys\") {\n          if (interactArgs?.withFallback) {\n            return await this.interactSendKeysWithFallback(element, ...args)\n          }\n\n          return await element.sendKeys(...args)\n        } else if (methodName === \"click\") {\n          if (isWebDriverElement(element)) {\n            /** @type {FindArgs} */\n            const clickArgs = {}\n            if (interactArgs?.method !== undefined) clickArgs.method = interactArgs.method\n            if (interactArgs?.scrollTo !== undefined) clickArgs.scrollTo = interactArgs.scrollTo\n\n            await this.click(element, clickArgs)\n\n            return undefined\n          }\n\n          return await /** @type {{click: (...clickArgs: any[]) => Promise<any>}} */ (element).click(...args)\n        } else if (!(/** @type {any} */ (element))[methodName]) {\n          throw new Error(`${element.constructor.name} hasn't an attribute named: ${methodName}`)\n        } else if (typeof (/** @type {any} */ (element))[methodName] != \"function\") {\n          throw new Error(`${element.constructor.name}#${methodName} is not a function`)\n        }\n\n        // Dont call with candidate, because that will bind the function wrong.\n        return await (/** @type {any} */ (element))[methodName](...args)\n      } catch (error) {\n        if (error instanceof Error) {\n          const retryableErrorName = getRetryableInteractErrorName(error)\n\n          if (retryableErrorName) {\n            // Retry finding the element and interacting with it\n            if (tries >= 3) {\n              let elementDescription\n\n              if (typeof elementOrIdentifier == \"string\") {\n                elementDescription = `CSS selector ${elementOrIdentifier}`\n              } else {\n                elementDescription = `${element.constructor.name}`\n              }\n\n              throw errorWithCause(`${elementDescription} ${methodName} failed after ${tries} tries - ${retryableErrorName}: ${error.message}`, error)\n            } else {\n              await wait(50)\n            }\n          } else {\n            throw errorWithCause(`${element.constructor.name} ${methodName} failed - ${error.constructor.name}: ${error.message}`, error)\n          }\n        } else {\n          throw errorWithCause(`${element.constructor.name} ${methodName} failed - ${typeof error}: ${error}`, error)\n        }\n      }\n    }\n  }\n\n  /**\n   * @param {import(\"selenium-webdriver\").WebElement} element\n   * @returns {Promise<string | undefined>}\n   */\n  async readInteractableValue(element) {\n    const valueProperty = await element.getAttribute(\"value\")\n\n    if (typeof valueProperty == \"string\") {\n      return valueProperty\n    }\n\n    const textContent = await element.getText()\n\n    if (typeof textContent == \"string\") {\n      return textContent\n    }\n\n    return undefined\n  }\n\n  /**\n   * @param {import(\"selenium-webdriver\").WebElement} element\n   * @param {...any} args\n   * @returns {Promise<unknown>}\n   */\n  async interactSendKeysWithFallback(element, ...args) {\n    const expectedAppend = getSendKeysTextAppend(...args)\n    const beforeValue = await this.readInteractableValue(element)\n    const sendKeysResult = await element.sendKeys(...args)\n    const afterValue = await this.readInteractableValue(element)\n\n    if (typeof beforeValue == \"string\" && typeof afterValue == \"string\" && afterValue !== beforeValue) {\n      return sendKeysResult\n    }\n\n    const nextValue = getSendKeysUsesSelectAllAndDelete(...args) ? expectedAppend : `${beforeValue || \"\"}${expectedAppend}`\n\n    if (typeof beforeValue == \"string\" && nextValue === beforeValue) {\n      return sendKeysResult\n    }\n\n    await this.getWebDriver().executeScript(`\n      const element = arguments[0]\n      const nextValue = String(arguments[1] ?? \"\")\n\n      if (typeof element.focus == \"function\") {\n        element.focus()\n      }\n\n      if (typeof element.value == \"string\") {\n        const prototype = Object.getPrototypeOf(element)\n        const descriptor = Object.getOwnPropertyDescriptor(prototype, \"value\") || Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, \"value\") || Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, \"value\")\n        const previousValue = String(element.value)\n\n        if (descriptor && typeof descriptor.set == \"function\") {\n          descriptor.set.call(element, nextValue)\n        } else {\n          element.value = nextValue\n        }\n\n        if (element._valueTracker && typeof element._valueTracker.setValue == \"function\") {\n          element._valueTracker.setValue(previousValue)\n        }\n\n        element.dispatchEvent(new Event(\"input\", {bubbles: true}))\n        element.dispatchEvent(new Event(\"change\", {bubbles: true}))\n        return element.value\n      }\n\n      if (element.isContentEditable) {\n        element.textContent = nextValue\n        element.dispatchEvent(new Event(\"input\", {bubbles: true}))\n        return element.textContent\n      }\n\n      return null\n    `, element, nextValue)\n\n    return sendKeysResult\n  }\n\n  /**\n   * @param {string} selector\n   * @param {WaitForNoSelectorArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async waitForNoSelector(selector, args = {}) {\n    const {useBaseSelector, ...restArgs} = args\n\n    if (Object.keys(restArgs).length > 0) {\n      throw new Error(`Unexpected args: ${Object.keys(restArgs).join(\", \")}`)\n    }\n\n    const actualSelector = useBaseSelector ? this.getSelector(selector) : selector\n\n    await this.driverSetTimeouts(0)\n\n    try {\n      await this._withRethrownErrors(async () => {\n        await this.getWebDriver().wait(\n          async () => {\n            const elements = await this.getWebDriver().findElements(By.css(actualSelector))\n\n            // Not found at all\n            if (elements.length === 0) {\n              return true\n            }\n\n            // Found but not visible\n            try {\n              const isDisplayed = await elements[0].isDisplayed()\n\n              return !isDisplayed\n            } catch (error) {\n              if (\n                error instanceof Error &&\n                (error.constructor.name === \"StaleElementReferenceError\" || error.message.includes(\"stale element reference\"))\n              ) {\n                return false\n              }\n\n              throw error\n            }\n          },\n          this.getTimeouts()\n        )\n      })\n    } finally {\n      await this.restoreTimeouts()\n    }\n  }\n\n  /**\n   * @param {() => Promise<any>} callback\n   * @returns {Promise<any>}\n   */\n  async _withRethrownErrors(callback) {\n    try {\n      return await callback()\n    } catch (error) {\n      if (error instanceof WebDriverError) {\n        throw errorWithCause(`Selenium ${error.constructor.name}: ${error.message}`, error)\n      } else {\n        throw error\n      }\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"webdriver-driver.js","sourceRoot":"","sources":["../../src/drivers/webdriver-driver.js"],"names":[],"mappings":"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","sourcesContent":["import {By, error as SeleniumError} from \"selenium-webdriver\"\nimport logging from \"selenium-webdriver/lib/logging.js\"\nimport {wait} from \"awaitery\"\nimport timeout from \"awaitery/build/timeout.js\"\n\n/**\n * @param {string} message\n * @param {unknown} cause\n * @returns {Error & {cause: unknown}}\n */\nfunction errorWithCause(message, cause) {\n  const error = /** @type {Error & {cause: unknown}} */ (new Error(message))\n  error.cause = cause\n  return error\n}\n\n/**\n * @param {unknown} element\n * @returns {element is import(\"selenium-webdriver\").WebElement}\n */\nfunction isWebDriverElement(element) {\n  return Boolean(\n    element &&\n    typeof element === \"object\" &&\n    \"getId\" in element &&\n    typeof element.getId === \"function\"\n  )\n}\n\n/**\n * @param {unknown} error\n * @returns {string | undefined}\n */\nfunction getErrorName(error) {\n  if (error instanceof Error) {\n    return error.constructor.name\n  }\n\n  return undefined\n}\n\n/**\n * @param {unknown} error\n * @returns {string | undefined}\n */\nfunction getRetryableInteractErrorName(error) {\n  let currentError = error\n\n  while (currentError) {\n    const errorName = getErrorName(currentError)\n\n    if (errorName === \"ElementNotInteractableError\" || errorName === \"ElementClickInterceptedError\" || errorName === \"StaleElementReferenceError\") {\n      return errorName\n    }\n\n    if (!(currentError instanceof Error) || !(\"cause\" in currentError)) {\n      return undefined\n    }\n\n    currentError = currentError.cause\n  }\n\n  return undefined\n}\n\n/**\n * @param {...any} args\n * @returns {string}\n */\nfunction getSendKeysTextAppend(...args) {\n  return args\n    .map((arg) => {\n      const stringArg = String(arg)\n\n      if (/[\\uE009\\uE03D]a\\uE000/i.test(stringArg)) {\n        return \"\"\n      }\n\n      return stringArg.replace(/[\\uE000-\\uF8FF]/g, \"\")\n    })\n    .join(\"\")\n}\n\n/**\n * @param {...any} args\n * @returns {boolean}\n */\nfunction getSendKeysUsesSelectAllAndDelete(...args) {\n  return args.some((arg) => /[\\uE009\\uE03D]a\\uE000/i.test(String(arg))) &&\n    args.some((arg) => String(arg).includes(\"\\uE003\") || String(arg).includes(\"\\uE017\"))\n}\n\n/**\n * @param {{level: {name: string}, message: string}} entry\n * @param {string} message\n * @returns {boolean}\n */\nfunction shouldIgnoreBrowserLogEntry(entry, message) {\n  return entry.level.name === \"DEBUG\" &&\n    /(?:^|\\s-\\s)\\[DOM\\] Password field is not contained in a form:/i.test(message)\n}\n\n/**\n * @typedef {object} FindArgs\n * @property {number} [timeout] Override timeout for lookup.\n * @property {boolean | null} [visible] Whether to require elements to be visible (`true`) or hidden (`false`). Use `null` to disable visibility filtering.\n * @property {\"actions\" | \"js\"} [method] Override the click path. `\"actions\"` uses the Selenium Actions API (real pointer move + click); `\"js\"` dispatches `element.click()` via `executeScript` inside the page's JS context (skips WebDriver's pointer synthesis entirely — useful when the default click is dropped by a framework responder that refuses synthetic WebDriver pointer events).\n * @property {boolean} [scrollTo] Whether to scroll found elements into view before returning them.\n * @property {boolean} [useBaseSelector] Whether to scope by the base selector.\n */\n/**\n * @typedef {FindArgs & {withFallback?: boolean}} InteractArgs\n */\n/**\n * @typedef {object} WaitForNoSelectorArgs\n * @property {boolean} [useBaseSelector] Whether to scope by the base selector.\n */\n\nclass ElementNotFoundError extends Error { }\nconst {WebDriverError} = SeleniumError\n\n/**\n * @param {Record<string, any> | undefined} args\n * @param {string} key\n * @returns {boolean}\n */\nfunction hasOwnArg(args, key) {\n  return Boolean(args && Object.prototype.hasOwnProperty.call(args, key))\n}\n\n/**\n * @param {unknown} error\n * @returns {boolean}\n */\nfunction isElementNotFoundError(error) {\n  let currentError = error\n\n  while (currentError) {\n    if (currentError instanceof ElementNotFoundError) return true\n\n    if (!(currentError instanceof Error) || !(\"cause\" in currentError)) {\n      return false\n    }\n\n    currentError = currentError.cause\n  }\n\n  return false\n}\n\n/**\n * @param {unknown} error\n * @returns {boolean}\n */\nfunction isElementLookupTimeoutError(error) {\n  let currentError = error\n\n  while (currentError) {\n    if (currentError instanceof SeleniumError.TimeoutError) return true\n\n    if (!(currentError instanceof Error) || !(\"cause\" in currentError)) {\n      return false\n    }\n\n    currentError = currentError.cause\n  }\n\n  return false\n}\n\n/**\n * @param {unknown} error\n * @returns {boolean}\n */\nfunction isElementUnavailableForScrollError(error) {\n  return isElementNotFoundError(error) || isElementLookupTimeoutError(error)\n}\n\n/**\n * Base driver using selenium-webdriver sessions.\n */\nexport default class WebDriverDriver {\n  /**\n   * @param {object} args\n   * @param {import(\"../browser.js\").default} args.browser\n   * @param {Record<string, any>} [args.options]\n   */\n  constructor({browser, options = {}}) {\n    this.browser = browser\n    this.options = options\n    this.baseUrl = undefined\n    this.webDriver = undefined\n    this._driverTimeouts = 5000\n    this._timeouts = 5000\n    /**\n     * Process-exit handlers installed while a WebDriver session is alive.\n     * Retained so `stop()` can deregister them before removing the\n     * WebDriver reference.\n     * @type {{sigint: () => void, sigterm: () => void, beforeExit: () => void} | null}\n     */\n    this._exitHandlers = null\n  }\n\n  /**\n   * @param {string} baseUrl\n   * @returns {void}\n   */\n  setBaseUrl(baseUrl) {\n    this.baseUrl = baseUrl\n  }\n\n  /** @returns {string} */\n  getBaseUrl() {\n    if (!this.baseUrl) {\n      throw new Error(\"Driver base URL has not been set\")\n    }\n\n    return this.baseUrl\n  }\n\n  /** @returns {number} */\n  getTimeouts() { return this._timeouts }\n\n  /**\n   * @returns {import(\"selenium-webdriver\").WebDriver}\n   */\n  getWebDriver() {\n    if (!this.webDriver) throw new Error(\"Driver hasn't been initialized yet\")\n    this.browser.throwIfHttpServerError()\n\n    return this.webDriver\n  }\n\n  /**\n   * @param {import(\"selenium-webdriver\").WebDriver} webDriver\n   * @returns {void}\n   */\n  setWebDriver(webDriver) {\n    this.webDriver = webDriver\n    this.browser.driver = webDriver\n  }\n\n  /**\n   * Installs process-level handlers that terminate the WebDriver session\n   * if the Node process exits without an explicit `stop()` call. Without\n   * this, the chromedriver-spawned Chrome is orphaned to init (PPID=1)\n   * when the test runner exits — each `npx velocious test` run that\n   * skips explicit cleanup leaves a Chrome plus thousands of\n   * `/tmp/org.chromium.Chromium.scoped_dir.*` behind. Driver subclass\n   * `start()` implementations must call this after setting the\n   * WebDriver on a fresh session; tests that stub `setWebDriver`\n   * directly deliberately bypass it.\n   * @returns {void}\n   */\n  installExitHandlers() {\n    if (this._exitHandlers) return\n    const sigint = () => { void this._onExitSignal(\"SIGINT\") }\n    const sigterm = () => { void this._onExitSignal(\"SIGTERM\") }\n    const beforeExit = () => { void this._onExitSignal(\"beforeExit\") }\n    process.once(\"SIGINT\", sigint)\n    process.once(\"SIGTERM\", sigterm)\n    process.once(\"beforeExit\", beforeExit)\n    this._exitHandlers = {sigint, sigterm, beforeExit}\n  }\n\n  /** @returns {void} */\n  _removeExitHandlers() {\n    const handlers = this._exitHandlers\n    if (!handlers) return\n    this._exitHandlers = null\n    process.off(\"SIGINT\", handlers.sigint)\n    process.off(\"SIGTERM\", handlers.sigterm)\n    process.off(\"beforeExit\", handlers.beforeExit)\n  }\n\n  /**\n   * @param {\"SIGINT\" | \"SIGTERM\" | \"beforeExit\"} signal\n   * @returns {Promise<void>}\n   */\n  async _onExitSignal(signal) {\n    this._removeExitHandlers()\n    try {\n      await this.stop()\n    } catch {\n      // Best-effort — the process is going down anyway, and we'd rather\n      // orphan a browser than throw from a signal handler.\n    }\n    // Preserve the conventional signal-exit status (128 + signal number)\n    // so CI / wrapper scripts can still tell interrupted runs apart\n    // from a clean pass. Plain `process.exit(0)` would misreport a\n    // cancelled run as successful.\n    if (signal === \"SIGINT\") process.exit(130)\n    if (signal === \"SIGTERM\") process.exit(143)\n  }\n\n  /**\n   * @returns {Promise<void>}\n   */\n  async start() {\n    throw new Error(\"start() must be implemented by the driver\")\n  }\n\n  /**\n   * @returns {Promise<void>}\n   */\n  async stop() {\n    this._removeExitHandlers()\n    if (this.webDriver) {\n      await timeout({timeout: this.getTimeouts(), errorMessage: \"timeout while quitting WebDriver\"}, async () => await /** @type {NonNullable<typeof this.webDriver>} */ (this.webDriver).quit())\n    }\n\n    this.webDriver = undefined\n    this.browser.driver = undefined\n  }\n\n  /**\n   * @param {number} newTimeout\n   * @returns {Promise<void>}\n   */\n  async driverSetTimeouts(newTimeout) {\n    this._driverTimeouts = newTimeout\n    await this.getWebDriver().manage().setTimeouts({implicit: newTimeout})\n  }\n\n  /**\n   * @returns {Promise<void>}\n   */\n  async restoreTimeouts() {\n    if (!this.getTimeouts()) {\n      throw new Error(\"Timeouts haven't previously been set\")\n    }\n\n    await this.driverSetTimeouts(this.getTimeouts())\n  }\n\n  /**\n   * @param {number} newTimeout\n   * @returns {Promise<void>}\n   */\n  async setTimeouts(newTimeout) {\n    this._timeouts = newTimeout\n    await this.restoreTimeouts()\n  }\n\n  /**\n   * @param {string} selector\n   * @returns {string}\n   */\n  getSelector(selector) {\n    return this.browser.getSelector(selector)\n  }\n\n  /**\n   * @param {string} path\n   * @returns {Promise<void>}\n   */\n  async driverVisit(path) {\n    const isAbsoluteUrl = /^[a-z]+:\\/\\//i.test(path)\n    const url = isAbsoluteUrl ? path : `${this.getBaseUrl()}${path}`\n\n    await this.getWebDriver().get(url)\n  }\n\n  /**\n   * Deletes all cookies for the current browser session.\n   * @returns {Promise<void>}\n   */\n  async deleteAllCookies() {\n    await this.getWebDriver().manage().deleteAllCookies()\n  }\n\n  /** @returns {Promise<string>} */\n  async getCurrentUrl() {\n    try {\n      return await this.getWebDriver().getCurrentUrl()\n    } catch {\n      return \"\"\n    }\n  }\n\n  /** @returns {Promise<string>} */\n  async getHTML() {\n    return await this.getWebDriver().getPageSource()\n  }\n\n  /** @returns {Promise<string>} */\n  async takeScreenshot() {\n    return await this.getWebDriver().takeScreenshot()\n  }\n\n  /**\n   * Gets browser logs\n   * @returns {Promise<string[]>}\n   */\n  async getBrowserLogs() {\n    let entries\n\n    try {\n      entries = await this.getWebDriver().manage().logs().get(logging.Type.BROWSER)\n    } catch {\n      return []\n    }\n    const browserLogs = []\n\n    for (const entry of entries) {\n      const messageMatch = entry.message.match(/^(.+) (\\d+):(\\d+) (.+)$/)\n      let message\n\n      if (messageMatch) {\n        message = messageMatch[4]\n      } else {\n        message = entry.message\n      }\n\n      if (shouldIgnoreBrowserLogEntry(entry, message)) continue\n\n      browserLogs.push(`${entry.level.name}: ${message}`)\n    }\n\n    return browserLogs\n  }\n\n  /**\n   * Finds all elements by CSS selector\n   * @param {string} selector\n   * @param {FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement[]>}\n   */\n  async all(selector, args = {}) {\n    const {scrollTo = false, visible = true, timeout, useBaseSelector = true, ...restArgs} = args\n    const restArgsKeys = Object.keys(restArgs)\n    let actualTimeout\n\n    if (timeout === undefined) {\n      actualTimeout = this._driverTimeouts\n    } else {\n      actualTimeout = timeout\n    }\n\n    if (restArgsKeys.length > 0) throw new Error(`Unknown arguments: ${restArgsKeys.join(\", \")}`)\n\n    const actualSelector = useBaseSelector ? this.getSelector(selector) : selector\n    const startTime = Date.now()\n    const getTimeLeft = () => Math.max(actualTimeout - (Date.now() - startTime), 0)\n    const getElements = async () => {\n      const foundElements = await this.getWebDriver().findElements(By.css(actualSelector))\n\n      if (visible !== true && visible !== false) {\n        return foundElements\n      }\n\n      const filteredElements = []\n\n      for (const element of foundElements) {\n        const isDisplayed = await element.isDisplayed()\n\n        if (visible && !isDisplayed) continue\n        if (!visible && isDisplayed) continue\n\n        filteredElements.push(element)\n      }\n\n      return filteredElements\n    }\n    /** @type {import(\"selenium-webdriver\").WebElement[]} */\n    let elements = []\n\n    while (true) {\n      const timeLeft = actualTimeout == 0 ? 0 : getTimeLeft()\n\n      try {\n        if (timeLeft == 0) {\n          elements = await getElements()\n        } else {\n          await this.getWebDriver().wait(async () => {\n            elements = await getElements()\n\n            return elements.length > 0\n          }, timeLeft)\n        }\n\n        break\n      } catch (error) {\n        let isStaleElementError = false\n\n        if (error instanceof SeleniumError.StaleElementReferenceError) {\n          isStaleElementError = true\n        } else if (error instanceof WebDriverError && error.message.toLowerCase().includes(\"stale element reference\")) {\n          isStaleElementError = true\n        }\n\n        if (\n          (error instanceof SeleniumError.TimeoutError || isStaleElementError)\n          && getTimeLeft() > 0\n        ) {\n          continue\n        }\n\n        throw errorWithCause(`Couldn't get elements with selector: ${actualSelector}: ${error instanceof Error ? error.message : error}`, error)\n      }\n    }\n    if (scrollTo) {\n      for (const element of elements) {\n        await this.scrollElementIntoView(element)\n      }\n    }\n\n    return elements\n  }\n\n  /**\n   * Finds a single element by CSS selector\n   * @param {string} selector\n   * @param {FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async find(selector, args = {}) {\n    const startTime = Date.now()\n    /** @type {import(\"selenium-webdriver\").WebElement[]} */\n    let elements\n\n    try {\n      elements = await this.all(selector, args)\n    } catch (error) {\n      if (error instanceof Error) {\n        throw errorWithCause(`${error.constructor.name} - ${error.message} (selector: ${this.getSelector(selector)})`, error)\n      }\n\n      throw errorWithCause(`${typeof error} - ${error} (selector: ${this.getSelector(selector)})`, error)\n    }\n\n    if (elements.length > 1) {\n      throw new Error(`More than 1 elements (${elements.length}) was found by CSS: ${this.getSelector(selector)}`)\n    }\n\n    if (!elements[0]) {\n      const elapsedSeconds = (Date.now() - startTime) / 1000\n      throw new ElementNotFoundError(`Element couldn't be found after ${elapsedSeconds.toFixed(2)}s by CSS: ${this.getSelector(selector)}`)\n    }\n\n    return elements[0]\n  }\n\n  /**\n   * Finds a single element by test ID\n   * @param {string} testID\n   * @param {FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async findByTestID(testID, args) {\n    return await this.find(`[data-testid='${testID}']`, args)\n  }\n\n  /**\n   * Checks whether an element with the given test ID is currently rendered.\n   * @param {string} testID\n   * @param {FindArgs} [args]\n   * @returns {Promise<boolean>}\n   */\n  async hasTestID(testID, args) {\n    try {\n      await this.findByTestID(testID, {...args, timeout: 0})\n      return true\n    } catch (error) {\n      if (error instanceof ElementNotFoundError) {\n        return false\n      }\n\n      throw error\n    }\n  }\n\n  /**\n   * @param {string|import(\"selenium-webdriver\").WebElement|({selector: string} & FindArgs & {withFallback?: boolean})} elementOrIdentifier\n   * @param {FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async _findElement(elementOrIdentifier, args) {\n    /** @type {import(\"selenium-webdriver\").WebElement} */\n    let element\n\n    if (typeof elementOrIdentifier == \"string\") {\n      element = await this.find(elementOrIdentifier, args)\n    } else if (typeof elementOrIdentifier == \"object\" && elementOrIdentifier !== null && \"selector\" in elementOrIdentifier) {\n      const {selector, ...restArgs} = elementOrIdentifier\n\n      delete restArgs.withFallback\n\n      element = await this.find(selector, restArgs)\n    } else {\n      element = /** @type {import(\"selenium-webdriver\").WebElement} */ (elementOrIdentifier)\n    }\n\n    return element\n  }\n\n  /**\n   * Finds a single element by CSS selector without waiting\n   * @param {string} selector\n   * @param {FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async findNoWait(selector, args = {}) {\n    await this.driverSetTimeouts(0)\n\n    try {\n      return await this.find(selector, args)\n    } finally {\n      await this.restoreTimeouts()\n    }\n  }\n\n  /**\n   * Clicks an element, allowing selector args when using a CSS selector.\n   * @param {string|import(\"selenium-webdriver\").WebElement} elementOrIdentifier\n   * @param {FindArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async click(elementOrIdentifier, args) {\n    const {method, scrollTo = false, ...findArgs} = args || {}\n    let tries = 0\n\n    while (true) {\n      tries++\n\n      try {\n        const element = await this._findElement(elementOrIdentifier, findArgs)\n\n        if (scrollTo) {\n          await this.scrollElementIntoView(element)\n        }\n\n        if (method === \"actions\") {\n          await this.getWebDriver().actions({async: true}).move({origin: element}).click().perform()\n        } else if (method === \"js\") {\n          await this.getWebDriver().executeScript(\"arguments[0].click()\", element)\n        } else if (method === undefined) {\n          await element.click()\n        } else {\n          throw new Error(`Unknown method: ${method}`)\n        }\n\n        break\n      } catch (error) {\n        if (error instanceof Error) {\n          if (error.constructor.name === \"ElementClickInterceptedError\" || error.constructor.name === \"StaleElementReferenceError\") {\n            throw error\n          } else if (error.constructor.name === \"ElementNotInteractableError\") {\n            if (tries >= 3) {\n              throw errorWithCause(`Element ${elementOrIdentifier.constructor.name} click failed after ${tries} tries - ${error.constructor.name}: ${error.message}`, error)\n            } else {\n              await wait(50)\n            }\n          } else {\n            throw errorWithCause(`Element ${elementOrIdentifier.constructor.name} click failed - ${error.constructor.name}: ${error.message}`, error)\n          }\n        } else {\n          throw errorWithCause(`Element ${elementOrIdentifier.constructor.name} click failed - ${typeof error}: ${error}`, error)\n        }\n      }\n    }\n  }\n\n  /**\n   * @param {import(\"selenium-webdriver\").WebElement} element\n   * @returns {Promise<void>}\n   */\n  async scrollElementIntoView(element) {\n    await this.getWebDriver().actions({async: true}).move({origin: element}).perform()\n  }\n\n  /**\n   * @param {string|import(\"selenium-webdriver\").WebElement|({selector: string} & FindArgs & {withFallback?: boolean})} elementOrIdentifier\n   * @param {FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async findScrollTarget(elementOrIdentifier, args) {\n    try {\n      return await this._findElement(elementOrIdentifier, args)\n    } catch (error) {\n      if (!isElementUnavailableForScrollError(error) || this.hasExplicitVisibleScrollLookup(elementOrIdentifier, args)) {\n        throw error\n      }\n\n      return await this.findRenderedScrollTarget(elementOrIdentifier, args, error)\n    }\n  }\n\n  /**\n   * @param {string|import(\"selenium-webdriver\").WebElement|({selector: string} & FindArgs & {withFallback?: boolean})} elementOrIdentifier\n   * @param {FindArgs} [args]\n   * @returns {boolean}\n   */\n  hasExplicitVisibleScrollLookup(elementOrIdentifier, args) {\n    if (hasOwnArg(args, \"visible\")) return true\n\n    return Boolean(\n      typeof elementOrIdentifier == \"object\" &&\n      elementOrIdentifier !== null &&\n      \"selector\" in elementOrIdentifier &&\n      hasOwnArg(elementOrIdentifier, \"visible\")\n    )\n  }\n\n  /**\n   * @param {string|import(\"selenium-webdriver\").WebElement|({selector: string} & FindArgs & {withFallback?: boolean})} elementOrIdentifier\n   * @param {FindArgs | undefined} args\n   * @param {unknown} originalError\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async findRenderedScrollTarget(elementOrIdentifier, args, originalError) {\n    const selectorAndArgs = this.getSelectorScrollLookupArgs(elementOrIdentifier, args)\n\n    if (!selectorAndArgs) throw originalError\n\n    const {selector, findArgs} = selectorAndArgs\n    const renderedElements = []\n    const foundElements = await this.all(selector, {...findArgs, scrollTo: false, timeout: 0, visible: null})\n\n    for (const element of foundElements) {\n      if (await this.isRenderedScrollTarget(element)) {\n        renderedElements.push(element)\n      }\n    }\n\n    if (renderedElements.length === 1) return renderedElements[0]\n\n    if (renderedElements.length > 1) {\n      throw new Error(`More than 1 rendered elements (${renderedElements.length}) was found by CSS: ${this.getSelector(selector)}`)\n    }\n\n    throw originalError\n  }\n\n  /**\n   * @param {string|import(\"selenium-webdriver\").WebElement|({selector: string} & FindArgs & {withFallback?: boolean})} elementOrIdentifier\n   * @param {FindArgs} [args]\n   * @returns {{selector: string, findArgs: FindArgs} | undefined}\n   */\n  getSelectorScrollLookupArgs(elementOrIdentifier, args) {\n    if (typeof elementOrIdentifier == \"string\") {\n      return {selector: elementOrIdentifier, findArgs: args || {}}\n    }\n\n    if (typeof elementOrIdentifier == \"object\" && elementOrIdentifier !== null && \"selector\" in elementOrIdentifier) {\n      const {selector, ...restArgs} = elementOrIdentifier\n\n      delete restArgs.withFallback\n\n      return {selector, findArgs: restArgs}\n    }\n\n    return undefined\n  }\n\n  /**\n   * @param {import(\"selenium-webdriver\").WebElement} element\n   * @returns {Promise<boolean>}\n   */\n  async isRenderedScrollTarget(element) {\n    return Boolean(await this.getWebDriver().executeScript(`\n      const element = arguments[0]\n      if (!(element instanceof Element)) return false\n\n      for (let current = element; current; current = current.parentElement) {\n        const style = window.getComputedStyle(current)\n        if (current.hidden) return false\n        if (current.getAttribute(\"aria-hidden\") === \"true\") return false\n        if (style.display === \"none\") return false\n        if (style.visibility === \"hidden\" || style.visibility === \"collapse\") return false\n        if (style.opacity === \"0\") return false\n      }\n\n      return Array.from(element.getClientRects()).some((rect) => rect.width > 0 && rect.height > 0)\n    `, element))\n  }\n\n  /**\n   * Scrolls an element into view.\n   * @param {string|import(\"selenium-webdriver\").WebElement|({selector: string} & FindArgs & {withFallback?: boolean})} elementOrIdentifier\n   * @param {FindArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async scrollIntoView(elementOrIdentifier, args) {\n    const element = await this.findScrollTarget(elementOrIdentifier, args)\n\n    await this.scrollElementIntoView(element)\n  }\n\n  /**\n   * Scrolls the element with the given test ID into view.\n   * @param {string} testID\n   * @param {FindArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async scrollTestIdIntoView(testID, args) {\n    const element = await this.findScrollTarget(`[data-testid='${testID}']`, args)\n\n    await this.scrollElementIntoView(element)\n  }\n\n  /**\n   * Interacts with an element by calling a method on it with the given arguments.\n   * Retrying on ElementNotInteractableError, ElementClickInterceptedError, or StaleElementReferenceError.\n   * @param {import(\"selenium-webdriver\").WebElement|string|{selector: string} & InteractArgs} elementOrIdentifier The element or a CSS selector to find the element.\n   * @param {string} methodName The method name to call on the element.\n   * @param {...any} args Arguments to pass to the method.\n   * @returns {Promise<any>}\n   */\n  async interact(elementOrIdentifier, methodName, ...args) {\n    let tries = 0\n\n    while (true) {\n      tries++\n\n      /** @type {InteractArgs | undefined} */\n      let interactArgs\n\n      if (typeof elementOrIdentifier === \"object\" && elementOrIdentifier && !isWebDriverElement(elementOrIdentifier)) {\n        interactArgs = elementOrIdentifier\n      }\n\n      /** @type {FindArgs | undefined} */\n      let findArgs\n\n      if (interactArgs) {\n        /** @type {FindArgs & {selector?: string, method?: any, withFallback?: any}} */\n        const sanitizedFindArgs = {...interactArgs}\n\n        delete sanitizedFindArgs.selector\n        delete sanitizedFindArgs.method\n        delete sanitizedFindArgs.withFallback\n        findArgs = sanitizedFindArgs\n      }\n\n      const element = interactArgs\n        ? await this._findElement(/** @type {{selector: string}} */ (interactArgs).selector, findArgs)\n        : await this._findElement(elementOrIdentifier, findArgs)\n\n      try {\n        if (methodName === \"sendKeys\") {\n          if (interactArgs?.withFallback) {\n            return await this.interactSendKeysWithFallback(element, ...args)\n          }\n\n          return await element.sendKeys(...args)\n        } else if (methodName === \"click\") {\n          if (isWebDriverElement(element)) {\n            /** @type {FindArgs} */\n            const clickArgs = {}\n            if (interactArgs?.method !== undefined) clickArgs.method = interactArgs.method\n            if (interactArgs?.scrollTo !== undefined) clickArgs.scrollTo = interactArgs.scrollTo\n\n            await this.click(element, clickArgs)\n\n            return undefined\n          }\n\n          return await /** @type {{click: (...clickArgs: any[]) => Promise<any>}} */ (element).click(...args)\n        } else if (!(/** @type {any} */ (element))[methodName]) {\n          throw new Error(`${element.constructor.name} hasn't an attribute named: ${methodName}`)\n        } else if (typeof (/** @type {any} */ (element))[methodName] != \"function\") {\n          throw new Error(`${element.constructor.name}#${methodName} is not a function`)\n        }\n\n        // Dont call with candidate, because that will bind the function wrong.\n        return await (/** @type {any} */ (element))[methodName](...args)\n      } catch (error) {\n        if (error instanceof Error) {\n          const retryableErrorName = getRetryableInteractErrorName(error)\n\n          if (retryableErrorName) {\n            // Retry finding the element and interacting with it\n            if (tries >= 3) {\n              let elementDescription\n\n              if (typeof elementOrIdentifier == \"string\") {\n                elementDescription = `CSS selector ${elementOrIdentifier}`\n              } else {\n                elementDescription = `${element.constructor.name}`\n              }\n\n              throw errorWithCause(`${elementDescription} ${methodName} failed after ${tries} tries - ${retryableErrorName}: ${error.message}`, error)\n            } else {\n              await wait(50)\n            }\n          } else {\n            throw errorWithCause(`${element.constructor.name} ${methodName} failed - ${error.constructor.name}: ${error.message}`, error)\n          }\n        } else {\n          throw errorWithCause(`${element.constructor.name} ${methodName} failed - ${typeof error}: ${error}`, error)\n        }\n      }\n    }\n  }\n\n  /**\n   * @param {import(\"selenium-webdriver\").WebElement} element\n   * @returns {Promise<string | undefined>}\n   */\n  async readInteractableValue(element) {\n    const valueProperty = await element.getAttribute(\"value\")\n\n    if (typeof valueProperty == \"string\") {\n      return valueProperty\n    }\n\n    const textContent = await element.getText()\n\n    if (typeof textContent == \"string\") {\n      return textContent\n    }\n\n    return undefined\n  }\n\n  /**\n   * @param {import(\"selenium-webdriver\").WebElement} element\n   * @param {...any} args\n   * @returns {Promise<unknown>}\n   */\n  async interactSendKeysWithFallback(element, ...args) {\n    const expectedAppend = getSendKeysTextAppend(...args)\n    const beforeValue = await this.readInteractableValue(element)\n    const sendKeysResult = await element.sendKeys(...args)\n    const afterValue = await this.readInteractableValue(element)\n\n    if (typeof beforeValue == \"string\" && typeof afterValue == \"string\" && afterValue !== beforeValue) {\n      return sendKeysResult\n    }\n\n    const nextValue = getSendKeysUsesSelectAllAndDelete(...args) ? expectedAppend : `${beforeValue || \"\"}${expectedAppend}`\n\n    if (typeof beforeValue == \"string\" && nextValue === beforeValue) {\n      return sendKeysResult\n    }\n\n    await this.getWebDriver().executeScript(`\n      const element = arguments[0]\n      const nextValue = String(arguments[1] ?? \"\")\n\n      if (typeof element.focus == \"function\") {\n        element.focus()\n      }\n\n      if (typeof element.value == \"string\") {\n        const prototype = Object.getPrototypeOf(element)\n        const descriptor = Object.getOwnPropertyDescriptor(prototype, \"value\") || Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, \"value\") || Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, \"value\")\n        const previousValue = String(element.value)\n\n        if (descriptor && typeof descriptor.set == \"function\") {\n          descriptor.set.call(element, nextValue)\n        } else {\n          element.value = nextValue\n        }\n\n        if (element._valueTracker && typeof element._valueTracker.setValue == \"function\") {\n          element._valueTracker.setValue(previousValue)\n        }\n\n        element.dispatchEvent(new Event(\"input\", {bubbles: true}))\n        element.dispatchEvent(new Event(\"change\", {bubbles: true}))\n        return element.value\n      }\n\n      if (element.isContentEditable) {\n        element.textContent = nextValue\n        element.dispatchEvent(new Event(\"input\", {bubbles: true}))\n        return element.textContent\n      }\n\n      return null\n    `, element, nextValue)\n\n    return sendKeysResult\n  }\n\n  /**\n   * @param {string} selector\n   * @param {WaitForNoSelectorArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async waitForNoSelector(selector, args = {}) {\n    const {useBaseSelector, ...restArgs} = args\n\n    if (Object.keys(restArgs).length > 0) {\n      throw new Error(`Unexpected args: ${Object.keys(restArgs).join(\", \")}`)\n    }\n\n    const actualSelector = useBaseSelector ? this.getSelector(selector) : selector\n\n    await this.driverSetTimeouts(0)\n\n    try {\n      await this._withRethrownErrors(async () => {\n        await this.getWebDriver().wait(\n          async () => {\n            const elements = await this.getWebDriver().findElements(By.css(actualSelector))\n\n            // Not found at all\n            if (elements.length === 0) {\n              return true\n            }\n\n            // Found but not visible\n            try {\n              const isDisplayed = await elements[0].isDisplayed()\n\n              return !isDisplayed\n            } catch (error) {\n              if (\n                error instanceof Error &&\n                (error.constructor.name === \"StaleElementReferenceError\" || error.message.includes(\"stale element reference\"))\n              ) {\n                return false\n              }\n\n              throw error\n            }\n          },\n          this.getTimeouts()\n        )\n      })\n    } finally {\n      await this.restoreTimeouts()\n    }\n  }\n\n  /**\n   * @param {() => Promise<any>} callback\n   * @returns {Promise<any>}\n   */\n  async _withRethrownErrors(callback) {\n    try {\n      return await callback()\n    } catch (error) {\n      if (error instanceof WebDriverError) {\n        throw errorWithCause(`Selenium ${error.constructor.name}: ${error.message}`, error)\n      } else {\n        throw error\n      }\n    }\n  }\n}\n"]}

package/build/system-test.d.ts

@@ -16,11 +16,11 @@ export default class SystemTest extends Browser {
     /**
      * Runs a system test
      * @overload
-     * @param {SystemTestArgs} args
+     * @param {SystemTestRunArgs} args
      * @param {function(SystemTest): Promise<void>} callback
      * @returns {Promise<void>}
      */
-    static run(args: SystemTestArgs, callback: (arg0: SystemTest) => Promise<void>): Promise<void>;
+    static run(args: SystemTestRunArgs, callback: (arg0: SystemTest) => Promise<void>): Promise<void>;
     /**
      * Creates a new SystemTest instance
      * @param {SystemTestArgs} [args]
@@ -239,6 +239,9 @@ export type SystemTestArgs = {
      */
     driver?: SystemTestDriverConfig | undefined;
 };
+export type SystemTestRunArgs = SystemTestArgs & {
+    reinitializeAfterFailure?: boolean;
+};
 export type SystemTestDriverConfig = {
     /**
      * Driver implementation to use.

package/build/system-test.js

@@ -22,6 +22,9 @@ import Browser from "./browser.js";
  * @property {Record<string, any>} [urlArgs] Query params appended to the root path.
  * @property {SystemTestDriverConfig} [driver] Driver configuration.
  */
+/**
+ * @typedef {SystemTestArgs & {reinitializeAfterFailure?: boolean}} SystemTestRunArgs
+ */
 /**
  * @typedef {object} SystemTestDriverConfig
  * @property {"selenium"|"appium"} [type] Driver implementation to use.
@@ -122,19 +125,20 @@ class SystemTest extends Browser {
     /**
      * Runs a system test
      * @overload
-     * @param {SystemTestArgs} args
+     * @param {SystemTestRunArgs} args
      * @param {function(SystemTest): Promise<void>} callback
      * @returns {Promise<void>}
      */
     /**
      * Runs a system test
-     * @param {SystemTestArgs | function(SystemTest): Promise<void>} [args]
+     * @param {SystemTestRunArgs | function(SystemTest): Promise<void>} [args]
      * @param {function(SystemTest): Promise<void>} [callback]
      * @returns {Promise<void>}
      */
     static async run(args, callback) {
         const resolvedCallback = typeof args === "function" ? args : callback;
-        const systemTest = this.current(typeof args === "function" ? {} : args);
+        const { reinitializeAfterFailure = true, ...systemTestArgs } = /** @type {SystemTestRunArgs} */ (typeof args === "function" ? {} : args || {});
+        const systemTest = this.current(systemTestArgs);
         if (!resolvedCallback) {
             throw new Error("SystemTest.run requires a callback");
         }
@@ -199,9 +203,29 @@ class SystemTest extends Browser {
             if (teardownError) {
                 console.error("System test teardown failed after test failure", teardownError);
             }
+            if (reinitializeAfterFailure) {
+                try {
+                    systemTest.debugLog("Run failed - reinitialize SystemTest");
+                    await systemTest.reinitialize();
+                    systemTest.debugLog("Reinitialized SystemTest after failed run");
+                }
+                catch (error) {
+                    console.error("System test reinitialize failed after test failure", error);
+                }
+            }
             throw runError;
         }
         if (teardownError) {
+            if (reinitializeAfterFailure) {
+                try {
+                    systemTest.debugLog("Teardown failed - reinitialize SystemTest");
+                    await systemTest.reinitialize();
+                    systemTest.debugLog("Reinitialized SystemTest after failed teardown");
+                }
+                catch (error) {
+                    console.error("System test reinitialize failed after teardown failure", error);
+                }
+            }
             throw teardownError;
         }
     }
@@ -838,4 +862,4 @@ class SystemTest extends Browser {
 }
 SystemTest.rootPath = "/blank?systemTest=true";
 export default SystemTest;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"system-test.js","sourceRoot":"","sources":["../src/system-test.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {digg} from \"diggerize\"\nimport Server from \"scoundrel-remote-eval/build/server/index.js\"\nimport ServerWebSocket from \"scoundrel-remote-eval/build/server/connections/web-socket/index.js\"\nimport SystemTestCommunicator from \"./system-test-communicator.js\"\nimport SystemTestHttpServer from \"./system-test-http-server.js\"\nimport {waitFor} from \"awaitery\"\nimport timeout from \"awaitery/build/timeout.js\"\nimport {WebSocketServer} from \"ws\"\nimport Browser from \"./browser.js\"\n\n/**\n * @typedef {object} SystemTestArgs\n * @property {string} [host] Hostname for the app server.\n * @property {number} [port] Port for the app server.\n * @property {string} [httpHost] Hostname for the static HTTP server.\n * @property {number} [httpPort] Port for the static HTTP server.\n * @property {string} [httpConnectHost] Hostname used by the driver to reach the HTTP server.\n * @property {boolean} [debug] Enable debug logging.\n * @property {(error: any) => boolean} [errorFilter] Filter for browser errors (return false to ignore).\n * @property {number} [clientWsPort] Port for the browser-command WebSocket server.\n * @property {number} [scoundrelPort] Port for the Scoundrel WebSocket server.\n * @property {Record<string, any>} [urlArgs] Query params appended to the root path.\n * @property {SystemTestDriverConfig} [driver] Driver configuration.\n */\n/**\n * @typedef {object} SystemTestDriverConfig\n * @property {\"selenium\"|\"appium\"} [type] Driver implementation to use.\n * @property {Record<string, any>} [options] Driver-specific options.\n */\n/**\n * @typedef {object} FindArgs\n * @property {number} [timeout] Override timeout for lookup.\n * @property {boolean | null} [visible] Whether to require elements to be visible (`true`) or hidden (`false`). Use `null` to disable visibility filtering.\n * @property {\"actions\" | \"js\"} [method] Override the click path. `\"actions\"` uses the Selenium Actions API (real pointer move + click); `\"js\"` dispatches `element.click()` via `executeScript` inside the page's JS context (skips WebDriver's pointer synthesis entirely — useful when the default click is dropped by a framework responder that refuses synthetic WebDriver pointer events).\n * @property {boolean} [scrollTo] Whether to scroll found elements into view before returning them.\n * @property {boolean} [useBaseSelector] Whether to scope by the base selector.\n */\n/**\n * @typedef {FindArgs & {withFallback?: boolean}} InteractArgs\n */\n/**\n * @typedef {object} WaitForNoSelectorArgs\n * @property {boolean} [useBaseSelector] Whether to scope by the base selector.\n */\n/**\n * @typedef {object} NotificationMessageArgs\n * @property {boolean} [dismiss] Whether to dismiss the notification after it appears.\n */\n\n/**\n * @param {string} message\n * @returns {boolean}\n */\nfunction shouldIgnoreChromePasswordFieldWarning(message) {\n  return /(?:^|\\s-\\s)\\[DOM\\] Password field is not contained in a form:/i.test(message)\n}\n\n/** @type {Record<string, any>} */\nconst globalAny = globalThis\n\nexport default class SystemTest extends Browser {\n  static rootPath = \"/blank?systemTest=true\"\n\n  /** @type {SystemTestCommunicator | undefined} */\n  communicator = undefined\n\n  _started = false\n  _clientWsPort = 1985\n  _httpHost = \"localhost\"\n  _httpPort = 1984\n  /** @type {((error: any) => boolean) | undefined} */\n  _errorFilter = undefined\n  _scoundrelPort = 8090\n  /** @type {WebSocketServer | undefined} */\n  scoundrelWss = undefined\n  /** @type {WebSocketServer | undefined} */\n  clientWss = undefined\n\n  /**\n   * Gets the current system test instance\n   * @param {SystemTestArgs} [args]\n   * @returns {SystemTest}\n   */\n  static current(args = {}) {\n    if (!globalAny.systemTest) {\n      globalAny.systemTest = new SystemTest(args)\n    }\n\n    return globalAny.systemTest\n  }\n\n  /** @returns {SystemTestCommunicator} */\n  getCommunicator() {\n    if (!this.communicator) {\n      throw new Error(\"Communicator hasn't been initialized yet\")\n    }\n\n    return this.communicator\n  }\n\n  /**\n   * Extracts an error message if possible from the payload sent from the browser.\n   * @param {{message?: string, value?: any[]} | Error} data\n   * @returns {string | undefined}\n   */\n  extractErrorMessage(data) {\n    if (data instanceof Error) return data.message\n    if (typeof data === \"object\" && typeof data.message === \"string\") return data.message\n    if (typeof data === \"string\") return data\n\n    const firstValue = Array.isArray(data?.value) ? data.value[0] : undefined\n\n    if (firstValue instanceof Error && typeof firstValue.message === \"string\") return firstValue.message\n    if (typeof firstValue === \"string\") return firstValue\n\n    return undefined\n  }\n\n  /**\n   * Whether a browser error should be ignored based on built-in rules and an optional error filter.\n   * @param {{message?: string, value?: any[]}} data\n   * @returns {boolean}\n   */\n  shouldIgnoreError(data) {\n    const message = this.extractErrorMessage(data)\n\n    if (typeof message === \"string\") {\n      if (message.includes(\"Minified React error #418\")) return true\n      if (message.includes(\"Minified React error #419\")) return true\n      if (shouldIgnoreChromePasswordFieldWarning(message)) return true\n    }\n\n    if (this._errorFilter && this._errorFilter(data) === false) {\n      return true\n    }\n\n    return false\n  }\n\n  /**\n   * Runs a system test\n   * @overload\n   * @param {function(SystemTest): Promise<void>} callback\n   * @returns {Promise<void>}\n   */\n  /**\n   * Runs a system test\n   * @overload\n   * @param {SystemTestArgs} args\n   * @param {function(SystemTest): Promise<void>} callback\n   * @returns {Promise<void>}\n   */\n  /**\n   * Runs a system test\n   * @param {SystemTestArgs | function(SystemTest): Promise<void>} [args]\n   * @param {function(SystemTest): Promise<void>} [callback]\n   * @returns {Promise<void>}\n   */\n  static async run(args, callback) {\n    const resolvedCallback = typeof args === \"function\" ? args : callback\n    const systemTest = this.current(typeof args === \"function\" ? {} : args)\n\n    if (!resolvedCallback) {\n      throw new Error(\"SystemTest.run requires a callback\")\n    }\n\n    systemTest.debugLog(\"Resetting browser cookies before initialize\")\n    await systemTest.deleteAllCookies()\n    systemTest.debugLog(\"Browser cookies cleared\")\n\n    systemTest.debugLog(\"getRootPath\")\n    const rootPath = systemTest.getRootPath()\n\n    systemTest.debugLog(`Visit rootPath with dismissTo: ${rootPath}`)\n    await systemTest.dismissTo(rootPath)\n    systemTest.debugLog(`Dismissed to root path ${rootPath}`)\n\n    if (!systemTest.ws || systemTest.ws.readyState !== 1) {\n      systemTest.debugLog(\"WebSocket not connected after dismissTo, waiting for reconnection\")\n      systemTest.ws = null\n      systemTest.getCommunicator().ws = null\n      await systemTest.waitForClientWebSocket()\n      systemTest.debugLog(\"Client websocket reconnected\")\n    }\n\n    systemTest.debugLog(\"Run started - send initialize\")\n    await timeout({timeout: 10_000, errorMessage: \"Sending intialize to useSystemTest() timed out\"}, async () => {\n      await systemTest.getCommunicator().sendCommand({type: \"initialize\"})\n    })\n\n    /** @type {unknown} */\n    let runError = undefined\n    /** @type {unknown} */\n    let teardownError = undefined\n\n    try {\n      systemTest.debugLog(\"findByTestID blankText\")\n      await systemTest.findByTestID(\"blankText\", {useBaseSelector: false})\n      systemTest.debugLog(\"Found blankText\")\n\n      systemTest.debugLog(\"resolvedCallback\")\n      await resolvedCallback(systemTest)\n      systemTest.debugLog(\"Run callback completed\")\n    } catch (error) {\n      systemTest.debugLog(`Run error caught, taking screenshot: ${error instanceof Error ? error.message : error}`)\n      await systemTest.takeScreenshot()\n\n      runError = error\n    } finally {\n      systemTest.debugLog(\"Run finished - send teardown\")\n      const teardownWs = systemTest.getCommunicator().ws\n      // WebSocket.CLOSING (2) and WebSocket.CLOSED (3) cannot recover, so skip teardown.\n      // OPEN (1) sends immediately. CONNECTING (0) queues the command and flushes on\n      // onOpen — the 10s timeout below covers the wait.\n      const wsClosed = !teardownWs || teardownWs.readyState === 2 || teardownWs.readyState === 3\n\n      if (wsClosed) {\n        systemTest.debugLog(\"Skipping teardown — browser websocket is closed (likely by navigation/sign-out during the test)\")\n      } else {\n        try {\n          await timeout({timeout: 10_000, errorMessage: \"Sending teardown to useSystemTest() timed out\"}, async () => {\n            await systemTest.getCommunicator().sendCommand({type: \"teardown\"})\n          })\n        } catch (error) {\n          teardownError = error\n        }\n      }\n    }\n\n    if (runError) {\n      if (teardownError) {\n        console.error(\"System test teardown failed after test failure\", teardownError)\n      }\n\n      throw runError\n    }\n\n    if (teardownError) {\n      throw teardownError\n    }\n  }\n\n  /**\n   * Creates a new SystemTest instance\n   * @param {SystemTestArgs} [args]\n   */\n  constructor({clientWsPort = 1985, host = \"localhost\", port = 8081, httpHost = \"localhost\", httpPort = 1984, httpConnectHost, debug = false, errorFilter, scoundrelPort = 8090, urlArgs, driver, ...restArgs} = {host: \"localhost\", port: 8081, httpHost: \"localhost\", httpPort: 1984, debug: false}) {\n    super({debug, driver})\n\n    const restArgsKeys = Object.keys(restArgs)\n\n    if (restArgsKeys.length > 0) {\n      throw new Error(`Unknown arguments: ${restArgsKeys.join(\", \")}`)\n    }\n\n    this._host = host\n    this._port = port\n    this._clientWsPort = clientWsPort\n    this._httpHost = httpHost\n    this._httpPort = httpPort\n    this._httpConnectHost = httpConnectHost\n    this._debug = debug\n    this._errorFilter = errorFilter\n    this._scoundrelPort = scoundrelPort\n    this._urlArgs = urlArgs\n    this._rootPath = this.buildRootPath()\n\n    /** @type {Record<number, object>} */\n    this._responses = {}\n\n    this._sendCount = 0\n    this.startScoundrel()\n    this.communicator = new SystemTestCommunicator({onCommand: this.onCommandReceived})\n    this.setCommunicator(this.communicator)\n  }\n\n  /**\n   * Starts Scoundrel server which the browser connects to for remote evaluation in the browser\n   * @returns {void}\n   */\n  startScoundrel() {\n    if (this.scoundrelWss) throw new Error(\"Scoundrel server already started\")\n\n    this.scoundrelWss = new WebSocketServer({port: this._scoundrelPort})\n    this.serverWebSocket = new ServerWebSocket(this.scoundrelWss)\n    this.server = new Server(this.serverWebSocket)\n  }\n\n  /**\n   * @returns {Promise<void>}\n   */\n  async stopScoundrel() {\n    if (this.server?.close) {\n      await timeout({timeout: this.getTimeouts(), errorMessage: \"timeout while waiting for Scoundrel to stop\"}, async () => await /** @type {NonNullable<typeof this.server>} */ (this.server).close())\n    }\n    await this.closeWebSocketServer(this.scoundrelWss, \"Scoundrel WebSocket server\")\n  }\n\n  /**\n   * Waits for the Scoundrel client (browser) to connect and returns it.\n   * @param {number} [timeoutMs]\n   * @returns {Promise<import(\"scoundrel-remote-eval/build/client/index.js\").default>}\n   */\n  async getScoundrelClient(timeoutMs = 10000) {\n    if (!this.server) {\n      throw new Error(\"Scoundrel server is not started\")\n    }\n\n    this.debugLog(\"getScoundrelClient: waiting for browser Scoundrel initialization\")\n    await timeout({timeout: timeoutMs, errorMessage: \"Timed out waiting for Scoundrel to initialize\"}, async () => {\n      await this.getCommunicator().sendCommand({type: \"waitForScoundrel\"})\n    })\n    this.debugLog(\"getScoundrelClient: browser reported Scoundrel initialized\")\n\n    /**\n     * @param {any} client\n     * @returns {boolean}\n     */\n    const isOpenClient = (client) => client?.backend?.ws?.readyState === 1\n\n    const existingClients = this.server.getClients?.()\n    const openExistingClients = existingClients?.filter(isOpenClient)\n\n    if (openExistingClients && openExistingClients.length > 0) {\n      this.debugLog(`getScoundrelClient: using existing open client (${openExistingClients.length} available)`)\n      return openExistingClients[openExistingClients.length - 1]\n    }\n    this.debugLog(`getScoundrelClient: no open cached clients, waiting for new connection (cached total: ${existingClients?.length ?? 0})`)\n\n    if (!this.server.events?.on) {\n      throw new Error(\"Scoundrel server events are unavailable\")\n    }\n\n    /** @type {((client: any) => void) | undefined} */\n    let onNewClient\n    const cleanupListener = () => {\n      if (onNewClient) {\n        this.server?.events.off(\"newClient\", onNewClient)\n      }\n    }\n\n    try {\n      return await timeout({timeout: timeoutMs, errorMessage: \"Timed out waiting for Scoundrel client\"}, async () => await new Promise((resolve) => {\n        onNewClient = (/** @type {any} */ client) => {\n          if (!isOpenClient(client)) return\n          cleanupListener()\n          this.debugLog(\"getScoundrelClient: received new open client\")\n          resolve(client)\n        }\n\n        this.server?.events.on(\"newClient\", onNewClient)\n      }))\n    } finally {\n      cleanupListener()\n    }\n  }\n\n  /**\n   * Finds all elements by CSS selector\n   * @param {string} selector\n   * @param {FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement[]>}\n   */\n  async all(selector, args = {}) {\n    return await this.getDriverAdapter().all(selector, args)\n  }\n\n  /**\n   * Clicks an element that has children which fills out the element and would otherwise have caused a ElementClickInterceptedError\n   * @param {string|import(\"selenium-webdriver\").WebElement} elementOrIdentifier\n   * @returns {Promise<void>}\n   */\n  /**\n   * Clicks an element, allowing selector args when using a CSS selector.\n   * @param {string|import(\"selenium-webdriver\").WebElement} elementOrIdentifier\n   * @param {FindArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async click(elementOrIdentifier, args) {\n    await this.getDriverAdapter().click(elementOrIdentifier, args)\n  }\n\n  /**\n   * Finds a single element by CSS selector\n   * @param {string} selector\n   * @param {FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async find(selector, args = {}) {\n    return await this.getDriverAdapter().find(selector, args)\n  }\n\n  /**\n   * Finds a single element by test ID\n   * @param {string} testID\n   * @param {FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async findByTestID(testID, args) {\n    return await this.getDriverAdapter().findByTestID(testID, args)\n  }\n\n  /**\n   * Checks whether an element with the given test ID is currently rendered.\n   * @param {string} testID\n   * @param {FindArgs} [args]\n   * @returns {Promise<boolean>}\n   */\n  async hasTestID(testID, args) {\n    return await this.getDriverAdapter().hasTestID(testID, args)\n  }\n\n  /**\n   * Finds a single element by CSS selector without waiting\n   * @param {string} selector\n   * @param {FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async findNoWait(selector, args = {}) {\n    return await this.getDriverAdapter().findNoWait(selector, args)\n  }\n\n  /**\n   * Interacts with an element by calling a method on it with the given arguments.\n   * Retrying on ElementNotInteractableError, ElementClickInterceptedError, or StaleElementReferenceError.\n   * @param {import(\"selenium-webdriver\").WebElement|string|{selector: string} & InteractArgs} elementOrIdentifier The element or a CSS selector to find the element.\n   * @param {string} methodName The method name to call on the element.\n   * @param {...any} args Arguments to pass to the method.\n   * @returns {Promise<any>}\n   */\n  async interact(elementOrIdentifier, methodName, ...args) {\n    return await this.getDriverAdapter().interact(elementOrIdentifier, methodName, ...args)\n  }\n\n  /**\n   * Expects no element to be found by CSS selector\n   * @param {string} selector\n   * @param {FindArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async expectNoElement(selector, args = {}) {\n    let found = false\n\n    try {\n      await this.findNoWait(selector, args)\n      found = true\n    } catch (error) {\n      if (error instanceof Error && error.message.startsWith(\"Element couldn't be found after \")) {\n        // Ignore\n      } else {\n        throw error\n      }\n    }\n\n    if (found) {\n      throw new Error(`Expected not to find: ${selector}`)\n    }\n  }\n\n  /**\n   * @param {string} selector\n   * @param {WaitForNoSelectorArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async waitForNoSelector(selector, args = {}) {\n    await this.getDriverAdapter().waitForNoSelector(selector, args)\n  }\n\n  /**\n   * Gets notification messages\n   * @returns {Promise<string[]>}\n   */\n  async notificationMessages() {\n    const notificationMessageElements = await this.all(\"[data-class='notification-message']\", {useBaseSelector: false})\n    const notificationMessageTexts = []\n\n    for (const notificationMessageElement of notificationMessageElements) {\n      const text = await notificationMessageElement.getText()\n\n      notificationMessageTexts.push(text)\n    }\n\n    return notificationMessageTexts\n  }\n\n  /**\n   * Expects a notification message to appear and waits for it if necessary.\n   * @param {string} expectedNotificationMessage\n   * @param {NotificationMessageArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async expectNotificationMessage(expectedNotificationMessage, args = {}) {\n    const {dismiss = true, ...restArgs} = args\n\n    if (Object.keys(restArgs).length > 0) {\n      throw new Error(`Unexpected args: ${Object.keys(restArgs).join(\", \")}`)\n    }\n\n    /** @type {string[]} */\n    const allDetectedNotificationMessages = []\n    let foundNotificationMessageElement\n    let foundNotificationMessageCount\n\n    await waitFor(async () => {\n      const notificationMessageElements = await this.all(\"[data-testid='notification-message']\", {useBaseSelector: false})\n\n      for (const notificationMessageElement of notificationMessageElements) {\n        const notificationMessage = (await this.getDriver().executeScript(\"return arguments[0].textContent;\", notificationMessageElement))?.trim() || await notificationMessageElement.getText()\n\n        if (!allDetectedNotificationMessages.includes(notificationMessage)) {\n          allDetectedNotificationMessages.push(notificationMessage)\n        }\n\n        if (notificationMessage == expectedNotificationMessage) {\n          foundNotificationMessageElement = notificationMessageElement\n          foundNotificationMessageCount = await notificationMessageElement.getAttribute(\"data-count\")\n          return\n        }\n      }\n\n      throw new Error(`Notification message ${expectedNotificationMessage} wasn't included in: ${allDetectedNotificationMessages.join(\", \")}`)\n    })\n\n    if (foundNotificationMessageElement && dismiss) {\n      await this.interact(foundNotificationMessageElement, \"click\") // Dismiss the notification message\n      if (!foundNotificationMessageCount) {\n        throw new Error(\"Expected notification message to have a data-count\")\n      }\n\n      await this.waitForNoSelector(`[data-testid='notification-message'][data-count='${foundNotificationMessageCount}']`, {useBaseSelector: false})\n    }\n  }\n\n  /** @returns {Promise<void>} */\n  async dismissNotificationMessages() {\n    const notificationMessageElements = await this.all(\"[data-class='notification-message']\", {useBaseSelector: false})\n\n    for (const notificationMessageElement of notificationMessageElements) {\n      await this.interact(notificationMessageElement, \"click\")\n    }\n\n    await this.waitForNoSelector(\"[data-class='notification-message']\", {useBaseSelector: false})\n  }\n\n  /**\n   * Indicates whether the system test has been started\n   * @returns {boolean}\n   */\n  isStarted() { return this._started }\n\n  /**\n   * Starts the system test\n   * @returns {Promise<void>}\n   */\n  async start() {\n    this.debugLog(\"Start called\")\n    const isNativeHost = process.env.SYSTEM_TEST_HOST === \"native\"\n\n    if (isNativeHost) {\n      this.currentUrl = \"native://\"\n      this.debugLog(\"Using native app host\")\n    } else if (process.env.SYSTEM_TEST_HOST == \"expo-dev-server\") {\n      this.currentUrl = `http://${this._host}:${this._port}`\n      this.debugLog(`Using expo-dev-server at ${this.currentUrl}`)\n    } else if (process.env.SYSTEM_TEST_HOST == \"dist\") {\n      const connectHost = this._httpConnectHost ?? this._httpHost\n      this.currentUrl = `http://${connectHost}:${this._httpPort}`\n\n      this.debugLog(`Spawning HTTP server for dist on ${this._httpHost}:${this._httpPort}`)\n      this.systemTestHttpServer = new SystemTestHttpServer({\n        host: this._httpHost,\n        port: this._httpPort,\n        debug: this._debug,\n        onError: this.onHttpServerError\n      })\n\n      this.debugLog(\"Starting HTTP server\")\n      await this.systemTestHttpServer.start()\n      this.debugLog(\"Checking HTTP server health\")\n      await this.systemTestHttpServer.assertReachable({timeoutMs: this.getTimeouts()})\n      this.debugLog(\"HTTP server started\")\n    } else {\n      throw new Error(\"Please set SYSTEM_TEST_HOST to 'expo-dev-server', 'dist', or 'native'\")\n    }\n\n    this.getDriverAdapter().setBaseUrl(this.currentUrl)\n\n    // Start the client WebSocket server before the driver for native hosts,\n    // because the native app launches immediately on driver start and its\n    // useSystemTestExpo hook connects to the WebSocket as soon as it renders.\n    // If the server isn't listening yet, the connection fails with no retry.\n    if (isNativeHost) {\n      this.debugLog(\"Starting WebSocket server (before driver for native)\")\n      await this.startWebSocketServer()\n      this.debugLog(\"WebSocket server started\")\n    }\n\n    this.debugLog(\"Starting driver\")\n    await this.getDriverAdapter().start()\n    this.debugLog(\"Driver started\")\n\n    await this.setTimeouts(10000)\n    this.debugLog(\"Timeouts set on driver\")\n\n    if (!isNativeHost) {\n      // Web socket server to communicate with browser\n      this.debugLog(\"Starting WebSocket server\")\n      await this.startWebSocketServer()\n      this.debugLog(\"WebSocket server started\")\n    }\n\n    if (!isNativeHost) {\n      // Visit the root page and wait for Expo to be loaded and the app to appear\n      this.debugLog(\"Visiting root path\")\n      const rootPath = this.getRootPath()\n      await this.driverVisit(rootPath)\n      this.debugLog(`Visited root path ${rootPath}`)\n\n      try {\n        this.debugLog(\"Finding root element body > #root\")\n        await this.find(\"body > #root\", {useBaseSelector: false})\n        this.debugLog(\"Found root element body > #root\")\n\n        this.debugLog(\"Finding systemTestingComponent\")\n        await this.findByTestID(\"systemTestingComponent\", {useBaseSelector: false, timeout: 30000, visible: true})\n        this.debugLog(\"Found systemTestingComponent\")\n        this.debugLog(\"Found root and systemTestingComponent\")\n      } catch (error) {\n        this.debugLog(\"Error while finding root/systemTestingComponent, taking screenshot\")\n        await this.takeScreenshot()\n        this.debugLog(\"Screenshot captured after root/systemTestingComponent lookup failure\")\n        throw error\n      }\n    } else {\n      try {\n        this.debugLog(\"Finding systemTestingComponent for native app\")\n        await this.findByTestID(\"systemTestingComponent\", {useBaseSelector: false, timeout: 30000, visible: null})\n        this.debugLog(\"Found systemTestingComponent for native app\")\n      } catch (error) {\n        this.debugLog(\"Error while finding native systemTestingComponent, taking screenshot\")\n        await this.takeScreenshot()\n        this.debugLog(\"Screenshot captured after native systemTestingComponent lookup failure\")\n        throw error\n      }\n    }\n\n    // Wait for client to connect\n    this.debugLog(\"Waiting for client WebSocket connection (opening)\")\n    this.debugLog(`WS state: ${this.ws?.readyState ?? \"none\"}`)\n    this.debugLog(\"waitForClientWebSocket\")\n    await this.waitForClientWebSocket()\n    this.debugLog(\"Client WebSocket connected\")\n\n    this._started = true\n    this.debugLog(\"Marked system test as started\")\n    if (!isNativeHost) {\n      this.debugLog(\"Setting base selector to focused systemTestingComponent\")\n      this.setBaseSelector(\"[data-testid='systemTestingComponent'][data-focussed='true']\")\n      this.debugLog(\"Base selector set\")\n    }\n    this.debugLog(\"Start completed\")\n  }\n\n  /**\n   * @returns {string}\n   */\n  getRootPath() {\n    return this._rootPath ?? SystemTest.rootPath\n  }\n\n  /**\n   * @param {string} rootPath\n   * @returns {void}\n   */\n  setRootPath(rootPath) {\n    this._rootPath = rootPath\n  }\n\n  /**\n   * @returns {string}\n   */\n  buildRootPath() {\n    const url = new URL(SystemTest.rootPath, \"http://localhost\")\n    const appendParam = (/** @type {string} */ key, /** @type {any} */ value) => {\n      if (value === undefined || value === null) return\n      url.searchParams.append(key, String(value))\n    }\n\n    if (this._urlArgs) {\n      if (this._urlArgs instanceof URLSearchParams) {\n        for (const [key, value] of this._urlArgs) {\n          appendParam(key, value)\n        }\n      } else {\n        for (const [key, value] of Object.entries(this._urlArgs)) {\n          appendParam(key, value)\n        }\n      }\n    }\n\n    if (!url.searchParams.has(\"systemTestClientWsPort\") && this._clientWsPort !== 1985) {\n      appendParam(\"systemTestClientWsPort\", this._clientWsPort)\n    }\n\n    if (!url.searchParams.has(\"systemTestScoundrelPort\") && this._scoundrelPort !== 8090) {\n      appendParam(\"systemTestScoundrelPort\", this._scoundrelPort)\n    }\n\n    const rootPath =  `${url.pathname}${url.search}${url.hash}`\n\n    this.debugLog(`buildRootPath rootPath: ${rootPath}`)\n\n    return rootPath\n  }\n\n  /**\n   * Waits for the client web socket to connect\n   * @returns {Promise<void>}\n   */\n  async waitForClientWebSocket() {\n    try {\n      await timeout({timeout: 30000, errorMessage: \"timeout while waiting for client WebSocket connection\"}, () => new Promise((resolve, reject) => {\n        if (this.ws) {\n          resolve(undefined)\n          return\n        }\n\n        this.waitForClientWebSocketPromiseReject = reject\n        this.waitForClientWebSocketPromiseResolve = resolve\n      }))\n    } catch (error) {\n      delete this.waitForClientWebSocketPromiseReject\n      delete this.waitForClientWebSocketPromiseResolve\n      throw error\n    }\n  }\n\n  /**\n   * Starts the web socket server and waits for it to be ready.\n   * @returns {Promise<void>}\n   */\n  async startWebSocketServer() {\n    this.clientWss = new WebSocketServer({port: this._clientWsPort})\n    await new Promise((resolve) => {\n      /** @type {NonNullable<typeof this.clientWss>} */ (this.clientWss).once(\"listening\", resolve)\n    })\n    this.clientWss.on(\"connection\", this.onWebSocketConnection)\n    this.clientWss.on(\"close\", this.onWebSocketClose)\n    this.clientWss.on(\"error\", (error) => {\n      this.debugError(error)\n\n      if (this.waitForClientWebSocketPromiseReject) {\n        this.waitForClientWebSocketPromiseReject(error instanceof Error ? error : new Error(String(error)))\n        delete this.waitForClientWebSocketPromiseReject\n        delete this.waitForClientWebSocketPromiseResolve\n      }\n    })\n  }\n\n  /**\n   * Sets the on command callback\n   * @param {function({type: string, data: Record<string, any>}): Promise<void>} callback\n   * @returns {void}\n   */\n  onCommand(callback) {\n    this._onCommandCallback = callback\n  }\n\n  /**\n   * Handles a command received from the browser\n   * @param {{data: Record<string, any>}} args\n   * @returns {Promise<any>}\n   */\n  onCommandReceived = async ({data}) => {\n    const type = data.type\n    let result\n\n    if (type == \"console.error\") {\n      const showMessage = !this.shouldIgnoreError(data)\n\n      if (showMessage) {\n        console.error(\"Browser error\", ...data.value)\n      }\n    } else if (type == \"console.log\") {\n      console.log(\"Browser log\", ...data.value)\n    } else if (type == \"error\" || data.type == \"unhandledrejection\") {\n      this.handleError(data)\n    } else if (this._onCommandCallback) {\n      result = await this._onCommandCallback({data, type})\n    } else {\n      console.error(`onWebSocketClientMessage unknown data (type ${type})`, data)\n    }\n\n    return result\n  }\n\n  /**\n   * Handles a new web socket connection\n   * @param {WebSocket} ws\n   * @returns {Promise<void>}\n   */\n  onWebSocketConnection = async (ws) => {\n    this.ws = ws\n    this.getCommunicator().ws = ws\n    this.getCommunicator().onOpen()\n\n    // @ts-expect-error\n    this.ws.on(\"error\", digg(this, \"communicator\", \"onError\"))\n\n    // @ts-expect-error\n    this.ws.on(\"message\", digg(this, \"communicator\", \"onMessage\"))\n\n    if (this.waitForClientWebSocketPromiseResolve) {\n      this.waitForClientWebSocketPromiseResolve(undefined)\n      delete this.waitForClientWebSocketPromiseResolve\n      delete this.waitForClientWebSocketPromiseReject\n    }\n  }\n\n  /** @returns {void} */\n  onWebSocketClose = () => {\n    this.ws = null\n    this.getCommunicator().ws = null\n\n    if (this.waitForClientWebSocketPromiseReject) {\n      this.waitForClientWebSocketPromiseReject(new Error(\"Client websocket closed before connecting\"))\n      delete this.waitForClientWebSocketPromiseReject\n      delete this.waitForClientWebSocketPromiseResolve\n    }\n  }\n\n  /**\n   * Handles an error reported from the browser\n   * @param {Record<string, any>} data\n   * @returns {void}\n   */\n  handleError(data) {\n    if (this.shouldIgnoreError(data)) return\n\n    const error = new Error(`Browser error: ${data.message}`)\n\n    if (data.backtrace) {\n      error.stack = `${error.message}\\n${data.backtrace}\\n\\n${error.stack}`\n    }\n\n    console.error(error)\n  }\n\n  /**\n   * Stops the system test\n   * @returns {Promise<void>}\n   */\n  async stop() {\n    await this.stopScoundrel()\n    if (this.ws) {\n      this.ws.close()\n      this.ws = null\n    }\n    await this.closeWebSocketServer(this.clientWss, \"client WebSocket server\")\n    if (this.driverAdapter) {\n      await this.driverAdapter.stop()\n    }\n    if (this.systemTestHttpServer) {\n      const httpServer = this.systemTestHttpServer\n      await timeout({timeout: this.getTimeouts(), errorMessage: \"timeout while closing HTTP server\"}, async () => await httpServer.close())\n    }\n  }\n\n  /**\n   * Fully tears down and restarts the system test instance.\n   * @returns {Promise<void>}\n   */\n  async reinitialize() {\n    await this.stop()\n\n    this._started = false\n    this._baseSelector = undefined\n    this.currentUrl = undefined\n    this.driver = undefined\n    this.driverAdapter = this.createDriver(this._driverConfig)\n    this.ws = null\n    this.clientWss = undefined\n    this.scoundrelWss = undefined\n    this.server = undefined\n    this.serverWebSocket = undefined\n    this.systemTestHttpServer = undefined\n    this._httpServerError = undefined\n    this.waitForClientWebSocketPromiseReject = undefined\n    this.waitForClientWebSocketPromiseResolve = undefined\n    this.communicator = new SystemTestCommunicator({onCommand: this.onCommandReceived})\n    this.setCommunicator(this.communicator)\n\n    this.startScoundrel()\n    await this.start()\n  }\n\n  /**\n   * @param {WebSocketServer | undefined} wss\n   * @param {string} [label]\n   * @returns {Promise<void>}\n   */\n  async closeWebSocketServer(wss, label = \"WebSocket server\") {\n    if (!wss) return\n\n    await timeout({timeout: this.getTimeouts(), errorMessage: `timeout while closing ${label}`}, async () => await new Promise((resolve, reject) => {\n      let settled = false\n      const terminateClient = (/** @type {any} */ client) => {\n        try {\n          client.terminate()\n        } catch {\n          // Ignore termination errors\n        }\n      }\n      const settle = (/** @type {(value: any) => void} */ callback, /** @type {any} */ arg) => {\n        if (settled) return\n        settled = true\n        callback(arg)\n      }\n\n      wss.once(\"close\", () => settle(resolve, undefined))\n      wss.once(\"error\", (error) => settle(reject, error))\n      if (wss.clients && wss.clients.size > 0) {\n        wss.clients.forEach(terminateClient)\n      }\n      wss.close((error) => {\n        if (error) settle(reject, error)\n        else settle(resolve, undefined)\n      })\n    }))\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"system-test.js","sourceRoot":"","sources":["../src/system-test.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {digg} from \"diggerize\"\nimport Server from \"scoundrel-remote-eval/build/server/index.js\"\nimport ServerWebSocket from \"scoundrel-remote-eval/build/server/connections/web-socket/index.js\"\nimport SystemTestCommunicator from \"./system-test-communicator.js\"\nimport SystemTestHttpServer from \"./system-test-http-server.js\"\nimport {waitFor} from \"awaitery\"\nimport timeout from \"awaitery/build/timeout.js\"\nimport {WebSocketServer} from \"ws\"\nimport Browser from \"./browser.js\"\n\n/**\n * @typedef {object} SystemTestArgs\n * @property {string} [host] Hostname for the app server.\n * @property {number} [port] Port for the app server.\n * @property {string} [httpHost] Hostname for the static HTTP server.\n * @property {number} [httpPort] Port for the static HTTP server.\n * @property {string} [httpConnectHost] Hostname used by the driver to reach the HTTP server.\n * @property {boolean} [debug] Enable debug logging.\n * @property {(error: any) => boolean} [errorFilter] Filter for browser errors (return false to ignore).\n * @property {number} [clientWsPort] Port for the browser-command WebSocket server.\n * @property {number} [scoundrelPort] Port for the Scoundrel WebSocket server.\n * @property {Record<string, any>} [urlArgs] Query params appended to the root path.\n * @property {SystemTestDriverConfig} [driver] Driver configuration.\n */\n/**\n * @typedef {SystemTestArgs & {reinitializeAfterFailure?: boolean}} SystemTestRunArgs\n */\n/**\n * @typedef {object} SystemTestDriverConfig\n * @property {\"selenium\"|\"appium\"} [type] Driver implementation to use.\n * @property {Record<string, any>} [options] Driver-specific options.\n */\n/**\n * @typedef {object} FindArgs\n * @property {number} [timeout] Override timeout for lookup.\n * @property {boolean | null} [visible] Whether to require elements to be visible (`true`) or hidden (`false`). Use `null` to disable visibility filtering.\n * @property {\"actions\" | \"js\"} [method] Override the click path. `\"actions\"` uses the Selenium Actions API (real pointer move + click); `\"js\"` dispatches `element.click()` via `executeScript` inside the page's JS context (skips WebDriver's pointer synthesis entirely — useful when the default click is dropped by a framework responder that refuses synthetic WebDriver pointer events).\n * @property {boolean} [scrollTo] Whether to scroll found elements into view before returning them.\n * @property {boolean} [useBaseSelector] Whether to scope by the base selector.\n */\n/**\n * @typedef {FindArgs & {withFallback?: boolean}} InteractArgs\n */\n/**\n * @typedef {object} WaitForNoSelectorArgs\n * @property {boolean} [useBaseSelector] Whether to scope by the base selector.\n */\n/**\n * @typedef {object} NotificationMessageArgs\n * @property {boolean} [dismiss] Whether to dismiss the notification after it appears.\n */\n\n/**\n * @param {string} message\n * @returns {boolean}\n */\nfunction shouldIgnoreChromePasswordFieldWarning(message) {\n  return /(?:^|\\s-\\s)\\[DOM\\] Password field is not contained in a form:/i.test(message)\n}\n\n/** @type {Record<string, any>} */\nconst globalAny = globalThis\n\nexport default class SystemTest extends Browser {\n  static rootPath = \"/blank?systemTest=true\"\n\n  /** @type {SystemTestCommunicator | undefined} */\n  communicator = undefined\n\n  _started = false\n  _clientWsPort = 1985\n  _httpHost = \"localhost\"\n  _httpPort = 1984\n  /** @type {((error: any) => boolean) | undefined} */\n  _errorFilter = undefined\n  _scoundrelPort = 8090\n  /** @type {WebSocketServer | undefined} */\n  scoundrelWss = undefined\n  /** @type {WebSocketServer | undefined} */\n  clientWss = undefined\n\n  /**\n   * Gets the current system test instance\n   * @param {SystemTestArgs} [args]\n   * @returns {SystemTest}\n   */\n  static current(args = {}) {\n    if (!globalAny.systemTest) {\n      globalAny.systemTest = new SystemTest(args)\n    }\n\n    return globalAny.systemTest\n  }\n\n  /** @returns {SystemTestCommunicator} */\n  getCommunicator() {\n    if (!this.communicator) {\n      throw new Error(\"Communicator hasn't been initialized yet\")\n    }\n\n    return this.communicator\n  }\n\n  /**\n   * Extracts an error message if possible from the payload sent from the browser.\n   * @param {{message?: string, value?: any[]} | Error} data\n   * @returns {string | undefined}\n   */\n  extractErrorMessage(data) {\n    if (data instanceof Error) return data.message\n    if (typeof data === \"object\" && typeof data.message === \"string\") return data.message\n    if (typeof data === \"string\") return data\n\n    const firstValue = Array.isArray(data?.value) ? data.value[0] : undefined\n\n    if (firstValue instanceof Error && typeof firstValue.message === \"string\") return firstValue.message\n    if (typeof firstValue === \"string\") return firstValue\n\n    return undefined\n  }\n\n  /**\n   * Whether a browser error should be ignored based on built-in rules and an optional error filter.\n   * @param {{message?: string, value?: any[]}} data\n   * @returns {boolean}\n   */\n  shouldIgnoreError(data) {\n    const message = this.extractErrorMessage(data)\n\n    if (typeof message === \"string\") {\n      if (message.includes(\"Minified React error #418\")) return true\n      if (message.includes(\"Minified React error #419\")) return true\n      if (shouldIgnoreChromePasswordFieldWarning(message)) return true\n    }\n\n    if (this._errorFilter && this._errorFilter(data) === false) {\n      return true\n    }\n\n    return false\n  }\n\n  /**\n   * Runs a system test\n   * @overload\n   * @param {function(SystemTest): Promise<void>} callback\n   * @returns {Promise<void>}\n   */\n  /**\n   * Runs a system test\n   * @overload\n   * @param {SystemTestRunArgs} args\n   * @param {function(SystemTest): Promise<void>} callback\n   * @returns {Promise<void>}\n   */\n  /**\n   * Runs a system test\n   * @param {SystemTestRunArgs | function(SystemTest): Promise<void>} [args]\n   * @param {function(SystemTest): Promise<void>} [callback]\n   * @returns {Promise<void>}\n   */\n  static async run(args, callback) {\n    const resolvedCallback = typeof args === \"function\" ? args : callback\n    const {reinitializeAfterFailure = true, ...systemTestArgs} = /** @type {SystemTestRunArgs} */ (typeof args === \"function\" ? {} : args || {})\n    const systemTest = this.current(systemTestArgs)\n\n    if (!resolvedCallback) {\n      throw new Error(\"SystemTest.run requires a callback\")\n    }\n\n    systemTest.debugLog(\"Resetting browser cookies before initialize\")\n    await systemTest.deleteAllCookies()\n    systemTest.debugLog(\"Browser cookies cleared\")\n\n    systemTest.debugLog(\"getRootPath\")\n    const rootPath = systemTest.getRootPath()\n\n    systemTest.debugLog(`Visit rootPath with dismissTo: ${rootPath}`)\n    await systemTest.dismissTo(rootPath)\n    systemTest.debugLog(`Dismissed to root path ${rootPath}`)\n\n    if (!systemTest.ws || systemTest.ws.readyState !== 1) {\n      systemTest.debugLog(\"WebSocket not connected after dismissTo, waiting for reconnection\")\n      systemTest.ws = null\n      systemTest.getCommunicator().ws = null\n      await systemTest.waitForClientWebSocket()\n      systemTest.debugLog(\"Client websocket reconnected\")\n    }\n\n    systemTest.debugLog(\"Run started - send initialize\")\n    await timeout({timeout: 10_000, errorMessage: \"Sending intialize to useSystemTest() timed out\"}, async () => {\n      await systemTest.getCommunicator().sendCommand({type: \"initialize\"})\n    })\n\n    /** @type {unknown} */\n    let runError = undefined\n    /** @type {unknown} */\n    let teardownError = undefined\n\n    try {\n      systemTest.debugLog(\"findByTestID blankText\")\n      await systemTest.findByTestID(\"blankText\", {useBaseSelector: false})\n      systemTest.debugLog(\"Found blankText\")\n\n      systemTest.debugLog(\"resolvedCallback\")\n      await resolvedCallback(systemTest)\n      systemTest.debugLog(\"Run callback completed\")\n    } catch (error) {\n      systemTest.debugLog(`Run error caught, taking screenshot: ${error instanceof Error ? error.message : error}`)\n      await systemTest.takeScreenshot()\n\n      runError = error\n    } finally {\n      systemTest.debugLog(\"Run finished - send teardown\")\n      const teardownWs = systemTest.getCommunicator().ws\n      // WebSocket.CLOSING (2) and WebSocket.CLOSED (3) cannot recover, so skip teardown.\n      // OPEN (1) sends immediately. CONNECTING (0) queues the command and flushes on\n      // onOpen — the 10s timeout below covers the wait.\n      const wsClosed = !teardownWs || teardownWs.readyState === 2 || teardownWs.readyState === 3\n\n      if (wsClosed) {\n        systemTest.debugLog(\"Skipping teardown — browser websocket is closed (likely by navigation/sign-out during the test)\")\n      } else {\n        try {\n          await timeout({timeout: 10_000, errorMessage: \"Sending teardown to useSystemTest() timed out\"}, async () => {\n            await systemTest.getCommunicator().sendCommand({type: \"teardown\"})\n          })\n        } catch (error) {\n          teardownError = error\n        }\n      }\n    }\n\n    if (runError) {\n      if (teardownError) {\n        console.error(\"System test teardown failed after test failure\", teardownError)\n      }\n\n      if (reinitializeAfterFailure) {\n        try {\n          systemTest.debugLog(\"Run failed - reinitialize SystemTest\")\n          await systemTest.reinitialize()\n          systemTest.debugLog(\"Reinitialized SystemTest after failed run\")\n        } catch (error) {\n          console.error(\"System test reinitialize failed after test failure\", error)\n        }\n      }\n\n      throw runError\n    }\n\n    if (teardownError) {\n      if (reinitializeAfterFailure) {\n        try {\n          systemTest.debugLog(\"Teardown failed - reinitialize SystemTest\")\n          await systemTest.reinitialize()\n          systemTest.debugLog(\"Reinitialized SystemTest after failed teardown\")\n        } catch (error) {\n          console.error(\"System test reinitialize failed after teardown failure\", error)\n        }\n      }\n\n      throw teardownError\n    }\n  }\n\n  /**\n   * Creates a new SystemTest instance\n   * @param {SystemTestArgs} [args]\n   */\n  constructor({clientWsPort = 1985, host = \"localhost\", port = 8081, httpHost = \"localhost\", httpPort = 1984, httpConnectHost, debug = false, errorFilter, scoundrelPort = 8090, urlArgs, driver, ...restArgs} = {host: \"localhost\", port: 8081, httpHost: \"localhost\", httpPort: 1984, debug: false}) {\n    super({debug, driver})\n\n    const restArgsKeys = Object.keys(restArgs)\n\n    if (restArgsKeys.length > 0) {\n      throw new Error(`Unknown arguments: ${restArgsKeys.join(\", \")}`)\n    }\n\n    this._host = host\n    this._port = port\n    this._clientWsPort = clientWsPort\n    this._httpHost = httpHost\n    this._httpPort = httpPort\n    this._httpConnectHost = httpConnectHost\n    this._debug = debug\n    this._errorFilter = errorFilter\n    this._scoundrelPort = scoundrelPort\n    this._urlArgs = urlArgs\n    this._rootPath = this.buildRootPath()\n\n    /** @type {Record<number, object>} */\n    this._responses = {}\n\n    this._sendCount = 0\n    this.startScoundrel()\n    this.communicator = new SystemTestCommunicator({onCommand: this.onCommandReceived})\n    this.setCommunicator(this.communicator)\n  }\n\n  /**\n   * Starts Scoundrel server which the browser connects to for remote evaluation in the browser\n   * @returns {void}\n   */\n  startScoundrel() {\n    if (this.scoundrelWss) throw new Error(\"Scoundrel server already started\")\n\n    this.scoundrelWss = new WebSocketServer({port: this._scoundrelPort})\n    this.serverWebSocket = new ServerWebSocket(this.scoundrelWss)\n    this.server = new Server(this.serverWebSocket)\n  }\n\n  /**\n   * @returns {Promise<void>}\n   */\n  async stopScoundrel() {\n    if (this.server?.close) {\n      await timeout({timeout: this.getTimeouts(), errorMessage: \"timeout while waiting for Scoundrel to stop\"}, async () => await /** @type {NonNullable<typeof this.server>} */ (this.server).close())\n    }\n    await this.closeWebSocketServer(this.scoundrelWss, \"Scoundrel WebSocket server\")\n  }\n\n  /**\n   * Waits for the Scoundrel client (browser) to connect and returns it.\n   * @param {number} [timeoutMs]\n   * @returns {Promise<import(\"scoundrel-remote-eval/build/client/index.js\").default>}\n   */\n  async getScoundrelClient(timeoutMs = 10000) {\n    if (!this.server) {\n      throw new Error(\"Scoundrel server is not started\")\n    }\n\n    this.debugLog(\"getScoundrelClient: waiting for browser Scoundrel initialization\")\n    await timeout({timeout: timeoutMs, errorMessage: \"Timed out waiting for Scoundrel to initialize\"}, async () => {\n      await this.getCommunicator().sendCommand({type: \"waitForScoundrel\"})\n    })\n    this.debugLog(\"getScoundrelClient: browser reported Scoundrel initialized\")\n\n    /**\n     * @param {any} client\n     * @returns {boolean}\n     */\n    const isOpenClient = (client) => client?.backend?.ws?.readyState === 1\n\n    const existingClients = this.server.getClients?.()\n    const openExistingClients = existingClients?.filter(isOpenClient)\n\n    if (openExistingClients && openExistingClients.length > 0) {\n      this.debugLog(`getScoundrelClient: using existing open client (${openExistingClients.length} available)`)\n      return openExistingClients[openExistingClients.length - 1]\n    }\n    this.debugLog(`getScoundrelClient: no open cached clients, waiting for new connection (cached total: ${existingClients?.length ?? 0})`)\n\n    if (!this.server.events?.on) {\n      throw new Error(\"Scoundrel server events are unavailable\")\n    }\n\n    /** @type {((client: any) => void) | undefined} */\n    let onNewClient\n    const cleanupListener = () => {\n      if (onNewClient) {\n        this.server?.events.off(\"newClient\", onNewClient)\n      }\n    }\n\n    try {\n      return await timeout({timeout: timeoutMs, errorMessage: \"Timed out waiting for Scoundrel client\"}, async () => await new Promise((resolve) => {\n        onNewClient = (/** @type {any} */ client) => {\n          if (!isOpenClient(client)) return\n          cleanupListener()\n          this.debugLog(\"getScoundrelClient: received new open client\")\n          resolve(client)\n        }\n\n        this.server?.events.on(\"newClient\", onNewClient)\n      }))\n    } finally {\n      cleanupListener()\n    }\n  }\n\n  /**\n   * Finds all elements by CSS selector\n   * @param {string} selector\n   * @param {FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement[]>}\n   */\n  async all(selector, args = {}) {\n    return await this.getDriverAdapter().all(selector, args)\n  }\n\n  /**\n   * Clicks an element that has children which fills out the element and would otherwise have caused a ElementClickInterceptedError\n   * @param {string|import(\"selenium-webdriver\").WebElement} elementOrIdentifier\n   * @returns {Promise<void>}\n   */\n  /**\n   * Clicks an element, allowing selector args when using a CSS selector.\n   * @param {string|import(\"selenium-webdriver\").WebElement} elementOrIdentifier\n   * @param {FindArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async click(elementOrIdentifier, args) {\n    await this.getDriverAdapter().click(elementOrIdentifier, args)\n  }\n\n  /**\n   * Finds a single element by CSS selector\n   * @param {string} selector\n   * @param {FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async find(selector, args = {}) {\n    return await this.getDriverAdapter().find(selector, args)\n  }\n\n  /**\n   * Finds a single element by test ID\n   * @param {string} testID\n   * @param {FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async findByTestID(testID, args) {\n    return await this.getDriverAdapter().findByTestID(testID, args)\n  }\n\n  /**\n   * Checks whether an element with the given test ID is currently rendered.\n   * @param {string} testID\n   * @param {FindArgs} [args]\n   * @returns {Promise<boolean>}\n   */\n  async hasTestID(testID, args) {\n    return await this.getDriverAdapter().hasTestID(testID, args)\n  }\n\n  /**\n   * Finds a single element by CSS selector without waiting\n   * @param {string} selector\n   * @param {FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async findNoWait(selector, args = {}) {\n    return await this.getDriverAdapter().findNoWait(selector, args)\n  }\n\n  /**\n   * Interacts with an element by calling a method on it with the given arguments.\n   * Retrying on ElementNotInteractableError, ElementClickInterceptedError, or StaleElementReferenceError.\n   * @param {import(\"selenium-webdriver\").WebElement|string|{selector: string} & InteractArgs} elementOrIdentifier The element or a CSS selector to find the element.\n   * @param {string} methodName The method name to call on the element.\n   * @param {...any} args Arguments to pass to the method.\n   * @returns {Promise<any>}\n   */\n  async interact(elementOrIdentifier, methodName, ...args) {\n    return await this.getDriverAdapter().interact(elementOrIdentifier, methodName, ...args)\n  }\n\n  /**\n   * Expects no element to be found by CSS selector\n   * @param {string} selector\n   * @param {FindArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async expectNoElement(selector, args = {}) {\n    let found = false\n\n    try {\n      await this.findNoWait(selector, args)\n      found = true\n    } catch (error) {\n      if (error instanceof Error && error.message.startsWith(\"Element couldn't be found after \")) {\n        // Ignore\n      } else {\n        throw error\n      }\n    }\n\n    if (found) {\n      throw new Error(`Expected not to find: ${selector}`)\n    }\n  }\n\n  /**\n   * @param {string} selector\n   * @param {WaitForNoSelectorArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async waitForNoSelector(selector, args = {}) {\n    await this.getDriverAdapter().waitForNoSelector(selector, args)\n  }\n\n  /**\n   * Gets notification messages\n   * @returns {Promise<string[]>}\n   */\n  async notificationMessages() {\n    const notificationMessageElements = await this.all(\"[data-class='notification-message']\", {useBaseSelector: false})\n    const notificationMessageTexts = []\n\n    for (const notificationMessageElement of notificationMessageElements) {\n      const text = await notificationMessageElement.getText()\n\n      notificationMessageTexts.push(text)\n    }\n\n    return notificationMessageTexts\n  }\n\n  /**\n   * Expects a notification message to appear and waits for it if necessary.\n   * @param {string} expectedNotificationMessage\n   * @param {NotificationMessageArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async expectNotificationMessage(expectedNotificationMessage, args = {}) {\n    const {dismiss = true, ...restArgs} = args\n\n    if (Object.keys(restArgs).length > 0) {\n      throw new Error(`Unexpected args: ${Object.keys(restArgs).join(\", \")}`)\n    }\n\n    /** @type {string[]} */\n    const allDetectedNotificationMessages = []\n    let foundNotificationMessageElement\n    let foundNotificationMessageCount\n\n    await waitFor(async () => {\n      const notificationMessageElements = await this.all(\"[data-testid='notification-message']\", {useBaseSelector: false})\n\n      for (const notificationMessageElement of notificationMessageElements) {\n        const notificationMessage = (await this.getDriver().executeScript(\"return arguments[0].textContent;\", notificationMessageElement))?.trim() || await notificationMessageElement.getText()\n\n        if (!allDetectedNotificationMessages.includes(notificationMessage)) {\n          allDetectedNotificationMessages.push(notificationMessage)\n        }\n\n        if (notificationMessage == expectedNotificationMessage) {\n          foundNotificationMessageElement = notificationMessageElement\n          foundNotificationMessageCount = await notificationMessageElement.getAttribute(\"data-count\")\n          return\n        }\n      }\n\n      throw new Error(`Notification message ${expectedNotificationMessage} wasn't included in: ${allDetectedNotificationMessages.join(\", \")}`)\n    })\n\n    if (foundNotificationMessageElement && dismiss) {\n      await this.interact(foundNotificationMessageElement, \"click\") // Dismiss the notification message\n      if (!foundNotificationMessageCount) {\n        throw new Error(\"Expected notification message to have a data-count\")\n      }\n\n      await this.waitForNoSelector(`[data-testid='notification-message'][data-count='${foundNotificationMessageCount}']`, {useBaseSelector: false})\n    }\n  }\n\n  /** @returns {Promise<void>} */\n  async dismissNotificationMessages() {\n    const notificationMessageElements = await this.all(\"[data-class='notification-message']\", {useBaseSelector: false})\n\n    for (const notificationMessageElement of notificationMessageElements) {\n      await this.interact(notificationMessageElement, \"click\")\n    }\n\n    await this.waitForNoSelector(\"[data-class='notification-message']\", {useBaseSelector: false})\n  }\n\n  /**\n   * Indicates whether the system test has been started\n   * @returns {boolean}\n   */\n  isStarted() { return this._started }\n\n  /**\n   * Starts the system test\n   * @returns {Promise<void>}\n   */\n  async start() {\n    this.debugLog(\"Start called\")\n    const isNativeHost = process.env.SYSTEM_TEST_HOST === \"native\"\n\n    if (isNativeHost) {\n      this.currentUrl = \"native://\"\n      this.debugLog(\"Using native app host\")\n    } else if (process.env.SYSTEM_TEST_HOST == \"expo-dev-server\") {\n      this.currentUrl = `http://${this._host}:${this._port}`\n      this.debugLog(`Using expo-dev-server at ${this.currentUrl}`)\n    } else if (process.env.SYSTEM_TEST_HOST == \"dist\") {\n      const connectHost = this._httpConnectHost ?? this._httpHost\n      this.currentUrl = `http://${connectHost}:${this._httpPort}`\n\n      this.debugLog(`Spawning HTTP server for dist on ${this._httpHost}:${this._httpPort}`)\n      this.systemTestHttpServer = new SystemTestHttpServer({\n        host: this._httpHost,\n        port: this._httpPort,\n        debug: this._debug,\n        onError: this.onHttpServerError\n      })\n\n      this.debugLog(\"Starting HTTP server\")\n      await this.systemTestHttpServer.start()\n      this.debugLog(\"Checking HTTP server health\")\n      await this.systemTestHttpServer.assertReachable({timeoutMs: this.getTimeouts()})\n      this.debugLog(\"HTTP server started\")\n    } else {\n      throw new Error(\"Please set SYSTEM_TEST_HOST to 'expo-dev-server', 'dist', or 'native'\")\n    }\n\n    this.getDriverAdapter().setBaseUrl(this.currentUrl)\n\n    // Start the client WebSocket server before the driver for native hosts,\n    // because the native app launches immediately on driver start and its\n    // useSystemTestExpo hook connects to the WebSocket as soon as it renders.\n    // If the server isn't listening yet, the connection fails with no retry.\n    if (isNativeHost) {\n      this.debugLog(\"Starting WebSocket server (before driver for native)\")\n      await this.startWebSocketServer()\n      this.debugLog(\"WebSocket server started\")\n    }\n\n    this.debugLog(\"Starting driver\")\n    await this.getDriverAdapter().start()\n    this.debugLog(\"Driver started\")\n\n    await this.setTimeouts(10000)\n    this.debugLog(\"Timeouts set on driver\")\n\n    if (!isNativeHost) {\n      // Web socket server to communicate with browser\n      this.debugLog(\"Starting WebSocket server\")\n      await this.startWebSocketServer()\n      this.debugLog(\"WebSocket server started\")\n    }\n\n    if (!isNativeHost) {\n      // Visit the root page and wait for Expo to be loaded and the app to appear\n      this.debugLog(\"Visiting root path\")\n      const rootPath = this.getRootPath()\n      await this.driverVisit(rootPath)\n      this.debugLog(`Visited root path ${rootPath}`)\n\n      try {\n        this.debugLog(\"Finding root element body > #root\")\n        await this.find(\"body > #root\", {useBaseSelector: false})\n        this.debugLog(\"Found root element body > #root\")\n\n        this.debugLog(\"Finding systemTestingComponent\")\n        await this.findByTestID(\"systemTestingComponent\", {useBaseSelector: false, timeout: 30000, visible: true})\n        this.debugLog(\"Found systemTestingComponent\")\n        this.debugLog(\"Found root and systemTestingComponent\")\n      } catch (error) {\n        this.debugLog(\"Error while finding root/systemTestingComponent, taking screenshot\")\n        await this.takeScreenshot()\n        this.debugLog(\"Screenshot captured after root/systemTestingComponent lookup failure\")\n        throw error\n      }\n    } else {\n      try {\n        this.debugLog(\"Finding systemTestingComponent for native app\")\n        await this.findByTestID(\"systemTestingComponent\", {useBaseSelector: false, timeout: 30000, visible: null})\n        this.debugLog(\"Found systemTestingComponent for native app\")\n      } catch (error) {\n        this.debugLog(\"Error while finding native systemTestingComponent, taking screenshot\")\n        await this.takeScreenshot()\n        this.debugLog(\"Screenshot captured after native systemTestingComponent lookup failure\")\n        throw error\n      }\n    }\n\n    // Wait for client to connect\n    this.debugLog(\"Waiting for client WebSocket connection (opening)\")\n    this.debugLog(`WS state: ${this.ws?.readyState ?? \"none\"}`)\n    this.debugLog(\"waitForClientWebSocket\")\n    await this.waitForClientWebSocket()\n    this.debugLog(\"Client WebSocket connected\")\n\n    this._started = true\n    this.debugLog(\"Marked system test as started\")\n    if (!isNativeHost) {\n      this.debugLog(\"Setting base selector to focused systemTestingComponent\")\n      this.setBaseSelector(\"[data-testid='systemTestingComponent'][data-focussed='true']\")\n      this.debugLog(\"Base selector set\")\n    }\n    this.debugLog(\"Start completed\")\n  }\n\n  /**\n   * @returns {string}\n   */\n  getRootPath() {\n    return this._rootPath ?? SystemTest.rootPath\n  }\n\n  /**\n   * @param {string} rootPath\n   * @returns {void}\n   */\n  setRootPath(rootPath) {\n    this._rootPath = rootPath\n  }\n\n  /**\n   * @returns {string}\n   */\n  buildRootPath() {\n    const url = new URL(SystemTest.rootPath, \"http://localhost\")\n    const appendParam = (/** @type {string} */ key, /** @type {any} */ value) => {\n      if (value === undefined || value === null) return\n      url.searchParams.append(key, String(value))\n    }\n\n    if (this._urlArgs) {\n      if (this._urlArgs instanceof URLSearchParams) {\n        for (const [key, value] of this._urlArgs) {\n          appendParam(key, value)\n        }\n      } else {\n        for (const [key, value] of Object.entries(this._urlArgs)) {\n          appendParam(key, value)\n        }\n      }\n    }\n\n    if (!url.searchParams.has(\"systemTestClientWsPort\") && this._clientWsPort !== 1985) {\n      appendParam(\"systemTestClientWsPort\", this._clientWsPort)\n    }\n\n    if (!url.searchParams.has(\"systemTestScoundrelPort\") && this._scoundrelPort !== 8090) {\n      appendParam(\"systemTestScoundrelPort\", this._scoundrelPort)\n    }\n\n    const rootPath =  `${url.pathname}${url.search}${url.hash}`\n\n    this.debugLog(`buildRootPath rootPath: ${rootPath}`)\n\n    return rootPath\n  }\n\n  /**\n   * Waits for the client web socket to connect\n   * @returns {Promise<void>}\n   */\n  async waitForClientWebSocket() {\n    try {\n      await timeout({timeout: 30000, errorMessage: \"timeout while waiting for client WebSocket connection\"}, () => new Promise((resolve, reject) => {\n        if (this.ws) {\n          resolve(undefined)\n          return\n        }\n\n        this.waitForClientWebSocketPromiseReject = reject\n        this.waitForClientWebSocketPromiseResolve = resolve\n      }))\n    } catch (error) {\n      delete this.waitForClientWebSocketPromiseReject\n      delete this.waitForClientWebSocketPromiseResolve\n      throw error\n    }\n  }\n\n  /**\n   * Starts the web socket server and waits for it to be ready.\n   * @returns {Promise<void>}\n   */\n  async startWebSocketServer() {\n    this.clientWss = new WebSocketServer({port: this._clientWsPort})\n    await new Promise((resolve) => {\n      /** @type {NonNullable<typeof this.clientWss>} */ (this.clientWss).once(\"listening\", resolve)\n    })\n    this.clientWss.on(\"connection\", this.onWebSocketConnection)\n    this.clientWss.on(\"close\", this.onWebSocketClose)\n    this.clientWss.on(\"error\", (error) => {\n      this.debugError(error)\n\n      if (this.waitForClientWebSocketPromiseReject) {\n        this.waitForClientWebSocketPromiseReject(error instanceof Error ? error : new Error(String(error)))\n        delete this.waitForClientWebSocketPromiseReject\n        delete this.waitForClientWebSocketPromiseResolve\n      }\n    })\n  }\n\n  /**\n   * Sets the on command callback\n   * @param {function({type: string, data: Record<string, any>}): Promise<void>} callback\n   * @returns {void}\n   */\n  onCommand(callback) {\n    this._onCommandCallback = callback\n  }\n\n  /**\n   * Handles a command received from the browser\n   * @param {{data: Record<string, any>}} args\n   * @returns {Promise<any>}\n   */\n  onCommandReceived = async ({data}) => {\n    const type = data.type\n    let result\n\n    if (type == \"console.error\") {\n      const showMessage = !this.shouldIgnoreError(data)\n\n      if (showMessage) {\n        console.error(\"Browser error\", ...data.value)\n      }\n    } else if (type == \"console.log\") {\n      console.log(\"Browser log\", ...data.value)\n    } else if (type == \"error\" || data.type == \"unhandledrejection\") {\n      this.handleError(data)\n    } else if (this._onCommandCallback) {\n      result = await this._onCommandCallback({data, type})\n    } else {\n      console.error(`onWebSocketClientMessage unknown data (type ${type})`, data)\n    }\n\n    return result\n  }\n\n  /**\n   * Handles a new web socket connection\n   * @param {WebSocket} ws\n   * @returns {Promise<void>}\n   */\n  onWebSocketConnection = async (ws) => {\n    this.ws = ws\n    this.getCommunicator().ws = ws\n    this.getCommunicator().onOpen()\n\n    // @ts-expect-error\n    this.ws.on(\"error\", digg(this, \"communicator\", \"onError\"))\n\n    // @ts-expect-error\n    this.ws.on(\"message\", digg(this, \"communicator\", \"onMessage\"))\n\n    if (this.waitForClientWebSocketPromiseResolve) {\n      this.waitForClientWebSocketPromiseResolve(undefined)\n      delete this.waitForClientWebSocketPromiseResolve\n      delete this.waitForClientWebSocketPromiseReject\n    }\n  }\n\n  /** @returns {void} */\n  onWebSocketClose = () => {\n    this.ws = null\n    this.getCommunicator().ws = null\n\n    if (this.waitForClientWebSocketPromiseReject) {\n      this.waitForClientWebSocketPromiseReject(new Error(\"Client websocket closed before connecting\"))\n      delete this.waitForClientWebSocketPromiseReject\n      delete this.waitForClientWebSocketPromiseResolve\n    }\n  }\n\n  /**\n   * Handles an error reported from the browser\n   * @param {Record<string, any>} data\n   * @returns {void}\n   */\n  handleError(data) {\n    if (this.shouldIgnoreError(data)) return\n\n    const error = new Error(`Browser error: ${data.message}`)\n\n    if (data.backtrace) {\n      error.stack = `${error.message}\\n${data.backtrace}\\n\\n${error.stack}`\n    }\n\n    console.error(error)\n  }\n\n  /**\n   * Stops the system test\n   * @returns {Promise<void>}\n   */\n  async stop() {\n    await this.stopScoundrel()\n    if (this.ws) {\n      this.ws.close()\n      this.ws = null\n    }\n    await this.closeWebSocketServer(this.clientWss, \"client WebSocket server\")\n    if (this.driverAdapter) {\n      await this.driverAdapter.stop()\n    }\n    if (this.systemTestHttpServer) {\n      const httpServer = this.systemTestHttpServer\n      await timeout({timeout: this.getTimeouts(), errorMessage: \"timeout while closing HTTP server\"}, async () => await httpServer.close())\n    }\n  }\n\n  /**\n   * Fully tears down and restarts the system test instance.\n   * @returns {Promise<void>}\n   */\n  async reinitialize() {\n    await this.stop()\n\n    this._started = false\n    this._baseSelector = undefined\n    this.currentUrl = undefined\n    this.driver = undefined\n    this.driverAdapter = this.createDriver(this._driverConfig)\n    this.ws = null\n    this.clientWss = undefined\n    this.scoundrelWss = undefined\n    this.server = undefined\n    this.serverWebSocket = undefined\n    this.systemTestHttpServer = undefined\n    this._httpServerError = undefined\n    this.waitForClientWebSocketPromiseReject = undefined\n    this.waitForClientWebSocketPromiseResolve = undefined\n    this.communicator = new SystemTestCommunicator({onCommand: this.onCommandReceived})\n    this.setCommunicator(this.communicator)\n\n    this.startScoundrel()\n    await this.start()\n  }\n\n  /**\n   * @param {WebSocketServer | undefined} wss\n   * @param {string} [label]\n   * @returns {Promise<void>}\n   */\n  async closeWebSocketServer(wss, label = \"WebSocket server\") {\n    if (!wss) return\n\n    await timeout({timeout: this.getTimeouts(), errorMessage: `timeout while closing ${label}`}, async () => await new Promise((resolve, reject) => {\n      let settled = false\n      const terminateClient = (/** @type {any} */ client) => {\n        try {\n          client.terminate()\n        } catch {\n          // Ignore termination errors\n        }\n      }\n      const settle = (/** @type {(value: any) => void} */ callback, /** @type {any} */ arg) => {\n        if (settled) return\n        settled = true\n        callback(arg)\n      }\n\n      wss.once(\"close\", () => settle(resolve, undefined))\n      wss.once(\"error\", (error) => settle(reject, error))\n      if (wss.clients && wss.clients.size > 0) {\n        wss.clients.forEach(terminateClient)\n      }\n      wss.close((error) => {\n        if (error) settle(reject, error)\n        else settle(resolve, undefined)\n      })\n    }))\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "system-testing",
-  "version": "1.0.103",
+  "version": "1.0.104",
   "description": "System testing with Selenium and browsers.",
   "bin": {
     "system-testing": "build/cli.js"