supercov 4.1.0 → 4.2.0

package/docs/agent-loop.md

@@ -49,6 +49,11 @@ and file paths in place of the examples. For example,
 Rust projects can use `cargo test`, Python projects `pytest`, and Ruby projects
 `bundle exec rspec`. Keep the baseline and verification commands identical.
 
+A loss in the comparison is not always a regression. An end-to-end suite
+reaches slightly different code from one run to the next, and adding a test
+changes no source: when `diff` notes that both runs measured the same source,
+rerun before treating a loss as real.
+
 The `line` query is useful before writing a test because it shows which tests
 already reach that line. Extending a nearby test is often better than adding a
 duplicate.

package/docs/cli.md

@@ -356,6 +356,13 @@ npx supercov diff <older-run> <newer-run>
 expected behavior became covered without an unexplained regression elsewhere.
 Neither input run is changed.
 
+Two runs of the same code can differ a little: what an end-to-end suite
+reaches depends on timing, on the order of tests, and on state outside the
+code. When both runs measured the same source, `diff` says so under the
+totals, and a loss it lists is not a change in the code. Run again before
+acting on one. In `--json`, `inputs.sourceChanged` and `inputs.testsChanged`
+say what differed between the two runs.
+
 The same filters can focus a comparison:
 
 ```sh supercov

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supercov",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "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.1.0",
-    "@supercov/cli-darwin-x64": "4.1.0",
-    "@supercov/cli-linux-arm64-gnu": "4.1.0",
-    "@supercov/cli-linux-arm64-musl": "4.1.0",
-    "@supercov/cli-linux-x64-gnu": "4.1.0",
-    "@supercov/cli-linux-x64-musl": "4.1.0",
-    "@supercov/cli-win32-arm64": "4.1.0",
-    "@supercov/cli-win32-x64": "4.1.0"
+    "@supercov/cli-darwin-arm64": "4.2.0",
+    "@supercov/cli-darwin-x64": "4.2.0",
+    "@supercov/cli-linux-arm64-gnu": "4.2.0",
+    "@supercov/cli-linux-arm64-musl": "4.2.0",
+    "@supercov/cli-linux-x64-gnu": "4.2.0",
+    "@supercov/cli-linux-x64-musl": "4.2.0",
+    "@supercov/cli-win32-arm64": "4.2.0",
+    "@supercov/cli-win32-x64": "4.2.0"
   },
   "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";
@@ -224,28 +224,324 @@ 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;
+    // graceful-fs, which Jest reads through, copies `fs` when it loads, and a
+    // tool that runs Jest in its own process has usually loaded it by then.
+    for (const [file, cached] of Object.entries(Module._cache)) {
+        if (/[\\/]graceful-fs[\\/]graceful-fs\.js$/.test(file) && typeof cached?.exports?.readFileSync === "function") {
+            try {
+                cached.exports.readFileSync = supercovReadFileSync;
+            }
+            catch { }
+        }
+    }
+    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. Any other process is Jest's from the
+// moment it loads Jest: a worker of its, or a tool that runs Jest in its own
+// process (`require("jest").run()`, as react-scripts and Vue's CLI do), where
+// a failure in a single test file still printed the line Supercov had
+// wrapped. A worker of another tool's (a bundler minifies in the same kind
+// of process) never loads it.
+if (isJestEntrypoint)
+    process.__SUPERCOV_FAILURE_OUTPUT__("jest");
+else {
+    const jest = /(?:^|[\\/])(?:jest|jest-cli|@jest[\\/]core|jest-runner)(?:[\\/]|$)/;
+    const load = Module._load;
+    let loaded = false;
+    Module._load = function supercovJestLoad(request, ...rest) {
+        if (!loaded && typeof request === "string" && request.includes("jest") && jest.test(request)) {
+            loaded = true;
+            process.__SUPERCOV_FAILURE_OUTPUT__("jest");
+        }
+        return Reflect.apply(load, this, [request, ...rest]);
+    };
+}
 // 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)) {
+// holds the copy and the dependencies. The copy's lockfile is taken out of
+// the warning, which is not printed when no other is left; one the project
+// really has twice still warns.
+//
+// The warning is recognised by its text where Next prints it, in whatever
+// process loads Next: started by its own command, by a server of the
+// project's, or from a script. Next 15.4 to 16.4 print it through `warnOnce`.
+{
     const copy = fileURLToPath(new URL("../../", import.meta.url));
     const copies = [...new Set([copy, (() => {
                 try {
-                    return realpathSync(copy);
+                    return `${realpathSync(copy)}${sep}`;
                 }
                 catch {
                     return copy;
                 }
             })()])];
-    const declared = "function warnDuplicatedLockFiles(lockFiles) {";
+    const quieted = `
+;try { typeof warnOnce === "function" && (warnOnce = ((print) => function (...message) {
+    const text = message[0];
+    if (typeof text !== "string" || !text.includes("multiple lockfiles"))
+        return print.apply(this, message);
+    const copies = ${JSON.stringify(copies)};
+    const lines = text.split("\\n");
+    const listed = (line) => /^\\s+\\* \\S/.test(line);
+    const kept = lines.filter((line) => !listed(line) || !copies.some((copy) => line.trim().slice(2).startsWith(copy)));
+    if (!kept.some(listed))
+        return undefined;
+    return print.apply(this, [kept.join("\\n"), ...message.slice(1)]);
+})(warnOnce)); } catch {}
+`.replace(/\n\s*/g, " ");
     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)));`);
