proxymail-qa 0.6.0 → 0.8.0

package/README.md

@@ -52,6 +52,24 @@ test('sign-up sends a working code', async ({ page, inbox }) => {
 });
 ```
 
+In a run (the GitHub Action, or `startRun` in `globalSetup`), the report can say
+which test each email came from. Use the `qa` fixture from
+`proxymail-qa/playwright`, a client that names its test in every call, and add
+the reporter, which records failed and flaky tests and the totals:
+
+```ts
+// playwright.config.ts
+reporter: [['list'], ['proxymail-qa/playwright/reporter']],
+
+// signup.spec.ts
+import { test, expect } from 'proxymail-qa/playwright';
+
+test('sign-up sends one code', async ({ page, qa }) => {
+  const { address } = await qa.createAddress();
+  // …
+});
+```
+
 ## Cypress
 
 Register tasks in `cypress.config.ts`, since Cypress runs them in Node:
@@ -106,6 +124,34 @@ await qa.setPassword(address, { password: 'the-new-test-password' });
 const result = await qa.checkEmail(address, { type: 'link', expectHost: 'staging.example.com' });
 expect(result.failed).toEqual([]);
 
+// A localised email: in German, with the user's name in it.
+await qa.checkEmail(address, { expectLanguage: 'de', expectText: ['Hallo Maya'] });
+
+// What to type or pick in each field of a sign-up form, from a new address
+// made for it: a username and password that fit the rules, the date of birth
+// in the field's format, a country the drop-down offers. You fill it in.
+const { values } = await qa.formValues({
+  fields: [
+    { id: 'email', type: 'email', label: 'Email' },
+    { id: 'dob', type: 'text', label: 'Date of birth', placeholder: 'DD/MM/YYYY' },
+  ],
+});
+
+// Borrow an account in the state the test needs. Your hooks make one when
+// none is free, confirm its state and put it back; they talk to your app,
+// Proxy Mail QA never does.
+await qa.withAccount(
+  {
+    tags: ['verified', 'premium'],
+    create: async (account) => signUpAndUpgrade(account.address, account.password),
+    check: async (account) => (await getUser(account.address)).plan === 'premium',
+    reset: async (account) => resetUser(account.address),
+  },
+  async (account) => {
+    // …the test…
+  },
+);
+
 // A run: this client's calls add what they saw, for a report on the pull
 // request. In GitHub Actions, the Proxy Mail QA action does this for you and
 // the client picks the run up from PROXYMAIL_QA_RUN.

package/dist/index.d.ts

@@ -3,6 +3,19 @@ export interface ClientOptions {
     baseUrl?: string;
     fetch?: typeof fetch;
     run?: string | null;
+    test?: string | null;
+}
+export interface TestResultInput {
+    name: string;
+    status: 'passed' | 'failed' | 'flaky' | 'skipped';
+    durationMs?: number;
+    error?: string;
+}
+export interface TestTotals {
+    passed: number;
+    failed: number;
+    skipped?: number;
+    flaky?: number;
 }
 export interface Persona {
     first_name: string | null;
@@ -34,6 +47,48 @@ export interface CheckedOutAccount extends Address {
         until: string;
     };
 }
+export interface FormFieldInput {
+    id?: string;
+    type?: string;
+    name?: string;
+    label?: string;
+    placeholder?: string;
+    autocomplete?: string;
+    group?: string;
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+    options?: Array<{
+        value: string;
+        label?: string;
+    }>;
+}
+export interface FormValuesOptions extends Omit<CreateAddressInput, 'password' | 'persona' | 'name'> {
+    fields: FormFieldInput[];
+    address?: string;
+}
+export interface FormValue {
+    id: string;
+    kind: 'email' | 'confirm_email' | 'first_name' | 'last_name' | 'full_name' | 'username' | 'password' | 'confirm_password' | 'date_of_birth' | 'birth_day' | 'birth_month' | 'birth_year' | 'country' | 'other';
+    value: string | null;
+    note?: string;
+}
+export interface FormValues {
+    address: string;
+    created: boolean;
+    persona: Persona | null;
+    password?: string;
+    values: FormValue[];
+}
+export interface PreparedAccountOptions extends CheckoutOptions {
+    create?: (account: CheckedOutAccount & {
+        password: string;
+    }) => Promise<void>;
+    newAccount?: Omit<CreateAddressInput, 'password'>;
+    check?: (account: CheckedOutAccount) => Promise<boolean | void>;
+    reset?: (account: CheckedOutAccount) => Promise<void>;
+    attempts?: number;
+}
 export interface ReturnState {
     addTags?: string[];
     removeTags?: string[];
@@ -148,7 +203,7 @@ export interface CountOptions {
     subtype?: CountSubtype | CountSubtype[];
 }
 export type CountSubtype = 'otp' | 'coupon' | 'verify' | 'magic_signin' | 'invite' | 'reset' | 'other' | 'any';
-export type CheckId = 'spf' | 'dkim' | 'dmarc' | 'local_links' | 'plain_http' | 'expected_host' | 'expiry' | 'plain_text' | 'size' | 'images_only';
+export type CheckId = 'spf' | 'dkim' | 'dmarc' | 'local_links' | 'plain_http' | 'expected_host' | 'expiry' | 'plain_text' | 'size' | 'images_only' | 'expected_text' | 'language';
 export interface EmailCheck {
     check: CheckId;
     status: 'pass' | 'fail' | 'warn' | 'skip';
@@ -172,6 +227,8 @@ export interface EmailChecks {
 export interface CheckOptions extends CountOptions {
     emailId?: string;
     expectHost?: string;
+    expectText?: string[];
+    expectLanguage?: string;
 }
 export interface NoEmail {
     address: string;
@@ -222,13 +279,16 @@ export declare class ProxyMailQA {
     private readonly baseUrl;
     private readonly fetcher;
     run: string | null;
+    readonly test: string | null;
     constructor(options?: ClientOptions);
+    forTest(name: string): ProxyMailQA;
     private request;
     project(): Promise<Record<string, unknown>>;
     createAddress(input: CreateAddressInput & {
         password: true;
     }): Promise<CreatedAddressWithPassword>;
     createAddress(input?: CreateAddressInput): Promise<CreatedAddress>;
+    formValues(options: FormValuesOptions): Promise<FormValues>;
     listAddresses(options?: ListAddressesOptions): Promise<Address[]>;
     getAddress(address: string): Promise<Address>;
     checkOutAccount(options?: CheckoutOptions): Promise<CheckedOutAccount>;
@@ -240,7 +300,12 @@ export declare class ProxyMailQA {
         };
     }>;
     returnAccount(account: CheckedOutAccount, state?: ReturnState): Promise<Address>;
-    withAccount<T>(options: CheckoutOptions, fn: (account: CheckedOutAccount) => Promise<T>): Promise<T>;
+    withAccount<T>(options: PreparedAccountOptions, fn: (account: CheckedOutAccount) => Promise<T>): Promise<T>;
+    private prepareAccount;
+    private newAccount;
+    private failedCheck;
+    private restoreAccount;
+    private note;
     updateAddress(address: string, patch: AddressPatch): Promise<Address>;
     deleteAddress(address: string): Promise<void>;
     waitForCode(address: string, options?: WaitOptions): Promise<Match>;
@@ -279,6 +344,8 @@ export declare class ProxyMailQA {
     getRun(id?: string): Promise<Run>;
     runReport(id?: string): Promise<string>;
     listRuns(limit?: number): Promise<Run[]>;
+    recordTest(result: TestResultInput, run?: string): Promise<void>;
+    recordTestTotals(totals: TestTotals, run?: string): Promise<void>;
     addRunNote(text: string, options?: {
         failed?: boolean;
         address?: string;

package/dist/index.js

@@ -42,15 +42,25 @@ export class ProxyMailQA {
     fetcher;
     // The run this client's calls add to, if any.
     run;
+    // The test they belong to, if any.
+    test;
     constructor(options = {}) {
         const env = globalThis.process?.env;
         const apiKey = options.apiKey ?? env?.PROXYMAIL_QA_API_KEY;
         if (!apiKey)
             throw new Error('Pass apiKey or set PROXYMAIL_QA_API_KEY. Create a key in Project settings → API keys.');
         this.apiKey = apiKey;
-        this.baseUrl = (options.baseUrl ?? 'https://api.proxymail.qa').replace(/\/+$/, '');
+        // PROXYMAIL_QA_API_URL, as the Python helper reads it, may end in /v1.
+        this.baseUrl = (options.baseUrl ?? (env?.PROXYMAIL_QA_API_URL?.trim().replace(/\/v1\/?$/, '') || 'https://api.proxymail.qa')).replace(/\/+$/, '');
         this.fetcher = options.fetch ?? globalThis.fetch.bind(globalThis);
         this.run = options.run === undefined ? env?.PROXYMAIL_QA_RUN?.trim() || null : options.run;
+        this.test = options.test?.trim() || null;
+    }
+    // A client for one test: the same key and run, and every call says which
+    // test it belongs to, so the run's report shows which test each email came
+    // from. proxymail-qa/playwright's qa fixture does this for you.
+    forTest(name) {
+        return new ProxyMailQA({ apiKey: this.apiKey, baseUrl: this.baseUrl, fetch: this.fetcher, run: this.run, test: name });
     }
     // retry: this call is asked again if nothing arrives, so the run only
     // records the last try's "nothing arrived".
@@ -61,6 +71,8 @@ export class ProxyMailQA {
                 Authorization: `Bearer ${this.apiKey}`,
                 ...(body === undefined ? {} : { 'Content-Type': 'application/json' }),
                 ...(this.run ? { 'Proxy-Mail-QA-Run': this.run, ...(retry ? { 'Proxy-Mail-QA-Run-Retry': 'true' } : {}) } : {}),
+                // Percent-encoded: a test's name can hold characters headers can't.
+                ...(this.run && this.test ? { 'Proxy-Mail-QA-Test': encodeURIComponent(this.test) } : {}),
             },
             body: body === undefined ? undefined : JSON.stringify(body),
         });
@@ -90,6 +102,33 @@ export class ProxyMailQA {
             country: input.country,
         });
     }
+    // What to type or pick in each field of a sign-up form, from a new address
+    // made for it (a date of birth if it asks, a country it offers, a password
+    // that fits its rules) or one made earlier (address). You fill it in.
+    formValues(options) {
+        return this.request('POST', '/form-values', {
+            fields: options.fields.map((f) => ({
+                id: f.id,
+                type: f.type,
+                name: f.name,
+                label: f.label,
+                placeholder: f.placeholder,
+                autocomplete: f.autocomplete,
+                group: f.group,
+                pattern: f.pattern,
+                min_length: f.minLength,
+                max_length: f.maxLength,
+                options: f.options,
+            })),
+            address: options.address,
+            label: options.label,
+            lifetime_days: options.lifetimeDays,
+            domain: options.domain,
+            age: options.age,
+            date_of_birth: options.dateOfBirth,
+            country: options.country,
+        });
+    }
     // Newest first. With filters, finds test accounts made earlier, such as
     // an under-18 in GB with a saved password: every filter given must match.
     listAddresses(options = {}) {
@@ -147,18 +186,140 @@ export class ProxyMailQA {
     }
     // Checks out an account, runs fn with it, and always returns it. fn can
     // say what state it left the account in by returning { addTags, removeTags }.
+    // With create, check and reset (PreparedAccountOptions), the account is
+    // also confirmed to be in the state the test needs, a new one is made when
+    // none is free, and its state is restored afterwards.
     async withAccount(options, fn) {
-        const account = await this.checkOutAccount(options);
+        const account = await this.prepareAccount(options);
         let state = {};
+        let result;
         try {
-            const result = await fn(account);
+            result = await fn(account);
             if (result && typeof result === 'object' && ('addTags' in result || 'removeTags' in result))
                 state = result;
-            return result;
         }
-        finally {
-            await this.returnAccount(account, state).catch(() => { });
+        catch (err) {
+            await this.restoreAccount(account, options, state).catch(() => { });
+            throw err;
+        }
+        await this.restoreAccount(account, options, state);
+        return result;
+    }
+    // A checked-out account in the state the test needs, or an error saying why
+    // there isn't one.
+    async prepareAccount(options) {
+        const { create, check, reset, newAccount, attempts = 3, ...filters } = options;
+        const tried = [];
+        let lastProblem = '';
+        for (let i = 0; i < attempts; i++) {
+            let account;
+            try {
+                account = await this.checkOutAccount(filters);
+            }
+            catch (err) {
+                if (!(err instanceof ProxyMailQAError && (err.status === 404 || err.status === 409)))
+                    throw err;
+                // None matches, or every match is busy: make one, if the test can.
+                if (create)
+                    return this.newAccount(options);
+                // Accounts that failed their check have left the pool.
+                if (tried.length)
+                    break;
+                throw err;
+            }
+            // The pool has come round again: every match has been tried.
+            if (tried.includes(account.address)) {
+                await this.returnAccount(account).catch(() => { });
+                break;
+            }
+            tried.push(account.address);
+            let problem = await this.failedCheck(check, account);
+            if (problem === null)
+                return account;
+            if (reset) {
+                problem = await reset(account).then(() => this.failedCheck(check, account), (err) => `reset failed: ${message(err)}`);
+                if (problem === null)
+                    return account;
+            }
+            lastProblem = problem;
+            await this.note(`Test account failed its check (${problem}); it loses its tags and is tagged check-failed.`, account.address);
+            await this.returnAccount(account, { addTags: ['check-failed'], removeTags: filters.tags }).catch(() => { });
+        }
+        if (create)
+            return this.newAccount(options);
+        throw new Error(tried.length
+            ? `No test account passed the check: tried ${tried.join(', ')}${lastProblem ? ` (last: ${lastProblem})` : ''}. Pass create to make one.`
+            : 'No test account passed the check. Pass create to make one.');
+    }
+    // Makes an account with the test's create hook, holding it from the start
+    // so no parallel test takes it half made, then tags and checks it.
+    async newAccount(options) {
+        const { create, check, newAccount = {}, tags = [], country, minAge, maxAge, minutes } = options;
+        if (!create)
+            throw new Error('Pass create to make new accounts.');
+        if ((minAge !== undefined || maxAge !== undefined) && !newAccount.age && !newAccount.dateOfBirth) {
+            throw new Error('Give newAccount an age or dateOfBirth, so new accounts match minAge and maxAge.');
+        }
+        const created = await this.createAddress({ ...newAccount, country: newAccount.country ?? country, password: true });
+        const held = await this.checkOutAccount({ search: created.address, minutes });
+        if (held.address !== created.address) {
+            await this.returnAccount(held).catch(() => { });
+            throw new Error(`Couldn't hold the new account ${created.address}.`);
+        }
+        try {
+            await create({ ...held, password: created.password });
+            const tagged = await this.updateAddress(created.address, { tags: [...new Set([...held.tags, ...tags.map((t) => t.toLowerCase())])] });
+            const account = { ...tagged, checkout: held.checkout };
+            const ages = age(account.persona?.date_of_birth);
+            if (ages !== null && ((minAge !== undefined && ages < minAge) || (maxAge !== undefined && ages > maxAge))) {
+                throw new Error(`The new account is ${ages}, outside minAge and maxAge: give newAccount a matching age.`);
+            }
+            const problem = await this.failedCheck(check, account);
+            if (problem !== null)
+                throw new Error(`The new account ${created.address} failed its check after create: ${problem}`);
+            await this.note(`Made a new test account${tags.length ? ` tagged ${tags.join(', ')}` : ''}.`, created.address);
+            return account;
+        }
+        catch (err) {
+            // Untagged, it stays out of the pool; it expires with its address.
+            await this.updateAddress(created.address, { tags: held.tags }).catch(() => { });
+            await this.returnAccount(held).catch(() => { });
+            throw err;
+        }
+    }
+    // null when the account passes (or there's no check), or why it doesn't.
+    async failedCheck(check, account) {
+        if (!check)
+            return null;
+        try {
+            return (await check(account)) === false ? 'check returned false' : null;
+        }
+        catch (err) {
+            return message(err);
+        }
+    }
+    // Runs reset, then returns the account. If reset fails, the account leaves
+    // the pool's state (needs-reset) and the error is thrown.
+    async restoreAccount(account, options, state) {
+        if (options.reset) {
+            try {
+                await options.reset(account);
+            }
+            catch (err) {
+                await this.note(`Couldn't reset the test account (${message(err)}); it loses its tags and is tagged needs-reset.`, account.address);
+                await this.returnAccount(account, {
+                    addTags: [...(state.addTags ?? []), 'needs-reset'],
+                    removeTags: [...(state.removeTags ?? []), ...(options.tags ?? [])],
+                }).catch(() => { });
+                throw err;
+            }
         }
+        await this.returnAccount(account, state).catch(() => { });
+    }
+    // Adds a line to the current run, if there is one, without failing the test.
+    async note(text, address) {
+        if (this.run)
+            await this.addRunNote(text, { address }).catch(() => { });
     }
     updateAddress(address, patch) {
         return this.request('PATCH', `/addresses/${encodeURIComponent(address)}`, patch);
@@ -199,15 +360,21 @@ export class ProxyMailQA {
     }
     // Checks one email the address received: SPF, DKIM and DMARC, links to
     // localhost or plain http, where its link goes (expectHost), a stated
-    // expiry, a plain-text part, size and image-only emails. Doesn't wait: wait
-    // for the email first. Throws ProxyMailQAError (404) when none matches.
+    // expiry, a plain-text part, size and image-only emails, and given phrases
+    // (expectText) and its language (expectLanguage). Doesn't wait: wait for
+    // the email first. Throws ProxyMailQAError (404) when none matches.
     checkEmail(address, options = {}) {
         const extra = {};
         if (options.emailId)
             extra.email_id = options.emailId;
         if (options.expectHost)
             extra.expect_host = options.expectHost;
-        return this.request('GET', `/addresses/${encodeURIComponent(address)}/checks${countQuery(options, extra)}`);
+        if (options.expectLanguage)
+            extra.expect_language = options.expectLanguage;
+        let query = countQuery(options, extra);
+        for (const phrase of options.expectText ?? [])
+            query += `${query ? '&' : '?'}expect_text=${encodeURIComponent(phrase)}`;
+        return this.request('GET', `/addresses/${encodeURIComponent(address)}/checks${query}`);
     }
     // Resolves when no matching email arrives within timeout seconds (default
     // 30; longer repeats the request), for checks such as "an unsubscribed user
@@ -266,6 +433,23 @@ export class ProxyMailQA {
     }
     // A line of your own in the run, such as a test that failed for a reason
     // of its own. failed: true fails the run.
+    // A test's result in the run (a failed one fails it), from a test runner's
+    // reporter: proxymail-qa/playwright/reporter sends failed and flaky tests,
+    // then the totals.
+    recordTest(result, run) {
+        const id = run ?? this.requireRun();
+        return this.request('POST', `/runs/${encodeURIComponent(id)}/tests`, {
+            name: result.name,
+            status: result.status,
+            duration_ms: result.durationMs,
+            error: result.error,
+        });
+    }
+    // How the suite went, for the top of the run's report.
+    recordTestTotals(totals, run) {
+        const id = run ?? this.requireRun();
+        return this.request('POST', `/runs/${encodeURIComponent(id)}/tests`, { totals });
+    }
     addRunNote(text, options = {}) {
         const id = options.run ?? this.requireRun();
         return this.request('POST', `/runs/${encodeURIComponent(id)}/notes`, { text, failed: options.failed ?? false, address: options.address });
@@ -313,3 +497,12 @@ export class ProxyMailQA {
         }
     }
 }
