supercov 4.24.7 → 4.25.0

package/runtime/javascript/playwrightCacheThread.mjs

@@ -0,0 +1,6 @@
+// The thread Node runs module hooks in, where Playwright compiles ES modules
+// and writes them into its cache: written whole there too (atomic.mjs says
+// why). Supercov's own hooks run in the importing thread where Node can, so
+// this goes to that thread on its own.
+import { writePlaywrightCacheWhole } from "./atomic.mjs";
+writePlaywrightCacheWhole();

package/runtime/javascript/register.mjs

@@ -13,28 +13,20 @@ 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";
+// Supercov runs Node with --enable-source-maps so a stack through an
+// instrumented copy names the project's file. The flag also reads the maps
+// every package ships, which a plain run never does: a third of the CPU a
+// measured Vitest suite added. Where Node can, Supercov's flag maps the
+// project's files alone, unless the command asked for maps itself: a second
+// flag in NODE_OPTIONS, or one on its own command line.
+if ((process.env.NODE_OPTIONS ?? "").split(/\s+/).filter((option) => option === "--enable-source-maps").length === 1 &&
+    !process.execArgv.includes("--enable-source-maps") &&
+    typeof Module.setSourceMapsSupport === "function")
+    Module.setSourceMapsSupport(true, { nodeModules: false, generatedCode: true });
 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);
@@ -213,8 +205,16 @@ const nodeAssertWrapper = new URL("./nodeAssert.mjs", import.meta.url).href;
 const nodeAssertStrictWrapper = new URL("./nodeAssertStrict.mjs", import.meta.url).href;
 const isPlaywrightEntrypoint = /\/(?:node_modules\/\.bin\/playwright|node_modules\/(?:@playwright\/test|playwright)\/(?:cli\.js|.*\/program\.js))$/.test(entrypoint);
 const isJestEntrypoint = /\/node_modules\/(?:\.bin\/jest|(?:jest|jest-cli)\/bin\/jest\.js)$/.test(entrypoint);
-if (generatedPlaywrightConfig && isPlaywrightEntrypoint)
+if (generatedPlaywrightConfig && isPlaywrightEntrypoint) {
     process.env.SUPERCOV_INSIDE_PLAYWRIGHT = "1";
+    // Every process the runner starts inherits SUPERCOV_INSIDE_PLAYWRIGHT, the
+    // app server and each mock server too, and loading the wrapper cost each of
+    // them 190 ms before its first line: a server Playwright waits on missed its
+    // first look, about 4 s a run. The runner's children are marked as not test
+    // workers, and the launch supervisor marks the ones it forks from its worker
+    // entry as workers, so only those load the wrapper.
+    process.env.SUPERCOV_PLAYWRIGHT_WORKER = "0";
+}
 // 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",
@@ -984,13 +984,41 @@ if (missingFile) {
         }
     };
 }
-register(new URL("./resolve-loader.mjs", import.meta.url), {
-    data: {
-        typescriptRequireHook: typeof typescriptHandler === "function" && typescriptHandler.name !== "loadTS",
-        supportFile,
-        missingFile,
-    },
-});
+const loaderData = {
+    typescriptRequireHook: typeof typescriptHandler === "function" && typescriptHandler.name !== "loadTS",
+    supportFile,
+    missingFile,
+};
+// Where Node can (22.15, 23.5), the hooks run in this thread. Off it, every
+// Node process started a thread of its own and compiled a module loader
+// there, and each import and require waited on a message to it: on a Next.js
+// app's Vitest suite on one worker, a third of the time a measured run added.
+if (typeof Module.registerHooks === "function") {
+    const hooks = await import("./resolve-loader.mjs");
+    hooks.initialize(loaderData);
+    Module.registerHooks({ resolve: hooks.resolveSync, load: hooks.loadSync });
+    // Playwright compiles ES modules in the hooks thread its own loader
+    // starts, which these hooks no longer reach: the cache patch goes to that
+    // thread by itself, ahead of the first module anyone registers off this
+    // one, which is what starts it. Supercov names the cache for every run,
+    // and registering it unasked started the thread in every Node process --
+    // a Vitest worker -- and sent each of its imports through it.
+    if (process.env.PWTEST_CACHE_DIR) {
+        const registerOffThread = Module.register;
+        let cacheThreadRegistered = false;
+        Module.register = function (...args) {
+            if (!cacheThreadRegistered) {
+                cacheThreadRegistered = true;
+                registerOffThread.call(this, new URL("./playwrightCacheThread.mjs", import.meta.url));
+            }
+            return registerOffThread.apply(this, args);
+        };
+        syncBuiltinESMExports();
+    }
+}
+else {
+    register(new URL("./resolve-loader.mjs", import.meta.url), { data: loaderData });
+}
 if (process.env.SUPERCOV_DEBUG === "1") {
     console.error("[supercov] preload", { entrypoint });
 }
