@piwitests/reporter 0.9.1 → 0.12.0

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

@@ -23,6 +23,40 @@ export interface SelectorCounts {
     name?: number;
     classes?: Record<string, number>;
 }
+/**
+ * The element's position among same-role elements in the document at capture
+ * time — a name-independent structural identity. `levelCount` additionally
+ * counts same-role elements sharing this element's heading level, so a lone
+ * `h1` among many `h2`s still gets a name-free `getByRole('heading', { level: 1 })`.
+ */
+export interface RolePosition {
+    role: string;
+    count: number;
+    index: number;
+    levelCount?: number;
+}
+/**
+ * An anchor-worthy ancestor — one carrying a stable hook (test id, id,
+ * explicit role, aria-label, or a landmark tag) that a scoped alternative can
+ * chain from. Nearest ancestors first.
+ */
+export interface AncestorAnchor {
+    tag: string;
+    /** Hops from the element (1 = direct parent). */
+    depth: number;
+    testId: string | null;
+    id: string | null;
+    role: string | null;
+    ariaLabel: string | null;
+    /** Same-role matches for the captured element within this ancestor. */
+    scopedRoleCount?: number;
+    /** Document-wide match count for this ancestor's own data-testid. */
+    testIdCount?: number;
+    /** Document-wide match count for this ancestor's own id. */
+    idCount?: number;
+    /** Document-wide count of elements resolving to this ancestor's landmark/explicit role. */
+    roleCount?: number;
+}
 export interface ElementAttributes {
     tagName: string;
     attributes: Record<string, string | null>;
@@ -41,6 +75,10 @@ export interface ElementAttributes {
     hasLabel?: boolean;
     /** Live-page uniqueness probe results for candidate selectors. */
     selectorCounts?: SelectorCounts;
+    /** Position among same-role elements — powers name-free and renamed-element healing. */
+    rolePosition?: RolePosition | null;
+    /** Anchor-worthy ancestors, nearest first — power ancestor-scoped alternatives. */
+    ancestors?: AncestorAnchor[];
 }
 export interface LocatorSnapshot {
     location: string | null;
@@ -58,6 +96,10 @@ export interface LocatorSnapshot {
             x: number;
             y: number;
         } | null;
+        /** Position among same-role elements at capture time. */
+        rolePosition?: RolePosition | null;
+        /** Anchor-worthy ancestors, nearest first. */
+        ancestors?: AncestorAnchor[];
     } | null;
     alternatives: RankedLocator[];
 }
@@ -72,8 +114,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[];
 /**
@@ -92,6 +135,16 @@ export declare const LOCATOR_CREATING_CHAINS: ReadonlySet<string>;
  * the same attribute set.
  */
 export declare const CAPTURED_ATTRIBUTES: string[];
+/**
+ * Implicit ARIA role for an HTML tag (when no explicit `role` is set). Exported
+ * so the in-page probe (`capture-fixtures.ts#probeElementAttrs`) can receive
+ * this same map as an `evaluate` argument instead of re-declaring it — the
+ * probe is serialized into the browser and can't reference this module's
+ * closure, but the map is pure data and rides in as an argument.
+ */
+export declare const TAG_TO_ROLE: Record<string, string>;
+/** Implicit ARIA role for an `<input>` keyed by its `type` attribute. Exported for the probe (see {@link TAG_TO_ROLE}). */
+export declare const INPUT_TYPE_TO_ROLE: Record<string, string>;
 /**
  * Resolve the ARIA role for an element. An explicit `role` attribute wins;
  * otherwise the implicit role is derived from the tag name (and `type` for
@@ -100,6 +153,12 @@ export declare const CAPTURED_ATTRIBUTES: string[];
  * such elements and other alternatives take over.
  */
 export declare function resolveAriaRole(attrs: ElementAttributes): string | null;
