test-inventory 0.2.1 → 0.4.0

package/dist/model.d.ts

@@ -1,6 +1,6 @@
 import type { CallExpression, Expression, Node } from 'oxc-parser';
 import type { FunctionNode } from './ast.ts';
-import type { Annotation, DiagnosticCode, DiagnosticLevel, MetaValue } from './types.ts';
+import type { Annotation, DiagnosticCode, DiagnosticLevel, HookCounts, MetaValue } from './types.ts';
 export type State = 'skip' | 'fixme' | 'todo' | 'expectedToFail';
 export type Mode = 'parallel' | 'serial' | 'default';
 /** A state set by a declaration, a describe or a call such as `test.skip(condition)`. */
@@ -12,6 +12,11 @@ export interface StateSetting {
     /** The reason could not be worked out to a string, so `reason` holds its source text. */
     hasDynamicReason: boolean;
     line: number;
+    /**
+     * Set by code in a test or hook body, which runs only when the test does: a state set while the file loads, on the
+     * test or a describe around it, keeps the test from getting there.
+     */
+    afterLoad?: boolean;
 }
 export interface Span {
     start: number;
@@ -40,6 +45,22 @@ export interface Details {
     annotations: Annotation[];
     locks: string[];
     meta: Record<string, MetaValue> | null;
+    run: RunSettings;
+}
+/** Run settings written in one place; a key that is missing is not set there. */
+export interface RunSettings {
+    timeout?: number;
+    /** A retry setting replaces the whole `retry` of the describes around, delay and condition included. */
+    retry?: {
+        count: number;
+        delay: number | null;
+        condition: string | null;
+    };
+    repeats?: number;
+    /** Playwright `test.slow()`: the conditions of the calls, any of which makes the test slow; null when one always does. */
+    slow?: {
+        conditions: string[] | null;
+    };
 }
 interface Declaration {
     title: Title | null;
@@ -60,10 +81,16 @@ export interface TestDeclaration extends Declaration {
     title: Title;
     /** Framework-specific names through which the test body can change its own state, such as Vitest's `context.skip`. */
     testContext: unknown;
+    /** Names the test function takes from its context, without the framework's own keys. */
+    fixtures: string[];
+    /** Uses Vitest 5's `bench` fixture. */
+    usesBench: boolean;
 }
 export interface SuiteDeclaration extends Declaration {
     kind: 'describe';
     isShuffled: boolean;
+    /** What the describe passes down to the calls inside it, such as Vitest's `skip` option; null for nothing. */
+    passesDown: unknown;
 }
 export interface Condition {
     /** `always` and `never` are conditions that could be worked out from the file. */
@@ -78,23 +105,46 @@ export type ApiCall = TestDeclaration | SuiteDeclaration | {
     hasDynamicReason: boolean;
     problems: Problem[];
 }
-/** `test.describe.configure()`: a mode, locks (Playwright 1.64), or both. */
+/** `test.describe.configure()`: a mode, locks (Playwright 1.64), a timeout and retries. */
  | {
     kind: 'configure';
     mode: Mode | null;
     locks: string[];
+    run: RunSettings;
+    problems: Problem[];
+}
+/** Playwright `test.setTimeout()` or `test.slow()`, which apply where they are called. */
+ | {
+    kind: 'run';
+    settings: RunSettings;
+    /** Source text of the first argument. */ argument: string | null;
     problems: Problem[];
 } | {
     kind: 'hook';
+    name: keyof HookCounts;
     fn: FunctionNode | null;
     testContext: unknown;
+    fixtures: string[];
+}
+/** Playwright `test.step()` or `test.step.skip()`. */
+ | {
+    kind: 'step';
+    title: Title;
+    isSkipped: boolean;
+    fn: FunctionNode | null;
 } | {
     kind: 'annotations';
     items: Annotation[];
     problems: Problem[];
-} | {
+}
+/**
+ * A call the runner refuses. When it is shaped like a declaration, as `describe.sequential('title', fn)` is in Vitest
+ * 5, `declaration` is what it would declare, so that its tests are listed as not loaded rather than missing.
+ */
+ | {
     kind: 'invalid';
     problem: Problem;
+    declaration?: TestDeclaration | SuiteDeclaration;
 } | {
     kind: 'other';
 };
@@ -105,6 +155,11 @@ export interface CallContext {
     inTest: boolean;
     /** Inside a test or hook body, where calls don't declare tests. */
     inBody: boolean;
+    /**
+     * What the describe the call is registered in passes down, as the framework returned it: the describe around a
+     * helper's call, not where the helper is written. Null outside any describe.
+     */
+    passedDown: unknown;
     /**
      * What a function declared in the file, or imported from a local module, returns, for a call on its result such as
      * `conditionalTest({ min: 22 })('title', fn)`; null when the name is not a function the scan can find.
@@ -119,6 +174,8 @@ export interface Returns {
         expression: Expression;
         scopes: readonly Node[];
     }[] | null;
+    /** What the functions the values call return, looked up in the file that writes the function. */
+    returnsOf: CallContext['returnsOf'];
 }
 /** A module read to see whether it exports a custom `test` object. */
 export interface ModuleSource {
@@ -140,8 +197,8 @@ export interface Adapter {
     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
-     * when it holds none. A function the value calls is not followed to what it returns.
+     * when it holds none. A function the value calls is followed to what it returns through `returnsOf`.
      */
-    testFunction(expression: Expression, scopes: readonly Node[]): unknown;
+    testFunction(expression: Expression, scopes: readonly Node[], returnsOf: CallContext['returnsOf']): unknown;
 }
 export {};

package/dist/records.d.ts

@@ -1,9 +1,10 @@
-import type { Extraction } from './extract.ts';
+import { type Extraction } from './extract.ts';
 import type { ParsedFile } from './parse.ts';
-import type { Diagnostic, Framework, SuiteRecord, TestRecord } from './types.ts';
+import type { Diagnostic, FileRecord, Framework, HookCounts, SuiteRecord, TestRecord } from './types.ts';
 /** @inline */
 export type CommentsMode = 'all' | 'non-active' | 'none';
 export interface FileRecords {
+    file: FileRecord;
     suites: SuiteRecord[];
     tests: TestRecord[];
     diagnostics: Diagnostic[];
@@ -13,7 +14,11 @@ interface RecordOptions {
     framework: Framework;
     comments: CommentsMode;
     isTypeTest: boolean;
+    /** A Vitest 5 benchmark file, such as `*.bench.ts`. */
+    isBenchmarkFile: boolean;
 }
+/** The record of a scanned file, from its records and the hooks at its top level. */
+export declare function fileRecord(relativeFilePath: string, hooks: HookCounts, records: Pick<FileRecords, 'suites' | 'tests'>): FileRecord;
 /** An error for each id used by more than one record. Ordinals keep ids apart, so only a hash collision causes one. */
 export declare function duplicateIdDiagnostics(records: readonly {
     id: string;

package/dist/records.js

@@ -1,13 +1,16 @@
 import { REJECTS_FILE, toDiagnostic } from "./diagnostics.js";
+import { anySlow, eitherCondition, noHooks, } from "./extract.js";
 import { problem } from "./frameworks/common.js";
 import { hashNodes, shortHash } from "./hash.js";
 /**
- * The state the runner applies, from the candidates nearest the test first. An unconditional skip, fixme or todo
- * wins over an unconditional expected failure, since the test doesn't run; then the nearest conditional state.
+ * The state the runner applies, from the candidates nearest the test first. An unconditional skip, fixme or todo wins
+ * over an unconditional expected failure, since the test doesn't run, and one set while the file loads wins over one
+ * in a test or hook body, which then never runs; then the nearest conditional state.
  */
 function chooseState(candidates) {
     const always = candidates.filter((candidate) => candidate.setting.condition === null);
-    return (always.find((candidate) => candidate.setting.state !== 'expectedToFail') ?? always.at(0) ?? candidates.at(0) ?? null);
+    const stops = always.filter((candidate) => candidate.setting.state !== 'expectedToFail');
+    return (stops.find((candidate) => !candidate.setting.afterLoad) ?? stops.at(0) ?? always.at(0) ?? candidates.at(0) ?? null);
 }
 /** The scope and the scopes around it, innermost first. */
 function outward(scope) {
@@ -27,6 +30,47 @@ function bodyNodes(fn) {
     const body = fn.body;
     return body.type === 'BlockStatement' ? body.body : [body];
 }
+function addHooks(scopes) {
+    const total = noHooks();
+    for (const scope of scopes) {
+        for (const name of Object.keys(total))
+            total[name] += scope.hooks[name];
+    }
+    return total;
+}
+/**
+ * The run settings that apply, from the places that set them, nearest first: the first that sets a key wins, and any
+ * `test.slow()` makes the test slow.
+ */
+function runKeys(places) {
+    const first = (key) => places.find((place) => place[key] !== undefined)?.[key];
+    const retry = first('retry');
+    const slows = places.flatMap((place) => place.slow ?? []);
+    return {
+        timeout: first('timeout') ?? null,
+        isSlow: slows.length > 0,
+        slowCondition: eitherCondition(anySlow(slows).conditions ?? []) || null,
+        retries: retry?.count ?? null,
+        retryDelay: retry?.delay ?? null,
+        retryCondition: retry?.condition ?? null,
+        repeats: first('repeats') ?? null,
+    };
+}
+/** The record of a scanned file, from its records and the hooks at its top level. */
+export function fileRecord(relativeFilePath, hooks, records) {
+    return {
+        relativeFilePath,
+        fileName: relativeFilePath.slice(relativeFilePath.lastIndexOf('/') + 1),
+        hooks,
+        suiteCount: records.suites.length,
+        testCount: records.tests.length,
+    };
+}
+/** Whether a function's block holds no statements; comments are not statements. */
+function hasNoStatements(fn) {
+    const body = fn?.body;
+    return body?.type === 'BlockStatement' && body.body.length === 0;
+}
 /** The number of times the runner repeats a test: its own cases times those of each describe table around it. */
 function repetitions(counts) {
     let product = 1;
@@ -69,7 +113,12 @@ class RecordBuilder {
         this.diagnostics.push(...duplicateIdDiagnostics([...suites, ...tests], this.options.relativeFilePath));
         // Diagnostics for the whole file have no line, which sorts as 0, before the others.
         const diagnostics = this.diagnostics.sort((a, b) => Number(a.lineStart) - Number(b.lineStart) || Number(a.columnStart) - Number(b.columnStart));
-        return { suites, tests, diagnostics };
+        return {
+            file: fileRecord(this.options.relativeFilePath, extraction.hooks, { suites, tests }),
+            suites,
+            tests,
+            diagnostics,
+        };
     }
     diagnostic(item, testId = null) {
         return toDiagnostic(item, this.options.relativeFilePath, this.parsed.source, testId);
@@ -134,6 +183,8 @@ class RecordBuilder {
             annotations: scope.details.annotations,
             locks: unique(scope.details.locks),
             meta: scope.details.meta,
+            hooks: { ...scope.hooks },
+            ...runKeys([scope.details.run]),
         };
     }
     test(pending) {
@@ -170,6 +221,10 @@ class RecordBuilder {
         const tables = [declaration, ...describes.map((scope) => suiteOf(scope).declaration)].filter((item) => item.isParameterized);
         for (const item of pending.problems)
             this.diagnostics.push(this.diagnostic(item, id));
+        if (declaration.usesBench && !this.options.isBenchmarkFile) {
+            const message = 'The test uses the bench fixture, which Vitest only provides in benchmark files such as *.bench.ts; elsewhere the test fails.';
+            this.diagnostics.push(this.diagnostic(problem('bench-outside-benchmark-file', located, message), id));
+        }
         if (pending.isInLoop) {
             this.diagnostics.push(this.diagnostic(problem('test-in-loop', located, 'The test is declared in a loop; it is listed once, while the runner creates one test per iteration.'), id));
         }
@@ -219,6 +274,21 @@ class RecordBuilder {
                 ...declaration.details.locks,
             ]),
             meta: Object.keys(meta).length > 0 ? meta : null,
+            hooks: addHooks(scopes),
+            // Calls in the body and in `beforeEach` hooks run last, so they win over what the describes set.
+            ...runKeys([
+                pending.run,
+                ...scopes.map((scope) => scope.hookRun),
+                declaration.details.run,
+                ...scopes.map((scope) => scope.details.run),
+            ]),
+            fixtures: unique([...declaration.fixtures, ...[...scopes].reverse().flatMap((scope) => scope.hookFixtures)]),
+            expectCount: pending.expectCount,
+            expectedAssertions: pending.expectedAssertions,
+            expectsAssertions: pending.expectsAssertions,
+            hasEmptyBody: hasNoStatements(declaration.hashed),
+            steps: pending.steps,
+            isBenchmark: this.options.isBenchmarkFile || declaration.usesBench,
             isParameterized: tables.length > 0,
             caseCount: tables.length > 0 ? repetitions(tables.map((item) => item.caseCount)) : null,
             isInLoop: pending.isInLoop,

package/dist/scan-file.d.ts

@@ -13,5 +13,7 @@ export interface FileSettings {
 export interface FileResult extends FileRecords {
     usesGlobals: boolean;
 }
+/** The records of a file the scan read no tests from. */
+export declare function noRecords(relativeFilePath: string): Omit<FileRecords, 'diagnostics'>;
 /** Reads one file: parse, extract, build records, and drop the AST. Never throws. */
 export declare function scanFile(code: string, relativeFilePath: string, settings: FileSettings): FileResult;

package/dist/scan-file.js

@@ -1,14 +1,15 @@
 import { fileDiagnostic, toDiagnostic } from "./diagnostics.js";
-import { extract } from "./extract.js";
+import { extract, noHooks } from "./extract.js";
 import { parseModule } from "./frameworks/bindings.js";
-import { problem } from "./frameworks/common.js";
+import { atLeast, problem } from "./frameworks/common.js";
 import { PlaywrightAdapter } from "./frameworks/playwright.js";
 import { VitestAdapter } from "./frameworks/vitest.js";
 import { parseFile } from "./parse.js";
-import { buildRecords } from "./records.js";
+import { buildRecords, fileRecord } from "./records.js";
 import { snippet } from "./source.js";
 import { Values } from "./values.js";
 const TYPE_TEST = /\.(test|spec)-d\.[cm]?[jt]sx?$/;
+const BENCHMARK = /\.(bench|benchmark)\.[cm]?[jt]sx?$/;
 /** A file read for the scan: the scanned file, or a module a helper function is imported from. */
 function frame(parsed, relativeFilePath, settings, readModule) {
     const file = { source: parsed.source, values: new Values(), version: settings.version };
@@ -17,6 +18,10 @@ function frame(parsed, relativeFilePath, settings, readModule) {
         : new VitestAdapter(parsed, file, readModule);
     return { parsed, adapter, values: file.values, readModule, relativeFilePath };
 }
+/** The records of a file the scan read no tests from. */
+export function noRecords(relativeFilePath) {
+    return { file: fileRecord(relativeFilePath, noHooks(), { suites: [], tests: [] }), suites: [], tests: [] };
+}
 /** Reads one file: parse, extract, build records, and drop the AST. Never throws. */
 export function scanFile(code, relativeFilePath, settings) {
     try {
@@ -27,7 +32,7 @@ export function scanFile(code, relativeFilePath, settings) {
             diagnostics.push(toDiagnostic(problem('parse-error', { start, end }, `The file could not be parsed: ${message}`, snippet(parsed.source.slice(start, end)) || null), relativeFilePath, parsed.source));
             // The parser keeps what it could read after some errors; after others it returns nothing.
             if (parsed.program.body.length === 0)
-                return { suites: [], tests: [], diagnostics, usesGlobals: false };
+                return { ...noRecords(relativeFilePath), diagnostics, usesGlobals: false };
         }
         const main = frame(parsed, relativeFilePath, settings, settings.readModule);
         const extraction = extract(main, (module) => {
@@ -39,6 +44,8 @@ export function scanFile(code, relativeFilePath, settings) {
             framework: settings.framework,
             comments: settings.comments,
             isTypeTest: settings.framework === 'vitest' && TYPE_TEST.test(relativeFilePath),
+            // Vitest 5's default `benchmark.include`.
+            isBenchmarkFile: settings.framework === 'vitest' && atLeast(settings.version, 5, 0) && BENCHMARK.test(relativeFilePath),
         });
         return {
             ...records,
@@ -50,8 +57,7 @@ export function scanFile(code, relativeFilePath, settings) {
         const raw = error instanceof Error ? error.message : String(error);
         const message = settings.root === null ? raw : raw.replaceAll(settings.root, '.');
         return {
-            suites: [],
-            tests: [],
+            ...noRecords(relativeFilePath),
             diagnostics: [
                 fileDiagnostic('internal-error', relativeFilePath, `Reading the file failed unexpectedly: ${message}`),
             ],

package/dist/scan.js

@@ -7,7 +7,7 @@ import { detectFrameworkVersion, OLDEST } from "./framework-version.js";
 import { createInventory } from "./inventory.js";
 import { checkComments, checkFramework, checkObject, checkStrings, checkVersion, invalid, majorMinor, } from "./options.js";
 import { moduleResolver } from "./resolve.js";
-import { scanFile } from "./scan-file.js";
+import { noRecords, scanFile } from "./scan-file.js";
 import { globalsCheck } from "./vitest-config.js";
 function versionDiagnostics(framework, version, source, range) {
     const name = framework === 'playwright' ? 'Playwright' : 'Vitest';
@@ -86,8 +86,7 @@ export async function scan(options) {
         }
         catch (error) {
             results.push({
-                suites: [],
-                tests: [],
+                ...noRecords(relativeFilePath),
                 diagnostics: [
                     fileDiagnostic('read-error', relativeFilePath, `The file could not be read: ${readFailure(error)}.`),
                 ],

package/dist/summary.js

@@ -27,6 +27,7 @@ export function summarize(fileCount, suites, tests, diagnostics) {
         inConditionCount: count('isInCondition'),
         inFunctionCount: count('isInFunction'),
         typeTestCount: count('isTypeTest'),
+        benchmarkCount: count('isBenchmark'),
         diagnosticCount: diagnostics.length,
         tagCounts: countBy(tests, (test) => test.tags),
         annotationCounts: countBy(tests, (test) => test.annotations.map((annotation) => annotation.type)),

package/dist/types.d.ts

@@ -31,7 +31,7 @@ export type StateSource = 'test' | 'suite' | 'file';
  * @inline
  */
 export type DiagnosticLevel = 'error' | 'warning';
-export type DiagnosticCode = 'unresolved-test-import' | 'parse-error' | 'read-error' | 'framework-mismatch' | 'unresolved-tag' | 'unresolved-annotation' | 'unresolved-cases' | 'test-in-loop' | 'dynamic-title' | 'duplicate-title' | 'duplicate-id' | 'internal-error' | 'invalid-chain' | 'skip-without-body' | 'test-without-body' | 'describe-not-called' | 'async-describe' | 'nested-test' | 'tag-without-at' | 'removed-api' | 'only-in-skipped-describe' | 'config-may-change-state' | 'symlink-ignored' | 'invalid-import' | 'globals-not-enabled' | 'unknown-framework-version' | 'unsupported-framework-version' | 'local-test-object' | 'state-in-helper' | 'unresolved-option' | 'dynamic-reason' | 'no-files-matched' | 'unsupported-file' | 'approximate-framework-version' | 'test-in-function';
+export type DiagnosticCode = 'unresolved-test-import' | 'parse-error' | 'read-error' | 'framework-mismatch' | 'unresolved-tag' | 'unresolved-annotation' | 'unresolved-cases' | 'test-in-loop' | 'dynamic-title' | 'duplicate-title' | 'duplicate-id' | 'internal-error' | 'invalid-chain' | 'skip-without-body' | 'test-without-body' | 'describe-not-called' | 'async-describe' | 'nested-test' | 'tag-without-at' | 'removed-api' | 'only-in-skipped-describe' | 'config-may-change-state' | 'symlink-ignored' | 'invalid-import' | 'globals-not-enabled' | 'unknown-framework-version' | 'unsupported-framework-version' | 'local-test-object' | 'state-in-helper' | 'unresolved-option' | 'dynamic-reason' | 'no-files-matched' | 'unsupported-file' | 'approximate-framework-version' | 'test-in-function' | 'empty-title' | 'bench-outside-benchmark-file';
 export type MetaValue = string | number | boolean | null | MetaValue[] | {
     [key: string]: MetaValue;
 };
@@ -45,10 +45,30 @@ export interface Inventory {
     /** Read from the project, or given with `--framework-version`; null when unknown. */
     frameworkVersion: string | null;
     summary: Summary;
+    /** One per scanned file, in the order the files were scanned. */
+    files: FileRecord[];
     suites: SuiteRecord[];
     tests: TestRecord[];
     diagnostics: Diagnostic[];
 }
+/**
+ * One line of the JSON Lines output (`--format jsonl`): the inventory with each record on its own line, marked by
+ * `type`. The `inventory` line comes first, then the files, suites, tests and diagnostics in the order of the JSON
+ * output, and the `summary` line last.
+ */
+export type InventoryLine = ({
+    type: 'inventory';
+} & Pick<Inventory, 'schemaVersion' | 'tool' | 'framework' | 'frameworkVersion'>) | ({
+    type: 'file';
+} & FileRecord) | ({
+    type: 'suite';
+} & SuiteRecord) | ({
+    type: 'test';
+} & TestRecord) | ({
+    type: 'diagnostic';
+} & Diagnostic) | ({
+    type: 'summary';
+} & Summary);
 /** @inline */
 export interface Tool {
     name: 'test-inventory';
@@ -76,12 +96,38 @@ export interface Summary {
     inConditionCount: Count;
     inFunctionCount: Count;
     typeTestCount: Count;
+    benchmarkCount: Count;
     diagnosticCount: Count;
     /** Tests per tag. */
     tagCounts: Record<string, Count>;
     /** Tests per annotation type. */
     annotationCounts: Record<string, Count>;
 }
+/** A scanned file, also one that has no tests or could not be read. */
+export interface FileRecord {
+    /** Path from the project root, with `/` separators. */
+    relativeFilePath: string;
+    fileName: string;
+    /** Hooks at the top level of the file, which run around every test in it. */
+    hooks: HookCounts;
+    suiteCount: Count;
+    testCount: Count;
+}
+/**
+ * How many hooks of each kind are registered, including by helper functions called there.
+ *
+ * @inline
+ */
+export interface HookCounts {
+    beforeAll: Count;
+    beforeEach: Count;
+    afterEach: Count;
+    afterAll: Count;
+    /** Vitest only. */
+    aroundEach: Count;
+    /** Vitest only. */
+    aroundAll: Count;
+}
 /** A describe block, with what is written on the describe itself. Inherited values are on the tests. */
 export interface SuiteRecord {
     id: Hash;
@@ -142,6 +188,21 @@ export interface SuiteRecord {
     locks: string[];
     /** Vitest only; literal values only. */
     meta: Record<string, MetaValue> | null;
+    /** Hooks registered directly in the describe. */
+    hooks: HookCounts;
+    /** In milliseconds; null when nothing here sets it. */
+    timeout: Count | null;
+    /** Playwright `test.slow()` written in the describe, which triples the timeout of its tests. */
+    isSlow: boolean;
+    /** Source text of the `test.slow()` condition; null when unconditional or not slow. */
+    slowCondition: string | null;
+    retries: Count | null;
+    /** Vitest only: milliseconds between retries, from the `retry` object (4.1). */
+    retryDelay: Count | null;
+    /** Vitest only: source text of the `retry` object's `condition`, a RegExp or a function. */
+    retryCondition: string | null;
+    /** Vitest only: how many times the runner runs each test again after the first run. */
+    repeats: Count | null;
 }
 /** A test, with the effective values the runner applies, including those inherited from its describes. */
 export interface TestRecord {
@@ -210,6 +271,42 @@ export interface TestRecord {
     locks: string[];
     /** Merged from the describes and the test. Vitest only; literal values only. */
     meta: Record<string, MetaValue> | null;
+    /** Every hook that runs around the test: those of the file and of each describe around it. */
+    hooks: HookCounts;
+    /**
+     * In milliseconds: the last `test.setTimeout()` in the body or a `beforeEach`, otherwise the nearest describe or file
+     * that sets one. Null when the file sets none, so the config's timeout applies.
+     */
+    timeout: Count | null;
+    /** Playwright `test.slow()` applies: the runner triples the timeout. */
+    isSlow: boolean;
+    /** Source text of the condition of the `test.slow()` that applies; null when unconditional or not slow. */
+    slowCondition: string | null;
+    /** How many times the runner retries the test when it fails; null when the file sets none. */
+    retries: Count | null;
+    /** Vitest only: milliseconds between retries, from the `retry` object (4.1). */
+    retryDelay: Count | null;
+    /** Vitest only: source text of the `retry` object's `condition`, a RegExp or a function. */
+    retryCondition: string | null;
+    /** Vitest only: how many times the runner runs the test again after the first run. */
+    repeats: Count | null;
+    /**
+     * Names the test function takes from its context, then those of the `beforeEach`, `afterEach` and `aroundEach` hooks
+     * around it, once each. Vitest's own context keys, such as `expect` and `task`, are left out.
+     */
+    fixtures: string[];
+    /** Calls of `expect()`, `expect.soft()` and `expect.poll()` written in the body, each counted once. */
+    expectCount: Count;
+    /** Vitest `expect.assertions(n)` in the body. */
+    expectedAssertions: Count | null;
+    /** Vitest `expect.hasAssertions()` in the body. */
+    expectsAssertions: boolean;
+    /** The test function has no statements, comments aside. */
+    hasEmptyBody: boolean;
+    /** Playwright `test.step()` and `test.step.skip()` calls in the body, in source order. */
+    steps: Step[];
+    /** Vitest 5 benchmark: in a benchmark file, or using the `bench` fixture. Plain `vitest` doesn't run it. */
+    isBenchmark: boolean;
     /** Declared with `.each` or `.for`, or inside a describe declared with them, so the runner repeats it. */
     isParameterized: boolean;
     /**
@@ -225,6 +322,17 @@ export interface TestRecord {
     isInFunction: boolean;
 }
 /** @inline */
+export interface Step {
+    /** The title, or its source text when it can't be worked out. */
+    title: string;
+    hasDynamicTitle: boolean;
+    lineStart: Position;
+    /** 0 for a step directly in the test, 1 for a step inside it, and so on. */
+    depth: Count;
+    /** Declared with `test.step.skip()`. */
+    isSkipped: boolean;
+}
+/** @inline */
 export interface DeclaredAt {
     /** The helper's file, from the project root. */
     relativeFilePath: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "test-inventory",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "Test metadata from source code, not from test results.",
   "keywords": [
     "testing",
@@ -71,7 +71,7 @@
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "format": "prettier --write . --ignore-path .gitignore --ignore-path .prettierignore --ignore-path .git/info/exclude",
-    "format:check": "prettier --check . --ignore-path .gitignore --ignore-path .prettierignore --ignore-path .git/info/exclude",
+    "format:check": "node scripts/format-check.ts",
     "docs:api": "typedoc",
     "docs:dev": "npm run docs:api && vitepress dev docs",
     "docs:build": "npm run docs:api && vitepress build docs",