@useblacksmith/vitest 0.3.0 → 0.5.0

package/README.md

@@ -59,11 +59,11 @@ The plugin uses Vitest's dependency tracking: each run records which modules and
 |---|---|---|
 | `runAllTests` | `false` | Run every test instead of the affected selection. |
 | `shadow` | `false` | Run every test, but log what the affected selection would have run and which failing test files it would have skipped, i.e. failures the selection would have missed. Use it to evaluate the plugin on a repo before relying on the selection. |
-| `dependencies` | `{}` | Dependencies the tracking cannot see, as globs of test files mapped to the glob(s) of the files they depend on, relative to the config root: `{ 'tests/**/*.spec.ts': 'fixtures/**' }`. A change to a matching file reruns the mapped tests. |
+| `dependencies` | `{}` | Dependencies the tracking cannot see, as globs of test files mapped to the glob(s) of the files they depend on, relative to the config root (`../shared/**` reaches outside a package): `{ 'tests/**/*.spec.ts': 'fixtures/**' }`. A change to a matching file reruns the mapped tests; a glob that matches no file in the repository warns. |
 
 ## Caveats
 
-- **Only dependencies in the test process are tracked.** `import`, `require`, and `fs` are automatically tracked. Files read from a child process, `globalSetup`, or outside of node are not; declare them with the `dependencies` option.
+- **Only dependencies the test reaches through node are tracked.** `import`, `require`, and `fs` are tracked automatically, in the test process, in every node process it starts through `child_process` and in every `worker_threads` worker (each gets a preloaded recorder; their own children inherit it). A child or worker records what it has loaded as it goes, so one the test kills or terminates still counts, up to the end of its test file. For any child, the command and the arguments that name files are recorded too. A child started with `env: { ..., NODE_OPTIONS: undefined }`, or a worker with `env: SHARE_ENV`, gets no recorder, only its command line. Files read by `globalSetup`, by non-node programs, or build outputs a child runs in place of their sources are not; declare them with the `dependencies` option. In browser mode, vitest itself reports nothing, so the plugin records the modules the browser loaded from the project's Vite module graph instead; files a browser test fetches at run time are not tracked.
 - **Shards must be stable for maximal efficacy.** The plugin assigns test files to shards by a hash of their path, so a file stays in its shard as others are added or removed. A custom `test.sequence.sequencer` is honoured, but every test that moves to another shard reruns there.
 
 ## Development

package/dist/affected.d.ts

@@ -1,14 +1,15 @@
-import { BloomFilter } from './bloom.js';
 import type { Reporter, TestModule, TestRunEndReason, TestSpecification, VCSProvider, VCSProviderOptions, Vitest } from 'vitest/node';
 import { type Tree } from './git.js';
 export declare const SNAPSHOT_FILE = "blacksmith.json";
-declare const SNAPSHOT_VERSION = 4;
+declare const SNAPSHOT_VERSION = 6;
 /** A `dependencies` entry, compiled: test files matching `tests` depend on files matching `deps`; both root-relative. */
 export interface DependencyRule {
+    /** The `tests` glob as written, for messages. */
+    source: string;
     tests: (file: string) => boolean;
     deps: (file: string) => boolean;
 }
