@piwitests/reporter 0.11.0 → 0.12.0

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

@@ -12,6 +12,7 @@ export declare const ATTACHMENT_NAMES: {
     readonly network: "piwi-network";
     readonly webVitals: "piwi-web-vitals";
     readonly locatorSuggestion: "piwi-locator-suggestion";
+    readonly pageState: "piwi-page-state";
 };
 /** Set of every internal attachment name — used to skip them when collecting user attachments. */
 export declare const INTERNAL_ATTACHMENT_NAMES: ReadonlySet<string>;

package/dist/internal/capture/attachments.js

@@ -15,6 +15,7 @@ exports.ATTACHMENT_NAMES = {
     network: 'piwi-network',
     webVitals: 'piwi-web-vitals',
     locatorSuggestion: 'piwi-locator-suggestion',
+    pageState: 'piwi-page-state',
 };
 /** Set of every internal attachment name — used to skip them when collecting user attachments. */
 exports.INTERNAL_ATTACHMENT_NAMES = new Set(Object.values(exports.ATTACHMENT_NAMES));

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

@@ -20,7 +20,108 @@ interface CapturedAttrs {
         name?: number;
         classes?: Record<string, number>;
     };
+    /** Position among same-role elements, document-wide (null when the element has no role). */
+    rolePosition: {
+        role: string;
+        count: number;
+        index: number;
+        levelCount?: number;
+    } | null;
+    /** Anchor-worthy ancestors, nearest first (empty when none found or probing failed). */
+    ancestors: Array<{
+        tag: string;
+        depth: number;
+        testId: string | null;
+        id: string | null;
+        role: string | null;
+        ariaLabel: string | null;
+        scopedRoleCount?: number;
+        testIdCount?: number;
+        idCount?: number;
+        roleCount?: number;
+    }>;
 }
+/** Plain-object projection of a performance entry, shipped out of the page. */
+export interface RawVitalEntry {
+    startTime?: number;
+    value?: number;
+    hadRecentInput?: boolean;
+    interactionId?: number;
+    duration?: number;
+}
+/**
+ * Aggregate buffered performance entries into LCP/CLS/INP. Pure and Node-side
+ * so it is unit-testable; the in-page evaluate only ships raw entry projections.
+ * A null entry list means the entry type is unsupported (non-Chromium) — the
+ * metric is null rather than 0 so absence is distinguishable from "no shifts".
+ */
+export declare function computeCoreVitals(lcpEntries: RawVitalEntry[] | null, shiftEntries: RawVitalEntry[] | null, eventEntries: RawVitalEntry[] | null): {
+    lcp: number | null;
+    cls: number | null;
+    inp: number | null;
+} | null;
+/** Page state captured at test end. Storage values and cookie values are NEVER included. */
+export interface PageState {
+    url: string;
+    hash: string | null;
+    /** `history.state` as JSON, capped and token-masked. */
+    historyState: string | null;
+    /** Key names + value lengths only. */
+    localStorage: Array<{
+        key: string;
+        length: number;
+    }>;
+    sessionStorage: Array<{
+        key: string;
+        length: number;
+    }>;
+    /** Cookie names + flags only (values are never read). */
+    cookies: Array<{
+        name: string;
+        domain: string;
+        path: string;
+        httpOnly: boolean;
+        secure: boolean;
+        sameSite?: string;
+        expires?: number;
+    }>;
+}
+/** Raw in-page reads shipped out of the evaluate (see `readPageState`). */
+export interface RawPageState {
+    url: string;
+    hash: string | null;
+    historyState: string | null;
+    localStorage: Array<{
+        key: string;
+        length: number;
+    }>;
+    sessionStorage: Array<{
+        key: string;
+        length: number;
+    }>;
+}
+/**
+ * Assemble the wire page-state from the in-page reads and the context cookies.
+ * Pure and Node-side so the sanitization (token masking, caps, value-free
+ * cookies) is unit-testable.
+ */
+export declare function buildPageState(raw: RawPageState, cookies: Array<Record<string, unknown>> | null): PageState;
+/**
+ * Everything the in-page probe needs, serialized into the browser on every
+ * action. `tagRoles`/`inputRoles` are the shared role maps (single source of
+ * truth in `locator-healing.ts`), and `roleSources` is the CSS selector for
+ * every element the probe can resolve a role for — all derived from the map so
+ * nothing is hand-maintained twice. Exported so the dogfood mirror
+ * (`application/tests/fixtures.ts`) reuses the same assembled object.
+ */
+export interface ProbeArg {
+    keep: string[];
+    tagRoles: Record<string, string>;
+    inputRoles: Record<string, string>;
+    roleSources: string;
+}
+/** Built once — passed verbatim into evaluate() on every action. */
+export declare const CAPTURED_ATTRS_ARG: ProbeArg;
 /**
  * ARIA snapshot that tolerates every Playwright version the reporter supports,
  * returning null instead of throwing so a capture can never fail the test. The
@@ -43,7 +144,7 @@ export declare function ariaSnapshotBestEffort(target: Locator, timeout?: number
  * `el` is browser-context (no DOM lib in this Node package), hence `any`.
  * Exported for unit testing; still passed directly to `evaluate()` below.
  */
