oxmutate 2.0.0 → 2.0.2

package/dist/coordinator.js

@@ -54,8 +54,11 @@ function timeoutReason(v) {
         return DEADLOCK_REASON;
     if (v.idle)
         return 'its test waited past the budget with the worker idle: a hang, not a slow test';
+    if (v.slowTwice)
+        return "its tests failed only by their own timeout, in two runs";
     return 'stopped by the watchdog twice, the second time with 3x the budget';
 }
+const slowKill = (v) => v?.status === 'Killed' && v.slow === true;
 const RERUN_SLACK = 3;
 export const MAX_TEST_MS = 5000;
 const MS_PER_MINUTE = 60_000;
@@ -659,7 +662,7 @@ export async function run(options) {
                     if (rec.timeout)
                         verdicts.set(rec.id, { status: 'Timeout', testsCompleted, ...(rec.deadlock && { idle: true, deadlock: true }) });
                     else if (rec.killed)
-                        verdicts.set(rec.id, { status: 'Killed', killedBy: [...(prev?.killedBy ?? []), ...(rec.failed ?? [])], testsCompleted });
+                        verdicts.set(rec.id, { status: 'Killed', killedBy: [...(prev?.killedBy ?? []), ...(rec.failed ?? [])], testsCompleted, slow: rec.slow === true && (prev?.status !== 'Killed' || prev.slow === true) });
                     else
                         verdicts.set(rec.id, { status: prev?.status ?? 'Survived', killedBy: prev?.killedBy, testsCompleted });
                 }
