supercov 2.0.1 → 3.0.1

package/runtime/javascript/register.mjs

@@ -7,8 +7,8 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import Module, { register, syncBuiltinESMExports } from "node:module";
-import { closeSync, openSync, unlinkSync } from "node:fs";
-import { resolve } from "node:path";
+import fs, { closeSync, openSync, readFileSync, realpathSync, unlinkSync } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { installLaunchSupervisor, wrapImportedCapability } from "./launchSupervisor.mjs";
 import { __supercovBindCapabilityWrapper } from "./capability.mjs";
@@ -121,6 +121,42 @@ syncBuiltinESMExports();
 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
+// `--test-coverage-exclude` globs relative to the working directory, and the
+// instrumented copy's source map names the project's file, outside the
+// isolated workspace the tests run in: `src/**` matched nothing, the report
+// was empty and its thresholds passed with nothing checked. When those globs
+// are given, the map this process caches names the copy's own path instead;
+// its embedded original text is what Node reports. Nothing is written: other
+// coverage tools read the file as it is on disk.
+const NODE_COVERAGE_FILTERS = process.execArgv.some((argument) => /^--test-coverage-(?:include|exclude)(?:=|$)/.test(argument)) &&
+    (Boolean(process.env.NODE_V8_COVERAGE) || process.execArgv.includes("--experimental-test-coverage"));
+const INLINE_MAP = "//# sourceMappingURL=data:application/json;base64,";
+function mapToCopy(source, filename) {
+    if (typeof source !== "string" || !source.includes("__supercov"))
+        return source;
+    const at = source.lastIndexOf(INLINE_MAP);
+    if (at < 0)
+        return source;
+    const end = source.indexOf("\n", at);
+    const encoded = source.slice(at + INLINE_MAP.length, end < 0 ? undefined : end).trim();
+    try {
+        const map = JSON.parse(Buffer.from(encoded, "base64").toString("utf8"));
+        if (!Array.isArray(map.sources) || map.sources.length !== 1)
+            return source;
+        map.sources = [filename.replace(/^.*[\\/]/, "")];
+        return `${source.slice(0, at)}${INLINE_MAP}${Buffer.from(JSON.stringify(map)).toString("base64")}${end < 0 ? "" : source.slice(end)}`;
+    }
+    catch {
+        return source;
+    }
+}
+if (NODE_COVERAGE_FILTERS) {
+    const compile = Module.prototype._compile;
+    Module.prototype._compile = function _compile(content, filename, ...rest) {
+        return Reflect.apply(compile, this, [mapToCopy(content, filename), filename, ...rest]);
+    };
+}
 const playwrightTarget = process.env.SUPERCOV_PLAYWRIGHT_MODULE;
 const projectRoot = process.env.SUPERCOV_PROJECT_ROOT?.replaceAll("\\", "/").replace(/\/$/, "");
 const nodeTestWrapper = new URL("./nodeTest.mjs", import.meta.url).href;
