@qartisan/playwright-loupe 0.0.0-stage → 0.0.1

package/dist/config/validate.js

@@ -0,0 +1,231 @@
+import { CATEGORY_MODES, CATEGORY_TARGETS, SCREENSHOT_VIEWS, THEMES } from './types.js';
+const COLOR = /^#[0-9a-fA-F]{6}$/;
+/** What a tag prefix cannot contain: `@layer:api` has the prefix `layer`. */
+const INVALID_PREFIX = /[@:\s]/;
+function describe(value) {
+    if (value === null)
+        return 'null';
+    if (value === undefined)
+        return 'undefined';
+    if (Array.isArray(value))
+        return 'an array';
+    if (value instanceof RegExp)
+        return `a RegExp (${String(value)})`;
+    if (typeof value === 'string')
+        return JSON.stringify(value.length > 40 ? `${value.slice(0, 40)}…` : value);
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    if (typeof value === 'function')
+        return 'a function';
+    return `an ${typeof value}`;
+}
+function isPlainObject(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function join(path, key) {
+    return path === '' ? key : `${path}.${key}`;
+}
+/** Optimal string alignment distance: Levenshtein plus adjacent transpositions (`titel` → `title` is 1). */
+export function editDistance(a, b) {
+    const d = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array(b.length).fill(0)]);
+    for (let j = 1; j <= b.length; j++)
+        d[0][j] = j;
+    for (let i = 1; i <= a.length; i++) {
+        for (let j = 1; j <= b.length; j++) {
+            const row = d[i];
+            const previous = d[i - 1];
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            row[j] = Math.min(previous[j] + 1, row[j - 1] + 1, previous[j - 1] + cost);
+            if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+                row[j] = Math.min(row[j], d[i - 2][j - 2] + 1);
+            }
+        }
+    }
+    return d[a.length][b.length];
+}
+/** The closest known key, when it is close enough to be a typo. */
+export function suggestKey(key, known) {
+    let best = null;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (const candidate of known) {
+        const distance = candidate.toLowerCase() === key.toLowerCase() ? 0 : editDistance(key, candidate);
+        if (distance < bestDistance) {
+            best = candidate;
+            bestDistance = distance;
+        }
+    }
+    const tolerance = key.length <= 3 ? 1 : key.length <= 6 ? 2 : 3;
+    return bestDistance <= tolerance ? best : null;
+}
+function object(fields, ctx) {
+    return (value, path, errors) => {
+        if (!isPlainObject(value)) {
+            errors.push(`${ctx.source}: ${path || 'the config'} must be an object, got ${describe(value)}`);
+            return;
+        }
+        const known = Object.keys(fields);
+        for (const [key, child] of Object.entries(value)) {
+            const check = fields[key];
+            if (check) {
+                if (child !== undefined)
+                    check(child, join(path, key), errors);
+                continue;
+            }
+            const suggestion = suggestKey(key, known);
+            const hint = suggestion ? `Did you mean "${suggestion}"?` : `Known options: ${known.join(', ')}.`;
+            errors.push(`${ctx.source}: ${join(path, key)} is not a known option. ${hint}`);
+        }
+    };
+}
+function fail(ctx, path, expected, value, errors) {
+    errors.push(`${ctx.source}: ${path} must be ${expected}, got ${describe(value)}`);
+}
+function nonEmptyString(ctx) {
+    return (value, path, errors) => {
+        if (typeof value !== 'string' || value.trim() === '')
+            fail(ctx, path, 'a non-empty string', value, errors);
+    };
+}
+function oneOf(values, ctx) {
+    return (value, path, errors) => {
+        if (typeof value !== 'string' || !values.includes(value)) {
+            fail(ctx, path, `one of ${values.map((item) => `"${item}"`).join(', ')}`, value, errors);
+        }
+    };
+}
+function boolean(ctx) {
+    return (value, path, errors) => {
+        if (typeof value !== 'boolean')
+            fail(ctx, path, 'a boolean', value, errors);
+    };
+}
+function color(ctx) {
+    return (value, path, errors) => {
+        if (typeof value !== 'string' || !COLOR.test(value))
+            fail(ctx, path, 'a #rrggbb color', value, errors);
+    };
+}
+function regexps(ctx) {
+    return (value, path, errors) => {
+        const expected = 'a RegExp or an array of RegExp';
+        if (value instanceof RegExp)
+            return;
+        if (!Array.isArray(value))
+            return fail(ctx, path, expected, value, errors);
+        if (value.length === 0)
+            return fail(ctx, path, `${expected} (not empty)`, value, errors);
+        value.forEach((item, index) => {
+            if (!(item instanceof RegExp))
+                fail(ctx, `${path}[${index}]`, 'a RegExp', item, errors);
+        });
+    };
+}
+function arrayOf(item, ctx) {
+    return (value, path, errors) => {
+        if (!Array.isArray(value))
+            return fail(ctx, path, 'an array', value, errors);
+        value.forEach((child, index) => item(child, `${path}[${index}]`, errors));
+    };
+}
+function values(ctx) {
+    return (value, path, errors) => {
+        if (!Array.isArray(value))
+            return fail(ctx, path, 'an array of non-empty strings', value, errors);
+        const seen = new Set();
+        value.forEach((item, index) => {
+            if (typeof item !== 'string' || item.trim() === '')
+                return fail(ctx, `${path}[${index}]`, 'a non-empty string', item, errors);
+            if (seen.has(item))
+                errors.push(`${ctx.source}: ${path}[${index}] repeats the value "${item}"`);
+            seen.add(item);
+        });
+    };
+}
+function tagPrefix(ctx) {
+    return (value, path, errors) => {
+        if (typeof value !== 'string' || value === '' || INVALID_PREFIX.test(value)) {
+            fail(ctx, path, "a tag prefix without '@', ':' or spaces (\"layer\" for @layer:api)", value, errors);
+        }
+    };
+}
+function dimension(ctx) {
+    const tag = object({ name: nonEmptyString(ctx), from: () => { }, prefix: tagPrefix(ctx), values: values(ctx) }, ctx);
+    const annotation = object({ name: nonEmptyString(ctx), from: () => { }, type: nonEmptyString(ctx), values: values(ctx) }, ctx);
+    return (value, path, errors) => {
+        if (!isPlainObject(value))
+            return fail(ctx, path, 'an object', value, errors);
+        const required = value['from'] === 'tag' ? ['name', 'prefix'] : value['from'] === 'annotation' ? ['name', 'type'] : null;
+        if (!required)
+            return fail(ctx, `${path}.from`, '"tag" or "annotation"', value['from'], errors);
+        for (const key of required) {
+            if (value[key] === undefined)
+                errors.push(`${ctx.source}: ${join(path, key)} is required when from is "${String(value['from'])}"`);
+        }
+        (value['from'] === 'tag' ? tag : annotation)(value, path, errors);
+    };
+}
+function categoryRule(ctx) {
+    const fields = object({ name: nonEmptyString(ctx), match: regexps(ctx), on: oneOf(CATEGORY_TARGETS, ctx), color: color(ctx) }, ctx);
+    return (value, path, errors) => {
+        fields(value, path, errors);
+        if (!isPlainObject(value))
+            return;
+        for (const key of ['name', 'match']) {
+            if (value[key] === undefined)
+                errors.push(`${ctx.source}: ${join(path, key)} is required`);
+        }
+    };
+}
+/** Checks across the items of one list: unique dimension names, prefixes and annotation types. */
+function checkDimensionList(definitions, ctx, errors) {
+    if (!Array.isArray(definitions))
+        return;
+    const seen = new Map();
+    definitions.forEach((definition, index) => {
+        if (!isPlainObject(definition))
+            return;
+        const keys = [
+            ['name', definition['name']],
+            [definition['from'] === 'tag' ? 'prefix' : 'type', definition['from'] === 'tag' ? definition['prefix'] : definition['type']],
+        ];
+        for (const [field, value] of keys) {
+            if (typeof value !== 'string')
+                continue;
+            const key = `${field === 'name' ? 'name' : `${String(definition['from'])}:${field}`}\0${value}`;
+            const first = seen.get(key);
+            if (first !== undefined) {
+                errors.push(`${ctx.source}: dimensions.definitions[${index}].${field} "${value}" is already used by dimensions.definitions[${first}]`);
+            }
+            else {
+                seen.set(key, index);
+            }
+        }
+    });
+}
+/**
+ * Validates one config layer. `source` names it in messages (`loupe.config.ts`,
+ * `reporter options`). `configFile` is only accepted in inline options.
+ */
+export function validateConfig(value, source, options = {}) {
+    const ctx = { source };
+    const errors = [];
+    const fields = {
+        outputFolder: nonEmptyString(ctx),
+        title: nonEmptyString(ctx),
+        environment: nonEmptyString(ctx),
+        categories: object({ mode: oneOf(CATEGORY_MODES, ctx), rules: arrayOf(categoryRule(ctx), ctx), uncategorized: nonEmptyString(ctx) }, ctx),
+        dimensions: object({ auto: boolean(ctx), definitions: arrayOf(dimension(ctx), ctx) }, ctx),
+        screenshots: object({ defaultView: oneOf(SCREENSHOT_VIEWS, ctx) }, ctx),
+        theme: oneOf(THEMES, ctx),
+    };
+    if (options.allowConfigFile)
+        fields['configFile'] = nonEmptyString(ctx);
+    object(fields, ctx)(value, '', errors);
+    if (isPlainObject(value) && isPlainObject(value['dimensions'])) {
+        checkDimensionList(value['dimensions']['definitions'], ctx, errors);
+    }
+    return errors;
+}