@@ -686,12 +689,19 @@ export async function run(options) {
         progress.phase(`isolated runs (static mutants and stragglers: ${String(isolatedQueue.length)})`);
         const i0 = performance.now();
         const first = await runIsolated(isolatedQueue);
-        const stopped = isolatedQueue.filter((m) => first.get(m.id)?.status === 'Timeout' && !first.get(m.id)?.idle);
+        const stopped = isolatedQueue.filter((m) => (first.get(m.id)?.status === 'Timeout' && !first.get(m.id)?.idle) || slowKill(first.get(m.id)));
         stats.isolatedByCause.rerun += stopped.length;
         const again = await runIsolated(stopped, RERUN_SLACK);
         for (const m of stopped) {
             const v = again.get(m.id);
-            if (v && v.status !== 'Timeout' && v.status !== 'RuntimeError') {
+            if (!v || v.status === 'RuntimeError')
+                continue;
+            if (slowKill(first.get(m.id))) {
+                first.set(m.id, slowKill(v) ? { status: 'Timeout', slowTwice: true, testsCompleted: v.testsCompleted } : v);
+                if (v.status === 'Survived')
+                    stats.timeoutsOverturned++;
+            }
+            else if (v.status !== 'Timeout') {
                 first.set(m.id, v);
                 stats.timeoutsOverturned++;
             }
@@ -709,20 +719,20 @@ export async function run(options) {
         const survivors = toRun.filter((m) => m.status === 'Survived' && new Set(m.coveredBy).size > 1);
         stats.isolatedByCause.confirm += survivors.length;
         const confirmed = await runIsolated(survivors);
-        const stoppedHere = survivors.filter((m) => confirmed.get(m.id)?.status === 'Timeout' && !confirmed.get(m.id)?.idle);
+        const stoppedHere = survivors.filter((m) => (confirmed.get(m.id)?.status === 'Timeout' && !confirmed.get(m.id)?.idle) || slowKill(confirmed.get(m.id)));
         stats.isolatedByCause.rerun += stoppedHere.length;
         const recheck = await runIsolated(stoppedHere, RERUN_SLACK);
         for (const m of stoppedHere) {
             const v = recheck.get(m.id);
             if (v)
-                confirmed.set(m.id, v);
+                confirmed.set(m.id, slowKill(confirmed.get(m.id)) && slowKill(v) ? { status: 'Timeout', slowTwice: true, testsCompleted: v.testsCompleted } : v);
         }
         for (const m of survivors) {
             const v = confirmed.get(m.id);
             if (v && v.status !== 'Survived' && v.status !== 'RuntimeError') {
                 m.status = v.status;
                 m.killedBy = v.killedBy;
-                m.statusReason = 'killed only when the mutant stays active across the whole test file (cross-test effect)';
+                m.statusReason = v.slowTwice ? timeoutReason(v) : 'killed only when the mutant stays active across the whole test file (cross-test effect)';
                 stats.survivorsOverturned++;
             }
         }

package/dist/progress-file.js

@@ -0,0 +1,22 @@
+import { closeSync, openSync, readSync, writeSync } from 'node:fs';
+const MARK_BYTES = 256;
+export function markWriter(file) {
+    const fd = openSync(file, 'w');
+    let length = 0;
+    return {
+        write(text) {
+            const padded = text.padEnd(length);
+            length = padded.length;
+            writeSync(fd, padded, 0);
+        },
+        close: () => closeSync(fd),
+    };
+}
+export function markReader(file) {
+    const fd = openSync(file, 'w+');
+    const buffer = Buffer.alloc(MARK_BYTES);
+    return {
+        read: () => buffer.toString('utf8', 0, readSync(fd, buffer, 0, MARK_BYTES, 0)).trim(),
+        close: () => closeSync(fd),
+    };
+}

package/dist/runner.js

@@ -3,6 +3,7 @@ import { createRequire } from 'node:module';
 import { availableParallelism, loadavg } from 'node:os';
 import path from 'node:path';
 import { BEAT_ENV, markTest, realNow, startHeartbeat } from './heartbeat.js';
+import { markWriter } from './progress-file.js';
 import { isDeadlock, takeFloor, trackRpc, trackTimers, watch } from './quiescence.js';
 import { resolveEsm } from './resolve.js';
 import { ACTIVE_MUTANT_ENV, FILE_KEY, NAMESPACE, cwd, env } from './runtime.js';
@@ -154,8 +155,12 @@ async function probe(test, fn, reset) {
 const POLLUTION_ERROR_CHARS = 300;
 const FILE_ERROR_CHARS = 500;
 let resultsFd;
-let progressFd;
-let markLength = 0;
+let progress;
+const OWN_TIMEOUT = /^(?:Test|Hook) timed out in \d+ms/u;
+function ownTimeout(t) {
+    const errors = t.result?.errors ?? [];
+    return errors.length > 0 && errors.every((e) => OWN_TIMEOUT.test(e.message ?? ''));
+}
 function emit(record) {
     if (!resultsPath)
         return;
@@ -165,19 +170,15 @@ function emit(record) {
 function mark(text) {
     if (!progressPath)
         return;
-    progressFd ??= openSync(progressPath, 'w');
-    const padded = text.trimEnd().padEnd(markLength);
-    markLength = padded.length;
-    if (padded)
-        writeSync(progressFd, padded, 0);
+    progress ??= markWriter(progressPath);
+    progress.write(text);
 }
 function closeFiles() {
-    for (const fd of [resultsFd, progressFd])
-        if (fd !== undefined)
-            closeSync(fd);
+    if (resultsFd !== undefined)
+        closeSync(resultsFd);
+    progress?.close();
     resultsFd = undefined;
-    progressFd = undefined;
-    markLength = 0;
+    progress = undefined;
 }
 function chain(test) {
     const suites = [];
@@ -617,24 +618,32 @@ export default class OxmutateRunner extends Base {
         else if (mode === 'isolated') {
             const failed = [];
             let ran = 0;
+            let decisive = 0;
             const visit = (t) => {
                 if (t.type === 'test' && (t.result?.state === 'pass' || t.result?.state === 'fail'))
                     ran++;
-                if (t.type === 'test' && t.result?.state === 'fail')
+                if (t.type === 'test' && t.result?.state === 'fail') {
                     failed.push(t.id);
+                    if (!ownTimeout(t))
+                        decisive++;
+                }
                 for (const c of t.tasks ?? [])
                     visit(c);
             };
             for (const f of files) {
                 visit(f);
-                if (f.result?.state === 'fail' && !failed.length)
+                if (f.result?.state === 'fail' && !failed.length) {
                     failed.push(f.id);
+                    decisive++;
+                }
             }
             const [first] = files;
+            if (unhandled > 0)
+                decisive++;
             if (unhandled > 0 && !failed.length && first)
                 failed.push(first.id);
             const timeout = ranAway() || deadlocked;
-            emit({ type: 'isolated', id: env[ACTIVE_MUTANT_ENV] ?? ns.activeMutant, killed: failed.length > 0 && !timeout, failed, ran, ...(timeout && { timeout }), ...(deadlocked && { deadlock: true }) });
+            emit({ type: 'isolated', id: env[ACTIVE_MUTANT_ENV] ?? ns.activeMutant, killed: failed.length > 0 && !timeout, failed, ran, ...(timeout && { timeout }), ...(deadlocked && { deadlock: true }), ...(failed.length > 0 && decisive === 0 && { slow: true }) });
         }
         closeFiles();
         return super.onAfterRunFiles?.(files);

package/dist/scheduler.js

@@ -1,14 +1,14 @@
 import { fork } from 'node:child_process';
-import { closeSync, openSync, readFileSync, readSync, writeFileSync } from 'node:fs';
+import { readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { beatFile, classifyStall, CPU_WINDOW_MS, cpuShare, readBeat } from './heartbeat.js';
+import { markReader } from './progress-file.js';
 import { env, stderr } from './runtime.js';
 const childJs = fileURLToPath(new URL('./child.js', import.meta.url));
 const STDERR_TAIL = 4000;
 const WATCHDOG_POLL_MS = 50;
 const CLOSE_GRACE_MS = 2000;
-const PROGRESS_BYTES = 256;
 function inFlight(progress) {
     try {
         return readFileSync(progress, 'utf8').trim().split(' ')[0] || undefined;
@@ -57,8 +57,7 @@ class Server {
         });
     }
     run(unit, budget) {
-        const progress = openSync(unit.progress, 'w+');
-        const mark = Buffer.alloc(PROGRESS_BYTES);
+        const progress = markReader(unit.progress);
         const sent = performance.now();
         return new Promise((resolve) => {
             let settled = false;
@@ -67,13 +66,13 @@ class Server {
                     return;
                 settled = true;
                 clearInterval(timer);
-                closeSync(progress);
+                progress.close();
                 this.onMessage = undefined;
                 this.onExit = undefined;
                 resolve({ ...o, ms: performance.now() - sent });
             };
             const timer = setInterval(() => {
-                const line = mark.toString('utf8', 0, readSync(progress, mark, 0, PROGRESS_BYTES, 0)).trim();
+                const line = progress.read();
                 if (!line)
                     return;
                 const [id = '', since = '0'] = line.split(' ');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxmutate",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "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",
   "author": "Ofri Peretz <ofriperetzdev@gmail.com>",