supercov 0.0.54 → 0.0.55

package/docs/supported-suites.md

@@ -63,9 +63,10 @@ one run and preserves runner identity wherever the runner exposes it.
 
 Vitest Browser Mode runs the test file in a real browser. Supercov measures it
 per test like any other Vitest run: lines, branches, MC/DC and assertion
-coverage, with no extra configuration. Every provider is supported, because
-evidence travels over Vitest's own browser command channel rather than anything
-provider-specific.
+coverage. Combined Node/browser projects are configured after Vitest resolves
+inline definitions, config-file references, globs and project selection.
+Evidence travels over Vitest's own browser command channel; the compatibility
+suite exercises Chromium through the Playwright provider.
 
 Component code is instrumented the same way as any other source, with one
 addition that matters most here. A JSX tree is a single statement, so an
@@ -83,6 +84,26 @@ where it is created.
 `expect.element(...)`, `expect.soft(...)` and `expect.poll(...)` are recognised
 as assertions, so their passing occurrences are available to assertion maps.
 
+### React and React Native
+
+React components can use Testing Library with Vitest/jsdom, Vitest Browser Mode,
+or Babel/Jest. React Native and Expo component tests run through their existing
+Jest presets, including native mocks. This is JavaScript component-test coverage:
+it does not measure Hermes, native modules, simulator/device execution, Detox or
+Maestro. React SSR hydration is exercised in jsdom and Chromium; this does not
+establish Next.js Server Components, streaming SSR or server actions.
+
+An assertion map can explain which displayed value, accessible name, disabled
+state or error message a test checks. JSX expression coverage and a passing
+assertion are evidence for reviewing that explanation, not automatic semantic
+proof. A button being rendered does not establish that its disabled state was
+checked. Keep your existing runner and matchers.
+
+The [React verification example](https://github.com/supercorp-ai/supercov/tree/main/examples/react-verification)
+shows a fully executed checkout whose weak tests accept four UI regressions,
+then adds four precise assertions and independently checks the broken copies.
+The agent-authored maps credit only those four UI expressions.
+
 ### Builds and source formats
 
 JavaScript and TypeScript projects may use Vite, Next, Turbopack, Webpack,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supercov",
-  "version": "0.0.54",
+  "version": "0.0.55",
   "description": "Coverage for coding agents and software factories \ud83c\udf19",
   "license": "MIT",
   "repository": {
@@ -54,6 +54,7 @@
     "test:rustc-backend-spike": "node scripts/rustc-backend-spike.mjs",
     "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:react": "cargo build -p supercov && node scripts/rust-vitest-projects-integration.mjs && npm --prefix examples/react-verification ci && npm --prefix examples/react-verification run demo && node scripts/react-hydration-compatibility.mjs",
     "test:runtime": "node --test tests/runtime/*.test.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",
@@ -97,14 +98,14 @@
     "test:launcher": "go vet ./cmd/... && go test ./cmd/..."
   },
   "optionalDependencies": {
-    "@supercov/cli-darwin-arm64": "0.0.54",
-    "@supercov/cli-darwin-x64": "0.0.54",
-    "@supercov/cli-linux-arm64-gnu": "0.0.54",
-    "@supercov/cli-linux-arm64-musl": "0.0.54",
-    "@supercov/cli-linux-x64-gnu": "0.0.54",
-    "@supercov/cli-linux-x64-musl": "0.0.54",
-    "@supercov/cli-win32-arm64": "0.0.54",
-    "@supercov/cli-win32-x64": "0.0.54"
+    "@supercov/cli-darwin-arm64": "0.0.55",
+    "@supercov/cli-darwin-x64": "0.0.55",
+    "@supercov/cli-linux-arm64-gnu": "0.0.55",
+    "@supercov/cli-linux-arm64-musl": "0.0.55",
+    "@supercov/cli-linux-x64-gnu": "0.0.55",
+    "@supercov/cli-linux-x64-musl": "0.0.55",
+    "@supercov/cli-win32-arm64": "0.0.55",
+    "@supercov/cli-win32-x64": "0.0.55"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.55.0",
@@ -126,6 +127,7 @@
     "@playwright/test": "1.62.1",
     "@swc/core": "^1.16.1",
     "@types/node": "^24.0.0",
+    "@vitest/browser-playwright": "4.1.11",
     "esbuild": "^0.28.2",
     "expect": "30.4.1",
     "jest": "30.5.1",

package/runtime/javascript/jest.cjs

@@ -28,8 +28,32 @@ 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}`)}`;
+function testIdentity(testFile, fullName, occurrence = 0) {
+    return `jest:${digest(`${testFile}\0${fullName}${occurrence ? `\0${occurrence}` : ""}`)}`;
+}
+// Circus keeps its declaration tree on the environment global. It distinguishes
+// identical titles and survives retries; expect.currentTestName alone cannot.
+function currentDeclaration() {
+    const symbol = Object.getOwnPropertySymbols(globalThis)
+        .find(key => key.description === "JEST_STATE_SYMBOL");
+    const state = symbol && globalThis[symbol];
+    if (!state?.currentlyRunningTest || !state.rootDescribeBlock) return undefined;
+    const names = new Map();
+    let found;
+    function visit(block, parents) {
+        for (const child of block.children ?? []) {
+            if (child.type === "describeBlock") visit(child, [...parents, child.name]);
+            else if (child.type === "test") {
+                const name = [...parents, child.name].join(" ");
+                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)};
+            }
+        }
+    }
+    visit(state.rootDescribeBlock, []);
+    return found;
 }
 // Mirrors provenance.mjs, which is ESM and out of reach here.
 const KINDS = [
@@ -56,7 +80,7 @@ function writeEvidence(suffix, payload) {
     renameSync(temporary, target);
 }
 
-if (runtime && evidenceDirectory && typeof beforeEach === "function" && typeof afterEach === "function") {
+if (runtime && evidenceDirectory && typeof beforeEach === "function" && typeof afterAll === "function") {
     // One in-memory snapshot per test; the server JSONL transport would be
     // redundant and unattributed, as under Vitest.
     runtime.enableRuntimeSnapshotEvidence();
@@ -64,6 +88,7 @@ if (runtime && evidenceDirectory && typeof beforeEach === "function" && typeof a
     const emittedSetupFiles = new Set();
     let active;
     beforeEach(() => {
+        flushActive();
         const state = expect.getState();
         const testFile = localFile(state.testPath ?? "unknown");
         if (!emittedSetupFiles.has(testFile)) {
@@ -87,8 +112,9 @@ if (runtime && evidenceDirectory && typeof beforeEach === "function" && typeof a
             }
         }
         const fullName = state.currentTestName ?? "test";
-        const testId = testIdentity(testFile, fullName);
-        const retry = attempts.get(testId) ?? 0;
+        const declaration = currentDeclaration();
+        const testId = testIdentity(testFile, fullName, declaration?.occurrence);
+        const retry = declaration?.retry ?? attempts.get(testId) ?? 0;
         attempts.set(testId, retry + 1);
         const testKey = digest(testId);
         const scope = {
@@ -104,7 +130,10 @@ if (runtime && evidenceDirectory && typeof beforeEach === "function" && typeof a
         runtime.activateCoverageScope(scope);
         runtime.resetCoverage(testId);
     });
-    afterEach(() => {
+    // Flush after all user afterEach hooks (including Testing Library cleanup).
+    // Our setup registers first, so an afterEach snapshot would run too early.
+    // The next beforeEach or this file's afterAll runs after test teardown.
+    function flushActive() {
         const current = active;
         active = undefined;
         if (!current)
@@ -130,5 +159,6 @@ if (runtime && evidenceDirectory && typeof beforeEach === "function" && typeof a
         // snapshot (Vitest isolates files; Jest does not).
         runtime.resetCoverage();
         runtime.activateCoverageScope();
-    });
+    }
+    afterAll(flushActive);
 }

package/runtime/javascript/jest.config.mjs

@@ -30,7 +30,16 @@ export default async function supercovJestConfig() {
         ...config,
         // Concurrent tests in one file would share the worker's scope.
         maxConcurrency: 1,
-        setupFilesAfterEnv: [...asList(config.setupFilesAfterEnv), here("jest.cjs")],
+        setupFiles: [here("jestRuntime.cjs"), ...asList(config.setupFiles)],
+        // Babel-based presets (including React Native) lower the runtime
+        // side-effect import in instrumented tests to require(). Jest cannot
+        // require our ESM shim. Its environment already owns the runtime, so
+        // resolve only our generated import to a CommonJS bridge instead.
+        moduleNameMapper: {
+            "(?:^|/)\\.supercov/node_modules/runtime\\.mjs$": here("jestRuntime.cjs"),
+            ...config.moduleNameMapper,
+        },
+        setupFilesAfterEnv: [here("jest.cjs"), ...asList(config.setupFilesAfterEnv)],
         reporters: [
             ...(config.reporters === undefined ? ["default"] : asList(config.reporters)),
             here("jestReporter.mjs"),

package/runtime/javascript/jestReporter.mjs

@@ -30,12 +30,23 @@ function attemptStatus(status) {
  * record carries the attempt's coverage; the report joins the two.
  */
 export default class SupercovJestReporter {
-    onTestCaseResult(test, result) {
+    onTestResult(test, fileResult) {
+        // Jest's final array follows declaration order, including skipped cases.
+        // Completion order does not: retries can finish after a namesake test.
+        const occurrences = new Map();
+        for (const result of fileResult.testResults ?? []) {
+            const occurrence = occurrences.get(result.fullName) ?? 0;
+            occurrences.set(result.fullName, occurrence + 1);
+            this.recordResult(test, result, occurrence);
+        }
+    }
+    recordResult(test, result, occurrence) {
         const evidenceDirectory = process.env["SUPERCOV_EVIDENCE_DIR"];
         if (!evidenceDirectory)
             return;
         const testFile = localFile(test.path);
-        const testId = `jest:${digest(`${testFile}\0${result.fullName}`)}`;
+        const identity = `${testFile}\0${result.fullName}${occurrence ? `\0${occurrence}` : ""}`;
+        const testId = `jest:${digest(identity)}`;
         const retry = Math.max((result.invocations ?? 1) - 1, 0);
         const status = attemptStatus(result.status);
         const provenance = inferTestProvenance({

package/runtime/javascript/jestRuntime.cjs

@@ -0,0 +1,12 @@
+"use strict";
+
+// Keep Babel-transformed test modules on the same runtime as the Jest adapter.
+// Loading a second runtime here would split assertion and coverage evidence.
+// jsdom owns a separate global and copies process without the preload's
+// private property. Retrieve the host runtime through Node's VM API, then
+// expose it before user setup files can import instrumented application code.
+const runtime = globalThis.__SUPERCOV_DIRECT_RUNTIME__ ?? process.__SUPERCOV_DIRECT_RUNTIME__ ??
+    require("node:vm").runInThisContext("globalThis.__SUPERCOV_DIRECT_RUNTIME__");
+if (!runtime) throw new Error("[supercov] Jest runtime was not initialized by the preload");
+globalThis.__SUPERCOV_DIRECT_RUNTIME__ = runtime;
+module.exports = runtime;

package/runtime/javascript/register.mjs

@@ -190,22 +190,28 @@ 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.
+    const generatedJestConfig = fileURLToPath(new URL("./jest.config.mjs", import.meta.url));
     for (let index = 2; index < process.argv.length; index += 1) {
         const argument = process.argv[index];
         if (argument === "--config" || argument === "-c") {
             const value = process.argv[index + 1];
-            if (value)
+            // Expo's Jest executable forwards argv to the real Jest process.
+            // Preserve the original config across that second preload; reading
+            // our own config as the user's would recurse until the heap fills.
+            if (value && resolve(value) !== resolve(generatedJestConfig))
                 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));
+            const value = resolve(argument.slice("--config=".length));
+            if (value !== resolve(generatedJestConfig))
+                process.env.SUPERCOV_ORIGINAL_JEST_CONFIG = value;
             process.argv.splice(index, 1);
             index -= 1;
         }
     }
-    process.argv.push("--config", fileURLToPath(new URL("./jest.config.mjs", import.meta.url)));
+    process.argv.push("--config", generatedJestConfig);
 }
 if (generatedPlaywrightConfig &&
     isPlaywrightEntrypoint) {

package/runtime/javascript/vitestBrowser.mjs

@@ -17,6 +17,7 @@ const browserContext = await import("vitest/browser").catch(() =>
 const { commands } = browserContext;
 const attempts = new Map();
 const activeScopes = new Map();
+const emittedSetupFiles = new Set();
 enableRuntimeSnapshotEvidence();
 function attemptStatus(state) {
     if (state === "pass")
@@ -62,6 +63,27 @@ async function sendEvidence(payload, suffix) {
 }
 beforeEach(async (context) => {
     const task = context.task;
+    // Module imports and shared setup execute before the first test. Save
+    // them before resetCoverage clears the snapshot, with a setup identity
+    // rather than crediting that execution to the first test.
+    if (!emittedSetupFiles.has(task.file.id)) {
+        const setupSnapshot = coverageSnapshot();
+        if (setupSnapshot.hits.length || setupSnapshot.decisions.length) {
+            await sendEvidence({
+                testId: `vitest:${task.file.id}:setup`,
+                test: `${task.file.name} > module setup`,
+                projectName: task.file.projectName,
+                title: "module setup",
+                retry: 0,
+                status: "passed",
+                role: "setup",
+                runtime: [setupSnapshot],
+                browser: [],
+                server: [],
+            }, `vitest-${task.file.id}-setup`);
+        }
+        emittedSetupFiles.add(task.file.id);
+    }
     const testId = `vitest:${task.id}`;
     const retry = attempts.get(testId) ?? 0;
     attempts.set(testId, retry + 1);

package/runtime/javascript/vitestReporter.mjs

@@ -25,6 +25,15 @@ function rawAttemptStatus(state, expectedFailure) {
 /** Records final runner outcomes, including tests that never execute hooks. */
 export default class SupercovVitestReporter {
     reportedAttempts = new Set();
+    constructor(configureProjects) {
+        this.configureProjects = configureProjects;
+    }
+    onInit(vitest) {
+        this.configureProjects?.(vitest.projects);
+    }
+    onBrowserInit(project) {
+        this.configureProjects?.([project]);
+    }
     onTestCaseResult(testCase) {
         const evidenceDirectory = process.env["SUPERCOV_EVIDENCE_DIR"];
         if (!evidenceDirectory)