-export declare function probeElementAttrs(el: any, keep: string[]): CapturedAttrs;
+export declare function probeElementAttrs(el: any, arg: ProbeArg): CapturedAttrs;
 /**
  * The fixtures `piwiFixtures` / `extendPiwiFixtures` contribute. The single
  * added fixture is `piwiCapture`: an auto, test-scoped teardown hook that

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

@@ -1,12 +1,55 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.piwiFixtures = void 0;
+exports.piwiFixtures = exports.CAPTURED_ATTRS_ARG = void 0;
+exports.computeCoreVitals = computeCoreVitals;
+exports.buildPageState = buildPageState;
 exports.ariaSnapshotBestEffort = ariaSnapshotBestEffort;
 exports.probeElementAttrs = probeElementAttrs;
 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");
+/**
+ * Aggregate buffered performance entries into LCP/CLS/INP. Pure and Node-side
+ * so it is unit-testable; the in-page evaluate only ships raw entry projections.
+ * A null entry list means the entry type is unsupported (non-Chromium) — the
+ * metric is null rather than 0 so absence is distinguishable from "no shifts".
+ */
+function computeCoreVitals(lcpEntries, shiftEntries, eventEntries) {
+    // The last LCP candidate is the final LCP.
+    const lastLcp = lcpEntries && lcpEntries.length > 0 ? lcpEntries[lcpEntries.length - 1] : null;
+    const lcp = lastLcp && typeof lastLcp.startTime === 'number' ? Math.round(lastLcp.startTime) : null;
+    // Simple sum over shifts without recent input. The spec's session-window
+    // grouping matters for long sessions; a test's page lifetime is short enough
+    // that the plain sum tracks it closely.
+    let cls = null;
+    if (shiftEntries) {
+        const sum = shiftEntries.reduce((acc, e) => acc + (e.hadRecentInput ? 0 : typeof e.value === 'number' ? e.value : 0), 0);
+        cls = Math.round(sum * 10000) / 10000;
+    }
+    // Worst interaction latency: max duration per interactionId, then the p98
+    // interaction when there are many (mirrors the INP definition, simplified).
+    let inp = null;
+    if (eventEntries && eventEntries.length > 0) {
+        const byInteraction = new Map();
+        for (const e of eventEntries) {
+            if (typeof e.interactionId !== 'number' || e.interactionId <= 0)
+                continue;
+            const duration = typeof e.duration === 'number' ? e.duration : 0;
+            const prev = byInteraction.get(e.interactionId) ?? 0;
+            if (duration > prev)
+                byInteraction.set(e.interactionId, duration);
+        }
+        const durations = [...byInteraction.values()].sort((a, b) => a - b);
+        if (durations.length > 0) {
+            const index = durations.length > 50 ? Math.floor(durations.length * 0.98) : durations.length - 1;
+            inp = Math.round(durations[Math.min(index, durations.length - 1)]);
+        }
+    }
+    if (lcp === null && cls === null && inp === null)
+        return null;
+    return { lcp, cls, inp };
+}
 function createSink() {
     return {
         networkRequests: [],
@@ -18,6 +61,7 @@ function createSink() {
         lastActivePage: null,
         testInfo: null,
         stashedWebVitals: null,
+        stashedPageState: null,
         stashedAria: null,
     };
 }
@@ -64,12 +108,13 @@ function pageContext(page) {
         return null;
     }
 }
