@useblacksmith/vitest 0.4.0 → 0.5.0

package/dist/record-reads.js

@@ -1,107 +1,302 @@
 import { createRequire, syncBuiltinESMExports } from 'node:module';
+import os from 'node:os';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { promisify } from 'node:util';
+import { afterAll } from 'vitest';
+import { BRAND, CHILD_RECORD_ENV, copyProperties, isIgnored, wrapReads, } from './fs-recorder.js';
 /**
- * Setup file the plugin puts first in every worker: each `fs` read lands in
- * the dependency set Vitest keeps for the test file being run, beside its
- * imports, so a fixture, a listed directory or a probed-but-missing file
- * reruns the test when it changes. The wrapped functions stay on the shared
- * `fs` object across the files a worker runs; the set is looked up per call,
- * so a read is charged to whichever file is current.
+ * Runs as the first setup file of every test file. Vitest records what a
+ * test imports; this records the files it reads through `node:fs` and the
+ * node processes and worker threads it starts (their modules and reads, via
+ * `record-child`), adding each to the dependency set vitest keeps per test
+ * file.
+ *
+ * The functions on the builtin are replaced, so every specifier that reaches
+ * them (`fs`, `node:fs`, `fs/promises`, `require`) is covered.
  */
-// Loaded with `require`, not `import`: under `vmThreads`/`vmForks` an import
-// would build this context's `node:fs` module namespace now, from the
-// functions as they are before wrapping, and a test file's own
-// `import { readFileSync } from 'node:fs'` would get that snapshot.
-const fs = createRequire(import.meta.url)('node:fs');
-const BRAND = Symbol.for('blacksmith.recordReads');
+const require = createRequire(import.meta.url);
+const fs = require('node:fs');
+const childProcess = require('node:child_process');
+const workerThreads = require('node:worker_threads');
 const CONTEXT = Symbol.for('blacksmith.recordReads.context');
-// `vmThreads`/`vmForks` evaluate this file once per test context while the
-// builtin `fs` object is shared, so the wrappers read the worker state through
-// a slot the latest evaluation points at the current context's global.
+// The `vm` pools load this file in one context and run tests in another; the
+// builtin is shared, so it carries the context that holds the worker state.
 const shared = fs;
 shared[CONTEXT] = globalThis;
-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;
+const ORIGINALS = Symbol.for('blacksmith.recordReads.originals');
+// Unwrapped, so this module's own file handling records nothing; kept on the
+// builtin because a later evaluation in the same process finds `fs` wrapped.
+const { existsSync: exists, mkdtempSync: mkdtemp, readFileSync: read, statSync: stat, unlinkSync: unlink, } = (shared[ORIGINALS] ??= {
+    existsSync: fs.existsSync,
+    mkdtempSync: fs.mkdtempSync,
+    readFileSync: fs.readFileSync,
+    statSync: fs.statSync,
+    unlinkSync: fs.unlinkSync,
+});
+function workerState() {
+    return shared[CONTEXT]?.__vitest_worker__;
 }
