supercov 0.0.31 → 0.0.33

package/README.md

@@ -109,11 +109,12 @@ The denominator comes from source structure before the run, so adding or removin
 | TypeScript | Available | `npx supercov -- npm test` |
 | Rust | Available | `npx supercov -- cargo test` |
 | Python | Available | `npx supercov -- pytest` |
+| Ruby | Available | `npx supercov -- rspec` |
 | Zig | Coming soon | — |
 | PHP | Coming soon | — |
 | C | Coming soon | — |
 
-Supercov requires Node.js 22 or newer. Rust support currently uses Rust 1.95; cargo-nextest 0.9.138 and 0.9.140 are supported. Python support requires CPython 3.12 or newer and measures pytest and unittest runs.
+Supercov requires Node.js 22 or newer. Rust support currently uses Rust 1.95; cargo-nextest 0.9.138 and 0.9.140 are supported. Python support requires CPython 3.12 or newer and measures pytest and unittest runs. Ruby support requires Ruby 3.3 or newer (3.4 or newer for full measurement) and measures RSpec, Minitest, test-unit and Cucumber runs.
 
 ## Supported test suites
 

package/docs/getting-started.md

@@ -9,7 +9,7 @@ npx supercov -- npm test
 ```
 
 No account, config file, import, custom reporter, or hosted service is required.
-Supercov supports JavaScript, TypeScript, Rust, and Python today.
+Supercov supports JavaScript, TypeScript, Rust, Python, and Ruby today.
 
 ## Before you start
 
@@ -18,7 +18,8 @@ You need:
 - Node.js 22 or newer;
 - a test command that already works in the repository; and
 - for Rust, the Rust 1.95 toolchain;
-- for Python, CPython 3.12 or newer with pytest or unittest.
+- for Python, CPython 3.12 or newer with pytest or unittest;
+- for Ruby, Ruby 3.4 or newer with RSpec, Minitest, test-unit or Cucumber (3.3 measures lines, methods and simple branches only).
 
 The CLI is distributed through npm, even for Rust projects. The first `npx`
 invocation may download Supercov from the npm registry. Supercov itself does not
@@ -41,6 +42,9 @@ npx supercov -- cargo nextest run
 
 # Python
 npx supercov -- pytest
+
+# Ruby
+npx supercov -- rspec
 ```
 
 Supercov runs that command in an isolated, instrumented copy of the project.

package/docs/supported-suites.md

@@ -1,6 +1,6 @@
 # Supported languages and test suites
 
-Supercov supports JavaScript, TypeScript, Rust, and Python today. Start with
+Supercov supports JavaScript, TypeScript, Rust, Python, and Ruby today. Start with
 the same test command the repository already uses; Supercov detects supported
 runners inside that command.
 
@@ -9,6 +9,7 @@ npx supercov -- npm test
 npx supercov -- npx playwright test
 npx supercov -- cargo test
 npx supercov -- pytest
+npx supercov -- rspec
 ```
 
 ## Language support
@@ -19,6 +20,7 @@ npx supercov -- pytest
 | TypeScript | Available | `npx supercov -- npm test` |
 | Rust | Available | `npx supercov -- cargo test` |
 | Python | Available | `npx supercov -- pytest` |
+| Ruby | Available | `npx supercov -- rspec` |
 | Zig | Coming soon | — |
 | PHP | Coming soon | — |
 | C | Coming soon | — |
@@ -67,6 +69,14 @@ Playwright support includes Chromium, Firefox, and WebKit, along with pages,
 frames, popups, workers, request contexts, WebSockets, and test-launched child
 processes where the runner exposes their identity.
 
+Browsers a suite launches itself are covered too. A fixture that calls
+`chromium.launchPersistentContext`, or `launch`/`connect` and hands out its own
+contexts and pages in place of Playwright's `page` fixture, is adopted by each
+test's collector: its pages are read before the fixture closes them, and a
+context kept for the whole worker follows the current test's identity. Actions
+on such pages are not recorded as separate phases, so their evidence is
+attributed to the test and its assertions rather than to individual clicks.
+
 Node child processes inherit coverage automatically. Long-running servers get
 a short drain window after the test command finishes so buffered evidence can
 arrive. Work without a reliable test identity is kept as background coverage
@@ -129,6 +139,87 @@ npx supercov -- uv run pytest
 npx supercov -- python -m unittest
 ```
 
