@mindlace/chreode 0.1.0 → 0.2.0

package/dist/flakes/gh.js

@@ -0,0 +1,74 @@
+import { defaultExec, lines } from '../run/exec.js';
+import { FLAKE_LABEL, OCCURRENCE_MARKER } from './ledger.js';
+const LABEL_DESCRIPTION = 'A test that failed, then passed on retry (chreode)';
+const LABEL_COLOR = 'D93F0B';
+/** The ledger's GitHub side over `gh`. Every call is argv (no shell), so test titles and
+ *  error text reach GitHub verbatim. */
+export function ghLedgerDeps(exec = defaultExec) {
+    let labelReady = false;
+    const ensureLabel = () => {
+        if (labelReady)
+            return;
+        const labels = JSON.parse(exec('gh', ['label', 'list', '--limit', '1000', '--json', 'name']));
+        if (!labels.some((l) => l.name === FLAKE_LABEL)) {
+            exec('gh', [
+                'label',
+                'create',
+                FLAKE_LABEL,
+                '--description',
+                LABEL_DESCRIPTION,
+                '--color',
+                LABEL_COLOR
+            ]);
+        }
+        labelReady = true;
+    };
+    return {
+        listOpenFlakeIssues() {
+            // A label filter, not a title search: it does not depend on search-index lag.
+            const raw = JSON.parse(exec('gh', [
+                'issue',
+                'list',
+                '--label',
+                FLAKE_LABEL,
+                '--state',
+                'open',
+                '--limit',
+                '1000',
+                '--json',
+                'number,title,labels,url'
+            ]));
+            return raw.map((i) => ({
+                number: i.number,
+                title: i.title,
+                url: i.url,
+                labels: i.labels.map((l) => l.name)
+            }));
+        },
+        countOccurrenceComments(issue) {
+            const raw = JSON.parse(exec('gh', ['issue', 'view', String(issue), '--json', 'comments']));
+            return raw.comments.filter((c) => c.body.includes(OCCURRENCE_MARKER)).length;
+        },
+        createIssue(title, body) {
+            ensureLabel();
+            const out = exec('gh', [
+                'issue',
+                'create',
+                '--title',
+                title,
+                '--body',
+                body,
+                '--label',
+                FLAKE_LABEL
+            ]);
+            const url = lines(out).at(-1) ?? '';
+            const m = /\/issues\/(\d+)$/.exec(url);
+            if (!m)
+                throw new Error(`gh issue create printed no issue URL: ${out.trim()}`);
+            return { number: Number(m[1]), title, url, labels: [FLAKE_LABEL] };
+        },
+        commentIssue(issue, body) {
+            exec('gh', ['issue', 'comment', String(issue), '--body', body]);
+        }
+    };
+}

package/dist/flakes/ledger.d.ts

@@ -0,0 +1,53 @@
+import type { ResolvedFlakes } from '../config/types.js';
+import { type FlakeEvent } from './log.js';
+export declare const FLAKE_LABEL = "flake";
+export declare const OCCURRENCE_MARKER = "<!-- chreode:flake-occurrence -->";
+export declare const ISSUE_TITLE_MAX = 256;
+export interface RunContext {
+    branch: string;
+    sha: string;
+}
+export interface FlakeIssue {
+    number: number;
+    title: string;
+    url: string;
+    labels: string[];
+}
+/** The GitHub side, injected: see gh.ts for the real one. */
+export interface FlakeLedgerDeps {
+    /** Open issues labelled FLAKE_LABEL. */
+    listOpenFlakeIssues(): FlakeIssue[];
+    /** Comments on the issue that carry OCCURRENCE_MARKER. */
+    countOccurrenceComments(issue: number): number;
+    /** Creates an issue labelled FLAKE_LABEL. */
+    createIssue(title: string, body: string): FlakeIssue;
+    commentIssue(issue: number, body: string): void;
+}
+export interface LedgerEntry {
+    number: number;
+    title: string;
+    url: string;
+    /** Occurrences so far: 1 (the issue) + marker comments. */
+    count: number;
+}
+export interface LedgerResult {
+    filed: LedgerEntry[];
+    bumped: LedgerEntry[];
+    escalations: LedgerEntry[];
+}
+export declare function firstLine(err: unknown): string;
+/** A GitHub call failed partway: `partial` was recorded, `remaining` was not. */
+export declare class LedgerError extends Error {
+    readonly partial: LedgerResult;
+    readonly remaining: FlakeEvent[];
+    constructor(partial: LedgerResult, remaining: FlakeEvent[], cause: unknown);
+}
+export declare function issueTitle(event: FlakeEvent): string;
+export declare function issueBody(event: FlakeEvent, ctx: RunContext, config: ResolvedFlakes): string;
+export declare function occurrenceBody(event: FlakeEvent, ctx: RunContext): string;
+/**
+ * One open issue per flaking test (exact title match); each later sighting adds a marker
+ * comment. An issue at `threshold` occurrences without the snooze label is an escalation.
+ * Any GitHub failure throws LedgerError naming what was and was not recorded.
+ */
+export declare function processFlakeEvents(events: readonly FlakeEvent[], ctx: RunContext, config: ResolvedFlakes, deps: FlakeLedgerDeps): LedgerResult;