package/dist/core/attachments.d.ts

@@ -0,0 +1,22 @@
+import type { AttachmentKind, ComparisonRole } from '../schema/v1.js';
+/** Text bodies up to this size (UTF-8 bytes) are inlined in the JSON; larger ones are written to files. */
+export declare const INLINE_TEXT_LIMIT: number;
+export declare function isTextContentType(contentType: string): boolean;
+export declare function attachmentKind(name: string, contentType: string): AttachmentKind;
+/**
+ * toHaveScreenshot / toMatchSnapshot attach images named `<name>-expected.png`,
+ * `<name>-actual.png` and `<name>-diff.png`. The group is the name without the
+ * role suffix (`<name>.png`), shared by the three images.
+ */
+export declare function comparisonOf(name: string, contentType: string): {
+    group: string;
+    role: ComparisonRole;
+} | null;
+/** File extension for a content type, '.bin' when unknown. */
+export declare function extensionFor(contentType: string): string;
+/** Turns an attachment name into a safe single-segment file name. */
+export declare function safeFileName(name: string): string;
+/** File name for a body attachment: the safe name, plus an extension from the content type when it has none. */
+export declare function bodyFileName(name: string, contentType: string): string;
+/** Returns `fileName`, or `name-1.ext`, `name-2.ext`, ... when taken; records the result in `taken`. */
+export declare function uniqueFileName(fileName: string, taken: Set<string>): string;

