system-testing 1.0.104 → 1.0.106

package/README.md

@@ -1,6 +1,6 @@
 # System testing
 
-Rails inspired system testing for Expo apps.
+Rails inspired system testing for browser, React Native, and Expo apps.
 
 ## Install
 
@@ -183,7 +183,7 @@ Useful browser methods:
 
 If you want app-level navigation instead of direct URL loads, keep `Browser` for the driver/session side and use one of the `useSystemTest*` hooks in the app so the communicator has something to talk to.
 
-`react` and `expo-router` are optional peer dependencies. Install them only in apps that import the React/Expo hook helpers; CLI/browser-daemon consumers should not need React just to use `system-testing`.
+`react` is an optional peer dependency. Install it only in apps that import the React hook helpers; CLI/browser-daemon consumers should not need React just to use `system-testing`. `expo-router` is not a package-level peer dependency. Install it only in Expo Router apps that import `system-testing/build/expo.js` or `system-testing/build/use-system-test-expo.js`.
 
 ### Browser daemon CLI
 
@@ -302,7 +302,7 @@ Minimal example:
 
 ```jsx
 import {Stack} from "expo-router"
-import useSystemTestExpo from "system-testing/build/use-system-test-expo.js"
+import {useSystemTestExpo} from "system-testing/build/expo.js"
 
 export default function RootLayout() {
   const {enabled, systemTestBrowserHelper} = useSystemTestExpo({

package/build/browser-command-runner.js

@@ -1,3 +1,20 @@
+/**
+ * Parse a cookie boolean attribute coming in over the JSON command transport.
+ * The transport carries booleans either as native `true`/`false` or as the
+ * string forms `"true"`/`"false"`. Anything else is rejected so a typo like
+ * `--cookie-secure=TRUE` or `--cookie-secure=1` fails loudly instead of
+ * silently producing an insecure cookie.
+ * @param {string} fieldName
+ * @param {unknown} rawValue
+ * @returns {boolean}
+ */
+function parseCookieBoolean(fieldName, rawValue) {
+    if (rawValue === true || rawValue === "true")
+        return true;
+    if (rawValue === false || rawValue === "false")
+        return false;
+    throw new Error(`addCookie ${fieldName} must be true or false, got ${JSON.stringify(rawValue)}`);
+}
 /** Runs browser commands across CLI and WebSocket transports. */
 export default class BrowserCommandRunner {
     /**
@@ -144,6 +161,41 @@ export default class BrowserCommandRunner {
             await this.browser.expectNoElement(commandArgs.selector, this.normalizeFindArgs(commandArgs));
             return { ok: true };
         }
+        if (command === "executeScript") {
+            const script = commandArgs.script;
+            if (typeof script !== "string" || script.length === 0) {
+                throw new Error("executeScript requires script");
+            }
+            const scriptArgs = Array.isArray(commandArgs.args) ? commandArgs.args : [];
+            const result = await this.browser.executeScript(script, ...scriptArgs);
+            return { result };
+        }
+        if (command === "addCookie") {
+            const name = commandArgs.name;
+            if (typeof name !== "string" || name.length === 0) {
+                throw new Error("addCookie requires name");
+            }
+            const value = commandArgs.value;
+            if (typeof value !== "string") {
+                throw new Error("addCookie requires string value");
+            }
+            /** @type {{name: string, value: string, domain?: string, path?: string, secure?: boolean, httpOnly?: boolean, expiry?: number, sameSite?: "Strict" | "Lax" | "None"}} */
+            const cookie = { name, value };
+            if (typeof commandArgs.domain === "string" && commandArgs.domain.length > 0)
+                cookie.domain = commandArgs.domain;
+            if (typeof commandArgs.path === "string" && commandArgs.path.length > 0)
+                cookie.path = commandArgs.path;
+            if (commandArgs.secure !== undefined)
+                cookie.secure = parseCookieBoolean("secure", commandArgs.secure);
+            if (commandArgs.httpOnly !== undefined)
+                cookie.httpOnly = parseCookieBoolean("httpOnly", commandArgs.httpOnly);
+            if (commandArgs.expiry !== undefined)
+                cookie.expiry = Number(commandArgs.expiry);
+            if (typeof commandArgs.sameSite === "string")
+                cookie.sameSite = /** @type {"Strict" | "Lax" | "None"} */ (commandArgs.sameSite);
+            await this.browser.addCookie(cookie);
+            return { ok: true };
+        }
         if (command === "interact") {
             const selector = commandArgs.selector;
             const methodName = commandArgs.methodName ?? commandArgs.method;
@@ -169,4 +221,4 @@ export default class BrowserCommandRunner {
         throw new Error(`Unknown browser command: ${command}`);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"browser-command-runner.js","sourceRoot":"","sources":["../src/browser-command-runner.js"],"names":[],"mappings":"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","sourcesContent":["/** Runs browser commands across CLI and WebSocket transports. */\nexport default class BrowserCommandRunner {\n  /**\n   * @param {object} args\n   * @param {import(\"./browser.js\").default} args.browser\n   */\n  constructor({browser}) {\n    this.browser = browser\n  }\n\n  /**\n   * @param {Record<string, any>} commandArgs\n   * @returns {{timeout?: number}}\n   */\n  normalizeTimeoutArgs(commandArgs) {\n    const normalizedArgs = {}\n\n    if (\"timeout\" in commandArgs && commandArgs.timeout !== undefined) {\n      normalizedArgs.timeout = Number(commandArgs.timeout)\n\n      if (Number.isNaN(normalizedArgs.timeout)) {\n        throw new Error(`Invalid timeout: ${commandArgs.timeout}`)\n      }\n    }\n\n    return normalizedArgs\n  }\n\n  /**\n   * @param {Record<string, any>} commandArgs\n   * @returns {import(\"./system-test.js\").FindArgs}\n   */\n  normalizeFindArgs(commandArgs) {\n    const findArgs = /** @type {import(\"./system-test.js\").FindArgs} */ (this.normalizeTimeoutArgs(commandArgs))\n\n    if (\"visible\" in commandArgs && commandArgs.visible !== undefined) {\n      if (commandArgs.visible === null || commandArgs.visible === \"null\") {\n        findArgs.visible = null\n      } else if (typeof commandArgs.visible === \"boolean\") {\n        findArgs.visible = commandArgs.visible\n      } else {\n        findArgs.visible = commandArgs.visible === \"true\"\n      }\n    }\n\n    if (\"useBaseSelector\" in commandArgs && commandArgs.useBaseSelector !== undefined) {\n      if (typeof commandArgs.useBaseSelector === \"boolean\") {\n        findArgs.useBaseSelector = commandArgs.useBaseSelector\n      } else {\n        findArgs.useBaseSelector = commandArgs.useBaseSelector === \"true\"\n      }\n    }\n\n    if (\"scrollTo\" in commandArgs && commandArgs.scrollTo !== undefined) {\n      if (typeof commandArgs.scrollTo === \"boolean\") {\n        findArgs.scrollTo = commandArgs.scrollTo\n      } else {\n        findArgs.scrollTo = commandArgs.scrollTo === \"true\"\n      }\n    }\n\n    return findArgs\n  }\n\n  /**\n   * @param {import(\"selenium-webdriver\").WebElement} element\n   * @returns {Promise<Record<string, any>>}\n   */\n  async serializeElement(element) {\n    const text = await element.getText()\n    const tagName = await element.getTagName()\n    const displayed = await element.isDisplayed()\n\n    return {displayed, tagName, text}\n  }\n\n  /**\n   * @param {string} command\n   * @param {Record<string, any>} commandArgs\n   * @returns {Promise<any>}\n   */\n  async run(command, commandArgs = {}) {\n    if (command === \"visit\") {\n      const path = commandArgs.path ?? commandArgs.url\n\n      if (!path) {\n        throw new Error(\"visit requires path or url\")\n      }\n\n      await this.browser.visit(path, this.normalizeTimeoutArgs(commandArgs))\n      return {ok: true}\n    }\n\n    if (command === \"dismissTo\") {\n      const path = commandArgs.path ?? commandArgs.url\n\n      if (!path) {\n        throw new Error(\"dismissTo requires path or url\")\n      }\n\n      await this.browser.dismissTo(path, this.normalizeTimeoutArgs(commandArgs))\n      return {ok: true}\n    }\n\n    if (command === \"setBaseSelector\") {\n      if (!commandArgs.selector) {\n        throw new Error(\"setBaseSelector requires selector\")\n      }\n\n      this.browser.setBaseSelector(commandArgs.selector)\n      return {ok: true}\n    }\n\n    if (command === \"getCurrentUrl\") {\n      return {currentUrl: await this.browser.getCurrentUrl()}\n    }\n\n    if (command === \"getHTML\") {\n      return {html: await this.browser.getHTML()}\n    }\n\n    if (command === \"getBrowserLogs\") {\n      return {logs: await this.browser.getBrowserLogs()}\n    }\n\n    if (command === \"takeScreenshot\") {\n      return await this.browser.takeScreenshot()\n    }\n\n    if (command === \"find\") {\n      if (!commandArgs.selector) {\n        throw new Error(\"find requires selector\")\n      }\n\n      const element = await this.browser.find(commandArgs.selector, this.normalizeFindArgs(commandArgs))\n\n      return {element: await this.serializeElement(element)}\n    }\n\n    if (command === \"findByTestID\") {\n      const testID = commandArgs.testID ?? commandArgs.testId\n\n      if (!testID) {\n        throw new Error(\"findByTestID requires testID\")\n      }\n\n      const element = await this.browser.findByTestID(testID, this.normalizeFindArgs(commandArgs))\n\n      return {element: await this.serializeElement(element)}\n    }\n\n    if (command === \"click\") {\n      const selector = commandArgs.selector\n\n      if (!selector) {\n        throw new Error(\"click requires selector\")\n      }\n\n      await this.browser.click(selector, this.normalizeFindArgs(commandArgs))\n      return {ok: true}\n    }\n\n    if (command === \"waitForNoSelector\") {\n      if (!commandArgs.selector) {\n        throw new Error(\"waitForNoSelector requires selector\")\n      }\n\n      await this.browser.waitForNoSelector(commandArgs.selector, this.normalizeFindArgs(commandArgs))\n      return {ok: true}\n    }\n\n    if (command === \"expectNoElement\") {\n      if (!commandArgs.selector) {\n        throw new Error(\"expectNoElement requires selector\")\n      }\n\n      await this.browser.expectNoElement(commandArgs.selector, this.normalizeFindArgs(commandArgs))\n      return {ok: true}\n    }\n\n    if (command === \"interact\") {\n      const selector = commandArgs.selector\n      const methodName = commandArgs.methodName ?? commandArgs.method\n      const methodArgs = Array.isArray(commandArgs.args) ? commandArgs.args : []\n      const interactArgs = /** @type {{selector: string} & import(\"./system-test.js\").InteractArgs} */ ({selector, ...this.normalizeFindArgs(commandArgs)})\n\n      if (!selector) {\n        throw new Error(\"interact requires selector\")\n      }\n\n      if (!methodName) {\n        throw new Error(\"interact requires methodName\")\n      }\n\n      if (\"withFallback\" in commandArgs && commandArgs.withFallback !== undefined) {\n        if (typeof commandArgs.withFallback === \"boolean\") {\n          interactArgs.withFallback = commandArgs.withFallback\n        } else {\n          interactArgs.withFallback = commandArgs.withFallback === \"true\"\n        }\n      }\n\n      const result = await this.browser.interact(interactArgs, methodName, ...methodArgs)\n\n      return {result}\n    }\n\n    throw new Error(`Unknown browser command: ${command}`)\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"browser-command-runner.js","sourceRoot":"","sources":["../src/browser-command-runner.js"],"names":[],"mappings":"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","sourcesContent":["/**\n * Parse a cookie boolean attribute coming in over the JSON command transport.\n * The transport carries booleans either as native `true`/`false` or as the\n * string forms `\"true\"`/`\"false\"`. Anything else is rejected so a typo like\n * `--cookie-secure=TRUE` or `--cookie-secure=1` fails loudly instead of\n * silently producing an insecure cookie.\n * @param {string} fieldName\n * @param {unknown} rawValue\n * @returns {boolean}\n */\nfunction parseCookieBoolean(fieldName, rawValue) {\n  if (rawValue === true || rawValue === \"true\") return true\n  if (rawValue === false || rawValue === \"false\") return false\n\n  throw new Error(`addCookie ${fieldName} must be true or false, got ${JSON.stringify(rawValue)}`)\n}\n\n/** Runs browser commands across CLI and WebSocket transports. */\nexport default class BrowserCommandRunner {\n  /**\n   * @param {object} args\n   * @param {import(\"./browser.js\").default} args.browser\n   */\n  constructor({browser}) {\n    this.browser = browser\n  }\n\n  /**\n   * @param {Record<string, any>} commandArgs\n   * @returns {{timeout?: number}}\n   */\n  normalizeTimeoutArgs(commandArgs) {\n    const normalizedArgs = {}\n\n    if (\"timeout\" in commandArgs && commandArgs.timeout !== undefined) {\n      normalizedArgs.timeout = Number(commandArgs.timeout)\n\n      if (Number.isNaN(normalizedArgs.timeout)) {\n        throw new Error(`Invalid timeout: ${commandArgs.timeout}`)\n      }\n    }\n\n    return normalizedArgs\n  }\n\n  /**\n   * @param {Record<string, any>} commandArgs\n   * @returns {import(\"./system-test.js\").FindArgs}\n   */\n  normalizeFindArgs(commandArgs) {\n    const findArgs = /** @type {import(\"./system-test.js\").FindArgs} */ (this.normalizeTimeoutArgs(commandArgs))\n\n    if (\"visible\" in commandArgs && commandArgs.visible !== undefined) {\n      if (commandArgs.visible === null || commandArgs.visible === \"null\") {\n        findArgs.visible = null\n      } else if (typeof commandArgs.visible === \"boolean\") {\n        findArgs.visible = commandArgs.visible\n      } else {\n        findArgs.visible = commandArgs.visible === \"true\"\n      }\n    }\n\n    if (\"useBaseSelector\" in commandArgs && commandArgs.useBaseSelector !== undefined) {\n      if (typeof commandArgs.useBaseSelector === \"boolean\") {\n        findArgs.useBaseSelector = commandArgs.useBaseSelector\n      } else {\n        findArgs.useBaseSelector = commandArgs.useBaseSelector === \"true\"\n      }\n    }\n\n    if (\"scrollTo\" in commandArgs && commandArgs.scrollTo !== undefined) {\n      if (typeof commandArgs.scrollTo === \"boolean\") {\n        findArgs.scrollTo = commandArgs.scrollTo\n      } else {\n        findArgs.scrollTo = commandArgs.scrollTo === \"true\"\n      }\n    }\n\n    return findArgs\n  }\n\n  /**\n   * @param {import(\"selenium-webdriver\").WebElement} element\n   * @returns {Promise<Record<string, any>>}\n   */\n  async serializeElement(element) {\n    const text = await element.getText()\n    const tagName = await element.getTagName()\n    const displayed = await element.isDisplayed()\n\n    return {displayed, tagName, text}\n  }\n\n  /**\n   * @param {string} command\n   * @param {Record<string, any>} commandArgs\n   * @returns {Promise<any>}\n   */\n  async run(command, commandArgs = {}) {\n    if (command === \"visit\") {\n      const path = commandArgs.path ?? commandArgs.url\n\n      if (!path) {\n        throw new Error(\"visit requires path or url\")\n      }\n\n      await this.browser.visit(path, this.normalizeTimeoutArgs(commandArgs))\n      return {ok: true}\n    }\n\n    if (command === \"dismissTo\") {\n      const path = commandArgs.path ?? commandArgs.url\n\n      if (!path) {\n        throw new Error(\"dismissTo requires path or url\")\n      }\n\n      await this.browser.dismissTo(path, this.normalizeTimeoutArgs(commandArgs))\n      return {ok: true}\n    }\n\n    if (command === \"setBaseSelector\") {\n      if (!commandArgs.selector) {\n        throw new Error(\"setBaseSelector requires selector\")\n      }\n\n      this.browser.setBaseSelector(commandArgs.selector)\n      return {ok: true}\n    }\n\n    if (command === \"getCurrentUrl\") {\n      return {currentUrl: await this.browser.getCurrentUrl()}\n    }\n\n    if (command === \"getHTML\") {\n      return {html: await this.browser.getHTML()}\n    }\n\n    if (command === \"getBrowserLogs\") {\n      return {logs: await this.browser.getBrowserLogs()}\n    }\n\n    if (command === \"takeScreenshot\") {\n      return await this.browser.takeScreenshot()\n    }\n\n    if (command === \"find\") {\n      if (!commandArgs.selector) {\n        throw new Error(\"find requires selector\")\n      }\n\n      const element = await this.browser.find(commandArgs.selector, this.normalizeFindArgs(commandArgs))\n\n      return {element: await this.serializeElement(element)}\n    }\n\n    if (command === \"findByTestID\") {\n      const testID = commandArgs.testID ?? commandArgs.testId\n\n      if (!testID) {\n        throw new Error(\"findByTestID requires testID\")\n      }\n\n      const element = await this.browser.findByTestID(testID, this.normalizeFindArgs(commandArgs))\n\n      return {element: await this.serializeElement(element)}\n    }\n\n    if (command === \"click\") {\n      const selector = commandArgs.selector\n\n      if (!selector) {\n        throw new Error(\"click requires selector\")\n      }\n\n      await this.browser.click(selector, this.normalizeFindArgs(commandArgs))\n      return {ok: true}\n    }\n\n    if (command === \"waitForNoSelector\") {\n      if (!commandArgs.selector) {\n        throw new Error(\"waitForNoSelector requires selector\")\n      }\n\n      await this.browser.waitForNoSelector(commandArgs.selector, this.normalizeFindArgs(commandArgs))\n      return {ok: true}\n    }\n\n    if (command === \"expectNoElement\") {\n      if (!commandArgs.selector) {\n        throw new Error(\"expectNoElement requires selector\")\n      }\n\n      await this.browser.expectNoElement(commandArgs.selector, this.normalizeFindArgs(commandArgs))\n      return {ok: true}\n    }\n\n    if (command === \"executeScript\") {\n      const script = commandArgs.script\n\n      if (typeof script !== \"string\" || script.length === 0) {\n        throw new Error(\"executeScript requires script\")\n      }\n\n      const scriptArgs = Array.isArray(commandArgs.args) ? commandArgs.args : []\n      const result = await this.browser.executeScript(script, ...scriptArgs)\n\n      return {result}\n    }\n\n    if (command === \"addCookie\") {\n      const name = commandArgs.name\n\n      if (typeof name !== \"string\" || name.length === 0) {\n        throw new Error(\"addCookie requires name\")\n      }\n\n      const value = commandArgs.value\n\n      if (typeof value !== \"string\") {\n        throw new Error(\"addCookie requires string value\")\n      }\n\n      /** @type {{name: string, value: string, domain?: string, path?: string, secure?: boolean, httpOnly?: boolean, expiry?: number, sameSite?: \"Strict\" | \"Lax\" | \"None\"}} */\n      const cookie = {name, value}\n\n      if (typeof commandArgs.domain === \"string\" && commandArgs.domain.length > 0) cookie.domain = commandArgs.domain\n      if (typeof commandArgs.path === \"string\" && commandArgs.path.length > 0) cookie.path = commandArgs.path\n      if (commandArgs.secure !== undefined) cookie.secure = parseCookieBoolean(\"secure\", commandArgs.secure)\n      if (commandArgs.httpOnly !== undefined) cookie.httpOnly = parseCookieBoolean(\"httpOnly\", commandArgs.httpOnly)\n      if (commandArgs.expiry !== undefined) cookie.expiry = Number(commandArgs.expiry)\n      if (typeof commandArgs.sameSite === \"string\") cookie.sameSite = /** @type {\"Strict\" | \"Lax\" | \"None\"} */ (commandArgs.sameSite)\n\n      await this.browser.addCookie(cookie)\n\n      return {ok: true}\n    }\n\n    if (command === \"interact\") {\n      const selector = commandArgs.selector\n      const methodName = commandArgs.methodName ?? commandArgs.method\n      const methodArgs = Array.isArray(commandArgs.args) ? commandArgs.args : []\n      const interactArgs = /** @type {{selector: string} & import(\"./system-test.js\").InteractArgs} */ ({selector, ...this.normalizeFindArgs(commandArgs)})\n\n      if (!selector) {\n        throw new Error(\"interact requires selector\")\n      }\n\n      if (!methodName) {\n        throw new Error(\"interact requires methodName\")\n      }\n\n      if (\"withFallback\" in commandArgs && commandArgs.withFallback !== undefined) {\n        if (typeof commandArgs.withFallback === \"boolean\") {\n          interactArgs.withFallback = commandArgs.withFallback\n        } else {\n          interactArgs.withFallback = commandArgs.withFallback === \"true\"\n        }\n      }\n\n      const result = await this.browser.interact(interactArgs, methodName, ...methodArgs)\n\n      return {result}\n    }\n\n    throw new Error(`Unknown browser command: ${command}`)\n  }\n}\n"]}