+/**
+ * Heading level for a `heading`-role element: h1-h6 from the tag, else an
+ * explicit `aria-level` attribute. Null when unknown (don't guess the ARIA
+ * default) or when the element isn't a heading.
+ */
+export declare function headingLevel(attrs: ElementAttributes, role: string | null): number | null;
 /**
  * Build a ranked list of alternative locators from the captured element
  * attributes. The list is sorted descending by stability score.
@@ -160,6 +219,7 @@ export interface LocatorSuggestion {
 export declare function parseAriaRoleName(ariaSnapshot: string): Array<{
     role: string;
     name: string | null;
+    level: number | null;
 }>;
 /**
  * Token-set (Dice) similarity, 0-1, case- and punctuation-insensitive.
@@ -195,4 +255,4 @@ export declare function suggestLocatorsFromAria(failed: FailedLocatorInfo, ariaS
  * Returns null when no user frame can be identified — the snapshot keeps
  * `location: null` and the server falls back to fingerprint / ARIA lookup.
  */
-export declare function captureCallerLocation(): string | null;
+export declare function captureCallerLocation(stack?: string): string | null;

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

@@ -33,9 +33,10 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CAPTURED_ATTRIBUTES = exports.LOCATOR_CREATING_CHAINS = exports.ACTION_METHODS = exports.CHAIN_METHODS = exports.LOCATOR_METHODS = void 0;
+exports.INPUT_TYPE_TO_ROLE = exports.TAG_TO_ROLE = exports.CAPTURED_ATTRIBUTES = exports.LOCATOR_CREATING_CHAINS = exports.ACTION_METHODS = exports.CHAIN_METHODS = exports.LOCATOR_METHODS = void 0;
 exports.dedupeSnapshotsByLocation = dedupeSnapshotsByLocation;
 exports.resolveAriaRole = resolveAriaRole;
+exports.headingLevel = headingLevel;
 exports.generateAlternatives = generateAlternatives;
 exports.classifyCssStability = classifyCssStability;
 exports.isAutoGenerated = isAutoGenerated;
