oxmutate 1.2.2 → 1.2.4

package/dist/command-runner.js

@@ -1,4 +1,4 @@
-import { cpSync, mkdirSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { cpSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { ambientRuntime, run as spawn } from 'bellpull';
 import { ACTIVE_MUTANT_ENV, env } from './runtime.js';
@@ -11,8 +11,28 @@ export function makeSandbox(root) {
     for (const entry of readdirSync(root))
         if (!SKIP.has(entry))
             cpSync(path.join(root, entry), path.join(sandbox, entry), { recursive: true });
+    rebaseExtends(root, sandbox);
     return sandbox;
 }
+const RELATIVE_EXTENDS = /("extends"\s*:\s*")(\.{1,2}\/[^"]*)(")/g;
+function rebaseExtends(from, to) {
+    for (const entry of readdirSync(to, { withFileTypes: true })) {
+        if (SKIP.has(entry.name))
+            continue;
+        const copied = path.join(to, entry.name);
+        if (entry.isDirectory())
+            rebaseExtends(path.join(from, entry.name), copied);
+        else if (/^tsconfig.*\.json$/.test(entry.name)) {
+            const text = readFileSync(copied, 'utf8');
+            const rebased = text.replace(RELATIVE_EXTENDS, (_match, open, rel, close) => {
+                const relative = path.relative(to, path.resolve(from, rel)).split(path.sep).join('/');
+                return `${open}${relative.startsWith('.') ? relative : `./${relative}`}${close}`;
+            });
+            if (rebased !== text)
+                writeFileSync(copied, rebased);
+        }
+    }
+}
 const MS_PER_MINUTE = 60_000;
 const OUTPUT_TAIL = 1500;
 const PROCESS_SLACK_MS = 5000;

package/dist/coordinator.js

@@ -159,7 +159,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 };
+            return { tests: recs.flatMap((r) => r.tests ?? []), perTest, static: stat, runOnce: recs.flatMap((r) => r.runOnce ?? []) };
         };
         progress.phase('dry run');
         const d0 = performance.now();