package/build/browser.d.ts

@@ -1,23 +1,3 @@
-/**
- * @typedef {object} BrowserArgs
- * @property {boolean} [debug] Enable debug logging.
- * @property {BrowserDriverConfig} [driver] Driver configuration.
- * @property {import("./system-test-communicator.js").default} [communicator] Optional command communicator for helper-driven navigation.
- * @property {string} [screenshotsPath] Directory used for saved screenshots and browser artifacts.
- */
-/**
- * @typedef {object} BrowserDriverConfig
- * @property {"selenium"|"appium"} [type] Driver implementation to use.
- * @property {Record<string, any>} [options] Driver-specific options.
- */
-/**
- * @typedef {object} BrowserNavigationArgs
- * @property {number} [timeout] Override the timeout for this navigation command.
- */
-/**
- * @typedef {object} BrowserPathWaitArgs
- * @property {number} [timeout] Override the timeout for this path wait.
- */
 /** Generic browser session wrapper around the configured driver. */
 export default class Browser {
     /** @param {BrowserArgs} [args] */
@@ -104,6 +84,27 @@ export default class Browser {
      * @returns {Promise<void>}
      */
     waitForPath(expectedPath: string, args?: BrowserPathWaitArgs): Promise<void>;
+    /**
+     * Waits until the current URL exactly matches the expected URL.
+     * @param {string} expectedUrl Exact URL expected.
+     * @param {BrowserCurrentUrlWaitArgs} [args] Optional timeout.
+     * @returns {Promise<void>}
+     */
+    waitForCurrentUrl(expectedUrl: string, args?: BrowserCurrentUrlWaitArgs): Promise<void>;
+    /**
+     * Waits until the current URL contains a fragment.
+     * @param {string} expectedFragment Fragment that should appear.
+     * @param {BrowserCurrentUrlWaitArgs} [args] Optional timeout.
+     * @returns {Promise<void>}
+     */
+    waitForUrlContains(expectedFragment: string, args?: BrowserCurrentUrlWaitArgs): Promise<void>;
+    /**
+     * Waits until the current URL does not contain a fragment.
+     * @param {string} unexpectedFragment Fragment that should disappear.
+     * @param {BrowserCurrentUrlWaitArgs} [args] Optional timeout.
+     * @returns {Promise<void>}
+     */
+    waitForUrlExcludes(unexpectedFragment: string, args?: BrowserCurrentUrlWaitArgs): Promise<void>;
     /**
      * @param {string} selector
      * @param {import("./system-test.js").FindArgs} [args]
@@ -152,6 +153,40 @@ export default class Browser {
     clearAndSendKeys(elementOrIdentifier: import("selenium-webdriver").WebElement | string | ({
         selector: string;
     } & import("./system-test.js").InteractArgs), nextValue: string): Promise<void>;
+    /**
+     * Replaces an input-like element's value by test id.
+     * @param {string} testID Field `data-testid` to target.
+     * @param {string} nextValue Text to leave in the field.
+     * @param {BrowserTestIDInputArgs} [args] Optional lookup timeout.
+     * @returns {Promise<void>}
+     */
+    replaceTestIDInputValue(testID: string, nextValue: string, args?: BrowserTestIDInputArgs): Promise<void>;
+    /**
+     * Waits until a test id contains expected visible text.
+     * @param {string} testID Element `data-testid` to inspect.
+     * @param {string} expectedText Fragment that must appear in the element text.
+     * @param {BrowserTextWaitArgs} [args] Optional timeout.
+     * @returns {Promise<void>}
+     */
+    waitForTestIDText(testID: string, expectedText: string, args?: BrowserTextWaitArgs): Promise<void>;
+    /**
+     * Waits until a test id no longer contains excluded visible text.
+     * @param {string} testID Element `data-testid` to inspect.
+     * @param {string} excludedText Fragment that should disappear from the element text.
+     * @param {BrowserTextWaitArgs} [args] Optional timeout.
+     * @returns {Promise<void>}
+     */
+    waitForTestIDTextExcludes(testID: string, excludedText: string, args?: BrowserTextWaitArgs): Promise<void>;
+    /**
+     * Asserts a rendered element has a CSS color from the expected palette.
+     * @param {string} testID Element `data-testid` to inspect.
+     * @param {string} propertyName CSS property to read.
+     * @param {string} expectedRgb Expected RGB fragment.
+     * @param {string} lightRgb Disallowed RGB fragment.
+     * @param {string} description Human-readable element description.
+     * @returns {Promise<void>}
+     */
+    expectTestIDCssColor(testID: string, propertyName: string, expectedRgb: string, lightRgb: string, description: string): Promise<void>;
     /**
      * Scrolls an element into view.
      * @param {import("selenium-webdriver").WebElement|string|{selector: string} & import("./system-test.js").FindArgs} elementOrIdentifier
@@ -194,6 +229,42 @@ export default class Browser {
     driverVisit(path: string): Promise<void>;
     /** @returns {Promise<void>} */
     deleteAllCookies(): Promise<void>;
+    /**
+     * Add a cookie to the active driver session for the current document
+     * origin. Useful when an out-of-band login (curl, fetch, etc.) returned
+     * a `Set-Cookie` value and the test needs the browser to start
+     * authenticated without driving the sign-in UI.
+     *
+     * The driver must already be on a page whose origin/domain matches the
+     * cookie domain, otherwise Selenium will reject the call.
+     * @param {{name: string, value: string, domain?: string, path?: string, secure?: boolean, httpOnly?: boolean, expiry?: number, sameSite?: "Strict" | "Lax" | "None"}} cookie
+     * @returns {Promise<void>}
+     */
+    addCookie(cookie: {
+        name: string;
+        value: string;
+        domain?: string;
+        path?: string;
+        secure?: boolean;
+        httpOnly?: boolean;
+        expiry?: number;
+        sameSite?: "Strict" | "Lax" | "None";
+    }): Promise<void>;
+    /**
+     * Run an arbitrary script in the active browser session and return the
+     * resolved value. `script` is the function body executed in the browser
+     * (`new Function("...")`-style); `args` are forwarded as `arguments[i]`.
+     * Asynchronous scripts must `return` a Promise, which Selenium awaits.
+     *
+     * Useful for verification flows that need to call into application code
+     * (e.g. `fetch("/development/sign-in", {...})`) without going through the
+     * UI, or to read browser state the existing finder/interact commands
+     * don't expose.
+     * @param {string} script
+     * @param {...any} args
+     * @returns {Promise<any>}
+     */
+    executeScript(script: string, ...args: any[]): Promise<any>;
     /**
      * @param {string} type
      * @param {string} path
@@ -282,3 +353,21 @@ export type BrowserPathWaitArgs = {
      */
     timeout?: number | undefined;
 };
+export type BrowserTextWaitArgs = {
+    /**
+     * Override the timeout for this text wait.
+     */
+    timeout?: number | undefined;
+};
+export type BrowserCurrentUrlWaitArgs = {
+    /**
+     * Override the timeout for this URL wait.
+     */
+    timeout?: number | undefined;
+};
+export type BrowserTestIDInputArgs = {
+    /**
+     * Override timeout for the input lookup.
+     */
+    timeout?: number | undefined;
+};

package/build/browser.js

@@ -27,6 +27,65 @@ import AppiumDriver from "./drivers/appium-driver.js";
  * @typedef {object} BrowserPathWaitArgs
  * @property {number} [timeout] Override the timeout for this path wait.
  */
+/**
+ * @typedef {object} BrowserTextWaitArgs
+ * @property {number} [timeout] Override the timeout for this text wait.
+ */
+/**
+ * @typedef {object} BrowserCurrentUrlWaitArgs
+ * @property {number} [timeout] Override the timeout for this URL wait.
+ */
+/**
+ * @typedef {object} BrowserTestIDInputArgs
+ * @property {number} [timeout] Override timeout for the input lookup.
+ */
+/**
+ * Builds a data-testid CSS selector.
+ * @param {string} testID Raw value from a `data-testid` attribute.
+ * @returns {string} CSS attribute selector.
+ */
+function testIdSelector(testID) {
+    return `[data-testid="${cssAttributeValue(testID)}"]`;
+}
+/**
+ * Escapes a value for use inside a double-quoted CSS attribute selector.
+ * @param {string | number} value Raw attribute value.
+ * @returns {string} Escaped selector value.
+ */
+function cssAttributeValue(value) {
+    return String(value).replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+/**
+ * Extracts the RGB channels from CSS `rgb(...)`/`rgba(...)` values or an RGB fragment.
+ * @param {string} value CSS color value or RGB fragment like `30, 41, 59`.
+ * @returns {[number, number, number] | undefined}
+ */
+function cssRgbChannels(value) {
+    const rgbMatch = value.match(/rgba?\(([^)]+)\)/);
+    const channelsValue = rgbMatch ? rgbMatch[1] : value;
+    const channels = channelsValue
+        .replace(/\s*\/.*$/, "")
+        .split(/[,\s]+/)
+        .filter(Boolean)
+        .slice(0, 3)
+        .map((channel) => Number(channel));
+    if (channels.length !== 3 || channels.some((channel) => !Number.isFinite(channel)))
+        return undefined;
+    return /** @type {[number, number, number]} */ (channels);
+}
+/**
+ * Checks whether a browser-normalized CSS color matches the RGB triplet.
+ * @param {string} actualValue Browser-normalized CSS color.
+ * @param {string} rgbFragment RGB fragment like `30, 41, 59`.
+ * @returns {boolean} Whether the RGB channels match.
+ */
+function cssValueMatchesRgb(actualValue, rgbFragment) {
+    const actualChannels = cssRgbChannels(actualValue);
+    const expectedChannels = cssRgbChannels(rgbFragment);
+    if (!actualChannels || !expectedChannels)
+        return false;
+    return actualChannels.every((actualChannel, index) => actualChannel === expectedChannels[index]);
+}
 /** Generic browser session wrapper around the configured driver. */
 export default class Browser {
     /** @param {BrowserArgs} [args] */
@@ -178,6 +237,48 @@ export default class Browser {
             }
         });
     }
