@piwitests/reporter 0.9.1 → 0.11.0

package/README.md

@@ -39,6 +39,19 @@ Run your tests — results are uploaded automatically:
 npx playwright test
 ```
 
+**Recommended: enable the [capture fixtures](#capture-fixtures)** — one small file unlocks the dashboard's richest features (locator healing, slow-endpoint analysis, Web Vitals, console capture, failure-time ARIA snapshots):
+
+```typescript
+// tests/fixtures.ts
+import { test as base, expect } from '@playwright/test'
+import { piwiFixtures } from '@piwitests/reporter'
+
+export const test = base.extend(piwiFixtures)
+export { expect }
+```
+
+Import `test` from this file in your specs instead of `@playwright/test` — see [Capture fixtures](#capture-fixtures) below.
+
 Prefer to wire it up by hand? Add the reporter to the `reporter` array instead:
 
 ```typescript
@@ -123,35 +136,42 @@ export default defineConfig({
 })
 ```
 
-## Performance Metrics & Web Vitals
+## Capture fixtures
 
-To capture network request timing and browser Web Vitals, use the provided fixtures:
+The reporter works without any test-code changes, but the **capture fixtures** observe your tests from the inside and unlock the dashboard's richest features. Extend your `test` with them:
 
 ```typescript
 // tests/fixtures.ts
 import { test as base, expect } from '@playwright/test'
-import { dashboardFixtures } from '@piwitests/reporter'
+import { piwiFixtures } from '@piwitests/reporter'
 
-export const test = base.extend(dashboardFixtures)
+export const test = base.extend(piwiFixtures)
 export { expect }
 ```
 
-Or extend the base `test` in one line with `extendDashboardFixtures`:
+Or extend the base `test` in one line with `extendPiwiFixtures`:
 
 ```typescript
 import { test as base } from '@playwright/test'
-import { extendDashboardFixtures } from '@piwitests/reporter'
+import { extendPiwiFixtures } from '@piwitests/reporter'
 
