test-inventory 0.8.0 → 0.9.0

package/dist/frameworks/playwright.js

@@ -209,6 +209,7 @@ export class PlaywrightAdapter {
     imports;
     followed = new Map();
     reported = new Set();
+    refusedRests = new Set();
     /** Variables and names of functions read as test objects on trust, each reported once. */
     assumed = new Set();
     aliases = new Map();
@@ -259,6 +260,7 @@ export class PlaywrightAdapter {
             return this.configure(call, context);
         if (HOOKS.has(key)) {
             const fn = hookFunction(this.file, context.scopes, call.arguments);
+            this.checkFixtureArguments(fn);
             return {
                 kind: 'hook',
                 name: key,
@@ -270,6 +272,8 @@ export class PlaywrightAdapter {
         }
         if (RUN_MEMBERS.has(key))
             return this.runSetting(call, key, context);
+        if (key === 'extend')
+            this.checkExtendFixtures(call, context);
         if (OTHER_MEMBERS.has(key))
             return { kind: 'other' };
         return this.invalid(call, names, "is not part of Playwright's API", context);
@@ -476,6 +480,7 @@ export class PlaywrightAdapter {
         const line = this.file.source.line(call.start);
         const fn = isFunctionNode(last) ? last : null;
         const hashed = fn ?? namedFunction(this.file, context.scopes, last);
+        this.checkFixtureArguments(hashed);
         return {
             kind: 'test',
             title,
@@ -495,6 +500,56 @@ export class PlaywrightAdapter {
             problems,
         };
     }
+    /**
+     * Playwright reads which fixtures a function takes from its source, and refuses a rest property among them, as
+     * `({ page, ...fixtures })`, failing the whole run. A nested one, as `({ page: { mouse, ...rest } })`, is allowed.
+     */
+    checkFixtureArguments(fn) {
+        const parameter = fn?.params[0];
+        const rest = parameter?.type === 'ObjectPattern' ? parameter.properties.find((item) => item.type === 'RestElement') : null;
+        if (!rest || this.refusedRests.has(rest))
+            return;
+        this.refusedRests.add(rest);
+        const source = snippet(text(this.file, rest));
+        const message = `Playwright refuses the rest property ${source} in fixture arguments, so it fails to load the file and runs no tests at all.`;
+        this.problems.push(problem('invalid-fixture-argument', rest, message, source));
+    }
+    /** The fixture functions of `test.extend({ ... })`, each given as a function or as `[function, options]`. */
+    checkExtendFixtures(call, context) {
+        const argument = call.arguments.at(0);
+        if (argument && argument.type !== 'SpreadElement')
+            this.checkFixtureObject(argument, context.scopes, new Set());
+    }
+    /**
+     * An object of fixtures, written in place or held in a constant, with the objects it spreads; `seen` ends a constant
+     * that spreads itself, which throws at run time.
+     */
+    checkFixtureObject(expression, scopes, seen) {
+        const node = unwrap(expression);
+        if (seen.has(node))
+            return;
+        seen.add(node);
+        if (node.type === 'Identifier') {
+            const constant = this.file.values.constantOf(node.name, scopes);
+            if (constant)
+                this.checkFixtureObject(constant.init, constant.scopes, seen);
+            return;
+        }
+        if (node.type !== 'ObjectExpression')
+            return;
+        for (const property of node.properties) {
+            if (property.type === 'SpreadElement') {
+                this.checkFixtureObject(property.argument, scopes, seen);
+                continue;
+            }
+            const value = unwrap(property.value);
+            const fn = value.type === 'ArrayExpression' ? value.elements[0] : value;
+            if (isFunctionNode(fn))
+                this.checkFixtureArguments(fn);
+            else if (fn?.type === 'Identifier')
+                this.checkFixtureArguments(this.file.values.functionOf(fn.name, scopes));
+        }
+    }
     /** `test.step(title, body)` in a test body; a title that can't be worked out is kept as source text. */
     step(call, isSkipped, context) {
         const { title } = readTitle(this.file, context.scopes, call.arguments[0], {
@@ -505,6 +560,8 @@ export class PlaywrightAdapter {
     }
     modifier(call, state, context) {
         const [condition, description] = [call.arguments.at(0), call.arguments.at(1)];
+        if (isFunctionNode(condition))
+            this.checkFixtureArguments(condition);
         const problems = [];
         if (isTitleLiteral(condition)) {
             const callee = snippet(text(this.file, call.callee));

package/dist/frameworks/test-functions.d.ts

@@ -27,7 +27,8 @@ export interface Dialect {
     mismatched: ReadonlySet<string>;
     /** The names that start a chain, as exported and as globals; a map, so `constructor` matches nothing inherited. */
     starts: ReadonlyMap<string, Start>;
-    hooks: ReadonlySet<string>;
+    /** Each hook's name in code, and the name it is counted under, as Mocha's `before` is counted as `beforeAll`. */
+    hooks: ReadonlyMap<string, keyof HookCounts>;
     /** Members that build a test object from another, such as Vitest's `extend`. */
     derivations: ReadonlySet<string>;
     /** Members that give a test function a mode, as `skip` and `only` do, which a variable can hold it with. */
@@ -40,6 +41,14 @@ export interface Dialect {
     defaultImport: string | null;
     /** Why `require()` of the module fails; null when the module can be required. */
     required: string | null;
+    /** Other modules the runner reads as its own, as Bun rewrites `@jest/globals` and `vitest` to `bun:test`. */
+    aliases?: ReadonlySet<string>;
+    /** What the module is when called, as `node:test`'s default export and `require()` are its `test`. */
+    callable?: Start;
+    /** The module's other members, which a chain on the callable module may start with and is then no test. */
+    others?: ReadonlySet<string>;
+    /** Whether the functions must be imported, as the runner sets no globals; `starts` are then exports only. */
+    importOnly?: boolean;
 }
 /** What a test function chosen at run time, as in `isCI ? it.skip : it`, is either way: only the links both have. */
 export declare function shared(a: TestFunction | null, b: TestFunction | null): TestFunction | null;
@@ -83,6 +92,8 @@ export declare class SuiteBindings implements TestObjects {
      * its module, as the walk reads globals and chains itself; in a followed module, also globals and chains.
      */
     private boundStart;
+    /** A name the module is bound to: its namespace, and its `test` too when the module can be called. */
+    private bindModule;
     exportedStart(name: string): Start | null;
     private holdsTestObject;
     reexports(source: string, imported: string, exported: Exported): boolean;
@@ -130,6 +141,20 @@ export declare abstract class SuiteAdapter implements Adapter {
      */
     protected resolve(chain: Chain, args: readonly Argument[], lookup: Lookup): TestFunction | null;
     private start;
+    /**
+     * What a chain on the framework's module starts with: the member it names, or for a module that can be called, as
+     * `node:test`'s, the module itself, as in `test.skip(...)`.
+     */
+    private member;
+    /**
+     * The member a name is destructured from a test or describe function as, with that function's kind and the
+     * expression it is taken from: `each`, `test` and `test` in `const { each } = test`; null for any other name.
+     */
+    protected destructuredMember(name: string, lookup: Lookup): {
+        kind: Kind;
+        member: string;
+        from: Expression;
+    } | null;
     /**
      * The function and modifiers a variable holds, as in `const skipOnCi = test.skipIf(isCI)`, with the member `name`
      * takes when it is destructured, as in `const { beforeEach } = test`. The members Vitest reads through `this`, such as

package/dist/frameworks/test-functions.js

@@ -43,7 +43,7 @@ export class SuiteBindings {
         this.program = program;
         this.isFollowed = isFollowed;
         this.declared = topLevelNames(program);
-        this.imported = moduleImports(program, (source) => source === dialect.source || dialect.mismatched.has(source));
+        this.imported = moduleImports(program, (source) => isOwnModule(dialect, source) || dialect.mismatched.has(source));
         this.follow = follow;
         this.functions = new ModuleFunctions(program, this.imported, follow);
         for (const statement of program.body) {
@@ -53,7 +53,7 @@ export class SuiteBindings {
             if (dialect.mismatched.has(source)) {
                 this.problems.push(problem('framework-mismatch', statement, `The file imports '${source}', but the scan is for ${dialect.name}.`));
             }
-            if (source !== dialect.source)
+            if (!isOwnModule(dialect, source))
                 continue;
             for (const specifier of statement.specifiers) {
                 this.declarations.add(specifier);
@@ -62,7 +62,7 @@ export class SuiteBindings {
                 }
                 else if (specifier.type === 'ImportDefaultSpecifier') {
                     if (dialect.defaultImport === null)
-                        this.namespaces.add(specifier.local.name);
+                        this.bindModule(specifier.local.name);
                     else
                         this.problems.push(problem('invalid-import', specifier, dialect.defaultImport));
                 }
@@ -74,7 +74,7 @@ export class SuiteBindings {
         const declarators = allDeclarators(program);
         if (dialect.required !== null) {
             for (const declarator of declarators) {
-                if (declarator.init && requiredModule(declarator.init) === dialect.source) {
+                if (declarator.init && isOwnModule(dialect, requiredModule(declarator.init))) {
                     this.problems.push(problem('invalid-import', declarator, dialect.required));
                 }
             }
@@ -129,7 +129,7 @@ export class SuiteBindings {
     startOf(expression) {
         const node = unwrap(expression);
         if (node.type === 'Identifier') {
-            const global = this.declared.has(node.name) ? undefined : this.dialect.starts.get(node.name);
+            const global = this.declared.has(node.name) || this.dialect.importOnly ? undefined : this.dialect.starts.get(node.name);
             return this.starts.get(node.name) ?? global ?? null;
         }
         if (node.type !== 'MemberExpression')
@@ -154,7 +154,14 @@ export class SuiteBindings {
             return this.starts.get(node.name) ?? null;
         if (node.type !== 'MemberExpression' || !this.isNamespace(node.object))
             return null;
-        return this.dialect.starts.get(propertyName(node) ?? '') ?? null;
+        const name = propertyName(node) ?? '';
+        return this.dialect.starts.get(name) ?? null;
+    }
+    /** A name the module is bound to: its namespace, and its `test` too when the module can be called. */
+    bindModule(name) {
+        this.namespaces.add(name);
+        if (this.dialect.callable)
+            this.starts.set(name, this.dialect.callable);
     }
     exportedStart(name) {
         const own = ownExport(this.program, name);
@@ -167,7 +174,7 @@ export class SuiteBindings {
         return this.functions.holdsTestObject(name, (expression) => this.isTestObject(expression));
     }
     reexports(source, imported, exported) {
-        if (source !== this.dialect.source)
+        if (!isOwnModule(this.dialect, source))
             return this.follow(source, imported, exported);
         return exported === 'test object' && this.dialect.starts.has(imported);
     }
@@ -183,10 +190,11 @@ export class SuiteBindings {
     }
     bindMember(imported, local) {
         const start = this.dialect.starts.get(imported);
+        const hook = this.dialect.hooks.get(imported);
         if (start)
             this.starts.set(local, start);
-        else if (this.dialect.hooks.has(imported))
-            this.hooks.set(local, imported);
+        else if (hook)
+            this.hooks.set(local, hook);
         else
             this.members.set(local, imported);
     }
@@ -202,7 +210,7 @@ export class SuiteBindings {
         if (!this.dialect.isModule(init))
             return false;
         if (id.type === 'Identifier') {
-            this.namespaces.add(id.name);
+            this.bindModule(id.name);
             return true;
         }
         if (id.type !== 'ObjectPattern')
@@ -218,6 +226,10 @@ export class SuiteBindings {
         return true;
     }
 }
+/** Whether a module is the framework's own, or one it reads as its own. */
+function isOwnModule(dialect, source) {
+    return source !== null && (source === dialect.source || (dialect.aliases?.has(source) ?? false));
+}
 /**
  * What Vitest's and Jest's adapters share: how a call's chain is followed to the test or describe function it starts
  * from, through imports, variables, helper functions and globals.
@@ -257,7 +269,7 @@ export class SuiteAdapter {
             return followed.get(key) === true;
         });
         this.problems = [...this.bindings.problems];
-        this.imports = moduleImports(parsed.program, (source) => source === dialect.source || dialect.mismatched.has(source));
+        this.imports = moduleImports(parsed.program, (source) => isOwnModule(dialect, source) || dialect.mismatched.has(source));
     }
     testFunction(expression, scopes, returnsOf) {
         return this.aliasOf(expression, { scopes, inBody: false, returnsOf });
@@ -288,10 +300,8 @@ export class SuiteAdapter {
         const { base, links: chainLinks } = chain;
         const { scopes, inBody } = lookup;
         // `require('@jest/globals').test(...)`: the module itself, called in place.
-        if (base.type === 'CallExpression' && this.dialect.isModule(base)) {
-            const start = this.dialect.starts.get(chainLinks.at(0)?.name ?? '');
-            return start ? { kind: start.kind, index: 1, modifiers: links(start.links) } : null;
-        }
+        if (base.type === 'CallExpression' && this.dialect.isModule(base))
+            return this.member(chainLinks);
         if (base.type === 'CallExpression') {
             const returned = this.returned(base, chainLinks, args, lookup);
             return returned && { kind: returned.kind, index: 0, modifiers: returned.links };
@@ -302,7 +312,7 @@ export class SuiteAdapter {
         // name, such as `(test) => test.result()`, is not the framework's.
         const declaration = this.file.values.declarationOf(base.name, scopes);
         if (declaration === null) {
-            const global = this.dialect.starts.get(base.name);
+            const global = this.dialect.importOnly ? undefined : this.dialect.starts.get(base.name);
             if (!global)
                 return null;
             this.usesGlobals = true;
@@ -322,13 +332,40 @@ export class SuiteAdapter {
                 ? { kind: this.dialect.starts.get(base.name)?.kind ?? 'test', index: 0 }
                 : null;
         }
-        if (this.bindings.namespaces.has(base.name)) {
-            const start = this.dialect.starts.get(chainLinks.at(0)?.name ?? '');
-            return start ? { kind: start.kind, index: 1, modifiers: links(start.links) } : null;
-        }
+        if (this.bindings.namespaces.has(base.name))
+            return this.member(chainLinks);
         const start = this.bindings.starts.get(base.name);
         return start ? { kind: start.kind, index: 0, modifiers: links(start.links) } : null;
     }
+    /**
+     * What a chain on the framework's module starts with: the member it names, or for a module that can be called, as
+     * `node:test`'s, the module itself, as in `test.skip(...)`.
+     */
+    member(chainLinks) {
+        const start = this.dialect.starts.get(chainLinks.at(0)?.name ?? '');
+        if (start)
+            return { kind: start.kind, index: 1, modifiers: links(start.links) };
+        const { callable } = this.dialect;
+        // The module's other members, as `test.mock.fn()`, are not tests; one it doesn't have is refused as a chain.
+        if (!callable || this.dialect.others?.has(chainLinks.at(0)?.name ?? ''))
+            return null;
+        return { kind: callable.kind, index: 0, modifiers: links(callable.links) };
+    }
+    /**
+     * The member a name is destructured from a test or describe function as, with that function's kind and the
+     * expression it is taken from: `each`, `test` and `test` in `const { each } = test`; null for any other name.
+     */
+    destructuredMember(name, lookup) {
+        const declaration = this.file.values.declarationOf(name, lookup.scopes);
+        if (declaration?.type !== 'VariableDeclarator')
+            return null;
+        const member = boundMembers(declaration.id, name)?.at(-1);
+        if (member === undefined)
+            return null;
+        const alias = this.alias(declaration, name, lookup);
+        // A variable holds a test function only through its value, so there is one.
+        return alias && { kind: alias.kind, member, from: declaration.init };
+    }
     /**
      * The function and modifiers a variable holds, as in `const skipOnCi = test.skipIf(isCI)`, with the member `name`
      * takes when it is destructured, as in `const { beforeEach } = test`. The members Vitest reads through `this`, such as
@@ -432,7 +469,7 @@ export class SuiteAdapter {
         const { dialect } = this;
         return {
             name: dialect.name,
-            isSource: (source) => source === dialect.source,
+            isSource: (source) => isOwnModule(dialect, source),
             testObjects: (program, follow) => new SuiteBindings(program, dialect, follow, true),
         };
     }
@@ -458,11 +495,16 @@ export class SuiteAdapter {
     /** Hooks called directly, such as `beforeEach(...)` imported from the framework or used as a global. */
     hookCall(call, context) {
         const callee = unwrap(call.callee);
+        // A hook on the module, as `test.beforeEach()` on `node:test`'s default export.
+        if (callee.type === 'MemberExpression' && this.bindings.isNamespace(callee.object)) {
+            const hook = this.dialect.hooks.get(propertyName(callee) ?? '');
+            return hook ? this.hook(call, hook, context) : null;
+        }
         if (callee.type !== 'Identifier')
             return null;
         const declaration = this.file.values.declarationOf(callee.name, context.scopes);
         const hook = declaration === null
-            ? this.dialect.hooks.has(callee.name) && callee.name
+            ? this.dialect.hooks.get(callee.name)
             : this.bindings.declarations.has(declaration) && this.bindings.hooks.get(callee.name);
         return hook ? this.hook(call, hook, context) : null;
     }

package/dist/frameworks/vitest.d.ts

@@ -6,11 +6,19 @@ import { type FileContext, type Link } from './common.ts';
 import { SuiteAdapter, type Kind } from './test-functions.ts';
 export declare class VitestAdapter extends SuiteAdapter {
     private warnedAboutTags;
-    constructor(parsed: ParsedFile, file: FileContext, readModule: ModuleReader | null);
+    /** The length a value in a case title is shortened to, as the config sets it. */
+    private readonly titleTruncate;
+    constructor(parsed: ParsedFile, file: FileContext, readModule: ModuleReader | null, titleTruncate?: number);
     protected isAliasLink(kind: Kind, link: Link): boolean;
     classify(call: CallExpression, context: CallContext): ApiCall | null;
     /** A call to `bench` imported from Vitest 5, which is undefined there, so the call throws. */
     private benchCall;
+    /**
+     * A call of a member Vitest calls on its test or describe function, destructured from it, as `each` in
+     * `const { each } = test`: the member reads the function it is called on, which a plain call doesn't give it, so the
+     * call throws while the file loads. Which members do that depends on the version.
+     */
+    private unboundCall;
     private chainCall;
     protected hook(call: CallExpression, name: keyof HookCounts, context: CallContext): ApiCall;
     private contextSkip;

package/dist/frameworks/vitest.js

@@ -37,7 +37,7 @@ const VITEST = {
         ['describe', { kind: 'describe', links: [] }],
         ['suite', { kind: 'describe', links: [] }],
     ]),
-    hooks: new Set(HOOKS.keys()),
+    hooks: new Map([...HOOKS.keys()].map((name) => [name, name])),
     derivations: DERIVATIONS,
     modifiers: new Set([...MODIFIERS.test, ...MODIFIERS.describe]),
     carriesKinds: true,
@@ -112,10 +112,24 @@ function fixturesOf(fn, index, version) {
         return !since || !atLeast(version, ...since);
     });
 }
+/**
+ * Whether a member of `test` or `describe` reads the function it is called on through `this`, so that it throws when
+ * destructured, as each version of Vitest runs it (checked with 3.2.4, 4.0.18, 4.1.12, 5.0.0 and 5.1.0).
+ */
+function readsItsFunction(kind, member, version) {
+    if (kind === 'describe')
+        return member === 'each' || (member === 'for' && atLeast(version, 5, 0));
+    if (['each', 'for', 'skipIf', 'runIf'].includes(member))
+        return true;
+    return ['extend', 'scoped', 'override'].includes(member) && atLeast(version, 4, 1);
+}
 export class VitestAdapter extends SuiteAdapter {
     warnedAboutTags = false;
-    constructor(parsed, file, readModule) {
+    /** The length a value in a case title is shortened to, as the config sets it. */
+    titleTruncate;
+    constructor(parsed, file, readModule, titleTruncate = 40) {
         super(parsed, file, readModule, VITEST, TEST_MEMBERS);
+        this.titleTruncate = titleTruncate;
         if (atLeast(file.version, 5, 0)) {
             for (const call of nestedHoistedCalls(parsed.program)) {
                 const callee = snippet(text(this.file, call.callee));
@@ -139,6 +153,7 @@ export class VitestAdapter extends SuiteAdapter {
         return (this.benchCall(call, context) ??
             this.hookCall(call, context) ??
             this.contextSkip(call, context) ??
+            this.unboundCall(call, context) ??
             this.chainCall(call, context));
     }
     /** A call to `bench` imported from Vitest 5, which is undefined there, so the call throws. */
@@ -157,6 +172,22 @@ export class VitestAdapter extends SuiteAdapter {
             problem: problem('removed-api', call, `Vitest 5 no longer exports bench from 'vitest'; ${callee}(...) fails. Benchmarks are not tests.`, callee),
         };
     }
+    /**
+     * A call of a member Vitest calls on its test or describe function, destructured from it, as `each` in
+     * `const { each } = test`: the member reads the function it is called on, which a plain call doesn't give it, so the
+     * call throws while the file loads. Which members do that depends on the version.
+     */
+    unboundCall(call, context) {
+        const callee = unwrap(call.callee);
+        if (callee.type !== 'Identifier')
+            return null;
+        const found = this.destructuredMember(callee.name, context);
+        if (!found || !readsItsFunction(found.kind, found.member, this.file.version))
+            return null;
+        const from = snippet(text(this.file, found.from));
+        const message = `${callee.name} is destructured from ${from}, so it loses the test object it reads, and Vitest fails the file.`;
+        return { kind: 'invalid', problem: problem('invalid-chain', call, message, callee.name) };
+    }
     chainCall(call, context) {
         const chain = readChain(call.callee);
         const resolved = chain ? this.resolve(chain, call.arguments, context) : null;
@@ -489,12 +520,12 @@ export class VitestAdapter extends SuiteAdapter {
         if (meta)
             details.meta = this.meta(meta, context, problems);
         for (const key of ['timeout', 'repeats']) {
-            const option = options.values.get(key);
+            const option = given(key);
             const value = option ? readCount(this.file, key, option, problems) : null;
             if (value !== null)
                 details.run[key] = value;
         }
-        const retry = options.values.get('retry');
+        const retry = given('retry');
         if (retry)
             this.retry(retry, details, context, problems);
         return result;
@@ -583,7 +614,7 @@ export class VitestAdapter extends SuiteAdapter {
                 return null;
             cases = resolved.value;
         }
-        const caseTitle = (items, index) => title.isDynamic ? null : vitestCaseTitle(title.text, items, index, this.file.version);
+        const caseTitle = (items, index) => title.isDynamic ? null : vitestCaseTitle(title.text, items, index, this.file.version, this.titleTruncate);
         if (table.name === 'for') {
             return cases.map((item, index) => ({
                 title: caseTitle(item === null || item === undefined ? [] : Array.isArray(item) ? item : [item], index),

package/dist/frameworks/webdriverio.d.ts

@@ -0,0 +1,27 @@
+import type { CallExpression } from 'oxc-parser';
+import type { ApiCall, CallContext, ModuleReader } from '../model.ts';
+import type { ParsedFile } from '../parse.ts';
+import type { FileContext } from './common.ts';
+import { JasmineAdapter } from './jasmine.ts';
+import { MochaAdapter, type MochaInterface } from './mocha.ts';
+/** The framework a WebdriverIO config runs its specs with; Cucumber's are `.feature` files, which the scan doesn't read. */
+export type WebdriverIOFramework = 'mocha' | 'jasmine';
+/**
+ * WebdriverIO on Mocha: Mocha's calls, where a number after a test's function is a retry count. WebdriverIO catches
+ * a call Mocha refuses while it loads the file, runs the tests declared before it, and then fails the file.
+ */
+export declare class WebdriverIOMochaAdapter extends MochaAdapter {
+    protected readonly trailingRetries = true;
+    protected readonly refusedEffect = "WebdriverIO runs only the tests declared above it in the file, and none of the spec files after it in its worker";
+    constructor(parsed: ParsedFile, file: FileContext, readModule: ModuleReader | null, ui?: MochaInterface);
+    classify(call: CallExpression, context: CallContext): ApiCall | null;
+}
+/**
+ * WebdriverIO on Jasmine: Jasmine's calls, where a second number after a spec's function, after the timeout, is a
+ * retry count. A call Jasmine refuses at the top level of a file fails the whole worker that runs it.
+ */
+export declare class WebdriverIOJasmineAdapter extends JasmineAdapter {
+    protected readonly trailingRetries = true;
+    protected readonly refusedEffect = "WebdriverIO fails the worker that runs the spec file, which runs none of its specs, nor those of the files grouped with it";
+    constructor(parsed: ParsedFile, file: FileContext, readModule: ModuleReader | null);
+}

package/dist/frameworks/webdriverio.js

@@ -0,0 +1,37 @@
+import { JasmineAdapter } from "./jasmine.js";
+import { MochaAdapter } from "./mocha.js";
+/**
+ * The file as the framework WebdriverIO runs it with sees it: the version is that of the Mocha or Jasmine its adapter
+ * depends on, Mocha 12 and Jasmine 6 from WebdriverIO 10, Mocha 10.8 and Jasmine 5 before.
+ */
+function bundled(file, from10, before) {
+    if (file.version === null)
+        return file;
+    return { ...file, version: file.version[0] >= 10 ? from10 : before };
+}
+/**
+ * WebdriverIO on Mocha: Mocha's calls, where a number after a test's function is a retry count. WebdriverIO catches
+ * a call Mocha refuses while it loads the file, runs the tests declared before it, and then fails the file.
+ */
+export class WebdriverIOMochaAdapter extends MochaAdapter {
+    trailingRetries = true;
+    refusedEffect = 'WebdriverIO runs only the tests declared above it in the file, and none of the spec files after it in its worker';
+    constructor(parsed, file, readModule, ui = 'bdd') {
+        super(parsed, bundled(file, [12, 0], [10, 8]), readModule, ui);
+    }
+    classify(call, context) {
+        const found = super.classify(call, context);
+        return found?.kind === 'invalid' ? { ...found, problem: { ...found.problem, keepsEarlierTests: true } } : found;
+    }
+}
+/**
+ * WebdriverIO on Jasmine: Jasmine's calls, where a second number after a spec's function, after the timeout, is a
+ * retry count. A call Jasmine refuses at the top level of a file fails the whole worker that runs it.
+ */
+export class WebdriverIOJasmineAdapter extends JasmineAdapter {
+    trailingRetries = true;
+    refusedEffect = 'WebdriverIO fails the worker that runs the spec file, which runs none of its specs, nor those of the files grouped with it';
+    constructor(parsed, file, readModule) {
+        super(parsed, bundled(file, [6, 3], [5, 0]), readModule);
+    }
+}

package/dist/model.d.ts

@@ -37,6 +37,8 @@ export interface Problem {
     level?: DiagnosticLevel;
     /** Raised by code in a test, hook or helper body, which runs after the file is loaded and so can't stop it loading. */
     afterLoad?: boolean;
+    /** The runner still runs the tests the file declared before the call that stops it loading, as WebdriverIO's Mocha. */
+    keepsEarlierTests?: boolean;
 }
 export interface Title {
     text: string;
@@ -222,6 +224,8 @@ export interface Adapter {
     /** Where each of `fileTags` is written. */
     fileTagSpans: Span[];
     usesGlobals: boolean;
+    /** Whether a test declared in a test's body is a subtest the runner runs as the test does, as in `node:test`. */
+    nestsTests?: boolean;
     classify(call: CallExpression, context: CallContext): ApiCall | null;
     /**
      * The test or describe function a value holds, in the adapter's own terms, as `it.skip` in `return it.skip`; null

package/dist/node-scripts.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The `node --test` commands of a package.json script, each as the files and globs it gives; empty for a command
+ * that gives none. A command runs node:test when `--test` comes before any file, as `node build.js --test` passes it on
+ * to the script.
+ */
+export declare function nodeTestCommands(script: string): string[][];

package/dist/node-scripts.js

@@ -0,0 +1,85 @@
+/** Node.js options that take their value as the next argument, so it is not a file to test. */
+const VALUE_OPTIONS = new Set([
+    '--allow-fs-read',
+    '--allow-fs-write',
+    '--conditions',
+    '-C',
+    '--config-file',
+    '--cpu-prof-dir',
+    '--cpu-prof-name',
+    '--diagnostic-dir',
+    '--disable-warning',
+    '--dns-result-order',
+    '--env-file',
+    '--env-file-if-exists',
+    '--experimental-config-file',
+    '--experimental-loader',
+    '--heap-prof-dir',
+    '--heap-prof-name',
+    '--heapsnapshot-signal',
+    '--icu-data-dir',
+    '--import',
+    '--input-type',
+    '--loader',
+    '--localstorage-file',
+    '--max-http-header-size',
+    '--openssl-config',
+    '--redirect-warnings',
+    '--report-dir',
+    '--report-filename',
+    '--require',
+    '-r',
+    '--secure-heap',
+    '--secure-heap-min',
+    '--test-concurrency',
+    '--test-coverage-branches',
+    '--test-coverage-exclude',
+    '--test-coverage-functions',
+    '--test-coverage-include',
+    '--test-coverage-lines',
+    '--test-global-setup',
+    '--test-isolation',
+    '--test-name-pattern',
+    '--test-random-seed',
+    '--test-reporter',
+    '--test-reporter-destination',
+    '--test-rerun-failures',
+    '--test-shard',
+    '--test-skip-pattern',
+    '--test-timeout',
+    '--title',
+    '--unhandled-rejections',
+    '--watch-kill-signal',
+    '--watch-path',
+]);
+/**
+ * The `node --test` commands of a package.json script, each as the files and globs it gives; empty for a command
+ * that gives none. A command runs node:test when `--test` comes before any file, as `node build.js --test` passes it on
+ * to the script.
+ */
+export function nodeTestCommands(script) {
+    const commands = [];
+    for (const command of script.split(/&&|\|\||[;|]/)) {
+        const words = [...command.matchAll(/'([^']*)'|"([^"]*)"|(\S+)/g)].map((match) => match[1] ?? match[2] ?? match[3]);
+        const node = words.findIndex((word) => /(^|[/\\])node(\.exe)?$/.test(word));
+        if (node === -1)
+            continue;
+        let runsTests = false;
+        const files = [];
+        for (let index = node + 1; index < words.length; index++) {
+            const word = words[index];
+            if (word === '--test')
+                runsTests = true;
+            else if (VALUE_OPTIONS.has(word))
+                index++;
+            else if (!word.startsWith('-')) {
+                if (!runsTests)
+                    break;
+                files.push(word);
+            }
+        }
+        if (runsTests)
+            commands.push(files);
+    }
+    return commands;
+}