supercov 0.0.9 → 0.0.12

package/{dist → runtime/javascript}/playwright.js

@@ -105,6 +105,7 @@ class CoveragePhaseController {
     pendingRegistrations = new Set();
     scriptUpdate = Promise.resolve();
     proxyCache = new WeakMap();
+    runtimeSnapshots;
     // Parameter properties are stateful despite the base ESLint rule treating
     // this as an empty constructor.
     // eslint-disable-next-line no-useless-constructor
@@ -118,6 +119,41 @@ class CoveragePhaseController {
     allWorkers() {
         return [...this.workers];
     }
+    async collectRuntimeSnapshots() {
+        if (this.runtimeSnapshots)
+            return this.runtimeSnapshots;
+        const snapshots = [];
+        for (const page of this.allPages()) {
+            for (const frame of page.frames()) {
+                const snapshot = await frame
+                    .evaluate(() => {
+                    const getSnapshot = globalThis.__SUPERCOV_COVERAGE_SNAPSHOT__;
+                    return getSnapshot?.() ?? { decisions: [], hits: [], events: [] };
+                })
+                    .catch(() => ({
+                    decisions: [],
+                    hits: [],
+                    events: [],
+                }));
+                snapshots.push(snapshot);
+            }
+        }
+        for (const worker of this.allWorkers()) {
+            const snapshot = await worker
+                .evaluate(() => {
+                const getSnapshot = globalThis.__SUPERCOV_COVERAGE_SNAPSHOT__;
+                return getSnapshot?.() ?? { decisions: [], hits: [], events: [] };
+            })
+                .catch(() => ({
+                decisions: [],
+                hits: [],
+                events: [],
+            }));
+            snapshots.push(snapshot);
+        }
+        this.runtimeSnapshots = snapshots;
+        return snapshots;
+    }
     async registerPage(page) {
         if (this.pages.has(page))
             return;
@@ -190,6 +226,7 @@ class CoveragePhaseController {
             globalThis.__SUPERCOV_MCDC_TEST_ID__ = attemptId;
             if (phase)
                 globalThis.__SUPERCOV_PHASE_ID__ = phase;
+            globalThis.__SUPERCOV_ACTIVATE_PROBE_CONTEXT__?.(attemptId, phase);
             const originalFetch = globalThis.fetch?.bind(globalThis);
             if (!originalFetch)
                 return;
@@ -217,8 +254,8 @@ class CoveragePhaseController {
         await this.activateInBrowser(phase.id);
         return phase;
     }
-    beginAssertion(operation) {
-        const phase = this.createPhase("assertion", operation, this.lastActionId);
+    beginAssertion(operation, source = callerSource()) {
+        const phase = this.createPhase("assertion", operation, this.lastActionId, source);
         this.activePhaseId = phase.id;
         // Playwright queues browser protocol commands in order. Starting this
         // evaluation before an async locator assertion is sufficient to tag its
@@ -294,8 +331,7 @@ class CoveragePhaseController {
         this.proxyCache.set(target, proxy);
         return proxy;
     }
-    createPhase(kind, operation, causedByPhaseId) {
-        const source = callerSource();
+    createPhase(kind, operation, causedByPhaseId, source = callerSource()) {
         const phase = {
             id: `${this.scope.attemptId}:phase:${++this.counter}`,
             kind,
@@ -369,6 +405,8 @@ class CoveragePhaseController {
         await Promise.all([...this.pages].flatMap((page) => page.frames()).map((frame) => frame
             .evaluate(({ id, storageKey, scopeCookie, scopeValue, phaseCookie }) => {
             globalThis.__SUPERCOV_PHASE_ID__ = id;
+            const coverageGlobal = globalThis;
+            coverageGlobal.__SUPERCOV_ACTIVATE_PROBE_CONTEXT__?.(coverageGlobal.__SUPERCOV_MCDC_TEST_ID__ ?? "unscoped", id);
             try {
                 localStorage.setItem(storageKey, id);
                 document.cookie = `${scopeCookie}=${encodeURIComponent(scopeValue)}; Path=/; SameSite=Lax`;
@@ -387,7 +425,9 @@ class CoveragePhaseController {
             .catch(() => undefined)));
         await Promise.all([...this.workers].map((worker) => worker
             .evaluate((id) => {
-            globalThis.__SUPERCOV_PHASE_ID__ = id;
+            const coverageGlobal = globalThis;
+            coverageGlobal.__SUPERCOV_PHASE_ID__ = id;
+            coverageGlobal.__SUPERCOV_ACTIVATE_PROBE_CONTEXT__?.(coverageGlobal.__SUPERCOV_MCDC_TEST_ID__ ?? "unscoped", id);
         }, phaseId)
             .catch(() => undefined)));
         await Promise.all([...this.pages].map((page) => this.activatePage(page, phaseId)));
@@ -414,7 +454,7 @@ class CoveragePhaseController {
             }
             const installed = (await cdp
                 .send("Page.addScriptToEvaluateOnNewDocument", {
-                source: `globalThis.__SUPERCOV_PHASE_ID__=${JSON.stringify(phaseId)};`,
+                source: `globalThis.__SUPERCOV_PHASE_ID__=${JSON.stringify(phaseId)};globalThis.__SUPERCOV_ACTIVATE_PROBE_CONTEXT__?.(globalThis.__SUPERCOV_MCDC_TEST_ID__??"unscoped",${JSON.stringify(phaseId)});`,
                 runImmediately: true,
             })
                 .catch(() => undefined));
@@ -425,7 +465,40 @@ class CoveragePhaseController {
     }
 }
 let activeController;
+let bridgedAssertionDepth = 0;
 const controllers = new Map();
+const directRuntime = () => globalThis.__SUPERCOV_DIRECT_RUNTIME__;
+globalThis.__SUPERCOV_ASSERTION_PHASE_BRIDGE__ = (operation, source, callback) => {
+    const controller = activeController;
+    const runtime = directRuntime();
+    if (!controller || !runtime)
+        return { handled: false };
+    const phase = controller.beginAssertion(operation, source);
+    bridgedAssertionDepth += 1;
+    try {
+        const value = runtime.withCoverageCarrier({ version: 1, scope: controller.scope, phaseId: phase.id }, callback);
+        bridgedAssertionDepth -= 1;
+        if (value &&
+            typeof value.then === "function")
+            return {
+                handled: true,
+                value: Promise.resolve(value).then((resolved) => {
+                    controller.finish(phase);
+                    return resolved;
+                }, (error) => {
+                    controller.finish(phase, error);
+                    throw error;
+                }),
+            };
+        controller.finish(phase);
+        return { handled: true, value };
+    }
+    catch (error) {
+        bridgedAssertionDepth -= 1;
+        controller.finish(phase, error);
+        throw error;
+    }
+};
 function activeCoverageHeaders() {
     const controller = activeController;
     if (!controller)
@@ -572,7 +645,9 @@ function wrapMatchers(matchers, path = "expect") {
                 return value;
             return (...args) => {
                 const controller = activeController;
-                const phase = controller?.beginAssertion(`${path}.${name}`);
+                const phase = bridgedAssertionDepth === 0
+                    ? controller?.beginAssertion(`${path}.${name}`)
+                    : undefined;
                 try {
                     const result = Reflect.apply(value, target, args);
                     if (result instanceof Promise) {
@@ -663,22 +738,51 @@ function readServerRecords(scope) {
         return [];
     }
 }
+function phaseSourceLine(source) {
+    return source?.replace(/:\d+$/, "");
+}
+/**
+ * Playwright's redirected `expect` is the preferred assertion boundary, but
+ * its transform loader can bypass Node's resolve hook for project-owned
+ * fixture modules. The ahead-of-run frontend therefore keeps a lexical
+ * fallback. If both paths observe the same assertion, retain the richer
+ * Playwright phase (including action causality) exactly once.
+ */
+function mergeCollectedPhases(controllerPhases, fallbackPhases) {
+    const observed = new Map();
+    for (const phase of controllerPhases) {
+        if (phase.kind !== "assertion")
+            continue;
+        const key = `${phase.operation}\0${phaseSourceLine(phase.source) ?? ""}`;
+        observed.set(key, (observed.get(key) ?? 0) + 1);
+    }
+    const remaining = fallbackPhases.filter((phase) => {
+        if (phase.kind !== "assertion")
+            return true;
+        const key = `${phase.operation}\0${phaseSourceLine(phase.source) ?? ""}`;
+        const count = observed.get(key) ?? 0;
+        if (count === 0)
+            return true;
+        observed.set(key, count - 1);
+        return false;
+    });
+    return [...controllerPhases, ...remaining];
+}
 const instrumentedTest = base.extend({
     page: async ({ page }, use, testInfo) => {
         const scope = executionScope(testInfo);
-        const configuredHeaders = Object.fromEntries(Object.entries(testInfo.project.use.extraHTTPHeaders ?? {}).map(([name, value]) => [name, String(value)]));
-        const controller = new CoveragePhaseController(scope, configuredHeaders);
-        controllers.set(scope.attemptId, controller);
-        activeController = controller;
+        const controller = controllers.get(scope.attemptId);
+        if (!controller)
+            throw new Error(`Supercov's automatic Playwright collector was not initialized for ${scope.attemptId}`);
         await controller.registerPage(page);
         try {
             await use(controller.wrap(page));
         }
         finally {
-            await controller.dispose();
-            if (activeController === controller)
-                activeController = undefined;
-            controllers.delete(scope.attemptId);
+            // This fixture still owns a live page. The automatic test fixture tears
+            // down after page dependencies and therefore cannot reliably evaluate
+            // frames on every Playwright version.
+            await controller.collectRuntimeSnapshots();
         }
     },
     browser: [
@@ -705,8 +809,13 @@ const instrumentedTest = base.extend({
         }));
     },
     mcdcAutoCollect: [
-        async ({ page }, use, testInfo) => {
+        async ({}, use, testInfo) => {
             const scope = executionScope(testInfo);
+            const configuredHeaders = Object.fromEntries(Object.entries(testInfo.project.use.extraHTTPHeaders ?? {}).map(([name, value]) => [name, String(value)]));
+            const controller = new CoveragePhaseController(scope, configuredHeaders);
+            controllers.set(scope.attemptId, controller);
+            activeController = controller;
+            directRuntime()?.activateCoverageScope(scope);
             const serverOutput = serverEvidencePath(scope);
             mkdirSync(serverEvidenceDirectory(scope), { recursive: true });
             rmSync(serverOutput, { force: true });
@@ -714,81 +823,60 @@ const instrumentedTest = base.extend({
                 await use();
             }
             finally {
-                const controller = controllers.get(scope.attemptId);
-                const browser = [];
-                const pages = controller?.allPages() ?? [page];
-                for (const currentPage of pages) {
-                    for (const frame of currentPage.frames()) {
-                        const frameSnapshot = await frame
-                            .evaluate(() => {
-                            const getSnapshot = globalThis.__SUPERCOV_COVERAGE_SNAPSHOT__;
-                            return getSnapshot?.() ?? { decisions: [], hits: [], events: [] };
-                        })
-                            .catch(() => ({
-                            decisions: [],
-                            hits: [],
-                            events: [],
-                        }));
-                        browser.push(frameSnapshot);
+                try {
+                    const browser = await controller.collectRuntimeSnapshots();
+                    const server = readServerRecords(scope);
+                    // Emit an artifact even when this test touched no application source.
+                    // A complete test-to-coverage matrix must also identify tests that are
+                    // removable without changing coverage.
+                    const outputPath = testInfo.outputPath("mcdc.json");
+                    mkdirSync(dirname(outputPath), { recursive: true });
+                    const testFile = relative(process.cwd(), testInfo.file)
+                        .split(sep)
+                        .join("/");
+                    const payload = {
+                        testId: testInfo.testId,
+                        scope,
+                        test: testInfo.titlePath.join(" > "),
+                        testFile,
+                        title: testInfo.title,
+                        retry: testInfo.retry,
+                        status: testInfo.status ?? "unknown",
+                        expectedStatus: testInfo.expectedStatus,
+                        provenance: inferTestProvenance({
+                            runner: "playwright",
+                            file: testFile,
+                            project: testInfo.project.name,
+                            explicitKind: process.env["SUPERCOV_TEST_KIND"],
+                        }),
+                        phases: mergeCollectedPhases(controller.phases, directRuntime()?.takeNodeAssertionPhases(scope) ?? []),
+                        browser,
+                        server,
+                    };
+                    const serialized = `${JSON.stringify(payload)}\n`;
+                    atomicWriteFileSync(outputPath, serialized);
+                    // Pool runners may cycle-restore a VM immediately after Playwright
+                    // exits, which can discard or overwrite the normal artifact copy.
+                    // Write one uniquely named, one-shot evidence file to the runner's
+                    // shared directory as well. No test streams into this path.
+                    const evidenceDirectory = process.env["SUPERCOV_EVIDENCE_DIR"] ??
+                        (GENERATED_EVIDENCE_DIRECTORY.startsWith("__")
+                            ? undefined
+                            : GENERATED_EVIDENCE_DIRECTORY);
+                    if (evidenceDirectory) {
+                        const resolvedDirectory = resolve(process.cwd(), evidenceDirectory);
+                        const safeTestId = testInfo.testId.replace(/[^a-zA-Z0-9_-]/g, "_");
+                        const testEvidenceDirectory = resolve(resolvedDirectory, `${safeTestId}-${testInfo.retry}`);
+                        mkdirSync(testEvidenceDirectory, { recursive: true });
+                        atomicWriteFileSync(resolve(testEvidenceDirectory, "mcdc.json"), serialized);
                     }
                 }
-                for (const worker of controller?.allWorkers() ?? []) {
-                    const workerSnapshot = await worker
-                        .evaluate(() => {
-                        const getSnapshot = globalThis.__SUPERCOV_COVERAGE_SNAPSHOT__;
-                        return getSnapshot?.() ?? { decisions: [], hits: [], events: [] };
-                    })
-                        .catch(() => ({
-                        decisions: [],
-                        hits: [],
-                        events: [],
-                    }));
-                    browser.push(workerSnapshot);
-                }
-                const server = readServerRecords(scope);
-                // Emit an artifact even when this test touched no application source.
-                // A complete test-to-coverage matrix must also identify tests that are
-                // removable without changing coverage.
-                const outputPath = testInfo.outputPath("mcdc.json");
-                mkdirSync(dirname(outputPath), { recursive: true });
-                const testFile = relative(process.cwd(), testInfo.file)
-                    .split(sep)
-                    .join("/");
-                const payload = {
-                    testId: testInfo.testId,
-                    scope,
-                    test: testInfo.titlePath.join(" > "),
-                    testFile,
-                    title: testInfo.title,
-                    retry: testInfo.retry,
-                    status: testInfo.status ?? "unknown",
-                    expectedStatus: testInfo.expectedStatus,
-                    provenance: inferTestProvenance({
-                        runner: "playwright",
-                        file: testFile,
-                        project: testInfo.project.name,
-                        explicitKind: process.env["SUPERCOV_TEST_KIND"],
-                    }),
-                    phases: controller?.phases ?? [],
-                    browser,
-                    server,
-                };
-                const serialized = `${JSON.stringify(payload)}\n`;
-                atomicWriteFileSync(outputPath, serialized);
-                // Pool runners may cycle-restore a VM immediately after Playwright
-                // exits, which can discard or overwrite the normal artifact copy.
-                // Write one uniquely named, one-shot evidence file to the runner's
-                // shared directory as well. No test streams into this path.
-                const evidenceDirectory = process.env["SUPERCOV_EVIDENCE_DIR"] ??
-                    (GENERATED_EVIDENCE_DIRECTORY.startsWith("__")
-                        ? undefined
-                        : GENERATED_EVIDENCE_DIRECTORY);
-                if (evidenceDirectory) {
-                    const resolvedDirectory = resolve(process.cwd(), evidenceDirectory);
-                    const safeTestId = testInfo.testId.replace(/[^a-zA-Z0-9_-]/g, "_");
-                    const testEvidenceDirectory = resolve(resolvedDirectory, `${safeTestId}-${testInfo.retry}`);
-                    mkdirSync(testEvidenceDirectory, { recursive: true });
-                    atomicWriteFileSync(resolve(testEvidenceDirectory, "mcdc.json"), serialized);
+                finally {
+                    await controller.dispose();
+                    directRuntime()?.activateCoverageScope();
+                    if (activeController === controller)
+                        activeController = undefined;
+                    controllers.delete(scope.attemptId);
                 }
             }
         },
@@ -797,4 +885,3 @@ const instrumentedTest = base.extend({
 });
 export const test = instrumentedTest;
 /*__SUPERCOV_ADAPTER_EXPORTS__*/
-//# sourceMappingURL=playwright.js.map

package/{dist → runtime/javascript}/playwrightReporter.js

@@ -38,4 +38,3 @@ export default class SupercovPlaywrightReporter {
         atomicWriteFileSync(resolve(directory, "mcdc.json"), `${JSON.stringify(payload)}\n`);
     }
 }
-//# sourceMappingURL=playwrightReporter.js.map

package/{dist → runtime/javascript}/provenance.js

@@ -48,4 +48,3 @@ export function inferTestProvenance({ runner, file, project, explicitKind, }) {
         source: defaultKind === "unknown" ? "unknown" : "runner-default",
     };
 }
-//# sourceMappingURL=provenance.js.map

package/{dist → runtime/javascript}/register.mjs

@@ -7,9 +7,61 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import Module, { register, syncBuiltinESMExports } from "node:module";
+import { closeSync, openSync, unlinkSync } from "node:fs";
 import { resolve } from "node:path";
 import { installLaunchSupervisor } from "./launchSupervisor.js";
 installLaunchSupervisor();
+// Long-running commands are diagnosed without changing their runner's exit
+// semantics. The first preloaded Node process atomically elects itself for the
+// run and periodically reports public active-resource types. This deliberately
+// uses no Unix signal: a launch tree may contain uninstrumented Node children,
+// and signalling one would terminate a healthy command by default.
+if (!process.__SUPERCOV_DIAGNOSTIC_REPORTER__) {
+    process.__SUPERCOV_DIAGNOSTIC_REPORTER__ = true;
+    const ownerFile = process.env.SUPERCOV_DIAGNOSTIC_OWNER_FILE;
+    let ownerDescriptor;
+    try {
+        if (ownerFile)
+            ownerDescriptor = openSync(ownerFile, "wx");
+    }
+    catch {
+        // Another preloaded process owns diagnostics for this run.
+    }
+    if (ownerDescriptor !== undefined) {
+        const configuredInterval = Number(process.env.SUPERCOV_DIAGNOSTIC_INTERVAL_MS ?? 60_000);
+        const intervalMs = Number.isSafeInteger(configuredInterval) && configuredInterval > 0
+            ? configuredInterval
+            : 60_000;
+        const reportResources = () => {
+            const resources = typeof process.getActiveResourcesInfo === "function"
+                ? process.getActiveResourcesInfo()
+                : [];
+            const counts = Object.fromEntries([...new Set(resources)].sort().map(resource => [
+                resource,
+                resources.filter(candidate => candidate === resource).length,
+            ]));
+            console.error(`[supercov:active-resources] ${JSON.stringify({
+                pid: process.pid,
+                ppid: process.ppid,
+                uptimeMs: Math.round(process.uptime() * 1000),
+                resources: counts,
+            })}`);
+        };
+        const diagnosticTimer = setInterval(reportResources, intervalMs);
+        diagnosticTimer.unref();
+        process.once("exit", () => {
+            clearInterval(diagnosticTimer);
+            try {
+                closeSync(ownerDescriptor);
+            }
+            catch { }
+            try {
+                unlinkSync(ownerFile);
+            }
+            catch { }
+        });
+    }
+}
 // Assertion-call instrumentation also uses this runtime in test processes
 // whose application build is handled by Vite or another compiler. Loading it
 // for every isolated test launch keeps node:assert attribution runner-agnostic.
@@ -195,4 +247,3 @@ if (process.env.SUPERCOV_CJS_INTERCEPT === "1") {
         return originalLoad.call(this, request, parent, isMain);
     };
 }
-//# sourceMappingURL=register.mjs.map

package/{dist → runtime/javascript}/resolve-loader.mjs

@@ -1,11 +1,3 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
 import { resolve as resolvePath } from "node:path";
 import { pathToFileURL } from "node:url";
 const GENERATED_TARGET = "__SUPERCOV_PLAYWRIGHT_MODULE__";
@@ -81,31 +73,3 @@ export async function resolve(specifier, context, nextResolve) {
     }
     return nextResolve(specifier, context);
 }
-export async function load(url, context, nextLoad) {
-    const loaded = await nextLoad(url, context);
-    const transformer = process.env.SUPERCOV_ESM_TRANSFORMER;
-    const wrapper = process.env.SUPERCOV_ESM_CAPABILITY_WRAPPER;
-    if (!transformer ||
-        !wrapper ||
-        loaded.format !== "module" ||
-        !belongsToProject(url) ||
-        loaded.source === undefined ||
-        loaded.source === null)
-        return loaded;
-    const source = typeof loaded.source === "string"
-        ? loaded.source
-        : Buffer.from(loaded.source).toString("utf8");
-    try {
-        const { transformCapabilityImports } = await import(__rewriteRelativeImportExtension(transformer));
-        const transformed = transformCapabilityImports(source, url, wrapper);
-        return transformed.transformed
-            ? { ...loaded, source: transformed.code }
-            : loaded;
-    }
-    catch (error) {
-        if (process.env.SUPERCOV_DEBUG === "1")
-            console.error("[supercov] ESM capability transform skipped", { url, error });
-        return loaded;
-    }
-}
-//# sourceMappingURL=resolve-loader.mjs.map

package/{dist → runtime/javascript}/runnerEvidence.js

@@ -52,9 +52,9 @@ export function callerLocation(ignored) {
     }
     return {};
 }
-export function readScopedServerEvidence(scope) {
+export function readScopedServerEvidence(scope, evidencePath = serverEvidencePath(scope)) {
     try {
-        return readFileSync(serverEvidencePath(scope), "utf8")
+        return readFileSync(evidencePath, "utf8")
             .split("\n")
             .filter(Boolean)
             .map((line) => JSON.parse(line))
@@ -64,7 +64,7 @@ export function readScopedServerEvidence(scope) {
         return [];
     }
 }
-export function writeRunnerEvidence(identity, status, scope, evidenceDirectoryOverride, phases = []) {
+export function writeRunnerEvidence(identity, status, scope, evidenceDirectoryOverride, phases = [], serverEvidenceSource) {
     const evidenceDirectory = evidenceDirectoryOverride ?? process.env["SUPERCOV_EVIDENCE_DIR"];
     if (!evidenceDirectory)
         return;
@@ -85,10 +85,11 @@ export function writeRunnerEvidence(identity, status, scope, evidenceDirectoryOv
         ...(phases.length > 0 ? { phases } : {}),
         runtime: [],
         browser: [],
-        server: readScopedServerEvidence(scope),
+        server: serverEvidenceSource
+            ? readScopedServerEvidence(scope, serverEvidenceSource)
+            : readScopedServerEvidence(scope),
     };
     const directory = resolve(process.cwd(), evidenceDirectory, `${identity.runner.replace(/[^A-Za-z0-9_-]/g, "_")}-${scope.attemptId}`);
     mkdirSync(directory, { recursive: true });
     atomicWriteFileSync(resolve(directory, "mcdc.json"), `${JSON.stringify(payload)}\n`);
 }
-//# sourceMappingURL=runnerEvidence.js.map