-/** Read navigation/paint timings from a page — null when unavailable or the page is gone. */
+/** Read navigation/paint timings and core-vitals entries — 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(() => {
+        // the callback return type pins the result. Aggregation happens Node-side
+        // in computeCoreVitals so the in-page code stays a thin projection.
+        const probe = await page.evaluate(async () => {
             const navEntries = performance.getEntriesByType('navigation');
             const paintEntries = performance.getEntriesByType('paint');
             const nav = navEntries[0];
@@ -90,20 +135,165 @@ async function readWebVitals(page) {
                 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 };
+            // Buffered-observer read of an entry type. Returns null when the type is
+            // unsupported (non-Chromium); [] when supported but nothing recorded.
+            // Buffered entries are dispatched in a queued task, so wait one macrotask
+            // before draining with takeRecords().
+            const readBuffered = (type, extra) => new Promise((resolve) => {
+                try {
+                    const PO = globalThis.PerformanceObserver;
+                    if (!PO || !(PO.supportedEntryTypes || []).includes(type))
+                        return resolve(null);
+                    const out = [];
+                    const po = new PO((list) => out.push(...list.getEntries()));
+                    po.observe({ type, buffered: true, ...extra });
+                    setTimeout(() => {
+                        try {
+                            out.push(...po.takeRecords());
+                            po.disconnect();
+                        }
+                        catch {
+                            // Entries gathered so far still count.
+                        }
+                        resolve(out);
+                    }, 0);
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+            const [lcpRaw, shiftRaw, eventRaw, firstInputRaw] = await Promise.all([
+                readBuffered('largest-contentful-paint'),
+                readBuffered('layout-shift'),
+                // durationThreshold 40 mirrors the web-vitals library — captures every
+                // interaction slow enough to matter without flooding the buffer.
+                readBuffered('event', { durationThreshold: 40 }),
+                readBuffered('first-input'),
+            ]);
+            const project = (entries) => entries === null
+                ? null
+                : entries.map((e) => ({
+                    startTime: e.startTime,
+                    value: e.value,
+                    hadRecentInput: e.hadRecentInput,
+                    interactionId: e.interactionId,
+                    duration: e.duration,
+                }));
+            const interactionEntries = eventRaw === null && firstInputRaw === null ? null : [...(eventRaw ?? []), ...(firstInputRaw ?? [])];
+            return {
+                navigation,
+                paint,
+                lcpEntries: project(lcpRaw),
+                shiftEntries: project(shiftRaw),
+                eventEntries: project(interactionEntries),
+            };
+        });
+        if (!probe)
+            return null;
+        const vitals = computeCoreVitals(probe.lcpEntries, probe.shiftEntries, probe.eventEntries);
+        if (!probe.navigation && Object.keys(probe.paint).length === 0 && !vitals)
+            return null;
+        return { navigation: probe.navigation, paint: probe.paint, vitals };
+    }
+    catch {
+        return null;
+    }
+}
+const PAGE_STATE_MAX_STORAGE_KEYS = 50;
+const PAGE_STATE_MAX_COOKIES = 30;
+const PAGE_STATE_HISTORY_CAP = 2048;
+const TOKEN_MASK_RES = [/\beyJ[\w-]{10,}\.[\w-]{5,}\.[\w-]{5,}\b/g, /\b[0-9a-f]{32,}\b/gi];
+/**
+ * Assemble the wire page-state from the in-page reads and the context cookies.
+ * Pure and Node-side so the sanitization (token masking, caps, value-free
+ * cookies) is unit-testable.
+ */
+function buildPageState(raw, cookies) {
+    let historyState = raw.historyState;
+    if (historyState) {
+        for (const re of TOKEN_MASK_RES)
+            historyState = historyState.replace(re, '[masked]');
+        if (historyState.length > PAGE_STATE_HISTORY_CAP) {
+            historyState = historyState.slice(0, PAGE_STATE_HISTORY_CAP) + '…';
+        }
+    }
+    const capStorage = (entries) => (Array.isArray(entries) ? entries : []).slice(0, PAGE_STATE_MAX_STORAGE_KEYS).map((e) => ({
+        key: String(e.key).slice(0, 200),
+        length: typeof e.length === 'number' ? e.length : 0,
+    }));
+    return {
+        url: raw.url,
+        hash: raw.hash || null,
+        historyState: historyState || null,
+        localStorage: capStorage(raw.localStorage),
+        sessionStorage: capStorage(raw.sessionStorage),
+        cookies: (cookies ?? []).slice(0, PAGE_STATE_MAX_COOKIES).map((c) => ({
+            name: String(c.name ?? ''),
+            domain: String(c.domain ?? ''),
+            path: String(c.path ?? ''),
+            httpOnly: Boolean(c.httpOnly),
+            secure: Boolean(c.secure),
+            ...(c.sameSite !== undefined ? { sameSite: String(c.sameSite) } : {}),
+            ...(typeof c.expires === 'number' ? { expires: c.expires } : {}),
+        })),
+    };
+}
+/** Read the page's state — null when unavailable or the page is gone. */
+async function readPageState(page) {
+    try {
+        const raw = await page.evaluate(() => {
+            // Key names + value lengths only — values never leave the page.
+            const listStorage = (s) => {
+                const out = [];
+                try {
+                    for (let i = 0; i < s.length; i++) {
+                        const key = s.key(i);
+                        if (key != null)
+                            out.push({ key, length: (s.getItem(key) ?? '').length });
+                    }
+                }
+                catch {
+                    // Storage access can throw in sandboxed/opaque-origin pages.
+                }
+                return out;
+            };
+            const g = globalThis;
+            let historyState = null;
+            try {
+                historyState = g.history?.state == null ? null : JSON.stringify(g.history.state);
+            }
+            catch {
+                // Unserializable history state.
+            }
+            return {
+                url: g.location.href,
+                hash: g.location.hash || null,
+                historyState,
+                localStorage: listStorage(globalThis.localStorage),
+                sessionStorage: listStorage(globalThis.sessionStorage),
+            };
         });
+        if (!raw)
+            return null;
+        // Cookie flags are only reachable from the context API, never document.cookie.
+        let cookies = null;
+        try {
+            cookies = (await pageContext(page)?.cookies()) ?? null;
+        }
+        catch {
+            cookies = null;
+        }
+        return buildPageState(raw, cookies);
     }
     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.
+ * Take the page-dependent teardown reads (web vitals; page state; 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;
@@ -115,6 +305,11 @@ async function stashPageState(sink, closing) {
     const vitals = await readWebVitals(page);
     if (vitals)
         sink.stashedWebVitals = vitals;
+    if (process.env.PIWI_CAPTURE_PAGE_STATE !== 'false') {
+        const pageState = await readPageState(page);
+        if (pageState)
+            sink.stashedPageState = pageState;
+    }
     const status = sink.testInfo?.status;
     if (status === 'failed' || status === 'timedOut' || status === 'interrupted') {
         const aria = await ariaSnapshotBestEffort(page.locator(':root'), 1000);
@@ -134,9 +329,15 @@ const PATCHED_BROWSERS = new WeakSet();
 const CHAIN_METHOD_SET = new Set(locator_healing_js_1.CHAIN_METHODS);
 const ACTION_METHOD_SET = new Set(locator_healing_js_1.ACTION_METHODS);
 const FORM_FIELD_TAGS = new Set(['input', 'select', 'textarea']);
-// CAPTURED_ATTRIBUTES is passed verbatim into evaluate() on every action — copy
-// it once instead of spreading a fresh array per call.
-const CAPTURED_ATTRS_ARG = [...locator_healing_js_1.CAPTURED_ATTRIBUTES];
+/** Built once — passed verbatim into evaluate() on every action. */
+exports.CAPTURED_ATTRS_ARG = {
+    keep: [...locator_healing_js_1.CAPTURED_ATTRIBUTES],
+    tagRoles: locator_healing_js_1.TAG_TO_ROLE,
+    inputRoles: locator_healing_js_1.INPUT_TYPE_TO_ROLE,
+    // '[role]' plus every tag the maps can resolve (input/select are handled by
+    // special-cased logic in the probe, so add them explicitly).
+    roleSources: [...new Set(['[role]', 'input', 'select', ...Object.keys(locator_healing_js_1.TAG_TO_ROLE)])].join(','),
+};
 /**
  * ARIA snapshot that tolerates every Playwright version the reporter supports,
  * returning null instead of throwing so a capture can never fail the test. The
@@ -181,7 +382,8 @@ async function ariaSnapshotBestEffort(target, timeout) {
  * `el` is browser-context (no DOM lib in this Node package), hence `any`.
  * Exported for unit testing; still passed directly to `evaluate()` below.
  */
-function probeElementAttrs(el, keep) {
+function probeElementAttrs(el, arg) {
+    const { keep, tagRoles, inputRoles, roleSources } = arg;
     const attrMap = {};
     for (const key of keep) {
         const v = el.getAttribute(key) ?? el[key];
@@ -228,6 +430,136 @@ function probeElementAttrs(el, keep) {
     catch {
         // Uniqueness probing is best-effort — never fail the capture.
     }
+    // Structural probe: the element's position among same-role elements plus
+    // anchor-worthy ancestors — powers name-free and ancestor-scoped
+    // alternatives that survive accessible-name renames. Role resolution reuses
+    // the shared maps passed in via `arg` (see roleOf below).
+    let rolePosition = null;
+    const ancestors = [];
+    try {
+        const doc = el.ownerDocument;
+        const cssEsc = (s) => doc.defaultView.CSS.escape(s);
+        const count = (sel) => {
+            try {
+                return doc.querySelectorAll(sel).length;
+            }
+            catch {
+                return undefined;
+            }
+        };
+        // Role resolution on live DOM nodes, mirroring the Node-side resolveAriaRole
+        // branching. The role maps are passed in (arg.tagRoles/inputRoles) so this
+        // serialized-into-page function shares the single source of truth in
+        // locator-healing.ts rather than re-declaring it.
+        const roleOf = (n) => {
+            const explicit = n.getAttribute('role');
+            if (explicit)
+                return explicit;
+            const tag = (n.tagName || '').toLowerCase();
+            if (tag === 'input')
+                return inputRoles[(n.getAttribute('type') || 'text').toLowerCase()] ?? 'textbox';
+            if (tag === 'select')
+                return n.getAttribute('multiple') != null ? 'listbox' : 'combobox';
+            if (tag === 'a')
+                return n.getAttribute('href') != null ? 'link' : null;
+            return tagRoles[tag] ?? null;
+        };
+        const levelOf = (n) => {
+            const m = /^h([1-6])$/.exec((n.tagName || '').toLowerCase());
+            if (m)
+                return Number(m[1]);
+            const al = n.getAttribute('aria-level');
+            return al && /^\d+$/.test(al) ? Number(al) : null;
+        };
+        const targetRole = roleOf(el);
+        const targetLevel = targetRole === 'heading' ? levelOf(el) : null;
+        if (targetRole) {
+            const nodes = doc.querySelectorAll(roleSources);
+            // A truncated scan would produce wrong counts/indexes — skip instead.
+            if (nodes.length <= 4000) {
+                let roleCountAll = 0;
+                let index = -1;
+                let levelCount = 0;
+                for (let i = 0; i < nodes.length; i++) {
+                    const n = nodes[i];
+                    if (roleOf(n) !== targetRole)
+                        continue;
+                    if (n === el)
+                        index = roleCountAll;
+                    roleCountAll++;
+                    if (targetLevel != null && levelOf(n) === targetLevel)
+                        levelCount++;
+                }
+                if (index !== -1) {
+                    rolePosition = {
+                        role: targetRole,
+                        count: roleCountAll,
+                        index,
+                        ...(targetLevel != null ? { levelCount } : {}),
+                    };
+                }
+                // Anchor-worthy ancestors: a stable hook (test id, id, explicit role,
+                // aria-label) or a container/landmark tag, nearest first. Counts are
+                // computed here so alternative generation never guesses uniqueness.
+                const CONTAINER_TAGS = ['form', 'nav', 'main', 'article', 'section', 'dialog', 'table'];
+                const docRoleCount = (role) => {
+                    let c = 0;
+                    for (let i = 0; i < nodes.length; i++)
+                        if (roleOf(nodes[i]) === role)
+                            c++;
+                    return c;
+                };
+                let node = el.parentElement;
+                let depth = 0;
+                while (node && depth < 12 && ancestors.length < 4) {
+                    depth++;
+                    const tag = (node.tagName || '').toLowerCase();
+                    if (tag === 'body' || tag === 'html')
+                        break;
+                    const testId = node.getAttribute('data-testid');
+                    const id = node.getAttribute('id');
+                    const explicitRole = node.getAttribute('role');
+                    const ariaLabel = node.getAttribute('aria-label');
+                    const anchorRole = explicitRole || (CONTAINER_TAGS.includes(tag) ? tagRoles[tag] : null) || null;
+                    if (testId || id || anchorRole || ariaLabel) {
+                        // The leaf-role match count within this ancestor (level-scoped for
+                        // headings — the emitted chained locator is level-scoped too).
+                        const scoped = node.querySelectorAll(roleSources);
+                        let scopedRoleCount = 0;
+                        if (scoped.length <= 2000) {
+                            for (let i = 0; i < scoped.length; i++) {
+                                const n = scoped[i];
+                                if (roleOf(n) !== targetRole)
+                                    continue;
+                                if (targetLevel != null && levelOf(n) !== targetLevel)
+                                    continue;
+                                scopedRoleCount++;
+                            }
+                        }
+                        else {
+                            scopedRoleCount = -1; // truncated — unusable
+                        }
+                        ancestors.push({
+                            tag,
+                            depth,
+                            testId: testId || null,
+                            id: id || null,
+                            role: explicitRole || null,
+                            ariaLabel: ariaLabel || null,
+                            ...(scopedRoleCount >= 0 ? { scopedRoleCount } : {}),
+                            ...(testId ? { testIdCount: count(`[data-testid=${JSON.stringify(testId)}]`) } : {}),
+                            ...(id ? { idCount: count(`#${cssEsc(id)}`) } : {}),
+                            ...(anchorRole ? { roleCount: docRoleCount(anchorRole) } : {}),
+                        });
+                    }
+                    node = node.parentElement;
+                }
+            }
+        }
+    }
+    catch {
+        // Structural probing is best-effort — never fail the capture.
+    }
     return {
         tagName: el.tagName?.toLowerCase?.() ?? 'unknown',
         attributes: attrMap,
@@ -240,6 +572,8 @@ function probeElementAttrs(el, keep) {
         },
         hasLabel: !!(el.labels && el.labels.length > 0),
         selectorCounts,
+        rolePosition,
+        ancestors,
     };
 }
 // Chain methods that take args and define a new locator scope (not just narrow).
@@ -308,7 +642,7 @@ function wrapLocator(page, locator, originMethod, originArgs) {
                 // 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 probe = target.evaluate(probeElementAttrs, exports.CAPTURED_ATTRS_ARG);
                 const settledProbe = probe.then(() => undefined, () => undefined);
                 PENDING_PROBES.add(settledProbe);
                 settledProbe.then(() => PENDING_PROBES.delete(settledProbe));
@@ -338,13 +672,17 @@ function wrapLocator(page, locator, originMethod, originArgs) {
                             location: callerLocation,
                             used,
                             // hasLabel/selectorCounts inform alternative generation only —
-                            // keep the stored element to the wire shape.
+                            // keep the stored element to the wire shape. rolePosition and
+                            // ancestors ARE wire fields: the server's renamed-element match
+                            // uses them at heal time.
                             element: {
                                 tagName: attrs.tagName,
                                 attributes: attrs.attributes,
                                 textContent: attrs.textContent,
                                 accessibleName,
                                 center: attrs.center,
+                                ...(attrs.rolePosition ? { rolePosition: attrs.rolePosition } : {}),
+                                ...(attrs.ancestors && attrs.ancestors.length > 0 ? { ancestors: attrs.ancestors } : {}),
                             },
                             alternatives: (0, locator_healing_js_1.generateAlternatives)({ ...attrs, accessibleName }),
                         };
@@ -626,6 +964,16 @@ async function flushSink(sink, testInfo) {
             body: Buffer.from(JSON.stringify(webVitals)),
         });
     }
+    // Page state at test end (pass AND fail — the pass side is the diff baseline).
+    if (process.env.PIWI_CAPTURE_PAGE_STATE !== 'false') {
+        const pageState = (pageReadable ? await readPageState(page) : null) ?? sink.stashedPageState;
+        if (pageState) {
+            await testInfo.attach(attachments_js_1.ATTACHMENT_NAMES.pageState, {
+                contentType: 'application/json',
+                body: Buffer.from(JSON.stringify(pageState)),
+            });
+        }
+    }
 }
 /**
  * Playwright fixtures that collect network requests, console entries,

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[];
 }
@@ -93,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
@@ -101,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.
@@ -161,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.
@@ -196,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;
@@ -149,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',
@@ -159,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',
@@ -191,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',
@@ -224,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.
@@ -234,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;
@@ -280,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,
         });
     }
@@ -293,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,
         });
     }
@@ -379,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');
@@ -538,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;
 }
@@ -584,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) {
@@ -614,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.
@@ -643,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;
@@ -667,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 };
@@ -687,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
@@ -722,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.11.0",
+  "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",