@piwitests/reporter 0.63.0 → 0.64.0

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

@@ -1,4 +1,4 @@
-export { FAILURE_SCREENSHOT_ATTACHMENT } from '@piwitests/core/wire';
+export { F as FAILURE_SCREENSHOT_ATTACHMENT } from '../../wire-7zsqlBoY.js';
 
 /**
  * Names of the `testInfo` attachments the dashboard fixtures produce and the

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

@@ -1,10 +1,65 @@
-import { ProbeArg } from '@piwitests/picker-dom';
-export { ProbeArg, ProbedAttrs, probeElementAttrs } from '@piwitests/picker-dom';
-import { PageInteraction } from '@piwitests/core/page-interaction';
+import { P as ProbeArg, a as ProbedAttrs } from '../../types-CGr9jJZ_.js';
 import { Page, TestInfo, TestType, Fixtures, PlaywrightTestArgs, PlaywrightTestOptions, PlaywrightWorkerArgs, PlaywrightWorkerOptions, Locator } from '@playwright/test';
-import { LocatorPageUse, ProcessRole, RoleCost } from '@piwitests/core/wire';
-import { RunIntent, IntentAnswer } from '@piwitests/core/run-channel';
-import { JsCoverageEntry } from '@piwitests/core/code-reach';
+import { L as LocatorPageUse, P as ProcessRole, R as RoleCost } from '../../wire-7zsqlBoY.js';
+
+/**
+ * Runs inside the browser via `evaluate()` (live picker) or as part of a
+ * concatenated `<script>` (snapshot picker) — probes an element for its
+ * attributes, geometry, label association, and selector-uniqueness counts,
+ * plus (when `arg.includeStructural`) its position among same-role elements
+ * and anchor-worthy ancestors, which power name-free and ancestor-scoped
+ * locator alternatives. With `arg.countMatches` false it counts nothing and
+ * reports the anchors alone. The test id is read from `arg.testIdAttribute`,
+ * `data-testid` by default.
+ *
+ * Must stay a fully self-contained function (no references to this module's
+ * closure): both hosts re-serialize it via `Function.prototype.toString()`.
+ * `el` is browser-context (no DOM lib in this package), hence `any`.
+ */
+declare function probeElementAttrs(el: any, arg: ProbeArg): ProbedAttrs;
+
+/**
+ * What the page was doing at test end beyond its DOM, as the capture fixtures read it: the element holding
+ * keyboard focus, the element under the mouse, a text selection, the checkboxes in the indeterminate state. A
+ * trace snapshot records none of these, so the dashboard applies them to the failure-time DOM it renders.
+ *
+ * An element is named by its **element path**: the tag and the position among same-tag siblings
+ * (`:nth-of-type`) of each element from the root down, `/`-separated (`html:1/body:1/form:1/input:2`), with
+ * `|` stepping into the open shadow root of the element before it (`html:1/body:1/x-card:1|button:1`). Only
+ * same-tag siblings count, so the elements a trace snapshot drops (scripts, `noscript`, preload links) never
+ * shift it. A text position is an element path and a character offset into that element's text, scripts and
+ * styles left out, so it holds however the text was split into nodes. Positions only: a field's value and
+ * the selected text are never read.
+ */
+/** One element of the page, by element path, with a short label for people (`input#email`, `button "Save"`). */
+interface ElementRef {
+    path: string;
+    label: string;
+}
+/** A position in the page's text: an element and a character offset into its text. */
+interface TextPoint {
+    path: string;
+    offset: number;
+}
+interface PageInteraction {
+    /** The focused element; `visible` when the browser drew its focus ring (`:focus-visible`). */
+    focus?: {
+        element: ElementRef;
+        visible: boolean;
+        /** The caret or selected range in a text field, as `[start, end]`. */
+        selection?: [number, number];
+    };
+    /** The innermost element under the mouse (`:hover`). */
+    hover?: ElementRef;
+    /** A text selection in the page outside a field, and its length in characters. */
+    selection?: {
+        start: TextPoint;
+        end: TextPoint;
+        length: number;
+    };
+    /** Checkboxes in the indeterminate state, which only a script can set. */
+    indeterminate?: ElementRef[];
+}
 
 /** A main-frame navigation, full or same-document: the page starts over. */
 declare function noteNavigation(page: object): void;
@@ -27,6 +82,42 @@ declare class LocatorPageLog {
     list(): LocatorPageUse[];
 }
 
