supercov 0.0.52 → 0.0.54

package/README.md

@@ -136,17 +136,23 @@ The denominator comes from source structure before the run, so adding or removin
 
 ## Install for your language
 
-The same binary ships through each language's own package manager, at the same version, from one release:
+Measuring a project should not start by installing another language. The same binary, at the same version, from one release:
 
 ```bash
-npx supercov -- npm test                          # npm
-uvx --from supercov-cli supercov -- pytest        # PyPI
-gem install supercov && supercov -- bundle exec rspec   # RubyGems
-cargo binstall supercov && supercov -- cargo test  # crates.io
+npx supercov -- npm test                                 # npm
+uvx --from supercov-cli supercov -- pytest               # PyPI
+gem install supercov && supercov -- bundle exec rspec    # RubyGems
+cargo binstall supercov && supercov -- cargo test        # crates.io
+go run github.com/supercorp-ai/supercov/cmd/supercov@latest -- go test ./...   # Go
+brew install supercorp-ai/tap/supercov && supercov -- ./gradlew test           # Homebrew
 ```
 
 `pip install supercov-cli` and `gem install supercov` install a wheel or gem that carries the binary for your platform; nothing is compiled. `cargo binstall` downloads that same binary from the GitHub release, while plain `cargo install supercov` builds it from source and needs Rust 1.95.
 
+A Go project needs Go and nothing else. Like any `go run` with a version suffix it resolves by module path and ignores the `go.mod` in your current directory, so it neither needs nor touches your module.
+
+Java and Kotlin have no registry of their own here, so a JVM project takes the binary directly -- Homebrew above, `npx` if Node is already present, or the platform archive from the [latest release](https://github.com/supercorp-ai/supercov/releases/latest). Maven and Gradle are driven as your test command, not as a plugin. Supercov adds the JUnit Platform launcher its measurement needs to the build file inside its own isolated workspace copy -- your `pom.xml` or `build.gradle` is never edited.
+
 ## Supported languages
 
 | Language | Status | Start with |
@@ -156,7 +162,7 @@ cargo binstall supercov && supercov -- cargo test  # crates.io
 | Rust | Available | `npx supercov -- cargo test` |
 | Python | Available | `npx supercov -- pytest` |
 | Ruby | Available | `npx supercov -- rspec` |
-| Go | Available | `npx supercov -- go test ./...` |
+| Go | Available | `go run github.com/supercorp-ai/supercov/cmd/supercov@latest -- go test ./...` |
 | Java | Available | `npx supercov -- mvn test` |
 | Kotlin | Available | `npx supercov -- ./gradlew test` |
 | Zig | Coming soon | — |

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,30 @@ 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, with no extra configuration. Every provider is supported, because
+evidence travels over Vitest's own browser command channel rather than anything
+provider-specific.
+
+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.
+
 ### 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.52",
+  "version": "0.0.54",
   "description": "Coverage for coding agents and software factories \ud83c\udf19",
   "license": "MIT",
   "repository": {
@@ -97,14 +97,14 @@
     "test:launcher": "go vet ./cmd/... && go test ./cmd/..."
   },
   "optionalDependencies": {
-    "@supercov/cli-darwin-arm64": "0.0.52",
-    "@supercov/cli-darwin-x64": "0.0.52",
-    "@supercov/cli-linux-arm64-gnu": "0.0.52",
-    "@supercov/cli-linux-arm64-musl": "0.0.52",
-    "@supercov/cli-linux-x64-gnu": "0.0.52",
-    "@supercov/cli-linux-x64-musl": "0.0.52",
-    "@supercov/cli-win32-arm64": "0.0.52",
-    "@supercov/cli-win32-x64": "0.0.52"
+    "@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"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.55.0",

package/runtime/javascript/runtime.mjs

@@ -751,8 +751,19 @@ function withNodeAssertionPhase(operation, source, callback) {
   const scope = context.scope;
   if (!scope)
     return callback();
-  const existing = context.phaseId && assertionPhaseState(scope).phaseIds.has(context.phaseId);
-  if (existing)
+  // A lexically instrumented occurrence is an authored assertion site in its
+  // own right, even when it runs inside another assertion's callback: the
+  // validator passed to assert.throws is the ordinary case, and its inner
+  // assertions are what claim *what* the error says. Skipping every nested
+  // phase left those with no passing occurrence, so they could never earn
+  // credit however carefully they were mapped.
+  //
+  // What must still be skipped is the same call seen twice -- the module proxy
+  // firing inside the lexical wrapper. That path has no lexical source and
+  // arrives as a lazy stack fallback, so the shape of `source` tells them
+  // apart without comparing coordinates the transform has moved.
+  const nested = context.phaseId && assertionPhaseState(scope).phaseIds.has(context.phaseId);
+  if (nested && typeof source !== "string")
     return callback();
   // A lexical occurrence already identifies its source. Stack fallback is lazy
   // and qualified so transformed coordinates cannot impersonate original ones.
@@ -1196,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;
@@ -1244,20 +1264,35 @@ function tryBegin(successId, catchId) {
   return { successId, catchId, caught: false };
 }
 function tryCatch(frame, value) {
-  frame.caught = true;
+  // Record the outcome the moment it is known, not when the construct is left.
+  // The commit used to sit in the generated `finally`, and `process.exit()` in
+  // a catch body skips `finally` -- so a catch that ran and whose statements
+  // were credited was still reported as never entered. Statement probes fire
+  // in place and survived, which is what made the report contradict itself.
+  if (!frame.caught) {
+    frame.caught = true;
+    coverageHit(frame.catchId);
+  }
   return value;
 }
 function tryEnd(frame) {
-  coverageHit(frame.caught ? frame.catchId : frame.successId);
+  // Completing without catching is only knowable here.
+  if (!frame.caught) coverageHit(frame.successId);
 }
 function loopBegin(zeroId, enteredId) {
   return { zeroId, enteredId, entered: false };
 }
 function loopEntered(frame) {
-  frame.entered = true;
+  // Same reason as tryCatch: a loop body that exits the process would
+  // otherwise report zero iterations. Guarded so a loop still counts once,
+  // however many times it iterates.
+  if (!frame.entered) {
+    frame.entered = true;
+    coverageHit(frame.enteredId);
+  }
 }
 function loopEnd(frame) {
-  coverageHit(frame.entered ? frame.enteredId : frame.zeroId);
+  if (!frame.entered) coverageHit(frame.zeroId);
 }
 function mcdcBegin(id, meta) {
   if (!state.decisions.has(id)) {
@@ -1330,6 +1365,7 @@ const directRuntimeApi = {
   optionalCallEnd,
   optionalCallReached,
   optionalSelect,
+  renderedValueV2,
   parenthesizedAssignmentValue,
   phaseBelongsToAttempt,
   registerProbeV2,
@@ -1380,6 +1416,7 @@ export {
   optionalCallEnd,
   optionalCallReached,
   optionalSelect,
+  renderedValueV2,
   parenthesizedAssignmentValue,
   phaseBelongsToAttempt,
   registerProbeV2,

package/runtime/javascript/vitestBrowser.mjs

@@ -0,0 +1,107 @@
+// 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();
+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;
+    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();
+});