test-inventory 0.8.0 → 0.9.0

package/dist/options.d.ts

@@ -4,13 +4,16 @@ export type { CommentsMode };
 /** @inline */
 export interface ScanOptions {
     /**
-     * Glob patterns for the test files, relative to `root`. As in Playwright and Vitest, they match names that start with
-     * a dot too. Without them, the test files are those the configs in the root and the folders below it run.
+     * Glob patterns for the test files, relative to `root`. As in the runners, they match names that start with a dot
+     * too. Without them, the test files are those the configs in the root and the folders below it run, or for node:test
+     * and Bun those `node --test` and `bun test` run.
      */
     patterns?: string[];
     /**
-     * The runner whose tests are listed. Without it, the one the project uses: whose package a package.json lists, or
-     * whose config is in the root or below. With none of them or several, the scan throws a `TypeError` that names them.
+     * The runner whose tests are listed. Without it, the one the project uses: whose package a package.json in the root
+     * or below lists, whose config is there, or for node:test and Bun, run by a package.json script, else one a
+     * package.json above the root lists. With none of them or
+     * several, the scan throws a `TypeError` that names them.
      */
     framework?: Framework;
     /** The project root. Paths in the output are relative to it. Defaults to the current directory. */
@@ -26,6 +29,11 @@ export interface ScanOptions {
      * out, each with the title the runner gives it. Defaults to `false`: one record per declaration.
      */
     expandCases?: boolean;
+    /**
+     * Stops the scan when it aborts: the scan checks it before it starts and between files, and then rejects with the
+     * signal's `reason`, as `fetch` does.
+     */
+    signal?: AbortSignal;
 }
 /** @inline */
 export interface ScanSourceOptions {
@@ -51,6 +59,7 @@ export declare function checkObject(value: unknown, name: string): Record<string
 export declare function checkFramework(value: unknown, option: string): Framework;
 export declare function checkComments(value: unknown, option: string): CommentsMode;
 export declare function checkFlag(value: unknown, option: string): boolean;
+export declare function checkSignal(value: unknown, option: string): AbortSignal | null;
 export declare function checkVersion(value: unknown, option: string): string | null;
 export declare function checkString(value: unknown, option: string): string;
 export declare function checkStrings(value: unknown, option: string, required: boolean): string[];

package/dist/options.js

@@ -1,4 +1,14 @@
-const FRAMEWORKS = ['playwright', 'vitest', 'jest'];
+const FRAMEWORKS = [
+    'playwright',
+    'vitest',
+    'jest',
+    'mocha',
+    'jasmine',
+    'cypress',
+    'webdriverio',
+    'node',
+    'bun',
+];
 const COMMENTS = ['all', 'non-active', 'none'];
 // A prerelease and build metadata each appear once, so a long input can't make the match backtrack for long.
 const VERSION = /^v?(\d+)\.(\d+)(?:\.\d+)?(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
@@ -14,8 +24,10 @@ export function checkObject(value, name) {
     return value;
 }
 export function checkFramework(value, option) {
-    if (!FRAMEWORKS.includes(value))
-        throw invalid(option, '"playwright", "vitest" or "jest"');
+    if (!FRAMEWORKS.includes(value)) {
+        const names = FRAMEWORKS.map((name) => `"${name}"`);
+        throw invalid(option, `${names.slice(0, -1).join(', ')} or ${names.at(-1)}`);
+    }
     return value;
 }
 export function checkComments(value, option) {
@@ -32,6 +44,13 @@ export function checkFlag(value, option) {
         throw invalid(option, 'true or false');
     return value;
 }
+export function checkSignal(value, option) {
+    if (value === undefined)
+        return null;
+    if (!(value instanceof AbortSignal))
+        throw invalid(option, 'an AbortSignal');
+    return value;
+}
 export function checkVersion(value, option) {
     if (value === undefined || value === null)
         return null;

package/dist/records.d.ts

@@ -52,8 +52,14 @@ export interface VitestTags {
 }
 /** What the config the file uses gives it. */
 export interface FileConfig {
-    /** Whether a `.only` fails the run: Playwright's `forbidOnly`, always, never, or under the condition with this text. */
-    forbidOnly: boolean | string;
+    /**
+     * Why a `.only` fails, from Playwright's `forbidOnly` or Vitest's `allowOnly`, and whether it surely does; null when
+     * it doesn't.
+     */
+    forbidOnly: {
+        message: string;
+        isSure: boolean;
+    } | null;
     /** The names of the projects that run a test, null when unknown, and what they set for it. */
     forTest(test: TestRecord, suites: SuiteRecord[]): {
         projects: string[] | null;

package/dist/records.js

@@ -184,11 +184,16 @@ class RecordBuilder {
     fileName;
     ordinals = new Map();
     suiteIds = new Map();
+    testIds = new Map();
     diagnostics = [];
     /** The line of the first problem for which the runner refuses the file; null when it loads. */
     rejectedAt = null;
+    /** Whether the tests declared before the line that stops the file loading still run. */
+    keepsEarlierTests = false;
     /** Jest: the describes with a test of their own that uses `.only`, which then keep their mode from their others. */
     focused = new Set();
+    /** Jasmine: scopes with a focused spec or describe below them, whose own focus Jasmine gives up for the inner one. */
+    focusedBelow = new Set();
     constructor(parsed, options) {
         this.parsed = parsed;
         this.options = options;
@@ -215,7 +220,14 @@ class RecordBuilder {
         const lines = [...rejecting, ...(firstTag ? [firstTag] : [])].map((item) => this.parsed.source.line(item.node.start));
         if (lines.length > 0)
             this.rejectedAt = Math.min(...lines);
+        this.keepsEarlierTests = rejecting.length > 0 && rejecting.every((item) => item.keepsEarlierTests === true);
         this.focused = new Set(extraction.tests.filter((test) => test.declaration.isOnly).map((test) => test.scope));
+        const focusedAt = [
+            ...extraction.tests.filter((test) => test.declaration.isOnly).map((test) => test.scope),
+            // A describe's scope is inside the file's, so it has a parent.
+            ...extraction.suites.filter((suite) => suite.declaration.isOnly).map((suite) => suite.scope.parent),
+        ];
+        this.focusedBelow = new Set(focusedAt.flatMap((scope) => outward(scope)));
         const suites = extraction.suites.map((suite) => this.suite(suite));
         const tests = extraction.tests.map((test) => this.test(test, suites));
         for (const item of problems) {
@@ -265,15 +277,12 @@ class RecordBuilder {
      * warning. `call` is the `.only` call when it is in this file, whose callee the diagnostic shows.
      */
     forbidOnly(located, call) {
-        const forbid = this.options.config?.forbidOnly ?? false;
-        if (forbid === false)
+        const forbid = this.options.config?.forbidOnly ?? null;
+        if (forbid === null)
             return;
-        const message = forbid === true
-            ? 'The config sets forbidOnly, so this .only fails the run before any test runs.'
-            : `The config sets forbidOnly when ${forbid}, so then this .only fails the run before any test runs.`;
         const callee = call && snippet(this.parsed.source.text.slice(call.callee.start, call.callee.end));
-        const found = problem('forbidden-only', located, message, callee);
-        this.diagnostics.push(this.diagnostic(forbid === true ? found : { ...found, level: 'warning' }));
+        const found = problem('forbidden-only', located, forbid.message, callee);
+        this.diagnostics.push(this.diagnostic(forbid.isSure ? found : { ...found, level: 'warning' }));
     }
     suite(pending) {
         const { scope, declaration, call } = pending;
@@ -366,6 +375,16 @@ class RecordBuilder {
         const setting = own('skip') ?? own('todo') ?? own('expectedToFail');
         return { chosen: setting ? { setting, source: 'test' } : null, isOnly: declaration.isOnly || passesOnly };
     }
+    /**
+     * Whether Jasmine runs a spec as focused: a `fit`, or a spec in an `fdescribe` with no focused spec or describe
+     * below it, as Jasmine runs only the innermost focus (checked with Jasmine 4.6.0 and 7.0.0).
+     */
+    jasmineFocus(pending, scopes) {
+        if (pending.declaration.isOnly)
+            return true;
+        const nearest = scopes.find((scope) => scope.isOnly);
+        return nearest !== undefined && !this.focusedBelow.has(nearest);
+    }
     test(pending, suites) {
         const { declaration } = pending;
         const dependencies = this.options.dependencies(pending);
@@ -374,7 +393,14 @@ class RecordBuilder {
         const scopes = outward(pending.scope);
         const describes = scopes.filter((scope) => scope.kind === 'describe').reverse();
         const title = declaration.title;
-        const id = this.id([this.describeTitles(describes), title.withoutTags]);
+        const parents = [];
+        for (let parent = pending.parent; parent; parent = parent.parent)
+            parents.unshift(parent);
+        const parentTitles = parents.map((parent) => parent.declaration.title.withoutTags);
+        const id = this.id(parents.length > 0
+            ? [this.describeTitles(describes), parentTitles, title.withoutTags]
+            : [this.describeTitles(describes), title.withoutTags]);
+        this.testIds.set(pending, id);
         const fileScope = scopes[scopes.length - 1];
         const tags = unique([
             ...(this.options.config?.configTags ?? []),
@@ -387,21 +413,31 @@ class RecordBuilder {
         const tagsFirst = this.options.config?.tags?.beatsDescribes ?? true;
         const tagged = (own, tag, around) => tagsFirst ? [...own, ...tag, ...around] : [...own, ...around, ...tag];
         const jest = this.options.framework === 'jest' ? this.jestState(pending, scopes) : null;
+        const focused = this.options.framework === 'jasmine' ? this.jasmineFocus(pending, scopes) : null;
+        // A focused Jasmine spec runs inside an `xdescribe`, whose own skip doesn't reach it; `pending()` still does.
+        const declaredSkip = (scope, setting) => focused === true && scope.kind === 'describe' && suiteOf(scope).declaration.states.includes(setting);
         const chosen = jest
             ? jest.chosen
             : chooseState([
                 ...declaredStates(pending.states.slice(0, declaration.states.length), fromTags, declaration),
                 ...pending.states.slice(declaration.states.length).map((setting) => ({ setting, source: 'test' })),
-                ...scopes.flatMap((scope) => scope.states.map((setting) => ({
+                // A test the declaration skips never runs its body, so its subtests never run; one its body skips still runs it.
+                ...parents.flatMap((parent) => parent.declaration.states.map((setting) => ({ setting, source: 'suite' }))),
+                ...scopes.flatMap((scope) => scope.states
+                    .filter((setting) => !declaredSkip(scope, setting))
+                    .map((setting) => ({
                     setting,
                     source: scope.kind === 'file' ? 'file' : 'suite',
                 }))),
             ]);
-        // When the runner refuses the file, no test in it runs, whatever else is written.
-        const rejected = this.rejectedAt !== null;
+        // When the runner refuses the file, no test in it runs, whatever else is written, or none after the refused call.
+        const rejected = this.rejectedAt !== null && !(this.keepsEarlierTests && this.parsed.source.line(located.start) < this.rejectedAt);
         const state = rejected ? 'notLoaded' : (chosen?.setting.state ?? 'active');
         const setting = rejected ? null : (chosen?.setting ?? null);
-        const suitePath = describes.flatMap((scope) => suiteOf(scope).declaration.title?.text ?? []);
+        const suitePath = [
+            ...describes.flatMap((scope) => suiteOf(scope).declaration.title?.text ?? []),
+            ...parents.map((parent) => parent.declaration.title.text),
+        ];
         const tagConcurrent = this.options.config?.tags?.concurrentBeatsTags ? undefined : fromTags?.concurrent;
         const tagMode = tagConcurrent === undefined ? null : tagConcurrent ? 'parallel' : 'default';
         const [mode = null] = tagged([declaration.mode], [tagMode], scopes.map((scope) => scope.mode)).filter((item) => item !== null);
@@ -411,7 +447,7 @@ class RecordBuilder {
         }
         const isOnly = jest
             ? jest.isOnly
-            : declaration.isOnly || scopes.some((scope) => scope.isOnly) || fromTags?.only === true;
+            : (focused ?? (declaration.isOnly || scopes.some((scope) => scope.isOnly) || fromTags?.only === true));
         const comments = this.options.comments === 'all' || (this.options.comments === 'non-active' && state !== 'active')
             ? pending.comments
             : [];
@@ -442,6 +478,7 @@ class RecordBuilder {
             dependencies: dependencies.files,
             hasUnfollowedDependencies: !dependencies.isComplete,
             suiteId: describes.length > 0 ? this.suiteIds.get(describes[describes.length - 1]) : null,
+            parentTestId: pending.parent ? this.testIds.get(pending.parent) : null,
             suitePath,
             relativeFilePath: this.options.relativeFilePath,
             fileName: this.fileName,

package/dist/resolve.d.ts

@@ -2,8 +2,25 @@ import type { ModuleReader } from './model.ts';
 /** Parses JSON written with comments and trailing commas, as tsconfig files often are; null when it isn't JSON. */
 export declare function parseJsonc(text: string): unknown;
 /**
- * Returns a reader for the modules a test file imports. It follows relative paths, tsconfig `paths` and `baseUrl` from
- * the tsconfig nearest the importing file, package.json `imports` (`#name`), and workspace packages whose entry is
- * TypeScript source. Each module it reads carries a reader for the modules that module imports in turn.
+ * How a runner's config maps imports, for every module a test imports: aliases, tried first, as Vite's
+ * `resolve.alias` and Jest's `moduleNameMapper`, and folders a bare name is looked for in, as Jest's `modulePaths` and
+ * `moduleDirectories`.
  */
-export declare function moduleResolver(root: string): (fromFile: string) => ModuleReader;
+export interface ImportMap {
+    /** A string `find` maps the name itself and the names below it, as `@` maps `@/x`; a regex maps what it matches. */
+    aliases: {
+        find: string | RegExp;
+        replacements: string[];
+    }[];
+    /** Folders a bare name is looked for in. */
+    paths: string[];
+    /** Names of folders a bare name is looked for in, in the importing file's folder and each folder above it. */
+    directories: string[];
+}
+/**
+ * Returns a reader for the modules a test file imports. It follows the import map of the config the file runs with,
+ * relative paths, tsconfig `paths` and `baseUrl` from the tsconfig nearest the importing file, package.json `imports`
+ * (`#name`), and workspace packages whose entry is TypeScript source. Each module it reads carries a reader for the
+ * modules that module imports in turn, with the same import map.
+ */
+export declare function moduleResolver(root: string): (fromFile: string, map?: ImportMap | null) => ModuleReader;

package/dist/resolve.js

@@ -323,13 +323,34 @@ function workspaceSource(specifier, directory, packagesOf) {
     const local = packagesOf(directory).get(name);
     return local ? packageEntry(local, subpath) : null;
 }
+/** A file a bare name stands for in the folders an import map adds; null when none has it. */
+function searched(specifier, directory, map) {
+    const folders = [...map.paths];
+    for (let folder = directory;; folder = path.dirname(folder)) {
+        folders.push(...map.directories.map((name) => path.join(folder, name)));
+        if (path.dirname(folder) === folder)
+            break;
+    }
+    return folders.map((folder) => findFile(path.join(folder, specifier))).find((file) => file !== null) ?? null;
+}
+/** The names an alias maps a specifier to; null when it doesn't match. */
+function mapped(specifier, alias) {
+    const { find, replacements } = alias;
+    if (typeof find === 'string') {
+        if (specifier !== find && !specifier.startsWith(`${find}/`))
+            return null;
+        return replacements.map((replacement) => replacement + specifier.slice(find.length));
+    }
+    return find.test(specifier) ? replacements.map((replacement) => specifier.replace(find, replacement)) : null;
+}
 /**
- * Returns a reader for the modules a test file imports. It follows relative paths, tsconfig `paths` and `baseUrl` from
- * the tsconfig nearest the importing file, package.json `imports` (`#name`), and workspace packages whose entry is
- * TypeScript source. Each module it reads carries a reader for the modules that module imports in turn.
+ * Returns a reader for the modules a test file imports. It follows the import map of the config the file runs with,
+ * relative paths, tsconfig `paths` and `baseUrl` from the tsconfig nearest the importing file, package.json `imports`
+ * (`#name`), and workspace packages whose entry is TypeScript source. Each module it reads carries a reader for the
+ * modules that module imports in turn, with the same import map.
  */
 export function moduleResolver(root) {
-    // Many test files import the same fixtures file and share a tsconfig; each is read once.
+    // Many test files import the same fixtures file and share a tsconfig; each is read once per import map.
     const modules = new Map();
     const tsconfigs = new Map();
     const pathOptions = new Map();
@@ -362,11 +383,11 @@ export function moduleResolver(root) {
             workspaces.set(folder, packages);
         return packages;
     };
-    const reader = (fromFile) => (specifier) => {
-        const directory = path.dirname(fromFile);
+    /** The file a name stands for from a folder, or why it can't be followed. */
+    const locate = (specifier, directory, map) => {
         let candidates;
         // `.` and `..` are paths too: the index of the file's folder, or of the folder above.
-        if (/^\.\.?(?:\/|$)/.test(specifier)) {
+        if (/^\.\.?(?:\/|$)/.test(specifier) || path.isAbsolute(specifier)) {
             candidates = [path.resolve(directory, specifier)];
         }
         else if (specifier.startsWith('#')) {
@@ -388,29 +409,44 @@ export function moduleResolver(root) {
                 const workspace = fromBaseUrl ? null : workspaceSource(specifier, directory, packagesOf);
                 if (workspace && 'reason' in workspace)
                     return workspace;
-                const file = fromBaseUrl ?? workspace?.file;
+                const file = fromBaseUrl ?? workspace?.file ?? (map && searched(specifier, directory, map));
                 // No package name starts with `@/` or `~/`, so these are aliases, as Vite's `resolve.alias` sets them; any
                 // other name with no file may still be a package or a built-in module, as TypeScript takes it to be.
                 if (!file && /^[@~]\//.test(specifier)) {
-                    return { reason: targets ? 'could not be read' : 'is a path alias that no tsconfig paths define' };
+                    return { reason: targets ? 'could not be read' : 'is a path alias that no tsconfig paths or config define' };
                 }
                 if (!file)
                     return { reason: 'is not a local file, a path alias or a workspace package' };
                 candidates = [file];
             }
         }
-        const found = candidates.map(findFile).find((file) => file !== null);
-        if (!found)
-            return { reason: 'could not be read' };
-        if (!modules.has(found)) {
+        return candidates.map(findFile).find((file) => file !== null) ?? { reason: 'could not be read' };
+    };
+    const reader = (fromFile, map = null) => (specifier) => {
+        const directory = path.dirname(fromFile);
+        const aliased = map?.aliases.map((alias) => mapped(specifier, alias)).find((names) => names !== null);
+        // The config maps the name to others, each a path or a name looked up as written, the first that is found.
+        const located = (aliased ?? [specifier]).map((name) => locate(name, directory, map));
+        const found = located.find((item) => typeof item === 'string');
+        if (found === undefined) {
+            return aliased
+                ? { reason: `is mapped by the config to ${aliased.join(' or ')}, which could not be read` }
+                : located[0];
+        }
+        let known = modules.get(map);
+        if (!known) {
+            known = new Map();
+            modules.set(map, known);
+        }
+        if (!known.has(found)) {
             const content = readContent(found);
-            modules.set(found, content && {
+            known.set(found, content && {
                 ...content,
                 relativeFilePath: path.relative(root, found).replaceAll('\\', '/'),
-                readModule: reader(found),
+                readModule: reader(found, map),
             });
         }
-        return modules.get(found) ?? { reason: 'could not be read' };
+        return known.get(found) ?? { reason: 'could not be read' };
     };
     return reader;
 }

package/dist/scan-file.d.ts

@@ -1,6 +1,8 @@
 import type { RunsWith } from './config-dependencies.ts';
 import { DependencyGraph, type SnapshotFiles } from './dependency-hash.ts';
 import { ExportedValues } from './imported-values.ts';
+import { type MochaInterface } from './frameworks/mocha.ts';
+import { type WebdriverIOFramework } from './frameworks/webdriverio.ts';
 import type { ModuleReader } from './model.ts';
 import { type CommentsMode, type FileConfig, type FileRecords } from './records.ts';
 import type { Framework } from './types.ts';
@@ -18,6 +20,12 @@ export interface FileSettings {
     isBenchmarkFile?: boolean | null;
     /** What the config the file uses sets for its tests; null without a config. */
     config?: FileConfig | null;
+    /** The interface Mocha's config sets for the tests: `describe` and `it`, or `suite` and `test`. */
+    mochaInterface?: MochaInterface;
+    /** The length Vitest's config shortens a value in a case title to; Vitest's default, 40, when unset. */
+    titleTruncate?: number;
+    /** The framework a WebdriverIO config runs the specs with. */
+    webdriverioFramework?: WebdriverIOFramework;
     /** Shared by the files of one scan, so that code many tests reach is read once. */
     graph?: DependencyGraph;
     /** Shared by the files of one scan, so that each module's exported values are worked out once. */

package/dist/scan-file.js

@@ -7,6 +7,12 @@ import { atLeast, problem } from "./frameworks/common.js";
 import { PlaywrightAdapter } from "./frameworks/playwright.js";
 import { VitestAdapter } from "./frameworks/vitest.js";
 import { JestAdapter } from "./frameworks/jest.js";
+import { MochaAdapter } from "./frameworks/mocha.js";
+import { BunAdapter } from "./frameworks/bun.js";
+import { CypressAdapter } from "./frameworks/cypress.js";
+import { NodeAdapter } from "./frameworks/node.js";
+import { WebdriverIOJasmineAdapter, WebdriverIOMochaAdapter, } from "./frameworks/webdriverio.js";
+import { JasmineAdapter } from "./frameworks/jasmine.js";
 import { parseFile } from "./parse.js";
 import { buildRecords, fileRecord } from "./records.js";
 import { snippet } from "./source.js";
@@ -15,14 +21,22 @@ const TYPE_TEST = /\.(test|spec)-d\.[cm]?[jt]sx?$/;
 const BENCHMARK = /\.(bench|benchmark)\.[cm]?[jt]sx?$/;
 const ADAPTERS = {
     playwright: (parsed, file, readModule) => new PlaywrightAdapter(parsed.program, file, readModule),
-    vitest: (parsed, file, readModule) => new VitestAdapter(parsed, file, readModule),
+    vitest: (parsed, file, readModule, settings) => new VitestAdapter(parsed, file, readModule, settings.titleTruncate),
     jest: (parsed, file, readModule) => new JestAdapter(parsed, file, readModule),
+    mocha: (parsed, file, readModule, settings) => new MochaAdapter(parsed, file, readModule, settings.mochaInterface),
+    jasmine: (parsed, file, readModule) => new JasmineAdapter(parsed, file, readModule),
+    cypress: (parsed, file, readModule) => new CypressAdapter(parsed, file, readModule),
+    webdriverio: (parsed, file, readModule, settings) => settings.webdriverioFramework === 'jasmine'
+        ? new WebdriverIOJasmineAdapter(parsed, file, readModule)
+        : new WebdriverIOMochaAdapter(parsed, file, readModule, settings.mochaInterface),
+    node: (parsed, file, readModule) => new NodeAdapter(parsed, file, readModule),
+    bun: (parsed, file, readModule) => new BunAdapter(parsed, file, readModule),
 };
 /** A file read for the scan: the scanned file, or a module a helper function is imported from. */
 function frame(parsed, relativeFilePath, settings, readModule, exports) {
     const values = new Values(exports.reader(readModule));
     const file = { source: parsed.source, values, version: settings.version };
-    const adapter = ADAPTERS[settings.framework](parsed, file, readModule);
+    const adapter = ADAPTERS[settings.framework](parsed, file, readModule, settings);
     return { parsed, adapter, values: file.values, readModule, relativeFilePath };
 }
 /** The records of a file the scan read no tests from. */

package/dist/scan.js

@@ -3,15 +3,16 @@ import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { glob } from 'tinyglobby';
 import { ConfigDependencies } from "./config-dependencies.js";
-import { ConfigRuns, fileConfig } from "./config-runs.js";
+import { ConfigRuns, fileConfig, importMap, mochaInterface, webdriverioFramework, webdriverioInterface, } from "./config-runs.js";
 import { Configs, settingAt } from "./config.js";
+import { atLeast } from "./frameworks/common.js";
 import { DependencyGraph } from "./dependency-hash.js";
 import { ExportedValues } from "./imported-values.js";
 import { fileDiagnostic } from "./diagnostics.js";
 import { findFiles, normalizePattern, readFailure } from "./files.js";
 import { detectFramework, detectFrameworkVersion, FRAMEWORK_NAMES, OLDEST } from "./framework-version.js";
 import { createInventory } from "./inventory.js";
-import { checkComments, checkFlag, checkFramework, checkObject, checkStrings, checkVersion, invalid, majorMinor, toPosixPath, } from "./options.js";
+import { checkComments, checkFlag, checkFramework, checkObject, checkSignal, checkStrings, checkVersion, invalid, majorMinor, toPosixPath, } from "./options.js";
 import { moduleResolver } from "./resolve.js";
 import { noRecords, scanFile } from "./scan-file.js";
 import { globalsCheck } from "./vitest-config.js";
@@ -23,12 +24,17 @@ function versionDiagnostics(framework, version, source, range) {
         ];
     }
     const [major, minor] = majorMinor(version);
-    const [oldestMajor, oldestMinor] = OLDEST[framework];
+    const patch = Number(/^v?\d+\.\d+\.(\d+)/.exec(version)?.[1] ?? 0);
+    const [oldestMajor, oldestMinor, oldestPatch = 0] = OLDEST[framework];
+    const oldest = OLDEST[framework].join('.');
     // A range gets the newest rules of its major, so only its major has to be supported.
-    const tooOld = major < oldestMajor || (major === oldestMajor && minor < oldestMinor && range === null);
+    const tooOld = major < oldestMajor ||
+        (major === oldestMajor &&
+            range === null &&
+            (minor < oldestMinor || (minor === oldestMinor && patch < oldestPatch)));
     if (tooOld) {
         return [
-            fileDiagnostic('unsupported-framework-version', source, `${name} ${version} is older than ${oldestMajor}.${oldestMinor}, the oldest supported version; the results follow ${oldestMajor}.${oldestMinor}.`),
+            fileDiagnostic('unsupported-framework-version', source, `${name} ${version} is older than ${oldest}, the oldest supported version; the results follow ${oldest}.`),
         ];
     }
     if (range === null)
@@ -37,6 +43,18 @@ function versionDiagnostics(framework, version, source, range) {
         fileDiagnostic('approximate-framework-version', source, `Only the range "${range}" was found for ${name}, so the rules of the newest ${major}.x release apply.`),
     ];
 }
+/**
+ * The length Vitest shortens a value in a case title to: `test.taskTitleValueFormatTruncate` from Vitest 5,
+ * `test.chaiConfig.truncateThreshold` before, from the project that runs the file; 40, Vitest's default, when it sets
+ * none or the scan can't read it.
+ */
+function titleTruncate(placement, version) {
+    const key = atLeast(version, 5, 0)
+        ? ['test', 'taskTitleValueFormatTruncate']
+        : ['test', 'chaiConfig', 'truncateThreshold'];
+    const setting = placement.settings && settingAt(placement.settings, key);
+    return setting?.kind === 'value' && typeof setting.value === 'number' ? setting.value : 40;
+}
 /** Why Jest gives a file that uses its globals none: a project that runs it sets `injectGlobals` to false. */
 function jestGlobals(placement) {
     const off = placement.projects?.find(({ settings }) => {
@@ -111,6 +129,9 @@ function noFiles(root, patterns, framework, placements) {
     if ([...placements.values()].some((placement) => placement.config)) {
         return 'No test files were found from the configs in the root.';
     }
+    if (framework === 'node') {
+        return "No patterns were given, and no file in the root matches what node --test runs: Node.js's default patterns, or the files a package.json script gives it.";
+    }
     const name = FRAMEWORK_NAMES[framework];
     return `No patterns were given, and no ${name} config is in the root or a folder below it, so there are no test files to find.`;
 }
@@ -127,6 +148,8 @@ export async function scan(options) {
     const comments = checkComments(checked.comments, 'options.comments');
     const expandCases = checkFlag(checked.expandCases, 'options.expandCases');
     const override = checkVersion(checked.frameworkVersion, 'options.frameworkVersion');
+    const signal = checkSignal(checked.signal, 'options.signal');
+    signal?.throwIfAborted();
     if (checked.root !== undefined && (typeof checked.root !== 'string' || checked.root === '')) {
         throw invalid('options.root', 'a non-empty string');
     }
@@ -138,6 +161,7 @@ export async function scan(options) {
         : checkFramework(checked.framework, 'options.framework');
     // Without patterns, the configs choose among all JavaScript and TypeScript files.
     const found = await findFiles(root, patterns ?? [SCRIPT_FILES], ignore, framework);
+    signal?.throwIfAborted();
     const scanned = found.files.map((file) => file.relativeFilePath);
     const detected = override === null ? detectFrameworkVersion(root, framework, scanned) : null;
     const frameworkVersion = override ?? detected?.version ?? null;
@@ -186,6 +210,7 @@ export async function scan(options) {
     const results = [];
     const globalsFiles = [];
     for (const { absolutePath, relativeFilePath } of files) {
+        signal?.throwIfAborted();
         const placement = placements.get(absolutePath);
         if (placement.config)
             configs.use(placement.config);
@@ -211,10 +236,17 @@ export async function scan(options) {
             version: rules,
             comments,
             expandCases,
-            readModule: readerFor(absolutePath),
+            readModule: readerFor(absolutePath, importMap(placement, framework)),
             root,
             isBenchmarkFile: placement.runs === null ? null : placement.runs === 'benchmark',
             config: fileConfig(placement, framework, rules, absolutePath),
+            mochaInterface: framework === 'mocha'
+                ? mochaInterface(placement, configs)
+                : framework === 'webdriverio'
+                    ? webdriverioInterface(placement, configs)
+                    : undefined,
+            webdriverioFramework: framework === 'webdriverio' ? webdriverioFramework(placement, configs) : undefined,
+            titleTruncate: framework === 'vitest' ? titleTruncate(placement, rules) : undefined,
             graph,
             exports,
             runsWith,
@@ -229,9 +261,12 @@ export async function scan(options) {
         }
         results.push({ ...result, file: { ...result.file, config } });
     }
+    // Mocha, Jasmine, Cypress, WebdriverIO and Bun always set their globals, and Playwright and node:test have none.
     const missingGlobals = framework === 'jest'
         ? (file) => jestGlobals(placements.get(file))
-        : globalsCheck(root, configs, (file) => placements.get(file));
+        : ['mocha', 'jasmine', 'cypress', 'webdriverio', 'node', 'bun'].includes(framework)
+            ? () => null
+            : globalsCheck(root, configs, (file) => placements.get(file));
     let globals = null;
     for (const { absolutePath, relativeFilePath } of globalsFiles) {
         const message = missingGlobals(absolutePath);

package/dist/toml.d.ts

@@ -0,0 +1,13 @@
+import type { Value } from './values.ts';
+/** A line of TOML the reader doesn't take, with its line number. */
+export declare class TomlError extends Error {
+    readonly line: number;
+    constructor(message: string, line: number);
+}
+type Table = Record<string, Value>;
+/**
+ * The part of TOML a `bunfig.toml` uses: tables and dotted keys, strings, numbers, booleans, arrays over several lines,
+ * inline tables and comments. Dates and arrays of tables are refused with a `TomlError`.
+ */
+export declare function readToml(text: string): Table;
+export {};