package/dist/flakes/ledger.js

@@ -0,0 +1,108 @@
+import { dedupeEvents } from './log.js';
+export const FLAKE_LABEL = 'flake';
+export const OCCURRENCE_MARKER = '<!-- chreode:flake-occurrence -->';
+export const ISSUE_TITLE_MAX = 256;
+export function firstLine(err) {
+    return (err instanceof Error ? err.message : String(err)).split('\n')[0] ?? '';
+}
+/** A GitHub call failed partway: `partial` was recorded, `remaining` was not. */
+export class LedgerError extends Error {
+    partial;
+    remaining;
+    constructor(partial, remaining, cause) {
+        super(firstLine(cause), { cause });
+        this.partial = partial;
+        this.remaining = remaining;
+        this.name = 'LedgerError';
+    }
+}
+export function issueTitle(event) {
+    return `flake(${event.kind}): ${event.file} › ${event.title}`.slice(0, ISSUE_TITLE_MAX).trimEnd();
+}
+function longestRun(text) {
+    return Math.max(0, ...(text.match(/`+/g) ?? []).map((run) => run.length));
+}
+/** Inline code span that survives backticks in `text`; keeps @mentions and #refs inert. */
+function codeSpan(text) {
+    const fence = '`'.repeat(longestRun(text) + 1);
+    const pad = text.startsWith('`') || text.endsWith('`') ? ' ' : '';
+    return `${fence}${pad}${text}${pad}${fence}`;
+}
+/** Fenced block whose fence is longer than any backtick run inside (minimum 3). */
+function codeFence(text) {
+    const fence = '`'.repeat(Math.max(3, longestRun(text) + 1));
+    return [fence, text, fence];
+}
+function details(event, ctx) {
+    const where = event.project === '' ? event.runner : `${event.runner}, project ${event.project}`;
+    return [
+        `- **Test:** ${codeSpan(`${event.file} › ${event.title}`)} (${where})`,
+        `- **Observed:** ${event.at} on \`${ctx.branch}\` @ ${event.sha ?? ctx.sha}`,
+        ...(event.tracePath ? [`- **First-attempt trace:** \`${event.tracePath}\``] : []),
+        '',
+        '**First-attempt error:**',
+        ...codeFence(event.firstAttemptError)
+    ].join('\n');
+}
+export function issueBody(event, ctx, config) {
+    return [
+        'Filed by chreode flake tracking: this test failed, then passed on retry.',
+        '',
+        details(event, ctx),
+        '',
+        `A flake is a bug, not noise. Diagnose it with the playbook: ${config.playbookUrl}`,
+        `At ${config.threshold} recorded occurrences it fails signoff until fixed; label this issue`,
+        `\`${config.snoozeLabel}\` to defer that deliberately.`
+    ].join('\n');
+}
+export function occurrenceBody(event, ctx) {
+    return [OCCURRENCE_MARKER, '', 'Flaked again.', '', details(event, ctx)].join('\n');
+}
+/**
+ * One open issue per flaking test (exact title match); each later sighting adds a marker
+ * comment. An issue at `threshold` occurrences without the snooze label is an escalation.
+ * Any GitHub failure throws LedgerError naming what was and was not recorded.
+ */
+export function processFlakeEvents(events, ctx, config, deps) {
+    const result = { filed: [], bumped: [], escalations: [] };
+    const unique = dedupeEvents(events);
+    if (unique.length === 0)
+        return result;
+    let open;
+    try {
+        open = [...deps.listOpenFlakeIssues()];
+    }
+    catch (err) {
+        throw new LedgerError(result, unique, err);
+    }
+    for (const [i, event] of unique.entries()) {
+        try {
+            const title = issueTitle(event);
+            const existing = open.find((candidate) => candidate.title === title);
+            let entry;
+            let labels;
+            if (existing === undefined) {
+                const created = deps.createIssue(title, issueBody(event, ctx, config));
+                // A later event whose title truncates to the same string bumps this issue.
+                open.push(created);
+                entry = { number: created.number, title, url: created.url, count: 1 };
+                labels = created.labels;
+                result.filed.push(entry);
+            }
+            else {
+                const prior = deps.countOccurrenceComments(existing.number);
+                deps.commentIssue(existing.number, occurrenceBody(event, ctx));
+                entry = { number: existing.number, title, url: existing.url, count: prior + 2 };
+                labels = existing.labels;
+                result.bumped.push(entry);
+            }
+            if (entry.count >= config.threshold && !labels.includes(config.snoozeLabel)) {
+                result.escalations.push(entry);
+            }
+        }
+        catch (err) {
+            throw new LedgerError(result, unique.slice(i), err);
+        }
+    }
+    return result;
+}

package/dist/flakes/log.d.ts

@@ -0,0 +1,39 @@
+/** One retried-then-passed test, as a reporter saw it. */
+export interface FlakeEvent {
+    /** Issue-title bucket, e.g. 'e2e', 'unit', 'client'. */
+    kind: string;
+    runner: 'playwright' | 'vitest';
+    /** Runner project name ('' if none). */
+    project: string;
+    /** Repo-relative, '/'-separated. */
+    file: string;
+    /** Describe chain joined with ' › '. */
+    title: string;
+    /** At most ERROR_LINE_CAP lines, ANSI-stripped. */
+    firstAttemptError: string;
+    /** Playwright trace of the failed attempt. */
+    tracePath?: string;
+    /** CHREODE_HEAD when run under signoff. */
+    sha?: string;
+    /** ISO timestamp. */
+    at: string;
+}
+/** Repo-relative. Not under test-results/: Playwright wipes its outputDir at start and would
+ *  delete events an earlier vitest step wrote. */
+export declare const FLAKE_LOG_FILE = ".chreode/flakes.jsonl";
+export declare const ERROR_LINE_CAP = 40;
+export declare function flakeLogPath(env?: NodeJS.ProcessEnv, cwd?: string): string;
+/** jsonl, append-only: sequential writer processes in one run never clobber each other. */
+export declare function appendFlakeEvent(event: FlakeEvent, logPath: string): void;
+export declare function readFlakeEvents(logPath: string): FlakeEvent[];
+export declare function clearFlakeLog(logPath: string): void;
+export declare function writeFlakeEvents(logPath: string, events: readonly FlakeEvent[]): void;
+export declare function flakeKey(event: FlakeEvent): string;
+/** One report per test per run: the same flake seen in two projects counts once. */
+export declare function dedupeEvents(events: readonly FlakeEvent[]): FlakeEvent[];
+export declare function truncateError(message: string | undefined): string;
+/** The nearest ancestor holding `.git`: a directory in a checkout, a file in a worktree. */
+export declare function findRepoRoot(start: string, exists?: (path: string) => boolean): string | null;
+/** Relative to the git root found from the file itself, so a runner started in a subpackage
+ *  still yields repo paths; '/'-separated. */
+export declare function repoRelative(file: string, cwd?: string, exists?: (path: string) => boolean): string;

package/dist/flakes/log.js

@@ -0,0 +1,89 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative, sep } from 'node:path';
+import { stripAnsi } from '../run/stderr.js';
+/** Repo-relative. Not under test-results/: Playwright wipes its outputDir at start and would
+ *  delete events an earlier vitest step wrote. */
+export const FLAKE_LOG_FILE = '.chreode/flakes.jsonl';
+export const ERROR_LINE_CAP = 40;
+export function flakeLogPath(env = process.env, cwd = process.cwd()) {
+    const fromEnv = env.CHREODE_FLAKE_LOG;
+    return fromEnv !== undefined && fromEnv !== '' ? fromEnv : join(cwd, FLAKE_LOG_FILE);
+}
+/** jsonl, append-only: sequential writer processes in one run never clobber each other. */
+export function appendFlakeEvent(event, logPath) {
+    mkdirSync(dirname(logPath), { recursive: true });
+    appendFileSync(logPath, `${JSON.stringify(event)}\n`);
+}
+const REQUIRED = ['kind', 'runner', 'project', 'file', 'title', 'firstAttemptError', 'at'];
+function isFlakeEvent(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    const record = v;
+    return REQUIRED.every((key) => typeof record[key] === 'string');
+}
+export function readFlakeEvents(logPath) {
+    if (!existsSync(logPath))
+        return [];
+    const events = [];
+    for (const line of readFileSync(logPath, 'utf8').split('\n')) {
+        if (line.trim() === '')
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (isFlakeEvent(parsed))
+                events.push(parsed);
+        }
+        catch {
+            // An interrupted write: skip it rather than fail the report.
+        }
+    }
+    return events;
+}
+export function clearFlakeLog(logPath) {
+    rmSync(logPath, { force: true });
+}
+export function writeFlakeEvents(logPath, events) {
+    if (events.length === 0) {
+        clearFlakeLog(logPath);
+        return;
+    }
+    mkdirSync(dirname(logPath), { recursive: true });
+    writeFileSync(logPath, events.map((e) => `${JSON.stringify(e)}\n`).join(''));
+}
+export function flakeKey(event) {
+    return `${event.kind}/${event.file}/${event.title}`;
+}
+/** One report per test per run: the same flake seen in two projects counts once. */
+export function dedupeEvents(events) {
+    const seen = new Set();
+    return events.filter((e) => {
+        const key = flakeKey(e);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+export function truncateError(message) {
+    if (message === undefined || message === '')
+        return '(first attempt error unavailable)';
+    return stripAnsi(message).split('\n').slice(0, ERROR_LINE_CAP).join('\n');
+}
+/** The nearest ancestor holding `.git`: a directory in a checkout, a file in a worktree. */
+export function findRepoRoot(start, exists = existsSync) {
+    let dir = start;
+    for (;;) {
+        if (exists(join(dir, '.git')))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+/** Relative to the git root found from the file itself, so a runner started in a subpackage
+ *  still yields repo paths; '/'-separated. */
+export function repoRelative(file, cwd = process.cwd(), exists = existsSync) {
+    const root = findRepoRoot(dirname(file), exists) ?? cwd;
+    return relative(root, file).split(sep).join('/');
+}

package/dist/flakes/phase.d.ts

@@ -0,0 +1,34 @@
+import type { ResolvedFlakes } from '../config/types.js';
+import { type FlakeLedgerDeps, type LedgerEntry, type LedgerResult, type RunContext } from './ledger.js';
+export interface FlakePhaseInput {
+    logPath: string;
+    ctx: RunContext;
+    config: ResolvedFlakes;
+    ledger: FlakeLedgerDeps;
+    log: (m: string) => void;
+    warn: (m: string) => void;
+}
+export type FlakePhaseOutcome = {
+    kind: 'none';
+} | {
+    kind: 'reported';
+    result: LedgerResult;
+} | {
+    kind: 'gh-error';
+    message: string;
+    partial: LedgerResult;
+};
+/**
+ * Report the logged flakes to the ledger. Recorded events leave the log; on a GitHub failure
+ * the unrecorded ones stay for the next run (an outage must not block merging, and each event
+ * keeps its own sha and time). Escalations are returned, not acted on: the caller decides.
+ */
+export declare function runFlakePhase(input: FlakePhaseInput): FlakePhaseOutcome;
+/** The failure text for escalated flakes; each issue is listed once, at its highest count. */
+export declare function escalationMessage(escalations: readonly LedgerEntry[], config: ResolvedFlakes): string;
+/**
+ * The single place a phase outcome becomes a pass/fail decision: the failure message when any
+ * flake escalated (including ones recorded before a GitHub error), otherwise undefined.
+ * Signoff and `flake-report` both call this.
+ */
+export declare function escalationFailure(outcome: FlakePhaseOutcome, config: ResolvedFlakes): string | undefined;

package/dist/flakes/phase.js

@@ -0,0 +1,66 @@
+import { LedgerError, processFlakeEvents } from './ledger.js';
+import { clearFlakeLog, readFlakeEvents, writeFlakeEvents } from './log.js';
+function printResult(result, log) {
+    for (const f of result.filed)
+        log(`[chreode] flake filed: ${f.url} ${f.title}`);
+    for (const b of result.bumped) {
+        log(`[chreode] flake seen again (${b.count} occurrences): ${b.url} ${b.title}`);
+    }
+}
+/**
+ * Report the logged flakes to the ledger. Recorded events leave the log; on a GitHub failure
+ * the unrecorded ones stay for the next run (an outage must not block merging, and each event
+ * keeps its own sha and time). Escalations are returned, not acted on: the caller decides.
+ */
+export function runFlakePhase(input) {
+    const events = readFlakeEvents(input.logPath);
+    if (events.length === 0)
+        return { kind: 'none' };
+    input.log(`\n[chreode] flakes: ${events.length} retried-then-passed result(s) recorded`);
+    let result;
+    try {
+        result = processFlakeEvents(events, input.ctx, input.config, input.ledger);
+    }
+    catch (err) {
+        if (!(err instanceof LedgerError))
+            throw err;
+        printResult(err.partial, input.log);
+        writeFlakeEvents(input.logPath, err.remaining);
+        input.warn(`[chreode] flakes: a GitHub call failed (${err.message}); kept ` +
+            `${err.remaining.length} event(s) in ${input.logPath} for the next run`);
+        return { kind: 'gh-error', message: err.message, partial: err.partial };
+    }
+    clearFlakeLog(input.logPath);
+    printResult(result, input.log);
+    return { kind: 'reported', result };
+}
+function dedupeEscalations(escalations) {
+    const byIssue = new Map();
+    for (const e of escalations) {
+        const seen = byIssue.get(e.number);
+        if (!seen || e.count > seen.count)
+            byIssue.set(e.number, e);
+    }
+    return [...byIssue.values()];
+}
+/** The failure text for escalated flakes; each issue is listed once, at its highest count. */
+export function escalationMessage(escalations, config) {
+    const unique = dedupeEscalations(escalations);
+    return [
+        `\n[chreode] FAILED: ${unique.length} flake(s) reached ${config.threshold} occurrences:`,
+        ...unique.map((e) => `  ${e.url} (${e.count} occurrences) ${e.title}`),
+        `[chreode] Fix each one (playbook: ${config.playbookUrl}), or label its issue`,
+        `[chreode] ${config.snoozeLabel} to defer it deliberately.`
+    ].join('\n');
+}
+/**
+ * The single place a phase outcome becomes a pass/fail decision: the failure message when any
+ * flake escalated (including ones recorded before a GitHub error), otherwise undefined.
+ * Signoff and `flake-report` both call this.
+ */
+export function escalationFailure(outcome, config) {
+    if (outcome.kind === 'none')
+        return undefined;
+    const result = outcome.kind === 'reported' ? outcome.result : outcome.partial;
+    return result.escalations.length > 0 ? escalationMessage(result.escalations, config) : undefined;
+}

package/dist/flakes/report.d.ts

@@ -0,0 +1,14 @@
+import { type ResolvedConfig } from '../config/types.js';
+import { type Exec } from '../run/exec.js';
+import type { FlakeLedgerDeps } from './ledger.js';
+export interface FlakeReportDeps {
+    exec: Exec;
+    ledger: FlakeLedgerDeps;
+    logPath: string;
+    log: (m: string) => void;
+    warn: (m: string) => void;
+    error: (m: string) => void;
+}
+/** `chreode flake-report`: the signoff flake phase on its own, for hosted CI or by hand.
+ *  Without a `flakes` block it uses the defaults: running it is the opt-in. */
+export declare function runFlakeReport(config: ResolvedConfig, overrides?: Partial<FlakeReportDeps>): number;

package/dist/flakes/report.js

@@ -0,0 +1,45 @@
+import { resolveFlakes } from '../config/types.js';
+import { defaultExec } from '../run/exec.js';
+import { ghLedgerDeps } from './gh.js';
+import { flakeLogPath } from './log.js';
+import { escalationFailure, runFlakePhase } from './phase.js';
+/** `chreode flake-report`: the signoff flake phase on its own, for hosted CI or by hand.
+ *  Without a `flakes` block it uses the defaults: running it is the opt-in. */
+export function runFlakeReport(config, overrides = {}) {
+    const d = {
+        exec: defaultExec,
+        ledger: ghLedgerDeps(),
+        logPath: flakeLogPath(),
+        log: (m) => console.log(m),
+        warn: (m) => console.warn(m),
+        error: (m) => console.error(m),
+        ...overrides
+    };
+    const flakes = config.flakes ?? resolveFlakes({});
+    const sha = d.exec('git', ['rev-parse', 'HEAD']).trim();
+    let branch = 'HEAD';
+    try {
+        branch = d.exec('git', ['symbolic-ref', '-q', '--short', 'HEAD']).trim();
+    }
+    catch {
+        // Detached, e.g. a CI checkout of a sha.
+    }
+    const outcome = runFlakePhase({
+        logPath: d.logPath,
+        ctx: { branch, sha },
+        config: flakes,
+        ledger: d.ledger,
+        log: d.log,
+        warn: d.warn
+    });
+    if (outcome.kind === 'none') {
+        d.log('[chreode] flakes: no flakes recorded');
+        return 0;
+    }
+    const failure = escalationFailure(outcome, flakes);
+    if (failure !== undefined) {
+        d.error(failure);
+        return 1;
+    }
+    return 0;
+}

package/dist/index.d.ts

@@ -1,2 +1,4 @@
 export { defineConfig } from './config/types.js';
-export type { AllowlistEntry, ChreodeConfig, Matcher, ProtectionConfig, RuleConfig, StepConfig, StepContext } from './config/types.js';
+export { burnInStep, type BurnInStepOptions } from './burn-in/step.js';
+export type { AllowlistEntry, BurnInConfig, BurnInRunner, ChreodeConfig, FlakesConfig, Matcher, ProtectionConfig, RuleConfig, StepConfig, StepContext } from './config/types.js';
+export type { FlakeEvent } from './flakes/log.js';

package/dist/index.js

@@ -1 +1,2 @@
 export { defineConfig } from './config/types.js';
+export { burnInStep } from './burn-in/step.js';

package/dist/reporters/options.d.ts

@@ -0,0 +1,17 @@
+import { type FlakeEvent } from '../flakes/log.js';
+export interface FlakeReporterOptions {
+    /** Issue-title bucket: fixed, or derived from the runner project name. */
+    kind?: string | ((project: string) => string);
+    /** Record only these runner projects (default: all). */
+    projects?: string[];
+    /** Where events go (default: appended to the flake log). A seam for tests. */
+    append?: (event: FlakeEvent) => void;
+}
+export declare function resolveKind(kind: FlakeReporterOptions['kind'], project: string, fallback: string): string;
+export declare function wants(projects: readonly string[] | undefined, project: string): boolean;
+/** The sha under test when running under signoff. */
+export declare function headSha(env?: NodeJS.ProcessEnv): {
+    sha?: string;
+};
+/** Resolved at write time, so CHREODE_FLAKE_LOG set by signoff is honoured. */
+export declare function defaultAppend(event: FlakeEvent): void;

package/dist/reporters/options.js

@@ -0,0 +1,18 @@
+import { appendFlakeEvent, flakeLogPath } from '../flakes/log.js';
+export function resolveKind(kind, project, fallback) {
+    if (typeof kind === 'function')
+        return kind(project);
+    return kind ?? fallback;
+}
+export function wants(projects, project) {
+    return projects === undefined || projects.includes(project);
+}
+/** The sha under test when running under signoff. */
+export function headSha(env = process.env) {
+    const sha = env.CHREODE_HEAD;
+    return sha ? { sha } : {};
+}
+/** Resolved at write time, so CHREODE_FLAKE_LOG set by signoff is honoured. */
+export function defaultAppend(event) {
+    appendFlakeEvent(event, flakeLogPath());
+}

package/dist/reporters/playwright.d.ts

@@ -0,0 +1,15 @@
+import type { Reporter, TestCase, TestResult } from 'playwright/types/testReporter';
+import { type FlakeReporterOptions } from './options.js';
+/**
+ * Records every test that failed (or timed out) and then passed on a retry. Playwright loads
+ * reporters by module specifier, hence the default export. Imports Playwright's types only.
+ */
+export default class PlaywrightFlakeReporter implements Reporter {
+    private readonly options;
+    private readonly append;
+    /** The first failed attempt of each test that has not passed yet. */
+    private readonly failed;
+    constructor(options?: FlakeReporterOptions);
+    onTestEnd(test: TestCase, result: TestResult): void;
+    printsToStdio(): boolean;
+}

package/dist/reporters/playwright.js

@@ -0,0 +1,47 @@
+import { repoRelative, truncateError } from '../flakes/log.js';
+import { defaultAppend, headSha, resolveKind, wants } from './options.js';
+/**
+ * Records every test that failed (or timed out) and then passed on a retry. Playwright loads
+ * reporters by module specifier, hence the default export. Imports Playwright's types only.
+ */
+export default class PlaywrightFlakeReporter {
+    options;
+    append;
+    /** The first failed attempt of each test that has not passed yet. */
+    failed = new Map();
+    constructor(options = {}) {
+        this.options = options;
+        this.append = options.append ?? defaultAppend;
+    }
+    onTestEnd(test, result) {
+        if (result.status === 'failed' || result.status === 'timedOut') {
+            if (!this.failed.has(test.id))
+                this.failed.set(test.id, result);
+            return;
+        }
+        const first = this.failed.get(test.id);
+        if (result.status !== 'passed' || result.retry === 0 || first === undefined)
+            return;
+        this.failed.delete(test.id);
+        // ['', project, file, ...describes, title]
+        const titlePath = test.titlePath();
+        const project = titlePath[1] ?? '';
+        if (!wants(this.options.projects, project))
+            return;
+        const trace = first.attachments.find((a) => a.name === 'trace')?.path;
+        this.append({
+            kind: resolveKind(this.options.kind, project, 'e2e'),
+            runner: 'playwright',
+            project,
+            file: repoRelative(test.location.file),
+            title: titlePath.slice(3).join(' › '),
+            firstAttemptError: truncateError(first.error?.message),
+            ...(trace ? { tracePath: trace } : {}),
+            ...headSha(),
+            at: new Date().toISOString()
+        });
+    }
+    printsToStdio() {
+        return false;
+    }
+}

package/dist/reporters/vitest.d.ts

@@ -0,0 +1,15 @@
+import type { Reporter, TestModule } from 'vitest/node';
+import { type FlakeReporterOptions } from './options.js';
+/**
+ * Records every test that passed after at least one retry. vitest reporters are a root-level
+ * option, so instantiate this in the root config's `reporters`; it sees every project and
+ * filters with `projects`. Imports vitest's types only.
+ */
+export declare class VitestFlakeReporter implements Reporter {
+    private readonly options;
+    private readonly append;
+    constructor(options?: FlakeReporterOptions);
+    onTestRunEnd(testModules: ReadonlyArray<TestModule>): void;
+    private walk;
+}
+export default VitestFlakeReporter;