@crvouga/atlas 0.9.0 → 0.10.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog: @crvouga/atlas
 
+## 0.10.0 (2026-10-21)
+
+### Features
+
+- explore tests by spec, environment and run, readable by agents (#15) ([cb2b8da](https://github.com/crvouga/atlas/commit/cb2b8da7a3c7ec8ca8e3849021ea43358eb593a3))
+
 ## 0.9.0 (2026-10-15)
 
 ### Features

package/dist/playwright-reporter/src/evidence.d.ts

@@ -0,0 +1,122 @@
+import type { FullProject, TestCase, TestError, TestResult, TestStep } from 'playwright/types/testReporter';
+import type { PublishChecksInput } from '../../schema/src/layer.js';
+/** One check as handed to the streaming reporter: the input type of a check in `PublishChecksSchema`. */
+export type CheckInput = PublishChecksInput['checks'][number];
+type AttachmentInput = NonNullable<CheckInput['attachments']>[number];
+type StepInput = NonNullable<CheckInput['steps']>[number];
+type AnnotationInput = NonNullable<CheckInput['annotations']>[number];
+/** Which results upload their attachments: every one, only failed checks and failed attempts, or none. */
+export type AttachmentMode = 'all' | 'failures' | 'none';
+/** What to upload of the files Playwright attached: the `mode`, and the largest single file in bytes (`maxBytes`). */
+export type AttachmentPolicy = {
+    /** `all`, `failures` (failed checks and failed attempts only) or `none`. */
+    readonly mode: AttachmentMode;
+    /** A larger file is not uploaded; the check gets an `attachment-skipped` annotation instead. */
+    readonly maxBytes: number;
+};
+/** Where a check comes from and how it is recorded, as worked out by the reporter before its evidence is collected. */
+export type CheckContext = {
+    /** The check's stable id: `<specPath>#<describe titles > test title>`. */
+    readonly id: string;
+    readonly title: string;
+    /** The spec the check belongs to, relative to the repository. */
+    readonly specPath: string;
+    /** Facts about where it ran: browser, device, viewport, os, playwright version. */
+    readonly labels: Readonly<Record<string, string>>;
+    /** Relative paths (source locations) are written relative to this directory. */
+    readonly root: string;
+    readonly attachments: AttachmentPolicy;
+    /** The most timeline steps recorded per result; the rest are counted in an annotation. */
+    readonly maxSteps: number;
+};
+/**
+ * Removes terminal colour and cursor codes, which Playwright puts in error messages and step titles.
+ * @example
+ * stripAnsi('\u001b[31mExpected\u001b[39m'); // 'Expected'
+ */
+export declare function stripAnsi(text: string): string;
+/**
+ * The failure detail of an error: its message and stack without terminal codes, the message once, cut to `maxChars`.
+ * An absent error is the empty string.
+ * @param error A Playwright `TestError` (a result's or a step's).
+ * @param maxChars The longest detail kept. Default 8000.
+ */
+export declare function errorDetail(error: TestError | undefined, maxChars?: number): string;
+/**
+ * The Atlas status of one Playwright result: skipped is `not-run`; the status the test expected (`passed`, or `failed`
+ * for a `test.fail()`) is `passed`; anything else (failed, timed out, interrupted, an expected failure that passed) is
+ * `failed`.
+ */
+export declare function resultStatus(test: Pick<TestCase, 'expectedStatus'>, result: Pick<TestResult, 'status'>): 'passed' | 'failed' | 'not-run';
+/** Whether Playwright will run this test again after this result: it did not get what it expected and has retries left. */
+export declare function willRetry(test: Pick<TestCase, 'expectedStatus' | 'retries'>, result: Pick<TestResult, 'status' | 'retry'>): boolean;
+/**
+ * The timeline kind of a Playwright step, by its category: `test.step` is `step` (or the Gherkin keyword, `given`,
+ * `when`, `then`, `and`, `but`, for a playwright-bdd step), `expect` is `assertion`, `pw:api` is `action`, `hook`,
+ * `fixture`; any other category is kept as it is.
+ */
+export declare function stepKind(step: Pick<TestStep, 'category' | 'title'>): string;
+/**
+ * Playwright's step tree as Atlas's flat timeline: each step gets an id (`s1`, `s2`, …), its parent's id, its kind,
+ * when it started after the result did (`offsetMs`), how long it took, and `failed` with the error as detail when it
+ * failed. At most `max` steps are kept, in order; `dropped` counts the rest.
+ * @param steps `result.steps`.
+ * @param startedAtMs When the result started (`result.startTime`), in epoch milliseconds.
+ * @param max The most steps kept.
+ */
+export declare function flattenSteps(steps: readonly TestStep[], startedAtMs: number, max: number): {
+    steps: StepInput[];
+    dropped: number;
+};
+/**
+ * The closest directory at or above `start` that holds `.git` (a folder, or a file in a worktree), or null. Reads the
+ * file system only; it never runs git.
+ */
+export declare function findRepoRoot(start: string, exists?: (file: string) => boolean): string | null;
+/** `file` relative to `root`, with forward slashes on every OS. */
+export declare function repoPath(file: string, root: string): string;
+/**
+ * The `.feature` file a playwright-bdd generated test came from, or undefined for any other test file. playwright-bdd
+ * writes `<outputDir>/<path>.feature.spec.js` (its outputDir is `.features-gen` by default, mirroring the feature
+ * folders); this returns the first `<path>.feature` that exists beside `.features-gen` (dropping leading folders, such
+ * as a per-project output folder, until one does), else the mapped path even if no such file is found.
+ * @param file The absolute path of the test file (`test.location.file`).
+ * @example
+ * bddFeaturePath('/repo/e2e/.features-gen/features/login.feature.spec.js'); // '/repo/e2e/features/login.feature'
+ */
+export declare function bddFeaturePath(file: string, exists?: (file: string) => boolean): string | undefined;
+/** The environment a project tests by default: `mobile-web` when it emulates a mobile device (`use.isMobile`), else `desktop-web`. */
+export declare function projectEnvironment(project: Pick<FullProject, 'use'> | undefined): string;
+/**
+ * What every check of a project carries as labels: `browser` (`use.browserName`, else the device's
+ * `defaultBrowserType`), `channel`, `device` (the project name), `viewport` (`<width>x<height>`), `os`
+ * (`process.platform`) and `playwright` (its version). Labels describe a result; they never split its slot.
+ * @param project The Playwright project, or undefined when it is not known.
+ * @param version Playwright's version (`config.version`).
+ */
+export declare function projectLabels(project: Pick<FullProject, 'name' | 'use'> | undefined, version?: string): Record<string, string>;
+/**
+ * The files and output of one result as attachments with their bytes: every `result.attachments` entry (role `video`,
+ * `screenshot` or `trace` by its Playwright name, else the name itself; bytes from `body`, or read from `path`), and
+ * standard output and error as `log` text. A file over the size limit, or that cannot be read, is left out with an
+ * `attachment-skipped` annotation saying why. Never throws.
+ * @param result The Playwright result.
+ * @param failed Whether the result failed, for the `failures` mode.
+ * @param policy What to upload.
+ */
+export declare function resultAttachments(result: Pick<TestResult, 'attachments' | 'stdout' | 'stderr'>, failed: boolean, policy: AttachmentPolicy): Promise<{
+    attachments: AttachmentInput[];
+    annotations: AnnotationInput[];
+}>;
+/**
+ * The final check of a Playwright test from all its results (one per try): status of the last result (`flaky`, as a
+ * tag and a label, when it passed after a failed try), failure detail without terminal codes, duration, tags (the
+ * test's tags without `@`, and its annotation types), annotations, links (annotations whose description is a URL),
+ * timeline steps, one attempt per try when it was retried, attachments, and the test's location under the
+ * `playwright` extension. Reads attached files; never throws for a file it cannot read.
+ * @param test The Playwright test.
+ * @param results Its results, oldest first (`test.results`).
+ * @param context Its identity and what to record.
+ */
+export declare function checkOf(test: TestCase, results: readonly TestResult[], context: CheckContext): Promise<CheckInput>;
+export {};

package/dist/playwright-reporter/src/evidence.js

@@ -0,0 +1,327 @@
+/**
+ * @module Playwright results as Atlas evidence
+ *
+ * The pure half of the Playwright Test reporter: how one Playwright test and its results become one Atlas check, with
+ * its status, failure detail, duration, tags, annotations, links, timeline steps, retry attempts and attachments, and
+ * how a project becomes an environment and labels. Nothing here talks to a store; the only input/output is reading the
+ * files Playwright attached (videos, traces, screenshots) and looking for a repository root or a `.feature` file.
+ *
+ * @see docs/rich-evidence.md
+ */
+import { existsSync } from 'node:fs';
+import { readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+const ANSI = /\u001b\[[0-9;?]*[ -/]*[@-~]/g;
+/**
+ * Removes terminal colour and cursor codes, which Playwright puts in error messages and step titles.
+ * @example
+ * stripAnsi('\u001b[31mExpected\u001b[39m'); // 'Expected'
+ */
+export function stripAnsi(text) {
+    return text.replace(ANSI, '');
+}
+/**
+ * The failure detail of an error: its message and stack without terminal codes, the message once, cut to `maxChars`.
+ * An absent error is the empty string.
+ * @param error A Playwright `TestError` (a result's or a step's).
+ * @param maxChars The longest detail kept. Default 8000.
+ */
+export function errorDetail(error, maxChars = 8000) {
+    if (!error)
+        return '';
+    const message = stripAnsi(error.message ?? error.value ?? '').trim();
+    const stack = stripAnsi(error.stack ?? '').trim();
+    const text = !stack ? message : !message || stack.includes(message) ? stack : `${message}\n${stack}`;
+    return text.length > maxChars ? `${text.slice(0, maxChars)}…` : text;
+}
+/**
+ * The Atlas status of one Playwright result: skipped is `not-run`; the status the test expected (`passed`, or `failed`
+ * for a `test.fail()`) is `passed`; anything else (failed, timed out, interrupted, an expected failure that passed) is
+ * `failed`.
+ */
+export function resultStatus(test, result) {
+    if (result.status === 'skipped')
+        return 'not-run';
+    if (result.status === test.expectedStatus)
+        return 'passed';
+    return 'failed';
+}
+/** Whether Playwright will run this test again after this result: it did not get what it expected and has retries left. */
+export function willRetry(test, result) {
+    return result.status !== 'skipped' && result.status !== 'interrupted' && result.status !== test.expectedStatus && result.retry < test.retries;
+}
+const GHERKIN = /^(given|when|then|and|but)\b/i;
+const STEP_KINDS = { expect: 'assertion', 'pw:api': 'action', hook: 'hook', fixture: 'fixture', 'test.attach': 'attach' };
+/**
+ * The timeline kind of a Playwright step, by its category: `test.step` is `step` (or the Gherkin keyword, `given`,
+ * `when`, `then`, `and`, `but`, for a playwright-bdd step), `expect` is `assertion`, `pw:api` is `action`, `hook`,
+ * `fixture`; any other category is kept as it is.
+ */
+export function stepKind(step) {
+    if (step.category === 'test.step')
+        return GHERKIN.exec(stripAnsi(step.title).trim())?.[1]?.toLowerCase() ?? 'step';
+    return STEP_KINDS[step.category] ?? step.category;
+}
+/**
+ * Playwright's step tree as Atlas's flat timeline: each step gets an id (`s1`, `s2`, …), its parent's id, its kind,
+ * when it started after the result did (`offsetMs`), how long it took, and `failed` with the error as detail when it
+ * failed. At most `max` steps are kept, in order; `dropped` counts the rest.
+ * @param steps `result.steps`.
+ * @param startedAtMs When the result started (`result.startTime`), in epoch milliseconds.
+ * @param max The most steps kept.
+ */
+export function flattenSteps(steps, startedAtMs, max) {
+    const out = [];
+    let dropped = 0;
+    const count = (list) => list.reduce((sum, step) => sum + 1 + count(step.steps ?? []), 0);
+    const visit = (list, parentId) => {
+        for (const step of list) {
+            if (out.length >= max) {
+                dropped += 1 + count(step.steps ?? []);
+                continue;
+            }
+            const id = `s${out.length + 1}`;
+            const skipped = (step.annotations ?? []).some(annotation => annotation.type === 'skip');
+            const started = step.startTime instanceof Date ? step.startTime.getTime() : Number.NaN;
+            out.push({
+                id,
+                ...(parentId ? { parentId } : {}),
+                name: stripAnsi(step.title),
+                kind: stepKind(step),
+                status: step.error ? 'failed' : skipped ? 'skipped' : 'passed',
+                ...(Number.isFinite(started) ? { offsetMs: Math.max(0, started - startedAtMs) } : {}),
+                ...(Number.isFinite(step.duration) && step.duration >= 0 ? { durationMs: step.duration } : {}),
+                ...(step.error ? { detail: errorDetail(step.error, 2000) } : {})
+            });
+            visit(step.steps ?? [], id);
+        }
+    };
+    visit(steps, undefined);
+    return { steps: out, dropped };
+}
+/**
+ * The closest directory at or above `start` that holds `.git` (a folder, or a file in a worktree), or null. Reads the
+ * file system only; it never runs git.
+ */
+export function findRepoRoot(start, exists = existsSync) {
+    for (let dir = path.resolve(start);; dir = path.dirname(dir)) {
+        if (exists(path.join(dir, '.git')))
+            return dir;
+        if (path.dirname(dir) === dir)
+            return null;
+    }
+}
+/** `file` relative to `root`, with forward slashes on every OS. */
+export function repoPath(file, root) {
+    return path.relative(root, path.resolve(root, file)).replaceAll('\\', '/');
+}
+const GENERATED = /\.feature\.spec\.[cm]?[jt]s$/;
+/**
+ * The `.feature` file a playwright-bdd generated test came from, or undefined for any other test file. playwright-bdd
+ * writes `<outputDir>/<path>.feature.spec.js` (its outputDir is `.features-gen` by default, mirroring the feature
+ * folders); this returns the first `<path>.feature` that exists beside `.features-gen` (dropping leading folders, such
+ * as a per-project output folder, until one does), else the mapped path even if no such file is found.
+ * @param file The absolute path of the test file (`test.location.file`).
+ * @example
+ * bddFeaturePath('/repo/e2e/.features-gen/features/login.feature.spec.js'); // '/repo/e2e/features/login.feature'
+ */
+export function bddFeaturePath(file, exists = existsSync) {
+    const normalized = file.replaceAll('\\', '/');
+    if (!GENERATED.test(normalized))
+        return undefined;
+    const marker = normalized.lastIndexOf('/.features-gen/');
+    if (marker < 0)
+        return normalized.replace(GENERATED, '.feature');
+    const base = normalized.slice(0, marker);
+    const rest = normalized.slice(marker + '/.features-gen/'.length).replace(GENERATED, '.feature').split('/');
+    for (let skip = 0; skip < rest.length; skip++) {
+        const candidate = `${base}/${rest.slice(skip).join('/')}`;
+        if (exists(candidate))
+            return candidate;
+    }
+    return `${base}/${rest.join('/')}`;
+}
+/** The environment a project tests by default: `mobile-web` when it emulates a mobile device (`use.isMobile`), else `desktop-web`. */
+export function projectEnvironment(project) {
+    return project?.use?.isMobile ? 'mobile-web' : 'desktop-web';
+}
+/**
+ * What every check of a project carries as labels: `browser` (`use.browserName`, else the device's
+ * `defaultBrowserType`), `channel`, `device` (the project name), `viewport` (`<width>x<height>`), `os`
+ * (`process.platform`) and `playwright` (its version). Labels describe a result; they never split its slot.
+ * @param project The Playwright project, or undefined when it is not known.
+ * @param version Playwright's version (`config.version`).
+ */
+export function projectLabels(project, version) {
+    const use = (project?.use ?? {});
+    const labels = {};
+    const browser = use.browserName ?? use.defaultBrowserType;
+    if (browser)
+        labels.browser = browser;
+    if (use.channel)
+        labels.channel = use.channel;
+    labels.device = project?.name || 'default';
+    if (use.viewport && Number.isFinite(use.viewport.width) && Number.isFinite(use.viewport.height))
+        labels.viewport = `${use.viewport.width}x${use.viewport.height}`;
+    labels.os = process.platform;
+    if (version)
+        labels.playwright = version;
+    return labels;
+}
+const ROLES = { video: 'video', screenshot: 'screenshot', trace: 'trace' };
+function wanted(policy, failed) {
+    return policy.mode === 'all' || (policy.mode === 'failures' && failed);
+}
+function skippedNote(name, message) {
+    return { type: 'attachment-skipped', level: 'warning', message: `${name} ${message}` };
+}
+/**
+ * The files and output of one result as attachments with their bytes: every `result.attachments` entry (role `video`,
+ * `screenshot` or `trace` by its Playwright name, else the name itself; bytes from `body`, or read from `path`), and
+ * standard output and error as `log` text. A file over the size limit, or that cannot be read, is left out with an
+ * `attachment-skipped` annotation saying why. Never throws.
+ * @param result The Playwright result.
+ * @param failed Whether the result failed, for the `failures` mode.
+ * @param policy What to upload.
+ */
+export async function resultAttachments(result, failed, policy) {
+    const attachments = [];
+    const annotations = [];
+    if (!wanted(policy, failed))
+        return { attachments, annotations };
+    for (const given of result.attachments ?? []) {
+        const role = ROLES[given.name] ?? given.name;
+        const name = given.path ? path.basename(given.path) : given.name;
+        const meta = { name, role, ...(given.contentType ? { contentType: given.contentType } : {}) };
+        try {
+            if (given.body) {
+                if (given.body.length > policy.maxBytes) {
+                    annotations.push(skippedNote(name, `(${given.body.length} bytes) was not uploaded: larger than maxAttachmentBytes (${policy.maxBytes})`));
+                    continue;
+                }
+                attachments.push({ ...meta, data: new Uint8Array(given.body) });
+            }
+            else if (given.path) {
+                const size = (await stat(given.path)).size;
+                if (size > policy.maxBytes) {
+                    annotations.push(skippedNote(name, `(${size} bytes) was not uploaded: larger than maxAttachmentBytes (${policy.maxBytes})`));
+                    continue;
+                }
+                attachments.push({ ...meta, data: new Uint8Array(await readFile(given.path)) });
+            }
+        }
+        catch (error) {
+            annotations.push(skippedNote(name, `could not be read: ${error instanceof Error ? error.message : String(error)}`));
+        }
+    }
+    for (const [stream, chunks] of [['stdout', result.stdout], ['stderr', result.stderr]]) {
+        const text = (chunks ?? []).map(chunk => (typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk))).join('');
+        if (!text.trim())
+            continue;
+        const bytes = new TextEncoder().encode(text).length;
+        if (bytes > policy.maxBytes) {
+            annotations.push(skippedNote(stream, `(${bytes} bytes) was not uploaded: larger than maxAttachmentBytes (${policy.maxBytes})`));
+            continue;
+        }
+        attachments.push({ name: stream, role: 'log', contentType: 'text/plain', text });
+    }
+    return { attachments, annotations };
+}
+const startOf = (result) => (result.startTime instanceof Date ? result.startTime.getTime() : 0);
+function annotationsOf(test, result, root) {
+    const seen = new Set();
+    const annotations = [];
+    const links = [];
+    const all = [...(test.annotations ?? []), ...((result?.annotations) ?? [])];
+    for (const annotation of all) {
+        const key = `${annotation.type}\u0000${annotation.description ?? ''}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        annotations.push({
+            type: annotation.type,
+            message: annotation.description ?? '',
+            ...(annotation.location ? { source: { file: repoPath(annotation.location.file, root), line: annotation.location.line, column: annotation.location.column } } : {})
+        });
+        if (annotation.description && /^https?:\/\//.test(annotation.description))
+            links.push({ url: annotation.description, rel: annotation.type });
+    }
+    return { annotations, types: [...new Set(all.map(annotation => annotation.type))], links };
+}
+/**
+ * The final check of a Playwright test from all its results (one per try): status of the last result (`flaky`, as a
+ * tag and a label, when it passed after a failed try), failure detail without terminal codes, duration, tags (the
+ * test's tags without `@`, and its annotation types), annotations, links (annotations whose description is a URL),
+ * timeline steps, one attempt per try when it was retried, attachments, and the test's location under the
+ * `playwright` extension. Reads attached files; never throws for a file it cannot read.
+ * @param test The Playwright test.
+ * @param results Its results, oldest first (`test.results`).
+ * @param context Its identity and what to record.
+ */
+export async function checkOf(test, results, context) {
+    const final = results.at(-1);
+    if (!final)
+        return { id: context.id, title: context.title, status: 'not-run', specPath: context.specPath, labels: { ...context.labels } };
+    const status = resultStatus(test, final);
+    const retried = results.length > 1;
+    const flaky = retried && status === 'passed';
+    const { annotations: noted, types, links } = annotationsOf(test, final, context.root);
+    const annotations = [...noted];
+    const timeline = flattenSteps(final.steps ?? [], startOf(final), context.maxSteps);
+    if (timeline.dropped)
+        annotations.push({ type: 'steps-truncated', level: 'info', message: `${timeline.dropped} more steps were not recorded (maxSteps ${context.maxSteps})` });
+    const files = await resultAttachments(final, status === 'failed', context.attachments);
+    annotations.push(...files.annotations);
+    const attempts = [];
+    if (retried) {
+        for (const result of results) {
+            const attemptStatus = resultStatus(test, result);
+            const last = result === final;
+            const evidence = last ? null : await resultAttachments(result, attemptStatus === 'failed', context.attachments);
+            const steps = last ? null : flattenSteps(result.steps ?? [], startOf(result), context.maxSteps).steps;
+            attempts.push({
+                index: result.retry,
+                status: attemptStatus,
+                ...(Number.isFinite(result.duration) && result.duration >= 0 ? { durationMs: result.duration } : {}),
+                ...(result.startTime instanceof Date ? { startedAtMs: Math.max(0, startOf(result)) } : {}),
+                ...(result.error ? { detail: errorDetail(result.error) } : {}),
+                ...(steps?.length ? { steps } : {}),
+                ...(evidence?.attachments.length ? { attachments: evidence.attachments } : {}),
+                ...(evidence?.annotations.length ? { annotations: evidence.annotations } : {})
+            });
+        }
+    }
+    const firstFailure = results.find(result => result.error)?.error;
+    const skipReason = (test.annotations ?? []).find(annotation => annotation.type === 'skip' || annotation.type === 'fixme')?.description;
+    const detail = status === 'failed' ? (errorDetail(final.error ?? final.errors?.[0]) || `${final.status}`)
+        : flaky ? `Passed on retry ${final.retry} (flaky)${firstFailure ? `: ${errorDetail(firstFailure, 500).split('\n')[0]}` : ''}`
+            : status === 'not-run' ? (skipReason ? `Skipped: ${skipReason}` : 'Skipped')
+                : '';
+    const tags = [...new Set([...(test.tags ?? []).map(tag => tag.replace(/^@/, '')), ...types, ...(flaky ? ['flaky'] : [])])].filter(Boolean);
+    const labels = { ...context.labels, ...(retried ? { retries: String(results.length - 1) } : {}), ...(flaky ? { flaky: 'true' } : {}) };
+    return {
+        id: context.id,
+        title: context.title,
+        status,
+        detail,
+        specPath: context.specPath,
+        ...(Number.isFinite(final.duration) && final.duration >= 0 ? { durationMs: final.duration } : {}),
+        ...(tags.length ? { tags } : {}),
+        labels,
+        ...(links.length ? { links } : {}),
+        ...(annotations.length ? { annotations } : {}),
+        ...(timeline.steps.length ? { steps: timeline.steps } : {}),
+        ...(attempts.length ? { attempts } : {}),
+        ...(files.attachments.length ? { attachments: files.attachments } : {}),
+        extensions: {
+            playwright: {
+                testId: test.id,
+                ...(test.location ? { location: { file: repoPath(test.location.file, context.root), line: test.location.line, column: test.location.column } } : {}),
+                expectedStatus: test.expectedStatus,
+                status: final.status,
+                retries: test.retries,
+                ...(Number.isInteger(final.workerIndex) ? { workerIndex: final.workerIndex } : {})
+            }
+        }
+    };
+}

package/dist/playwright-reporter/src/index.d.ts

@@ -0,0 +1,114 @@
+import type { FullConfig, FullProject, Reporter as PlaywrightReporter, Suite, TestCase, TestResult } from 'playwright/types/testReporter';
+import type { ObjectStore } from '../../reports/src/object-store.js';
+import { type AttachmentMode } from './evidence.js';
+export { bddFeaturePath, checkOf, errorDetail, findRepoRoot, flattenSteps, projectEnvironment, projectLabels, repoPath, resultAttachments, resultStatus, stepKind, stripAnsi, willRetry } from './evidence.js';
+export type { AttachmentMode, AttachmentPolicy, CheckContext, CheckInput } from './evidence.js';
+/** A value given once for every project, or worked out from each project. */
+export type PerProject<T> = T | ((project: FullProject) => T);
+/**
+ * Options of the Playwright Test reporter, given as the second element of its entry in `reporter` in
+ * `playwright.config.ts`. Every one is optional: with `ATLAS_SERVER_URL`, `ATLAS_TOKEN` and `ATLAS_PROJECT` set, none
+ * is needed.
+ */
+export type AtlasPlaywrightReporterOptions = {
+    /** Project namespace on a shared Atlas server. Default `ATLAS_PROJECT`. */
+    readonly project?: string;
+    /** The Atlas server (`https://atlas.example.com`), or any store location (`./atlas-reports`, `s3://bucket/prefix`). Default `ATLAS_SERVER_URL`, else `ATLAS_STORE`. */
+    readonly url?: string;
+    /** A publish token. Default `ATLAS_PUBLISH_TOKEN`, else `ATLAS_TOKEN` (or the file `ATLAS_TOKEN_FILE` names). */
+    readonly token?: string;
+    /** Publish to this store instead of a URL: a directory store, an in-memory store in tests, anything that implements `ObjectStore`. */
+    readonly store?: ObjectStore;
+    /** A stable name for this suite. With the check id, environment and parameters it picks the slot a result fills. Default `playwright`. */
+    readonly producer?: string;
+    /** The part kind of every layer. Default `checks`. */
+    readonly kind?: string;
+    /** The environment of a project's checks. Default `mobile-web` for a project with `use.isMobile`, else `desktop-web`. */
+    readonly environment?: PerProject<string>;
+    /** Choices that make a result its own slot (a locale, a tenant). Empty by default: labels never split slots, parameters do. */
+    readonly parameters?: PerProject<Readonly<Record<string, string>>>;
+    /** More labels for every check of a project, beside browser, device, viewport, os and playwright. */
+    readonly labels?: PerProject<Readonly<Record<string, string>>>;
+    /** The commit tested. Default `ATLAS_SHA`, then the CI's own variables (`GITHUB_SHA`…), then git. */
+    readonly sha?: string;
+    /** The branch tested. Default `ATLAS_BRANCH`, then `GITHUB_HEAD_REF`, `GITHUB_REF_NAME`…, then git. */
+    readonly branch?: string;
+    /** Where to read the CI run. Default the GitHub Actions run (or the CI's own run URL variable). */
+    readonly runUrl?: string;
+    /** The spec a test belongs to, relative to the repository. Default: the `.feature` of a playwright-bdd test, else the test file. */
+    readonly specPath?: (test: TestCase) => string | undefined;
+    /** Paths are relative to this directory. Default the git root above Playwright's `rootDir`, else `rootDir`. */
+    readonly rootDir?: string;
+    /** Which results upload their attachments (videos, screenshots, traces, output): `all`, `failures` or `none`. Default `all`. */
+    readonly attachments?: AttachmentMode;
+    /** A larger file is not uploaded; the check says so in an annotation. Default 50 MiB. */
+    readonly maxAttachmentBytes?: number;
+    /** The most timeline steps recorded per result. Default 500. */
+    readonly maxSteps?: number;
+    /** Record the project's spec files (path, domain, kind, title) in every layer, so a server can group checks by spec without a published spec set. Default true. */
+    readonly specs?: boolean;
+    /** Send what has finished this often, in ms. Default 5000 (every layer repeats the spec list). */
+    readonly flushMs?: number;
+    /** Send at once when this many checks are waiting. Default 50 (their attachments are held in memory until sent). */
+    readonly batchSize?: number;
+    /** Tries for each layer at the end of the run. Default 5. */
+    readonly attempts?: number;
+    /** Print nothing, not even the summary line. */
+    readonly quiet?: boolean;
+    /** Where messages go. Default: the summary to standard output, problems to standard error. */
+    readonly log?: (line: string) => void;
+    /** The environment variables to read. Default `process.env`. */
+    readonly env?: Readonly<Record<string, string | undefined>>;
+};
+/**
+ * The Playwright Test reporter of Atlas. Add it beside your console reporter; it streams each test as `running` when
+ * it starts and with its full evidence when its last try ends, one stream of layers per Playwright project, and
+ * prints one summary line when the run ends. It never fails or slows the run on account of Atlas.
+ *
+ * @example
+ * ```ts
+ * // playwright.config.ts
+ * import { defineConfig } from '@playwright/test';
+ *
+ * export default defineConfig({
+ *   reporter: [['list'], ['@crvouga/atlas/playwright-reporter', { project: 'checkout', producer: 'e2e-web' }]],
+ *   use: { video: 'retain-on-failure', trace: 'retain-on-failure', screenshot: 'only-on-failure' }
+ * });
+ * ```
+ */
+export default class AtlasPlaywrightReporter implements PlaywrightReporter {
+    private readonly options;
+    private config;
+    private store;
+    private label;
+    private root;
+    private identity;
+    private readonly streams;
+    private readonly identities;
+    private readonly specPaths;
+    private readonly running;
+    private readonly pending;
+    private warned;
+    private recorded;
+    /** Playwright passes the options given in `playwright.config.ts`. */
+    constructor(options?: AtlasPlaywrightReporterOptions);
+    /** This reporter prints only a summary line, so Playwright keeps its own console output. */
+    printsToStdio(): boolean;
+    private say;
+    /** Said once per run: Atlas problems never flood the test output. */
+    private warn;
+    /** Resolves where layers go, where the run came from, and the directory paths are relative to. Never throws. */
+    onBegin(config: FullConfig, _suite: Suite): void;
+    private specPathOf;
+    private titleOf;
+    private specsOf;
+    private streamOf;
+    private identityOf;
+    private send;
+    /** Reports the test as `running`, so the report shows it while it runs. */
+    onTestBegin(test: TestCase, _result: TestResult): void;
+    /** On a test's last try, collects its evidence (reading its attached files) and reports it. A try Playwright will repeat leaves the test `running`. */
+    onTestEnd(test: TestCase, result: TestResult): void;
+    /** Waits for every result, marks tests the run did not finish as `not-run`, sends the rest, and prints one summary line. */
+    onEnd(): Promise<void>;
+}