+    /**
+     * Waits until the current URL exactly matches the expected URL.
+     * @param {string} expectedUrl Exact URL expected.
+     * @param {BrowserCurrentUrlWaitArgs} [args] Optional timeout.
+     * @returns {Promise<void>}
+     */
+    async waitForCurrentUrl(expectedUrl, args = {}) {
+        await waitFor({ timeout: this.getCommandTimeout(args.timeout) }, async () => {
+            const currentUrl = await this.getCurrentUrl();
+            if (currentUrl !== expectedUrl) {
+                throw new Error(`Timed out waiting for URL ${expectedUrl}. Current URL: ${currentUrl}`);
+            }
+        });
+    }
+    /**
+     * Waits until the current URL contains a fragment.
+     * @param {string} expectedFragment Fragment that should appear.
+     * @param {BrowserCurrentUrlWaitArgs} [args] Optional timeout.
+     * @returns {Promise<void>}
+     */
+    async waitForUrlContains(expectedFragment, args = {}) {
+        await waitFor({ timeout: this.getCommandTimeout(args.timeout) }, async () => {
+            const currentUrl = await this.getCurrentUrl();
+            if (!currentUrl.includes(expectedFragment)) {
+                throw new Error(`Timed out waiting for URL to include ${expectedFragment}. Current URL: ${currentUrl}`);
+            }
+        });
+    }
+    /**
+     * Waits until the current URL does not contain a fragment.
+     * @param {string} unexpectedFragment Fragment that should disappear.
+     * @param {BrowserCurrentUrlWaitArgs} [args] Optional timeout.
+     * @returns {Promise<void>}
+     */
+    async waitForUrlExcludes(unexpectedFragment, args = {}) {
+        await waitFor({ timeout: this.getCommandTimeout(args.timeout) }, async () => {
+            const currentUrl = await this.getCurrentUrl();
+            if (currentUrl.includes(unexpectedFragment)) {
+                throw new Error(`Timed out waiting for URL to exclude ${unexpectedFragment}. Current URL: ${currentUrl}`);
+            }
+        });
+    }
     /**
      * @param {string} selector
      * @param {import("./system-test.js").FindArgs} [args]
@@ -237,6 +338,71 @@ export default class Browser {
         await this.interact(elementOrIdentifier, "click");
         await this.interact(elementOrIdentifier, "sendKeys", Key.chord(Key.CONTROL, "a"), Key.BACK_SPACE, nextValue);
     }
+    /**
+     * Replaces an input-like element's value by test id.
+     * @param {string} testID Field `data-testid` to target.
+     * @param {string} nextValue Text to leave in the field.
+     * @param {BrowserTestIDInputArgs} [args] Optional lookup timeout.
+     * @returns {Promise<void>}
+     */
+    async replaceTestIDInputValue(testID, nextValue, args = {}) {
+        await this.clearAndSendKeys({
+            selector: testIdSelector(testID),
+            timeout: args.timeout,
+            withFallback: true
+        }, nextValue);
+    }
+    /**
+     * Waits until a test id contains expected visible text.
+     * @param {string} testID Element `data-testid` to inspect.
+     * @param {string} expectedText Fragment that must appear in the element text.
+     * @param {BrowserTextWaitArgs} [args] Optional timeout.
+     * @returns {Promise<void>}
+     */
+    async waitForTestIDText(testID, expectedText, args = {}) {
+        await waitFor({ timeout: this.getCommandTimeout(args.timeout) }, async () => {
+            const element = await this.findByTestID(testID, { timeout: 0 });
+            const actualText = await element.getText();
+            if (!actualText.includes(expectedText)) {
+                throw new Error(`Timed out waiting for text ${expectedText}. Last text was ${actualText}`);
+            }
+        });
+    }
+    /**
+     * Waits until a test id no longer contains excluded visible text.
+     * @param {string} testID Element `data-testid` to inspect.
+     * @param {string} excludedText Fragment that should disappear from the element text.
+     * @param {BrowserTextWaitArgs} [args] Optional timeout.
+     * @returns {Promise<void>}
+     */
+    async waitForTestIDTextExcludes(testID, excludedText, args = {}) {
+        await waitFor({ timeout: this.getCommandTimeout(args.timeout) }, async () => {
+            const element = await this.findByTestID(testID, { timeout: 0 });
+            const actualText = await element.getText();
+            if (actualText.includes(excludedText)) {
+                throw new Error(`Timed out waiting for text to exclude ${excludedText}. Last text was ${actualText}`);
+            }
+        });
+    }
+    /**
+     * Asserts a rendered element has a CSS color from the expected palette.
+     * @param {string} testID Element `data-testid` to inspect.
+     * @param {string} propertyName CSS property to read.
+     * @param {string} expectedRgb Expected RGB fragment.
+     * @param {string} lightRgb Disallowed RGB fragment.
+     * @param {string} description Human-readable element description.
+     * @returns {Promise<void>}
+     */
+    async expectTestIDCssColor(testID, propertyName, expectedRgb, lightRgb, description) {
+        const element = await this.findByTestID(testID);
+        const actualValue = await element.getCssValue(propertyName);
+        if (cssValueMatchesRgb(actualValue, lightRgb)) {
+            throw new Error(`Expected ${description} to avoid the light palette, got ${propertyName} ${actualValue}`);
+        }
+        if (!cssValueMatchesRgb(actualValue, expectedRgb)) {
+            throw new Error(`Expected ${description} to include rgb(${expectedRgb}), got ${propertyName} ${actualValue}`);
+        }
+    }
     /**
      * Scrolls an element into view.
      * @param {import("selenium-webdriver").WebElement|string|{selector: string} & import("./system-test.js").FindArgs} elementOrIdentifier
@@ -311,6 +477,46 @@ export default class Browser {
     async deleteAllCookies() {
         await this.getDriverAdapter().deleteAllCookies();
     }
+    /**
+     * Add a cookie to the active driver session for the current document
+     * origin. Useful when an out-of-band login (curl, fetch, etc.) returned
+     * a `Set-Cookie` value and the test needs the browser to start
+     * authenticated without driving the sign-in UI.
+     *
+     * The driver must already be on a page whose origin/domain matches the
+     * cookie domain, otherwise Selenium will reject the call.
+     * @param {{name: string, value: string, domain?: string, path?: string, secure?: boolean, httpOnly?: boolean, expiry?: number, sameSite?: "Strict" | "Lax" | "None"}} cookie
+     * @returns {Promise<void>}
+     */
+    async addCookie(cookie) {
+        if (!cookie || typeof cookie.name !== "string" || cookie.name.length === 0) {
+            throw new Error("addCookie requires a non-empty `name`");
+        }
+        if (typeof cookie.value !== "string") {
+            throw new Error("addCookie requires a string `value`");
+        }
+        await this.getDriver().manage().addCookie(cookie);
+    }
+    /**
+     * Run an arbitrary script in the active browser session and return the
+     * resolved value. `script` is the function body executed in the browser
+     * (`new Function("...")`-style); `args` are forwarded as `arguments[i]`.
+     * Asynchronous scripts must `return` a Promise, which Selenium awaits.
+     *
+     * Useful for verification flows that need to call into application code
+     * (e.g. `fetch("/development/sign-in", {...})`) without going through the
+     * UI, or to read browser state the existing finder/interact commands
+     * don't expose.
+     * @param {string} script
+     * @param {...any} args
+     * @returns {Promise<any>}
+     */
+    async executeScript(script, ...args) {
+        if (typeof script !== "string" || script.length === 0) {
+            throw new Error("executeScript requires a non-empty `script` string");
+        }
+        return await this.getDriver().executeScript(script, ...args);
+    }
     /**
      * @param {string} type
      * @param {string} path
@@ -425,4 +631,4 @@ export default class Browser {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"browser.js","sourceRoot":"","sources":["../src/browser.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport fs from \"node:fs/promises\"\nimport {Key} from \"selenium-webdriver\"\nimport moment from \"moment\"\nimport {prettify} from \"htmlfy\"\nimport {waitFor} from \"awaitery\"\nimport timeout from \"awaitery/build/timeout.js\"\nimport SeleniumDriver from \"./drivers/selenium-driver.js\"\nimport AppiumDriver from \"./drivers/appium-driver.js\"\n\n/**\n * @typedef {object} BrowserArgs\n * @property {boolean} [debug] Enable debug logging.\n * @property {BrowserDriverConfig} [driver] Driver configuration.\n * @property {import(\"./system-test-communicator.js\").default} [communicator] Optional command communicator for helper-driven navigation.\n * @property {string} [screenshotsPath] Directory used for saved screenshots and browser artifacts.\n */\n/**\n * @typedef {object} BrowserDriverConfig\n * @property {\"selenium\"|\"appium\"} [type] Driver implementation to use.\n * @property {Record<string, any>} [options] Driver-specific options.\n */\n/**\n * @typedef {object} BrowserNavigationArgs\n * @property {number} [timeout] Override the timeout for this navigation command.\n */\n/**\n * @typedef {object} BrowserPathWaitArgs\n * @property {number} [timeout] Override the timeout for this path wait.\n */\n\n/** Generic browser session wrapper around the configured driver. */\nexport default class Browser {\n  /** @type {import(\"selenium-webdriver\").WebDriver | undefined} */\n  driver = undefined\n\n  /** @type {import(\"./drivers/webdriver-driver.js\").default | undefined} */\n  driverAdapter = undefined\n\n  _debug = false\n  /** @type {BrowserDriverConfig | undefined} */\n  _driverConfig = undefined\n  /** @type {Error | undefined} */\n  _httpServerError = undefined\n\n  /** @param {BrowserArgs} [args] */\n  constructor({debug = false, driver, communicator, screenshotsPath = `${process.cwd()}/tmp/screenshots`, ...restArgs} = {}) {\n    const restArgsKeys = Object.keys(restArgs)\n\n    if (restArgsKeys.length > 0) {\n      throw new Error(`Unknown browser arguments: ${restArgsKeys.join(\", \")}`)\n    }\n\n    this._debug = debug\n    this._driverConfig = driver\n    this._screenshotsPath = screenshotsPath\n    this.communicator = communicator\n    this.driverAdapter = this.createDriver(driver)\n  }\n\n  /**\n   * @param {BrowserDriverConfig} [driverConfig]\n   * @returns {import(\"./drivers/webdriver-driver.js\").default}\n   */\n  createDriver(driverConfig = {}) {\n    const {type = \"selenium\", options, ...restArgs} = driverConfig\n    const restArgsKeys = Object.keys(restArgs)\n\n    if (restArgsKeys.length > 0) {\n      throw new Error(`Unknown driver args: ${restArgsKeys.join(\", \")}`)\n    }\n\n    if (type === \"selenium\") {\n      return new SeleniumDriver({browser: this, options})\n    }\n\n    if (type === \"appium\") {\n      return new AppiumDriver({browser: this, options})\n    }\n\n    throw new Error(`Unsupported driver type: ${type}`)\n  }\n\n  /**\n   * @param {import(\"./system-test-communicator.js\").default | undefined} communicator\n   * @returns {void}\n   */\n  setCommunicator(communicator) {\n    this.communicator = communicator\n  }\n\n  /** @returns {boolean} */\n  communicatorExists() {\n    return Boolean(this.communicator)\n  }\n\n  /**\n   * @param {string} baseSelector\n   * @returns {void}\n   */\n  setBaseSelector(baseSelector) { this._baseSelector = baseSelector }\n\n  /** @returns {string | undefined} */\n  getBaseSelector() { return this._baseSelector }\n\n  /**\n   * @param {string} selector\n   * @returns {string}\n   */\n  getSelector(selector) {\n    return this.getBaseSelector() ? `${this.getBaseSelector()} ${selector}` : selector\n  }\n\n  /**\n   * @param {...any} args\n   * @returns {void}\n   */\n  debugError(...args) {\n    console.error(\"[Browser error]\", ...args)\n  }\n\n  /**\n   * @param {...any} args\n   * @returns {void}\n   */\n  debugLog(...args) {\n    if (this._debug) {\n      console.log(\"[Browser debug]\", ...args)\n    }\n  }\n\n  /** @returns {void} */\n  throwIfHttpServerError() {\n    if (this._httpServerError) {\n      throw new Error(`HTTP server error: ${this._httpServerError.message}`)\n    }\n  }\n\n  /**\n   * @param {Error} error\n   * @returns {void}\n   */\n  onHttpServerError = (error) => {\n    const errorMessage = error instanceof Error ? error.message : String(error)\n\n    this._httpServerError = error instanceof Error ? error : new Error(errorMessage)\n    console.error(`HTTP server error: ${errorMessage}`)\n  }\n\n  /** @returns {import(\"selenium-webdriver\").WebDriver} */\n  getDriver() {\n    return this.getDriverAdapter().getWebDriver()\n  }\n\n  /** @returns {import(\"./drivers/webdriver-driver.js\").default} */\n  getDriverAdapter() {\n    if (!this.driverAdapter) {\n      throw new Error(\"Driver hasn't been initialized yet\")\n    }\n\n    return this.driverAdapter\n  }\n\n  /** @returns {number} */\n  getTimeouts() { return this.getDriverAdapter().getTimeouts() }\n\n  /** @returns {Promise<void>} */\n  async restoreTimeouts() {\n    await this.getDriverAdapter().restoreTimeouts()\n  }\n\n  /**\n   * @param {number} newTimeout\n   * @returns {Promise<void>}\n   */\n  async driverSetTimeouts(newTimeout) {\n    await this.getDriverAdapter().driverSetTimeouts(newTimeout)\n  }\n\n  /**\n   * @param {number} newTimeout\n   * @returns {Promise<void>}\n   */\n  async setTimeouts(newTimeout) {\n    await this.getDriverAdapter().setTimeouts(newTimeout)\n  }\n\n  /** @returns {Promise<string[]>} */\n  async getBrowserLogs() {\n    return await this.getDriverAdapter().getBrowserLogs()\n  }\n\n  /** @returns {Promise<string>} */\n  async getCurrentUrl() {\n    return await this.getDriverAdapter().getCurrentUrl()\n  }\n\n  /**\n   * Waits until the current URL pathname exactly matches the expected path.\n   * @param {string} expectedPath\n   * @param {BrowserPathWaitArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async waitForPath(expectedPath, args = {}) {\n    await waitFor({timeout: this.getCommandTimeout(args.timeout)}, async () => {\n      const currentUrl = await this.getCurrentUrl()\n      const currentPath = new URL(currentUrl).pathname\n\n      if (currentPath !== expectedPath) {\n        throw new Error(`Timed out waiting for path ${expectedPath}. Current URL: ${currentUrl}`)\n      }\n    })\n  }\n\n  /**\n   * @param {string} selector\n   * @param {import(\"./system-test.js\").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   * @param {string} selector\n   * @param {import(\"./system-test.js\").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   * @param {string} testID\n   * @param {import(\"./system-test.js\").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   * @param {string} selector\n   * @param {import(\"./system-test.js\").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   * @param {string | import(\"selenium-webdriver\").WebElement} elementOrIdentifier\n   * @param {import(\"./system-test.js\").FindArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async click(elementOrIdentifier, args) {\n    await this.getDriverAdapter().click(elementOrIdentifier, args)\n  }\n\n  /**\n   * @param {import(\"selenium-webdriver\").WebElement|string|{selector: string} & import(\"./system-test.js\").InteractArgs} elementOrIdentifier\n   * @param {string} methodName\n   * @param {...any} args\n   * @returns {Promise<any>}\n   */\n  async interact(elementOrIdentifier, methodName, ...args) {\n    return await this.getDriverAdapter().interact(elementOrIdentifier, methodName, ...args)\n  }\n\n  /**\n   * Clears an input and sends replacement keys through retryable browser interactions.\n   * @param {import(\"selenium-webdriver\").WebElement|string|{selector: string} & import(\"./system-test.js\").InteractArgs} elementOrIdentifier\n   * @param {string} nextValue\n   * @returns {Promise<void>}\n   */\n  async clearAndSendKeys(elementOrIdentifier, nextValue) {\n    await this.interact(elementOrIdentifier, \"click\")\n    await this.interact(elementOrIdentifier, \"sendKeys\", Key.chord(Key.CONTROL, \"a\"), Key.BACK_SPACE, nextValue)\n  }\n\n  /**\n   * Scrolls an element into view.\n   * @param {import(\"selenium-webdriver\").WebElement|string|{selector: string} & import(\"./system-test.js\").FindArgs} elementOrIdentifier\n   * @param {import(\"./system-test.js\").FindArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async scrollIntoView(elementOrIdentifier, args) {\n    await this.getDriverAdapter().scrollIntoView(elementOrIdentifier, args)\n  }\n\n  /**\n   * Scrolls the element with the given test ID into view.\n   * @param {string} testID\n   * @param {import(\"./system-test.js\").FindArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async scrollTestIdIntoView(testID, args) {\n    await this.getDriverAdapter().scrollTestIdIntoView(testID, args)\n  }\n\n  /**\n   * @param {string} selector\n   * @param {import(\"./system-test.js\").WaitForNoSelectorArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async waitForNoSelector(selector, args = {}) {\n    await this.getDriverAdapter().waitForNoSelector(selector, args)\n  }\n\n  /**\n   * @param {string} selector\n   * @param {import(\"./system-test.js\").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  /** @returns {Promise<string>} */\n  async getHTML() {\n    return await this.getDriverAdapter().getHTML()\n  }\n\n  /**\n   * @param {number | undefined} timeoutOverride\n   * @returns {number}\n   */\n  getCommandTimeout(timeoutOverride) {\n    if (timeoutOverride !== undefined) {\n      return timeoutOverride\n    }\n\n    return this.getTimeouts()\n  }\n\n  /**\n   * @param {string} path\n   * @returns {Promise<void>}\n   */\n  async driverVisit(path) {\n    await this.getDriverAdapter().driverVisit(path)\n  }\n\n  /** @returns {Promise<void>} */\n  async deleteAllCookies() {\n    await this.getDriverAdapter().deleteAllCookies()\n  }\n\n  /**\n   * @param {string} type\n   * @param {string} path\n   * @param {BrowserNavigationArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async sendBrowserCommand(type, path, args = {}) {\n    if (!this.communicator) {\n      throw new Error(\"Communicator hasn't been initialized yet\")\n    }\n\n    await timeout(\n      {timeout: this.getCommandTimeout(args.timeout), errorMessage: `timeout while sending browser command ${type}: ${path}`},\n      async () => await /** @type {NonNullable<typeof this.communicator>} */ (this.communicator).sendCommand({type, path})\n    )\n  }\n\n  /**\n   * Visits a path using the injected browser helper when available, otherwise navigates directly with the driver.\n   * @param {string} path\n   * @param {BrowserNavigationArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async visit(path, args = {}) {\n    if (this.communicatorExists() && (!this.communicator?.ws || this.communicator.ws.readyState === 1)) {\n      await this.sendBrowserCommand(\"visit\", path, args)\n    } else {\n      await timeout(\n        {timeout: this.getCommandTimeout(args.timeout), errorMessage: `timeout while visiting path: ${path}`},\n        async () => await this.driverVisit(path)\n      )\n    }\n  }\n\n  /**\n   * Dismisses to a path via the injected browser helper when available, otherwise navigates directly with the driver.\n   * @param {string} path\n   * @param {BrowserNavigationArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async dismissTo(path, args = {}) {\n    if (this.communicatorExists() && (!this.communicator?.ws || this.communicator.ws.readyState === 1)) {\n      await this.sendBrowserCommand(\"dismissTo\", path, args)\n    } else {\n      await timeout(\n        {timeout: this.getCommandTimeout(args.timeout), errorMessage: `timeout while dismissing to path: ${path}`},\n        async () => await this.driverVisit(path)\n      )\n    }\n  }\n\n  /**\n   * Formats browser logs for console output and truncates overly long output.\n   * @param {string[]} logs\n   * @param {number} [maxLines]\n   * @returns {string[]}\n   */\n  formatBrowserLogsForConsole(logs, maxLines = 200) {\n    if (!Array.isArray(logs) || logs.length === 0) {\n      return [\"(no browser logs)\"]\n    }\n\n    if (logs.length <= maxLines) {\n      return logs\n    }\n\n    const keptLogs = logs.slice(logs.length - maxLines)\n    const hiddenCount = logs.length - maxLines\n\n    return [`(showing last ${maxLines} of ${logs.length} browser logs, ${hiddenCount} omitted)`, ...keptLogs]\n  }\n\n  /**\n   * @param {string[]} logs\n   * @returns {void}\n   */\n  printBrowserLogsForFailure(logs) {\n    console.log(\"Browser logs:\")\n\n    for (const line of this.formatBrowserLogsForConsole(logs)) {\n      console.log(line)\n    }\n  }\n\n  /**\n   * Takes a screenshot, writes HTML/browser logs to disk, and returns the collected artifacts.\n   * @returns {Promise<{currentUrl: string, html: string, htmlPath: string, logs: string[], logsPath: string, screenshotPath: string}>}\n   */\n  async takeScreenshot() {\n    this.debugLog(\"Getting path for screenshots\")\n    const path = this._screenshotsPath\n\n    this.debugLog(`Creating dir with recursive: ${path}`)\n    await fs.mkdir(path, {recursive: true})\n\n    this.debugLog(\"Getting screenshot image content\")\n    const imageContent = await timeout({timeout: 5000, errorMessage: \"timeout while taking screenshot\"}, async () => await this.getDriverAdapter().takeScreenshot())\n\n    this.debugLog(\"Generating date variables\")\n    const now = new Date()\n    const timestamp = moment(now).format(\"YYYY-MM-DD-HH-MM-SS\")\n    const screenshotPath = `${path}/${timestamp}.png`\n    const htmlPath = `${path}/${timestamp}.html`\n    const logsPath = `${path}/${timestamp}.logs.txt`\n\n    this.debugLog(\"Getting browser logs\")\n    const logs = await timeout({timeout: 5000, errorMessage: \"timeout while reading browser logs\"}, async () => await this.getBrowserLogs())\n    const html = await timeout({timeout: 5000, errorMessage: \"timeout while reading page HTML\"}, async () => await this.getHTML())\n    const htmlPretty = prettify(html)\n    this.printBrowserLogsForFailure(logs)\n\n    this.debugLog(\"Writing files\")\n    await fs.writeFile(htmlPath, htmlPretty)\n    await fs.writeFile(logsPath, logs.join(\"\\n\"))\n    await fs.writeFile(screenshotPath, imageContent, \"base64\")\n\n    const currentUrl = await this.getCurrentUrl()\n\n    console.log(\"Current URL:\", currentUrl)\n    console.log(\"Logs:\", logsPath)\n    console.log(\"Screenshot:\", screenshotPath)\n    console.log(\"HTML:\", htmlPath)\n\n    return {\n      currentUrl,\n      html,\n      htmlPath,\n      logs,\n      logsPath,\n      screenshotPath\n    }\n  }\n\n  /** @returns {Promise<void>} */\n  async stopDriver() {\n    if (this.driverAdapter) {\n      await this.driverAdapter.stop()\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"browser.js","sourceRoot":"","sources":["../src/browser.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport fs from \"node:fs/promises\"\nimport {Key} from \"selenium-webdriver\"\nimport moment from \"moment\"\nimport {prettify} from \"htmlfy\"\nimport {waitFor} from \"awaitery\"\nimport timeout from \"awaitery/build/timeout.js\"\nimport SeleniumDriver from \"./drivers/selenium-driver.js\"\nimport AppiumDriver from \"./drivers/appium-driver.js\"\n\n/**\n * @typedef {object} BrowserArgs\n * @property {boolean} [debug] Enable debug logging.\n * @property {BrowserDriverConfig} [driver] Driver configuration.\n * @property {import(\"./system-test-communicator.js\").default} [communicator] Optional command communicator for helper-driven navigation.\n * @property {string} [screenshotsPath] Directory used for saved screenshots and browser artifacts.\n */\n/**\n * @typedef {object} BrowserDriverConfig\n * @property {\"selenium\"|\"appium\"} [type] Driver implementation to use.\n * @property {Record<string, any>} [options] Driver-specific options.\n */\n/**\n * @typedef {object} BrowserNavigationArgs\n * @property {number} [timeout] Override the timeout for this navigation command.\n */\n/**\n * @typedef {object} BrowserPathWaitArgs\n * @property {number} [timeout] Override the timeout for this path wait.\n */\n/**\n * @typedef {object} BrowserTextWaitArgs\n * @property {number} [timeout] Override the timeout for this text wait.\n */\n/**\n * @typedef {object} BrowserCurrentUrlWaitArgs\n * @property {number} [timeout] Override the timeout for this URL wait.\n */\n/**\n * @typedef {object} BrowserTestIDInputArgs\n * @property {number} [timeout] Override timeout for the input lookup.\n */\n\n/**\n * Builds a data-testid CSS selector.\n * @param {string} testID Raw value from a `data-testid` attribute.\n * @returns {string} CSS attribute selector.\n */\nfunction testIdSelector(testID) {\n  return `[data-testid=\"${cssAttributeValue(testID)}\"]`\n}\n\n/**\n * Escapes a value for use inside a double-quoted CSS attribute selector.\n * @param {string | number} value Raw attribute value.\n * @returns {string} Escaped selector value.\n */\nfunction cssAttributeValue(value) {\n  return String(value).replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, \"\\\\\\\"\")\n}\n\n/**\n * Extracts the RGB channels from CSS `rgb(...)`/`rgba(...)` values or an RGB fragment.\n * @param {string} value CSS color value or RGB fragment like `30, 41, 59`.\n * @returns {[number, number, number] | undefined}\n */\nfunction cssRgbChannels(value) {\n  const rgbMatch = value.match(/rgba?\\(([^)]+)\\)/)\n  const channelsValue = rgbMatch ? rgbMatch[1] : value\n  const channels = channelsValue\n    .replace(/\\s*\\/.*$/, \"\")\n    .split(/[,\\s]+/)\n    .filter(Boolean)\n    .slice(0, 3)\n    .map((channel) => Number(channel))\n\n  if (channels.length !== 3 || channels.some((channel) => !Number.isFinite(channel))) return undefined\n\n  return /** @type {[number, number, number]} */ (channels)\n}\n\n/**\n * Checks whether a browser-normalized CSS color matches the RGB triplet.\n * @param {string} actualValue Browser-normalized CSS color.\n * @param {string} rgbFragment RGB fragment like `30, 41, 59`.\n * @returns {boolean} Whether the RGB channels match.\n */\nfunction cssValueMatchesRgb(actualValue, rgbFragment) {\n  const actualChannels = cssRgbChannels(actualValue)\n  const expectedChannels = cssRgbChannels(rgbFragment)\n\n  if (!actualChannels || !expectedChannels) return false\n\n  return actualChannels.every((actualChannel, index) => actualChannel === expectedChannels[index])\n}\n\n/** Generic browser session wrapper around the configured driver. */\nexport default class Browser {\n  /** @type {import(\"selenium-webdriver\").WebDriver | undefined} */\n  driver = undefined\n\n  /** @type {import(\"./drivers/webdriver-driver.js\").default | undefined} */\n  driverAdapter = undefined\n\n  _debug = false\n  /** @type {BrowserDriverConfig | undefined} */\n  _driverConfig = undefined\n  /** @type {Error | undefined} */\n  _httpServerError = undefined\n\n  /** @param {BrowserArgs} [args] */\n  constructor({debug = false, driver, communicator, screenshotsPath = `${process.cwd()}/tmp/screenshots`, ...restArgs} = {}) {\n    const restArgsKeys = Object.keys(restArgs)\n\n    if (restArgsKeys.length > 0) {\n      throw new Error(`Unknown browser arguments: ${restArgsKeys.join(\", \")}`)\n    }\n\n    this._debug = debug\n    this._driverConfig = driver\n    this._screenshotsPath = screenshotsPath\n    this.communicator = communicator\n    this.driverAdapter = this.createDriver(driver)\n  }\n\n  /**\n   * @param {BrowserDriverConfig} [driverConfig]\n   * @returns {import(\"./drivers/webdriver-driver.js\").default}\n   */\n  createDriver(driverConfig = {}) {\n    const {type = \"selenium\", options, ...restArgs} = driverConfig\n    const restArgsKeys = Object.keys(restArgs)\n\n    if (restArgsKeys.length > 0) {\n      throw new Error(`Unknown driver args: ${restArgsKeys.join(\", \")}`)\n    }\n\n    if (type === \"selenium\") {\n      return new SeleniumDriver({browser: this, options})\n    }\n\n    if (type === \"appium\") {\n      return new AppiumDriver({browser: this, options})\n    }\n\n    throw new Error(`Unsupported driver type: ${type}`)\n  }\n\n  /**\n   * @param {import(\"./system-test-communicator.js\").default | undefined} communicator\n   * @returns {void}\n   */\n  setCommunicator(communicator) {\n    this.communicator = communicator\n  }\n\n  /** @returns {boolean} */\n  communicatorExists() {\n    return Boolean(this.communicator)\n  }\n\n  /**\n   * @param {string} baseSelector\n   * @returns {void}\n   */\n  setBaseSelector(baseSelector) { this._baseSelector = baseSelector }\n\n  /** @returns {string | undefined} */\n  getBaseSelector() { return this._baseSelector }\n\n  /**\n   * @param {string} selector\n   * @returns {string}\n   */\n  getSelector(selector) {\n    return this.getBaseSelector() ? `${this.getBaseSelector()} ${selector}` : selector\n  }\n\n  /**\n   * @param {...any} args\n   * @returns {void}\n   */\n  debugError(...args) {\n    console.error(\"[Browser error]\", ...args)\n  }\n\n  /**\n   * @param {...any} args\n   * @returns {void}\n   */\n  debugLog(...args) {\n    if (this._debug) {\n      console.log(\"[Browser debug]\", ...args)\n    }\n  }\n\n  /** @returns {void} */\n  throwIfHttpServerError() {\n    if (this._httpServerError) {\n      throw new Error(`HTTP server error: ${this._httpServerError.message}`)\n    }\n  }\n\n  /**\n   * @param {Error} error\n   * @returns {void}\n   */\n  onHttpServerError = (error) => {\n    const errorMessage = error instanceof Error ? error.message : String(error)\n\n    this._httpServerError = error instanceof Error ? error : new Error(errorMessage)\n    console.error(`HTTP server error: ${errorMessage}`)\n  }\n\n  /** @returns {import(\"selenium-webdriver\").WebDriver} */\n  getDriver() {\n    return this.getDriverAdapter().getWebDriver()\n  }\n\n  /** @returns {import(\"./drivers/webdriver-driver.js\").default} */\n  getDriverAdapter() {\n    if (!this.driverAdapter) {\n      throw new Error(\"Driver hasn't been initialized yet\")\n    }\n\n    return this.driverAdapter\n  }\n\n  /** @returns {number} */\n  getTimeouts() { return this.getDriverAdapter().getTimeouts() }\n\n  /** @returns {Promise<void>} */\n  async restoreTimeouts() {\n    await this.getDriverAdapter().restoreTimeouts()\n  }\n\n  /**\n   * @param {number} newTimeout\n   * @returns {Promise<void>}\n   */\n  async driverSetTimeouts(newTimeout) {\n    await this.getDriverAdapter().driverSetTimeouts(newTimeout)\n  }\n\n  /**\n   * @param {number} newTimeout\n   * @returns {Promise<void>}\n   */\n  async setTimeouts(newTimeout) {\n    await this.getDriverAdapter().setTimeouts(newTimeout)\n  }\n\n  /** @returns {Promise<string[]>} */\n  async getBrowserLogs() {\n    return await this.getDriverAdapter().getBrowserLogs()\n  }\n\n  /** @returns {Promise<string>} */\n  async getCurrentUrl() {\n    return await this.getDriverAdapter().getCurrentUrl()\n  }\n\n  /**\n   * Waits until the current URL pathname exactly matches the expected path.\n   * @param {string} expectedPath\n   * @param {BrowserPathWaitArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async waitForPath(expectedPath, args = {}) {\n    await waitFor({timeout: this.getCommandTimeout(args.timeout)}, async () => {\n      const currentUrl = await this.getCurrentUrl()\n      const currentPath = new URL(currentUrl).pathname\n\n      if (currentPath !== expectedPath) {\n        throw new Error(`Timed out waiting for path ${expectedPath}. Current URL: ${currentUrl}`)\n      }\n    })\n  }\n\n  /**\n   * Waits until the current URL exactly matches the expected URL.\n   * @param {string} expectedUrl Exact URL expected.\n   * @param {BrowserCurrentUrlWaitArgs} [args] Optional timeout.\n   * @returns {Promise<void>}\n   */\n  async waitForCurrentUrl(expectedUrl, args = {}) {\n    await waitFor({timeout: this.getCommandTimeout(args.timeout)}, async () => {\n      const currentUrl = await this.getCurrentUrl()\n\n      if (currentUrl !== expectedUrl) {\n        throw new Error(`Timed out waiting for URL ${expectedUrl}. Current URL: ${currentUrl}`)\n      }\n    })\n  }\n\n  /**\n   * Waits until the current URL contains a fragment.\n   * @param {string} expectedFragment Fragment that should appear.\n   * @param {BrowserCurrentUrlWaitArgs} [args] Optional timeout.\n   * @returns {Promise<void>}\n   */\n  async waitForUrlContains(expectedFragment, args = {}) {\n    await waitFor({timeout: this.getCommandTimeout(args.timeout)}, async () => {\n      const currentUrl = await this.getCurrentUrl()\n\n      if (!currentUrl.includes(expectedFragment)) {\n        throw new Error(`Timed out waiting for URL to include ${expectedFragment}. Current URL: ${currentUrl}`)\n      }\n    })\n  }\n\n  /**\n   * Waits until the current URL does not contain a fragment.\n   * @param {string} unexpectedFragment Fragment that should disappear.\n   * @param {BrowserCurrentUrlWaitArgs} [args] Optional timeout.\n   * @returns {Promise<void>}\n   */\n  async waitForUrlExcludes(unexpectedFragment, args = {}) {\n    await waitFor({timeout: this.getCommandTimeout(args.timeout)}, async () => {\n      const currentUrl = await this.getCurrentUrl()\n\n      if (currentUrl.includes(unexpectedFragment)) {\n        throw new Error(`Timed out waiting for URL to exclude ${unexpectedFragment}. Current URL: ${currentUrl}`)\n      }\n    })\n  }\n\n  /**\n   * @param {string} selector\n   * @param {import(\"./system-test.js\").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   * @param {string} selector\n   * @param {import(\"./system-test.js\").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   * @param {string} testID\n   * @param {import(\"./system-test.js\").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   * @param {string} selector\n   * @param {import(\"./system-test.js\").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   * @param {string | import(\"selenium-webdriver\").WebElement} elementOrIdentifier\n   * @param {import(\"./system-test.js\").FindArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async click(elementOrIdentifier, args) {\n    await this.getDriverAdapter().click(elementOrIdentifier, args)\n  }\n\n  /**\n   * @param {import(\"selenium-webdriver\").WebElement|string|{selector: string} & import(\"./system-test.js\").InteractArgs} elementOrIdentifier\n   * @param {string} methodName\n   * @param {...any} args\n   * @returns {Promise<any>}\n   */\n  async interact(elementOrIdentifier, methodName, ...args) {\n    return await this.getDriverAdapter().interact(elementOrIdentifier, methodName, ...args)\n  }\n\n  /**\n   * Clears an input and sends replacement keys through retryable browser interactions.\n   * @param {import(\"selenium-webdriver\").WebElement|string|{selector: string} & import(\"./system-test.js\").InteractArgs} elementOrIdentifier\n   * @param {string} nextValue\n   * @returns {Promise<void>}\n   */\n  async clearAndSendKeys(elementOrIdentifier, nextValue) {\n    await this.interact(elementOrIdentifier, \"click\")\n    await this.interact(elementOrIdentifier, \"sendKeys\", Key.chord(Key.CONTROL, \"a\"), Key.BACK_SPACE, nextValue)\n  }\n\n  /**\n   * Replaces an input-like element's value by test id.\n   * @param {string} testID Field `data-testid` to target.\n   * @param {string} nextValue Text to leave in the field.\n   * @param {BrowserTestIDInputArgs} [args] Optional lookup timeout.\n   * @returns {Promise<void>}\n   */\n  async replaceTestIDInputValue(testID, nextValue, args = {}) {\n    await this.clearAndSendKeys({\n      selector: testIdSelector(testID),\n      timeout: args.timeout,\n      withFallback: true\n    }, nextValue)\n  }\n\n  /**\n   * Waits until a test id contains expected visible text.\n   * @param {string} testID Element `data-testid` to inspect.\n   * @param {string} expectedText Fragment that must appear in the element text.\n   * @param {BrowserTextWaitArgs} [args] Optional timeout.\n   * @returns {Promise<void>}\n   */\n  async waitForTestIDText(testID, expectedText, args = {}) {\n    await waitFor({timeout: this.getCommandTimeout(args.timeout)}, async () => {\n      const element = await this.findByTestID(testID, {timeout: 0})\n      const actualText = await element.getText()\n\n      if (!actualText.includes(expectedText)) {\n        throw new Error(`Timed out waiting for text ${expectedText}. Last text was ${actualText}`)\n      }\n    })\n  }\n\n  /**\n   * Waits until a test id no longer contains excluded visible text.\n   * @param {string} testID Element `data-testid` to inspect.\n   * @param {string} excludedText Fragment that should disappear from the element text.\n   * @param {BrowserTextWaitArgs} [args] Optional timeout.\n   * @returns {Promise<void>}\n   */\n  async waitForTestIDTextExcludes(testID, excludedText, args = {}) {\n    await waitFor({timeout: this.getCommandTimeout(args.timeout)}, async () => {\n      const element = await this.findByTestID(testID, {timeout: 0})\n      const actualText = await element.getText()\n\n      if (actualText.includes(excludedText)) {\n        throw new Error(`Timed out waiting for text to exclude ${excludedText}. Last text was ${actualText}`)\n      }\n    })\n  }\n\n  /**\n   * Asserts a rendered element has a CSS color from the expected palette.\n   * @param {string} testID Element `data-testid` to inspect.\n   * @param {string} propertyName CSS property to read.\n   * @param {string} expectedRgb Expected RGB fragment.\n   * @param {string} lightRgb Disallowed RGB fragment.\n   * @param {string} description Human-readable element description.\n   * @returns {Promise<void>}\n   */\n  async expectTestIDCssColor(testID, propertyName, expectedRgb, lightRgb, description) {\n    const element = await this.findByTestID(testID)\n    const actualValue = await element.getCssValue(propertyName)\n\n    if (cssValueMatchesRgb(actualValue, lightRgb)) {\n      throw new Error(`Expected ${description} to avoid the light palette, got ${propertyName} ${actualValue}`)\n    }\n    if (!cssValueMatchesRgb(actualValue, expectedRgb)) {\n      throw new Error(`Expected ${description} to include rgb(${expectedRgb}), got ${propertyName} ${actualValue}`)\n    }\n  }\n\n  /**\n   * Scrolls an element into view.\n   * @param {import(\"selenium-webdriver\").WebElement|string|{selector: string} & import(\"./system-test.js\").FindArgs} elementOrIdentifier\n   * @param {import(\"./system-test.js\").FindArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async scrollIntoView(elementOrIdentifier, args) {\n    await this.getDriverAdapter().scrollIntoView(elementOrIdentifier, args)\n  }\n\n  /**\n   * Scrolls the element with the given test ID into view.\n   * @param {string} testID\n   * @param {import(\"./system-test.js\").FindArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async scrollTestIdIntoView(testID, args) {\n    await this.getDriverAdapter().scrollTestIdIntoView(testID, args)\n  }\n\n  /**\n   * @param {string} selector\n   * @param {import(\"./system-test.js\").WaitForNoSelectorArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async waitForNoSelector(selector, args = {}) {\n    await this.getDriverAdapter().waitForNoSelector(selector, args)\n  }\n\n  /**\n   * @param {string} selector\n   * @param {import(\"./system-test.js\").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  /** @returns {Promise<string>} */\n  async getHTML() {\n    return await this.getDriverAdapter().getHTML()\n  }\n\n  /**\n   * @param {number | undefined} timeoutOverride\n   * @returns {number}\n   */\n  getCommandTimeout(timeoutOverride) {\n    if (timeoutOverride !== undefined) {\n      return timeoutOverride\n    }\n\n    return this.getTimeouts()\n  }\n\n  /**\n   * @param {string} path\n   * @returns {Promise<void>}\n   */\n  async driverVisit(path) {\n    await this.getDriverAdapter().driverVisit(path)\n  }\n\n  /** @returns {Promise<void>} */\n  async deleteAllCookies() {\n    await this.getDriverAdapter().deleteAllCookies()\n  }\n\n  /**\n   * Add a cookie to the active driver session for the current document\n   * origin. Useful when an out-of-band login (curl, fetch, etc.) returned\n   * a `Set-Cookie` value and the test needs the browser to start\n   * authenticated without driving the sign-in UI.\n   *\n   * The driver must already be on a page whose origin/domain matches the\n   * cookie domain, otherwise Selenium will reject the call.\n   * @param {{name: string, value: string, domain?: string, path?: string, secure?: boolean, httpOnly?: boolean, expiry?: number, sameSite?: \"Strict\" | \"Lax\" | \"None\"}} cookie\n   * @returns {Promise<void>}\n   */\n  async addCookie(cookie) {\n    if (!cookie || typeof cookie.name !== \"string\" || cookie.name.length === 0) {\n      throw new Error(\"addCookie requires a non-empty `name`\")\n    }\n\n    if (typeof cookie.value !== \"string\") {\n      throw new Error(\"addCookie requires a string `value`\")\n    }\n\n    await this.getDriver().manage().addCookie(cookie)\n  }\n\n  /**\n   * Run an arbitrary script in the active browser session and return the\n   * resolved value. `script` is the function body executed in the browser\n   * (`new Function(\"...\")`-style); `args` are forwarded as `arguments[i]`.\n   * Asynchronous scripts must `return` a Promise, which Selenium awaits.\n   *\n   * Useful for verification flows that need to call into application code\n   * (e.g. `fetch(\"/development/sign-in\", {...})`) without going through the\n   * UI, or to read browser state the existing finder/interact commands\n   * don't expose.\n   * @param {string} script\n   * @param {...any} args\n   * @returns {Promise<any>}\n   */\n  async executeScript(script, ...args) {\n    if (typeof script !== \"string\" || script.length === 0) {\n      throw new Error(\"executeScript requires a non-empty `script` string\")\n    }\n\n    return await this.getDriver().executeScript(script, ...args)\n  }\n\n  /**\n   * @param {string} type\n   * @param {string} path\n   * @param {BrowserNavigationArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async sendBrowserCommand(type, path, args = {}) {\n    if (!this.communicator) {\n      throw new Error(\"Communicator hasn't been initialized yet\")\n    }\n\n    await timeout(\n      {timeout: this.getCommandTimeout(args.timeout), errorMessage: `timeout while sending browser command ${type}: ${path}`},\n      async () => await /** @type {NonNullable<typeof this.communicator>} */ (this.communicator).sendCommand({type, path})\n    )\n  }\n\n  /**\n   * Visits a path using the injected browser helper when available, otherwise navigates directly with the driver.\n   * @param {string} path\n   * @param {BrowserNavigationArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async visit(path, args = {}) {\n    if (this.communicatorExists() && (!this.communicator?.ws || this.communicator.ws.readyState === 1)) {\n      await this.sendBrowserCommand(\"visit\", path, args)\n    } else {\n      await timeout(\n        {timeout: this.getCommandTimeout(args.timeout), errorMessage: `timeout while visiting path: ${path}`},\n        async () => await this.driverVisit(path)\n      )\n    }\n  }\n\n  /**\n   * Dismisses to a path via the injected browser helper when available, otherwise navigates directly with the driver.\n   * @param {string} path\n   * @param {BrowserNavigationArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async dismissTo(path, args = {}) {\n    if (this.communicatorExists() && (!this.communicator?.ws || this.communicator.ws.readyState === 1)) {\n      await this.sendBrowserCommand(\"dismissTo\", path, args)\n    } else {\n      await timeout(\n        {timeout: this.getCommandTimeout(args.timeout), errorMessage: `timeout while dismissing to path: ${path}`},\n        async () => await this.driverVisit(path)\n      )\n    }\n  }\n\n  /**\n   * Formats browser logs for console output and truncates overly long output.\n   * @param {string[]} logs\n   * @param {number} [maxLines]\n   * @returns {string[]}\n   */\n  formatBrowserLogsForConsole(logs, maxLines = 200) {\n    if (!Array.isArray(logs) || logs.length === 0) {\n      return [\"(no browser logs)\"]\n    }\n\n    if (logs.length <= maxLines) {\n      return logs\n    }\n\n    const keptLogs = logs.slice(logs.length - maxLines)\n    const hiddenCount = logs.length - maxLines\n\n    return [`(showing last ${maxLines} of ${logs.length} browser logs, ${hiddenCount} omitted)`, ...keptLogs]\n  }\n\n  /**\n   * @param {string[]} logs\n   * @returns {void}\n   */\n  printBrowserLogsForFailure(logs) {\n    console.log(\"Browser logs:\")\n\n    for (const line of this.formatBrowserLogsForConsole(logs)) {\n      console.log(line)\n    }\n  }\n\n  /**\n   * Takes a screenshot, writes HTML/browser logs to disk, and returns the collected artifacts.\n   * @returns {Promise<{currentUrl: string, html: string, htmlPath: string, logs: string[], logsPath: string, screenshotPath: string}>}\n   */\n  async takeScreenshot() {\n    this.debugLog(\"Getting path for screenshots\")\n    const path = this._screenshotsPath\n\n    this.debugLog(`Creating dir with recursive: ${path}`)\n    await fs.mkdir(path, {recursive: true})\n\n    this.debugLog(\"Getting screenshot image content\")\n    const imageContent = await timeout({timeout: 5000, errorMessage: \"timeout while taking screenshot\"}, async () => await this.getDriverAdapter().takeScreenshot())\n\n    this.debugLog(\"Generating date variables\")\n    const now = new Date()\n    const timestamp = moment(now).format(\"YYYY-MM-DD-HH-MM-SS\")\n    const screenshotPath = `${path}/${timestamp}.png`\n    const htmlPath = `${path}/${timestamp}.html`\n    const logsPath = `${path}/${timestamp}.logs.txt`\n\n    this.debugLog(\"Getting browser logs\")\n    const logs = await timeout({timeout: 5000, errorMessage: \"timeout while reading browser logs\"}, async () => await this.getBrowserLogs())\n    const html = await timeout({timeout: 5000, errorMessage: \"timeout while reading page HTML\"}, async () => await this.getHTML())\n    const htmlPretty = prettify(html)\n    this.printBrowserLogsForFailure(logs)\n\n    this.debugLog(\"Writing files\")\n    await fs.writeFile(htmlPath, htmlPretty)\n    await fs.writeFile(logsPath, logs.join(\"\\n\"))\n    await fs.writeFile(screenshotPath, imageContent, \"base64\")\n\n    const currentUrl = await this.getCurrentUrl()\n\n    console.log(\"Current URL:\", currentUrl)\n    console.log(\"Logs:\", logsPath)\n    console.log(\"Screenshot:\", screenshotPath)\n    console.log(\"HTML:\", htmlPath)\n\n    return {\n      currentUrl,\n      html,\n      htmlPath,\n      logs,\n      logsPath,\n      screenshotPath\n    }\n  }\n\n  /** @returns {Promise<void>} */\n  async stopDriver() {\n    if (this.driverAdapter) {\n      await this.driverAdapter.stop()\n    }\n  }\n}\n"]}

package/build/cli-helpers.js

@@ -192,8 +192,29 @@ export function resolveBrowserCommand(flags) {
             args.visible = flags.visible;
         if (flags["use-base-selector"] !== undefined)
             args.useBaseSelector = flags["use-base-selector"];
+        if (flags.script)
+            args.script = flags.script;
+        // Cookie flags use a `cookie-` prefix so the cookie name does not
+        // collide with the daemon-level `--name <my-browser>` flag the CLI
+        // already consumes for routing.
+        if (flags["cookie-name"])
+            args.name = flags["cookie-name"];
+        if (flags["cookie-value"] !== undefined)
+            args.value = flags["cookie-value"];
+        if (flags["cookie-domain"])
+            args.domain = flags["cookie-domain"];
+        if (flags["cookie-path"])
+            args.path = flags["cookie-path"];
+        if (flags["cookie-secure"] !== undefined)
+            args.secure = flags["cookie-secure"];
+        if (flags["cookie-http-only"] !== undefined)
+            args.httpOnly = flags["cookie-http-only"];
+        if (flags["cookie-expiry"] !== undefined)
+            args.expiry = flags["cookie-expiry"];
+        if (flags["cookie-same-site"])
+            args.sameSite = flags["cookie-same-site"];
         return { args, command: flags.command };
     }
     throw new Error("No browser command was given");
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli-helpers.js","sourceRoot":"","sources":["../src/cli-helpers.js"],"names":[],"mappings":"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","sourcesContent":["/**\n * @param {string[]} argv\n * @returns {{_: string[], flags: Record<string, any>}}\n */\nexport function parseArgv(argv) {\n  /** @type {{_: string[], flags: Record<string, any>}} */\n  const result = {_: [], flags: {}}\n  const setFlag = (/** @type {string} */ key, /** @type {any} */ value) => {\n    if (!(key in result.flags)) {\n      result.flags[key] = value\n      return\n    }\n\n    if (!Array.isArray(result.flags[key])) {\n      result.flags[key] = [result.flags[key]]\n    }\n\n    result.flags[key].push(value)\n  }\n\n  for (let index = 0; index < argv.length; index++) {\n    const value = argv[index]\n\n    if (!value.startsWith(\"--\")) {\n      result._.push(value)\n      continue\n    }\n\n    const flag = value.slice(2)\n\n    if (flag.includes(\"=\")) {\n      const [key, ...rest] = flag.split(\"=\")\n\n      setFlag(key, rest.join(\"=\"))\n      continue\n    }\n\n    const nextValue = argv[index + 1]\n\n    if (nextValue && !nextValue.startsWith(\"--\")) {\n      setFlag(flag, nextValue)\n      index += 1\n    } else {\n      setFlag(flag, true)\n    }\n  }\n\n  return result\n}\n\n/**\n * Parses a CLI timeout flag into milliseconds.\n * Bare numeric values are treated as seconds for CLI ergonomics.\n * @param {any} timeoutFlag\n * @returns {number | undefined}\n */\nfunction resolveCliTimeout(timeoutFlag) {\n  if (timeoutFlag === undefined) {\n    return undefined\n  }\n\n  if (typeof timeoutFlag === \"number\") {\n    return timeoutFlag * 1000\n  }\n\n  const timeoutString = String(timeoutFlag).trim()\n\n  if (/^\\d+(\\.\\d+)?ms$/i.test(timeoutString)) {\n    return Number(timeoutString.slice(0, -2))\n  }\n\n  if (/^\\d+(\\.\\d+)?s$/i.test(timeoutString)) {\n    return Number(timeoutString.slice(0, -1)) * 1000\n  }\n\n  if (/^\\d+(\\.\\d+)?$/.test(timeoutString)) {\n    return Number(timeoutString) * 1000\n  }\n\n  throw new Error(`Invalid timeout flag: ${timeoutFlag}`)\n}\n\n/**\n * @param {Record<string, any>} flags\n * @returns {{command: string, args: Record<string, any>}}\n */\nexport function resolveBrowserCommand(flags) {\n  const timeout = resolveCliTimeout(flags.timeout)\n\n  if (flags.visit) {\n    /** @type {Record<string, any>} */\n    const args = {url: flags.visit}\n\n    if (timeout !== undefined) {\n      args.timeout = timeout\n    }\n\n    return {args, command: \"visit\"}\n  }\n\n  if (flags[\"dismiss-to\"]) {\n    /** @type {Record<string, any>} */\n    const args = {path: flags[\"dismiss-to\"]}\n\n    if (timeout !== undefined) {\n      args.timeout = timeout\n    }\n\n    return {args, command: \"dismissTo\"}\n  }\n\n  if (flags[\"find-by-test-id\"]) {\n    /** @type {Record<string, any>} */\n    const args = {\n      testID: flags[\"find-by-test-id\"],\n      timeout,\n      useBaseSelector: flags[\"use-base-selector\"],\n      visible: flags.visible\n    }\n\n    if (flags[\"scroll-to\"] !== undefined) {\n      args.scrollTo = flags[\"scroll-to\"]\n    }\n\n    return {\n      args,\n      command: \"findByTestID\"\n    }\n  }\n\n  if (flags.find) {\n    /** @type {Record<string, any>} */\n    const args = {\n      selector: flags.find,\n      timeout,\n      useBaseSelector: flags[\"use-base-selector\"],\n      visible: flags.visible\n    }\n\n    if (flags[\"scroll-to\"] !== undefined) {\n      args.scrollTo = flags[\"scroll-to\"]\n    }\n\n    return {\n      args,\n      command: \"find\"\n    }\n  }\n\n  if (flags.click) {\n    /** @type {Record<string, any>} */\n    const args = {\n      selector: flags.click,\n      timeout,\n      useBaseSelector: flags[\"use-base-selector\"],\n      visible: flags.visible\n    }\n\n    if (flags[\"scroll-to\"] !== undefined) {\n      args.scrollTo = flags[\"scroll-to\"]\n    }\n\n    return {\n      args,\n      command: \"click\"\n    }\n  }\n\n  if (flags[\"wait-for-no-selector\"]) {\n    return {\n      args: {\n        selector: flags[\"wait-for-no-selector\"],\n        timeout,\n        useBaseSelector: flags[\"use-base-selector\"]\n      },\n      command: \"waitForNoSelector\"\n    }\n  }\n\n  if (flags[\"expect-no-element\"]) {\n    return {\n      args: {\n        selector: flags[\"expect-no-element\"],\n        timeout,\n        useBaseSelector: flags[\"use-base-selector\"]\n      },\n      command: \"expectNoElement\"\n    }\n  }\n\n  if (flags[\"set-base-selector\"]) {\n    return {args: {selector: flags[\"set-base-selector\"]}, command: \"setBaseSelector\"}\n  }\n\n  if (flags[\"get-html\"]) {\n    return {args: {}, command: \"getHTML\"}\n  }\n\n  if (flags[\"get-browser-logs\"]) {\n    return {args: {}, command: \"getBrowserLogs\"}\n  }\n\n  if (flags[\"get-current-url\"]) {\n    return {args: {}, command: \"getCurrentUrl\"}\n  }\n\n  if (flags[\"take-screenshot\"]) {\n    return {args: {}, command: \"takeScreenshot\"}\n  }\n\n  if (flags.command) {\n    const args = {}\n\n    if (flags.url) args.url = flags.url\n    if (flags.path) args.path = flags.path\n    if (flags.selector) args.selector = flags.selector\n    if (flags[\"test-id\"]) args.testID = flags[\"test-id\"]\n    if (flags.method) args.methodName = flags.method\n    if (flags.arg) args.args = Array.isArray(flags.arg) ? flags.arg : [flags.arg]\n    if (flags[\"with-fallback\"] !== undefined) args.withFallback = flags[\"with-fallback\"]\n    if (timeout !== undefined) args.timeout = timeout\n    if (flags[\"scroll-to\"] !== undefined) args.scrollTo = flags[\"scroll-to\"]\n    if (flags.visible !== undefined) args.visible = flags.visible\n    if (flags[\"use-base-selector\"] !== undefined) args.useBaseSelector = flags[\"use-base-selector\"]\n\n    return {args, command: flags.command}\n  }\n\n  throw new Error(\"No browser command was given\")\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli-helpers.js","sourceRoot":"","sources":["../src/cli-helpers.js"],"names":[],"mappings":"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","sourcesContent":["/**\n * @param {string[]} argv\n * @returns {{_: string[], flags: Record<string, any>}}\n */\nexport function parseArgv(argv) {\n  /** @type {{_: string[], flags: Record<string, any>}} */\n  const result = {_: [], flags: {}}\n  const setFlag = (/** @type {string} */ key, /** @type {any} */ value) => {\n    if (!(key in result.flags)) {\n      result.flags[key] = value\n      return\n    }\n\n    if (!Array.isArray(result.flags[key])) {\n      result.flags[key] = [result.flags[key]]\n    }\n\n    result.flags[key].push(value)\n  }\n\n  for (let index = 0; index < argv.length; index++) {\n    const value = argv[index]\n\n    if (!value.startsWith(\"--\")) {\n      result._.push(value)\n      continue\n    }\n\n    const flag = value.slice(2)\n\n    if (flag.includes(\"=\")) {\n      const [key, ...rest] = flag.split(\"=\")\n\n      setFlag(key, rest.join(\"=\"))\n      continue\n    }\n\n    const nextValue = argv[index + 1]\n\n    if (nextValue && !nextValue.startsWith(\"--\")) {\n      setFlag(flag, nextValue)\n      index += 1\n    } else {\n      setFlag(flag, true)\n    }\n  }\n\n  return result\n}\n\n/**\n * Parses a CLI timeout flag into milliseconds.\n * Bare numeric values are treated as seconds for CLI ergonomics.\n * @param {any} timeoutFlag\n * @returns {number | undefined}\n */\nfunction resolveCliTimeout(timeoutFlag) {\n  if (timeoutFlag === undefined) {\n    return undefined\n  }\n\n  if (typeof timeoutFlag === \"number\") {\n    return timeoutFlag * 1000\n  }\n\n  const timeoutString = String(timeoutFlag).trim()\n\n  if (/^\\d+(\\.\\d+)?ms$/i.test(timeoutString)) {\n    return Number(timeoutString.slice(0, -2))\n  }\n\n  if (/^\\d+(\\.\\d+)?s$/i.test(timeoutString)) {\n    return Number(timeoutString.slice(0, -1)) * 1000\n  }\n\n  if (/^\\d+(\\.\\d+)?$/.test(timeoutString)) {\n    return Number(timeoutString) * 1000\n  }\n\n  throw new Error(`Invalid timeout flag: ${timeoutFlag}`)\n}\n\n/**\n * @param {Record<string, any>} flags\n * @returns {{command: string, args: Record<string, any>}}\n */\nexport function resolveBrowserCommand(flags) {\n  const timeout = resolveCliTimeout(flags.timeout)\n\n  if (flags.visit) {\n    /** @type {Record<string, any>} */\n    const args = {url: flags.visit}\n\n    if (timeout !== undefined) {\n      args.timeout = timeout\n    }\n\n    return {args, command: \"visit\"}\n  }\n\n  if (flags[\"dismiss-to\"]) {\n    /** @type {Record<string, any>} */\n    const args = {path: flags[\"dismiss-to\"]}\n\n    if (timeout !== undefined) {\n      args.timeout = timeout\n    }\n\n    return {args, command: \"dismissTo\"}\n  }\n\n  if (flags[\"find-by-test-id\"]) {\n    /** @type {Record<string, any>} */\n    const args = {\n      testID: flags[\"find-by-test-id\"],\n      timeout,\n      useBaseSelector: flags[\"use-base-selector\"],\n      visible: flags.visible\n    }\n\n    if (flags[\"scroll-to\"] !== undefined) {\n      args.scrollTo = flags[\"scroll-to\"]\n    }\n\n    return {\n      args,\n      command: \"findByTestID\"\n    }\n  }\n\n  if (flags.find) {\n    /** @type {Record<string, any>} */\n    const args = {\n      selector: flags.find,\n      timeout,\n      useBaseSelector: flags[\"use-base-selector\"],\n      visible: flags.visible\n    }\n\n    if (flags[\"scroll-to\"] !== undefined) {\n      args.scrollTo = flags[\"scroll-to\"]\n    }\n\n    return {\n      args,\n      command: \"find\"\n    }\n  }\n\n  if (flags.click) {\n    /** @type {Record<string, any>} */\n    const args = {\n      selector: flags.click,\n      timeout,\n      useBaseSelector: flags[\"use-base-selector\"],\n      visible: flags.visible\n    }\n\n    if (flags[\"scroll-to\"] !== undefined) {\n      args.scrollTo = flags[\"scroll-to\"]\n    }\n\n    return {\n      args,\n      command: \"click\"\n    }\n  }\n\n  if (flags[\"wait-for-no-selector\"]) {\n    return {\n      args: {\n        selector: flags[\"wait-for-no-selector\"],\n        timeout,\n        useBaseSelector: flags[\"use-base-selector\"]\n      },\n      command: \"waitForNoSelector\"\n    }\n  }\n\n  if (flags[\"expect-no-element\"]) {\n    return {\n      args: {\n        selector: flags[\"expect-no-element\"],\n        timeout,\n        useBaseSelector: flags[\"use-base-selector\"]\n      },\n      command: \"expectNoElement\"\n    }\n  }\n\n  if (flags[\"set-base-selector\"]) {\n    return {args: {selector: flags[\"set-base-selector\"]}, command: \"setBaseSelector\"}\n  }\n\n  if (flags[\"get-html\"]) {\n    return {args: {}, command: \"getHTML\"}\n  }\n\n  if (flags[\"get-browser-logs\"]) {\n    return {args: {}, command: \"getBrowserLogs\"}\n  }\n\n  if (flags[\"get-current-url\"]) {\n    return {args: {}, command: \"getCurrentUrl\"}\n  }\n\n  if (flags[\"take-screenshot\"]) {\n    return {args: {}, command: \"takeScreenshot\"}\n  }\n\n  if (flags.command) {\n    const args = {}\n\n    if (flags.url) args.url = flags.url\n    if (flags.path) args.path = flags.path\n    if (flags.selector) args.selector = flags.selector\n    if (flags[\"test-id\"]) args.testID = flags[\"test-id\"]\n    if (flags.method) args.methodName = flags.method\n    if (flags.arg) args.args = Array.isArray(flags.arg) ? flags.arg : [flags.arg]\n    if (flags[\"with-fallback\"] !== undefined) args.withFallback = flags[\"with-fallback\"]\n    if (timeout !== undefined) args.timeout = timeout\n    if (flags[\"scroll-to\"] !== undefined) args.scrollTo = flags[\"scroll-to\"]\n    if (flags.visible !== undefined) args.visible = flags.visible\n    if (flags[\"use-base-selector\"] !== undefined) args.useBaseSelector = flags[\"use-base-selector\"]\n    if (flags.script) args.script = flags.script\n    // Cookie flags use a `cookie-` prefix so the cookie name does not\n    // collide with the daemon-level `--name <my-browser>` flag the CLI\n    // already consumes for routing.\n    if (flags[\"cookie-name\"]) args.name = flags[\"cookie-name\"]\n    if (flags[\"cookie-value\"] !== undefined) args.value = flags[\"cookie-value\"]\n    if (flags[\"cookie-domain\"]) args.domain = flags[\"cookie-domain\"]\n    if (flags[\"cookie-path\"]) args.path = flags[\"cookie-path\"]\n    if (flags[\"cookie-secure\"] !== undefined) args.secure = flags[\"cookie-secure\"]\n    if (flags[\"cookie-http-only\"] !== undefined) args.httpOnly = flags[\"cookie-http-only\"]\n    if (flags[\"cookie-expiry\"] !== undefined) args.expiry = flags[\"cookie-expiry\"]\n    if (flags[\"cookie-same-site\"]) args.sameSite = flags[\"cookie-same-site\"]\n\n    return {args, command: flags.command}\n  }\n\n  throw new Error(\"No browser command was given\")\n}\n"]}

package/build/cli.js

@@ -12,6 +12,8 @@ function printHelp() {
   system-testing browser-command [--name my-browser] [--port 1991] --visit=https://example.com
   system-testing browser-command [--name my-browser] --find-by-test-id someID [--timeout 15]
   system-testing browser-command [--name my-browser] --take-screenshot
+  system-testing browser-command [--name my-browser] --command=executeScript --script='return document.title' [--arg ...]
+  system-testing browser-command [--name my-browser] --command=addCookie --cookie-name=auth --cookie-value=... [--cookie-domain=127.0.0.1] [--cookie-path=/]
 `);
 }
 /**
@@ -78,4 +80,4 @@ main(process.argv.slice(2)).catch((error) => {
     console.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.js"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\n\nimport BrowserCommandClient from \"./browser-command-client.js\"\nimport BrowserProcess from \"./browser-process.js\"\nimport BrowserRegistry from \"./browser-registry.js\"\nimport {parseArgv, resolveBrowserCommand} from \"./cli-helpers.js\"\n\n/** @returns {void} */\nfunction printHelp() {\n  console.log(`Usage:\n  system-testing browser <name> [--port 1991] [--base-url https://example.com]\n  system-testing browser-list\n  system-testing browser-stop [--name my-browser]\n  system-testing browser-command [--name my-browser] [--port 1991] --visit=https://example.com\n  system-testing browser-command [--name my-browser] --find-by-test-id someID [--timeout 15]\n  system-testing browser-command [--name my-browser] --take-screenshot\n`)\n}\n\n/**\n * @param {string[]} argv\n * @returns {Promise<void>}\n */\nasync function main(argv) {\n  const parsed = parseArgv(argv)\n  const mainCommand = parsed._[0]\n\n  if (!mainCommand || parsed.flags.help) {\n    printHelp()\n    return\n  }\n\n  if (mainCommand === \"browser\") {\n    const name = parsed._[1]\n\n    if (!name) {\n      throw new Error(\"browser requires a name\")\n    }\n\n    const browserProcess = new BrowserProcess({\n      baseUrl: parsed.flags[\"base-url\"],\n      browserArgs: {\n        driver: parsed.flags.driver ? {type: parsed.flags.driver} : undefined\n      },\n      debug: parsed.flags.debug === true || parsed.flags.debug === \"true\",\n      name,\n      port: parsed.flags.port ? Number(parsed.flags.port) : 0\n    })\n\n    await browserProcess.start()\n    console.log(JSON.stringify({name, pid: process.pid, port: browserProcess.port}))\n    await new Promise(() => {})\n  } else if (mainCommand === \"browser-list\") {\n    const entries = await BrowserRegistry.list()\n\n    if (parsed.flags.json) {\n      console.log(JSON.stringify(entries, null, 2))\n      return\n    }\n\n    for (const entry of entries) {\n      console.log(`${entry.name}\\t${entry.port}\\tpid=${entry.pid}`)\n    }\n  } else if (mainCommand === \"browser-stop\") {\n    const stoppedEntry = await BrowserRegistry.stop(parsed.flags.name)\n\n    if (parsed.flags.json) {\n      console.log(JSON.stringify(stoppedEntry, null, 2))\n      return\n    }\n\n    console.log(`Stopped ${stoppedEntry.name}\\tpid=${stoppedEntry.pid}`)\n  } else if (mainCommand === \"browser-command\") {\n    const client = new BrowserCommandClient({\n      name: parsed.flags.name,\n      port: parsed.flags.port ? Number(parsed.flags.port) : undefined\n    })\n    const {args, command} = resolveBrowserCommand(parsed.flags)\n    const result = await client.send({args, command, type: \"browser-command\"})\n\n    console.log(JSON.stringify(result, null, 2))\n  } else {\n    throw new Error(`Unknown command: ${mainCommand}`)\n  }\n}\n\nmain(process.argv.slice(2)).catch((error) => {\n  console.error(error instanceof Error ? error.message : String(error))\n  process.exit(1)\n})\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.js"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\n\nimport BrowserCommandClient from \"./browser-command-client.js\"\nimport BrowserProcess from \"./browser-process.js\"\nimport BrowserRegistry from \"./browser-registry.js\"\nimport {parseArgv, resolveBrowserCommand} from \"./cli-helpers.js\"\n\n/** @returns {void} */\nfunction printHelp() {\n  console.log(`Usage:\n  system-testing browser <name> [--port 1991] [--base-url https://example.com]\n  system-testing browser-list\n  system-testing browser-stop [--name my-browser]\n  system-testing browser-command [--name my-browser] [--port 1991] --visit=https://example.com\n  system-testing browser-command [--name my-browser] --find-by-test-id someID [--timeout 15]\n  system-testing browser-command [--name my-browser] --take-screenshot\n  system-testing browser-command [--name my-browser] --command=executeScript --script='return document.title' [--arg ...]\n  system-testing browser-command [--name my-browser] --command=addCookie --cookie-name=auth --cookie-value=... [--cookie-domain=127.0.0.1] [--cookie-path=/]\n`)\n}\n\n/**\n * @param {string[]} argv\n * @returns {Promise<void>}\n */\nasync function main(argv) {\n  const parsed = parseArgv(argv)\n  const mainCommand = parsed._[0]\n\n  if (!mainCommand || parsed.flags.help) {\n    printHelp()\n    return\n  }\n\n  if (mainCommand === \"browser\") {\n    const name = parsed._[1]\n\n    if (!name) {\n      throw new Error(\"browser requires a name\")\n    }\n\n    const browserProcess = new BrowserProcess({\n      baseUrl: parsed.flags[\"base-url\"],\n      browserArgs: {\n        driver: parsed.flags.driver ? {type: parsed.flags.driver} : undefined\n      },\n      debug: parsed.flags.debug === true || parsed.flags.debug === \"true\",\n      name,\n      port: parsed.flags.port ? Number(parsed.flags.port) : 0\n    })\n\n    await browserProcess.start()\n    console.log(JSON.stringify({name, pid: process.pid, port: browserProcess.port}))\n    await new Promise(() => {})\n  } else if (mainCommand === \"browser-list\") {\n    const entries = await BrowserRegistry.list()\n\n    if (parsed.flags.json) {\n      console.log(JSON.stringify(entries, null, 2))\n      return\n    }\n\n    for (const entry of entries) {\n      console.log(`${entry.name}\\t${entry.port}\\tpid=${entry.pid}`)\n    }\n  } else if (mainCommand === \"browser-stop\") {\n    const stoppedEntry = await BrowserRegistry.stop(parsed.flags.name)\n\n    if (parsed.flags.json) {\n      console.log(JSON.stringify(stoppedEntry, null, 2))\n      return\n    }\n\n    console.log(`Stopped ${stoppedEntry.name}\\tpid=${stoppedEntry.pid}`)\n  } else if (mainCommand === \"browser-command\") {\n    const client = new BrowserCommandClient({\n      name: parsed.flags.name,\n      port: parsed.flags.port ? Number(parsed.flags.port) : undefined\n    })\n    const {args, command} = resolveBrowserCommand(parsed.flags)\n    const result = await client.send({args, command, type: \"browser-command\"})\n\n    console.log(JSON.stringify(result, null, 2))\n  } else {\n    throw new Error(`Unknown command: ${mainCommand}`)\n  }\n}\n\nmain(process.argv.slice(2)).catch((error) => {\n  console.error(error instanceof Error ? error.message : String(error))\n  process.exit(1)\n})\n"]}

package/build/expo.d.ts

@@ -0,0 +1 @@
+export { default as useSystemTestExpo } from "./use-system-test-expo.js";

package/build/expo.js

@@ -0,0 +1,2 @@
+export { default as useSystemTestExpo } from "./use-system-test-expo.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhwby5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9leHBvLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxPQUFPLElBQUksaUJBQWlCLEVBQUMsTUFBTSwyQkFBMkIsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7ZGVmYXVsdCBhcyB1c2VTeXN0ZW1UZXN0RXhwb30gZnJvbSBcIi4vdXNlLXN5c3RlbS10ZXN0LWV4cG8uanNcIlxuIl19

package/build/index.d.ts

@@ -5,5 +5,4 @@ export { default as BrowserRegistry } from "./browser-registry.js";
 export { default as SystemTest } from "./system-test.js";
 export { default as SystemTestBrowserHelper } from "./system-test-browser-helper.js";
 export { default as useSystemTest } from "./use-system-test.js";
-export { default as useSystemTestExpo } from "./use-system-test-expo.js";
 export { default as useSystemTestReactNative } from "./use-system-test-react-native.js";

package/build/index.js

@@ -5,6 +5,5 @@ export { default as BrowserRegistry } from "./browser-registry.js";
 export { default as SystemTest } from "./system-test.js";
 export { default as SystemTestBrowserHelper } from "./system-test-browser-helper.js";
 export { default as useSystemTest } from "./use-system-test.js";
-export { default as useSystemTestExpo } from "./use-system-test-expo.js";
 export { default as useSystemTestReactNative } from "./use-system-test-react-native.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXguanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLE9BQU8sSUFBSSxPQUFPLEVBQUMsTUFBTSxjQUFjLENBQUE7QUFDL0MsT0FBTyxFQUFDLE9BQU8sSUFBSSxvQkFBb0IsRUFBQyxNQUFNLDZCQUE2QixDQUFBO0FBQzNFLE9BQU8sRUFBQyxPQUFPLElBQUksY0FBYyxFQUFDLE1BQU0sc0JBQXNCLENBQUE7QUFDOUQsT0FBTyxFQUFDLE9BQU8sSUFBSSxlQUFlLEVBQUMsTUFBTSx1QkFBdUIsQ0FBQTtBQUNoRSxPQUFPLEVBQUMsT0FBTyxJQUFJLFVBQVUsRUFBQyxNQUFNLGtCQUFrQixDQUFBO0FBQ3RELE9BQU8sRUFBQyxPQUFPLElBQUksdUJBQXVCLEVBQUMsTUFBTSxpQ0FBaUMsQ0FBQTtBQUNsRixPQUFPLEVBQUMsT0FBTyxJQUFJLGFBQWEsRUFBQyxNQUFNLHNCQUFzQixDQUFBO0FBQzdELE9BQU8sRUFBQyxPQUFPLElBQUksaUJBQWlCLEVBQUMsTUFBTSwyQkFBMkIsQ0FBQTtBQUN0RSxPQUFPLEVBQUMsT0FBTyxJQUFJLHdCQUF3QixFQUFDLE1BQU0sbUNBQW1DLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQge2RlZmF1bHQgYXMgQnJvd3Nlcn0gZnJvbSBcIi4vYnJvd3Nlci5qc1wiXG5leHBvcnQge2RlZmF1bHQgYXMgQnJvd3NlckNvbW1hbmRDbGllbnR9IGZyb20gXCIuL2Jyb3dzZXItY29tbWFuZC1jbGllbnQuanNcIlxuZXhwb3J0IHtkZWZhdWx0IGFzIEJyb3dzZXJQcm9jZXNzfSBmcm9tIFwiLi9icm93c2VyLXByb2Nlc3MuanNcIlxuZXhwb3J0IHtkZWZhdWx0IGFzIEJyb3dzZXJSZWdpc3RyeX0gZnJvbSBcIi4vYnJvd3Nlci1yZWdpc3RyeS5qc1wiXG5leHBvcnQge2RlZmF1bHQgYXMgU3lzdGVtVGVzdH0gZnJvbSBcIi4vc3lzdGVtLXRlc3QuanNcIlxuZXhwb3J0IHtkZWZhdWx0IGFzIFN5c3RlbVRlc3RCcm93c2VySGVscGVyfSBmcm9tIFwiLi9zeXN0ZW0tdGVzdC1icm93c2VyLWhlbHBlci5qc1wiXG5leHBvcnQge2RlZmF1bHQgYXMgdXNlU3lzdGVtVGVzdH0gZnJvbSBcIi4vdXNlLXN5c3RlbS10ZXN0LmpzXCJcbmV4cG9ydCB7ZGVmYXVsdCBhcyB1c2VTeXN0ZW1UZXN0RXhwb30gZnJvbSBcIi4vdXNlLXN5c3RlbS10ZXN0LWV4cG8uanNcIlxuZXhwb3J0IHtkZWZhdWx0IGFzIHVzZVN5c3RlbVRlc3RSZWFjdE5hdGl2ZX0gZnJvbSBcIi4vdXNlLXN5c3RlbS10ZXN0LXJlYWN0LW5hdGl2ZS5qc1wiXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXguanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLE9BQU8sSUFBSSxPQUFPLEVBQUMsTUFBTSxjQUFjLENBQUE7QUFDL0MsT0FBTyxFQUFDLE9BQU8sSUFBSSxvQkFBb0IsRUFBQyxNQUFNLDZCQUE2QixDQUFBO0FBQzNFLE9BQU8sRUFBQyxPQUFPLElBQUksY0FBYyxFQUFDLE1BQU0sc0JBQXNCLENBQUE7QUFDOUQsT0FBTyxFQUFDLE9BQU8sSUFBSSxlQUFlLEVBQUMsTUFBTSx1QkFBdUIsQ0FBQTtBQUNoRSxPQUFPLEVBQUMsT0FBTyxJQUFJLFVBQVUsRUFBQyxNQUFNLGtCQUFrQixDQUFBO0FBQ3RELE9BQU8sRUFBQyxPQUFPLElBQUksdUJBQXVCLEVBQUMsTUFBTSxpQ0FBaUMsQ0FBQTtBQUNsRixPQUFPLEVBQUMsT0FBTyxJQUFJLGFBQWEsRUFBQyxNQUFNLHNCQUFzQixDQUFBO0FBQzdELE9BQU8sRUFBQyxPQUFPLElBQUksd0JBQXdCLEVBQUMsTUFBTSxtQ0FBbUMsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7ZGVmYXVsdCBhcyBCcm93c2VyfSBmcm9tIFwiLi9icm93c2VyLmpzXCJcbmV4cG9ydCB7ZGVmYXVsdCBhcyBCcm93c2VyQ29tbWFuZENsaWVudH0gZnJvbSBcIi4vYnJvd3Nlci1jb21tYW5kLWNsaWVudC5qc1wiXG5leHBvcnQge2RlZmF1bHQgYXMgQnJvd3NlclByb2Nlc3N9IGZyb20gXCIuL2Jyb3dzZXItcHJvY2Vzcy5qc1wiXG5leHBvcnQge2RlZmF1bHQgYXMgQnJvd3NlclJlZ2lzdHJ5fSBmcm9tIFwiLi9icm93c2VyLXJlZ2lzdHJ5LmpzXCJcbmV4cG9ydCB7ZGVmYXVsdCBhcyBTeXN0ZW1UZXN0fSBmcm9tIFwiLi9zeXN0ZW0tdGVzdC5qc1wiXG5leHBvcnQge2RlZmF1bHQgYXMgU3lzdGVtVGVzdEJyb3dzZXJIZWxwZXJ9IGZyb20gXCIuL3N5c3RlbS10ZXN0LWJyb3dzZXItaGVscGVyLmpzXCJcbmV4cG9ydCB7ZGVmYXVsdCBhcyB1c2VTeXN0ZW1UZXN0fSBmcm9tIFwiLi91c2Utc3lzdGVtLXRlc3QuanNcIlxuZXhwb3J0IHtkZWZhdWx0IGFzIHVzZVN5c3RlbVRlc3RSZWFjdE5hdGl2ZX0gZnJvbSBcIi4vdXNlLXN5c3RlbS10ZXN0LXJlYWN0LW5hdGl2ZS5qc1wiXG4iXX0=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "system-testing",
-  "version": "1.0.104",
+  "version": "1.0.106",
   "description": "System testing with Selenium and browsers.",
   "bin": {
     "system-testing": "build/cli.js"
@@ -62,14 +62,10 @@
     "ya-use-event-emitter": "^0.1.2"
   },
   "peerDependencies": {
-    "expo-router": ">= 1.0.0",
     "react": ">= 18.3.0",
     "selenium-webdriver": ">= 4.34.0"
   },
   "peerDependenciesMeta": {
-    "expo-router": {
-      "optional": true
-    },
     "react": {
       "optional": true
     }