+/**
+ * The run channel: each worker of a test run the editor started keeps one connection, from before its first test to its
+ * end, to the local socket the editor service listens on for the record channel's hand-offs
+ * (`@piwitests/core/ide-recorder`). The run's environment names it as `PIWI_RUN_CHANNEL`, `<socket path>#<token>` as
+ * `PIWI_RECORD_CHANNEL` is (`formatRecordChannel`, `parseRecordChannel`). Its first line, `run-attach`, tells it from a
+ * hand-off's `attach`. Over it the worker says which test it runs and where it stopped, and the editor service steers
+ * it: pause, step, resume, finish, run to a line, end the test, the breakpoints, an image of the stopped page, and, at
+ * a stop the pause bar shows, the bar's own **Pick a locator** and **Record here**, the check panel's **Check an
+ * element** and a region's ARIA snapshot, started from outside the page; at any stop, the responses the test kept (an
+ * interactive run keeps the text bodies of its pages' fetch and XHR answers), one of them to mock, and a locator's
+ * matches; and, for a viewer outside the page, the stopped page's live view (`@piwitests/core/run-view`: its frames,
+ * the input played on it) and the locator of the element under a point of an image of it; and, for an agent (the
+ * editor's MCP server), the stopped page's ARIA snapshot in AI mode, an action on one of its elements by its ref, that
+ * element's ranked locators, what the run does as it goes (`events`), and its browser bound for Playwright's own tools
+ * on request (`bind`). A worker holds a failure for the editor only once the service said it shows and answers one
+ * (`holds` in its `run-attach`, answered by `attached`): a service that predates it says nothing, and the failure goes
+ * on. A person shares the run on the team instance's run page from the editor's surfaces (`share`, **Share live**):
+ * each worker then opens its live view stream there (`@piwitests/core/live-view`), and says how it stands (`live`).
+ * Each message is one line of JSON, at most `MAX_HANDOFF_LINE` long (`lineReader`), checked field by field on both
+ * sides. A side ignores a message it cannot read.
+ */
+
+/**
+ * What a stop the pause bar shows starts from outside the page, in the test's window: the bar's **Pick a locator**
+ * (`pick`) and **Record here** (`record`), their results going where the bar's go; the check panel's **Check an
+ * element** (`assert`), through the record channel's hand-off in its `check` mode, the editor service writing the
+ * check; and a region picked with the bar's picker (`assert-region`), whose ARIA snapshot the worker reads and sends
+ * (`region`).
+ */
+type RunIntent = 'pick' | 'record' | 'assert' | 'assert-region';
+/** Whether an intent started, or why not, in one sentence. */
+interface IntentAnswer {
+    ok: boolean;
+    message: string;
+}
+
 /**
  * The pause bar's Pick a locator and Record here, started from outside the page (the editor's hub, for Piwi Picker):
  * the bar takes an intent while it waits for its answer, and one handed to it while it is about to (its highlight
@@ -68,6 +159,38 @@ declare function callMethod(target: object, prop: string | symbol, args: unknown
  */
 declare function internalCall<T>(owner: unknown, run: () => Promise<T>): Promise<T>;
 
+/**
+ * Code reach: the application source files whose functions ran during a test,
+ * from Chromium's JavaScript coverage. A file counts when at least one of its
+ * functions ran, not counting a script's top-level code (importing a module
+ * runs its top level, so it says nothing about the test) and code that maps to
+ * no source.
+ *
+ * Through a source map, a function belongs to the source its start maps to,
+ * when some code inside it maps there too. Code a bundler or a dev server
+ * generates (a module factory, a preload helper, a hot-reload hook) has no
+ * mapping of its own and would otherwise take that of whatever precedes it;
+ * it runs when a module is imported, so it counts for no file.
+ *
+ * The reporter feeds this with V8's function coverage, read over a CDP
+ * session; this module holds the pure part.
+ */
+
+/** One script of a JavaScript coverage report: V8's `Profiler.takePreciseCoverage` entry, with its source when read. */
+interface JsCoverageEntry {
+    url: string;
+    source?: string;
+    functions: Array<{
+        functionName: string;
+        isBlockCoverage?: boolean;
+        ranges: Array<{
+            startOffset: number;
+            endOffset: number;
+            count: number;
+        }>;
+    }>;
+}
+
 /** Where code reach resolves paths. */
 interface CodeReachRoots {
     /** Directories a module path or a map source is tried against, first match wins; the repository root is last. */
@@ -757,4 +880,4 @@ declare const piwiFixtures: Fixtures<PiwiFixtures, PiwiWorkerFixtures, Playwrigh
  */
 declare function extendPiwiFixtures<TestArgs extends FixtureArgs, WorkerArgs extends FixtureArgs>(test: TestType<TestArgs, WorkerArgs>): TestType<TestArgs & PiwiFixtures, WorkerArgs & PiwiWorkerFixtures>;
 
-export { CAPTURED_ATTRS_ARG, type IntentStop, LocatorPageLog, type PageState, type PiwiFixtures, type PiwiWorkerFixtures, type RawPageState, type RawVitalEntry, activeResourceLedger, ariaSnapshotBestEffort, ariaSnapshotJSONBestEffort, boxCaptureFrames, buildPageState, callMethod, codeReachRoots, computeCoreVitals, configuredCodeReachRoots, errorPlace, extendPiwiFixtures, failureError, intentAt, internalCall, noteLocatorCall, noteNavigation, noteResourceUse, pageMapFetcher, piwiFixtures, readPageInteraction, recordResourceCensus, resolveCodeReach, startCodeReach, startResourceLedger, stopCodeReach, stopResourceLedger };
+export { CAPTURED_ATTRS_ARG, type IntentStop, LocatorPageLog, type PageState, type PiwiFixtures, type PiwiWorkerFixtures, ProbeArg, ProbedAttrs, type RawPageState, type RawVitalEntry, activeResourceLedger, ariaSnapshotBestEffort, ariaSnapshotJSONBestEffort, boxCaptureFrames, buildPageState, callMethod, codeReachRoots, computeCoreVitals, configuredCodeReachRoots, errorPlace, extendPiwiFixtures, failureError, intentAt, internalCall, noteLocatorCall, noteNavigation, noteResourceUse, pageMapFetcher, piwiFixtures, probeElementAttrs, readPageInteraction, recordResourceCensus, resolveCodeReach, startCodeReach, startResourceLedger, stopCodeReach, stopResourceLedger };