test-inventory 0.4.1 → 0.6.0

package/dist/records.d.ts

@@ -1,6 +1,8 @@
-import { type Extraction } from './extract.ts';
+import { type Extraction, type PendingTest } from './extract.ts';
+import type { Dependencies } from './dependency-hash.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 +11,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 +69,9 @@ interface RecordOptions {
     isTypeTest: boolean;
     /** A Vitest 5 benchmark file, such as `*.bench.ts`. */
     isBenchmarkFile: boolean;
+    config: FileConfig | null;
+    /** What a test runs, for its `dependencyHash`. */
+    dependencies: (test: PendingTest) => Dependencies;
 }
 /** 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;

package/dist/records.js

@@ -2,6 +2,7 @@ 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";
+import { snippet } from "./source.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, and one set while the file loads wins over one
@@ -12,6 +13,65 @@ function chooseState(candidates) {
     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 first use of each tag the Vitest config doesn't define, by `strictTags` an error that fails the file while it
+ * loads, in the order Vitest meets them: the `@module-tag` comments, the describes' `tags` as the describes are called,
+ * then the tests'. A use in a function or under a condition only fails the file if that code runs.
+ */
+function undefinedTags(extraction, tags) {
+    const defined = new Set(tags.definitions.map(({ name }) => name));
+    const declared = (items) => items
+        .flatMap(({ declaration, site, call, isInCondition, isInFunction }) => declaration.details.tags.map((name) => ({ name, span: site ?? call, isSure: !isInCondition && !isInFunction })))
+        .sort((a, b) => a.span.start - b.span.start);
+    const uses = [
+        ...extraction.fileTags.map((tag) => ({ ...tag, isSure: true })),
+        ...declared(extraction.suites),
+        ...declared(extraction.tests),
+    ].filter(({ name }) => !defined.has(name));
+    // Each tag is reported once: at its first use that surely runs, else at its first use.
+    const first = new Map();
+    for (const use of uses) {
+        const known = first.get(use.name);
+        if (!known || (!known.isSure && use.isSure))
+            first.set(use.name, use);
+    }
+    const reported = [...first.values()].sort((a, b) => uses.indexOf(a) - uses.indexOf(b));
+    return reported.map(({ name, span, isSure }) => {
+        const consequence = isSure
+            ? 'Vitest fails the file while it loads, and none of its tests run'
+            : 'Vitest fails the file if this code runs while it loads';
+        const message = `The Vitest config doesn't define the tag "${name}", so with strictTags ${consequence}.`;
+        return { problem: problem('undefined-tag', span, message), isSure };
+    });
+}
+const FLAG_ORDER = ['skip', 'todo', 'expectedToFail'];
+const ALWAYS = { condition: null, reason: null, hasDynamicReason: false };
+/**
+ * The states of a test's declaration with those of its Vitest tags. Vitest merges the options and then takes `only`
+ * over `skip` over `todo`, so a `.only` on either side drops the skip and todo of both.
+ */
+function declaredStates(declared, options, { isOnly, skipPassedDown }) {
+    const own = declared.map((setting) => ({ setting, source: 'test' }));
+    if (options === null)
+        return own;
+    // A describe's `skip` option is merged in too, where the scan otherwise leaves it to the describe's own state; the
+    // test's own skip, when it has one, sorts first.
+    const passed = skipPassedDown === undefined
+        ? []
+        : [{ setting: { ...ALWAYS, state: 'skip', line: skipPassedDown }, source: 'suite' }];
+    const all = [...own, ...passed, ...tagStates(options).map((setting) => ({ setting, source: 'config' }))];
+    const kept = isOnly || options.only ? all.filter(({ setting }) => setting.state === 'expectedToFail') : all;
+    return kept.sort((a, b) => FLAG_ORDER.indexOf(a.setting.state) - FLAG_ORDER.indexOf(b.setting.state));
+}
+/** The states the options of a test's Vitest tags set. */
+function tagStates(options) {
+    const states = [
+        [options.skip, 'skip'],
+        [options.todo, 'todo'],
+        [options.fails, 'expectedToFail'],
+    ];
+    return states.filter(([isSet]) => isSet === true).map(([, state]) => ({ ...ALWAYS, state, line: null }));
+}
 /** The scope and the scopes around it, innermost first. */
 function outward(scope) {
     const scopes = [];
@@ -30,6 +90,10 @@ function bodyNodes(fn) {
     const body = fn.body;
     return body.type === 'BlockStatement' ? body.body : [body];
 }
+/** Where a run setting of a scope is written, for a test in it: the file, or a describe. */
+function placeOf(scope) {
+    return scope.kind === 'file' ? 'file' : 'suite';
+}
 function addHooks(scopes) {
     const total = noHooks();
     for (const scope of scopes) {
@@ -56,11 +120,47 @@ function runKeys(places) {
         repeats: first('repeats') ?? null,
     };
 }
+/** A test's run settings from the file, and where each comes from: the nearest place that sets it. */
+function testRun(places) {
+    const from = (key) => places.find((place) => place.run[key] !== undefined)?.source ?? null;
+    return {
+        ...runKeys(places.map((place) => place.run)),
+        timeoutSource: from('timeout'),
+        retriesSource: from('retry'),
+        repeatsSource: from('repeats'),
+        timeoutConfigText: null,
+        retriesConfigText: null,
+        repeatsConfigText: null,
+    };
+}
+/** A test's run settings, with what the config sets where the file sets nothing. */
+function withConfig(fromFile, config) {
+    const run = { ...fromFile };
+    if (run.timeoutSource === null && config?.timeout !== undefined) {
+        run.timeout = config.timeout;
+        run.timeoutSource = 'config';
+        run.timeoutConfigText = config.timeoutText;
+    }
+    if (run.retriesSource === null && config?.retry !== undefined) {
+        run.retries = config.retry?.count ?? null;
+        run.retryDelay = config.retry?.delay ?? null;
+        run.retryCondition = config.retry?.condition ?? null;
+        run.retriesSource = 'config';
+        run.retriesConfigText = config.retryText;
+    }
+    if (run.repeatsSource === null && config?.repeats !== undefined) {
+        run.repeats = config.repeats;
+        run.repeatsSource = 'config';
+        run.repeatsConfigText = config.repeatsText;
+    }
+    return run;
+}
 /** 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),
+        config: null,
         hooks,
         suiteCount: records.suites.length,
         testCount: records.tests.length,
@@ -94,19 +194,28 @@ class RecordBuilder {
     }
     build(extraction) {
         const duplicates = this.duplicates(extraction.tests);
-        const rejecting = [
-            ...extraction.problems,
-            ...extraction.tests.flatMap((test) => test.problems),
-            ...duplicates.map((item) => item.problem),
-        ].filter((item) => REJECTS_FILE[this.options.framework].has(item.code) && item.afterLoad !== true);
-        // Each of these problems points at the code that causes it.
-        const lines = rejecting.map((item) => this.parsed.source.line(item.node.start));
+        const tags = this.options.framework === 'vitest' ? (this.options.config?.tags ?? null) : null;
+        const testProblems = extraction.tests.flatMap((test) => test.problems);
+        // With the config's tags known, what they do is in the records, unless a tag can't be worked out.
+        const isTagMissing = [...extraction.problems, ...testProblems].some((item) => item.code === 'unresolved-tag');
+        const undefinedUses = tags?.isStrict ? undefinedTags(extraction, tags) : [];
+        const problems = [
+            ...extraction.problems.filter((item) => tags === null || isTagMissing || item.code !== 'config-may-change-state'),
+            ...undefinedUses.map((use) => use.problem),
+        ];
+        const rejecting = [...problems, ...testProblems, ...duplicates.map((item) => item.problem)].filter((item) => REJECTS_FILE[this.options.framework].has(item.code) && item.code !== 'undefined-tag' && item.afterLoad !== true);
+        // Each of these problems points at the code that causes it. Vitest meets the tags in the order they are listed.
+        const firstTag = undefinedUses.find((use) => use.isSure)?.problem;
+        const lines = [...rejecting, ...(firstTag ? [firstTag] : [])].map((item) => this.parsed.source.line(item.node.start));
         if (lines.length > 0)
             this.rejectedAt = Math.min(...lines);
         const suites = extraction.suites.map((suite) => this.suite(suite));
-        const tests = extraction.tests.map((test) => this.test(test));
-        for (const item of extraction.problems)
-            this.diagnostics.push(this.diagnostic(item));
+        const tests = extraction.tests.map((test) => this.test(test, suites));
+        for (const item of problems) {
+            const found = this.diagnostic(item);
+            const isSure = undefinedUses.find((use) => use.problem === item)?.isSure ?? true;
+            this.diagnostics.push(isSure ? found : { ...found, level: 'warning' });
+        }
         for (const { index, problem: item } of duplicates) {
             this.diagnostics.push(this.diagnostic(item, tests[index].id));
         }
@@ -144,8 +253,25 @@ class RecordBuilder {
         this.ordinals.set(key, ordinal + 1);
         return shortHash(JSON.stringify([this.options.relativeFilePath, ...parts, ordinal]));
     }
+    /**
+     * Reports a `.only` that the config's `forbidOnly` makes fail the run, at `located`; one under a condition is a
+     * warning. `call` is the `.only` call when it is in this file, whose callee the diagnostic shows.
+     */
+    forbidOnly(located, call) {
+        const forbid = this.options.config?.forbidOnly ?? false;
+        if (forbid === false)
+            return;
+        const message = forbid === true
+            ? 'The config sets forbidOnly, so this .only fails the run before any test runs.'
+            : `The config sets forbidOnly when ${forbid}, so then this .only fails the run before any test runs.`;
+        const callee = call && snippet(this.parsed.source.text.slice(call.callee.start, call.callee.end));
+        const found = problem('forbidden-only', located, message, callee);
+        this.diagnostics.push(this.diagnostic(forbid === true ? found : { ...found, level: 'warning' }));
+    }
     suite(pending) {
         const { scope, declaration, call } = pending;
+        if (declaration.isOnly)
+            this.forbidOnly(pending.site ?? call, pending.site ? null : call);
         const parents = outward(scope).slice(1, -1).reverse();
         const title = declaration.title;
         // Suite ids are marked so that a describe and a test with the same title in the same place differ.
@@ -187,16 +313,47 @@ class RecordBuilder {
             ...runKeys([scope.details.run]),
         };
     }
-    test(pending) {
+    /** What the config's Vitest tags set on a test with `tags`, merged as Vitest merges them; null when none applies. */
+    tagOptions(tags) {
+        const definitions = this.options.config?.tags?.definitions ?? [];
+        const applied = tags.flatMap((name) => definitions.filter((definition) => definition.name === name));
+        if (applied.length === 0)
+            return null;
+        // Vitest applies the tags from the highest number to the lowest, so the lowest wins; a tag without one goes first.
+        const rank = ({ priority }) => priority ?? Infinity;
+        applied.sort((a, b) => rank(b) - rank(a));
+        const merged = { run: {} };
+        for (const { options } of applied) {
+            const { run, meta, ...flags } = options;
+            Object.assign(merged, flags);
+            Object.assign(merged.run, run);
+            if (meta)
+                merged.meta = { ...merged.meta, ...meta };
+        }
+        return merged;
+    }
+    test(pending, suites) {
         const { declaration } = pending;
+        const dependencies = this.options.dependencies(pending);
         // A test from an imported helper is placed at the call in this file that registers it.
         const located = pending.site ?? pending.call;
         const scopes = outward(pending.scope);
         const describes = scopes.filter((scope) => scope.kind === 'describe').reverse();
         const title = declaration.title;
         const id = this.id([this.describeTitles(describes), title.withoutTags]);
+        const fileScope = scopes[scopes.length - 1];
+        const tags = unique([
+            ...fileScope.details.tags,
+            ...describes.flatMap((scope) => scope.details.tags),
+            ...declaration.details.tags,
+        ]);
+        const fromTags = this.tagOptions(tags);
+        // In Vitest 5 the options of a test's tags win over those the describes pass down; before, the describes' win.
+        const tagsFirst = this.options.config?.tags?.beatsDescribes ?? true;
+        const tagged = (own, tag, around) => tagsFirst ? [...own, ...tag, ...around] : [...own, ...around, ...tag];
         const chosen = chooseState([
-            ...pending.states.map((setting) => ({ setting, source: 'test' })),
+            ...declaredStates(pending.states.slice(0, declaration.states.length), fromTags, declaration),
+            ...pending.states.slice(declaration.states.length).map((setting) => ({ setting, source: 'test' })),
             ...scopes.flatMap((scope) => scope.states.map((setting) => ({
                 setting,
                 source: scope.kind === 'file' ? 'file' : 'suite',
@@ -207,13 +364,14 @@ class RecordBuilder {
         const state = rejected ? 'notLoaded' : (chosen?.setting.state ?? 'active');
         const setting = rejected ? null : (chosen?.setting ?? null);
         const suitePath = describes.flatMap((scope) => suiteOf(scope).declaration.title?.text ?? []);
-        const fileScope = scopes[scopes.length - 1];
-        const mode = declaration.mode ?? scopes.find((scope) => scope.mode !== null)?.mode ?? null;
+        const tagConcurrent = this.options.config?.tags?.concurrentBeatsTags ? undefined : fromTags?.concurrent;
+        const tagMode = tagConcurrent === undefined ? null : tagConcurrent ? 'parallel' : 'default';
+        const [mode = null] = tagged([declaration.mode], [tagMode], scopes.map((scope) => scope.mode)).filter((item) => item !== null);
         const meta = {};
-        for (const values of [...describes.map((scope) => scope.details.meta), declaration.details.meta]) {
+        for (const values of [fromTags?.meta, ...describes.map((scope) => scope.details.meta), declaration.details.meta]) {
             Object.assign(meta, values);
         }
-        const isOnly = declaration.isOnly || scopes.some((scope) => scope.isOnly);
+        const isOnly = declaration.isOnly || scopes.some((scope) => scope.isOnly) || fromTags?.only === true;
         const comments = this.options.comments === 'all' || (this.options.comments === 'non-active' && state !== 'active')
             ? pending.comments
             : [];
@@ -225,15 +383,23 @@ class RecordBuilder {
             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 (declaration.isOnly)
+            this.forbidOnly(located, pending.site ? null : pending.call);
         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));
         }
-        if (declaration.isOnly && chosen && chosen.source !== 'test' && chosen.setting.state === 'skip') {
+        if ((declaration.isOnly || fromTags?.only === true) &&
+            chosen &&
+            chosen.source !== 'test' &&
+            chosen.setting.state === 'skip') {
             this.diagnostics.push(this.diagnostic(problem('only-in-skipped-describe', located, 'The test uses .only, but a describe around it is skipped, so it is skipped too.'), id));
         }
-        return {
+        const record = {
             id,
             bodyHash: declaration.hashed ? hashNodes([declaration.hashed]) : null,
+            dependencyHash: dependencies.hash,
+            dependencies: dependencies.files,
+            hasUnfollowedDependencies: !dependencies.isComplete,
             suiteId: describes.length > 0 ? this.suiteIds.get(describes[describes.length - 1]) : null,
             suitePath,
             relativeFilePath: this.options.relativeFilePath,
@@ -261,11 +427,7 @@ class RecordBuilder {
             stateLine: rejected ? this.rejectedAt : (setting?.line ?? null),
             isParallel: mode === 'parallel',
             isSerial: mode === 'serial',
-            tags: unique([
-                ...fileScope.details.tags,
-                ...describes.flatMap((scope) => scope.details.tags),
-                ...declaration.details.tags,
-            ]),
+            tags,
             annotations: [...describes.flatMap((scope) => scope.details.annotations), ...pending.annotations],
             comments,
             locks: unique([
@@ -276,11 +438,10 @@ class RecordBuilder {
             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),
+            ...testRun([
+                { run: pending.run, source: 'test' },
+                ...scopes.map((scope) => ({ run: scope.hookRun, source: placeOf(scope) })),
+                ...tagged([{ run: declaration.details.run, source: 'test' }], [{ run: fromTags?.run ?? {}, source: 'config' }], scopes.map((scope) => ({ run: scope.details.run, source: placeOf(scope) }))),
             ]),
             fixtures: unique([...declaration.fixtures, ...[...scopes].reverse().flatMap((scope) => scope.hookFixtures)]),
             expectCount: pending.expectCount,
@@ -294,6 +455,13 @@ class RecordBuilder {
             isInLoop: pending.isInLoop,
             isInCondition: pending.isInCondition,
             isInFunction: pending.isInFunction,
+            projects: null,
+        };
+        const { projects, defaults } = this.options.config?.forTest(record, suites) ?? { projects: null, defaults: null };
+        return {
+            ...withConfig(record, defaults),
+            isParallel: record.isParallel || (mode === null && defaults?.parallel === true),
+            projects,
         };
     }
     /**

package/dist/scan-file.d.ts

@@ -1,5 +1,7 @@
+import type { RunsWith } from './config-dependencies.ts';
+import { DependencyGraph, type SnapshotFiles } from './dependency-hash.ts';
 import type { ModuleReader } from './model.ts';
-import { type CommentsMode, type FileRecords } from './records.ts';
+import { type CommentsMode, type FileConfig, type FileRecords } from './records.ts';
 import type { Framework } from './types.ts';
 export interface FileSettings {
     framework: Framework;
@@ -9,6 +11,16 @@ export interface FileSettings {
     readModule: ModuleReader | null;
     /** The project root, left out of error messages so that the output has no absolute paths. */
     root: string | null;
+    /** Whether the config runs the file as a benchmark; null takes it from the file's name, as Vitest 5's default does. */
+    isBenchmarkFile?: boolean | null;
+    /** What the config the file uses sets for its tests; null without a config. */
+    config?: FileConfig | null;
+    /** Shared by the files of one scan, so that code many tests reach is read once. */
+    graph?: DependencyGraph;
+    /** What the file's config runs with each of its tests: the config, setup files and setup projects. */
+    runsWith?: RunsWith;
+    /** Reads the snapshot files tests compare against; none when one file's code is scanned. */
+    snapshotFiles?: SnapshotFiles;
 }
 export interface FileResult extends FileRecords {
     usesGlobals: boolean;

package/dist/scan-file.js

@@ -1,3 +1,4 @@
+import { DependencyGraph, fileDependencies } from "./dependency-hash.js";
 import { fileDiagnostic, toDiagnostic } from "./diagnostics.js";
 import { extract, noHooks } from "./extract.js";
 import { parseModule } from "./frameworks/bindings.js";
@@ -39,17 +40,28 @@ export function scanFile(code, relativeFilePath, settings) {
             const helper = parseModule(module);
             return helper.error ? null : frame(helper, module.relativeFilePath, settings, module.readModule);
         });
+        const isTypeTest = settings.framework === 'vitest' && TYPE_TEST.test(relativeFilePath);
+        const unfollowed = [];
+        const dependencies = fileDependencies(settings.graph ?? new DependencyGraph(), main, extraction, isTypeTest, (place) => unfollowed.push(place), settings.runsWith, settings.snapshotFiles);
         const records = buildRecords(extraction, parsed, {
             relativeFilePath,
             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),
+            isTypeTest,
+            // Vitest 5's default `benchmark.include`, when no config says.
+            isBenchmarkFile: settings.framework === 'vitest' &&
+                atLeast(settings.version, 5, 0) &&
+                (settings.isBenchmarkFile ?? BENCHMARK.test(relativeFilePath)),
+            config: settings.config ?? null,
+            dependencies,
         });
         return {
             ...records,
-            diagnostics: [...diagnostics, ...records.diagnostics],
+            diagnostics: [
+                ...diagnostics,
+                ...records.diagnostics,
+                ...unfollowed.map((place) => toDiagnostic(place.problem, place.relativeFilePath, place.source)),
+            ],
             usesGlobals: extraction.usesGlobals,
         };
     }

package/dist/scan-source.js

@@ -22,5 +22,5 @@ export function scanSource(options) {
         readModule: null,
         root: null,
     });
-    return createInventory(framework, frameworkVersion, 1, [result], []);
+    return createInventory(framework, frameworkVersion, 1, [result], [], []);
 }

package/dist/scan.d.ts

@@ -1,7 +1,8 @@
 import { type ScanOptions } from './options.ts';
 import type { Inventory } from './types.ts';
 /**
- * Scans the test files that match `patterns` under `root`, one file at a time.
+ * Scans the test files that match `patterns` under `root`, or without patterns those the configs run, one file at a
+ * time.
  *
  * Throws a `TypeError` for invalid options. Problems with files and code are reported as diagnostics.
  */