package/dist/core/attachments.js

@@ -0,0 +1,79 @@
+/** Text bodies up to this size (UTF-8 bytes) are inlined in the JSON; larger ones are written to files. */
+export const INLINE_TEXT_LIMIT = 4 * 1024;
+const TEXT_TYPE = /^(?:text\/|application\/(?:json|xml|javascript)\b|application\/[\w.+-]+\+(?:json|xml)\b)/i;
+export function isTextContentType(contentType) {
+    return TEXT_TYPE.test(contentType);
+}
+export function attachmentKind(name, contentType) {
+    const type = contentType.toLowerCase();
+    if (type.startsWith('image/'))
+        return 'screenshot';
+    if (type.startsWith('video/'))
+        return 'video';
+    if (name === 'trace' || (type === 'application/zip' && /trace/i.test(name)))
+        return 'trace';
+    if (isTextContentType(type))
+        return 'text';
+    return 'other';
+}
+const COMPARISON_NAME = /^(.+)-(expected|actual|diff)(\.[a-z0-9]+)?$/i;
+/**
+ * toHaveScreenshot / toMatchSnapshot attach images named `<name>-expected.png`,
+ * `<name>-actual.png` and `<name>-diff.png`. The group is the name without the
+ * role suffix (`<name>.png`), shared by the three images.
+ */
+export function comparisonOf(name, contentType) {
+    if (!contentType.toLowerCase().startsWith('image/'))
+        return null;
+    const match = COMPARISON_NAME.exec(name);
+    if (!match)
+        return null;
+    const [, base = '', role = '', extension = ''] = match;
+    return { group: base + extension, role: role.toLowerCase() };
+}
+const EXTENSIONS = {
+    'image/png': '.png',
+    'image/jpeg': '.jpg',
+    'image/gif': '.gif',
+    'image/webp': '.webp',
+    'image/svg+xml': '.svg',
+    'video/webm': '.webm',
+    'video/mp4': '.mp4',
+    'application/zip': '.zip',
+    'application/json': '.json',
+    'application/xml': '.xml',
+    'text/plain': '.txt',
+    'text/html': '.html',
+    'text/markdown': '.md',
+    'text/csv': '.csv',
+};
+/** File extension for a content type, '.bin' when unknown. */
+export function extensionFor(contentType) {
+    const type = contentType.toLowerCase().split(';')[0]?.trim() ?? '';
+    return EXTENSIONS[type] ?? (isTextContentType(type) ? '.txt' : '.bin');
+}
+/** Turns an attachment name into a safe single-segment file name. */
+export function safeFileName(name) {
+    const safe = name
+        .replace(/[^\w.@+-]+/g, '-')
+        .replace(/^[.-]+/, '')
+        .slice(0, 100);
+    return safe || 'attachment';
+}
+/** File name for a body attachment: the safe name, plus an extension from the content type when it has none. */
+export function bodyFileName(name, contentType) {
+    const safe = safeFileName(name);
+    return /\.[a-z0-9]{1,8}$/i.test(safe) ? safe : safe + extensionFor(contentType);
+}
+/** Returns `fileName`, or `name-1.ext`, `name-2.ext`, ... when taken; records the result in `taken`. */
+export function uniqueFileName(fileName, taken) {
+    let candidate = fileName;
+    if (taken.has(candidate)) {
+        const dot = fileName.lastIndexOf('.');
+        const [stem, extension] = dot > 0 ? [fileName.slice(0, dot), fileName.slice(dot)] : [fileName, ''];
+        for (let i = 1; taken.has(candidate); i++)
+            candidate = `${stem}-${i}${extension}`;
+    }
+    taken.add(candidate);
+    return candidate;
+}

