supercov 0.0.0 → 0.0.2

package/dist/playwright.js

@@ -0,0 +1,794 @@
+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 { createHash } from "node:crypto";
+import childProcess from "node:child_process";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import http from "node:http";
+import https from "node:https";
+import { syncBuiltinESMExports } from "node:module";
+import { dirname, relative, resolve, sep } from "node:path";
+import * as standardPlaywright from "@playwright/test";
+import { inferTestProvenance } from "./provenance.js";
+import { COVERAGE_PHASE_HEADER, COVERAGE_SCOPE_HEADER, COVERAGE_CARRIER_ENV, encodeCoverageCarrier, encodeCoverageScope, serverEvidenceDirectory, serverEvidencePath, } from "./transport.js";
+export * from "@playwright/test";
+const generatedTargetModule = "__SUPERCOV_PLAYWRIGHT_MODULE__";
+const targetModule = process.env["SUPERCOV_PLAYWRIGHT_MODULE"] ??
+    (generatedTargetModule.startsWith("__")
+        ? "@playwright/test"
+        : generatedTargetModule);
+const adapter = (targetModule === "@playwright/test"
+    ? standardPlaywright
+    : await import(__rewriteRelativeImportExtension(targetModule)));
+const base = (adapter.offlineTest ?? adapter.test);
+const baseExpect = adapter.expect;
+const GENERATED_EVIDENCE_DIRECTORY = "__SUPERCOV_EVIDENCE_DIRECTORY__";
+const GENERATED_RUN_ID = "__SUPERCOV_RUN_ID__";
+const PHASE_STORAGE_KEY = "__supercov_phase";
+const ACTION_METHODS = new Set([
+    "blur",
+    "check",
+    "click",
+    "dblclick",
+    "dispatchEvent",
+    "dragTo",
+    "evaluate",
+    "evaluateHandle",
+    "fill",
+    "focus",
+    "goBack",
+    "goForward",
+    "goto",
+    "hover",
+    "press",
+    "reload",
+    "selectOption",
+    "setInputFiles",
+    "tap",
+    "type",
+    "uncheck",
+]);
+const REQUEST_METHODS = new Set([
+    "delete",
+    "fetch",
+    "get",
+    "head",
+    "patch",
+    "post",
+    "put",
+]);
+function isApiRequestContext(value) {
+    const candidate = value;
+    return (typeof candidate["fetch"] === "function" &&
+        typeof candidate["get"] === "function" &&
+        typeof candidate["post"] === "function" &&
+        typeof candidate["storageState"] === "function");
+}
+function callerSource() {
+    const stack = new Error().stack?.split("\n").slice(2) ?? [];
+    const candidate = stack.find((line) => /[/\\]tests[/\\]/.test(line) &&
+        !line.includes(".supercov") &&
+        !line.includes("node_modules"));
+    if (!candidate)
+        return undefined;
+    return candidate
+        .trim()
+        .replace(/^at\s+/, "")
+        .replace("file:///workspace/", "")
+        .replace("/workspace/", "");
+}
+class CoveragePhaseController {
+    scope;
+    configuredHeaders;
+    phases = [];
+    counter = 0;
+    lastActionId;
+    activePhaseId;
+    pages = new Set();
+    workers = new Set();
+    contexts = new Set();
+    contextConfiguredHeaders = new Map();
+    contextRoutes = new Map();
+    cdpSessions = new Map();
+    newDocumentScriptIds = new Map();
+    pendingRegistrations = new Set();
+    scriptUpdate = Promise.resolve();
+    proxyCache = new WeakMap();
+    // Parameter properties are stateful despite the base ESLint rule treating
+    // this as an empty constructor.
+    // eslint-disable-next-line no-useless-constructor
+    constructor(scope, configuredHeaders = {}) {
+        this.scope = scope;
+        this.configuredHeaders = configuredHeaders;
+    }
+    allPages() {
+        return [...this.pages];
+    }
+    allWorkers() {
+        return [...this.workers];
+    }
+    async registerPage(page) {
+        if (this.pages.has(page))
+            return;
+        this.pages.add(page);
+        await this.registerContext(page.context());
+        const cdp = await page.context().newCDPSession(page).catch(() => undefined);
+        if (cdp)
+            this.cdpSessions.set(page, cdp);
+        const phaseId = this.requestPhaseId();
+        if (phaseId)
+            await this.activatePage(page, phaseId);
+        page.on("worker", (worker) => {
+            void this.registerWorker(worker);
+        });
+        for (const worker of page.workers())
+            void this.registerWorker(worker);
+    }
+    async registerContext(context, configuredHeaders = this.configuredHeaders) {
+        if (this.contexts.has(context))
+            return;
+        this.contexts.add(context);
+        this.contextConfiguredHeaders.set(context, configuredHeaders);
+        await context.addInitScript(({ attemptId, scopeHeader, scopeValue }) => {
+            globalThis.__SUPERCOV_MCDC_TEST_ID__ = attemptId;
+            try {
+                const originalFetch = globalThis.fetch?.bind(globalThis);
+                if (originalFetch) {
+                    globalThis.fetch = ((input, init) => {
+                        const headers = new Headers(init?.headers ??
+                            (input instanceof Request ? input.headers : undefined));
+                        headers.set(scopeHeader, scopeValue);
+                        const phase = globalThis.__SUPERCOV_PHASE_ID__;
+                        if (phase)
+                            headers.set("x-supercov-phase", phase);
+                        return originalFetch(input, { ...init, headers });
+                    });
+                }
+            }
+            catch {
+                // Browser instrumentation must not change application behavior.
+            }
+        }, {
+            attemptId: this.scope.attemptId,
+            scopeHeader: COVERAGE_SCOPE_HEADER,
+            scopeValue: encodeCoverageScope(this.scope),
+        });
+        const attachPhase = async (route) => {
+            const phaseId = this.requestPhaseId();
+            await route.continue({
+                headers: {
+                    ...route.request().headers(),
+                    [COVERAGE_SCOPE_HEADER]: encodeCoverageScope(this.scope),
+                    ...(phaseId ? { [COVERAGE_PHASE_HEADER]: phaseId } : {}),
+                },
+            });
+        };
+        this.contextRoutes.set(context, attachPhase);
+        await context.route("**/*", attachPhase);
+        const register = (page) => {
+            const pending = this.registerPage(page).finally(() => this.pendingRegistrations.delete(pending));
+            this.pendingRegistrations.add(pending);
+        };
+        context.on("page", register);
+        context.on("serviceworker", (worker) => {
+            void this.registerWorker(worker);
+        });
+        for (const worker of context.serviceWorkers())
+            void this.registerWorker(worker);
+        await this.updateContextHeaders(context, this.requestPhaseId());
+        for (const page of context.pages())
+            register(page);
+    }
+    async registerWorker(worker) {
+        if (this.workers.has(worker))
+            return;
+        this.workers.add(worker);
+        const phaseId = this.requestPhaseId();
+        await worker
+            .evaluate(({ attemptId, scopeHeader, scopeValue, phaseHeader, phase }) => {
+            globalThis.__SUPERCOV_MCDC_TEST_ID__ = attemptId;
+            if (phase)
+                globalThis.__SUPERCOV_PHASE_ID__ = phase;
+            const originalFetch = globalThis.fetch?.bind(globalThis);
+            if (!originalFetch)
+                return;
+            globalThis.fetch = ((input, init) => {
+                const headers = new Headers(init?.headers ??
+                    (input instanceof Request ? input.headers : undefined));
+                headers.set(scopeHeader, scopeValue);
+                if (phase)
+                    headers.set(phaseHeader, phase);
+                return originalFetch(input, { ...init, headers });
+            });
+        }, {
+            attemptId: this.scope.attemptId,
+            scopeHeader: COVERAGE_SCOPE_HEADER,
+            scopeValue: encodeCoverageScope(this.scope),
+            phaseHeader: COVERAGE_PHASE_HEADER,
+            phase: phaseId,
+        })
+            .catch(() => undefined);
+    }
+    async beginAction(operation) {
+        const phase = this.createPhase("action", operation);
+        this.lastActionId = phase.id;
+        this.activePhaseId = phase.id;
+        await this.activateInBrowser(phase.id);
+        return phase;
+    }
+    beginAssertion(operation) {
+        const phase = this.createPhase("assertion", operation, this.lastActionId);
+        this.activePhaseId = phase.id;
+        // Playwright queues browser protocol commands in order. Starting this
+        // evaluation before an async locator assertion is sufficient to tag its
+        // polling work without turning synchronous expect matchers into promises.
+        void this.activateInBrowser(phase.id);
+        return phase;
+    }
+    requestPhaseId() {
+        return this.activePhaseId;
+    }
+    async dispose() {
+        await Promise.all([...this.pendingRegistrations]);
+        await this.scriptUpdate;
+        for (const [page, cdp] of this.cdpSessions) {
+            const identifier = this.newDocumentScriptIds.get(page);
+            if (identifier)
+                await cdp
+                    .send("Page.removeScriptToEvaluateOnNewDocument", {
+                    identifier,
+                })
+                    .catch(() => undefined);
+            await cdp.detach().catch(() => undefined);
+        }
+        for (const [context, route] of this.contextRoutes)
+            await context.unroute("**/*", route).catch(() => undefined);
+    }
+    finish(phase, error) {
+        phase.endedAtMs = Date.now();
+        phase.status = error === undefined ? "passed" : "failed";
+        if (error !== undefined)
+            phase.error = error instanceof Error ? error.message : String(error);
+    }
+    wrap(target) {
+        const cached = this.proxyCache.get(target);
+        if (cached)
+            return cached;
+        const proxy = new Proxy(target, {
+            get: (object, property, receiver) => {
+                if (property === "then")
+                    return undefined;
+                // Playwright's locator matchers validate `receiver.constructor.name`.
+                // Preserve the native constructor rather than wrapping it as a method.
+                if (property === "constructor")
+                    return object.constructor;
+                const value = Reflect.get(object, property, receiver);
+                if (typeof value !== "function")
+                    return value;
+                const method = String(property);
+                return (...args) => {
+                    const isRequest = REQUEST_METHODS.has(method) &&
+                        isApiRequestContext(object);
+                    if (ACTION_METHODS.has(method) || isRequest) {
+                        return (async () => {
+                            const operation = `${object.constructor?.name ?? "Playwright"}.${method}`;
+                            const phase = await this.beginAction(operation);
+                            try {
+                                const result = await Reflect.apply(value, object, isRequest ? this.scopeApiRequest(args) : args);
+                                this.finish(phase);
+                                return this.prepareResult(result);
+                            }
+                            catch (error) {
+                                this.finish(phase, error);
+                                throw error;
+                            }
+                        })();
+                    }
+                    const invokedArgs = method === "newContext" && object.constructor?.name === "Browser"
+                        ? this.scopeBrowserContext(args)
+                        : args;
+                    const result = Reflect.apply(value, object, invokedArgs);
+                    return this.wrapResult(result, method === "newContext" ? invokedArgs : undefined);
+                };
+            },
+        });
+        this.proxyCache.set(target, proxy);
+        return proxy;
+    }
+    createPhase(kind, operation, causedByPhaseId) {
+        const source = callerSource();
+        const phase = {
+            id: `${this.scope.attemptId}:phase:${++this.counter}`,
+            kind,
+            operation,
+            ...(source ? { source } : {}),
+            ...(causedByPhaseId ? { causedByPhaseId } : {}),
+            startedAtMs: Date.now(),
+        };
+        this.phases.push(phase);
+        return phase;
+    }
+    wrapResult(result, sourceArgs) {
+        if (result instanceof Promise)
+            return result.then((resolved) => this.prepareResult(resolved, sourceArgs));
+        if (result === null ||
+            typeof result !== "object" ||
+            Array.isArray(result) ||
+            ArrayBuffer.isView(result))
+            return result;
+        return this.wrap(result);
+    }
+    async prepareResult(result, sourceArgs) {
+        if (!result ||
+            typeof result !== "object" ||
+            Array.isArray(result) ||
+            ArrayBuffer.isView(result))
+            return result;
+        const candidate = result;
+        if (typeof candidate["pages"] === "function" &&
+            typeof candidate["route"] === "function")
+            await this.registerContext(result, (sourceArgs?.[0]
+                ?.extraHTTPHeaders ?? this.configuredHeaders));
+        if (typeof candidate["frames"] === "function" &&
+            typeof candidate["context"] === "function")
+            await this.registerPage(result);
+        return this.wrap(result);
+    }
+    scopeApiRequest(args) {
+        const scoped = [...args];
+        const optionIndex = 1;
+        const phaseId = this.requestPhaseId();
+        const coverageHeaders = {
+            [COVERAGE_SCOPE_HEADER]: encodeCoverageScope(this.scope),
+            ...(phaseId ? { [COVERAGE_PHASE_HEADER]: phaseId } : {}),
+        };
+        const options = scoped[optionIndex] && typeof scoped[optionIndex] === "object"
+            ? scoped[optionIndex]
+            : {};
+        scoped[optionIndex] = {
+            ...options,
+            headers: mergeRequestHeaders(options.headers, coverageHeaders),
+        };
+        return scoped;
+    }
+    scopeBrowserContext(args) {
+        const scoped = [...args];
+        const options = scoped[0] && typeof scoped[0] === "object"
+            ? scoped[0]
+            : {};
+        scoped[0] = {
+            ...options,
+            extraHTTPHeaders: {
+                ...(options.extraHTTPHeaders ?? {}),
+                ...(activeCoverageHeaders() ?? {}),
+            },
+        };
+        return scoped;
+    }
+    async activateInBrowser(phaseId) {
+        await Promise.all([...this.contexts].map((context) => this.updateContextHeaders(context, phaseId)));
+        await Promise.all([...this.pages].flatMap((page) => page.frames()).map((frame) => frame
+            .evaluate(({ id, storageKey }) => {
+            globalThis.__SUPERCOV_PHASE_ID__ = id;
+            try {
+                localStorage.setItem(storageKey, id);
+            }
+            catch {
+                // Sandboxed/cross-origin frames may not expose localStorage.
+            }
+        }, { id: phaseId, storageKey: PHASE_STORAGE_KEY })
+            .catch(() => undefined)));
+        await Promise.all([...this.workers].map((worker) => worker
+            .evaluate((id) => {
+            globalThis.__SUPERCOV_PHASE_ID__ = id;
+        }, phaseId)
+            .catch(() => undefined)));
+        await Promise.all([...this.pages].map((page) => this.activatePage(page, phaseId)));
+    }
+    async updateContextHeaders(context, phaseId) {
+        await context
+            .setExtraHTTPHeaders({
+            ...(this.contextConfiguredHeaders.get(context) ?? this.configuredHeaders),
+            [COVERAGE_SCOPE_HEADER]: encodeCoverageScope(this.scope),
+            ...(phaseId ? { [COVERAGE_PHASE_HEADER]: phaseId } : {}),
+        })
+            .catch(() => undefined);
+    }
+    async activatePage(page, phaseId) {
+        const cdp = this.cdpSessions.get(page);
+        if (!cdp)
+            return;
+        this.scriptUpdate = this.scriptUpdate.then(async () => {
+            const previous = this.newDocumentScriptIds.get(page);
+            if (previous) {
+                await cdp.send("Page.removeScriptToEvaluateOnNewDocument", {
+                    identifier: previous,
+                }).catch(() => undefined);
+            }
+            const installed = (await cdp
+                .send("Page.addScriptToEvaluateOnNewDocument", {
+                source: `globalThis.__SUPERCOV_PHASE_ID__=${JSON.stringify(phaseId)};`,
+                runImmediately: true,
+            })
+                .catch(() => undefined));
+            if (installed?.identifier)
+                this.newDocumentScriptIds.set(page, installed.identifier);
+        });
+        await this.scriptUpdate.catch(() => undefined);
+    }
+}
+let activeController;
+const controllers = new Map();
+function activeCoverageHeaders() {
+    const controller = activeController;
+    if (!controller)
+        return undefined;
+    const phaseId = controller.requestPhaseId();
+    return {
+        [COVERAGE_SCOPE_HEADER]: encodeCoverageScope(controller.scope),
+        ...(phaseId ? { [COVERAGE_PHASE_HEADER]: phaseId } : {}),
+    };
+}
+function mergeRequestHeaders(existing, coverage) {
+    if (existing instanceof Headers) {
+        return { ...Object.fromEntries(existing.entries()), ...coverage };
+    }
+    if (Array.isArray(existing)) {
+        const normalized = {};
+        for (let index = 0; index + 1 < existing.length; index += 2) {
+            normalized[String(existing[index])] = existing[index + 1];
+        }
+        return { ...normalized, ...coverage };
+    }
+    return {
+        ...(existing && typeof existing === "object" ? existing : {}),
+        ...coverage,
+    };
+}
+function scopedNodeRequestArguments(args) {
+    const coverage = activeCoverageHeaders();
+    if (!coverage || args.length === 0)
+        return args;
+    const scoped = [...args];
+    const first = scoped[0];
+    const startsWithUrl = typeof first === "string" || first instanceof URL;
+    const candidate = startsWithUrl ? scoped[1] : first;
+    const hasOptions = candidate !== null &&
+        typeof candidate === "object" &&
+        !(candidate instanceof URL);
+    if (hasOptions) {
+        const index = startsWithUrl ? 1 : 0;
+        const options = candidate;
+        scoped[index] = {
+            ...options,
+            headers: mergeRequestHeaders(options.headers, coverage),
+        };
+    }
+    else if (startsWithUrl) {
+        scoped.splice(1, 0, { headers: coverage });
+    }
+    return scoped;
+}
+function installNodeRequestScopePropagation() {
+    const originalHttpRequest = http.request;
+    const originalHttpGet = http.get;
+    const originalHttpsRequest = https.request;
+    const originalHttpsGet = https.get;
+    http.request = ((...args) => Reflect.apply(originalHttpRequest, http, scopedNodeRequestArguments(args)));
+    http.get = ((...args) => Reflect.apply(originalHttpGet, http, scopedNodeRequestArguments(args)));
+    https.request = ((...args) => Reflect.apply(originalHttpsRequest, https, scopedNodeRequestArguments(args)));
+    https.get = ((...args) => Reflect.apply(originalHttpsGet, https, scopedNodeRequestArguments(args)));
+    // Existing ESM named imports such as `import { request } from "node:http"`
+    // must observe the patched CommonJS-compatible builtin exports too.
+    syncBuiltinESMExports();
+    if (typeof globalThis.fetch === "function") {
+        const originalFetch = globalThis.fetch.bind(globalThis);
+        globalThis.fetch = ((input, init) => {
+            const coverage = activeCoverageHeaders();
+            if (!coverage)
+                return originalFetch(input, init);
+            const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : undefined));
+            for (const [name, value] of Object.entries(coverage))
+                headers.set(name, value);
+            return originalFetch(input, { ...init, headers });
+        });
+    }
+}
+installNodeRequestScopePropagation();
+function scopedChildOptions(args, optionIndex) {
+    const controller = activeController;
+    if (!controller)
+        return args;
+    const scoped = [...args];
+    const existing = scoped[optionIndex] && typeof scoped[optionIndex] === "object"
+        ? scoped[optionIndex]
+        : {};
+    const options = {
+        ...existing,
+        env: {
+            ...process.env,
+            ...(existing.env ?? {}),
+            SUPERCOV_RUN_ID: controller.scope.runId,
+            [COVERAGE_CARRIER_ENV]: encodeCoverageCarrier({
+                version: 1,
+                scope: controller.scope,
+                ...(controller.requestPhaseId()
+                    ? { phaseId: controller.requestPhaseId() }
+                    : {}),
+            }),
+        },
+    };
+    if (typeof scoped[optionIndex] === "function")
+        scoped.splice(optionIndex, 0, options);
+    else
+        scoped[optionIndex] = options;
+    return scoped;
+}
+function childOptionIndex(method, args) {
+    if (method === "spawn" || method === "spawnSync" || method === "fork")
+        return Array.isArray(args[1]) ? 2 : 1;
+    if (method === "execFile" || method === "execFileSync")
+        return Array.isArray(args[1]) ? 2 : 1;
+    return 1;
+}
+function installChildProcessScopePropagation() {
+    for (const method of [
+        "exec",
+        "execFile",
+        "execFileSync",
+        "execSync",
+        "fork",
+        "spawn",
+        "spawnSync",
+    ]) {
+        const original = childProcess[method];
+        childProcess[method] = function (...args) {
+            return Reflect.apply(original, childProcess, scopedChildOptions(args, childOptionIndex(method, args)));
+        };
+    }
+    syncBuiltinESMExports();
+}
+installChildProcessScopePropagation();
+function wrapMatchers(matchers, path = "expect") {
+    return new Proxy(matchers, {
+        get(target, property, receiver) {
+            const value = Reflect.get(target, property, receiver);
+            const name = String(property);
+            if (value && typeof value === "object")
+                return wrapMatchers(value, `${path}.${name}`);
+            if (typeof value !== "function")
+                return value;
+            return (...args) => {
+                const controller = activeController;
+                const phase = controller?.beginAssertion(`${path}.${name}`);
+                try {
+                    const result = Reflect.apply(value, target, args);
+                    if (result instanceof Promise) {
+                        return result.then((resolved) => {
+                            if (phase && controller)
+                                controller.finish(phase);
+                            return resolved;
+                        }, (error) => {
+                            if (phase && controller)
+                                controller.finish(phase, error);
+                            throw error;
+                        });
+                    }
+                    if (phase && controller)
+                        controller.finish(phase);
+                    return result;
+                }
+                catch (error) {
+                    if (phase && controller)
+                        controller.finish(phase, error);
+                    throw error;
+                }
+            };
+        },
+    });
+}
+function wrapExpectCallable(callable) {
+    return new Proxy(callable, {
+        apply(target, thisArg, argumentsList) {
+            const result = Reflect.apply(target, thisArg, argumentsList);
+            if (typeof result === "function")
+                return wrapExpectCallable(result);
+            if (result && typeof result === "object")
+                return wrapMatchers(result);
+            return result;
+        },
+        get(target, property, receiver) {
+            const value = Reflect.get(target, property, receiver);
+            if (typeof value !== "function")
+                return value;
+            return wrapExpectCallable(value.bind(target));
+        },
+    });
+}
+export const expect = wrapExpectCallable(baseExpect);
+function currentRunId() {
+    return (process.env["SUPERCOV_RUN_ID"] ??
+        (GENERATED_RUN_ID.startsWith("__") ? "unscoped" : GENERATED_RUN_ID));
+}
+function executionScope(testInfo) {
+    const runId = currentRunId();
+    const workerId = `pid-${process.pid}-worker-${testInfo.workerIndex}`;
+    const testKey = createHash("sha256")
+        .update(testInfo.testId)
+        .digest("hex")
+        .slice(0, 24);
+    const attemptId = createHash("sha256")
+        .update(`${runId}\0${workerId}\0${testInfo.testId}\0${testInfo.retry}`)
+        .digest("hex")
+        .slice(0, 24);
+    return {
+        version: 1,
+        runId,
+        workerId,
+        testId: testInfo.testId,
+        testKey,
+        retry: testInfo.retry,
+        attemptId,
+    };
+}
+function readServerRecords(scope) {
+    try {
+        return readFileSync(serverEvidencePath(scope), "utf8")
+            .split("\n")
+            .filter(Boolean)
+            .flatMap((line) => {
+            try {
+                const record = JSON.parse(line);
+                return record.scope?.attemptId === scope.attemptId ? [record] : [];
+            }
+            catch {
+                // Ignore a final partial line if the server was writing during collection.
+                return [];
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+}
+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;
+        await controller.registerPage(page);
+        try {
+            await use(controller.wrap(page));
+        }
+        finally {
+            await controller.dispose();
+            if (activeController === controller)
+                activeController = undefined;
+            controllers.delete(scope.attemptId);
+        }
+    },
+    browser: [
+        async ({ browser }, use) => {
+            await use(new Proxy(browser, {
+                get(target, property, receiver) {
+                    const controller = activeController;
+                    return controller
+                        ? Reflect.get(controller.wrap(target), property, receiver)
+                        : Reflect.get(target, property, receiver);
+                },
+            }));
+        },
+        { scope: "worker" },
+    ],
+    request: async ({ request }, use) => {
+        await use(new Proxy(request, {
+            get(target, property, receiver) {
+                const controller = activeController;
+                return controller
+                    ? Reflect.get(controller.wrap(target), property, receiver)
+                    : Reflect.get(target, property, receiver);
+            },
+        }));
+    },
+    mcdcAutoCollect: [
+        async ({ page }, use, testInfo) => {
+            const scope = executionScope(testInfo);
+            const serverOutput = serverEvidencePath(scope);
+            mkdirSync(serverEvidenceDirectory(scope), { recursive: true });
+            rmSync(serverOutput, { force: true });
+            try {
+                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);
+                    }
+                }
+                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`;
+                writeFileSync(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 });
+                    writeFileSync(resolve(testEvidenceDirectory, "mcdc.json"), serialized);
+                }
+            }
+        },
+        { auto: true },
+    ],
+});
+export const test = instrumentedTest;
+export const offlineTest = instrumentedTest;
+export const WebhookBodiesContract = adapter.WebhookBodiesContract;
+//# sourceMappingURL=playwright.js.map