@asrunjs/asrun 0.0.0-stage → 0.2.0

package/dist/lib/profiles.js

@@ -0,0 +1,121 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parse } from 'yaml';
+import { ROOT } from './paths.js';
+const NAME_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+const DEFAULT_SESSION_CHECK_PATH = '/account/';
+export const PRODUCTION = 'production';
+export const STAGING = 'staging';
+export const PROFILES_FILE = path.join(ROOT, 'profiles.yaml');
+/** The Playwright project name of a profile: its id. */
+export const projectName = (profile) => profile.id;
+export const profileLabel = (profile) => `${profile.id} (${profile.env})`;
+function validateTags(where, raw) {
+    if (raw === undefined || raw === null)
+        return [];
+    if (!Array.isArray(raw) || raw.some((tag) => typeof tag !== 'string' || !NAME_PATTERN.test(tag))) {
+        throw new Error(`${where}: "tags" must be a list of lowercase words (letters, digits, dashes), e.g. [us, core]`);
+    }
+    const duplicate = raw.find((tag, index) => raw.indexOf(tag) !== index);
+    if (duplicate)
+        throw new Error(`${where}: "tags" lists "${duplicate}" twice`);
+    return raw;
+}
+function validateSiteAddress(where, value) {
+    if (typeof value !== 'string' || value === '')
+        throw new Error(`${where} is missing "baseURL"`);
+    try {
+        const url = new URL(value);
+        if (url.protocol !== 'https:' && url.protocol !== 'http:')
+            throw new Error('protocol');
+    }
+    catch {
+        throw new Error(`${where}: "baseURL" must be a full http(s) URL, e.g. https://www.example.com`);
+    }
+    return value.replace(/\/$/, '');
+}
+function validate(raw, index) {
+    const label = `profiles.yaml: profile #${index + 1}`;
+    for (const key of ['id', 'name', 'env']) {
+        if (typeof raw?.[key] !== 'string' || raw[key] === '') {
+            throw new Error(`${label} is missing "${key}"`);
+        }
+    }
+    const where = `profiles.yaml: profile "${raw.id}"`;
+    if (!NAME_PATTERN.test(raw.id)) {
+        throw new Error(`${where}: "id" must be lowercase letters and digits, separated by single dashes (e.g. "example-staging")`);
+    }
+    if (!NAME_PATTERN.test(raw.env)) {
+        throw new Error(`${where}: "env" must be lowercase letters, digits and single dashes (e.g. "production", "staging")`);
+    }
+    if (raw.envs !== undefined) {
+        throw new Error(`${where} has an "envs" map. Each profile is one environment: give it an "env" and a "baseURL" instead.`);
+    }
+    if (raw.baseURL === undefined) {
+        throw new Error(`${where} is missing "baseURL" (the site address of ${raw.env})`);
+    }
+    const baseURL = validateSiteAddress(where, raw.baseURL);
+    if (raw.account !== undefined && raw.account !== null && typeof raw.account !== 'string') {
+        throw new Error(`${where}: "account" must be text (a mailbox or username), or omitted`);
+    }
+    if (raw.email !== undefined && typeof raw.email !== 'boolean') {
+        throw new Error(`${where}: "email" must be true or false`);
+    }
+    if (raw.env === PRODUCTION && raw.email === true) {
+        throw new Error(`${where}: "email: true" is not allowed. Tests never send email in production.`);
+    }
+    const sessionCheckPath = raw.sessionCheckPath ?? DEFAULT_SESSION_CHECK_PATH;
+    if (typeof sessionCheckPath !== 'string' || !sessionCheckPath.startsWith('/') || /\s/.test(sessionCheckPath)) {
+        throw new Error(`${where}: "sessionCheckPath" must start with "/" and contain no spaces`);
+    }
+    const account = typeof raw.account === 'string' && raw.account.trim() !== '' ? raw.account.trim() : null;
+    return {
+        id: raw.id,
+        name: raw.name,
+        env: raw.env,
+        baseURL,
+        account,
+        tags: validateTags(where, raw.tags),
+        email: raw.email === true,
+        sessionCheckPath,
+    };
+}
+export function loadProfiles(file = PROFILES_FILE) {
+    if (!fs.existsSync(file)) {
+        throw new Error(`profiles.yaml is missing. Create it in the project root (see the comments in the file for the fields).`);
+    }
+    const text = fs.readFileSync(file, 'utf8');
+    const parsed = parse(text, { merge: true });
+    const raw = parsed?.profiles;
+    if (!Array.isArray(raw)) {
+        throw new Error('profiles.yaml needs a "profiles:" list (it may be empty while you set the suite up).');
+    }
+    const profiles = raw.map(validate);
+    const ids = profiles.map((profile) => profile.id);
+    const duplicate = ids.find((id, index) => ids.indexOf(id) !== index);
+    if (duplicate)
+        throw new Error(`profiles.yaml: duplicate profile id "${duplicate}"`);
+    return profiles;
+}
+function sortProfiles(profiles) {
+    const rank = (env) => (env === PRODUCTION ? 0 : env === STAGING ? 1 : 2);
+    return [...profiles].sort((a, b) => rank(a.env) - rank(b.env) || a.id.localeCompare(b.id));
+}
+/** The profiles of one environment (`env` omitted: all of them), production first. */
+export const listProfiles = (env, profiles = loadProfiles()) => sortProfiles(profiles.filter((profile) => !env || profile.env === env));
+export function getProfile(id, profiles = loadProfiles()) {
+    const profile = profiles.find((candidate) => candidate.id === id);
+    if (!profile) {
+        const known = profiles.map((candidate) => candidate.id).join(', ') || '(none)';
+        throw new Error(`Unknown profile "${id}". Known profiles: ${known}. Check profiles.yaml.`);
+    }
+    return profile;
+}
+/** The profiles that carry this tag. */
+export const listProfilesWithTag = (tag, env, profiles = loadProfiles()) => listProfiles(env, profiles).filter((profile) => profile.tags.includes(tag));
+/** Every environment used by a profile: production, staging, then the rest. */
+export const listEnvs = (profiles = loadProfiles()) => {
+    const envs = [...new Set(profiles.map((profile) => profile.env))];
+    const rank = (env) => (env === PRODUCTION ? 0 : env === STAGING ? 1 : 2);
+    return envs.sort((a, b) => rank(a) - rank(b) || a.localeCompare(b));
+};

