e2e 0.16.0 → 0.18.0

package/dist/run/last-run.d.ts

@@ -1,5 +1,6 @@
 /** What `--last-failed` reads back from the previous run's report. */
 import type { Report1Document } from '../report/build.ts';
+type ReportCarried = NonNullable<Report1Document['run']['carried']>;
 /**
  * The previous run's report, read from where this run will write its own. It
  * is what `--last-failed` selects from, and reporters receive it as
@@ -9,13 +10,46 @@ import type { Report1Document } from '../report/build.ts';
 export declare function readLastRun(reportPath: string): Promise<Report1Document>;
 /**
  * The result ids of a report's tests that did not pass: failed, timed out,
- * interrupted, or skipped because a setup, a serial predecessor, a hook, or
- * the worker failed, and every selected test in the scope of a `beforeAll` or
- * `afterAll` that failed, until a run where that hook passes. A report older
- * than `selected` counts every result as selected. An explicit
- * skip and a filtered test passed in the sense that matters here: nothing to
- * run again. The ids are `resultId(testId, target, agent)`, so a test is
- * named per target and agent whichever of its `--repeat-each` runs did not
- * pass.
+ * interrupted, or skipped because a setup, a serial predecessor, a hook, the
+ * worker, or the failure limit stopped it, every selected test in the scope
+ * of a `beforeAll` or `afterAll` that failed, until a run where that hook
+ * passes, and every test the report carries from an earlier run that it did
+ * not run again. A report older than `selected` counts every result as
+ * selected. An explicit skip and a filtered test passed in the sense that
+ * matters here: nothing to run again. The ids are
+ * `resultId(testId, target, agent)`, so a test is named per target and agent
+ * whichever of its `--repeat-each` runs did not pass.
  */
 export declare function lastFailedIds(document: Report1Document): ReadonlySet<string>;
+/** What a rerun's collection found: the tests it collected by id, and the files it discovered but could not collect. */
+export interface RerunCollection {
+    readonly testIds: ReadonlySet<string>;
+    readonly uncollectedFiles: ReadonlySet<string>;
+}
+/**
+ * What a `--last-failed` rerun carries forward from the report it selected
+ * from: every result that report owed a rerun and this run did not run, as
+ * the run that last ran it reported it; the serial groups those results'
+ * attempts live on; and the suite hook failures whose scope still holds one
+ * of them. A result is owed when it did not pass, or when it is in the scope
+ * of a failed `beforeAll` or `afterAll` this run did not see pass: a hook
+ * whose scope this run ran again without it failing is resolved, and one
+ * that failed again is this run's own error, which still makes its left-out
+ * tests owed. A test this run did not run is one it collected (`collected`,
+ * by test id), on a target the config still has, that it did not select:
+ * left out by a filter, on a target or agent the run did not ask for, or a
+ * setup no selected test needed, which the report lists no row for. A test in
+ * a file the run found but could not collect (`uncollectedFiles`, a narrowed
+ * run past a file that fails to import) is still there and stays carried. A
+ * test the run no longer collects cannot run again and is dropped. A test
+ * this run selected is no longer carried, whatever its outcome: its own
+ * result says it now. Undefined when nothing is carried.
+ */
+export declare function carryForward(lastRun: Report1Document, current: Report1Document, collected: RerunCollection): ReportCarried | undefined;
+/**
+ * The artifact paths a report names, relative to the artifacts root: every
+ * attempt's of its results and serial groups, and of what it carries. What a
+ * `--last-failed` rerun keeps of the tree when it starts.
+ */
+export declare function reportArtifactPaths(document: Report1Document): ReadonlySet<string>;
+export {};

package/dist/run/last-run.js

@@ -8,7 +8,16 @@ const UNDELIVERED_SKIPS = new Set([
     'serial-predecessor-failed',
     'hook-failed',
     'infrastructure-unavailable',
+    'failure-limit',
 ]);