-export const test = extendDashboardFixtures(base)
+export const test = extendPiwiFixtures(base)
 export { expect } from '@playwright/test'
 ```
 
+Then import `test` from your fixtures file in every spec — a spec that imports `test` from `@playwright/test` directly still runs and reports fine, it just isn't captured.
+
 ### What gets captured
 
-- **Network requests** — method, URL, status, duration, resource type. Aggregated on the dashboard into a *Slow API Endpoints* table grouped by `METHOD + normalized route`.
+- **Network requests** — method, URL, status, duration, resource type (API/document traffic only). Aggregated on the dashboard into a *Slow API Endpoints* table grouped by `METHOD + normalized route`.
+- **Console entries** — `warning`, `error`, and `assert` messages with their source location.
 - **Browser Web Vitals** — TTFB, DOM Interactive, DOMContentLoaded, Load Complete, First Paint, First Contentful Paint — displayed with color-coded thresholds.
+- **ARIA snapshot** — captured automatically when a test fails, shown as failure evidence and fed to the AI diagnosis.
+- **Locator snapshots** — for each acted-on element, its attributes plus ranked alternative locators, stamped with the call site. These power locator healing; when a failing locator matches nothing, a fresh suggestion is attached as a Playwright annotation.
+
+Capture works for the `page` fixture, `browser.newPage()`, `browser.newContext().newPage()`, and popups. Everything is only collected when `collectPerformanceMetrics` is `true` (the default); locator snapshots can be disabled separately with `captureLocators: false`.
 
-Both are only collected when `collectPerformanceMetrics` is `true` (the default).
+Without the fixtures you still get full run history, statuses, errors, traces, reports, streaming, and clustering — the fixtures add the slow-endpoint, Web Vitals, console, ARIA, and locator-healing layers. See the [capture fixtures guide](https://piwitests.github.io/capture-fixtures) for the full feature matrix and composition patterns.
 
 ## Authentication
 
@@ -195,7 +215,7 @@ When `collectCiInfo` is enabled (default), the reporter auto-detects:
 2. As tests complete, results are streamed in batches to the server
 3. After all tests finish, HTML reports are compressed and uploaded
 4. Trace files from test attachments are uploaded
-5. Network request and web vitals data (from fixtures) are included per test case
+5. Data from the capture fixtures (network requests, console entries, web vitals, ARIA snapshots, locator snapshots) is included per test case
 6. The server stores everything and makes it available in the dashboard UI
 
 ## Requirements
@@ -229,10 +249,10 @@ Everything public — the reporter, config helpers, and the capture fixtures —
 - Ensure traces are enabled: `use: { trace: 'retain-on-failure' }`
 - Check the dashboard server is running and accessible at `serverUrl`
 
-### Network/Web Vitals not appearing
+### Fixture data not appearing (network, Web Vitals, console, ARIA, locator healing)
 
-- Extend your `test` with `dashboardFixtures` / `extendDashboardFixtures` from `@piwitests/reporter`
-- Verify `collectPerformanceMetrics` is not set to `false`
+- Extend your `test` with `piwiFixtures` / `extendPiwiFixtures` from `@piwitests/reporter`, and import `test` from your fixtures file in every spec — not from `@playwright/test` directly
+- Verify `collectPerformanceMetrics` is not set to `false` (and `captureLocators` for locator healing)
 - Ensure tests navigate to at least one page (`await page.goto(...)`)
 
 ### Connection errors

package/dist/index.d.ts

@@ -11,5 +11,6 @@ export default PiwiDashboardReporter;
 export { PiwiDashboardReporter };
 export { wrapConfig } from './public/config-wrapper.js';
 export { createGlobalSetup } from './public/global-setup.js';
-export { dashboardFixtures, extendDashboardFixtures } from './internal/capture/capture-fixtures.js';
+export { piwiFixtures, extendPiwiFixtures } from './internal/capture/capture-fixtures.js';
+export type { PiwiFixtures } from './internal/capture/capture-fixtures.js';
 export type { PiwiDashboardOptions, PlaywrightTestConfig } from './public/options.js';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extendDashboardFixtures = exports.dashboardFixtures = exports.createGlobalSetup = exports.wrapConfig = exports.PiwiDashboardReporter = void 0;
+exports.extendPiwiFixtures = exports.piwiFixtures = exports.createGlobalSetup = exports.wrapConfig = exports.PiwiDashboardReporter = void 0;
 /**
  * Public API of `@piwitests/reporter`.
  *
@@ -20,5 +20,5 @@ var global_setup_js_1 = require("./public/global-setup.js");
 Object.defineProperty(exports, "createGlobalSetup", { enumerable: true, get: function () { return global_setup_js_1.createGlobalSetup; } });
 // ── Capture fixtures ─────────────────────────────────────────────────────────
 var capture_fixtures_js_1 = require("./internal/capture/capture-fixtures.js");
-Object.defineProperty(exports, "dashboardFixtures", { enumerable: true, get: function () { return capture_fixtures_js_1.dashboardFixtures; } });
-Object.defineProperty(exports, "extendDashboardFixtures", { enumerable: true, get: function () { return capture_fixtures_js_1.extendDashboardFixtures; } });
+Object.defineProperty(exports, "piwiFixtures", { enumerable: true, get: function () { return capture_fixtures_js_1.piwiFixtures; } });
+Object.defineProperty(exports, "extendPiwiFixtures", { enumerable: true, get: function () { return capture_fixtures_js_1.extendPiwiFixtures; } });

package/dist/internal/capture/attachments.d.ts

@@ -1,8 +1,8 @@
 /**
  * Names of the `testInfo` attachments the dashboard fixtures produce and the
  * reporter parses. Single source of truth — imported by the producer
- * (`fixtures.ts`), the consumers (`reporter.ts` / `file-handler.ts`), and the
- * dogfooding `application/tests/fixtures.ts`, so producer and consumer can
+ * (`capture-fixtures.ts`), the consumers (`reporter.ts` / `file-handler.ts`), and
+ * the dogfooding `application/tests/fixtures.ts`, so producer and consumer can
  * never drift on a name.
  */
 export declare const ATTACHMENT_NAMES: {

package/dist/internal/capture/attachments.js

@@ -4,8 +4,8 @@ exports.LOCATOR_SUGGESTION_ANNOTATION = exports.INTERNAL_ATTACHMENT_NAMES = expo
 /**
  * Names of the `testInfo` attachments the dashboard fixtures produce and the
  * reporter parses. Single source of truth — imported by the producer
- * (`fixtures.ts`), the consumers (`reporter.ts` / `file-handler.ts`), and the
- * dogfooding `application/tests/fixtures.ts`, so producer and consumer can
+ * (`capture-fixtures.ts`), the consumers (`reporter.ts` / `file-handler.ts`), and
+ * the dogfooding `application/tests/fixtures.ts`, so producer and consumer can
  * never drift on a name.
  */
 exports.ATTACHMENT_NAMES = {

package/dist/internal/capture/capture-fixtures.d.ts

@@ -1,4 +1,7 @@
-import type { Fixtures, Locator } from '@playwright/test';
+import type { Fixtures, Locator, PlaywrightTestArgs, PlaywrightTestOptions, PlaywrightWorkerArgs, PlaywrightWorkerOptions, TestType } from '@playwright/test';
+type FixtureArgs = {
+    [key: string]: any;
+};
 /** Shape returned by the in-page element probe (see `wrapLocator`). */
 interface CapturedAttrs {
     tagName: string;
@@ -41,6 +44,17 @@ export declare function ariaSnapshotBestEffort(target: Locator, timeout?: number
  * Exported for unit testing; still passed directly to `evaluate()` below.
  */
 export declare function probeElementAttrs(el: any, keep: string[]): CapturedAttrs;
+/**
+ * The fixtures `piwiFixtures` / `extendPiwiFixtures` contribute. The single
+ * added fixture is `piwiCapture`: an auto, test-scoped teardown hook that
+ * attaches the collected `piwi-*` data. Its name is **reserved** — a user
+ * fixture of the same name replaces the capture teardown and silently disables
+ * all capture. Exported so `piwiFixtures` and the extended `test` carry it in
+ * their types (and a collision surfaces to the type checker).
+ */
+export interface PiwiFixtures {
+    piwiCapture: void;
+}
 /**
  * Playwright fixtures that collect network requests, console entries,
  * web vitals, ARIA snapshots, and locator interaction data during a test.
@@ -50,9 +64,10 @@ export declare function probeElementAttrs(el: any, keep: string[]): CapturedAttr
  * `browser.newContext()`. Collected data is attached as `piwi-*`
  * test-info attachments which the Piwi Dashboard reporter parses on `onTestEnd`.
  */
-export declare const dashboardFixtures: Fixtures;
+export declare const piwiFixtures: Fixtures<PiwiFixtures, {}, PlaywrightTestArgs & PlaywrightTestOptions, PlaywrightWorkerArgs & PlaywrightWorkerOptions>;
 /**
- * Extend a Playwright `test` object with Piwi Dashboard fixtures.
+ * Extend a Playwright `test` object with the Piwi capture fixtures. The
+ * returned `test` carries the existing fixtures plus {@link PiwiFixtures}.
  *
  * Use this instead of importing `@playwright/test` directly from this package
  * to avoid the "Requiring @playwright/test second time" error caused by
@@ -61,10 +76,10 @@ export declare const dashboardFixtures: Fixtures;
  * @example
  * ```ts
  * import { test as base } from '@playwright/test';