package/dist/lib/ready.d.ts

@@ -0,0 +1,36 @@
+import { type Locator, type Page } from '@playwright/test';
+export interface ReadyOptions {
+    /** Key requests the action starts (URL substring or RegExp). Each must finish with a status below 400. */
+    responses?: (string | RegExp)[];
+    /** What must be visible once the content is really there (not a spinner, a frame or a placeholder). */
+    ready?: Locator | Locator[];
+    /** Per request and per locator, in ms. */
+    timeout?: number;
+}
+/**
+ * Runs `action` (a click, a navigation) and waits until its result is there: first the key requests it starts have
+ * finished, then the `ready` locators are visible. Read the result only after this returns.
+ *
+ * The response waiters are registered before the action runs, so a fast response is never missed.
+ *
+ *   await actAndWait(page, () => share.click(), {responses: [/\/api\/documents\/.+\/email/], ready: composer.getByRole('textbox', {name: 'To'})});
+ */
+export declare function actAndWait<T>(page: Page, action: () => Promise<T>, options?: ReadyOptions): Promise<T>;
+/**
+ * For an action that may or may not raise a confirmation (a "Discard draft?" dialog after closing a composer): clicks
+ * `optional` whenever it is visible, and returns once `target` is hidden. Both happen in one retry loop, so a
+ * confirmation that shows up late is still clicked, and no confirmation does not cost a wait.
+ *
+ * `isVisible()` alone is not enough: it answers for this instant only and its `timeout` option is ignored.
+ * Prefer a `target` that stays on the same element (a role/name or test id locator); a `.last()` locator moves to the
+ * confirm dialog while that dialog is open.
+ *
+ *   await composer.getByRole('button', {name: 'close', exact: true}).click();
+ *   await clickOptionalUntilHidden(page.getByRole('button', {name: 'Discard', exact: true}), composer, {message: 'The email composer did not close'});
+ */
+export declare function clickOptionalUntilHidden(optional: Locator, target: Locator, options?: {
+    timeout?: number;
+    message?: string;
+}): Promise<void>;
+/** Waits until nothing inside `scope` says it is still loading (busy regions, progress bars, spinners and skeletons that have a role or test id). */
+export declare function expectNotBusy(scope: Locator | Page, timeout?: number): Promise<void>;

