@itmetsam/samurai-framework 0.15.2 → 0.16.0

package/dist/project/files-store.js

@@ -2,6 +2,7 @@ import { constants, createReadStream } from "node:fs";
 import { copyFile, mkdir, readFile, stat } from "node:fs/promises";
 import { createHash } from "node:crypto";
 import path from "node:path";
+import { DEFAULT_FILES_DIR } from "../config/defaults.js";
 /** Files bigger than this aren't stored while recording */
 export const RECORD_LIMIT = 50 * 1024 * 1024;
 const NAME_LIMIT = 120;
@@ -20,7 +21,7 @@ export function cleanFileName(name) {
     return cleaned === "" ? "file" : cleaned;
 }
 /** The files folder: absolute, and relative to the project with forward slashes */
-export function filesFolder(projectDir, filesDir = "files") {
+export function filesFolder(projectDir, filesDir = DEFAULT_FILES_DIR) {
     const absolute = path.resolve(projectDir, filesDir);
     return {
         absolute,

package/dist/project/index.d.ts

@@ -2,3 +2,4 @@ export { ConfigEditError, editConfig, hasConfigPath, propertyText, type ConfigVa
 export { addVariable, ExistsError, VARIABLE_NAME } from "./variables.js";
 export { isGitIgnored, SECRET_NAME, setSecret } from "./secrets-file.js";
 export { cleanFileName, filesFolder, isFolderIgnored, RECORD_LIMIT, storeFile, } from "./files-store.js";
+export { loadConfig, type ResolvedConfig, type ResolvedEnvironment, type ResolvedIgnoreError, } from "../config/resolved-config.js";

package/dist/project/index.js

@@ -2,3 +2,4 @@ export { ConfigEditError, editConfig, hasConfigPath, propertyText, } from "./con
 export { addVariable, ExistsError, VARIABLE_NAME } from "./variables.js";
 export { isGitIgnored, SECRET_NAME, setSecret } from "./secrets-file.js";
 export { cleanFileName, filesFolder, isFolderIgnored, RECORD_LIMIT, storeFile, } from "./files-store.js";
+export { loadConfig, } from "../config/resolved-config.js";

package/dist/recorder/session-browser.js

@@ -1,7 +1,7 @@
 import { Browser } from "../browser/browser.js";
 import { ensureWarm } from "../browser/warm-up.js";
 import { readConfig } from "../config/config.js";
-import { browsersFor } from "../runner/browsers.js";
+import { browsersFor } from "../config/browsers-for.js";
 import { DEFAULT_PORT } from "../runner/ports.js";
 /**
  * The browser a recording uses: the one asked for, else the first of the project's (recording in two browsers at

package/dist/recorder/session.d.ts

@@ -31,8 +31,10 @@ export interface RecordSpecOptions extends ProjectOptions {
     /** Called after each step is written to the file, with the file's new content */
     onEvent?: (event: RecorderEvent, source: string) => void;
     /**
-     * Called when the recording is paused or resumed, or the toolbar fails (or comes back) on a page.
-     * There is no initial call: until the first one the recording is `{ state: "recording", toolbar: true }`
+     * Called once with the recording's first status right after `onStarted` resolves (`{ state: "recording" }`,
+     * and `toolbar: false` if the toolbar had already failed to load), then whenever the recording is paused
+     * or resumed, or the toolbar fails (or comes back) on a page. Statuses that arrive while `onStarted` runs are held
+     * and sent once it resolves, after the first status.
      */
     onStatus?: (status: {
         state: "recording" | "paused";
@@ -46,6 +48,7 @@ export interface RecordSpecOptions extends ProjectOptions {
         browser: Browser;
     }) => void | Promise<void>;
 }
+/** What a recording returns; every field is always present, empty when there is nothing to report. */
 export interface RecordResult {
     file: string;
     /** Full name of the test the steps went into */

package/dist/recorder/session.js

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs";
 import path from "node:path";
-import { loadConfig, projectDir } from "../config/config.js";
+import { loadRawConfig, projectDir } from "../config/config.js";
 import { loadSecrets } from "../config/secrets.js";
 import { filesFolder, isFolderIgnored } from "../project/index.js";
 import { withProject } from "../runner/project.js";
@@ -30,11 +30,21 @@ export async function recordSpec(options) {
             ...options,
             headless: options.headless ?? settings.headless,
         });
-        const loaded = await loadConfig();
+        const loaded = await loadRawConfig();
         const folder = filesFolder(projectDir(), loaded.filesDir);
         const hadFolder = existsSync(folder.absolute);
         let recorder;
         const addedSecrets = new Set();
+        // Statuses that come while `onStarted` runs wait behind the first one, which is always the first
+        let waiting = [];
+        let toolbarLoaded = true;
+        const onStatus = (status) => {
+            toolbarLoaded = status.toolbar;
+            if (waiting)
+                waiting.push(status);
+            else
+                options.onStatus?.(status);
+        };
         let stopRequested;
         const stopped = new Promise((resolve) => (stopRequested = resolve));
         try {
@@ -50,7 +60,7 @@ export async function recordSpec(options) {
                 toolbar: {
                     ...(await toolbarOptions(run, spec.source, projectDir(), loaded, testIndex)),
                     projectDir: projectDir(),
-                    ...(options.onStatus && { onStatus: options.onStatus }),
+                    ...(options.onStatus && { onStatus }),
                     onSecretAdded: (name) => addedSecrets.add(name),
                     onStop: () => stopRequested(),
                 },
@@ -65,6 +75,11 @@ export async function recordSpec(options) {
                 },
             });
             await options.onStarted?.({ page, browser });
+            const queued = waiting ?? [];
+            waiting = undefined;
+            options.onStatus?.({ state: "recording", toolbar: toolbarLoaded });
+            for (const status of queued)
+                options.onStatus?.(status);
             let windowClosed = false;
             void browser.exited.then(() => (windowClosed = true));
             await new Promise((resolve) => {

package/dist/runner/groups.d.ts

@@ -1,9 +1,5 @@
 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";
-/** The spec pattern when a group names none */
-export declare const DEFAULT_TEST_MATCH = "**/*.spec.ts";
 /** A test as groups see it: its spec file (relative to `srcDir`, or any path inside it) and full name */
 export interface GroupTest {
     file: string;
@@ -16,7 +12,10 @@ export interface ResolvedGroup {
     kind: "picked" | "pattern";
     /** What selects the tests of a pattern group, for display */
     pattern?: string;
-    /** Ids (see `testId`) of the found tests in the group */
+    /**
+     * Ids of the found tests in the group: the spec file relative to `srcDir` with `/` separators, `::`, then the
+     * full name (`FoundTest.id` is the same)
+     */
     testIds: string[];
     /** Picked tests that no longer exist */
     missing: {

package/dist/runner/groups.js

@@ -1,10 +1,7 @@
 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 */
-export const DEFAULT_TEST_MATCH = "**/*.spec.ts";
+import { DEFAULT_TEST_MATCH } from "../config/defaults.js";
+import { browsersFor } from "../config/browsers-for.js";
 /**
  * The real path of `p` (symlinks resolved), or `p` itself when it does not exist. Registered test files come
  * from stack traces, which resolve symlinks, so paths compared with them must be real too

package/dist/runner/page-logs-report.js

@@ -1,3 +1,4 @@
+import { DEFAULT_LOGS_CAPTURE } from "../config/defaults.js";
 import { toTestError } from "./test-error.js";
 /** The page threw exceptions nobody caught, and config `logs.failOnPageError` says that fails the test */
 export class PageErrorsError extends Error {
@@ -16,15 +17,17 @@ export class RouteErrorsError extends Error {
     }
 }
 function isIgnored(error, ignore) {
-    return ignore.some((pattern) => typeof pattern === "string" ? error.message.includes(pattern) : pattern.test(error.message));
+    return ignore.some((pattern) => typeof pattern === "string"
+        ? error.message.includes(pattern)
+        : pattern.test(error.message));
 }
 /**
  * Decides, once a test body is done, whether page errors fail it and which log entries go in the report:
  * `capture` "failures" (default) attaches them to failed tests, "all" always, "off" never.
  */
 export function judgePageLogs(input) {
-    const { config, entries, errors, dropped, testFailed, allowPageErrors, routeErrors = [] } = input;
-    const capture = config?.capture ?? "failures";
+    const { config, entries, errors, dropped, testFailed, allowPageErrors, routeErrors = [], } = input;
+    const capture = config?.capture ?? DEFAULT_LOGS_CAPTURE;
     let error;
     if (routeErrors.length > 0 && !testFailed) {
         error = toTestError(new RouteErrorsError(routeErrors));

package/dist/runner/project.js

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { removeGeneratedFiles } from "../browser/generated-files.js";
-import { loadConfig, projectDir, setActiveProject } from "../config/config.js";
+import { loadRawConfig, projectDir, setActiveProject, } from "../config/config.js";
 import { resetSecrets } from "../config/mask.js";
 import { setRunSettings } from "../config/run-settings.js";
 import { keepLogFiles } from "../logger/index.js";
@@ -20,7 +20,7 @@ export async function withProject(options, work) {
     const releaseLogs = keepLogFiles(path.resolve(dir ?? previousDir));
     try {
         setActiveProject({ dir: dir ?? previousDir, config, dataDir });
-        const loaded = config ?? (await loadConfig());
+        const loaded = config ?? (await loadRawConfig());
         setActiveProject({ dir: dir ?? previousDir, config: loaded, dataDir });
         resetSecrets();
         const run = prepareRun(loaded, {

package/dist/runner/retries-option.js

@@ -1,3 +1,4 @@
+import { DEFAULT_RETRIES } from "../config/defaults.js";
 import { parseRetries } from "../config/retries.js";
 /** How many times a failing test is run again: the flag, else `SAMURAI_RETRIES`, else the config's `retries`, else 0 */
 export function resolveRetries({ flag, env, config }) {
@@ -8,5 +9,5 @@ export function resolveRetries({ flag, env, config }) {
         return parseRetries(fromEnv, "SAMURAI_RETRIES");
     if (config !== undefined)
         return parseRetries(config, "retries");
-    return 0;
+    return DEFAULT_RETRIES;
 }

package/dist/runner/run.d.ts

@@ -1,6 +1,6 @@
 import type { Modifier, TestSummary } from "../types/test.js";
 import { type ProjectOptions } from "./project.js";
-import type { ResolvedGroup } from "./groups.js";
+import { type ResolvedGroup } from "./groups.js";
 import type { RunnerOptions } from "./options.js";
 export interface RunTestsOptions extends RunnerOptions, ProjectOptions {
 }
@@ -16,15 +16,25 @@ export interface RunTestsOptions extends RunnerOptions, ProjectOptions {
 export declare function runTests(options?: RunTestsOptions): Promise<TestSummary>;
 /** A test found in a spec file */
 export interface FoundTest {
+    /**
+     * The id the groups use for this test (`ResolvedGroup.testIds`): its spec file relative to `srcDir` with `/`
+     * separators, then `::` and its full name, e.g. `checkout/cart.spec.ts::Cart > adds`
+     */
+    id: string;
     /** Full name: `describe` titles and the test title joined with " > " */
     name: string;
     file: string;
+    /** The spec file relative to `srcDir`, with `/` separators */
+    relativeFile: string;
     /** `skip` or `fixme` (not run), or `only` (focused); absent for a plain test. A modifier on a `describe` counts. */
     modifier?: Modifier;
     /** The `{ reason }` given with the `skip` or `fixme` that applies */
     reason?: string;
 }
-/** Imports the project's specs without running anything and lists the tests the options select */
+/**
+ * Imports the project's specs without running anything and lists the tests the options select, each with the id
+ * its group uses and its spec file relative to `srcDir`
+ */
 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[]>;

package/dist/runner/run.js

@@ -1,4 +1,6 @@
+import path from "path";
 import { withProject } from "./project.js";
+import { testId, toPosix } from "./groups.js";
 import TestRunner from "./test-runner.js";
 /**
  * Sets the project up (config, environment, secrets), builds a runner from the rest of the options and hands both to
@@ -33,14 +35,26 @@ function inProject(options, work) {
 export async function runTests(options = {}) {
     return inProject(options, (runner) => runner.start());
 }
-/** Imports the project's specs without running anything and lists the tests the options select */
+/**
+ * Imports the project's specs without running anything and lists the tests the options select, each with the id
+ * its group uses and its spec file relative to `srcDir`
+ */
 export async function listTests(options = {}) {
-    return inProject(options, async (runner) => (await runner.register()).map(({ name, file, modifier, reason }) => ({
-        name,
-        file,
-        ...(modifier && { modifier }),
-        ...(reason !== undefined && { reason }),
-    })));
+    return inProject(options, async (runner) => {
+        const { tests, srcDir } = await runner.list();
+        return tests.map((test) => {
+            const { name, file, modifier, reason } = test;
+            const relativeFile = toPosix(path.relative(srcDir, file));
+            return {
+                id: testId(relativeFile, name),
+                name,
+                file,
+                relativeFile,
+                ...(modifier && { modifier }),
+                ...(reason !== undefined && { reason }),
+            };
+        });
+    });
 }
 /** Imports the project's specs without running anything and lists the config's groups with the tests each holds */
 export async function listGroups(options = {}) {

package/dist/runner/select.js

@@ -1,8 +1,8 @@
 import path from "path";
 import { pathToFileURL } from "url";
-import { loadConfig } from "../config/config.js";
+import { loadRawConfig } from "../config/config.js";
 import logger from "../logger/index.js";
-import { browsersFor } from "./browsers.js";
+import { browsersFor } from "../config/browsers-for.js";
 import { findGroup, resolveGroups, testId, toPosix, } from "./groups.js";
 import { assertModuleProject } from "./module-type.js";
 import { clearRegistry, registeredTests } from "./registry.js";
@@ -40,7 +40,7 @@ export function idOf(test, srcDir) {
 }
 /** The config's groups, resolved against the tests the specs register */
 async function resolveAll(tests) {
-    const config = await loadConfig();
+    const config = await loadRawConfig();
     const { dir, srcDir } = realDirs(config.srcDir);
     const groups = resolveGroups(config, tests.map(({ file, name }) => ({
         file: toPosix(path.relative(srcDir, file)),
@@ -69,7 +69,7 @@ export function selectTests({ all, groups, srcDir }, options) {
  */
 export async function browsersOfRun(groups, options) {
     const { browsers: flag, group } = options;
-    const config = await loadConfig();
+    const config = await loadRawConfig();
     const ofGroup = group !== undefined && !(flag && flag.length > 0)
         ? findGroup(groups, group).browsers
         : undefined;

package/dist/runner/test-dir.js

@@ -1,7 +1,8 @@
 import path from "path";
 import { projectDir } from "../config/config.js";
 import { cleanName } from "../browser/evidence.js";
-import { DEFAULT_SRC_DIR, realPath, toPosix } from "./groups.js";
+import { DEFAULT_SRC_DIR } from "../config/defaults.js";
+import { realPath, toPosix } from "./groups.js";
 /** The project and source folders as real paths: registered test files come from stack traces, which resolve symlinks */
 export function realDirs(configuredSrcDir) {
     const dir = realPath(projectDir());

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

@@ -26,8 +26,14 @@ export default class TestRunner {
     static init(run: PreparedRun, options?: RunnerOptions, project?: ProjectInfo): Promise<TestRunner>;
     /** The groups of the config with the tests each holds; see `listGroups` */
     groups(): Promise<ResolvedGroup[]>;
-    /** Imports the spec files and returns the tests the options select: by `group`, `testNames` and `grep` */
-    register(): Promise<RegisteredTestCase[]>;
+    /**
+     * Imports the spec files and returns the tests the options select (by `group`, `testNames` and `grep`)
+     * with the real `srcDir` their ids are relative to
+     */
+    list(): Promise<{
+        tests: RegisteredTestCase[];
+        srcDir: string;
+    }>;
     /**
      * 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. With more than one worker the tests run at the same time in worker processes.

package/dist/runner/test-runner.js

@@ -2,12 +2,12 @@ import { glob } from "node:fs/promises";
 import path from "path";
 import { ensureWarm } from "../browser/warm-up.js";
 import { projectBrowser } from "../browsers/resolve.js";
-import { loadConfig, projectDir, readConfig } from "../config/config.js";
+import { loadRawConfig, projectDir, readConfig } from "../config/config.js";
 import { forbidsOnly } from "../config/forbid-only.js";
 import logger from "../logger/index.js";
 import { AllHooks } from "./all-hooks.js";
 import { assertNoOnly, narrowToOnly } from "./focus.js";
-import { DEFAULT_SRC_DIR, DEFAULT_TEST_MATCH } from "./groups.js";
+import { DEFAULT_SRC_DIR, DEFAULT_TEST_MATCH } from "../config/defaults.js";
 import { DEFAULT_PORT } from "./ports.js";
 import TestReporter from "./reporter.js";
 import { concurrency, planItems, poolMode, runPooled, serialKeyOf, } from "./pooled-run.js";
@@ -16,7 +16,7 @@ import { staticSkip } from "./skip.js";
 import { browsersOfRun, loadSpecs, selectTests } from "./select.js";
 import { resolveRetries } from "./retries-option.js";
 import { runWithRetries } from "./retry.js";
-import { resolveWorkers } from "./workers-option.js";
+import { resolveWorkers } from "../config/workers-option.js";
 import { WorkerPool } from "./worker-pool.js";
 import { processWorkerFactory } from "./worker-process.js";
 /** Finds the spec files, picks the tests and browsers of a run and runs each test in each browser */
@@ -48,9 +48,13 @@ export default class TestRunner {
     async groups() {
         return (await loadSpecs(this.testFiles)).groups;
     }
-    /** Imports the spec files and returns the tests the options select: by `group`, `testNames` and `grep` */
-    async register() {
-        return selectTests(await loadSpecs(this.testFiles), this.options);
+    /**
+     * Imports the spec files and returns the tests the options select (by `group`, `testNames` and `grep`)
+     * with the real `srcDir` their ids are relative to
+     */
+    async list() {
+        const loaded = await loadSpecs(this.testFiles);
+        return { tests: selectTests(loaded, this.options), srcDir: loaded.srcDir };
     }
     /**
      * Runs the selected tests in every browser of the run, one browser after the other, and returns the summary that
@@ -60,7 +64,7 @@ export default class TestRunner {
         const { reportPath, onEvent, signal } = this.options;
         // The specs are imported once: their top-level code runs once per run
         const loaded = await loadSpecs(this.testFiles);
-        const config = await loadConfig();
+        const config = await loadRawConfig();
         // A focused test the config refuses stops the run before anything starts; else only the focused ones run
         assertNoOnly(loaded.all, forbidsOnly(config), loaded.srcDir);
         const selected = narrowToOnly(selectTests(loaded, this.options));

package/dist/steps/edit.d.ts

@@ -22,6 +22,16 @@ export type StepEdit = {
     test: number;
     from: number;
     to: number;
+}
+/**
+ * Removes the whole test, with the comments and the blank line above it. For several tests, apply from the last index to the first.
+ * It removes all leading trivia from the end of the previous statement, so comments above the test go with it: a
+ * file-header comment when the test is the first statement, and a trailing `// comment` on the previous test's line.
+ * Throws for a test that isn't `removable`
+ */
+ | {
+    op: "remove-test";
+    test: number;
 };
 /**
  * Applies one edit and returns the new source. Only the touched statement changes, plus the test's parameters

package/dist/steps/edit.js

@@ -125,6 +125,10 @@ export function applyEdit(source, edit) {
         }
         case "remove":
             return removeStep(source, parsed, edit.index);
+        case "remove-test":
+            if (!parsed.removable)
+                throw new Error(`Cannot remove test "${parsed.name}": it is not a statement of its own`);
+            return splice(source, parsed.start, parsed.end, "");
         case "move": {
             const { start, end } = pickStep(parsed, edit.from);
             if (edit.to < 0 || edit.to >= parsed.steps.length)

package/dist/steps/index.d.ts

@@ -1,6 +1,6 @@
-export { parseSpec } from "./parse.js";
+export { parseSpec, parseSpecFile } from "./parse.js";
 export { applyEdit, type StepEdit } from "./edit.js";
 export { stepToSource, locatorToSource, callToSource, filesToSource, valueToSource, } from "./emit.js";
 export { formatSize, humanSize, parseSize, sizeFromSource } from "./files.js";
 export { locatorFromSpec } from "./build.js";
-export type { Expectation, FileEntry, GeneratedFileSpec, LocatorCall, LocatorSpec, ParsedStep, ParsedTest, Step, TextMatcher, TextValue, } from "./model.js";
+export type { Expectation, FileEntry, GeneratedFileSpec, LocatorCall, LocatorSpec, ParsedStep, ParsedTest, Step, TextMatcher, TextValue, UnparsedTest, } from "./model.js";

package/dist/steps/index.js

@@ -1,4 +1,4 @@
-export { parseSpec } from "./parse.js";
+export { parseSpec, parseSpecFile } from "./parse.js";
 export { applyEdit } from "./edit.js";
 export { stepToSource, locatorToSource, callToSource, filesToSource, valueToSource, } from "./emit.js";
 export { formatSize, humanSize, parseSize, sizeFromSource } from "./files.js";

package/dist/steps/model.d.ts

@@ -146,6 +146,15 @@ export interface ParsedTest {
     /** Offset just after the `{` of the test body, and of its closing `}` */
     bodyStart: number;
     bodyEnd: number;
+    /** Where the whole test starts: the full start of its statement, so the comments and blank line above are included */
+    start: number;
+    /** Where the whole test ends: the end of its statement, after the `;` */
+    end: number;
+    /**
+     * False when the test call isn't a statement of its own (a loop or `if` body without braces, an arrow's
+     * expression body), so it can't be removed without breaking the file
+     */
+    removable: boolean;
     /**
      * The fixtures the test's callback destructures, and the offset where another one goes: after the last one
      * (`list`), inside an empty `{}` (`empty`) or inside the empty `()` of a callback without parameters (`none`).
@@ -161,3 +170,11 @@ export interface ParsedTest {
     /** The `{ reason }` written with the `skip` or `fixme` that applies, when it is a string literal */
     reason?: string;
 }
+/** A `test` or `describe` call the codec can't read: its title isn't a plain string, or its function isn't written inline */
+export interface UnparsedTest {
+    kind: "test" | "describe";
+    /** The statement's range, as for `ParsedTest` */
+    start: number;
+    end: number;
+    reason: "dynamic-title" | "not-inline";
+}

package/dist/steps/parse.d.ts

@@ -1,3 +1,8 @@
-import type { ParsedTest } from "./model.js";
+import type { ParsedTest, UnparsedTest } from "./model.js";
+/** The tests in a spec file, with their steps and where each statement sits, and the tests and describes it can't read */
+export declare function parseSpecFile(source: string): {
+    tests: ParsedTest[];
+    unparsed: UnparsedTest[];
+};
 /** The tests in a spec file, with their steps and where each statement sits */
 export declare function parseSpec(source: string): ParsedTest[];

package/dist/steps/parse.js

@@ -85,24 +85,64 @@ function effectiveMark(own, describes) {
         };
     return chain.some((m) => m.modifier === "only") ? { modifier: "only" } : {};
 }
-/** The tests in a spec file, with their steps and where each statement sits */
-export function parseSpec(source) {
+/** The range of a whole test: its statement with the comments above it, or the call alone when it isn't a statement */
+function wholeRange(call) {
+    const statement = ts.isExpressionStatement(call.parent) ? call.parent : call;
+    return { start: statement.getFullStart(), end: statement.end };
+}
+/** Whether the call is a statement directly inside a block, a module block or the file, so removing its range leaves valid code */
+function isRemovable(call) {
+    const statement = call.parent;
+    if (!ts.isExpressionStatement(statement))
+        return false;
+    const container = statement.parent;
+    return (ts.isBlock(container) ||
+        ts.isSourceFile(container) ||
+        ts.isModuleBlock(container));
+}
+/** A test or describe the codec can't read, with where its statement sits */
+function unreadable(node, kind, reason) {
+    return { kind, reason, ...wholeRange(node) };
+}
+/** `test.skip(condition, reason)` inside a body: it takes a condition where a test takes a title, so it is neither a test nor unparsed */
+function isConditionForm(node, callee) {
+    const [first] = node.arguments;
+    return ((callee.modifier === "skip" || callee.modifier === "fixme") &&
+        !(first &&
+            (ts.isStringLiteral(first) ||
+                ts.isNoSubstitutionTemplateLiteral(first) ||
+                ts.isTemplateExpression(first))));
+}
+/** The tests in a spec file, with their steps and where each statement sits, and the tests and describes it can't read */
+export function parseSpecFile(source) {
     const sourceFile = ts.createSourceFile("spec.ts", source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
     const tests = [];
+    const unparsed = [];
     const visit = (node, titles, describes) => {
         const callee = ts.isCallExpression(node)
             ? calleeOf(node.expression)
             : undefined;
-        if (ts.isCallExpression(node) && callee) {
+        if (ts.isCallExpression(node) &&
+            callee &&
+            (callee.name === "test" || callee.name === "describe") &&
+            !(callee.name === "test" && isConditionForm(node, callee))) {
+            const kind = callee.name;
             const title = stringOf(node.arguments[0]);
             const { callback, reason } = callbackOf(node, callee.modifier);
             const body = callbackBody(callback);
+            if (title === undefined) {
+                unparsed.push(unreadable(node, kind, "dynamic-title"));
+                return;
+            }
+            if (!body) {
+                unparsed.push(unreadable(node, kind, "not-inline"));
+                return;
+            }
             const mark = {
                 ...(callee.modifier && { modifier: callee.modifier }),
                 ...(reason !== undefined && { reason }),
             };
-            if (title !== undefined && body && callee.name === "test") {
-                // `test.skip(condition, reason)` has no title and no body, so it stays a step of the test it is in
+            if (kind === "test") {
                 const titlePath = [...titles, title];
                 tests.push({
                     titlePath,
@@ -110,18 +150,22 @@ export function parseSpec(source) {
                     steps: body.statements.map((statement) => parseStatement(source, statement, sourceFile)),
                     bodyStart: body.getStart(sourceFile) + 1,
                     bodyEnd: body.end - 1,
+                    ...wholeRange(node),
+                    removable: isRemovable(node),
                     fixtures: callbackFixtures(callback, sourceFile),
                     ...effectiveMark(mark, describes),
                 });
                 return;
             }
-            if (title !== undefined && body && callee.name === "describe") {
-                ts.forEachChild(body, (child) => visit(child, [...titles, title], [...describes, mark]));
-                return;
-            }
+            ts.forEachChild(body, (child) => visit(child, [...titles, title], [...describes, mark]));
+            return;
         }
         ts.forEachChild(node, (child) => visit(child, titles, describes));
     };
     visit(sourceFile, [], []);
-    return tests;
+    return { tests, unparsed };
+}
+/** The tests in a spec file, with their steps and where each statement sits */
+export function parseSpec(source) {
+    return parseSpecFile(source).tests;
 }

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

@@ -1,7 +1,5 @@
 import type { BiDiCommands, BiDiEvents } from "../types/bidi.js";
 import { type EventName, type Subscription, type SubscribeOptions } from "./subscriptions.js";
-/** Time (ms) a command may wait for its reply before it fails with code "timeout" */
-export declare const DEFAULT_COMMAND_TIMEOUT = 30000;
 export interface ConnectorOptions {
     /** @default DEFAULT_COMMAND_TIMEOUT */
     commandTimeout?: number;

package/dist/transport/bidi-connection.js

@@ -1,11 +1,10 @@
 import EventEmitter from "node:events";
+import { DEFAULT_COMMAND_TIMEOUT } from "../config/defaults.js";
 import logger from "../logger/index.js";
 import { WaitTimeoutError } from "../wait/wait-until.js";
 import { BiDiError } from "./bidi-error.js";
 import { forLog } from "./log-redaction.js";
 import { SubscriptionManager, } from "./subscriptions.js";
-/** Time (ms) a command may wait for its reply before it fails with code "timeout" */
-export const DEFAULT_COMMAND_TIMEOUT = 30000;
 /**
  * The connection to the browser is gone (the browser exited or was closed, or the socket dropped). Commands that
  * were waiting fail with it, and so does every command sent afterwards: a closed socket would swallow them silently.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itmetsam/samurai-framework",
-  "version": "0.15.2",
+  "version": "0.16.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": {
@@ -48,6 +48,10 @@
       "types": "./dist/project/index.d.ts",
       "default": "./dist/project/index.js"
     },
+    "./capabilities": {
+      "types": "./dist/capabilities.d.ts",
+      "default": "./dist/capabilities.js"
+    },
     "./package.json": "./package.json"
   },
   "scripts": {
@@ -55,7 +59,7 @@
     "build": "rm -rf dist && tsc -p tsconfig.build.json && node scripts/copy-types.mjs",
     "prepack": "npm run build",
     "test": "SAMURAI_LOG_LEVEL=${SAMURAI_LOG_LEVEL:-warn} tsx --import ./scripts/test-tmp.mjs --test --test-timeout=10000 \"src/**/*.test.ts\"",
-    "test:browser": "SAMURAI_LOG_LEVEL=${SAMURAI_LOG_LEVEL:-warn} tsx --import ./scripts/test-tmp.mjs --test --test-concurrency=1 --test-timeout=60000 \"src/**/*.browser-test.ts\"",
+    "test:browser": "SAMURAI_LOG_LEVEL=${SAMURAI_LOG_LEVEL:-warn} tsx --import ./scripts/test-tmp.mjs --test --test-concurrency=1 --test-timeout=60000 ${SAMURAI_TEST_SHARD:+--test-shard=$SAMURAI_TEST_SHARD} \"src/**/*.browser-test.ts\"",
     "test:browser:chrome": "SAMURAI_TEST_BROWSER=chrome npm run test:browser",
     "test:cli": "tsx --import ./scripts/test-tmp.mjs --test --test-concurrency=1 \"src/**/*.cli-test.ts\""
   },