supercov 0.0.42 → 0.0.44

package/docs/verification.md

@@ -16,7 +16,7 @@ Before merging, check three things:
 3. **The test protects behavior.** It should make a meaningful assertion without
    weakening existing assertions or changing application code for the metric.
 
-```sh
+```sh supercov
 npx supercov diff <baseline-run> <new-run>
 npx supercov runs <new-run> test "new test name"
 ```
@@ -34,7 +34,7 @@ Supercov separates four states:
 - **stale** — the run is valid history but no longer describes the current
   workspace.
 
-```sh
+```sh supercov
 npx supercov runs latest
 npx supercov runs latest scope
 npx supercov runs latest gaps
@@ -78,6 +78,18 @@ self-consistent calculation error does not pass unnoticed. Python and Ruby
 gates run real suites through their supported runners and assert the resulting
 coverage totals, test identity, and measurement limits.
 
+Rust numbers are also checked against an independent LLVM line-coverage
+oracle over real crates. `npm run oracle:rust` runs the same tests plain, under
+the oracle, and under Supercov on twenty-six crates from bytes to tokio,
+compares line coverage file by file, and fails if Supercov ran any suite
+differently from plain Cargo. The two tools count differently — the oracle
+counts every executable region after monomorphisation, Supercov the lines its
+own obligations sit on — so the per-file comparison is read by a person: a file
+at 0% in one and 70% in the other means lost evidence or a wrong denominator,
+and this check found five such defects before 0.0.42. It runs locally and
+costs no hosted minutes; `scripts/rust-coverage-oracle.mjs` documents what
+each flag means.
+
 These checks reduce risk; they do not replace reviewing the assertions and
 behavior protected by a new test.
 

package/docs/workspace-isolation.md

@@ -74,7 +74,7 @@ staging state. Completed runs remain immutable.
 
 Preview cleanup before removing anything:
 
-```sh
+```sh supercov
 npx supercov clean --dry-run
 npx supercov clean --keep 20
 npx supercov clean

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "supercov",
-  "version": "0.0.42",
-  "description": "Zero-edit, runner-aware coverage completeness for JavaScript, TypeScript, Rust, Python, and Ruby test suites",
+  "version": "0.0.44",
+  "description": "Coverage for coding agents and software factories 🌙",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -16,6 +16,21 @@
     "bin",
     "runtime/javascript",
     "docs",
+    "analyzers/typescript/bin",
+    "analyzers/typescript/dist/analyze.js",
+    "analyzers/typescript/dist/mock-counts.js",
+    "analyzers/typescript/dist/archive.js",
+    "analyzers/typescript/dist/awaited-observations.js",
+    "analyzers/typescript/dist/compiler.js",
+    "analyzers/typescript/dist/frontend.js",
+    "analyzers/typescript/dist/native-frontend.js",
+    "analyzers/typescript/dist/pragmas.js",
+    "analyzers/typescript/dist/types.js",
+    "analyzers/typescript/dist/build-identity.json",
+    "analyzers/typescript/src",
+    "analyzers/typescript/package.json",
+    "analyzers/typescript/tsconfig.json",
+    "analyzers/typescript/README.md",
     "README.md"
   ],
   "engines": {
@@ -34,6 +49,7 @@
   },
   "scripts": {
     "build": "cargo build -p supercov",
+    "build:asserted-typescript": "npm --prefix analyzers/typescript run build",
     "sync:rust-assets": "node scripts/sync-rust-package-assets.mjs",
     "test:rust-assets": "node scripts/sync-rust-package-assets.mjs --check",
     "check:rustc-backend-spike": "(cd spikes/rustc-backend && RUSTC_BOOTSTRAP=1 RUSTUP_TOOLCHAIN=1.95.0 cargo fmt --check && RUSTC_BOOTSTRAP=1 RUSTUP_TOOLCHAIN=1.95.0 cargo clippy --all-targets -- -D warnings)",
@@ -41,16 +57,19 @@
     "test:rust-compiler-spikes": "cargo build -p supercov && node scripts/rust-libtest-companion-spike.mjs && node scripts/rust-async-attribution-spike.mjs && node scripts/rust-subprocess-attribution-spike.mjs && node scripts/rust-custom-harness-spike.mjs && node scripts/rust-libtest-builder-lifecycle-spike.mjs",
     "test": "cargo test --workspace",
     "test:runtime": "node --test tests/runtime/*.test.mjs",
+    "test:asserted-typescript": "npm --prefix analyzers/typescript test",
+    "test:asserted-integration": "cargo build -p supercov && npm --prefix analyzers/typescript run build && SUPERCOV_ASSERTED_INTEGRATION=1 node --test analyzers/typescript/tests/archive.integration.test.mjs",
+    "test:asserted-package": "cargo build -p supercov && npm run build:asserted-typescript && node scripts/asserted-packed-integration.mjs",
     "test:fixture": "cargo build -p supercov && node scripts/rust-fixture-matrix.mjs",
-    "test:packed-npx": "cargo build --release -p supercov && node scripts/packed-npx-integration.mjs",
+    "test:packed-npx": "cargo build --release -p supercov && npm run build:asserted-typescript && node scripts/packed-npx-integration.mjs",
     "test:isolation": "cargo build -p supercov && node scripts/isolation-integration.mjs",
     "test:filesystem": "cargo test --workspace && cargo build -p supercov && node scripts/workspace-crash-integration.mjs",
     "test:watchdog": "cargo build -p supercov && node scripts/watchdog-integration.mjs",
     "test:engine-contract": "cargo build -p supercov && node scripts/engine-contract.mjs",
     "test:agent": "cargo build -p supercov && node scripts/agent-query-eval.mjs",
-    "test:engine": "cargo fmt --all -- --check && cargo clippy --workspace --all-targets -- -D warnings && cargo test --workspace && cargo build -p supercov && npm run test:runtime && npm run test:rust-assets && node scripts/rust-process-supervision.mjs && node scripts/rust-direct-node-integration.mjs && node scripts/rust-public-run-integration.mjs && node scripts/rust-embedded-runtime-integration.mjs && node scripts/rust-direct-vitest-integration.mjs && node scripts/rust-direct-playwright-integration.mjs && node scripts/rust-custom-browser-playwright-integration.mjs && node scripts/rust-generic-esbuild-integration.mjs && node scripts/rust-generic-tsc-integration.mjs && node scripts/rust-generic-build-matrix.mjs && node scripts/rust-vite-playwright-integration.mjs",
+    "test:engine": "cargo fmt --all -- --check && cargo clippy --workspace --all-targets -- -D warnings && cargo test --workspace && cargo build -p supercov && npm run test:runtime && npm run test:rust-assets && node scripts/rust-process-supervision.mjs && node scripts/rust-direct-node-integration.mjs && node scripts/rust-public-run-integration.mjs && node scripts/rust-embedded-runtime-integration.mjs && node scripts/rust-direct-vitest-integration.mjs && node scripts/rust-direct-jest-integration.mjs && node scripts/rust-direct-playwright-integration.mjs && node scripts/rust-custom-browser-playwright-integration.mjs && node scripts/rust-generic-esbuild-integration.mjs && node scripts/rust-generic-tsc-integration.mjs && node scripts/rust-generic-build-matrix.mjs && node scripts/rust-vite-playwright-integration.mjs",
     "test:platform": "cargo test --workspace && cargo build -p supercov && node scripts/rust-process-supervision.mjs && node scripts/workspace-crash-integration.mjs",
-    "test:native-package": "cargo build --release -p supercov && node scripts/native-package-integration.mjs && node scripts/native-release-set-integration.mjs",
+    "test:native-package": "cargo build --release -p supercov && npm run build:asserted-typescript && node scripts/native-package-integration.mjs && node scripts/native-release-set-integration.mjs",
     "test:pypi-wheel": "node scripts/pypi-wheel-integration.mjs",
     "test:pypi-registry": "node scripts/pypi-registry-integration.mjs",
     "build:rubygem": "cargo build --release -p supercov && node scripts/build-rubygem.mjs",
@@ -61,11 +80,12 @@
     "test:test262": "cargo build --release -p supercov && node scripts/test262-equivalence.mjs",
     "benchmark:check": "cargo build --release -p supercov && node scripts/rust-transform-benchmark.mjs",
     "benchmark:python-monitoring": "cargo build -p supercov && node scripts/python-monitoring-benchmark.mjs",
-    "check": "cargo fmt --all -- --check && cargo clippy --workspace --all-targets -- -D warnings && npm run test && npm run test:runtime && npm run test:rust-assets && node scripts/package-preflight.mjs && node scripts/verify-binstall-metadata.mjs --offline",
+    "check": "cargo fmt --all -- --check && cargo clippy --workspace --all-targets -- -D warnings && npm run test && npm run test:runtime && npm run test:rust-assets && npm run test:asserted-typescript && npm run test:asserted-integration && npm run test:asserted-package && node scripts/package-preflight.mjs && node scripts/verify-binstall-metadata.mjs --offline",
     "release:check": "cargo clean && node scripts/sweep-target.mjs && npm run check && npm run test:engine && npm run test:fixture && npm run test:watchdog && npm run test:engine-contract && npm run test:agent && npm run test:child-attribution && npm run test:host-loader && npm run test:python-monitoring && npm run test:ruby-coverage && npm run test:rust-public-cargo && npm run test:packed-npx && npm run test:clang-mcdc && npm run benchmark:check",
     "release:bump": "node scripts/bump-version.mjs",
     "sweep": "node scripts/sweep-target.mjs",
-    "prepack": "node scripts/package-preflight.mjs",
+    "oracle:rust": "cargo build --release -p supercov && node scripts/rust-coverage-oracle.mjs",
+    "prepack": "npm run build:asserted-typescript && node scripts/package-preflight.mjs",
     "prepublishOnly": "npm run release:check",
     "test:child-attribution": "cargo build -p supercov && node scripts/rust-child-attribution-integration.mjs",
     "test:host-loader": "cargo build -p supercov && node scripts/rust-host-loader-integration.mjs",
@@ -74,14 +94,14 @@
     "test:rust-public-cargo": "cargo build -p supercov && node scripts/rust-public-cargo-integration.mjs"
   },
   "optionalDependencies": {
-    "@supercov/cli-darwin-arm64": "0.0.42",
-    "@supercov/cli-darwin-x64": "0.0.42",
-    "@supercov/cli-linux-arm64-gnu": "0.0.42",
-    "@supercov/cli-linux-arm64-musl": "0.0.42",
-    "@supercov/cli-linux-x64-gnu": "0.0.42",
-    "@supercov/cli-linux-x64-musl": "0.0.42",
-    "@supercov/cli-win32-arm64": "0.0.42",
-    "@supercov/cli-win32-x64": "0.0.42"
+    "@supercov/cli-darwin-arm64": "0.0.44",
+    "@supercov/cli-darwin-x64": "0.0.44",
+    "@supercov/cli-linux-arm64-gnu": "0.0.44",
+    "@supercov/cli-linux-arm64-musl": "0.0.44",
+    "@supercov/cli-linux-x64-gnu": "0.0.44",
+    "@supercov/cli-linux-x64-musl": "0.0.44",
+    "@supercov/cli-win32-arm64": "0.0.44",
+    "@supercov/cli-win32-x64": "0.0.44"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.55.0",

package/runtime/javascript/jest.cjs

@@ -0,0 +1,134 @@
+"use strict";
+// Supercov Jest adapter. Jest loads it through `setupFilesAfterEnv` of the
+// configuration the preload substitutes (jest.config.mjs), so it runs inside
+// every test file's environment with Jest's globals in scope. It assigns each
+// test attempt its exact scope before the test runs and writes the attempt's
+// coverage and assertion phases after it. Jest tells the environment nothing
+// about an outcome, so the reporter (jestReporter.mjs) records that; the two
+// records share a test id and the report joins them. It computes no coverage.
+//
+// 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 { relative, resolve, sep } = require("node:path");
+
+// jest-environment-node exposes the outer process's own globals to the sandbox
+// through getters, so this is the same runtime instance the instrumented
+// sources under test call into.
+const runtime =
+    globalThis.__SUPERCOV_DIRECT_RUNTIME__ ??
+    (typeof process !== "undefined" ? process.__SUPERCOV_DIRECT_RUNTIME__ : undefined);
+const evidenceDirectory = process.env.SUPERCOV_EVIDENCE_DIR;
+
+function digest(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, 24);
+}
+function localFile(path) {
+    return relative(process.cwd(), path).split(sep).join("/");
+}
+// Must match jestReporter.mjs: the reporter has the same file and full name.
+function testIdentity(testFile, fullName) {
+    return `jest:${digest(`${testFile}\0${fullName}`)}`;
+}
+// Mirrors provenance.mjs, which is ESM and out of reach here.
+const KINDS = [
+    ["unit", /(^|[/_.-])unit([/_.-]|$)/i],
+    ["component", /(^|[/_.-])(component|components|ct)([/_.-]|$)/i],
+    ["integration", /(^|[/_.-])(integration|int)([/_.-]|$)/i],
+    ["e2e", /(^|[/_.-])(e2e|end-to-end|offline|online)([/_.-]|$)/i],
+];
+function provenance(testFile) {
+    const explicit = process.env.SUPERCOV_TEST_KIND?.trim();
+    if (explicit)
+        return { runner: "jest", kind: explicit.toLowerCase(), source: "explicit" };
+    const kind = KINDS.find(([, pattern]) => pattern.test(testFile))?.[0];
+    return kind
+        ? { 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);
+}
+
+if (runtime && evidenceDirectory && typeof beforeEach === "function" && typeof afterEach === "function") {
+    // One in-memory snapshot per test; the server JSONL transport would be
+    // redundant and unattributed, as under Vitest.
+    runtime.enableRuntimeSnapshotEvidence();
+    const attempts = new Map();
+    const emittedSetupFiles = new Set();
+    let active;
+    beforeEach(() => {
+        const state = expect.getState();
+        const testFile = localFile(state.testPath ?? "unknown");
+        if (!emittedSetupFiles.has(testFile)) {
+            // Code the test file ran while loading, before its first test.
+            emittedSetupFiles.add(testFile);
+            const setupSnapshot = runtime.coverageSnapshot();
+            if (setupSnapshot.hits.length || setupSnapshot.decisions.length) {
+                writeEvidence(`jest-${digest(testFile)}-setup`, {
+                    testId: `jest:${digest(testFile)}:setup`,
+                    test: `${testFile} > module setup`,
+                    testFile,
+                    title: "module setup",
+                    retry: 0,
+                    status: "passed",
+                    provenance: provenance(testFile),
+                    role: "setup",
+                    runtime: [setupSnapshot],
+                    browser: [],
+                    server: [],
+                });
+            }
+        }
+        const fullName = state.currentTestName ?? "test";
+        const testId = testIdentity(testFile, fullName);
+        const retry = attempts.get(testId) ?? 0;
+        attempts.set(testId, retry + 1);
+        const testKey = digest(testId);
+        const scope = {
+            version: 1,
+            runId: process.env.SUPERCOV_RUN_ID ?? "unscoped",
+            workerId: `jest-${process.env.JEST_WORKER_ID ?? process.pid}`,
+            testId,
+            testKey,
+            retry,
+            attemptId: `${testKey}-${retry}`,
+        };
+        active = { scope, testFile, fullName, retry };
+        runtime.activateCoverageScope(scope);
+        runtime.resetCoverage(testId);
+    });
+    afterEach(() => {
+        const current = active;
+        active = undefined;
+        if (!current)
+            return;
+        const { scope } = current;
+        writeEvidence(`jest-${scope.attemptId}`, {
+            testId: scope.testId,
+            scope,
+            test: current.fullName,
+            testFile: current.testFile,
+            title: current.fullName,
+            retry: current.retry,
+            // The reporter's record carries the outcome.
+            status: "unknown",
+            provenance: provenance(current.testFile),
+            phases: runtime.takeNodeAssertionPhases(scope),
+            runtime: [runtime.coverageSnapshot()],
+            browser: [],
+            server: [],
+        });
+        // One runtime state serves every test file a worker runs, so what this
+        // test recorded must not leak into the next file's module-setup
+        // snapshot (Vitest isolates files; Jest does not).
+        runtime.resetCoverage();
+        runtime.activateCoverageScope();
+    });
+}

package/runtime/javascript/jest.config.mjs

@@ -0,0 +1,39 @@
+// Supercov's Jest configuration, handed to Jest through `--config` by the
+// preload (register.mjs) in place of the user's. It reads the user's own
+// configuration the way Jest reads it -- a jest.config.* file in any format
+// Jest accepts, or the "jest" key of package.json -- and adds the adapter
+// (jest.cjs) and the reporter (jestReporter.mjs). Nothing of the user's is
+// replaced: their setup files and reporters keep running.
+import { createRequire } from "node:module";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = (name) => fileURLToPath(new URL(`./${name}`, import.meta.url));
+const asList = (value) => (value === undefined ? [] : Array.isArray(value) ? value : [value]);
+
+export default async function supercovJestConfig() {
+    let config = { rootDir: process.cwd() };
+    try {
+        // The project's own jest-config, so version and resolution match Jest's.
+        const projectRequire = createRequire(resolve(process.cwd(), "package.json"));
+        const { readInitialOptions } = projectRequire("jest-config");
+        const original = process.env["SUPERCOV_ORIGINAL_JEST_CONFIG"] || undefined;
+        const read = await readInitialOptions(original, { skipMultipleConfigError: true });
+        config = read.config ?? config;
+        config.rootDir ??= read.configPath ? dirname(read.configPath) : process.cwd();
+    } catch (error) {
+        // jest-config before 29.3 has no readInitialOptions; the project's
+        // 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`);
+    }
+    return {
+        ...config,
+        // Concurrent tests in one file would share the worker's scope.
+        maxConcurrency: 1,
+        setupFilesAfterEnv: [...asList(config.setupFilesAfterEnv), here("jest.cjs")],
+        reporters: [
+            ...(config.reporters === undefined ? ["default"] : asList(config.reporters)),
+            here("jestReporter.mjs"),
+        ],
+    };
+}

