system-testing 1.0.77 → 1.0.79

package/README.md

@@ -8,6 +8,34 @@ Rails inspired system testing for Expo apps.
 npm install --save-dev system-testing
 ```
 
+## Choose the right layer
+
+This package has three main entry points:
+
+- `SystemTest`: full app-oriented system testing with selector helpers, app bootstrapping, WebSocket communication, screenshots, logs, and Scoundrel support.
+- `Browser`: lower-level driver session for opening URLs, taking screenshots, and reading HTML/logs without the rest of the system-test flow.
+- `system-testing` CLI browser daemon: a long-running named browser process that can be controlled from CLI commands or WebSocket messages.
+- `useSystemTest*` hooks: browser-side integration that lets your app respond to `visit` / `dismissTo` commands from `SystemTest`.
+
+Use `SystemTest` if you are testing your app. Use `Browser` if you just want a Selenium/Appium-backed browser session.
+
+## Getting started
+
+1. Add one of the browser-side hooks to your app:
+   `useSystemTestExpo` for Expo Router, or `useSystemTest` / `useSystemTestReactNative` for your own navigation stack.
+2. Wrap your app in a root element with `testID="systemTestingComponent"`.
+3. Make sure your root test route renders an element with `testID="blankText"`, or change `SystemTest.rootPath`.
+4. Start tests with `SystemTest.run(...)` for app flows, or instantiate `Browser` directly for ordinary browsing/capture.
+
+Minimal app-side requirements:
+
+```jsx
+<View testID="systemTestingComponent" dataSet={{focussed: "true"}}>
+  <Text testID="blankText">Blank</Text>
+  {children}
+</View>
+```
+
 ## Usage
 
 ```js
