supercov 0.0.45 → 0.0.46

package/runtime/javascript/nodeTest.mjs

@@ -87,7 +87,7 @@ function restoreUserError(error, depth = 0) {
     return error;
 }
 const registrationCounts = new Map();
-function wrappedRegistration(original, parentTestId) {
+function wrappedRegistration(original, parentTestId, forcedStatus) {
     const wrapped = function supercovNodeTest(...args) {
         const index = callbackIndex(args);
         if (index < 0)
@@ -115,13 +115,15 @@ function wrappedRegistration(original, parentTestId) {
         const scope = runnerExecutionScope(identity);
         const options = testOptions(args, index);
         const evidenceDirectory = process.env["SUPERCOV_EVIDENCE_DIR"];
+        if (options?.skip || options?.todo || forcedStatus)
+            writeRunnerEvidence(identity, "skipped", scope, evidenceDirectory);
         const next = [...args];
         const execute = (callbackThis, context, done) => {
             // A test or its hooks may intentionally modify Supercov's public
             // environment while testing integrations. Keep this attempt's transport
             // destination fixed to the value present when the test was registered.
             beginBufferedServerEvidence(scope);
-            let status = options?.skip || options?.todo
+            let status = options?.skip || options?.todo || forcedStatus
                 ? "skipped"
                 : "passed";
             const contextProxy = new Proxy(context, {
@@ -138,6 +140,8 @@ function wrappedRegistration(original, parentTestId) {
                     }
                     if (property === "test" && typeof value === "function")
                         return wrappedRegistration(value.bind(target), scope.testId);
+                    if (["after", "before", "afterEach", "beforeEach"].includes(property) && typeof value === "function")
+                        return restoringHook(value.bind(target), scope);
                     return typeof value === "function" ? value.bind(target) : value;
                 },
             });
@@ -149,6 +153,11 @@ function wrappedRegistration(original, parentTestId) {
                 const flushedServerEvidence = flushBufferedServerEvidence(scope);
                 writeRunnerEvidence(identity, nextStatus, scope, evidenceDirectory, takeNodeAssertionPhases(scope), flushedServerEvidence);
             };
+            const finishBody = () => {
+                // User t.after callbacks run after the body. Register last so
+                // their assertions and cleanup probes are part of this attempt.
+                context.after(() => emit());
+            };
             try {
                 if (callback.length >= 2) {
                     const callbackDone = (error) => {
@@ -156,7 +165,7 @@ function wrappedRegistration(original, parentTestId) {
                             status = "failed";
                             restoreUserError(error);
                         }
-                        emit();
+                        finishBody();
                         done?.(error);
                     };
                     return withCoverageCarrier({ version: 1, scope }, () => Reflect.apply(callback, callbackThis, [contextProxy, callbackDone]));
@@ -164,19 +173,19 @@ function wrappedRegistration(original, parentTestId) {
                 const result = withCoverageCarrier({ version: 1, scope }, () => Reflect.apply(callback, callbackThis, [contextProxy]));
                 if (result && typeof result.then === "function")
                     return Promise.resolve(result).then((value) => {
-                        emit();
+                        finishBody();
                         return value;
                     }, (error) => {
                         status = "failed";
-                        emit();
+                        finishBody();
                         throw restoreUserError(error);
                     });
-                emit();
+                finishBody();
                 return result;
             }
             catch (error) {
                 status = "failed";
-                emit();
+                finishBody();
                 throw restoreUserError(error);
             }
         };
@@ -200,45 +209,52 @@ function wrappedRegistration(original, parentTestId) {
             Object.defineProperty(wrapped, property, {
                 configurable: true,
                 enumerable: true,
-                value: wrappedRegistration(member, parentTestId),
+                value: wrappedRegistration(member, parentTestId, property === "only" ? undefined : "skipped"),
             });
     }
     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) {
+// Shared hooks get their own setup scope. Their execution is visible but is
+// never silently copied into every test. t.after and other per-test hooks keep
+// the exact owning attempt supplied by the TestContext proxy.
+function restoringHook(original, scope, hookName = "hook") {
     return function supercovNodeTestHook(...args) {
         const index = callbackIndex(args);
-        if (index < 0)
-            return Reflect.apply(original, this, args);
+        if (index < 0) return Reflect.apply(original, this, args);
         const callback = args[index];
+        const location = callerLocation(supercovNodeTestHook);
+        let invocation = 0;
+        const execute = (receiver, context, done) => {
+            const identity = { runner: "node:test", role: "setup", name: `[${hookName}] ${callback.name || "anonymous"}`,
+                ...location, registrationOrdinal: invocation++ };
+            const owner = scope ?? runnerExecutionScope(identity);
+            const evidenceDirectory = process.env["SUPERCOV_EVIDENCE_DIR"];
+            if (!scope) beginBufferedServerEvidence(owner);
+            let emitted = false;
+            const finish = error => {
+                if (scope || emitted) return;
+                emitted = true;
+                writeRunnerEvidence(identity, error ? "failed" : "passed", owner, evidenceDirectory,
+                    takeNodeAssertionPhases(owner), flushBufferedServerEvidence(owner));
+            };
+            try {
+                const result = withCoverageCarrier({ version: 1, scope: owner }, () =>
+                    callback.length >= 2 ? callback.call(receiver, context, error => {
+                        finish(error);
+                        done?.(error ? restoreUserError(error) : undefined);
+                    }) : callback.call(receiver, context));
+                if (callback.length >= 2) return result;
+                if (result && typeof result.then === "function")
+                    return Promise.resolve(result).then(value => { finish(); return value; },
+                        error => { finish(error); throw restoreUserError(error); });
+                finish();
+                return result;
+            } catch (error) { finish(error); throw restoreUserError(error); }
+        };
         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);
-                }
-            };
+            ? function supercovNodeTestHookDoneCallback(context, done) { return execute(this, context, done); }
+            : function supercovNodeTestHookCallback(context) { return execute(this, context); };
         return Reflect.apply(original, this, next);
     };
 }
@@ -246,10 +262,10 @@ 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 = restoringHook(native.before);
-export const after = restoringHook(native.after);
-export const beforeEach = restoringHook(native.beforeEach);
-export const afterEach = restoringHook(native.afterEach);
+export const before = restoringHook(native.before, undefined, "before");
+export const after = restoringHook(native.after, undefined, "after");
+export const beforeEach = restoringHook(native.beforeEach, undefined, "beforeEach");
+export const afterEach = restoringHook(native.afterEach, undefined, "afterEach");
 export const mock = native.mock;
 export const snapshot = native.snapshot;
 export const run = native.run;

package/runtime/javascript/provenance.mjs

@@ -7,7 +7,10 @@ const NORMALIZED_KINDS = [
 function classifiedKind(value) {
     if (!value)
         return undefined;
-    return NORMALIZED_KINDS.find(([, pattern]) => pattern.test(value))?.[0];
+    // gatewayE2e.test.ts and responseIntegration.test.ts are conventional
+    // camel-case paths too. Do not infer kinds from test titles or API usage.
+    const words = value.replace(/([a-z0-9])([A-Z])/g, "$1-$2");
+    return NORMALIZED_KINDS.find(([, pattern]) => pattern.test(words))?.[0];
 }
 export function inferTestProvenance({ runner, file, project, explicitKind, }) {
     if (explicitKind?.trim()) {

package/runtime/javascript/register.mjs

@@ -69,17 +69,21 @@ if (verboseDiagnostics && !process.__SUPERCOV_DIAGNOSTIC_REPORTER__) {
         });
     }
 }
-// Runner adapters and instrumented modules import the runtime when they need
-// it. Keeping the preload itself thin avoids evaluating the full collector in
-// npm launchers, web-server supervisors, and other Node children that never
-// execute measured JavaScript.
-if (process.env.SUPERCOV_DURABLE_EVIDENCE_EACH_TEST === "1") {
+// Direct instrumentation must initialize the collector before script files
+// with no import boundary evaluate. Other modes let the runner adapter or an
+// instrumented module load it, except when durable remote evidence requires it.
+if (process.env.SUPERCOV_DURABLE_EVIDENCE_EACH_TEST === "1" ||
+    process.env.SUPERCOV_DIRECT_INSTRUMENTATION === "1") {
     // A translated remote/VM command can execute an ahead-of-run transformed
     // test through an opaque runner that bypasses the ordinary Playwright or
     // node:test import boundary. The remote-launch adapter marks that process;
     // initialize the runtime before its transformed module can evaluate.
     globalThis.__SUPERCOV_DIRECT_RUNTIME__ ??= await import("./runtime.mjs");
     process.__SUPERCOV_DIRECT_RUNTIME__ ??= globalThis.__SUPERCOV_DIRECT_RUNTIME__;
+    // Generic builds can contain script files with no import/export syntax.
+    // They cannot import the collector without changing their module semantics,
+    // and may evaluate before any ESM instrumented file imports it.
+    globalThis.__supercovRuntime ??= globalThis.__SUPERCOV_DIRECT_RUNTIME__;
 }
 // Workers are independent Node processes and an explicit `execArgv: []`
 // otherwise strips the preload that supplies the isolated runtime. Preserve

package/runtime/javascript/runnerEvidence.mjs

@@ -36,13 +36,15 @@ export function runnerTestId(identity) {
     ];
     // Preserve existing top-level, uniquely registered test IDs. Nested tests
     // and repeated registrations need more than a shared source/name identity.
+    if (identity.role === "setup")
+        parts.push("role", "setup");
     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
+    const key = identity.role === "setup" || identity.parentTestId || identity.registrationOrdinal
         ? JSON.stringify(["registration-v2", ...parts])
         : parts.join("\0");
     return `${identity.runner}:${createHash("sha256").update(key).digest("hex").slice(0, 24)}`;
@@ -116,6 +118,7 @@ export function writeRunnerEvidence(identity, status, scope, evidenceDirectoryOv
         title: identity.name.split(" > ").at(-1) ?? identity.name,
         retry: identity.retry ?? 0,
         status,
+        ...(identity.role ? { role: identity.role } : {}),
         provenance: inferTestProvenance({
             runner: identity.runner,
             file: testFile,

package/runtime/javascript/runtime.mjs

@@ -963,15 +963,56 @@ function requestCoverageContext(value) {
   const phaseId = typeof rawPhaseId === "string" && rawPhaseId.length > 0 && (!scope || phaseBelongsToAttempt(rawPhaseId, scope.attemptId)) ? rawPhaseId : void 0;
   return __spreadValues(__spreadValues({}, scope ? { scope } : {}), phaseId ? { phaseId } : {});
 }
-function withRequestPhase(handler) {
+// Keep connection ownership on the emitter, without changing listener
+// identity (removeListener/off and once still see the original callbacks).
+const emitterContextMaps = runtimeGlobal.__SUPERCOV_EMITTER_CONTEXT_MAPS__ ??= new Map();
+const emitterCoverageContexts = emitterContextMaps.get(runtimeInstance) ?? new WeakMap();
+emitterContextMaps.set(runtimeInstance, emitterCoverageContexts);
+const patchedEmitterInstances = runtimeGlobal.__SUPERCOV_EMITTER_PATCHED_INSTANCES__ ??= new Set();
+function installNodeRequestPropagation() {
+  if (isBrowser || patchedEmitterInstances.has(runtimeInstance) || typeof process === "undefined") return;
+  const EventEmitter = process.getBuiltinModule?.("node:events")?.EventEmitter;
+  const Server = process.getBuiltinModule?.("node:http")?.Server;
+  const SecureServer = process.getBuiltinModule?.("node:https")?.Server;
+  if (!EventEmitter) return;
+  const original = EventEmitter.prototype.emit;
+  EventEmitter.prototype.emit = function(event, ...args) {
+    let context = emitterCoverageContexts.get(this);
+    if ((event === "request" || event === "upgrade") &&
+        ((Server && this instanceof Server) || (SecureServer && this instanceof SecureServer))) {
+      // HTTP headers establish ownership even when Express/SDK listeners and
+      // the server process were created by a shared before hook.
+      const incoming = requestCoverageContext(args[0]);
+      if (incoming) context = incoming.scope ? incoming : context ?? currentRequestContext();
+    }
+    const invoke = () => Reflect.apply(original, this, [event, ...args]);
+    try {
+      return context ? withCoverageCarrier({ version: 1, ...context }, invoke) : invoke();
+    } finally {
+      if (event === "close") emitterCoverageContexts.delete(this);
+    }
+  };
+  patchedEmitterInstances.add(runtimeInstance);
+}
+installNodeRequestPropagation();
+
+function withRequestPhase(handler, event) {
   if (!serverPhaseStorage)
     return handler;
+  const registeredContext = currentRequestContext();
   return function coverageRequestPhase(...args) {
     var _a8, _b, _c, _d;
     const requestContext = args.map((argument) => requestCoverageContext(argument)).find((context2) => context2 !== void 0);
-    const inheritedContext = requestContext === void 0 ? currentRequestContext() : {};
+    // An untagged request to a test-owned server must not erase that server's
+    // owner. Shared servers have no captured test scope and stay unattributed.
+    const inheritedContext = requestContext?.scope ? {} : registeredContext.scope ? registeredContext : requestContext === void 0 ? currentRequestContext() : {};
     const context = __spreadValues(__spreadValues({}, ((_a8 = requestContext == null ? void 0 : requestContext.scope) != null ? _a8 : inheritedContext.scope) ? { scope: (_b = requestContext == null ? void 0 : requestContext.scope) != null ? _b : inheritedContext.scope } : {}), ((_c = requestContext == null ? void 0 : requestContext.phaseId) != null ? _c : inheritedContext.phaseId) ? { phaseId: (_d = requestContext == null ? void 0 : requestContext.phaseId) != null ? _d : inheritedContext.phaseId } : {});
-    const invoke = () => Reflect.apply(handler, this, args);
+    const invoke = () => {
+      if (event === "connection" && context.scope && args[0] &&
+          typeof args[0] === "object" && typeof args[0].emit === "function")
+        emitterCoverageContexts.set(args[0], context);
+      return Reflect.apply(handler, this, args);
+    };
     return requestContext !== void 0 || context.scope || context.phaseId ? serverPhaseStorage.run(context, () => withProbeV2Context(context, invoke)) : invoke();
   };
 }