supercov 4.21.0 → 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/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.21.0",
+  "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.21.0",
-    "@supercov/cli-darwin-x64": "4.21.0",
-    "@supercov/cli-linux-arm64-gnu": "4.21.0",
-    "@supercov/cli-linux-arm64-musl": "4.21.0",
-    "@supercov/cli-linux-x64-gnu": "4.21.0",
-    "@supercov/cli-linux-x64-musl": "4.21.0",
-    "@supercov/cli-win32-arm64": "4.21.0",
-    "@supercov/cli-win32-x64": "4.21.0"
+    "@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/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);
   }