supercov 0.0.53 → 0.0.55

package/docs/supported-suites.md

@@ -49,7 +49,7 @@ Supercov reports the level it actually observed. It does not guess.
 | Runner | Attribution |
 | --- | --- |
 | Playwright | Exact per test, worker, retry, outcome, action, and assertion phase |
-| Vitest | Exact per test, with setup execution kept separate |
+| Vitest | Exact per test, with setup execution kept separate; Browser Mode included |
 | Jest | Exact per test, including parameterized tests, with the user's own configuration, setup files and reporters kept; passing `expect` occurrences are identified for assertion maps |
 | `node:test` | Exact per test |
 | AVA and Mocha | Aggregate structural coverage |
@@ -59,6 +59,51 @@ Supercov reports the level it actually observed. It does not guess.
 One command may launch several runners. Supercov combines their evidence into
 one run and preserves runner identity wherever the runner exposes it.
 
+### Vitest Browser Mode
+
+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. 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
+expression rendered inside it -- `aria-label={label(state)}`, a child
+`{formatted(value)}` -- is measured on its own rather than counted as covered
+because the component rendered once. This is also what lets a UI assertion be
+explained precisely: `toHaveAccessibleName` names the attribute and
+`toHaveTextContent` names the child, and each is credited separately.
+
+Expressions that cannot independently fail to evaluate do not become
+obligations. `{value}` is reached exactly when the tree is, and
+`onClick={() => save()}` is measured where the handler is called rather than
+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.53",
+  "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.53",
-    "@supercov/cli-darwin-x64": "0.0.53",
-    "@supercov/cli-linux-arm64-gnu": "0.0.53",
-    "@supercov/cli-linux-arm64-musl": "0.0.53",
-    "@supercov/cli-linux-x64-gnu": "0.0.53",
-    "@supercov/cli-linux-x64-musl": "0.0.53",
-    "@supercov/cli-win32-arm64": "0.0.53",
-    "@supercov/cli-win32-x64": "0.0.53"
+    "@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/runtime.mjs

@@ -1207,6 +1207,15 @@ function selectionEnd(frame, value) {
   }
   return value;
 }
+// A JSX expression container has nowhere to put a statement and cannot hold a
+// bare comma operator, so a rendered expression carries its probe as a call
+// that returns the value through. Like optionalSelect, it records after the
+// value evaluates: an expression that throws is reported unevaluated rather
+// than covered.
+function renderedValueV2(file, index, value) {
+  coverageHitV2(file, index);
+  return value;
+}
 function optionalSelect(shortId, continuedId, value) {
   coverageHit(value === null || value === void 0 ? shortId : continuedId);
   return value;
@@ -1356,6 +1365,7 @@ const directRuntimeApi = {
   optionalCallEnd,
   optionalCallReached,
   optionalSelect,
+  renderedValueV2,
   parenthesizedAssignmentValue,
   phaseBelongsToAttempt,
   registerProbeV2,
@@ -1406,6 +1416,7 @@ export {
   optionalCallEnd,
   optionalCallReached,
   optionalSelect,
+  renderedValueV2,
   parenthesizedAssignmentValue,
   phaseBelongsToAttempt,
   registerProbeV2,

package/runtime/javascript/vitestBrowser.mjs

@@ -0,0 +1,129 @@
+// Vitest Browser Mode runs the test file in the browser, so the node setup
+// cannot be used: it imports node:fs through atomic.mjs, and Vite externalises
+// that for the client. Loading it fails the whole suite before a single test
+// collects, which is what a browser-mode project saw.
+//
+// This setup mirrors the node one's payload contract exactly. What it cannot do
+// in the browser -- resolve a path against the project root, infer provenance,
+// write a file -- it hands to node over Vitest's browser command channel, so
+// that contract has one implementation.
+import { afterEach, beforeEach } from "vitest";
+import { coverageSnapshot, activateCoverageScope, enableRuntimeSnapshotEvidence, resetCoverage, takeNodeAssertionPhases, } from "./runtime.mjs";
+// Vitest exposes the command channel at "vitest/browser" from v4 and at
+// "@vitest/browser/context" before that. Both are tried so a project is not
+// forced onto one Vitest line to be measured.
+const browserContext = await import("vitest/browser").catch(() =>
+    import("@vitest/browser/context"));
+const { commands } = browserContext;
+const attempts = new Map();
+const activeScopes = new Map();
+const emittedSetupFiles = new Set();
+enableRuntimeSnapshotEvidence();
+function attemptStatus(state) {
+    if (state === "pass")
+        return "passed";
+    if (state === "fail")
+        return "failed";
+    if (state === "skip" || state === "todo")
+        return "skipped";
+    return "unknown";
+}
+function titlePath(task) {
+    const names = [task.name];
+    let suite = task.suite;
+    while (suite?.name) {
+        names.unshift(suite.name);
+        suite = suite.suite;
+    }
+    return names;
+}
+// The node setup keys an attempt by sha256(testId). Browsers have the same
+// digest behind an async API, so the hook awaits it rather than substituting a
+// different hash and giving the same test two identities across environments.
+async function testKeyOf(testId) {
+    const bytes = new TextEncoder().encode(testId);
+    const digest = await crypto.subtle.digest("SHA-256", bytes);
+    return [...new Uint8Array(digest)]
+        .map((byte) => byte.toString(16).padStart(2, "0"))
+        .join("")
+        .slice(0, 24);
+}
+// Evidence leaves the browser over Vitest's own command channel: node runs the
+// handler, the test awaits it, and the failure is reported rather than
+// swallowed -- silently losing a test's evidence is the worst shape a
+// measurement bug takes.
+async function sendEvidence(payload, suffix) {
+    try {
+        await commands.__supercovEvidence(payload, suffix);
+    }
+    catch (error) {
+        console.error("[supercov] failed to record browser evidence:", error);
+        throw error;
+    }
+}
+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);
+    const testKey = await testKeyOf(testId);
+    const scope = {
+        version: 1,
+        runId: globalThis.__SUPERCOV_RUN_ID__ ?? "unscoped",
+        workerId: "vitest-browser",
+        testId,
+        testKey,
+        retry,
+        attemptId: `${testKey}-${retry}`,
+    };
+    activeScopes.set(task.id, scope);
+    activateCoverageScope(scope);
+    resetCoverage(testId);
+});
+afterEach(async (context) => {
+    const task = context.task;
+    const scope = activeScopes.get(task.id);
+    const retry = scope?.retry ?? task.result?.retryCount ?? 0;
+    // Node relativises the test file Vitest reports and infers provenance, so
+    // both environments describe a test the same way and neither trusts the
+    // browser realm to say which file it was.
+    const payload = {
+        testId: scope?.testId ?? `vitest:${task.id}`,
+        ...(scope ? { scope } : {}),
+        test: [...titlePath(task)].join(" > "),
+        projectName: task.file?.projectName,
+        title: task.name,
+        retry,
+        status: attemptStatus(task.result?.state),
+        ...(scope ? { phases: takeNodeAssertionPhases(scope) } : {}),
+        // Browser-mode evidence is a runtime snapshot like node's: the code
+        // under test runs in the same realm as the probes.
+        runtime: [coverageSnapshot()],
+        browser: [],
+        server: [],
+    };
+    await sendEvidence(payload, `vitest-${task.id}-${retry}`);
+    activeScopes.delete(task.id);
+    activateCoverageScope();
+});

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)