supercov 0.0.43 → 0.0.44

package/docs/troubleshooting.md

@@ -3,7 +3,7 @@
 Start with the run summary. It usually tells you whether the problem is the test
 command, source discovery, runner attribution, or a measurement boundary.
 
-```sh
+```sh supercov
 npx supercov runs latest
 npx supercov runs latest scope
 npx supercov runs latest runners
@@ -28,13 +28,13 @@ would for another npm package.
 Run the same command from the repository root. If first-party code lives in an
 unusual directory, declare the source roots explicitly:
 
-```sh
+```sh supercov
 SUPERCOV_SOURCE_ROOTS=src,app npx supercov -- npm test
 ```
 
 Then inspect what Supercov included and excluded:
 
-```sh
+```sh supercov
 npx supercov runs latest scope
 ```
 
@@ -45,7 +45,7 @@ warning. The goal is an honest boundary around code the repository owns.
 
 First check runner and source scope:
 
-```sh
+```sh supercov
 npx supercov runs latest runners
 npx supercov runs latest scope
 npx supercov runs latest gaps
@@ -67,7 +67,7 @@ file that cannot be compiled with them is measured through Ruby's `Coverage`
 module alone rather than failing the run. To put a file on that path
 deliberately, name a fragment of its path:
 
-```sh
+```sh supercov
 SUPERCOV_RUBY_SKIP_PROBES=app/models/order.rb npx supercov -- bundle exec rspec
 ```
 
@@ -82,7 +82,7 @@ workspace after relevant source, tests, dependencies, configuration, or
 toolchain inputs change. Rerun the same complete command to create a current
 baseline:
 
-```sh
+```sh supercov
 npx supercov -- npm test
 ```
 
@@ -133,7 +133,7 @@ mode still match.
 
 Inspect the recorded phases with:
 
-```sh
+```sh supercov
 npx supercov runs latest
 ```
 
@@ -143,7 +143,7 @@ See [Speed and storage](performance.md) for practical ways to shorten a loop.
 
 Preview cleanup, then choose how much history to keep:
 
-```sh
+```sh supercov
 npx supercov clean --dry-run
 npx supercov clean --keep 20
 npx supercov clean

package/docs/verification.md

@@ -16,7 +16,7 @@ Before merging, check three things:
 3. **The test protects behavior.** It should make a meaningful assertion without
    weakening existing assertions or changing application code for the metric.
 
-```sh
+```sh supercov
 npx supercov diff <baseline-run> <new-run>
 npx supercov runs <new-run> test "new test name"
 ```
@@ -34,7 +34,7 @@ Supercov separates four states:
 - **stale** — the run is valid history but no longer describes the current
   workspace.
 
-```sh
+```sh supercov
 npx supercov runs latest
 npx supercov runs latest scope
 npx supercov runs latest gaps

package/docs/workspace-isolation.md

@@ -74,7 +74,7 @@ staging state. Completed runs remain immutable.
 
 Preview cleanup before removing anything:
 
