supercov 2.0.1 → 3.0.1

package/runtime/javascript/ava.mjs

@@ -0,0 +1,82 @@
+// Supercov AVA adapter. The preload imports it in each AVA worker -- a
+// worker thread, or a child process under --no-worker-threads -- and it
+// patches AVA's own Runner, so a suite runs exactly as written. AVA runs a
+// file's tests concurrently, so a test's coverage cannot be told apart by
+// time: each test, with its beforeEach and afterEach hooks, runs inside a
+// coverage carrier of its own, as node:test subtests do, and what ran under
+// it is written with the test's outcome once it settles. Loading the test
+// file and before/after hooks run outside any test and count for the run.
+// It computes no coverage.
+import { realpathSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { beginBufferedServerEvidence, flushBufferedServerEvidence, takeNodeAssertionPhases, withCoverageCarrier, } from "./runtime.mjs";
+import { runnerExecutionScope, writeRunnerEvidence } from "./runnerEvidence.mjs";
+
+// The installed ava package the entrypoint belongs to.
+function avaRoot(entrypoint) {
+    let real;
+    try {
+        real = realpathSync(entrypoint).replaceAll("\\", "/");
+    }
+    catch {
+        return undefined;
+    }
+    const at = real.lastIndexOf("/node_modules/ava/");
+    return at < 0 ? undefined : real.slice(0, at + "/node_modules/ava".length);
+}
+
+export async function adaptAva(entrypoint) {
+    const evidenceDirectory = process.env.SUPERCOV_EVIDENCE_DIR;
+    const root = avaRoot(entrypoint);
+    if (!evidenceDirectory || !root)
+        return;
+    let loaded;
+    try {
+        loaded = await import(pathToFileURL(join(root, "lib", "runner.js")).href);
+    }
+    catch {
+        return;
+    }
+    const Runner = loaded.default ?? loaded.Runner;
+    const runTest = Runner?.prototype?.runTest;
+    if (typeof runTest !== "function" || runTest.supercovAva)
+        return;
+    Runner.prototype.runTest = function supercovAvaRunTest(task, contextRef) {
+        // AVA refuses two tests with one title in a file, so the title names
+        // the test.
+        const identity = { runner: "ava", file: this.file, name: task.title };
+        const scope = runnerExecutionScope(identity);
+        beginBufferedServerEvidence(scope);
+        const finish = (status) => writeRunnerEvidence(identity, status, scope, evidenceDirectory, takeNodeAssertionPhases(scope), flushBufferedServerEvidence(scope));
+        let settled;
+        try {
+            settled = Promise.resolve(withCoverageCarrier({ version: 1, scope }, () => Reflect.apply(runTest, this, [task, contextRef])));
+        }
+        catch (error) {
+            finish("failed");
+            throw error;
+        }
+        return settled.then((passed) => {
+            finish(passed ? "passed" : "failed");
+            return passed;
+        }, (error) => {
+            finish("failed");
+            throw error;
+        });
+    };
+    Runner.prototype.runTest.supercovAva = true;
+    // A skipped or todo test never reaches runTest; AVA announces it.
+    const start = Runner.prototype.start;
+    if (typeof start === "function")
+        Runner.prototype.start = function supercovAvaStart(...args) {
+            // AVA's emitter hands a listener { data: state }.
+            this.on("stateChange", ({ data: state } = {}) => {
+                if (state?.type !== "selected-test" || !(state.skip || state.todo))
+                    return;
+                const identity = { runner: "ava", file: this.file, name: state.title };
+                writeRunnerEvidence(identity, "skipped", runnerExecutionScope(identity), evidenceDirectory);
+            });
+            return Reflect.apply(start, this, args);
+        };
+}

package/runtime/javascript/bootstrap.cjs

@@ -0,0 +1,43 @@
+"use strict";
+// Instrumented sources load this before anything else. Under the preload it
+// finds the runtime already installed and does nothing. A process that runs
+// the workspace from somewhere else -- a container or VM the workspace is
+// mounted into, started by an SDK that passed on none of Supercov's settings,
+// or a worker the preload never reached -- has no runtime, and without one the
+// first probe would throw. Such a process installs the runtime itself, with
+// the run's settings read from beside this file and their paths moved to
+// wherever the workspace is seen from here, so its coverage lands in the
+// run's own evidence directory.
+const installed = globalThis.__SUPERCOV_DIRECT_RUNTIME__ ?? process.__SUPERCOV_DIRECT_RUNTIME__;
+if (installed) {
+    globalThis.__SUPERCOV_DIRECT_RUNTIME__ ??= installed;
+}
+else {
+    try {
+        const fs = require("node:fs");
+        const path = require("node:path");
+        // <workspace>/.supercov/node_modules/bootstrap.cjs
+        const root = path.resolve(__dirname, "..", "..");
+        const settings = JSON.parse(fs.readFileSync(path.join(__dirname, "run.json"), "utf8"));
+        const moved = (value) => typeof value === "string" && settings.root !== root
+            ? value.split(settings.root).join(root)
+            : value;
+        // Settings carried over from the host name the host's paths, which do
+        // not exist here; replace them all rather than keep a mixture.
+        const foreign = process.env.SUPERCOV_PROJECT_ROOT !== root;
+        for (const [name, value] of Object.entries(settings.environment)) {
+            if (foreign || process.env[name] === undefined)
+                process.env[name] = moved(value);
+        }
+        process.env.SUPERCOV_PROJECT_ROOT = root;
+        process.env.SUPERCOV_EXECUTION_LOG_SHARD ??= `bootstrap-${process.pid}-${Date.now()}`;
+        require("./runtime.mjs");
+        // Counted in the run's summary: coverage from here belongs to no test.
+        require("./launchSupervisor.mjs").recordExecution({ event: "guest-process", guestRoot: root });
+    }
+    catch {
+        // Without its settings or its runtime nothing can be recorded here,
+        // and the first probe fails as it did before this file existed.
+    }
+}
+module.exports = globalThis.__SUPERCOV_DIRECT_RUNTIME__;

package/runtime/javascript/jest.cjs

@@ -9,9 +9,10 @@
 //
 // CommonJS on purpose: Jest's module system loads setup files without the
 // ESM flag, and the runtime it needs is already on the sandbox global.
-const { createHash } = require("node:crypto");
-const { mkdirSync, renameSync, writeFileSync } = require("node:fs");
+const { createHash, randomUUID } = require("node:crypto");
+const { appendFileSync, closeSync, fsyncSync, mkdirSync, openSync, statSync, writeFileSync } = require("node:fs");
 const { relative, resolve, sep } = require("node:path");
+const { Buffer } = require("node:buffer");
 
 // jest-environment-node exposes the outer process's own globals to the sandbox
 // through getters, so this is the same runtime instance the instrumented
@@ -48,7 +49,11 @@ function currentDeclaration() {
                 const occurrence = names.get(name) ?? 0;
                 names.set(name, occurrence + 1);
                 if (child === state.currentlyRunningTest)
-                    found = {occurrence, retry: Math.max((child.invocations ?? 1) - 1, 0)};
+                    found = {
+                        occurrence,
+                        retry: Math.max((child.invocations ?? 1) - 1, 0),
+                        path: [...parents, child.name],
+                    };
             }
         }
     }
