reporting-labs 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Naveen Khunteta (Naveen Automation Labs)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,247 @@
+<p align="center"><img src="https://raw.githubusercontent.com/naveenanimation20/reporting-labs/main/assets/logo-wordmark.svg" alt="reportingLabs" width="320"></p>
+
+# reportingLabs
+
+**One HTML file that tells you what broke, who owns it, and whether it is new.**
+
+reportingLabs turns a test run into a single, self-contained HTML report. No server, no upload, no dashboard to log into. Open the file, or attach it to a CI job, an email or a Slack message.
+
+It is runner-agnostic by design: the report is built from a plain JSON model that adapters feed. The **Playwright adapter ships today**; WebdriverIO, Cypress and Jest/Vitest adapters are on the roadmap.
+
+<p align="center"><img src="https://raw.githubusercontent.com/naveenanimation20/reporting-labs/main/docs/overview.png" alt="Overview page of a reportingLabs report" width="900"></p>
+
+## Quick start
+
+**1. Install**
+
+```bash
+npm i -D reporting-labs
+```
+
+**2. Add the reporter to `playwright.config.ts`**
+
+```ts
+export default defineConfig({
+  reporter: [['reporting-labs', { title: 'My app – regression' }]],
+});
+```
+
+**3. Run your tests and open the report**
+
+```bash
+npx playwright test
+open reporting-labs/index.html
+```
+
+That is all. Everything below is optional.
+
+## A tour of the report
+
+### Overview: the state of the run in one screen
+
+- **Tiles**: pass rate with a ring and the change from the previous run, then passed / failed / flaky / skipped. Click a tile to see those tests.
+- **Run strip**: every test as one cell, in run order. Hover for the name, click to open.
+- **Needs attention**: failures ranked by priority and severity, with the spec file, the owner, and whether the failure is new or has been failing since a given build.
+- **Failure clusters**: failures grouped by error message, so 30 red tests with one root cause read as one problem.
+- **Breakdown**: stacked bars per priority, severity, feature, owner, spec file, project or tag. Click a row to filter the test list. With more than one project you also get a feature × project heatmap.
+- **Slowest tests** and **Got slower** (tests that took 2× longer than last run), **Flakiest tests**, **Skipped** (with reasons), **Environment** and the **Trend** across runs.
+
+<p align="center"><img src="https://raw.githubusercontent.com/naveenanimation20/reporting-labs/main/docs/heatmap.png" alt="Breakdown card with the feature by project heatmap" width="900"></p>
+
+<p align="center"><img src="https://raw.githubusercontent.com/naveenanimation20/reporting-labs/main/docs/trend.png" alt="Trend chart with hover tooltip" width="900"></p>
+
+### Failures: everything you need to triage
+
+- **By owner**: who to ping, with failed and flaky counts. Click an owner to filter.
+- **Download CSV / JSON**: the failed and flaky tests with title, spec, project, priority, owner, ticket, attempts, duration, first error line and new/known status. Ready for Jira or a sheet.
+- **Copy summary**: a Slack/Teams-ready message with top failures, owners, ticket keys and an owner breakdown.
+- The table shows every failed or flaky test with its history over the last runs as dots.
+
+<p align="center"><img src="https://raw.githubusercontent.com/naveenanimation20/reporting-labs/main/docs/failures.png" alt="Failures page" width="900"></p>
+
+### Test detail: the error, the steps, the evidence
+
+- **Expected vs received** side by side with the difference highlighted. Object diffs are colored line by line.
+- Error **location** (linked to VS Code), Playwright's **code snippet**, full message and stack.
+- **Steps** with a bar per step showing its share of the test time. Given/When/Then titles are styled as Gherkin.
+- Retries as tabs, screenshots inline (click to zoom), videos, traces, console output, logs, test data and API calls.
+- **Open in VS Code** jumps to the failing line.
+
+<p align="center"><img src="https://raw.githubusercontent.com/naveenanimation20/reporting-labs/main/docs/test-detail.png" alt="Test detail with expected vs received diff and step bars" width="900"></p>
+
+### Timeline: how the run used its workers
+
+<p align="center"><img src="https://raw.githubusercontent.com/naveenanimation20/reporting-labs/main/docs/timeline.png" alt="Timeline by worker" width="900"></p>
+
+## Make the report smarter: tag your tests
+
+One line per test gives you priority ranking, owner rollups, feature breakdowns and Jira links.
+
+```ts
+import { meta } from 'reporting-labs';
+
+test('completes purchase', async ({ page }) => {
+  meta({ priority: 'P0', severity: 'blocker', owner: 'naveen', feature: 'payment', story: 'SHOP-250' });
+  // ...
+});
+```
+
+Tags work too: `{ tag: ['@P1', '@severity:critical', '@owner:priya'] }`. Plain annotations (`test.info().annotations.push({ type: 'priority', description: 'P1' })`) are picked up as well.
+
+Turn story, epic or issue keys into links:
+
+```ts
+links: { story: 'https://acme.atlassian.net/browse/{id}', epic: 'https://acme.atlassian.net/browse/{id}' }
+```
+
+## Logs, test data and API calls
+
+```ts
+import { log, testData, api, recordApi } from 'reporting-labs';
+
+test('creates an order', async ({ request }) => {
+  await log('starting with an empty cart');                                 // timestamped log line
+
+  await testData({ user: 'naveen@x.com', password: 'S3cret' }, 'Login');    // object → key/value block
+  await testData(rowsFromExcelOrJson, 'Coupons');                           // array of objects → table
+  await testData(fs.readFileSync('data/users.csv', 'utf8'), 'users.csv');   // CSV string → table
+
+  const res = await recordApi('POST', '/v1/orders', { headers, data },
+    () => request.post('/v1/orders', { headers, data }));                   // request + response panel
+});
+```
+
+Passwords, tokens, API keys, `Authorization` / `Cookie` headers, JWTs and `Bearer …` values are masked as `****` everywhere. Add your own keys with `maskKeys: ['otp', 'pan']`.
+
+## Run history: new vs known, flaky, slower
+
+The reporter keeps `reporting-labs.history.json` next to your config (last 30 runs by default). Commit it, or cache it in CI, and the report starts answering the questions you ask first:
+
+| Question | Where it shows |
+|---|---|
+| Did this break just now, or has it been red for days? | `new this run` / `failing since #1838` on every failure; the Failed tile splits the count |
+| Which tests are flaky? | Last-10-runs dots on every failure, plus the Flakiest tests card |
+| What got slower? | Got slower tab on the Slowest card (2× slower than last run) |
+| Are we trending up or down? | Trend chart with pass rate, fail rate and duration per run, hover for details |
+
+The first run has nothing to compare with; these cards fill in from the second run.
+
+## Screenshots, videos, traces
+
+Nothing extra to do. Use your runner's own settings and the report picks the attachments up:
+
+```ts
+use: {
+  screenshot: 'only-on-failure',   // shown inline, click to zoom
+  video: 'retain-on-failure',      // inline player (copied to ./assets, or embedded with embedVideos: true)
+  trace: 'on-first-retry',         // trace card with download and how to open it
+}
+```
+
+`toHaveScreenshot` failures get a visual comparison viewer: slider, side by side, and diff. Anything you attach with `test.info().attach()` shows up too: images inline, text/JSON as a code block, everything else as a download.
+
+## What the report covers
+
+Every outcome Playwright can produce is shown, not just pass/fail:
+
+- passed, failed, flaky (passed on retry), skipped with the `test.skip` / `test.fixme` reason, timed out with the exceeded timeout, interrupted
+- `test.fail()` tests that fail as expected count as passed with an "Expected failure" badge; one that unexpectedly passes is reported as failed with a note
+- errors outside tests (a spec that throws at load, global setup, a worker crash) get their own card at the top of the overview
+- interrupted runs and global timeouts show a banner with how many tests did not finish
+- shard and worker count in the Environment card, together with Playwright and Node versions, OS, browsers, the CI job link (GitHub Actions, GitLab, Jenkins, CircleCI, Azure, Bitbucket) and the git commit
+
+## Options
+
+All options are optional. Pass them as the second element of the reporter tuple.
+
+| Option | Default | What it does |
+|---|---|---|
+| `title` | `'Test report'` | Report title in the header |
+| `logo` | – | Path or data URI of your logo, shown next to the title |
+| `project` | – | `{ name, version, team, url }` shown under the title |
+| `metadata` | `{}` | Key/value chips in the header, e.g. `{ env: 'staging', build: '#1842' }`. `build` labels the run in history; in CI the run number is used when it is not set |
+| `env` | – | Extra rows for the Environment card, e.g. `{ 'App build': '2.4.0-rc3' }` |
+| `dimensions` | `['priority','severity','feature','owner']` | Meta keys that get charts and filters |
+| `dimensionOrder` | P0…P4, blocker…trivial | Sort order per dimension, e.g. `{ severity: ['blocker','critical','major','minor'] }` |
+| `links` | `{}` | URL templates per meta key, `{id}` is replaced by the value |
+| `maskKeys` | `[]` | Extra keys to mask in logs, data and API panels |
+| `widgets` | all on | Hide cards: `{ tags: false, timeline: false, flaky: false, environment: false, skipped: false, ... }` |
+| `sections` | `[]` | Extra HTML sections below the summary, e.g. release notes |
+| `history` | `{ enabled: true, keep: 30 }` | Run history file; `file` sets a custom path |
+| `palette` | `'lab'` | `'lab'` (blue), `'ocean'`, `'ember'`, `'mono'`. Viewers can switch in the header |
+| `accent` | palette accent | Override the accent with your brand color |
+| `theme` | `'auto'` | `'light'`, `'dark'` or follow the OS |
+| `customCss` | `''` | CSS appended to the report |
+| `editorLinks` | `true` locally, `false` in CI | "Open in VS Code" links |
+| `bdd` | auto | Style Given/When/Then steps as Gherkin |
+| `outputFolder` | `'reporting-labs'` | Where the report and copied assets go |
+| `outputFile` | `'index.html'` | Report file name |
+| `embedAttachments` | `true` | Inline screenshots as base64 (single file) |
+| `embedLimit` | 2 MB | Larger attachments are copied to `./assets` instead |
+| `embedVideos` | `false` | Inline videos too (big file) |
+| `embedFonts` | `true` | Bundle IBM Plex (~140 KB) so the report looks the same offline |
+| `announce` | `true` | Print the report path after the run |
+
+A fuller example:
+
+```ts
+reporter: [['reporting-labs', {
+  title: 'ShopLite – nightly regression',
+  project: { name: 'ShopLite Web', version: '2.4.0', team: 'QA Platform' },
+  metadata: { env: 'staging', branch: process.env.GIT_BRANCH ?? 'main', build: process.env.BUILD_ID ?? 'local' },
+  links: { story: 'https://acme.atlassian.net/browse/{id}' },
+  sections: [{ title: 'Release notes', html: '<p>Checkout v2 at 50% rollout.</p>' }],
+}]]
+```
+
+`npx reporting-labs init` writes a starter `reporting-labs.config.ts`.
+
+## Running in CI
+
+The report is a plain file written next to your tests, so it works anywhere `npx playwright test` runs: locally, GitHub Actions, GitLab, Jenkins, CircleCI, Azure Pipelines, Bitbucket. Nothing phones home and no fonts are fetched, so it also works in locked-down networks.
+
+What happens automatically in CI:
+
+- The Environment card links the CI job and the commit (GitHub Actions, GitLab, Jenkins, CircleCI, Azure, Bitbucket are detected from their environment variables).
+- The run is labelled with the CI run number in the history and the trend chart, unless you set `metadata.build` yourself.
+- "Open in VS Code" links are off when the `CI` variable is set, because they would point at the runner's paths. Set `editorLinks: true` to force them.
+
+Two things to set up:
+
+1. **Publish the report.** Upload `reporting-labs/` as a build artifact (or archive it in Jenkins). Screenshots and fonts are inside `index.html`; videos and large files sit in `reporting-labs/assets/`.
+2. **Keep the history.** `reporting-labs.history.json` is what powers the trend, new vs known failures, flaky history and duration regressions. On GitHub Actions restore and save it with `actions/cache`; on Jenkins the workspace usually persists on its own.
+
+Ready-to-copy samples: [docs/ci/github-actions.yml](https://github.com/naveenanimation20/reporting-labs/blob/main/docs/ci/github-actions.yml) and [docs/ci/Jenkinsfile](https://github.com/naveenanimation20/reporting-labs/blob/main/docs/ci/Jenkinsfile).
+
+```yaml
+# GitHub Actions, the two steps that matter
+- uses: actions/cache@v4
+  with:
+    path: reporting-labs.history.json
+    key: reporting-labs-history-${{ github.ref_name }}-${{ github.run_id }}
+    restore-keys: reporting-labs-history-${{ github.ref_name }}-
+- uses: actions/upload-artifact@v4
+  if: always()
+  with:
+    name: test-report
+    path: reporting-labs/
+```
+
+**Jenkins HTML Publisher note.** Jenkins' default Content-Security-Policy blocks inline JavaScript, so a single-file report shows up blank inside Jenkins (Playwright's own HTML report has the same issue). Either download the archived artifact and open it locally, or have an admin relax the policy in the script console: `System.setProperty("hudson.model.DirectoryBrowserSupport.CSP", "")`.
+
+## Good to know
+
+- **Single file.** Screenshots and fonts are embedded, so `index.html` works from a mail attachment or a CI artifact. Videos and large files go to `./assets` next to it.
+- **Keyboard.** `j` / `k` next and previous test, `f` failed only, `/` search, `1`–`5` switch views, `Esc` close.
+- **Print.** A print stylesheet is included for PDF export.
+- **Themes.** Light and dark follow the OS; the toggle in the header remembers the choice.
+
+## Roadmap
+
+- WebdriverIO, Cypress, Jest/Vitest, JUnit XML adapters via the shared JSON schema
+- AI summary and failure clustering (bring your own API key)
+- Hosted history dashboard across branches/projects
+
+## License
+
+MIT © Naveen Automation Labs

