test-inventory 0.5.0 → 0.6.1

package/CHANGELOG.md

@@ -1,5 +1,108 @@
 # test-inventory
 
+## 0.6.1
+
+### Patch Changes
+
+- [#69](https://github.com/Huldoser/test-inventory/pull/69) [`41ce74d`](https://github.com/Huldoser/test-inventory/commit/41ce74d6dc5fb413ffcfa789442754a445f5572c) - An import that matches a tsconfig `paths` pattern but none of its files, as an installed package does with
+  `"paths": { "*": ["./src/types/*"] }`, now goes on to the usual lookup, as TypeScript does. Such imports were reported
+  as unreadable, so every test that used a package or a built-in module such as `node:fs` got
+  `hasUnfollowedDependencies`. An `@/` or `~/` alias whose files are missing is still reported.
+
+- [#69](https://github.com/Huldoser/test-inventory/pull/69) [`41ce74d`](https://github.com/Huldoser/test-inventory/commit/41ce74d6dc5fb413ffcfa789442754a445f5572c) - A file that only passes names on, as a barrel `index.ts` with `export * from './fees'` or
+  `export { OrderTicket } from './order-ticket'` does, is now in the `dependencies` of the tests that import through it,
+  so `--related` keeps them when the file changes. Which module a re-export points at is now part of `dependencyHash`, as
+  an import's already was, so the hash of a test that imports through a re-export changes once.
+
+- [#69](https://github.com/Huldoser/test-inventory/pull/69) [`41ce74d`](https://github.com/Huldoser/test-inventory/commit/41ce74d6dc5fb413ffcfa789442754a445f5572c) - An imported file that isn't text, such as `import logo from './logo.png'`, is now taken by its bytes in
+  `dependencyHash`. It was read as text, where every byte that isn't UTF-8 reads the same, so two different images could
+  give the same hash.
+
+- [#69](https://github.com/Huldoser/test-inventory/pull/69) [`41ce74d`](https://github.com/Huldoser/test-inventory/commit/41ce74d6dc5fb413ffcfa789442754a445f5572c) - A `<script>` block in a Vue or Svelte component whose `type` isn't JavaScript, such as
+  `<script type="application/ld+json">` in `<svelte:head>`, is no longer read as the component's code. It made the
+  component unreadable, so the modules its real script imports were missing from `dependencies`.
+
+- [#68](https://github.com/Huldoser/test-inventory/pull/68) [`fa9b97a`](https://github.com/Huldoser/test-inventory/commit/fa9b97affd5d8598dcb91f11c7fc2c5343ec5b87) - `dependencyHash` now follows what a Vue or Svelte single-file component imports, also the components and helpers only
+  its template uses, so a change to a child component changes the hash of the tests that mount its parent. A component
+  whose script doesn't parse is still taken by its text, and its tests get `hasUnfollowedDependencies`.
+
+- [#69](https://github.com/Huldoser/test-inventory/pull/69) [`41ce74d`](https://github.com/Huldoser/test-inventory/commit/41ce74d6dc5fb413ffcfa789442754a445f5572c) - A file with brackets nested more than 500 deep, such as a generated fixture, now gets a `parse-error` instead of
+  crashing the scan. oxc-parser overflows the native stack on such a file, about 5,000 deep, and the process dies with a
+  segmentation fault that no error handling can catch, so no inventory was written.
+
+- [#69](https://github.com/Huldoser/test-inventory/pull/69) [`41ce74d`](https://github.com/Huldoser/test-inventory/commit/41ce74d6dc5fb413ffcfa789442754a445f5572c) - `expectCount` now counts `expect.element()`, the assertion of Vitest browser mode, so a browser test that checks the
+  page only with `await expect.element(locator).toBeVisible()` no longer looks like a test without assertions.
+
+- [#69](https://github.com/Huldoser/test-inventory/pull/69) [`41ce74d`](https://github.com/Huldoser/test-inventory/commit/41ce74d6dc5fb413ffcfa789442754a445f5572c) - An import written with a `.jsx` extension now finds the `.tsx` file it refers to, as `.js` already found `.ts`, so
+  `import { OrderHeader } from './OrderHeader.jsx'` is followed instead of marking the test with
+  `hasUnfollowedDependencies`.
+
+- [#69](https://github.com/Huldoser/test-inventory/pull/69) [`41ce74d`](https://github.com/Huldoser/test-inventory/commit/41ce74d6dc5fb413ffcfa789442754a445f5572c) - From Playwright 1.57, the config's `tag` is now read: every test gets it first in its `tags`, and a project's `grep` or
+  `grepInvert` matches it, so a project with `grepInvert: /@nightly/` in a config with `tag: '@nightly'` no longer runs
+  the tests. When the scan can't work out the `tag`, as for `process.env.CI_ENVIRONMENT_NAME`, it gets a
+  `config-value-unknown` warning, and the tests of a project with a `grep` get `projects: null`.
+
+- [#69](https://github.com/Huldoser/test-inventory/pull/69) [`41ce74d`](https://github.com/Huldoser/test-inventory/commit/41ce74d6dc5fb413ffcfa789442754a445f5572c) - From Playwright 1.64, a project with `default: false` is no longer listed in a test's `projects`, as Playwright runs it
+  only with `--project`, unless a project that runs lists it in `dependencies` or `teardown`. A `default` the scan can't
+  work out gets a `config-value-unknown` warning, and the tests it may run get `projects: null`.
+
+- [#69](https://github.com/Huldoser/test-inventory/pull/69) [`41ce74d`](https://github.com/Huldoser/test-inventory/commit/41ce74d6dc5fb413ffcfa789442754a445f5572c) - Playwright's `defineConfig(base, config)` is now merged as Playwright merges it: a project of `config` merges into the
+  project of `base` with the same name instead of replacing all of `base`'s projects, and `expect`, `use` and `build`
+  merge key by key. A setup project from a base config is no longer lost, and an `expect.toHaveScreenshot.pathTemplate`
+  from the base still marks the tests that compare screenshots with `hasUnfollowedDependencies`.
+
+- [#69](https://github.com/Huldoser/test-inventory/pull/69) [`41ce74d`](https://github.com/Huldoser/test-inventory/commit/41ce74d6dc5fb413ffcfa789442754a445f5572c) - A Vitest `retry` object in a test's or describe's options before Vitest 4.1 now gets an `unresolved-option` warning
+  and `retries: null`. Vitest 4.0 and 3.2 never run such a test; the scan used to ignore the object and give the
+  config's retry count instead.
+
+- [#69](https://github.com/Huldoser/test-inventory/pull/69) [`41ce74d`](https://github.com/Huldoser/test-inventory/commit/41ce74d6dc5fb413ffcfa789442754a445f5572c) - A Vitest test's own `skip`, `only`, `todo` or `fails` option now replaces the one its tags set, as Vitest does, so
+  `test('title', { tags: ['flaky'], skip: false }, fn)` is active instead of skipped, and a conditional `skip` replaces
+  the tag's unconditional one.
+
+- [#69](https://github.com/Huldoser/test-inventory/pull/69) [`41ce74d`](https://github.com/Huldoser/test-inventory/commit/41ce74d6dc5fb413ffcfa789442754a445f5572c) - An import that starts with `@/` or `~/`, as a Vite `resolve.alias` allows, now gives the test
+  `hasUnfollowedDependencies` and a `dependency-not-followed` warning when no tsconfig `paths` define it. It was taken for
+  an installed package, so the aliased file was missing from `dependencies` without a sign, and `--related` left the test
+  out when that file changed.
+
+- [#69](https://github.com/Huldoser/test-inventory/pull/69) [`41ce74d`](https://github.com/Huldoser/test-inventory/commit/41ce74d6dc5fb413ffcfa789442754a445f5572c) - Vitest 5 tests follow the option rules of Vitest 5.0.5: the last of `.skip`, `skipIf()` and `runIf()` on a test
+  decides its skip, so `test.skip.skipIf(false)` is active, and a `skipIf()` or `runIf()` replaces the skip of a tag or of
+  the options a describe passes down. An option set to `undefined`, as in `test.skip('title', { skip: undefined }, fn)`,
+  no longer undoes the chain or a tag.
+
+- [#69](https://github.com/Huldoser/test-inventory/pull/69) [`41ce74d`](https://github.com/Huldoser/test-inventory/commit/41ce74d6dc5fb413ffcfa789442754a445f5572c) - In Vitest 5, the projects of a config that another config lists in `projects` are named inside that config's name, as
+  Vitest names them: the `unit` project of `apps/web/vitest.config.ts`, named `web`, is `web (unit)`.
+
+- [#69](https://github.com/Huldoser/test-inventory/pull/69) [`41ce74d`](https://github.com/Huldoser/test-inventory/commit/41ce74d6dc5fb413ffcfa789442754a445f5572c) - A Vitest project without a `test.name` now has the name Vitest gives it, in `projects` and in `configs`: the `name` in
+  the package.json of its folder, else the folder's name, so `projects: ['packages/*']` names its projects
+  `@trading/pricing` or `ledger` instead of `""`. An inline project without a name is named after its place among the
+  inline projects, as `0`, and in Vitest 5 no longer takes the name of the config it extends.
+
+## 0.6.0
+
+### Minor Changes
+
+- [#61](https://github.com/Huldoser/test-inventory/pull/61) [`926352f`](https://github.com/Huldoser/test-inventory/commit/926352fd67caf8d26e17e346b9e916400e28a4e3) - Each test now has a `dependencyHash` of everything it runs in the project, beside the unchanged `bodyHash`: its own call
+  with its options, the hooks, `test.use()` and options of its file and of every describe around it, the fixtures it,
+  those hooks, conditions and `test.use()` values ask for, with the fixtures those ask for, `auto` ones and overrides of
+  Playwright's own, through every `extend()` and `mergeTests()`, the file's other top-level code, the config and the
+  configs it builds on, setup files, global setup and teardown, the Playwright setup projects the test runs after, and the
+  snapshot files and screenshots it compares against, and the functions, classes, constants and modules all of these use,
+  followed by scope and through imports, re-exports, barrels, `require()`, `import()` and Vitest's `vi.mock()` with a
+  fixed path, with the code each module runs when it loads. A helper that declares the test is in it with the arguments of
+  the call that declares it, so two calls give two hashes. Formatting and comments don't change it, nor does moving the
+  test. Installed packages are left out, and types too, except for type tests.
+
+  `dependencies` lists the files that went into the hash. When the test reaches something the scan can't follow, a local
+  file that is missing or doesn't parse, an import with a path worked out at run time or a pattern, a value only a
+  declaration file describes, or a setup file the config names in a way the scan can't work out,
+  `hasUnfollowedDependencies` is `true` and the new `dependency-not-followed` warning says where, once per place.
+
+- [#65](https://github.com/Huldoser/test-inventory/pull/65) [`31a9bee`](https://github.com/Huldoser/test-inventory/commit/31a9beef6f2912a03c4ae70ccd797b9b40cfe3e8) - `--related <file>` and the `related` filter of `filterInventory()` keep the tests a change to a file can affect: those
+  whose `dependencies` include it, and those that reach code the scan can't follow, which a change may affect unseen.
+  `--related -` reads the files from standard input, one per line, so `git diff --name-only origin/main... | npx
+test-inventory --framework playwright --related -` lists the tests a pull request can affect. Paths are taken from the
+  current folder, as git writes them, also when `--root` is a folder in the repository.
+
 ## 0.5.0
 
 ### Minor Changes

package/dist/bin.js

@@ -2,6 +2,7 @@
 import { run } from "./cli.js";
 process.exitCode = await run(process.argv.slice(2), {
     stdout: process.stdout,
+    stdin: process.stdin,
     stderr: process.stderr,
     cwd: process.cwd(),
 });

package/dist/cli.d.ts

@@ -1,9 +1,11 @@
-import type { Writable } from 'node:stream';
+import type { Readable, Writable } from 'node:stream';
 export interface Io {
     stdout: Writable;
     stderr: Writable;
     cwd: string;
+    /** Read for `--related -`. */
+    stdin?: Readable;
 }
-export declare const HELP = "Usage: test-inventory [glob...] --framework <playwright|vitest> [options]\n\nLists the tests in the matching files as JSON, read from the source code without running them. Without globs, the\ntest files are those the Playwright or Vitest configs in the root and the folders below it run.\n\nOptions:\n  --framework <name>           playwright or vitest (required)\n  --root <dir>                 project root; paths in the output are relative to it (default: current directory)\n  --ignore <glob>              leave out matching files; can be repeated (node_modules is always left out)\n  --framework-version <x.y.z>  apply the rules of this framework version instead of the one in the project\n  --comments <mode>            comments above tests: all, non-active or none (default: non-active)\n  --state <state>              keep tests in this state, such as skip or fixme; can be repeated\n  --tag <tag>                  keep tests with this tag, such as @smoke; can be repeated\n  --grep <regex>               keep tests whose full name matches, ignoring case\n  --only                       keep tests that use .only, or are inside a describe that does\n  --without-reason             keep tests that don't run and give no reason\n  --fields <keys>              write only these keys of each test, separated by commas; id is always kept\n  --format <format>            json or jsonl, one record per line (default: json)\n  -o, --output <file>          write to a file instead of standard output\n  --pretty                     indent the JSON\n  -h, --help                   show this help\n  -v, --version                show the version\n\nExit codes: 0 when the scan finishes, even with diagnostics; 2 for invalid arguments, an output that cannot be\nwritten, or a crash. 1 is reserved for a future release.\n\nExamples:\n  test-inventory \"tests/**/*.spec.ts\" --framework playwright --output inventory.json\n  test-inventory \"tests/**/*.spec.ts\" --framework playwright --state skip --fields fullName,reason\n";
+export declare const HELP = "Usage: test-inventory [glob...] --framework <playwright|vitest> [options]\n\nLists the tests in the matching files as JSON, read from the source code without running them. Without globs, the\ntest files are those the Playwright or Vitest configs in the root and the folders below it run.\n\nOptions:\n  --framework <name>           playwright or vitest (required)\n  --root <dir>                 project root; paths in the output are relative to it (default: current directory)\n  --ignore <glob>              leave out matching files; can be repeated (node_modules is always left out)\n  --framework-version <x.y.z>  apply the rules of this framework version instead of the one in the project\n  --comments <mode>            comments above tests: all, non-active or none (default: non-active)\n  --state <state>              keep tests in this state, such as skip or fixme; can be repeated\n  --tag <tag>                  keep tests with this tag, such as @smoke; can be repeated\n  --grep <regex>               keep tests whose full name matches, ignoring case\n  --only                       keep tests that use .only, or are inside a describe that does\n  --without-reason             keep tests that don't run and give no reason\n  --related <file>             keep tests a change to this file can affect; can be repeated; - reads files, one per\n                               line, from standard input, as git diff --name-only writes them\n  --fields <keys>              write only these keys of each test, separated by commas; id is always kept\n  --format <format>            json or jsonl, one record per line (default: json)\n  -o, --output <file>          write to a file instead of standard output\n  --pretty                     indent the JSON\n  -h, --help                   show this help\n  -v, --version                show the version\n\nExit codes: 0 when the scan finishes, even with diagnostics; 2 for invalid arguments, an output that cannot be\nwritten, or a crash. 1 is reserved for a future release.\n\nExamples:\n  test-inventory \"tests/**/*.spec.ts\" --framework playwright --output inventory.json\n  test-inventory \"tests/**/*.spec.ts\" --framework playwright --state skip --fields fullName,reason\n";
 /** Runs the command line with the given arguments and streams. Resolves to the exit code. */
 export declare function run(argv: string[], io: Io): Promise<number>;

package/dist/cli.js

@@ -5,7 +5,7 @@ import { parseArgs } from 'node:util';
 import { readFailure } from "./files.js";
 import { checkFields, filterInventory, matcher, pickTestFields } from "./filter.js";
 import { writeInventory, writeInventoryLines } from "./json.js";
-import { OptionsError } from "./options.js";
+import { OptionsError, toPosixPath } from "./options.js";
 import { scan } from "./scan.js";
 import { toolVersion } from "./version.js";
 export const HELP = `Usage: test-inventory [glob...] --framework <playwright|vitest> [options]
@@ -24,6 +24,8 @@ Options:
   --grep <regex>               keep tests whose full name matches, ignoring case
   --only                       keep tests that use .only, or are inside a describe that does
   --without-reason             keep tests that don't run and give no reason
+  --related <file>             keep tests a change to this file can affect; can be repeated; - reads files, one per
+                               line, from standard input, as git diff --name-only writes them
   --fields <keys>              write only these keys of each test, separated by commas; id is always kept
   --format <format>            json or jsonl, one record per line (default: json)
   -o, --output <file>          write to a file instead of standard output
@@ -49,6 +51,7 @@ const FLAGS = {
     'filter.states': '--state',
     'filter.tags': '--tag',
     'filter.grep': '--grep',
+    'filter.related': '--related',
     fields: '--fields',
 };
 const FORMATS = ['json', 'jsonl'];
@@ -83,6 +86,13 @@ async function writeOutput(io, file, write) {
         throw error;
     }
 }
+/** All of a stream's text, as `git diff --name-only` writes to it. */
+async function text(stream) {
+    const chunks = [];
+    for await (const chunk of stream)
+        chunks.push(Buffer.from(chunk));
+    return Buffer.concat(chunks).toString('utf8');
+}
 /** ESLint's exit codes. 1 is reserved for a future release. */
 const FINISHED = 0;
 const FAILED = 2;
@@ -109,6 +119,7 @@ export async function run(argv, io) {
                 grep: { type: 'string' },
                 only: { type: 'boolean' },
                 'without-reason': { type: 'boolean' },
+                related: { type: 'string', multiple: true },
                 fields: { type: 'string' },
                 format: { type: 'string' },
                 output: { type: 'string', short: 'o' },
@@ -144,6 +155,16 @@ export async function run(argv, io) {
         only: values.only,
         withoutReason: values['without-reason'],
     };
+    const root = path.resolve(io.cwd, values.root ?? '.');
+    if (values.related) {
+        const read = values.related.includes('-') && io.stdin ? await text(io.stdin) : '';
+        const named = [
+            ...values.related.filter((file) => file !== '-'),
+            ...read.split(/\r?\n/).filter((line) => line.trim()),
+        ];
+        // Paths from the current folder, as git writes them there, to the root the output's paths start from.
+        filter.related = named.map((file) => toPosixPath(path.relative(root, path.resolve(io.cwd, file.trim()))));
+    }
     const fields = values.fields?.split(',').map((field) => field.trim());
     let inventory;
     let result;
@@ -155,7 +176,7 @@ export async function run(argv, io) {
         inventory = await scan({
             patterns: positionals.length > 0 ? positionals : undefined,
             framework: values.framework,
-            root: path.resolve(io.cwd, values.root ?? '.'),
+            root,
             ignore: values.ignore ?? [],
             frameworkVersion: values['framework-version'],
             comments: values.comments,

package/dist/config-dependencies.d.ts

@@ -0,0 +1,62 @@
+import type { ConfigRuns, Placement } from './config-runs.ts';
+import type { ModuleReader, ModuleSource, Span } from './model.ts';
+import { SourceText } from './source.ts';
+import type { Framework } from './types.ts';
+/**
+ * Something in a config the scan can't follow: where it is written, or the config and the path it names, which the
+ * warning points at.
+ */
+export type ConfigGap = {
+    message: string;
+    /** Not reported, as the config reader reports it already: the tests are only marked. */
+    isQuiet: boolean;
+} & ({
+    relativeFilePath: string;
+    source: SourceText;
+    span: Span;
+} | {
+    module: ModuleSource;
+    text: string | null;
+});
+/** What the config a file uses runs with each of its tests: modules to take whole, and what can't be followed. */
+export interface RunsWith {
+    /** The config the file uses, which builds on others through imports. */
+    config: ModuleSource | null;
+    /** Its setup files, the configs that list its project, and the files of setup projects. */
+    modules: ModuleSource[];
+    gaps: ConfigGap[];
+    /** Where the config puts snapshots elsewhere than the runner's default, which the scan doesn't follow. */
+    moved: ConfigGap | null;
+}
+/**
+ * Finds what each file's config makes its tests run besides the file: the config itself, which brings in the configs it
+ * builds on through imports, the setup files and global setup and teardown of each project that runs the file, the
+ * config that lists a Vitest project, whose global setup runs too, and for Playwright the files of the setup projects
+ * the file's projects depend on. Read once per config and set of projects.
+ */
+export declare class ConfigDependencies {
+    private readonly framework;
+    private readonly runs;
+    private readonly readerFor;
+    /** The files setup projects may run. */
+    private readonly candidates;
+    private readonly found;
+    private readonly ids;
+    constructor(framework: Framework, runs: ConfigRuns, readerFor: (fromFile: string) => ModuleReader, candidates: readonly string[]);
+    of(placement: Placement): RunsWith;
+    private idOf;
+    private read;
+    /** Whether Playwright's `snapshotDir` is the testDir of every project that runs the file, its default. */
+    private isDefault;
+    /** The first setting of the config or a project running the file that puts snapshots elsewhere; null for none. */
+    private moved;
+    /** The files of the setup projects the file's projects depend on, and the ones those depend on. */
+    private setupProjects;
+    /**
+     * A setup file a config names, found from `root` as the runners find it; null for a name that isn't a file there,
+     * which is a package, whose code is left out as installed code is.
+     */
+    private setupFile;
+    /** A file the scan reads code from, by its absolute path, as the modules a test imports are read. */
+    private module;
+}

package/dist/config-dependencies.js

@@ -0,0 +1,231 @@
+import path from 'node:path';
+import { settingAt } from "./config.js";
+import { SourceText } from "./source.js";
+const NOTHING = { config: null, modules: [], gaps: [], moved: null };
+/** The keys that put snapshots elsewhere than the runner's default, by framework. */
+const SNAPSHOT_KEYS = {
+    playwright: [
+        ['snapshotPathTemplate'],
+        ['snapshotDir'],
+        ['expect', 'toHaveScreenshot', 'pathTemplate'],
+        ['expect', 'toMatchAriaSnapshot', 'pathTemplate'],
+    ],
+    vitest: [
+        ['test', 'resolveSnapshotPath'],
+        ['test', 'snapshotEnvironment'],
+        ['test', 'browser', 'expect', 'toMatchScreenshot', 'resolveScreenshotPath'],
+        ['test', 'browser', 'expect', 'toMatchScreenshot', 'screenshotDirectory'],
+    ],
+};
+/** The keys of a config that name setup files, by framework; Vitest's are a project's own. */
+const SETUP_KEYS = {
+    playwright: [['globalSetup'], ['globalTeardown']],
+    vitest: [
+        ['test', 'setupFiles'],
+        ['test', 'globalSetup'],
+    ],
+};
+const UNKNOWN_PROJECTS = "The projects that run the file can't be worked out, so dependencyHash doesn't cover their setup.";
+/**
+ * Finds what each file's config makes its tests run besides the file: the config itself, which brings in the configs it
+ * builds on through imports, the setup files and global setup and teardown of each project that runs the file, the
+ * config that lists a Vitest project, whose global setup runs too, and for Playwright the files of the setup projects
+ * the file's projects depend on. Read once per config and set of projects.
+ */
+export class ConfigDependencies {
+    framework;
+    runs;
+    readerFor;
+    /** The files setup projects may run. */
+    candidates;
+    found = new Map();
+    ids = new Map();
+    constructor(framework, runs, readerFor, candidates) {
+        this.framework = framework;
+        this.runs = runs;
+        this.readerFor = readerFor;
+        this.candidates = candidates;
+    }
+    of(placement) {
+        const { config } = placement;
+        if (config === null)
+            return NOTHING;
+        // Projects without a name are told apart by identity, as two may have different setup.
+        const ids = (placement.projects ?? []).map((project) => this.idOf(project));
+        const key = `${config.file}\0${placement.projects === null}\0${ids.join('\0')}`;
+        let found = this.found.get(key);
+        if (!found) {
+            found = this.read(config, placement);
+            this.found.set(key, found);
+        }
+        return found;
+    }
+    idOf(project) {
+        let id = this.ids.get(project);
+        if (id === undefined) {
+            id = this.ids.size;
+            this.ids.set(project, id);
+        }
+        return id;
+    }
+    read(config, placement) {
+        const own = this.module(config.file);
+        if (!own) {
+            // The config reader reports a config it can't read.
+            const message = "The config can't be read, so dependencyHash doesn't cover it.";
+            const span = { start: 0, end: 0 };
+            const gap = { relativeFilePath: config.record.relativeFilePath, source: new SourceText(''), span, message };
+            return { config: null, modules: [], gaps: [{ ...gap, isQuiet: true }], moved: null };
+        }
+        const modules = new Set();
+        const gaps = [];
+        const places = new Set();
+        /** The setup files a key of `settings` names, found from `root`, as written in the config `module`. */
+        const setup = (module, settings, root, keys) => {
+            const key = keys.join('.');
+            const found = written(settings, keys);
+            for (const item of found ? listOf(found.setting) : []) {
+                if (item.kind === 'value' && typeof item.value === 'string') {
+                    const read = this.setupFile(root, item.value);
+                    if (read && !('reason' in read))
+                        modules.add(read);
+                    else if (read) {
+                        const message = `${key} names '${item.value}', which ${read.reason}, so dependencyHash doesn't cover it.`;
+                        gaps.push({ module, text: item.value, message, isQuiet: false });
+                    }
+                }
+                else if (item.kind === 'unknown') {
+                    const message = `${key} can't be worked out, so dependencyHash doesn't cover the files it names.`;
+                    // A Vitest 3 workspace file, which the scan doesn't read, has no place in the config.
+                    if (!item.where)
+                        gaps.push({ module, text: null, message, isQuiet: true });
+                    // One gap per place, as both setup keys may come from the same spread.
+                    else if (!places.has(item.where.node)) {
+                        places.add(item.where.node);
+                        const { frame, node } = item.where;
+                        const at = { relativeFilePath: frame.relativeFilePath, source: frame.parsed.source, span: node };
+                        gaps.push({ ...at, message, isQuiet: found.isInherited });
+                    }
+                }
+            }
+        };
+        const { projects } = placement;
+        if (projects === null)
+            gaps.push({ module: own, text: null, message: UNKNOWN_PROJECTS, isQuiet: true });
+        const folder = path.dirname(config.file);
+        if (this.framework === 'playwright') {
+            for (const keys of SETUP_KEYS.playwright)
+                setup(own, config.settings, folder, keys);
+            this.setupProjects(config, own, projects ?? [], modules, gaps);
+        }
+        else {
+            // A file no project runs still runs with the config's own setup when the runner is given it.
+            const running = projects?.length
+                ? projects
+                : [{ settings: placement.settings, root: folder, container: null }];
+            // Vitest runs the global setup of the config it starts with for every project, extending it or not.
+            setup(own, config.settings, folder, ['test', 'globalSetup']);
+            for (const project of running) {
+                // A file several projects run may be run by one from another config, which the file runs with too; the config
+                // reader has read that config, so it can be read.
+                const written = 'config' in project ? this.module(project.config.file) : own;
+                modules.add(written);
+                for (const keys of SETUP_KEYS.vitest)
+                    setup(written, project.settings, project.root, keys);
+                const { container } = project;
+                const outer = container && this.module(container.file);
+                if (container && outer) {
+                    modules.add(outer);
+                    setup(outer, container.settings, path.dirname(container.file), ['test', 'globalSetup']);
+                }
+            }
+        }
+        return { config: own, modules: [...modules], gaps, moved: this.moved(own, config, placement) };
+    }
+    /** Whether Playwright's `snapshotDir` is the testDir of every project that runs the file, its default. */
+    isDefault(config, placement, keys, found) {
+        if (keys[0] !== 'snapshotDir' || found.kind !== 'value' || typeof found.value !== 'string')
+            return false;
+        const folder = path.resolve(path.dirname(config.file), found.value);
+        const projects = placement.projects ?? [];
+        return projects.length > 0 && projects.every((project) => project.testDir === folder);
+    }
+    /** The first setting of the config or a project running the file that puts snapshots elsewhere; null for none. */
+    moved(own, config, placement) {
+        const settings = [config.settings, ...(placement.projects ?? []).map((project) => project.settings)];
+        for (const keys of SNAPSHOT_KEYS[this.framework]) {
+            for (const setting of settings) {
+                const found = settingAt(setting, keys);
+                if (found === null || this.isDefault(config, placement, keys, found))
+                    continue;
+                const message = `${keys.join('.')} puts snapshots where the scan doesn't look, so dependencyHash doesn't cover them.`;
+                if (found.kind === 'unknown' && found.where) {
+                    const { frame, node } = found.where;
+                    return {
+                        relativeFilePath: frame.relativeFilePath,
+                        source: frame.parsed.source,
+                        span: node,
+                        message,
+                        isQuiet: false,
+                    };
+                }
+                const text = found.kind === 'value' && typeof found.value === 'string' ? found.value : null;
+                return { module: own, text, message, isQuiet: false };
+            }
+        }
+        return null;
+    }
+    /** The files of the setup projects the file's projects depend on, and the ones those depend on. */
+    setupProjects(config, own, projects, modules, gaps) {
+        const names = new Set();
+        const pending = projects.flatMap((project) => project.dependencies);
+        for (let name = pending.pop(); name !== undefined; name = pending.pop()) {
+            if (names.has(name))
+                continue;
+            names.add(name);
+            const project = this.runs.projectNamed(config, name);
+            if (!project) {
+                // The config reader reports a project it can't work out.
+                const message = `The files of the setup project '${name}' can't be worked out, so dependencyHash doesn't cover them.`;
+                gaps.push({ module: own, text: null, message, isQuiet: true });
+                continue;
+            }
+            pending.push(...project.about.dependencies);
+            const files = this.candidates.filter((file) => project.runs(file)).map((file) => this.module(file));
+            for (const file of files.filter((item) => item !== null))
+                modules.add(file);
+        }
+    }
+    /**
+     * A setup file a config names, found from `root` as the runners find it; null for a name that isn't a file there,
+     * which is a package, whose code is left out as installed code is.
+     */
+    setupFile(root, file) {
+        // `path.join(__dirname, 'setup.ts')` gives an absolute path.
+        const relative = path.isAbsolute(file) ? path.relative(root, file).replaceAll('\\', '/') : file;
+        const isPath = /^\.\.?[\\/]/.test(relative);
+        const read = this.readerFor(path.join(root, 'config'))(isPath ? relative : `./${relative}`);
+        return 'reason' in read && !isPath ? null : read;
+    }
+    /** A file the scan reads code from, by its absolute path, as the modules a test imports are read. */
+    module(file) {
+        const read = this.readerFor(file)(`./${path.basename(file)}`);
+        return 'reason' in read ? null : read;
+    }
+}
+/**
+ * The setting under a path of keys, and whether it comes from an object around it that the scan can't work out
+ * rather than from the key itself; null when the config doesn't set it.
+ */
+function written(setting, keys) {
+    const found = settingAt(setting, keys);
+    if (found?.kind !== 'unknown')
+        return found && { setting: found, isInherited: false };
+    // An unknown setting is set by the object around the key when the key itself isn't written there.
+    const around = settingAt(setting, keys.slice(0, -1));
+    const isWritten = around.kind === 'object' && around.keys.get(keys.at(-1)) === found;
+    return { setting: found, isInherited: !isWritten };
+}
+function listOf(setting) {
+    return setting.kind === 'list' ? setting.items : [setting];
+}

package/dist/config-runs.d.ts

@@ -11,8 +11,18 @@ export interface ProjectAbout {
     name: string;
     testDir: string;
     dependencies: string[];
+    /** The project's settings, which its setup files are read from. */
+    settings: Setting;
+    /** The folder its setup files are found from: Vitest's root, or the config's folder. */
+    root: string;
+    /** For a Vitest project from a config another config lists, the outermost one, whose global setup runs too. */
+    container: ConfigFile | null;
+    /** The config the project is written in. */
+    config: ConfigFile;
     grep: ((title: string) => boolean) | null;
     grepRoot: string;
+    /** Whether the runner runs the project without `--project`, as Playwright's `default` decides; null when unknown. */
+    runsByDefault: boolean | null;
     defaults: ProjectDefaults;
 }
 /**
@@ -35,6 +45,8 @@ export interface Placement {
     runs: Run | false | null;
     /** The projects of the config that run the file, which a Playwright `grep` may narrow per test; null when unknown. */
     projects: ProjectAbout[] | null;
+    /** The tags Playwright's config `tag` gives every test; null when the scan can't work them out. */
+    tags: string[] | null;
 }
 /** Finds the configs a file is under and decides which one runs it, as the runner started at the root would. */
 export declare class ConfigRuns {
@@ -46,7 +58,7 @@ export declare class ConfigRuns {
     private readonly projects;
     private readonly ignoreRules;
     private readonly folderStates;
-    /** The Vitest configs whose projects are being found, to stop at one whose projects name itself. */
+    /** The Vitest configs whose projects are being found, with their names, to stop at one whose projects name itself. */
     private readonly expanding;
     constructor(configs: Configs, framework: Framework, version: [number, number] | null, findsFiles: boolean);
     /**
@@ -55,14 +67,36 @@ export declare class ConfigRuns {
      * nearest config.
      */
     placementOf(file: string): Placement;
+    private place;
+    /**
+     * Playwright's config `tag`, from 1.57, which it gives every test before its own tags; null when the scan can't work
+     * it out. That is reported where the config writes `tag`; a config whose settings come from code the scan can't
+     * follow is reported there already, as its projects can't be worked out either.
+     */
+    private configTags;
     /** The projects of a config the output lists; null when the scan can't work them out. */
     projectsIn(config: ConfigFile): ProjectRecord[] | null;
+    /**
+     * A config's project, named as the runner names it, with the files it runs; null when there is none, or the scan
+     * can't tell which files it runs.
+     */
+    projectNamed(config: ConfigFile, name: string): {
+        about: ProjectAbout;
+        runs: (file: string) => unknown;
+    } | null;
     private projectsOf;
     /** Vitest's `retry`: before 4.1, which reads only a count, an object is one the scan can't work out. */
     private vitestRetry;
     /** A project whose files can't be worked out, because of `setting` under `key`: it may run any file. */
     private unknownProject;
     private playwrightProjects;
+    /**
+     * Whether Playwright runs each project without `--project`: from 1.64, not with `default: false`, unless a project it
+     * runs lists it in `dependencies` or `teardown`, directly or through others. Null when the scan can't tell.
+     */
+    private runsByDefault;
+    /** The name of a project a Vitest config lists, with a warning when its `test.name` can't be worked out. */
+    private listedName;
     /** A Playwright project: its own settings, else the config's, else Playwright's defaults. */
     private playwrightProject;
     /**
@@ -73,17 +107,25 @@ export declare class ConfigRuns {
     /** A folder's status and the rules inside it, worked out once per project folder however many files it holds. */
     private folderState;
     private rulesIn;
+    /**
+     * The projects of a Vitest config, the one the runner starts with or, in Vitest 5, a config another lists, whose name
+     * then goes around the names of its projects.
+     */
     private vitestProjects;
-    /** A project written in `test.projects`, which inherits the root config as each version of Vitest decides. */
+    /**
+     * A project written in `test.projects`, which inherits the root config as each version of Vitest decides, named
+     * after `index` when it has no name of its own.
+     */
     private vitestEntry;
     /**
      * The projects of a config file or folder `test.projects` names: the config's own, also the projects it lists in
-     * Vitest 5, or a project with Vitest's defaults for a folder without a config.
+     * Vitest 5, or a project with Vitest's defaults for a folder without a config. Without a name, a project is named
+     * after the package.json in its folder, else the folder.
      */
     private vitestPath;
     /**
-     * A Vitest project: its files are found from `test.dir`, else `test.root` or `root`, else its folder. With browser
-     * mode on, each of `browser.instances` is a project of its own, named as Vitest names it.
+     * A Vitest project, with the name Vitest gives it: its files are found from `test.dir`, else `test.root` or `root`,
+     * else its folder. With browser mode on, each of `browser.instances` is a project of its own, named as Vitest names it.
      */
     private vitestProject;
     /** The files a Vitest project runs and its settings; `ownTags`, when set, in place of the tags in `settings`. */