package/dist/lib/ready.js

@@ -0,0 +1,53 @@
+import { expect } from '@playwright/test';
+const matches = (pattern, url) => (typeof pattern === 'string' ? url.includes(pattern) : pattern.test(url));
+/**
+ * Runs `action` (a click, a navigation) and waits until its result is there: first the key requests it starts have
+ * finished, then the `ready` locators are visible. Read the result only after this returns.
+ *
+ * The response waiters are registered before the action runs, so a fast response is never missed.
+ *
+ *   await actAndWait(page, () => share.click(), {responses: [/\/api\/documents\/.+\/email/], ready: composer.getByRole('textbox', {name: 'To'})});
+ */
+export async function actAndWait(page, action, options = {}) {
+    const { responses = [], ready = [], timeout = 30_000 } = options;
+    const waiters = responses.map((pattern) => page
+        .waitForResponse((response) => matches(pattern, response.url()), { timeout })
+        .then((response) => ({ pattern, response }), () => ({ pattern, response: null })));
+    const result = await action();
+    for (const { pattern, response } of await Promise.all(waiters)) {
+        if (!response)
+            throw new Error(`The page did not finish loading: no response for the request ${pattern} within ${timeout / 1000}s`);
+        if (response.status() >= 400) {
+            throw new Error(`The page did not load its data: the request ${pattern} failed (HTTP ${response.status()})`);
+        }
+    }
+    for (const locator of Array.isArray(ready) ? ready : [ready]) {
+        await expect(locator, 'The content did not finish loading').toBeVisible({ timeout });
+    }
+    return result;
+}
+/**
+ * For an action that may or may not raise a confirmation (a "Discard draft?" dialog after closing a composer): clicks
+ * `optional` whenever it is visible, and returns once `target` is hidden. Both happen in one retry loop, so a
+ * confirmation that shows up late is still clicked, and no confirmation does not cost a wait.
+ *
+ * `isVisible()` alone is not enough: it answers for this instant only and its `timeout` option is ignored.
+ * Prefer a `target` that stays on the same element (a role/name or test id locator); a `.last()` locator moves to the
+ * confirm dialog while that dialog is open.
+ *
+ *   await composer.getByRole('button', {name: 'close', exact: true}).click();
+ *   await clickOptionalUntilHidden(page.getByRole('button', {name: 'Discard', exact: true}), composer, {message: 'The email composer did not close'});
+ */
+export async function clickOptionalUntilHidden(optional, target, options = {}) {
+    const { timeout = 30_000, message = 'The element did not close' } = options;
+    await expect(async () => {
+        if (await optional.isVisible())
+            await optional.click({ timeout: 2_000 });
+        await expect(target).toBeHidden({ timeout: 1_000 });
+    }, message).toPass({ timeout, intervals: [250, 500, 1_000] });
+}
+/** Waits until nothing inside `scope` says it is still loading (busy regions, progress bars, spinners and skeletons that have a role or test id). */
+export async function expectNotBusy(scope, timeout = 30_000) {
+    const busy = scope.locator('[aria-busy="true"], [role="progressbar"], [role="status"][aria-live][aria-busy="true"], [data-tn*="loading" i], [data-tn*="skeleton" i], [data-testid*="loading" i], [data-testid*="skeleton" i]');
+    await expect(busy, 'The content is still loading').toHaveCount(0, { timeout });
+}

package/dist/lib/records.d.ts

