test-inventory 0.7.0 → 0.9.0

package/dist/frameworks/vitest.js

@@ -1,26 +1,8 @@
 import { childNodes, isFunctionNode, isImportMetaVitest, propertyKey, propertyName, unwrap, } from "../ast.js";
 import { snippet } from "../source.js";
-import { allDeclarators, bindAll, exportName, followImport, followModule, moduleImports, ModuleFunctions, requiredModule, } from "./bindings.js";
-import { atLeast, hookFunction, isTestName, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, origin, problem, readChain, readCondition, returnedFunction, returnedTestObject, boundMembers, destructuredNames, takesWhole, readCount, readOptions, readStrings, isTitleLiteral, readReason, namedFunction, unresolvedOption, unresolvedOptions, readTitle, refused, text, } from "./common.js";
-/** What a test function chosen at run time, as in `isCI ? it.skip : it`, is either way: only the links both have. */
-function shared(a, b) {
-    if (!a || a.kind !== b?.kind)
-        return null;
-    const same = (link, index) => {
-        const other = b.links.at(index);
-        return other?.name === link.name && !link.args && !link.template && !other.args && !other.template;
-    };
-    const differs = a.links.findIndex((link, index) => !same(link, index));
-    return { kind: a.kind, links: differs === -1 ? a.links : a.links.slice(0, differs) };
-}
-// Maps rather than object literals, so names such as `constructor` don't match inherited properties.
-const KINDS = new Map([
-    ['test', 'test'],
-    ['it', 'test'],
-    ['describe', 'describe'],
-    ['suite', 'describe'],
-]);
-const MISMATCHED_SOURCES = new Set(['@playwright/test', 'playwright/test', '@jest/globals']);
+import { vitestCaseTitle } from "../case-titles.js";
+import { atLeast, hookFunction, problem, readChain, readCondition, destructuredNames, takesWhole, readCount, readOptions, readStrings, isTitleLiteral, readReason, namedFunction, origin, unresolvedOption, unresolvedOptions, readTitle, refused, text, } from "./common.js";
+import { SuiteAdapter } from "./test-functions.js";
 const MODIFIERS = {
     test: new Set(['concurrent', 'sequential', 'only', 'skip', 'todo', 'fails']),
     describe: new Set(['concurrent', 'sequential', 'shuffle', 'skip', 'only', 'todo']),
@@ -44,7 +26,25 @@ function isHook(name) {
 /** First members of chains that never declare a test, even when Vitest refuses the rest of the chain. */
 const NOT_DECLARING = new Set([...HOOKS.keys(), ...DERIVATIONS]);
 /** First members that show a name imported from a local file is used as Vitest's `test`. */
-const TEST_MEMBERS = new Set([...MODIFIERS.test, ...MODIFIERS.describe, ...TABLES, ...CONDITIONS, ...KINDS.keys()]);
+const TEST_MEMBERS = [...MODIFIERS.test, ...MODIFIERS.describe, ...TABLES, ...CONDITIONS];
+const VITEST = {
+    name: 'Vitest',
+    source: 'vitest',
+    mismatched: new Set(['@playwright/test', 'playwright/test', '@jest/globals']),
+    starts: new Map([
+        ['test', { kind: 'test', links: [] }],
+        ['it', { kind: 'test', links: [] }],
+        ['describe', { kind: 'describe', links: [] }],
+        ['suite', { kind: 'describe', links: [] }],
+    ]),
+    hooks: new Map([...HOOKS.keys()].map((name) => [name, name])),
+    derivations: DERIVATIONS,
+    modifiers: new Set([...MODIFIERS.test, ...MODIFIERS.describe]),
+    carriesKinds: true,
+    isModule: isImportMetaVitest,
+    defaultImport: "Vitest has no default export; import { test, describe } from 'vitest' instead.",
+    required: 'Vitest cannot be loaded with require(); tests that use it are missing.',
+};
 /** Calls Vitest moves to the top of the file before running it: `vi.mock`, `vi.unmock` and `vi.hoisted`. */
 const HOISTED_OBJECTS = new Set(['vi', 'vitest']);
 const HOISTED_METHODS = new Set(['mock', 'unmock', 'hoisted']);
@@ -112,186 +112,30 @@ function fixturesOf(fn, index, version) {
         return !since || !atLeast(version, ...since);
     });
 }
