test-inventory 0.8.0 → 0.9.0

package/dist/framework-version.js

@@ -1,12 +1,54 @@
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
 import { globSync } from 'tinyglobby';
+import { nodeTestCommands } from "./node-scripts.js";
 import { OptionsError } from "./options.js";
-const PACKAGES = { playwright: '@playwright/test', vitest: 'vitest', jest: 'jest' };
+/** The package of each runner; `node:test` ships with Node.js. */
+const PACKAGES = {
+    playwright: '@playwright/test',
+    vitest: 'vitest',
+    jest: 'jest',
+    mocha: 'mocha',
+    // Karma and Angular projects list only jasmine-core, which the jasmine command depends on.
+    jasmine: 'jasmine-core',
+    cypress: 'cypress',
+    webdriverio: '@wdio/cli',
+};
+/** The packages that give a framework's version, the first found. */
+function versionPackages(framework) {
+    return framework === 'jasmine' ? [PACKAGES.jasmine, 'jasmine'] : [PACKAGES[framework]];
+}
+/**
+ * The packages that show a project runs a framework. For Jasmine, the jasmine command or Karma's adapter: jasmine-core
+ * alone is often left over in projects that moved to Jest, or comes with type packages.
+ */
+function runnerPackages(framework) {
+    return framework === 'jasmine' ? ['jasmine', 'karma-jasmine'] : [PACKAGES[framework]];
+}
 /** Each framework's name in messages. */