@@ -1056,9 +1084,21 @@ if (generatedPlaywrightConfig &&
     }
     process.argv.push("--config", generatedPlaywrightConfig);
 }
+// A process the runner marked as not a test worker skips the wrapper, unless
+// it was started from Playwright's own files: a worker Playwright starts some
+// other way than its worker entry still has the wrapper, only later. The
+// runner itself has it too: it lists each test with the fixtures its spec's
+// `test` carries, and puts tests with the same worker fixtures in one worker.
+// A CommonJS spec it listed with Playwright's own `test` ran in the worker
+// with the wrapper's, beside a spec through a facade that has Playwright's
+// own in both, and the worker refused the pair: "Playwright detected
+// inconsistent test.use() options". An ES module spec already had the wrapper
+// in the runner, through the module hooks.
+const isPlaywrightProcess = /\/node_modules\/(?:@playwright\/test|playwright)\//.test(entrypoint);
+const mayBePlaywrightWorker = process.env.SUPERCOV_PLAYWRIGHT_WORKER !== "0" || isPlaywrightProcess;
 if (process.env.SUPERCOV_CJS_INTERCEPT === "1" &&
     process.env.SUPERCOV_INSIDE_PLAYWRIGHT === "1" &&
-    !isPlaywrightEntrypoint &&
+    (isPlaywrightEntrypoint || mayBePlaywrightWorker) &&
     process.env.SUPERCOV_INSIDE_VITEST !== "1" &&
     process.env.VITEST !== "true") {
     const target = playwrightTarget ?? "@playwright/test";
@@ -1066,6 +1106,16 @@ if (process.env.SUPERCOV_CJS_INTERCEPT === "1" &&
     const originalPlaywrightConfig = process.env.SUPERCOV_ORIGINAL_PLAYWRIGHT_CONFIG
         ?.replaceAll("\\", "/");
     const wrapper = await import(__rewriteRelativeImportExtension(new URL("./playwright.mjs", import.meta.url)));
+    // A spec transpiled from `import test from "@playwright/test"` reads the
+    // module's `default` when it says it is an ES module, and the module
+    // itself otherwise: the wrapper's namespace says nothing and is no
+    // function, and a Next.js app's spec failed with `(0 , _test.default) is not
+    // a function`. Its exports, marked as an ES module's, with `test` itself
+    // as the default. Not a function that calls `test` (Playwright names a
+    // test by where it was declared, read from the stack, and an extra frame
+    // moved it), nor the exports assigned onto the wrapper's `test` (its
+    // fixtures then differed between the runner and a worker).
+    const commonjsWrapper = { ...wrapper, __esModule: true, default: wrapper.test };
     const originalLoad = Module._load;
     Module._load = function supercovLoad(request, parent, isMain) {
         const parentFile = parent?.filename?.replaceAll("\\", "/");
@@ -1083,7 +1133,7 @@ if (process.env.SUPERCOV_CJS_INTERCEPT === "1" &&
                 ? parentFile.startsWith(`${normalizedRoot}/`)
                 : parentFile.includes("/tests/"));
         if (request === target && belongsToProject)
-            return wrapper;
+            return commonjsWrapper;
         return originalLoad.call(this, request, parent, isMain);
     };
 }
@@ -1136,7 +1186,13 @@ if (process.env.SUPERCOV_CJS_INTERCEPT === "1") {
         }
     }
     const originalLoad = Module._load;
