supercov 4.24.7 → 4.25.0

package/runtime/javascript/playwright.mjs

@@ -18,7 +18,8 @@ import * as standardPlaywright from "@playwright/test";
 import * as coverageRuntime from "./runtime.mjs";
 import { inferTestProvenance, testTags } from "./provenance.mjs";
 import { appendJsonLineDurableSync, appendJsonLineSync } from "./atomic.mjs";
-import { COVERAGE_PHASE_HEADER, COVERAGE_PHASE_COOKIE, COVERAGE_PHASE_SITE_COOKIE, COVERAGE_SCOPE_COOKIE, COVERAGE_SCOPE_HEADER, COVERAGE_SCOPE_SITE_COOKIE, COVERAGE_CARRIER_ENV, encodeCoverageCarrier, encodeCoverageScope, serverEvidenceDirectory, serverEvidencePath, } from "./transport.mjs";
+import { expandSnapshot, mergeSnapshots } from "./snapshots.mjs";
+import { COVERAGE_DOCUMENT_PHASE_COOKIE, COVERAGE_DOCUMENT_PHASE_SITE_COOKIE, COVERAGE_PHASE_HEADER, COVERAGE_PHASE_COOKIE, COVERAGE_PHASE_SITE_COOKIE, COVERAGE_SCOPE_COOKIE, COVERAGE_SCOPE_HEADER, COVERAGE_SCOPE_SITE_COOKIE, COVERAGE_CARRIER_ENV, encodeCoverageCarrier, encodeCoverageScope, serverEvidenceDirectory, serverEvidencePath, startDocumentInPhase, } from "./transport.mjs";
 export * from "@playwright/test";
 const generatedTargetModule = "__SUPERCOV_PLAYWRIGHT_MODULE__";
 const targetModule = process.env["SUPERCOV_PLAYWRIGHT_MODULE"] ??
