supercov 0.0.53 → 0.0.54

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.53",
+  "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.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.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

@@ -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,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();
+});