@@ -0,0 +1,33 @@
+/** Every piece of data a test creates carries this prefix, so it can never be mistaken for real data. */
+export declare const TEST_DATA_PREFIX = "[asrun]";
+export type RecordStatus = 'open' | 'cleaned' | 'leftover';
+/** One piece of test data a case created, as written to the ledger. */
+export interface LedgerEntry {
+    id: string;
+    runId: string;
+    env: string;
+    profile: string;
+    caseId: string;
+    /** What kind of thing it is, e.g. "Document draft". */
+    kind: string;
+    /** Its name in the product; always starts with TEST_DATA_PREFIX. */
+    name: string;
+    /** Where a person can find and remove it by hand, e.g. "/app/documents". */
+    where: string | null;
+    /** `open`: created, not yet removed (also what a crashed run leaves behind). */
+    status: RecordStatus;
+    error: string | null;
+    createdAt: string;
+}
+export declare const RECORDS_DIR: string;
+/** The ledger of one test: `.tmp/records/<runId>/<file>.json`. One file per test, so parallel workers never share a file. */
+export declare const ledgerFile: (runId: string, testId: string) => string;
+export declare function writeLedger(file: string, entries: LedgerEntry[]): void;
+/** Entries of one run (or of every run) that are not known to be removed. */
+export declare function findLeftovers(options?: {
+    runId?: string;
+    env?: string;
+}): LedgerEntry[];
+/** Forget the ledgers of runs whose leftovers a person has removed by hand. */
+export declare function forgetLedgers(env: string): number;
+export declare function describeLeftovers(entries: LedgerEntry[]): string;

package/dist/lib/records.js

@@ -0,0 +1,61 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { ROOT } from './paths.js';
+/** Every piece of data a test creates carries this prefix, so it can never be mistaken for real data. */
+export const TEST_DATA_PREFIX = '[asrun]';
+export const RECORDS_DIR = path.join(ROOT, '.tmp', 'records');
+/** The ledger of one test: `.tmp/records/<runId>/<file>.json`. One file per test, so parallel workers never share a file. */
+export const ledgerFile = (runId, testId) => path.join(RECORDS_DIR, runId, `${testId.replace(/[^\w-]/g, '_')}.json`);
+export function writeLedger(file, entries) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(entries, null, 2));
+}
+function readLedger(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return [];
+    }
+}
+/** Entries of one run (or of every run) that are not known to be removed. */
+export function findLeftovers(options = {}) {
+    if (!fs.existsSync(RECORDS_DIR))
+        return [];
+    const runs = options.runId ? [options.runId] : fs.readdirSync(RECORDS_DIR);
+    return runs
+        .flatMap((run) => {
+        const dir = path.join(RECORDS_DIR, run);
+        if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory())
+            return [];
+        return fs.readdirSync(dir).filter((name) => name.endsWith('.json')).flatMap((name) => readLedger(path.join(dir, name)));
+    })
+        .filter((entry) => entry.status !== 'cleaned' && (!options.env || entry.env === options.env));
+}
+/** Forget the ledgers of runs whose leftovers a person has removed by hand. */
+export function forgetLedgers(env) {
+    if (!fs.existsSync(RECORDS_DIR))
+        return 0;
+    let removed = 0;
+    for (const run of fs.readdirSync(RECORDS_DIR)) {
+        const dir = path.join(RECORDS_DIR, run);
+        if (!fs.statSync(dir).isDirectory())
+            continue;
+        for (const name of fs.readdirSync(dir)) {
+            const file = path.join(dir, name);
+            if (readLedger(file).some((entry) => entry.env === env)) {
+                fs.rmSync(file);
+                removed++;
+            }
+        }
+        if (fs.readdirSync(dir).length === 0)
+            fs.rmdirSync(dir);
+    }
+    return removed;
+}
+export function describeLeftovers(entries) {
+    return entries
+        .map((entry) => `  - [${entry.profile} (${entry.env})] ${entry.kind} "${entry.name}" (case ${entry.caseId}, run ${entry.runId}` +
+        `${entry.where ? `, look in ${entry.where}` : ''})${entry.error ? `\n      cleanup said: ${entry.error}` : ''}`)
+        .join('\n');
+}

package/dist/lib/run-filters.d.ts

