@useblacksmith/vitest 0.3.0 → 0.5.0

package/dist/browser.js

@@ -0,0 +1,57 @@
+function dependenciesCache(vitest) {
+    const cache = vitest.cache;
+    const record = cache?._dependencies?.record;
+    return typeof record === 'function'
+        ? { record: record.bind(cache?._dependencies) }
+        : null;
+}
+const warned = new WeakSet();
+/**
+ * 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 function recordBrowserDependencies(vitest, module) {
+    const project = module.project;
+    if (!project.isBrowserEnabled())
+        return;
+    const cache = dependenciesCache(vitest);
+    if (!cache) {
+        if (!warned.has(vitest)) {
+            warned.add(vitest);
+            vitest.logger.warn('[blacksmith] this vitest does not expose its dependency record; browser tests run on every --changed');
+        }
+        return;
+    }
+    const graph = project.vite.environments.client?.moduleGraph;
+    if (!graph)
+        return;
+    const roots = [...(graph.getModulesByFile(module.moduleId) ?? [])];
+    // A test the browser never fetched through this graph has no record to
+    // give; an empty one would let `--changed` skip it on every edit.
+    if (roots.length === 0)
+        return;
+    const files = new Set([module.moduleId]);
+    const seen = new Set();
+    const queue = [
+        ...roots,
+        ...project.config.setupFiles.flatMap((file) => [
+            ...(graph.getModulesByFile(file) ?? []),
+        ]),
+    ];
+    while (queue.length > 0) {
+        const node = queue.pop();
+        if (!node?.id || seen.has(node.id))
+            continue;
+        seen.add(node.id);
+        if (node.file)
+            files.add(node.file);
+        for (const imported of node.importedModules)
+            queue.push(imported);
+    }
+    cache.record(project, module.moduleId, [...files]);
+}

package/dist/cache.d.ts

@@ -19,8 +19,17 @@ export interface CacheKey {
     prefix: string;
 }
 export declare const DEFAULT_CACHE_PREFIX = "blacksmith-vitest";
+/**
+ * What the recorded inputs were resolved and run under. A `matrix.node` job
+ * on another major, or a platform whose resolution differs (case-insensitive
+ * fs, `.node` binaries), must not vouch for this one.
+ */
+export declare function runtimeId(): string;
 export declare function cacheKey(input: {
     snapshotVersion: number;
+    runtime: string;
+    /** Vitest's root relative to the repository: each package of a monorepo keeps its own entries. */
+    root: string;
     projects: string[];
     shard: {
         index: number;

package/dist/cache.js

@@ -16,14 +16,23 @@ const TWIRP = 'twirp/github.actions.results.api.v1.CacheService/';
 export const BUNDLE_VERSION = 'blacksmith-vitest-bundle-1';
 export const TIMEOUT_MS = 15_000;
 /** Files under the cache dir that travel in the bundle. */
-export const RECORD_FILE = /^(dependencies\.json|blacksmith(\.[0-9a-f]{12})?\.json)$/;
+export const RECORD_FILE = /^(dependencies\.json|blacksmith(\.[0-9a-f]{12})?(\.\d+of\d+)?\.json)$/;
 export const DEFAULT_CACHE_PREFIX = 'blacksmith-vitest';
+/**
+ * What the recorded inputs were resolved and run under. A `matrix.node` job
+ * on another major, or a platform whose resolution differs (case-insensitive
+ * fs, `.node` binaries), must not vouch for this one.
+ */
+export function runtimeId() {
+    return `node${process.versions.node.split('.')[0]}-${process.platform}-${process.arch}`;
+}
 export function cacheKey(input) {
     const scope = [
         `v${input.snapshotVersion}`,
-        input.projects.some(Boolean)
+        input.runtime,
+        input.root !== '' || input.projects.some(Boolean)
             ? createHash('sha1')
-                .update(input.projects.join('\n'))
+                .update([input.root, ...input.projects].join('\n'))
                 .digest('hex')
                 .slice(0, 12)
             : 'all',

package/dist/fs-recorder.d.ts

@@ -0,0 +1,18 @@
+import type * as FS from 'node:fs';
+/** Marks a function this module already wrapped, so a second load leaves it alone. */
+export declare const BRAND: unique symbol;
+/** Set in a child process's environment: the file its recorder appends the paths it loaded or read to. */
+export declare const CHILD_RECORD_ENV = "BLACKSMITH_CHILD_RECORD";
+/** The repository root; a read outside it is not recorded, the anchor cannot cover it. */
+export declare const ENV_REPO = "BLACKSMITH_REPO";
+export declare function toPath(target: unknown): string | null;
+/** Installed packages are vouched for by the lockfile, not by their files. */
+export declare function isIgnored(absolute: string): boolean;
+type Wrappable = Record<string, unknown>;
+/** Replaces `object[name]` with a function that calls `before(args)` first; properties and symbols of the original (`realpathSync.native`, `promisify.custom`) carry over. */
+export declare function wrap(object: Wrappable, name: string, before: (args: unknown[]) => void): void;
+/** Own properties of `original` that `wrapped` lacks, non-enumerable ones included. */
+export declare function copyProperties(wrapped: object, original: object): void;
+/** Wraps every read entry point of `fs` so `record` sees the path argument; a copied tree is recorded file by file. */
+export declare function wrapReads(fs: typeof FS, record: (file: string) => void): void;
+export {};

package/dist/fs-recorder.js

@@ -0,0 +1,104 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** Marks a function this module already wrapped, so a second load leaves it alone. */
+export const BRAND = Symbol.for('blacksmith.recordReads');
+/** Set in a child process's environment: the file its recorder appends the paths it loaded or read to. */
+export const CHILD_RECORD_ENV = 'BLACKSMITH_CHILD_RECORD';
+/** The repository root; a read outside it is not recorded, the anchor cannot cover it. */
+export const ENV_REPO = 'BLACKSMITH_REPO';
+export function toPath(target) {
+    if (typeof target === 'string')
+        return target;
+    if (Buffer.isBuffer(target))
+        return target.toString();
+    if (target instanceof URL) {
+        try {
+            return fileURLToPath(target);
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+/** Installed packages are vouched for by the lockfile, not by their files. */
+export function isIgnored(absolute) {
+    if (absolute.split(path.sep).includes('node_modules'))
+        return true;
+    const repo = process.env[ENV_REPO];
+    if (!repo)
+        return false;
+    const relative = path.relative(repo, absolute);
+    return relative.startsWith('..') || path.isAbsolute(relative);
+}
+/** Replaces `object[name]` with a function that calls `before(args)` first; properties and symbols of the original (`realpathSync.native`, `promisify.custom`) carry over. */
+export function wrap(object, name, before) {
+    const original = object[name];
+    if (typeof original !== 'function' || BRAND in original)
+        return;
+    const wrapped = function (...args) {
+        before(args);
+        return original.apply(this, args);
+    };
+    copyProperties(wrapped, original);
+    wrap(wrapped, 'native', before);
+    Object.defineProperty(wrapped, BRAND, { value: true });
+    object[name] = wrapped;
+}
+/** Own properties of `original` that `wrapped` lacks, non-enumerable ones included. */
+export function copyProperties(wrapped, original) {
+    for (const key of Reflect.ownKeys(original)) {
+        if (Object.prototype.hasOwnProperty.call(wrapped, key))
+            continue;
+        const descriptor = Object.getOwnPropertyDescriptor(original, key);
+        if (descriptor)
+            Object.defineProperty(wrapped, key, descriptor);
+    }
+}
+const READS = [
+    'access',
+    'copyFile',
+    'lstat',
+    'open',
+    'opendir',
+    'readdir',
+    'readFile',
+    'readlink',
+    'realpath',
+    'stat',
+];
+/** Wraps every read entry point of `fs` so `record` sees the path argument; a copied tree is recorded file by file. */
+export function wrapReads(fs, record) {
+    const first = (args) => {
+        const file = toPath(args[0]);
+        if (file !== null)
+            record(file);
+    };
+    const tree = (args) => {
+        first(args);
+        const file = toPath(args[0]);
+        if (file === null)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(file, { recursive: true, encoding: 'utf8' });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries)
+            record(path.join(file, entry));
+    };
+    const target = fs;
+    const promises = fs.promises;
+    for (const name of READS) {
+        wrap(target, name, first);
+        wrap(target, `${name}Sync`, first);
+        wrap(promises, name, first);
+    }
+    wrap(target, 'existsSync', first);
+    wrap(target, 'createReadStream', first);
+    wrap(target, 'cp', tree);
+    wrap(promises, 'cp', tree);
+    wrap(target, 'cpSync', tree);
+}

package/dist/git.d.ts

@@ -19,3 +19,10 @@ export declare function knownPaths(repo: string): Promise<Set<string>>;
 export declare function anchorTree(repo: string, paths: Iterable<string>): Promise<Tree>;
 /** Paths whose blob differs between the trees, including files only present in one of them. */
 export declare function diffTrees(before: Tree, after: Tree): string[];
+/**
+ * The blob sha each of `paths` had at `commit`, for those that were tracked
+ * there; `null` when git cannot answer. `cat-file` replies one line per request
+ * in order, so a path is matched by position and may hold spaces; one holding
+ * a newline cannot be requested and is left out.
+ */
+export declare function blobsAt(repo: string, commit: string, paths: readonly string[]): Promise<Map<string, string> | null>;

package/dist/git.js

@@ -64,7 +64,7 @@ export function knownPaths(repo) {
  * untracked files not ignored, so a directory's listing is what `git status`
  * would attribute to it. Index entries whose file is gone are left out.
  */
-async function listKnown(repo, pathspecs, literal = true) {
+async function listKnown(repo, pathspecs, literal = true, ignored = false) {
     const known = new Set();
     const gone = new Set();
     for (let i = 0; i < pathspecs.length; i += 500) {
@@ -76,7 +76,7 @@ async function listKnown(repo, pathspecs, literal = true) {
             '--cached',
             '--others',
             '--deleted',
-            '--exclude-standard',
+            ...(ignored ? [] : ['--exclude-standard']),
             '--',
             ...pathspecs.slice(i, i + 500),
         ]);
@@ -143,7 +143,7 @@ export async function anchorTree(repo, paths) {
         !file.startsWith('../') &&
         !path.isAbsolute(file))
         .sort();
-    const tree = {};
+    const tree = Object.create(null);
     if (wanted.length === 0)
         return tree;
     const present = new Map();
@@ -159,7 +159,9 @@ export async function anchorTree(repo, paths) {
     for (const [file, stat] of present)
         (stat.isDirectory() ? dirs : others).push(file);
     const known = await listKnown(repo, dirs);
-    for (const file of await listKnown(repo, others))
+    // A recorded file counts even when git ignores it: generated code and
+    // `.env.local` are inputs the test read, whatever `.gitignore` says.
+    for (const file of await listKnown(repo, others, true, true))
         known.add(file);
     const sorted = [...known].sort();
     const files = [];
@@ -208,11 +210,26 @@ export async function anchorTree(repo, paths) {
             modes[index] = indexModes.get(file) ?? '100644';
         });
     }
-    const shas = (await git(repo, ['hash-object', '--stdin-paths'], files.join('\n')))
+    // `hash-object --stdin-paths` takes one path per line and has no `-z`: a
+    // path with a newline in it would split into two and shift every sha after
+    // it, so such a file gets its own call.
+    const batched = [];
+    for (const [index, file] of files.entries()) {
+        if (!file.includes('\n')) {
+            batched.push(index);
+            continue;
+        }
+        const sha = (await git(repo, ['hash-object', '--', file])).trim();
+        tree[file] = `${modes[index]} ${sha}`;
+    }
+    if (batched.length === 0)
+        return tree;
+    const shas = (await git(repo, ['hash-object', '--stdin-paths'], batched.map((index) => files[index]).join('\n')))
         .trim()
         .split('\n');
-    files.forEach((file, index) => {
-        const sha = shas[index];
+    batched.forEach((index, position) => {
+        const file = files[index] ?? '';
+        const sha = shas[position];
         if (sha === undefined)
             throw new Error(`git hash-object returned no sha for ${file}`);
         tree[file] = `${modes[index]} ${sha}`;
@@ -223,12 +240,41 @@ export async function anchorTree(repo, paths) {
 export function diffTrees(before, after) {
     const changed = [];
     for (const [file, sha] of Object.entries(after)) {
-        if (before[file] !== sha)
+        if (!Object.hasOwn(before, file) || before[file] !== sha)
             changed.push(file);
     }
     for (const file of Object.keys(before)) {
-        if (!(file in after))
+        if (!Object.hasOwn(after, file))
             changed.push(file);
     }
     return changed;
 }
+/**
+ * The blob sha each of `paths` had at `commit`, for those that were tracked
+ * there; `null` when git cannot answer. `cat-file` replies one line per request
+ * in order, so a path is matched by position and may hold spaces; one holding
+ * a newline cannot be requested and is left out.
+ */
+export async function blobsAt(repo, commit, paths) {
+    const named = paths.filter((file) => !file.includes('\n'));
+    if (named.length === 0)
+        return new Map();
+    let output;
+    try {
+        output = await git(repo, ['cat-file', '--batch-check=%(objectname) %(objecttype)'], named.map((file) => `${commit}:${file}\n`).join(''));
+    }
+    catch {
+        return null;
+    }
+    const lines = output.split('\n');
+    const result = new Map();
+    named.forEach((file, index) => {
+        const line = lines[index] ?? '';
+        if (line.endsWith(' missing'))
+            return;
+        const [sha, type] = line.split(' ');
+        if (type === 'blob' && sha)
+            result.set(file, sha);
+    });
+    return result;
+}

package/dist/index.js

@@ -1,4 +1,6 @@
 import { fileURLToPath } from 'node:url';
+import { ENV_REPO } from './fs-recorder.js';
+import { repoRoot } from './git.js';
 import { compileDependencies, configuredProvider, isTreeSnapshotProvider, isSnapshotRecorder, restoreDependencyCache, ShadowAnalysis, SnapshotRecorder, TreeSnapshotProvider, } from './affected.js';
 import { customSequencer, HashShardSequencer, stableShards, } from './sequencer.js';
 /** Beside this module; `.ts` when the plugin runs from source (its own test fixtures). */
@@ -13,7 +15,6 @@ function supportsChanged(vitest) {
 }
 export default function blacksmith(options = {}) {
     const provider = new TreeSnapshotProvider();
-    provider.dependencies = compileDependencies(options.dependencies);
     let changedApplied = false;
     let restored;
     let shadow;
@@ -39,7 +40,12 @@ export default function blacksmith(options = {}) {
             // second plugin instance; configure the provider vitest actually uses.
             const active = configuredProvider(vitest) ?? provider;
             active.vitest = vitest;
+            provider.dependencies = compileDependencies(options.dependencies, vitest.config.root);
             active.dependencies = provider.dependencies;
+            // Workers drop what they read outside the repository: the anchor
+            // cannot cover it, and vitest's record would otherwise keep every
+            // temp file a run touched.
+            process.env[ENV_REPO] ??= await repoRoot(vitest.config.root);
             // Their sequencer's shards must not depend on which tests the
             // selection kept, or the provider's view of the shard and vitest's
             // would differ.
@@ -71,6 +77,11 @@ export default function blacksmith(options = {}) {
                     vitest.logger.warn('[blacksmith] This vitest version does not support running changed tests with Blacksmith');
                 }
             }
+            // Coverage follows the selection (vitest's `config.related`) rather
+            // than asking the provider again with a `changedSince` it ignores.
+            if (!options.shadow && vitest.config.changed && supportsChanged(vitest)) {
+                vitest.config.coverage.changed = false;
+            }
             // Per project, since a project's own `setupFiles` replace the root's;
             // first, so reads by those setup files are recorded too. A browser
             // project has no `node:fs` to wrap.

package/dist/record-child.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/record-child.js

@@ -0,0 +1,60 @@
+import { createRequire, syncBuiltinESMExports } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { CHILD_RECORD_ENV, isIgnored, wrapReads } from './fs-recorder.js';
+/**
+ * Preloaded (`--import`) into every node process and worker thread a test
+ * starts: records the modules it loads and the files it reads, and appends
+ * them to the file the test's recorder named in the environment. Children of
+ * the child inherit the environment and append to the same file.
+ */
+const require = createRequire(import.meta.url);
+const fs = require('node:fs');
+const nodeModule = require('node:module');
+const output = process.env[CHILD_RECORD_ENV];
+if (output) {
+    // Our own bookkeeping must not count as a read.
+    const { openSync, writeSync } = fs;
+    let fd;
+    const paths = new Set();
+    // Written on the spot, not batched or left to `exit`: a signal
+    // (`child.kill()`) or `worker.terminate()` can end this process or thread
+    // at any point, with no `exit` event and no later tick.
+    const record = (file) => {
+        const absolute = path.resolve(file);
+        if (isIgnored(absolute) || paths.has(absolute))
+            return;
+        paths.add(absolute);
+        try {
+            fd ??= openSync(output, 'a');
+            writeSync(fd, `${absolute}\n`);
+        }
+        catch { }
+    };
+    wrapReads(fs, record);
+    // A loader preloaded before this one (tsx) may already hold the ESM
+    // namespace of `node:fs`; resync so its named imports see the wrappers.
+    syncBuiltinESMExports();
+    // Node 22.15+: every ESM and CJS resolution, including through loaders such as tsx.
+    if (typeof nodeModule.registerHooks === 'function') {
+        nodeModule.registerHooks({
+            resolve(specifier, context, next) {
+                const result = next(specifier, context);
+                if (result.url.startsWith('file:')) {
+                    try {
+                        record(fileURLToPath(result.url));
+                    }
+                    catch { }
+                }
+                return result;
+            },
+        });
+    }
+    process.on('exit', function blacksmithRecordChild() {
+        const script = process.argv[1];
+        if (script)
+            record(script);
+        for (const id of Object.keys(require.cache))
+            record(id);
+    });
+}