supercov 0.0.20 → 0.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supercov",
-  "version": "0.0.20",
+  "version": "0.0.21",
   "description": "Zero-edit, runner-aware coverage completeness for JavaScript test suites",
   "license": "MIT",
   "repository": {
@@ -68,12 +68,12 @@
     "prepublishOnly": "npm run release:check"
   },
   "optionalDependencies": {
-    "@supercov/cli-darwin-arm64": "0.0.20",
-    "@supercov/cli-darwin-x64": "0.0.20",
-    "@supercov/cli-linux-arm64-gnu": "0.0.20",
-    "@supercov/cli-linux-arm64-musl": "0.0.20",
-    "@supercov/cli-linux-x64-gnu": "0.0.20",
-    "@supercov/cli-linux-x64-musl": "0.0.20"
+    "@supercov/cli-darwin-arm64": "0.0.21",
+    "@supercov/cli-darwin-x64": "0.0.21",
+    "@supercov/cli-linux-arm64-gnu": "0.0.21",
+    "@supercov/cli-linux-arm64-musl": "0.0.21",
+    "@supercov/cli-linux-x64-gnu": "0.0.21",
+    "@supercov/cli-linux-x64-musl": "0.0.21"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.55.0",

package/runtime/javascript/launchSupervisor.js

@@ -195,7 +195,7 @@ export function guestCoverageEnvironment(mapping, coverageEnvironment = process.
         key,
         value === undefined ? value : replaceRoot(value, mapping),
     ]));