+## Ruby
+
+| Runner | Attribution | Current requirement |
+| --- | --- | --- |
+| RSpec | Exact example and before/example/after phase identity | Ruby 3.4 or newer for full measurement; run with `npx supercov -- rspec` or `bundle exec rspec` |
+| Minitest (including Minitest::Spec and ActiveSupport::TestCase) | Exact test and setup/test/teardown identity; skips recorded | `ruby -Itest ...`, `rake test`, `rails test` |
+| test-unit | Exact test and setup/test/teardown identity; omissions and pendings recorded | `ruby -Itest ...`, `rake test` |
+| parallel_tests, Rails process workers | Exact per worker process | Workers inherit the run through `RUBYOPT`; verified on a Rails app with bootsnap, Zeitwerk and two forked workers |
+| Thread-parallel Minitest (`parallelize_me!`, `parallelize(with: :threads)`) | Probe observations exact per test; line, method and simple-branch observations made while phases overlapped go to the run, declared | |
+| Cucumber | Exact scenario identity (`features/x.feature:LINE`), hook steps as setup/teardown | `cucumber`, `bundle exec cucumber` |
+
+Supercov measures Ruby with Ruby's own `Coverage` module plus probe calls it
+splices into application files in memory as they load. Nothing on disk is
+rewritten or copied; the project runs with its own interpreter and bundle, and
+Supercov only adds a `-r` entry to `RUBYOPT` and a few `SUPERCOV_*` variables.
+No insertion adds a line, so backtraces keep their line numbers.
+
+Measured obligations are statements, method definitions, `if`/`unless`/
+ternary/`while`/`until` decisions with MC/DC vectors over `&&`/`||` operands,
+`while`/`until`/`for` iteration and the idiomatic iterator blocks (`each`,
+`map`, `times`, `select`, ...), `&&`/`||`/`||=`/`&&=` short-circuiting,
+`case`/`when`, `case`/`in` and `&.` selection, and `begin`/`rescue` completion,
+handler selection and propagation. `||=` and `&&=` on method-call, index and
+constant targets are exact too: an arrival probe and a right-side probe count
+the skipped side without re-reading the target. Blocks and lambdas are
+statements inside their methods, not function entry points, and that includes
+a `define_method` block: Ruby's own method coverage reports one entry per
+method it defines, but the block's body is measured statement by statement
+instead of as a definition.
+
+A statement on a line Ruby's own line table never counts (`x = case`, a
+multi-line literal assignment, a bare `begin`, `if false`) gets a probe at load
+time instead.
+`if true`/`if false`/`if nil` and other literal predicates are folded the way
+Ruby folds them: no branch, and the dead arm is not an obligation. A Spring
+preloader started before the run has no hook and fails closed; JRuby and
+TruffleRuby are not supported.
+
+The runtime loads through `RUBYOPT` before Bundler and requires only
+`coverage`, so it never activates a gem an application's Gemfile pins
+differently. Insertions are checked against Ruby itself by a sweep
+(`scripts/ruby-position-sweep.rb`) over Ruby's whole standard library and the
+Rails, Rack, RSpec, Minitest and Cucumber gems, about 3,000 files: every file
+is transformed and compiled, and every position Supercov expects is compared
+with what Ruby reports. With `--load` each file also runs twice, untouched and
+transformed, so the probes are proven to preserve behaviour and every method
+position is checked.
+
+A `begin` whose body ends in an expression that can `return` from inside
+itself has its handlers and propagation measured as usual, but its normal
+completion is declared instead of probed unless every branch of that
+expression can carry the probe: Ruby cannot pass such an expression as an
+argument, which is what a probe wrapper does.
+
+Measuring never breaks the program being measured. If a file cannot be
+compiled with its probes, it loads unmodified: Ruby's `Coverage` still
+measures its lines, methods and own branches, and only the obligations a
+probe would have proven are declared for that file. Setting
+`SUPERCOV_RUBY_SKIP_PROBES` to a comma-separated list of path fragments puts
+chosen files on that same path deliberately, which is the escape hatch if
+instrumentation ever disagrees with one of yours.
+
+An obligation Supercov declares unmeasured leaves the obligation totals and is
+reported as a measurement limit rather than a gap. Its line still counts in
+the line total, as it does for every other language, so a file with declared
+obligations reads slightly pessimistically on lines.
+
+Ruby 3.3 does not apply its `Coverage` module to code compiled by a load hook,
+so on 3.3 Supercov measures through `Coverage` alone: lines, methods and the
+branches Ruby reports itself. Everything that needs a probe (multi-condition
+decisions, `||=`, loops, `rescue` flow, a second statement on a line) is
+declared unmeasured on that interpreter rather than shown as a gap. Ruby 3.4
+and newer measure everything.
+
+```sh
+npx supercov -- rspec
+npx supercov -- bundle exec rspec
+npx supercov -- ruby -Itest test/shapes_test.rb
+npx supercov -- bin/rails test
+```
+
 ## Containers, VMs, and remote execution
 
 Supercov can collect from supported processes launched through a container, VM,