+        if (typeof content === "string" && typeof filename === "string" && filename.endsWith("log.js") &&
+            /[\\/]next[\\/]dist[\\/]build[\\/]output[\\/]log\.js$/.test(filename)) {
+            // After the last statement, before the source map's line.
+            const map = content.lastIndexOf("\n//# sourceMappingURL=");
+            content = map < 0 ? `${content}${quieted}` : `${content.slice(0, map)}${quieted}${content.slice(map)}`;
         }
         return Reflect.apply(compile, this, [content, filename, ...rest]);
     };

package/runtime/javascript/runtime.mjs

@@ -905,8 +905,12 @@ function cleanInstrumentationStack(error, lexical = false) {
   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;
-  if (added && written && added[2] === void 0 && !/^node:/.test(written[3])) {
-    const merged = written[2] === void 0 ? lines[first - 1] : `${written[1]}${written[2]} (${added[3]})`;
+  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]);
@@ -922,8 +926,16 @@ function withNodeAssertionPhase(operation, source, callback) {
   const lexical = typeof source === "string";
   const context = currentRequestContext();
   const scope = context.scope;
-  if (!scope)
-    return callback();
+  // No test is known to be running: a runner Supercov has no adapter in, such
+  // as Jest started from another tool's process. The assertion still fails
+  // with the frames its author would see.
+  if (!scope) {
+    try {
+      return callback();
+    } catch (error) {
+      throw cleanInstrumentationStack(error, lexical);
+    }
+  }
   // A lexically instrumented occurrence is an authored assertion site in its
   // own right, even when it runs inside another assertion's callback: the
   // validator passed to assert.throws is the ordinary case, and its inner

package/runtime/javascript/vitestReporter.mjs

@@ -1,112 +1,7 @@
-import fs from "node:fs";
-import { syncBuiltinESMExports } from "node:module";
-import { basename, isAbsolute, relative, resolve, sep } from "node:path";
+import { relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { inferTestProvenance } from "./provenance.mjs";
 import { appendEvidenceRecord } from "./atomic.mjs";
-// The files of the copy Supercov rewrote, by path inside it, and where each
-// is kept as its author wrote it or as a tool of the command changed it.
-const copyRoots = (() => {
-    const copy = fileURLToPath(new URL("../../", import.meta.url));
-    try {
-        return [...new Set([copy, fs.realpathSync(copy)])];
-    }
-    catch {
-        return [copy];
-    }
-})();
-let rewritten;
-function rewrittenFile(path) {
-    if (rewritten === undefined) {
-        try {
-            rewritten = new Set(JSON.parse(fs.readFileSync(new URL("./authored-sources.json", import.meta.url), "utf8")));
-        }
-        catch {
-            rewritten = new Set();
-        }
-    }
-    if (typeof path !== "string" || !isAbsolute(path))
-        return undefined;
-    for (const root of copyRoots) {
-        const local = relative(root, path);
-        if (local !== ".." && !local.startsWith(`..${sep}`) && !isAbsolute(local)) {
-            const file = local.split(sep).join("/");
-            return rewritten.has(file) ? file : undefined;
-        }
-    }
-    return undefined;
-}
-const SOURCE_MAP = "\n//# sourceMappingURL=data:application/json;base64,";
-/**
- * A rewritten file's source map names the project's own file, by absolute
- * path, so a Node stack trace reads as the project's. Vitest prints a frame
- * relative to its root, which is the copy: `../../../../lib/crypto.ts:3:11`
- * where it prints `lib/crypto.ts:3:11` without Supercov, and a file outside
- * its module graph gets no code under the frame. Vite is handed the same
- * code with a map that names the file itself.
- */
-export function supercovSourceMaps() {
-    const { readFile } = fs.promises;
-    return {
-        name: "supercov:source-maps",
-        enforce: "pre",
-        async load(id) {
-            if (rewrittenFile(id) === undefined)
-                return null;
-            try {
-                const code = await readFile(id, "utf8");
-                const found = code.lastIndexOf(SOURCE_MAP);
-                if (found < 0)
-                    return null;
-                const encoded = code.slice(found + SOURCE_MAP.length).trim();
-                if (/\s/.test(encoded))
-                    return null;
-                const map = JSON.parse(Buffer.from(encoded, "base64").toString("utf8"));
-                map.sources = [basename(id)];
-                return { code: code.slice(0, found + 1), map };
-            }
-            catch {
-                return null;
-            }
-        },
-    };
-}
-// Vitest reads a file a failure names: to print the code around the nearest
-// frame, and (Vitest 4) to look for a source map in it. In the copy that is
-// the rewritten file. An assertion wrapped into one long line printed no code
-// at all, any other line printed Supercov's, and positions that were already
-// the author's were mapped a second time through the file's own map: a test
-// file's frame at `:12:35` read `:12:0`. What Vitest itself reads is the text
-// the file was rewritten from. What runs is not read here: Vite loads it.
-let readsAuthored = false;
-function readAuthoredFromVitest() {
-    if (readsAuthored)
-        return;
-    readsAuthored = true;
-    const { readFileSync, existsSync } = fs;
-    const kept = (name, file) => fileURLToPath(new URL(`./${name}/${file}`, import.meta.url));
-    const calledByVitest = () => {
-        const holder = {};
-        const limit = Error.stackTraceLimit;
-        try {
-            Error.stackTraceLimit = 1;
-            Error.captureStackTrace(holder, supercovReadFileSync);
-        }
-        finally {
-            Error.stackTraceLimit = limit;
-        }
-        return /[\\/]vitest[\\/]dist[\\/]/.test(String(holder.stack).split("\n")[1] ?? "");
-    };
-    function supercovReadFileSync(path, ...rest) {
-        const file = rewrittenFile(path);
-        if (file === undefined || !calledByVitest())
-            return Reflect.apply(readFileSync, this, [path, ...rest]);
-        const changed = kept(".changed", file);
-        return Reflect.apply(readFileSync, this, [existsSync(changed) ? changed : kept(".authored", file), ...rest]);
-    }
-    fs.readFileSync = supercovReadFileSync;
-    syncBuiltinESMExports();
-}
 function sourcePath(moduleId) {
     const absolute = moduleId.startsWith("file:")
         ? fileURLToPath(moduleId)
@@ -134,7 +29,8 @@ export default class SupercovVitestReporter {
     }
     onInit(vitest) {
         this.configureProjects?.(vitest.projects);
-        readAuthoredFromVitest();
+        // Failures print the project's paths and code: see register.mjs.
+        process.__SUPERCOV_FAILURE_OUTPUT__?.("vitest");
     }
     onBrowserInit(project) {
         this.configureProjects?.([project]);