+const message = (err) => (err instanceof Error ? err.message : String(err));
+// Whole years from a YYYY-MM-DD date of birth, or null without one.
+function age(dateOfBirth) {
+    if (!dateOfBirth)
+        return null;
+    const [y, m, d] = dateOfBirth.split('-').map(Number);
+    const now = new Date();
+    return now.getUTCFullYear() - y - (now.getUTCMonth() + 1 < m || (now.getUTCMonth() + 1 === m && now.getUTCDate() < d) ? 1 : 0);
+}

package/dist/playwright-reporter.d.ts

@@ -0,0 +1,11 @@
+import type { FullResult, Reporter, Suite } from '@playwright/test/reporter';
+import { type ClientOptions } from './index.js';
+export default class ProxyMailQAReporter implements Reporter {
+    private readonly options;
+    private suite;
+    constructor(options?: Pick<ClientOptions, 'apiKey' | 'baseUrl'>);
+    onBegin(_config: unknown, suite: Suite): void;
+    onEnd(_result: FullResult): Promise<void>;
+    printsToStdio(): boolean;
+    private client;
+}

package/dist/playwright-reporter.js

@@ -0,0 +1,64 @@
+import { ProxyMailQA } from './index.js';
+import { testName } from './test-name.js';
+// Enough for a report; the rest are in Playwright's own.
+const MAX_RESULTS = 200;
+export default class ProxyMailQAReporter {
+    options;
+    suite = null;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    onBegin(_config, suite) {
+        this.suite = suite;
+    }
+    async onEnd(_result) {
+        const qa = this.client();
+        if (!qa || !this.suite)
+            return;
+        const totals = { passed: 0, failed: 0, skipped: 0, flaky: 0 };
+        const results = [];
+        for (const test of this.suite.allTests()) {
+            const outcome = test.outcome();
+            if (outcome === 'expected')
+                totals.passed++;
+            else if (outcome === 'skipped')
+                totals.skipped++;
+            else {
+                const flaky = outcome === 'flaky';
+                if (flaky)
+                    totals.flaky++;
+                else
+                    totals.failed++;
+                const last = test.results.at(-1);
+                results.push({
+                    name: nameOf(test),
+                    status: flaky ? 'flaky' : 'failed',
+                    durationMs: last?.duration,
+                    error: flaky ? undefined : last?.error?.message,
+                });
+            }
+        }
+        // Failures never fail the test run itself: the report is evidence.
+        for (const result of results.slice(0, MAX_RESULTS))
+            await qa.recordTest(result).catch(() => { });
+        await qa.recordTestTotals(totals).catch(() => { });
+    }
+    printsToStdio() {
+        return false;
+    }
+    client() {
+        try {
+            const qa = new ProxyMailQA(this.options);
+            return qa.run ? qa : null;
+        }
+        catch {
+            // No API key: nothing to report to.
+            return null;
+        }
+    }
+}
+// titlePath: the root, the project, the file, then describe blocks and the title.
+function nameOf(test) {
+    const [, project = '', , ...path] = test.titlePath();
+    return testName(project, path);
+}

