test-inventory 0.7.0 → 0.9.0

package/dist/config-runs.js

@@ -1,13 +1,27 @@
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, statSync } from 'node:fs';
 import path from 'node:path';
+import { pathToFileURL } from 'node:url';
 import picomatch from 'picomatch';
 import { globSync } from 'tinyglobby';
 import { mergeDeep, settingAt, unknownText, } from "./config.js";
 import { atLeast } from "./frameworks/common.js";
+import { nodeTestCommands } from "./node-scripts.js";
+import { durationOf } from "./frameworks/mocha.js";
 import { VITEST_BENCHMARK_INCLUDE, VITEST_INCLUDE, VITEST_TYPECHECK_INCLUDE, vitestExclude, } from "./vitest-defaults.js";
 const PLAYWRIGHT_TEST_MATCH = '**/*.@(spec|test).?(c|m)[jt]s?(x)';
 /** A file Vitest takes as a project config, by name. */
 const VITEST_CONFIG = /^(vitest|vite)(\..*)?\.config\./;
+/** Jest's default `testMatch` before 30.0, and from 30.0, which also matches `.mjs`, `.cjs`, `.mts` and `.cts`. */
+const JEST_TEST_MATCH = {
+    29: ['**/__tests__/**/*.[jt]s?(x)', '**/?(*.)+(spec|test).[tj]s?(x)'],
+    30: ['**/__tests__/**/*.?([mc])[jt]s?(x)', '**/?(*.)+(spec|test).?([mc])[jt]s?(x)'],
+};
+/** The extensions a file a Jest `projects` glob matches needs to be read as a config. */
+const JEST_CONFIG_EXTENSIONS = ['.js', '.ts', '.mjs', '.mts', '.cjs', '.cts', '.json'];
+/** Jest's default `moduleFileExtensions` before 30.0; 30.0 adds `mts` and `cts`. */
+const JEST_EXTENSIONS = ['js', 'mjs', 'cjs', 'jsx', 'ts', 'tsx', 'json', 'node'];
+/** Presets that leave Jest's choice of test files as it is, so the scan needs nothing from them. */
+const NEUTRAL_PRESETS = /^(ts-jest(\/.*)?|jest-puppeteer)$/;
 /** Vitest 3's workspace files, which list its projects in place of `test.projects`. */
 const VITEST_WORKSPACES = ['ts', 'mts', 'cts', 'js', 'mjs', 'cjs', 'json'].map((extension) => `vitest.workspace.${extension}`);
 const NO_DEFAULTS = {
@@ -101,6 +115,11 @@ export class ConfigRuns {
     projects = new Map();
     ignoreRules = new Map();
     folderStates = new Map();
+    /** The project Jest runs with when no config is found up to the root. */
+    jestDefaults = null;
+    mochaDefaults = null;
+    nodeRuns = null;
+    bunFiles = null;
     /** The Vitest configs whose projects are being found, with their names, to stop at one whose projects name itself. */
     expanding = new Map();
     constructor(configs, framework, version, findsFiles) {
@@ -119,7 +138,21 @@ export class ConfigRuns {
         return { ...placement, tags: this.configTags(placement.config) };
     }
     place(file) {
-        const around = this.configs.around(file);
+        if (this.framework === 'mocha')
+            return this.placeMocha(file);
+        if (this.framework === 'jasmine')
+            return this.placeJasmine(file);
+        if (this.framework === 'cypress')
+            return this.placeCypress(file);
+        if (this.framework === 'webdriverio')
+            return this.placeWebdriverIO(file);
+        if (this.framework === 'node')
+            return this.placeNode(file);
+        if (this.framework === 'bun')
+            return this.placeBun(file);
+        // Jest started at the root reads the config there only, and the others through its `projects`.
+        const rootConfig = this.framework === 'jest' ? this.configs.inFolder(this.configs.root) : null;
+        const around = this.framework !== 'jest' ? this.configs.around(file) : rootConfig ? [rootConfig] : [];
         for (const config of around) {
             const running = this.projectsOf(config).flatMap((project) => {
                 const runs = project.runs?.(file);
@@ -137,6 +170,12 @@ export class ConfigRuns {
             return { config: unknown.config, settings: unknown.settings, runs: null, projects: null };
         }
         const nearest = around.at(-1) ?? null;
+        if (nearest === null && this.framework === 'jest') {
+            // Jest then reads a package.json above the root, taken to have no `jest` key: its defaults apply from the root.
+            this.jestDefaults ??= this.jestProject(this.noConfig(), emptySettings(), this.configs.root, emptySettings());
+            const runs = this.jestDefaults.runs;
+            return { config: null, settings: null, runs: runs(file), projects: null };
+        }
         return {
             config: nearest,
             settings: nearest?.settings ?? null,
@@ -186,17 +225,498 @@ export class ConfigRuns {
         const project = this.projectsOf(config).find((item) => item.runs && item.about.name === name);
         return project ? { about: project.about, runs: project.runs } : null;
     }
+    /** Mocha runs one set of files, from the config it starts with, or its defaults without one. */
+    placeMocha(file) {
+        const config = this.configs.mochaConfig();
+        const project = config
+            ? this.projectsOf(config)[0]
+            : (this.mochaDefaults ??= this.mochaProject(this.noConfig(), emptySettings()));
+        if (project.unknown) {
+            this.configs.reportUnknown(project.unknown.setting, project.unknown.key, this.findsFiles ? NOT_FOUND : ASSUMED);
+            return { config, settings: project.settings, runs: null, projects: null };
+        }
+        const runs = project.runs(file);
+        if (!config)
+            return { config: null, settings: null, runs, projects: null };
+        return { config, settings: project.settings, runs, projects: runs ? [project.about] : [] };
+    }
+    /**
+     * The files Mocha runs, as it looks them up from the root, the folder it starts in, wherever its config is: each
+     * `spec` entry a glob, a file, a file without its extension, or a folder whose files with one of the `extension`s it
+     * takes, also in folders below with `recursive`, less those `ignore` matches; and the `file` entries, loaded first.
+     * With globs, every file they match, less `ignore`. A timeout may be written as `'2s'`.
+     */
+    mochaProject(config, settings) {
+        const folder = this.configs.root;
+        const lists = {};
+        for (const [key, fallback] of [
+            ['spec', ['./test']],
+            ['extension', ['js', 'cjs', 'mjs']],
+            ['ignore', []],
+            ['file', []],
+        ]) {
+            const setting = settingAt(settings, [key]) ?? (key === 'ignore' ? settingAt(settings, ['exclude']) : null);
+            const found = setting === null || isUnset(setting) ? [...fallback] : patterns(setting, false);
+            if (!Array.isArray(found))
+                return this.unknownProject(config, found, key);
+            lists[key] = found.map((item) => (key === 'extension' ? item.replace(/^\./, '') : item));
+        }
+        const recursiveSetting = settingAt(settings, ['recursive']);
+        if (recursiveSetting?.kind === 'unknown')
+            return this.unknownProject(config, recursiveSetting, 'recursive');
+        const recursive = recursiveSetting?.kind === 'value' && recursiveSetting.value === true;
+        const extensions = lists.extension;
+        // Mocha matches `ignore` against the path as its lookup finds it, without `./`, so a pattern starting with `./`
+        // matches nothing; picomatch would drop the `./` and match.
+        const ignored = lists.ignore.map((glob) => (glob.startsWith('./') ? () => false : picomatch(posix(glob))));
+        const specs = lists.spec.map((spec) => mochaSpec(folder, spec, extensions, recursive));
+        // A `file` entry is loaded as written, before the specs, and `ignore` doesn't apply to it.
+        const loaded = new Set(lists.file.map((entry) => path.resolve(folder, entry)));
+        const duration = (key) => {
+            const setting = settingAt(settings, [key]);
+            const value = setting?.kind === 'value' ? durationOf(setting.value, key) : null;
+            return value === null ? setting : { kind: 'value', value };
+        };
+        const about = {
+            name: '',
+            testDir: folder,
+            dependencies: [],
+            settings,
+            root: folder,
+            container: null,
+            config,
+            grep: null,
+            grepRoot: folder,
+            runsByDefault: true,
+            defaults: { ...NO_DEFAULTS, timeout: duration('timeout'), retry: duration('retries') },
+        };
+        return {
+            config,
+            settings,
+            about,
+            unknown: null,
+            runs: (file) => {
+                const relative = posix(path.relative(folder, file));
+                if (loaded.has(file))
+                    return 'test';
+                // A project's scripts often give Mocha the spec on its command line, which no config shows, so with globs the
+                // scan takes each file they match as run, less `ignore`.
+                if (this.findsFiles && !specs.some((spec) => spec(file)))
+                    return false;
+                return ignored.some((isMatch) => isMatch(relative)) ? false : 'test';
+            },
+        };
+    }
+    /**
+     * Jasmine runs one set of files, from its config. Without one it runs none, unless it is given files: Karma and
+     * Angular projects give it theirs from their own configs, which the scan doesn't read, so their globs decide.
+     */
+    placeJasmine(file) {
+        const config = this.configs.jasmineConfig();
+        if (!config)
+            return { config: null, settings: null, runs: this.findsFiles ? false : 'test', projects: null };
+        const [project] = this.projectsOf(config);
+        if (project.unknown) {
+            this.configs.reportUnknown(project.unknown.setting, project.unknown.key, this.findsFiles ? NOT_FOUND : ASSUMED);
+            return { config, settings: project.settings, runs: null, projects: null };
+        }
+        const runs = project.runs(file);
+        return { config, settings: project.settings, runs, projects: runs ? [project.about] : [] };
+    }
+    /**
+     * The files Jasmine runs: those under `spec_dir`, from the root, that a `spec_files` glob matches, less those a glob
+     * starting with `!` matches. With globs, every file they match, as files given to Jasmine replace `spec_files`.
+     */
+    jasmineProject(config) {
+        const folder = this.configs.root;
+        const settings = config.settings;
+        const dirSetting = settingAt(settings, ['spec_dir']);
+        if (dirSetting?.kind === 'unknown')
+            return this.unknownProject(config, dirSetting, 'spec_dir');
+        const specDir = dirSetting?.kind === 'value' && typeof dirSetting.value === 'string' ? dirSetting.value : '';
+        const filesSetting = settingAt(settings, ['spec_files']);
+        const found = filesSetting === null || isUnset(filesSetting) ? [] : patterns(filesSetting, false);
+        if (!Array.isArray(found))
+            return this.unknownProject(config, found, 'spec_files');
+        const globs = found.map((glob) => ({ exclude: glob.startsWith('!'), glob: glob.replace(/^!/, '') }));
+        const matcher = (exclude) => {
+            const list = globs.filter((item) => item.exclude === exclude).map((item) => posix(path.join(specDir, item.glob)));
+            return list.length > 0 ? picomatch(list) : () => false;
+        };
+        const [included, excluded] = [matcher(false), matcher(true)];
+        const about = {
+            name: '',
+            testDir: path.resolve(folder, specDir),
+            dependencies: [],
+            settings,
+            root: folder,
+            container: null,
+            config,
+            grep: null,
+            grepRoot: folder,
+            runsByDefault: true,
+            defaults: NO_DEFAULTS,
+        };
+        return {
+            config,
+            settings,
+            about,
+            unknown: null,
+            runs: (file) => {
+                // Files given to Jasmine replace `spec_files`, its `!` globs included.
+                if (!this.findsFiles)
+                    return 'test';
+                const relative = posix(path.relative(folder, file));
+                return included(relative) && !excluded(relative) ? 'test' : false;
+            },
+        };
+    }
+    /**
+     * Cypress runs a file in its e2e project, or in its component project when the config sets up component testing.
+     * Without a config it runs nothing, unless it is given files.
+     */
+    placeCypress(file) {
+        const config = this.configs.rootConfig();
+        if (!config)
+            return { config: null, settings: null, runs: this.findsFiles ? false : 'test', projects: null };
+        const projects = this.projectsOf(config);
+        const unknown = projects.find((project) => project.unknown);
+        if (unknown?.unknown) {
+            this.configs.reportUnknown(unknown.unknown.setting, unknown.unknown.key, this.findsFiles ? NOT_FOUND : ASSUMED);
+            return { config, settings: unknown.settings, runs: null, projects: null };
+        }
+        // Cypress runs a file given to it only when its testing type's `specPattern` takes the file too.
+        const running = projects.filter((project) => project.runs?.(file));
+        return {
+            config,
+            settings: config.settings,
+            runs: running.length > 0 ? 'test' : false,
+            projects: running.map((project) => project.about),
+        };
+    }
+    /**
+     * Cypress's testing types as projects: `e2e`, and `component` when the config has it. Each runs the files under the
+     * config's folder that its `specPattern` matches, dot files left out, without those its `excludeSpecPattern` matches,
+     * dot files included, and those in `node_modules` unless a `specPattern` names it; component testing also leaves out
+     * the files e2e's `specPattern` matches. `cypress run` matches each pattern against the whole path, as globby does.
+     */
+    cypressProjects(config) {
+        const folder = path.dirname(config.file);
+        const types = [
+            ['e2e', ['cypress/e2e/**/*.cy.{js,jsx,ts,tsx}'], ['*.hot-update.js']],
+        ];
+        if (settingAt(config.settings, ['component']) !== null) {
+            types.push(['component', ['**/*.cy.{js,jsx,ts,tsx}'], ['**/__snapshots__/*', '**/__image_snapshots__/*']]);
+        }
+        // Cypress takes a pattern written from the config's folder as one relative to it.
+        const relative = (glob) => posix(glob.startsWith(folder + path.sep) ? path.relative(folder, glob) : glob);
+        const projects = [];
+        let e2eSpecs = [];
+        for (const [type, defaultSpecs, defaultExcludes] of types) {
+            const lists = [];
+            for (const [key, fallback] of [
+                ['specPattern', defaultSpecs],
+                ['excludeSpecPattern', defaultExcludes],
+            ]) {
+                const setting = settingAt(config.settings, [type, key]);
+                const found = setting === null || isUnset(setting) ? fallback : patterns(setting, false);
+                if (!Array.isArray(found))
+                    return [this.unknownProject(config, found, `${type}.${key}`)];
+                lists.push(found);
+            }
+            const [specs, excludes] = lists;
+            if (type === 'e2e')
+                e2eSpecs = specs;
+            const isSpec = picomatch(specs.map(relative));
+            const excluded = [...excludes, ...(type === 'component' ? e2eSpecs : [])].map(relative);
+            if (!specs.some((glob) => glob.includes('node_modules')))
+                excluded.push('**/node_modules/**');
+            const isExcluded = picomatch(excluded, { dot: true });
+            const retry = settingAt(config.settings, [type, 'retries']) ?? settingAt(config.settings, ['retries']);
+            const written = retry?.kind === 'object' ? settingAt(retry, ['runMode']) : retry;
+            // Cypress takes `null` as no retries set.
+            const runMode = written?.kind === 'value' && written.value === null ? null : written;
+            const about = {
+                name: type,
+                testDir: folder,
+                dependencies: [],
+                settings: config.settings,
+                root: folder,
+                container: null,
+                config,
+                grep: null,
+                grepRoot: folder,
+                runsByDefault: true,
+                defaults: { ...NO_DEFAULTS, retry: runMode },
+            };
+            projects.push({
+                config,
+                settings: config.settings,
+                about,
+                unknown: null,
+                runs: (file) => {
+                    const from = posix(path.relative(folder, file));
+                    return isSpec(from) && !isExcluded(from) ? 'test' : false;
+                },
+            });
+        }
+        return projects;
+    }
+    /** `bun test` runs the files of `bunFilesOf`, with the settings of the `bunfig.toml` in the root, when there is one. */
+    placeBun(file) {
+        const config = this.configs.rootConfig();
+        if (!this.bunFiles) {
+            this.bunFiles = this.bunFilesOf(config);
+            if (this.bunFiles.refused)
+                this.configs.reportConfig(config, this.bunFiles.refused);
+        }
+        const found = this.bunFiles;
+        const runs = found.refused === null && (!this.findsFiles || found.runs(file)) ? 'test' : false;
+        if (!config)
+            return { config: null, settings: null, runs, projects: null };
+        const projects = runs ? [found.isConcurrent(file) ? found.concurrent : found.about] : [];
+        return { config, settings: config.settings, runs, projects };
+    }
+    /**
+     * The files `bun test` runs: those under `[test] root`, the root by default, whose name without its extension ends
+     * with `.test`, `_test`, `.spec` or `_spec`, with a JavaScript or TypeScript extension, outside dot folders and
+     * `node_modules`, and from Bun 1.3.11 outside the folders and files a `pathIgnorePatterns` glob matches. `[test] retry`
+     * applies to every test, and the tests of the files a `concurrentTestGlob` glob matches run at once.
+     */
+    bunFilesOf(config) {
+        const folder = this.configs.root;
+        const settings = config?.settings ?? emptySettings();
+        // Bun reads a string or a list of them, and ignores a `root` of another type.
+        const read = (key) => {
+            const setting = settingAt(settings, ['test', key]);
+            if (setting === null)
+                return [];
+            const found = patterns(setting, false);
+            return Array.isArray(found) ? found : null;
+        };
+        const roots = read('root') ?? [];
+        // Bun 1.2 reads neither `pathIgnorePatterns` nor `retry`. It reads the first from 1.3.11, and the version holds no
+        // patch to tell 1.3.10 from it, so all of 1.3 reads it.
+        const readsFrom13 = atLeast(this.version, 1, 3);
+        const ignored = readsFrom13 ? read('pathIgnorePatterns') : [];
+        const concurrent = read('concurrentTestGlob');
+        const wrong = ignored === null ? 'pathIgnorePatterns' : concurrent === null ? 'concurrentTestGlob' : null;
+        const refused = wrong &&
+            `The config's test.${wrong} is not a string or a list of strings, so Bun refuses the config and runs no test.`;
+        const testRoot = path.resolve(folder, roots[0] ?? '.');
+        const isIgnored = picomatch(ignored ?? []);
+        const isConcurrent = picomatch(concurrent ?? []);
+        const about = (parallel) => ({
+            name: '',
+            testDir: testRoot,
+            dependencies: [],
+            settings,
+            root: folder,
+            container: null,
+            config: config,
+            grep: null,
+            grepRoot: folder,
+            runsByDefault: true,
+            defaults: {
+                ...NO_DEFAULTS,
+                retry: readsFrom13 ? settingAt(settings, ['test', 'retry']) : null,
+                parallel: parallel ? { kind: 'value', value: true } : null,
+            },
+        });
+        return {
+            refused,
+            about: about(false),
+            concurrent: about(true),
+            // Bun 1.4.4 matches the glob against the file's whole path.
+            isConcurrent: (file) => isConcurrent(posix(file)),
+            runs: (file) => {
+                if (!isInside(testRoot, file))
+                    return false;
+                const relative = posix(path.relative(folder, file));
+                const parts = relative.split('/');
+                if (parts.some((part) => part.startsWith('.') || part === 'node_modules'))
+                    return false;
+                if (parts.some((_, index) => isIgnored(parts.slice(0, index + 1).join('/'))))
+                    return false;
+                return /(\.test|_test|\.spec|_spec)\.(js|jsx|ts|tsx|mjs|cjs|mts|cts)$/i.test(relative);
+            },
+        };
+    }
+    /** `node --test` runs the files its arguments name, or without any, those its default patterns match; see `nodeFiles`. */
+    placeNode(file) {
+        if (!this.findsFiles)
+            return { config: null, settings: null, runs: 'test', projects: null };
+        this.nodeRuns ??= this.nodeFiles();
+        const runs = this.nodeRuns(posix(path.relative(this.configs.root, file)));
+        return { config: null, settings: null, runs: runs ? 'test' : false, projects: null };
+    }
+    /**
+     * The files `node --test` runs from the root, outside dot folders and `node_modules`: those the arguments of the
+     * package.json script that runs it give, the `test` script first, each a glob or a path, and from Node.js 26.8 a folder
+     * for the default patterns inside it; without arguments, the default patterns. They take TypeScript files too from
+     * Node.js 22.18, which strips types by default.
+     */
+    nodeFiles() {
+        const extensions = stripsTypes(this.version) ? 'cjs,mjs,js,cts,mts,ts' : 'cjs,mjs,js';
+        const defaults = ['**/*.test', '**/*-test', '**/*_test', '**/test-*', '**/test', '**/test/**/*'].map((glob) => `${glob}.{${extensions}}`);
+        const searchesFolders = atLeast(this.version, 26, 8);
+        const commands = nodeTestArguments(path.join(this.configs.root, 'package.json'));
+        // Each command runs the files it gives, or without any, those the default patterns match.
+        const globs = (commands.length > 0 ? commands : [[]]).flatMap((files) => files.length === 0
+            ? defaults
+            : files.flatMap((argument) => {
+                const folder = path.resolve(this.configs.root, argument);
+                if (!searchesFolders || !existsSync(folder) || !statSync(folder).isDirectory())
+                    return [argument];
+                return defaults.map((glob) => `${argument.replace(/\/+$/, '')}/${glob}`);
+            }));
+        const isMatch = picomatch(globs.map((glob) => path.posix.normalize(posix(glob))));
+        return (relative) => isMatch(relative) && !relative.split('/').includes('node_modules');
+    }
+    /** WebdriverIO runs the files of the config in the root; without one, it runs nothing, unless it is given files. */
+    placeWebdriverIO(file) {
+        const config = this.configs.rootConfig();
+        if (!config)
+            return { config: null, settings: null, runs: this.findsFiles ? false : 'test', projects: null };
+        const [project] = this.projectsOf(config);
+        if (project.unknown) {
+            this.configs.reportUnknown(project.unknown.setting, project.unknown.key, this.findsFiles ? NOT_FOUND : ASSUMED);
+            return { config, settings: project.settings, runs: null, projects: null };
+        }
+        const runs = project.runs(file);
+        return { config, settings: project.settings, runs, projects: runs ? [project.about] : [] };
+    }
+    /**
+     * The files `wdio` runs: those under `rootDir`, the config's folder by default, that a `specs` glob matches, also in
+     * the nested lists that group files into one worker, less those `exclude` leaves out. A capability's own `specs` replace the config's for it, and its `exclude` adds to the config's. Globs leave out
+     * dot files and folders, and one without a `/` matches a file's name at any depth. When every `exclude` entry holds a
+     * `/`, `\` or `*`, they are globs too; otherwise each one leaves out every file whose URL contains it. Files given
+     * with `--spec` replace `specs`, so scanned with globs, every file they match counts as run, less the excludes. The
+     * config's `mochaOpts.timeout` and `retries`, or `jasmineOpts.defaultTimeoutInterval`, apply to every test.
+     */
+    webdriverioProject(config) {
+        const { settings } = config;
+        const writtenRoot = settingAt(settings, ['rootDir']);
+        if (writtenRoot !== null &&
+            !isUnset(writtenRoot) &&
+            !(writtenRoot.kind === 'value' && typeof writtenRoot.value === 'string')) {
+            return this.unknownProject(config, unknownAt(writtenRoot), 'rootDir');
+        }
+        // The config's `rootDir`, from the folder `wdio` starts in, replaces the config's folder.
+        const folder = writtenRoot?.kind === 'value' && typeof writtenRoot.value === 'string'
+            ? path.resolve(this.configs.root, writtenRoot.value)
+            : path.dirname(config.file);
+        const globs = (owner, keys) => {
+            const setting = keys.map((key) => settingAt(owner, [key])).find((item) => item !== null && !isUnset(item));
+            if (!setting)
+                return null;
+            // A single glob is taken as a list of one; a nested list groups files into one worker.
+            const items = setting.kind === 'list'
+                ? setting.items.flatMap((item) => (item.kind === 'list' ? item.items : [item]))
+                : [setting];
+            const found = patterns({ kind: 'list', items }, false);
+            return Array.isArray(found) ? found : found;
+        };
+        // WebdriverIO globs each pattern with `/` for `\`, from `rootDir`.
+        const fromRoot = (glob) => {
+            const slashed = glob.replaceAll('\\', '/');
+            return path.posix.normalize(path.isAbsolute(slashed) ? posix(path.relative(folder, slashed)) : slashed);
+        };
+        // As glob's matchBase does, a pattern without a slash matches at any depth, outside dot folders too.
+        const matcher = (list) => picomatch(list.map(fromRoot).map((glob) => (glob.includes('/') ? glob : `**/${glob}`)));
+        const specs = globs(settings, ['specs']) ?? [];
+        if (!Array.isArray(specs))
+            return this.unknownProject(config, specs, 'specs');
+        const written = globs(settings, ['exclude']) ?? [];
+        if (!Array.isArray(written))
+            return this.unknownProject(config, written, 'exclude');
+        const excludes = written.filter((item) => !isSuiteName(settings, item));
+        const isGlob = excludes.every((item) => /[/\\*]/.test(item));
+        const isPathExcluded = matcher(excludes);
+        const isExcluded = (file, relative) => isGlob ? isPathExcluded(relative) : excludes.some((item) => pathToFileURL(file).href.includes(item));
+        // Each capability may set its own specs, which replace the config's, and excludes, added to the config's.
+        const capabilities = settingAt(settings, ['capabilities']);
+        const runs = [];
+        for (const capability of capabilities?.kind === 'list' && capabilities.items.length > 0
+            ? capabilities.items
+            : [emptySettings()]) {
+            const own = globs(capability, ['specs', 'wdio:specs']);
+            if (own !== null && !Array.isArray(own))
+                return this.unknownProject(config, own, 'capabilities.specs');
+            const exclude = globs(capability, ['exclude', 'wdio:exclude']) ?? [];
+            if (!Array.isArray(exclude))
+                return this.unknownProject(config, exclude, 'capabilities.exclude');
+            runs.push({ isSpec: matcher(own ?? specs), isExcluded: matcher(exclude) });
+        }
+        const framework = settingAt(settings, ['framework']);
+        const isJasmine = framework?.kind === 'value' && framework.value === 'jasmine';
+        const options = settingAt(settings, [isJasmine ? 'jasmineOpts' : 'mochaOpts']) ?? emptySettings();
+        const duration = (key) => {
+            const setting = settingAt(options, [key]);
+            const value = setting?.kind === 'value' ? durationOf(setting.value, key) : null;
+            return value === null ? setting : { kind: 'value', value };
+        };
+        // A `defaultTimeoutInterval` of 0 replaces WebdriverIO's default, and its Jasmine adapter then takes 60 seconds.
+        const interval = settingAt(options, ['defaultTimeoutInterval']);
+        const jasmineTimeout = interval?.kind === 'value' && interval.value === 0 ? { kind: 'value', value: 60_000 } : interval;
+        const about = {
+            name: '',
+            testDir: folder,
+            dependencies: [],
+            settings,
+            root: folder,
+            container: null,
+            config,
+            grep: null,
+            grepRoot: folder,
+            runsByDefault: true,
+            defaults: isJasmine
+                ? { ...NO_DEFAULTS, timeout: jasmineTimeout }
+                : { ...NO_DEFAULTS, timeout: duration('timeout'), retry: duration('retries') },
+        };
+        return {
+            config,
+            settings,
+            about,
+            unknown: null,
+            runs: (file) => {
+                const relative = posix(path.relative(folder, file));
+                if (isExcluded(file, relative))
+                    return false;
+                // Files given with `--spec` replace every capability's specs.
+                const running = runs.some((run) => (!this.findsFiles || run.isSpec(relative)) && !run.isExcluded(relative));
+                return running ? 'test' : false;
+            },
+        };
+    }
     projectsOf(config) {
         let projects = this.projects.get(config);
         if (!projects) {
-            projects = this.framework === 'playwright' ? this.playwrightProjects(config) : this.vitestProjects(config);
+            if (this.framework === 'playwright')
+                projects = this.playwrightProjects(config);
+            else if (this.framework === 'jest')
+                projects = this.jestProjects(config);
+            else if (this.framework === 'mocha')
+                projects = [this.mochaProject(config, config.settings)];
+            else if (this.framework === 'jasmine')
+                projects = [this.jasmineProject(config)];
+            else if (this.framework === 'cypress')
+                projects = this.cypressProjects(config);
+            else if (this.framework === 'webdriverio')
+                projects = [this.webdriverioProject(config)];
+            else
+                projects = this.vitestProjects(config);
             this.projects.set(config, projects);
         }
         return projects;
     }
     /** Vitest's `retry`: before 4.1, which reads only a count, an object is one the scan can't work out. */
-    vitestRetry(setting) {
-        return setting?.kind === 'object' && !atLeast(this.version, 4, 1) ? unknownAt(setting) : setting;
+    vitestRetry(config, setting) {
+        if (setting?.kind !== 'object' || atLeast(this.version, 4, 1))
+            return setting;
+        const message = "The config's test.retry is an object, which Vitest reads from 4.1; before, it runs no test.";
+        this.configs.reportSetting(setting, config, 'test.retry', message);
+        return unknownAt(setting);
     }
     /** A project whose files can't be worked out, because of `setting` under `key`: it may run any file. */
     unknownProject(config, setting, key) {
@@ -429,10 +949,196 @@ export class ConfigRuns {
         }
         return rules;
     }
+    /** A config for the defaults of a runner started where no config is found. */
+    noConfig() {
+        const file = path.join(this.configs.root, 'package.json');
+        return { file, record: { relativeFilePath: 'package.json', extends: [] }, settings: emptySettings() };
+    }
+    /**
+     * Jest's projects: the config itself, or the entries of its `projects`. A path or glob there names a folder, whose
+     * config is the one Jest finds from it, or a config file; an object is a project whose `rootDir` defaults to the
+     * config's folder. The config's own test files then count only when an entry names its folder.
+     */
+    jestProjects(config) {
+        const folder = path.dirname(config.file);
+        const list = settingAt(config.settings, ['projects']);
+        const isEmpty = list?.kind === 'list' && list.items.length === 0;
+        if (list === null || isUnset(list) || isEmpty) {
+            return [this.jestProject(config, config.settings, folder, config.settings)];
+        }
+        if (list.kind !== 'list')
+            return [this.unknownProject(config, unknownAt(list), 'projects')];
+        const rootDir = jestRootDir(config.settings, folder);
+        if (typeof rootDir !== 'string')
+            return [this.unknownProject(config, rootDir, 'rootDir')];
+        return list.items.flatMap((item) => {
+            if (item.kind === 'object')
+                return [this.jestProject(config, item, folder, config.settings)];
+            if (item.kind !== 'value' || typeof item.value !== 'string') {
+                return [this.unknownProject(config, unknownAt(item), 'projects')];
+            }
+            const entry = replaceRootDir(rootDir, item.value);
+            // Jest globs from where it is started, with `\` as a separator on Windows, and keeps an entry that matches nothing
+            // as a path.
+            const pattern = posix(path.isAbsolute(entry) ? path.relative(this.configs.root, entry) : entry);
+            const matches = picomatch.scan(pattern).isGlob
+                ? globSync(pattern, { cwd: this.configs.root, absolute: true, onlyFiles: false, expandDirectories: false })
+                : [];
+            // Jest leaves out a matched file it can't require, such as a README.
+            const requirable = matches.filter((match) => statSync(match).isDirectory() || JEST_CONFIG_EXTENSIONS.some((extension) => match.endsWith(extension)));
+            const targets = matches.length > 0 ? requirable : [path.resolve(this.configs.root, entry)];
+            // Jest fails on an entry that names nothing, so it adds no project here.
+            return targets.sort().flatMap((target) => {
+                if (!existsSync(target))
+                    return [];
+                const isFile = statSync(target).isFile();
+                const nested = isFile ? this.configs.at(target) : this.configs.projectConfig(target);
+                if (!nested || nested === config)
+                    return [this.jestProject(config, config.settings, folder, config.settings)];
+                return [this.jestProject(nested, nested.settings, path.dirname(nested.file), config.settings)];
+            });
+        });
+    }
+    /**
+     * The files a Jest project runs, as Jest's SearchSource picks them: under one of `roots`, with an extension in
+     * `moduleFileExtensions`, not left out by `modulePathIgnorePatterns`, matching `testMatch` or `testRegex`, and not
+     * `testPathIgnorePatterns`. Paths and patterns are matched with `/`, and `<rootDir>` stands for `rootDir`. `global`
+     * is the config Jest is started with, whose `testTimeout` applies to every project in Jest 29.
+     */
+    jestProject(config, written, folder, global) {
+        const rootDir = jestRootDir(written, folder);
+        if (typeof rootDir !== 'string')
+            return this.unknownProject(config, rootDir, 'rootDir');
+        const settings = this.withPreset(config, written, rootDir);
+        const isJest30 = this.version === null || this.version[0] >= 30;
+        const lists = {};
+        const defaults = [
+            ['roots', ['<rootDir>']],
+            ['testMatch', isJest30 ? JEST_TEST_MATCH[30] : JEST_TEST_MATCH[29]],
+            ['testRegex', []],
+            ['testPathIgnorePatterns', ['/node_modules/']],
+            ['modulePathIgnorePatterns', []],
+            ['moduleFileExtensions', isJest30 ? [...JEST_EXTENSIONS, 'mts', 'cts'] : JEST_EXTENSIONS],
+        ];
+        for (const [key, fallback] of defaults) {
+            const setting = settingAt(settings, [key]);
+            const found = isJestSet(setting) ? patterns(setting, key === 'testRegex') : fallback;
+            // A list of paths left out only takes files away, so the entries the scan can read are still a good guess.
+            if (!Array.isArray(found) && key.endsWith('IgnorePatterns')) {
+                this.configs.reportUnknown(found, key, 'the scan may list test files that Jest leaves out');
+                const items = setting?.kind === 'list' ? setting.items : [];
+                lists[key] = items.flatMap((item) => item.kind === 'value' && typeof item.value === 'string' ? [item.value] : []);
+                continue;
+            }
+            if (!Array.isArray(found))
+                return this.unknownProject(config, found, key);
+            lists[key] = found;
+        }
+        const testRegex = lists.testRegex.map((item) => typeof item === 'string' ? regExp(item, '') : item);
+        const invalid = lists.testRegex.find((_, index) => testRegex[index] === null);
+        const testMatchSetting = settingAt(settings, ['testMatch']);
+        let refusal = null;
+        if (invalid !== undefined) {
+            refusal = `The config's testRegex '${String(invalid)}' is not a regular expression, so Jest fails to start.`;
+        }
+        else if (testRegex.length > 0 && isJestSet(testMatchSetting)) {
+            refusal = 'The config sets both testMatch and testRegex, which Jest refuses, so it runs no tests.';
+        }
+        const roots = lists.roots
+            .map((item) => replaceRootDir(rootDir, item))
+            .map((root) => path.resolve(rootDir, root));
+        const escaped = posix(rootDir).replaceAll(/([!()*?[\\\]{}])/g, '\\$1');
+        const testMatch = testRegex.length > 0 ? [] : lists.testMatch.map((glob) => posix(replaceRootDir(escaped, glob)));
+        const isTestMatch = jestGlobs(testMatch);
+        // A pattern is a regular expression, in which Jest replaces every `<rootDir>`; escapes stay as written.
+        const joined = (key) => {
+            const items = lists[key].map((item) => item.replaceAll('<rootDir>', posix(rootDir)));
+            if (items.length === 0)
+                return null;
+            const expression = regExp(items.join('|'), '');
+            refusal ??= expression ? null : `The config's ${key} is not a regular expression, so Jest fails to start.`;
+            return expression;
+        };
+        const ignored = joined('testPathIgnorePatterns');
+        const moduleIgnored = joined('modulePathIgnorePatterns');
+        if (refusal)
+            this.configs.reportConfig(config, refusal);
+        const extensions = new Set(lists.moduleFileExtensions);
+        const preset = settingAt(written, ['preset']);
+        const isPackage = preset?.kind === 'value' && typeof preset.value === 'string' && !isLocalPreset(preset.value);
+        if (isPackage && !NEUTRAL_PRESETS.test(String(preset.value))) {
+            const message = `The config's preset '${preset.value}' is a package the scan doesn't read, and it may set which files are tests; the scan takes Jest's defaults for what the config doesn't set.`;
+            if (testMatchSetting === null && testRegex.length === 0)
+                this.configs.reportConfig(config, message);
+        }
+        const displayName = settingAt(settings, ['displayName']);
+        const named = displayName?.kind === 'object' ? settingAt(displayName, ['name']) : displayName;
+        const name = named?.kind === 'value' && typeof named.value === 'string' ? named.value : '';
+        const about = {
+            name,
+            testDir: rootDir,
+            dependencies: [],
+            settings,
+            root: rootDir,
+            container: null,
+            config,
+            grep: null,
+            grepRoot: rootDir,
+            runsByDefault: true,
+            defaults: {
+                // A project's own testTimeout counts from Jest 30; before, only the config Jest is started with sets it.
+                timeout: (isJest30 ? settingAt(settings, ['testTimeout']) : null) ?? settingAt(global, ['testTimeout']),
+                retry: null,
+                repeatEach: null,
+                repeats: null,
+                parallel: null,
+                tags: null,
+            },
+        };
+        return {
+            config,
+            settings,
+            about,
+            unknown: null,
+            runs: (file) => {
+                const unix = posix(file);
+                if (refusal || !extensions.has(path.extname(file).slice(1)))
+                    return false;
+                if (!roots.some((root) => isInside(root, file)) || moduleIgnored?.test(unix))
+                    return false;
+                if (testMatch.length > 0 && !isTestMatch(unix))
+                    return false;
+                if (ignored?.test(unix))
+                    return false;
+                return testRegex.length === 0 || testRegex.some((expression) => matches(expression, unix))
+                    ? 'test'
+                    : false;
+            },
+        };
+    }
     /**
      * The projects of a Vitest config, the one the runner starts with or, in Vitest 5, a config another lists, whose name
      * then goes around the names of its projects.
      */
+    /**
+     * A project's settings over those of its `preset` when that is a local file, as `'../../jest.preset.js'`, which Jest
+     * finds from `rootDir`: the project's own settings win, as Jest merges them. A preset that is a package isn't read.
+     */
+    withPreset(config, settings, rootDir) {
+        const preset = settingAt(settings, ['preset']);
+        if (preset?.kind !== 'value' || typeof preset.value !== 'string' || !isLocalPreset(preset.value))
+            return settings;
+        const target = path.resolve(rootDir, replaceRootDir(rootDir, preset.value));
+        const file = ['', '.js', '.json', '.cjs'].map((extension) => target + extension).find(isFileAt);
+        if (!file) {
+            this.configs.reportConfig(config, `The config's preset '${preset.value}' doesn't exist, so Jest fails to start.`);
+            return settings;
+        }
+        const base = this.configs.at(file).settings;
+        if (base.kind !== 'object' || settings.kind !== 'object')
+            return settings;
+        return { ...settings, keys: new Map([...base.keys, ...settings.keys]) };
+    }
     vitestProjects(config, container = null) {
         const folder = path.dirname(config.file);
         const list = settingAt(config.settings, ['test', 'projects']);
@@ -502,7 +1208,26 @@ export class ConfigRuns {
         const ownTags = isVitest5 ? settingAt(entry, ['test', 'tags']) : null;
         const settings = mergeDeep(base, entry);
         const name = this.listedName(isVitest5 ? entry : settings, index, container);
-        return this.vitestProject(config, settings, folder, ownTags, name);
+        const root = this.inlineRoot(config, entry, folder);
+        if (typeof root !== 'string')
+            return [this.unknownProject(config, root.setting, root.key)];
+        return this.vitestProject(config, settings, root, ownTags, name, true);
+    }
+    /**
+     * The folder an inline project runs from. Without a root of its own, every version runs it from the config's root;
+     * Vitest 5 also resolves its own root from there, where older versions resolve it from the config's folder.
+     */
+    inlineRoot(config, entry, folder) {
+        const parent = writtenRoot(config.settings);
+        const parentRoot = typeof parent === 'string' ? path.resolve(folder, parent) : (parent ?? folder);
+        const own = writtenRoot(entry);
+        if (own === null)
+            return parentRoot;
+        if (typeof own !== 'string')
+            return own;
+        if (!atLeast(this.version, 5, 0))
+            return path.resolve(folder, own);
+        return typeof parentRoot === 'string' ? path.resolve(parentRoot, own) : parentRoot;
     }
     /**
      * The projects of a config file or folder `test.projects` names: the config's own, also the projects it lists in
@@ -527,10 +1252,11 @@ export class ConfigRuns {
     }
     /**
      * A Vitest project, with the name Vitest gives it: its files are found from `test.dir`, else `test.root` or `root`,
-     * else its folder. With browser mode on, each of `browser.instances` is a project of its own, named as Vitest names it.
+     * else its folder; with `isRoot`, `folder` is its root already. With browser mode on, each of `browser.instances` is
+     * a project of its own, named as Vitest names it.
      */
-    vitestProject(config, settings, folder, ownTags, name) {
-        const project = this.vitestFiles(config, settings, folder, ownTags, name);
+    vitestProject(config, settings, folder, ownTags, name, isRoot = false) {
+        const project = this.vitestFiles(config, settings, folder, ownTags, name, isRoot);
         if (project.unknown)
             return [project];
         const enabled = settingAt(settings, ['test', 'browser', 'enabled']);
@@ -553,11 +1279,11 @@ export class ConfigRuns {
         });
     }
     /** The files a Vitest project runs and its settings; `ownTags`, when set, in place of the tags in `settings`. */
-    vitestFiles(config, settings, folder, ownTags, name) {
+    vitestFiles(config, settings, folder, ownTags, name, isRoot) {
         let root = folder;
         let dir = null;
         let hasTestRoot = false;
-        for (const key of ['test.root', 'root', 'test.dir']) {
+        for (const key of isRoot ? ['test.dir'] : ['test.root', 'root', 'test.dir']) {
             const setting = settingAt(settings, key.split('.'));
             if (setting === null || isUnset(setting))
                 continue;
@@ -618,7 +1344,7 @@ export class ConfigRuns {
             runsByDefault: true,
             defaults: {
                 timeout: settingAt(settings, ['test', 'testTimeout']),
-                retry: this.vitestRetry(settingAt(settings, ['test', 'retry'])),
+                retry: this.vitestRetry(config, settingAt(settings, ['test', 'retry'])),
                 repeatEach: null,
                 // Vitest 5 added `repeats` to the config.
                 repeats: atLeast(this.version, 5, 0) ? settingAt(settings, ['test', 'repeats']) : null,
@@ -704,7 +1430,47 @@ function hasInSourceTests(file) {
 function unknownAt(setting) {
     return setting.kind === 'unknown' ? setting : { kind: 'unknown', where: null };
 }
+/**
+ * The root a config sets, `test.root` over Vite's `root`, as written; null when it sets none, and the setting and its
+ * key when it can't be worked out.
+ */
+function writtenRoot(settings) {
+    for (const key of ['test.root', 'root']) {
+        const setting = settingAt(settings, key.split('.'));
+        if (setting === null || isUnset(setting))
+            continue;
+        if (setting.kind !== 'value' || typeof setting.value !== 'string')
+            return { setting: unknownAt(setting), key };
+        return setting.value;
+    }
+    return null;
+}
 /** A config's settings without `test.projects`, as an inline project inherits them; both are known objects. */
+/**
+ * Whether Mocha's lookup of one `spec` entry finds a file: an entry with glob characters is a glob, which takes any
+ * file it matches; otherwise a file, the entry with one of the extensions added, or a folder, whose files with one of
+ * the extensions it takes, without hidden ones, and those of folders below with `recursive`.
+ */
+function mochaSpec(folder, spec, extensions, recursive) {
+    const target = path.resolve(folder, spec);
+    if (picomatch.scan(posix(spec)).isGlob) {
+        const isMatch = picomatch(posix(spec).replace(/^\.\//, ''));
+        return (file) => isMatch(posix(path.relative(folder, file)));
+    }
+    const stat = statSync(target, { throwIfNoEntry: false });
+    if (stat?.isFile())
+        return (file) => file === target;
+    if (!stat?.isDirectory())
+        return (file) => extensions.some((extension) => file === `${target}.${extension}`);
+    return (file) => {
+        if (!isInside(target, file) || path.basename(file).startsWith('.'))
+            return false;
+        if (!recursive && path.dirname(file) !== target)
+            return false;
+        // An extension may have several parts, as `spec.js`.
+        return extensions.some((extension) => file.endsWith(`.${extension}`));
+    };
+}
 function withoutProjects(settings) {
     const root = settings;
     const test = root.keys.get('test');
@@ -913,21 +1679,19 @@ const UNKNOWN_DEFAULTS = {
     parallel: false,
 };
 /**
- * What the config a file uses gives it: Playwright's `forbidOnly`, read from the top level only, as Playwright reads
- * it, and for each test, the projects that run it and what they set; null without a config.
+ * What the config a file uses gives it: Playwright's `forbidOnly` or Vitest's `allowOnly`, read from the top level
+ * only, as the runners read them, and for each test, the projects that run it and what they set; null without a config.
  */
 export function fileConfig(placement, framework, version, file) {
     const { config, projects } = placement;
     if (config === null) {
         // Without a config, Vitest defines no tags and keeps strictTags on.
         const tags = vitestTags(null, null, null, atLeast(version, 5, 0));
-        return framework === 'vitest' ? { forbidOnly: false, forTest: () => NO_CONFIG, tags, configTags: [] } : null;
+        const forbidOnly = onlyRule(framework, null);
+        return framework === 'vitest' ? { forbidOnly, forTest: () => NO_CONFIG, tags, configTags: [] } : null;
     }
-    const forbidOnly = framework === 'playwright' ? settingAt(config.settings, ['forbidOnly']) : null;
     return {
-        forbidOnly: forbidOnly?.kind === 'unknown'
-            ? (unknownText(forbidOnly) ?? false)
-            : forbidOnly?.kind === 'value' && forbidOnly.value === true,
+        forbidOnly: onlyRule(framework, config.settings),
         forTest(test, suites) {
             if (projects === null)
                 return { projects: null, defaults: UNKNOWN_DEFAULTS };
@@ -939,9 +1703,241 @@ export function fileConfig(placement, framework, version, file) {
         configTags: placement.tags ?? [],
     };
 }
+/**
+ * Why a `.only` fails: with Playwright's `forbidOnly`, the run, before any test; with Vitest's `allowOnly` off, the
+ * test itself, which Vitest marks failed instead of running it (checked in 3.2.4, 4.1.12 and 5.1.0). `allowOnly` is
+ * off by default when `process.env.CI` is set. Null when nothing fails.
+ */
+function onlyRule(framework, settings) {
+    if (framework === 'playwright') {
+        const forbid = settings && settingAt(settings, ['forbidOnly']);
+        const condition = forbid?.kind === 'unknown' ? unknownText(forbid) : null;
+        if (condition) {
+            const message = `The config sets forbidOnly when ${condition}, so then this .only fails the run before any test runs.`;
+            return { message, isSure: false };
+        }
+        if (forbid?.kind !== 'value' || forbid.value !== true)
+            return null;
+        return { message: 'The config sets forbidOnly, so this .only fails the run before any test runs.', isSure: true };
+    }
+    if (framework !== 'vitest')
+        return null;
+    const allow = settings && settingAt(settings, ['test', 'allowOnly']);
+    const effect = 'Vitest fails this .only test instead of running it';
+    if (allow === null || isUnset(allow)) {
+        return {
+            message: `Vitest's allowOnly is off when process.env.CI is set, as in CI, and then ${effect}.`,
+            isSure: false,
+        };
+    }
+    const condition = allow.kind === 'unknown' ? unknownText(allow) : null;
+    if (condition) {
+        return { message: `The config sets allowOnly to ${condition}; when that is false, ${effect}.`, isSure: false };
+    }
+    // An object or a list is true, as is any value but `false` and the other falsy ones.
+    if (allow.kind !== 'value' || allow.value)
+        return null;
+    return { message: `The config sets allowOnly to ${String(allow.value)}, so ${effect}.`, isSure: true };
+}
 /** The tags the projects that run a file define, when they all define the same; null otherwise. */
 function agreedTags(projects) {
     const [first, ...others] = (projects ?? []).map(({ defaults }) => defaults.tags);
     const text = JSON.stringify(first ?? null);
     return first && others.every((tags) => JSON.stringify(tags) === text) ? first : null;
 }
+/**
+ * Jest's `rootDir`: the config's folder, or the folder the config sets, from its folder, where an inline project's
+ * `<rootDir>` is the config's folder too; unknown when it can't tell.
+ */
+function jestRootDir(settings, folder) {
+    const setting = settingAt(settings, ['rootDir']);
+    if (setting === null || isUnset(setting))
+        return folder;
+    return setting.kind === 'value' && typeof setting.value === 'string'
+        ? path.resolve(folder, replaceRootDir(folder, setting.value))
+        : unknownAt(setting);
+}
+/** Jest's `replaceRootDirInPath`: `<rootDir>` at the start of a path stands for the project's `rootDir`. */
+function replaceRootDir(rootDir, item) {
+    return item.startsWith('<rootDir>') ? path.join(rootDir, item.slice('<rootDir>'.length)) : item;
+}
+/**
+ * Jest's `globsToMatcher`: a path matches a glob that isn't negated and no negated glob leaves it out, or, when every
+ * glob is negated, none leaves it out. Globs match the absolute path, dot files too.
+ */
+function jestGlobs(globs) {
+    const matchers = globs.map((glob) => {
+        const isMatch = picomatch(glob, { dot: true }, true);
+        return { isMatch, negated: isMatch.state.negated || Boolean(isMatch.state.negatedExtglob) };
+    });
+    return (file) => {
+        let kept;
+        for (const { isMatch, negated } of matchers) {
+            const matched = isMatch(file);
+            if (!matched && negated)
+                kept = false;
+            else if (matched && !negated)
+                kept = true;
+        }
+        return matchers.every(({ negated }) => negated) ? kept !== false : kept === true;
+    };
+}
+/** Whether a Jest setting is given: `null` and `undefined` leave Jest's default, as a `testMatch: null` beside `testRegex`. */
+function isJestSet(setting) {
+    return setting !== null && !isUnset(setting) && !(setting.kind === 'value' && setting.value === null);
+}
+/** A Jest preset written as a path, which Jest reads from the project, rather than a package's name. */
+function isLocalPreset(preset) {
+    return /^(\.{1,2}\/|\/|<rootDir>)/.test(preset);
+}
+function isFileAt(file) {
+    return existsSync(file) && statSync(file).isFile();
+}
+/**
+ * The interface Mocha's `ui` gives a file's tests: BDD by default, or TDD. Another one, QUnit, exports or a package,
+ * declares tests in a way the scan doesn't read, which is reported on the config, and the file is read as BDD.
+ */
+export function mochaInterface(placement, configs) {
+    const { config } = placement;
+    const ui = config ? settingAt(config.settings, ['ui']) : null;
+    if (ui === null || isUnset(ui))
+        return 'bdd';
+    if (ui.kind !== 'value') {
+        configs.reportUnknown(unknownAt(ui), 'ui', "the scan reads the tests as Mocha's default, BDD");
+        return 'bdd';
+    }
+    if (ui.value === 'bdd' || ui.value === 'tdd')
+        return ui.value;
+    const message = `The config's ui '${String(ui.value)}' is an interface the scan doesn't read, so it reads the tests as Mocha's default, BDD.`;
+    configs.reportConfig(config, message);
+    return 'bdd';
+}
+/**
+ * Whether an `exclude` entry names one of the config's `suites` rather than files: WebdriverIO leaves that suite out of
+ * a `--suite` run, and takes it as no exclusion otherwise.
+ */
+function isSuiteName(settings, item) {
+    if (/[/\\*?]/.test(item) || /\.(js|ts|mjs|cjs|es6|feature)$/i.test(item))
+        return false;
+    const suites = settingAt(settings, ['suites']);
+    return suites?.kind === 'object' && suites.keys.has(item);
+}
+/** The interface WebdriverIO's `mochaOpts.ui` gives a file's tests, read as Mocha's `ui`. */
+export function webdriverioInterface(placement, configs) {
+    if (placement.config === null || webdriverioFramework(placement, null) === 'jasmine')
+        return 'bdd';
+    const options = settingAt(placement.config.settings, ['mochaOpts']);
+    return mochaInterface({ ...placement, config: { ...placement.config, settings: options ?? emptySettings() } }, configs);
+}
+/**
+ * The framework a WebdriverIO config runs the specs with: Mocha by default, or Jasmine. Cucumber runs feature files,
+ * which the scan doesn't read; that and a value the scan can't work out are reported on the config when `configs` is
+ * given, and the files are read as Mocha's.
+ */
+export function webdriverioFramework(placement, configs) {
+    const { config } = placement;
+    const framework = config ? settingAt(config.settings, ['framework']) : null;
+    if (framework === null || isUnset(framework))
+        return 'mocha';
+    if (framework.kind === 'value' && (framework.value === 'mocha' || framework.value === 'jasmine'))
+        return framework.value;
+    if (framework.kind !== 'value') {
+        configs?.reportUnknown(unknownAt(framework), 'framework', "the scan reads the tests as WebdriverIO's default, Mocha's");
+    }
+    else {
+        const message = `The config's framework '${String(framework.value)}' is one the scan doesn't read, so it reads the tests as WebdriverIO's default, Mocha's.`;
+        configs?.reportConfig(config, message);
+    }
+    return 'mocha';
+}
+/**
+ * How the config a file runs with maps its imports, for its dependencies: Vite's `resolve.alias` and Vitest's
+ * `test.alias`, from the project and from the config file, and Jest's `moduleNameMapper`, `modulePaths` and
+ * `moduleDirectories` other than `node_modules`, with `<rootDir>` in them. Null for the other runners, without a
+ * config, or when it maps nothing.
+ */
+export function importMap(placement, framework) {
+    const { config, settings } = placement;
+    if (!config || !settings)
+        return null;
+    // The files of a project share its map, so the modules they import are read once.
+    if (!importMaps.has(settings))
+        importMaps.set(settings, readImportMap(config, settings, placement, framework));
+    return importMaps.get(settings) ?? null;
+}
+const importMaps = new WeakMap();
+function readImportMap(config, settings, placement, framework) {
+    const map = { aliases: [], paths: [], directories: [] };
+    if (framework === 'vitest') {
+        const sources = settings === config.settings ? [settings] : [settings, config.settings];
+        for (const source of sources) {
+            for (const key of [
+                ['test', 'alias'],
+                ['resolve', 'alias'],
+            ])
+                map.aliases.push(...viteAliases(settingAt(source, key)));
+        }
+    }
+    else if (framework === 'jest') {
+        const rootDir = placement.projects?.[0]?.root ?? path.dirname(config.file);
+        const mapper = settingAt(settings, ['moduleNameMapper']);
+        for (const [pattern, target] of mapper?.kind === 'object' ? mapper.keys : []) {
+            const replacements = (target.kind === 'list' ? strings(target) : stringOf(target)).map((item) => replaceRootDir(rootDir, item));
+            const find = regExp(pattern, '');
+            if (find && replacements.length > 0)
+                map.aliases.push({ find, replacements });
+        }
+        map.paths = strings(settingAt(settings, ['modulePaths'])).map((item) => path.resolve(rootDir, replaceRootDir(rootDir, item)));
+        map.directories = strings(settingAt(settings, ['moduleDirectories'])).filter((name) => name !== 'node_modules');
+    }
+    return map.aliases.length + map.paths.length + map.directories.length > 0 ? map : null;
+}
+/**
+ * Vite's aliases: an object of names and their replacements, or a list of `{ find, replacement }`, where `find` is a
+ * name or a regex. Entries the scan can't work out are left out.
+ */
+function viteAliases(setting) {
+    if (setting?.kind === 'object') {
+        return [...setting.keys].flatMap(([find, target]) => stringOf(target).map((replacement) => ({ find, replacements: [replacement] })));
+    }
+    if (setting?.kind !== 'list')
+        return [];
+    return setting.items.flatMap((item) => {
+        const find = settingAt(item, ['find']);
+        const replacements = stringOf(settingAt(item, ['replacement']));
+        const name = find?.kind === 'value' && typeof find.value === 'string' ? find.value : null;
+        const pattern = find?.kind === 'regex' ? regExp(find.source, find.flags) : null;
+        const written = name ?? pattern;
+        return written !== null && replacements.length > 0 ? [{ find: written, replacements }] : [];
+    });
+}
+/** A setting's string as a list of one; empty for anything else. */
+function stringOf(setting) {
+    return setting?.kind === 'value' && typeof setting.value === 'string' ? [setting.value] : [];
+}
+/** Whether a Node.js version runs TypeScript files without a flag: from 22.18 on the 22 line, and from 23.6. */
+function stripsTypes(version) {
+    if (version === null)
+        return true;
+    const [major, minor] = version;
+    return major > 23 || (major === 23 && minor >= 6) || (major === 22 && minor >= 18);
+}
+/**
+ * The `node --test` commands of the package.json script that runs node:test, the `test` script first, each as the
+ * files it gives; none when no script runs it or there is no package.json.
+ */
+function nodeTestArguments(manifest) {
+    let scripts = {};
+    try {
+        scripts = JSON.parse(readFileSync(manifest, 'utf8')).scripts ?? {};
+    }
+    catch {
+        return [];
+    }
+    for (const script of [scripts.test, ...Object.values(scripts)]) {
+        const commands = typeof script === 'string' ? nodeTestCommands(script) : [];
+        if (commands.length > 0)
+            return commands;
+    }
+    return [];
+}