- * import { extendDashboardFixtures } from '@piwitests/reporter';
+ * import { extendPiwiFixtures } from '@piwitests/reporter';
  *
- * export const test = extendDashboardFixtures(base);
+ * export const test = extendPiwiFixtures(base);
  * ```
  */
-export declare function extendDashboardFixtures<T>(test: T): T;
+export declare function extendPiwiFixtures<TestArgs extends FixtureArgs, WorkerArgs extends FixtureArgs>(test: TestType<TestArgs, WorkerArgs>): TestType<TestArgs & PiwiFixtures, WorkerArgs>;
 export {};

package/dist/internal/capture/capture-fixtures.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dashboardFixtures = void 0;
+exports.piwiFixtures = void 0;
 exports.ariaSnapshotBestEffort = ariaSnapshotBestEffort;
 exports.probeElementAttrs = probeElementAttrs;
-exports.extendDashboardFixtures = extendDashboardFixtures;
+exports.extendPiwiFixtures = extendPiwiFixtures;
 const node_zlib_1 = require("node:zlib");
 const locator_healing_js_1 = require("./locator-healing.js");
 const attachments_js_1 = require("./attachments.js");
@@ -16,6 +16,9 @@ function createSink() {
         capturePromises: [],
         failedLocators: [],
         lastActivePage: null,
+        testInfo: null,
+        stashedWebVitals: null,
+        stashedAria: null,
     };
 }
 /**
@@ -25,6 +28,100 @@ function createSink() {
  * test (auth setup, teardown) is intentionally not captured.
  */
 let currentSink = null;
+/**
+ * Element probes whose protocol call is still in flight. Closing a page,
+ * context, or browser while a probe is mid-flight makes Playwright's
+ * connection dispatcher throw a global "Object with guid handle@… was not
+ * bound in the connection" error, which fails whichever test happens to be
+ * running. The close wrappers drain this set (bounded) before closing.
+ */
+const PENDING_PROBES = new Set();
+async function drainPendingProbes(capMs) {
+    if (PENDING_PROBES.size === 0)
+        return;
+    let cap;
+    await Promise.race([
+        Promise.allSettled(PENDING_PROBES),
+        new Promise((resolve) => {
+            cap = setTimeout(resolve, capMs);
+        }),
+    ]);
+    clearTimeout(cap);
+}
+function isPageClosed(page) {
+    try {
+        return typeof page.isClosed === 'function' ? page.isClosed() : false;
+    }
+    catch {
+        return false;
+    }
+}
+function pageContext(page) {
+    try {
+        return typeof page.context === 'function' ? page.context() : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Read navigation/paint timings from a page — null when unavailable or the page is gone. */
+async function readWebVitals(page) {
+    try {
+        // Runs in the browser, so the perf-entry reads stay `any` (no DOM lib);
+        // the callback return type pins the result to WebVitals.
+        return await page.evaluate(() => {
+            const navEntries = performance.getEntriesByType('navigation');
+            const paintEntries = performance.getEntriesByType('paint');
+            const nav = navEntries[0];
+            const navigation = nav
+                ? {
+                    url: nav.name,
+                    ttfb: Math.round(nav.responseStart - nav.fetchStart),
+                    domInteractive: Math.round(nav.domInteractive - nav.fetchStart),
+                    domContentLoaded: Math.round(nav.domContentLoadedEventEnd - nav.fetchStart),
+                    loadComplete: Math.round(nav.loadEventEnd - nav.fetchStart),
+                    transferSize: nav.transferSize || 0,
+                    encodedBodySize: nav.encodedBodySize || 0,
+                    decodedBodySize: nav.decodedBodySize || 0,
+                }
+                : null;
+            const paint = {};
+            for (const entry of paintEntries) {
+                const key = entry.name.replace(/-([a-z])/g, (_, l) => l.toUpperCase());
+                paint[key] = Math.round(entry.startTime);
+            }
+            if (!navigation && Object.keys(paint).length === 0)
+                return null;
+            return { navigation, paint };
+        });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Take the page-dependent teardown reads (web vitals; ARIA snapshot when the
+ * test failed) while the last active page is still open. Called by the close
+ * wrappers just before a close that would take that page with it — flushSink
+ * runs too late for a live read on the standard test page.
+ */
+async function stashPageState(sink, closing) {
+    const page = sink.lastActivePage;
+    if (!page || isPageClosed(page))
+        return;
+    const belongsToClosing = closing.page === page || (closing.context !== undefined && pageContext(page) === closing.context);
+    if (!belongsToClosing)
+        return;
+    const vitals = await readWebVitals(page);
+    if (vitals)
+        sink.stashedWebVitals = vitals;
+    const status = sink.testInfo?.status;
+    if (status === 'failed' || status === 'timedOut' || status === 'interrupted') {
+        const aria = await ariaSnapshotBestEffort(page.locator(':root'), 1000);
+        if (aria)
+            sink.stashedAria = aria;
+    }
+}
 // Idempotency guards: a page/context/browser can be reached through several
 // paths (browser patch, context patch, the `page` fixture, popup events), and
 // must be wrapped exactly once.
@@ -204,14 +301,23 @@ function wrapLocator(page, locator, originMethod, originArgs) {
                     sink.failedLocators.push({ method: originMethod, args: originArgs });
                     throw error;
                 }
-                // Fire-and-forget: capture element data without blocking the test.
-                // evaluate() can hang when page navigates (element detaches), so
-                // race it against a 500ms deadline and never throw.
+                // Fire-and-forget: capture element data without blocking the test. The
+                // snapshot wait below is bounded by a 500ms deadline (evaluate can hang
+                // when the page navigates), but the probe's underlying protocol call is
+                // tracked in PENDING_PROBES so the close wrappers can drain it — and in
+                // capturePromises so flushSink outwaits it — even when the deadline
+                // abandons it. An evaluate still in flight when its page closes crashes
+                // the connection dispatcher with a global "not bound" error.
+                const probe = target.evaluate(probeElementAttrs, CAPTURED_ATTRS_ARG);
+                const settledProbe = probe.then(() => undefined, () => undefined);
+                PENDING_PROBES.add(settledProbe);
+                settledProbe.then(() => PENDING_PROBES.delete(settledProbe));
+                sink.capturePromises.push(settledProbe);
                 const resolveAttrs = (async () => {
                     let deadline;
                     try {
                         const attrs = await Promise.race([
-                            target.evaluate(probeElementAttrs, CAPTURED_ATTRS_ARG),
+                            probe,
                             new Promise((_, reject) => {
                                 deadline = setTimeout(() => reject(new Error('locator capture timeout')), 500);
                             }),
@@ -265,6 +371,24 @@ function instrumentPage(page) {
     if (!page || INSTRUMENTED_PAGES.has(page))
         return;
     INSTRUMENTED_PAGES.add(page);
+    // A page reached through the `page` fixture safety net may live in a context
+    // the browser patch never saw — instrument it so its close is wrapped too.
+    const ctx = pageContext(page);
+    if (ctx)
+        instrumentContext(ctx);
+    // Drain in-flight probes before a user-initiated close (the guard tolerates
+    // page-like test fakes without a close method), and preserve the
+    // page-dependent teardown reads while the page can still serve them.
+    if (typeof page.close === 'function') {
+        const originalClose = page.close.bind(page);
+        page.close = async (...args) => {
+            await drainPendingProbes(1000);
+            const sink = currentSink;
+            if (sink)
+                await stashPageState(sink, { page });
+            return originalClose(...args);
+        };
+    }
     // Opt-out: skipped when PIWI_CAPTURE_LOCATORS=false (set automatically when
     // the reporter's collectPerformanceMetrics / captureLocators is disabled),
     // so the per-action DOM read + ARIA snapshot cost is never paid when unused.
@@ -363,6 +487,21 @@ function instrumentContext(context) {
         instrumentPage(page);
         return page;
     };
+    // The built-in context fixture closes here at test teardown — BEFORE the
+    // auto capture fixture flushes. Drain in-flight probes (an evaluate crossing
+    // the close crashes the connection with a global "not bound" error) and take
+    // the page-dependent reads (web vitals, failure ARIA snapshot) while the
+    // test's page is still open.
+    if (typeof context.close === 'function') {
+        const originalClose = context.close.bind(context);
+        context.close = async (...args) => {
+            await drainPendingProbes(1000);
+            const sink = currentSink;
+            if (sink)
+                await stashPageState(sink, { context });
+            return originalClose(...args);
+        };
+    }
     // Popups and pages the context opens on its own (idempotent with the above).
     context.on('page', (page) => instrumentPage(page));
 }
@@ -389,6 +528,15 @@ function patchBrowser(browser) {
         instrumentContext(context);
         return context;
     };
+    // Worker shutdown closes the browser; a probe still in flight would crash
+    // the connection dispatcher.
+    if (typeof browser.close === 'function') {
+        const originalClose = browser.close.bind(browser);
+        browser.close = async (...args) => {
+            await drainPendingProbes(1000);
+            return originalClose(...args);
+        };
+    }
 }
 /**
  * Drain in-flight capture work and attach the collected `piwi-*` data
@@ -422,9 +570,13 @@ async function flushSink(sink, testInfo) {
         });
     }
     const page = sink.lastActivePage;
-    if (page && testInfo.status !== 'passed' && testInfo.status !== 'skipped') {
+    const pageReadable = page !== null && !isPageClosed(page);
+    if (testInfo.status !== 'passed' && testInfo.status !== 'skipped') {
         try {
-            const snapshot = await ariaSnapshotBestEffort(page.locator(':root'));
+            // Prefer a live read; fall back to the snapshot the close wrappers
+            // stashed — the standard test page is already closed when this auto
+            // fixture tears down.
+            const snapshot = (pageReadable ? await ariaSnapshotBestEffort(page.locator(':root')) : null) ?? sink.stashedAria;
             if (snapshot) {
                 await testInfo.attach(attachments_js_1.ATTACHMENT_NAMES.ariaSnapshot, {
                     contentType: 'text/plain',
@@ -465,45 +617,14 @@ async function flushSink(sink, testInfo) {
             body: Buffer.from(JSON.stringify(sink.networkRequests)),
         });
     }
-    if (page) {
-        try {
-            // Runs in the browser, so the perf-entry reads stay `any` (no DOM lib);
-            // the callback return type pins `webVitals` to WebVitals.
-            const webVitals = await page.evaluate(() => {
-                const navEntries = performance.getEntriesByType('navigation');
-                const paintEntries = performance.getEntriesByType('paint');
-                const nav = navEntries[0];
-                const navigation = nav
-                    ? {
-                        url: nav.name,
-                        ttfb: Math.round(nav.responseStart - nav.fetchStart),
-                        domInteractive: Math.round(nav.domInteractive - nav.fetchStart),
-                        domContentLoaded: Math.round(nav.domContentLoadedEventEnd - nav.fetchStart),
-                        loadComplete: Math.round(nav.loadEventEnd - nav.fetchStart),
-                        transferSize: nav.transferSize || 0,
-                        encodedBodySize: nav.encodedBodySize || 0,
-                        decodedBodySize: nav.decodedBodySize || 0,
-                    }
-                    : null;
-                const paint = {};
-                for (const entry of paintEntries) {
-                    const key = entry.name.replace(/-([a-z])/g, (_, l) => l.toUpperCase());
-                    paint[key] = Math.round(entry.startTime);
-                }
-                if (!navigation && Object.keys(paint).length === 0)
-                    return null;
-                return { navigation, paint };
-            });
-            if (webVitals) {
-                await testInfo.attach(attachments_js_1.ATTACHMENT_NAMES.webVitals, {
-                    contentType: 'application/json',
-                    body: Buffer.from(JSON.stringify(webVitals)),
-                });
-            }
-        }
-        catch {
-            /* ignore */
-        }
+    // Live read when the page still exists (e.g. a browser.newPage the test left
+    // open); otherwise the vitals the close wrappers stashed before the page went.
+    const webVitals = (pageReadable ? await readWebVitals(page) : null) ?? sink.stashedWebVitals;
+    if (webVitals) {
+        await testInfo.attach(attachments_js_1.ATTACHMENT_NAMES.webVitals, {
+            contentType: 'application/json',
+            body: Buffer.from(JSON.stringify(webVitals)),
+        });
     }
 }
 /**
@@ -515,7 +636,7 @@ async function flushSink(sink, testInfo) {
  * `browser.newContext()`. Collected data is attached as `piwi-*`
  * test-info attachments which the Piwi Dashboard reporter parses on `onTestEnd`.
  */
-exports.dashboardFixtures = {
+exports.piwiFixtures = {
     // Worker-scoped: patch the shared browser so every page/context created from
     // it — including by user fixtures that take `browser` directly — is captured.
     browser: [
@@ -535,9 +656,10 @@ exports.dashboardFixtures = {
     // Auto, test-scoped: open a capture sink for the running test and flush it
     // (attach the collected data) at teardown. Runs for every test without being
     // requested, so suites that never destructure `page` are still captured.
-    piwiDashboardCapture: [
+    piwiCapture: [
         async ({}, use, testInfo) => {
             const sink = createSink();
+            sink.testInfo = testInfo;
             currentSink = sink;
             try {
                 await use();
@@ -551,7 +673,8 @@ exports.dashboardFixtures = {
     ],
 };
 /**
- * Extend a Playwright `test` object with Piwi Dashboard fixtures.
+ * Extend a Playwright `test` object with the Piwi capture fixtures. The
+ * returned `test` carries the existing fixtures plus {@link PiwiFixtures}.
  *
  * Use this instead of importing `@playwright/test` directly from this package
  * to avoid the "Requiring @playwright/test second time" error caused by
@@ -560,11 +683,11 @@ exports.dashboardFixtures = {
  * @example
  * ```ts
  * import { test as base } from '@playwright/test';
