oxmutate 1.3.0 → 1.4.0

package/dist/coordinator.d.ts

@@ -23,6 +23,8 @@ export interface MutantResult extends NativeMutant {
     flaky?: boolean | undefined;
     /** Reused from the incremental cache, not run. */
     reused?: boolean | undefined;
+    /** Paths this mutant's run wrote outside the sandbox, found in its unit and put back (diskguard.ts). */
+    wrote?: string[] | undefined;
 }
 export interface TestInfo {
     id: string;
@@ -50,6 +52,8 @@ export interface RunStats {
     canaryFiles: 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. */
+    diskWrites: number;
     /** Survivors of the warm run that a whole-file re-run killed (cross-test effects). */
     survivorsOverturned: number;
     /** Watchdog timeouts that finished when re-run with 3x the budget: the machine was slow, not the mutant. */

package/dist/coordinator.js

@@ -7,6 +7,7 @@ import { checkSurvivors } from './checker.js';
 import { runCommandMutants } from './command-runner.js';
 import { disables } from './config.js';
 import { rangeDisables } from './directives.js';
+import { guardDisk, isClean } from './diskguard.js';
 import { globToRegExp, matchFiles } from './files.js';
 import { changedLines, parseMutateSpec, shardOf, touches, withinRange } from './lanes.js';
 import { native } from './native.js';
@@ -53,7 +54,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, 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, 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}`);
@@ -332,12 +333,58 @@ export async function run(options) {
             return units.sort((a, b) => weight(b) - weight(a));
         };
         const records = [];
+        const disk = env['OXMUTATE_NO_DISKGUARD'] ? undefined : await guardDisk(root);
+        const inFlight = new Set();
+        const tainted = new Set();
+        const writers = new Map();
+        const diskWrittenDuring = async (unit) => {
+            const change = await disk?.check();
+            const dirty = change !== undefined && !isClean(change);
+            if (dirty) {
+                stats.diskWrites++;
+                if (!disk?.restore(change)) {
+                    throw new InstrumentFault(`a mutant wrote outside the sandbox and the project could not be put back: ${[...change.changed, ...change.added, ...change.removed].join(', ')}. fix: restore them (git checkout / git clean), and see which test writes into the project`);
+                }
+                for (const other of inFlight)
+                    tainted.add(other);
+            }
+            if (!dirty && !tainted.delete(unit.results))
+                return undefined;
+            const entry = planUnits.get(unit.results);
+            if (!entry)
+                return [];
+            const ids = [...new Set(Object.values(entry.plan).flat())];
+            const paths = change ? [...change.changed, ...change.added, ...change.removed] : [];
+            if (dirty && ids.length === 1) {
+                const id = ids[0];
+                writers.set(id, paths);
+                if (inFlight.size === 0)
+                    records.push(...readRecords(unit.results));
+                else
+                    unfinished.add(id);
+                return [];
+            }
+            if (entry.depth >= 40) {
+                for (const id of ids)
+                    unfinished.add(id);
+                return [];
+            }
+            if (ids.length < 2)
+                return [makeUnit(entry.file, entry.plan, entry.depth + 1)];
+            const half = new Set(ids.slice(0, Math.ceil(ids.length / 2)));
+            const pick = (inHalf) => Object.fromEntries(Object.entries(entry.plan).map(([t, l]) => [t, l.filter((id) => half.has(id) === inHalf)]).filter(([, l]) => l.length > 0));
+            return [makeUnit(entry.file, pick(true), entry.depth + 1), makeUnit(entry.file, pick(false), entry.depth + 1)];
+        };
         const runaways = new Set();
         const crashedIds = new Set();
         const pool = createPool({ root, vitestConfig: options.vitestConfig, workers: 1, instrumentedMap: mapFile, nodeArgs: options.testRunnerNodeArgs, inlineDeps: true }, options.concurrency, work, 'mutant');
         pools.push(pool);
         const killedSoFar = (spec) => new Set([...runaways, ...crashedIds, ...records.filter((r) => r.type === 'mutant' && r.status !== 'Survived' && Boolean(r.spec) === spec).map((r) => r.id ?? '')]);
-        const afterUnit = (unit, outcome) => {
+        const afterUnit = async (unit, outcome) => {
+            inFlight.delete(unit.results);
+            const wrote = await diskWrittenDuring(unit);
+            if (wrote)
+                return wrote;
             const raw = readRecords(unit.results);
             const suspect = new Set(raw.filter((r) => r.type === 'polluted').flatMap((r) => (r.suspects ?? []).map((id) => `${id}|${r.test ?? ''}`)));
             const recs = raw.filter((r) => !(r.type === 'mutant' && suspect.has(`${r.id ?? ''}|${r.test ?? ''}`)));
@@ -380,6 +427,7 @@ export async function run(options) {
         progress.phase('warm runs', killedCount);
         const m0 = performance.now();
         const beforeUnit = (unit) => {
+            inFlight.add(unit.results);
             const entry = planUnits.get(unit.results);
             if (!entry)
                 return true;
@@ -391,8 +439,10 @@ export async function run(options) {
                 if (keep.length)
                     left[t] = keep;
             }
-            if (Object.keys(left).length === 0)
+            if (Object.keys(left).length === 0) {
+                inFlight.delete(unit.results);
                 return false;
+            }
             entry.plan = left;
             writeFileSync(unit.plan, JSON.stringify({ tests: left, hitLimits, skip: [], specTests: [...specOf.keys()], runOnce: dry.runOnce, testMs: testMsOf(left) }));
             return true;
@@ -670,6 +720,11 @@ export async function run(options) {
         stats.isolatedMs = performance.now() - i0;
         stats.watchdogKills = pool.stats.killed;
         stats.idleStalls = pool.stats.idle;
+        for (const [id, paths] of writers) {
+            const m = byId.get(id);
+            if (m)
+                m.wrote = paths;
+        }
         stats.deadlocks = mutants.filter((m) => m.statusReason === DEADLOCK_REASON).length;
         stats.crashes = pool.stats.crashed;
         if (options.incremental) {

package/dist/diskguard.js

@@ -0,0 +1,92 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { ambientRuntime, run } from 'bellpull';
+export const MAX_SNAPSHOT_BYTES = 64 * 1024 * 1024;
+export const isClean = (c) => c.changed.length + c.added.length + c.removed.length === 0;
+async function git(cwd, args) {
+    const r = await run('git', args, { cwd, runtime: ambientRuntime() }).catch(() => undefined);
+    return r?.ok ? r.stdout : undefined;
+}
+export async function guardDisk(root, maxSnapshotBytes = MAX_SNAPSHOT_BYTES) {
+    const listed = await git(root, ['ls-files', '-z', '--cached', '--', '.']);
+    if (listed === undefined)
+        return undefined;
+    const files = listed.split('\0').filter(Boolean);
+    const tracked = new Map();
+    let bytes = 0;
+    for (const rel of files) {
+        const abs = path.join(root, rel);
+        if (!existsSync(abs))
+            continue;
+        const st = statSync(abs);
+        if (!st.isFile())
+            continue;
+        bytes += st.size;
+        tracked.set(rel, { size: st.size, mtimeMs: st.mtimeMs });
+    }
+    const restorable = bytes <= maxSnapshotBytes;
+    if (restorable)
+        for (const [rel, t] of tracked)
+            t.content = readFileSync(path.join(root, rel));
+    const dirs = new Map();
+    for (const rel of tracked.keys()) {
+        const dir = path.dirname(rel);
+        if (!dirs.has(dir))
+            dirs.set(dir, new Set(readdirSync(path.join(root, dir))));
+    }
+    const knownIgnored = new Map();
+    const ignored = async (rels) => {
+        const ask = rels.filter((rel) => !knownIgnored.has(rel));
+        if (ask.length) {
+            const r = await run('git', ['check-ignore', '--', ...ask], { cwd: root, runtime: ambientRuntime() }).catch(() => undefined);
+            const yes = new Set((r?.stdout ?? '').split('\n').filter(Boolean));
+            for (const rel of ask)
+                knownIgnored.set(rel, yes.has(rel));
+        }
+        return new Set(rels.filter((rel) => knownIgnored.get(rel)));
+    };
+    return {
+        async check() {
+            const changed = [];
+            const removed = [];
+            for (const [rel, t] of tracked) {
+                const abs = path.join(root, rel);
+                if (!existsSync(abs)) {
+                    removed.push(rel);
+                    continue;
+                }
+                const st = statSync(abs);
+                if (st.size !== t.size || st.mtimeMs !== t.mtimeMs)
+                    changed.push(rel);
+            }
+            const fresh = [];
+            for (const [dir, before] of dirs) {
+                const abs = path.join(root, dir);
+                if (!existsSync(abs))
+                    continue;
+                for (const name of readdirSync(abs))
+                    if (!before.has(name))
+                        fresh.push(path.join(dir, name));
+            }
+            const skip = await ignored(fresh);
+            return { changed, added: fresh.filter((rel) => !skip.has(rel)), removed };
+        },
+        restore(change) {
+            if (!restorable)
+                return false;
+            for (const rel of [...change.changed, ...change.removed]) {
+                const t = tracked.get(rel);
+                if (!t?.content)
+                    return false;
+                mkdirSync(path.dirname(path.join(root, rel)), { recursive: true });
+                writeFileSync(path.join(root, rel), t.content);
+                const st = statSync(path.join(root, rel));
+                t.mtimeMs = st.mtimeMs;
+                t.size = st.size;
+            }
+            for (const rel of change.added)
+                rmSync(path.join(root, rel), { recursive: true, force: true });
+            return true;
+        },
+    };
+}

package/dist/reports.js

@@ -96,6 +96,7 @@ function corrections(s) {
     return [
         s.watchdogKills && `${String(s.watchdogKills)} runaway(s) stopped`,
         s.deadlocks && `${String(s.deadlocks)} deadlock(s) called by their worker`,
+        s.diskWrites && `${String(s.diskWrites)} write(s) outside the sandbox put back, their units re-run`,
         s.pollutionRestarts && `${String(s.pollutionRestarts)} polluted context(s) restarted (in ${String(s.canaryFiles)} file(s))`,
         s.flakyMutants && `${String(s.flakyMutants)} flaky verdict(s)`,
         s.survivorsOverturned && `${String(s.survivorsOverturned)} survivor(s) killed by a whole-file re-run`,

package/dist/scheduler.js

@@ -172,7 +172,7 @@ export function createPool(config, size, workDir, tag) {
                     if (outcome.killedFor || outcome.crashed) {
                         servers[slot] = replacement();
                     }
-                    const more = after(unit, outcome);
+                    const more = await after(unit, outcome);
                     queue.unshift(...more);
                     busy--;
                     signal();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxmutate",
-  "version": "1.3.0",
+  "version": "1.4.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": {