supercov 4.21.0 → 4.23.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

@@ -921,6 +921,7 @@ terminal or offline environment after the package has been downloaded.
 | Variable | Use |
 | --- | --- |
 | `SUPERCOV_SOURCE_ROOTS` | Comma-separated directories or files that hold your own code, in any language; everything else is left out |
+| `SUPERCOV_TEST_ROOTS` | For an Ant build whose `<batchtest>` directories cannot be read from its files: comma-separated directories that hold its tests |
 | `SUPERCOV_TEST_KIND` | Label the wrapped command as a test level such as `unit` or `e2e` |
 | `SUPERCOV_SOURCE_TOOLS` | Comma-separated names of tools the test command runs that read source as text, such as a linter or a spell checker, besides Biome, oxlint, dprint, cspell and knip. Each is run on your source as you wrote it instead of on the instrumented copy |
 | `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 |

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
@@ -713,6 +736,9 @@ npx supercov -- npx playwright test
 | Spock | Exact per feature, under the names Spock itself reports | — |
 | TestNG | Exact per test, each data-provider invocation its own | — |
 | JUnit 4 alone | Exact per test, through Vintage — see below | Maven or Gradle |
+| JUnit 4 under Ant's `<junit>` | Exact per test, under the names Ant's XML report uses | Ant 1.10 — see below |
+| Any platform engine under Ant's `<junitlauncher>` | Exact per test, through the platform listener | Ant 1.10 — see below |
+| TestNG under Ant's `<testng>` | Exact per test, through the TestNG listener | TestNG 6.x with its Ant task — see below |
 
 Multi-module builds are measured module by module: each compiles its own source
 set and forks its own JVM, so each gets a runtime and records evidence of its
@@ -775,6 +801,70 @@ npx supercov -- ./gradlew test
 npx supercov -- ./mvnw verify
 ```
 
+### Ant and Ivy
+
+A project with a `build.xml` (and no Maven or Gradle build) is an Ant build.
+Ant has no layout convention, so Supercov reads the build: it follows the
+`<import>` chain with the properties it defines, takes the directories each
+`<batchtest>` or `<testclasses>` scans as the tests — or, where it scans
+compiled classes, the sources the `<javac>` writing them compiles — and what
+its other `<javac>` tasks compile as the code they test, leaving out the
+directories the build writes into. Java elsewhere, such as the sources a test
+compiles as its input, is left alone. Where a `<javac>` compiles from a path
+the build makes only at run time, every other `src` directory holding Java is
+taken as product code too.
+When the build names its tests where that cannot be read — a path a custom
+task builds at run time — say where they are:
+
+```sh
+SUPERCOV_TEST_ROOTS=test/src npx supercov -- ant test
+```
+
+`SUPERCOV_SOURCE_ROOTS` narrows the product code the same way as for any
+project.
+
+Ant's `<junit>` task runs JUnit 4 itself, not on the JUnit Platform, so in the
+copy each `<junit>` task gets a result formatter of Supercov's next to its own
+formatters. The task loads it in every JVM it forks — one per test class by
+default — and it tells the runtime when each test starts and ends. Each JVM
+writes its evidence at the end of its suite and on shutdown, so a JVM the
+task stops for running past its timeout still leaves what it recorded, and
+the run merges every one. The formatter is compiled by the copy's build just
+before the task, against the task's own classpath and Ant's runtime. Tests
+keep the names Ant's XML reports give them, `Class#method`; a test a suite
+runs is named within it, `Suite#Class#method`, and a test two tasks or
+filesets both run is numbered in the second (`[2]`). A test the task stops
+for its timeout is recorded as failed, with what it ran until then. A build
+that names no tests where they can be read keeps the `src/main` and
+`src/test` convention.
+
+Ant's `<junitlauncher>` runs tests on the JUnit Platform, so it gets the same
+platform listener Maven and Gradle builds get, as a `<listener>` of the task,
+compiled the same way against the task's classpath. TestNG's `<testng>` task
+gets the TestNG listener in its own `listeners` attribute, beside any the
+build names.
+
+Many Ant builds import a shared harness from beside the project —
+`<import file="../../../tools/master/build/common/common-build.xml"/>` — and
+the `<junit>` task lives there. The copy is laid out at the project's place
+within the closest directory holding it and everything its build imports,
+with links standing for the rest, so `../` reaches what it reaches in the
+checkout. A file outside the project that holds a `<junit>` task — the
+harness, or a wrapper script's own build file beside it — is changed in the
+copy's own version of that file; the original and the rest of the harness
+are only read. Small files and directories beside the project are copied
+rather than linked, so a wrapper script that writes beside itself writes into
+the copy; anything larger than 4 MB stays a link.
+
+Only the project's own sources are measured: modules resolved as jars, Ivy's
+included, are not instrumented. Code that is not Java or Kotlin — XSLT,
+sitemaps, scripts run by the JVM — is outside what the figure covers.
+
+```sh
+npx supercov -- ant test
+npx supercov -- ../../../run-single-test.sh . ALL
+```
+
 ## Containers, VMs, and remote execution
 
 Supercov can collect from supported processes launched through a container, VM,

package/docs/workspace-isolation.md

@@ -200,8 +200,9 @@ its settings with paths moved to the guest's mount, and the guest's coverage is
 credited to the test that launched it. A guest started any other way, with none
 of those settings, still runs the instrumented code: it reads the run's
 settings from the mounted workspace itself, and its coverage counts for the run
-as background coverage, credited to no test. The run summary's `Guests` line
-says how many processes did that.
+as background coverage, credited to no test. The run summary's `Unattributed`
+line counts processes whose coverage has no named test identity. Local processes
+can also appear here; this count does not establish container or VM execution.
 
 Dependencies stay out of the instrumented copy. The root `node_modules` is
 linked entry by entry to the project's own, so an environment that mounts the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supercov",
-  "version": "4.21.0",
+  "version": "4.23.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.23.0",
+    "@supercov/cli-darwin-x64": "4.23.0",
+    "@supercov/cli-linux-arm64-gnu": "4.23.0",
+    "@supercov/cli-linux-arm64-musl": "4.23.0",
+    "@supercov/cli-linux-x64-gnu": "4.23.0",
+    "@supercov/cli-linux-x64-musl": "4.23.0",
+    "@supercov/cli-win32-arm64": "4.23.0",
+    "@supercov/cli-win32-x64": "4.23.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);
   }