@itmetsam/samurai-framework 0.9.0 → 0.10.0

package/README.md

@@ -82,7 +82,7 @@ import { defineConfig } from "./src/config/config.js";
 
 export default defineConfig({
   srcDir: "./src/tests",
-  browser: "firefox",
+  browsers: ["firefox"],
   timeout: 30000,
   environments: {
     staging: { baseURL: "https://staging.example.com" },

package/dist/browser/chrome-launch.d.ts

@@ -33,6 +33,18 @@ export declare const chromeCapabilities: (launch: ChromeLaunch) => {
         };
     };
 };
+/** Another Chrome has the profile open: a second one would wait for it until the start timeout */
+export declare class ChromeProfileInUseError extends Error {
+    readonly profileDir: string;
+    readonly pid: number;
+    constructor(profileDir: string, pid: number);
+}
+/**
+ * The process of a Chrome that has `profileDir` open, if there is one. Chrome marks a profile it uses with a
+ * `SingletonLock` link named `<host>-<pid>` and removes it when it closes; a link left by a process that is gone, or
+ * by another computer sharing the folder, does not count. Windows keeps no such link: nothing is found there.
+ */
+export declare function chromeUsingProfile(profileDir: string, host?: string, alive?: (pid: number) => boolean): number | undefined;
 /**
  * Chrome speaks BiDi through its chromedriver: this starts one, asks it for a session with `webSocketUrl`, and
  * connects to the socket it hands back. The session exists when this resolves, so there is no `session.new`.

package/dist/browser/chrome-launch.js

@@ -1,6 +1,8 @@
 import { spawn } from "node:child_process";
 import EventEmitter from "node:events";
-import { mkdirSync } from "node:fs";
+import { mkdirSync, readlinkSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import logger from "../logger/index.js";
 import { BiDiConnector } from "../transport/bidi-connection.js";
 import { SESSION_CAPABILITIES } from "./session-capabilities.js";
@@ -27,6 +29,44 @@ export const chromeCapabilities = (launch) => ({
         },
     },
 });
+/** Another Chrome has the profile open: a second one would wait for it until the start timeout */
+export class ChromeProfileInUseError extends Error {
+    constructor(profileDir, pid) {
+        super(`Chrome is already running on the profile ${profileDir} (process ${pid}). Close that Chrome, or end the process if a previous run left it behind.`);
+        this.profileDir = profileDir;
+        this.pid = pid;
+        this.name = "ChromeProfileInUseError";
+    }
+}
+/**
+ * The process of a Chrome that has `profileDir` open, if there is one. Chrome marks a profile it uses with a
+ * `SingletonLock` link named `<host>-<pid>` and removes it when it closes; a link left by a process that is gone, or
+ * by another computer sharing the folder, does not count. Windows keeps no such link: nothing is found there.
+ */
+export function chromeUsingProfile(profileDir, host = os.hostname(), alive = isAlive) {
+    let target;
+    try {
+        target = readlinkSync(path.join(profileDir, "SingletonLock"));
+    }
+    catch {
+        return undefined;
+    }
+    const match = /^(.*)-(\d+)$/.exec(target);
+    if (!match || match[1] !== host)
+        return undefined;
+    const pid = Number(match[2]);
+    return alive(pid) ? pid : undefined;
+}
+function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        // No permission to signal it still means it exists
+        return err.code === "EPERM";
+    }
+}
 /**
  * Chrome speaks BiDi through its chromedriver: this starts one, asks it for a session with `webSocketUrl`, and
  * connects to the socket it hands back. The session exists when this resolves, so there is no `session.new`.
@@ -34,6 +74,9 @@ export const chromeCapabilities = (launch) => ({
  */
 export async function launchChrome(launch) {
     mkdirSync(launch.profileDir, { recursive: true });
+    const running = chromeUsingProfile(launch.profileDir);
+    if (running !== undefined)
+        throw new ChromeProfileInUseError(launch.profileDir, running);
     launch.signal?.throwIfAborted();
     const driver = spawn(launch.driverPath, ["--port=0"], {
         stdio: ["ignore", "pipe", "pipe"],

package/dist/cli/args.d.ts

@@ -1,4 +1,6 @@
-import type { ProjectOptions } from "../runner/run.js";
+import { type ProjectOptions, type RunnerOptions } from "../runner/run.js";
+/** `firefox` or `chrome` */
+type SupportedBrowser = NonNullable<RunnerOptions["browsers"]>[number];
 /** The values a command line can override for one run */
 type RunOverrides = Pick<ProjectOptions, "environment" | "timeout" | "expectTimeout">;
 /** Flags and positional arguments of a command line; an unknown flag is an error */
@@ -11,6 +13,7 @@ export declare function parseCommandLine(argv: string[]): {
         port?: string | undefined;
         grep?: string | undefined;
         group?: string | undefined;
+        browser?: string[] | undefined;
         file?: string[] | undefined;
         json?: boolean | undefined;
         all?: boolean | undefined;
@@ -33,8 +36,10 @@ export interface RunnerFlags {
     grep?: string;
     group?: string;
     files?: string[];
+    /** `--browser`, repeated for more than one; replaces the config's `browsers` for this run */
+    browsers?: SupportedBrowser[];
 }
-/** Reads `--headless`, `--port <n>`, `--grep <text>`, `--group <name>` and `--file <spec>` (repeatable) from `argv` */
+/** Reads `--headless`, `--port <n>`, `--grep <text>`, `--group <name>`, `--file <spec>` and `--browser <name>` (both repeatable) from `argv` */
 export declare function parseRunnerFlags(argv: string[]): RunnerFlags;
 /** Reads `--env`, `--timeout` and `--expect-timeout` from `argv`; the environment falls back to SAMURAI_ENV */
 export declare function parseRunOverrides(argv: string[], env?: Partial<NodeJS.ProcessEnv>): RunOverrides;

package/dist/cli/args.js

@@ -1,4 +1,5 @@
 import { parseArgs } from "node:util";
+import { checkBrowserList, } from "../runner/run.js";
 const FLAGS = {
     env: { type: "string" },
     timeout: { type: "string" },
@@ -7,6 +8,7 @@ const FLAGS = {
     port: { type: "string" },
     grep: { type: "string" },
     group: { type: "string" },
+    browser: { type: "string", multiple: true },
     file: { type: "string", multiple: true },
     json: { type: "boolean" },
     all: { type: "boolean" },
@@ -33,7 +35,7 @@ export function parseCommandLine(argv) {
 function parseFlags(argv) {
     return parseCommandLine(argv).values;
 }
-/** Reads `--headless`, `--port <n>`, `--grep <text>`, `--group <name>` and `--file <spec>` (repeatable) from `argv` */
+/** Reads `--headless`, `--port <n>`, `--grep <text>`, `--group <name>`, `--file <spec>` and `--browser <name>` (both repeatable) from `argv` */
 export function parseRunnerFlags(argv) {
     const values = parseFlags(argv);
     const flags = {};
@@ -52,6 +54,10 @@ export function parseRunnerFlags(argv) {
         flags.group = values.group;
     if (values.file?.length)
         flags.files = values.file;
+    if (values.browser?.length) {
+        checkBrowserList(values.browser, "--browser");
+        flags.browsers = values.browser;
+    }
     return flags;
 }
 /** Reads `--env`, `--timeout` and `--expect-timeout` from `argv`; the environment falls back to SAMURAI_ENV */

package/dist/cli/console-reporter.d.ts

@@ -8,8 +8,12 @@ export interface ConsoleReporterOptions {
 export declare class ConsoleReporter {
     private readonly write;
     private readonly paint;
+    /** Whether the run has more than one browser: only then is each test labelled with its browser */
+    private labelled;
     constructor({ write, color }: ConsoleReporterOptions);
     handle(event: RunEvent): void;
+    /** ` [chrome]` in a run with more than one browser, else nothing */
+    private tag;
     private line;
     private summary;
 }

package/dist/cli/console-reporter.js

@@ -2,16 +2,19 @@ const seconds = (ms) => `${(ms / 1000).toFixed(1)}s`;
 /** Prints a run for a person: one line per test as it ends, then every failure in full and a count */
 export class ConsoleReporter {
     constructor({ write, color }) {
+        /** Whether the run has more than one browser: only then is each test labelled with its browser */
+        this.labelled = false;
         this.write = write;
         this.paint = (code, text) => color ? `\u001b[${code}m${text}\u001b[0m` : text;
     }
     handle(event) {
         switch (event.type) {
             case "run-start":
-                this.write(`Running ${event.total} ${event.total === 1 ? "test" : "tests"} against ${event.environment}\n`);
+                this.labelled = event.browsers.length > 1;
+                this.write(`Running ${event.total} ${event.total === 1 ? "test" : "tests"} against ${event.environment}${this.labelled ? ` in ${event.browsers.join(", ")}` : ""}\n`);
                 return;
             case "test-end":
-                this.write(`  ${this.line(event.name, event.result)}\n`);
+                this.write(`  ${this.line(event.name, event.result, event.browser)}\n`);
                 return;
             case "run-end":
                 this.summary(event.summary);
@@ -20,13 +23,17 @@ export class ConsoleReporter {
                 return;
         }
     }
-    line(name, result) {
+    /** ` [chrome]` in a run with more than one browser, else nothing */
+    tag(browser) {
+        return this.labelled ? ` ${this.paint(90, `[${browser}]`)}` : "";
+    }
+    line(name, result, browser) {
         const took = "duration" in result
             ? ` ${this.paint(90, `(${seconds(result.duration)})`)}`
             : "";
         return result.status === "success"
-            ? `${this.paint(32, "✔")} ${name}${took}`
-            : `${this.paint(31, "✖")} ${name}${took}`;
+            ? `${this.paint(32, "✔")} ${name}${this.tag(browser)}${took}`
+            : `${this.paint(31, "✖")} ${name}${this.tag(browser)}${took}`;
     }
     summary(summary) {
         const failed = summary.tests.filter((test) => test.status !== "success");
@@ -34,7 +41,7 @@ export class ConsoleReporter {
             if (!("name" in test))
                 continue;
             const message = "message" in test ? test.message : "did not finish";
-            this.write(`\n${this.paint(31, `${test.name}`)}\n`);
+            this.write(`\n${this.paint(31, `${test.name}`)}${"browser" in test ? this.tag(test.browser) : ""}\n`);
             this.write(`${message
                 .split("\n")
                 .map((line) => `    ${line}`)

package/dist/cli/init.js

@@ -23,7 +23,7 @@ export function scaffold(name) {
 
 export default defineConfig({
   srcDir: "./tests",
-  browser: "firefox",
+  browsers: ["firefox"],
   timeout: 30000,
   environments: {
     local: { baseURL: "http://localhost:3000" },

package/dist/cli/main.d.ts

@@ -1,4 +1,4 @@
-export declare const USAGE = "samurai: browser tests over WebDriver BiDi\n\nUsage:\n  samurai run [options]       Run the tests (the default command)\n  samurai list [options]      List the tests without running them\n  samurai record <spec>       Open a browser and record what you do into a spec file\n  samurai init [folder]       Scaffold a project: config, an example test, .env.example\n  samurai flow <command>      List, check and run the flows in ./flows (see below)\n  samurai browsers [command]  List, install and remove the browsers SAMURAI launches\n\nOptions for run and list:\n  --env <name>                Environment to run against (or SAMURAI_ENV)\n  --file <spec>               Only this spec file; repeatable\n  --grep <text>               Only tests whose full name contains the text\n  --group <name>              Only the tests of this group of the config's groups\n  --json                      Machine-readable output: JSON lines for run, one array for list\n\nOptions for run:\n  --timeout <ms>              Time one test may take\n  --expect-timeout <ms>       Time actions and assertions retry\n  --headless, --no-headless   Run the browser without a window, or with one.\n                              Default: the config's use.headless, else headless when CI is set\n  --port <n>                  Browser debugging port (default 9223)\n\nOptions for record (also --env, --port, --json, --headless, --no-headless):\n  --new <title>               Add a test with this title (creates the spec file if needed)\n  --test <name|index>         Record into this test; not needed when the file has one\n  --at <n>                    Insert from step n (default: after the last step)\n  --url <url>                 Page to start on (default: the environment's baseURL)\n  Stop with Ctrl+C or by closing the browser window.\n\n  -h, --help                  Show this help\n  -v, --version               Show the version\n\nExit code: 0 when every test passed, 1 when a test failed, 2 for a usage or configuration error.\n\nsamurai flow:\n  list                        The flows in ./flows\n  check [<flow>...]           Check flows without running them\n  run <flow>... | --all       Run flows; each writes result/flows/<id>.json\n  Options for run: --env, --headless, --timeout, --expect-timeout, --port, --json, --allow-unsupported\n  Run `samurai flow` alone for the details.\n\nsamurai browsers:\n  list                        The pinned browsers and every build in the cache (the default)\n  install [firefox|chrome|all]\n                              Download the pinned builds (default: all)\n  uninstall <name> [--build <id>] | --unused\n\nRun it in the project folder, the one holding samurai.config.ts.\n";
+export declare const USAGE = "samurai: browser tests over WebDriver BiDi\n\nUsage:\n  samurai run [options]       Run the tests (the default command)\n  samurai list [options]      List the tests without running them\n  samurai record <spec>       Open a browser and record what you do into a spec file\n  samurai init [folder]       Scaffold a project: config, an example test, .env.example\n  samurai flow <command>      List, check and run the flows in ./flows (see below)\n  samurai browsers [command]  List, install and remove the browsers SAMURAI launches\n\nOptions for run and list:\n  --env <name>                Environment to run against (or SAMURAI_ENV)\n  --file <spec>               Only this spec file; repeatable\n  --grep <text>               Only tests whose full name contains the text\n  --group <name>              Only the tests of this group of the config's groups\n  --browser <name>            Run in this browser (firefox or chrome) instead of the config's\n                              browsers; repeat it for more than one\n  --json                      Machine-readable output: JSON lines for run, one array for list\n\nOptions for run:\n  --timeout <ms>              Time one test may take\n  --expect-timeout <ms>       Time actions and assertions retry\n  --headless, --no-headless   Run the browser without a window, or with one.\n                              Default: the config's use.headless, else headless when CI is set\n  --port <n>                  Browser debugging port (default 9223)\n\nOptions for record (also --env, --port, --json, --headless, --no-headless):\n  --browser <name>            Record in this browser (default: the first of the config's browsers)\n  --new <title>               Add a test with this title (creates the spec file if needed)\n  --test <name|index>         Record into this test; not needed when the file has one\n  --at <n>                    Insert from step n (default: after the last step)\n  --url <url>                 Page to start on (default: the environment's baseURL)\n  Stop with Ctrl+C or by closing the browser window.\n\n  -h, --help                  Show this help\n  -v, --version               Show the version\n\nExit code: 0 when every test passed, 1 when a test failed, 2 for a usage or configuration error.\n\nsamurai flow:\n  list                        The flows in ./flows\n  check [<flow>...]           Check flows without running them\n  run <flow>... | --all       Run flows; each writes result/flows/<id>.json\n  Options for run: --env, --headless, --timeout, --expect-timeout, --port, --json, --allow-unsupported\n  Run `samurai flow` alone for the details.\n\nsamurai browsers:\n  list                        The pinned browsers and every build in the cache (the default)\n  install [firefox|chrome|all]\n                              Download the pinned builds (default: all)\n  uninstall <name> [--build <id>] | --unused\n\nRun it in the project folder, the one holding samurai.config.ts.\n";
 export interface Io {
     out: (text: string) => void;
     err: (text: string) => void;

package/dist/cli/main.js

@@ -22,6 +22,8 @@ Options for run and list:
   --file <spec>               Only this spec file; repeatable
   --grep <text>               Only tests whose full name contains the text
   --group <name>              Only the tests of this group of the config's groups
+  --browser <name>            Run in this browser (firefox or chrome) instead of the config's
+                              browsers; repeat it for more than one
   --json                      Machine-readable output: JSON lines for run, one array for list
 
 Options for run:
@@ -32,6 +34,7 @@ Options for run:
   --port <n>                  Browser debugging port (default 9223)
 
 Options for record (also --env, --port, --json, --headless, --no-headless):
+  --browser <name>            Record in this browser (default: the first of the config's browsers)
   --new <title>               Add a test with this title (creates the spec file if needed)
   --test <name|index>         Record into this test; not needed when the file has one
   --at <n>                    Insert from step n (default: after the last step)
@@ -99,6 +102,8 @@ export async function main(argv, io) {
             if (at !== undefined && (!Number.isInteger(at) || at < 0))
                 throw new Error(`--at must be a step number, got "${values.at}"`);
             const flags = parseRunnerFlags(rest);
+            if (flags.browsers && flags.browsers.length > 1)
+                throw new Error("--browser: a recording uses one browser");
             const test = values.test === undefined
                 ? undefined
                 : /^\d+$/.test(values.test)
@@ -116,6 +121,7 @@ export async function main(argv, io) {
                 ...(values.url !== undefined && { url: values.url }),
                 ...(flags.headless !== undefined && { headless: flags.headless }),
                 ...(flags.port !== undefined && { port: flags.port }),
+                ...(flags.browsers && { browser: flags.browsers[0] }),
                 ...(io.signal && { signal: io.signal }),
                 onStarted: () => {
                     if (!values.json)
@@ -178,6 +184,7 @@ export async function main(argv, io) {
             ...(flags.grep !== undefined && { grep: flags.grep }),
             ...(flags.group !== undefined && { group: flags.group }),
             ...(flags.files && { files: flags.files }),
+            ...(flags.browsers && { browsers: flags.browsers }),
         };
         if (command === "list") {
             const tests = await listTests(options);

package/dist/config/config.js

@@ -1,6 +1,7 @@
 import path from "path";
 import logger from "../logger/index.js";
 import { pathToFileURL } from "url";
+import { validateBrowserConfig } from "../runner/browsers.js";
 let activeProject;
 /** Makes `project` the one config, secrets, reports and downloads are resolved for; `undefined` ends it */
 export function setActiveProject(project) {
@@ -22,14 +23,17 @@ export function browsersDir() {
 }
 /** The whole `samurai.config.ts` of the project (the working directory unless a project is active) */
 export async function loadConfig() {
-    if (activeProject?.config)
+    if (activeProject?.config) {
+        validateBrowserConfig(activeProject.config);
         return activeProject.config;
+    }
     const configUrl = path.join(projectDir(), "samurai.config.ts");
     logger.debug("Reading config from: %s", configUrl);
     const config = (await import(pathToFileURL(configUrl).href));
     if (!config.default) {
         throw new Error("samurai.config.ts does not export defineConfig as default!");
     }
+    validateBrowserConfig(config.default);
     return config.default;
 }
 /** A project's config without keeping the project active (`withProject` is one at a time): the given one, else its samurai.config.ts */

package/dist/flows/run/handlers/support.d.ts

@@ -1,5 +1,6 @@
 import { type AnyNodeDefinition, type ExpressionContext, type FlowFile, type FlowNodeModel } from "../../core/index.js";
 import type { RunEvent } from "../../../runner/reporter.js";
+import type { SupportedBrowser } from "../../../types/browser.js";
 import type { NodeResult, NodeTest } from "../events.js";
 /** What a handler can use of the run */
 export interface HandlerRun {
@@ -10,8 +11,10 @@ export interface HandlerRun {
     };
     context: ExpressionContext;
     nodeTests: Record<string, NodeTest[]>;
+    /** The browsers of the nodes that have their own (a Group node's group); the others use the project's */
+    nodeBrowsers?: Record<string, SupportedBrowser[]>;
     signal: AbortSignal;
-    runTests: (tests: NodeTest[], onEvent: (e: RunEvent) => void) => Promise<"passed" | "failed" | "cancelled">;
+    runTests: (tests: NodeTest[], onEvent: (e: RunEvent) => void, browsers?: SupportedBrowser[]) => Promise<"passed" | "failed" | "cancelled">;
     sleep: (ms: number, signal: AbortSignal) => Promise<void>;
     onTestEvent: (nodeId: string, e: RunEvent) => void;
     /** Definitions of kinds core doesn't have (steps), for expression scopes */

package/dist/flows/run/handlers/support.js

@@ -7,7 +7,7 @@ export const fail = (e) => ({
 export async function runNodeTests(node, run, list) {
     let result;
     try {
-        result = await run.runTests(list, (e) => run.onTestEvent(node.id, e));
+        result = await run.runTests(list, (e) => run.onTestEvent(node.id, e), run.nodeBrowsers?.[node.id]);
     }
     catch (e) {
         return fail(e);

package/dist/flows/run/project.js

@@ -109,6 +109,7 @@ export async function runFlowInProject(options) {
     // Phase 3: walk it
     const byId = new Map(tests.map((t) => [t.id, t]));
     const nodeTests = {};
+    const nodeBrowsers = {};
     for (const node of flow.nodes) {
         const ids = node.kind === "test"
             ? [node.ref?.testId ?? ""]
@@ -117,6 +118,11 @@ export async function runFlowInProject(options) {
                 : undefined;
         if (!ids)
             continue;
+        if (node.kind === "group") {
+            const browsers = groups.find((g) => g.name === node.ref?.group)?.browsers;
+            if (browsers)
+                nodeBrowsers[node.id] = browsers;
+        }
         nodeTests[node.id] = ids.flatMap((id) => {
             const t = byId.get(id);
             return t ? [{ file: t.file, name: t.name }] : [];
@@ -126,6 +132,7 @@ export async function runFlowInProject(options) {
     return runFlow({
         flow,
         nodeTests,
+        nodeBrowsers,
         environment,
         ...(options.signal && { signal: options.signal }),
         ...(options.onEvent && { onEvent: options.onEvent }),
@@ -133,7 +140,7 @@ export async function runFlowInProject(options) {
         unsupported,
         handlers: { ...HANDLERS, ...steps.handlers },
         nodes: steps.nodes,
-        runTests: async ({ tests, onEvent, signal }) => {
+        runTests: async ({ tests, onEvent, signal, browsers }) => {
             const summary = await run({
                 projectDir,
                 config,
@@ -148,6 +155,7 @@ export async function runFlowInProject(options) {
                     expectTimeout: options.expectTimeout,
                 }),
                 ...(options.port !== undefined && { port: options.port }),
+                ...(browsers && { browsers }),
                 files: [...new Set(tests.map((t) => t.file))],
                 testNames: tests.map((t) => t.name),
                 reportPath: false,

package/dist/flows/run/run.d.ts

@@ -2,10 +2,13 @@ import { type AnyNodeDefinition, type FlowFile } from "../core/index.js";
 import type { RunEvent } from "../../runner/reporter.js";
 import type { FlowEvent, FlowSummary, NodeTest } from "./events.js";
 import { type Handler } from "./handlers/index.js";
+import type { SupportedBrowser } from "../../types/browser.js";
 export interface RunFlowOptions {
     flow: FlowFile;
     /** The tests of each Test and Group node, by node id */
     nodeTests: Record<string, NodeTest[]>;
+    /** The browsers a Group node runs in (its group's); a node not listed uses the project's */
+    nodeBrowsers?: Record<string, SupportedBrowser[]>;
     environment: {
         name: string;
         variables: Record<string, string | number | boolean>;
@@ -20,6 +23,8 @@ export interface RunFlowOptions {
         tests: NodeTest[];
         onEvent: (e: RunEvent) => void;
         signal: AbortSignal;
+        /** Set for a node that runs in browsers of its own */
+        browsers?: SupportedBrowser[];
     }) => Promise<"passed" | "failed" | "cancelled">;
     sleep?: (ms: number, signal: AbortSignal) => Promise<void>;
     /**

package/dist/flows/run/run.js

@@ -65,9 +65,15 @@ export async function runFlow(options) {
         environment: options.environment,
         context,
         nodeTests: options.nodeTests,
+        ...(options.nodeBrowsers && { nodeBrowsers: options.nodeBrowsers }),
         signal,
         sleep: options.sleep ?? defaultSleep,
-        runTests: (tests, onTestEvent) => options.runTests({ tests, onEvent: onTestEvent, signal }),
+        runTests: (tests, onTestEvent, browsers) => options.runTests({
+            tests,
+            onEvent: onTestEvent,
+            signal,
+            ...(browsers && { browsers }),
+        }),
         onTestEvent: (nodeId, event) => onEvent({ type: "test", nodeId, event }),
         nodes,
         log: (nodeId, level, text) => logger[level](`[${nodeId}] ${text}`),

package/dist/recorder/session.d.ts

@@ -1,5 +1,6 @@
 import { Browser } from "../browser/browser.js";
 import type Page from "../browser/page.js";
+import type { SupportedBrowser } from "../types/browser.js";
 import type { PreparedRun } from "../runner/prepare-run.js";
 import { type ProjectOptions } from "../runner/project.js";
 import type { SamuraiTestConfig } from "../types/config.js";
@@ -20,6 +21,8 @@ export interface RecordSpecOptions extends ProjectOptions {
     at?: number;
     /** The page to start on. @default the environment's base URL; without one the browser starts blank */
     url?: string;
+    /** The browser to record in. @default the first of the config's `browsers`, else Firefox */
+    browser?: SupportedBrowser;
     /** The browser's debugging port. @default 9223 */
     port?: number;
     /** Run the browser without a window. A person can't use it then; for tests and machines without a display. @default the config's `use.headless`, else headless on CI and a window otherwise */

package/dist/recorder/session.js

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { Browser } from "../browser/browser.js";
 import { ensureWarm } from "../browser/warm-up.js";
+import { browsersFor } from "../runner/browsers.js";
 import { loadConfig, projectDir, readConfig } from "../config/config.js";
 import { loadSecrets } from "../config/secrets.js";
 import { filesFolder, isFolderIgnored, isGitIgnored, } from "../project/index.js";
@@ -101,7 +102,9 @@ export async function recordSpec(options) {
             throw new Error(`${options.file} does not exist; give a title with --new to create it`);
         }
         // Before the spec is touched: a recording without its browser changes nothing
-        const browserName = (await readConfig("browser")) ?? "firefox";
+        // Recording in two browsers at once makes no sense: the first of the project's, or the one asked for
+        const browserName = options.browser ??
+            browsersFor({ project: await readConfig("browsers") })[0];
         await ensureWarm(browserName, { port: options.port ?? 9223 }, options.signal);
         options.signal?.throwIfAborted();
         source ??= "";

package/dist/runner/browsers.d.ts

@@ -0,0 +1,22 @@
+import type { SupportedBrowser } from "../types/browser.js";
+import type { SamuraiTestConfig } from "../types/config.js";
+/** Every browser a config may name, in the order the messages list them */
+export declare const BROWSER_NAMES: readonly SupportedBrowser[];
+/** The browsers of a run that names none */
+export declare const DEFAULT_BROWSERS: readonly SupportedBrowser[];
+/** Throws when `list` is not a non-empty list of distinct browser names; `where` names the key in the message */
+export declare function checkBrowserList(list: unknown, where: string): void;
+/**
+ * Checks the browser keys of a config: the removed `browser`, and `browsers` on the project and on each group.
+ * Throws an Error that says what to write instead.
+ */
+export declare function validateBrowserConfig(config: SamuraiTestConfig): void;
+/**
+ * The browsers a run uses, the first that is set winning: the command line, the group being run, the project, then
+ * Firefox. An empty list counts as not given.
+ */
+export declare function browsersFor(sources: {
+    flag?: readonly SupportedBrowser[] | undefined;
+    group?: readonly SupportedBrowser[] | undefined;
+    project?: readonly SupportedBrowser[] | undefined;
+}): SupportedBrowser[];

package/dist/runner/browsers.js

@@ -0,0 +1,44 @@
+/** Every browser a config may name, in the order the messages list them */
+export const BROWSER_NAMES = ["firefox", "chrome"];
+/** The browsers of a run that names none */
+export const DEFAULT_BROWSERS = ["firefox"];
+const isBrowser = (value) => typeof value === "string" &&
+    BROWSER_NAMES.includes(value);
+/** Throws when `list` is not a non-empty list of distinct browser names; `where` names the key in the message */
+export function checkBrowserList(list, where) {
+    if (!Array.isArray(list) || list.length === 0)
+        throw new Error(`${where} must list at least one browser.`);
+    const seen = new Set();
+    for (const name of list) {
+        if (!isBrowser(name))
+            throw new Error(`Unknown browser "${String(name)}" in ${where}. Choose ${BROWSER_NAMES.join(" or ")}.`);
+        if (seen.has(name))
+            throw new Error(`Browser "${name}" is listed twice in ${where}.`);
+        seen.add(name);
+    }
+}
+/**
+ * Checks the browser keys of a config: the removed `browser`, and `browsers` on the project and on each group.
+ * Throws an Error that says what to write instead.
+ */
+export function validateBrowserConfig(config) {
+    const legacy = config.browser;
+    if (legacy !== undefined)
+        throw new Error(`"browser" was replaced by "browsers": use browsers: [${JSON.stringify(legacy)}]`);
+    if (config.browsers !== undefined)
+        checkBrowserList(config.browsers, "browsers");
+    config.groups?.forEach((group, index) => {
+        if (group.browsers !== undefined)
+            checkBrowserList(group.browsers, `groups[${index}].browsers`);
+    });
+}
+/**
+ * The browsers a run uses, the first that is set winning: the command line, the group being run, the project, then
+ * Firefox. An empty list counts as not given.
+ */
+export function browsersFor(sources) {
+    for (const list of [sources.flag, sources.group, sources.project])
+        if (list && list.length > 0)
+            return [...list];
+    return [...DEFAULT_BROWSERS];
+}

package/dist/runner/groups.d.ts

@@ -1,3 +1,4 @@
+import type { SupportedBrowser } from "../types/browser.js";
 import type { SamuraiGroup } from "../types/config.js";
 /** The test folder when the config names none */
 export declare const DEFAULT_SRC_DIR = "./src";
@@ -22,6 +23,8 @@ export interface ResolvedGroup {
         file: string;
         title: string;
     }[];
+    /** The browsers the group's tests run in: its own `browsers`, else the project's, else Firefox */
+    browsers: SupportedBrowser[];
 }
 /**
  * The real path of `p` (symlinks resolved), or `p` itself when it does not exist. Registered test files come
@@ -33,10 +36,11 @@ export declare const toPosix: (p: string) => string;
 /** The id of a test: its spec file relative to `srcDir` with `/` separators, then `::` and its full name */
 export declare const testId: (file: string, name: string) => string;
 /** Works out which of `tests` (files relative to `srcDir`) belong to the group */
-export declare function resolveGroup(group: SamuraiGroup, tests: GroupTest[], projectDir: string, srcDir: string): ResolvedGroup;
+export declare function resolveGroup(group: SamuraiGroup, tests: GroupTest[], projectDir: string, srcDir: string, projectBrowsers?: readonly SupportedBrowser[]): ResolvedGroup;
 /** Resolves every group of the config */
 export declare function resolveGroups(config: {
     groups?: SamuraiGroup[];
+    browsers?: SupportedBrowser[];
 }, tests: GroupTest[], projectDir: string, srcDir: string): ResolvedGroup[];
 /** The group called `name`, or an error naming the groups there are */
 export declare function findGroup<T extends {

package/dist/runner/groups.js

@@ -1,5 +1,6 @@
 import { realpathSync } from "node:fs";
 import { matchesGlob, relative, resolve } from "node:path";
+import { browsersFor } from "./browsers.js";
 /** The test folder when the config names none */
 export const DEFAULT_SRC_DIR = "./src";
 /** The spec pattern when a group names none */
@@ -21,7 +22,11 @@ export const toPosix = (p) => p.replace(/\\/g, "/");
 /** The id of a test: its spec file relative to `srcDir` with `/` separators, then `::` and its full name */
 export const testId = (file, name) => `${toPosix(file)}::${name}`;
 /** Works out which of `tests` (files relative to `srcDir`) belong to the group */
-export function resolveGroup(group, tests, projectDir, srcDir) {
+export function resolveGroup(group, tests, projectDir, srcDir, projectBrowsers) {
+    const browsers = browsersFor({
+        group: group.browsers,
+        project: projectBrowsers,
+    });
     const found = tests.map((t) => ({ ...t, id: testId(t.file, t.name) }));
     // Tests picked by hand override src and testMatch
     if (group.tests) {
@@ -38,6 +43,7 @@ export function resolveGroup(group, tests, projectDir, srcDir) {
             missing: picked
                 .filter((t) => !known.has(t.id))
                 .map(({ file, title }) => ({ file, title })),
+            browsers,
         };
     }
     const base = group.src ? resolve(projectDir, group.src) : srcDir;
@@ -54,11 +60,12 @@ export function resolveGroup(group, tests, projectDir, srcDir) {
         pattern: [group.src, group.testMatch].filter(Boolean).join(" · ") || pattern,
         testIds,
         missing: [],
+        browsers,
     };
 }
 /** Resolves every group of the config */
 export function resolveGroups(config, tests, projectDir, srcDir) {
-    return (config.groups ?? []).map((group) => resolveGroup(group, tests, projectDir, srcDir));
+    return (config.groups ?? []).map((group) => resolveGroup(group, tests, projectDir, srcDir, config.browsers));
 }
 /** The group called `name`, or an error naming the groups there are */
 export function findGroup(groups, name) {

package/dist/runner/reporter.d.ts

@@ -1,17 +1,22 @@
 import type { RegisteredTestCase, TestError, TestLogEntry, TestResult, TestSummary } from "../types/test.js";
+import type { SupportedBrowser } from "../types/browser.js";
 /** What a run reports while it happens */
 export type RunEvent = {
     type: "run-start";
     environment: string;
+    /** Every selected test in every browser */
     total: number;
+    browsers: SupportedBrowser[];
 } | {
     type: "test-start";
     name: string;
     file: string;
+    browser: SupportedBrowser;
 } | {
     type: "test-end";
     name: string;
     file: string;
+    browser: SupportedBrowser;
     result: TestResult;
 } | {
     type: "run-end";
@@ -20,6 +25,8 @@ export type RunEvent = {
 export interface ReporterOptions {
     /** The environment the run uses, recorded in the report */
     environment: string;
+    /** The browsers the run uses, in the order they run; recorded in the report */
+    browsers: SupportedBrowser[];
     /** Where the report is written. @default <cwd>/result/report.json */
     output?: string | false;
     /** Called with every event, in order. A throwing listener is ignored */
@@ -29,14 +36,15 @@ export default class TestReporter {
     private testResults;
     private summary;
     private environment;
+    private browsers;
     private output;
     private listener;
     constructor(options: ReporterOptions);
     private emit;
     onStart(total?: number): void;
     onEnd(): Promise<TestSummary>;
-    onTestStart(test: RegisteredTestCase): void;
-    onTestEnd(test: RegisteredTestCase, error?: TestError, extras?: {
+    onTestStart(test: RegisteredTestCase, browser: SupportedBrowser): void;
+    onTestEnd(test: RegisteredTestCase, browser: SupportedBrowser, error?: TestError, extras?: {
         logs?: TestLogEntry[];
         logsDropped?: number;
         screenshots?: {

package/dist/runner/reporter.js

@@ -2,14 +2,15 @@ import { mkdir, writeFile } from "fs/promises";
 import path from "path";
 import { projectDir } from "../config/config.js";
 import { maskDeep } from "../config/mask.js";
-/** Results are keyed by file and full title, so equal titles in different files or describe blocks stay apart */
-function keyOf(test) {
-    return `${test.file}::${test.name}`;
+/** Results are keyed by file, full title and browser, so equal titles in different files or describe blocks, and the same test in two browsers, stay apart */
+function keyOf(test, browser) {
+    return `${test.file}::${test.name}::${browser}`;
 }
 export default class TestReporter {
     constructor(options) {
         this.testResults = new Map();
         this.environment = options.environment;
+        this.browsers = [...options.browsers];
         this.output =
             options.output ?? path.join(projectDir(), "result/report.json");
         this.listener = options.onEvent;
@@ -29,9 +30,15 @@ export default class TestReporter {
             status: "failed",
             startTime: t.startTime,
             environment: this.environment,
+            browsers: this.browsers,
             tests: [],
         };
-        this.emit({ type: "run-start", environment: this.environment, total });
+        this.emit({
+            type: "run-start",
+            environment: this.environment,
+            total,
+            browsers: this.browsers,
+        });
     }
     async onEnd() {
         performance.mark(`group-finish`);
@@ -40,6 +47,7 @@ export default class TestReporter {
             ...this.summary,
             duration,
             environment: this.environment,
+            browsers: this.browsers,
             tests: Array.from(this.testResults.values()),
             status: Array.from(this.testResults.values()).every((r) => r.status === "success")
                 ? "success"
@@ -54,19 +62,25 @@ export default class TestReporter {
         this.emit({ type: "run-end", summary: this.summary });
         return this.summary;
     }
-    onTestStart(test) {
-        const key = keyOf(test);
+    onTestStart(test, browser) {
+        const key = keyOf(test, browser);
         const t = performance.mark(`${key}-start`);
         this.testResults.set(key, {
             name: test.name,
             file: test.file,
+            browser,
             status: "started",
             startTime: t.startTime,
         });
-        this.emit({ type: "test-start", name: test.name, file: test.file });
+        this.emit({
+            type: "test-start",
+            name: test.name,
+            file: test.file,
+            browser,
+        });
     }
-    onTestEnd(test, error, extras) {
-        const key = keyOf(test);
+    onTestEnd(test, browser, error, extras) {
+        const key = keyOf(test, browser);
         performance.mark(`${key}-finish`);
         const duration = performance.measure("test-duration", `${key}-start`, `${key}-finish`).duration;
         const result = maskDeep({
@@ -79,6 +93,12 @@ export default class TestReporter {
             ...(extras?.screenshots?.length && { screenshots: extras.screenshots }),
         });
         this.testResults.set(key, result);
-        this.emit({ type: "test-end", name: test.name, file: test.file, result });
+        this.emit({
+            type: "test-end",
+            name: test.name,
+            file: test.file,
+            browser,
+            result,
+        });
     }
 }

package/dist/runner/run.d.ts

@@ -24,6 +24,7 @@ export interface FoundTest {
 export declare function listTests(options?: RunTestsOptions): Promise<FoundTest[]>;
 /** Imports the project's specs without running anything and lists the config's groups with the tests each holds */
 export declare function listGroups(options?: RunTestsOptions): Promise<ResolvedGroup[]>;
+export { BROWSER_NAMES, checkBrowserList } from "./browsers.js";
 export type { RunEvent } from "./reporter.js";
 export type { TestError, TestResult, TestSummary } from "../types/test.js";
 export type { ResolvedGroup } from "./groups.js";

package/dist/runner/run.js

@@ -44,3 +44,4 @@ export async function listGroups(options = {}) {
         expectTimeout,
     }, async (run) => (await TestRunner.init(run, undefined, runner)).groups());
 }
+export { BROWSER_NAMES, checkBrowserList } from "./browsers.js";

package/dist/runner/test-runner.d.ts

@@ -1,3 +1,4 @@
+import type { SupportedBrowser } from "../types/browser.js";
 import type { RegisteredTestCase } from "../types/test.js";
 import type { PreparedRun } from "./prepare-run.js";
 import { type RunEvent } from "./reporter.js";
@@ -13,6 +14,8 @@ export interface RunnerOptions {
     testNames?: string[];
     /** Only the tests of this group of the config's `groups` (unknown name: an error). Combines with the other filters */
     group?: string;
+    /** The browsers to run in, instead of the group's or the project's `browsers` (the command line's `--browser`) */
+    browsers?: SupportedBrowser[];
     /** Run the browser without a window. @default false */
     headless?: boolean;
     /** Remote debugging port of the browser. @default 9223 */
@@ -49,7 +52,12 @@ export default class TestRunner {
     groups(): Promise<ResolvedGroup[]>;
     /** Imports the spec files and returns the tests the options select: by `group`, `testNames` and `grep` */
     register(): Promise<RegisteredTestCase[]>;
-    /** Runs the selected tests and returns the summary that was also written to the report */
+    /**
+     * The browsers the run uses: the options' (`--browser`), else the selected group's, else the project's, else
+     * Firefox. A group is only looked up when there is something to look up
+     */
+    private browsersOfRun;
+    /** Runs the selected tests in every browser of the run, one browser after the other, and returns the summary that was also written to the report */
     start(): Promise<import("../types/test.js").TestSummary>;
     private executeTestCase;
 }

package/dist/runner/test-runner.js

@@ -4,6 +4,8 @@ import path from "path";
 import { pathToFileURL } from "url";
 import { Browser } from "../browser/browser.js";
 import { ensureWarm } from "../browser/warm-up.js";
+import { projectBrowser } from "../browsers/resolve.js";
+import { browsersFor } from "./browsers.js";
 import { loadConfig, projectDir, readConfig } from "../config/config.js";
 import logger from "../logger/index.js";
 import { assertModuleProject } from "./module-type.js";
@@ -108,34 +110,59 @@ export default class TestRunner {
         }
         return all.filter((test) => inGroup(test) && isSelected(test.name, this.options));
     }
-    /** Runs the selected tests and returns the summary that was also written to the report */
+    /**
+     * The browsers the run uses: the options' (`--browser`), else the selected group's, else the project's, else
+     * Firefox. A group is only looked up when there is something to look up
+     */
+    async browsersOfRun() {
+        const { browsers: flag, group } = this.options;
+        const config = await loadConfig();
+        let ofGroup;
+        if (group !== undefined && !(flag && flag.length > 0)) {
+            const { groups } = await this.resolveAll(await this.registerAll());
+            ofGroup = findGroup(groups, group).browsers;
+        }
+        return browsersFor({ flag, group: ofGroup, project: config.browsers });
+    }
+    /** Runs the selected tests in every browser of the run, one browser after the other, and returns the summary that was also written to the report */
     async start() {
         const { reportPath, onEvent, signal } = this.options;
+        const selected = await this.register();
+        const browsers = await this.browsersOfRun();
         const reporter = new TestReporter({
             environment: this.run.settings.environment,
+            browsers,
             ...(reportPath !== undefined && { output: reportPath }),
             ...(onEvent && { onEvent }),
         });
-        const selected = await this.register();
         this.srcDir = realDirs((await loadConfig()).srcDir).srcDir;
-        // A missing browser is one clear error before the run, not a failure per test; a fresh build's slow
-        // first start happens here, outside any test's timeout
-        if (selected.length > 0)
-            await ensureWarm((await readConfig("browser")) ?? "firefox", { port: this.options.port ?? 9223 }, signal);
-        reporter.onStart(selected.length);
-        for (const test of selected) {
-            if (signal?.aborted) {
-                reporter.onTestStart(test);
-                reporter.onTestEnd(test, { message: "Run aborted", type: "error" });
-                continue;
+        // A missing browser is one clear error before the run, not a failure per test, and before any browser has run a
+        // test; a fresh build's slow first start happens here too, outside any test's timeout
+        if (selected.length > 0) {
+            for (const browser of browsers)
+                await projectBrowser(browser);
+            for (const browser of browsers)
+                await ensureWarm(browser, { port: this.options.port ?? 9223 }, signal);
+        }
+        reporter.onStart(selected.length * browsers.length);
+        for (const browser of browsers) {
+            for (const test of selected) {
+                if (signal?.aborted) {
+                    reporter.onTestStart(test, browser);
+                    reporter.onTestEnd(test, browser, {
+                        message: "Run aborted",
+                        type: "error",
+                    });
+                    continue;
+                }
+                await this.executeTestCase(test, browser, reporter);
             }
-            await this.executeTestCase(test, reporter);
         }
         return reporter.onEnd();
     }
-    async executeTestCase(test, reporter) {
-        logger.verbose("Starting test: %s", test.name);
-        reporter.onTestStart(test);
+    async executeTestCase(test, selectedBrowser, reporter) {
+        logger.verbose("Starting test: %s in %s", test.name, selectedBrowser);
+        reporter.onTestStart(test, selectedBrowser);
         // A test ends once, whichever of finishing, failing, timing out, an abort or a closed browser comes first
         let ended = false;
         let evidence;
@@ -143,7 +170,7 @@ export default class TestRunner {
             if (ended)
                 return;
             ended = true;
-            reporter.onTestEnd(test, error, {
+            reporter.onTestEnd(test, selectedBrowser, error, {
                 ...logs,
                 screenshots: evidence?.screenshots,
             });
@@ -151,7 +178,6 @@ export default class TestRunner {
         let browserClosed = false;
         /** Set once the runner itself closes the browser */
         let closing = false;
-        const selectedBrowser = (await readConfig("browser")) ?? "firefox";
         const { settings, secrets } = this.run;
         const timeout = settings.timeout;
         const { reportPath } = this.options;
@@ -205,11 +231,12 @@ export default class TestRunner {
                         resolve();
                     });
                     page = launched.page;
-                    evidence = new Evidence(resultDir, testDirOf(test, this.srcDir));
+                    evidence = new Evidence(resultDir, `${selectedBrowser}/${testDirOf(test, this.srcDir)}`);
                     launched.page.setEvidence(evidence);
                     const fixtures = {
                         page: launched.page,
                         browser: launched.browser,
+                        browserName: selectedBrowser,
                         env: createEnvFixture(settings.environment, settings.variables),
                         secrets: createSecretsFixture(settings.environment, secrets),
                     };

package/dist/transport/bidi-connection.d.ts

@@ -65,3 +65,16 @@ export declare class BiDiConnector {
     private messageListener;
     kill(): void;
 }
+/**
+ * The message as the debug log gets it: a `script.message` on a private channel is logged by channel and
+ * action only, so a value the tester types or a secret added from the recorder toolbar never reaches the log
+ * (an added secret is only registered for masking after it is saved).
+ */
+export declare function forLog(message: {
+    type?: string;
+    method?: string;
+    params?: {
+        channel?: unknown;
+        data?: unknown;
+    };
+}): unknown;

package/dist/transport/bidi-connection.js

@@ -216,7 +216,27 @@ const PRIVATE_CHANNEL = /^samurai-(recorder|toolbar)-/;
  * action only, so a value the tester types or a secret added from the recorder toolbar never reaches the log
  * (an added secret is only registered for masking after it is saved).
  */
-function forLog(message) {
+export function forLog(message) {
+    return shortened(redacted(message));
+}
+/** A string longer than this is cut in the log: a file's bytes travel in 1 MB chunks, 50 MB makes 70 MB of debug log */
+const LOG_STRING_LIMIT = 1000;
+/** A copy of `value` with every long string cut to its start and its length; short values come back as they are */
+function shortened(value, depth = 0) {
+    if (typeof value === "string")
+        return value.length > LOG_STRING_LIMIT
+            ? `${value.slice(0, 200)}… (${value.length} characters)`
+            : value;
+    if (value === null || typeof value !== "object" || depth > 30)
+        return value;
+    if (Array.isArray(value))
+        return value.map((item) => shortened(item, depth + 1));
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        key,
+        shortened(item, depth + 1),
+    ]));
+}
+function redacted(message) {
     const channel = message.params?.channel;
     if (message.type !== "event" ||
         message.method !== "script.message" ||

package/dist/types/config.d.ts

@@ -24,6 +24,8 @@ export interface SamuraiGroup {
    * Overrides 'src' and 'testMatch'  options.
    */
   tests?: SamuraiTest[];
+  /** The browsers this group's tests run in, instead of the project's `browsers` */
+  browsers?: SupportedBrowser[];
 }
 
 export interface SamuraiEnvironment {
@@ -45,10 +47,10 @@ export interface SamuraiTestConfig {
    */
   srcDir?: string;
   /**
-   * The browser to use for all tests: "firefox" or "chrome"
-   * @default "firefox"
+   * The browsers the tests run in, one after the other: every selected test runs once in each. A group can name its own.
+   * @default ["firefox"]
    */
-  browser?: SupportedBrowser;
+  browsers?: SupportedBrowser[];
   /**
    * Browser binaries to launch instead of the builds SAMURAI downloads, relative to the project.
    * `SAMURAI_FIREFOX_PATH` / `SAMURAI_CHROME_PATH` win over these.

package/dist/types/test.d.ts

@@ -1,10 +1,13 @@
 import type { Browser } from "../browser/browser.ts";
 import type Page from "../browser/page.ts";
+import type { SupportedBrowser } from "./browser.ts";
 
 /** What a test function receives */
 export interface TestFixtures {
   page: Page;
   browser: Browser;
+  /** The browser this run of the test is in */
+  browserName: SupportedBrowser;
   /** The chosen environment's variables; reading an unknown name throws */
   env: Readonly<Record<string, string | number | boolean>>;
   /** Secrets by name (SAMURAI_SECRET_<NAME>); reading an unset name throws */
@@ -66,12 +69,15 @@ export interface TestLogEntry {
 interface TestResultIdentity {
   name: string;
   file: string;
+  /** The browser the test ran in */
+  browser: SupportedBrowser;
   startTime: number;
 }
 
 interface TestResultBase {
   name: string;
   file: string;
+  browser: SupportedBrowser;
   startTime: number;
   status: "started";
 }
@@ -102,4 +108,6 @@ interface TestSummaryBase {
   tests: TestResult[];
   /** The environment the run used */
   environment: string;
+  /** The browsers the run used, in the order they ran */
+  browsers: SupportedBrowser[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itmetsam/samurai-framework",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Browser test framework over WebDriver BiDi: auto-waiting locators, environments and secrets, a recorder, and a command line.",
   "main": "dist/api.js",
   "exports": {