supercov 4.0.1 → 4.1.1

package/docs/cli.md

@@ -147,6 +147,7 @@ npx supercov runs <run-id> [query] [options]
 | `decision <id \| path:line>` | Understand missing boolean outcomes and MC/DC witnesses |
 | `line <path:line>` | See one line's state, obligations, and covering tests |
 | `test <id \| name>` | See the coverage attributed to one test |
+| `tests without-evidence` | List the tests that made assertions and recorded no coverage, which the summary counts in a warning |
 | `kinds` | Group coverage by test level, such as unit or E2E |
 | `runners` | Group coverage by test runner |
 | `scope` | See what is source and what is not, by directory and reason; `--files` lists every file |
@@ -175,12 +176,16 @@ npx supercov runs latest files --group dir --depth 2 --metric branches
 ```
 
 ```
-Directory   Files  Lines     e2e    unit      All
-app             4     15  86.67%   0.00%  100.00%
-lib             1     10  90.00%  40.00%   90.00%
-components      1      2 100.00%   0.00%  100.00%
+Directory   Files  Lines      e2e    unit  no test      All
+app             5     23   86.96%   0.00%    8.70%   95.65%
+lib             1     10   90.00%  40.00%    0.00%   90.00%
+.               2      8   75.00%   0.00%   25.00%  100.00%
+components      1      2  100.00%   0.00%    0.00%  100.00%
 ```
 
+`no test` is what ran only while no test was running, such as a server
+starting before the first test. The column is there when a directory has any.
+
 In `--json`, every file of `files` and `gaps` carries `totals` and `covered`
 for each metric beside what is missing, so a percentage can be worked out for
 any file or set of files.

package/docs/coverage-model.md

@@ -106,6 +106,14 @@ By test kind
   no test                    lines  17.14%  branches   0.00%  MC/DC   0.00%
 ```
 
+`files --group dir` has the same figure as a `no test` column wherever a
+directory has any, so a directory's `All` never stands above its kinds
+unexplained.
+
+A test that made assertions and has no covered line to its name is counted in
+a warning on the summary. `npx supercov runs latest tests without-evidence`
+lists every such test, with its file, kind and outcome.
+
 See [Supported suites](supported-suites.md) for the attribution available from
 each runner.
 

package/package.json

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

package/runtime/javascript/jestRuntime.cjs

@@ -9,4 +9,9 @@ const runtime = globalThis.__SUPERCOV_DIRECT_RUNTIME__ ?? process.__SUPERCOV_DIR
     require("node:vm").runInThisContext("globalThis.__SUPERCOV_DIRECT_RUNTIME__");
 if (!runtime) throw new Error("[supercov] Jest runtime was not initialized by the preload");
 globalThis.__SUPERCOV_DIRECT_RUNTIME__ = runtime;
+// A process that turns out to run Jest (a wrapper that calls it in place)
+// prints a failure's paths as the project's too. See register.mjs.
+const failureOutput = process.__SUPERCOV_FAILURE_OUTPUT__ ??
+    require("node:vm").runInThisContext("process.__SUPERCOV_FAILURE_OUTPUT__");
+if (typeof failureOutput === "function") failureOutput("jest");
 module.exports = runtime;

package/runtime/javascript/register.mjs

@@ -8,7 +8,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 };
 import Module, { register, syncBuiltinESMExports } from "node:module";
 import fs, { closeSync, openSync, readFileSync, realpathSync, unlinkSync } from "node:fs";