package/dist/playwright.d.ts

@@ -0,0 +1,5 @@
+import { ProxyMailQA } from './index.js';
+export declare const test: import("playwright/test").TestType<import("playwright/test").PlaywrightTestArgs & import("playwright/test").PlaywrightTestOptions & {
+    qa: ProxyMailQA;
+}, import("playwright/test").PlaywrightWorkerArgs & import("playwright/test").PlaywrightWorkerOptions>;
+export { expect } from '@playwright/test';

package/dist/playwright.js

@@ -0,0 +1,25 @@
+// Playwright tests with Proxy Mail QA. The qa fixture is a client for the
+// test it's in: in a run (PROXYMAIL_QA_RUN, set by the GitHub Action or by
+// startRun in globalSetup), each call says which test it belongs to, so the
+// run's report shows which test each email came from.
+//
+//   import { test, expect } from 'proxymail-qa/playwright';
+//
+//   test('sign-up sends one code', async ({ page, qa }) => {
+//     const { address } = await qa.createAddress();
+//     …
+//   });
+//
+// Add proxymail-qa/playwright/reporter to the config's reporters to record
+// failed tests and the totals in the run too.
+import { test as base } from '@playwright/test';
+import { ProxyMailQA } from './index.js';
+import { testName } from './test-name.js';
+export const test = base.extend({
+    // eslint-disable-next-line no-empty-pattern
+    qa: async ({}, use, testInfo) => {
+        // titlePath starts with the file.
+        await use(new ProxyMailQA().forTest(testName(testInfo.project.name, testInfo.titlePath.slice(1))));
+    },
+});
+export { expect } from '@playwright/test';

