oxmutate 1.4.0 → 1.5.0

package/dist/coordinator.d.ts

@@ -50,6 +50,9 @@ export interface RunStats {
     idleStalls: number;
     crashes: number;
     canaryFiles: number;
+    /** Of the verdicts the incremental cache would have reused, how many were run afresh to check it, and how many disagreed on detected or not. */
+    auditSampled: number;
+    auditDisagreed: number;
     /** Contexts restarted because a mutant left state behind (the per-execution canary fired). */
     pollutionRestarts: number;
     /** Units after which the project on disk had changed (diskguard.ts): put back, and their verdicts and those of the units running beside them re-run. */

package/dist/coordinator.js

@@ -12,6 +12,7 @@ import { globToRegExp, matchFiles } from './files.js';
 import { changedLines, parseMutateSpec, shardOf, touches, withinRange } from './lanes.js';
 import { native } from './native.js';
 import { startProgress } from './progress.js';
+import { VERSION } from './reports.js';
 import { FILE_KEY, env, stderr } from './runtime.js';
 import { createPool } from './scheduler.js';
 import { summarizeSpec, tracesFor } from './spec-oracle.js';
@@ -27,7 +28,26 @@ function readRecords(file) {
         .map((l) => JSON.parse(l));
 }
 const sha = (s) => createHash('sha256').update(s).digest('hex').slice(0, 16);
+const LOCKFILES = ['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lock', 'bun.lockb'];
+function lockfileHash(root) {
+    const found = LOCKFILES.map((f) => path.join(root, f)).find((f) => existsSync(f));
+    if (found)
+        return sha(readFileSync(found, 'utf8'));
+    const above = path.dirname(root);
+    return above === root ? 'none' : lockfileHash(above);
+}
+const verdictOptions = (o) => ({
+    timeoutMS: o.timeoutMS,
+    timeoutFactor: o.timeoutFactor,
+    excludedMutations: [...o.excludedMutations].sort(),
+    ignoreStatic: o.ignoreStatic,
+    strykerCompat: o.strykerCompat,
+    testOverrides: o.testOverrides,
+    vitestConfig: o.vitestConfig && existsSync(o.vitestConfig) ? sha(readFileSync(o.vitestConfig, 'utf8')) : null,
+});
 const UNIT_PAIRS = 400;
+const detected = (s) => s === 'Killed' || s === 'Timeout';
+const AUDIT_SHARE = 0.05;
 const DEADLOCK_REASON = 'its test deadlocked: nothing left in the worker could resume it (a hang, called in under a second)';
 function timeoutReason(v) {
     if (v.deadlock)
@@ -54,7 +74,7 @@ export async function run(options) {
     const work = mkdtempSync(path.join(tmpdir(), 'oxmutate-'));
     const stats = {
         files: 0, mutants: 0, instrumentMs: 0, dryRunMs: 0, mutationMs: 0, staticMs: 0, staticRecollections: 0, isolatedMs: 0, wallMs: 0, testExecutions: 0,
-        watchdogKills: 0, idleStalls: 0, deadlocks: 0, crashes: 0, canaryFiles: 0, pollutionRestarts: 0, diskWrites: 0, survivorsOverturned: 0, timeoutsOverturned: 0, compileErrors: 0, isolatedRuns: 0, reused: 0, flakyTests: 0, flakyMutants: 0, units: 0, serversSpawned: 0,
+        watchdogKills: 0, idleStalls: 0, deadlocks: 0, crashes: 0, canaryFiles: 0, pollutionRestarts: 0, diskWrites: 0, auditSampled: 0, auditDisagreed: 0, survivorsOverturned: 0, timeoutsOverturned: 0, compileErrors: 0, isolatedRuns: 0, reused: 0, flakyTests: 0, flakyMutants: 0, units: 0, serversSpawned: 0,
     };
     let unitSeq = 0;
     const fileFor = (kind, ext) => path.join(work, `${kind}-${String(unitSeq++)}.${ext}`);
@@ -169,7 +189,7 @@ export async function run(options) {
             if (fileErrors.length) {
                 throw new InstrumentFault(`${String(fileErrors.length)} test file(s) failed to load during the dry run, so their tests would be missing from every verdict: ${fileErrors.slice(0, 3).map((e) => `${path.relative(root, e.file)}: ${e.error}`).join('; ')}`);
             }
-            return { tests: recs.flatMap((r) => r.tests ?? []), perTest, static: stat, runOnce: recs.flatMap((r) => r.runOnce ?? []) };
+            return { tests: recs.flatMap((r) => r.tests ?? []), perTest, static: stat, runOnce: recs.flatMap((r) => r.runOnce ?? []), modules: Object.assign({}, ...recs.map((r) => r.modules ?? {})) };
         };
         progress.phase('dry run');
         const d0 = performance.now();
@@ -263,13 +283,23 @@ export async function run(options) {
             }
             return h;
         };
-        const fingerprint = (m) => sha([sha(sources[m.file] ?? ''), ...[...new Set(m.coveredBy.map((t) => testInfo.get(t)?.file ?? ''))].sort().map(fileHash)].join(':'));
+        const envKey = sha(JSON.stringify({ oxmutate: VERSION, node: process.version, lock: lockfileHash(root), options: verdictOptions(options) }));
+        const fingerprint = (m) => {
+            const testFiles = new Set([...m.coveredBy.map((t) => testInfo.get(t)?.file ?? ''), ...(staticFiles.get(m.id) ?? [])]);
+            const graph = new Set([...testFiles].flatMap((f) => dry.modules[f] ?? []).filter((f) => !testFiles.has(f) && f !== path.join(root, m.file)));
+            return sha([envKey, sha(sources[m.file] ?? ''), ...[...testFiles].sort().map(fileHash), '|', ...[...graph].sort().map((f) => `${f}=${fileHash(f)}`)].join(':'));
+        };
+        const audited = new Map();
         const cache = options.incremental && existsSync(options.incrementalFile) ? JSON.parse(readFileSync(options.incrementalFile, 'utf8')).mutants : {};
         for (const m of mutants) {
             if (m.status === 'Ignored' || (!m.static && m.coveredBy.length === 0))
                 continue;
             const hit = cache[m.id];
             if (hit && hit.fp === fingerprint(m)) {
+                if (Math.random() < AUDIT_SHARE) {
+                    audited.set(m.id, hit.status);
+                    continue;
+                }
                 m.status = hit.status;
                 m.killedBy = hit.killedBy;
                 m.testsCompleted = hit.testsCompleted;
@@ -729,7 +759,11 @@ export async function run(options) {
         stats.crashes = pool.stats.crashed;
         if (options.incremental) {
             mkdirSync(path.dirname(options.incrementalFile), { recursive: true });
-            const next = { ...cache };
+            stats.auditSampled = audited.size;
+            stats.auditDisagreed = [...audited].filter(([id, was]) => detected(byId.get(id)?.status) !== detected(was)).length;
+            if (stats.auditDisagreed > 0)
+                stderr.write(`oxmutate: ${String(stats.auditDisagreed)} of ${String(audited.size)} audited cached verdicts disagree with a fresh run; the incremental cache is rebuilt from this run\n`);
+            const next = stats.auditDisagreed > 0 ? {} : { ...cache };
             for (const m of mutants) {
                 if (['Killed', 'Survived', 'Timeout'].includes(m.status) && !m.flaky)
                     next[m.id] = { fp: fingerprint(m), status: m.status, killedBy: m.killedBy, testsCompleted: m.testsCompleted };

package/dist/reports.js

@@ -102,7 +102,7 @@ function corrections(s) {
         s.survivorsOverturned && `${String(s.survivorsOverturned)} survivor(s) killed by a whole-file re-run`,
         s.timeoutsOverturned && `${String(s.timeoutsOverturned)} timeout(s) that finished given 3x the time`,
         s.compileErrors && `${String(s.compileErrors)} survivor(s) that do not type-check, out of the score`,
-        s.reused && `${String(s.reused)} verdict(s) reused`,
+        s.reused && `${String(s.reused)} verdict(s) reused${s.auditSampled ? ` (${String(s.auditSampled)} audited, ${String(s.auditDisagreed)} disagreeing)` : ''}`,
         s.crashes && `${String(s.crashes)} worker crash(es)`,
     ].filter((c) => Boolean(c));
 }

package/dist/runner.d.ts

@@ -35,6 +35,7 @@ declare const OxmutateRunner_base: new (config: unknown) => {
         evaluatedModules?: {
             getModuleById: (id: string) => unknown;
             invalidateModule: (node: unknown) => void;
+            fileToModulesMap?: Map<string, unknown>;
         };
     };
     _currentSpecification?: unknown;

package/dist/runner.js

@@ -120,6 +120,7 @@ function takeCopy(test) {
     const file = collections.get(test.file?.filepath ?? '')?.[n];
     return file && find(file, test.id);
 }
+const dryModules = new Map();
 const PROBE_ID = '__oxmutate_probe__';
 async function probe(test, fn) {
     const file = test.file?.filepath;
@@ -425,6 +426,10 @@ export default class OxmutateRunner extends Base {
         return super.importFile?.(filepath, source);
     }
     async onAfterRunSuite(suite) {
+        if (mode === 'dry' && suite.filepath) {
+            const files = [...(this.workerState?.evaluatedModules?.fileToModulesMap?.keys() ?? [])];
+            dryModules.set(suite.filepath, files.filter((f) => path.isAbsolute(f) && !f.split(path.sep).includes('node_modules')));
+        }
         const copies = suite.filepath ? collections.get(suite.filepath) : undefined;
         if (suite.filepath && copies) {
             collections.delete(suite.filepath);
@@ -574,7 +579,7 @@ export default class OxmutateRunner extends Base {
                 if (result?.state === 'fail' && !f.tasks?.length)
                     fileErrors.push({ file: filepath, error: (result.errors?.[0]?.message ?? 'failed to collect').slice(0, FILE_ERROR_CHARS) });
             }
-            emit({ type: 'dry', tests, coverage: ns.mutantCoverage, fileErrors, runOnce: [...runOnce] });
+            emit({ type: 'dry', tests, coverage: ns.mutantCoverage, fileErrors, runOnce: [...runOnce], modules: Object.fromEntries(dryModules) });
         }
         else if (mode === 'isolated') {
             const failed = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxmutate",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Mutation testing for JavaScript and TypeScript on the oxc engine, run warm inside the project's own Vitest, with CI lanes, SARIF and an agent surface. No dependency outside the burgee family. A Stryker migration path.",
   "license": "MIT",
   "repository": {