@@ -287,7 +287,7 @@ export async function run(options) {
         const unfinished = new Set();
         const makeUnit = (file, plan, depth = 0) => {
             const unit = { mode: 'mutant', files: [file], results: fileFor('unit', 'jsonl'), progress: fileFor('unit', 'progress'), plan: fileFor('plan', 'json') };
-            writeFileSync(unit.plan, JSON.stringify({ tests: plan, hitLimits, skip: [], specTests: [...specOf.keys()] }));
+            writeFileSync(unit.plan, JSON.stringify({ tests: plan, hitLimits, skip: [], specTests: [...specOf.keys()], runOnce: dry.runOnce }));
             planUnits.set(unit.results, { file, plan, depth });
             stats.units++;
             return unit;
@@ -384,7 +384,7 @@ export async function run(options) {
             if (Object.keys(left).length === 0)
                 return false;
             entry.plan = left;
-            writeFileSync(unit.plan, JSON.stringify({ tests: left, hitLimits, skip: [], specTests: [...specOf.keys()] }));
+            writeFileSync(unit.plan, JSON.stringify({ tests: left, hitLimits, skip: [], specTests: [...specOf.keys()], runOnce: dry.runOnce }));
             return true;
         };
         await pool.drain(unitsForRound(toRun, (m) => fileOrder.get(m.id) ?? []), (_, id) => warmBudget(id), afterUnit, beforeUnit);

package/dist/runner.d.ts

@@ -26,7 +26,18 @@ declare const OxmutateRunner_base: new (config: unknown) => {
     onBeforeCollect?(paths: string[]): unknown;
     importFile?(filepath: string, source: string): unknown;
     onBeforeRunSuite?(suite: AnyTask): unknown;
+    onAfterRunSuite?(suite: AnyTask): unknown;
+    onBeforeRunTask?(test: AnyTask): unknown;
     onCollectStart?(file: unknown): unknown;
+    /** Vitest's own: the current task, and the module graph a test file is invalidated in (Vitest 4). */
+    workerState?: {
+        current?: unknown;
+        evaluatedModules?: {
+            getModuleById: (id: string) => unknown;
+            invalidateModule: (node: unknown) => void;
+        };
+    };
+    _currentSpecification?: unknown;
     onBeforeTryTask?(test: AnyTask, options: {
         retry: number;
         repeats: number;
@@ -53,6 +64,7 @@ export default class OxmutateRunner extends OxmutateRunner_base {
      * each time (the family's colour setup sets TERM, COLORTERM and NO_COLOR), so they are not leaks.
      */
     importFile(filepath: string, source: string): unknown;
+    onAfterRunSuite(suite: AnyTask): Promise<unknown>;
     onBeforeRunSuite(suite: AnyTask): Promise<unknown>;
     /**
      * `static` mode (.sdlc/intents/oxmutate/staticwarm.qnt). Re-evaluating the project's modules in
@@ -63,6 +75,17 @@ export default class OxmutateRunner extends OxmutateRunner_base {
      * rest of the batch back to the fresh-worker path.
      */
     private decideStatic;
+    /**
+     * Collected here, before Vitest marks the test running: it refuses `it()` inside a running test.
+     * A file whose copies cannot be collected falls back to the canary restarting its context.
+     */
+    onBeforeRunTask(test: AnyTask): Promise<unknown>;
+    /**
+     * Fresh collections of `filepath` until there are `count`. Only the test file is evaluated again
+     * (Vitest 5 re-imports it; on Vitest 4 its module is invalidated first), so each costs the file's
+     * own top level, not its imports.
+     */
+    private collectCopies;
     /** Reset per-try state (snapshot counters, assertion counts) the way Vitest does for a retry. */
     private retryReset;
     onAfterRunFiles(files: AnyTask[]): unknown;

package/dist/runner.js

@@ -82,6 +82,60 @@ let polluted = false;
 const STATIC_CANARY_MAX = 4;
 let canaryEvery = 1;
 const MAX_CANARY_EVERY = 8;
+const runOnce = new Set(mode === 'mutant' ? (plan.runOnce ?? []) : []);
+const probed = new Set();
+const collections = new Map();
+const taken = new Map();
+const RUNS_PER_MUTANT = 4;
+const RUNS_AFTER = 2;
+async function findCollect() {
+    const browser = (await fromProject('vitest/internal/browser').catch(() => ({})));
+    if (browser.collectTests)
+        return browser.collectTests;
+    const vitestDir = path.dirname(createRequire(path.join(cwd(), 'package.json')).resolve('vitest/package.json'));
+    return (await fromProject('@vitest/runner', vitestDir).catch(() => ({}))).collectTests;
+}
+let collector;
+const loadCollect = () => (collector ??= findCollect());
+const find = (t, id) => (t.id === id ? t : t.tasks?.reduce((hit, c) => hit ?? find(c, id), undefined));
+const hasBeforeAll = (t) => t.type !== 'test' && (statics.getSuiteHooks(t).beforeAll.length > 0 || (t.tasks ?? []).some(hasBeforeAll));
+async function afterAllOf(t) {
+    if (t.type === 'test')
+        return;
+    for (const c of t.tasks ?? [])
+        await afterAllOf(c);
+    for (const hook of statics.getSuiteHooks(t).afterAll)
+        await hook(t);
+}
+function takeCopy(test) {
+    const n = taken.get(test.id) ?? 0;
+    taken.set(test.id, n + 1);
+    const file = collections.get(test.file?.filepath ?? '')?.[n];
+    return file && find(file, test.id);
+}
+const PROBE_ID = '__oxmutate_probe__';
+async function probe(test, fn) {
+    const file = test.file?.filepath;
+    if (!file || probed.has(file))
+        return;
+    probed.add(file);
+    await afterEach(test, test.context, []);
+    const cleanups = await beforeEach(test, test.context);
+    ns.currentTestId = PROBE_ID;
+    try {
+        await fn();
+    }
+    catch {
+        runOnce.add(file);
+    }
+    finally {
+        ns.currentTestId = test.id;
+        if (ns.mutantCoverage)
+            delete ns.mutantCoverage.perTest[PROBE_ID];
+        for (const cleanup of cleanups.reverse())
+            await cleanup();
+    }
+}
 const POLLUTION_ERROR_CHARS = 300;
 const FILE_ERROR_CHARS = 500;
 function emit(record) {
@@ -194,24 +248,38 @@ export default class OxmutateRunner extends Base {
             markTest(true);
             try {
                 await fn();
+                if (mode === 'dry')
+                    await probe(test, fn);
             }
             finally {
                 markTest(false);
             }
             return;
         }
-        const context = test.context;
+        let current = test;
+        let run = fn;
+        let context = test.context;
+        let invoked = false;
         const spec = specTests.has(test.id);
         const done = spec ? decidedBySpec : decided;
         const ids = polluted ? [] : (plan.tests[test.id] ?? []).filter((id) => !done.has(id));
         let cleanups = [];
         let attempt = 0;
         const teardown = async () => {
-            await afterEach(test, context, cleanups);
+            await afterEach(current, context, cleanups);
             cleanups = [];
         };
         const setup = async () => {
-            cleanups = await beforeEach(test, context);
+            if (invoked && test.file && runOnce.has(test.file.filepath)) {
+                const copy = takeCopy(test);
+                if (!copy)
+                    throw new Error('oxmutate: a run-once test ran out of fresh collections');
+                current = copy;
+                run = statics.getTestFn(copy) ?? fn;
+                context = copy.context;
+            }
+            invoked = true;
+            cleanups = await beforeEach(current, context);
             await this.retryReset(test, ++attempt);
         };
         const fresh = async () => {
@@ -224,7 +292,7 @@ export default class OxmutateRunner extends Base {
                 return true;
             await fresh();
             try {
-                await fn();
+                await run();
                 unchecked = [];
                 canaryEvery = Math.min(MAX_CANARY_EVERY, canaryEvery * 2);
                 return true;
@@ -245,7 +313,7 @@ export default class OxmutateRunner extends Base {
             let status = 'Survived';
             try {
                 await setup();
-                await fn();
+                await run();
             }
             catch (e) {
                 status = isHitLimit(e) ? 'Timeout' : 'Killed';
@@ -282,7 +350,7 @@ export default class OxmutateRunner extends Base {
         if (attempt > 0)
             await fresh();
         try {
-            await fn();
+            await run();
         }
         finally {
             for (const cleanup of cleanups.reverse())
@@ -294,6 +362,15 @@ export default class OxmutateRunner extends Base {
             pristine = snapshot();
         return super.importFile?.(filepath, source);
     }
+    async onAfterRunSuite(suite) {
+        const copies = suite.filepath ? collections.get(suite.filepath) : undefined;
+        if (suite.filepath && copies) {
+            collections.delete(suite.filepath);
+            for (const copy of copies)
+                await afterAllOf(copy);
+        }
+        return super.onAfterRunSuite?.(suite);
+    }
     async onBeforeRunSuite(suite) {
         if (mode === 'static' && suite.filepath && staticIds.length)
             await this.decideStatic(suite);
@@ -374,6 +451,44 @@ export default class OxmutateRunner extends Base {
             writeFileSync(progressPath, '');
         vi.resetModules();
     }
+    async onBeforeRunTask(test) {
+        const filepath = test.file?.filepath;
+        if (mode === 'mutant' && !polluted && filepath && runOnce.has(filepath)) {
+            const done = specTests.has(test.id) ? decidedBySpec : decided;
+            const runs = (plan.tests[test.id] ?? []).filter((id) => !done.has(id)).length * RUNS_PER_MUTANT + RUNS_AFTER;
+            if (!(await this.collectCopies(filepath, (taken.get(test.id) ?? 0) + runs)))
+                runOnce.delete(filepath);
+        }
+        return super.onBeforeRunTask?.(test);
+    }
+    async collectCopies(filepath, count) {
+        const files = collections.get(filepath) ?? [];
+        collections.set(filepath, files);
+        if (files.length >= count)
+            return true;
+        const collect = await loadCollect();
+        if (!collect)
+            return false;
+        const { workerState } = this;
+        const was = { current: workerState?.current, spec: this._currentSpecification };
+        try {
+            while (files.length < count) {
+                const node = workerState?.evaluatedModules?.getModuleById(filepath);
+                if (node)
+                    workerState?.evaluatedModules?.invalidateModule(node);
+                const [file] = await collect([filepath], this);
+                if (!file || file.result?.state === 'fail' || hasBeforeAll(file))
+                    return false;
+                files.push(file);
+            }
+            return true;
+        }
+        finally {
+            if (workerState)
+                workerState.current = was.current;
+            this._currentSpecification = was.spec;
+        }
+    }
     async retryReset(test, attempt) {
         await super.onBeforeTryTask?.(test, { retry: attempt, repeats: 0 });
     }
@@ -394,7 +509,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 });
+            emit({ type: 'dry', tests, coverage: ns.mutantCoverage, fileErrors, runOnce: [...runOnce] });
         }
         else if (mode === 'isolated') {
             const failed = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxmutate",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "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": {