@@ -0,0 +1,19 @@
+/** Matches the spec file of one case (`documents/published-flow` must not match `documents/published-flow-2`). */
+export declare const casePattern: (id: string) => string;
+export interface RunFilters {
+    env: string;
+    /** `null` = every profile of the environment (no `--project` filter). */
+    profiles: string[] | null;
+    suites: string[];
+    /** The user's own `--grep`. */
+    grep?: string;
+    /** Leave out the cases that write data. */
+    readOnly: boolean;
+    /** Only these cases (ids such as `documents/published-flow`), e.g. the ones whose baselines are being updated. */
+    only?: string[];
+}
+/**
+ * The Playwright arguments that decide WHICH tests run. Shared by `pnpm asrun` and by the web UI's
+ * "what would this run do" preview, so both always agree.
+ */
+export declare function filterArgs(filters: RunFilters): string[];

package/dist/lib/run-filters.js

@@ -0,0 +1,30 @@
+/** `--grep` pattern that matches a tag exactly (`@smoke` must not match `@smoke-extra`). */
+const tagPattern = (name) => `@${name}(?![\\w-])`;
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/** Matches the spec file of one case (`documents/published-flow` must not match `documents/published-flow-2`). */
+export const casePattern = (id) => `(?:^|\\s)${escapeRegExp(id)}\\.spec\\.ts`;
+/**
+ * The Playwright arguments that decide WHICH tests run. Shared by `pnpm asrun` and by the web UI's
+ * "what would this run do" preview, so both always agree.
+ */
+export function filterArgs(filters) {
+    // Playwright accepts a single --grep and matches it against the file, titles and tags, so the
+    // suite filter and the user's own --grep are combined into one regular expression.
+    const grepParts = [];
+    if (filters.suites.length > 0) {
+        grepParts.push(`(?:${filters.suites.map(tagPattern).join('|')})`);
+    }
+    if (filters.grep) {
+        grepParts.push(`(?:${filters.grep})`);
+    }
+    if (filters.only && filters.only.length > 0) {
+        grepParts.push(`(?:${filters.only.map(casePattern).join('|')})`);
+    }
+    const invert = ['@seed', ...(filters.readOnly ? ['@writes'] : [])].join('|');
+    return [
+        ...(filters.profiles ? filters.profiles.flatMap((id) => ['--project', id]) : []),
+        ...(grepParts.length > 0 ? ['--grep', grepParts.map((part) => `(?=.*${part})`).join('')] : []),
+        '--grep-invert',
+        invert,
+    ];
+}

package/dist/lib/run-summary.d.ts