+    const redirected = new Set(["test", "node:test", "assert", "node:assert", "assert/strict", "node:assert/strict"]);
     Module._load = function supercovNodeTestLoad(request, parent, isMain) {
+        // Every require comes here, cached or not, thousands in a test
+        // worker: only these six names are redirected, and nothing else is
+        // looked at for any other.
+        if (!redirected.has(request))
+            return originalLoad.call(this, request, parent, isMain);
         const parentFile = parent?.filename?.replaceAll("\\", "/");
         const belongsToProject = Boolean(projectRoot &&
             parentFile?.startsWith(`${projectRoot}/`) &&

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);
@@ -111,7 +115,9 @@ function throughRequireHook(resolved) {
         return resolved;
     return { ...resolved, format: "commonjs" };
 }
-export async function resolve(specifier, context, nextResolve) {
+// A specifier Supercov answers itself (`url`), or sends on as another
+// (`next`, answered as it is); undefined for every other.
+function redirected(specifier, context) {
     // Some transpilers preserve the source-relative runtime import while moving
     // only the transformed application file to an output directory. The
     // source-local copy keeps strict rootDir compilers happy; this fallback
@@ -157,8 +163,16 @@ export async function resolve(specifier, context, nextResolve) {
                 shortCircuit: true,
             };
         }
-        return nextResolve(REPLACEMENT, context);
+        return { next: REPLACEMENT };
     }
+    return undefined;
+}
+export async function resolve(specifier, context, nextResolve) {
+    const redirect = redirected(specifier, context);
+    if (redirect?.url)
+        return redirect;
+    if (redirect?.next)
+        return nextResolve(redirect.next, context);
     try {
         return throughRequireHook(await nextResolve(specifier, context));
     }
@@ -168,6 +182,28 @@ export async function resolve(specifier, context, nextResolve) {
         throw error;
     }
 }
+// The same hooks run in the loading thread (`module.registerHooks`), where
+// the next hook answers at once. There they see `require` calls too, which
+// the hooks off the thread never did, and the CommonJS loader routes itself:
+// a TypeScript file it was given back as CommonJS was compiled as JavaScript,
+// past the handler ts-node/register installed for it.
+export function resolveSync(specifier, context, nextResolve) {
+    if (context.conditions?.includes("require"))
+        return nextResolve(specifier, context);
+    const redirect = redirected(specifier, context);
+    if (redirect?.url)
+        return redirect;
+    if (redirect?.next)
+        return nextResolve(redirect.next, context);
+    try {
+        return throughRequireHook(nextResolve(specifier, context));
+    }
+    catch (error) {
+        if (error?.code === "ERR_MODULE_NOT_FOUND")
+            noteMissing(specifier, context.parentURL);
+        throw error;
+    }
+}
 
 // Node's own test coverage filters files by `--test-coverage-include` and
 // `--test-coverage-exclude` globs relative to the working directory, and the
@@ -200,7 +236,17 @@ function mapToCopy(source, filename) {
     }
 }
 export async function load(url, context, nextLoad) {
-    const result = await nextLoad(url, context);
+    return loaded(url, await nextLoad(url, context));
+}
+export function loadSync(url, context, nextLoad) {
+    // Every module this process loads, required or imported: a server's
+    // runtime rescans the module cache for new ones only when this moved.
+    globalThis.__SUPERCOV_MODULE_LOADS__ = (globalThis.__SUPERCOV_MODULE_LOADS__ ?? 0) + 1;
+    if (context.conditions?.includes("require"))
+        return nextLoad(url, context);
+    return loaded(url, nextLoad(url, context));
+}
+function loaded(url, result) {
     noteLoaded(url);
     if (!NODE_COVERAGE_FILTERS || result.source == null || !url.startsWith("file:"))
         return result;

package/runtime/javascript/runnerEvidence.mjs

@@ -98,12 +98,27 @@ export function callerLocation(boundary = callerLocation) {
         return {};
     }
 }
+/**
+ * A compact attempt file names its scope on a writer's first line only; each
+ * line without one is the attempt of the line before it.
+ */
+function inheritingScope() {
+    let current;
+    return (line) => {
+        const record = JSON.parse(line);
+        if (record.scope)
+            current = record.scope;
+        else if (current)
+            record.scope = current;
+        return record;
+    };
+}
 export function readScopedServerEvidence(scope, evidencePath = serverEvidencePath(scope)) {
     try {
         return readFileSync(evidencePath, "utf8")
             .split("\n")
             .filter(Boolean)
-            .map((line) => JSON.parse(line))
+            .map(inheritingScope())
             .filter((record) => record.scope?.attemptId === scope.attemptId);
     }
     catch {