@itmetsam/samurai-framework 0.15.2 → 0.17.0

package/dist/{runner → config}/workers-option.js

@@ -1,5 +1,5 @@
 import { availableParallelism } from "node:os";
-import { parseWorkers } from "../config/workers.js";
+import { parseWorkers } from "./workers.js";
 /**
  * How many workers a run uses: the flag, else `SAMURAI_WORKERS`, else the config's `workers`, else half the CPUs.
  * A percentage is a share of the CPUs. At least 1.

package/dist/flows/run/project-options.d.ts

@@ -20,6 +20,8 @@ export interface RunFlowInProjectOptions extends ProjectOptions {
     /** `"fail"` (default): a flow with a node that can't run is refused. `"skip"`: those nodes are skipped. */
     unsupported?: "fail" | "skip";
     port?: number;
+    /** The folder the tests' named screenshots go in, instead of `<project>/result` (see `runTests`). Relative to the project folder */
+    outputDir?: string;
     /**
      * How many worker processes the tests of the whole run share: a number, or a percentage like `"50%"`. Unset
      * takes `SAMURAI_WORKERS` (`workersEnv`), then the config's `workers`, then half the CPUs. 1 runs each Test

package/dist/flows/run/project.js

@@ -1,12 +1,13 @@
 import path from "node:path";
+import { DEFAULT_SRC_DIR } from "../../config/defaults.js";
 import { projectConfig } from "../../config/config.js";
 import { checkFlow, withKeys, } from "../core/index.js";
-import { DEFAULT_SRC_DIR, realPath, resolveGroups, testId, toPosix, } from "../../runner/groups.js";
+import { realPath, resolveGroups, testId, toPosix, } from "../../runner/groups.js";
 import logger, { keepLogFiles } from "../../logger/index.js";
 import { resolveRetries } from "../../runner/retries-option.js";
-import { resolveWorkers } from "../../runner/workers-option.js";
+import { resolveWorkers } from "../../config/workers-option.js";
 import { withProject } from "../../runner/project.js";
-import { browsersFor } from "../../runner/browsers.js";
+import { browsersFor } from "../../config/browsers-for.js";
 import { DEFAULT_PORT } from "../../runner/ports.js";
 import { runTests } from "../../runner/run.js";
 import TestRunner from "../../runner/test-runner.js";
@@ -84,7 +85,7 @@ async function prepare(options) {
         ...(options.dataDir !== undefined && { dataDir: options.dataDir }),
         environment: name,
     }, async (run) => {
-        const found = await (await TestRunner.init(run)).register();
+        const { tests: found } = await (await TestRunner.init(run)).list();
         const tests = found.map((t) => ({
             id: testId(toPosix(path.relative(srcDir, t.file)), t.name),
             file: t.file,
@@ -175,6 +176,9 @@ async function walkFlowInProject(options) {
                 ...(options.headless !== undefined && {
                     headless: options.headless,
                 }),
+                ...(options.outputDir !== undefined && {
+                    outputDir: options.outputDir,
+                }),
                 files,
                 basePort: options.port ?? DEFAULT_PORT,
                 ...(retries > 0 && { retries }),
@@ -213,6 +217,9 @@ async function walkFlowInProject(options) {
                     files: [...new Set(tests.map((t) => t.file))],
                     testNames: tests.map((t) => t.name),
                     reportPath: false,
+                    ...(options.outputDir !== undefined && {
+                        outputDir: options.outputDir,
+                    }),
                     signal,
                     onEvent,
                 });

package/dist/network/data-collector.js

@@ -1,6 +1,5 @@
+import { DEFAULT_MAX_BODY_SIZE } from "../config/defaults.js";
 import { BiDiError } from "../transport/bidi-error.js";
-/** How large a response body may be to be kept: 10 MiB */
-const DEFAULT_MAX_BODY_SIZE = 10 * 1024 * 1024;
 /**
  * Chrome counts the headers of a response in the size it compares with the collector's limit (a 14-byte body
  * arrives as about 200 bytes), Firefox counts the body. Chrome's limit is raised by this much and the body is

package/dist/network/router.js

@@ -1,11 +1,10 @@
+import { DEFAULT_ROUTE_TIMEOUT } from "../config/defaults.js";
 import logger from "../logger/index.js";
 import { toRequest } from "./bidi-wire.js";
 import { Intercept } from "./intercept.js";
 import { PendingRoute, } from "./route.js";
 import { matchUrl, samePattern } from "./url-match.js";
 export { Route } from "./route.js";
-/** Time (ms) a handler may take to answer a request before the router lets it continue */
-const DEFAULT_ROUTE_TIMEOUT = 30000;
 /** How many handler errors the router keeps */
 const MAX_ERRORS = 100;
 /**

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, writtenConfig, type ConfigViews, type ResolvedConfig, type ResolvedEnvironment, type ResolvedIgnoreError, type WrittenConfig, } 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, writtenConfig, } 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/options.d.ts

@@ -28,7 +28,13 @@ export interface RunnerOptions {
     headless?: boolean;
     /** Remote debugging port of the browser. @default DEFAULT_PORT (9223) */
     port?: number;
