test-inventory 0.6.0 → 0.6.1

package/CHANGELOG.md

@@ -1,5 +1,82 @@
 # 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

package/dist/config-runs.d.ts

@@ -21,6 +21,8 @@ export interface ProjectAbout {
     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;
 }
 /**
@@ -43,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 {
@@ -54,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);
     /**
@@ -63,6 +67,13 @@ 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;
     /**
@@ -79,6 +90,13 @@ export declare class ConfigRuns {
     /** 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;
     /**
@@ -89,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`. */

package/dist/config-runs.js

@@ -101,8 +101,8 @@ export class ConfigRuns {
     projects = new Map();
     ignoreRules = new Map();
     folderStates = new Map();
-    /** The Vitest configs whose projects are being found, to stop at one whose projects name itself. */
-    expanding = new Set();
+    /** The Vitest configs whose projects are being found, with their names, to stop at one whose projects name itself. */
+    expanding = new Map();
     constructor(configs, framework, version, findsFiles) {
         this.configs = configs;
         this.framework = framework;
@@ -115,6 +115,10 @@ export class ConfigRuns {
      * nearest config.
      */
     placementOf(file) {
+        const placement = this.place(file);
+        return { ...placement, tags: this.configTags(placement.config) };
+    }
+    place(file) {
         const around = this.configs.around(file);
         for (const config of around) {
             const running = this.projectsOf(config).flatMap((project) => {
@@ -140,6 +144,29 @@ export class ConfigRuns {
             projects: nearest ? [] : null,
         };
     }
+    /**
+     * 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.
+     */
+    configTags(config) {
+        if (config === null || this.framework !== 'playwright' || !atLeast(this.version, 1, 57))
+            return [];
+        const setting = settingAt(config.settings, ['tag']);
+        if (setting === null || isUnset(setting))
+            return [];
+        const tags = [];
+        for (const item of setting.kind === 'list' ? setting.items : [setting]) {
+            if (item.kind !== 'value' || typeof item.value !== 'string') {
+                if (config.settings.kind === 'object' && config.settings.keys.has('tag')) {
+                    this.configs.reportUnknown(unknownAt(item), 'tag', "the tests' tags leave it out");
+                }
+                return null;
+            }
+            tags.push(item.value);
+        }
+        return tags;
+    }
     /** The projects of a config the output lists; null when the scan can't work them out. */
     projectsIn(config) {
         const projects = this.projectsOf(config);
@@ -183,6 +210,7 @@ export class ConfigRuns {
             config,
             grep: null,
             grepRoot: '',
+            runsByDefault: true,
             defaults: NO_DEFAULTS,
         };
         return { config, settings: setting, about, runs: null, unknown: { setting, key } };
@@ -192,10 +220,68 @@ export class ConfigRuns {
         if (list?.kind === 'unknown')
             return [this.unknownProject(config, list, 'projects')];
         const items = list?.kind === 'list' ? list.items : [emptySettings()];
-        return items.map((project) => this.playwrightProject(config, project));
+        const running = this.runsByDefault(config, items);
+        return items.map((project) => this.playwrightProject(config, project, running.get(project)));
+    }
+    /**
+     * 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.
+     */
+    runsByDefault(config, projects) {
+        const isRead = atLeast(this.version, 1, 64);
+        const runs = new Map(projects.map((project) => [project, !isRead]));
+        const names = projects.map((project) => playwrightName(config, project));
+        const visit = (project, value) => {
+            const current = runs.get(project);
+            if (current === true || current === value)
+                return;
+            runs.set(project, value);
+            const teardown = settingAt(project, ['teardown']);
+            const dependencies = settingAt(project, ['dependencies']);
+            const needed = strings(dependencies);
+            if (teardown?.kind === 'value' && typeof teardown.value === 'string')
+                needed.push(teardown.value);
+            // A list the scan can't work out may name any project, which then may run.
+            const unknowns = [teardown, dependencies, ...(dependencies?.kind === 'list' ? dependencies.items : [])].filter((setting) => setting?.kind === 'unknown');
+            for (const unknown of unknowns) {
+                this.configs.reportUnknown(unknown, 'projects dependencies', "the scan can't tell which projects run the tests");
+            }
+            for (const [index, other] of projects.entries()) {
+                if (needed.includes(names[index]))
+                    visit(other, value);
+                else if (unknowns.length > 0)
+                    visit(other, null);
+            }
+        };
+        // The projects that surely run go first, so that what they pull in is sure to run too.
+        for (const value of isRead ? [true, null] : []) {
+            for (const project of projects) {
+                const setting = settingAt(project, ['default']);
+                const seed = setting?.kind === 'unknown' ? null : !(setting?.kind === 'value' && setting.value === false);
+                if (seed !== value)
+                    continue;
+                if (seed === null && project.kind !== 'unknown') {
+                    this.configs.reportUnknown(setting, 'projects default', "the scan can't tell which projects run the tests");
+                }
+                visit(project, value);
+            }
+        }
+        return runs;
+    }
+    /** The name of a project a Vitest config lists, with a warning when its `test.name` can't be worked out. */
+    listedName(settings, fallback, container) {
+        const name = settingAt(settings, ['test', 'name']);
+        const label = name?.kind === 'object' ? settingAt(name, ['label']) : name;
+        // Only a name written in a config the scan reads; a config it can't read is reported as a whole.
+        const holder = name?.kind === 'object' ? name : settingAt(settings, ['test']);
+        const isWritten = holder?.kind === 'object' && [...holder.keys.values()].includes(label);
+        if (label?.kind === 'unknown' && isWritten) {
+            this.configs.reportUnknown(label, 'test.name', 'the project is named after its folder or its place in the list');
+        }
+        return vitestName(settings, fallback, container);
     }
     /** A Playwright project: its own settings, else the config's, else Playwright's defaults. */
-    playwrightProject(config, project) {
+    playwrightProject(config, project, runsByDefault) {
         if (project.kind === 'unknown')
             return this.unknownProject(config, project, 'projects');
         const take = (key) => {
@@ -249,12 +335,11 @@ export class ConfigRuns {
             greps.push((title) => expressions.some((expression) => matches(expression, title)));
         }
         const [isGrepped, isInverted] = greps;
-        const name = take('name');
         const dependencies = settingAt(project, ['dependencies']);
         // Playwright's root folder: the config's testDir, the start of each test's grep title.
         const configDir = settingAt(config.settings, ['testDir']);
         const about = {
-            name: name?.setting.kind === 'value' && typeof name.setting.value === 'string' ? name.setting.value : '',
+            name: playwrightName(config, project),
             testDir: root,
             dependencies: strings(dependencies),
             // A project's own keys, as `snapshotPathTemplate`; the config's apply to every project, and are read there.
@@ -268,6 +353,7 @@ export class ConfigRuns {
             grepRoot: configDir?.kind === 'value' && typeof configDir.value === 'string'
                 ? path.resolve(folder, configDir.value)
                 : folder,
+            runsByDefault,
             defaults: {
                 timeout: take('timeout')?.setting ?? null,
                 retry: take('retries')?.setting ?? null,
@@ -283,7 +369,7 @@ export class ConfigRuns {
             about,
             unknown: null,
             runs: (file) => {
-                if (!isInside(root, file))
+                if (runsByDefault === false || !isInside(root, file))
                     return false;
                 if (isIgnored(file) || !isMatch(file))
                     return false;
@@ -343,7 +429,11 @@ export class ConfigRuns {
         }
         return rules;
     }
-    vitestProjects(config) {
+    /**
+     * 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.
+     */
+    vitestProjects(config, container = null) {
         const folder = path.dirname(config.file);
         const list = settingAt(config.settings, ['test', 'projects']);
         const isVitest3 = this.version !== null && this.version[0] < 4;
@@ -354,12 +444,15 @@ export class ConfigRuns {
             // Vitest 3 takes its projects from a workspace file, which the scan doesn't read.
             return [this.unknownProject(config, { kind: 'unknown', where: null }, 'test.projects')];
         }
+        const name = container ?? vitestName(config.settings, '', null);
         if (list === null)
-            return this.vitestProject(config, config.settings, folder, null);
+            return this.vitestProject(config, config.settings, folder, null, name);
         if (list.kind !== 'list')
             return [this.unknownProject(config, unknownAt(list), 'test.projects')];
-        this.expanding.add(config);
+        this.expanding.set(config, name);
         const globs = [];
+        // Vitest names an inline project without a name after its place among the entries that aren't paths.
+        let index = 0;
         const projects = list.items.flatMap((item) => {
             if (item.kind === 'value' && typeof item.value === 'string') {
                 // `<rootDir>` is the config's folder, written with / as globs are.
@@ -368,10 +461,10 @@ export class ConfigRuns {
                 if (pattern.startsWith('!') || picomatch.scan(pattern).isGlob)
                     globs.push(pattern);
                 else
-                    return this.vitestPath(config, path.resolve(folder, pattern));
+                    return this.vitestPath(config, path.resolve(folder, pattern), container);
                 return [];
             }
-            return this.vitestEntry(config, item, folder);
+            return this.vitestEntry(config, item, folder, String(index++), container);
         });
         const matches = globs.length
             ? globSync(globs, {
@@ -383,12 +476,15 @@ export class ConfigRuns {
                 ignore: ['**/node_modules/**'],
             })
             : [];
-        projects.push(...matches.flatMap((match) => this.vitestPath(config, path.resolve(match))));
+        projects.push(...matches.flatMap((match) => this.vitestPath(config, path.resolve(match), container)));
         this.expanding.delete(config);
         return projects;
     }
-    /** A project written in `test.projects`, which inherits the root config as each version of Vitest decides. */
-    vitestEntry(config, entry, folder) {
+    /**
+     * 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.
+     */
+    vitestEntry(config, entry, folder, index, container) {
         if (entry.kind !== 'object') {
             // A function or a promise, read by running the config, or a setting of the wrong type.
             return [this.unknownProject(config, unknownAt(entry), 'test.projects')];
@@ -401,31 +497,40 @@ export class ConfigRuns {
         else if (extended?.kind === 'value' ? extended.value === true : this.version === null || this.version[0] >= 5) {
             base = withoutProjects(config.settings);
         }
-        // Vitest 5 takes a project's own tags in place of those it extends.
-        const ownTags = atLeast(this.version, 5, 0) ? settingAt(entry, ['test', 'tags']) : null;
-        return this.vitestProject(config, mergeDeep(base, entry), folder, ownTags);
+        const isVitest5 = atLeast(this.version, 5, 0);
+        // Vitest 5 takes a project's own tags in place of those it extends, and doesn't pass on the name.
+        const ownTags = isVitest5 ? settingAt(entry, ['test', 'tags']) : null;
+        const settings = mergeDeep(base, entry);
+        const name = this.listedName(isVitest5 ? entry : settings, index, container);
+        return this.vitestProject(config, settings, folder, ownTags, name);
     }
     /**
      * 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.
      */
-    vitestPath(config, target) {
+    vitestPath(config, target, container) {
         const nested = VITEST_CONFIG.test(path.basename(target)) ? this.configs.at(target) : this.configs.inFolder(target);
+        const folder = nested ? path.dirname(nested.file) : target;
+        // A config that lists itself also runs as a project, under its own name.
+        const listing = nested && this.expanding.get(nested);
+        const fallback = packageName(folder) ?? path.basename(folder);
+        const name = listing ?? this.listedName(nested?.settings ?? emptySettings(), fallback, container);
         if (!nested)
-            return this.vitestProject(config, emptySettings(), target, null);
-        const isContainer = (this.version === null || this.version[0] >= 5) && !this.expanding.has(nested);
+            return this.vitestProject(config, emptySettings(), target, null, name);
+        const isContainer = (this.version === null || this.version[0] >= 5) && listing === undefined;
         const projects = isContainer && settingAt(nested.settings, ['test', 'projects'])
-            ? this.vitestProjects(nested)
-            : this.vitestProject(nested, nested.settings, path.dirname(nested.file), null);
+            ? this.vitestProjects(nested, name)
+            : this.vitestProject(nested, nested.settings, folder, null, name);
         // The outermost config lists the others, so it is set last.
         return projects.map((project) => ({ ...project, about: { ...project.about, container: config } }));
     }
     /**
-     * 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.
      */
-    vitestProject(config, settings, folder, ownTags) {
-        const project = this.vitestFiles(config, settings, folder, ownTags);
+    vitestProject(config, settings, folder, ownTags, name) {
+        const project = this.vitestFiles(config, settings, folder, ownTags, name);
         if (project.unknown)
             return [project];
         const enabled = settingAt(settings, ['test', 'browser', 'enabled']);
@@ -448,7 +553,7 @@ export class ConfigRuns {
         });
     }
     /** The files a Vitest project runs and its settings; `ownTags`, when set, in place of the tags in `settings`. */
-    vitestFiles(config, settings, folder, ownTags) {
+    vitestFiles(config, settings, folder, ownTags, name) {
         let root = folder;
         let dir = null;
         let hasTestRoot = false;
@@ -500,10 +605,8 @@ export class ConfigRuns {
             flags.push(setting?.kind === 'value' && setting.value === true);
         }
         const [checksTypes, onlyTypes] = flags;
-        const name = settingAt(settings, ['test', 'name']);
-        const label = name?.kind === 'object' ? settingAt(name, ['label']) : name;
         const about = {
-            name: label?.kind === 'value' && typeof label.value === 'string' ? label.value : '',
+            name,
             testDir: base,
             dependencies: [],
             settings,
@@ -512,6 +615,7 @@ export class ConfigRuns {
             config,
             grep: null,
             grepRoot: base,
+            runsByDefault: true,
             defaults: {
                 timeout: settingAt(settings, ['test', 'testTimeout']),
                 retry: this.vitestRetry(settingAt(settings, ['test', 'retry'])),
@@ -548,12 +652,41 @@ function matches(expression, text) {
     expression.lastIndex = 0;
     return expression.test(text);
 }
+/** A Playwright project's name: its own, else the config's, else empty. */
+function playwrightName(config, project) {
+    for (const setting of [settingAt(project, ['name']), settingAt(config.settings, ['name'])]) {
+        if (setting && !isUnset(setting)) {
+            return setting.kind === 'value' && typeof setting.value === 'string' ? setting.value : '';
+        }
+    }
+    return '';
+}
 /** The strings of a list setting, such as Playwright's `dependencies`; none for anything else. */
+/**
+ * A Vitest project's name: its `test.name`, or the name's `label`, else `fallback`; in Vitest 5, inside the name of the
+ * config that lists it, as `web (unit)`.
+ */
+function vitestName(settings, fallback, container) {
+    const name = settingAt(settings, ['test', 'name']);
+    const label = name?.kind === 'object' ? settingAt(name, ['label']) : name;
+    const own = (label?.kind === 'value' && typeof label.value === 'string' && label.value) || fallback;
+    return container === null ? own : `${container} (${own})`;
+}
 function strings(setting) {
     if (setting?.kind !== 'list')
         return [];
     return setting.items.flatMap((item) => (item.kind === 'value' && typeof item.value === 'string' ? [item.value] : []));
 }
+/** The `name` of the package.json in a folder; null without one, or when it has none. */
+function packageName(folder) {
+    try {
+        const { name } = JSON.parse(readFileSync(path.join(folder, 'package.json'), 'utf8'));
+        return typeof name === 'string' && name !== '' ? name : null;
+    }
+    catch {
+        return null;
+    }
+}
 /** A setting written as `undefined`, which the runners take as not set. */
 function isUnset(setting) {
     return setting.kind === 'value' && setting.value === undefined;
@@ -603,20 +736,26 @@ function folders(relative) {
  * The projects that run a test: those that run its file, less those whose Playwright `grep` or `grepInvert` leaves its
  * title out, matched as Playwright matches it, against the project's name, the file's path from the config's root
  * folder, the titles of the describes and the test and their tags. Null when a `grep` meets a title the scan can't work
- * out.
+ * out, or the test is in a project the scan can't tell runs.
  */
-function projectsRunning(projects, test, suites, file) {
+function projectsRunning(projects, test, suites, file, configTags) {
     const titles = [...test.suitePath, test.title];
-    const isDynamic = test.hasDynamicTitle || suites.some((suite) => suite.hasDynamicTitle && test.suitePath.includes(suite.title));
-    // Tags written into a title are in its text already; Playwright adds the others after it.
-    const tags = test.tags.filter((tag) => !titles.some((title) => title.includes(tag)));
+    const isDynamic = test.hasDynamicTitle ||
+        configTags === null ||
+        suites.some((suite) => suite.hasDynamicTitle && test.suitePath.includes(suite.title));
+    // Tags written into a title are in its text already; Playwright adds the config's after the file, the others after it.
+    const tags = test.tags.filter((tag) => !configTags?.includes(tag) && !titles.some((title) => title.includes(tag)));
     const running = [];
     for (const project of projects) {
         const { name, grep, grepRoot } = project;
         if (grep && isDynamic)
             return null;
-        if (!grep || grep([name, path.relative(grepRoot, file), ...titles, ...tags].join(' ')))
-            running.push(project);
+        const text = [name, path.relative(grepRoot, file), ...(configTags ?? []), ...titles, ...tags].join(' ');
+        if (grep && !grep(text))
+            continue;
+        if (project.runsByDefault === null)
+            return null;
+        running.push(project);
     }
     return running;
 }
@@ -782,7 +921,7 @@ export function fileConfig(placement, framework, version, file) {
     if (config === null) {
         // Without a config, Vitest defines no tags and keeps strictTags on.
         const tags = vitestTags(null, null, null, atLeast(version, 5, 0));
-        return framework === 'vitest' ? { forbidOnly: false, forTest: () => NO_CONFIG, tags } : null;
+        return framework === 'vitest' ? { forbidOnly: false, forTest: () => NO_CONFIG, tags, configTags: [] } : null;
     }
     const forbidOnly = framework === 'playwright' ? settingAt(config.settings, ['forbidOnly']) : null;
     return {
@@ -792,11 +931,12 @@ export function fileConfig(placement, framework, version, file) {
         forTest(test, suites) {
             if (projects === null)
                 return { projects: null, defaults: UNKNOWN_DEFAULTS };
-            const running = projectsRunning(projects, test, suites, file);
+            const running = projectsRunning(projects, test, suites, file, placement.tags);
             // A grep the scan can't match leaves the projects that run the file, which may still agree.
             return { projects: running?.map(({ name }) => name) ?? null, defaults: configDefaults(running ?? projects) };
         },
         tags: agreedTags(projects),
+        configTags: placement.tags ?? [],
     };
 }
 /** The tags the projects that run a file define, when they all define the same; null otherwise. */