package/docs/troubleshooting.md

@@ -60,6 +60,21 @@ Compare the command with [Supported suites](supported-suites.md). If the runner
 should be supported, preserve the summary and exact command when reporting the
 problem.
 
+## A Ruby file behaves differently while Supercov measures it
+
+Supercov splices probe calls into Ruby sources in memory as they load, and a
+file that cannot be compiled with them is measured through Ruby's `Coverage`
+module alone rather than failing the run. To put a file on that path
+deliberately, name a fragment of its path:
+
+```sh
+SUPERCOV_RUBY_SKIP_PROBES=app/models/order.rb npx supercov -- bundle exec rspec
+```
+
+Its lines, methods and simple branches stay measured; everything that needs a
+probe is declared as a measurement limit for that file. Please report the file,
+since Supercov aims to instrument every Ruby source correctly.
+
 ## A run is marked stale
 
 A stored run remains valid history, but it stops describing the current

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supercov",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "description": "Zero-edit, runner-aware coverage completeness for JavaScript, TypeScript, Rust, and Python test suites",
   "license": "MIT",
   "repository": {
@@ -50,7 +50,7 @@
     "test:watchdog": "cargo build -p supercov && node scripts/watchdog-integration.mjs",
     "test:engine-contract": "cargo build -p supercov && node scripts/engine-contract.mjs",
     "test:agent": "cargo build -p supercov && node scripts/agent-query-eval.mjs",
-    "test:engine": "cargo fmt --all -- --check && cargo clippy --workspace --all-targets -- -D warnings && cargo test --workspace && cargo build -p supercov && npm run test:runtime && npm run test:rust-assets && node scripts/rust-process-supervision.mjs && node scripts/rust-direct-node-integration.mjs && node scripts/rust-public-run-integration.mjs && node scripts/rust-embedded-runtime-integration.mjs && node scripts/rust-direct-vitest-integration.mjs && node scripts/rust-direct-playwright-integration.mjs && node scripts/rust-generic-esbuild-integration.mjs && node scripts/rust-generic-tsc-integration.mjs && node scripts/rust-generic-build-matrix.mjs && node scripts/rust-vite-playwright-integration.mjs",
+    "test:engine": "cargo fmt --all -- --check && cargo clippy --workspace --all-targets -- -D warnings && cargo test --workspace && cargo build -p supercov && npm run test:runtime && npm run test:rust-assets && node scripts/rust-process-supervision.mjs && node scripts/rust-direct-node-integration.mjs && node scripts/rust-public-run-integration.mjs && node scripts/rust-embedded-runtime-integration.mjs && node scripts/rust-direct-vitest-integration.mjs && node scripts/rust-direct-playwright-integration.mjs && node scripts/rust-custom-browser-playwright-integration.mjs && node scripts/rust-generic-esbuild-integration.mjs && node scripts/rust-generic-tsc-integration.mjs && node scripts/rust-generic-build-matrix.mjs && node scripts/rust-vite-playwright-integration.mjs",
     "test:platform": "cargo test --workspace && cargo build -p supercov && node scripts/rust-process-supervision.mjs && node scripts/workspace-crash-integration.mjs",
     "test:native-package": "cargo build --release -p supercov && node scripts/native-package-integration.mjs && node scripts/native-release-set-integration.mjs",
     "test:pypi-wheel": "node scripts/pypi-wheel-integration.mjs",
@@ -64,18 +64,19 @@
     "benchmark:check": "cargo build --release -p supercov && node scripts/rust-transform-benchmark.mjs",
     "benchmark:python-monitoring": "cargo build -p supercov && node scripts/python-monitoring-benchmark.mjs",
     "check": "cargo fmt --all -- --check && cargo clippy --workspace --all-targets -- -D warnings && npm run test && npm run test:runtime && npm run test:rust-assets && node scripts/package-preflight.mjs",
-    "release:check": "npm run check && npm run test:engine && npm run test:fixture && npm run test:watchdog && npm run test:engine-contract && npm run test:agent && npm run test:python-monitoring && npm run test:packed-npx && npm run test:clang-mcdc && npm run benchmark:check",
+    "release:check": "npm run check && npm run test:engine && npm run test:fixture && npm run test:watchdog && npm run test:engine-contract && npm run test:agent && npm run test:python-monitoring && npm run test:ruby-coverage && npm run test:packed-npx && npm run test:clang-mcdc && npm run benchmark:check",
     "prepack": "node scripts/package-preflight.mjs",
     "prepublishOnly": "npm run release:check",
-    "test:python-monitoring": "cargo build -p supercov && node scripts/python-monitoring-integration.mjs"
+    "test:python-monitoring": "cargo build -p supercov && node scripts/python-monitoring-integration.mjs",
+    "test:ruby-coverage": "cargo build -p supercov && node scripts/ruby-coverage-integration.mjs"
   },
   "optionalDependencies": {
-    "@supercov/cli-darwin-arm64": "0.0.31",
-    "@supercov/cli-darwin-x64": "0.0.31",
-    "@supercov/cli-linux-arm64-gnu": "0.0.31",
-    "@supercov/cli-linux-arm64-musl": "0.0.31",
-    "@supercov/cli-linux-x64-gnu": "0.0.31",
-    "@supercov/cli-linux-x64-musl": "0.0.31"
+    "@supercov/cli-darwin-arm64": "0.0.33",
+    "@supercov/cli-darwin-x64": "0.0.33",
+    "@supercov/cli-linux-arm64-gnu": "0.0.33",
+    "@supercov/cli-linux-arm64-musl": "0.0.33",
+    "@supercov/cli-linux-x64-gnu": "0.0.33",
+    "@supercov/cli-linux-x64-musl": "0.0.33"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.55.0",

package/runtime/javascript/playwright.js

@@ -168,6 +168,20 @@ class CoveragePhaseController {
     scriptUpdate = Promise.resolve();
     proxyCache = new WeakMap();
     runtimeSnapshots;
+    // Contexts this controller found rather than created: it does not know
+    // what `extraHTTPHeaders` their owner configured, so it must not rewrite
+    // them (the scope cookie and the fetch patch still carry attribution).
+    adoptedContexts = new Set();
+    // Listeners installed on contexts that outlive this test, removed on
+    // dispose so a worker-scoped context does not keep registering pages with
+    // controllers of tests that already finished.
+    contextListeners = new Map();
+    // Snapshots read from pages the suite closed before teardown. A `page`
+    // fixture override tears down before the collector's own fixture, and a
+    // closed page cannot be evaluated, so the evidence is taken on the way out.
+    earlySnapshots = [];
+    snapshottedPages = new WeakSet();
+    disposed = false;
     // Parameter properties are stateful despite the base ESLint rule treating
     // this as an empty constructor.
     // eslint-disable-next-line no-useless-constructor
@@ -185,21 +199,15 @@ class CoveragePhaseController {
         if (this.runtimeSnapshots)
             return this.runtimeSnapshots;
         timingCount("collectRuntimeSnapshots.cold");
-        const snapshots = [];
+        // Contexts the suite created without going through any fixture the
+        // collector wraps (a raw `browser.newContext()` mid-test) are found
+        // through their browser now, so their still-open pages are read too.
+        await this.adoptTrackedContexts().catch(() => undefined);
+        const snapshots = [...this.earlySnapshots];
         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);
-            }
+            if (this.snapshottedPages.has(page))
+                continue;
+            snapshots.push(...(await this.snapshotPage(page)));
         }
         for (const worker of this.allWorkers()) {
             const snapshot = await worker
@@ -217,12 +225,50 @@ class CoveragePhaseController {
         this.runtimeSnapshots = snapshots;
         return snapshots;
     }
+    async snapshotPage(page) {
+        const snapshots = [];
+        for (const frame of page.frames()) {
+            snapshots.push(await frame
+                .evaluate(() => {
+                const getSnapshot = globalThis.__SUPERCOV_COVERAGE_SNAPSHOT__;
+                return getSnapshot?.() ?? { decisions: [], hits: [], events: [] };
+            })
+                .catch(() => ({
+                decisions: [],
+                hits: [],
+                events: [],
+            })));
+        }
+        return snapshots;
+    }
+    /** Read a registered page's evidence while it can still be evaluated. */
+    async snapshotBeforeClose(page) {
+        if (!this.pages.has(page) || this.snapshottedPages.has(page) || this.runtimeSnapshots)
+            return;
+        this.snapshottedPages.add(page);
+        this.earlySnapshots.push(...(await this.snapshotPage(page)));
+    }
+    /**
+     * Register every live context the process created outside the wrapped
+     * fixtures: contexts launched directly (`launchPersistentContext`) and
+     * every context of every browser launched or connected directly.
+     */
+    async adoptTrackedContexts() {
+        if (this.disposed)
+            return;
+        for (const context of liveTrackedContexts()) {
+            if (!this.contexts.has(context))
+                await this.registerContext(context, this.configuredHeaders, { adopted: true }).catch(() => undefined);
+        }
+    }
     async registerPage(page) {
-        if (this.pages.has(page))
+        if (this.pages.has(page) || this.disposed)
             return;
         timingCount("registerPage");
         this.pages.add(page);
-        await this.registerContext(page.context());
+        await this.registerContext(page.context(), this.configuredHeaders, {
+            adopted: !this.contexts.has(page.context()) && liveTrackedContexts().has(page.context()),
+        });
         const cdp = await page.context().newCDPSession(page).catch(() => undefined);
         if (cdp)
             this.cdpSessions.set(page, cdp);
@@ -235,26 +281,40 @@ class CoveragePhaseController {
         for (const worker of page.workers())
             void this.registerWorker(worker);
     }
-    async registerContext(context, configuredHeaders = this.configuredHeaders) {
-        if (this.contexts.has(context))
+    async registerContext(context, configuredHeaders = this.configuredHeaders, { adopted = false } = {}) {
+        if (this.contexts.has(context) || this.disposed)
             return;
         this.contexts.add(context);
         this.contextConfiguredHeaders.set(context, configuredHeaders);
+        if (adopted)
+            this.adoptedContexts.add(context);
+        // 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.
+        // That is made harmless rather than avoided: every copy publishes its
+        // 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 }) => {
-            globalThis.__SUPERCOV_MCDC_TEST_ID__ = attemptId;
+            const coverageGlobal = globalThis;
+            coverageGlobal.__SUPERCOV_ATTEMPT__ = { attemptId, scopeValue };
+            coverageGlobal.__SUPERCOV_MCDC_TEST_ID__ = attemptId;
             try {
                 document.cookie = `${scopeCookie}=${encodeURIComponent(scopeValue)}; Path=/; SameSite=Lax`;
-                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 });
-                    });
+                if (!coverageGlobal.__SUPERCOV_BROWSER_FETCH_PATCHED__) {
+                    const originalFetch = globalThis.fetch?.bind(globalThis);
+                    if (originalFetch) {
+                        coverageGlobal.__SUPERCOV_BROWSER_FETCH_PATCHED__ = true;
+                        globalThis.fetch = ((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 {
@@ -265,18 +325,21 @@ class CoveragePhaseController {
             scopeHeader: COVERAGE_SCOPE_HEADER,
             scopeValue: encodeCoverageScope(this.scope),
             scopeCookie: COVERAGE_SCOPE_COOKIE,
-        });
+        }).catch(() => undefined);
         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) => {
+        const registerServiceWorker = (worker) => {
             void this.registerWorker(worker);
-        });
+        };
+        context.on("page", register);
+        context.on("serviceworker", registerServiceWorker);
+        this.contextListeners.set(context, [["page", register], ["serviceworker", registerServiceWorker]]);
         for (const worker of context.serviceWorkers())
             void this.registerWorker(worker);
-        await this.updateContextHeaders(context, this.requestPhaseId());
+        if (!adopted)
+            await this.updateContextHeaders(context, this.requestPhaseId());
         for (const page of context.pages())
             register(page);
     }