-/** The names a file binds to Vitest's `test`, `describe`, hooks and namespace. */
-class VitestBindings {
-    kinds = new Map();
-    hooks = new Map();
-    namespaces = new Set();
-    /** Names `bench` is imported as from Vitest 5, which no longer exports it. */
-    benches = new Set();
-    /** The import specifiers and declarators that bind those names, to tell them from local names that shadow them. */
-    declarations = new Set();
-    problems = [];
-    /** Names imported from other modules, which may be test objects there. */
-    imported;
-    follow;
-    /** The module's functions and the variables they may build test objects in; see `ModuleFunctions`. */
-    functions;
-    constructor(program, version, follow) {
-        this.imported = moduleImports(program, (source) => source === 'vitest' || MISMATCHED_SOURCES.has(source));
-        this.follow = follow;
-        this.functions = new ModuleFunctions(program, this.imported, follow);
-        for (const statement of program.body) {
-            if (statement.type !== 'ImportDeclaration' || statement.importKind === 'type')
-                continue;
-            const source = statement.source.value;
-            if (MISMATCHED_SOURCES.has(source)) {
-                this.problems.push(problem('framework-mismatch', statement, `The file imports '${source}', but the scan is for Vitest.`));
-            }
-            if (source !== 'vitest')
-                continue;
-            for (const specifier of statement.specifiers) {
-                this.declarations.add(specifier);
-                if (specifier.type === 'ImportNamespaceSpecifier') {
-                    this.namespaces.add(specifier.local.name);
-                }
-                else if (specifier.type === 'ImportDefaultSpecifier') {
-                    this.problems.push(problem('invalid-import', specifier, "Vitest has no default export; import { test, describe } from 'vitest' instead."));
-                }
-                else {
-                    this.bindImported(exportName(specifier.imported), specifier.local.name, version);
-                }
-            }
-        }
-        const declarators = allDeclarators(program);
-        for (const declarator of declarators) {
-            if (declarator.init && requiredModule(declarator.init) === 'vitest') {
-                this.problems.push(problem('invalid-import', declarator, 'Vitest cannot be loaded with require(); tests that use it are missing.'));
-            }
-        }
-        bindAll(declarators, (declarator) => {
-            const bound = this.bind(declarator);
-            if (bound)
-                this.declarations.add(declarator);
-            return bound;
-        });
-        this.functions.keep(declarators.filter((declarator) => !this.declarations.has(declarator)));
-    }
-    isTestName(name) {
-        return this.kinds.has(name) || this.importsTestObject(name) || this.holdsTestObject(name);
-    }
-    /**
-     * `followsCalls` is cleared where a call is not followed to what it returns: while the names are bound, so that only
-     * a value asked about is followed, as following reads other modules, and in the scanned file, whose calls the walk
-     * follows in their scopes.
-     */
-    isTestObject(expression, followsCalls = true) {
-        const node = unwrap(expression);
-        if (node.type === 'Identifier') {
-            const { name } = node;
-            return (this.kinds.get(name) === 'test' || this.importsTestObject(name) || (followsCalls && this.holdsTestObject(name)));
-        }
-        if (node.type === 'MemberExpression') {
-            return KINDS.get(propertyName(node) ?? '') === 'test' && this.isNamespace(node.object);
-        }
-        // `process.env.CI ? vitestTest : skippedTest` is a test object either way.
-        if (node.type === 'ConditionalExpression') {
-            return this.isTestObject(node.consequent, followsCalls) || this.isTestObject(node.alternate, followsCalls);
-        }
-        if (node.type !== 'CallExpression')
-            return false;
-        const callee = unwrap(node.callee);
-        // `defineBrokerTest()`, a function that returns a test object.
-        if (callee.type === 'Identifier')
-            return followsCalls && this.returnsTestObject(callee.name);
-        return (callee.type === 'MemberExpression' &&
-            DERIVATIONS.has(propertyName(callee) ?? '') &&
-            this.isTestObject(callee.object, followsCalls));
-    }
-    returnsTestObject(name) {
-        return this.functions.returnsTestObject(name, (expression) => this.isTestObject(expression));
-    }
-    holdsTestObject(name) {
-        return this.functions.holdsTestObject(name, (expression) => this.isTestObject(expression));
-    }
-    reexports(source, imported, exported) {
-        if (source !== 'vitest')
-            return this.follow(source, imported, exported);
-        return exported === 'test object' && KINDS.has(imported);
-    }
-    /** Whether a name is imported from another module that exports it as a test object, as `base` from './base'. */
-    importsTestObject(name) {
-        const from = this.imported.get(name);
-        return from !== undefined && this.follow(from.source, from.imported);
-    }
-    isNamespace(expression) {
-        const node = unwrap(expression);
-        return node.type === 'Identifier' && this.namespaces.has(node.name);
-    }
-    bindImported(imported, local, version) {
-        const kind = KINDS.get(imported);
-        if (kind) {
-            this.kinds.set(local, kind);
-        }
-        else if (isHook(imported)) {
-            this.hooks.set(local, imported);
-        }
-        else if (imported === 'bench' && atLeast(version, 5, 0)) {
-            this.benches.add(local);
-        }
-    }
-    bind(declarator) {
-        const { id, init } = declarator;
-        if (!init)
-            return false;
-        if (id.type === 'Identifier' && this.isTestObject(init, false)) {
-            this.kinds.set(id.name, 'test');
-            return true;
-        }
-        if (id.type !== 'ObjectPattern' || !isImportMetaVitest(init))
-            return false;
-        // In-source tests: const { it, describe } = import.meta.vitest
-        for (const property of id.properties) {
-            if (property.type === 'RestElement' || property.value.type !== 'Identifier')
-                continue;
-            const key = propertyKey(property);
-            const kind = KINDS.get(key ?? '');
-            if (kind)
-                this.kinds.set(property.value.name, kind);
-            if (key !== null && isHook(key))
-                this.hooks.set(property.value.name, key);
-        }
+/**
+ * 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 {
-    problems;
-    fileTags = [];
-    fileTagSpans = [];
-    usesGlobals = false;
-    file;
-    readModule;
-    bindings;
-    imports;
-    followed = new Map();
-    reported = new Set();
-    /** Variables and names of functions read as test objects on trust, each reported once. */
-    assumed = new Set();
-    aliases = new Map();
-    /** Describe callbacks and the name of their first parameter, which Vitest calls with its `test`. */
-    suiteParameters = new Map();
+export class VitestAdapter extends SuiteAdapter {
     warnedAboutTags = false;
-    constructor(parsed, file, readModule) {
-        this.file = file;
-        this.readModule = readModule;
-        // A test object the file builds from an imported one, as in `const it = base.extend({...})`, is followed quietly:
-        // a call through the import itself is what reports an import that can't be followed.
-        const followed = new Map();
-        this.bindings = new VitestBindings(parsed.program, file.version, (source, imported, exported = 'test object') => {
-            const key = `${source}\0${exported}\0${imported}`;
-            if (!followed.has(key)) {
-                followed.set(key, followModule(source, imported, readModule, this.framework(), exported).exported);
-            }
-            return followed.get(key) === true;
-        });
-        this.problems = [...this.bindings.problems];
+    /** 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));
                 this.problems.push(problem('removed-api', call, `Vitest 5 fails a file that calls ${callee}(...) anywhere but its top level, because the call is hoisted there.`, callee));
             }
         }
-        this.imports = moduleImports(parsed.program, (source) => source === 'vitest' || MISMATCHED_SOURCES.has(source));
         if (atLeast(file.version, 4, 1)) {
             // Vitest's own pattern, over the whole text as Vitest reads it, so the same tags come out.
             for (const match of parsed.source.text.matchAll(/(\/\/|\*)\s*@module-tag\s+([\w\-/]+)\b/g)) {
@@ -302,19 +146,22 @@ export class VitestAdapter {
             }
         }
     }
+    isAliasLink(kind, link) {
+        return MODIFIERS[kind].has(link.name) || TABLES.has(link.name) || CONDITIONS.has(link.name);
+    }
     classify(call, context) {
         return (this.benchCall(call, context) ??
             this.hookCall(call, context) ??
             this.contextSkip(call, context) ??
+            this.unboundCall(call, context) ??
             this.chainCall(call, context));
     }
-    testFunction(expression, scopes, returnsOf) {
-        return this.aliasOf(expression, { scopes, inBody: false, returnsOf });
-    }
     /** A call to `bench` imported from Vitest 5, which is undefined there, so the call throws. */
     benchCall(call, context) {
         const base = readChain(call.callee)?.base;
-        if (base?.type !== 'Identifier' || !this.bindings.benches.has(base.name))
+        if (base?.type !== 'Identifier' || this.bindings.members.get(base.name) !== 'bench')
+            return null;
+        if (!atLeast(this.file.version, 5, 0))
             return null;
         const declaration = this.file.values.declarationOf(base.name, context.scopes);
         if (declaration === null || !this.bindings.declarations.has(declaration))
@@ -325,6 +172,22 @@ export class VitestAdapter {
             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;
@@ -358,176 +221,6 @@ export class VitestAdapter {
         // Which of its parts the chain means is not known, so it declares a plain test or describe.
         return refused(call, refusal, context, () => this.declaration(call, kind, [], context));
     }
-    /**
-     * The function a chain calls and the links after it, or null when it isn't one of Vitest's. An import that can't be
-     * followed is reported only outside test and hook bodies, where a call can declare tests.
-     */
-    resolve(chain, args, lookup) {
-        const start = this.start(chain, args, lookup);
-        if (!start)
-            return null;
-        let kind = start.kind;
-        let links = [...(start.modifiers ?? []), ...chain.links.slice(start.index)];
-        // A test object derived inline, as in `test.extend({ ... }).skip(...)`.
-        links = links.slice(links.findLastIndex((link) => DERIVATIONS.has(link.name) && link.args !== null) + 1);
-        // Vitest's test object also carries `describe` and `suite`, and they carry `test` and `it`.
-        while (links.length > 0 && KINDS.has(links[0].name) && !links[0].args) {
-            kind = KINDS.get(links[0].name);
-            links = links.slice(1);
-        }
-        return { kind, links };
-    }
-    start(chain, args, lookup) {
-        const { base, links } = chain;
-        const { scopes, inBody } = lookup;
-        if (base.type === 'CallExpression') {
-            const returned = this.returned(base, links, args, lookup);
-            return returned && { kind: returned.kind, index: 0, modifiers: returned.links };
-        }
-        if (base.type !== 'Identifier')
-            return null;
-        // A name the file doesn't declare is one of Vitest's globals; a local variable or parameter with the same name,
-        // such as `(test) => test.result()`, is not Vitest's.
-        const declaration = this.file.values.declarationOf(base.name, scopes);
-        if (declaration === null) {
-            const global = KINDS.get(base.name);
-            if (global)
-                this.usesGlobals = true;
-            return global ? { kind: global, index: 0 } : null;
-        }
-        // A parameter's declaration is its function: `describe('market orders', (test) => { test(...) })`.
-        if (this.suiteParameters.get(declaration) === base.name)
-            return { kind: 'test', index: 0 };
-        const followed = this.imports.get(base.name)?.node === declaration &&
-            this.worthFollowing(base.name, links, args) &&
-            this.follow(base.name, !inBody && mayDeclareTests(base.name, links));
-        if (!followed && !this.bindings.declarations.has(declaration)) {
-            const alias = declaration.type === 'VariableDeclarator' ? this.alias(declaration, base.name, lookup) : null;
-            if (alias)
-                return { kind: alias.kind, index: 0, modifiers: alias.links };
-            return this.assumeLocal(declaration, base.name, links, args)
-                ? { kind: KINDS.get(base.name) ?? 'test', index: 0 }
-                : null;
-        }
-        if (this.bindings.namespaces.has(base.name)) {
-            const kind = KINDS.get(links.at(0)?.name ?? '');
-            return kind ? { kind, index: 1 } : null;
-        }
-        const kind = this.bindings.kinds.get(base.name);
-        return kind ? { kind, index: 0 } : 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
-     * `each` and `skipIf`, return a test function only when called, so their calls are never read through a variable.
-     */
-    alias(declarator, name, lookup) {
-        const destructured = boundMembers(declarator.id, name);
-        if (!destructured)
-            return null;
-        let alias = this.aliases.get(declarator);
-        if (alias === undefined) {
-            // Set first, so a variable defined through itself ends the lookup.
-            this.aliases.set(declarator, null);
-            alias = declarator.init ? this.aliasOf(declarator.init, lookup) : null;
-            this.aliases.set(declarator, alias);
-        }
-        const links = destructured.map((member) => ({ name: member, args: null, template: null }));
-        return alias && { kind: alias.kind, links: [...alias.links, ...links] };
-    }
-    aliasOf(expression, lookup) {
-        const node = unwrap(expression);
-        if (node.type === 'ConditionalExpression') {
-            // `isCI ? describe.concurrent : describe`: only the modifiers both branches have apply.
-            return shared(this.aliasOf(node.consequent, lookup), this.aliasOf(node.alternate, lookup));
-        }
-        const chain = readChain(node);
-        const resolved = chain ? this.resolve(chain, [], lookup) : null;
-        const allowed = (link) => resolved !== null &&
-            (MODIFIERS[resolved.kind].has(link.name) || TABLES.has(link.name) || CONDITIONS.has(link.name));
-        return resolved?.links.every(allowed) ? resolved : null;
-    }
-    /**
-     * The function a call returns, as `conditionalTest({ min: 22 })` returns `it` or `it.skip`: what all the values the
-     * function returns have in common, as for a variable chosen by a condition. When the function can't be found, a call
-     * named like a test object is read as one on trust, with a warning; see `returnedTestObject`.
-     */
-    returned(call, links, args, lookup) {
-        const callee = unwrap(call.callee);
-        if (callee.type !== 'Identifier')
-            return null;
-        const returns = lookup.returnsOf(callee.name, lookup.scopes);
-        if (returns)
-            return returnedFunction(returns, shared);
-        if (!isTestName(callee.name) || !this.looksLikeTest(links, args))
-            return null;
-        if (!this.assumed.has(callee.name)) {
-            this.assumed.add(callee.name);
-            this.problems.push(returnedTestObject(this.file, call));
-        }
-        return { kind: KINDS.get(callee.name) ?? 'test', links: [] };
-    }
-    /** Whether a local variable is read as a test object it could be; see `localTestObject`. */
-    assumeLocal(declaration, name, links, args) {
-        if (declaration.type !== 'VariableDeclarator' || !mayHoldTestObject(declaration) || !isTestName(name))
-            return false;
-        if (!this.looksLikeTest(links, args))
-            return false;
-        if (!this.assumed.has(declaration)) {
-            this.assumed.add(declaration);
-            this.problems.push(localTestObject(this.file, name, declaration));
-        }
-        return true;
-    }
-    looksLikeTest(links, args) {
-        return links.length === 0 ? looksLikeDeclaration(args) : TEST_MEMBERS.has(links[0].name);
-    }
-    /**
-     * Whether a call through an imported name is worth following to the module: shaped like a test, or any call with a
-     * title and a body through a name that reads like a test function, as `it.effect('title', fn)` on a test object that
-     * a package extends.
-     */
-    worthFollowing(name, links, args) {
-        return this.looksLikeTest(links, args) || (isTestName(name) && looksLikeDeclaration(args));
-    }
-    /** Vitest as followed modules are read, with the rules of the scanned version. */
-    framework() {
-        const version = this.file.version;
-        return {
-            name: 'Vitest',
-            isSource: (source) => source === 'vitest',
-            testObjects: (program, follow) => new VitestBindings(program, version, follow),
-        };
-    }
-    /** Follows the import of `name` once, and reports it once when it can't be followed and `report` is set. */
-    follow(name, report) {
-        const imported = this.imports.get(name);
-        let result = this.followed.get(name);
-        if (!result) {
-            result = followImport(name, imported, this.readModule, this.file, this.framework());
-            this.followed.set(name, result);
-            if (result.exported) {
-                this.bindings.kinds.set(name, KINDS.get(imported.imported) ?? 'test');
-                this.bindings.declarations.add(imported.node);
-            }
-        }
-        if (report && result.problem && !this.reported.has(name)) {
-            this.reported.add(name);
-            this.problems.push(result.problem);
-        }
-        return result.exported;
-    }
-    /** Hooks called directly, such as `beforeEach(...)` imported from Vitest or used as a global. */
-    hookCall(call, context) {
-        const callee = unwrap(call.callee);
-        if (callee.type !== 'Identifier')
-            return null;
-        const declaration = this.file.values.declarationOf(callee.name, context.scopes);
-        const hook = declaration === null
-            ? isHook(callee.name) && callee.name
-            : this.bindings.declarations.has(declaration) && this.bindings.hooks.get(callee.name);
-        return hook ? this.hook(call, hook, context) : null;
-    }
     hook(call, name, context) {
         const fn = hookFunction(this.file, context.scopes, call.arguments);
         const index = HOOKS.get(name);
@@ -703,7 +396,7 @@ export class VitestAdapter {
             hashed: fn ?? namedFunction(this.file, context.scopes, body),
             isParameterized: table !== null,
             caseCount: table ? this.caseCount(call, table, context, problems) : null,
-            cases: table ? this.tableCases(table, context) : null,
+            cases: table ? this.tableCases(table, title, context) : null,
             problems,
         };
         let declared;
@@ -827,12 +520,12 @@ export class VitestAdapter {
         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;
@@ -901,7 +594,7 @@ export class VitestAdapter {
      * array into the callback's arguments when every case is one, and `.for` passes each case whole. A tagged template
      * gives one object per row, keyed by the names in its first line.
      */
-    tableCases(table, context) {
+    tableCases(table, title, context) {
         let cases;
         if (table.template) {
             const values = table.template.expressions.map((item) => this.file.values.resolve(item, context.scopes));
@@ -921,32 +614,19 @@ export class VitestAdapter {
                 return null;
             cases = resolved.value;
         }
+        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) => ({
-                items: item === null || item === undefined ? [] : Array.isArray(item) ? item : [item],
+            return cases.map((item, index) => ({
+                title: caseTitle(item === null || item === undefined ? [] : Array.isArray(item) ? item : [item], index),
                 args: [item],
             }));
         }
         const arraysOnly = cases.every((item) => Array.isArray(item));
-        return cases.map((item) => {
+        return cases.map((item, index) => {
             const items = Array.isArray(item) ? item : [item];
-            return { items, args: arraysOnly ? items : [item] };
+            return { title: caseTitle(items, index), args: arraysOnly ? items : [item] };
         });
     }
-    arrayLength(node, context) {
-        if (node === undefined || node.type === 'SpreadElement')
-            return null;
-        const resolved = this.file.values.resolve(node, context.scopes);
-        if (resolved.ok && Array.isArray(resolved.value))
-            return resolved.value.length;
-        const expression = unwrap(node);
-        // The cases may hold values that can't be worked out, such as functions, while the list itself is written out.
-        if (expression.type === 'ArrayExpression' &&
-            expression.elements.every((element) => element?.type !== 'SpreadElement')) {
-            return expression.elements.length;
-        }
-        return null;
-    }
     tagsUsed(node) {
         if (this.warnedAboutTags)
             return;

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/imported-values.js

@@ -1,4 +1,4 @@
-import { ownExport, parseModule, starReexport } from "./frameworks/bindings.js";
+import { commonJsExport, commonJsNames, ownExport, parseModule, starReexport } from "./frameworks/bindings.js";
 import { Values } from "./values.js";
 const UNRESOLVED = { ok: false, importedFrom: null };
 /** How many modules deep a name is followed through re-exports and imports, as for test objects. */
@@ -81,6 +81,20 @@ export class ExportedValues {
         if (own) {
             return opened.values.resolveName(own.kind === 'specifier' ? own.local : name, [program]);
         }
+        const commonJs = commonJsExport(program, name);
+        if (commonJs)
+            return opened.values.resolve(commonJs, [program]);
+        // What `require()` gives for a module that exports its names one by one: an object of them.
+        const names = name === 'default' ? commonJsNames(program) : [];
+        if (names.length > 0) {
+            const entries = names.map((item) => [item, opened.values.resolve(commonJsExport(program, item), [program])]);
+            if (!entries.every(([, value]) => value.ok))
+                return UNRESOLVED;
+            return {
+                ok: true,
+                value: Object.fromEntries(entries.map(([key, value]) => [key, value.value])),
+            };
+        }
         // `export *` passes on every name but the default. When two modules export the name with different values, Node
         // refuses to load the module and Vite's module runner keeps the first, so the value isn't known.
         if (name === 'default')