+/** The id `--last-failed` names a result by: its test, target, and agent, whichever its repeat. */
+function rerunId(result) {
+    return resultId(result.testId, result.targetId, result.agent);
+}
+/** Whether a run error is a failed `beforeAll` or `afterAll`, the failures `--last-failed` runs the scope of again. */
+function isSuiteHookFailure(error) {
+    return error.phase === 'beforeAll' || error.phase === 'afterAll';
+}
 /** Whether a result is one `--last-failed` runs again: it did not pass, or the run never got to it. */
 function didNotPass(result) {
     switch (result.status) {
@@ -72,19 +81,88 @@ export async function readLastRun(reportPath) {
 }
 /**
  * The result ids of a report's tests that did not pass: failed, timed out,
- * interrupted, or skipped because a setup, a serial predecessor, a hook, or
- * the worker failed, and every selected test in the scope of a `beforeAll` or
- * `afterAll` that failed, until a run where that hook passes. A report older
- * than `selected` counts every result as selected. An explicit
- * skip and a filtered test passed in the sense that matters here: nothing to
- * run again. The ids are `resultId(testId, target, agent)`, so a test is
- * named per target and agent whichever of its `--repeat-each` runs did not
- * pass.
+ * interrupted, or skipped because a setup, a serial predecessor, a hook, the
+ * worker, or the failure limit stopped it, every selected test in the scope
+ * of a `beforeAll` or `afterAll` that failed, until a run where that hook
+ * passes, and every test the report carries from an earlier run that it did
+ * not run again. A report older than `selected` counts every result as
+ * selected. An explicit skip and a filtered test passed in the sense that
+ * matters here: nothing to run again. The ids are
+ * `resultId(testId, target, agent)`, so a test is named per target and agent
+ * whichever of its `--repeat-each` runs did not pass.
  */
 export function lastFailedIds(document) {
-    const hookFailures = document.run.errors.filter((error) => error.phase === 'beforeAll' || error.phase === 'afterAll');
+    const hookFailures = document.run.errors.filter(isSuiteHookFailure);
     const rerun = (result) => didNotPass(result) || (result.selected !== false && hookFailures.some((error) => inHookScope(result, error)));
-    return new Set(document.run.results.filter(rerun).map((result) => resultId(result.testId, result.targetId, result.agent)));
+    const ids = new Set(document.run.results.filter(rerun).map(rerunId));
+    for (const result of document.run.carried?.results ?? [])
+        ids.add(rerunId(result));
+    return ids;
+}
+/** Whether two suite hook failures are the same hook's: one phase, one scope. */
+function sameHook(a, b) {
+    if (a.phase !== b.phase)
+        return false;
+    if (a.scope === undefined || b.scope === undefined)
+        return a.scope === b.scope;
+    return (a.scope.file === b.scope.file &&
+        a.scope.targetId === b.scope.targetId &&
+        a.scope.titlePath.length === b.scope.titlePath.length &&
+        a.scope.titlePath.every((title, index) => b.scope.titlePath[index] === title));
+}
+/**
+ * What a `--last-failed` rerun carries forward from the report it selected
+ * from: every result that report owed a rerun and this run did not run, as
+ * the run that last ran it reported it; the serial groups those results'
+ * attempts live on; and the suite hook failures whose scope still holds one
+ * of them. A result is owed when it did not pass, or when it is in the scope
+ * of a failed `beforeAll` or `afterAll` this run did not see pass: a hook
+ * whose scope this run ran again without it failing is resolved, and one
+ * that failed again is this run's own error, which still makes its left-out
+ * tests owed. A test this run did not run is one it collected (`collected`,
+ * by test id), on a target the config still has, that it did not select:
+ * left out by a filter, on a target or agent the run did not ask for, or a
+ * setup no selected test needed, which the report lists no row for. A test in
+ * a file the run found but could not collect (`uncollectedFiles`, a narrowed
+ * run past a file that fails to import) is still there and stays carried. A
+ * test the run no longer collects cannot run again and is dropped. A test
+ * this run selected is no longer carried, whatever its outcome: its own
+ * result says it now. Undefined when nothing is carried.
+ */
+export function carryForward(lastRun, current, collected) {
+    const selected = new Set(current.run.results.filter((result) => result.selected !== false).map(rerunId));
+    const targets = new Set(current.run.targets.map((target) => target.id));
+    const stillThere = (result) => collected.testIds.has(result.testId) || collected.uncollectedFiles.has(result.file);
+    const notRun = (result) => !selected.has(rerunId(result)) && stillThere(result) && targets.has(result.targetId);
+    const failedAgain = current.run.errors.filter(isSuiteHookFailure);
+    const hooks = [...lastRun.run.errors.filter(isSuiteHookFailure), ...(lastRun.run.carried?.errors ?? [])];
+    const reportedAgain = (error) => failedAgain.some((again) => sameHook(again, error));
+    const passedAgain = (error) => !reportedAgain(error) &&
+        current.run.results.some((result) => result.selected !== false && result.status !== 'skipped' && inHookScope(result, error));
+    const unresolved = hooks.filter((error) => !passedAgain(error));
+    // A test the run before left out is known by the row it carried, not by its filtered one.
+    const history = [...lastRun.run.results.filter((result) => result.selected !== false), ...(lastRun.run.carried?.results ?? [])];
+    const results = history.filter((result) => notRun(result) && (didNotPass(result) || unresolved.some((error) => inHookScope(result, error))));
+    if (results.length === 0)
+        return undefined;
+    const groupIds = new Set(results.flatMap((result) => (result.serialGroupId === undefined ? [] : [result.serialGroupId])));
+    const currentGroupIds = new Set(current.run.serialGroups.map((group) => group.id));
+    const serialGroups = [...lastRun.run.serialGroups, ...(lastRun.run.carried?.serialGroups ?? [])].filter((group) => groupIds.has(group.id) && !currentGroupIds.has(group.id));
+    const errors = unresolved.filter((error) => !reportedAgain(error) && results.some((result) => inHookScope(result, error)));
+    return { results, serialGroups, errors };
+}
+/**
+ * The artifact paths a report names, relative to the artifacts root: every
+ * attempt's of its results and serial groups, and of what it carries. What a
+ * `--last-failed` rerun keeps of the tree when it starts.
+ */
+export function reportArtifactPaths(document) {
+    const parts = [document.run, ...(document.run.carried === undefined ? [] : [document.run.carried])];
+    const attempts = parts.flatMap((part) => [
+        ...part.results.flatMap((result) => result.attempts),
+        ...part.serialGroups.flatMap((group) => group.attempts),
+    ]);
+    return new Set(attempts.flatMap((attempt) => attempt.artifacts.flatMap((artifact) => (artifact.path === undefined ? [] : [artifact.path]))));
 }
 /**
  * The shape the read relies on: a report-1 envelope whose every result has
@@ -96,10 +174,38 @@ function isReport(value) {
         return false;
     const document = value;
     return (document.schemaVersion === 'report-1' &&
-        Array.isArray(document.run?.results) &&
-        document.run.results.every(isResult) &&
-        Array.isArray(document.run.errors) &&
-        document.run.errors.every(isError));
+        isRunPart(document.run) &&
+        (document.run.carried === undefined || isRunPart(document.run.carried)));
+}
+/** A run, or what one carries: results and errors of the shape read here, and its serial groups. */
+function isRunPart(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const part = value;
+    return (Array.isArray(part.results) &&
+        part.results.every(isResult) &&
+        Array.isArray(part.errors) &&
+        part.errors.every(isError) &&
+        Array.isArray(part.serialGroups) &&
+        part.serialGroups.every((group) => typeof group === 'object' && group !== null && hasAttempts(group)));
+}
+/** Whether a result or serial group lists its attempts, each with its artifacts, the way a rerun reads them. */
+function hasAttempts(value) {
+    const { attempts } = value;
+    return Array.isArray(attempts) && attempts.every(hasArtifacts);
+}
+/** Whether an attempt lists its artifacts as records whose path, when there is one, is a string. */
+function hasArtifacts(attempt) {
+    if (typeof attempt !== 'object' || attempt === null)
+        return false;
+    const { artifacts } = attempt;
+    return (Array.isArray(artifacts) &&
+        artifacts.every((artifact) => {
+            if (typeof artifact !== 'object' || artifact === null)
+                return false;
+            const { path } = artifact;
+            return path === undefined || typeof path === 'string';
+        }));
 }
 function isResult(value) {
     if (typeof value !== 'object' || value === null)
@@ -110,6 +216,7 @@ function isResult(value) {
         typeof result.status === 'string' &&
         typeof result.file === 'string' &&
         Array.isArray(result.titlePath) &&
+        hasAttempts(result) &&
         (skip === undefined || (typeof skip === 'object' && skip !== null && typeof skip.cause === 'string')));
 }
 function isError(value) {

package/dist/run/process-output.d.ts

@@ -0,0 +1,73 @@
+/**
+ * What user code in an `e2e run` process prints outside a test body: the
+ * config's top-level code, a test file's top level while it is collected,
+ * and reporters in the runner; the config's top-level code again in each
+ * worker. It is redacted with every secret value the process knows, as a
+ * test's output is. Until a config has loaded its secrets are unknown, so
+ * what is printed meanwhile is held, and withheld if the load fails.
+ */
+import { type SecretLedger } from '../internal/redact.ts';
+import type { ListReporterOutput } from '../report/list.ts';
+export type OutputStream = 'stdout' | 'stderr';
+/** Writes text to one stream of the terminal; the callback fires once the stream took it. Answers false while the stream is backed up, like `Writable.write`. */
+export type TerminalWrite = (text: string, callback?: () => void) => boolean;
+/** Where runner output goes instead of the terminal while the list reporter shows the run. */
+export interface OutputView {
+    /** Prints redacted text from `stream`. */
+    show(stream: OutputStream, text: string): void;
+    /** Prints what `show` left unfinished; nothing more follows. */
+    end(): void;
+}
+/**
+ * Holds what is written while a config loads. Released once the load
+ * registered the config's secrets; dropped for a warning when it failed.
+ */
+export declare class ConfigLoadHold {
+    private held;
+    /** Holds `chunk` if a load is in flight; answers whether it did. */
+    hold(stream: OutputStream, chunk: string | Uint8Array): boolean;
+    /**
+     * Runs `load`, which loads a config and registers its secrets, holding
+     * what is written meanwhile. Then hands each held write to `release` in
+     * order, or, if `load` threw, `warn`s with how much was withheld.
+     */
+    during<T>(load: () => Promise<T>, release: (stream: OutputStream, chunk: string | Uint8Array) => void, warn: (line: string) => void): Promise<T>;
+}
+/**
+ * The runner process's user output, on its way to the terminal or, while
+ * the list reporter shows it, through the reporter, which prints it above
+ * its live window instead of letting it land inside.
+ */
+export declare class RunnerOutput {
+    private readonly terminal;
+    /** Each stream redacted on its own, across writes: a value split over two writes is still caught. */
+    private readonly redactors;
+    private readonly loadHold;
+    private view;
+    /** The terminal's stdout for the list reporter: its own lines and live window go straight there. */
+    readonly listOutput: ListReporterOutput;
+    constructor(terminal: Readonly<Record<OutputStream, TerminalWrite>>, ledger: SecretLedger);
+    /**
+     * One write of user code to `stream`, redacted: the tail a later write
+     * could complete into a value waits for it, or for `end`. Held while a
+     * config loads. Answers what the terminal did.
+     */
+    write(stream: OutputStream, chunk: string | Uint8Array, callback?: () => void): boolean;
+    /**
+     * Runs `load`, a config load that registers the config's secrets, holding
+     * what is printed until it ends: the config's top-level code may print a
+     * value before the process knows it is one. Released redacted once it
+     * loaded; withheld with a warning when it failed.
+     */
+    withholdDuring<T>(load: () => Promise<T>): Promise<T>;
+    /**
+     * Passes what is printed to `view` from now on, or to the terminal again
+     * when undefined. What the previous view was given is released to it
+     * first, unfinished lines included, and that view ended.
+     */
+    showThrough(view: OutputView | undefined): void;
+    /** Releases what is still held, redacted, to the terminal. Later writes stay redacted; only a tail a later write could complete into a value is held. */
+    end(): void;
+    private release;
+    private emit;
+}

package/dist/run/process-output.js

@@ -0,0 +1,130 @@
+/**
+ * What user code in an `e2e run` process prints outside a test body: the
+ * config's top-level code, a test file's top level while it is collected,
+ * and reporters in the runner; the config's top-level code again in each
+ * worker. It is redacted with every secret value the process knows, as a
+ * test's output is. Until a config has loaded its secrets are unknown, so
+ * what is printed meanwhile is held, and withheld if the load fails.
+ */
+import { StreamRedactor } from '../internal/redact.js';
+/** The warning that stands in for what a config printed before it failed to load. */
+function withheldWarning(bytes) {
+    return `withheld ${bytes} bytes of output printed while the config failed to load: its secrets are unknown, so the output cannot be redacted`;
+}
+/**
+ * Holds what is written while a config loads. Released once the load
+ * registered the config's secrets; dropped for a warning when it failed.
+ */
+export class ConfigLoadHold {
+    held;
+    /** Holds `chunk` if a load is in flight; answers whether it did. */
+    hold(stream, chunk) {
+        if (this.held === undefined)
+            return false;
+        // A copy: the writer may reuse its buffer once the write returns.
+        this.held.push({ stream, chunk: typeof chunk === 'string' ? chunk : Buffer.from(chunk) });
+        return true;
+    }
+    /**
+     * Runs `load`, which loads a config and registers its secrets, holding
+     * what is written meanwhile. Then hands each held write to `release` in
+     * order, or, if `load` threw, `warn`s with how much was withheld.
+     */
+    async during(load, release, warn) {
+        this.held = [];
+        let loaded = false;
+        try {
+            const value = await load();
+            loaded = true;
+            return value;
+        }
+        finally {
+            const held = this.held;
+            this.held = undefined;
+            if (loaded) {
+                for (const { stream, chunk } of held)
+                    release(stream, chunk);
+            }
+            else {
+                const bytes = held.reduce((total, { chunk }) => total + Buffer.byteLength(chunk), 0);
+                if (bytes > 0)
+                    warn(withheldWarning(bytes));
+            }
+        }
+    }
+}
+/**
+ * The runner process's user output, on its way to the terminal or, while
+ * the list reporter shows it, through the reporter, which prints it above
+ * its live window instead of letting it land inside.
+ */
+export class RunnerOutput {
+    terminal;
+    /** Each stream redacted on its own, across writes: a value split over two writes is still caught. */
+    redactors;
+    loadHold = new ConfigLoadHold();
+    view;
+    /** The terminal's stdout for the list reporter: its own lines and live window go straight there. */
+    listOutput;
+    constructor(terminal, ledger) {
+        this.terminal = terminal;
+        this.redactors = { stdout: new StreamRedactor(ledger), stderr: new StreamRedactor(ledger) };
+        this.listOutput = {
+            write: (line) => void terminal.stdout(`${line}\n`),
+            raw: (text) => void terminal.stdout(text),
+        };
+    }
+    /**
+     * One write of user code to `stream`, redacted: the tail a later write
+     * could complete into a value waits for it, or for `end`. Held while a
+     * config loads. Answers what the terminal did.
+     */
+    write(stream, chunk, callback) {
+        if (this.loadHold.hold(stream, chunk)) {
+            if (callback !== undefined)
+                process.nextTick(callback);
+            return true;
+        }
+        return this.emit(stream, this.redactors[stream].push(chunk), callback);
+    }
+    /**
+     * Runs `load`, a config load that registers the config's secrets, holding
+     * what is printed until it ends: the config's top-level code may print a
+     * value before the process knows it is one. Released redacted once it
+     * loaded; withheld with a warning when it failed.
+     */
+    withholdDuring(load) {
+        return this.loadHold.during(load, (stream, chunk) => this.write(stream, chunk), (line) => this.emit('stderr', `e2e: [warning] ${line}\n`));
+    }
+    /**
+     * Passes what is printed to `view` from now on, or to the terminal again
+     * when undefined. What the previous view was given is released to it
+     * first, unfinished lines included, and that view ended.
+     */
+    showThrough(view) {
+        if (this.view !== undefined) {
+            this.release();
+            this.view.end();
+        }
+        this.view = view;
+    }
+    /** Releases what is still held, redacted, to the terminal. Later writes stay redacted; only a tail a later write could complete into a value is held. */
+    end() {
+        this.showThrough(undefined);
+        this.release();
+    }
+    release() {
+        this.emit('stdout', this.redactors.stdout.flush());
+        this.emit('stderr', this.redactors.stderr.flush());
+    }
+    emit(stream, text, callback) {
+        if (text === '' || this.view !== undefined) {
+            if (text !== '')
+                this.view?.show(stream, text);
+            if (callback !== undefined)
+                process.nextTick(callback);
+            return true;
+        }
+        return this.terminal[stream](text, callback);
+    }
+}

package/dist/run/provision.d.ts

@@ -55,6 +55,8 @@ export interface PrepareScope {
     /** The same `env` the workers are started with: what prepare provisions must be where a launch will look for it. */
     readonly env: NodeJS.ProcessEnv;
     readonly signal: AbortSignal;
+    /** Whether the run asked for a visible surface, so a hook provisions for the browser it will launch. */
+    readonly headed: boolean;
     /** Where a hook's progress lines go, under the target they concern. */
     readonly notice: (targetName: string, line: string) => void;
 }

package/dist/run/provision.js

@@ -129,6 +129,7 @@ export class PreparedEngines {
                 runId: scope.runId,
                 targetName: target.name,
                 projectRoot: scope.projectRoot,
+                headed: scope.headed,
                 app: engineAppInfo(target.app),
                 slots,
                 env: scope.env,

package/dist/run/realm.d.ts

@@ -33,7 +33,10 @@ export declare function findRegistered(realm: Realm, test: CollectedTest): Regis
 /**
  * Runs one hook, or a fixture teardown, within its budget. One that overruns
  * fails with the runner's timeout error naming `label`; `onTimeout` lets the
- * caller cancel what it started.
+ * caller cancel what it started. The hook owns the `expect.poll` calls it
+ * starts: one still running when it returns fails it with
+ * `STEP_NOT_AWAITED` and is cancelled, and one left by a hook that failed is
+ * cancelled beside that failure.
  */
 export declare function runHook(label: string, run: () => void | Promise<void>, timeoutMs: number, onTimeout?: () => void): Promise<void>;
 export interface RealmManagerOptions {

package/dist/run/realm.js

@@ -1,5 +1,6 @@
 /** Suite realm lifecycle: module re-import, beforeAll/afterAll scope tracking. */
 import { importModule } from '../config/load.js';
+import { PollScope, runInPollScope } from '../expect/poll-scope.js';
 import { classifyError, E2EError, serializeError, TestTimeoutError, } from '../internal/errors.js';
 import { DebugTrace } from '../internal/debug.js';
 import { titlePathKey } from '../internal/ids.js';
@@ -12,13 +13,26 @@ export function findRegistered(realm, test) {
 /**
  * Runs one hook, or a fixture teardown, within its budget. One that overruns
  * fails with the runner's timeout error naming `label`; `onTimeout` lets the
- * caller cancel what it started.
+ * caller cancel what it started. The hook owns the `expect.poll` calls it
+ * starts: one still running when it returns fails it with
+ * `STEP_NOT_AWAITED` and is cancelled, and one left by a hook that failed is
+ * cancelled beside that failure.
  */
-export function runHook(label, run, timeoutMs, onTimeout) {
-    return withTimeout(Promise.resolve().then(run), timeoutMs, () => {
-        onTimeout?.();
-        return new TestTimeoutError(`${label} timed out`);
-    });
+export async function runHook(label, run, timeoutMs, onTimeout) {
+    const polls = new PollScope(`the ${label}`);
+    try {
+        await withTimeout(runInPollScope(polls, () => Promise.resolve().then(run)), timeoutMs, () => {
+            onTimeout?.();
+            return new TestTimeoutError(`${label} timed out`);
+        });
+    }
+    catch (cause) {
+        polls.close();
+        throw cause;
+    }
+    const notAwaited = polls.close();
+    if (notAwaited !== undefined)
+        throw notAwaited;
 }
 /** Creates realms and runs suite-scope hooks with per-realm entry tracking. */
 export class RealmManager {

package/dist/run/records.d.ts

@@ -30,13 +30,13 @@ export interface ArtifactRecord {
     /**
      * Mirrors report-1: how much of the file the runner masked. A screenshot is
      * `complete`; a trace is `complete` once every registered secret value was
-     * rewritten out of its text, and `not-required` when no secret reached its
-     * session (filled, or held by the engine); a video is `incomplete`, since a recording masks nothing
+     * rewritten out of its text, and `not-required` when the run has no
+     * secret value to rewrite; a video is `incomplete`, since a recording masks nothing
      * (a secure field renders its own dots, but anything else the screen
      * showed is in the frames), and is kept as it is; a download is
      * `incomplete` too, bytes the app served and the runner did not rewrite,
-     * unless a secret reached the session and the file is text the
-     * ledger was run over, which makes it `complete`. report-1 also admits an
+     * unless the file is text the session's ledger was run over, which makes
+     * it `complete`. report-1 also admits an
      * `incomplete` artifact without a `path`: a video a hosted service keeps,
      * recorded by `url`, or one its producer withheld, which this runner never
      * writes.
@@ -148,6 +148,22 @@ export interface ResultRecord {
  * every other field is plain data.
  */
 export type WireResultRecord = Omit<ResultRecord, 'target'>;
+/** The failure a runtime skip followed, with the evidence its attempt captured. */
+export interface FailureBeforeSkip {
+    readonly error: SerializedError;
+    readonly failure: FailureEvidence | undefined;
+    /** The failing attempt's artifacts; for a serial member, the group attempt's. */
+    readonly artifacts: readonly ArtifactRecord[];
+}
+/**
+ * The failure a test's `test.skip(...)` followed: the last attempt that
+ * failed before a skipped retry, or a soft failure the skipping attempt kept.
+ * Engine cleanup diagnostics after the skip are not one. A serial member's
+ * attempts live on its group, which `groupOf` looks up only for such a member.
+ */
+export declare function failureBeforeSkip(result: Pick<ResultRecord, 'status' | 'skip' | 'attempts' | 'serialGroupId' | 'test'>, groupOf: (id: string) => SerialGroupRecord | undefined): FailureBeforeSkip | undefined;
+/** Whether any skipped result followed a failure: what `failOnSkippedFailure` fails a run for. */
+export declare function someSkippedAfterFailure(results: readonly ResultRecord[], serialGroups: readonly SerialGroupRecord[]): boolean;
 /** Strips the live target from a result for transport. */
 export declare function encodeResult(record: ResultRecord): WireResultRecord;
 export interface RunError {

package/dist/run/records.js

@@ -7,6 +7,32 @@
 export function isFailedStatus(status) {
     return status !== 'passed' && status !== 'skipped' && status !== 'flaky';
 }
+/**
+ * The failure a test's `test.skip(...)` followed: the last attempt that
+ * failed before a skipped retry, or a soft failure the skipping attempt kept.
+ * Engine cleanup diagnostics after the skip are not one. A serial member's
+ * attempts live on its group, which `groupOf` looks up only for such a member.
+ */
+export function failureBeforeSkip(result, groupOf) {
+    if (result.status !== 'skipped' || result.skip?.cause !== 'explicit')
+        return undefined;
+    const runs = result.serialGroupId === undefined
+        ? result.attempts
+        : (groupOf(result.serialGroupId)?.attempts ?? []).flatMap((attempt) => attempt.members
+            .filter((member) => member.testId === result.test.id)
+            .map((member) => ({ ...member, artifacts: attempt.artifacts })));
+    for (const run of runs.toReversed()) {
+        const error = run.error ?? run.secondaryErrors.find((secondary) => secondary.phase !== 'cleanup');
+        if (error !== undefined)
+            return { error, failure: run.failure, artifacts: run.artifacts };
+    }
+    return undefined;
+}
+/** Whether any skipped result followed a failure: what `failOnSkippedFailure` fails a run for. */
+export function someSkippedAfterFailure(results, serialGroups) {
+    const groups = new Map(serialGroups.map((group) => [group.id, group]));
+    return results.some((result) => failureBeforeSkip(result, (id) => groups.get(id)) !== undefined);
+}
 /** Strips the live target from a result for transport. */
 export function encodeResult(record) {
     const { target: _target, ...rest } = record;

package/dist/run/retry.d.ts

@@ -12,6 +12,15 @@ export declare function isRetryEligible(attempt: RetryAttempt): boolean;
  * Runs up to `maxAttempts` attempts, stopping on pass, interrupt, or a
  * failure that does not consume retry budget. `runOnce` returns the
  * finished attempt, or undefined when the attempt could not start (the
- * loop stops and the last observed status stands).
+ * loop stops and the last observed status stands). An interrupt during a
+ * retry keeps the verdict the failed attempt before it reached: the test
+ * did fail, and only its second chance was cut short.
  */
 export declare function runWithRetries(maxAttempts: number, interruptSignal: AbortSignal, runOnce: (attemptIndex: number) => Promise<RetryAttempt | undefined>): Promise<ResultStatus>;
+/**
+ * The verdict a sequence of finished attempts reaches: a pass is `flaky`
+ * after a failure, an interrupt during a retry keeps the verdict before it,
+ * and a self-skip decides. Also the verdict of attempts a worker finished
+ * before the run's interrupt stopped it, so both read alike.
+ */
+export declare function retryVerdict(attempts: readonly RetryAttempt[]): ResultStatus;