@@ -130,6 +166,212 @@ const isPlaywrightEntrypoint = /\/(?:node_modules\/\.bin\/playwright|node_module
 const isJestEntrypoint = /\/node_modules\/(?:\.bin\/jest|(?:jest|jest-cli)\/bin\/jest\.js)$/.test(entrypoint);
 if (generatedPlaywrightConfig && isPlaywrightEntrypoint)
     process.env.SUPERCOV_INSIDE_PLAYWRIGHT = "1";
+// Linters, formatters and type checks read the project to judge it, not to
+// run it. The workspace holds rewritten copies, and ESLint failed semver,
+// js-yaml and picomatch on code nobody wrote ("Strings must use singlequote",
+// "'globalThis' is not defined"), Supercov's own .supercov/*.mjs included.
+// Such a process reads every rewritten file as its author wrote it, and no
+// directory listing in the workspace shows .supercov.
+const analysisTools = "eslint|eslint_d|prettier|standard|semistandard|ts-standard|xo|jshint|tslint";
+const isAnalysisEntrypoint = new RegExp(`/node_modules/(?:\\.bin/(?:${analysisTools})$|(?:${analysisTools})/)`).test(entrypoint) ||
+    (/\/node_modules\/(?:\.bin\/(?:tsc|vue-tsc)$|(?:typescript|vue-tsc)\/bin\/)/.test(entrypoint) &&
+        process.argv.includes("--noEmit"));
+if (isAnalysisEntrypoint)
+    installAuthoredSourceView();
+function installAuthoredSourceView() {
+    let authored;
+    try {
+        authored = new Set(JSON.parse(readFileSync(new URL("./authored-sources.json", import.meta.url), "utf8")));
+    }
+    catch {
+        authored = new Set();
+    }
+    const authoredRoot = fileURLToPath(new URL("./.authored/", import.meta.url));
+    const workspace = fileURLToPath(new URL("../../", import.meta.url));
+    const roots = [...new Set([workspace, (() => {
+                try {
+                    return realpathSync(workspace);
+                }
+                catch {
+                    return workspace;
+                }
+            })()])];
+    const inside = (path) => {
+        if (typeof path !== "string" && !(path instanceof URL))
+            return undefined;
+        let absolute;
+        try {
+            absolute = resolve(path instanceof URL ? fileURLToPath(path) : path);
+        }
+        catch {
+            return undefined;
+        }
+        for (const root of roots) {
+            const local = relative(root, absolute);
+            if (local !== ".." && !local.startsWith(`..${sep}`) && !isAbsolute(local))
+                return local.split(sep).join("/");
+        }
+        return undefined;
+    };
+    const authoredPath = (path) => {
+        const local = inside(path);
+        return local !== undefined && authored.has(local) ? resolve(authoredRoot, local) : path;
+    };
+    // A recursive listing names nested entries by relative path, or as
+    // entries whose parent is inside .supercov.
+    const supercovPath = (path) => typeof path === "string" && path.split(/[\\/]/).includes(".supercov");
+    const hidden = (entry) => {
+        if (typeof entry === "string")
+            return supercovPath(entry);
+        if (entry instanceof Uint8Array)
+            return supercovPath(new TextDecoder().decode(entry));
+        const parent = inside(entry?.parentPath ?? entry?.path ?? "");
+        return entry?.name === ".supercov" || supercovPath(parent);
+    };
+    const listed = (path, entries) => inside(path) === undefined || !Array.isArray(entries)
+        ? entries
+        : entries.filter((entry) => !hidden(entry));
+    const { readFileSync: readSync, readFile: readCallback, readdirSync: listSync, readdir: listCallback } = fs;
+    const { readFile: readPromise, readdir: listPromise } = fs.promises;
+    fs.readFileSync = function readFileSync(path, ...rest) {
+        return Reflect.apply(readSync, this, [authoredPath(path), ...rest]);
+    };
+    fs.readFile = function readFile(path, ...rest) {
+        return Reflect.apply(readCallback, this, [authoredPath(path), ...rest]);
+    };
+    fs.promises.readFile = function readFile(path, ...rest) {
+        return Reflect.apply(readPromise, this, [authoredPath(path), ...rest]);
+    };
+    fs.readdirSync = function readdirSync(path, ...rest) {
+        return listed(path, Reflect.apply(listSync, this, [path, ...rest]));
+    };
+    fs.readdir = function readdir(path, ...rest) {
+        const callback = rest.at(-1);
+        if (typeof callback !== "function")
+            return Reflect.apply(listCallback, this, [path, ...rest]);
+        return Reflect.apply(listCallback, this, [path, ...rest.slice(0, -1), (error, entries) => callback(error, error ? entries : listed(path, entries))]);
+    };
+    fs.promises.readdir = async function readdir(path, ...rest) {
+        return listed(path, await Reflect.apply(listPromise, this, [path, ...rest]));
+    };
+    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.`);
+};
+const coverageTool = /\/node_modules\/(?:\.bin\/(c8|nyc)|(c8|nyc)\/bin\/(?:c8|nyc)\.js)$/.exec(entrypoint);
+if (coverageTool)
+    skipCoverageThresholds(coverageTool[1] ?? coverageTool[2]);
+if (/\/node_modules\/(?:\.bin\/karma|karma\/bin\/karma)$/.test(entrypoint))
+    skipKarmaCoverageCheck();
+// karma-coverage checks `coverageReporter.check` in the reporter karma builds
+// from its plugin, which the karma process requires by name from the project.
+// Loaded first, the plugin's constructor is replaced by one that leaves the
+// check out of the configuration it is given.
+function skipKarmaCoverageCheck() {
+    try {
+        const plugin = Module.createRequire(resolve(process.cwd(), "package.json"))("karma-coverage");
+        const entry = plugin?.["reporter:coverage"];
+        if (!Array.isArray(entry) || typeof entry[1] !== "function")
+            return;
+        const Reporter = entry[1];
+        function CoverageReporter(rootConfig, ...rest) {
+            const options = rootConfig?.coverageReporter;
+            if (options && Object.prototype.hasOwnProperty.call(options, "check")) {
+                delete options.check;
+                process.__SUPERCOV_SKIPPED_COVERAGE_THRESHOLDS__("karma-coverage");
+            }
+            return Reflect.construct(Reporter, [rootConfig, ...rest], new.target);
+        }
+        CoverageReporter.$inject = Reporter.$inject;
+        CoverageReporter.prototype = Reporter.prototype;
+        plugin["reporter:coverage"] = [entry[0], CoverageReporter];
+    }
+    catch (error) {
+        if (process.env.SUPERCOV_DEBUG === "1")
+            console.error("[supercov] karma-coverage's check stays as configured", error);
+    }
+}
+// nyc (through 18) remaps with istanbul-lib-source-maps 4, which drops an
+// `if`'s implicit else from any file with a source map: it has no location to
+// map. The instrumented copy has one, so nyc read one branch fewer for every
+// `if` without an `else` than it reads without Supercov. Version 5 keeps the
+// location in the file of the branch's other one; so does this, loaded before
+// nyc's remapping captures the function.
+function keepImplicitElse(toolRequire) {
+    try {
+        const path = toolRequire.resolve("istanbul-lib-source-maps/lib/get-mapping.js");
+        const getMapping = toolRequire(path);
+        const cached = Module._cache[path];
+        if (typeof getMapping !== "function" || !cached)
+            return;
+        let lastSource;
+        cached.exports = function getMappingKeepingImplicitElse(sourceMap, location, originalFile) {
+            const mapping = getMapping(sourceMap, location, originalFile);
+            if (mapping) {
+                lastSource = mapping.source;
+                return mapping;
+            }
+            const implicit = location?.start?.line === undefined && location?.end?.line === undefined;
+            const source = lastSource;
+            lastSource = undefined;
+            return implicit && source !== undefined ? { source, loc: location } : mapping;
+        };
+    }
+    catch (error) {
+        if (process.env.SUPERCOV_DEBUG === "1")
+            console.error("[supercov] nyc keeps its own remapping", error);
+    }
+}
+function skipCoverageThresholds(tool) {
+    const skipped = async function skippedCoverageThresholds() {
+        process.__SUPERCOV_SKIPPED_COVERAGE_THRESHOLDS__(tool);
+    };
+    try {
+        // Resolved from the tool's own bin, so the module patched is the one
+        // its CLI loads next (npm links .bin/c8 to c8/bin/c8.js).
+        const toolRequire = Module.createRequire(realpathSync(process.argv[1]));
+        if (tool === "c8") {
+            // Every c8 threshold -- --check-coverage, --100, .c8rc, .nycrc,
+            // package.json, `c8 check-coverage` -- is checked here, and
+            // report.js takes this export when it loads.
+            toolRequire("../lib/commands/check-coverage.js").checkCoverages = skipped;
+        }
+        else {
+            keepImplicitElse(toolRequire);
+            // A gated nyc run, `nyc report --check-coverage` and
+            // `nyc check-coverage` all check through this method.
+            const NYC = toolRequire("../index.js");
+            NYC.prototype.checkCoverage = skipped;
+            // The instrumented copy's source map leads to the project's own
+            // file, outside the isolated workspace nyc runs in, and
+            // excluding after remapping (nyc's default) dropped it: nyc
+            // reported "All files 0". The project's excludes still apply,
+            // to the copies, before remapping.
+            const collect = NYC.prototype.getCoverageMapFromAllCoverageFiles;
+            if (typeof collect === "function") {
+                NYC.prototype.getCoverageMapFromAllCoverageFiles = function getCoverageMapFromAllCoverageFiles(...args) {
+                    this.config.excludeAfterRemap = false;
+                    return Reflect.apply(collect, this, args);
+                };
+            }
+        }
+    }
+    catch (error) {
+        if (process.env.SUPERCOV_DEBUG === "1")
+            console.error(`[supercov] ${tool}'s coverage thresholds stay as configured`, error);
+    }
+}
 register(new URL("./resolve-loader.mjs", import.meta.url));
 if (process.env.SUPERCOV_DEBUG === "1") {
     console.error("[supercov] preload", { entrypoint });
@@ -162,6 +404,18 @@ if (generatedVitestConfig && /\/vitest(?:\.m?js)?$/.test(entrypoint)) {
             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;
     }
@@ -186,6 +440,32 @@ 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
@@ -210,6 +490,14 @@ if (isJestEntrypoint && process.env.SUPERCOV_EVIDENCE_DIR) {
             process.argv.splice(index, 1);
             index -= 1;
         }
+        else if (/^--coverage-?[Tt]hreshold(?:=|$)/.test(argument ?? "")) {
+            // Overrides the configuration's coverageThreshold, which
+            // jest.config.mjs leaves out (see the coverage tools above).
+            const valued = !argument.includes("=") && process.argv[index + 1]?.startsWith("{");
+            process.argv.splice(index, valued ? 2 : 1);
+            index -= 1;
+            process.__SUPERCOV_SKIPPED_COVERAGE_THRESHOLDS__("Jest");
+        }
     }
     process.argv.push("--config", generatedJestConfig);
 }