-function record(target) {
-    const dependencies = shared[CONTEXT]
-        ?.__vitest_worker__?.dependencies;
-    if (!dependencies)
-        return;
-    const file = toPath(target);
-    if (file === null)
+function dependencies() {
+    return workerState()?.dependencies;
+}
+function record(file, cwd = process.cwd()) {
+    const set = dependencies();
+    if (!set)
         return;
-    const absolute = path.resolve(file);
-    if (absolute.split(path.sep).includes('node_modules'))
+    const absolute = path.resolve(cwd, file);
+    if (isIgnored(absolute))
         return;
-    dependencies.add(absolute);
+    set.add(absolute);
+}
+wrapReads(fs, (file) => record(file));
+/** Beside this module; `.ts` when the plugin runs from source (its own test fixtures). */
+const recordChild = fileURLToPath(new URL(import.meta.url.endsWith('.ts') ? './record-child.ts' : './record-child.js', import.meta.url));
+let recordDir;
+let spawned = 0;
+/** Where one child (and its descendants) appends what it loaded. */
+function recordFile() {
+    recordDir ??= mkdtemp(path.join(os.tmpdir(), 'blacksmith-child-'));
+    return path.join(recordDir, `${process.pid}-${spawned++}.txt`);
+}
+/**
+ * `given` (the call's `env`, or the parent's when it had none) with the
+ * recorder preloaded and a file to report to; `null` when the caller asked
+ * for a child free of node options with `env: { ...process.env, NODE_OPTIONS:
+ * undefined }`, which is left alone.
+ */
+function recordedEnv(given) {
+    const cleared = given !== undefined &&
+        Object.prototype.hasOwnProperty.call(given, 'NODE_OPTIONS') &&
+        given.NODE_OPTIONS === undefined;
+    if (cleared)
+        return null;
+    const env = { ...(given ?? process.env) };
+    const file = recordFile();
+    env[CHILD_RECORD_ENV] = file;
+    env.NODE_OPTIONS = [
+        env.NODE_OPTIONS,
+        `--import ${pathToFileURL(recordChild).href}`,
+    ]
+        .filter(Boolean)
+        .join(' ');
+    return { env, file };
+}
+const OUTSTANDING = Symbol.for('blacksmith.recordReads.outstanding');
+// On the shared builtin, like the context: the `vm` pools evaluate this file
+// once per test file while the wrapped `child_process` and `Worker` keep the
+// first evaluation's closures, so every evaluation must see one set.
+/** Children that have not exited yet, each still charged to the test file that started it. */
+function outstanding() {
+    return (shared[OUTSTANDING] ??= new Set());
+}
+function startChild(file, cwd) {
+    const child = { file, cwd, test: workerState()?.filepath };
+    if (file !== null)
+        outstanding().add(child);
+    return child;
+}
+/** The options object of a `child_process` call, inserted when the call had none. */
+function optionsOf(args) {
+    let index = args.findIndex((arg, i) => i > 0 && typeof arg === 'object' && arg !== null && !Array.isArray(arg));
+    if (index === -1) {
+        index = Array.isArray(args[1]) ? 2 : 1;
+        args.splice(index, 0, {});
+    }
+    const options = { ...args[index] };
+    args[index] = options;
+    return options;
+}
+/**
+ * Prepares a `child_process` call: the child gets the recorder preloaded and
+ * a file to report to, and the command plus every argument naming a file is
+ * recorded right away, which is all a non-node child (a shell script, a
+ * binary) can contribute.
+ */
+function instrument(args) {
+    if (!dependencies())
+        return startChild(null, process.cwd());
+    const options = optionsOf(args);
+    const cwd = typeof options.cwd === 'string'
+        ? path.resolve(options.cwd)
+        : options.cwd instanceof URL
+            ? fileURLToPath(options.cwd)
+            : process.cwd();
+    const recorded = recordedEnv(options.env);
+    if (recorded)
+        options.env = recorded.env;
+    const words = [
+        ...(typeof args[0] === 'string' ? args[0].split(/\s+/) : []),
+        ...(Array.isArray(args[1]) ? args[1] : []),
+    ];
+    for (const word of words) {
+        if (typeof word !== 'string' || word === '')
+            continue;
+        const candidate = path.resolve(cwd, word);
+        try {
+            if (exists(candidate) && stat(candidate).isFile())
+                record(candidate);
+        }
+        catch { }
+    }
+    return startChild(recorded?.file ?? null, cwd);
 }
-/** A recursive copy reads every file below its source. */
-function recordTree(target) {
-    record(target);
-    const file = toPath(target);
-    if (file === null)
+/** What the child has reported so far, relative to its working directory, while its test file is the one running. */
+function recordReported(child) {
+    if (child.file === null || child.test !== workerState()?.filepath)
         return;
-    let entries;
+    let reported;
     try {
-        entries = fs.readdirSync(file, { recursive: true, encoding: 'utf8' });
+        reported = read(child.file, 'utf8');
     }
     catch {
         return;
     }
-    for (const entry of entries)
-        record(path.join(file, entry));
+    for (const line of reported.split('\n'))
+        if (line !== '')
+            record(line, child.cwd);
 }
-function wrap(object, name, recorder = record) {
-    const original = object[name];
+/** Records what the exited child reported and forgets it. */
+function collect(child) {
+    if (child.file === null)
+        return;
+    recordReported(child);
+    try {
+        unlink(child.file);
+    }
+    catch { }
+    outstanding().delete(child);
+}
+// Vitest ships the test file's dependency set as soon as its hooks are done,
+// so a child still running then (a server the test tears down, a worker it
+// never joins) reports what it has loaded so far here. Whether this hook
+// runs before or after the file's own `afterAll` (`sequence.hooks`), the
+// child's exit still reports to this file while it is the one running.
+afterAll(() => {
+    const current = workerState()?.filepath;
+    for (const child of outstanding()) {
+        if (child.test !== current)
+            continue;
+        recordReported(child);
+        outstanding().delete(child);
+    }
+});
+function wrapChildProcess(name, sync) {
+    const target = childProcess;
+    const original = target[name];
     if (typeof original !== 'function' || BRAND in original)
         return;
-    const wrapped = function (...args) {
-        recorder(args[0]);
-        return original.apply(this, args);
-    };
-    // `realpathSync.native` and friends live on the function.
-    Object.assign(wrapped, original);
-    wrap(wrapped, 'native', recorder);
+    const call = original;
+    const wrapped = sync
+        ? function (...args) {
+            const child = instrument(args);
+            try {
+                return call.apply(this, args);
+            }
+            finally {
+                collect(child);
+            }
+        }
+        : function (...args) {
+            const child = instrument(args);
+            const process = call.apply(this, args);
+            // Only `exit`: an `error` listener would keep a spawn failure from
+            // surfacing as the uncaught error it is. A child that never ran
+            // reported nothing and is forgotten with its test file.
+            if (typeof process?.once === 'function') {
+                process.once('exit', () => collect(child));
+            }
+            return process;
+        };
+    // Node's own promisified `exec`/`execFile` call the unwrapped function;
+    // `promisify(execFile)` must go through the wrapper to reach the child.
+    if (promisify.custom in original) {
+        Object.defineProperty(wrapped, promisify.custom, {
+            value: (...args) => {
+                let child;
+                const promise = new Promise((resolve, reject) => {
+                    child = wrapped(...args, (error, stdout, stderr) => error
+                        ? reject(Object.assign(error, { stdout, stderr }))
+                        : resolve({ stdout, stderr }));
+                });
+                return Object.defineProperty(promise, 'child', {
+                    value: child,
+                    enumerable: true,
+                });
+            },
+        });
+    }
+    copyProperties(wrapped, original);
     Object.defineProperty(wrapped, BRAND, { value: true });
-    object[name] = wrapped;
-}
-const READS = [
-    'access',
-    'copyFile',
-    'lstat',
-    'open',
-    'opendir',
-    'readdir',
-    'readFile',
-    'readlink',
-    'realpath',
-    'stat',
-];
-for (const name of READS) {
-    wrap(fs, name);
-    wrap(fs, `${name}Sync`);
-    wrap(fs.promises, name);
-}
-wrap(fs, 'existsSync');
-wrap(fs, 'createReadStream');
-for (const object of [fs, fs.promises]) {
-    wrap(object, 'cp', recordTree);
-}
-wrap(fs, 'cpSync', recordTree);
+    target[name] = wrapped;
+}
+for (const name of ['spawn', 'exec', 'execFile', 'fork']) {
+    wrapChildProcess(name, false);
+}
+for (const name of ['spawnSync', 'execSync', 'execFileSync']) {
+    wrapChildProcess(name, true);
+}
+/** The script a worker runs, when it is a file; `null` for `eval`, `data:` and `node:` sources. */
+function workerScript(filename, options) {
+    if (options?.eval === true)
+        return null;
+    if (filename instanceof URL) {
+        return filename.protocol === 'file:' ? fileURLToPath(filename) : null;
+    }
+    return filename.startsWith('data:') || filename.startsWith('node:')
+        ? null
+        : filename;
+}
+/**
+ * A worker thread has its own `fs` builtin and module registry, so it is
+ * recorded like a child: the preload comes through its `env` (a worker reads
+ * `NODE_OPTIONS` from there), and the script it runs is recorded right away.
+ * A worker sharing the parent's environment (`env: SHARE_ENV`) contributes
+ * only its script, and so does one whose `NODE_OPTIONS` node refuses to
+ * change (the parent's holds an option a worker's may not carry, `--title`
+ * say): it is then started exactly as asked.
+ */
+function wrapWorker() {
+    const target = workerThreads;
+    const Original = workerThreads.Worker;
+    if (BRAND in Original)
+        return;
+    function RecordedWorker(filename, options) {
+        const construct = (given) => Reflect.construct(Original, [filename, given], new.target ?? RecordedWorker);
+        if (!dependencies())
+            return construct(options);
+        const script = workerScript(filename, options);
+        if (script !== null)
+            record(script);
+        const recorded = options?.env === workerThreads.SHARE_ENV
+            ? null
+            : recordedEnv(options?.env);
+        if (!recorded)
+            return construct(options);
+        const child = startChild(recorded.file, process.cwd());
+        let worker;
+        try {
+            worker = construct({ ...options, env: recorded.env });
+        }
+        catch (error) {
+            outstanding().delete(child);
+            if (error.code !== 'ERR_WORKER_INVALID_EXEC_ARGV') {
+                throw error;
+            }
+            return construct(options);
+        }
+        // `exit` follows an uncaught error in the worker too; an `error`
+        // listener here would swallow that error instead of letting Vitest report it.
+        worker.once('exit', () => collect(child));
+        return worker;
+    }
+    RecordedWorker.prototype = Original.prototype;
+    Object.setPrototypeOf(RecordedWorker, Original);
+    copyProperties(RecordedWorker, Original);
+    Object.defineProperty(RecordedWorker, BRAND, { value: true });
+    target.Worker = RecordedWorker;
+}
+wrapWorker();
 // `import { readFileSync } from 'node:fs'` binds the builtin's ESM namespace,
 // which only sees the wrapped functions once the namespace is resynced; the
 // vm pools keep their own per-context namespaces and expose their resync.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@useblacksmith/vitest",
-	"version": "0.4.0",
+	"version": "0.5.0",
 	"description": "Runs only the Vitest tests affected since the last successful run, with Blacksmith-backed caching",
 	"type": "module",
 	"license": "MIT",
@@ -30,6 +30,9 @@
 	"devDependencies": {
 		"@types/node": "^26.6.6",
 		"@types/picomatch": "^4.0.3",
+		"@vitest/browser-playwright": "^5.1.0",
+		"@vitest/coverage-v8": "^5.1.0",
+		"playwright": "^1.65.0",
 		"typescript": "^7.0.2",
 		"vite": "^8.3.5",
 		"vitest": "^5.1.0"

package/dist/bloom.d.ts

@@ -1,23 +0,0 @@
-/** Serialized form stored in the snapshot: `m` bits, `k` hashes, bits base64-encoded. */
-export interface BloomJSON {
-    m: number;
-    k: number;
-    bits: string;
-}
-/**
- * Set membership for the test files a snapshot vouches for. A false positive
- * would skip a test the shard never covered, so the default sizing keeps the
- * rate at one in a billion: ~43 bits per entry.
- */
-export declare class BloomFilter {
-    readonly m: number;
-    readonly k: number;
-    private readonly bits;
-    private constructor();
-    static from(keys: Iterable<string>, falsePositiveRate?: number): BloomFilter;
-    static parse(value: unknown): BloomFilter | null;
-    has(key: string): boolean;
-    toJSON(): BloomJSON;
-    /** Kirsch–Mitzenmacher double hashing over the two 64-bit halves of sha256. */
-    private indexes;
-}

package/dist/bloom.js

@@ -1,70 +0,0 @@
-import { createHash } from 'node:crypto';
-/**
- * Set membership for the test files a snapshot vouches for. A false positive
- * would skip a test the shard never covered, so the default sizing keeps the
- * rate at one in a billion: ~43 bits per entry.
- */
-export class BloomFilter {
-    m;
-    k;
-    bits;
-    constructor(m, k, bits) {
-        this.m = m;
-        this.k = k;
-        this.bits = bits;
-    }
-    static from(keys, falsePositiveRate = 1e-9) {
-        const entries = [...keys];
-        const n = Math.max(entries.length, 1);
-        const m = Math.ceil((-n * Math.log(falsePositiveRate)) / Math.LN2 ** 2);
-        const k = Math.max(1, Math.round((m / n) * Math.LN2));
-        const filter = new BloomFilter(m, k, new Uint8Array(Math.ceil(m / 8)));
-        for (const key of entries) {
-            for (const index of filter.indexes(key)) {
-                const byte = index >> 3;
-                filter.bits[byte] = (filter.bits[byte] ?? 0) | (1 << (index & 7));
-            }
-        }
-        return filter;
-    }
-    static parse(value) {
-        if (typeof value !== 'object' || value === null)
-            return null;
-        const { m, k, bits } = value;
-        if (!Number.isInteger(m) ||
-            !Number.isInteger(k) ||
-            m < 1 ||
-            k < 1 ||
-            typeof bits !== 'string') {
-            return null;
-        }
-        const bytes = Buffer.from(bits, 'base64');
-        if (bytes.length !== Math.ceil(m / 8))
-            return null;
-        return new BloomFilter(m, k, new Uint8Array(bytes));
-    }
-    has(key) {
-        for (const index of this.indexes(key)) {
-            if (((this.bits[index >> 3] ?? 0) & (1 << (index & 7))) === 0)
-                return false;
-        }
-        return true;
-    }
-    toJSON() {
-        return {
-            m: this.m,
-            k: this.k,
-            bits: Buffer.from(this.bits).toString('base64'),
-        };
-    }
-    /** Kirsch–Mitzenmacher double hashing over the two 64-bit halves of sha256. */
-    *indexes(key) {
-        const digest = createHash('sha256').update(key).digest();
-        const h1 = digest.readBigUInt64BE(0);
-        const h2 = digest.readBigUInt64BE(8) | 1n;
-        const m = BigInt(this.m);
-        for (let i = 0n; i < BigInt(this.k); i++) {
-            yield Number((h1 + i * h2) % m);
-        }
-    }
-}