package/dist/test-name.d.ts

@@ -0,0 +1 @@
+export declare const testName: (project: string, path: readonly string[]) => string;

package/dist/test-name.js

@@ -0,0 +1,3 @@
+// A test's name as the run shows it, the same in the qa fixture and the
+// reporter: the project (when named), the describe blocks and the title.
+export const testName = (project, path) => [project, ...path].filter(Boolean).join(' › ');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "proxymail-qa",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Disposable test inboxes for Playwright, Cypress and scripts: create an address, then wait for its verification code or link.",
   "license": "MIT",
   "author": "Proxy Mail QA <hello@proxymail.qa> (https://proxymail.qa)",
@@ -29,6 +29,14 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./playwright": {
+      "types": "./dist/playwright.d.ts",
+      "default": "./dist/playwright.js"
+    },
+    "./playwright/reporter": {
+      "types": "./dist/playwright-reporter.d.ts",
+      "default": "./dist/playwright-reporter.js"
     }
   },
   "files": [
@@ -46,7 +54,16 @@
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "prepublishOnly": "npm run build && npm test"
   },
+  "peerDependencies": {
+    "@playwright/test": ">=1.40.0"
+  },
+  "peerDependenciesMeta": {
+    "@playwright/test": {
+      "optional": true
+    }
+  },
   "devDependencies": {
+    "@playwright/test": "^1.64.1",
     "typescript": "^5.6.0",
     "vitest": "^5.0.3"
   }