test-inventory 0.4.1 → 0.6.0

package/dist/diagnostics.js

@@ -22,6 +22,11 @@ export const LEVELS = {
     'removed-api': 'error',
     'only-in-skipped-describe': 'warning',
     'config-may-change-state': 'warning',
+    'undefined-tag': 'error',
+    'config-value-unknown': 'warning',
+    'file-not-run': 'warning',
+    'forbidden-only': 'error',
+    'dependency-not-followed': 'warning',
     'symlink-ignored': 'warning',
     'invalid-import': 'error',
     'globals-not-enabled': 'warning',
@@ -44,7 +49,7 @@ export const LEVELS = {
  */
 export const REJECTS_FILE = {
     playwright: new Set(['test-without-body', 'tag-without-at', 'invalid-chain', 'duplicate-title']),
-    vitest: new Set(['invalid-chain', 'removed-api']),
+    vitest: new Set(['invalid-chain', 'removed-api', 'undefined-tag']),
 };
 export function toDiagnostic(problem, relativeFilePath, source, testId = null) {
     const position = problem.node && source ? source.position(problem.node.start) : null;

package/dist/extract.d.ts

@@ -18,6 +18,10 @@ export interface Scope {
     hookRun: RunSettings;
     /** Fixtures of the hooks in the scope that run around each test. */
     hookFixtures: string[];
+    /** Fixtures of every hook in the scope, `beforeAll` and `afterAll` too, which set up what its tests run. */
+    setupFixtures: string[];
+    /** A hook in the scope takes its fixtures whole, so it may use any. */
+    takesAllFixtures: boolean;
     suite: PendingSuite | null;
 }
 /** Where a test or describe registered through an imported helper is written, in the helper's module. */
@@ -33,10 +37,17 @@ export interface PendingSuite {
     /** For a describe declared in an imported helper, the call in the scanned file that registers it; null otherwise. */
     site: Span | null;
     declaredAt: DeclaredAt | null;
+    /** The file the describe is written in. */
+    frame: Frame;
+    /** The outermost helper call in the scanned file that declares the describe; null when the file declares it. */
+    registeredBy: CallExpression | null;
     /** Where the scanned file registers the describe: its own call, or the outermost helper call that declares it. */
     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;
@@ -45,6 +56,10 @@ export interface PendingTest {
     /** For a test declared in an imported helper, the call in the scanned file that registers it; null otherwise. */
     site: Span | null;
     declaredAt: DeclaredAt | null;
+    /** The file the test is written in. */
+    frame: Frame;
+    /** The outermost helper call in the scanned file that declares the test; null when the file declares it. */
+    registeredBy: CallExpression | null;
     /** Where the scanned file registers the test: its own call, or the outermost helper call that declares it. */
     order: number;
     /** States from the declaration, then from calls in the body such as `test.skip(condition)`. */
@@ -80,6 +95,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

@@ -140,6 +140,8 @@ class Walker {
             hooks: noHooks(),
             hookRun: {},
             hookFixtures: [],
+            setupFixtures: [],
+            takesAllFixtures: false,
             suite: null,
         };
     }
@@ -158,7 +160,7 @@ class Walker {
             helper: null,
             declaredIn: null,
             quiet: false,
-            registeredAt: null,
+            registeredBy: null,
         });
         // Functions defined inside these are deferred in turn; the loop reaches them too, as they are added to the end.
         for (const entry of this.deferred)
@@ -175,6 +177,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) {
@@ -414,6 +420,8 @@ class Walker {
                     context.scope.hooks[api.name] += 1;
                     if (EACH_HOOKS.has(api.name))
                         context.scope.hookFixtures.push(...api.fixtures);
+                    context.scope.setupFixtures.push(...api.fixtures);
+                    context.scope.takesAllFixtures ||= api.takesAllFixtures;
                 }
                 if (api.fn) {
                     if (!call.arguments.includes(api.fn))
@@ -624,7 +632,7 @@ class Walker {
                 ...context,
                 isInFunction: true,
                 declaredIn: null,
-                registeredAt: context.registeredAt ?? call.start,
+                registeredBy: context.registeredBy ?? call,
             });
         });
         this.callStack.pop();
@@ -922,7 +930,9 @@ class Walker {
             call,
             site: this.site,
             declaredAt: this.declaredAt(call),
-            order: context.registeredAt ?? call.start,
+            frame: this.frame,
+            registeredBy: context.registeredBy,
+            order: (context.registeredBy ?? call).start,
             states: [...declaration.states],
             annotations: [...declaration.details.annotations],
             isInLoop: context.isInLoop,
@@ -972,6 +982,8 @@ class Walker {
             hooks: noHooks(),
             hookRun: {},
             hookFixtures: [],
+            setupFixtures: [],
+            takesAllFixtures: false,
             suite: null,
         };
         const suite = {
@@ -980,8 +992,12 @@ class Walker {
             call,
             site: this.site,
             declaredAt: this.declaredAt(call),
-            order: context.registeredAt ?? call.start,
+            frame: this.frame,
+            registeredBy: context.registeredBy,
+            order: (context.registeredBy ?? call).start,
             cuts: [],
+            isInCondition: context.isInCondition,
+            isInFunction: context.isInFunction,
         };
         scope.suite = suite;
         this.suites.push(suite);

package/dist/filter.d.ts

@@ -11,6 +11,12 @@ export interface InventoryFilter {
     only?: boolean;
     /** Keeps tests that don't run and give no reason. Tests in a file the runner refuses are left out. */
     withoutReason?: boolean;
+    /**
+     * Keeps the tests a change to one of these files can affect: those whose `dependencies` include it, and those that
+     * reach code the scan can't follow (`hasUnfollowedDependencies`). Paths are from the project root, as
+     * `dependencies` writes them. An empty list keeps only the tests the scan can't follow.
+     */
+    related?: string[];
 }
 /** An inventory whose test records have only `id` and the keys picked with `pickTestFields()`. */
 export type PickedInventory<K extends keyof TestRecord> = Omit<Inventory, 'tests'> & {

package/dist/filter.js

@@ -1,3 +1,4 @@
+import path from 'node:path';
 import { checkObject, OptionsError } from "./options.js";
 import { summarize } from "./summary.js";
 const STATES = ['active', 'skip', 'fixme', 'todo', 'expectedToFail', 'notLoaded'];
@@ -7,11 +8,15 @@ const FILTER_KEYS = [
     'grep',
     'only',
     'withoutReason',
+    'related',
 ];
 // Typed as a record of every key, so a key added to TestRecord fails to compile until it is listed here.
 const TEST_KEYS = Object.keys({
     id: true,
     bodyHash: true,
+    dependencyHash: true,
+    dependencies: true,
+    hasUnfollowedDependencies: true,
     suiteId: true,
     suitePath: true,
     relativeFilePath: true,
@@ -55,6 +60,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 +78,7 @@ const TEST_KEYS = Object.keys({
     isInLoop: true,
     isInCondition: true,
     isInFunction: true,
+    projects: true,
 });
 function list(value, option, allowed) {
     if (value === undefined)
@@ -110,11 +122,16 @@ export function matcher(filter) {
     const grep = pattern(checked.grep);
     const only = flag(checked.only, 'filter.only');
     const withoutReason = flag(checked.withoutReason, 'filter.withoutReason');
+    // Written as a shell or Windows may write them, as `./pages/order-ticket.ts` or `pages\\order-ticket.ts`.
+    const related = checked.related === undefined
+        ? null
+        : new Set(list(checked.related, 'filter.related', null).map((file) => path.posix.normalize(file.replaceAll('\\', '/'))));
     return (test) => (states.length === 0 || states.includes(test.state)) &&
         (tags.length === 0 || test.tags.some((tag) => tags.includes(tag))) &&
         (grep === null || grep.test(test.fullName)) &&
         (!only || test.isOnly) &&
-        (!withoutReason || (!test.isActive && !test.isNotLoaded && test.reason === null));
+        (!withoutReason || (!test.isActive && !test.isNotLoaded && test.reason === null)) &&
+        (related === null || test.hasUnfollowedDependencies || test.dependencies.some((file) => related.has(file)));
 }
 /**
  * Keeps the tests that pass every condition of the filter; a list keeps a test that has any of its values. The

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

@@ -116,6 +116,11 @@ export declare function readOptions(file: FileContext, scopes: readonly Node[],
 export declare function unresolvedOptions(file: FileContext, options: Options, result: string): Problem[];
 /** The names a function takes from the object pattern of one of its parameters, in source order. */
 export declare function destructuredNames(fn: FunctionNode | null, index: number | null): string[];
+/**
+ * Whether a function takes one of its parameters whole, as in `(fixtures) => ...`, or keeps the rest of its object
+ * pattern, so that any key of it may be used.
+ */
+export declare function takesWhole(fn: FunctionNode | null, index: number | null): boolean;
 /** A whole number, such as a timeout in milliseconds; null, with a warning, when it can't be worked out. */
 export declare function readCount(file: FileContext, name: string, option: OptionValue, problems: Problem[]): number | null;
 /** A warning for one option whose value could not be worked out. */

package/dist/frameworks/common.js

@@ -287,6 +287,17 @@ export function destructuredNames(fn, index) {
     const names = parameter.properties.map((property) => (property.type === 'Property' ? propertyKey(property) : null));
     return names.filter((name) => name !== null);
 }
+/**
+ * Whether a function takes one of its parameters whole, as in `(fixtures) => ...`, or keeps the rest of its object
+ * pattern, so that any key of it may be used.
+ */
+export function takesWhole(fn, index) {
+    const parameter = index === null ? undefined : fn?.params[index];
+    if (!parameter)
+        return false;
+    return (parameter.type !== 'ObjectPattern' ||
+        parameter.properties.some((property) => property.type === 'RestElement' || property.computed));
+}
 /** A whole number, such as a timeout in milliseconds; null, with a warning, when it can't be worked out. */
 export function readCount(file, name, option, problems) {
     const { node, resolved } = option;

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, 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";
+import { atLeast, findFunction, hookFunction, isTestName, isTitleLiteral, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, namedFunction, origin, problem, readChain, destructuredNames, takesWhole, 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;
@@ -258,7 +259,14 @@ export class PlaywrightAdapter {
             return this.configure(call, context);
         if (HOOKS.has(key)) {
             const fn = hookFunction(this.file, context.scopes, call.arguments);
-            return { kind: 'hook', name: key, fn, testContext: null, fixtures: destructuredNames(fn, 0) };
+            return {
+                kind: 'hook',
+                name: key,
+                fn,
+                testContext: null,
+                fixtures: destructuredNames(fn, 0),
+                takesAllFixtures: takesWhole(fn, 0),
+            };
         }
         if (RUN_MEMBERS.has(key))
             return this.runSetting(call, key, context);
@@ -474,6 +482,7 @@ export class PlaywrightAdapter {
             caseCount: null,
             testContext: null,
             fixtures: destructuredNames(hashed, 0),
+            takesAllFixtures: takesWhole(hashed, 0),
             usesBench: false,
             problems,
         };

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, 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";
+import { atLeast, hookFunction, isTestName, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, origin, problem, readChain, readCondition, returnedFunction, returnedTestObject, 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)
@@ -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);
             }
         }
     }
@@ -525,6 +528,7 @@ export class VitestAdapter {
             fn,
             testContext: index === null ? null : contextNames(fn, index),
             fixtures: fixturesOf(fn, index, this.file.version),
+            takesAllFixtures: takesWhole(fn, index),
         };
     }
     contextSkip(call, context) {
@@ -673,6 +677,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),
@@ -697,6 +702,7 @@ export class VitestAdapter {
                 ...base,
                 testContext: contextNames(base.hashed, index),
                 fixtures: fixturesOf(base.hashed, index, this.file.version),
+                takesAllFixtures: takesWhole(base.hashed, index),
                 usesBench: atLeast(this.file.version, 5, 0) && destructuredNames(base.hashed, index).includes('bench'),
             };
         }
@@ -871,7 +877,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/hash.d.ts

@@ -1,6 +1,6 @@
 import type { Node } from 'oxc-parser';
 import type { Span } from './model.ts';
-export declare function shortHash(input: string): string;
+export declare function shortHash(input: string | Uint8Array): string;
 /**
  * Hashes code by its syntax tree, so formatting, comments, quote style, trailing commas and line endings don't change
  * the hash. Nodes at the `cut` spans, such as the tests inside a describe, are left out. Returns null when no code is

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. */
@@ -83,6 +86,8 @@ export interface TestDeclaration extends Declaration {
     testContext: unknown;
     /** Names the test function takes from its context, without the framework's own keys. */
     fixtures: string[];
+    /** The test function takes its fixtures whole, or keeps the rest of them, so it may use any. */
+    takesAllFixtures: boolean;
     /** Uses Vitest 5's `bench` fixture. */
     usesBench: boolean;
 }
@@ -125,6 +130,7 @@ export type ApiCall = TestDeclaration | SuiteDeclaration | {
     fn: FunctionNode | null;
     testContext: unknown;
     fixtures: string[];
+    takesAllFixtures: boolean;
 }
 /** Playwright `test.step()` or `test.step.skip()`. */
  | {
@@ -193,6 +199,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;