@@ -71,13 +76,43 @@ function provenance(testFile) {
         ? { runner: "jest", kind, source: "path" }
         : { runner: "jest", kind: "unit", source: "runner-default" };
 }
-function writeEvidence(suffix, payload) {
-    const directory = resolve(process.cwd(), evidenceDirectory, suffix);
-    mkdirSync(directory, { recursive: true });
-    const target = resolve(directory, "mcdc.json");
-    const temporary = `${target}.${process.pid}.${Date.now()}.tmp`;
-    writeFileSync(temporary, `${JSON.stringify(payload)}\n`);
-    renameSync(temporary, target);
+// One journal per writer, as atomic.mjs's appendEvidenceRecord keeps it: a
+// file per test cost a directory, a file and a rename each. Jest gives every
+// test file a fresh module registry, so a worker starts one journal per file.
+let journal;
+function writeEvidence(payload) {
+    const line = `${JSON.stringify(payload)}\n`;
+    if (journal) {
+        let size = -1;
+        try {
+            size = statSync(journal.path).size;
+        }
+        catch {
+            // A missing journal is started again below.
+        }
+        if (size !== journal.size)
+            journal = undefined;
+    }
+    if (!journal) {
+        const directory = resolve(process.cwd(), evidenceDirectory);
+        mkdirSync(directory, { recursive: true });
+        const writer = (process.env.SUPERCOV_EXECUTION_LOG_SHARD ?? `pid-${process.pid}`).replace(/[^A-Za-z0-9_-]/g, "_");
+        journal = { path: resolve(directory, `jest-worker-${writer}-${randomUUID()}.mcdc.jsonl`), size: 0 };
+    }
+    if (process.env.SUPERCOV_DURABLE_EVIDENCE_EACH_TEST === "1") {
+        const descriptor = openSync(journal.path, "a", 0o600);
+        try {
+            writeFileSync(descriptor, line);
+            fsyncSync(descriptor);
+        }
+        finally {
+            closeSync(descriptor);
+        }
+    }
+    else {
+        appendFileSync(journal.path, line, { mode: 0o600 });
+    }
+    journal.size += Buffer.byteLength(line);
 }
 
 if (runtime && evidenceDirectory && typeof beforeEach === "function" && typeof afterAll === "function") {
@@ -96,7 +131,7 @@ if (runtime && evidenceDirectory && typeof beforeEach === "function" && typeof a
             emittedSetupFiles.add(testFile);
             const setupSnapshot = runtime.coverageSnapshot();
             if (setupSnapshot.hits.length || setupSnapshot.decisions.length) {
-                writeEvidence(`jest-${digest(testFile)}-setup`, {
+                writeEvidence({
                     testId: `jest:${digest(testFile)}:setup`,
                     test: `${testFile} > module setup`,
                     testFile,
@@ -126,7 +161,9 @@ if (runtime && evidenceDirectory && typeof beforeEach === "function" && typeof a
             retry,
             attemptId: `${testKey}-${retry}`,
         };
-        active = { scope, testFile, fullName, retry };
+        // Named as the reporter names it; the id keeps Jest's full name.
+        const name = declaration?.path?.join(" > ") ?? fullName;
+        active = { scope, testFile, fullName, name, retry };
         runtime.activateCoverageScope(scope);
         runtime.resetCoverage(testId);
     });
@@ -139,12 +176,12 @@ if (runtime && evidenceDirectory && typeof beforeEach === "function" && typeof a
         if (!current)
             return;
         const { scope } = current;
-        writeEvidence(`jest-${scope.attemptId}`, {
+        writeEvidence({
             testId: scope.testId,
             scope,
-            test: current.fullName,
+            test: current.name,
             testFile: current.testFile,
-            title: current.fullName,
+            title: current.name,
             retry: current.retry,
             // The reporter's record carries the outcome.
             status: "unknown",

package/runtime/javascript/jest.config.mjs

@@ -26,8 +26,16 @@ export default async function supercovJestConfig() {
         // configuration is not read and Jest's defaults apply.
         process.emitWarning(`[supercov] the project's Jest configuration was not read (${error?.message ?? error}); Jest's defaults apply`);
     }
+    // Jest's coverage measures the instrumented copy, probes included, and a
+    // suite at 100% read 83.33% of branches: its coverageThreshold failed
+    // passing runs. Jest still collects and reports coverage.
+    const { coverageThreshold, ...own } = config;
+    const collecting = own.collectCoverage === true ||
+        process.argv.some((argument) => /^--(?:coverage|collectCoverage|collect-coverage)(?:=true)?$/.test(argument));
+    if (coverageThreshold && collecting)
+        process.__SUPERCOV_SKIPPED_COVERAGE_THRESHOLDS__?.("Jest");
     return {
-        ...config,
+        ...own,
         // Concurrent tests in one file would share the worker's scope.
         maxConcurrency: 1,
         setupFiles: [here("jestRuntime.cjs"), ...asList(config.setupFiles)],

package/runtime/javascript/jestReporter.mjs

@@ -1,8 +1,7 @@
 import { createHash } from "node:crypto";
-import { mkdirSync } from "node:fs";
 import { relative, resolve, sep } from "node:path";
 import { inferTestProvenance } from "./provenance.mjs";
-import { atomicWriteFileSync } from "./atomic.mjs";
+import { appendEvidenceRecord } from "./atomic.mjs";
 function digest(value) {
     return createHash("sha256").update(value).digest("hex").slice(0, 24);
 }
@@ -57,7 +56,9 @@ export default class SupercovJestReporter {
         const record = (attempt, attemptStatus, flaky) => {
             const payload = {
                 testId,
-                test: result.fullName,
+                // Named by its describe blocks, `small > charges`, as every
+                // JavaScript runner is; the id keeps Jest's own full name.
+                test: [...(result.ancestorTitles ?? []), result.title].join(" > "),
                 testFile,
                 title: result.title,
                 retry: attempt,
@@ -69,9 +70,7 @@ export default class SupercovJestReporter {
                 browser: [],
                 server: [],
             };
-            const directory = resolve(process.cwd(), evidenceDirectory, `jest-${digest(testId)}-${attempt}-status`);
-            mkdirSync(directory, { recursive: true });
-            atomicWriteFileSync(resolve(directory, "mcdc.json"), `${JSON.stringify(payload)}\n`);
+            appendEvidenceRecord(resolve(process.cwd(), evidenceDirectory), "jest-status", payload);
         };
         // `jest.retryTimes` reports one result after the last attempt; every
         // attempt before it failed, or there would have been no retry. The

package/runtime/javascript/launchSupervisor.mjs

@@ -54,6 +54,10 @@ function executionLogPath(path, token = executionLog.token) {
         ? `${path.slice(0, -".jsonl".length)}${suffix}`
         : `${path}${suffix}`;
 }
+/** Append one event to the run's execution log, as the supervisor does. */
+export function recordExecution(value) {
+    record(value);
+}
 function record(value) {
     const configuredPath = process.env["SUPERCOV_EXECUTION_LOG"];
     if (!configuredPath)
@@ -254,15 +258,32 @@ function launchArgv(value) {
         return value.cmd;
     return [String(value.command)];
 }
+// A plain map of environment variables, as `run(argv, { ...process.env })`
+// passes one: string values under variable names, at least one of them in
+// capitals, and nothing an options object would carry. A name is anything
+// without `=`: Windows' own environment has `ProgramFiles(x86)`, and a map
+// copied from it was taken for options and its guest left unconfigured.
+function environmentMap(value) {
+    const entries = Object.entries(value);
+    return (entries.length > 0 &&
+        entries.every(([name, item]) => typeof item === "string" && /^[^=\0]+$/.test(name)) &&
+        entries.some(([name]) => /^[A-Z_][A-Z0-9_]*$/.test(name)) &&
+        !launchOptions(value));
+}
 function injectRemoteLaunch(options, mapping) {
-    const environmentKey = "environment" in options && !("env" in options) ? "environment" : "env";
+    const coverage = {
+        ...process.env,
+        SUPERCOV_EXECUTION_LOG_SHARD: `${process.pid}-${++remoteLaunchSequence}`,
+    };
+    if (environmentMap(options))
+        return guestCoverageEnvironment(mapping, coverage, options);
+    // The SDK's own name for a command's environment: `env`, `environment`
+    // or, as E2B spells it, `envs`. A new one is called `env`.
+    const environmentKey = ["env", "environment", "envs"].find((key) => key in options) ?? "env";
     const existing = options[environmentKey];
     return {
         ...options,
-        [environmentKey]: guestCoverageEnvironment(mapping, {
-            ...process.env,
-            SUPERCOV_EXECUTION_LOG_SHARD: `${process.pid}-${++remoteLaunchSequence}`,
-        }, existing && typeof existing === "object"
+        [environmentKey]: guestCoverageEnvironment(mapping, coverage, existing && typeof existing === "object"
             ? existing
             : {}),
     };
@@ -418,6 +439,21 @@ export function wrapCapabilityObject(value, mapping) {
                         guestRoot: mapping.guestRoot,
                     });
                 }
+                else if (typeof property === "string" &&
+                    /env/i.test(property) &&
+                    args.length === 1 &&
+                    args[0] &&
+                    typeof args[0] === "object" &&
+                    environmentMap(args[0])) {
+                    // A builder that takes the command's environment by itself
+                    // (`withEnvironment(env)`) before it starts the command.
+                    callArguments = [injectRemoteLaunch(args[0], mapping)];
+                    record({
+                        event: "remote-launch",
+                        command: commandSummary([property]),
+                        guestRoot: mapping.guestRoot,
+                    });
+                }
                 return wrapResult(Reflect.apply(member, target, callArguments), mapping);
             };
         },
@@ -435,6 +471,7 @@ export function wrapImportedCapability(value) {
         return value;
     if (isClassConstructor(value)) {
         patchBuilder(value);
+        patchMountMethods(value);
         return value;
     }
     const object = value;
@@ -489,6 +526,49 @@ export function wrapImportedCapability(value) {
     importedCapabilityProxies.set(object, proxy);
     return proxy;
 }
+const patchedMountMethods = new WeakSet();
+/**
+ * A builder made with `new` (`new GenericContainer(image)`) takes its mounts
+ * on an instance method, `withBindMounts([{ source, target }])`. The class
+ * itself must stay the exact value it is -- registries compare constructors
+ * -- so its mount methods are patched in place instead: called with a mount
+ * of the workspace, the builder they return is followed, and its later calls
+ * (`withEnvironment`, `start`) see the mapping. Called without one, they do
+ * what they always did.
+ */
+function patchMountMethods(builder) {
+    for (let prototype = builder.prototype; prototype && prototype !== Object.prototype; prototype = Object.getPrototypeOf(prototype)) {
+        for (const name of Object.getOwnPropertyNames(prototype)) {
+            if (!/mount/i.test(name))
+                continue;
+            const descriptor = Object.getOwnPropertyDescriptor(prototype, name);
+            if (!descriptor ||
+                typeof descriptor.value !== "function" ||
+                !descriptor.writable ||
+                patchedMountMethods.has(descriptor.value))
+                continue;
+            const original = descriptor.value;
+            const patched = function supercovMountMethod(...args) {
+                const hostRoot = process.env["SUPERCOV_PROJECT_ROOT"];
+                const mapping = hostRoot
+                    ? args.map((argument) => discoverWorkspaceMapping(argument, hostRoot)).find(Boolean)
+                    : undefined;
+                const result = Reflect.apply(original, this, args);
+                if (!mapping)
+                    return result;
+                record({
+                    event: "workspace-capability",
+                    hostRoot: mapping.hostRoot,
+                    guestRoot: mapping.guestRoot,
+                    cacheIdentities: [],
+                });
+                return wrapResult(result, mapping);
+            };
+            patchedMountMethods.add(patched);
+            Object.defineProperty(prototype, name, { ...descriptor, value: patched });
+        }
+    }
+}
 function patchBuilder(builder) {
     if (patchedBuilders.has(builder))
         return;
@@ -545,20 +625,52 @@ function inspectExports(value, depth = 0) {
         }
     }
 }
+// spawn, fork and execFile take (file, args?, options?, callback?): options
+// follow an argument list, or an explicit null or undefined in its place. exec
+// takes (command, options?, callback?), and calls execFile as (file, options,
+// callback) itself -- that object is the options, not an argument list.
 function childOptionsIndex(method, args) {
-    if (method === "spawn" || method === "spawnSync" || method === "fork")
-        return Array.isArray(args[1]) || (args.length > 2 && args[2] !== undefined)
-            ? 2
-            : 1;
-    if (method === "exec" ||
-        method === "execSync" ||
+    if (method === "spawn" ||
+        method === "spawnSync" ||
+        method === "fork" ||
         method === "execFile" ||
         method === "execFileSync")
-        return Array.isArray(args[1]) || (args.length > 2 && args[2] !== undefined)
-            ? 2
-            : 1;
+        return Array.isArray(args[1]) || (args[1] == null && args.length > 2) ? 2 : 1;
+    if (method === "exec" || method === "execSync")
+        return 1;
     return undefined;
 }
+// util.promisify(exec) and util.promisify(execFile) resolve { stdout, stderr }
+// through a function Node keeps on the original, and that function calls the
+// original. A wrapper carries its own, which calls the wrapper, or a promisified
+// call resolves the bare stdout string and skips the wrapper.
+const promisifyCustom = Symbol.for("nodejs.util.promisify.custom");
+function keepPromisifiedShape(original, wrapper) {
+    if (typeof original[promisifyCustom] !== "function")
+        return wrapper;
+    Object.defineProperty(wrapper, promisifyCustom, {
+        configurable: true,
+        value: (...args) => {
+            let settle;
+            let reject;
+            const promise = new Promise((ok, fail) => {
+                settle = ok;
+                reject = fail;
+            });
+            promise.child = wrapper(...args, (error, stdout, stderr) => {
+                if (error !== null) {
+                    error.stdout = stdout;
+                    error.stderr = stderr;
+                    reject(error);
+                }
+                else
+                    settle({ stdout, stderr });
+            });
+            return promise;
+        },
+    });
+    return wrapper;
+}
 function injectChildEnvironment(method, args) {
     const index = childOptionsIndex(method, args);
     if (index === undefined)
@@ -617,7 +729,7 @@ function patchChildProcesses() {
             configurable: true,
             enumerable: true,
             writable: true,
-            value: (...args) => Reflect.apply(original, childProcess, injectChildEnvironment(method, args)),
+            value: keepPromisifiedShape(original, (...args) => Reflect.apply(original, childProcess, injectChildEnvironment(method, args))),
         });
     }
     syncBuiltinESMExports();

package/runtime/javascript/mocha.mjs

@@ -0,0 +1,180 @@
+// Supercov Mocha adapter. The preload imports it in every Mocha process --
+// the CLI, the child the CLI forks for Node options, and each --parallel
+// worker -- and it patches Mocha's own Runner, so a suite runs exactly as
+// written: no reporter, --require or configuration is added. Each test
+// attempt gets its exact scope when Mocha announces it, before its
+// beforeEach hooks, and its coverage, assertion phases and outcome are
+// written after its afterEach hooks. Code that runs outside any test --
+// loading the test files, before/after all hooks -- is written as setup. It
+// computes no coverage.
+import { realpathSync } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+import { appendEvidenceRecord } from "./atomic.mjs";
+import { inferTestProvenance } from "./provenance.mjs";
+import { runnerExecutionScope } from "./runnerEvidence.mjs";
+
+const SETUP_HOOK = /^"(?:before|after) all" hook/;
+
+function localFile(path) {
+    return path ? relative(process.cwd(), path).split(sep).join("/") : undefined;
+}
+
+// The installed mocha package the entrypoint belongs to.
+function mochaRoot(entrypoint) {
+    let real;
+    try {
+        real = realpathSync(entrypoint).replaceAll("\\", "/");
+    }
+    catch {
+        return undefined;
+    }
+    const at = real.lastIndexOf("/node_modules/mocha/");
+    return at < 0 ? undefined : real.slice(0, at + "/node_modules/mocha".length);
+}
+
+export async function adaptMocha(entrypoint) {
+    const runtime = globalThis.__SUPERCOV_DIRECT_RUNTIME__ ?? process.__SUPERCOV_DIRECT_RUNTIME__;
+    const evidenceDirectory = process.env.SUPERCOV_EVIDENCE_DIR;
+    const root = mochaRoot(entrypoint);
+    if (!runtime || !evidenceDirectory || !root)
+        return;
+    // Mocha 12 is ESM and exports { Runner }; 10 and 11 are CommonJS and
+    // export the class itself. Either way this is the instance Mocha uses.
+    let loaded;
+    try {
+        loaded = await import(pathToFileURL(join(root, "lib", "runner.js")).href);
+    }
+    catch {
+        return;
+    }
+    const Runner = loaded.Runner ?? loaded.default?.Runner ?? loaded.default;
+    const run = Runner?.prototype?.run;
+    if (typeof run !== "function" || run.supercovMocha)
+        return;
+    // One snapshot per test, as under Jest; the server transport would only
+    // repeat it, unattributed.
+    runtime.enableRuntimeSnapshotEvidence();
+    const directory = resolve(process.cwd(), evidenceDirectory);
+    const write = (payload) => appendEvidenceRecord(directory, "mocha", payload);
+    // A --parallel parent overrides run() and never reaches this: its workers
+    // run the tests, each with a Runner of its own.
+    Runner.prototype.run = function supercovMochaRun(...args) {
+        observe(this, runtime, write);
+        return Reflect.apply(run, this, args);
+    };
+    Runner.prototype.run.supercovMocha = true;
+}
+
+function observe(runner, runtime, write) {
+    // Tests that share a file and a full title are told apart by the order in
+    // which their first attempts ran; a retry keeps its test's identity.
+    const firstAttempts = new Map();
+    const identities = new WeakMap();
+    let active;
+    let setups = 0;
+    function identity(test) {
+        const known = identities.get(test);
+        if (known)
+            return known;
+        const file = test.file;
+        const name = test.titlePath().join(" > ");
+        const key = `${file ?? ""}\0${name}`;
+        let occurrence = firstAttempts.get(key) ?? 0;
+        if (test.currentRetry() > 0)
+            occurrence = Math.max(occurrence - 1, 0);
+        else
+            firstAttempts.set(key, occurrence + 1);
+        const value = {
+            runner: "mocha",
+            file,
+            name,
+            ...(occurrence ? { registrationOrdinal: occurrence } : {}),
+            retry: test.currentRetry(),
+        };
+        identities.set(test, value);
+        return value;
+    }
+    function record(id, status, scope, snapshot) {
+        const testFile = localFile(id.file);
+        write({
+            testId: scope ? scope.testId : runnerExecutionScope(id).testId,
+            ...(scope ? { scope } : {}),
+            test: id.name,
+            ...(testFile ? { testFile } : {}),
+            title: id.name.split(" > ").at(-1) ?? id.name,
+            retry: id.retry ?? 0,
+            status,
+            ...(id.role ? { role: id.role } : {}),
+            provenance: inferTestProvenance({
+                runner: "mocha",
+                file: testFile,
+                explicitKind: process.env.SUPERCOV_TEST_KIND,
+            }),
+            ...(scope ? { phases: runtime.takeNodeAssertionPhases(scope) } : {}),
+            runtime: snapshot ? [snapshot] : [],
+            browser: [],
+            server: [],
+        });
+    }
+    // What ran since the last test or setup ended, outside any test.
+    function flushSetup(name) {
+        const snapshot = runtime.coverageSnapshot();
+        runtime.resetCoverage();
+        if (!snapshot.hits.length && !snapshot.decisions.length)
+            return;
+        setups += 1;
+        const id = { runner: "mocha", name, role: "setup", registrationOrdinal: setups };
+        record(id, "passed", runnerExecutionScope(id), snapshot);
+    }
+    function flushActive() {
+        const current = active;
+        active = undefined;
+        if (!current)
+            return;
+        record(current.id, current.status, current.scope, runtime.coverageSnapshot());
+        runtime.resetCoverage();
+        runtime.activateCoverageScope();
+    }
+    runner.on("start", () => flushSetup("module setup"));
+    runner.on("test", (test) => {
+        flushActive();
+        flushSetup(`${test.parent?.fullTitle() || "root suite"} > hooks`);
+        const id = identity(test);
+        const scope = runnerExecutionScope(id);
+        active = { test, id, scope, status: "unknown" };
+        runtime.activateCoverageScope(scope);
+        runtime.resetCoverage(scope.testId);
+    });
+    runner.on("pass", (test) => {
+        if (active?.test === test)
+            active.status = "passed";
+    });
+    // A failed attempt Mocha will run again, and a failing beforeEach or
+    // afterEach hook, fail the attempt that is running.
+    runner.on("retry", (test) => {
+        if (active?.test === test)
+            active.status = "failed";
+    });
+    runner.on("fail", (runnable) => {
+        if (active && (active.test === runnable || runnable.type === "hook"))
+            active.status = "failed";
+        else if (runnable.type === "test")
+            record(identity(runnable), "failed");
+    });
+    runner.on("pending", (test) => {
+        if (active?.test === test)
+            active.status = "skipped";
+        else
+            record(identity(test), "skipped");
+    });
+    runner.on("hook", (hook) => {
+        if (SETUP_HOOK.test(hook.title ?? ""))
+            flushActive();
+    });
+    runner.on("suite end", flushActive);
+    runner.on("end", () => {
+        flushActive();
+        flushSetup("hooks");
+    });
+}