package/dist/core/build.d.ts

@@ -0,0 +1,34 @@
+import type { FullConfig, FullResult, Suite, TestError, TestStep } from '@playwright/test/reporter';
+import type { LoupeReport, RunScope } from '../schema/v1.js';
+import { type CategoriesOptions, type ErrorText } from './categories.js';
+import { type DimensionsOptions } from './dimensions.js';
+/** Folder, inside the report folder, that holds the copied attachments. */
+export declare const DATA_FOLDER = "data";
+export interface BuildOptions {
+    runId: string;
+    generatorVersion: string;
+    /** Absolute report folder; attachments are copied under `<outputFolder>/data/`. */
+    outputFolder: string;
+    env: Readonly<Record<string, string | undefined>>;
+    scopeOverride: RunScope | null;
+    /** `run.environment.name`, from the config (`environment`, `LOUPE_ENV`). */
+    environmentName: string | null;
+    categories?: CategoriesOptions;
+    dimensions?: DimensionsOptions;
+    /** Errors received through `onError`, with the project of the worker when Playwright gives it. */
+    runErrors?: ReadonlyArray<{
+        error: TestError;
+        project: string | null;
+    }>;
+}
+/**
+ * Titles of the failing steps leading to `error`, outermost first: the path to
+ * the deepest step that ended with the same message. Empty when no step did.
+ */
+export declare function failingSteps(steps: readonly TestStep[], error: TestError): string[];
+/**
+ * Text an error is categorized on. `steps`: titles of the failing steps, outermost first.
+ * Run errors lose the `merge-reports` tag prefix, so rules match the same text merged or not.
+ */
+export declare function errorText(message: string, stack: string | null, steps: readonly string[], runError: boolean): ErrorText;
+export declare function buildReport(config: FullConfig, suite: Suite, result: FullResult, options: BuildOptions): Promise<LoupeReport>;

