supercov 0.0.41 → 0.0.43

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/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/runtime.mjs

@@ -144,6 +144,12 @@ function createState() {
     decisions: /* @__PURE__ */ new Map(),
     hits: /* @__PURE__ */ new Set(),
     events: [],
+    // Position of the test-file statement currently executing ("file:line:column"), set by the
+    // instrumented test module; production hits recorded meanwhile are attributed to it.
+    testStatement: void 0,
+    // Per value-position logical expression (`a && b`, `a || b`, `a ?? b`): the distinct
+    // (right operand evaluated?, result truthy?) pairs seen, keyed by branch id.
+    logicals: /* @__PURE__ */ new Map(),
     eventKeys: /* @__PURE__ */ new Set(),
     bufferedAttempts: /* @__PURE__ */ new Set(),
     serverBuffers: /* @__PURE__ */ new Map(),
@@ -293,17 +299,26 @@ function decisionSnapshot() {
     vectors: [...decision.vectors.values()]
   }));
 }
+function logicalSnapshot() {
+  return [...state.logicals.entries()].map(([id, vectors]) => ({
+    id,
+    vectors: [...vectors.values()]
+  }));
+}
 function coverageSnapshot() {
   return {
     decisions: decisionSnapshot(),
     hits: [...state.hits],
-    events: state.events
+    events: state.events,
+    logicals: logicalSnapshot()
   };
 }
 function resetCoverage(testId2) {
   state.decisions.clear();
   state.hits.clear();
   state.events.length = 0;
+  state.testStatement = void 0;
+  state.logicals.clear();
   state.eventKeys.clear();
   state.probeV2ContextEpochs.clear();
   activateProbeV2Key(`reset\0${state.probeV2NextEpoch}`, true);
@@ -604,21 +619,22 @@ function appendServer(record) {
   var _a8, _b, _c, _d;
   if (state.runtimeSnapshots) {
     const timestampMs = (_a8 = record.timestampMs) != null ? _a8 : Date.now();
+    const statement = record.statementId ? { statementId: record.statementId } : {};
     if (record.type === "decision") {
-      recordBrowserEvent(__spreadProps(__spreadValues({
+      recordBrowserEvent(__spreadProps(__spreadValues(__spreadValues({
         type: "decision",
         id: record.meta.id,
         vector: record.vector,
         timestampMs
-      }, record.phaseId ? { phaseId: record.phaseId } : {}), {
+      }, record.phaseId ? { phaseId: record.phaseId } : {}), statement), {
         environment: "server"
       }));
     } else {
-      recordBrowserEvent(__spreadProps(__spreadValues({
+      recordBrowserEvent(__spreadProps(__spreadValues(__spreadValues({
         type: "hit",
         id: record.id,
         timestampMs
-      }, record.phaseId ? { phaseId: record.phaseId } : {}), {
+      }, record.phaseId ? { phaseId: record.phaseId } : {}), statement), {
         environment: "server"
       }));
     }
@@ -962,25 +978,31 @@ function recordBrowserEvent(event) {
   state.events.push(event);
   return true;
 }
+function testStatement(source) {
+  state.testStatement = typeof source === "string" && source.length > 0 ? source : void 0;
+}
+function statementFields() {
+  return state.testStatement ? { statementId: state.testStatement } : {};
+}
 function coverageHit(id) {
   state.hits.add(id);
   const timestampMs = Date.now();
   const phaseId = currentPhaseId();
   if (isBrowser) {
-    if (recordBrowserEvent(__spreadProps(__spreadValues({
+    if (recordBrowserEvent(__spreadProps(__spreadValues(__spreadValues({
       type: "hit",
       id,
       timestampMs
-    }, phaseId ? { phaseId } : {}), {
+    }, phaseId ? { phaseId } : {}), statementFields()), {
       environment: "browser"
     })))
       persistBrowser();
   } else {
-    appendServer(__spreadValues({
+    appendServer(__spreadValues(__spreadValues({
       type: "hit",
       id,
       timestampMs
-    }, phaseId ? { phaseId } : {}));
+    }, phaseId ? { phaseId } : {}), statementFields()));
   }
 }
 function registerProbeV2(definition) {
@@ -1113,6 +1135,20 @@ function selectionRight(frame, value, inferredName) {
 }
 function selectionEnd(frame, value) {
   coverageHit(frame.rightEvaluated ? frame.rightId : frame.shortId);
+  // Per-operand outcomes for the verifier: which side was selected and whether the result is
+  // truthy. With the operator (known from the manifest) this gives each operand's outcome.
+  const separator = frame.shortId.lastIndexOf(":");
+  if (separator > 0) {
+    const branchId = frame.shortId.slice(0, separator);
+    const right = frame.rightEvaluated;
+    const truthy = Boolean(value);
+    let vectors = state.logicals.get(branchId);
+    if (!vectors) {
+      vectors = /* @__PURE__ */ new Map();
+      state.logicals.set(branchId, vectors);
+    }
+    vectors.set(`${right ? "R" : "S"}${truthy ? "T" : "F"}`, { right, truthy });
+  }
   return value;
 }
 function optionalSelect(shortId, continuedId, value) {
@@ -1201,22 +1237,22 @@ function mcdcEnd(frame, value) {
   const timestampMs = Date.now();
   const phaseId = currentPhaseId();
   if (isBrowser) {
-    if (recordBrowserEvent(__spreadProps(__spreadValues({
+    if (recordBrowserEvent(__spreadProps(__spreadValues(__spreadValues({
       type: "decision",
       id: decision.meta.id,
       vector,
       timestampMs
-    }, phaseId ? { phaseId } : {}), {
+    }, phaseId ? { phaseId } : {}), statementFields()), {
       environment: "browser"
     })))
       persistBrowser();
   } else {
-    appendServer(__spreadValues({
+    appendServer(__spreadValues(__spreadValues({
       type: "decision",
       meta: decision.meta,
       vector,
       timestampMs
-    }, phaseId ? { phaseId } : {}));
+    }, phaseId ? { phaseId } : {}), statementFields()));
   }
   return value;
 }
@@ -1257,6 +1293,7 @@ const directRuntimeApi = {
   selectionEnd,
   selectionRight,
   takeNodeAssertionPhases,
+  testStatement,
   tryBegin,
   tryCatch,
   tryEnd,
@@ -1306,6 +1343,7 @@ export {
   selectionEnd,
   selectionRight,
   takeNodeAssertionPhases,
+  testStatement,
   tryBegin,
   tryCatch,
   tryEnd,