@@ -333,8 +396,14 @@ class CoveragePhaseController {
         return this.activePhaseId;
     }
     async dispose() {
+        this.disposed = true;
         await Promise.all([...this.pendingRegistrations]);
         await this.scriptUpdate;
+        for (const [context, listeners] of this.contextListeners) {
+            for (const [event, listener] of listeners)
+                context.off?.(event, listener);
+        }
+        this.contextListeners.clear();
         for (const [page, cdp] of this.cdpSessions) {
             const identifier = this.newDocumentScriptIds.get(page);
             if (identifier)
@@ -431,10 +500,15 @@ class CoveragePhaseController {
             ArrayBuffer.isView(result))
             return result;
         const candidate = result;
+        if (typeof candidate["contexts"] === "function" &&
+            typeof candidate["newContext"] === "function")
+            trackBrowser(result);
         if (typeof candidate["pages"] === "function" &&
-            typeof candidate["route"] === "function")
+            typeof candidate["route"] === "function") {
+            trackContext(result);
             await this.registerContext(result, (sourceArgs?.[0]
                 ?.extraHTTPHeaders ?? this.configuredHeaders));
+        }
         if (typeof candidate["frames"] === "function" &&
             typeof candidate["context"] === "function")
             await this.registerPage(result);
@@ -472,12 +546,18 @@ class CoveragePhaseController {
         return scoped;
     }
     async activateInBrowser(phaseId) {
-        await timed("activate.contextHeaders", () => Promise.all([...this.contexts].map((context) => this.updateContextHeaders(context, phaseId))));
+        await timed("activate.contextHeaders", () => Promise.all([...this.contexts]
+            .filter((context) => !this.adoptedContexts.has(context))
+            .map((context) => this.updateContextHeaders(context, phaseId))));
         await timed("activate.frameEvaluate", () => Promise.all([...this.pages].flatMap((page) => page.frames()).map((frame) => frame
-            .evaluate(({ id, storageKey, scopeCookie, scopeValue, phaseCookie }) => {
+            .evaluate(({ id, attemptId, storageKey, scopeCookie, scopeValue, phaseCookie }) => {
             globalThis.__SUPERCOV_PHASE_ID__ = id;
             const coverageGlobal = globalThis;
-            coverageGlobal.__SUPERCOV_ACTIVATE_PROBE_CONTEXT__?.(coverageGlobal.__SUPERCOV_MCDC_TEST_ID__ ?? "unscoped", id);
+            // A document that loaded under an earlier test's attempt (a page
+            // adopted mid-life from a shared context) follows the current one.
+            coverageGlobal.__SUPERCOV_ATTEMPT__ = { attemptId, scopeValue };
+            coverageGlobal.__SUPERCOV_MCDC_TEST_ID__ = attemptId;
+            coverageGlobal.__SUPERCOV_ACTIVATE_PROBE_CONTEXT__?.(attemptId, id);
             try {
                 localStorage.setItem(storageKey, id);
                 document.cookie = `${scopeCookie}=${encodeURIComponent(scopeValue)}; Path=/; SameSite=Lax`;
@@ -488,6 +568,7 @@ class CoveragePhaseController {
             }
         }, {
             id: phaseId,
+            attemptId: this.scope.attemptId,
             storageKey: PHASE_STORAGE_KEY,
             scopeCookie: COVERAGE_SCOPE_COOKIE,
             scopeValue: encodeCoverageScope(this.scope),
@@ -538,6 +619,129 @@ class CoveragePhaseController {
 let activeController;
 let bridgedAssertionDepth = 0;
 const controllers = new Map();
+// Browsers and contexts the process created without any fixture the collector
+// wraps. Test harnesses routinely launch their own browser in a worker-scoped
+// fixture (`chromium.launchPersistentContext` for a shared profile,
+// `chromium.launch`/`connect` plus `browser.newContext()` per test) and
+// override `page` on top; those objects never pass through the `browser`/`page`
+// fixtures, and imports made from inside node_modules are never redirected to
+// this shim, so wrapping exports would not see them either. Every page they
+// opened ran unmeasured. The Playwright classes are patched below so such
+// launches are recorded here, and each test's controller adopts what is live.
+const trackedBrowsers = new Set();
+const trackedContexts = new Set();
+const patchedPrototypes = new WeakSet();
+function trackBrowser(browser) {
+    if (!browser || typeof browser !== "object" || trackedBrowsers.has(browser))
+        return;
+    trackedBrowsers.add(browser);
+    browser.once?.("disconnected", () => trackedBrowsers.delete(browser));
+    patchBrowserPrototype(browser);
+}
+function trackContext(context) {
+    if (!context || typeof context !== "object" || trackedContexts.has(context))
+        return;
+    trackedContexts.add(context);
+    context.once?.("close", () => trackedContexts.delete(context));
+    patchContextPrototype(context);
+}
+function liveTrackedContexts() {
+    const contexts = new Set(trackedContexts);
+    for (const browser of trackedBrowsers) {
+        try {
+            for (const context of browser.contexts())
+                contexts.add(context);
+        }
+        catch {
+            // A browser that disconnected between the event and this sweep.
+        }
+    }
+    return contexts;
+}
+/** The controller that registered `page`, whichever test it belongs to. */
+function controllerOwning(page) {
+    if (activeController?.pages.has(page))
+        return activeController;
+    for (const controller of controllers.values())
+        if (controller.pages.has(page))
+            return controller;
+    return undefined;
+}
+function patchOnce(target, method, replace) {
+    const prototype = target && Object.getPrototypeOf(target);
+    if (!prototype || typeof prototype[method] !== "function")
+        return;
+    const marker = `__SUPERCOV_PATCHED_${method}__`;
+    if (prototype[marker])
+        return;
+    Object.defineProperty(prototype, marker, { value: true });
+    prototype[method] = replace(prototype[method]);
+}
+/** Record every context a directly launched or connected browser creates. */
+function patchBrowserPrototype(browser) {
+    const prototype = Object.getPrototypeOf(browser);
+    if (!prototype || patchedPrototypes.has(prototype))
+        return;
+    patchedPrototypes.add(prototype);
+    patchOnce(browser, "newContext", (original) => async function (...args) {
+        const context = await original.apply(this, args);
+        trackContext(context);
+        const controller = activeController;
+        if (controller && !controller.contexts.has(context))
+            await controller.registerContext(context, args[0]?.extraHTTPHeaders ?? controller.configuredHeaders, { adopted: true }).catch(() => undefined);
+        return context;
+    });
+}
+/**
+ * Read a page's evidence before the suite closes it. A `page` fixture defined
+ * downstream of this shim tears down before the collector's own fixture, and
+ * a customer context opened mid-test is usually closed in a `finally`; either
+ * way the page is gone by the time the test's snapshots are collected.
+ */
+function patchContextPrototype(context) {
+    patchOnce(context, "close", (original) => async function (...args) {
+        for (const page of this.pages()) {
+            await controllerOwning(page)?.snapshotBeforeClose(page).catch(() => undefined);
+        }
+        return original.apply(this, args);
+    });
+    for (const page of context.pages())
+        patchPagePrototype(page);
+    context.on?.("page", patchPagePrototype);
+}
+function patchPagePrototype(page) {
+    patchOnce(page, "close", (original) => async function (...args) {
+        await controllerOwning(this)?.snapshotBeforeClose(this).catch(() => undefined);
+        return original.apply(this, args);
+    });
+}
+/**
+ * Patch the browser types' launch and connect paths on their shared prototype
+ * so every browser or context the process creates is tracked, whichever module
+ * path imported them. When a test is running its controller registers the new
+ * object at once; otherwise the next controller adopts it.
+ */
+function installBrowserLaunchTracking() {
+    const browserType = standardPlaywright.chromium ?? standardPlaywright.firefox ?? standardPlaywright.webkit;
+    if (!browserType)
+        return;
+    for (const method of ["launch", "connect", "connectOverCDP"]) {
+        patchOnce(browserType, method, (original) => async function (...args) {
+            const browser = await original.apply(this, args);
+            trackBrowser(browser);
+            return browser;
+        });
+    }
+    patchOnce(browserType, "launchPersistentContext", (original) => async function (...args) {
+        const context = await original.apply(this, args);
+        trackContext(context);
+        const controller = activeController;
+        if (controller)
+            await controller.registerContext(context, args[1]?.extraHTTPHeaders ?? controller.configuredHeaders, { adopted: true }).catch(() => undefined);
+        return context;
+    });
+}
+installBrowserLaunchTracking();
 const directRuntime = () => globalThis.__SUPERCOV_DIRECT_RUNTIME__ ?? coverageRuntime;
 globalThis.__SUPERCOV_ASSERTION_PHASE_BRIDGE__ = (operation, source, callback) => {
     const controller = activeController;
@@ -839,7 +1043,7 @@ function mergeCollectedPhases(controllerPhases, fallbackPhases) {
     });
     return [...controllerPhases, ...remaining];
 }
-const instrumentedTest = base.extend({
+const instrumentedFixtures = {
     page: async ({ page }, use, testInfo) => {
         const scope = executionScope(testInfo);
         const controller = controllers.get(scope.attemptId);
@@ -887,6 +1091,7 @@ const instrumentedTest = base.extend({
             controllers.set(scope.attemptId, controller);
             activeController = controller;
             directRuntime()?.activateCoverageScope(scope);
+            await controller.adoptTrackedContexts().catch(() => undefined);
             const serverOutput = serverEvidencePath(scope);
             mkdirSync(serverEvidenceDirectory(scope), { recursive: true });
             rmSync(serverOutput, { force: true });
@@ -951,6 +1156,31 @@ const instrumentedTest = base.extend({
         },
         { auto: true },
     ],
-});
+};
+const instrumentedTest = base.extend(instrumentedFixtures);
 export const test = 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
+ * collect. Instrumenting only the discovered export left a real suite's
+ * storefront fixture entirely unmeasured: its 20 tests ran with no controller,
+ * so nothing they executed was ever read back.
+ */
+function isPlaywrightTest(value) {
+    return typeof value === "function" &&
+        typeof value.extend === "function" &&
+        typeof value.describe === "function" &&
+        typeof value.use === "function";
+}
+/**
+ * Re-export one of the facade's values. A test object is extended with the
+ * collector's fixtures; the overrides compose with the facade's own (`page`
+ * receives the facade's page and wraps it), so a custom browser fixture keeps
+ * working and is measured. Anything else passes through untouched.
+ */
+export function __supercovAdapterExport(value) {
+    if (!isPlaywrightTest(value))
+        return value;
+    return value === base ? instrumentedTest : value.extend(instrumentedFixtures);
+}
 /*__SUPERCOV_ADAPTER_EXPORTS__*/

package/runtime/javascript/runtime.js

@@ -808,14 +808,28 @@ function installServerChildPropagation() {
   runtimeGlobal.__SUPERCOV_CHILD_PATCHED__ = true;
 }
 installServerChildPropagation();
+/**
+ * Phase ids are minted as `<attemptId>:phase:<n>`, so a phase can be checked
+ * against the attempt it claims to belong to without a lookup.
+ */
+function phaseBelongsToAttempt(phaseId, attemptId) {
+  return typeof phaseId === "string" && typeof attemptId === "string" && attemptId.length > 0 && phaseId.startsWith(`${attemptId}:phase:`);
+}
 function currentPhaseId() {
   if (runtimeGlobal.__SUPERCOV_PHASE_ID__)
     return runtimeGlobal.__SUPERCOV_PHASE_ID__;
   if (!isBrowser)
     return currentRequestContext().phaseId;
   try {
+    // The stored phase is per origin, so in a browser context that outlives
+    // its test (a persistent profile shared by a whole worker) it still holds
+    // the previous test's last phase when the next test's document loads. A
+    // phase from another attempt would tag this test's evidence with a phase
+    // it never reported, which the archive rightly rejects; only a phase of
+    // the current attempt is honoured.
     const local = localStorage.getItem(phaseStorageKey);
-    if (local)
+    const attemptId = runtimeGlobal.__SUPERCOV_MCDC_TEST_ID__ != null ? runtimeGlobal.__SUPERCOV_MCDC_TEST_ID__ : testId;
+    if (local && phaseBelongsToAttempt(local, attemptId))
       return local;
     return void 0;
   } catch (e) {
@@ -870,7 +884,10 @@ function requestCoverageContext(value) {
   const encodedScope = (_a8 = headers.get(COVERAGE_SCOPE_HEADER)) != null ? _a8 : cookies.get(COVERAGE_SCOPE_COOKIE);
   const rawPhaseId = (_b = headers.get(COVERAGE_PHASE_HEADER)) != null ? _b : cookies.get(COVERAGE_PHASE_COOKIE);
   const scope = decodeCoverageScope(typeof encodedScope === "string" ? encodedScope : void 0);
-  const phaseId = typeof rawPhaseId === "string" && rawPhaseId.length > 0 ? rawPhaseId : void 0;
+  // The phase cookie outlives a test in a shared browser context just like
+  // the stored phase does (see currentPhaseId); a request carrying a scope
+  // and a phase from different attempts keeps the scope and drops the phase.
+  const phaseId = typeof rawPhaseId === "string" && rawPhaseId.length > 0 && (!scope || phaseBelongsToAttempt(rawPhaseId, scope.attemptId)) ? rawPhaseId : void 0;
   return __spreadValues(__spreadValues({}, scope ? { scope } : {}), phaseId ? { phaseId } : {});
 }
 function withRequestPhase(handler) {
@@ -1186,6 +1203,7 @@ const directRuntimeApi = {
   optionalCallReached,
   optionalSelect,
   parenthesizedAssignmentValue,
+  phaseBelongsToAttempt,
   registerProbeV2,
   resetCoverage,
   selectionBegin,
@@ -1233,6 +1251,7 @@ export {
   optionalCallReached,
   optionalSelect,
   parenthesizedAssignmentValue,
+  phaseBelongsToAttempt,
   registerProbeV2,
   resetCoverage,
   selectionBegin,