-import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import path, { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { installLaunchSupervisor, wrapImportedCapability } from "./launchSupervisor.mjs";
 import { __supercovBindCapabilityWrapper } from "./capability.mjs";
@@ -85,6 +85,34 @@ if (process.env.SUPERCOV_DURABLE_EVIDENCE_EACH_TEST === "1" ||
     // and may evaluate before any ESM instrumented file imports it.
     globalThis.__supercovRuntime ??= globalThis.__SUPERCOV_DIRECT_RUNTIME__;
 }
+// Next.js runs a middleware and a route with `runtime = "edge"` in a VM
+// context of its own, the Edge Runtime's, and that context's global is not
+// this one. An instrumented file found no runtime there: every request to an
+// application with a middleware.ts failed on "Cannot read properties of
+// undefined (reading 'mcdcBegin')", and `next build` failed collecting page
+// data for an edge route. Such a context reads this process's runtime, so
+// what runs there is measured like the rest of the server.
+const virtualMachine = Module._load("node:vm", undefined, false);
+const createContext = virtualMachine.createContext;
+virtualMachine.createContext = function createContextWithRuntime(...parameters) {
+    const context = Reflect.apply(createContext, this, parameters);
+    if (parameters[1]?.name === "Edge Runtime") {
+        try {
+            Object.defineProperty(context, "__SUPERCOV_DIRECT_RUNTIME__", {
+                configurable: true,
+                enumerable: false,
+                get: () => globalThis.__SUPERCOV_DIRECT_RUNTIME__ ?? process.__SUPERCOV_DIRECT_RUNTIME__,
+                set(value) {
+                    Object.defineProperty(context, "__SUPERCOV_DIRECT_RUNTIME__", {
+                        configurable: true, enumerable: false, writable: true, value,
+                    });
+                },
+            });
+        }
+        catch { }
+    }
+    return context;
+};
 // Workers are independent Node processes and an explicit `execArgv: []`
 // otherwise strips the preload that supplies the isolated runtime. Preserve
 // every user option while adding exactly one Supercov import.
@@ -196,6 +224,284 @@ else if (/\/node_modules\/next\/dist\/compiled\/jest-worker\/processChild\.js$/.
         return Reflect.apply(compile, this, [content, filename, ...rest]);
     };
 }