- * import { extendDashboardFixtures } from '@piwitests/reporter';
+ * import { extendPiwiFixtures } from '@piwitests/reporter';
  *
- * export const test = extendDashboardFixtures(base);
+ * export const test = extendPiwiFixtures(base);
  * ```
  */
-function extendDashboardFixtures(test) {
-    return test.extend(exports.dashboardFixtures);
+function extendPiwiFixtures(test) {
+    return test.extend(exports.piwiFixtures);
 }

package/dist/internal/capture/locator-healing.d.ts

@@ -72,8 +72,9 @@ export interface LocatorSnapshot {
 export declare function dedupeSnapshotsByLocation(snaps: LocatorSnapshot[]): LocatorSnapshot[];
 /**
  * Page-level locator-building methods wrapped by the capture proxy. Imported by
- * both `reporter/src/fixtures.ts` and the dogfooding `application/tests/fixtures.ts`
- * so the two stay in sync (a prior drift missed `scrollIntoViewIfNeeded`).
+ * both the capture fixtures (`capture-fixtures.ts`) and the dogfooding
+ * `application/tests/fixtures.ts` so the two stay in sync (a prior drift missed
+ * `scrollIntoViewIfNeeded`).
  */
 export declare const LOCATOR_METHODS: string[];
 /**

package/dist/internal/capture/locator-healing.js

@@ -73,8 +73,9 @@ function dedupeSnapshotsByLocation(snaps) {
 // ── Playwright method surface (shared with the fixture proxy) ────────────────
 /**
  * Page-level locator-building methods wrapped by the capture proxy. Imported by
- * both `reporter/src/fixtures.ts` and the dogfooding `application/tests/fixtures.ts`
- * so the two stay in sync (a prior drift missed `scrollIntoViewIfNeeded`).
+ * both the capture fixtures (`capture-fixtures.ts`) and the dogfooding
+ * `application/tests/fixtures.ts` so the two stay in sync (a prior drift missed
+ * `scrollIntoViewIfNeeded`).
  */
 exports.LOCATOR_METHODS = [
     'getByRole',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@piwitests/reporter",
-  "version": "0.9.1",
+  "version": "0.11.0",
   "description": "Playwright reporter for sending test results to Piwi Dashboard",
   "url": "https://github.com/PiwiTests/platform",
   "homepage": "https://piwitests.github.io",
@@ -19,7 +19,8 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.js"
-    }
+    },
+    "./package.json": "./package.json"
   },
   "keywords": [
     "playwright",