supercov 4.24.6 → 4.24.8

package/docs/supported-suites.md

@@ -77,6 +77,13 @@ 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.
 
+Bun can also run another test runner by its entry point, such as
+`bun node_modules/vitest/vitest.mjs run` or `bun node_modules/mocha/bin/mocha.js`.
+The Bun adapter sets that runner up as Node's preload would: Vitest gets
+Supercov's generated config, which merges the project's own (including one given
+by `--config`), and Mocha's runner is patched before it loads. Their tests are
+attributed as they are under Node.
+
 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

package/package.json

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

package/runtime/javascript/atomic.mjs

@@ -1,6 +1,8 @@
-import { appendFileSync, chmodSync, existsSync, mkdirSync, openSync, closeSync, fsyncSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import fs, { appendFileSync, chmodSync, existsSync, mkdirSync, openSync, closeSync, fsyncSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { randomUUID } from "node:crypto";
-import { dirname, resolve } from "node:path";
+import { syncBuiltinESMExports } from "node:module";
+import { threadId } from "node:worker_threads";
+import { dirname, resolve, sep } from "node:path";
 import { Buffer } from "node:buffer";
 
 // In a container Supercov's `docker` launcher mounts the run's directory
@@ -146,3 +148,41 @@ export function appendEvidenceRecord(directory, prefix, payload) {
     append(journal.path, line);
     journal.size += Buffer.byteLength(line);
 }
+
+// Playwright 1.59 writes each file it compiles into its cache in place and
+// reads it back unchecked: a process that read one while another wrote it
+// ran an empty module -- a config of no `default` failed at "Cannot add
+// property metadata, object is not extensible", a test file at "does not
+// provide an export named". The cache a run gives it starts empty and is
+// shared by every Playwright of the run, the containers a sealed suite execs
+// into among them, so every first compile raced; there each file is written
+// whole, or is not there yet and is compiled again. A file written beside the
+// cache's folders, not in one, is never taken for an old entry and removed.
+//
+// Playwright compiles in two threads: the config and CommonJS files in the
+// process's own, ES modules in the thread its loader hooks run in, which has
+// its own `fs` and does not run `--import`. Each calls this. The partial
+// file's name is unique to the write: a process ID repeats across containers
+// and both threads of one process count from zero.
+let cacheWritesWhole = false;
+export function writePlaywrightCacheWhole() {
+    const transformCache = process.env.PWTEST_CACHE_DIR;
+    if (!transformCache || cacheWritesWhole)
+        return;
+    cacheWritesWhole = true;
+    const cacheFolder = resolve(transformCache) + sep;
+    const writeFileSync = fs.writeFileSync;
+    fs.writeFileSync = function (file, ...rest) {
+        if (typeof file !== "string" || !resolve(file).startsWith(cacheFolder))
+            return writeFileSync.call(this, file, ...rest);
+        const partial = resolve(transformCache, `.writing-${process.pid}-${threadId}-${randomUUID()}`);
+        try {
+            writeFileSync.call(this, partial, ...rest);
+            fs.renameSync(partial, file);
+        }
+        finally {
+            fs.rmSync(partial, { force: true });
+        }
+    };
+    syncBuiltinESMExports();
+}

package/runtime/javascript/bunTest.mjs

@@ -5,6 +5,10 @@
 // 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";
+import { adaptRunnerEntry } from "./runnerEntry.mjs";
+
+// Bun runs no Node preload: a runner it starts is adapted here.
+await adaptRunnerEntry(process.argv[1]?.replaceAll("\\", "/") ?? "");
 
 const adapted = new WeakSet();
 const nativeJest = Bun.jest;

package/runtime/javascript/register.mjs

@@ -12,28 +12,11 @@ import path, { basename, dirname, isAbsolute, relative, resolve, sep } from "nod
 import { fileURLToPath } from "node:url";
 import { installLaunchSupervisor, wrapImportedCapability } from "./launchSupervisor.mjs";
 import { __supercovBindCapabilityWrapper } from "./capability.mjs";
+import { adaptRunnerEntry, noteSkippedCoverageThresholds } from "./runnerEntry.mjs";
+import { writePlaywrightCacheWhole } from "./atomic.mjs";
 installLaunchSupervisor();
-// Playwright 1.59 writes each file it compiles into its cache in place and
-// reads it back unchecked: a process that read one while another wrote it
-// ran an empty module, and a config of no `default` failed at "Cannot add
-// property metadata, object is not extensible". The cache a run gives it
-// starts empty, so every run compiled; there each file is written whole, or
-// is not there yet and is compiled again. A file written beside the cache's
-// folders, not in one, is never taken for an old entry and removed.
-const transformCache = process.env.PWTEST_CACHE_DIR;
-if (transformCache) {
-    const cacheFolder = resolve(transformCache) + sep;
-    const writeFileSync = fs.writeFileSync;
-    let written = 0;
-    fs.writeFileSync = function (file, ...rest) {
-        if (typeof file !== "string" || !resolve(file).startsWith(cacheFolder))
-            return writeFileSync.call(this, file, ...rest);
-        const partial = resolve(transformCache, `.writing-${process.pid}-${written++}`);
-        writeFileSync.call(this, partial, ...rest);
-        fs.renameSync(partial, file);
-    };
-    syncBuiltinESMExports();
-}
+// Playwright's compile cache, written whole (atomic.mjs says why).
+writePlaywrightCacheWhole();
 // Instrumented sources import the browser-safe capability seam; bind the
 // real supervisor implementation before any user module evaluates.
 __supercovBindCapabilityWrapper(wrapImportedCapability);
@@ -167,7 +150,6 @@ syncBuiltinESMExports();
 // is Vitest, replace its config with our generated merging config before the
 // CLI parses argv. This is what makes `supercov -- npm test` work
 // without editing package scripts, Vitest configs, setup files, or test imports.
-const generatedVitestConfig = process.env.SUPERCOV_GENERATED_VITEST_CONFIG;
 const generatedPlaywrightConfig = process.env.SUPERCOV_GENERATED_PLAYWRIGHT_CONFIG;
 const entrypoint = process.argv[1]?.replaceAll("\\", "/") ?? "";
 // Node's own test coverage filters files by `--test-coverage-include` and
@@ -789,19 +771,9 @@ function installAuthoredSourceView() {
     };
     syncBuiltinESMExports();
 }
-// A project's own coverage tool measures what runs, and under Supercov that is
-// the instrumented copy, whose probes are branches no test was written to
-// cover: c8, Jest and Vitest each failed a 100% gate on a suite that covers
-// every branch (80%, 83.33%, 87.5%). The tool still runs and reports; its
-// thresholds are not checked, and the run says so once. Jest's and Vitest's
-// thresholds are dropped from the configurations Supercov hands them, which
-// call this too.
-process.__SUPERCOV_SKIPPED_COVERAGE_THRESHOLDS__ ??= (tool) => {
-    if (process.__SUPERCOV_SKIPPED_COVERAGE_THRESHOLDS_NOTED__)
-        return;
-    process.__SUPERCOV_SKIPPED_COVERAGE_THRESHOLDS_NOTED__ = true;
-    console.error(`[supercov] ${tool}'s coverage thresholds were not checked: under Supercov, ${tool} measures the instrumented copy, probes included. Supercov's own report has this run's coverage.`);
-};
+// Jest's and Vitest's thresholds are dropped from the configurations Supercov
+// hands them, which call this too.
+process.__SUPERCOV_SKIPPED_COVERAGE_THRESHOLDS__ ??= noteSkippedCoverageThresholds;
 const coverageTool = /\/node_modules\/(?:\.bin\/(c8|nyc)|(c8|nyc)\/bin\/(?:c8|nyc)\.js)$/.exec(entrypoint);
 if (coverageTool)
     skipCoverageThresholds(coverageTool[1] ?? coverageTool[2]);
@@ -1004,59 +976,7 @@ register(new URL("./resolve-loader.mjs", import.meta.url), {
 if (process.env.SUPERCOV_DEBUG === "1") {
     console.error("[supercov] preload", { entrypoint });
 }
-if (generatedVitestConfig && /\/vitest(?:\.m?js)?$/.test(entrypoint)) {
-    // Worker processes inherit this marker. In particular, do not eagerly load
-    // Playwright's expect implementation in a Vitest worker: both runners use
-    // the Jest matcher registry symbol and intentionally cannot coexist there.
-    process.env.SUPERCOV_INSIDE_VITEST = "1";
-    let originalConfig;
-    for (let index = 2; index < process.argv.length; index += 1) {
-        const argument = process.argv[index];
-        if (argument === "--config" || argument === "-c") {
-            const configured = process.argv[index + 1];
-            const resolvedConfig = configured
-                ? resolve(process.cwd(), configured)
-                : undefined;
-            if (resolvedConfig && resolvedConfig !== resolve(generatedVitestConfig)) {
-                originalConfig = resolvedConfig;
-            }
-            process.argv.splice(index, configured ? 2 : 1);
-            index -= 1;
-        }
-        else if (argument?.startsWith("--config=")) {
-            const resolvedConfig = resolve(process.cwd(), argument.slice("--config=".length));
-            if (resolvedConfig !== resolve(generatedVitestConfig)) {
-                originalConfig = resolvedConfig;
-            }
-            process.argv.splice(index, 1);
-            index -= 1;
-        }
-    }
-    // Thresholds on the command line override the configuration's, which the
-    // generated config leaves out (see the coverage tools above). Vitest 0.x
-    // took them directly under --coverage.
-    for (let index = 2; index < process.argv.length; index += 1) {
-        const argument = process.argv[index];
-        if (!/^--coverage\.(?:thresholds(?:\.[^=]+)?|lines|functions|branches|statements|perFile|100|thresholdAutoUpdate)(?:=|$)/.test(argument))
-            continue;
-        const valued = !argument.includes("=") && /^(?:\d+(?:\.\d+)?|true|false)$/.test(process.argv[index + 1] ?? "");
-        process.argv.splice(index, valued ? 2 : 1);
-        index -= 1;
-        process.__SUPERCOV_SKIPPED_COVERAGE_THRESHOLDS__("Vitest");
-    }
-    if (originalConfig) {
-        process.env.SUPERCOV_ORIGINAL_VITEST_CONFIG = originalConfig;
-    }
-    process.argv.push("--config", generatedVitestConfig);
-    if (process.env.SUPERCOV_DEBUG === "1") {
-        console.error("[supercov] Vitest argv configured", {
-            entrypoint,
-            originalConfig,
-            generatedVitestConfig,
-            argv: process.argv.slice(2),
-        });
-    }
-}
+await adaptRunnerEntry(entrypoint);
 if ((isJestEntrypoint || process.env.JEST_WORKER_ID) && process.env.SUPERCOV_EVIDENCE_DIR) {
     // Jest evaluates instrumented modules in its own module system, past the
     // loader hook that imports the runtime on first use elsewhere, and
@@ -1068,32 +988,6 @@ if ((isJestEntrypoint || process.env.JEST_WORKER_ID) && process.env.SUPERCOV_EVI
     globalThis.__SUPERCOV_DIRECT_RUNTIME__ ??= await import("./runtime.mjs");
     process.__SUPERCOV_DIRECT_RUNTIME__ ??= globalThis.__SUPERCOV_DIRECT_RUNTIME__;
 }
-// The Mocha CLI, the child it forks for Node options, and each --parallel
-// worker run tests through Mocha's Runner, which the adapter patches before
-// Mocha loads it.
-const isMochaEntrypoint = /\/node_modules\/(?:\.bin\/_?mocha|mocha\/(?:bin\/_?mocha(?:\.js)?|lib\/cli\/cli\.js|lib\/nodejs\/worker\.c?js))$/.test(entrypoint);
-if (isMochaEntrypoint && process.env.SUPERCOV_EVIDENCE_DIR) {
-    globalThis.__SUPERCOV_DIRECT_RUNTIME__ ??= await import("./runtime.mjs");
-    process.__SUPERCOV_DIRECT_RUNTIME__ ??= globalThis.__SUPERCOV_DIRECT_RUNTIME__;
-    const { adaptMocha } = await import(new URL("./mocha.mjs", import.meta.url).href);
-    await adaptMocha(entrypoint);
-}
-// An AVA worker, a thread or a child process, runs one test file through
-// AVA's Runner, which the adapter patches before the worker loads it.
-if (/\/node_modules\/ava\/lib\/worker\/base\.js$/.test(entrypoint) && process.env.SUPERCOV_EVIDENCE_DIR) {
-    globalThis.__SUPERCOV_DIRECT_RUNTIME__ ??= await import("./runtime.mjs");
-    process.__SUPERCOV_DIRECT_RUNTIME__ ??= globalThis.__SUPERCOV_DIRECT_RUNTIME__;
-    const { adaptAva } = await import(new URL("./ava.mjs", import.meta.url).href);
-    await adaptAva(entrypoint);
-}
-// The tap CLI runs each test file as a process of its own, marked with
-// TAP_CHILD_ID; the adapter patches tap's TestBase before the file loads it.
-if (process.env.TAP_CHILD_ID && process.env.SUPERCOV_EVIDENCE_DIR && entrypoint) {
-    globalThis.__SUPERCOV_DIRECT_RUNTIME__ ??= await import("./runtime.mjs");
-    process.__SUPERCOV_DIRECT_RUNTIME__ ??= globalThis.__SUPERCOV_DIRECT_RUNTIME__;
-    const { adaptTap } = await import(new URL("./tap.mjs", import.meta.url).href);
-    await adaptTap(entrypoint);
-}
 if (isJestEntrypoint && process.env.SUPERCOV_EVIDENCE_DIR) {
     // Jest reads one configuration. Ours (jest.config.mjs) reads the user's
     // the way Jest would and adds the adapter and reporter; an explicit

package/runtime/javascript/resolve-loader.mjs

@@ -1,6 +1,10 @@
 import { appendFileSync, readFileSync } from "node:fs";
 import { dirname, resolve as resolvePath } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { writePlaywrightCacheWhole } from "./atomic.mjs";
+// This thread is where Playwright compiles ES modules and writes them into
+// its cache: written whole here too (atomic.mjs says why).
+writePlaywrightCacheWhole();
 const GENERATED_TARGET = "__SUPERCOV_PLAYWRIGHT_MODULE__";
 const TARGET = process.env.SUPERCOV_PLAYWRIGHT_MODULE ??
     (GENERATED_TARGET.startsWith("__") ? "@playwright/test" : GENERATED_TARGET);

package/runtime/javascript/runnerEntry.mjs

@@ -0,0 +1,108 @@
+// A runner started by its own entry point -- Vitest, Mocha, an AVA worker, a
+// tap child -- is adapted as it starts: Vitest takes the run's generated
+// config, the others' runners are patched before they load. Without it every
+// probe a test reaches is counted as background. Node runs this from
+// register.mjs before the CLI parses argv; Bun loads no Node preload, so its
+// adapter does instead.
+import { resolve } from "node:path";
+
+// A project's own coverage tool measures what runs, and under Supercov that is
+// the instrumented copy, whose probes are branches no test was written to
+// cover: c8, Jest and Vitest each failed a 100% gate on a suite that covers
+// every branch (80%, 83.33%, 87.5%). The tool still runs and reports; its
+// thresholds are not checked, and the run says so once.
+export function noteSkippedCoverageThresholds(tool) {
+    if (process.__SUPERCOV_SKIPPED_COVERAGE_THRESHOLDS_NOTED__)
+        return;
+    process.__SUPERCOV_SKIPPED_COVERAGE_THRESHOLDS_NOTED__ = true;
+    console.error(`[supercov] ${tool}'s coverage thresholds were not checked: under Supercov, ${tool} measures the instrumented copy, probes included. Supercov's own report has this run's coverage.`);
+}
+
+/** Point a Vitest process at the run's generated config. */
+function useGeneratedVitestConfig(entrypoint) {
+    const generatedVitestConfig = process.env.SUPERCOV_GENERATED_VITEST_CONFIG;
+    if (!generatedVitestConfig || !/\/vitest(?:\.m?js)?$/.test(entrypoint))
+        return;
+    // Worker processes inherit this marker. In particular, do not eagerly load
+    // Playwright's expect implementation in a Vitest worker: both runners use
+    // the Jest matcher registry symbol and intentionally cannot coexist there.
+    process.env.SUPERCOV_INSIDE_VITEST = "1";
+    let originalConfig;
+    for (let index = 2; index < process.argv.length; index += 1) {
+        const argument = process.argv[index];
+        if (argument === "--config" || argument === "-c") {
+            const configured = process.argv[index + 1];
+            const resolvedConfig = configured
+                ? resolve(process.cwd(), configured)
+                : undefined;
+            if (resolvedConfig && resolvedConfig !== resolve(generatedVitestConfig)) {
+                originalConfig = resolvedConfig;
+            }
+            process.argv.splice(index, configured ? 2 : 1);
+            index -= 1;
+        }
+        else if (argument?.startsWith("--config=")) {
+            const resolvedConfig = resolve(process.cwd(), argument.slice("--config=".length));
+            if (resolvedConfig !== resolve(generatedVitestConfig)) {
+                originalConfig = resolvedConfig;
+            }
+            process.argv.splice(index, 1);
+            index -= 1;
+        }
+    }
+    // Thresholds on the command line override the configuration's, which the
+    // generated config leaves out (see the coverage tools above). Vitest 0.x
+    // took them directly under --coverage.
+    for (let index = 2; index < process.argv.length; index += 1) {
+        const argument = process.argv[index];
+        if (!/^--coverage\.(?:thresholds(?:\.[^=]+)?|lines|functions|branches|statements|perFile|100|thresholdAutoUpdate)(?:=|$)/.test(argument))
+            continue;
+        const valued = !argument.includes("=") && /^(?:\d+(?:\.\d+)?|true|false)$/.test(process.argv[index + 1] ?? "");
+        process.argv.splice(index, valued ? 2 : 1);
+        index -= 1;
+        noteSkippedCoverageThresholds("Vitest");
+    }
+    if (originalConfig) {
+        process.env.SUPERCOV_ORIGINAL_VITEST_CONFIG = originalConfig;
+    }
+    process.argv.push("--config", generatedVitestConfig);
+    if (process.env.SUPERCOV_DEBUG === "1") {
+        console.error("[supercov] Vitest argv configured", {
+            entrypoint,
+            originalConfig,
+            generatedVitestConfig,
+            argv: process.argv.slice(2),
+        });
+    }
+}
+
+/** Adapt the runner whose entry point `entrypoint` is, if any. */
+export async function adaptRunnerEntry(entrypoint) {
+    useGeneratedVitestConfig(entrypoint);
+    // The Mocha CLI, the child it forks for Node options, and each --parallel
+    // worker run tests through Mocha's Runner, which the adapter patches before
+    // Mocha loads it.
+    const isMochaEntrypoint = /\/node_modules\/(?:\.bin\/_?mocha|mocha\/(?:bin\/_?mocha(?:\.js)?|lib\/cli\/cli\.js|lib\/nodejs\/worker\.c?js))$/.test(entrypoint);
+    if (isMochaEntrypoint && process.env.SUPERCOV_EVIDENCE_DIR) {
+        globalThis.__SUPERCOV_DIRECT_RUNTIME__ ??= await import("./runtime.mjs");
+        process.__SUPERCOV_DIRECT_RUNTIME__ ??= globalThis.__SUPERCOV_DIRECT_RUNTIME__;
+        const { adaptMocha } = await import(new URL("./mocha.mjs", import.meta.url).href);
+        await adaptMocha(entrypoint);
+    }
+    // An AVA worker, a thread or a child process, runs one test file through
+    // AVA's Runner, which the adapter patches before the worker loads it.
+    if (/\/node_modules\/ava\/lib\/worker\/base\.js$/.test(entrypoint) && process.env.SUPERCOV_EVIDENCE_DIR) {
+        globalThis.__SUPERCOV_DIRECT_RUNTIME__ ??= await import("./runtime.mjs");
+        process.__SUPERCOV_DIRECT_RUNTIME__ ??= globalThis.__SUPERCOV_DIRECT_RUNTIME__;
+        const { adaptAva } = await import(new URL("./ava.mjs", import.meta.url).href);
+        await adaptAva(entrypoint);
+    }
+    // The tap CLI runs each test file as a process of its own, marked with
+    // TAP_CHILD_ID; the adapter patches tap's TestBase before the file loads it.
+    if (process.env.TAP_CHILD_ID && process.env.SUPERCOV_EVIDENCE_DIR && entrypoint) {
+        globalThis.__SUPERCOV_DIRECT_RUNTIME__ ??= await import("./runtime.mjs");
+        process.__SUPERCOV_DIRECT_RUNTIME__ ??= globalThis.__SUPERCOV_DIRECT_RUNTIME__;
+        const { adaptTap } = await import(new URL("./tap.mjs", import.meta.url).href);
+        await adaptTap(entrypoint);
+    }
+}