package/runtime/javascript/resolve-loader.mjs

@@ -1,5 +1,5 @@
 import { resolve as resolvePath } from "node:path";
-import { pathToFileURL } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 const GENERATED_TARGET = "__SUPERCOV_PLAYWRIGHT_MODULE__";
 const TARGET = process.env.SUPERCOV_PLAYWRIGHT_MODULE ??
     (GENERATED_TARGET.startsWith("__") ? "@playwright/test" : GENERATED_TARGET);
@@ -75,3 +75,42 @@ export async function resolve(specifier, context, nextResolve) {
     }
     return nextResolve(specifier, context);
 }
+
+// Node's own test coverage filters files by `--test-coverage-include` and
+// `--test-coverage-exclude` globs relative to the working directory, and the
+// instrumented copy's source map names the project's file, outside the
+// isolated workspace the tests run in: `src/**` matched nothing, the report
+// was empty and its thresholds passed with nothing checked. When those globs
+// are given, the map this process caches names the copy's own path instead;
+// its embedded original text is what Node reports. Nothing is written: other
+// coverage tools read the file as it is on disk.
+const NODE_COVERAGE_FILTERS = process.execArgv.some((argument) => /^--test-coverage-(?:include|exclude)(?:=|$)/.test(argument)) &&
+    (Boolean(process.env.NODE_V8_COVERAGE) || process.execArgv.includes("--experimental-test-coverage"));
+const INLINE_MAP = "//# sourceMappingURL=data:application/json;base64,";
+function mapToCopy(source, filename) {
+    if (typeof source !== "string" || !source.includes("__supercov"))
+        return source;
+    const at = source.lastIndexOf(INLINE_MAP);
+    if (at < 0)
+        return source;
+    const end = source.indexOf("\n", at);
+    const encoded = source.slice(at + INLINE_MAP.length, end < 0 ? undefined : end).trim();
+    try {
+        const map = JSON.parse(Buffer.from(encoded, "base64").toString("utf8"));
+        if (!Array.isArray(map.sources) || map.sources.length !== 1)
+            return source;
+        map.sources = [filename.replace(/^.*[\\/]/, "")];
+        return `${source.slice(0, at)}${INLINE_MAP}${Buffer.from(JSON.stringify(map)).toString("base64")}${end < 0 ? "" : source.slice(end)}`;
+    }
+    catch {
+        return source;
+    }
+}
+export async function load(url, context, nextLoad) {
+    const result = await nextLoad(url, context);
+    if (!NODE_COVERAGE_FILTERS || result.source == null || !url.startsWith("file:"))
+        return result;
+    const text = typeof result.source === "string" ? result.source : Buffer.from(result.source).toString("utf8");
+    const mapped = mapToCopy(text, fileURLToPath(url));
+    return mapped === text ? result : { ...result, source: mapped };
+}