package/dist/core/build.js

@@ -0,0 +1,300 @@
+import { copyFile, mkdir, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { INLINE_TEXT_LIMIT, attachmentKind, bodyFileName, comparisonOf, isTextContentType, safeFileName, uniqueFileName, } from './attachments.js';
+import { DEFAULT_CATEGORIES, createCategorizer } from './categories.js';
+import { DEFAULT_DIMENSIONS, createDimensions } from './dimensions.js';
+import { computeTestId, relativePosix } from './identity.js';
+import { detectEnvironment, detectGit } from './metadata.js';
+import { collectOutput } from './output.js';
+import { esmImportLocation, isUsableLocation } from './runErrors.js';
+import { detectScopeReasons, resolveScope } from './scope.js';
+import { errorSignature, stripAnsi, stripMergeTagPrefix } from './signature.js';
+/** Folder, inside the report folder, that holds the copied attachments. */
+export const DATA_FOLDER = 'data';
+const OUTCOMES = {
+    expected: 'passed',
+    unexpected: 'failed',
+    flaky: 'flaky',
+    skipped: 'skipped',
+};
+/** Copies or writes attachments into the report folder, with collision-safe names per folder. */
+class AttachmentStore {
+    outputFolder;
+    taken = new Map();
+    constructor(outputFolder) {
+        this.outputFolder = outputFolder;
+    }
+    /** Removes attachments left by a previous report in the same folder. */
+    async reset() {
+        await rm(path.join(this.outputFolder, DATA_FOLDER), { recursive: true, force: true });
+    }
+    async add(folder, attachment) {
+        const { name, contentType } = attachment;
+        const result = {
+            name,
+            contentType,
+            kind: attachmentKind(name, contentType),
+            path: null,
+            body: null,
+            comparison: comparisonOf(name, contentType),
+        };
+        if (attachment.path) {
+            result.path = await this.store(folder, safeFileName(path.basename(attachment.path)), (target) => copyFile(attachment.path, target));
+        }
+        else if (attachment.body) {
+            const body = attachment.body;
+            if (isTextContentType(contentType) && body.byteLength <= INLINE_TEXT_LIMIT) {
+                result.body = body.toString('utf8');
+            }
+            else {
+                result.path = await this.store(folder, bodyFileName(name, contentType), (target) => writeFile(target, body));
+            }
+        }
+        return result;
+    }
+    /** Writes one file and returns its report-relative path, or null when the source file is missing. */
+    async store(folder, fileName, write) {
+        const taken = this.taken.get(folder) ?? new Set();
+        this.taken.set(folder, taken);
+        const unique = uniqueFileName(fileName, taken);
+        const target = path.join(this.outputFolder, ...folder.split('/'), unique);
+        await mkdir(path.dirname(target), { recursive: true });
+        try {
+            await write(target);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return null;
+            throw error;
+        }
+        return `${folder}/${unique}`;
+    }
+}
+/** Playwright reports -1 for steps and attempts that never finished. */
+function toMs(duration) {
+    return Math.max(0, Math.round(duration));
+}
+function emptyStats() {
+    return { total: 0, passed: 0, failed: 0, flaky: 0, skipped: 0 };
+}
+function countOutcome(stats, outcome) {
+    stats.total++;
+    stats[outcome]++;
+}
+function toAnnotation(annotation) {
+    return { type: annotation.type, description: annotation.description ?? null };
+}
+function isDefaultGrep(grep) {
+    return grep instanceof RegExp && grep.source === '.*' && grep.flags === '';
+}
+/** `test.only` / `describe.only` leave Playwright's internal `_only` flag on the node or an ancestor. */
+function isFocused(test) {
+    for (let node = test; node; node = node.parent) {
+        if (node._only === true)
+            return true;
+    }
+    return false;
+}
+/**
+ * Titles of the failing steps leading to `error`, outermost first: the path to
+ * the deepest step that ended with the same message. Empty when no step did.
+ */
+export function failingSteps(steps, error) {
+    const message = error.message ?? error.value;
+    if (message === undefined)
+        return [];
+    for (const step of [...steps].reverse()) {
+        if (!step.error || (step.error.message ?? step.error.value) !== message)
+            continue;
+        return [step.title, ...failingSteps(step.steps, error)];
+    }
+    // A step may fail with a wrapped message while one of its children has the exact one.
+    for (const step of [...steps].reverse()) {
+        const inner = failingSteps(step.steps, error);
+        if (inner.length > 0)
+            return [step.title, ...inner];
+    }
+    return [];
+}
+/**
+ * Text an error is categorized on. `steps`: titles of the failing steps, outermost first.
+ * Run errors lose the `merge-reports` tag prefix, so rules match the same text merged or not.
+ */
+export function errorText(message, stack, steps, runError) {
+    return {
+        message: runError ? stripMergeTagPrefix(message) : message,
+        stack: runError && stack !== null ? stripMergeTagPrefix(stack) : stack,
+        step: steps.length > 0 ? steps.join('\n') : null,
+    };
+}
+export async function buildReport(config, suite, result, options) {
+    const rootDir = config.rootDir;
+    const store = new AttachmentStore(options.outputFolder);
+    const categorizer = createCategorizer(options.categories ?? DEFAULT_CATEGORIES);
+    const dimensionSet = createDimensions(options.dimensions ?? DEFAULT_DIMENSIONS);
+    const categories = new Set();
+    const usedDimensions = new Set();
+    // `<anonymous>` and other non-paths are not locations.
+    const toLocation = (location) => isUsableLocation(location)
+        ? { file: relativePosix(rootDir, location.file), line: location.line, column: location.column }
+        : null;
+    /**
+     * `steps`: titles of the failing steps leading to the error, outermost first.
+     * `runError`: the `merge-reports` tag prefix is ignored by categories and the signature, kept in `message` and `stack`.
+     */
+    const toError = (error, steps = [], location = error.location, runError = false) => {
+        const message = stripAnsi(error.message ?? error.value ?? '');
+        const stack = error.stack ? stripAnsi(error.stack) : null;
+        const category = categorizer.categorize(errorText(message, stack, steps, runError));
+        categories.add(category);
+        return {
+            message,
+            stack,
+            location: toLocation(location),
+            snippet: error.snippet ? stripAnsi(error.snippet) : null,
+            signature: errorSignature(message, { runError }),
+            category,
+        };
+    };
+    const toStep = (step, parents) => {
+        const chain = [...parents, step.title];
+        return {
+            title: step.title,
+            // `subtitle` exists from Playwright 1.61; older versions keep the target in the title.
+            subtitle: step.subtitle ?? null,
+            category: step.category,
+            durationMs: toMs(step.duration),
+            error: step.error ? toError(step.error, chain) : null,
+            location: toLocation(step.location),
+            steps: step.steps.map((child) => toStep(child, chain)),
+        };
+    };
+    const toAttempt = async (attempt, folder) => {
+        const attachments = [];
+        for (const attachment of attempt.attachments) {
+            attachments.push(await store.add(`${folder}/${attempt.retry}`, attachment));
+        }
+        return {
+            index: attempt.retry,
+            status: attempt.status,
+            startedAt: attempt.startTime.toISOString(),
+            durationMs: toMs(attempt.duration),
+            workerIndex: attempt.workerIndex,
+            errors: attempt.errors.map((error) => toError(error, failingSteps(attempt.steps, error))),
+            steps: attempt.steps.map((step) => toStep(step, [])),
+            attachments,
+            annotations: attempt.annotations.map(toAnnotation),
+            stdout: collectOutput(attempt.stdout),
+            stderr: collectOutput(attempt.stderr),
+        };
+    };
+    await store.reset();
+    const tests = [];
+    for (const test of suite.allTests()) {
+        // titlePath() is ['', project, file, ...describes, title]; anonymous describes are omitted.
+        const suitePath = test.titlePath().slice(3, -1);
+        const project = test.parent.project()?.name ?? '';
+        const file = relativePosix(rootDir, test.location.file);
+        const id = computeTestId(project, file, [...suitePath, test.title]);
+        const folder = `${DATA_FOLDER}/${id}${test.repeatEachIndex > 0 ? `-r${test.repeatEachIndex}` : ''}`;
+        const attempts = [];
+        for (const attempt of test.results)
+            attempts.push(await toAttempt(attempt, folder));
+        const annotations = [
+            ...test.annotations.map(toAnnotation),
+            ...attempts.flatMap((attempt) => attempt.annotations),
+        ];
+        const dimensions = dimensionSet.of(test.tags, annotations);
+        for (const name of Object.keys(dimensions))
+            usedDimensions.add(name);
+        // A failing attempt did not end as expected (a test.fail() failing as expected is not one).
+        const lastFailing = attempts.findLast((attempt) => attempt.status !== test.expectedStatus && attempt.status !== 'skipped');
+        const firstError = lastFailing?.errors[0];
+        tests.push({
+            id,
+            repeatEachIndex: test.repeatEachIndex,
+            project,
+            file,
+            line: test.location.line,
+            column: test.location.column,
+            suitePath,
+            title: test.title,
+            tags: [...test.tags],
+            annotations: test.annotations.map(toAnnotation),
+            outcome: OUTCOMES[test.outcome()],
+            expectedStatus: test.expectedStatus,
+            durationMs: attempts.reduce((total, attempt) => total + attempt.durationMs, 0),
+            dimensions,
+            category: firstError?.category ?? null,
+            errorSignature: firstError?.signature ?? null,
+            attempts,
+        });
+    }
+    const projectStats = new Map();
+    const runStats = emptyStats();
+    for (const test of tests) {
+        countOutcome(runStats, test.outcome);
+        const stats = projectStats.get(test.project) ?? emptyStats();
+        projectStats.set(test.project, stats);
+        countOutcome(stats, test.outcome);
+    }
+    const projects = [];
+    for (const projectSuite of suite.suites) {
+        const project = projectSuite.project();
+        if (!project || projects.some((known) => known.name === project.name))
+            continue;
+        projects.push({
+            name: project.name,
+            testDir: relativePosix(rootDir, project.testDir),
+            retries: project.retries,
+            timeoutMs: project.timeout,
+            stats: projectStats.get(project.name) ?? emptyStats(),
+        });
+    }
+    // Newer Playwright versions expose more about the CLI; read them when present.
+    const extra = config;
+    const detected = detectScopeReasons({
+        argv: extra.argv ?? process.argv,
+        configGrep: !isDefaultGrep(config.grep) || config.grepInvert !== null,
+        shard: config.shard !== null,
+        projects: config.projects.map((project) => ({
+            name: project.name,
+            dependencies: project.dependencies,
+            teardown: project.teardown,
+        })),
+        filteredProjects: extra.filteredProjects?.map((project) => project.name),
+        runProjects: projects.map((project) => project.name),
+        only: suite.allTests().some(isFocused),
+    });
+    const actualWorkers = config.metadata['actualWorkers'];
+    const errors = [];
+    for (const { error, project } of options.runErrors ?? []) {
+        const message = stripAnsi(error.message ?? error.value ?? '');
+        const location = isUsableLocation(error.location) ? error.location : ((await esmImportLocation(message)) ?? undefined);
+        errors.push({ ...toError(error, [], location, true), project });
+    }
+    return {
+        schemaVersion: 1,
+        generator: { name: 'playwright-loupe', version: options.generatorVersion },
+        run: {
+            id: options.runId,
+            startedAt: result.startTime.toISOString(),
+            durationMs: toMs(result.duration),
+            status: result.status,
+            ...resolveScope(detected, options.scopeOverride),
+            playwrightVersion: config.version,
+            workers: typeof actualWorkers === 'number' ? actualWorkers : config.workers,
+            shard: config.shard ? { current: config.shard.current, total: config.shard.total } : null,
+            environment: detectEnvironment(options.env, options.environmentName, process.platform, process.arch, process.version),
+            git: detectGit(config.metadata, options.env),
+            excluded: null,
+            notes: [],
+            stats: runStats,
+            errors,
+        },
+        projects,
+        tests,
+        categories: categorizer.definitions(categories),
+        dimensions: dimensionSet.definitions(usedDimensions),
+    };
+}