@@ -90,9 +118,147 @@ await SystemTest.run({
 
 If you already run an Appium server, provide `serverUrl` instead of `serverArgs`. By default, `findByTestID` uses the Appium `accessibility id` strategy. To use CSS instead (for web contexts), set `options.testIdStrategy` to `"css"` and optionally `options.testIdAttribute` (defaults to `"data-testid"`).
 
-### Using `useSystemTest` in your Expo app
+For local or CI web runs against Chrome, `npm run test:appium:web` now resolves and downloads a matching Chrome for Testing `chromedriver` binary before it starts Appium. That keeps the Appium web path reproducible even when the installed Chrome patch version changes.
+
+### Generic browser usage
+
+`Browser` is the lower-level browser/session class behind `SystemTest`. Use it when you want driver-backed browsing, screenshots, logs, and HTML capture without the rest of the system-test bootstrapping.
+
+```js
+import {Browser} from "system-testing/build/index.js"
+
+const browser = new Browser()
+
+browser.getDriverAdapter().setBaseUrl("https://example.com")
+await browser.getDriverAdapter().start()
+await browser.setTimeouts(10000)
+
+await browser.visit("/")
+
+const html = await browser.getHTML()
+const logs = await browser.getBrowserLogs()
+const screenshot = await browser.takeScreenshot()
+
+await browser.stopDriver()
+```
+
+If `visit()`/`dismissTo()` should drive in-app navigation through the browser-side helper instead of direct URL loads, inject a communicator when constructing `Browser`. Without one, it falls back to direct driver navigation, which makes it usable for ordinary website browsing as well.
+
+Common `Browser` flow:
+
+1. Create the browser with the desired driver config.
+2. Set the base URL on the driver adapter.
+3. Start the driver and set timeouts.
+4. Call `visit()`.
+5. Read `getHTML()`, `getBrowserLogs()`, `getCurrentUrl()`, or `takeScreenshot()`.
+6. Call `stopDriver()` during teardown.
+
+Useful browser methods:
+
+- `visit(pathOrUrl)`: uses the helper communicator if present, otherwise loads directly through Selenium/Appium.
+- `dismissTo(pathOrUrl)`: same fallback behavior as `visit()`.
+- `getHTML()`: returns the current page source.
+- `getBrowserLogs()`: returns collected browser logs, or Appium logcat output for Android native runs.
+- `takeScreenshot()`: writes screenshot, HTML, and logs to disk and returns the artifact paths.
+
+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.
+
+### Browser daemon CLI
+
+If you want an external agent to drive a reusable browser process, start the browser daemon:
+
+```bash
+npx system-testing browser my-browser
+```
+
+Optional arguments:
+
+- `--port 1991`: use a fixed WebSocket port instead of an ephemeral one
+- `--base-url https://example.com`: set the browser base URL so relative `visit` paths work
+- `--driver selenium|appium`: choose the driver type
+- `--debug`: enable browser debug logging
+
+The process stays running until you stop it. On start it prints JSON with at least the browser `name`, `pid`, and `port`.
+
+List running browser daemons:
+
+```bash
+npx system-testing browser-list
+```
+
+This prints one line per browser with the name and port. Use `--json` if you want machine-readable output.
 
-`useSystemTest` wires your Expo app to the system-testing runner: it listens for WebSocket commands, initializes the browser helper, and lets tests navigate or reset state. Add it near the root layout of your Expo Router app (for example in `_layout.tsx` or a top-level provider component).
+Send commands from the CLI:
+
+```bash
+npx system-testing browser-command --name my-browser --visit=https://example.com/path
+npx system-testing browser-command --name my-browser --find-by-test-id saveButton
+npx system-testing browser-command --name my-browser --click='[data-testid="saveButton"]'
+npx system-testing browser-command --name my-browser --get-html
+npx system-testing browser-command --name my-browser --get-browser-logs
+npx system-testing browser-command --name my-browser --take-screenshot
+```
+
+If only one browser daemon is running, `browser-command` can omit `--name`. Results are printed as JSON so automation tools can parse them easily.
+
+Generic commands are also supported:
+
+```bash
+npx system-testing browser-command \
+  --name my-browser \
+  --command=interact \
+  --selector='[data-testid="emailInput"]' \
+  --method=sendKeys \
+  --arg='user@example.com'
+```
+
+The browser daemon is intended for agent-style development workflows where an AI or script needs to open the app, inspect HTML, locate elements, click controls, and read logs while validating layout or behavior changes.
+
+### Browser daemon WebSocket protocol
+
+The daemon also accepts WebSocket commands on its configured port. Send JSON payloads like:
+
+```json
+{"type":"browser-command","command":"visit","url":"https://example.com/path"}
+```
+
+Another example:
+
+```json
+{"type":"browser-command","command":"findByTestID","args":{"testID":"saveButton"}}
+```
+
+The server responds with JSON:
+
+```json
+{"ok":true,"requestId":"...","type":"browser-command-result","result":{"ok":true}}
+```
+
+If the command fails:
+
+```json
+{"ok":false,"requestId":"...","type":"browser-command-result","error":"..."}
+```
+
+Supported daemon commands currently include:
+
+- `visit`
+- `dismissTo`
+- `setBaseSelector`
+- `getCurrentUrl`
+- `getHTML`
+- `getBrowserLogs`
+- `takeScreenshot`
+- `find`
+- `findByTestID`
+- `click`
+- `waitForNoSelector`
+- `expectNoElement`
+- `interact`
+
+### Using `useSystemTestExpo` in your Expo app
+
+`useSystemTestExpo` wires your Expo app to the system-testing runner: it listens for WebSocket commands, initializes the browser helper, and lets tests navigate or reset state. Add it near the root layout of your Expo Router app (for example in `_layout.tsx` or a top-level provider component).
 
 To enable system tests in native builds, set `EXPO_PUBLIC_SYSTEM_TEST=true` at build time (and optionally `EXPO_PUBLIC_SYSTEM_TEST_HOST` to reach the test runner from a device/emulator). For native Appium runs, set `SYSTEM_TEST_HOST=native` in the test environment and point Appium at your APK.
 
@@ -100,10 +266,12 @@ Minimal example:
 
 ```jsx
 import {Stack} from "expo-router"
-import useSystemTest from "system-testing/build/use-system-test.js"
+import useSystemTestExpo from "system-testing/build/use-system-test-expo.js"
 
 export default function RootLayout() {
-  const {enabled, systemTestBrowserHelper} = useSystemTest({
+  const {enabled, systemTestBrowserHelper} = useSystemTestExpo({
+    // Optional: inject your own helper instance instead of using the shared default
+    // browserHelper: mySystemTestBrowserHelper,
     onFirstInitialize: () => {
       // One-time setup the first time the helper initializes
     },
@@ -129,12 +297,51 @@ export default function RootLayout() {
 
 Notes:
 - The hook auto-connects when the page is opened with `?systemTest=true` (as the runner does).
+- Pass `browserHelper` if you want to inject a prebuilt `SystemTestBrowserHelper`; otherwise the hook creates and enables a shared default instance.
 - `onFirstInitialize` runs only on the first `initialize` command; use it for one-time setup.
 - `onInitialize` is registered once when the helper is ready, but it runs on every `initialize` command (each `SystemTest.run`); use it to reset globals/session.
 - If you need scoundrel remote evaluation, wait for `systemTestBrowserHelper` and register your classes there, as shown in the commented snippet above.
 - Add a root wrapper with `testID="systemTestingComponent"` (and optionally `data-focussed="true"`) around your app so the runner has a stable element to detect and scope selectors against.
 - From your tests, use `await systemTest.getScoundrelClient()` to obtain the browser Scoundrel client for remote evaluation.
-- `useSystemTest` calls `useRouter()` from `expo-router`. If you are not using Expo Router, install `expo-router` or provide your own guard to avoid navigation errors.
+- `useSystemTestExpo` calls `useRouter()` from `expo-router`.
+
+### Using `useSystemTest` or `useSystemTestReactNative` without Expo Router
+
+`useSystemTest` is the generic runtime-agnostic hook. Provide `onNavigate` and `onDismissTo` callbacks for your own navigation stack. `useSystemTestReactNative` is a convenience wrapper around the same generic API for non-Expo React Native apps.
+
+Use these when:
+
+- you are not using Expo Router
+- you want to inject your own navigation behavior
+- you want to share the same app-side helper integration across different routing setups
+
+```js
+import useSystemTestReactNative from "system-testing/build/use-system-test-react-native.js"
+
+export default function App({navigation}) {
+  useSystemTestReactNative({
+    onDismissTo: ({path}) => {
+      navigation.reset({
+        index: 0,
+        routes: [{name: path}]
+      })
+    },
+    onNavigate: ({path}) => {
+      navigation.navigate(path)
+    }
+  })
+
+  return <Navigator />
+}
+```
+
+The generic hook options are:
+
+- `browserHelper`: inject an existing `SystemTestBrowserHelper` instance instead of using the shared default
+- `onFirstInitialize`: one-time setup callback
+- `onInitialize`: callback that runs on every `initialize` command
+- `onNavigate`: handler for `visit(...)`
+- `onDismissTo`: handler for `dismissTo(...)`
 
 ### Root path and `blankText`
 
@@ -181,7 +388,7 @@ Use `useBaseSelector: false` only for modal or overlay content. Keep the default
 Most selector helpers accept the same options:
 
 - `timeout` (number): override how long the lookup should wait.
-- `visible` (boolean): require elements to be visible (`true`) or hidden (`false`).
+- `visible` (boolean|null): require elements to be visible (`true`) or hidden (`false`), or disable visibility filtering with `null`.
 - `useBaseSelector` (boolean): scope the selector to the focused container.
 
 These options are supported by `find`, `findByTestID`, and `all`. `click` also accepts the same options when a selector string is used:
@@ -208,4 +415,10 @@ This tears down the browser, servers, and sockets, then starts them again so sub
 
 ## Dummy Expo app
 
-A ready-to-run Expo Router dummy app that uses `system-testing` lives in `spec/dummy`. Build the web bundle with `npm run export:web` and execute the sample system test with `npm run test:system` from that folder.
+A ready-to-run Expo Router dummy app that uses `system-testing` lives in `spec/dummy`.
+
+Useful commands from the package root:
+
+- `npm run export:web`: build the dummy Expo app for web
+- `SYSTEM_TEST_HOST=dist npx jasmine spec/system-test.spec.js`: run the sample system specs against the exported bundle
+- `SYSTEM_TEST_HOST=dist npx jasmine spec/system-test-logging.spec.js`: run the browser-log capture spec

package/build/browser-command-client.d.ts

@@ -0,0 +1,19 @@
+/** Sends browser commands to a running browser daemon. */
+export default class BrowserCommandClient {
+    /**
+     * @param {object} args
+     * @param {string} [args.name]
+     * @param {number} [args.port]
+     */
+    constructor({ name, port }?: {
+        name?: string;
+        port?: number;
+    });
+    name: string;
+    port: number;
+    /**
+     * @param {Record<string, any>} payload
+     * @returns {Promise<any>}
+     */
+    send(payload: Record<string, any>): Promise<any>;
+}

package/build/browser-command-client.js

@@ -0,0 +1,39 @@
+import BrowserRegistry from "./browser-registry.js";
+import WebSocket from "ws";
+/** Sends browser commands to a running browser daemon. */
+export default class BrowserCommandClient {
+    /**
+     * @param {object} args
+     * @param {string} [args.name]
+     * @param {number} [args.port]
+     */
+    constructor({ name, port } = {}) {
+        this.name = name;
+        this.port = port;
+    }
+    /**
+     * @param {Record<string, any>} payload
+     * @returns {Promise<any>}
+     */
+    async send(payload) {
+        const resolvedPort = this.port ?? (await BrowserRegistry.resolve(this.name)).port;
+        const ws = new WebSocket(`ws://127.0.0.1:${resolvedPort}`);
+        return await new Promise((resolve, reject) => {
+            ws.on("open", () => {
+                ws.send(JSON.stringify(payload));
+            });
+            ws.on("message", (rawData) => {
+                const response = JSON.parse(rawData.toString());
+                ws.close();
+                if (response.ok) {
+                    resolve(response.result);
+                }
+                else {
+                    reject(new Error(response.error));
+                }
+            });
+            ws.on("error", reject);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/browser-command-runner.d.ts

@@ -0,0 +1,27 @@
+/** Runs browser commands across CLI and WebSocket transports. */
+export default class BrowserCommandRunner {
+    /**
+     * @param {object} args
+     * @param {import("./browser.js").default} args.browser
+     */
+    constructor({ browser }: {
+        browser: import("./browser.js").default;
+    });
+    browser: import("./browser.js").default;
+    /**
+     * @param {Record<string, any>} commandArgs
+     * @returns {Record<string, any>}
+     */
+    normalizeFindArgs(commandArgs: Record<string, any>): Record<string, any>;
+    /**
+     * @param {import("selenium-webdriver").WebElement} element
+     * @returns {Promise<Record<string, any>>}
+     */
+    serializeElement(element: import("selenium-webdriver").WebElement): Promise<Record<string, any>>;
+    /**
+     * @param {string} command
+     * @param {Record<string, any>} commandArgs
+     * @returns {Promise<any>}
+     */
+    run(command: string, commandArgs?: Record<string, any>): Promise<any>;
+}

package/build/browser-command-runner.js

@@ -0,0 +1,144 @@
+/** Runs browser commands across CLI and WebSocket transports. */
+export default class BrowserCommandRunner {
+    /**
+     * @param {object} args
+     * @param {import("./browser.js").default} args.browser
+     */
+    constructor({ browser }) {
+        this.browser = browser;
+    }
+    /**
+     * @param {Record<string, any>} commandArgs
+     * @returns {Record<string, any>}
+     */
+    normalizeFindArgs(commandArgs) {
+        const findArgs = {};
+        if ("timeout" in commandArgs && commandArgs.timeout !== undefined) {
+            findArgs.timeout = Number(commandArgs.timeout);
+        }
+        if ("visible" in commandArgs && commandArgs.visible !== undefined) {
+            if (commandArgs.visible === null || commandArgs.visible === "null") {
+                findArgs.visible = null;
+            }
+            else if (typeof commandArgs.visible === "boolean") {
+                findArgs.visible = commandArgs.visible;
+            }
+            else {
+                findArgs.visible = commandArgs.visible === "true";
+            }
+        }
+        if ("useBaseSelector" in commandArgs && commandArgs.useBaseSelector !== undefined) {
+            if (typeof commandArgs.useBaseSelector === "boolean") {
+                findArgs.useBaseSelector = commandArgs.useBaseSelector;
+            }
+            else {
+                findArgs.useBaseSelector = commandArgs.useBaseSelector === "true";
+            }
+        }
+        return findArgs;
+    }
+    /**
+     * @param {import("selenium-webdriver").WebElement} element
+     * @returns {Promise<Record<string, any>>}
+     */
+    async serializeElement(element) {
+        const text = await element.getText();
+        const tagName = await element.getTagName();
+        const displayed = await element.isDisplayed();
+        return { displayed, tagName, text };
+    }
+    /**
+     * @param {string} command
+     * @param {Record<string, any>} commandArgs
+     * @returns {Promise<any>}
+     */
+    async run(command, commandArgs = {}) {
+        if (command === "visit") {
+            const path = commandArgs.path ?? commandArgs.url;
+            if (!path) {
+                throw new Error("visit requires path or url");
+            }
+            await this.browser.visit(path);
+            return { ok: true };
+        }
+        if (command === "dismissTo") {
+            const path = commandArgs.path ?? commandArgs.url;
+            if (!path) {
+                throw new Error("dismissTo requires path or url");
+            }
+            await this.browser.dismissTo(path);
+            return { ok: true };
+        }
+        if (command === "setBaseSelector") {
+            if (!commandArgs.selector) {
+                throw new Error("setBaseSelector requires selector");
+            }
+            this.browser.setBaseSelector(commandArgs.selector);
+            return { ok: true };
+        }
+        if (command === "getCurrentUrl") {
+            return { currentUrl: await this.browser.getCurrentUrl() };
+        }
+        if (command === "getHTML") {
+            return { html: await this.browser.getHTML() };
+        }
+        if (command === "getBrowserLogs") {
+            return { logs: await this.browser.getBrowserLogs() };
+        }
+        if (command === "takeScreenshot") {
+            return await this.browser.takeScreenshot();
+        }
+        if (command === "find") {
+            if (!commandArgs.selector) {
+                throw new Error("find requires selector");
+            }
+            const element = await this.browser.find(commandArgs.selector, this.normalizeFindArgs(commandArgs));
+            return { element: await this.serializeElement(element) };
+        }
+        if (command === "findByTestID") {
+            const testID = commandArgs.testID ?? commandArgs.testId;
+            if (!testID) {
+                throw new Error("findByTestID requires testID");
+            }
+            const element = await this.browser.findByTestID(testID, this.normalizeFindArgs(commandArgs));
+            return { element: await this.serializeElement(element) };
+        }
+        if (command === "click") {
+            const selector = commandArgs.selector;
+            if (!selector) {
+                throw new Error("click requires selector");
+            }
+            await this.browser.click(selector, this.normalizeFindArgs(commandArgs));
+            return { ok: true };
+        }
+        if (command === "waitForNoSelector") {
+            if (!commandArgs.selector) {
+                throw new Error("waitForNoSelector requires selector");
+            }
+            await this.browser.waitForNoSelector(commandArgs.selector, this.normalizeFindArgs(commandArgs));
+            return { ok: true };
+        }
+        if (command === "expectNoElement") {
+            if (!commandArgs.selector) {
+                throw new Error("expectNoElement requires selector");
+            }
+            await this.browser.expectNoElement(commandArgs.selector, this.normalizeFindArgs(commandArgs));
+            return { ok: true };
+        }
+        if (command === "interact") {
+            const selector = commandArgs.selector;
+            const methodName = commandArgs.methodName ?? commandArgs.method;
+            const methodArgs = Array.isArray(commandArgs.args) ? commandArgs.args : [];
+            if (!selector) {
+                throw new Error("interact requires selector");
+            }
+            if (!methodName) {
+                throw new Error("interact requires methodName");
+            }
+            const result = await this.browser.interact({ selector, ...this.normalizeFindArgs(commandArgs) }, methodName, ...methodArgs);
+            return { result };
+        }
+        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 {Record<string, any>}\n   */\n  normalizeFindArgs(commandArgs) {\n    const findArgs = {}\n\n    if (\"timeout\" in commandArgs && commandArgs.timeout !== undefined) {\n      findArgs.timeout = Number(commandArgs.timeout)\n    }\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    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)\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)\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\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      const result = await this.browser.interact({selector, ...this.normalizeFindArgs(commandArgs)}, methodName, ...methodArgs)\n\n      return {result}\n    }\n\n    throw new Error(`Unknown browser command: ${command}`)\n  }\n}\n"]}

package/build/browser-process.d.ts

@@ -0,0 +1,45 @@
+/** Long-running browser daemon exposing browser commands over WebSocket. */
+export default class BrowserProcess {
+    /**
+     * @param {object} args
+     * @param {string} args.name
+     * @param {Browser} [args.browser]
+     * @param {Record<string, any>} [args.browserArgs]
+     * @param {string} [args.baseUrl]
+     * @param {boolean} [args.debug]
+     * @param {number} [args.port]
+     */
+    constructor({ name, browser, browserArgs, baseUrl, debug, port }: {
+        name: string;
+        browser?: Browser;
+        browserArgs?: Record<string, any>;
+        baseUrl?: string;
+        debug?: boolean;
+        port?: number;
+    });
+    name: string;
+    browser: Browser;
+    baseUrl: string;
+    debug: boolean;
+    requestRunner: BrowserCommandRunner;
+    requestCount: number;
+    port: number;
+    /** @returns {Promise<void>} */
+    start(): Promise<void>;
+    wss: import("ws").Server<typeof import("ws").default, typeof import("node:http").IncomingMessage>;
+    /** @returns {Promise<void>} */
+    stop(): Promise<void>;
+    stopped: boolean;
+    /**
+     * @param {import("ws").WebSocket} ws
+     * @returns {void}
+     */
+    onConnection: (ws: import("ws").WebSocket) => void;
+    /**
+     * @param {Record<string, any>} payload
+     * @returns {Promise<any>}
+     */
+    handlePayload(payload: Record<string, any>): Promise<any>;
+}
+import Browser from "./browser.js";
+import BrowserCommandRunner from "./browser-command-runner.js";