package/runtime/javascript/runnerEvidence.mjs

@@ -1,8 +1,8 @@
 import { createHash, randomBytes } from "node:crypto";
-import { mkdirSync, readFileSync } from "node:fs";
+import { readFileSync } from "node:fs";
 import { relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-import { atomicWriteFileSync } from "./atomic.mjs";
+import { appendEvidenceRecord } from "./atomic.mjs";
 import { inferTestProvenance } from "./provenance.mjs";
 import { serverEvidencePath } from "./transport.mjs";
 
@@ -131,7 +131,5 @@ export function writeRunnerEvidence(identity, status, scope, evidenceDirectoryOv
             ? readScopedServerEvidence(scope, serverEvidenceSource)
             : readScopedServerEvidence(scope),
     };
-    const directory = resolve(process.cwd(), evidenceDirectory, `${identity.runner.replace(/[^A-Za-z0-9_-]/g, "_")}-${scope.attemptId}`);
-    mkdirSync(directory, { recursive: true });
-    atomicWriteFileSync(resolve(directory, "mcdc.json"), `${JSON.stringify(payload)}\n`);
+    appendEvidenceRecord(resolve(process.cwd(), evidenceDirectory), identity.runner.replace(/[^A-Za-z0-9_-]/g, "_"), payload);
 }