-    const registerUrl = pathToFileURL(resolve(mapping.guestRoot, ".supercov/register.mjs")).href;
+    const registerUrl = pathToFileURL(resolve(mapping.guestRoot, ".supercov/node_modules/register.mjs")).href;
     return {
         ...existingEnvironment,
         ...translated,

package/runtime/javascript/nodeTest.js

@@ -1,4 +1,6 @@
 import * as native from "node:test";
+import { fileURLToPath } from "node:url";
+import vm from "node:vm";
 import { beginBufferedServerEvidence, flushBufferedServerEvidence, takeNodeAssertionPhases, withCoverageCarrier, } from "./runtime.js";
 import { callerLocation, runnerExecutionScope, writeRunnerEvidence, } from "./runnerEvidence.js";
 function callbackIndex(args) {
@@ -14,6 +16,76 @@ function testOptions(args, index) {
     const candidate = args.slice(0, index).find((value) => value && typeof value === "object" && !Array.isArray(value));
     return candidate;
 }
+// node:test derives a test's reported location from the direct caller of the
+// registration call, and the adapter is that caller: every failing test
+// reported "test at .../nodeTest.js". A compiled trampoline carrying the
+// user's call site as its script origin registers the test instead, so the
+// runner sees the location a direct call would have produced. The padded
+// second line puts the call expression at the user's exact line and column.
+const registrationSites = new Map();
+function registrationAt(location) {
+    if (!location.file ||
+        location.line === undefined ||
+        location.column === undefined ||
+        location.line < 2)
+        return undefined;
+    const key = `${location.file}:${location.line}:${location.column}`;
+    let site = registrationSites.get(key);
+    if (site === undefined) {
+        try {
+            const filename = location.file.startsWith("file://")
+                ? fileURLToPath(location.file)
+                : location.file;
+            site = vm.compileFunction(`return (\n${" ".repeat(Math.max(0, location.column - 1))}original(...args));`, ["original", "args"], { filename, lineOffset: location.line - 2 });
+        }
+        catch {
+            site = null;
+        }
+        registrationSites.set(key, site);
+    }
+    return site ?? undefined;
+}
+// A failing test's stack was captured while Supercov's wrappers were on the
+// call path and while the code ran inside the mirrored workspace. Neither is
+// part of the user's program: drop adapter frames and map workspace paths
+// back to the source project so the report matches an uninstrumented run.
+const restoredErrors = new WeakSet();
+function restoreUserError(error, depth = 0) {
+    if (depth > 4 ||
+        !error ||
+        typeof error !== "object" ||
+        restoredErrors.has(error))
+        return error;
+    restoredErrors.add(error);
+    const workspaceRoot = process.env["SUPERCOV_PROJECT_ROOT"];
+    const sourceRoot = process.env["SUPERCOV_SOURCE_PROJECT_ROOT"];
+    const remap = (text) => workspaceRoot && sourceRoot && workspaceRoot !== sourceRoot
+        ? text.split(workspaceRoot).join(sourceRoot)
+        : text;
+    try {
+        if (typeof error.stack === "string")
+            error.stack = remap(error.stack
+                .split("\n")
+                .filter((line) => !(line.trimStart().startsWith("at ") &&
+                line.includes("/.supercov/")))
+                .join("\n"));
+        if (typeof error.message === "string")
+            error.message = remap(error.message);
+    }
+    catch {
+        // Frozen or accessor-backed errors keep their original form.
+    }
+    try {
+        restoreUserError(error.cause, depth + 1);
+        if (Array.isArray(error.errors))
+            for (const aggregated of error.errors)
+                restoreUserError(aggregated, depth + 1);
+    }
+    catch {
+        // A throwing accessor never replaces the user's error.
+    }
+    return error;
+}
 function wrappedRegistration(original) {
     const wrapped = function supercovNodeTest(...args) {
         const index = callbackIndex(args);
@@ -72,8 +144,10 @@ function wrappedRegistration(original) {
             try {
                 if (callback.length >= 2) {
                     const callbackDone = (error) => {
-                        if (error)
+                        if (error) {
                             status = "failed";
+                            restoreUserError(error);
+                        }
                         emit();
                         done?.(error);
                     };
@@ -87,7 +161,7 @@ function wrappedRegistration(original) {
                     }, (error) => {
                         status = "failed";
                         emit();
-                        throw error;
+                        throw restoreUserError(error);
                     });
                 emit();
                 return result;
@@ -95,7 +169,7 @@ function wrappedRegistration(original) {
             catch (error) {
                 status = "failed";
                 emit();
-                throw error;
+                throw restoreUserError(error);
             }
         };
         // node:test uses callback arity to distinguish promise/synchronous tests
@@ -107,6 +181,9 @@ function wrappedRegistration(original) {
             : function supercovNodeTestCallback(context) {
                 return execute(this, context);
             };
+        const registration = registrationAt(location);
+        if (registration)
+            return registration(this === undefined ? original : original.bind(this), next);
         return Reflect.apply(original, this, next);
     };
     for (const property of ["skip", "todo", "only"]) {
@@ -120,14 +197,51 @@ function wrappedRegistration(original) {
     }
     return wrapped;
 }
+// Hooks carry no coverage evidence, but an error thrown inside one still
+// reaches the report with the adapter's execution context in its stack.
+// Restore it at the same boundary the test wrapper uses.
+function restoringHook(original) {
+    return function supercovNodeTestHook(...args) {
+        const index = callbackIndex(args);
+        if (index < 0)
+            return Reflect.apply(original, this, args);
+        const callback = args[index];
+        const next = [...args];
+        // node:test uses callback arity to distinguish promise/synchronous
+        // hooks from the legacy done-callback form. Preserve it exactly.
+        next[index] = callback.length >= 2
+            ? function supercovNodeTestHookDoneCallback(context, done) {
+                const restoringDone = (error) => {
+                    if (error)
+                        restoreUserError(error);
+                    done?.(error);
+                };
+                return callback.call(this, context, restoringDone);
+            }
+            : function supercovNodeTestHookCallback(context) {
+                try {
+                    const result = callback.call(this, context);
+                    if (result && typeof result.then === "function")
+                        return Promise.resolve(result).then(undefined, (error) => {
+                            throw restoreUserError(error);
+                        });
+                    return result;
+                }
+                catch (error) {
+                    throw restoreUserError(error);
+                }
+            };
+        return Reflect.apply(original, this, next);
+    };
+}
 export const test = wrappedRegistration(native.test);
 export const it = wrappedRegistration(native.it);
 export const suite = native.suite;
 export const describe = native.describe;
-export const before = native.before;
-export const after = native.after;
-export const beforeEach = native.beforeEach;
-export const afterEach = native.afterEach;
+export const before = restoringHook(native.before);
+export const after = restoringHook(native.after);
+export const beforeEach = restoringHook(native.beforeEach);
+export const afterEach = restoringHook(native.afterEach);
 export const mock = native.mock;
 export const snapshot = native.snapshot;
 export const run = native.run;

package/runtime/javascript/register.mjs

@@ -82,7 +82,7 @@ if (process.env.SUPERCOV_DURABLE_EVIDENCE_EACH_TEST === "1") {
 const workerThreads = Module._load("node:worker_threads", undefined, false);
 const NativeWorker = workerThreads.Worker;
 const registerArgument = `--import=${new URL("./register.mjs", import.meta.url).href}`;
-const appendRegister = values => values.some(value => value === registerArgument || value.includes("/.supercov/register.mjs"))
+const appendRegister = values => values.some(value => value === registerArgument || value.includes("/.supercov/node_modules/register.mjs"))
     ? values
     : [...values, registerArgument];
 workerThreads.Worker = class SupercovWorker extends NativeWorker {

package/runtime/javascript/resolve-loader.mjs

@@ -4,7 +4,7 @@ const GENERATED_TARGET = "__SUPERCOV_PLAYWRIGHT_MODULE__";
 const TARGET = process.env.SUPERCOV_PLAYWRIGHT_MODULE ??
     (GENERATED_TARGET.startsWith("__") ? "@playwright/test" : GENERATED_TARGET);
 const REPLACEMENT = process.env.SUPERCOV_PLAYWRIGHT_WRAPPER ??
-    "./.supercov/playwright.js";
+    "./.supercov/node_modules/playwright.js";
 const PROJECT_ROOT = process.env.SUPERCOV_PROJECT_ROOT;
 const ORIGINAL_CONFIG = process.env.SUPERCOV_ORIGINAL_PLAYWRIGHT_CONFIG;
 function belongsToProject(parentURL) {
@@ -29,7 +29,7 @@ export async function resolve(specifier, context, nextResolve) {
     // source-local copy keeps strict rootDir compilers happy; this fallback
     // resolves the emitted import to Supercov's generated runtime without
     // requiring the project's build to copy our helper directory.
-    if (specifier.endsWith("/.supercov/runtime.js") &&
+    if (specifier.endsWith("/.supercov/node_modules/runtime.js") &&
         belongsToProject(context.parentURL)) {
         return {
             url: new URL("./runtime.js", import.meta.url).href,