+// A runner prints a failure with the files it names read from disk, and with
+// their paths relative to its root. Both are the copy's: the code under a
+// frame was Supercov's, and a file whose map names the project's own (so that
+// a Node stack trace reads as the project's) printed as
+// `../../../../src/crypto.js:10:11`. A runner's own printing reads a
+// rewritten file as the text it was rewritten from, and names it as it lies
+// in the copy. What runs is read as it is.
+//
+// Jest keeps the function it reads with from before any test loads, so its
+// processes are set up here, when they start. Its setup file and Vitest's
+// reporter ask again, which is what a process that only turns out to run a
+// suite gets.
+const failureOutput = { readers: [], installed: false };
+process.__SUPERCOV_FAILURE_OUTPUT__ ??= function supercovFailureOutput(runner) {
+    const reader = {
+        // Its message formatter reads the file under a frame and makes each
+        // frame's path relative to the root directory. So does the reporter
+        // that writes the tracefile coverage services read, where a file was
+        // `SF:../../../../src/crypto.js`.
+        jest: { prints: /[\\/](?:jest-message-util|istanbul-reports)[\\/]/, names: false, composes: true },
+        // Its own code reads the file under a frame, and Vitest 4 also looks in
+        // it for a source map, mapping positions a second time. Vite, which
+        // loads what runs, gets a map that names the file itself: frames then
+        // name the copy's file, and coverage reports it by its path in the
+        // project's layout.
+        vitest: { prints: /[\\/]vitest[\\/]dist[\\/]/, names: true },
+    }[runner];
+    // Asked with no runner, the reads are in place and change nothing until
+    // one is named: a process that may yet run a suite.
+    if (reader && !failureOutput.readers.includes(reader.prints.source)) {
+        failureOutput.readers.push(reader.prints.source);
+        failureOutput.prints = new RegExp(failureOutput.readers.join("|"));
+        failureOutput.names || (failureOutput.names = reader.names);
+        failureOutput.composes || (failureOutput.composes = reader.composes === true);
+    }
+    if (failureOutput.installed)
+        return;
+    failureOutput.installed = true;
+    let rewritten;
+    const copies = (() => {
+        const copy = fileURLToPath(new URL("../../", import.meta.url));
+        try {
+            return [...new Set([copy, `${realpathSync(copy)}${sep}`])];
+        }
+        catch {
+            return [copy];
+        }
+    })();
+    // The copy lies in the project at .supercov/workspaces/workspace/<name>.
+    const projects = copies
+        .filter((copy) => /[\\/]\.supercov[\\/]workspaces[\\/]workspace[\\/][^\\/]+[\\/]$/.test(copy))
+        .map((copy) => resolve(copy, "../../../..") + sep);
+    // The path inside the copy of a rewritten file that lies under one of `roots`.
+    const rewrittenUnder = (roots, file) => {
+        if (typeof file !== "string")
+            return undefined;
+        if (rewritten === undefined) {
+            try {
+                rewritten = new Set(JSON.parse(readFileSync(new URL("./authored-sources.json", import.meta.url), "utf8")));
+            }
+            catch {
+                rewritten = new Set();
+            }
+        }
+        for (const root of roots) {
+            if (file.startsWith(root)) {
+                const local = file.slice(root.length).split(sep).join("/");
+                return rewritten.has(local) ? local : undefined;
+            }
+        }
+        return undefined;
+    };
+    const kept = (name, file) => fileURLToPath(new URL(`./${name}/${file}`, import.meta.url));
+    const calledByPrinter = (above) => {
+        const holder = {};
+        const limit = Error.stackTraceLimit;
+        try {
+            Error.stackTraceLimit = 1;
+            Error.captureStackTrace(holder, above);
+        }
+        finally {
+            Error.stackTraceLimit = limit;
+        }
+        return failureOutput.prints.test(String(holder.stack).split("\n")[1] ?? "");
+    };
+    const mapComment = "\n//# sourceMappingURL=data:application/json;base64,";
+    const namedForItself = (file, contents) => {
+        const text = typeof contents === "string" ? contents : contents.toString("utf8");
+        const found = text.lastIndexOf(mapComment);
+        if (found < 0)
+            return contents;
+        const encoded = text.slice(found + mapComment.length).trimEnd();
+        if (/\s/.test(encoded))
+            return contents;
+        try {
+            const map = JSON.parse(Buffer.from(encoded, "base64").toString("utf8"));
+            map.sources = [basename(file)];
+            const renamed = `${text.slice(0, found + mapComment.length)}${Buffer.from(JSON.stringify(map)).toString("base64")}\n`;
+            return typeof contents === "string" ? renamed : Buffer.from(renamed, "utf8");
+        }
+        catch {
+            return contents;
+        }
+    };
+    // A transformer that compiles what it is given and reads no map in it
+    // (ts-jest) leaves Jest a map from its output to the rewritten file, so a
+    // frame read `src/crypto.ts:51:10` for line 10 of what the author wrote.
+    // Such a map is taken through the rewritten file's own before Jest reads
+    // it. One that already carries the author's text went through it in the
+    // transformer, as Babel's and SWC's do.
+    const digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    const decoded = (mappings) => {
+        const lines = [];
+        const state = [0, 0, 0, 0, 0];
+        for (const line of mappings.split(";")) {
+            const segments = [];
+            state[0] = 0;
+            for (const text of line.split(",")) {
+                if (text === "")
+                    continue;
+                const fields = [];
+                let value = 0, shift = 0;
+                for (const digit of text) {
+                    const bits = digits.indexOf(digit);
+                    value += (bits & 31) << shift;
+                    if (bits & 32) {
+                        shift += 5;
+                        continue;
+                    }
+                    fields.push(value & 1 ? -(value >> 1) : value >> 1);
+                    value = shift = 0;
+                }
+                segments.push(fields.map((field, index) => (state[index] += field)));
+            }
+            lines.push(segments);
+        }
+        return lines;
+    };
+    const encoded = (lines) => {
+        const state = [0, 0, 0, 0, 0];
+        const number = (value) => {
+            let rest = value < 0 ? (-value << 1) | 1 : value << 1;
+            let text = "";
+            do {
+                const bits = rest & 31;
+                rest >>>= 5;
+                text += digits[rest > 0 ? bits | 32 : bits];
+            } while (rest > 0);
+            return text;
+        };
+        return lines.map((segments) => {
+            state[0] = 0;
+            return segments.map((fields) => fields.map((field, index) => {
+                const text = number(field - state[index]);
+                state[index] = field;
+                return text;
+            }).join("")).join(",");
+        }).join(";");
+    };
+    const ownMap = (file) => {
+        const text = readSync(file, "utf8");
+        const found = text.lastIndexOf(mapComment);
+        return found < 0 ? undefined : JSON.parse(Buffer.from(text.slice(found + mapComment.length).trimEnd(), "base64").toString("utf8"));
+    };
+    const composed = (text) => {
+        let map;
+        try {
+            map = JSON.parse(text);
+            if (map?.version !== 3 || typeof map.mappings !== "string" || !Array.isArray(map.sources))
+                return text;
+            const through = map.sources.map((source, index) => {
+                if (typeof source !== "string" || rewrittenUnder(copies, source) === undefined)
+                    return undefined;
+                const own = ownMap(source);
+                if (!own || own.sourcesContent?.[0] === undefined || map.sourcesContent?.[index] === own.sourcesContent[0])
+                    return undefined;
+                return { own, lines: decoded(own.mappings) };
+            });
+            if (!through.some(Boolean))
+                return text;
+            const lines = decoded(map.mappings).map((segments) => segments.map((fields) => {
+                const inner = fields.length >= 4 ? through[fields[1]] : undefined;
+                if (!inner)
+                    return fields;
+                // The segment of the rewritten file's line that starts at or
+                // before the position; one that maps nothing is Supercov's.
+                const found = (inner.lines[fields[2]] ?? []).filter((segment) => segment[0] <= fields[3]).pop();
+                if (!found || found.length < 4)
+                    return [fields[0]];
+                return [fields[0], fields[1], found[2], found[3], ...fields.slice(4)];
+            }));
+            through.forEach((inner, index) => {
+                if (!inner)
+                    return;
+                const source = inner.own.sources?.[0];
+                if (typeof source === "string" && isAbsolute(source))
+                    map.sources[index] = source;
+                map.sourcesContent ?? (map.sourcesContent = []);
+                map.sourcesContent[index] = inner.own.sourcesContent[0];
+            });
+            map.mappings = encoded(lines);
+            return JSON.stringify(map);
+        }
+        catch {
+            return text;
+        }
+    };
+    const { readFileSync: readSync, existsSync: exists } = fs;
+    const { readFile: readPromise } = fs.promises;
+    const { relative: relativePath } = path;
+    function supercovReadFileSync(file, ...rest) {
+        if (!failureOutput.prints)
+            return Reflect.apply(readSync, this, [file, ...rest]);
+        const local = rewrittenUnder(copies, file);
+        if (local === undefined) {
+            const contents = Reflect.apply(readSync, this, [file, ...rest]);
+            return failureOutput.composes && typeof contents === "string" && typeof file === "string" && file.endsWith(".map")
+                ? composed(contents)
+                : contents;
+        }
+        if (calledByPrinter(supercovReadFileSync)) {
+            const changed = kept(".changed", local);
+            return Reflect.apply(readSync, this, [exists(changed) ? changed : kept(".authored", local), ...rest]);
+        }
+        const contents = Reflect.apply(readSync, this, [file, ...rest]);
+        return failureOutput.names ? namedForItself(file, contents) : contents;
+    }
+    fs.readFileSync = supercovReadFileSync;
+    fs.promises.readFile = async function supercovReadFile(file, ...rest) {
+        const contents = await Reflect.apply(readPromise, this, [file, ...rest]);
+        return failureOutput.names && rewrittenUnder(copies, file) !== undefined && (typeof contents === "string" || Buffer.isBuffer(contents))
+            ? namedForItself(file, contents)
+            : contents;
+    };
+    function supercovRelative(from, to) {
+        if (!failureOutput.prints)
+            return Reflect.apply(relativePath, this, [from, to]);
+        const local = rewrittenUnder(copies, to) === undefined ? rewrittenUnder(projects, to) : undefined;
+        return local !== undefined && calledByPrinter(supercovRelative)
+            ? Reflect.apply(relativePath, this, [from, copies[0] + local.split("/").join(sep)])
+            : Reflect.apply(relativePath, this, [from, to]);
+    }
+    path.relative = supercovRelative;
+    syncBuiltinESMExports();
+};
+// Jest itself prints from here on. A worker may be Jest's or another tool's
+// (a bundler minifies in the same kind of process): Jest's setup file names
+// the runner when a test file loads there.
+if (isJestEntrypoint)
+    process.__SUPERCOV_FAILURE_OUTPUT__("jest");
+else if (process.env.JEST_WORKER_ID)
+    process.__SUPERCOV_FAILURE_OUTPUT__();
+// Next.js looks for lockfiles from its directory upwards, takes the outermost
+// as its workspace root, and warns when it finds more than one. The copy
+// holds the project's lockfile and lies inside the project, so every build
+// under Supercov warned twice that the root "may not be correct", naming the
+// copy's lockfile. The root Next picks is the project, which is right: it
+// holds the copy and the dependencies. The copy's lockfile is left out of
+// what the warning counts, and one the project really has twice still warns.
+if (/\/node_modules\/(?:\.bin\/next$|next\/dist\/)/.test(entrypoint)) {
+    const copy = fileURLToPath(new URL("../../", import.meta.url));
+    const copies = [...new Set([copy, (() => {
+                try {
+                    return realpathSync(copy);
+                }
+                catch {
+                    return copy;
+                }
+            })()])];
+    const declared = "function warnDuplicatedLockFiles(lockFiles) {";
+    const compile = Module.prototype._compile;
+    Module.prototype._compile = function _compile(content, filename, ...rest) {
+        if (typeof content === "string" && /[\\/]next[\\/]dist[\\/]lib[\\/]find-root\.js$/.test(filename)) {
+            content = content.replace(declared, `${declared} lockFiles = lockFiles.filter((file, index) => index === lockFiles.length - 1 || !${JSON.stringify(copies)}.some((copy) => file.startsWith(copy)));`);
+        }
+        return Reflect.apply(compile, this, [content, filename, ...rest]);
+    };
+}
 function installAuthoredSourceView() {
     let authored;
     try {

package/runtime/javascript/runtime.mjs

@@ -886,21 +886,44 @@ function finishAssertionPhase(phase, error) {
     phase.error = error instanceof Error ? error.message : String(error);
 }
 
-function cleanInstrumentationStack(error) {
+const INSTRUMENTATION_FRAME = /[\\/]\.supercov[\\/](?:node_modules[\\/])?(?:playwright|nodeTest|vitest|runtime|launchSupervisor|nodeAssert|nodeAssertStrict|nodeAssertAdapter|register|resolve-loader)\.(?:js|mjs)(?::|\))/u;
+// A lexical wrapper runs the assertion in a function of its own, so its
+// stack had two frames where the author wrote one: the function Supercov
+// added, at the assertion, and below the runtime's frames the function the
+// author wrote, at the wrapper. Vitest printed both, `:12:35` and `:12:1`.
+// They are one frame again: the author's function, where the assertion is.
+function cleanInstrumentationStack(error, lexical = false) {
   if (!error || typeof error !== "object" || typeof error.stack !== "string")
     return error;
   const lines = error.stack.split("\n");
-  const visible = lines.filter((line, index) => index === 0 || !/[\\/]\.supercov[\\/](?:node_modules[\\/])?(?:playwright|nodeTest|vitest|runtime|launchSupervisor|nodeAssert|nodeAssertStrict|nodeAssertAdapter|register|resolve-loader)\.(?:js|mjs)(?::|\))/u.test(line));
-  if (visible.length !== lines.length) {
-    try {
-      error.stack = visible.join("\n");
-    } catch (e) {
-    }
+  const hidden = lines.map((line, index) => index > 0 && INSTRUMENTATION_FRAME.test(line));
+  const first = hidden.indexOf(true);
+  if (first < 0)
+    return error;
+  const last = hidden.lastIndexOf(true);
+  let visible;
+  const frame = /^(\s*at (?:async )?)(?:(.*?) \()?(.*?:\d+:\d+)\)?$/;
+  const added = lexical && first > 1 ? frame.exec(lines[first - 1]) : null;
+  const written = added && last + 1 < lines.length ? frame.exec(lines[last + 1]) : null;
+  const file = (location) => location.replace(/:\d+:\d+$/, "");
+  // Both are frames of the author's file, or the error is another's. A name
+  // on the added one comes from a source map (Jest names a frame by what is
+  // called at its position), and it is the name the author's line would have.
+  if (added && written && file(added[3]) === file(written[3])) {
+    const merged = added[2] !== void 0 || written[2] === void 0 ? lines[first - 1] : `${written[1]}${written[2]} (${added[3]})`;
+    visible = [...lines.slice(0, first - 1), merged, ...lines.slice(last + 2)];
+  } else {
+    visible = lines.filter((line, index) => !hidden[index]);
+  }
+  try {
+    error.stack = visible.join("\n");
+  } catch (e) {
   }
   return error;
 }
 function withNodeAssertionPhase(operation, source, callback) {
   var _a8;
+  const lexical = typeof source === "string";
   const context = currentRequestContext();
   const scope = context.scope;
   if (!scope)
@@ -944,13 +967,13 @@ function withNodeAssertionPhase(operation, source, callback) {
         return value;
       }, (error) => {
         finishAssertionPhase(phase, error);
-        throw cleanInstrumentationStack(error);
+        throw cleanInstrumentationStack(error, lexical);
       });
     finishAssertionPhase(phase);
     return result;
   } catch (error) {
     finishAssertionPhase(phase, error);
-    throw cleanInstrumentationStack(error);
+    throw cleanInstrumentationStack(error, lexical);
   }
 }
 // Callee binding preserves receiver, getter/evaluation order, spreads and the

package/runtime/javascript/vitestReporter.mjs

@@ -29,6 +29,8 @@ export default class SupercovVitestReporter {
     }
     onInit(vitest) {
         this.configureProjects?.(vitest.projects);
+        // Failures print the project's paths and code: see register.mjs.
+        process.__SUPERCOV_FAILURE_OUTPUT__?.("vitest");
     }
     onBrowserInit(project) {
         this.configureProjects?.([project]);