package/runtime/javascript/jestReporter.mjs

@@ -0,0 +1,77 @@
+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";
+function digest(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, 24);
+}
+function localFile(path) {
+    return relative(process.cwd(), path).split(sep).join("/");
+}
+function attemptStatus(status) {
+    switch (status) {
+        case "passed":
+        case "failed":
+            return status;
+        case "pending":
+        case "skipped":
+        case "todo":
+        case "disabled":
+            return "skipped";
+        default:
+            return "unknown";
+    }
+}
+/**
+ * Records each Jest attempt's outcome, which the test environment never
+ * learns: a test that times out, one skipped before its hooks, one that
+ * failed after its last hook. The test id formula must match jest.cjs, whose
+ * record carries the attempt's coverage; the report joins the two.
+ */
+export default class SupercovJestReporter {
+    onTestCaseResult(test, result) {
+        const evidenceDirectory = process.env["SUPERCOV_EVIDENCE_DIR"];
+        if (!evidenceDirectory)
+            return;
+        const testFile = localFile(test.path);
+        const testId = `jest:${digest(`${testFile}\0${result.fullName}`)}`;
+        const retry = Math.max((result.invocations ?? 1) - 1, 0);
+        const status = attemptStatus(result.status);
+        const provenance = inferTestProvenance({
+            runner: "jest",
+            file: testFile,
+            explicitKind: process.env["SUPERCOV_TEST_KIND"],
+        });
+        const record = (attempt, attemptStatus, flaky) => {
+            const payload = {
+                testId,
+                test: result.fullName,
+                testFile,
+                title: result.title,
+                retry: attempt,
+                status: attemptStatus,
+                expectedStatus: "passed",
+                flaky,
+                provenance,
+                runtime: [],
+                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`);
+        };
+        // `jest.retryTimes` reports one result after the last attempt; every
+        // attempt before it failed, or there would have been no retry. The
+        // adapter wrote each attempt's coverage without an outcome.
+        for (let attempt = 0; attempt < retry; attempt += 1)
+            record(attempt, "failed", false);
+        record(retry, status, retry > 0 && status === "passed");
+    }
+    // Jest calls these on every reporter.
+    onRunComplete() { }
+    getLastError() {
+        return undefined;
+    }
+}

package/runtime/javascript/nodeAssertAdapter.mjs

@@ -1,4 +1,6 @@
 import { withNodeAssertionPhase } from "./runtime.mjs";
+import { relative, sep } from "node:path";
+import { fileURLToPath } from "node:url";
 const ASSERTION_METHODS = new Set([
     "deepEqual",
     "deepStrictEqual",
@@ -19,18 +21,40 @@ const ASSERTION_METHODS = new Set([
     "strictEqual",
     "throws",
 ]);
-function assertionSource() {
-    const lines = new Error().stack?.split("\n").slice(2) ?? [];
-    const entry = lines.find((line) => !/(?:nodeAssert|nodeAssertion|runtime)\.[cm]?[jt]s/.test(line) &&
-        !line.includes("node:internal"));
-    if (!entry)
+function assertionSource(boundary) {
+    // Omit our own frames by function identity, not basename: a user's helper
+    // may itself be called runtime.mjs or nodeAssertAdapter.mjs. Never search
+    // deeper for a plausible-looking caller when the immediate frame is opaque.
+    // A loader may have transformed this file without composing source maps.
+    // Qualify stack coordinates so they cannot masquerade as the original
+    // source positions emitted by lexical probes and used for oracle matching.
+    try {
+        const error = {};
+        Error.captureStackTrace(error, boundary);
+        if (typeof error.stack !== "string")
+            return undefined;
+        const entry = error.stack.split("\n")[1]?.trim();
+        const match = entry && /(?:^at (?:async )?| \()((?:file:\/\/\/|\/|[A-Za-z]:[\\/]).*):(\d+):(\d+)\)?$/.exec(entry);
+        if (!match)
+            return undefined;
+        const file = match[1].startsWith("file:") ? fileURLToPath(match[1]) : match[1];
+        const roots = [process.env.SUPERCOV_PROJECT_ROOT, process.env.SUPERCOV_SOURCE_PROJECT_ROOT, process.cwd()].filter(Boolean);
+        for (const root of roots) {
+            const path = relative(root, file);
+            if (path !== ".." && !path.startsWith(`..${sep}`) && !/^(?:[A-Za-z]:|[\\/])/.test(path))
+                return `runtime-stack:${path.split(sep).join("/")}:${match[2]}:${match[3]}`;
+        }
+        return `runtime-stack:${file.split(sep).join("/")}:${match[2]}:${match[3]}`;
+    }
+    catch {
+        // Custom stack formatters must not change the user's assertion outcome.
         return undefined;
-    return entry.trim().replace(/^at\s+/, "");
+    }
 }
 function wrapAssertion(original, operation) {
     return new Proxy(original, {
-        apply(target, thisArgument, argumentsList) {
-            return withNodeAssertionPhase(operation, assertionSource(), () => Reflect.apply(target, thisArgument, argumentsList));
+        apply: function assertionApply(target, thisArgument, argumentsList) {
+            return withNodeAssertionPhase(operation, () => assertionSource(assertionApply), () => Reflect.apply(target, thisArgument, argumentsList));
         },
     });
 }

package/runtime/javascript/nodeTest.mjs

@@ -2,7 +2,7 @@ import * as native from "node:test";
 import { fileURLToPath } from "node:url";
 import vm from "node:vm";
 import { beginBufferedServerEvidence, flushBufferedServerEvidence, takeNodeAssertionPhases, withCoverageCarrier, } from "./runtime.mjs";
-import { callerLocation, runnerExecutionScope, writeRunnerEvidence, } from "./runnerEvidence.mjs";
+import { callerLocation, runnerExecutionScope, runnerTestId, writeRunnerEvidence, } from "./runnerEvidence.mjs";
 function callbackIndex(args) {
     for (let index = args.length - 1; index >= 0; index -= 1)
         if (typeof args[index] === "function")
@@ -86,16 +86,18 @@ function restoreUserError(error, depth = 0) {
     }
     return error;
 }
-function wrappedRegistration(original) {
+const registrationCounts = new Map();
+function wrappedRegistration(original, parentTestId) {
     const wrapped = function supercovNodeTest(...args) {
         const index = callbackIndex(args);
         if (index < 0)
             return Reflect.apply(original, this, args);
         const callback = args[index];
-        const location = callerLocation(/(?:nodeTest|runnerEvidence)\.[cm]?[jt]s/);
+        const location = callerLocation(supercovNodeTest);
         const identity = {
             runner: "node:test",
             name: testName(args, callback),
+            ...(parentTestId ? { parentTestId } : {}),
             ...location,
             // Source-map producers disagree about whether a call expression maps to
             // its first token or the first token on its source line. The line and
@@ -104,6 +106,12 @@ function wrappedRegistration(original) {
             // keeps one identity when esbuild, Babel, SWC, or TypeScript rewrites it.
             ...(location.line === undefined ? {} : { column: 1 }),
         };
+        // Allocate at registration, never callback completion: concurrent tests
+        // can finish in any order. Count each source/name within its parent.
+        const registrationKey = runnerTestId(identity);
+        const registrationOrdinal = registrationCounts.get(registrationKey) ?? 0;
+        registrationCounts.set(registrationKey, registrationOrdinal + 1);
+        identity.registrationOrdinal = registrationOrdinal;
         const scope = runnerExecutionScope(identity);
         const options = testOptions(args, index);
         const evidenceDirectory = process.env["SUPERCOV_EVIDENCE_DIR"];
@@ -129,7 +137,7 @@ function wrappedRegistration(original) {
                         };
                     }
                     if (property === "test" && typeof value === "function")
-                        return wrappedRegistration(value.bind(target));
+                        return wrappedRegistration(value.bind(target), scope.testId);
                     return typeof value === "function" ? value.bind(target) : value;
                 },
             });
@@ -192,7 +200,7 @@ function wrappedRegistration(original) {
             Object.defineProperty(wrapped, property, {
                 configurable: true,
                 enumerable: true,
-                value: wrappedRegistration(member),
+                value: wrappedRegistration(member, parentTestId),
             });
     }
     return wrapped;

package/runtime/javascript/register.mjs

@@ -9,6 +9,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 import Module, { register, syncBuiltinESMExports } from "node:module";
 import { closeSync, openSync, unlinkSync } from "node:fs";
 import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { installLaunchSupervisor, wrapImportedCapability } from "./launchSupervisor.mjs";
 import { __supercovBindCapabilityWrapper } from "./capability.mjs";
 installLaunchSupervisor();
@@ -115,7 +116,6 @@ syncBuiltinESMExports();
 // without editing package scripts, Vitest configs, setup files, or test imports.
 const generatedVitestConfig = process.env.SUPERCOV_GENERATED_VITEST_CONFIG;
 const generatedPlaywrightConfig = process.env.SUPERCOV_GENERATED_PLAYWRIGHT_CONFIG;
-const generatedJestConfig = process.env.SUPERCOV_GENERATED_JEST_CONFIG;
 const entrypoint = process.argv[1]?.replaceAll("\\", "/") ?? "";
 const playwrightTarget = process.env.SUPERCOV_PLAYWRIGHT_MODULE;
 const projectRoot = process.env.SUPERCOV_PROJECT_ROOT?.replaceAll("\\", "/").replace(/\/$/, "");
@@ -171,19 +171,37 @@ if (generatedVitestConfig && /\/vitest(?:\.m?js)?$/.test(entrypoint)) {
         });
     }
 }
-if (generatedJestConfig && isJestEntrypoint) {
+if ((isJestEntrypoint || process.env.JEST_WORKER_ID) && process.env.SUPERCOV_EVIDENCE_DIR) {
+    // Jest evaluates instrumented modules in its own module system, past the
+    // loader hook that imports the runtime on first use elsewhere, and
+    // jest-environment-node exposes to each test's sandbox only the globals
+    // the outer process held when that class loaded. The Jest process and
+    // each of its workers (JEST_WORKER_ID) therefore load the runtime first;
+    // without this, a suite with more than one test file failed on every
+    // instrumented module's first line inside the workers.
+    globalThis.__SUPERCOV_DIRECT_RUNTIME__ ??= await import("./runtime.mjs");
+    process.__SUPERCOV_DIRECT_RUNTIME__ ??= globalThis.__SUPERCOV_DIRECT_RUNTIME__;
+}
+if (isJestEntrypoint && process.env.SUPERCOV_EVIDENCE_DIR) {
+    // Jest reads one configuration. Ours (jest.config.mjs) reads the user's
+    // the way Jest would and adds the adapter and reporter; an explicit
+    // --config on the command line reaches it through the environment.
     for (let index = 2; index < process.argv.length; index += 1) {
         const argument = process.argv[index];
         if (argument === "--config" || argument === "-c") {
-            process.argv.splice(index, process.argv[index + 1] ? 2 : 1);
+            const value = process.argv[index + 1];
+            if (value)
+                process.env.SUPERCOV_ORIGINAL_JEST_CONFIG = resolve(value);
+            process.argv.splice(index, value ? 2 : 1);
             index -= 1;
         }
         else if (argument?.startsWith("--config=")) {
+            process.env.SUPERCOV_ORIGINAL_JEST_CONFIG = resolve(argument.slice("--config=".length));
             process.argv.splice(index, 1);
             index -= 1;
         }
     }
-    process.argv.push("--config", generatedJestConfig);
+    process.argv.push("--config", fileURLToPath(new URL("./jest.config.mjs", import.meta.url)));
 }
 if (generatedPlaywrightConfig &&
     isPlaywrightEntrypoint) {

package/runtime/javascript/runnerEvidence.mjs

@@ -27,13 +27,24 @@ function localFile(file) {
     return relative(process.cwd(), absolute).split(sep).join("/");
 }
 export function runnerTestId(identity) {
-    const key = [
+    const parts = [
         identity.runner,
         localFile(identity.file) ?? "unknown",
         identity.line ?? 0,
         identity.column ?? 0,
         identity.name,
-    ].join("\0");
+    ];
+    // Preserve existing top-level, uniquely registered test IDs. Nested tests
+    // and repeated registrations need more than a shared source/name identity.
+    if (identity.parentTestId)
+        parts.push("parent", identity.parentTestId);
+    if (identity.registrationOrdinal)
+        parts.push("registration", identity.registrationOrdinal);
+    // Titles can themselves contain separator text. Domain-separate and encode
+    // the extended identity structurally so it cannot alias a literal title.
+    const key = identity.parentTestId || identity.registrationOrdinal
+        ? JSON.stringify(["registration-v2", ...parts])
+        : parts.join("\0");
     return `${identity.runner}:${createHash("sha256").update(key).digest("hex").slice(0, 24)}`;
 }
 export function runnerExecutionScope(identity) {
@@ -50,24 +61,35 @@ export function runnerExecutionScope(identity) {
         testId,
         testKey,
         retry,
-        attemptId: `${testKey}-${retry}`,
+        // Different processes/worker threads can execute the same registration.
+        // Their files must not collide even though the stable test ID is shared.
+        attemptId: `${testKey}-${retry}-${processInstanceToken()}`,
     };
 }
-export function callerLocation(ignored) {
-    const lines = new Error().stack?.split("\n").slice(2) ?? [];
-    for (const entry of lines) {
-        if (ignored.test(entry) || entry.includes("node:internal"))
-            continue;
-        const match = /(?:\(|at\s+)(file:\/\/[^:)]+|(?:[A-Za-z]:)?[^():]+):(\d+):(\d+)\)?$/.exec(entry.trim());
+export function callerLocation(boundary = callerLocation) {
+    // Omit the registration wrapper by identity. A user file may have the same
+    // basename as a runtime adapter. Parse the location suffix, not individual
+    // path segments: spaces, parentheses and Unicode are valid filenames.
+    try {
+        const error = {};
+        Error.captureStackTrace(error, boundary);
+        if (typeof error.stack !== "string")
+            return {};
+        const entry = error.stack.split("\n")[1]?.trim();
+        const match = entry && /(?:^at (?:async )?| \()((?:file:\/\/|\/|[A-Za-z]:[\\/]|\\\\).*):(\d+):(\d+)\)?$/.exec(entry);
         if (!match)
-            continue;
+            return {};
         return {
             file: match[1],
             line: Number(match[2]),
             column: Number(match[3]),
         };
     }
-    return {};
+    catch {
+        // Custom formatters must not prevent registration. Missing provenance
+        // is explicit, never replaced with an unrelated deeper caller.
+        return {};
+    }
 }
 export function readScopedServerEvidence(scope, evidencePath = serverEvidencePath(scope)) {
     try {