@@ -73,8 +74,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',
@@ -148,6 +150,9 @@ exports.CAPTURED_ATTRIBUTES = [
     'alt',
     'title',
     'aria-label',
+    // `aria-level` carries the heading level for `role="heading"` elements
+    // (h1-h6 levels come from the tag itself).
+    'aria-level',
     'role',
     'type',
     'href',
@@ -158,8 +163,14 @@ exports.CAPTURED_ATTRIBUTES = [
     'multiple',
 ];
 // ── ARIA role resolution ─────────────────────────────────────────────────────
-/** Implicit ARIA role for an HTML tag (when no explicit `role` is set). */
-const TAG_TO_ROLE = {
+/**
+ * Implicit ARIA role for an HTML tag (when no explicit `role` is set). Exported
+ * so the in-page probe (`capture-fixtures.ts#probeElementAttrs`) can receive
+ * this same map as an `evaluate` argument instead of re-declaring it — the
+ * probe is serialized into the browser and can't reference this module's
+ * closure, but the map is pure data and rides in as an argument.
+ */
+exports.TAG_TO_ROLE = {
     a: 'link',
     button: 'button',
     nav: 'navigation',
@@ -190,8 +201,8 @@ const TAG_TO_ROLE = {
     summary: 'button',
     search: 'search',
 };
-/** Implicit ARIA role for an `<input>` keyed by its `type` attribute. */
-const INPUT_TYPE_TO_ROLE = {
+/** Implicit ARIA role for an `<input>` keyed by its `type` attribute. Exported for the probe (see {@link TAG_TO_ROLE}). */
+exports.INPUT_TYPE_TO_ROLE = {
     button: 'button',
     submit: 'button',
     reset: 'button',
@@ -223,7 +234,7 @@ function resolveAriaRole(attrs) {
         return null;
     if (tag === 'input') {
         const type = (attrs.attributes['type'] ?? 'text').toLowerCase();
-        return INPUT_TYPE_TO_ROLE[type] ?? 'textbox';
+        return exports.INPUT_TYPE_TO_ROLE[type] ?? 'textbox';
     }
     // A plain <select> is a combobox; only with `multiple` (or size > 1, not
     // captured) does it become a listbox. Matches the server's implicitRoleForTag.
@@ -233,7 +244,23 @@ function resolveAriaRole(attrs) {
     if (tag === 'a') {
         return attrs.attributes['href'] != null ? 'link' : null;
     }
-    return TAG_TO_ROLE[tag] ?? null;
+    return exports.TAG_TO_ROLE[tag] ?? null;
+}
+/**
+ * Heading level for a `heading`-role element: h1-h6 from the tag, else an
+ * explicit `aria-level` attribute. Null when unknown (don't guess the ARIA
+ * default) or when the element isn't a heading.
+ */
+function headingLevel(attrs, role) {
+    if (role !== 'heading')
+        return null;
+    const tagMatch = attrs.tagName.match(/^h([1-6])$/);
+    if (tagMatch)
+        return Number(tagMatch[1]);
+    const ariaLevel = attrs.attributes['aria-level'];
+    if (ariaLevel && /^\d+$/.test(ariaLevel))
+        return Number(ariaLevel);
+    return null;
 }
 // ── Alternative generation ───────────────────────────────────────────────────
 const attr = (a, key) => a.attributes[key] || null;
@@ -279,12 +306,17 @@ function generateAlternatives(attrs) {
             score: 100,
         });
     }
+    // Heading level rides along in every heading getByRole — it survives renames
+    // and disambiguates same-named headings at different levels.
+    const level = headingLevel(attrs, role);
+    const levelPart = level != null ? `, level: ${level}` : '';
+    const withLevel = (base) => level != null ? { ...base, level } : base;
     // 2. role + accessible name from browser ARIA tree (85-95)
     if (role && accessibleName) {
         add({
-            locator: `getByRole('${role}', { name: '${esc(accessibleName)}' })`,
+            locator: `getByRole('${role}', { name: '${esc(accessibleName)}'${levelPart} })`,
             method: 'getByRole',
-            args: { role, name: accessibleName },
+            args: withLevel({ role, name: accessibleName }),
             score: 90,
         });
     }
@@ -292,9 +324,9 @@ function generateAlternatives(attrs) {
     const ariaLabel = attr(attrs, 'aria-label');
     if (role && ariaLabel && ariaLabel !== accessibleName) {
         add({
-            locator: `getByRole('${role}', { name: '${esc(ariaLabel)}' })`,
+            locator: `getByRole('${role}', { name: '${esc(ariaLabel)}'${levelPart} })`,
             method: 'getByRole',
-            args: { role, name: ariaLabel },
+            args: withLevel({ role, name: ariaLabel }),
             score: 85,
         });
     }
@@ -378,6 +410,67 @@ function generateAlternatives(attrs) {
             score: 50,
         });
     }
+    // Structural alternatives (55-72) — name-free, so they survive label/text
+    // renames that break every name-derived locator above. Skipped when the
+    // element has its own unique data-testid (already the top alternative).
+    // Chained alternatives carry the LEAF method with flat args (never a `name`
+    // key) so the recommendation's method-family logic and the server's
+    // fingerprint reader treat them correctly.
+    const hasOwnTestId = !!(testId && isUnique(counts?.testId));
+    if (role && !hasOwnTestId) {
+        const rolePart = level != null ? `'${role}', { level: ${level} }` : `'${role}'`;
+        const leafArgs = withLevel({ role });
+        // Ancestor-anchored role locators: nearest anchor of each kind whose own
+        // hook is document-unique and that contains exactly one leaf-role match
+        // (level-scoped for headings — the probe counts accordingly).
+        let testIdAnchorDone = false;
+        let idAnchorDone = false;
+        let roleAnchorDone = false;
+        for (const anc of attrs.ancestors ?? []) {
+            if (anc.scopedRoleCount !== 1)
+                continue;
+            if (!testIdAnchorDone && anc.testId && anc.testIdCount === 1) {
+                testIdAnchorDone = true;
+                add({
+                    locator: `getByTestId('${esc(anc.testId)}').getByRole(${rolePart})`,
+                    method: 'getByRole',
+                    args: { ...leafArgs, anchorTestId: anc.testId },
+                    score: 72,
+                });
+            }
+            if (!idAnchorDone && anc.id && !isAutoGenerated(anc.id) && anc.idCount === 1) {
+                idAnchorDone = true;
+                const anchorSelector = isCssSafeId(anc.id) ? `#${anc.id}` : `[id="${escCssAttrValue(anc.id)}"]`;
+                add({
+                    locator: `locator('${esc(anchorSelector)}').getByRole(${rolePart})`,
+                    method: 'getByRole',
+                    args: { ...leafArgs, anchorSelector },
+                    score: 64,
+                });
+            }
+            const ancestorRole = anc.role || exports.TAG_TO_ROLE[anc.tag] || null;
+            if (!roleAnchorDone && ancestorRole && ancestorRole !== role && anc.roleCount === 1) {
+                roleAnchorDone = true;
+                add({
+                    locator: `getByRole('${esc(ancestorRole)}').getByRole(${rolePart})`,
+                    method: 'getByRole',
+                    args: { ...leafArgs, anchorRole: ancestorRole },
+                    score: 55,
+                });
+            }
+        }
+        // Name-free bare role — the sole element of its role on the page, or the
+        // sole heading at its level (a lone h1 among many h2s).
+        const pos = attrs.rolePosition;
+        if (pos && pos.role === role && (pos.count === 1 || (level != null && pos.levelCount === 1))) {
+            add({
+                locator: `getByRole(${rolePart})`,
+                method: 'getByRole',
+                args: leafArgs,
+                score: 58,
+            });
+        }
+    }
     // 11. CSS class-based locators — capped at 3 most stable classes; classes
     // the uniqueness probe saw on more than one element are dropped outright.
     const clsStr = attr(attrs, 'class');
@@ -537,7 +630,12 @@ function parseAriaRoleName(ariaSnapshot) {
         const name = m[2] == null ? null : m[2].replace(/\\(.)/g, '$1');
         if (!name && (role === 'generic' || role === 'group' || role === 'list' || role === 'paragraph'))
             continue;
-        out.push({ role, name });
+        // Heading level rides after the name as `[level=N]` (other bracketed
+        // markers like `[ref=eN]` are ignored). Scan only past the matched part so
+        // brackets inside the quoted name can't fake a level.
+        const levelMatch = /\[level=(\d+)\]/.exec(line.slice(m[0].length));
+        const level = levelMatch ? Number(levelMatch[1]) : null;
+        out.push({ role, name, level });
     }
     return out;
 }
@@ -583,16 +681,17 @@ const SUGG_TEXT_ROLES = new Set([
     'switch',
 ]);
 const SUGG_FIELD_ROLES = new Set(['textbox', 'combobox', 'searchbox', 'spinbutton', 'slider']);
-/** Extract the role (for getByRole) and the targeted accessible name from a failed locator's args. */
+/** Extract the role (for getByRole), targeted accessible name, and heading level from a failed locator's args. */
 function failedNameAndRole(failed) {
     if (failed.method === 'getByRole') {
         const role = typeof failed.args[0] === 'string' ? failed.args[0] : null;
         const opts = failed.args[1];
         const name = opts && typeof opts.name === 'string' ? opts.name : null;
-        return { role, name };
+        const level = opts && typeof opts.level === 'number' ? opts.level : null;
+        return { role, name, level };
     }
     const first = failed.args.find((a) => typeof a === 'string');
-    return { role: null, name: typeof first === 'string' ? first : null };
+    return { role: null, name: typeof first === 'string' ? first : null, level: null };
 }
 /** Render the failed locator back to source for the annotation message. */
 function renderFailing(failed) {
@@ -613,7 +712,8 @@ function freshSuggestions(candidate, failedMethod) {
         if (!out.includes(s))
             out.push(s);
     };
-    const roleLoc = `getByRole('${escAttr(role)}', { name: '${escAttr(name)}' })`;
+    const levelPart = candidate.level != null ? `, level: ${candidate.level}` : '';
+    const roleLoc = `getByRole('${escAttr(role)}', { name: '${escAttr(name)}'${levelPart} })`;
     const textLoc = `getByText('${escAttr(name)}')`;
     const labelLoc = `getByLabel('${escAttr(name)}')`;
     // Same-style first: a broken getByText is re-suggested as getByText where viable.
@@ -642,14 +742,22 @@ function freshSuggestions(candidate, failedMethod) {
 function suggestLocatorsFromAria(failed, ariaSnapshot) {
     if (!ariaSnapshot || !NAME_BASED_METHODS.has(failed.method))
         return null;
-    const { role, name } = failedNameAndRole(failed);
+    const { role, name, level } = failedNameAndRole(failed);
     if (!name)
         return null;
     const candidates = parseAriaRoleName(ariaSnapshot);
     if (candidates.length === 0)
         return null;
     const sameRole = role ? candidates.filter((c) => c.role === role) : [];
-    const pool = sameRole.length > 0 ? sameRole : candidates;
+    let pool = sameRole.length > 0 ? sameRole : candidates;
+    // A targeted heading level narrows the pool further — a lone renamed h1
+    // among many h2s becomes the single confident candidate. Fall back to all
+    // same-role candidates when none share the level (it may have changed too).
+    if (level != null && sameRole.length > 0) {
+        const sameLevel = sameRole.filter((c) => c.level === level);
+        if (sameLevel.length > 0)
+            pool = sameLevel;
+    }
     // The targeted name is still on the page → not a rename, nothing to suggest.
     if (pool.some((c) => nameSimilarity(c.name, name) >= 0.8))
         return null;
@@ -666,7 +774,7 @@ function suggestLocatorsFromAria(failed, ariaSnapshot) {
         return null;
     if (bestScore < 0.2 && pool.length !== 1)
         return null;
-    const suggestions = freshSuggestions({ role: best.role, name: best.name }, failed.method);
+    const suggestions = freshSuggestions({ role: best.role, name: best.name, level: best.level }, failed.method);
     if (suggestions.length === 0)
         return null;
     return { failing: renderFailing(failed), suggestions };
@@ -686,8 +794,7 @@ function suggestLocatorsFromAria(failed, ariaSnapshot) {
  * Returns null when no user frame can be identified — the snapshot keeps
  * `location: null` and the server falls back to fingerprint / ARIA lookup.
  */
-function captureCallerLocation() {
-    const stack = new Error().stack ?? '';
+function captureCallerLocation(stack = new Error().stack ?? '') {
     const lines = stack.split('\n');
     // The capture machinery's own frames sit at the top of the stack: this module
     // (locator-healing) then the single fixtures-proxy frame that called it. Skip
@@ -721,9 +828,10 @@ function captureCallerLocation() {
             prevWasCaptureModule = true;
             continue;
         }
-        // The fixtures proxy that called us — skip only when it directly follows
-        // this module, so a user's own `fixtures.*` deeper down is not dropped.
-        if (prevWasCaptureModule && /[\\/]fixtures\.[a-z]+$/i.test(file)) {
+        // The fixtures proxy that called us — `capture-fixtures.*` in this
+        // package, `fixtures.*` in the dogfood mirror. Skip only when it directly
+        // follows this module, so a user's own `fixtures.*` deeper down is kept.
+        if (prevWasCaptureModule && /[\\/](?:capture-)?fixtures\.[a-z]+$/i.test(file)) {
             prevWasCaptureModule = false;
             continue;
         }

package/dist/internal/config/env.d.ts

@@ -22,6 +22,7 @@ export declare const PIWI_ENV_KEYS: {
     readonly uploadTraces: "PIWI_UPLOAD_TRACES";
     readonly uploadReport: "PIWI_UPLOAD_REPORT";
     readonly captureLocators: "PIWI_CAPTURE_LOCATORS";
+    readonly capturePageState: "PIWI_CAPTURE_PAGE_STATE";
 };
 /**
  * Merge raw user options with defaults, reading from `PIWI_*` env vars when

package/dist/internal/config/env.js

@@ -16,6 +16,7 @@ const DEFAULTS = {
     collectCiInfo: true,
     collectPerformanceMetrics: true,
     captureLocators: true,
+    capturePageState: true,
     streaming: true,
     streamingBatchSize: 5,
     streamingBatchDelay: 2000,
@@ -47,6 +48,7 @@ exports.PIWI_ENV_KEYS = {
     uploadTraces: 'PIWI_UPLOAD_TRACES',
     uploadReport: 'PIWI_UPLOAD_REPORT',
     captureLocators: 'PIWI_CAPTURE_LOCATORS',
+    capturePageState: 'PIWI_CAPTURE_PAGE_STATE',
 };
 function readBool(val) {
     if (val === undefined)
@@ -83,6 +85,7 @@ const ENV_FALLBACK_SPECS = [
     { option: 'uploadTraces', env: exports.PIWI_ENV_KEYS.uploadTraces, kind: 'bool' },
     { option: 'uploadReport', env: exports.PIWI_ENV_KEYS.uploadReport, kind: 'bool' },
     { option: 'captureLocators', env: exports.PIWI_ENV_KEYS.captureLocators, kind: 'bool' },
+    { option: 'capturePageState', env: exports.PIWI_ENV_KEYS.capturePageState, kind: 'bool' },
 ];
 /**
  * Merge raw user options with defaults, reading from `PIWI_*` env vars when
@@ -150,4 +153,10 @@ function applyOptionsToEnv(options) {
         env[exports.PIWI_ENV_KEYS.captureLocators] = 'false';
     else if (options.captureLocators === true)
         env[exports.PIWI_ENV_KEYS.captureLocators] = 'true';
+    // Page-state capture follows the same bridge: off when either flag disables
+    // it, explicit true otherwise (unset keeps the fixture's default-on).
+    if (options.capturePageState === false || options.collectPerformanceMetrics === false)
+        env[exports.PIWI_ENV_KEYS.capturePageState] = 'false';
+    else if (options.capturePageState === true)
+        env[exports.PIWI_ENV_KEYS.capturePageState] = 'true';
 }

package/dist/internal/files/file-handler.js

@@ -156,6 +156,15 @@ class FileHandler {
         const aria = find(attachments_js_1.ATTACHMENT_NAMES.ariaSnapshot);
         if (aria?.body)
             testCase.ariaSnapshot = aria.body.toString();
+        const pageState = find(attachments_js_1.ATTACHMENT_NAMES.pageState);
+        if (pageState?.body) {
+            try {
+                testCase.pageState = JSON.parse(pageState.body.toString());
+            }
+            catch {
+                /* ignore */
+            }
+        }
     }
     /** Compute SHA-256 hash and size for a single test case's trace file. Returns `null` when the case has no trace on disk. */
     async computeSingleTraceHash(testCase) {

package/dist/internal/submit/serializer.js

@@ -57,6 +57,7 @@ function toWireTestCase(tc) {
         wastedTimeMs: rest.performanceMetrics?.waitTotalDuration ?? null,
         networkRequests: rest.networkRequests || null,
         webVitals: rest.webVitals || null,
+        pageState: rest.pageState || null,
         consoleLogs: rest.consoleLogs || null,
         ariaSnapshot: rest.ariaSnapshot || null,
         testSource: rest.testSource || null,

package/dist/public/options.d.ts

@@ -41,6 +41,14 @@ export interface PiwiDashboardOptions extends PlaywrightTestConfig {
      * in that case anyway). Can also be forced off with `PIWI_CAPTURE_LOCATORS=false`.
      */
     captureLocators?: boolean;
+    /**
+     * Capture the page's state at test end (URL, history state, localStorage/
+     * sessionStorage key names + value lengths, cookie names + flags). Values of
+     * storage entries and cookies are never captured. Defaults to `true`;
+     * automatically disabled when `collectPerformanceMetrics` is `false`. Can
+     * also be forced off with `PIWI_CAPTURE_PAGE_STATE=false`.
+     */
+    capturePageState?: boolean;
     /** Enable live streaming of results (falls back to batch if unsupported). Defaults to `true`. */
     streaming?: boolean;
     /** Number of test results to batch before sending during streaming. Defaults to `5`. */

package/dist/types/collected.d.ts

@@ -81,6 +81,7 @@ export interface CollectedTestCase {
     networkRequests?: unknown;
     /** Parsed from `piwi-web-vitals` attachments. */
     webVitals?: unknown;
+    pageState?: unknown;
     /** Parsed from `piwi-console` attachments. */
     consoleLogs?: unknown;
     /** Parsed from `piwi-aria-snapshot` attachment. */

package/dist/types/wire.d.ts

@@ -92,6 +92,7 @@ export interface WireTestCase {
     wastedTimeMs?: number | null;
     networkRequests?: unknown;
     webVitals?: unknown;
+    pageState?: unknown;
     consoleLogs?: unknown;
     ariaSnapshot?: unknown;
     testSource?: string | null;
@@ -136,6 +137,7 @@ export interface CompleteStreamEvent {
     slowestStepDuration?: number | null;
     networkRequests?: unknown;
     webVitals?: unknown;
+    pageState?: unknown;
     consoleLogs?: unknown;
     ariaSnapshot?: unknown;
     testSource?: string | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@piwitests/reporter",
-  "version": "0.9.1",
+  "version": "0.12.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",