@@ -0,0 +1,90 @@
+import type { LedgerEntry } from './records.js';
+/** One failure, split so that people read the meaning first and the technical noise only on demand. */
+export interface ParsedError {
+    /** First line of the message: what went wrong, in the words of the assertion message. */
+    headline: string;
+    /** The rest of the message before the call log (Locator / Expected / Received ...). */
+    context: string;
+    /** Playwright's call log: what it tried and waited for. */
+    callLog: string;
+    /** Code frame around the failing line. */
+    snippet: string;
+    /** Stack frames only (no message). */
+    stack: string;
+}
+export type ResultStatus = 'passed' | 'failed' | 'flaky' | 'skipped';
+export interface TestRunResult {
+    /** Playwright's id of the test (unique per project); the HTML report deep-links with it. */
+    testId: string;
+    caseId: string;
+    /** Profile id, without the environment. */
+    profile: string;
+    /** Environment of the run (`production`, `staging`, ...). Absent in summaries written before environments existed. */
+    env?: string;
+    /** The case writes test data (`writes` in its front matter). Absent in older summaries. */
+    writes?: boolean;
+    title: string;
+    status: ResultStatus;
+    durationMs: number;
+    /** How many times the test ran (retries included). */
+    attempts: number;
+    /** Title of the `test.step` that failed, e.g. "2. Find the first published document". */
+    failedStep: string | null;
+    errors: ParsedError[];
+    /** Paths relative to the HTML report folder (`data/<sha1>.png`). */
+    screenshots: string[];
+    /** Per-page recordings (`data/<sha1>.webm`). */
+    videos: string[];
+    /** All recordings of the test joined in order, relative to the report folder (`videos/<testId>.webm`). */
+    video?: string;
+}
+/** Playwright's overall result of the run. */
+export type RunStatus = 'passed' | 'failed' | 'timedout' | 'interrupted';
+/** How the run was started, so the report can run it again the same way. */
+export interface RunSettings {
+    stepText: boolean;
+    readOnly: boolean;
+    /** The profiles that were selected; null = every profile of the environment. */
+    profiles: string[] | null;
+    /** Tags that selected the profiles (absent = no tag filter). */
+    tags?: string[];
+    suites: string[];
+    /** The user's own `--grep`. */
+    grep?: string;
+    /** The run was limited to these cases (the part of an `--update-baselines` run that is not, or is, being rewritten). */
+    only?: string[];
+}
+/** Environment variable that carries the settings (JSON) from `pnpm asrun` to the summary reporter. */
+export declare const RUN_SETTINGS_ENV = "ASRUN_RUN_SETTINGS";
+export interface RunSummary {
+    runId: string;
+    /** Absent in summaries written before settings were recorded, and for runs not started by `pnpm asrun`. */
+    settings?: RunSettings;
+    /** Environment the whole run targeted. Absent in summaries written before environments existed (those were production). */
+    env?: string;
+    startedAt: string;
+    durationMs: number;
+    /** Absent in summaries written before run status was recorded. */
+    status?: RunStatus;
+    /**
+     * Errors that belong to the run, not to a test: a spec that fails to load (broken import, syntax
+     * error), a failing global setup or worker teardown. Absent in older summaries.
+     */
+    errors?: ParsedError[];
+    counts: Record<ResultStatus, number>;
+    /** Test data that was created and not removed again (needs a person). Absent in older summaries. */
+    leftovers?: LedgerEntry[];
+    results: TestRunResult[];
+}
+/** Turns a Playwright `TestError` into the parts shown by the UI. */
+export declare function parseError(error: {
+    message?: string;
+    stack?: string;
+    snippet?: string;
+    value?: string;
+}): ParsedError;
+/**
+ * `tests/<caseId>.spec.ts` -> `<caseId>`, with the group folder: `tests/documents/landing-page.spec.ts` -> `documents/landing-page`.
+ * Accepts the absolute path (`testInfo.file`) and the path relative to `tests/` (what `--list` reports).
+ */
+export declare function caseIdFromFile(file: string): string;

package/dist/lib/run-summary.js

@@ -0,0 +1,35 @@
+import { stripVTControlCharacters } from 'node:util';
+import path from 'node:path';
+import { TESTS_DIR } from './paths.js';
+/** Environment variable that carries the settings (JSON) from `pnpm asrun` to the summary reporter. */
+export const RUN_SETTINGS_ENV = 'ASRUN_RUN_SETTINGS';
+const CALL_LOG = /\n[ \t]*Call log:[ \t]*\n/;
+/** Turns a Playwright `TestError` into the parts shown by the UI. */
+export function parseError(error) {
+    const message = stripVTControlCharacters(error.message ?? error.value ?? 'Unknown error')
+        .replace(/^Error: /, '')
+        .trim();
+    const [body, callLog = ''] = message.split(CALL_LOG, 2);
+    const [headline = '', ...rest] = body.trim().split('\n');
+    const stack = stripVTControlCharacters(error.stack ?? '')
+        .split('\n')
+        .filter((line) => /^\s+at /.test(line))
+        .join('\n');
+    return {
+        headline: headline.trim(),
+        context: rest.join('\n').trim(),
+        callLog: callLog.trim(),
+        snippet: stripVTControlCharacters(error.snippet ?? '').trim(),
+        stack,
+    };
+}
+/**
+ * `tests/<caseId>.spec.ts` -> `<caseId>`, with the group folder: `tests/documents/landing-page.spec.ts` -> `documents/landing-page`.
+ * Accepts the absolute path (`testInfo.file`) and the path relative to `tests/` (what `--list` reports).
+ */
+export function caseIdFromFile(file) {
+    let relative = path.isAbsolute(file) ? path.relative(TESTS_DIR, file) : file;
+    if (relative.startsWith('..'))
+        relative = path.basename(file);
+    return relative.split(path.sep).join('/').replace(/\.spec\.[cm]?[jt]s$/, '');
+}

