supercov 4.20.3 → 4.22.0

package/README.md

@@ -411,3 +411,4 @@ Ask questions, share what you measured, and talk to the people building Supercov
 - [@Uhbif2](https://github.com/Uhbif2)
 - [@maik-intellicoach](https://github.com/maik-intellicoach)
 - [@untitaker](https://github.com/untitaker)
+- [@artile](https://github.com/artile)

package/docs/cli.md

@@ -926,6 +926,7 @@ terminal or offline environment after the package has been downloaded.
 | `SUPERCOV_RUN_ID` | Set by Supercov, not by you: in every process a measured command starts, the run's id, so a test or harness can tell it is measured |
 | `SUPERCOV_RUN_ID_FILE` | A file to write the recorded run's id to, for a script to query that run rather than `latest` |
 | `SUPERCOV_KEEP_WORKSPACE` | Set to `1` to leave the instrumented copy of the project in `.supercov/workspaces/` after the run, to inspect what the command ran |
+| `SUPERCOV_COMMAND_TIMEOUT_MS` | Stop the test command after this many milliseconds: what is still running is asked to stop, then made to five seconds later, what ran is recorded, and Supercov exits `124`. No deadline by default |
 
 Examples:
 
@@ -941,6 +942,7 @@ SUPERCOV_TEST_KIND=e2e npx supercov -- npx playwright test
 | `0` | The command or query succeeded |
 | Wrapped command's code | The test command failed and Supercov preserved its status |
 | `127`, `126` | The test command could not start: no such program, or one that may not be run, as a shell reports it |
+| `124` | The test command ran past `SUPERCOV_COMMAND_TIMEOUT_MS` and was stopped |
 | `1` | A valid measurement failed a policy you set, such as a coverage floor |
 | `2` | Supercov could not complete the request, or the evidence cannot answer it |
 

package/docs/supported-suites.md

@@ -52,6 +52,7 @@ Supercov reports the level it actually observed. It does not guess.
 | Vitest | Exact per test, with setup execution kept separate; Browser Mode included |
 | Jest | Exact per test, including parameterized tests, with the user's own configuration, setup files and reporters kept |
 | `node:test` | Exact per test |
+| `bun:test` (Bun 1.2.17 and 1.4.4 verified) | Exact test-body coverage, including concurrent and parameterized tests; lifecycle hooks recorded as setup |
 | Mocha | Exact per test and retry, `--parallel` included, with setup execution kept separate |
 | AVA | Exact per test, concurrent tests included, in worker threads or child processes |
 | node-tap 15 and newer | Exact per subtest, nested and parallel (`t.jobs`) subtests included |
@@ -61,6 +62,28 @@ Supercov reports the level it actually observed. It does not guess.
 One command may launch several runners. Supercov combines their evidence into
 one run and preserves runner identity wherever the runner exposes it.
 
+### Bun
+
+Run `supercov -- bun test` or the package script that launches it. Supercov
+loads a native Bun adapter through `BUN_OPTIONS`, preserving existing Bun
+options, configured preloads, and the project's files. Named ESM imports,
+namespace imports, and CommonJS `require('bun:test')` are supported. Bun ignores
+Node's preload settings, so the Node adapter alone cannot attribute its tests.
+
+Synchronous `describe` boundaries form the test title. Parameterized rows use
+the registration's title template and original row index in Supercov's queries;
+Bun keeps its own formatted reporter titles. Async test bodies retain their
+identity across `await`, including concurrent execution. Lifecycle hooks have
+separate setup identities and do not credit their coverage to the test body.
+
+Callback completion supplies the recorded outcome. If Bun interrupts a callback
+before it completes, Supercov preserves its named coverage with an **unknown**
+outcome. Bun's final runner verdict can additionally reflect a timeout, hook
+failure, assertion-count check, or unhandled error outside that callback; those
+verdicts are not inferred from callback completion. The measured command's exit
+status remains Bun's own. Coverage from an API copied by a module mock before
+adaptation may remain unattributed.
+
 ### Vitest Browser Mode
 
 Vitest Browser Mode runs the test file in a real browser. Supercov measures it

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supercov",
-  "version": "4.20.3",
+  "version": "4.22.0",
   "description": "Coverage, security and code quality for coding agents",
   "keywords": [
     "coverage",
@@ -122,14 +122,14 @@
     "test:windows-tls": "node scripts/windows-tls-test.mjs"
   },
   "optionalDependencies": {
-    "@supercov/cli-darwin-arm64": "4.20.3",
-    "@supercov/cli-darwin-x64": "4.20.3",
-    "@supercov/cli-linux-arm64-gnu": "4.20.3",
-    "@supercov/cli-linux-arm64-musl": "4.20.3",
-    "@supercov/cli-linux-x64-gnu": "4.20.3",
-    "@supercov/cli-linux-x64-musl": "4.20.3",
-    "@supercov/cli-win32-arm64": "4.20.3",
-    "@supercov/cli-win32-x64": "4.20.3"
+    "@supercov/cli-darwin-arm64": "4.22.0",
+    "@supercov/cli-darwin-x64": "4.22.0",
+    "@supercov/cli-linux-arm64-gnu": "4.22.0",
+    "@supercov/cli-linux-arm64-musl": "4.22.0",
+    "@supercov/cli-linux-x64-gnu": "4.22.0",
+    "@supercov/cli-linux-x64-musl": "4.22.0",
+    "@supercov/cli-win32-arm64": "4.22.0",
+    "@supercov/cli-win32-x64": "4.22.0"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.55.0",

package/runtime/javascript/bunTest.mjs

@@ -0,0 +1,185 @@
+// Bun does not load the Node --import preload. BUN_OPTIONS loads this before
+// its test files and their configured preloads. Older Bun versions create a
+// native API per file; newer versions share one. Adapt the factory and the
+// existing API so both keep native test registration and execution semantics.
+import * as runtime from "./runtime.mjs";
+import { callerLocation, runnerExecutionScope, runnerTestId, writeRunnerEvidence } from "./runnerEvidence.mjs";
+
+const adapted = new WeakSet();
+const nativeJest = Bun.jest;
+const attempts = new Map();
+function writeEvidence(identity, status, scope, directory, phases = [], source) {
+    return writeRunnerEvidence(identity, status, scope, directory, phases, source, true);
+}
+const previousPhaseObserver = globalThis.__SUPERCOV_ASSERTION_PHASE_STARTED__;
+globalThis.__SUPERCOV_ASSERTION_PHASE_STARTED__ = (scope, phase) => {
+    previousPhaseObserver?.(scope, phase);
+    const attempt = attempts.get(scope.attemptId);
+    if (attempt) {
+        attempt.phases.push(phase);
+        writeEvidence(attempt.identity, "unknown", scope, undefined, attempt.phases);
+    }
+};
+function adapt(api) {
+    if (adapted.has(api)) return api;
+    adapted.add(api);
+    const originals = { ...api };
+    let suites = [];
+    const registrations = new Map();
+    const evidenceDirectory = process.env.SUPERCOV_EVIDENCE_DIR;
+
+    function callbackIndex(args) {
+        return args.findLastIndex(value => typeof value === "function");
+    }
+
+    function wrap(original, kind, flags = {}, row = {}) {
+        const members = new Map();
+        function supercovBunRegistration(...args) {
+            const index = callbackIndex(args);
+            const callback = index < 0 ? undefined : args[index];
+            const name = row.name ?? (typeof args[0] === "string" ? args[0] : callback?.name || "anonymous test");
+            const location = row.location ?? callerLocation(supercovBunRegistration);
+            if (kind === "suite") {
+                if (!callback) return Reflect.apply(original, this, args);
+                const next = [...args];
+                next[index] = function () {
+                    const values = [...arguments];
+                    const parent = suites;
+                    suites = [...parent, { name, flags }];
+                    try { return Reflect.apply(callback, this, values); }
+                    finally { suites = parent; }
+                };
+                return Reflect.apply(original, this, next);
+            }
+            const identity = {
+                runner: "bun:test",
+                name: kind === "test" ? [...suites.map(suite => suite.name), name].join(" > ") : `[${kind}] ${name}`,
+                ...location,
+                ...(location.line === undefined ? {} : { column: 1 }),
+                ...(kind === "test" ? {} : { role: "setup" }),
+            };
+            const key = runnerTestId(identity);
+            identity.registrationOrdinal = registrations.get(key) ?? 0;
+            registrations.set(key, identity.registrationOrdinal + 1);
+            const effective = {};
+            for (const active of [...suites.map(suite => suite.flags), flags]) {
+                for (const [key, value] of Object.entries(active)) effective[key] ||= value;
+            }
+            if (!callback) {
+                const result = Reflect.apply(original, this, args);
+                writeEvidence(identity, effective.todo ? "todo" : "skipped", runnerExecutionScope(identity), evidenceDirectory);
+                return result;
+            }
+            let attempt = 0;
+            const next = [...args];
+            next[index] = function () {
+                const values = [...arguments];
+                const current = { ...identity, retry: attempt++ };
+                const scope = runnerExecutionScope(current);
+                // Bun may terminate a timed-out callback without running its
+                // finally or Node exit hooks. Persist identity before execution,
+                // and use the runtime's per-turn transport instead of buffering
+                // the whole attempt until callback completion.
+                attempts.set(scope.attemptId, { identity: current, phases: [] });
+                writeEvidence(current, "unknown", scope, evidenceDirectory);
+                let finished = false;
+                function finish(failed = false) {
+                    if (finished) return;
+                    finished = true;
+                    attempts.delete(scope.attemptId);
+                    const status = effective.todo ? "todo" : failed === Boolean(effective.failing) ? "passed" : "failed";
+                    writeEvidence(current, status, scope, evidenceDirectory, runtime.takeNodeAssertionPhases(scope));
+                }
+                const actual = [...values];
+                const bound = row.bound ?? 0;
+                if (callback.length > bound && typeof actual[bound] === "function") {
+                    const done = actual[bound];
+                    actual[bound] = error => { finish(error != null); return done(error); };
+                }
+                try {
+                    const result = runtime.withCoverageCarrier({ version: 1, scope }, () => Reflect.apply(callback, this, actual));
+                    if (result && typeof result.then === "function") {
+                        return Promise.resolve(result).then(value => { finish(); return value; }, error => { finish(true); throw error; });
+                    }
+                    if (callback.length <= bound) finish();
+                    return result;
+                } catch (error) {
+                    finish(true);
+                    throw error;
+                }
+            };
+            Object.defineProperty(next[index], "length", { value: callback.length });
+            const result = Reflect.apply(original, this, next);
+            if (effective.skip || effective.todo) {
+                writeEvidence(identity, effective.todo ? "todo" : "skipped", runnerExecutionScope(identity), evidenceDirectory);
+            }
+            return result;
+        }
+        return new Proxy(supercovBunRegistration, {
+            get(target, property) {
+                if (["call", "apply", "bind"].includes(property)) return Reflect.get(target, property);
+
+                if (members.has(property)) return members.get(property);
+                const member = Reflect.get(original, property, original);
+                if (typeof member !== "function") return member;
+                if (property === "each") {
+                    const each = table => {
+                        const nativeEach = Reflect.apply(member, original, [table]);
+                        if (!Array.isArray(table) || table.length === 0) return nativeEach;
+                        return function supercovBunEach(...args) {
+                            const location = callerLocation(supercovBunEach);
+                            for (const [index, value] of table.entries()) {
+                                const bound = Array.isArray(value) ? value.length : 1;
+                                const next = [...args];
+                                // Keep Bun's own formatting and binding. Only %# needs
+                                // the original index when registering one row at a time.
+                                let consumed = 0;
+                                if (typeof next[0] === "string") next[0] = next[0].replace(/%([sidfjop#%])/g, (token, format) => {
+                                    if (consumed >= bound) return token;
+                                    if (format === "#") return String(index);
+                                    if (format !== "%") consumed++;
+                                    return token;
+                                });
+                                const register = Reflect.apply(member, original, [[value]]);
+                                Reflect.apply(wrap(register, kind, flags, {
+                                    location, bound,
+                                    name: `${args[0]} [row ${index + 1}]`,
+                                }), this, next);
+                            }
+                        };
+                    };
+                    members.set(property, each);
+                    return each;
+                }
+                if (["skip", "todo", "only", "concurrent", "serial", "failing"].includes(property)) {
+                    const wrapped = wrap(member, kind, { ...flags, [property]: true });
+                    members.set(property, wrapped);
+                    return wrapped;
+                }
+                if (["if", "skipIf", "todoIf", "failingIf", "concurrentIf", "serialIf"].includes(property)) {
+                    return (...values) => wrap(Reflect.apply(member, original, values), kind, {
+                        ...flags,
+                        [property === "if" ? "skip" : property.slice(0, -2)]: flags[property === "if" ? "skip" : property.slice(0, -2)] || (property === "if" ? !values[0] : Boolean(values[0])),
+                    });
+                }
+                return member.bind(original);
+            },
+        });
+    }
+
+    api.test = api.it = wrap(originals.test, "test");
+    api.describe = wrap(originals.describe, "suite");
+    for (const [name, kind, flags] of [
+        ["xtest", "test", { skip: true }], ["xit", "test", { skip: true }],
+        ["xdescribe", "suite", { skip: true }],
+        ["beforeAll", "beforeAll", {}], ["afterAll", "afterAll", {}],
+        ["beforeEach", "beforeEach", {}], ["afterEach", "afterEach", {}],
+    ]) {
+        if (typeof originals[name] === "function") api[name] = wrap(originals[name], kind, flags);
+    }
+    return api;
+}
+if (typeof nativeJest === "function") {
+    Bun.jest = function (...args) { return adapt(Reflect.apply(nativeJest, this, args)); };
+    adapt(Reflect.apply(nativeJest, Bun, [import.meta.path]));
+}

package/runtime/javascript/provenance.mjs

@@ -139,7 +139,7 @@ function inferredProvenance({ runner, file, project, explicitKind, }) {
             source: "path",
         };
     }
-    const defaultKind = runner === "vitest" || runner === "jest" || runner === "node:test" || runner === "mocha" || runner === "ava" || runner === "tap"
+    const defaultKind = runner === "vitest" || runner === "jest" || runner === "node:test" || runner === "bun:test" || runner === "mocha" || runner === "ava" || runner === "tap"
         ? "unit"
         : "unknown";
     return {

package/runtime/javascript/register.mjs

@@ -944,10 +944,40 @@ if (supportDirectory) {
     };
     syncBuiltinESMExports();
 }
+// A file a test asked for by its path that Node did not find in the copy:
+// the copy leaves out build output, and a test that loads `../dist/x.js` an
+// earlier build made fails as a missing module. Noted where
+// SUPERCOV_MISSING_LOADS names, here for `require` and in the loader for
+// `import`, so the run can say which file the copy lacks and why.
+const missingFile = process.env.SUPERCOV_MISSING_LOADS;
+if (missingFile) {
+    const copyRoot = process.env.SUPERCOV_PROJECT_ROOT;
+    const resolveFilename = Module._resolveFilename;
+    Module._resolveFilename = function supercovNotedResolve(request, parent, ...rest) {
+        try {
+            return resolveFilename.call(this, request, parent, ...rest);
+        }
+        catch (error) {
+            if (error?.code === "MODULE_NOT_FOUND" && copyRoot && /^(?:\.{1,2}[\\/]|[\\/])/.test(request)) {
+                try {
+                    const file = resolve(parent?.filename ? dirname(parent.filename) : process.cwd(), request);
+                    const inside = file.startsWith(copyRoot + sep) ? file.slice(copyRoot.length + 1) : undefined;
+                    if (inside && !inside.startsWith(`.supercov${sep}`) && !inside.split(sep).includes("node_modules"))
+                        fs.appendFileSync(missingFile, `${JSON.stringify({ missing: file })}\n`);
+                }
+                catch {
+                    // Not noted: the run says nothing of it, as before.
+                }
+            }
+            throw error;
+        }
+    };
+}
 register(new URL("./resolve-loader.mjs", import.meta.url), {
     data: {
         typescriptRequireHook: typeof typescriptHandler === "function" && typescriptHandler.name !== "loadTS",
         supportFile,
+        missingFile,
     },
 });
 if (process.env.SUPERCOV_DEBUG === "1") {

package/runtime/javascript/resolve-loader.mjs

@@ -58,9 +58,27 @@ function noteLoaded(url) {
         // Not recorded: the file counts for every test, as before.
     }
 }
+// Where this process notes a file a test asked for by its path and Node did
+// not find, in the copy: a file the copy left out, build output above all,
+// fails a test as a missing module, and Supercov can say why (`register.mjs`
+// names it, and does the same for `require`).
+let missingFile;
+function noteMissing(specifier, parentURL) {
+    if (!missingFile || !/^(?:\.{1,2}\/|\/|file:)/.test(specifier))
+        return;
+    try {
+        const file = fileURLToPath(new URL(specifier, parentURL ?? pathToFileURL(`${process.cwd()}/`)));
+        if (projectFile(file))
+            appendFileSync(missingFile, `${JSON.stringify({ missing: file })}\n`);
+    }
+    catch {
+        // Not noted: the run says nothing of it, as before.
+    }
+}
 export function initialize(data) {
     typescriptRequireHook = data?.typescriptRequireHook === true;
     supportFile = typeof data?.supportFile === "string" ? data.supportFile : undefined;
+    missingFile = typeof data?.missingFile === "string" ? data.missingFile : undefined;
 }
 const packageTypes = new Map();
 function packageType(directory) {
@@ -141,7 +159,14 @@ export async function resolve(specifier, context, nextResolve) {
         }
         return nextResolve(REPLACEMENT, context);
     }
-    return throughRequireHook(await nextResolve(specifier, context));
+    try {
+        return throughRequireHook(await nextResolve(specifier, context));
+    }
+    catch (error) {
+        if (error?.code === "ERR_MODULE_NOT_FOUND")
+            noteMissing(specifier, context.parentURL);
+        throw error;
+    }
 }
 
 // Node's own test coverage filters files by `--test-coverage-include` and

package/runtime/javascript/runnerEvidence.mjs

@@ -2,7 +2,7 @@ import { createHash, randomBytes } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { appendEvidenceRecord } from "./atomic.mjs";
+import { appendEvidenceRecord, atomicWriteFileSync } from "./atomic.mjs";
 import { inferTestProvenance, testTags } from "./provenance.mjs";
 import { serverEvidencePath } from "./transport.mjs";
 
@@ -105,7 +105,7 @@ export function readScopedServerEvidence(scope, evidencePath = serverEvidencePat
         return [];
     }
 }
-export function writeRunnerEvidence(identity, status, scope, evidenceDirectoryOverride, phases = [], serverEvidenceSource) {
+export function writeRunnerEvidence(identity, status, scope, evidenceDirectoryOverride, phases = [], serverEvidenceSource, snapshot = false) {
     const evidenceDirectory = evidenceDirectoryOverride ?? process.env["SUPERCOV_EVIDENCE_DIR"];
     if (!evidenceDirectory)
         return;
@@ -132,7 +132,11 @@ export function writeRunnerEvidence(identity, status, scope, evidenceDirectoryOv
             ? readScopedServerEvidence(scope, serverEvidenceSource)
             : readScopedServerEvidence(scope),
     };
-    appendEvidenceRecord(resolve(process.cwd(), evidenceDirectory), identity.runner.replace(/[^A-Za-z0-9_-]/g, "_"), payload);
+    if (snapshot) {
+        atomicWriteFileSync(resolve(process.cwd(), evidenceDirectory, `attempt-${scope.attemptId}`, "mcdc.json"), JSON.stringify(payload));
+    } else {
+        appendEvidenceRecord(resolve(process.cwd(), evidenceDirectory), identity.runner.replace(/[^A-Za-z0-9_-]/g, "_"), payload);
+    }
 }
 
 // A failing test's stack as its author would have seen it, for the runners

package/runtime/javascript/runtime.mjs

@@ -1251,6 +1251,8 @@ function withNodeAssertionPhase(operation, source, callback) {
   });
   attempt.phases.push(phase);
   attempt.phaseIds.add(phase.id);
+  const phaseObserver = runtimeGlobal.__SUPERCOV_ASSERTION_PHASE_STARTED__;
+  if (phaseObserver) phaseObserver(scope, phase);
   try {
     const result = withStackRoom(() => withCoverageCarrier({ version: 1, scope, phaseId: phase.id }, callback));
     if (result && typeof result.then === "function")
@@ -1326,6 +1328,8 @@ function openNodeAssertionPhase(operation, source) {
     });
     attempt.phases.push(phase);
     attempt.phaseIds.add(phase.id);
+    const phaseObserver = runtimeGlobal.__SUPERCOV_ASSERTION_PHASE_STARTED__;
+    if (phaseObserver) phaseObserver(scope, phase);
     carrier = { version: 1, scope, phaseId: phase.id };
     finish = (error) => finishAssertionPhase(phase, error);
   }