package/bin/cli.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const [cmd] = process.argv.slice(2);
+
+if (cmd === 'init') {
+  const file = path.resolve('reporting-labs.config.ts');
+  if (fs.existsSync(file)) { console.log('reporting-labs.config.ts already exists.'); process.exit(0); }
+  fs.writeFileSync(file, `import type { ReportingLabsOptions } from 'reporting-labs';
+
+const config: ReportingLabsOptions = {
+  title: 'My app – regression',
+  // logo: 'https://example.com/logo.svg',
+  palette: 'lab',            // 'lab' (blue) | 'ocean' | 'ember' | 'mono'
+  theme: 'auto',
+  metadata: { env: process.env.TEST_ENV ?? 'local', branch: process.env.GIT_BRANCH ?? 'main' },
+  links: { story: 'https://acme.atlassian.net/browse/{id}' },
+  sections: [],
+};
+export default config;
+`);
+  console.log('Created reporting-labs.config.ts');
+  console.log("Add to playwright.config.ts:  reporter: [['reporting-labs', require('./reporting-labs.config').default]]");
+} else {
+  console.log(`reporting-labs
+
+  npx reporting-labs init     create a starter config file
+
+Usage in playwright.config.ts:
+  reporter: [['reporting-labs', { title: 'My report' }]]
+`);
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import ReportingLabsReporter from './reporter';
+export type { ReportingLabsOptions, ApiCall } from './types';
+export { ReportingLabsReporter };
+export { meta, log, testData, api, recordApi } from './meta';
+export default ReportingLabsReporter;

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordApi = exports.api = exports.testData = exports.log = exports.meta = exports.ReportingLabsReporter = void 0;
+const reporter_1 = __importDefault(require("./reporter"));
+exports.ReportingLabsReporter = reporter_1.default;
+var meta_1 = require("./meta");
+Object.defineProperty(exports, "meta", { enumerable: true, get: function () { return meta_1.meta; } });
+Object.defineProperty(exports, "log", { enumerable: true, get: function () { return meta_1.log; } });
+Object.defineProperty(exports, "testData", { enumerable: true, get: function () { return meta_1.testData; } });
+Object.defineProperty(exports, "api", { enumerable: true, get: function () { return meta_1.api; } });
+Object.defineProperty(exports, "recordApi", { enumerable: true, get: function () { return meta_1.recordApi; } });
+exports.default = reporter_1.default;

package/dist/mask.d.ts

@@ -0,0 +1,9 @@
+export declare function makeMasker(extraKeys?: string[]): {
+    mask: (v: unknown, key?: string) => unknown;
+    maskStr: (s: string) => string;
+    isSensitive: (k: string) => boolean;
+};
+export declare function parseCsv(text: string): {
+    columns: string[];
+    rows: string[][];
+};

package/dist/mask.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMasker = makeMasker;
+exports.parseCsv = parseCsv;
+const DEFAULT_KEYS = ['password', 'passwd', 'pwd', 'secret', 'token', 'apikey', 'api_key', 'api-key', 'authorization', 'auth', 'cookie', 'set-cookie', 'session', 'credential', 'private', 'ssn', 'cvv', 'card'];
+const VALUE_PATTERNS = [
+    /\b(Bearer|Basic|Token)\s+[A-Za-z0-9._~+\/=-]{8,}/gi,
+    /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{5,}/g, // JWT
+    /\b(sk|pk|ghp|xox[abp]|AKIA)[_-]?[A-Za-z0-9]{12,}\b/g,
+    /(password|passwd|pwd|token|secret|api[_-]?key)(\s*[=:]\s*)([^\s&;,"']+)/gi,
+];
+function makeMasker(extraKeys = []) {
+    const keys = [...DEFAULT_KEYS, ...extraKeys.map(k => k.toLowerCase())];
+    const isSensitive = (k) => { const l = k.toLowerCase(); return keys.some(s => l === s || l.includes(s)); };
+    const maskStr = (s) => VALUE_PATTERNS.reduce((acc, re) => acc.replace(re, (m, ...g) => {
+        if (g.length >= 3 && typeof g[1] === 'string' && /[=:]/.test(g[1]))
+            return g[0] + g[1] + '****';
+        return m.split(/\s+/)[0] + ' ****';
+    }), s);
+    const mask = (v, key = '') => {
+        if (key && isSensitive(key))
+            return '****';
+        if (typeof v === 'string')
+            return maskStr(v);
+        if (Array.isArray(v))
+            return v.map(x => mask(x));
+        if (v && typeof v === 'object') {
+            const o = {};
+            for (const [k, x] of Object.entries(v))
+                o[k] = mask(x, k);
+            return o;
+        }
+        return v;
+    };
+    return { mask, maskStr, isSensitive };
+}
+function parseCsv(text) {
+    const lines = text.replace(/\r/g, '').split('\n').filter(l => l.trim());
+    const split = (l) => { const out = []; let cur = '', q = false; for (const c of l) {
+        if (c === '"')
+            q = !q;
+        else if (c === ',' && !q) {
+            out.push(cur);
+            cur = '';
+        }
+        else
+            cur += c;
+    } out.push(cur); return out.map(s => s.trim()); };
+    const [head, ...body] = lines.map(split);
+    return { columns: head ?? [], rows: body };
+}

package/dist/meta.d.ts

@@ -0,0 +1,43 @@
+import type { ApiCall, TestMeta } from './types';
+/**
+ * Attach report metadata to the current test. Call it first thing inside the test body.
+ *
+ * @example
+ * meta({ priority: 'P1', severity: 'critical', owner: 'naveen', feature: 'checkout', story: 'SHOP-231' });
+ */
+export declare function meta(values: TestMeta): void;
+/**
+ * Add a timestamped log line to the current test. Lines containing "error"/"fail" show red, "warn" amber.
+ * Secrets like `password=...`, `Bearer ...`, JWTs are masked in the report.
+ * @example await log('cart total before coupons: $99.00');
+ */
+export declare function log(message: string, ...rest: unknown[]): Promise<void>;
+/**
+ * Attach the data used by this test.
+ * - object            → key/value block
+ * - array of objects  → table (rows from JSON / Excel / DB)
+ * - CSV string        → table
+ * Sensitive keys (password, token, secret, apiKey, authorization, cookie...) are masked as ****.
+ * @param data  the data
+ * @param name  heading shown in the report (default "Test data")
+ * @example await testData({ username: 'naveen', password: 'S3cret' }, 'Login');
+ */
+export declare function testData(data: unknown, name?: string): Promise<void>;
+/**
+ * Record an API request/response for this test. Shows up in the test detail and the API tab.
+ * Authorization/Cookie headers, tokens and secret-looking fields are masked.
+ * @example
+ * await api({ method: 'POST', url: '/v1/orders', status: 201, duration: 138, requestBody, responseBody });
+ */
+export declare function api(call: ApiCall): Promise<void>;
+/** Wrap a Playwright APIRequestContext call so it's recorded automatically. */
+export declare function recordApi<T extends {
+    status(): number;
+    headers(): Record<string, string>;
+    text(): Promise<string>;
+    url(): string;
+}>(method: string, url: string, options: {
+    headers?: Record<string, string>;
+    data?: unknown;
+    name?: string;
+} | undefined, run: () => Promise<T>): Promise<T>;

package/dist/meta.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.meta = meta;
+exports.log = log;
+exports.testData = testData;
+exports.api = api;
+exports.recordApi = recordApi;
+function info() {
+    // Lazy require so importing reporting-labs in playwright.config never loads the test runtime.
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { test } = require('@playwright/test');
+    return test.info();
+}
+/**
+ * Attach report metadata to the current test. Call it first thing inside the test body.
+ *
+ * @example
+ * meta({ priority: 'P1', severity: 'critical', owner: 'naveen', feature: 'checkout', story: 'SHOP-231' });
+ */
+function meta(values) {
+    const i = info();
+    for (const [k, v] of Object.entries(values)) {
+        if (v === undefined)
+            continue;
+        i.annotations.push({ type: k.toLowerCase(), description: String(v) });
+    }
+}
+/**
+ * Add a timestamped log line to the current test. Lines containing "error"/"fail" show red, "warn" amber.
+ * Secrets like `password=...`, `Bearer ...`, JWTs are masked in the report.
+ * @example await log('cart total before coupons: $99.00');
+ */
+async function log(message, ...rest) {
+    const msg = [message, ...rest.map(r => (typeof r === 'string' ? r : JSON.stringify(r)))].join(' ');
+    await info().attach('rl:log', { body: JSON.stringify({ t: Date.now(), msg }), contentType: 'application/x-rl-log' });
+}
+/**
+ * Attach the data used by this test.
+ * - object            → key/value block
+ * - array of objects  → table (rows from JSON / Excel / DB)
+ * - CSV string        → table
+ * Sensitive keys (password, token, secret, apiKey, authorization, cookie...) are masked as ****.
+ * @param data  the data
+ * @param name  heading shown in the report (default "Test data")
+ * @example await testData({ username: 'naveen', password: 'S3cret' }, 'Login');
+ */
+async function testData(data, name = 'Test data') {
+    await info().attach(name, { body: JSON.stringify(typeof data === 'string' ? { csv: data } : data), contentType: 'application/x-rl-data' });
+}
+/**
+ * Record an API request/response for this test. Shows up in the test detail and the API tab.
+ * Authorization/Cookie headers, tokens and secret-looking fields are masked.
+ * @example
+ * await api({ method: 'POST', url: '/v1/orders', status: 201, duration: 138, requestBody, responseBody });
+ */
+async function api(call) {
+    await info().attach(call.name ?? `${call.method.toUpperCase()} ${call.url}`, { body: JSON.stringify(call), contentType: 'application/x-rl-api' });
+}
+/** Wrap a Playwright APIRequestContext call so it's recorded automatically. */
+async function recordApi(method, url, options, run) {
+    const t0 = Date.now();
+    const res = await run();
+    let body = await res.text();
+    try {
+        body = JSON.parse(body);
+    }
+    catch { /* keep text */ }
+    await api({ method, url, status: res.status(), duration: Date.now() - t0, requestHeaders: options?.headers, requestBody: options?.data, responseHeaders: res.headers(), responseBody: body, name: options?.name });
+    return res;
+}

package/dist/reporter.d.ts

@@ -0,0 +1,37 @@
+import type { FullConfig, FullResult, Reporter, Suite, TestCase, TestError } from '@playwright/test/reporter';
+import { ReportingLabsOptions } from './types';
+export default class ReportingLabsReporter implements Reporter {
+    private options;
+    private config;
+    private suite;
+    private startTime;
+    private outDir;
+    private assetsDir;
+    private assetCounter;
+    private masker;
+    private globalErrors;
+    private globalOutput;
+    constructor(options?: ReportingLabsOptions);
+    printsToStdio(): boolean;
+    /** Errors outside tests: a spec that throws at load, global setup, a crashed worker. */
+    onError(error: TestError): void;
+    onStdOut(chunk: string | Buffer, test?: TestCase | void): void;
+    onStdErr(chunk: string | Buffer, test?: TestCase | void): void;
+    private pushOutput;
+    onBegin(config: FullConfig, suite: Suite): void;
+    onEnd(result: FullResult): Promise<void>;
+    /** Runtime facts for the Environment card: Playwright, Node, OS, browsers, CI job, git commit. */
+    private collectEnv;
+    private toDataBlock;
+    private loadHistory;
+    private dimensions;
+    /** Pull dimension values from annotations and tags. */
+    private extractMeta;
+    private rel;
+    private serializeError;
+    private outcome;
+    private titlePath;
+    private serializeResult;
+    private serializeStep;
+    private serializeAttachment;
+}