-export const FRAMEWORK_NAMES = { playwright: 'Playwright', vitest: 'Vitest', jest: 'Jest' };
-/** Oldest supported version of each framework. */
-export const OLDEST = { playwright: [1, 42], vitest: [3, 0], jest: [29, 0] };
+export const FRAMEWORK_NAMES = {
+    playwright: 'Playwright',
+    vitest: 'Vitest',
+    jest: 'Jest',
+    mocha: 'Mocha',
+    jasmine: 'Jasmine',
+    cypress: 'Cypress',
+    webdriverio: 'WebdriverIO',
+    node: 'node:test',
+    bun: 'Bun',
+};
+/** Oldest supported version of each framework, as major, minor and for Bun, whose 1.2.23 changed how it runs tests, patch. */
+export const OLDEST = {
+    playwright: [1, 42],
+    vitest: [3, 0],
+    jest: [29, 0],
+    mocha: [10, 0],
+    jasmine: [4, 0],
+    cypress: [13, 0],
+    webdriverio: [9, 0],
+    node: [22, 0],
+    bun: [1, 2, 23],
+};
 /** A file's text, or null when it is missing or can't be read. */
 function readText(file) {
     try {
@@ -29,7 +71,7 @@ function escape(text) {
     return text.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
 }
 /** The root, then each folder above it, as a monorepo package's dependencies may be installed or locked higher up. */
-function folders(root) {
+export function folders(root) {
     const list = [];
     for (let folder = path.resolve(root);; folder = path.dirname(folder)) {
         list.push(folder);
@@ -80,10 +122,16 @@ function declaredVersion(folder, name) {
  * below the root that declares it and holds one of the scanned `files` is read the same way, from its own folder up.
  */
 export function detectFrameworkVersion(root, framework, files) {
+    if (framework === 'node')
+        return nodeVersion(root);
+    if (framework === 'bun')
+        return bunVersion(root);
+    for (const name of versionPackages(framework)) {
+        const found = detectIn(root, folders(root), name);
+        if (found)
+            return found;
+    }
     const name = PACKAGES[framework];
-    const found = detectIn(root, folders(root), name);
-    if (found)
-        return found;
     // In path order, then shallowest first; the sort is stable, so packages as deep stay in path order.
     const nested = globSync('**/package.json', { cwd: root, ignore: ['**/node_modules/**'] })
         .sort()
@@ -111,18 +159,117 @@ function detectIn(root, all, name) {
     }
     return null;
 }
+/**
+ * The Node.js version a project pins, whose `node:test` runs its tests: the first of `.node-version`, `.nvmrc`, Volta's
+ * `node` and the newest version `engines.node` names, in the root, then in each folder above it. A pin without a
+ * minor, as `24`, or an alias, as `lts/*`, is a range or nothing.
+ */
+function nodeVersion(root) {
+    const source = (folder, file) => path.relative(root, path.join(folder, file)).replaceAll('\\', '/');
+    for (const folder of folders(root)) {
+        for (const file of ['.node-version', '.nvmrc']) {
+            const pinned = readText(path.join(folder, file))?.trim() ?? '';
+            const found = /^v?(\d+)(?:\.(\d+)(?:\.(\d+))?)?$/.exec(pinned);
+            if (!found)
+                continue;
+            const [major, minor, patch] = [found[1], found[2], found[3]];
+            return {
+                version: `${major}.${minor ?? 0}.${patch ?? 0}`,
+                source: source(folder, file),
+                range: minor === undefined ? pinned : null,
+            };
+        }
+        const manifest = readJson(path.join(folder, 'package.json'));
+        const volta = manifest?.volta?.node;
+        if (typeof volta === 'string' && /^\d+\.\d+\.\d+$/.test(volta)) {
+            return { version: volta, source: source(folder, 'package.json'), range: null };
+        }
+        // `engines.node` is a floor: the newest version it names is the likeliest to run, and none older than node:test's.
+        const engines = manifest?.engines?.node;
+        const named = typeof engines === 'string' ? [...engines.matchAll(/\d+(?:\.\d+){0,2}/g)].map(versionParts) : [];
+        if (typeof engines === 'string' && named.length > 0) {
+            const newest = named.reduce((a, b) => (compareParts(b, a) > 0 ? b : a));
+            const floor = compareParts(newest, [...OLDEST.node, 0]) < 0 ? [...OLDEST.node, 0] : newest;
+            return { version: floor.join('.'), source: source(folder, 'package.json'), range: engines };
+        }
+    }
+    return null;
+}
+function versionParts(match) {
+    const [major, minor = 0, patch = 0] = match[0].split('.').map(Number);
+    return [major, minor, patch];
+}
+function compareParts(a, b) {
+    return a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
+}
+/**
+ * The Bun version a project pins: `.bun-version`, which setup-bun reads, or `packageManager` or `engines.bun` in
+ * package.json, in the root, then in each folder above it; else the version of `@types/bun` or `bun-types`, which Bun
+ * publishes with each release, read as other packages are.
+ */
+function bunVersion(root) {
+    const source = (folder, file) => path.relative(root, path.join(folder, file)).replaceAll('\\', '/');
+    for (const folder of folders(root)) {
+        const pinned = readText(path.join(folder, '.bun-version'))?.trim() ?? '';
+        if (/^v?\d+\.\d+\.\d+$/.test(pinned)) {
+            return { version: pinned.replace(/^v/, ''), source: source(folder, '.bun-version'), range: null };
+        }
+        const manifest = readJson(path.join(folder, 'package.json'));
+        const manager = typeof manifest?.packageManager === 'string' ? /^bun@(\d+\.\d+\.\d+)/.exec(manifest.packageManager) : null;
+        if (manager)
+            return { version: manager[1], source: source(folder, 'package.json'), range: null };
+        const engines = manifest?.engines?.bun;
+        const lowest = typeof engines === 'string' ? /\d+\.\d+(\.\d+)?/.exec(engines) : null;
+        if (typeof engines === 'string' && lowest) {
+            const [major, minor, patch = '0'] = lowest[0].split('.');
+            return { version: `${major}.${minor}.${patch}`, source: source(folder, 'package.json'), range: engines };
+        }
+    }
+    for (const name of ['@types/bun', 'bun-types']) {
+        const found = detectIn(root, folders(root), name);
+        if (found)
+            return found;
+    }
+    return null;
+}
 /** Config file names of each runner. A Vite config alone doesn't count, as Vite apps without Vitest have one. */
 const CONFIG_NAMES = {
     playwright: /^playwright\.config\.[cm]?[jt]s$/,
     vitest: /^vitest\.config\.[cm]?[jt]s$/,
     jest: /^jest\.config\.([cm]?[jt]s|json)$/,
+    mocha: /^\.mocharc\.([cm]?js|ya?ml|jsonc?)$/,
+    // Matched against the path, not only the name: Jasmine's config is in spec/support.
+    jasmine: /(^|\/)spec\/support\/jasmine\.(m?js|json)$/,
+    cypress: /^cypress\.config\.[cm]?[jt]s$/,
+    webdriverio: /^wdio\.conf\.[cm]?[jt]s$/,
+    node: /^node\.config\.json$/,
+    bun: /^bunfig\.toml$/,
 };
-/** Whether a package.json lists a runner, or for Jest has a `jest` key, its config. */
+/**
+ * Whether a file is a runner's config. A `bunfig.toml` counts only with a `[test]` table, as projects that run another
+ * runner keep one for Bun's installs.
+ */
+function isConfig(root, file, framework) {
+    if (!CONFIG_NAMES[framework].test(framework === 'jasmine' ? file : path.basename(file)))
+        return false;
+    // A file that can't be read gives null, which holds no table.
+    return framework !== 'bun' || /^\s*\[test\]/m.test(String(readText(path.join(root, file))));
+}
+/**
+ * Whether a package.json lists a runner, or for Jest or Mocha has a `jest` or `mocha` key, its config, or for
+ * `node:test` has a script that runs `node --test`.
+ */
 function declares(manifest, framework) {
     const json = readJson(manifest);
     const fields = ['devDependencies', 'dependencies', 'peerDependencies', 'optionalDependencies'];
-    return (fields.some((field) => json?.[field]?.[PACKAGES[framework]] !== undefined) ||
-        (framework === 'jest' && json?.jest !== undefined));
+    if (framework === 'bun') {
+        return Object.values(json?.scripts ?? {}).some((script) => typeof script === 'string' && /(^|[\s;&|(])bun\s+test(?=\s|$)/.test(script));
+    }
+    if (framework === 'node') {
+        return Object.values(json?.scripts ?? {}).some((script) => typeof script === 'string' && nodeTestCommands(script).length > 0);
+    }
+    return (fields.some((field) => runnerPackages(framework).some((name) => json?.[field]?.[name] !== undefined)) ||
+        ((framework === 'jest' || framework === 'mocha') && json?.[framework] !== undefined));
 }
 /**
  * The runner a project uses, for a scan without `framework`: the one whose package a package.json in the root or a
@@ -131,7 +278,15 @@ function declares(manifest, framework) {
  * none of them or several, naming what it found.
  */
 export function detectFramework(root, ignore) {
-    const below = globSync(['**/package.json', '**/*.config.*'], {
+    const below = globSync([
+        '**/package.json',
+        '**/*.config.*',
+        '**/.mocharc.*',
+        '**/spec/support/jasmine.*',
+        '**/wdio.conf.*',
+        '**/node.config.json',
+        '**/bunfig.toml',
+    ], {
         cwd: root,
         ignore: ['**/node_modules/**', '**/.git/**', ...ignore],
     });
@@ -139,15 +294,15 @@ export function detectFramework(root, ignore) {
     const above = folders(root)
         .slice(1)
         .map((folder) => path.join(folder, 'package.json'));
-    const all = ['playwright', 'vitest', 'jest'];
-    let found = all.filter((framework) => below.some((file) => CONFIG_NAMES[framework].test(path.basename(file))) ||
+    const all = ['playwright', 'vitest', 'jest', 'mocha', 'jasmine', 'cypress', 'webdriverio', 'node', 'bun'];
+    let found = all.filter((framework) => below.some((file) => isConfig(root, file, framework)) ||
         manifests.some((manifest) => declares(manifest, framework)));
     if (found.length === 0)
         found = all.filter((framework) => above.some((manifest) => declares(manifest, framework)));
     if (found.length === 1)
         return found[0];
     if (found.length === 0) {
-        throw new OptionsError('options.framework is needed: no package.json in the root, below it or above it lists @playwright/test, vitest or jest, and no config of theirs is in the root or below.');
+        throw new OptionsError('options.framework is needed: no package.json in the root, below it or above it lists @playwright/test, vitest, jest, mocha, jasmine, cypress or @wdio/cli or has a script that runs node --test or bun test, and no config of theirs is in the root or below.');
     }
     const names = found.map((framework) => FRAMEWORK_NAMES[framework]);
     const values = found.map((framework) => `"${framework}"`);

package/dist/frameworks/bun.d.ts

@@ -0,0 +1,42 @@
+import type { CallExpression } from 'oxc-parser';
+import type { ApiCall, CallContext, ModuleReader } from '../model.ts';
+import type { ParsedFile } from '../parse.ts';
+import type { HookCounts } from '../types.ts';
+import { type FileContext, type Link } from './common.ts';
+import { SuiteAdapter, type Kind } from './test-functions.ts';
+/**
+ * Bun's `bun test`, from 1.2.23, which runs its tests the way 1.3 and 1.4 do. Its functions are globals in test files,
+ * and imports of `bun:test`, `@jest/globals` and `vitest` give them too. A chain holds its modes in any order, one of
+ * each group, and the conditions `if`, `skipIf`, `todoIf`, `failingIf`, `concurrentIf` and `serialIf` as often as
+ * it likes; options go second or third.
+ */
+export declare class BunAdapter extends SuiteAdapter {
+    constructor(parsed: ParsedFile, file: FileContext, readModule: ModuleReader | null);
+    classify(call: CallExpression, context: CallContext): ApiCall | null;
+    protected isAliasLink(_kind: Kind, link: Link): boolean;
+    /** A hook; before Bun 1.3, one given more than its function fails the file. */
+    protected hook(call: CallExpression, name: keyof HookCounts, context: CallContext): ApiCall;
+    private chainCall;
+    /**
+     * Whether Bun takes a chain: one of `skip`, `todo` and `failing`, one `only`, one of `concurrent` and `serial`, and
+     * one table, where a condition that holds counts as its mode, as `if(false)` counts as `skip`; the conditions and
+     * the table called and the modes not; and no `failing` on a describe. A condition the scan can't work out counts as
+     * not holding (checked with Bun 1.2.23, 1.3.14 and 1.4.4).
+     */
+    private isValid;
+    private condition;
+    private declaration;
+    /**
+     * The states of a chain, as Bun ranks them: `skip` over `todo` over `failing`. `if(condition)` skips when the
+     * condition is false; `skipIf`, `todoIf` and `failingIf` set theirs when it is true.
+     */
+    private states;
+    /** `concurrent` runs the test with others at once, and `serial` alone, also as `concurrentIf` and `serialIf` that hold. */
+    private mode;
+    /** A number as the timeout, or an object with `timeout`, `retry` and `repeats`. */
+    private options;
+    /** How many tests a table registers: one per item; null with a warning when the scan can't count them. */
+    private caseCount;
+    /** The cases of a table the scan can work out: an item that is an array is spread into the arguments, another is one. */
+    private tableCases;
+}

package/dist/frameworks/bun.js

@@ -0,0 +1,272 @@
+import { isFunctionNode, unwrap } from "../ast.js";
+import { bunCaseTitle } from "../case-titles.js";
+import { snippet } from "../source.js";
+import { requiredModule } from "./bindings.js";
+import { atLeast, hookFunction, namedFunction, problem, readChain, readCondition, readCount, readOptions, readTitle, refused, text, unresolvedOptions, } from "./common.js";
+import { SuiteAdapter } from "./test-functions.js";
+const SOURCE = 'bun:test';
+/** Bun rewrites imports of these to `bun:test` in its test files. */
+const ALIASES = new Set(['@jest/globals', 'vitest']);
+/** The modes a chain may hold one of each group of, as Bun throws on a second. */
+const GROUPS = [new Set(['skip', 'todo', 'failing']), new Set(['only']), new Set(['concurrent', 'serial'])];
+const MODES = new Set(GROUPS.flatMap((group) => [...group]));
+const CONDITIONS = new Set(['if', 'skipIf', 'todoIf', 'failingIf', 'concurrentIf', 'serialIf']);
+const MODIFIERS = new Set([...MODES, ...CONDITIONS, 'each']);
+const BUN = {
+    name: 'Bun',
+    source: SOURCE,
+    aliases: ALIASES,
+    mismatched: new Set(['@playwright/test', 'playwright/test', 'mocha']),
+    starts: new Map([
+        ['test', { kind: 'test', links: [] }],
+        ['it', { kind: 'test', links: [] }],
+        ['describe', { kind: 'describe', links: [] }],
+        ['xtest', { kind: 'test', links: ['skip'] }],
+        ['xit', { kind: 'test', links: ['skip'] }],
+        ['xdescribe', { kind: 'describe', links: ['skip'] }],
+    ]),
+    hooks: new Map(['beforeEach', 'afterEach', 'beforeAll', 'afterAll'].map((name) => [name, name])),
+    derivations: new Set(),
+    modifiers: MODIFIERS,
+    carriesKinds: false,
+    isModule: (expression) => {
+        const source = requiredModule(expression);
+        return source === SOURCE || (source !== null && ALIASES.has(source));
+    },
+    defaultImport: null,
+    required: null,
+};
+/**
+ * Bun's `bun test`, from 1.2.23, which runs its tests the way 1.3 and 1.4 do. Its functions are globals in test files,
+ * and imports of `bun:test`, `@jest/globals` and `vitest` give them too. A chain holds its modes in any order, one of
+ * each group, and the conditions `if`, `skipIf`, `todoIf`, `failingIf`, `concurrentIf` and `serialIf` as often as
+ * it likes; options go second or third.
+ */
+export class BunAdapter extends SuiteAdapter {
+    constructor(parsed, file, readModule) {
+        super(parsed, file, readModule, BUN, MODIFIERS);
+    }
+    classify(call, context) {
+        return this.hookCall(call, context) ?? this.chainCall(call, context);
+    }
+    isAliasLink(_kind, link) {
+        return MODIFIERS.has(link.name);
+    }
+    /** A hook; before Bun 1.3, one given more than its function fails the file. */
+    hook(call, name, context) {
+        const fn = hookFunction(this.file, context.scopes, call.arguments);
+        if (call.arguments.length > 1 && !atLeast(this.file.version, 1, 3)) {
+            const callee = snippet(text(this.file, call.callee));
+            const message = `${callee}() takes only its function before Bun 1.3, so Bun fails the file and runs none of its tests.`;
+            return { kind: 'invalid', problem: problem('invalid-chain', call, message, callee) };
+        }
+        return { kind: 'hook', name, fn, testContext: null, fixtures: [], takesAllFixtures: false };
+    }
+    chainCall(call, context) {
+        const chain = readChain(call.callee);
+        const resolved = chain ? this.resolve(chain, call.arguments, context) : null;
+        if (!resolved)
+            return null;
+        const { kind, links } = resolved;
+        const last = links.at(-1);
+        if ((last?.name === 'each' || CONDITIONS.has(last?.name ?? '')) && !last?.args)
+            return { kind: 'other' };
+        if (this.isValid(kind, links, context))
+            return this.declaration(call, kind, links, context);
+        const callee = snippet(text(this.file, call.callee));
+        const refusal = problem('invalid-chain', call, `${callee} is not part of Bun's API; the call throws, and Bun fails the file and runs none of its tests.`, callee);
+        return refused(call, refusal, context, () => this.declaration(call, kind, [], context));
+    }
+    /**
+     * Whether Bun takes a chain: one of `skip`, `todo` and `failing`, one `only`, one of `concurrent` and `serial`, and
+     * one table, where a condition that holds counts as its mode, as `if(false)` counts as `skip`; the conditions and
+     * the table called and the modes not; and no `failing` on a describe. A condition the scan can't work out counts as
+     * not holding (checked with Bun 1.2.23, 1.3.14 and 1.4.4).
+     */
+    isValid(kind, links, context) {
+        if (!links.every((link) => MODIFIERS.has(link.name)))
+            return false;
+        const called = links.every((link) => (MODES.has(link.name) ? !link.args : link.args !== null) && !link.template);
+        if (!called)
+            return false;
+        const modes = links.flatMap((link) => {
+            if (!CONDITIONS.has(link.name))
+                return [link.name];
+            const holds = this.condition(link, context).applies === (link.name === 'if' ? 'never' : 'always');
+            return holds ? [link.name === 'if' ? 'skip' : link.name.slice(0, -2)] : [];
+        });
+        if ([...GROUPS, new Set(['each'])].some((group) => modes.filter((name) => group.has(name)).length > 1)) {
+            return false;
+        }
+        return kind !== 'describe' || !modes.includes('failing');
+    }
+    condition(link, context) {
+        return readCondition(this.file, context.scopes, link.args.at(0));
+    }
+    declaration(call, kind, links, context) {
+        const args = call.arguments;
+        const callee = snippet(text(this.file, call.callee));
+        const problems = [];
+        const { title, problem: titleProblem } = readTitle(this.file, context.scopes, args[0], {
+            stripTags: false,
+            functionNames: true,
+        });
+        if (titleProblem)
+            problems.push(titleProblem);
+        const spread = args.some((arg) => arg.type === 'SpreadElement');
+        // (title, fn, options) or (title, options, fn); a number is the timeout.
+        const [second, third] = [args.at(1), args.at(2)];
+        const fnSecond = third === undefined || isFunctionLike(second);
+        const body = spread ? undefined : fnSecond ? second : third;
+        const options = spread ? undefined : fnSecond ? third : second;
+        const fn = isFunctionNode(body) ? body : null;
+        const names = new Set(links.map((link) => link.name));
+        const line = this.file.source.line(call.start);
+        const states = this.states(links, line, context);
+        const table = links.find((link) => link.name === 'each') ?? null;
+        const run = this.options(options, problems, context);
+        const base = {
+            title,
+            states,
+            isOnly: names.has('only'),
+            mode: this.mode(links, context),
+            details: { tags: [], annotations: [], locks: [], meta: null, run },
+            fn,
+            hashed: fn ?? namedFunction(this.file, context.scopes, body),
+            isParameterized: table !== null,
+            caseCount: table ? this.caseCount(table, problems, context) : null,
+            cases: table ? this.tableCases(table, title, context) : null,
+            problems,
+        };
+        const declared = kind === 'describe'
+            ? { kind: 'describe', ...base, isShuffled: false, passesDown: null }
+            : { kind: 'test', ...base, testContext: null, fixtures: [], takesAllFixtures: false, usesBench: false };
+        // Only a skipped or todo test may leave out its function.
+        const mayLeaveOut = kind === 'test' && (names.has('skip') || names.has('todo'));
+        const rows = table?.args?.at(0);
+        const resolvedRows = rows && rows.type !== 'SpreadElement' ? this.file.values.resolve(rows, context.scopes) : null;
+        if (resolvedRows?.ok && !Array.isArray(resolvedRows.value)) {
+            const source = snippet(text(this.file, rows));
+            const refusal = problem('invalid-chain', rows, `.each() takes an array, and ${source} is not one, so Bun fails the file and runs none of its tests.`, source);
+            return refused(call, refusal, context, () => declared);
+        }
+        // Bun wants a function second or third; a value that can't be one, as options alone, is none.
+        const missing = body === undefined || isValue(body);
+        if (missing && !spread && !mayLeaveOut) {
+            const refusal = problem('test-without-body', call, `${callee}() has no function, so Bun fails the file and runs none of its tests.`, callee);
+            return refused(call, refusal, context, () => declared);
+        }
+        // Bun refuses a retry above 0 with any repeats, 0 too.
+        if (run.retry && run.retry.count > 0 && run.repeats !== undefined && atLeast(this.file.version, 1, 3)) {
+            const refusal = problem('invalid-chain', options, `${callee}() sets both retry and repeats, which Bun refuses from 1.3, so it fails the file and runs none of its tests.`, snippet(text(this.file, options)));
+            return refused(call, refusal, context, () => declared);
+        }
+        return declared;
+    }
+    /**
+     * The states of a chain, as Bun ranks them: `skip` over `todo` over `failing`. `if(condition)` skips when the
+     * condition is false; `skipIf`, `todoIf` and `failingIf` set theirs when it is true.
+     */
+    states(links, line, context) {
+        const setting = (state, condition) => ({
+            state,
+            condition,
+            reason: null,
+            hasDynamicReason: false,
+            line,
+        });
+        const states = [];
+        for (const link of links) {
+            if (link.name === 'skip')
+                states.push(setting('skip', null));
+            else if (link.name === 'todo')
+                states.push(setting('todo', null));
+            else if (link.name === 'failing')
+                states.push(setting('expectedToFail', null));
+            if (!['if', 'skipIf', 'todoIf', 'failingIf'].includes(link.name))
+                continue;
+            let condition = this.condition(link, context);
+            if (link.name === 'if')
+                condition = negated(condition);
+            if (condition.applies === 'never')
+                continue;
+            const state = link.name === 'todoIf' ? 'todo' : link.name === 'failingIf' ? 'expectedToFail' : 'skip';
+            states.push(setting(state, condition.applies === 'always' ? null : condition.text));
+        }
+        const rank = ['skip', 'todo', 'expectedToFail'];
+        return states.sort((a, b) => rank.indexOf(a.state) - rank.indexOf(b.state));
+    }
+    /** `concurrent` runs the test with others at once, and `serial` alone, also as `concurrentIf` and `serialIf` that hold. */
+    mode(links, context) {
+        for (const link of links) {
+            const holds = !link.name.endsWith('If') || this.condition(link, context).applies === 'always';
+            if (holds && (link.name === 'concurrent' || link.name === 'concurrentIf'))
+                return 'parallel';
+            if (holds && (link.name === 'serial' || link.name === 'serialIf'))
+                return 'default';
+        }
+        return null;
+    }
+    /** A number as the timeout, or an object with `timeout`, `retry` and `repeats`. */
+    options(node, problems, context) {
+        const run = {};
+        if (node === undefined || isFunctionLike(node))
+            return run;
+        const expression = unwrap(node);
+        const resolved = this.file.values.resolve(expression, context.scopes);
+        if (resolved.ok && typeof resolved.value === 'number') {
+            const value = readCount(this.file, 'timeout', { node: expression, resolved }, problems);
+            if (value !== null)
+                run.timeout = value;
+            return run;
+        }
+        const read = readOptions(this.file, context.scopes, node);
+        problems.push(...unresolvedOptions(this.file, read, 'its timeout, retry and repeats are missing'));
+        for (const key of ['timeout', 'retry', 'repeats']) {
+            const option = read.values.get(key);
+            const value = option ? readCount(this.file, key, option, problems) : null;
+            if (value === null)
+                continue;
+            if (key === 'retry')
+                run.retry = { count: value, delay: null, condition: null };
+            else
+                run[key] = value;
+        }
+        return run;
+    }
+    /** How many tests a table registers: one per item; null with a warning when the scan can't count them. */
+    caseCount(table, problems, context) {
+        const cases = table.args.at(0);
+        const length = cases ? this.arrayLength(cases, context) : null;
+        const resolved = cases && cases.type !== 'SpreadElement' ? this.file.values.resolve(cases, context.scopes) : null;
+        // A table that isn't an array fails the file, which is reported where the call is read.
+        if (length === null && cases && !resolved?.ok) {
+            const source = snippet(text(this.file, cases));
+            problems.push(problem('unresolved-cases', cases, 'The cases of .each() could not be counted; caseCount is null.', source));
+        }
+        return length;
+    }
+    /** The cases of a table the scan can work out: an item that is an array is spread into the arguments, another is one. */
+    tableCases(table, title, context) {
+        const first = table.args.at(0);
+        const resolved = first && first.type !== 'SpreadElement' ? this.file.values.resolve(first, context.scopes) : null;
+        if (!resolved?.ok || !Array.isArray(resolved.value))
+            return null;
+        return resolved.value.map((item, index) => {
+            const row = Array.isArray(item) ? item : [item];
+            return { title: title.isDynamic ? null : bunCaseTitle(title.text, row, index, this.file.version), args: row };
+        });
+    }
+}
+function negated(condition) {
+    if (condition.applies === 'sometimes')
+        return { applies: 'sometimes', text: `!(${condition.text})` };
+    return { applies: condition.applies === 'always' ? 'never' : 'always', text: null };
+}
+function isFunctionLike(node) {
+    return node !== undefined && node.type !== 'SpreadElement' && isFunctionNode(unwrap(node));
+}
+/** Whether an argument is a value that can't be a function, as a literal or an object. */
+function isValue(node) {
+    return ['Literal', 'ObjectExpression', 'ArrayExpression', 'TemplateLiteral'].includes(unwrap(node).type);
+}

package/dist/frameworks/common.d.ts

@@ -63,7 +63,9 @@ export declare function returnedFunction<T>(returns: Returns, shared: (a: T | nu
 export declare function looksLikeDeclaration(args: readonly Argument[]): boolean;
 /**
  * A call the runner refuses. Shaped like a declaration outside any test or hook, it is also declared, without what
- * makes it fail, so that its tests, and those of a describe, are listed as not loaded rather than missing.
+ * makes it fail, so that its tests, and those of a describe, are listed as not loaded rather than missing. Inside a
+ * test or hook body, a test or describe is nested, whatever its arguments: the runner refuses it when the test runs,
+ * and the file still loads.
  */
 export declare function refused(call: CallExpression, refusal: Problem, context: CallContext, declare: () => ApiCall): ApiCall;
 /**

package/dist/frameworks/common.js

@@ -132,10 +132,18 @@ export function looksLikeDeclaration(args) {
 }
 /**
  * A call the runner refuses. Shaped like a declaration outside any test or hook, it is also declared, without what
- * makes it fail, so that its tests, and those of a describe, are listed as not loaded rather than missing.
+ * makes it fail, so that its tests, and those of a describe, are listed as not loaded rather than missing. Inside a
+ * test or hook body, a test or describe is nested, whatever its arguments: the runner refuses it when the test runs,
+ * and the file still loads.
  */
 export function refused(call, refusal, context, declare) {
-    const declared = context.inBody || !looksLikeDeclaration(call.arguments) ? null : declare();
+    if (context.inBody) {
+        const nested = declare();
+        if (nested.kind === 'test' || nested.kind === 'describe')
+            return nested;
+        return { kind: 'invalid', problem: refusal };
+    }
+    const declared = looksLikeDeclaration(call.arguments) ? declare() : null;
     // A declaration refused for a second reason as well, as for its options, is reported for the first.
     const found = declared?.kind === 'invalid' ? declared.declaration : declared;
     const declaration = found?.kind === 'test' || found?.kind === 'describe' ? found : undefined;
@@ -151,13 +159,7 @@ export function mayDeclareTests(name, links) {
 }
 /** A function declared in the file and passed by name, as in `test('fills an order', checkFill)`; null otherwise. */
 export function namedFunction(file, scopes, node) {
-    if (node?.type !== 'Identifier')
-        return null;
-    const declaration = file.values.declarationOf(node.name, scopes);
-    if (declaration?.type === 'FunctionDeclaration')
-        return declaration;
-    const init = declaration?.type === 'VariableDeclarator' && declaration.init ? unwrap(declaration.init) : null;
-    return isFunctionNode(init) ? init : null;
+    return node?.type === 'Identifier' ? file.values.functionOf(node.name, scopes) : null;
 }
 export function findFunction(args, from = 0) {
     for (const arg of args.slice(from)) {

package/dist/frameworks/cypress.d.ts

@@ -0,0 +1,31 @@
+import type { Argument, CallExpression } from 'oxc-parser';
+import type { CallContext, ModuleReader, SuiteDeclaration, TestDeclaration } from '../model.ts';
+import type { ParsedFile } from '../parse.ts';
+import { type FileContext } from './common.ts';
+import { MochaAdapter } from './mocha.ts';
+/**
+ * Cypress runs its specs on its own copy of Mocha's BDD interface. A test or describe takes Cypress's settings as an
+ * object before its function, as `it(title, { retries: 2 }, fn)`, and Cypress sets no Mocha timeout or retries from
+ * `this`.
+ */
+export declare class CypressAdapter extends MochaAdapter {
+    protected readonly readsContextSettings = false;
+    protected readonly refusedEffect = "Cypress fails the spec and runs none of its tests";
+    constructor(parsed: ParsedFile, file: FileContext, readModule: ModuleReader | null);
+    protected splitArguments(args: CallExpression['arguments']): {
+        body: Argument | undefined;
+        options: Argument | null;
+    };
+    /**
+     * Cypress's test config: `retries`, a count or `{ runMode, openMode }`, of which `cypress run` takes `runMode`;
+     * `browser`, which skips the test in the browsers it leaves out; `@cypress/grep`'s `tags`; and `env`, which Cypress
+     * 16 refuses in a test's config.
+     */
+    protected withOptions(declared: TestDeclaration | SuiteDeclaration, options: Argument, context: CallContext): void;
+    /**
+     * A retry count, or `runMode` of `{ runMode, openMode }`, which `cypress run` uses; null when it is `null`, which
+     * Cypress takes as no retries set, or can't be worked out.
+     */
+    private retryCount;
+    private count;
+}