@piwitests/reporter 0.62.0 → 0.64.0

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.62.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