-```sh
+```sh supercov
 npx supercov clean --dry-run
 npx supercov clean --keep 20
 npx supercov clean

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supercov",
-  "version": "0.0.43",
+  "version": "0.0.44",
   "description": "Coverage for coding agents and software factories 🌙",
   "license": "MIT",
   "repository": {
@@ -18,7 +18,9 @@
     "docs",
     "analyzers/typescript/bin",
     "analyzers/typescript/dist/analyze.js",
+    "analyzers/typescript/dist/mock-counts.js",
     "analyzers/typescript/dist/archive.js",
+    "analyzers/typescript/dist/awaited-observations.js",
     "analyzers/typescript/dist/compiler.js",
     "analyzers/typescript/dist/frontend.js",
     "analyzers/typescript/dist/native-frontend.js",
@@ -92,14 +94,14 @@
     "test:rust-public-cargo": "cargo build -p supercov && node scripts/rust-public-cargo-integration.mjs"
   },
   "optionalDependencies": {
-    "@supercov/cli-darwin-arm64": "0.0.43",
-    "@supercov/cli-darwin-x64": "0.0.43",
-    "@supercov/cli-linux-arm64-gnu": "0.0.43",
-    "@supercov/cli-linux-arm64-musl": "0.0.43",
-    "@supercov/cli-linux-x64-gnu": "0.0.43",
-    "@supercov/cli-linux-x64-musl": "0.0.43",
-    "@supercov/cli-win32-arm64": "0.0.43",
-    "@supercov/cli-win32-x64": "0.0.43"
+    "@supercov/cli-darwin-arm64": "0.0.44",
+    "@supercov/cli-darwin-x64": "0.0.44",
+    "@supercov/cli-linux-arm64-gnu": "0.0.44",
+    "@supercov/cli-linux-arm64-musl": "0.0.44",
+    "@supercov/cli-linux-x64-gnu": "0.0.44",
+    "@supercov/cli-linux-x64-musl": "0.0.44",
+    "@supercov/cli-win32-arm64": "0.0.44",
+    "@supercov/cli-win32-x64": "0.0.44"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.55.0",

package/runtime/javascript/nodeAssertAdapter.mjs

@@ -1,4 +1,6 @@
 import { withNodeAssertionPhase } from "./runtime.mjs";
+import { relative, sep } from "node:path";
+import { fileURLToPath } from "node:url";
 const ASSERTION_METHODS = new Set([
     "deepEqual",
     "deepStrictEqual",
@@ -19,18 +21,40 @@ const ASSERTION_METHODS = new Set([
     "strictEqual",
     "throws",
 ]);
-function assertionSource() {
-    const lines = new Error().stack?.split("\n").slice(2) ?? [];
-    const entry = lines.find((line) => !/(?:nodeAssert|nodeAssertion|runtime)\.[cm]?[jt]s/.test(line) &&
-        !line.includes("node:internal"));
-    if (!entry)
+function assertionSource(boundary) {
+    // Omit our own frames by function identity, not basename: a user's helper
+    // may itself be called runtime.mjs or nodeAssertAdapter.mjs. Never search
+    // deeper for a plausible-looking caller when the immediate frame is opaque.
+    // A loader may have transformed this file without composing source maps.
+    // Qualify stack coordinates so they cannot masquerade as the original
+    // source positions emitted by lexical probes and used for oracle matching.
+    try {
+        const error = {};
+        Error.captureStackTrace(error, boundary);
+        if (typeof error.stack !== "string")
+            return undefined;
+        const entry = error.stack.split("\n")[1]?.trim();
+        const match = entry && /(?:^at (?:async )?| \()((?:file:\/\/\/|\/|[A-Za-z]:[\\/]).*):(\d+):(\d+)\)?$/.exec(entry);
+        if (!match)
+            return undefined;
+        const file = match[1].startsWith("file:") ? fileURLToPath(match[1]) : match[1];
+        const roots = [process.env.SUPERCOV_PROJECT_ROOT, process.env.SUPERCOV_SOURCE_PROJECT_ROOT, process.cwd()].filter(Boolean);
+        for (const root of roots) {
+            const path = relative(root, file);
+            if (path !== ".." && !path.startsWith(`..${sep}`) && !/^(?:[A-Za-z]:|[\\/])/.test(path))
+                return `runtime-stack:${path.split(sep).join("/")}:${match[2]}:${match[3]}`;
+        }
+        return `runtime-stack:${file.split(sep).join("/")}:${match[2]}:${match[3]}`;
+    }
+    catch {
+        // Custom stack formatters must not change the user's assertion outcome.
         return undefined;
-    return entry.trim().replace(/^at\s+/, "");
+    }
 }
 function wrapAssertion(original, operation) {
     return new Proxy(original, {
-        apply(target, thisArgument, argumentsList) {
-            return withNodeAssertionPhase(operation, assertionSource(), () => Reflect.apply(target, thisArgument, argumentsList));
+        apply: function assertionApply(target, thisArgument, argumentsList) {
+            return withNodeAssertionPhase(operation, () => assertionSource(assertionApply), () => Reflect.apply(target, thisArgument, argumentsList));
         },
     });
 }

package/runtime/javascript/nodeTest.mjs

@@ -2,7 +2,7 @@ import * as native from "node:test";
 import { fileURLToPath } from "node:url";
 import vm from "node:vm";
 import { beginBufferedServerEvidence, flushBufferedServerEvidence, takeNodeAssertionPhases, withCoverageCarrier, } from "./runtime.mjs";
-import { callerLocation, runnerExecutionScope, writeRunnerEvidence, } from "./runnerEvidence.mjs";
+import { callerLocation, runnerExecutionScope, runnerTestId, writeRunnerEvidence, } from "./runnerEvidence.mjs";
 function callbackIndex(args) {
     for (let index = args.length - 1; index >= 0; index -= 1)
         if (typeof args[index] === "function")
@@ -86,16 +86,18 @@ function restoreUserError(error, depth = 0) {
     }
     return error;
 }
-function wrappedRegistration(original) {
+const registrationCounts = new Map();
+function wrappedRegistration(original, parentTestId) {
     const wrapped = function supercovNodeTest(...args) {
         const index = callbackIndex(args);
         if (index < 0)
             return Reflect.apply(original, this, args);
         const callback = args[index];
-        const location = callerLocation(/(?:nodeTest|runnerEvidence)\.[cm]?[jt]s/);
+        const location = callerLocation(supercovNodeTest);
         const identity = {
             runner: "node:test",
             name: testName(args, callback),
+            ...(parentTestId ? { parentTestId } : {}),
             ...location,
             // Source-map producers disagree about whether a call expression maps to
             // its first token or the first token on its source line. The line and
@@ -104,6 +106,12 @@ function wrappedRegistration(original) {
             // keeps one identity when esbuild, Babel, SWC, or TypeScript rewrites it.
             ...(location.line === undefined ? {} : { column: 1 }),
         };
+        // Allocate at registration, never callback completion: concurrent tests
+        // can finish in any order. Count each source/name within its parent.
+        const registrationKey = runnerTestId(identity);
+        const registrationOrdinal = registrationCounts.get(registrationKey) ?? 0;
+        registrationCounts.set(registrationKey, registrationOrdinal + 1);
+        identity.registrationOrdinal = registrationOrdinal;
         const scope = runnerExecutionScope(identity);
         const options = testOptions(args, index);
         const evidenceDirectory = process.env["SUPERCOV_EVIDENCE_DIR"];
@@ -129,7 +137,7 @@ function wrappedRegistration(original) {
                         };
                     }
                     if (property === "test" && typeof value === "function")
-                        return wrappedRegistration(value.bind(target));
+                        return wrappedRegistration(value.bind(target), scope.testId);
                     return typeof value === "function" ? value.bind(target) : value;
                 },
             });
@@ -192,7 +200,7 @@ function wrappedRegistration(original) {
             Object.defineProperty(wrapped, property, {
                 configurable: true,
                 enumerable: true,
-                value: wrappedRegistration(member),
+                value: wrappedRegistration(member, parentTestId),
             });
     }
     return wrapped;

package/runtime/javascript/runnerEvidence.mjs

@@ -27,13 +27,24 @@ function localFile(file) {
     return relative(process.cwd(), absolute).split(sep).join("/");
 }
 export function runnerTestId(identity) {
-    const key = [
+    const parts = [
         identity.runner,
         localFile(identity.file) ?? "unknown",
         identity.line ?? 0,
         identity.column ?? 0,
         identity.name,
-    ].join("\0");
+    ];
+    // Preserve existing top-level, uniquely registered test IDs. Nested tests
+    // and repeated registrations need more than a shared source/name identity.
+    if (identity.parentTestId)
+        parts.push("parent", identity.parentTestId);
+    if (identity.registrationOrdinal)
+        parts.push("registration", identity.registrationOrdinal);
+    // Titles can themselves contain separator text. Domain-separate and encode
+    // the extended identity structurally so it cannot alias a literal title.
+    const key = identity.parentTestId || identity.registrationOrdinal
+        ? JSON.stringify(["registration-v2", ...parts])
+        : parts.join("\0");
     return `${identity.runner}:${createHash("sha256").update(key).digest("hex").slice(0, 24)}`;
 }
 export function runnerExecutionScope(identity) {
@@ -50,24 +61,35 @@ export function runnerExecutionScope(identity) {
         testId,
         testKey,
         retry,
-        attemptId: `${testKey}-${retry}`,
+        // Different processes/worker threads can execute the same registration.
+        // Their files must not collide even though the stable test ID is shared.
+        attemptId: `${testKey}-${retry}-${processInstanceToken()}`,
     };
 }
-export function callerLocation(ignored) {
-    const lines = new Error().stack?.split("\n").slice(2) ?? [];
-    for (const entry of lines) {
-        if (ignored.test(entry) || entry.includes("node:internal"))
-            continue;
-        const match = /(?:\(|at\s+)(file:\/\/[^:)]+|(?:[A-Za-z]:)?[^():]+):(\d+):(\d+)\)?$/.exec(entry.trim());
+export function callerLocation(boundary = callerLocation) {
+    // Omit the registration wrapper by identity. A user file may have the same
+    // basename as a runtime adapter. Parse the location suffix, not individual
+    // path segments: spaces, parentheses and Unicode are valid filenames.
+    try {
+        const error = {};
+        Error.captureStackTrace(error, boundary);
+        if (typeof error.stack !== "string")
+            return {};
+        const entry = error.stack.split("\n")[1]?.trim();
+        const match = entry && /(?:^at (?:async )?| \()((?:file:\/\/|\/|[A-Za-z]:[\\/]|\\\\).*):(\d+):(\d+)\)?$/.exec(entry);
         if (!match)
-            continue;
+            return {};
         return {
             file: match[1],
             line: Number(match[2]),
             column: Number(match[3]),
         };
     }
-    return {};
+    catch {
+        // Custom formatters must not prevent registration. Missing provenance
+        // is explicit, never replaced with an unrelated deeper caller.
+        return {};
+    }
 }
 export function readScopedServerEvidence(scope, evidencePath = serverEvidencePath(scope)) {
     try {

package/runtime/javascript/runtime.mjs

@@ -721,9 +721,11 @@ function withCoverageCarrier(carrier, callback) {
 function assertionPhaseState(scope) {
   const key = attemptKey(scope);
   const existing = state.assertionPhases.get(key);
-  if (existing)
+  if (existing) {
+    existing.phaseIds ??= new Set(existing.phases.filter(phase => phase.kind === "assertion").map(phase => phase.id));
     return existing;
-  const created = { counter: 0, phases: [] };
+  }
+  const created = { counter: 0, phases: [], phaseIds: new Set() };
   state.assertionPhases.set(key, created);
   return created;
 }
@@ -753,9 +755,13 @@ function withNodeAssertionPhase(operation, source, callback) {
   const scope = context.scope;
   if (!scope)
     return callback();
-  const existing = context.phaseId ? assertionPhaseState(scope).phases.find((phase2) => phase2.id === context.phaseId && phase2.kind === "assertion") : void 0;
+  const existing = context.phaseId && assertionPhaseState(scope).phaseIds.has(context.phaseId);
   if (existing)
     return callback();
+  // The adapter's stack is only a fallback. Avoid formatting it when a lexical
+  // probe already supplied the active phase's exact original-source identity.
+  if (typeof source === "function")
+    source = source();
   const bridged = (_a8 = runtimeGlobal.__SUPERCOV_ASSERTION_PHASE_BRIDGE__) == null ? void 0 : _a8.call(runtimeGlobal, operation, source, callback);
   if (bridged == null ? void 0 : bridged.handled)
     return bridged.value;
@@ -768,6 +774,7 @@ function withNodeAssertionPhase(operation, source, callback) {
     startedAtMs: Date.now()
   });
   attempt.phases.push(phase);
+  attempt.phaseIds.add(phase.id);
   try {
     const result = withCoverageCarrier({ version: 1, scope, phaseId: phase.id }, callback);
     if (result && typeof result.then === "function")
@@ -785,6 +792,16 @@ function withNodeAssertionPhase(operation, source, callback) {
     throw cleanInstrumentationStack(error);
   }
 }
+// Resolve the target exactly once, before argument evaluation, just like a
+// native call reference. The closure carries only source identity and receiver;
+// it never captures an assertion phase or mutable current-statement state across
+// await. Rejected arguments therefore create no phase, and awaited producer work
+// is not retroactively attributed to the assertion invocation.
+function bindNodeAssertion(operation, source, receiver, method) {
+  const target = method === void 0 ? receiver : receiver[method];
+  const thisArgument = method === void 0 ? void 0 : receiver;
+  return (...args) => withNodeAssertionPhase(operation, source, () => Reflect.apply(target, thisArgument, args));
+}
 function takeNodeAssertionPhases(scope) {
   var _a8, _b;
   const key = attemptKey(scope);
@@ -1293,6 +1310,7 @@ const directRuntimeApi = {
   selectionEnd,
   selectionRight,
   takeNodeAssertionPhases,
+  bindNodeAssertion,
   testStatement,
   tryBegin,
   tryCatch,
@@ -1343,6 +1361,7 @@ export {
   selectionEnd,
   selectionRight,
   takeNodeAssertionPhases,
+  bindNodeAssertion,
   testStatement,
   tryBegin,
   tryCatch,