package/dist/lib/session.d.ts

@@ -0,0 +1,18 @@
+import type { Browser } from '@playwright/test';
+import type { Profile } from './profiles.js';
+export type SessionStatus = 'ok' | 'missing' | 'expired';
+/**
+ * Set by `pnpm asrun` after its pre-run login check: `profile-id:status,profile-id:status`
+ * for every profile that is not logged in. Lets the config and fixtures skip a second check.
+ */
+export declare const NOT_LOGGED_IN_ENV = "ASRUN_NOT_LOGGED_IN";
+export declare const hasSessionFile: (profile: Profile) => boolean;
+export declare const isLoginUrl: (url: string) => boolean;
+export declare function checkSession(browser: Browser, profile: Profile): Promise<SessionStatus>;
+export declare function parseNotLoggedIn(value?: string | undefined): Map<string, SessionStatus>;
+export declare const formatNotLoggedIn: (entries: Map<string, SessionStatus>) => string;
+export declare const signinCommand: (profile: {
+    id: string;
+}) => string;
+export declare const skipProfileHint: (profileIds: string[], env: string) => string;
+export declare const sessionProblemMessage: (profile: Profile, status: SessionStatus) => string;

package/dist/lib/session.js

@@ -0,0 +1,45 @@
+import fs from 'node:fs';
+import { authFile } from './paths.js';
+/**
+ * Set by `pnpm asrun` after its pre-run login check: `profile-id:status,profile-id:status`
+ * for every profile that is not logged in. Lets the config and fixtures skip a second check.
+ */
+export const NOT_LOGGED_IN_ENV = 'ASRUN_NOT_LOGGED_IN';
+export const hasSessionFile = (profile) => fs.existsSync(authFile(profile.id));
+export const isLoginUrl = (url) => {
+    try {
+        return new URL(url).pathname.startsWith('/login');
+    }
+    catch {
+        return false;
+    }
+};
+export async function checkSession(browser, profile) {
+    if (!hasSessionFile(profile)) {
+        return 'missing';
+    }
+    const context = await browser.newContext({ storageState: authFile(profile.id) });
+    try {
+        const page = await context.newPage();
+        await page.goto(new URL(profile.sessionCheckPath, profile.baseURL).href, {
+            waitUntil: 'domcontentloaded',
+        });
+        return isLoginUrl(page.url()) ? 'expired' : 'ok';
+    }
+    finally {
+        await context.close();
+    }
+}
+export function parseNotLoggedIn(value = process.env[NOT_LOGGED_IN_ENV]) {
+    const result = new Map();
+    for (const entry of (value ?? '').split(',').filter(Boolean)) {
+        const [id, status] = entry.split(':');
+        result.set(id, status === 'missing' ? 'missing' : 'expired');
+    }
+    return result;
+}
+export const formatNotLoggedIn = (entries) => [...entries].map(([id, status]) => `${id}:${status}`).join(',');
+export const signinCommand = (profile) => `pnpm signin ${profile.id}`;
+export const skipProfileHint = (profileIds, env) => `pnpm asrun --env ${env} --skip-profile ${profileIds.join(',')}`;
+export const sessionProblemMessage = (profile, status) => `Profile "${profile.id}" is not logged in to ${profile.env} (session ${status}). ` +
+    `Log in first: ${signinCommand(profile)}  -  or skip this profile: ${skipProfileHint([profile.id], profile.env)}`;

package/dist/lib/summary-reporter.d.ts

@@ -0,0 +1,16 @@
+import type { FullResult, Reporter, TestCase, TestError } from '@playwright/test/reporter';
+/**
+ * Writes `reports/<runId>/summary.json`: one entry per test (case x profile) with the error split into
+ * a readable headline and the technical details, so the UI can show what went wrong at a glance.
+ */
+export default class SummaryReporter implements Reporter {
+    private startedAt;
+    private readonly tests;
+    private readonly errors;
+    onBegin(): void;
+    onTestEnd(test: TestCase): void;
+    onError(error: TestError): void;
+    onEnd(fullResult: FullResult): void;
+    printsToStdio(): boolean;
+    private summarize;
+}