-export declare function compileDependencies(dependencies: Readonly<Record<string, string | readonly string[]>> | undefined): DependencyRule[];
+export declare function compileDependencies(dependencies: Readonly<Record<string, string | readonly string[]>> | undefined, root: string): DependencyRule[];
 export interface Shard {
     index: number;
     count: number;
@@ -19,17 +20,22 @@ export interface Shard {
  */
 export interface Snapshot {
     version: typeof SNAPSHOT_VERSION;
+    /** Node major, platform and arch the run was made on; another one does not share its skips. */
+    runtime: string;
     head: string;
+    /** Vitest's root relative to the repository, so one package's snapshot never vouches for another's. */
+    root: string;
     shard: Shard | null;
     /** Names of the projects the run covered (`--project` narrows them). */
     projects: string[];
     tree: Tree;
-    /** Repo-relative test files the run covered: ran, or deselected by our provider as unchanged. A test outside this set reruns whatever its record says. */
-    tests: BloomFilter;
+    /** Repo-relative test files the run vouches for, sorted: passed, or deselected by our provider as unchanged. A test outside this set (never run, failed, interrupted) reruns whatever its record says. */
+    tests: string[];
 }
 /**
- * `blacksmith.json`, or `blacksmith.<hash>.json` when `--project` narrowed the
- * run: invocations covering different project sets keep separate anchors.
+ * `blacksmith.json`, or `blacksmith[.<hash>][.<i>of<n>].json` when `--project`
+ * narrowed the run or `--shard` split it: invocations covering different
+ * project sets or shards keep separate anchors, as their cache keys do.
  */
 export declare function snapshotPath(vitest: Vitest, dir: string): string;
 /**
@@ -52,6 +58,13 @@ export declare class TreeSnapshotProvider implements VCSProvider {
     deselected: Set<string>;
     /** The plugin's `dependencies` option, compiled. */
     dependencies: DependencyRule[];
+    /**
+     * Paths whose content differs from the snapshot's. A path the snapshot did
+     * not anchor (a later run recorded it, or a file it imported was recorded
+     * after another shard's run) is a change only if it was not tracked with
+     * the same blob at the snapshot's commit.
+     */
+    private changedSince;
     findChangedFiles(options: VCSProviderOptions): Promise<string[]>;
     /**
      * Changed files to hand vitest, or `null` when every test of the shard has
@@ -107,10 +120,15 @@ export declare class SnapshotRecorder implements Reporter {
     private activeProvider;
     onInit(vitest: Vitest): void;
     onTestRunStart(specifications: ReadonlyArray<TestSpecification>): void;
-    onTestRunEnd(modules: ReadonlyArray<TestModule>, _errors: ReadonlyArray<unknown>, reason: TestRunEndReason): Promise<void>;
+    onTestModuleEnd(module: TestModule): void;
+    onTestRunEnd(modules: ReadonlyArray<TestModule>, errors: ReadonlyArray<unknown>, reason: TestRunEndReason): Promise<void>;
     /** Puts the record and this anchor in the Actions cache when a run can reach it. */
     private publish;
-    /** The tests this shard owns, when every one of them ran or was deselected by our own provider; `null` when the run covered less. */
+    /**
+     * The tests this shard owns, split into those the run vouches for (passed,
+     * or deselected by our own provider) and those `left` out (failed, or never
+     * reached); `null` when the run covered less than the shard.
+     */
     private coveredTests;
 }
 /**

package/dist/affected.js

@@ -4,18 +4,29 @@ import { mkdir, mkdtemp, readFile, rename, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import picomatch from 'picomatch';
-import { BloomFilter } from './bloom.js';
-import { cacheKey, ENV_CACHE_URL, restoreBundle, saveBundle } from './cache.js';
-import { anchorTree, diffTrees, headSha, knownPaths, lockfilePaths, repoRoot, } from './git.js';
+import { recordBrowserDependencies } from './browser.js';
+import { cacheKey, ENV_CACHE_URL, restoreBundle, runtimeId, saveBundle, } from './cache.js';
+import { anchorTree, blobsAt, diffTrees, headSha, knownPaths, lockfilePaths, repoRoot, } from './git.js';
 import { shardOwner } from './sequencer.js';
 export const SNAPSHOT_FILE = 'blacksmith.json';
 // Bumped whenever the snapshot's shape changes or the records an anchor
 // vouches for gain a kind of dependency, so an older snapshot is not trusted.
-const SNAPSHOT_VERSION = 4;
-export function compileDependencies(dependencies) {
+const SNAPSHOT_VERSION = 6;
+/**
+ * A glob written as a path from the root (`../../packages/*\/package.json`
+ * from `packages/a`) in the form candidates take, `../*\/package.json`:
+ * `path.relative` folds the `..` segments the same way for both.
+ */
+function normalizeGlob(root, glob) {
+    if (!/^\.\.?\//.test(glob))
+        return glob;
+    return rootRelative(root, path.resolve(root, glob));
+}
+export function compileDependencies(dependencies, root) {
     return Object.entries(dependencies ?? {}).map(([tests, deps]) => ({
-        tests: picomatch(tests, { dot: true }),
-        deps: picomatch(typeof deps === 'string' ? deps : [...deps], { dot: true }),
+        source: tests,
+        tests: picomatch(normalizeGlob(root, tests), { dot: true }),
+        deps: picomatch((typeof deps === 'string' ? [deps] : [...deps]).map((glob) => normalizeGlob(root, glob)), { dot: true }),
     }));
 }
 /** `file` relative to the config root with `/` separators, the form the `dependencies` globs match. */
@@ -33,19 +44,66 @@ const LOCKFILES = new Set([
     'bun.lock',
     'bun.lockb',
 ]);
+/**
+ * Package manifests and TypeScript configs on the way up from a recorded
+ * file to the repository root: `exports`, `imports`, `type`, `paths` and the
+ * like change what a module resolves to without any recorded file changing.
+ */
+function isManifest(file) {
+    const base = path.basename(file);
+    return base === 'package.json' || /^tsconfig(\..+)?\.json$/.test(base);
+}
+/**
+ * The workflow file running this job, when it lives in this repository. Its
+ * `matrix`, `env` and steps shape every test, so a change to it runs them all.
+ */
+function workflowPath() {
+    const ref = process.env.GITHUB_WORKFLOW_REF;
+    const repository = process.env.GITHUB_REPOSITORY;
+    if (!ref || !repository || !ref.startsWith(`${repository}/`))
+        return null;
+    const file = ref.slice(repository.length + 1).split('@')[0] ?? '';
+    return file.startsWith('.github/workflows/') ? file : null;
+}
+/** `dir` and every parent up to the repository root, repo-relative ('' for the root). */
+function ancestors(dir) {
+    const result = [];
+    for (let current = dir;;) {
+        if (current === '.' || current === '') {
+            result.push('');
+            return result;
+        }
+        result.push(current);
+        const parent = path.dirname(current);
+        if (parent === current)
+            return result;
+        current = parent;
+    }
+}
+function repoDir(file) {
+    const dir = path.dirname(file);
+    return dir === '.' ? '' : dir;
+}
 function projectNames(vitest) {
     return vitest.projects.map((project) => project.name).sort();
 }
 /**
- * `blacksmith.json`, or `blacksmith.<hash>.json` when `--project` narrowed the
- * run: invocations covering different project sets keep separate anchors.
+ * `blacksmith.json`, or `blacksmith[.<hash>][.<i>of<n>].json` when `--project`
+ * narrowed the run or `--shard` split it: invocations covering different
+ * project sets or shards keep separate anchors, as their cache keys do.
  */
 export function snapshotPath(vitest, dir) {
-    const filtered = vitest.config.project.length > 0;
-    const name = filtered
-        ? SNAPSHOT_FILE.replace('.json', `.${createHash('sha1').update(projectNames(vitest).join('\n')).digest('hex').slice(0, 12)}.json`)
-        : SNAPSHOT_FILE;
-    return path.join(dir, name);
+    const parts = [SNAPSHOT_FILE.replace('.json', '')];
+    if (vitest.config.project.length > 0) {
+        parts.push(createHash('sha1')
+            .update(projectNames(vitest).join('\n'))
+            .digest('hex')
+            .slice(0, 12));
+    }
+    const { shard } = vitest.config;
+    if (shard)
+        parts.push(`${shard.index}of${shard.count}`);
+    return path.join(dir, `${parts.join('.')}.json`);
 }
 /** Vitest's `dependencies.json`, or `null` before the first recorded run. */
 async function readRecords(vitest, dir) {
@@ -85,27 +143,105 @@ async function recordedDependencies(vitest, dir) {
  * those, so the anchor is the only way a change to them is seen).
  */
 async function anchoredPaths(vitest, repo, dir, rules) {
-    const paths = new Set(await lockfilePaths(repo, LOCKFILES));
-    if (rules.length > 0) {
-        for (const file of await knownPaths(repo)) {
-            const fromRoot = rootRelative(vitest.config.root, path.join(repo, file));
-            if (rules.some((rule) => rule.deps(fromRoot)))
-                paths.add(file);
-        }
-    }
+    const paths = new Set();
+    const workflow = workflowPath();
+    if (workflow)
+        paths.add(workflow);
     const records = await readRecords(vitest, dir);
+    const dirs = new Set();
     for (const project of Object.values(records?.projects ?? {})) {
         // Vitest records every project's paths relative to the root config's root.
         const root = vitest.config.root;
-        for (const module of project.modules) {
-            paths.add(repoRelative(repo, path.resolve(root, module)));
-        }
-        for (const test of Object.keys(project.files)) {
-            paths.add(repoRelative(repo, path.resolve(root, test)));
+        for (const file of [...project.modules, ...Object.keys(project.files)]) {
+            const relative = repoRelative(repo, path.resolve(root, file));
+            paths.add(relative);
+            // Outside the repository (`..`, or another drive on Windows): no manifest above it is ours.
+            if (relative.startsWith('..') || path.isAbsolute(relative))
+                continue;
+            for (const dir of ancestors(repoDir(relative)))
+                dirs.add(dir);
         }
     }
+    // A lockfile pins what the tests below it resolve; a vendored repo's or a
+    // fixture's lockfile pins nothing a test loads.
+    for (const file of await lockfilePaths(repo, LOCKFILES)) {
+        if (dirs.has(repoDir(file)))
+            paths.add(file);
+    }
+    const matched = rules.map(() => 0);
+    for (const file of await knownPaths(repo)) {
+        const fromRoot = rootRelative(vitest.config.root, path.join(repo, file));
+        let byRule = false;
+        rules.forEach((rule, index) => {
+            if (!rule.deps(fromRoot))
+                return;
+            matched[index] = (matched[index] ?? 0) + 1;
+            byRule = true;
+        });
+        if (byRule)
+            paths.add(file);
+        else if (isManifest(file) && dirs.has(repoDir(file)))
+            paths.add(file);
+    }
+    rules.forEach((rule, index) => {
+        if (matched[index] === 0) {
+            vitest.logger.warn(`[blacksmith] dependencies["${rule.source}"] matches no file in the repository; globs are relative to ${vitest.config.root}`);
+        }
+    });
     return [...paths];
 }
+/**
+ * Rewrites vitest's `dependencies.json` without the modules outside the
+ * repository (the anchor cannot cover them) and without tests that no longer
+ * exist, renumbering what the remaining records point to. Vitest only ever
+ * appends, so a record otherwise grows by every temp file a run touched.
+ */
+async function pruneRecords(vitest, repo, dir) {
+    const records = await readRecords(vitest, dir);
+    if (!records)
+        return;
+    const root = vitest.config.root;
+    for (const project of Object.values(records.projects ?? {})) {
+        const keep = new Map();
+        const modules = [];
+        const renumber = (record) => {
+            record.deps = [
+                ...new Set(record.deps.flatMap((index) => {
+                    const module = project.modules[index];
+                    if (module === undefined)
+                        return [];
+                    const absolute = path.resolve(root, module);
+                    if (repoRelative(repo, absolute).startsWith('..') ||
+                        path.isAbsolute(repoRelative(repo, absolute))) {
+                        return [];
+                    }
+                    let next = keep.get(index);
+                    if (next === undefined) {
+                        next = modules.push(module) - 1;
+                        keep.set(index, next);
+                    }
+                    return [next];
+                })),
+            ];
+        };
+        for (const [test, record] of Object.entries(project.files)) {
+            if (!existsSync(path.resolve(root, test))) {
+                delete project.files[test];
+                continue;
+            }
+            renumber(record);
+        }
+        if (project.config)
+            renumber(project.config);
+        if (project.globalSetup)
+            renumber(project.globalSetup);
+        project.modules = modules;
+    }
+    const file = path.join(dir, 'dependencies.json');
+    const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(tmp, JSON.stringify(records));
+    await rename(tmp, file);
+}
 function sameShard(a, b) {
     if (a === null)
         return b === undefined;
@@ -138,24 +274,28 @@ async function readSnapshot(file) {
     }
     if (typeof parsed !== 'object' || parsed === null)
         return null;
-    const { version, head, shard, projects, tree, tests } = parsed;
-    const covered = BloomFilter.parse(tests);
+    const { version, runtime, head, root, shard, projects, tree, tests } = parsed;
     if (version !== SNAPSHOT_VERSION ||
+        typeof runtime !== 'string' ||
         typeof head !== 'string' ||
+        typeof root !== 'string' ||
         !isShard(shard) ||
         !Array.isArray(projects) ||
         !projects.every((name) => typeof name === 'string') ||
         !isTree(tree) ||
-        covered === null) {
+        !Array.isArray(tests) ||
+        !tests.every((file) => typeof file === 'string')) {
         return null;
     }
     return {
         version: SNAPSHOT_VERSION,
+        runtime,
         head,
+        root,
         shard,
         projects: projects,
         tree,
-        tests: covered,
+        tests: tests,
     };
 }
 /**
@@ -183,12 +323,36 @@ export class TreeSnapshotProvider {
     deselected = new Set();
     /** The plugin's `dependencies` option, compiled. */
     dependencies = [];
+    /**
+     * Paths whose content differs from the snapshot's. A path the snapshot did
+     * not anchor (a later run recorded it, or a file it imported was recorded
+     * after another shard's run) is a change only if it was not tracked with
+     * the same blob at the snapshot's commit.
+     */
+    async changedSince(repo, snapshot, tree) {
+        const changed = diffTrees(snapshot.tree, tree);
+        const fresh = changed.filter((file) => !Object.hasOwn(snapshot.tree, file) && Object.hasOwn(tree, file));
+        if (fresh.length === 0)
+            return changed;
+        const blobs = await blobsAt(repo, snapshot.head, fresh);
+        if (!blobs)
+            return changed;
+        return changed.filter((file) => {
+            const entry = tree[file];
+            const sha = entry?.split(' ')[1];
+            return !(blobs.has(file) && blobs.get(file) === sha);
+        });
+    }
     async findChangedFiles(options) {
         this.deselected = new Set();
         const dependencies = await options.resolver.getDependencies();
         const cacheDir = this.vitest.vite.config.cacheDir;
         const selected = await this.select(options, dependencies, cacheDir, (message) => this.vitest.logger.log(`[blacksmith] ${message}`));
         if (selected === null) {
+            // Not a changed run any more: vitest's coverage provider narrows its
+            // report to `config.related`, which is about to be every test file,
+            // and no source file is a test file.
+            this.vitest.config.changed = false;
             return dependencies.map((dependency) => dependency.file);
         }
         const changed = new Set(selected);
@@ -213,6 +377,12 @@ export class TreeSnapshotProvider {
             log(`no dependency snapshot, running every test of the ${describeShard(shard)}`);
             return null;
         }
+        const repo = await repoRoot(root);
+        const here = repoRelative(repo, this.vitest.config.root);
+        if (snapshot.root !== here) {
+            log(`dependency snapshot is for ${snapshot.root || 'the repository root'}, this run is for ${here || 'the repository root'}, running every test of the ${describeShard(shard)}`);
+            return null;
+        }
         if (!sameShard(snapshot.shard, shard)) {
             log(`dependency snapshot is for ${describeShard(snapshot.shard)}, running every test of the ${describeShard(shard)}`);
             return null;
@@ -222,9 +392,12 @@ export class TreeSnapshotProvider {
             log(`dependency snapshot covers projects [${snapshot.projects.join(', ')}], this run covers [${projects.join(', ')}], running every test of the ${describeShard(shard)}`);
             return null;
         }
-        const repo = await repoRoot(root);
+        if (snapshot.runtime !== runtimeId()) {
+            log(`dependency snapshot was made on ${snapshot.runtime}, this is ${runtimeId()}, running every test of the ${describeShard(shard)}`);
+            return null;
+        }
         const tree = await anchorTree(repo, await anchoredPaths(this.vitest, repo, dir, this.dependencies));
-        const changedPaths = diffTrees(snapshot.tree, tree);
+        const changedPaths = await this.changedSince(repo, snapshot, tree);
         const owns = await shardOwner(this.vitest);
         // Entries without a record are test files vitest has never seen; a test
         // the snapshot does not vouch for has no trustworthy record either,
@@ -232,20 +405,43 @@ export class TreeSnapshotProvider {
         const uncovered = new Set(dependencies
             .filter((dependency) => dependency.recordedAt === undefined && owns(dependency.file))
             .map((dependency) => dependency.file));
+        const vouched = new Set(snapshot.tests);
         for (const specification of await this.vitest.globTestSpecifications()) {
             const file = specification.moduleId;
-            if (owns(file) && !snapshot.tests.has(repoRelative(repo, file))) {
+            if (owns(file) && !vouched.has(repoRelative(repo, file))) {
                 uncovered.add(file);
             }
         }
         const changed = new Set(uncovered);
+        const workflow = workflowPath();
+        const manifestDirs = [];
         for (const relative of changedPaths) {
-            if (LOCKFILES.has(path.basename(relative))) {
+            if (LOCKFILES.has(path.basename(relative)) || relative === workflow) {
                 log(`${relative} changed, running every test of the ${describeShard(shard)}`);
                 return null;
             }
+            if (isManifest(relative))
+                manifestDirs.push(repoDir(relative));
             changed.add(path.join(repo, relative));
         }
+        // A manifest changes resolution for everything below it: every test
+        // with a recorded file under its directory runs.
+        let viaManifest = 0;
+        if (manifestDirs.length > 0) {
+            const under = (file) => {
+                const relative = repoRelative(repo, file);
+                return (!relative.startsWith('..') &&
+                    manifestDirs.some((manifestDir) => manifestDir === '' || relative.startsWith(`${manifestDir}/`)));
+            };
+            for (const [test, deps] of await recordedDependencies(this.vitest, dir)) {
+                if (changed.has(test) || !owns(test))
+                    continue;
+                if (under(test) || [...deps].some(under)) {
+                    changed.add(test);
+                    viaManifest++;
+                }
+            }
+        }
         const triggered = this.dependencies.filter((rule) => changedPaths.some((relative) => rule.deps(rootRelative(root, path.join(repo, relative)))));
         let mapped = 0;
         if (triggered.length > 0) {
@@ -261,10 +457,13 @@ export class TreeSnapshotProvider {
                 }
             }
         }
-        log(`${changedPaths.length} files changed since ${snapshot.head.slice(0, 12)}, ${uncovered.size} test files not covered by it${mapped > 0 ? `, ${mapped} test files via dependencies` : ''}`);
+        log(`${changedPaths.length} files changed since ${snapshot.head.slice(0, 12)}, ${uncovered.size} test files not covered by it${viaManifest > 0 ? `, ${viaManifest} test files under a changed manifest` : ''}${mapped > 0 ? `, ${mapped} test files via dependencies` : ''}`);
         return [...changed];
     }
 }
+function containsOnly(module) {
+    return module.task?.containsOnly === true;
+}
 function isPartialSpecification(specification) {
     return (specification.testLines !== undefined ||
         specification.testIds !== undefined ||
@@ -307,6 +506,8 @@ export class ShadowAnalysis {
         const repo = await repoRoot(vitest.config.root);
         const key = cacheKey({
             snapshotVersion: SNAPSHOT_VERSION,
+            runtime: runtimeId(),
+            root: repoRelative(repo, vitest.config.root),
             projects: projectNames(vitest),
             shard: vitest.config.shard ?? null,
             head: process.env.GITHUB_SHA || (await headSha(repo)),
@@ -465,25 +666,42 @@ export class SnapshotRecorder {
     }
     onTestRunStart(specifications) {
         this.started = new Set(specifications.map((specification) => specification.moduleId));
-        this.partial = specifications.some(isPartialSpecification);
+        this.partial =
+            specifications.some(isPartialSpecification) ||
+                (this.vitest.config.tagsFilter?.length ?? 0) > 0;
     }
-    async onTestRunEnd(modules, _errors, reason) {
+    onTestModuleEnd(module) {
+        recordBrowserDependencies(this.vitest, module);
+    }
+    async onTestRunEnd(modules, errors, reason) {
         await this.reportShadow(modules);
-        if (reason !== 'passed')
+        // A failed run still vouches for the files that passed; the failed ones
+        // are left out and rerun next time. An interrupted run left files unrun,
+        // an unhandled error fails the run outside any module (`reason` does not
+        // see it), and a `.only` skipped its siblings: none of those vouch.
+        if (reason === 'interrupted' || errors.length > 0)
+            return;
+        if (modules.some((module) => containsOnly(module)))
             return;
-        const covered = await this.coveredTests();
+        const covered = await this.coveredTests(modules);
         if (covered === null)
             return;
+        if (covered.left.length > 0) {
+            this.vitest.logger.log(`[blacksmith] ${covered.left.length} failed test files left out of the dependency snapshot, they run again next time`);
+        }
         const cacheDir = this.vitest.vite.config.cacheDir;
         const { root, shard } = this.vitest.config;
         const repo = await repoRoot(root);
+        await pruneRecords(this.vitest, repo, cacheDir);
         const snapshot = {
             version: SNAPSHOT_VERSION,
+            runtime: runtimeId(),
             head: await headSha(repo),
+            root: repoRelative(repo, root),
             shard: shard ?? null,
             projects: projectNames(this.vitest),
             tree: await anchorTree(repo, await anchoredPaths(this.vitest, repo, cacheDir, this.provider.dependencies)),
-            tests: BloomFilter.from(covered.map((file) => repoRelative(repo, file))),
+            tests: covered.vouched.map((file) => repoRelative(repo, file)).sort(),
         };
         const file = snapshotPath(this.vitest, cacheDir);
         await mkdir(path.dirname(file), { recursive: true });
@@ -499,6 +717,8 @@ export class SnapshotRecorder {
             return;
         const key = cacheKey({
             snapshotVersion: snapshot.version,
+            runtime: snapshot.runtime,
+            root: snapshot.root,
             projects: snapshot.projects,
             shard: snapshot.shard,
             head: snapshot.head,
@@ -513,8 +733,12 @@ export class SnapshotRecorder {
             this.vitest.logger.log(`[blacksmith] dependency cache not saved: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    /** The tests this shard owns, when every one of them ran or was deselected by our own provider; `null` when the run covered less. */
-    async coveredTests() {
+    /**
+     * The tests this shard owns, split into those the run vouches for (passed,
+     * or deselected by our own provider) and those `left` out (failed, or never
+     * reached); `null` when the run covered less than the shard.
+     */
+    async coveredTests(modules) {
         if (this.partial || this.vitest.getGlobalTestNamePattern() !== undefined) {
             return null;
         }
@@ -525,9 +749,31 @@ export class SnapshotRecorder {
                 .map((specification) => specification.moduleId)
                 .filter(owns)),
         ];
-        return owned.every((file) => this.started.has(file) || deselected.has(file))
-            ? owned
-            : null;
+        // Nothing owned (an `include` matching no file) vouches for nothing.
+        if (owned.length === 0)
+            return null;
+        if (!owned.every((file) => this.started.has(file) || deselected.has(file)))
+            return null;
+        // A file may run in several projects; it passed when every one did.
+        const passed = new Map();
+        for (const module of modules) {
+            const state = module.state();
+            const fine = (state === 'passed' || state === 'skipped') &&
+                module.errors().length === 0;
+            passed.set(module.moduleId, (passed.get(module.moduleId) ?? true) && fine);
+        }
+        const vouched = [];
+        const left = [];
+        // Vitest reruns a deselected file when its config or globalSetup changed;
+        // one that ran is judged by its result, deselection vouches only for
+        // files that did not run.
+        for (const file of owned) {
+            const fine = this.started.has(file)
+                ? passed.get(file) === true
+                : deselected.has(file);
+            (fine ? vouched : left).push(file);
+        }
+        return { vouched, left };
     }
 }
 /**
@@ -554,6 +800,8 @@ export async function restoreDependencyCache(vitest) {
     const repo = await repoRoot(vitest.config.root);
     const key = cacheKey({
         snapshotVersion: SNAPSHOT_VERSION,
+        runtime: runtimeId(),
+        root: repoRelative(repo, vitest.config.root),
         projects: projectNames(vitest),
         shard: vitest.config.shard ?? null,
         head: process.env.GITHUB_SHA || (await headSha(repo)),

package/dist/browser.d.ts

@@ -0,0 +1,11 @@
+import type { TestModule, Vitest } from 'vitest/node';
+/**
+ * Vitest's browser tester never reports what a test file imported, so
+ * `dependencies.json` holds no record for a browser test and `--changed` runs
+ * it every time. The project's Vite client environment transformed every
+ * module the browser loaded; walking its graph from the test file and the
+ * setup files gives the same set the node worker reports, recorded through
+ * the same call its RPC makes. Virtual modules (`/@vitest/...`, `\0...`) have
+ * no file and are left out; vitest drops `node_modules` paths itself.
+ */
+export declare function recordBrowserDependencies(vitest: Vitest, module: TestModule): void;