supercov 4.24.8 → 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

@@ -14,6 +14,16 @@ import { installLaunchSupervisor, wrapImportedCapability } from "./launchSupervi
 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's compile cache, written whole (atomic.mjs says why).
 writePlaywrightCacheWhole();
@@ -195,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",
@@ -966,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 });
 }
@@ -1038,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";
@@ -1048,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("\\", "/");
@@ -1065,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);
     };
 }
@@ -1118,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

@@ -115,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
@@ -161,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));
     }
@@ -172,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
@@ -204,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 {

package/runtime/javascript/runtime.mjs

@@ -37,7 +37,8 @@ var COVERAGE_CARRIER_ENV = "SUPERCOV_CONTEXT";
 var DEFAULT_SERVER_EVIDENCE_ROOT = "/tmp/supercov-server-evidence";
 function configuredServerEvidenceRoot() {
   var _a8;
-  return typeof process !== "undefined" && ((_a8 = process.env) == null ? void 0 : _a8["SUPERCOV_SERVER_EVIDENCE_ROOT"]) ? process.env["SUPERCOV_SERVER_EVIDENCE_ROOT"] : DEFAULT_SERVER_EVIDENCE_ROOT;
+  const configured = typeof process !== "undefined" ? (_a8 = process.env) == null ? void 0 : _a8["SUPERCOV_SERVER_EVIDENCE_ROOT"] : void 0;
+  return configured ? configured : DEFAULT_SERVER_EVIDENCE_ROOT;
 }
 function nonEmpty(value) {
   return typeof value === "string" && value.length > 0;
@@ -117,6 +118,18 @@ function serverEvidenceDirectory(scope, root = configuredServerEvidenceRoot()) {
 function serverEvidencePath(scope, root = configuredServerEvidenceRoot()) {
   return `${serverEvidenceDirectory(scope, root)}/${pathComponent(scope.attemptId)}.jsonl`;
 }
+// A scope's evidence directory and file, made once per scope and root: a
+// server works them out for every record it writes, thousands per test.
+var scopedEvidenceLocations = /* @__PURE__ */ new WeakMap();
+function scopedEvidenceLocation(scope) {
+  const root = configuredServerEvidenceRoot();
+  const known = scopedEvidenceLocations.get(scope);
+  if (known !== void 0 && known.root === root)
+    return known;
+  const location = { root, directory: serverEvidenceDirectory(scope, root), path: serverEvidencePath(scope, root) };
+  scopedEvidenceLocations.set(scope, location);
+  return location;
+}
 function backgroundEvidenceDirectory(runId, root = configuredServerEvidenceRoot()) {
   return `${serverRunEvidenceDirectory(runId, root)}/background`;
 }
@@ -241,6 +254,7 @@ function activateProbeV2Key(key, force = false) {
     if (state.probeV2NextEpoch >= 4294967295) {
       state.probeV2NextEpoch = 1;
       state.probeV2ContextEpochs.clear();
+      state.probeV2EpochGeneration = (state.probeV2EpochGeneration || 0) + 1;
       for (const file of state.probeV2Files) {
         file.hitEpochs.fill(0);
         file.decisionObservationEpochs.fill(0);
@@ -260,8 +274,38 @@ function activateProbeV2Key(key, force = false) {
   state.probeV2Clock.epoch = epoch;
   return epoch;
 }
+// The async hook activates the current request's context before every
+// callback the server runs, and building its key and looking it up was most of
+// a Next server's time in the hook. A request's context object is never
+// changed once made, and its key is made of it alone, so each keeps the epoch
+// it was given until the epochs are cleared.
+// Every copy of the runtime in a process shares one state, and the hook is the
+// first copy's, so the cache and its generation live on that state too: a
+// reset from another copy has to reach them.
+var emptyProbeV2Context = Object.freeze({});
 function activateProbeV2Context(context) {
-  return activateProbeV2Key(probeV2ContextKey(context));
+  // Work no request owns is keyed by the test running when it runs, which
+  // changes under the same context: only a request's context keeps its epoch.
+  if (!context.scope)
+    return activateProbeV2Key(probeV2ContextKey(context));
+  if (state.probeV2ContextEpochCache === void 0) {
+    state.probeV2ContextEpochCache = /* @__PURE__ */ new WeakMap();
+    state.probeV2EpochGeneration = 0;
+  }
+  const cached = state.probeV2ContextEpochCache.get(context);
+  if (cached !== void 0 && cached.generation === state.probeV2EpochGeneration) {
+    state.probeV2Clock.epoch = cached.epoch;
+    return cached.epoch;
+  }
+  const epoch = activateProbeV2Key(probeV2ContextKey(context));
+  state.probeV2ContextEpochCache.set(context, { generation: state.probeV2EpochGeneration, epoch });
+  return epoch;
+}
+// The context the async hook leaves to a callback's first probe: the
+// request's store, or else the one the environment carries.
+function resolveProbeV2Epoch() {
+  var _a8, _b;
+  return activateProbeV2Context((_b = (_a8 = serverPhaseStorage == null ? void 0 : serverPhaseStorage.getStore()) != null ? _a8 : environmentRequestContext()) != null ? _b : emptyProbeV2Context);
 }
 function withProbeV2Context(context, callback) {
   const previous = state.probeV2Clock.epoch;
@@ -283,10 +327,14 @@ function installProbeV2AsyncHook() {
       return;
     const epochs = [];
     createHook({
+      // NaN, which no epoch equals: the callback's first probe works out
+      // its context. Most callbacks a server or a test runner runs reach no
+      // instrumented code, and working it out here, for every one, read the
+      // environment twice and built a key each time: on a Next app's suite,
+      // more of the server's time than any of Supercov's other work.
       before() {
-        var _a9, _b;
         epochs.push(state.probeV2Clock.epoch);
-        activateProbeV2Context((_b = (_a9 = serverPhaseStorage == null ? void 0 : serverPhaseStorage.getStore()) != null ? _a9 : environmentRequestContext()) != null ? _b : {});
+        state.probeV2Clock.epoch = NaN;
       },
       after() {
         var _a9;
@@ -329,6 +377,7 @@ function resetCoverage(testId2) {
   state.logicals.clear();
   state.eventKeys.clear();
   state.probeV2ContextEpochs.clear();
+  state.probeV2EpochGeneration = (state.probeV2EpochGeneration || 0) + 1;
   activateProbeV2Key(`reset\0${state.probeV2NextEpoch}`, true);
   if (testId2)
     runtimeGlobal.__SUPERCOV_MCDC_TEST_ID__ = testId2;
@@ -341,6 +390,78 @@ function resetCoverage(testId2) {
 }
 runtimeGlobal.__SUPERCOV_MCDC_SNAPSHOT__ = decisionSnapshot;
 runtimeGlobal.__SUPERCOV_COVERAGE_SNAPSHOT__ = coverageSnapshot;
+// A snapshot as the text the Playwright collector reads back. Its events
+// become rows over one table of the strings they repeat -- point ids, phase
+// ids, kinds -- each row in the key order of its event (`shapes`), and its
+// hits indexes into the same table; snapshots.mjs's expandSnapshot gives
+// back what JSON.parse of the whole would have. A large frontend's page
+// holds tens of thousands of events, each naming its point, phase and
+// environment in full, read back at the end of every test and from every
+// page that leaves: relaying them cost the browser's own process more than
+// its renderers spent running the app.
+function compactSnapshotText(snapshot) {
+  if (!snapshot || typeof snapshot !== "object" || !Array.isArray(snapshot.events) || !Array.isArray(snapshot.hits))
+    return JSON.stringify(snapshot);
+  const strings = [];
+  const stringIndexes = /* @__PURE__ */ new Map();
+  const intern = (value) => {
+    let index = stringIndexes.get(value);
+    if (index === void 0) {
+      index = strings.length;
+      strings.push(value);
+      stringIndexes.set(value, index);
+    }
+    return index;
+  };
+  const shapes = [];
+  const shapeIndexes = /* @__PURE__ */ new Map();
+  const rows = [];
+  for (let position = 0; position < snapshot.events.length; position += 1) {
+    const event = snapshot.events[position];
+    if (!event || typeof event !== "object" || Array.isArray(event))
+      return JSON.stringify(snapshot);
+    const fields = [];
+    const values = [];
+    const keys = Object.keys(event);
+    for (let index = 0; index < keys.length; index += 1) {
+      const value = event[keys[index]];
+      // What JSON.stringify leaves out of an object.
+      if (value === void 0 || typeof value === "function" || typeof value === "symbol")
+        continue;
+      if (typeof value === "string") {
+        fields.push(`s${keys[index]}`);
+        values.push(intern(value));
+      } else {
+        fields.push(`v${keys[index]}`);
+        values.push(value);
+      }
+    }
+    const name = fields.join("\0");
+    let shape = shapeIndexes.get(name);
+    if (shape === void 0) {
+      shape = shapes.length;
+      shapes.push(fields);
+      shapeIndexes.set(name, shape);
+    }
+    rows.push(shape);
+    for (let index = 0; index < values.length; index += 1)
+      rows.push(values[index]);
+  }
+  const hits = [];
+  for (let index = 0; index < snapshot.hits.length; index += 1) {
+    if (typeof snapshot.hits[index] !== "string")
+      return JSON.stringify(snapshot);
+    hits.push(intern(snapshot.hits[index]));
+  }
+  const rest = {};
+  const keys = Object.keys(snapshot);
+  for (let index = 0; index < keys.length; index += 1) {
+    if (keys[index] !== "events" && keys[index] !== "hits")
+      rest[keys[index]] = snapshot[keys[index]];
+  }
+  return JSON.stringify({ supercovCompactSnapshot: 1, order: keys, rest, strings, shapes, rows, hits });
+}
+runtimeGlobal.__SUPERCOV_COMPACT_SNAPSHOT__ = compactSnapshotText;
 runtimeGlobal.__SUPERCOV_RESET__ = resetCoverage;
 // A dedicated worker blocked in `Atomics.wait` runs no evaluation, so the
 // test runner could not read its evidence and reported the test as a lower
@@ -417,11 +538,32 @@ function pushWorkerEvidence() {
   runtimeGlobal.__SUPERCOV_WORKER_EVIDENCE__ = () => Array.from(received, ([token, pushed]) => ({ token, url: pushed.url, current: pushed.current, snapshot: pushed.snapshot }));
 })();
 var persistBrowserListenersInstalled = false;
+// How much evidence the document holds. Every part of it only grows until a
+// reset, so the same size twice is the same evidence.
+function evidenceSize() {
+  let size = state.hits.size + state.events.length;
+  for (const decision of state.decisions.values())
+    size += decision.vectors.size;
+  for (const vectors of state.logicals.values())
+    size += vectors.size;
+  return size;
+}
+// The evidence's size when this document gave it to the Playwright collector
+// on the way out. Its next document need not inherit it then: carried through
+// localStorage as well, every page of a test parsed all the evidence of the
+// pages before it on load and wrote it all again on leaving, a test of thirty
+// pages paying for the first one thirty times, and the collector merged the
+// same evidence once per page. What runs after the hand-over -- the rest of a
+// handler that set `location.href`, a render it started -- is still carried.
+var handedOverSize = -1;
 function persistBrowserNow() {
   if (!isBrowser)
     return;
   try {
-    localStorage.setItem(storageKey, JSON.stringify(coverageSnapshot()));
+    if (handedOverSize === evidenceSize())
+      localStorage.removeItem(storageKey);
+    else
+      localStorage.setItem(storageKey, JSON.stringify(coverageSnapshot()));
   } catch (e) {
   }
 }
@@ -433,8 +575,10 @@ function persistBrowserNow() {
 // it does.
 function handOverBrowser() {
   try {
-    if (typeof runtimeGlobal.__supercovLeaving === "function")
-      runtimeGlobal.__supercovLeaving(JSON.stringify(coverageSnapshot()));
+    if (typeof runtimeGlobal.__supercovLeaving === "function") {
+      runtimeGlobal.__supercovLeaving(compactSnapshotText(coverageSnapshot()));
+      handedOverSize = evidenceSize();
+    }
   } catch (e) {
   }
 }
@@ -468,6 +612,19 @@ function persistBrowser() {
 function attemptKey(scope) {
   return `${scope.runId}\0${scope.workerId}\0${scope.attemptId}`;
 }
+// An attempt's file says its scope once per writing process: each line
+// without one is of the scope of the line before it in the same file.
+var scopedPathsWritten = /* @__PURE__ */ new Set();
+function serverLine(record, path) {
+  if (!path)
+    return JSON.stringify(record);
+  const { scope, ...line } = record;
+  if (scope && !scopedPathsWritten.has(path)) {
+    scopedPathsWritten.add(path);
+    line.scope = scope;
+  }
+  return JSON.stringify(line);
+}
 function serverRecordKey(record) {
   var _a8;
   const suffix = record.type === "decision" ? `${record.id}:${vectorKey(record.vector)}` : record.id;
@@ -530,7 +687,7 @@ function flushBufferedServerEvidence(scope) {
     return void 0;
   try {
     makeEvidenceDirectory(fs, buffered.directory);
-    fs.appendFileSync(buffered.path, [...buffered.records.values()].map((record) => JSON.stringify(record)).join("\n") + "\n");
+    fs.appendFileSync(buffered.path, [...buffered.records.values()].map((record) => serverLine(record, buffered.path)).join("\n") + "\n");
     return buffered.path;
   } catch (e) {
     return void 0;
@@ -758,7 +915,8 @@ function flushOnTermination(flush) {
     }
   } catch (e) {
   }
-  for (const signal of ["SIGTERM", "SIGINT", "SIGHUP", "SIGBREAK"]) {
+  const signals = ["SIGTERM", "SIGINT", "SIGHUP", "SIGBREAK"];
+  for (const signal of signals) {
     try {
       process.on(signal, () => {
         drain();
@@ -770,6 +928,24 @@ function flushOnTermination(flush) {
     } catch (e) {
     }
   }
+  // A listener keeps nothing alive, and a signal a process sends itself is
+  // handled on a later turn of its event loop: `process.kill(process.pid,
+  // "SIGTERM")` as a script's last line exited 0, once nothing else held the
+  // loop open, where alone it ended by the signal. A signal to itself that
+  // only this listener would take is drained and left to act at once.
+  try {
+    const kill = process.kill;
+    const numbered = { 1: "SIGHUP", 2: "SIGINT", 15: "SIGTERM", 21: "SIGBREAK" };
+    process.kill = function supercovKill(pid, signal) {
+      const name = signal === void 0 ? "SIGTERM" : typeof signal === "number" ? numbered[signal] : signal;
+      if (Number(pid) === process.pid && signals.indexOf(name) >= 0 && process.listenerCount(name) <= 1) {
+        drain();
+        process.removeAllListeners(name);
+      }
+      return kill.apply(this, arguments);
+    };
+  } catch (e) {
+  }
 }
 // Rust compiled to wasm and measured by the Rust frontend keeps what it ran
 // in the module's memory, behind `__supercov_region_<crate>`. When the run
@@ -1024,8 +1200,9 @@ function appendServer(record) {
   if (!runId)
     return;
   try {
-    const directory = scope ? serverEvidenceDirectory(scope) : void 0;
-    const path = scope ? serverEvidencePath(scope) : void 0;
+    const location = scope ? scopedEvidenceLocation(scope) : void 0;
+    const directory = location == null ? void 0 : location.directory;
+    const path = location == null ? void 0 : location.path;
     // Work done while handling a request that named no test -- a webhook a
     // mock server sends -- says so, with the request's number.
     const stored = serverPhaseStorage == null ? void 0 : serverPhaseStorage.getStore();
@@ -1050,7 +1227,7 @@ function appendServer(record) {
       appendDurableBackgroundRecord(fs, runId, serialized);
       return;
     }
-    enqueueServerAppend(directory, path, JSON.stringify(serialized) + "\n", runId);
+    enqueueServerAppend(directory, path, serverLine(serialized, path) + "\n", runId);
     if (deduplicationKey)
       state.persistedServerRecords.add(deduplicationKey);
   } catch (cause) {
@@ -1639,13 +1816,24 @@ function noteSupport(scope) {
     const moduleBuiltin = typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("node:module") : void 0;
     const cache = moduleBuiltin && moduleBuiltin._cache;
     const root = process.env.SUPERCOV_PROJECT_ROOT;
-    if (cache && root) {
+    // The in-thread module hooks count every load (resolve-loader.mjs): a
+    // cache nothing was loaded into since the last request holds nothing
+    // new. Listing a Next server's thousands of keys on every request was
+    // the most of its time any of Supercov's code took. Without the count
+    // (off-thread hooks), every request looks.
+    const loads = runtimeGlobal.__SUPERCOV_MODULE_LOADS__;
+    const unchanged = typeof loads === "number" && loads === supportNoted.loads;
+    supportNoted.loads = loads;
+    if (cache && root && !unchanged) {
       for (const name of Object.keys(cache)) {
+        // Each is looked at once, whether it is noted or not.
+        if (supportNoted.modules.has(name))
+          continue;
+        supportNoted.modules.add(name);
         // The copy lives under `.supercov/`: the project root decides.
         const inside = name.indexOf(root) === 0 ? name.slice(root.length).replace(/^[\\/]/, "") : "";
-        if (supportNoted.modules.has(name) || inside === "" || /^\.supercov[\\/]/.test(inside) || /(?:^|[\\/])node_modules[\\/]/.test(inside))
+        if (inside === "" || /^\.supercov[\\/]/.test(inside) || /(?:^|[\\/])node_modules[\\/]/.test(inside))
           continue;
-        supportNoted.modules.add(name);
         lines.push({ loaded: name });
       }
     }
@@ -1789,6 +1977,8 @@ function recordCoverageHit(id) {
     activateProbeV2Context(currentRequestContext());
     epoch = clock.epoch;
     clock.epoch = previousEpoch;
+  } else if (epoch !== epoch) {
+    epoch = resolveProbeV2Epoch();
   }
   if (!state.hitEpochs)
     state.hitEpochs = /* @__PURE__ */ new Map();
@@ -1814,24 +2004,31 @@ function recordCoverageHit(id) {
     }, phaseId ? { phaseId } : {}));
   }
 }
+// A file's ids, as the instrumenter writes them: one string of ids separated
+// by spaces, or a list where an id holds one.
+function listedIds(ids) {
+  return typeof ids === "string" ? ids === "" ? [] : ids.split(" ") : ids;
+}
 function registerProbeV2(definition) {
   var _a8, _b;
+  const decisions = listedIds(definition.decisions);
+  const pointIds = listedIds(definition.pointIds);
   const file = {
     // Each decision's id and its number of conditions: the module carries
     // no source text, which the manifest holds.
-    decisions: definition.decisions,
+    decisions,
     decisionWidths: definition.decisionWidths,
-    pointIds: definition.pointIds,
+    pointIds,
     clock: state.probeV2Clock,
-    hitEpochs: new Uint32Array(definition.pointIds.length),
+    hitEpochs: new Uint32Array(pointIds.length),
     decisionEpochs: definition.decisionWidths.map((width) => width <= 6 ? new Uint32Array(2 * 3 ** width) : /* @__PURE__ */ new Map()),
-    decisionVectorCounts: definition.decisions.map((_, index) => {
+    decisionVectorCounts: decisions.map((_, index) => {
       var _a9, _b2;
       return (_b2 = (_a9 = definition.decisionVectorCounts) == null ? void 0 : _a9[index]) != null ? _b2 : 0;
     }),
-    decisionObservationEpochs: new Uint32Array(definition.decisions.length),
-    decisionObservationCounts: new Uint16Array(definition.decisions.length),
-    decisionCompleteEpochs: new Uint32Array(definition.decisions.length),
+    decisionObservationEpochs: new Uint32Array(decisions.length),
+    decisionObservationCounts: new Uint16Array(decisions.length),
+    decisionCompleteEpochs: new Uint32Array(decisions.length),
     pendingDefaults: new Uint32Array(definition.defaultCount || 0),
     // A selection's outcomes -- short falsy, short truthy, right falsy, right
     // truthy -- are four consecutive points per site from the first index.
@@ -1876,6 +2073,8 @@ function recordCoverageHitV2(file, index) {
   const previousEpoch = file.clock.epoch;
   if (fallbackEpoch)
     activateProbeV2Context(currentRequestContext());
+  else if (previousEpoch !== previousEpoch)
+    resolveProbeV2Epoch();
   try {
     const epoch = file.clock.epoch;
     if (file.hitEpochs[index] === epoch)
@@ -1928,6 +2127,8 @@ function recordMcdcEndV2(file, decisionIndex, encoded, value) {
   const previousEpoch = file.clock.epoch;
   if (fallbackEpoch)
     activateProbeV2Context(currentRequestContext());
+  else if (previousEpoch !== previousEpoch)
+    resolveProbeV2Epoch();
   try {
     const epoch = file.clock.epoch;
     const seen = file.decisionEpochs[decisionIndex];