test-inventory 0.4.0 → 0.5.0

package/dist/extract.d.ts

@@ -37,6 +37,9 @@ export interface PendingSuite {
     order: number;
     /** Statements of the tests and describes directly inside, left out of the describe's body hash. */
     cuts: Span[];
+    /** Declared under a condition, or in a function: it may not run while the file loads. */
+    isInCondition: boolean;
+    isInFunction: boolean;
 }
 export interface PendingTest {
     scope: Scope;
@@ -80,6 +83,11 @@ export interface Extraction {
     /** Hooks at the top level of the file. */
     hooks: HookCounts;
     usesGlobals: boolean;
+    /** The file's `@module-tag` tags, where each is written. */
+    fileTags: {
+        name: string;
+        span: Span;
+    }[];
 }
 /**
  * Applies settings written later in the same place: the last value of each wins, and a test is slow when any

package/dist/extract.js

@@ -110,7 +110,10 @@ class Walker {
     declaredIn = new Map();
     deferred = [];
     isDeferred = new Set();
-    /** Functions walked at one of their calls, so that their tests are recorded where they are registered. */
+    /**
+     * Functions walked at one of their calls, or as a test or hook body passed by name, so that their tests are recorded
+     * where they are registered and what they set isn't reported as unapplied.
+     */
     walkedAtCall = new Set();
     /** The functions being walked at their calls, innermost last, to stop recursion. */
     callStack = [];
@@ -172,6 +175,10 @@ class Walker {
             problems: [...this.main.adapter.problems, ...this.problems],
             hooks: this.fileScope.hooks,
             usesGlobals: this.main.adapter.usesGlobals,
+            fileTags: this.main.adapter.fileTags.map((name, index) => ({
+                name,
+                span: this.main.adapter.fileTagSpans[index],
+            })),
         };
     }
     visit(node, context) {
@@ -413,6 +420,8 @@ class Walker {
                         context.scope.hookFixtures.push(...api.fixtures);
                 }
                 if (api.fn) {
+                    if (!call.arguments.includes(api.fn))
+                        this.walkedAtCall.add(api.fn);
                     this.visitCallback(api.fn, {
                         ...context,
                         hookScope: context.scope,
@@ -938,6 +947,8 @@ class Walker {
         // A function declared in the file and passed by name runs as the test body too.
         const body = declaration.fn ?? declaration.hashed;
         if (body) {
+            if (!declaration.fn)
+                this.walkedAtCall.add(body);
             this.visitCallback(body, {
                 ...context,
                 test,
@@ -975,6 +986,8 @@ class Walker {
             declaredAt: this.declaredAt(call),
             order: context.registeredAt ?? call.start,
             cuts: [],
+            isInCondition: context.isInCondition,
+            isInFunction: context.isInFunction,
         };
         scope.suite = suite;
         this.suites.push(suite);

package/dist/filter.js

@@ -55,6 +55,12 @@ const TEST_KEYS = Object.keys({
     retryDelay: true,
     retryCondition: true,
     repeats: true,
+    timeoutSource: true,
+    retriesSource: true,
+    repeatsSource: true,
+    timeoutConfigText: true,
+    retriesConfigText: true,
+    repeatsConfigText: true,
     fixtures: true,
     expectCount: true,
     expectedAssertions: true,
@@ -67,6 +73,7 @@ const TEST_KEYS = Object.keys({
     isInLoop: true,
     isInCondition: true,
     isInFunction: true,
+    projects: true,
 });
 function list(value, option, allowed) {
     if (value === undefined)

package/dist/frameworks/bindings.d.ts

@@ -54,10 +54,32 @@ export declare function allDeclarators(program: Program): VariableDeclarator[];
 export declare function moduleImports(program: Program, isFramework: (source: string) => boolean): Map<string, ModuleImport>;
 /** The module of `require('module')`, or null for any other expression. */
 export declare function requiredModule(expression: Expression): string | null;
+/** What `module.exports = value` assigns, the default export of a CommonJS module; null for any other statement. */
+export declare function moduleExportsValue(statement: Node): Expression | null;
 /** Applies `bind` to each declarator until no more names are bound, so declaration order doesn't matter. */
 export declare function bindAll(declarators: VariableDeclarator[], bind: (declarator: VariableDeclarator) => boolean): void;
 /** Whether a module exports `name` as a test object, or as a function that returns one. */
 export declare function exportsTestObject(program: Program, name: string, objects: TestObjects, exported?: Exported): boolean;
+/** How a module exports `name` itself, in `statement`: declared, or exported by name from a local or another module. */
+export type OwnExport = {
+    statement: Node;
+} & ({
+    kind: 'default';
+    value: Expression;
+} | {
+    kind: 'variable' | 'function';
+} | {
+    kind: 'specifier';
+    local: string;
+    source: string | null;
+});
+/**
+ * The module's own export of `name`; null when it has none and only `export *` may pass the name on. An own export
+ * wins over those, as in JavaScript.
+ */
+export declare function ownExport(program: Program, name: string): OwnExport | null;
+/** The module `export * from 'module'` or `module.exports = require('module')` passes every name on from; or null. */
+export declare function starReexport(statement: Node): string | null;
 /** Whether a module imports, re-exports or requires any of the given sources. */
 export declare function importsFrom(program: Program, matches: (source: string) => boolean): boolean;
 /** Whether a name a module imports from another module is a test object there, which follows that module in turn. */

package/dist/frameworks/bindings.js

@@ -135,8 +135,8 @@ export function requiredModule(expression) {
     const argument = node.arguments.at(0);
     return argument?.type === 'Literal' && typeof argument.value === 'string' ? argument.value : null;
 }
-/** The module of `module.exports = require('module')`, which exports what that module does; null otherwise. */
-function commonJsReexport(statement) {
+/** What `module.exports = value` assigns, the default export of a CommonJS module; null for any other statement. */
+export function moduleExportsValue(statement) {
     if (statement.type !== 'ExpressionStatement')
         return null;
     const expression = unwrap(statement.expression);
@@ -147,7 +147,12 @@ function commonJsReexport(statement) {
         target.object.type === 'Identifier' &&
         target.object.name === 'module' &&
         propertyName(target) === 'exports';
-    return isModuleExports ? requiredModule(expression.right) : null;
+    return isModuleExports ? expression.right : null;
+}
+/** The module of `module.exports = require('module')`, which exports what that module does; null otherwise. */
+function commonJsReexport(statement) {
+    const value = moduleExportsValue(statement);
+    return value ? requiredModule(value) : null;
 }
 /** Applies `bind` to each declarator until no more names are bound, so declaration order doesn't matter. */
 export function bindAll(declarators, bind) {
@@ -191,10 +196,10 @@ export function exportsTestObject(program, name, objects, exported = 'test objec
  * The module's own export of `name`; null when it has none and only `export *` may pass the name on. An own export
  * wins over those, as in JavaScript.
  */
-function ownExport(program, name) {
+export function ownExport(program, name) {
     for (const statement of program.body) {
         if (statement.type === 'ExportDefaultDeclaration' && name === 'default') {
-            return { kind: 'default', value: statement.declaration };
+            return { statement, kind: 'default', value: statement.declaration };
         }
         if (statement.type !== 'ExportNamedDeclaration')
             continue;
@@ -202,21 +207,26 @@ function ownExport(program, name) {
         if (declaration?.type === 'VariableDeclaration') {
             const declared = declaration.declarations.some((item) => item.id.type === 'Identifier' && item.id.name === name);
             if (declared)
-                return { kind: 'variable' };
+                return { statement, kind: 'variable' };
         }
         const named = declaration?.type === 'FunctionDeclaration' || declaration?.type === 'ClassDeclaration';
         if (named && declaration.id?.name === name)
-            return { kind: 'function' };
+            return { statement, kind: 'function' };
         for (const specifier of statement.specifiers) {
             if (exportName(specifier.exported) !== name)
                 continue;
-            return { kind: 'specifier', local: exportName(specifier.local), source: statement.source?.value ?? null };
+            return {
+                statement,
+                kind: 'specifier',
+                local: exportName(specifier.local),
+                source: statement.source?.value ?? null,
+            };
         }
     }
     return null;
 }
 /** The module `export * from 'module'` or `module.exports = require('module')` passes every name on from; or null. */
-function starReexport(statement) {
+export function starReexport(statement) {
     if (statement.type === 'ExportAllDeclaration')
         return statement.exported ? null : statement.source.value;
     return commonJsReexport(statement);

package/dist/frameworks/common.d.ts

@@ -75,6 +75,8 @@ export declare function mayDeclareTests(name: string, links: Link[]): boolean;
 /** A function declared in the file and passed by name, as in `test('fills an order', checkFill)`; null otherwise. */
 export declare function namedFunction(file: FileContext, scopes: readonly Node[], node: Argument | undefined): FunctionNode | null;
 export declare function findFunction(args: readonly Argument[], from?: number): FunctionNode | null;
+/** A hook's function: written in the call, or declared in the file and passed by name, as in `beforeEach(signIn)`. */
+export declare function hookFunction(file: FileContext, scopes: readonly Node[], args: readonly Argument[]): FunctionNode | null;
 /** Reads a title. A title that cannot be worked out keeps its source text and gets a `dynamic-title` warning. */
 export declare function readTitle(file: FileContext, scopes: readonly Node[], node: Argument, options: {
     stripTags: boolean;

package/dist/frameworks/common.js

@@ -166,6 +166,10 @@ export function findFunction(args, from = 0) {
     }
     return null;
 }
+/** A hook's function: written in the call, or declared in the file and passed by name, as in `beforeEach(signIn)`. */
+export function hookFunction(file, scopes, args) {
+    return findFunction(args) ?? args.map((arg) => namedFunction(file, scopes, arg)).find((fn) => fn !== null) ?? null;
+}
 /** Reads a title. A title that cannot be worked out keeps its source text and gets a `dynamic-title` warning. */
 export function readTitle(file, scopes, node, options) {
     const expression = node.type === 'SpreadElement' ? null : node;

package/dist/frameworks/playwright.d.ts

@@ -1,9 +1,10 @@
 import type { CallExpression, Expression, Node, Program } from 'oxc-parser';
-import type { Adapter, ApiCall, CallContext, ModuleReader, Problem } from '../model.ts';
+import type { Adapter, ApiCall, CallContext, ModuleReader, Problem, Span } from '../model.ts';
 import { type FileContext } from './common.ts';
 export declare class PlaywrightAdapter implements Adapter {
     readonly problems: Problem[];
     readonly fileTags: string[];
+    readonly fileTagSpans: Span[];
     readonly usesGlobals = false;
     private readonly file;
     private readonly readModule;

package/dist/frameworks/playwright.js

@@ -1,7 +1,7 @@
 import { childNodes, isFunctionNode, 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, findFunction, isTestName, isTitleLiteral, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, namedFunction, origin, problem, readChain, destructuredNames, readCondition, readCount, readOptions, readReason, readStrings, readTitle, refused, returnedFunction, returnedTestObject, text, unresolvedOption, unresolvedOptions, } from "./common.js";
+import { atLeast, findFunction, hookFunction, isTestName, isTitleLiteral, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, namedFunction, origin, problem, readChain, destructuredNames, readCondition, readCount, readOptions, readReason, readStrings, readTitle, refused, returnedFunction, returnedTestObject, text, unresolvedOption, unresolvedOptions, } from "./common.js";
 const MISMATCHED_SOURCES = new Set(['vitest', '@jest/globals']);
 // Maps rather than object literals, so names such as `constructor` don't match inherited properties.
 const DESCRIBES = new Map([
@@ -201,6 +201,7 @@ const PLAYWRIGHT = {
 export class PlaywrightAdapter {
     problems;
     fileTags = [];
+    fileTagSpans = [];
     usesGlobals = false;
     file;
     readModule;
@@ -257,7 +258,7 @@ export class PlaywrightAdapter {
         if (key === 'describe.configure')
             return this.configure(call, context);
         if (HOOKS.has(key)) {
-            const fn = findFunction(call.arguments);
+            const fn = hookFunction(this.file, context.scopes, call.arguments);
             return { kind: 'hook', name: key, fn, testContext: null, fixtures: destructuredNames(fn, 0) };
         }
         if (RUN_MEMBERS.has(key))

package/dist/frameworks/vitest.d.ts

@@ -1,5 +1,5 @@
 import type { CallExpression, Expression, Node } from 'oxc-parser';
-import type { Adapter, ApiCall, CallContext, ModuleReader, Problem } from '../model.ts';
+import type { Adapter, ApiCall, CallContext, ModuleReader, Problem, Span } from '../model.ts';
 import type { ParsedFile } from '../parse.ts';
 import { type FileContext, type Link } from './common.ts';
 type Kind = 'test' | 'describe';
@@ -11,6 +11,7 @@ interface TestFunction {
 export declare class VitestAdapter implements Adapter {
     readonly problems: Problem[];
     readonly fileTags: string[];
+    readonly fileTagSpans: Span[];
     usesGlobals: boolean;
     private readonly file;
     private readonly readModule;

package/dist/frameworks/vitest.js

@@ -1,7 +1,7 @@
 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, findFunction, isTestName, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, origin, problem, readChain, readCondition, returnedFunction, returnedTestObject, destructuredNames, readCount, readOptions, readStrings, isTitleLiteral, readReason, namedFunction, unresolvedOption, unresolvedOptions, readTitle, refused, text, } from "./common.js";
+import { atLeast, hookFunction, isTestName, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, origin, problem, readChain, readCondition, returnedFunction, returnedTestObject, destructuredNames, 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)
@@ -256,6 +256,7 @@ class VitestBindings {
 export class VitestAdapter {
     problems;
     fileTags = [];
+    fileTagSpans = [];
     usesGlobals = false;
     file;
     readModule;
@@ -293,8 +294,10 @@ export class VitestAdapter {
         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)) {
+                const span = { start: match.index, end: match.index + match[0].length };
                 this.fileTags.push(match[2]);
-                this.tagsUsed({ start: match.index, end: match.index + match[0].length });
+                this.fileTagSpans.push(span);
+                this.tagsUsed(span);
             }
         }
     }
@@ -328,7 +331,7 @@ export class VitestAdapter {
             return null;
         const { kind, links } = resolved;
         if (kind === 'test' && links.length === 1 && isHook(links[0].name))
-            return this.hook(call, links[0].name);
+            return this.hook(call, links[0].name, context);
         if (links.length === 1 && DERIVATIONS.has(links[0].name))
             return { kind: 'other' };
         const last = links.at(-1);
@@ -514,10 +517,10 @@ export class VitestAdapter {
         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) : null;
+        return hook ? this.hook(call, hook, context) : null;
     }
-    hook(call, name) {
-        const fn = findFunction(call.arguments);
+    hook(call, name, context) {
+        const fn = hookFunction(this.file, context.scopes, call.arguments);
         const index = HOOKS.get(name);
         return {
             kind: 'hook',
@@ -673,6 +676,7 @@ export class VitestAdapter {
             states,
             isOnly: flags.has('only'),
             mode,
+            ...(skips ? { skipPassedDown: passed.line } : {}),
             details: read.details,
             fn,
             hashed: fn ?? namedFunction(this.file, context.scopes, body),
@@ -871,7 +875,7 @@ export class VitestAdapter {
         if (this.warnedAboutTags)
             return;
         this.warnedAboutTags = true;
-        this.problems.push(problem('config-may-change-state', node, 'The file uses Vitest tags, and tags defined in the Vitest config can skip tests or change how they run; the config is not read.'));
+        this.problems.push(problem('config-may-change-state', node, "The file uses Vitest tags, and tags defined in the Vitest config can skip tests or change how they run; the scan can't work out the config's tags."));
     }
 }
 /** Rows in a tagged-template table such as ``each`a | b ${1} | ${2}` ``: values divided by header columns. */

package/dist/index.d.ts

@@ -3,4 +3,4 @@ export { scanSource } from './scan-source.ts';
 export { filterInventory, pickTestFields } from './filter.ts';
 export type { InventoryFilter, PickedInventory } from './filter.ts';
 export type { CommentsMode, ScanOptions, ScanSourceOptions } from './options.ts';
-export type { Annotation, DeclaredAt, Diagnostic, DiagnosticCode, DiagnosticLevel, FileRecord, Framework, HookCounts, Inventory, InventoryLine, MetaValue, StateSource, SuiteRecord, Summary, TestRecord, TestState, Tool, } from './types.ts';
+export type { Annotation, ConfigRecord, DeclaredAt, Diagnostic, DiagnosticCode, DiagnosticLevel, FileRecord, Framework, HookCounts, Inventory, InventoryLine, MetaValue, StateSource, SuiteRecord, Summary, TestRecord, TestState, Tool, } from './types.ts';

package/dist/inventory.d.ts

@@ -1,3 +1,3 @@
 import type { FileRecords } from './records.ts';
-import type { Diagnostic, Framework, Inventory } from './types.ts';
-export declare function createInventory(framework: Framework, frameworkVersion: string | null, fileCount: number, files: readonly FileRecords[], projectDiagnostics: readonly Diagnostic[]): Inventory;
+import type { ConfigRecord, Diagnostic, Framework, Inventory } from './types.ts';
+export declare function createInventory(framework: Framework, frameworkVersion: string | null, fileCount: number, files: readonly FileRecords[], projectDiagnostics: readonly Diagnostic[], configs: ConfigRecord[]): Inventory;

package/dist/inventory.js

@@ -1,6 +1,6 @@
 import { summarize } from "./summary.js";
 import { toolVersion } from "./version.js";
-export function createInventory(framework, frameworkVersion, fileCount, files, projectDiagnostics) {
+export function createInventory(framework, frameworkVersion, fileCount, files, projectDiagnostics, configs) {
     const suites = files.flatMap((file) => file.suites);
     const tests = files.flatMap((file) => file.tests);
     const diagnostics = [...projectDiagnostics, ...files.flatMap((file) => file.diagnostics)];
@@ -10,6 +10,7 @@ export function createInventory(framework, frameworkVersion, fileCount, files, p
         framework,
         frameworkVersion,
         summary: summarize(fileCount, suites, tests, diagnostics),
+        configs,
         files: files.map((file) => file.file),
         suites,
         tests,

package/dist/json.js

@@ -48,6 +48,8 @@ export async function writeInventoryLines(inventory, write) {
     const line = (type, record) => emit(`${JSON.stringify({ type, ...record })}\n`);
     const { schemaVersion, tool, framework, frameworkVersion } = inventory;
     await line('inventory', { schemaVersion, tool, framework, frameworkVersion });
+    for (const config of inventory.configs)
+        await line('config', config);
     for (const file of inventory.files)
         await line('file', file);
     for (const suite of inventory.suites)

package/dist/model.d.ts

@@ -11,7 +11,8 @@ export interface StateSetting {
     reason: string | null;
     /** The reason could not be worked out to a string, so `reason` holds its source text. */
     hasDynamicReason: boolean;
-    line: number;
+    /** The line in the file that sets the state; null for a state from the config. */
+    line: number | null;
     /**
      * 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.
@@ -67,6 +68,8 @@ interface Declaration {
     states: StateSetting[];
     isOnly: boolean;
     mode: Mode | null;
+    /** Vitest: the line of the describe whose `skip` option reaches this declaration, merged into its options. */
+    skipPassedDown?: number;
     details: Details;
     fn: FunctionNode | null;
     /** The function whose code is hashed: `fn`, or a function declared in the file and passed by name. */
@@ -193,6 +196,8 @@ export interface Adapter {
     problems: Problem[];
     /** Tags that apply to every test in the file. */
     fileTags: string[];
+    /** Where each of `fileTags` is written. */
+    fileTagSpans: Span[];
     usesGlobals: boolean;
     classify(call: CallExpression, context: CallContext): ApiCall | null;
     /**

package/dist/options.d.ts

@@ -5,9 +5,9 @@ export type { CommentsMode };
 export interface ScanOptions {
     /**
      * Glob patterns for the test files, relative to `root`. As in Playwright and Vitest, they match names that start with
-     * a dot too.
+     * a dot too. Without them, the test files are those the configs in the root and the folders below it run.
      */
-    patterns: string[];
+    patterns?: string[];
     framework: Framework;
     /** The project root. Paths in the output are relative to it. Defaults to the current directory. */
     root?: string;

package/dist/records.d.ts

@@ -1,6 +1,7 @@
 import { type Extraction } from './extract.ts';
+import type { RunSettings } from './model.ts';
 import type { ParsedFile } from './parse.ts';
-import type { Diagnostic, FileRecord, Framework, HookCounts, SuiteRecord, TestRecord } from './types.ts';
+import type { Diagnostic, FileRecord, Framework, HookCounts, MetaValue, SuiteRecord, TestRecord } from './types.ts';
 /** @inline */
 export type CommentsMode = 'all' | 'non-active' | 'none';
 export interface FileRecords {
@@ -9,6 +10,57 @@ export interface FileRecords {
     tests: TestRecord[];
     diagnostics: Diagnostic[];
 }
+/** What the config the file uses sets for its tests, where the file sets nothing. */
+export interface ConfigDefaults {
+    /** A run setting the config sets; null when its projects set different values or it depends on a condition. */
+    timeout?: number | null;
+    retry?: RunSettings['retry'] | null;
+    repeats?: number | null;
+    /** The source text of a run setting the config sets under a condition; null for any other. */
+    timeoutText: string | null;
+    retryText: string | null;
+    repeatsText: string | null;
+    /** Whether tests run in parallel unless the file says otherwise: Playwright's `fullyParallel`, Vitest's `sequence.concurrent`. */
+    parallel: boolean;
+}
+/** What a Vitest tag the config defines sets on the tests that carry it. */
+export interface TagOptions {
+    skip?: boolean;
+    only?: boolean;
+    todo?: boolean;
+    fails?: boolean;
+    concurrent?: boolean;
+    run: RunSettings;
+    meta?: Record<string, MetaValue>;
+}
+export interface TagDefinition {
+    name: string;
+    /** Lower numbers win when two tags set the same option; a tag without one loses to every tag with one. */
+    priority: number | null;
+    options: TagOptions;
+}
+/** The tags the Vitest config defines (Vitest 4.1). */
+export interface VitestTags {
+    definitions: TagDefinition[];
+    /** `strictTags`: a tag the config doesn't define fails the file while it loads. */
+    isStrict: boolean;
+    /** From Vitest 5 a tag's options win over the describe's around the test; before, the describe's win. */
+    beatsDescribes: boolean;
+    /** Vitest 4.1 passes the config's `sequence.concurrent`, when it sets one, to every test, over a tag's `concurrent`. */
+    concurrentBeatsTags: boolean;
+}
+/** What the config the file uses gives it. */
+export interface FileConfig {
+    /** Whether a `.only` fails the run: Playwright's `forbidOnly`, always, never, or under the condition with this text. */
+    forbidOnly: boolean | string;
+    /** The names of the projects that run a test, null when unknown, and what they set for it. */
+    forTest(test: TestRecord, suites: SuiteRecord[]): {
+        projects: string[] | null;
+        defaults: ConfigDefaults | null;
+    };
+    /** Vitest's tags; null when the scan can't work them out, or the projects that run the file define different ones. */
+    tags: VitestTags | null;
+}
 interface RecordOptions {
     relativeFilePath: string;
     framework: Framework;
@@ -16,6 +68,7 @@ interface RecordOptions {
     isTypeTest: boolean;
     /** A Vitest 5 benchmark file, such as `*.bench.ts`. */
     isBenchmarkFile: boolean;
+    config: FileConfig | null;
 }
 /** 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;