-    /** Where the report is written; `false` writes none. @default `<project>/result/report.json` */
+    /**
+     * The folder for what the run writes, instead of `<project>/result`: `report.json` and the named screenshots
+     * (their paths in the results are relative to it). Relative to the project folder.
+     * @default `<project>/result`
+     */
+    outputDir?: string;
+    /** Where the report is written; `false` writes none. Beats `outputDir` for the report. @default `report.json` in `outputDir` */
     reportPath?: string | false;
     /** Receives start and end of the run and of every test, as they happen */
     onEvent?: (event: RunEvent) => void;

package/dist/runner/output.d.ts

@@ -0,0 +1,6 @@
+import type { RunnerOptions } from "./options.js";
+/** Where a run writes: the folder its screenshots go in, and its report (`false`: none) */
+export declare function runOutput(options: Pick<RunnerOptions, "outputDir" | "reportPath">, projectDir: string): {
+    resultDir: string;
+    report: string | false;
+};

package/dist/runner/output.js

@@ -0,0 +1,14 @@
+import path from "node:path";
+/** Where a run writes: the folder its screenshots go in, and its report (`false`: none) */
+export function runOutput(options, projectDir) {
+    const { outputDir, reportPath } = options;
+    const resultDir = outputDir !== undefined
+        ? path.resolve(projectDir, outputDir)
+        : typeof reportPath === "string"
+            ? path.dirname(reportPath)
+            : path.join(projectDir, "result");
+    return {
+        resultDir,
+        report: reportPath ?? path.join(resultDir, "report.json"),
+    };
+}

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-test.js

@@ -1,4 +1,3 @@
-import path from "path";
 import { takePendingAssertions } from "../assert/expect.js";
 import { Browser } from "../browser/browser.js";
 import { Evidence } from "../browser/evidence.js";
@@ -11,6 +10,7 @@ import { judgePageLogs } from "./page-logs-report.js";
 import { DEFAULT_PORT } from "./ports.js";
 import { runWithEachHooks } from "./hooks.js";
 import { isSkipSignal, staticSkip } from "./skip.js";
+import { runOutput } from "./output.js";
 import { testDirOf } from "./test-dir.js";
 import { toTestError } from "./test-error.js";
 /**
@@ -75,10 +75,7 @@ export async function runOneTest(test, browserName, run, options, srcDir, report
     const outcome = new TestOutcome(reporter, test, browserName);
     const { settings, secrets } = run;
     const timeout = settings.timeout;
-    const { reportPath } = options;
-    const resultDir = typeof reportPath === "string"
-        ? path.dirname(reportPath)
-        : path.join(projectDir(), "result");
+    const { resultDir } = runOutput(options, projectDir());
     let browser;
     let page;
     let timeoutTimer;

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,8 @@ 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 { runOutput } from "./output.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,19 +49,23 @@ 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
      * was also written to the report. With more than one worker the tests run at the same time in worker processes.
      */
     async start() {
-        const { reportPath, onEvent, signal } = this.options;
+        const { 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));
@@ -68,7 +73,7 @@ export default class TestRunner {
         const reporter = new TestReporter({
             environment: this.run.settings.environment,
             browsers,
-            ...(reportPath !== undefined && { output: reportPath }),
+            output: runOutput(this.options, projectDir()).report,
             ...(onEvent && { onEvent }),
         });
         // How the run goes is settled first: a bad `workers` is an error before any browser starts
@@ -155,7 +160,7 @@ export default class TestRunner {
     /** The pool of a run: up to `workers` worker processes that read the same project and settings as this run */
     createPool(workers, retries) {
         const { settings } = this.run;
-        const { reportPath, headless, port } = this.options;
+        const { reportPath, outputDir, headless, port } = this.options;
         const options = {
             workers,
             factory: processWorkerFactory(),
@@ -169,6 +174,7 @@ export default class TestRunner {
                 expectTimeout: settings.expectTimeout,
                 ...(headless !== undefined && { headless }),
                 ...(typeof reportPath === "string" && { reportPath }),
+                ...(outputDir !== undefined && { outputDir }),
                 files: this.testFiles,
                 basePort: port ?? DEFAULT_PORT,
                 ...(retries > 0 && { retries }),

package/dist/runner/worker-protocol.d.ts

@@ -24,6 +24,8 @@ export interface WorkerInit {
     retries?: number;
     /** Where the run's report goes when it is not the default; screenshots are kept beside it */
     reportPath?: string;
+    /** The run's `outputDir`: screenshots go there */
+    outputDir?: string;
     /** Spec files to import, absolute */
     files: string[];
     /** 0 for the first worker; picks the worker's browser port and profile folder */

package/dist/runner/worker-session.js

@@ -48,6 +48,9 @@ export function openSession(init) {
                         ...(init.reportPath !== undefined && {
                             reportPath: init.reportPath,
                         }),
+                        ...(init.outputDir !== undefined && {
+                            outputDir: init.outputDir,
+                        }),
                         port,
                         signal,
                     };

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)