supercov 4.1.1 → 4.2.1

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

@@ -354,7 +354,24 @@ npx supercov diff <older-run> <newer-run>
 
 `diff` reports gains and losses. Use it after adding a test to prove that the
 expected behavior became covered without an unexplained regression elsewhere.
-Neither input run is changed.
+Neither input run is changed. Under the totals it lists what was lost, marked
+`-`, and then what was gained, marked `+`:
+
+```
+gained: 1 lines, 1 branches, 0 MC/DC conditions
+lost: 1 lines, 1 branches, 0 MC/DC conditions
+- line src/fee.js:5
+- branch src/fee.js:2 false
++ line src/fee.js:3
++ branch src/fee.js:2 true
+```
+
+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:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supercov",
-  "version": "4.1.1",
+  "version": "4.2.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.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"
+    "@supercov/cli-darwin-arm64": "4.2.1",
+    "@supercov/cli-darwin-x64": "4.2.1",
+    "@supercov/cli-linux-arm64-gnu": "4.2.1",
+    "@supercov/cli-linux-arm64-musl": "4.2.1",
+    "@supercov/cli-linux-x64-gnu": "4.2.1",
+    "@supercov/cli-linux-x64-musl": "4.2.1",
+    "@supercov/cli-win32-arm64": "4.2.1",
+    "@supercov/cli-win32-x64": "4.2.1"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.55.0",

package/runtime/javascript/playwright.mjs

@@ -198,6 +198,7 @@ class CoveragePhaseController {
     cdpSessions = new Map();
     newDocumentScriptIds = new Map();
     pendingRegistrations = new Set();
+    pageRegistrations = new WeakMap();
     scriptUpdate = Promise.resolve();
     proxyCache = new WeakMap();
     runtimeSnapshots;
@@ -381,8 +382,27 @@ class CoveragePhaseController {
             }
         }
     }
-    async registerPage(page) {
-        if (this.pages.has(page) || this.disposed)
+    /**
+     * A page is registered once, and whoever asks while that is under way
+     * waits for it. Playwright announces a page to the context's listener
+     * before the fixture that hands it to the test has it, so the listener
+     * started the registration and the fixture, finding the page known,
+     * returned at once: the test's first `page.goto` began before the page had
+     * the session a phase is installed through. The document it loaded did not
+     * know its phase, and its hits were left to be placed by their time.
+     */
+    registerPage(page) {
+        if (this.disposed)
+            return Promise.resolve();
+        let registration = this.pageRegistrations.get(page);
+        if (!registration) {
+            registration = this.registerNewPage(page);
+            this.pageRegistrations.set(page, registration);
+        }
+        return registration;
+    }
+    async registerNewPage(page) {
+        if (this.pages.has(page))
             return;
         timingCount("registerPage");
         this.pages.add(page);
@@ -393,8 +413,15 @@ class CoveragePhaseController {
             adopted: !this.contexts.has(context) && tracked && !headersKnown,
         });
         const cdp = await page.context().newCDPSession(page).catch(() => undefined);
-        if (cdp)
+        if (cdp) {
+            // Chromium runs a session's new-document scripts only once the
+            // session has enabled the Page domain. Without it the script that
+            // tells a document its phase was accepted and never ran: a page
+            // learned its phase only from the next action, after it had
+            // loaded, and everything it ran while loading was placed by time.
+            await cdp.send("Page.enable").catch(() => undefined);
             this.cdpSessions.set(page, cdp);
+        }
         const phaseId = this.requestPhaseId();
         if (phaseId)
             await this.activatePage(page, phaseId);

package/runtime/javascript/register.mjs

@@ -452,6 +452,16 @@ process.__SUPERCOV_FAILURE_OUTPUT__ ??= function supercovFailureOutput(runner) {
         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))
@@ -469,35 +479,69 @@ process.__SUPERCOV_FAILURE_OUTPUT__ ??= function supercovFailureOutput(runner) {
     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.
+// 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 if (process.env.JEST_WORKER_ID)
-    process.__SUPERCOV_FAILURE_OUTPUT__();
+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

@@ -926,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