@piwitests/reporter 0.63.0 → 0.64.0

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

@@ -1,6 +1,214 @@
-export { CAPTURED_ATTRIBUTES, INPUT_TYPE_TO_ROLE, TAG_TO_ROLE, approximateAccessibleName, classifyCssStability, generateAlternatives, headingLevel, isAutoGenerated, resolveAriaRole } from '@piwitests/core/locator-generation';
-import { LocatorSnapshot } from '@piwitests/core/locator-healing-types';
-export { AncestorAnchor, ElementAttributes, LocatorSnapshot, RankedLocator, RolePosition, SelectorCounts } from '@piwitests/core/locator-healing-types';
+/**
+ * Shared types for locator healing — the in-runtime capture + storage of
+ * alternative locators for every element interaction.
+ *
+ * The single source of truth: the dashboard app re-exports these via
+ * `#shared/locator-healing.types`, and the reporter bundles them at build time.
+ */
+/** A ranked alternative locator suggestion. */
+interface RankedLocator {
+    locator: string;
+    method: string;
+    args: Record<string, unknown>;
+    /** 0-100 stability score. data-testid=100, semantic CSS=35-40, hash-suffixed=10. */
+    score: number;
+    /**
+     * True when a human confirmed this alternative in the reporter's
+     * failure-time locator picker (`pickLocatorOnFailure`). A confirmed pick is
+     * surfaced distinctly and preferred as the recommended fix.
+     */
+    pickedByUser?: boolean;
+    /** When the pick was saved from the dashboard's snapshot picker, ISO 8601. */
+    pickedAt?: string;
+}
+/**
+ * Match counts for candidate selectors, probed against the live DOM at capture
+ * time. A count > 1 marks the selector ambiguous (strict-mode violation).
+ */
+interface SelectorCounts {
+    testId?: number;
+    id?: number;
+    name?: number;
+    classes?: Record<string, number>;
+    /** How many elements share this element's role *and* exact accessible name (`getByRole(role, { name })` without `exact` also matches names that contain it). Absent when unknown (an older capture, or a probe run without the structural pass). */
+    roleName?: number;
+    /** Of the `roleName` matches, how many are visible (a laid-out box, or an `offsetParent`) — what `getByRole(role, { name }).visible()` would match. Absent when unknown. */
+    visibleRoleName?: number;
+    /** How many elements `getByText` would match on this element's text, counted no further than 2. Absent when unknown. */
+    text?: number;
+    /** How many elements share this element's `placeholder` — what `getByPlaceholder` would really match. Absent when unknown. */
+    placeholder?: number;
+    /** How many elements share this element's `alt` — what `getByAltText` would really match. Absent when unknown. */
+    alt?: number;
+    /** How many elements share this element's `title` — what `getByTitle` would really match. Absent when unknown. */
+    title?: number;
+}
+/**
+ * The element's position among same-role elements in the document at capture
+ * time — a name-independent structural identity used to re-find a renamed
+ * element on the failing page.
+ */
+interface RolePosition {
+    role: string;
+    /** How many elements resolved to this role, document-wide. */
+    count: number;
+    /** The captured element's 0-based index among them, in document order. */
+    index: number;
+    /** For headings: how many same-role elements share this element's level. */
+    levelCount?: number;
+}
+/**
+ * An anchor-worthy ancestor of the captured element — one carrying a stable
+ * hook (test id, id, explicit role, aria-label, or a landmark tag) that a
+ * scoped alternative locator can chain from. Nearest ancestors first.
+ */
+interface AncestorAnchor {
+    tag: string;
+    /** Hops from the element (1 = direct parent). */
+    depth: number;
+    testId: string | null;
+    id: string | null;
+    /** Explicit role attribute, if any. */
+    role: string | null;
+    ariaLabel: string | null;
+    /** Same-role matches for the captured element within this ancestor. */
+    scopedRoleCount?: number;
+    /**
+     * Matches for the captured element's text within this ancestor. A role-less
+     * leaf (a price `<span>`, a status badge) has no role to scope, so this is
+     * what tells a chain that resolves to one element from one that does not.
+     */
+    scopedTextCount?: 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;
+    /**
+     * A stable non-testid `data-*` hook on this ancestor (`data-product="43"`,
+     * `data-row-id="7"`). Many apps identify a repeated card or row this way and
+     * nothing else, so without it the only locator left is one that matches every
+     * card on the page.
+     */
+    dataAttr?: {
+        name: string;
+        value: string;
+    };
+    /** Document-wide match count for `dataAttr` as an attribute selector. */
+    dataAttrCount?: number;
+    /**
+     * Text inside this ancestor that tells it apart from its same-role siblings —
+     * the product name in a card, the customer name in a table row. A repeated
+     * container carries no unique hook of its own, so this is what makes
+     * `getByRole('listitem').filter({ hasText: 'Keyboard' })` land on one of them.
+     */
+    filterText?: string;
+    /** How many elements of this ancestor's role contain `filterText`. */
+    filterRoleCount?: number;
+}
+/** Raw element attributes captured after a successful action. */
+interface ElementAttributes {
+    tagName: string;
+    attributes: Record<string, string | null>;
+    /** Visible text, truncated to 80 chars. */
+    textContent: string | null;
+    /** Browser-computed accessible name from ariaSnapshot(). */
+    accessibleName: string | null;
+    /** Center point of the element's bounding box — spatial discriminator. */
+    center: {
+        x: number;
+        y: number;
+    } | null;
+    /** True when the element has an associated <label> — gates getByLabel. */
+    hasLabel?: boolean;
+    /** Text of the elements `aria-labelledby` points at, else of the first associated `<label>` — what names a form field. Absent when the probe did not read it. */
+    labelText?: string | null;
+    /** 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[];
+}
+/** One captured element interaction (per locator call site). */
+interface LocatorSnapshot {
+    /** The Playwright step location — unique, stable identity of this call site. */
+    location: string | null;
+    /** The locator the test code actually used. */
+    used: {
+        method: string;
+        /** All args passed to the locator method. */
+        args: unknown[];
+        /** Original step title, for round-tripping. */
+        raw: string;
+    };
+    /** Element attributes — null for gap entries (failed actions). */
+    element: {
+        tagName: string;
+        attributes: Record<string, string | null>;
+        textContent: string | null;
+        accessibleName: string | null;
+        center: {
+            x: number;
+            y: number;
+        } | null;
+        /** Position among same-role elements at capture time (newer reporters only). */
+        rolePosition?: RolePosition | null;
+        /** Anchor-worthy ancestors, nearest first (newer reporters only). */
+        ancestors?: AncestorAnchor[];
+    } | null;
+    /** Computed alternative locators, ranked by stability score (max 10). */
+    alternatives: RankedLocator[];
+}
+
+/**
+ * Locator generation — pure functions for building ranked alternative locators
+ * from element attributes. The single source of truth shared by the server, the
+ * dashboard SPA, the interactive DOM snapshot picker (which runs in the
+ * browser), and the Playwright reporter (which bundles this at build time).
+ */
+
+/** Implicit ARIA role for an HTML tag (when no explicit `role` is set). */
+declare const TAG_TO_ROLE: Record<string, string>;
+/** Implicit ARIA role for an `<input>` keyed by its `type` attribute. */
+declare const INPUT_TYPE_TO_ROLE: Record<string, string>;
+/** Element attributes captured by the probe. */
+declare const CAPTURED_ATTRIBUTES: string[];
+declare function resolveAriaRole(attrs: ElementAttributes): string | null;
+declare function headingLevel(attrs: ElementAttributes, role: string | null): number | null;
+declare function classifyCssStability(className: string): number;
+declare function isAutoGenerated(value: string): boolean;
+interface GenerateOptions {
+    /**
+     * The element's role from an accessibility model, for a caller that has one:
+     * every role candidate uses it instead of `resolveAriaRole(attrs)`, and null
+     * means the element has none. `rolePosition` and the anchors' scoped role
+     * counts must then describe this role.
+     */
+    role?: string | null;
+    /**
+     * The attribute `getByTestId` reads in the project (Playwright's
+     * `testIdAttribute`); `data-testid` when null or absent. The element's
+     * `getByTestId` candidate comes from it, and so do the anchors', whose
+     * `testId` and `testIdCount` the probe reads from the same attribute
+     * (`ProbeArg.testIdAttribute`). No `locator()` candidate selects on it, since
+     * `getByTestId` does; any other attribute, `data-testid` included, is an
+     * ordinary one.
+     */
+    testIdAttribute?: string | null;
+}
+declare function generateAlternatives(attrs: ElementAttributes, options?: GenerateOptions): RankedLocator[];
+/**
+ * Approximate the accessible name from probed attributes, in the order the
+ * accessible-name computation applies: `aria-labelledby` (resolved by the probe
+ * into `labelText`), `aria-label`, then — for a form field — its `<label>`, or —
+ * for anything else — its text, then `title` and `placeholder`.
+ *
+ * A form field is never named by its own text: a `<select>`'s text is its
+ * options and a `<textarea>`'s is its value.
+ */
+declare function approximateAccessibleName(attrs: ElementAttributes): string | null;
 
 /**
  * Reporter-local locator healing.
@@ -157,4 +365,4 @@ declare function callSitePath(file: string, cwd?: string, windows?: boolean): st
  */
 declare function captureCallerLocation(stack?: string): string | null;
 
-export { ACTION_METHODS, CHAIN_METHODS, EXPECT_CAPTURE_EXPRESSIONS, EXPECT_METHOD, FORM_FIELD_TAGS, type FailedLocatorInfo, LOCATOR_CREATING_CHAINS, LOCATOR_METHODS, type LocatorSuggestion, type NameSource, callSitePath, captureCallerLocation, dedupeSnapshotsByLocation, exactAccessibleName, extractAccessibleName, framePath, renderFailing, suggestLocatorsFromAria };
+export { ACTION_METHODS, type AncestorAnchor, CAPTURED_ATTRIBUTES, CHAIN_METHODS, EXPECT_CAPTURE_EXPRESSIONS, EXPECT_METHOD, type ElementAttributes, FORM_FIELD_TAGS, type FailedLocatorInfo, INPUT_TYPE_TO_ROLE, LOCATOR_CREATING_CHAINS, LOCATOR_METHODS, type LocatorSnapshot, type LocatorSuggestion, type NameSource, type RankedLocator, type RolePosition, type SelectorCounts, TAG_TO_ROLE, approximateAccessibleName, callSitePath, captureCallerLocation, classifyCssStability, dedupeSnapshotsByLocation, exactAccessibleName, extractAccessibleName, framePath, generateAlternatives, headingLevel, isAutoGenerated, renderFailing, resolveAriaRole, suggestLocatorsFromAria };

package/dist/internal/capture/pick-on-failure.d.ts

@@ -1,9 +1,187 @@
 import { TestInfo, Page } from '@playwright/test';
-import { PickedAnchorInfo, ProbeArg, ProbedAttrs } from '@piwitests/picker-dom';
-export { PickedAnchorInfo, PickedLeafInfo, generateAnchoredAlternatives, installPickerOverlay, mergeCandidates, showAnchorPicker, showPickerChoices } from '@piwitests/picker-dom';
-import { FailedLocatorInfo } from './locator-healing.js';
-import { RankedLocator, LocatorSnapshot } from '@piwitests/core/locator-healing-types';
-import '@piwitests/core/locator-generation';
+import { P as ProbeArg, a as ProbedAttrs } from '../../types-CGr9jJZ_.js';
+import { RankedLocator, LocatorSnapshot, FailedLocatorInfo } from './locator-healing.js';
+
+/** The overlay's texts a host may give in its own language; each one left out is the English default. */
+interface PickerOverlayStrings {
+    /** The banner's heading for the `'global'` transport with no failing locator. */
+    banner?: string;
+    /** The banner's foot before an element is hovered: the keys, Enter picking the focused element. */
+    keys?: string;
+    /** The banner's foot while an element is hovered: a click or Enter picks it. */
+    keysHovering?: string;
+    /** The banner's foot once an element is picked. */
+    analyzing?: string;
+}
+/** Configuration for `installPickerOverlay` — see the function doc for the transport split. */
+interface PickerOverlayArg {
+    transport: 'global' | 'postMessage';
+    /** Rendered failing locator for the banner heading (`'global'` transport only). */
+    failing?: string | null;
+    /** Probe arguments for the inline probe the `'postMessage'` transport performs on pick. */
+    probeArg?: ProbeArg;
+    /** The banner's texts, for a host that shows another language than English. */
+    strings?: PickerOverlayStrings;
+    /**
+     * The attribute `getByTestId` reads in the project (Playwright's
+     * `testIdAttribute`); `data-testid` when null or absent. The overlay's own
+     * description of an element and its snapping to a test id read it.
+     */
+    testIdAttribute?: string | null;
+}
+/**
+ * Runs inside the browser — installs the element-picking overlay: a hover
+ * highlight, an instruction banner, and capture-phase listeners that suppress
+ * the app's own handlers while picking. The hover target snaps to the nearest
+ * actionable ancestor (button/link/field/role/test id) and up/down walk the
+ * DOM chain before the click commits. The hover reaches into open shadow
+ * roots, and the chain walks out of them through each host. Enter picks the
+ * outlined element, or with none the focused one, so a control reached with
+ * Tab is picked without the pointer.
+ *
+ * `transport` picks how a pick/skip is reported, since the two hosts cross
+ * fundamentally different boundaries:
+ *  - `'global'` — the reporter drives a live page from Node over CDP. The
+ *    picked element is parked on `globalThis.__piwiPickedElement` and
+ *    `__piwiPickState` is set to `'picked'`/`'skipped'`, polled from Node;
+ *    probing happens later, from Node, against a live element handle.
+ *  - `'postMessage'` — the snapshot picker runs standalone inside a sandboxed
+ *    opaque-origin iframe with nothing outside able to reach in, so the pick
+ *    is probed and posted to `window.parent` in the same tick. The probe
+ *    itself can't be imported (a serialized function carries no imports), so
+ *    the embedding host installs it on `globalThis.__piwiProbe` before
+ *    invoking this function, and may install lifecycle hooks on
+ *    `globalThis.__piwiSnapshotExtras` (`onPick`/`onClose`) for its own
+ *    snapshot-only chrome (search, highlight hints, extended inertness).
+ *
+ * The banner is in English unless `arg.strings` gives its texts.
+ *
+ * The hovered element's locator is shown twice — in a chip pinned to the
+ * element itself and on its own line in the banner. Both render whatever
+ * `globalThis.__piwiDescribeElement(el)` returns when a host installs one (the
+ * extension points it at the real ranked locator engine), falling back to this
+ * function's own attribute-order approximation. A host whose answer improves
+ * later (checked against the page once the pointer rests) calls
+ * `globalThis.__piwiRedescribe()` to have the hovered element described again.
+ *
+ * Must stay fully self-contained (no module-closure references) — both hosts
+ * re-serialize this function via `Function.prototype.toString()` (the
+ * reporter through `page.evaluate`, the snapshot picker through `String()`
+ * into a `<script>` tag).
+ */
+declare function installPickerOverlay(arg: PickerOverlayArg): void;
+
+/** An ancestor the human blessed as an anchor, with its in-page uniqueness counts. */
+interface PickedAnchorInfo {
+    tag: string;
+    /** Hops from the picked element (1 = direct parent). */
+    depth: number;
+    testId: string | null;
+    id: string | null;
+    ariaLabel: string | null;
+    /** Resolved anchor role (explicit attribute or tag-implied). */
+    role: string | null;
+    /** Document-wide match count for the anchor's own test id. */
+    testIdCount?: number;
+    /** Document-wide match count for the anchor's own id. */
+    idCount?: number;
+    /** Document-wide count of same-role elements carrying the same aria-label. */
+    labeledRoleCount?: number;
+    /** Document-wide count of elements resolving to the anchor's role. */
+    roleCount?: number;
+    /** Leaf matches (picked element's identity) within this anchor's subtree. */
+    scopedLeafCount?: number;
+}
+/** The picked element's identity used for anchor-scoped candidates. */
+interface PickedLeafInfo {
+    role: string | null;
+    level: number | null;
+}
+/**
+ * The anchors step's texts a host may give in its own language; each one left
+ * out is the English default. `{count}` in a text stands for a number.
+ */
+interface AnchorPickerStrings {
+    title?: string;
+    hint?: string;
+    /** The footer with no parent selected. */
+    noneSelected?: string;
+    matchesOne?: string;
+    /** `{count}` elements, any count but one. */
+    matchesMany?: string;
+    countUnavailable?: string;
+    /** Under a parent: what it contains. */
+    containsOne?: string;
+    containsMany?: string;
+    /** Under a parent that cannot be selected. */
+    needsTestId?: string;
+    /** A parent with no test id, id or role, in place of its hook. */
+    noHook?: string;
+    use?: string;
+    skip?: string;
+}
+/** Arguments for `showAnchorPicker` — the role maps mirror the single source of truth in `@piwitests/core`. */
+interface AnchorPickerArg {
+    tagRoles: Record<string, string>;
+    inputRoles: Record<string, string>;
+    roleSources: string;
+    leafRole: string;
+    leafLevel: number | null;
+    leafTestId: string | null;
+    /**
+     * The attribute `getByTestId` reads in the project (Playwright's
+     * `testIdAttribute`), which `leafTestId` and each parent's test id are read
+     * from; `data-testid` when null or absent.
+     */
+    testIdAttribute?: string | null;
+    /** The panel's texts, for a host that shows another language than English. */
+    strings?: AnchorPickerStrings;
+}
+/**
+ * Runs inside the browser via `evaluate()` — the anchor step: lists the picked
+ * element's ancestors so the human can bless one or more stable parents to
+ * scope the locator to. Each row shows the ancestor's strongest hook and how
+ * many leaf matches it contains; the footer shows a live "matches N" count for
+ * the combined selection, recomputed against the real page on every toggle
+ * (exactly 1 = green). Hovering a row outlines that ancestor in the page and
+ * names it in a chip pinned to it. Resolves through `__piwiAnchorState` ('done' | 'skipped'); selected anchors
+ * land in `__piwiPickAnchors` (+ `__piwiPickChainCount`). While the step
+ * shows, `__piwiAnchorCleanup` holds its teardown (see `removeAnchorPicker`).
+ * Role resolution reuses the maps passed in `arg` (single source of truth in
+ * `@piwitests/core`). The ancestors and every count reach through open shadow
+ * roots, as Playwright's locators do. The panel is in English unless
+ * `arg.strings` gives its texts. Must stay fully self-contained.
+ */
+declare function showAnchorPicker(arg: AnchorPickerArg): void;
+
+/** Arguments for `showPickerChoices`. */
+interface PickerChoicesArg {
+    failing: string | null;
+    choices: Array<{
+        locator: string;
+        score: number;
+    }>;
+}
+/**
+ * Runs inside the browser via `evaluate()` — replaces the pick overlay with a
+ * confirmation panel listing the ranked replacement locators. The chosen index
+ * lands in `__piwiPickChoice` (-1 = skipped), polled from Node. While it shows,
+ * `__piwiChoiceCleanup` takes it out of the page unanswered (a pick that ended
+ * under it). Must stay fully self-contained.
+ */
+declare function showPickerChoices(arg: PickerChoicesArg): void;
+
+/**
+ * Build anchor-scoped candidates from the human-blessed parents. Shapes stay
+ * consistent with the heuristic chains in `generateAlternatives` — leaf method
+ * `getByRole` with flat anchor args, no leaf `name` key. Single-anchor
+ * candidates require the leaf to be unique inside that anchor; with two or
+ * more anchors a combined chain is added when the whole chain resolves to
+ * exactly one element (`chainLeafCount`). Pure — exported for tests.
+ */
+declare function generateAnchoredAlternatives(leaf: PickedLeafInfo, anchors: PickedAnchorInfo[], chainLeafCount?: number): RankedLocator[];
+/** Merge candidate lists, first list winning duplicates, sorted by score. Exported for tests. */
+declare function mergeCandidates(base: RankedLocator[], extra: RankedLocator[]): RankedLocator[];
 
 /**
  * The probe dependency, passed in by the capture fixture to avoid an import
@@ -91,4 +269,4 @@ declare function runLocatorPicker(page: Page, testInfo: TestInfo, failed: Failed
  */
 declare function applyPickToSnapshots(snapshots: LocatorSnapshot[], pick: UserPickResult): boolean;
 
-export { type PickedLocator, type PickerProbe, type UserPickResult, applyPickToSnapshots, deriveFailedLocator, parseLeafLocatorExpression, pickLocator, runLocatorPicker, unlessEnded };
+export { type PickedAnchorInfo, type PickedLeafInfo, type PickedLocator, type PickerProbe, type UserPickResult, applyPickToSnapshots, deriveFailedLocator, generateAnchoredAlternatives, installPickerOverlay, mergeCandidates, parseLeafLocatorExpression, pickLocator, runLocatorPicker, showAnchorPicker, showPickerChoices, unlessEnded };

package/dist/types-CGr9jJZ_.d.ts

@@ -0,0 +1,87 @@
+/** Arguments for `probeElementAttrs` — the role maps mirror the single source of truth in `@piwitests/core`. */
+interface ProbeArg {
+    /** Attribute whitelist to read off the element (the shared `CAPTURED_ATTRIBUTES`). */
+    keep: string[];
+    /** Required when `includeStructural` is true — role resolution needs the tag/input-type role maps. */
+    tagRoles?: Record<string, string>;
+    inputRoles?: Record<string, string>;
+    /** CSS selector matching every element role resolution can reach (also structural-only). */
+    roleSources?: string;
+    /** Compute `rolePosition` and ancestor-anchor candidates. The live picker always wants these; the snapshot picker never does (no anchors step there). */
+    includeStructural: boolean;
+    /**
+     * Count how many elements each candidate matches: `selectorCounts`,
+     * `rolePosition` and every anchor's counts, each a walk of the document or
+     * of an ancestor's subtree. True unless set: a caller that counts with an
+     * index of its own turns it off, and the anchors then carry what identifies
+     * them and no count, whatever the size of the page.
+     */
+    countMatches?: boolean;
+    /**
+     * The attribute `getByTestId` reads in the project (Playwright's
+     * `testIdAttribute`); `data-testid` when null or absent. It is read with
+     * `keep`, counted for `selectorCounts.testId`, read off each ancestor for its
+     * `testId` and `testIdCount`, and never taken as an ancestor's `dataAttr`;
+     * any other `data-*`, `data-testid` included, is an ordinary one.
+     */
+    testIdAttribute?: string | null;
+}
+/** Element shape the in-page probe returns — structural view of what the picker overlays need. */
+interface ProbedAttrs {
+    tagName: string;
+    attributes: Record<string, string | null>;
+    textContent: string;
+    center: {
+        x: number;
+        y: number;
+    };
+    hasLabel: boolean;
+    /** Text of the elements `aria-labelledby` points at, else of the first associated `<label>`. */
+    labelText: string | null;
+    selectorCounts: {
+        testId?: number;
+        id?: number;
+        name?: number;
+        classes?: Record<string, number>;
+        /** How many elements share this element's role *and* exact accessible name (`getByRole(role, { name })` without `exact` also matches names that contain it). */
+        roleName?: number;
+        /** Of the `roleName` matches, how many are laid out (a box, or an `offsetParent`) — what `getByRole(role, { name }).visible()` would match. */
+        visibleRoleName?: number;
+        /** How many elements `getByText` would match on this element's text, counted no further than 2 — every consumer only asks whether that is exactly one. Undefined when the element has no text, or the subtree was too large to scan. */
+        text?: number;
+        /** How many elements share this element's `placeholder` — what `getByPlaceholder` would really match. */
+        placeholder?: number;
+        /** How many elements share this element's `alt` — what `getByAltText` would really match. */
+        alt?: number;
+        /** How many elements share this element's `title` — what `getByTitle` would really match. */
+        title?: number;
+    };
+    rolePosition?: {
+        role: string;
+        count: number;
+        index: number;
+        levelCount?: number;
+    } | null;
+    ancestors?: Array<{
+        tag: string;
+        depth: number;
+        testId: string | null;
+        id: string | null;
+        role: string | null;
+        ariaLabel: string | null;
+        scopedRoleCount?: number;
+        scopedTextCount?: number;
+        testIdCount?: number;
+        idCount?: number;
+        roleCount?: number;
+        dataAttr?: {
+            name: string;
+            value: string;
+        };
+        dataAttrCount?: number;
+        filterText?: string;
+        filterRoleCount?: number;
+    }>;
+}
+
+export type { ProbeArg as P, ProbedAttrs as a };

package/dist/wire-7zsqlBoY.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Wire leaf shapes — the small, identical building blocks of the JSON contract
+ * exchanged between the reporter and the server. The single source of truth
+ * shared by the app (`#shared/types`) and the reporter (`types/wire.ts`).
+ *
+ * The per-case *payloads* are intentionally NOT here: the reporter produces a
+ * loose `WireTestCase` superset while the server receives the stricter
+ * `TestCasePayload` / `StreamEventPayload`. Those live on each side and are kept
+ * field-compatible by `apps/application/tests/unit/wire-shared-drift.test.ts`.
+ */
+
+/**
+ * One locator call and the page it ran on, as the capture fixtures record it
+ * in the `piwi-locator-pages` attachment: a test's calls, deduped by call
+ * site, chain and page. The dashboard joins it to the locator index, so a use
+ * of a chain knows the pages it was made on.
+ */
+interface LocatorPageUse {
+    /** `file:line:col` of the call, as a step location reports it (absolute; the server makes it project-relative). */
+    location: string;
+    /** The chain as Playwright prints it (`Locator.toString()`). */
+    locator: string;
+    /** The page's origin (`https://shop.test`), to tell the application's pages from third-party ones. */
+    origin: string;
+    /** The page key: the path with ids and tokens collapsed, no query, no hash (`/orders/:id`). */
+    page: string;
+    /** No locator interaction happened on the page since it was navigated to: the element was there as it loaded. */
+    arrival: boolean;
+}
+/** What a process is for the run, from its command line. */
+type ProcessRole = 'runner' | 'worker' | 'browser' | 'renderer' | 'gpu' | 'utility' | 'ffmpeg' | 'webServer' | 'other';
+/**
+ * Name of the PNG the capture fixtures attach to a failed test: the page the
+ * test last acted on. The reporter uploads it with the execution's files, and
+ * the dashboard shows it as the page at the failure.
+ */
+declare const FAILURE_SCREENSHOT_ATTACHMENT = "piwi-failure-screenshot";
+/** What the processes of one role used during a test. */
+interface RoleCost {
+    cpuMs: number;
+    /** Time runnable but waiting for a CPU. */
+    runWaitMs: number | null;
+    /** The largest process of the role during the test (its peak RSS). */
+    peakRssMb: number | null;
+    processes: number;
+}
+
+export { FAILURE_SCREENSHOT_ATTACHMENT as F, type LocatorPageUse as L, type ProcessRole as P, type RoleCost as R };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@piwitests/reporter",
-  "version": "0.63.0",
+  "version": "0.64.0",
   "description": "Playwright reporter that streams results, traces and HTML reports to a Piwi Dashboard instance",
   "url": "https://github.com/PiwiTests/piwi",
   "homepage": "https://piwitests.dev",
@@ -66,7 +66,7 @@
     "node": ">=20"
   },
   "peerDependencies": {
-    "@playwright/test": "^1.64.1"
+    "@playwright/test": ">=1.59.0 <2"
   },
   "dependencies": {
     "form-data": "^4.0.0"

package/templates/skills/write-the-missing-test/SKILL.md

@@ -87,10 +87,12 @@ view, and work from what it shows plus the repo.
 
 8. **Report back to Piwi.** Tell Piwi what you decided about the gap with
    `triage_gap` (Maintainer role or above on the project): `verb: "accept"` for the gap you
-   wrote the test for, `covered-by` with the covering test's id when a test you
-   found already covers it, or `dismiss` with the reason (`not-worth-testing`,
-   `covered-elsewhere`, `wrong`) when the evidence did not hold. Each verdict counts toward the precision of the
-   detector that raised the gap, so a detector that keeps being wrong is muted.
+   wrote the test for, `covered-by` with the test's id once a test written for the gap
+   has run, or `dismiss` when the gap needed no new test: `covered-elsewhere` with the id
+   of a test that already covered it, `not-worth-testing`, or `wrong` when the evidence did
+   not hold. Each verdict counts toward the precision of the detector that raised the gap
+   (`accept` and `covered-by` for it, `wrong` and `covered-elsewhere` against it), so a
+   detector that keeps being wrong is muted.
 
 ## Guardrails