@@ -51,6 +52,33 @@ const browserRuntimePrelude = `(() => { if (globalThis.__SUPERCOV_DIRECT_RUNTIME
 const WORKER_ACTIVATION_WAIT_MS = 250;
 const WORKER_SNAPSHOT_WAIT_MS = 5000;
 const WORKER_TIMED_OUT = Symbol("worker did not answer");
+/**
+ * Supercov's own Playwright calls, made as one internal API call. Each call a
+ * suite makes captures its stack, maps every frame through the runner's
+ * source maps, and reports a step and a trace event: the collector's calls at
+ * every action did all of that, and on a real suite they were most of what an
+ * action waited for, and showed up among the test's own steps. Inside one
+ * internal call the rest find its zone: they capture and report nothing. The
+ * one stack it captures names nothing anyone reads, so it is not formatted.
+ */
+const unformattedStack = () => "";
+function internally(owner, work) {
+    const wrapApiCall = owner?._wrapApiCall;
+    if (typeof wrapApiCall !== "function")
+        return work();
+    const prepareStackTrace = Error.prepareStackTrace;
+    Error.prepareStackTrace = unformattedStack;
+    try {
+        // `{ internal: true }`, or `true` where older releases take a flag.
+        return wrapApiCall.call(owner, () => {
+            Error.prepareStackTrace = prepareStackTrace;
+            return work();
+        }, { internal: true });
+    }
+    finally {
+        Error.prepareStackTrace = prepareStackTrace;
+    }
+}
 function bounded(promise, milliseconds) {
     let timer;
     return Promise.race([
@@ -197,6 +225,7 @@ class CoveragePhaseController {
     cdpSessions = new Map();
     newDocumentScriptIds = new Map();
     pendingRegistrations = new Set();
+    pendingAssertion;
     pageRegistrations = new WeakMap();
     scriptUpdate = Promise.resolve();
     proxyCache = new WeakMap();
@@ -257,12 +286,22 @@ class CoveragePhaseController {
     allPages() {
         return [...this.pages];
     }
+    /** Any Playwright object of this test's, to make internal calls through. */
+    anyOwner() {
+        for (const owners of [this.contexts, this.pages, this.workers])
+            for (const owner of owners)
+                return owner;
+        return undefined;
+    }
     allWorkers() {
         return [...this.workers];
     }
     async collectRuntimeSnapshots() {
         if (this.runtimeSnapshots)
             return this.runtimeSnapshots;
+        return internally(this.anyOwner() ?? [...liveTrackedContexts()][0], () => this.collectRuntimeSnapshotsNow());
+    }
+    async collectRuntimeSnapshotsNow() {
         timingCount("collectRuntimeSnapshots.cold");
         // Contexts the suite created without going through any fixture the
         // collector wraps (a raw `browser.newContext()` mid-test) are found
@@ -369,6 +408,9 @@ class CoveragePhaseController {
     async snapshotBeforeClose(page) {
         if (!this.pages.has(page) || this.snapshottedPages.has(page) || this.runtimeSnapshots)
             return;
+        return internally(page, () => this.snapshotBeforeCloseNow(page));
+    }
+    async snapshotBeforeCloseNow(page) {
         this.snapshottedPages.add(page);
         this.earlySnapshots.push(...(await this.snapshotPage(page)));
         // A dedicated worker ends with the page that owns it, so it is read
@@ -393,7 +435,7 @@ class CoveragePhaseController {
         for (const context of liveTrackedContexts()) {
             if (!this.contexts.has(context)) {
                 const headersKnown = trackedContextConfiguredHeaders.has(context);
-                await this.registerContext(context, { adopted: !headersKnown }).catch(() => undefined);
+                await internally(context, () => this.registerContext(context, { adopted: !headersKnown })).catch(() => undefined);
             }
         }
     }
@@ -407,8 +449,19 @@ class CoveragePhaseController {
      * already has one of this test's phases is left alone: a reset that
      * arrives late must not drop what this test ran.
      */
-    async takeCarriedEvidence() {
-        await Promise.all([...this.pendingRegistrations]);
+    /**
+     * `pages`, when given, are the pages the test starts with, read from the
+     * live contexts while those are being registered: what they carry is in
+     * their documents, which registering a context does not touch, so the
+     * test's setup need not wait for one before the other.
+     */
+    async takeCarriedEvidence(pages) {
+        if (pages === undefined)
+            await Promise.all([...this.pendingRegistrations]);
+        const targets = pages ?? this.allPages();
+        return internally(targets[0] ?? this.anyOwner(), () => this.takeCarriedEvidenceNow(targets));
+    }
+    async takeCarriedEvidenceNow(pages) {
         const prefix = `${this.scope.attemptId}:`;
         const take = (target) => bounded(target
             .evaluate((prefix) => {
@@ -416,16 +469,17 @@ class CoveragePhaseController {
             if (String(coverageGlobal.__SUPERCOV_PHASE_ID__ ?? "").startsWith(prefix))
                 return undefined;
             const getSnapshot = coverageGlobal.__SUPERCOV_COVERAGE_SNAPSHOT__;
+            const compact = coverageGlobal.__SUPERCOV_COMPACT_SNAPSHOT__;
             const reset = coverageGlobal.__SUPERCOV_RESET__;
             if (!getSnapshot || !reset)
                 return undefined;
-            const snapshot = JSON.stringify(getSnapshot());
+            const snapshot = typeof compact === "function" ? compact(getSnapshot()) : JSON.stringify(getSnapshot());
             reset();
             return snapshot;
         }, prefix)
-            .then((text) => (typeof text === "string" ? JSON.parse(text) : undefined))
+            .then((text) => (typeof text === "string" ? expandSnapshot(JSON.parse(text)) : undefined))
             .catch(() => undefined), WORKER_ACTIVATION_WAIT_MS);
-        const taken = await Promise.all(this.allPages().flatMap((page) => [
+        const taken = await Promise.all(pages.flatMap((page) => [
             ...page.frames().map(take),
             ...page.workers().map(take),
         ]));
@@ -447,7 +501,7 @@ class CoveragePhaseController {
             return Promise.resolve();
         let registration = this.pageRegistrations.get(page);
         if (!registration) {
-            registration = this.registerNewPage(page);
+            registration = internally(page, () => this.registerNewPage(page));
             this.pageRegistrations.set(page, registration);
         }
         return registration;
@@ -463,7 +517,15 @@ class CoveragePhaseController {
         await this.registerContext(context, {
             adopted: !this.contexts.has(context) && tracked && !headersKnown,
         });
-        const cdp = await page.context().newCDPSession(page).catch(() => undefined);
+        // A page of a context whose headers are not known learns each phase
+        // from a new-document script replaced through a session of its own
+        // (activatePage). Every other page needs none: a session with the
+        // Page domain on has the browser send it every event of the page a
+        // second time, and the browser's own process spent more on that than
+        // the renderers spent running the instrumented app.
+        const cdp = this.adoptedContexts.has(context)
+            ? await page.context().newCDPSession(page).catch(() => undefined)
+            : undefined;
         if (cdp) {
             // Chromium runs a session's new-document scripts only once the
             // session has enabled the Page domain. Without it the script that
@@ -471,25 +533,13 @@ class CoveragePhaseController {
             // learned its phase only from the next action, after it had
             // loaded, and everything it ran while loading was placed by time.
             await cdp.send("Page.enable").catch(() => undefined);
-            // A document that leaves hands its evidence over here: the
-            // next one reads what it stored only on the same origin.
-            cdp.on("Runtime.bindingCalled", ({ name, payload }) => {
-                if (name !== LEAVING_BINDING || this.runtimeSnapshots)
-                    return;
-                try {
-                    this.leftSnapshots.push(JSON.parse(payload));
-                }
-                catch {
-                    // Not evidence.
-                }
-            });
-            await cdp.send("Runtime.enable").catch(() => undefined);
-            await cdp.send("Runtime.addBinding", { name: LEAVING_BINDING }).catch(() => undefined);
             this.cdpSessions.set(page, cdp);
         }
         const phaseId = this.requestPhaseId();
-        if (phaseId)
+        if (phaseId && this.adoptedContexts.has(context))
             await this.activatePage(page, phaseId);
+        else if (phaseId)
+            await this.activateFrames(phaseId, [page]);
         page.on("worker", (worker) => {
             void this.registerWorker(worker);
         });
@@ -503,11 +553,18 @@ class CoveragePhaseController {
         patchContextPrototype(context);
         if (adopted)
             this.adoptedContexts.add(context);
-        // A Rust crate compiled to wasm the run measures: pages remember
-        // their wasm instances, so each test's work can be taken from them.
-        if (process.env.SUPERCOV_WASM_REGIONS === "1")
-            await context.addInitScript({ content: "globalThis.__SUPERCOV_WASM_REGIONS__ = true;" }).catch(() => undefined);
-        await context.addInitScript({ content: browserRuntimePrelude }).catch(() => undefined);
+        return internally(context, () => this.registerContextNow(context, adopted));
+    }
+    async registerContextNow(context, adopted) {
+        // The context's own scripts first: sent when it was made, so they
+        // are in place, or sent now for a context made some other way.
+        await prepareContext(context);
+        // Then what every new document of the context runs for this test, in
+        // this order, as one script: one call where several, each awaited,
+        // were most of what a test waited for before its page opened. Each
+        // part runs on its own, as separate scripts did, so one that throws
+        // leaves the others.
+        const parts = [];
         // A context that outlives its test (a worker-scoped browser fixture)
         // is registered again by every later test, so this script accumulates
         // on it and each new document runs every copy in registration order.
@@ -515,55 +572,25 @@ class CoveragePhaseController {
         // own attempt, so the newest wins; the fetch patch is installed once
         // and reads the attempt at call time, so a stale copy can never pin an
         // old scope onto a request the way nested wrappers would.
-        await context.addInitScript(({ attemptId, scopeHeader, scopeValue, scopeCookie, scopeSiteCookie }) => {
-            const coverageGlobal = globalThis;
-            coverageGlobal.__SUPERCOV_ATTEMPT__ = { attemptId, scopeValue };
-            coverageGlobal.__SUPERCOV_MCDC_TEST_ID__ = attemptId;
-            try {
-                document.cookie = `${scopeCookie}=${encodeURIComponent(scopeValue)}; Path=/; SameSite=Lax`;
-                // And for this document's frames on another of the app's
-                // hosts, where crossing sites is allowed.
-                if (globalThis.isSecureContext)
-                    document.cookie = `${scopeSiteCookie}=${encodeURIComponent(scopeValue)}; Path=/; SameSite=None; Secure`;
-                if (!coverageGlobal.__SUPERCOV_BROWSER_FETCH_PATCHED__) {
-                    const originalFetch = globalThis.fetch?.bind(globalThis);
-                    if (originalFetch) {
-                        coverageGlobal.__SUPERCOV_BROWSER_FETCH_PATCHED__ = true;
-                        globalThis.fetch = ((input, init) => {
-                            // Only the page's own origin hears the scope. A
-                            // header on a request to another origin makes the
-                            // browser ask that origin first, and one that
-                            // allows only the headers it uses refuses: the
-                            // page's fetch failed under measurement alone.
-                            try {
-                                const target = new URL(input instanceof Request ? input.url : String(input), location.href);
-                                if (target.origin !== location.origin)
-                                    return originalFetch(input, init);
-                            }
-                            catch {
-                                return originalFetch(input, init);
-                            }
-                            const headers = new Headers(init?.headers ??
-                                (input instanceof Request ? input.headers : undefined));
-                            headers.set(scopeHeader, coverageGlobal.__SUPERCOV_ATTEMPT__?.scopeValue ?? scopeValue);
-                            const phase = coverageGlobal.__SUPERCOV_PHASE_ID__;
-                            if (phase)
-                                headers.set("x-supercov-phase", phase);
-                            return originalFetch(input, { ...init, headers });
-                        });
-                    }
-                }
-            }
-            catch {
-                // Browser instrumentation must not change application behavior.
-            }
-        }, {
+        parts.push(`(${announceAttempt})(${JSON.stringify({
             attemptId: this.scope.attemptId,
             scopeHeader: COVERAGE_SCOPE_HEADER,
             scopeValue: encodeCoverageScope(this.scope),
             scopeCookie: COVERAGE_SCOPE_COOKIE,
             scopeSiteCookie: COVERAGE_SCOPE_SITE_COOKIE,
-        }).catch(() => undefined);
+        })});`);
+        // A new document starts in the last action's phase, from the cookie
+        // each action sets: one script per context, where a script replaced on
+        // every page at every phase took two Playwright calls each time.
+        parts.push(`(${startDocumentInPhase})(${JSON.stringify({
+            attemptId: this.scope.attemptId,
+            phaseCookie: COVERAGE_DOCUMENT_PHASE_COOKIE,
+            phaseSiteCookie: COVERAGE_DOCUMENT_PHASE_SITE_COOKIE,
+        })});`);
+        await Promise.all([
+            context.addInitScript({ content: separately(parts) }).catch(() => undefined),
+            adopted ? undefined : this.updateContextHeaders(context, this.requestPhaseId(), this.lastActionId),
+        ]);
         const register = (page) => {
             const pending = this.registerPage(page).finally(() => this.pendingRegistrations.delete(pending));
             this.pendingRegistrations.add(pending);
@@ -576,8 +603,6 @@ class CoveragePhaseController {
         this.contextListeners.set(context, [["page", register], ["serviceworker", registerServiceWorker]]);
         for (const worker of context.serviceWorkers())
             void this.registerWorker(worker);
-        if (!adopted)
-            await this.updateContextHeaders(context, this.requestPhaseId());
         for (const page of context.pages())
             register(page);
     }
@@ -585,6 +610,9 @@ class CoveragePhaseController {
         if (this.workers.has(worker))
             return;
         this.workers.add(worker);
+        return internally(worker, () => this.registerWorkerNow(worker));
+    }
+    async registerWorkerNow(worker) {
         const phaseId = this.requestPhaseId();
         const registration = await worker
             .evaluate(({ attemptId, scopeHeader, scopeValue, phaseHeader, phase }) => {
@@ -636,12 +664,21 @@ class CoveragePhaseController {
         const phase = this.createPhase("action", operation);
         this.lastActionId = phase.id;
         this.activePhaseId = phase.id;
-        await timed("action.activateInBrowser", () => this.activateInBrowser(phase.id));
+        await timed("action.activateInBrowser", () => this.activateInBrowser(phase.id, phase.id));
         return phase;
     }
-    beginAssertion(operation, source = callerSource()) {
+    beginAssertion(operation, source = callerSource(), reachesBrowser = true) {
         timingCount("beginAssertion");
         const phase = this.createPhase("assertion", operation, this.lastActionId, source);
+        // An assertion that is over before any message could reach the
+        // browser (`expect(value).toBe(1)`) gets no browser phase: telling the
+        // page and the app's cookies afterwards labelled what the page did
+        // next, the last action's work, as this assertion's, and queued two
+        // calls ahead of the test's next action.
+        if (!reachesBrowser) {
+            timingCount("assertion.offBrowser");
+            return phase;
+        }
         this.activePhaseId = phase.id;
         // Playwright queues browser protocol commands in order. Starting this
         // evaluation before an async locator assertion is sufficient to tag its
@@ -649,12 +686,37 @@ class CoveragePhaseController {
         void timed("assertion.activateInBrowser", () => this.activateInBrowser(phase.id));
         return phase;
     }
+    /**
+     * An instrumented assertion's phase, opened around its arguments as well
+     * as its matcher, which reaches the browser just before the first thing
+     * in it that can: a call on one of the test's Playwright objects, or a
+     * matcher that waits (promotePendingAssertion). Playwright sends calls in
+     * order, so the page has the phase before anything the assertion asks of
+     * it. One that asks nothing of the page sends nothing.
+     */
+    beginBridgedAssertion(operation, source) {
+        const phase = this.beginAssertion(operation, source, false);
+        this.pendingAssertion = phase;
+        return phase;
+    }
+    promotePendingAssertion() {
+        const phase = this.pendingAssertion;
+        if (!phase)
+            return;
+        this.pendingAssertion = undefined;
+        timingCount("assertion.promoted");
+        this.activePhaseId = phase.id;
+        void timed("assertion.activateInBrowser", () => this.activateInBrowser(phase.id));
+    }
     requestPhaseId() {
         return this.activePhaseId;
     }
     async dispose() {
         this.disposed = true;
         await Promise.all([...this.pendingRegistrations]);
+        return internally(this.anyOwner(), () => this.disposeNow());
+    }
+    async disposeNow() {
         await this.scriptUpdate;
         for (const [context, listeners] of this.contextListeners) {
             for (const [event, listener] of listeners)
@@ -662,6 +724,11 @@ class CoveragePhaseController {
         }
         this.contextListeners.clear();
         for (const [page, cdp] of this.cdpSessions) {
+            // A closed page took its session with it: detaching it failed for
+            // every page a test closed, each failure a Playwright error with a
+            // stack, and was the only collector call on a slice that failed.
+            if (page.isClosed?.())
+                continue;
             const identifier = this.newDocumentScriptIds.get(page);
             if (identifier)
                 await cdp
@@ -673,6 +740,8 @@ class CoveragePhaseController {
         }
     }
     finish(phase, error) {
+        if (this.pendingAssertion === phase)
+            this.pendingAssertion = undefined;
         phase.endedAtMs = Date.now();
         phase.status = error === undefined ? "passed" : "failed";
         if (error !== undefined)
@@ -695,6 +764,7 @@ class CoveragePhaseController {
                     return value;
                 const method = String(property);
                 return (...args) => {
+                    this.promotePendingAssertion();
                     const isRequest = REQUEST_METHODS.has(method) &&
                         isApiRequestContext(object);
                     if (ACTION_METHODS.has(method) || isRequest) {
@@ -818,19 +888,33 @@ class CoveragePhaseController {
      * the 43 extra seconds, with the database worker's bounded wait the
      * largest part).
      */
-    async activateInBrowser(phaseId) {
+    activateInBrowser(phaseId, documentPhaseId) {
+        return internally(this.anyOwner(), () => this.activateInBrowserNow(phaseId, documentPhaseId));
+    }
+    async activateInBrowserNow(phaseId, documentPhaseId) {
         await Promise.all([
             timed("activate.contextHeaders", () => Promise.all([...this.contexts]
                 .filter((context) => !this.adoptedContexts.has(context))
-                .map((context) => this.updateContextHeaders(context, phaseId)))),
+                .map((context) => this.updateContextHeaders(context, phaseId, documentPhaseId)))),
             this.activateFrames(phaseId),
             this.activateWorkers(phaseId),
-            timed("activate.pageScript", () => Promise.all([...this.pages].map((page) => this.activatePage(page, phaseId)))),
+            // A context whose headers are not known gets no cookies, so its
+            // pages' new documents learn the phase from a script replaced here.
+            timed("activate.pageScript", () => Promise.all([...this.pages]
+                .filter((page) => this.adoptedContexts.has(page.context()))
+                .map((page) => this.activatePage(page, phaseId)))),
         ]);
     }
-    async activateFrames(phaseId) {
-        await timed("activate.frameEvaluate", () => Promise.all([...this.pages].flatMap((page) => page.frames()).map((frame) => frame
-            .evaluate(({ id, attemptId, storageKey, scopeCookie, scopeValue, phaseCookie, scopeSiteCookie, phaseSiteCookie }) => {
+    async activateFrames(phaseId, pages = this.pages) {
+        // The app's own hosts have the phase from the context's cookies, set
+        // beside this; a document there writing them again was a round trip
+        // to the cookie store per cookie, on every action. A context whose
+        // headers are not known gets none, so its documents still write them.
+        const covered = (page) => this.adoptedContexts.has(page.context())
+            ? []
+            : this.appHosts.map((url) => new URL(url).hostname);
+        await timed("activate.frameEvaluate", () => Promise.all([...pages].flatMap((page) => page.frames().map((frame) => [frame, covered(page)])).map(([frame, coveredHosts]) => frame
+            .evaluate(({ id, attemptId, storageKey, scopeCookie, scopeValue, phaseCookie, scopeSiteCookie, phaseSiteCookie, coveredHosts }) => {
             globalThis.__SUPERCOV_PHASE_ID__ = id;
             const coverageGlobal = globalThis;
             // A document that loaded under an earlier test's attempt (a page
@@ -840,6 +924,8 @@ class CoveragePhaseController {
             coverageGlobal.__SUPERCOV_ACTIVATE_PROBE_CONTEXT__?.(attemptId, id);
             try {
                 localStorage.setItem(storageKey, id);
+                if (coveredHosts.includes(location.hostname))
+                    return;
                 document.cookie = `${scopeCookie}=${encodeURIComponent(scopeValue)}; Path=/; SameSite=Lax`;
                 document.cookie = `${phaseCookie}=${encodeURIComponent(id)}; Path=/; SameSite=Lax`;
                 if (globalThis.isSecureContext) {
@@ -859,8 +945,9 @@ class CoveragePhaseController {
             phaseCookie: COVERAGE_PHASE_COOKIE,
             scopeSiteCookie: COVERAGE_SCOPE_SITE_COOKIE,
             phaseSiteCookie: COVERAGE_PHASE_SITE_COOKIE,
+            coveredHosts,
         })
-            .catch(() => undefined))));
+            .catch(() => timingCount("activate.frameRefused")))));
     }
     async activateWorkers(phaseId) {
         await timed("activate.workerEvaluate", () => Promise.all([...this.workers].map(async (worker) => {
@@ -891,32 +978,49 @@ class CoveragePhaseController {
      * site from the first navigation on, and, on a secure origin, to frames
      * of the app's other hosts as well.
      */
-    async updateContextHeaders(context, phaseId) {
+    async updateContextHeaders(context, phaseId, documentPhaseId) {
         const scope = encodeURIComponent(encodeCoverageScope(this.scope));
         const phase = phaseId ? encodeURIComponent(phaseId) : undefined;
-        const pairs = (scopeName, phaseName) => [
+        const documentPhase = documentPhaseId ? encodeURIComponent(documentPhaseId) : undefined;
+        const pairs = (scopeName, phaseName, documentName) => [
             [scopeName, scope],
             ...(phase ? [[phaseName, phase]] : []),
+            ...(documentPhase ? [[documentName, documentPhase]] : []),
         ];
         // The context's own headers are left alone: they are the suite's, and
         // a test that sets more with `setExtraHTTPHeaders` keeps them. Setting
         // them back at every phase dropped a test's `X-Forwarded-For`.
-        await Promise.all([
-            ...this.appHosts.map((url) => {
-                const host = new URL(url);
-                // For the app's own site: requests, navigations and sockets.
-                const cookies = pairs(COVERAGE_SCOPE_COOKIE, COVERAGE_PHASE_COOKIE).map(([name, value]) => ({ name, value, url, sameSite: "Lax" }));
-                // For its frames on another of its hosts: a cookie that
-                // crosses sites must be Secure, which needs https or a local
-                // host. Chromium keeps such a cookie only when it is given by
-                // domain; given by an http URL it is dropped without a word.
-                if (host.protocol === "https:" || ["localhost", "127.0.0.1"].includes(host.hostname)) {
-                    cookies.push(...pairs(COVERAGE_SCOPE_SITE_COOKIE, COVERAGE_PHASE_SITE_COOKIE).map(([name, value]) => ({ name, value, domain: host.hostname, path: "/", sameSite: "None", secure: true })));
-                }
-                // One host refused leaves the others theirs.
-                return context.addCookies(cookies).catch(() => undefined);
-            }),
-        ]);
+        const byHost = this.appHosts.map((url) => {
+            const host = new URL(url);
+            // For the app's own site: requests, navigations and sockets.
+            const cookies = pairs(COVERAGE_SCOPE_COOKIE, COVERAGE_PHASE_COOKIE, COVERAGE_DOCUMENT_PHASE_COOKIE).map(([name, value]) => ({ name, value, url, sameSite: "Lax" }));
+            // For its frames on another of its hosts: a cookie that
+            // crosses sites must be Secure, which needs https or a local
+            // host. Chromium keeps such a cookie only when it is given by
+            // domain; given by an http URL it is dropped without a word.
+            if (host.protocol === "https:" || ["localhost", "127.0.0.1"].includes(host.hostname)) {
+                cookies.push(...pairs(COVERAGE_SCOPE_SITE_COOKIE, COVERAGE_PHASE_SITE_COOKIE, COVERAGE_DOCUMENT_PHASE_SITE_COOKIE).map(([name, value]) => ({ name, value, domain: host.hostname, path: "/", sameSite: "None", secure: true })));
+            }
+            return cookies;
+        });
+        // Every host's cookies in one call: a call per host, each its own
+        // round trip through Playwright, was most of what an action waited
+        // for. A cookie is kept per host, for every port of it: hosts that
+        // differ only by port gave the same cookies twice, and each goes once.
+        // A cookie the browser refuses fails the whole call, so then each host
+        // is given its own and one refused leaves the others theirs.
+        const distinct = new Map();
+        for (const cookie of byHost.flat()) {
+            const target = cookie.url ? new URL(cookie.url) : undefined;
+            const where = target ? `${target.protocol}//${target.hostname}${target.pathname}` : `${cookie.domain}${cookie.path}`;
+            const key = JSON.stringify([cookie.name, cookie.value, where, cookie.sameSite, cookie.secure ?? false]);
+            if (!distinct.has(key))
+                distinct.set(key, cookie);
+        }
+        await context.addCookies([...distinct.values()]).catch(() => {
+            timingCount("activate.cookiesRefused");
+            return Promise.all(byHost.map((cookies) => context.addCookies(cookies).catch(() => timingCount("activate.hostCookiesRefused"))));
+        });
     }
     async activatePage(page, phaseId) {
         const cdp = this.cdpSessions.get(page);
@@ -948,55 +1052,114 @@ class CoveragePhaseController {
  * the end of every test (20,000 events: 470 ms, against 34 ms as one JSON
  * string), and doubled a 76-test suite's time.
  */
-const LEAVING_BINDING = "__supercovLeaving";
 /**
- * One snapshot holding everything in `snapshots`, each observation once: a
- * document that left gave its evidence, and the next one on its origin
- * restored the same evidence and added to it.
+ * The attempt a new document belongs to, for the app's server: its cookies,
+ * and the header its fetch sends to its own origin.
  */
-function mergeSnapshots(snapshots) {
-    const hits = new Set();
-    const events = new Map();
-    const decisions = new Map();
-    const logicals = new Map();
-    const vectorsOf = (map, key, initial) => {
-        let entry = map.get(key);
-        if (!entry) {
-            entry = { ...initial, seen: new Map() };
-            map.set(key, entry);
-        }
-        return entry;
-    };
-    for (const snapshot of snapshots) {
-        for (const id of snapshot?.hits ?? [])
-            hits.add(id);
-        for (const event of snapshot?.events ?? [])
-            events.set(JSON.stringify(event), event);
-        for (const decision of snapshot?.decisions ?? []) {
-            const entry = vectorsOf(decisions, decision.id, { id: decision.id });
-            for (const vector of decision.vectors ?? [])
-                entry.seen.set(JSON.stringify(vector), vector);
-        }
-        for (const logical of snapshot?.logicals ?? []) {
-            const entry = vectorsOf(logicals, logical.id, { id: logical.id });
-            for (const vector of logical.vectors ?? [])
-                entry.seen.set(JSON.stringify(vector), vector);
+function announceAttempt({ attemptId, scopeHeader, scopeValue, scopeCookie, scopeSiteCookie }) {
+    const coverageGlobal = globalThis;
+    coverageGlobal.__SUPERCOV_ATTEMPT__ = { attemptId, scopeValue };
+    coverageGlobal.__SUPERCOV_MCDC_TEST_ID__ = attemptId;
+    try {
+        document.cookie = `${scopeCookie}=${encodeURIComponent(scopeValue)}; Path=/; SameSite=Lax`;
+        // And for this document's frames on another of the app's
+        // hosts, where crossing sites is allowed.
+        if (globalThis.isSecureContext)
+            document.cookie = `${scopeSiteCookie}=${encodeURIComponent(scopeValue)}; Path=/; SameSite=None; Secure`;
+        if (!coverageGlobal.__SUPERCOV_BROWSER_FETCH_PATCHED__) {
+            const originalFetch = globalThis.fetch?.bind(globalThis);
+            if (originalFetch) {
+                coverageGlobal.__SUPERCOV_BROWSER_FETCH_PATCHED__ = true;
+                globalThis.fetch = ((input, init) => {
+                    // Only the page's own origin hears the scope. A
+                    // header on a request to another origin makes the
+                    // browser ask that origin first, and one that
+                    // allows only the headers it uses refuses: the
+                    // page's fetch failed under measurement alone.
+                    try {
+                        const target = new URL(input instanceof Request ? input.url : String(input), location.href);
+                        if (target.origin !== location.origin)
+                            return originalFetch(input, init);
+                    }
+                    catch {
+                        return originalFetch(input, init);
+                    }
+                    const headers = new Headers(init?.headers ??
+                        (input instanceof Request ? input.headers : undefined));
+                    headers.set(scopeHeader, coverageGlobal.__SUPERCOV_ATTEMPT__?.scopeValue ?? scopeValue);
+                    const phase = coverageGlobal.__SUPERCOV_PHASE_ID__;
+                    if (phase)
+                        headers.set("x-supercov-phase", phase);
+                    return originalFetch(input, { ...init, headers });
+                });
+            }
         }
     }
-    return {
-        decisions: [...decisions.values()].map(({ seen, id }) => ({ id, vectors: [...seen.values()] })),
-        hits: [...hits],
-        events: [...events.values()],
-        logicals: [...logicals.values()].map(({ seen, id }) => ({ id, vectors: [...seen.values()] })),
-    };
+    catch {
+        // Browser instrumentation must not change application behavior.
+    }
+}
+const LEAVING_BINDING = "__supercovLeaving";
+/** Scripts as one, each part run on its own as separate scripts were. */
+function separately(parts) {
+    return parts.map((part) => `try {\n${part}\n} catch (error) {}`).join("\n");
+}
+/** A document that leaves hands its evidence to the test that has its page. */
+function takeLeavingEvidence(source, payload) {
+    const controller = source?.page ? controllerOwning(source.page) : undefined;
+    if (!controller || controller.runtimeSnapshots)
+        return;
+    try {
+        timingCount("transfer.leavingBytes", typeof payload === "string" ? payload.length : 0);
+        controller.leftSnapshots.push(expandSnapshot(JSON.parse(payload)));
+    }
+    catch {
+        // Not evidence.
+    }
+}
+/**
+ * What a context's documents run whichever test has them -- the runtime, and
+ * the binding through which a leaving document hands its evidence over (the
+ * next one reads what it stored only on the same origin) -- sent once, when
+ * the context is made: Playwright opens the test's page meanwhile, and the
+ * test's setup waits only for its own script and cookies. A context that
+ * outlives its test keeps the one binding: the test that has the page now
+ * takes what it hands over.
+ */
+const preparedContexts = new WeakMap();
+function prepareContext(context) {
+    let prepared = preparedContexts.get(context);
+    if (!prepared) {
+        const parts = [];
+        // A Rust crate compiled to wasm the run measures: pages remember
+        // their wasm instances, so each test's work can be taken from them.
+        if (process.env.SUPERCOV_WASM_REGIONS === "1")
+            parts.push("globalThis.__SUPERCOV_WASM_REGIONS__ = true;");
+        parts.push(browserRuntimePrelude);
+        prepared = Promise.resolve(internally(context, () => Promise.all([
+            context.addInitScript({ content: separately(parts) }).catch(() => undefined),
+            context.exposeBinding(LEAVING_BINDING, takeLeavingEvidence).catch(() => undefined),
+        ]))).catch(() => undefined);
+        preparedContexts.set(context, prepared);
+    }
+    return prepared;
 }
 function readSnapshot(target) {
     return target
         .evaluate(() => {
         const getSnapshot = globalThis.__SUPERCOV_COVERAGE_SNAPSHOT__;
-        return getSnapshot ? JSON.stringify(getSnapshot()) : undefined;
+        const compact = globalThis.__SUPERCOV_COMPACT_SNAPSHOT__;
+        if (!getSnapshot)
+            return undefined;
+        return typeof compact === "function" ? compact(getSnapshot()) : JSON.stringify(getSnapshot());
     })
-        .then((text) => (typeof text === "string" ? JSON.parse(text) : undefined));
+        .then((text) => {
+        if (typeof text !== "string")
+            return undefined;
+        // Phase timing counts the bytes each read carried, as its "ms".
+        timingCount("transfer.snapshotBytes", text.length);
+        return expandSnapshot(JSON.parse(text));
+    });
 }
 let activeController;
 let bridgedAssertionDepth = 0;
@@ -1034,6 +1197,7 @@ function trackContext(context, configuredHeaders) {
     trackedContexts.add(context);
     context.once?.("close", () => trackedContexts.delete(context));
     patchContextPrototype(context);
+    void prepareContext(context);
 }
 function liveTrackedContexts() {
     const contexts = new Set(trackedContexts);
@@ -1090,7 +1254,7 @@ function patchBrowserPrototype(browser) {
  * way the page is gone by the time the test's snapshots are collected.
  */
 /** The cookies Supercov gives a context to carry the test's scope. */
-const OWN_COOKIES = new Set([COVERAGE_SCOPE_COOKIE, COVERAGE_PHASE_COOKIE, COVERAGE_SCOPE_SITE_COOKIE, COVERAGE_PHASE_SITE_COOKIE]);
+const OWN_COOKIES = new Set([COVERAGE_SCOPE_COOKIE, COVERAGE_PHASE_COOKIE, COVERAGE_DOCUMENT_PHASE_COOKIE, COVERAGE_SCOPE_SITE_COOKIE, COVERAGE_PHASE_SITE_COOKIE, COVERAGE_DOCUMENT_PHASE_SITE_COOKIE]);
 const suiteCookies = (cookies) => (Array.isArray(cookies) ? cookies.filter((cookie) => !OWN_COOKIES.has(cookie?.name)) : cookies);
 function patchContextPrototype(context) {
     // A test reads and saves the cookies it and its app set, never
@@ -1162,7 +1326,7 @@ globalThis.__SUPERCOV_ASSERTION_PHASE_BRIDGE__ = (operation, source, callback) =
     const runtime = directRuntime();
     if (!controller || !runtime)
         return { handled: false };
-    const phase = controller.beginAssertion(operation, source);
+    const phase = controller.beginBridgedAssertion(operation, source);
     bridgedAssertionDepth += 1;
     try {
         const value = runtime.withCoverageCarrier({ version: 1, scope: controller.scope, phaseId: phase.id }, callback);
@@ -1194,7 +1358,7 @@ globalThis.__SUPERCOV_ASSERTION_PHASE_OPENER__ = (operation, source) => {
     const controller = activeController;
     if (!controller || !directRuntime())
         return undefined;
-    const phase = controller.beginAssertion(operation, source);
+    const phase = controller.beginBridgedAssertion(operation, source);
     bridgedAssertionDepth += 1;
     let held = true;
     const release = () => {
@@ -1378,7 +1542,45 @@ function installChildProcessScopePropagation() {
     syncBuiltinESMExports();
 }
 installChildProcessScopePropagation();
-function wrapMatchers(matchers, path = "expect") {
+// expect's own matchers that settle in the call, whatever they are given, on
+// a value that is no Playwright object: none of them can wait for the page.
+// Under `expect.poll`, `.resolves` or `.rejects` the same names wait.
+const SETTLED_MATCHERS = new Set([
+    "toBe",
+    "toBeCloseTo",
+    "toBeDefined",
+    "toBeFalsy",
+    "toBeGreaterThan",
+    "toBeGreaterThanOrEqual",
+    "toBeInstanceOf",
+    "toBeLessThan",
+    "toBeLessThanOrEqual",
+    "toBeNaN",
+    "toBeNull",
+    "toBeTruthy",
+    "toBeUndefined",
+    "toContain",
+    "toContainEqual",
+    "toEqual",
+    "toHaveLength",
+    "toHaveProperty",
+    "toMatch",
+    "toMatchObject",
+    "toStrictEqual",
+]);
+const PLAYWRIGHT_VALUE_TYPES = new Set(["APIResponse", "ElementHandle", "Frame", "FrameLocator", "JSHandle", "Locator", "Page"]);
+function isPlaywrightValue(value) {
+    if (!value || (typeof value !== "object" && typeof value !== "function"))
+        return false;
+    try {
+        return "_guid" in value || "_frame" in value || "_selector" in value ||
+            PLAYWRIGHT_VALUE_TYPES.has(value.constructor?.name);
+    }
+    catch {
+        return true;
+    }
+}
+function wrapMatchers(matchers, path = "expect", settles = false) {
     return new Proxy(matchers, {
         get(target, property) {
             // Matcher objects and built-ins can expose getters whose internal slots
@@ -1389,14 +1591,19 @@ function wrapMatchers(matchers, path = "expect") {
             if (value &&
                 typeof value === "object" &&
                 (name === "not" || name === "resolves" || name === "rejects"))
-                return wrapMatchers(value, `${path}.${name}`);
+                return wrapMatchers(value, `${path}.${name}`, settles && name === "not");
             if (typeof value !== "function")
                 return value;
             return (...args) => {
                 const controller = activeController;
+                const settled = settles && SETTLED_MATCHERS.has(name);
                 const phase = bridgedAssertionDepth === 0
-                    ? controller?.beginAssertion(`${path}.${name}`)
+                    ? controller?.beginAssertion(`${path}.${name}`, undefined, !settled)
                     : undefined;
+                // Inside an instrumented assertion, a matcher that can wait
+                // takes the assertion's phase to the browser before it starts.
+                if (bridgedAssertionDepth > 0 && !settled)
+                    controller?.promotePendingAssertion();
                 try {
                     const result = Reflect.apply(value, target, args);
                     if (result instanceof Promise) {
@@ -1423,21 +1630,21 @@ function wrapMatchers(matchers, path = "expect") {
         },
     });
 }
-function wrapExpectCallable(callable) {
+function wrapExpectCallable(callable, polls = false) {
     return new Proxy(callable, {
         apply(target, thisArg, argumentsList) {
             const result = Reflect.apply(target, thisArg, argumentsList);
             if (typeof result === "function")
-                return wrapExpectCallable(result);
+                return wrapExpectCallable(result, polls);
             if (result && typeof result === "object")
-                return wrapMatchers(result);
+                return wrapMatchers(result, "expect", !polls && !isPlaywrightValue(argumentsList[0]));
             return result;
         },
         get(target, property, receiver) {
             const value = Reflect.get(target, property, receiver);
             if (typeof value !== "function")
                 return value;
-            return wrapExpectCallable(value.bind(target));
+            return wrapExpectCallable(value.bind(target), polls || property === "poll");
         },
     });
 }
@@ -1467,26 +1674,6 @@ function executionScope(testInfo) {
         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 [];
-    }
-}
 function phaseSourceLine(source) {
     return source?.replace(/:\d+$/, "");
 }
@@ -1523,6 +1710,48 @@ function mergeCollectedPhases(controllerPhases, fallbackPhases) {
  * written to one uniquely named, one-shot evidence file in the runner's shared
  * directory as well. No test streams into this path.
  */
+/**
+ * A snapshot's events as columns.
+ * A page records each hit once per test as an event of five fields, and its
+ * thousands of them were most of a test's record. The engine decodes the
+ * columns into exactly these events, in this order.
+ */
+function columnarEvents(snapshot) {
+    const events = snapshot?.events;
+    if (!Array.isArray(events) || events.length === 0)
+        return snapshot;
+    const tables = { types: new Map(), phases: new Map(), environments: new Map() };
+    const index = (table, value) => {
+        let found = table.get(value);
+        if (found === undefined) {
+            found = table.size;
+            table.set(value, found);
+        }
+        return found;
+    };
+    const columns = { id: [], type: [], phase: [], environment: [], t: [], vector: {} };
+    let previous = 0;
+    events.forEach((event, position) => {
+        columns.id.push(event.id);
+        columns.type.push(index(tables.types, event.type));
+        columns.phase.push(event.phaseId == null ? -1 : index(tables.phases, event.phaseId));
+        columns.environment.push(index(tables.environments, event.environment));
+        columns.t.push(event.timestampMs - previous);
+        previous = event.timestampMs;
+        if (event.vector !== undefined)
+            columns.vector[position] = event.vector;
+    });
+    const { events: _events, ...rest } = snapshot;
+    return {
+        ...rest,
+        eventColumns: {
+            types: [...tables.types.keys()],
+            phases: [...tables.phases.keys()],
+            environments: [...tables.environments.keys()],
+            ...columns,
+        },
+    };
+}
 function appendEvidenceLine(serialized) {
     const evidenceDirectory = process.env["SUPERCOV_EVIDENCE_DIR"] ??
         (GENERATED_EVIDENCE_DIRECTORY.startsWith("__")
@@ -1542,7 +1771,7 @@ const instrumentedFixtures = {
         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);
+        await timed("fixture.pageSetup", () => controller.registerPage(page));
         try {
             await use(controller.wrap(page));
         }
@@ -1550,7 +1779,7 @@ const instrumentedFixtures = {
             // 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();
+            await timed("fixture.pageTeardown", () => controller.collectRuntimeSnapshots());
         }
     },
     browser: [
@@ -1580,12 +1809,25 @@ const instrumentedFixtures = {
         async ({}, use, testInfo) => {
             const scope = executionScope(testInfo);
             const configuredHeaders = Object.fromEntries(Object.entries(testInfo.project.use.extraHTTPHeaders ?? {}).map(([name, value]) => [name, String(value)]));
+            const setupStarted = performance.now();
             const controller = new CoveragePhaseController(scope, configuredHeaders, testInfo.project.use.baseURL);
             controllers.set(scope.attemptId, controller);
             activeController = controller;
             directRuntime()?.activateCoverageScope(scope);
-            await controller.adoptTrackedContexts().catch(() => undefined);
-            const carried = await controller.takeCarriedEvidence().catch(() => undefined);
+            // The pages the test starts with, whose evidence is taken while
+            // their contexts are registered.
+            const startingPages = [...liveTrackedContexts()].flatMap((context) => {
+                try {
+                    return context.pages();
+                }
+                catch {
+                    return [];
+                }
+            });
+            const [, carried] = await Promise.all([
+                timed("fixture.adopt", () => controller.adoptTrackedContexts().catch(() => undefined)),
+                timed("fixture.carried", () => controller.takeCarriedEvidence(startingPages).catch(() => undefined)),
+            ]);
             if (carried) {
                 appendEvidenceLine(`${JSON.stringify({
                     testId: `__supercov_background__:playwright:${scope.attemptId}`,
@@ -1593,7 +1835,7 @@ const instrumentedFixtures = {
                     status: "unknown",
                     provenance: { runner: "background", kind: "background", source: "explicit" },
                     role: "background",
-                    browser: [carried],
+                    browser: [columnarEvents(carried)],
                 })}\n`);
             }
             const serverOutput = serverEvidencePath(scope);
@@ -1603,14 +1845,15 @@ const instrumentedFixtures = {
             // no test is credited by time to the one test running then, and a
             // test is running for all of this, not only during its actions.
             const startedAtMs = Date.now();
+            timingCount("fixture.testSetup", performance.now() - setupStarted);
             try {
                 await use();
             }
             finally {
+                const teardownStarted = performance.now();
                 const endedAtMs = Date.now();
                 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.
@@ -1635,14 +1878,14 @@ const instrumentedFixtures = {
                         }),
                         phases: mergeCollectedPhases(controller.phases, directRuntime()?.takeNodeAssertionPhases(scope) ?? []),
                         ...(controller.workerEvidenceMissing ? { attribution: "partial" } : {}),
-                        browser,
-                        server,
+                        browser: browser.map(columnarEvents),
                         span: [startedAtMs, endedAtMs],
                     };
                     appendEvidenceLine(`${JSON.stringify(payload)}\n`);
                 }
                 finally {
                     await timed("controller.dispose", () => controller.dispose());
+                    timingCount("fixture.testTeardown", performance.now() - teardownStarted);
                     timingReport(testInfo.title);
                     directRuntime()?.activateCoverageScope();
                     if (activeController === controller)
@@ -1656,6 +1899,10 @@ const instrumentedFixtures = {
 };
 const instrumentedTest = base.extend(instrumentedFixtures);
 export const test = instrumentedTest;
+// `export *` passes no default on, and `import test from "@playwright/test"`
+// is Playwright's own default export: such a spec found none and failed with
+// `(0 , _test.default) is not a function`.
+export default instrumentedTest;
 /**
  * A Playwright `test` object: callable, and carrying the API a spec drives.
  * Facades export several -- one per fixture set -- and every one of them must