e2e 0.15.2 → 0.17.0

package/dist/report/build.d.ts

@@ -264,15 +264,36 @@ export interface ReportUsage {
     maxActionStepsInStep: number;
     estimatedCostUsd?: number;
 }
+/**
+ * The run's counts by result. `passed`, `failed` (timed out included),
+ * `interrupted`, `flaky`, and `skipped` count selected results only and add
+ * up to `selected`; `discovered` minus `selected` is what the selection left
+ * out.
+ */
 export interface ReportSummary {
     discovered: number;
     selected: number;
     executed: number;
     passed: number;
     failed: number;
+    /** Stopped by the run (a signal, `--max-failures`, a run-level error) before reaching a verdict; never counted as failed. */
+    interrupted: number;
     flaky: number;
     skipped: number;
 }
+/**
+ * What earlier runs left unresolved that a `--last-failed` rerun did not run
+ * again, because another filter left it out: the results as those runs
+ * reported them, the serial groups their members' attempts live on, and the
+ * suite hook failures whose scope still holds a carried test. The next
+ * `--last-failed` selects these tests too, so a test that never ran again
+ * stays owed until it does.
+ */
+export interface ReportCarried {
+    results: readonly ReportResult[];
+    serialGroups: readonly ReportSerialGroup[];
+    errors: readonly ReportError[];
+}
 export interface Report1Document {
     schemaVersion: 'report-1';
     run: {
@@ -309,6 +330,11 @@ export interface Report1Document {
         summary: ReportSummary;
         limits: ReportLimits;
         usage: ReportUsage;
+        /**
+         * Present on a `--last-failed` rerun that left out a test an earlier run
+         * did not pass. Not part of this run's status, exit code, or summary.
+         */
+        carried?: ReportCarried | undefined;
         /** Present on an `e2e explore` run only. */
         explore?: ReportExplore | undefined;
     };
@@ -316,4 +342,3 @@ export interface Report1Document {
 /** Builds the complete report-1 document. */
 export declare function buildReport(options: BuildReportOptions): Report1Document;
 export {};
-//# sourceMappingURL=build.d.ts.map

package/dist/report/build.js

@@ -8,6 +8,7 @@ import { resultId, timestamp } from '../internal/ids.js';
 import { obj } from '../internal/objects.js';
 import { packageVersion } from '../internal/package-version.js';
 import { projectRelativePath } from '../internal/source.js';
+import { someSkippedAfterFailure } from '../run/records.js';
 /**
  * What a target's engine declaration says about it: the one description the
  * runner grades against and the report records. A target without an engine is
@@ -155,20 +156,22 @@ function serializeTarget(config, target, provenance) {
         ...(provenance ?? describeTarget(target)),
     };
 }
-/** Computes report-1 summary counts from results. */
+/** Computes report-1 summary counts from results; the status counts are over the selected ones. */
 function computeSummary(results) {
     let selected = 0;
     let executed = 0;
     let passed = 0;
     let failed = 0;
+    let interrupted = 0;
     let flaky = 0;
     let skipped = 0;
     for (const result of results) {
-        if (result.selected)
-            selected += 1;
         if (result.attempts.length > 0 || (result.serialGroupId !== undefined && result.status !== 'skipped')) {
             executed += 1;
         }
+        if (!result.selected)
+            continue;
+        selected += 1;
         switch (result.status) {
             case 'passed':
                 passed += 1;
@@ -178,15 +181,17 @@ function computeSummary(results) {
                 break;
             case 'failed':
             case 'timed-out':
-            case 'interrupted':
                 failed += 1;
                 break;
+            case 'interrupted':
+                interrupted += 1;
+                break;
             case 'skipped':
                 skipped += 1;
                 break;
         }
     }
-    return { discovered: results.length, selected, executed, passed, failed, flaky, skipped };
+    return { discovered: results.length, selected, executed, passed, failed, interrupted, flaky, skipped };
 }
 /**
  * A run is `blocked` — not failed — when it did not pass and *every*
@@ -195,14 +200,17 @@ function computeSummary(results) {
  * nothing contradicts that. One genuine failure keeps the run failed, and so
  * does any run-level error (a launch that never came up, a cleanup or report
  * write that failed): it is its own fact about the run, not a blocked step,
- * and it must stay visible to a host reading the status. Derivation requires
+ * and it must stay visible to a host reading the status. So does a skip after
+ * a failure under `failOnSkippedFailure`. Derivation requires
  * positive evidence, never absence of it.
  */
-function deriveRunStatus(status, results, serialGroups, runErrors) {
+function deriveRunStatus(status, results, serialGroups, runErrors, failOnSkippedFailure) {
     if (status !== 'failed' && status !== 'error')
         return status;
     if (runErrors.length > 0)
         return status;
+    if (failOnSkippedFailure && someSkippedAfterFailure(results, serialGroups))
+        return status;
     // Serial members carry no attempts of their own; their failing error lives
     // on the group's last attempt (or its failing member).
     const groupCode = new Map();
@@ -320,7 +328,7 @@ export function buildReport(options) {
                 name: 'e2e',
                 version: packageVersion(import.meta.url, '../../package.json', '0.0.0'),
             },
-            status: deriveRunStatus(options.status, options.results, options.serialGroups, options.runErrors),
+            status: deriveRunStatus(options.status, options.results, options.serialGroups, options.runErrors, config?.failOnSkippedFailure === true),
             exitCode: options.exitCode,
             startedAt: options.startedAt,
             finishedAt: timestamp(),
@@ -368,4 +376,3 @@ function compareSerialGroups(a, b, targetIndex) {
         return a.declarationIndex - b.declarationIndex;
     return (targetIndex.get(a.targetId) ?? 0) - (targetIndex.get(b.targetId) ?? 0);
 }
-//# sourceMappingURL=build.js.map

package/dist/report/builtin.d.ts

@@ -11,4 +11,3 @@ export declare const BUILTIN_REPORTERS: readonly ["list", "json", "junit", "mark
 export declare const BUILTIN_REPORTER_LIST: string;
 export declare const STATELESS_REPORTERS: Record<Exclude<BuiltinReporter, 'list'>, Reporter>;
 export declare function isBuiltinReporter(value: string): value is BuiltinReporter;
-//# sourceMappingURL=builtin.d.ts.map

package/dist/report/builtin.js

@@ -19,4 +19,3 @@ export const STATELESS_REPORTERS = {
 export function isBuiltinReporter(value) {
     return BUILTIN_REPORTERS.includes(value);
 }
-//# sourceMappingURL=builtin.js.map

package/dist/report/code-frame.d.ts

@@ -11,4 +11,3 @@ export { userFrame, type StackFrame };
  * column caret, gutter-numbered like vitest (`  28| code`).
  */
 export declare function codeFrame(frame: StackFrame, pc: Colors): string[];
-//# sourceMappingURL=code-frame.d.ts.map

package/dist/report/code-frame.js

@@ -44,4 +44,3 @@ export function codeFrame(frame, pc) {
     }
     return rows;
 }
-//# sourceMappingURL=code-frame.js.map

package/dist/report/debug-steps.d.ts

@@ -11,4 +11,3 @@ import type { ResultRecord, SerialGroupRecord } from '../run/records.ts';
  * the empty string when the run performed no agent steps.
  */
 export declare function agentStepTable(results: readonly ResultRecord[], serialGroups: readonly SerialGroupRecord[]): string;
-//# sourceMappingURL=debug-steps.d.ts.map

package/dist/report/debug-steps.js

@@ -98,4 +98,3 @@ function formatUsd(value) {
     const trimmed = value.toFixed(digits).replace(/(\.\d*?)0+$/, '$1').replace(/\.$/, '');
     return `$${trimmed}`;
 }
-//# sourceMappingURL=debug-steps.js.map

package/dist/report/explore-text.d.ts

@@ -14,4 +14,3 @@ export declare function stepCountParts(steps: readonly ReportExploreStep[]): {
     readonly status: ReportExploreStep['status'];
     readonly text: string;
 }[];
-//# sourceMappingURL=explore-text.d.ts.map

package/dist/report/explore-text.js

@@ -34,4 +34,3 @@ export function stepCountParts(steps) {
         ...(counts.blocked > 0 ? [{ status: 'blocked', text: `${counts.blocked} blocked` }] : []),
     ];
 }
-//# sourceMappingURL=explore-text.js.map

package/dist/report/failure-text.d.ts

@@ -34,7 +34,12 @@ export declare function detailLines(error: ReportError | undefined): string[];
  * called with, which reads as code.
  */
 export declare function stepLabel(step: ReportStep, max?: number): string;
-/** The attempt whose story a block tells: a flaky test's last failure, otherwise the final one. */
+/**
+ * The attempt whose story a block tells: a flaky test's last failure; for a
+ * failed or timed-out test, the last attempt that reached that verdict, so a
+ * retry the run interrupted (or a serial member that retry never reached)
+ * tells nothing; otherwise the final one.
+ */
 export declare function toldAttempt(result: ReportResult, final: Outcome): AttemptView;
 /** A step that did not pass. */
 export type FailedStep = ReportStep & {
@@ -68,4 +73,3 @@ export declare function evidenceOf(told: AttemptView): ReportArtifact[];
 /** Renders one failed or flaky result as its own markdown page. */
 export declare function renderFailurePage(report: Report1Document, result: ReportResult, final: Outcome, options?: FailurePageOptions): string;
 export {};
-//# sourceMappingURL=failure-text.d.ts.map

package/dist/report/failure-text.js

@@ -69,9 +69,19 @@ function screenUrl(url) {
         return url;
     }
 }
-/** The attempt whose story a block tells: a flaky test's last failure, otherwise the final one. */
+/**
+ * The attempt whose story a block tells: a flaky test's last failure; for a
+ * failed or timed-out test, the last attempt that reached that verdict, so a
+ * retry the run interrupted (or a serial member that retry never reached)
+ * tells nothing; otherwise the final one.
+ */
 export function toldAttempt(result, final) {
-    return result.status === 'flaky' ? (final.lastFailed ?? final.final) : final.final;
+    if (result.status === 'flaky')
+        return final.lastFailed ?? final.final;
+    if (result.status === 'failed' || result.status === 'timed-out') {
+        return final.attempts.findLast((attempt) => attempt.status === 'failed' || attempt.status === 'timed-out') ?? final.final;
+    }
+    return final.final;
 }
 /** The step a failure happened at: the first that did not pass, with its position. */
 export function failedStepOf(steps) {
@@ -87,9 +97,9 @@ export function failedStepOf(steps) {
  */
 export function attemptsLine(result, final) {
     // An attempt that recorded nothing for this test (a serial group that never
-    // reached the member) says nothing about how the test fails.
+    // reached the member), or one the run interrupted, says nothing about how the test fails.
     const failed = final.attempts
-        .filter((attempt) => attempt.status !== 'passed' && attempt.status !== 'skipped' && (attempt.error !== undefined || attempt.steps.length > 0))
+        .filter((attempt) => attempt.status !== 'passed' && attempt.status !== 'skipped' && attempt.status !== 'interrupted' && (attempt.error !== undefined || attempt.steps.length > 0))
         .map((attempt) => ({
         code: cell(attempt.error?.code ?? attempt.status, 128),
         step: failedStepOf(attempt.steps)?.index,
@@ -297,4 +307,3 @@ export function renderFailurePage(report, result, final, options = {}) {
     lines.push(`<sub>e2e ${cell(run.runner.version, MAX_ID_CHARS)} · run ${code(run.id, MAX_ID_CHARS)} · the whole run is in \`report.json\`</sub>`);
     return `${lines.join('\n')}\n`;
 }
-//# sourceMappingURL=failure-text.js.map

package/dist/report/format.d.ts

@@ -58,20 +58,25 @@ export declare function rule(text: string, align: 'center' | 'right'): {
 export interface Counters {
     passed: number;
     failed: number;
+    interrupted: number;
     flaky: number;
     skipped: number;
     total: number;
 }
 export declare function emptyCounters(): Counters;
-/** The counter a result status lands in: every non-success status is a failure. */
-export declare function statusBucket(status: ResultStatus): 'passed' | 'failed' | 'flaky' | 'skipped';
+/**
+ * The counter a result status lands in. A timeout is a failure; an
+ * interrupted test was stopped by the run, not by its own verdict, so it
+ * counts on its own.
+ */
+export declare function statusBucket(status: ResultStatus): 'passed' | 'failed' | 'interrupted' | 'flaky' | 'skipped';
 /** Counts results by bucket; `total` is the number of items. */
 export declare function tally(items: readonly {
     readonly status: ResultStatus;
 }[]): Counters;
-/** A file's outcome from its tests: failed if any did, skipped if all did, else passed. */
-export declare function fileOutcome(counters: Counters): 'passed' | 'failed' | 'skipped';
-/** `2 failed | 10 passed | 1 flaky (13)` in vitest's colors and order. */
+/** A file's outcome from its tests: failed if any did, else interrupted if any was, skipped if all were, else passed. */
+export declare function fileOutcome(counters: Counters): 'passed' | 'failed' | 'interrupted' | 'skipped';
+/** `2 failed | 1 interrupted | 10 passed | 1 flaky (14)` in vitest's colors and order. */
 export declare function stateString(pc: Colors, counters: Counters): string;
 export interface AiUsage {
     calls: number;
@@ -156,4 +161,3 @@ export declare function fitColumns(text: string, columns: number): string;
  * `repeat`, which the renderers may still be handed.
  */
 export declare function repeatSuffix(repeat: number | undefined): string;
-//# sourceMappingURL=format.d.ts.map

package/dist/report/format.js

@@ -96,11 +96,15 @@ export function rule(text, align) {
     return { before: LONG_DASH.repeat(before), after: LONG_DASH.repeat(after) };
 }
 export function emptyCounters() {
-    return { passed: 0, failed: 0, flaky: 0, skipped: 0, total: 0 };
+    return { passed: 0, failed: 0, interrupted: 0, flaky: 0, skipped: 0, total: 0 };
 }
-/** The counter a result status lands in: every non-success status is a failure. */
+/**
+ * The counter a result status lands in. A timeout is a failure; an
+ * interrupted test was stopped by the run, not by its own verdict, so it
+ * counts on its own.
+ */
 export function statusBucket(status) {
-    return status === 'passed' || status === 'flaky' || status === 'skipped' ? status : 'failed';
+    return status === 'timed-out' ? 'failed' : status;
 }
 /** Counts results by bucket; `total` is the number of items. */
 export function tally(items) {
@@ -111,18 +115,21 @@ export function tally(items) {
     }
     return counters;
 }
-/** A file's outcome from its tests: failed if any did, skipped if all did, else passed. */
+/** A file's outcome from its tests: failed if any did, else interrupted if any was, skipped if all were, else passed. */
 export function fileOutcome(counters) {
     if (counters.failed > 0)
         return 'failed';
+    if (counters.interrupted > 0)
+        return 'interrupted';
     if (counters.total > 0 && counters.skipped === counters.total)
         return 'skipped';
     return 'passed';
 }
-/** `2 failed | 10 passed | 1 flaky (13)` in vitest's colors and order. */
+/** `2 failed | 1 interrupted | 10 passed | 1 flaky (14)` in vitest's colors and order. */
 export function stateString(pc, counters) {
     const parts = [
         counters.failed > 0 ? pc.bold(pc.red(`${counters.failed} failed`)) : undefined,
+        counters.interrupted > 0 ? pc.bold(pc.yellow(`${counters.interrupted} interrupted`)) : undefined,
         pc.bold(pc.green(`${counters.passed} passed`)),
         counters.flaky > 0 ? pc.yellow(`${counters.flaky} flaky`) : undefined,
         counters.skipped > 0 ? pc.gray(`${counters.skipped} skipped`) : undefined,
@@ -423,4 +430,3 @@ export function fitColumns(text, columns) {
 export function repeatSuffix(repeat) {
     return repeat === undefined || repeat === 0 ? '' : ` (repeat #${repeat})`;
 }
-//# sourceMappingURL=format.js.map

package/dist/report/json.d.ts

@@ -1,4 +1,3 @@
 /** The built-in `json` reporter: the report document to stdout, and nothing else there. */
 import type { Reporter } from '../types.ts';
 export declare const jsonReporter: Reporter;
-//# sourceMappingURL=json.d.ts.map

package/dist/report/json.js

@@ -5,4 +5,3 @@ export const jsonReporter = {
         process.stdout.write(`${JSON.stringify(run.report, null, 2)}\n`);
     },
 };
-//# sourceMappingURL=json.js.map

package/dist/report/junit.d.ts

@@ -13,4 +13,3 @@ export declare function renderJunitReport(report: Report1Document): string;
  * beside `report.json`, for CI test summaries.
  */
 export declare const junitReporter: import("../types.ts").Reporter;
-//# sourceMappingURL=junit.d.ts.map

package/dist/report/junit.js

@@ -1,6 +1,7 @@
 /** JUnit XML reporter: the report-1 document as `.e2e/junit.xml`. */
 import { sanitizeText } from '../internal/errors.js';
 import { repeatSuffix } from './format.js';
+import { toldAttempt } from './failure-text.js';
 import { outcome } from './outcome.js';
 import { fileReporter } from './write.js';
 /**
@@ -60,11 +61,9 @@ function addCounts(total, part) {
     total.skipped += part.skipped;
     total.timeMs += part.timeMs;
 }
-/** `<failure>` for a product verdict, `<error>` for anything that prevented one. */
-function verdictElement(error, status) {
-    if (error !== undefined)
-        return error.category === 'test' ? 'failure' : 'error';
-    return status === 'interrupted' ? 'error' : 'failure';
+/** `<failure>` for a product verdict, `<error>` for anything else that prevented one. */
+function verdictElement(error) {
+    return error === undefined || error.category === 'test' ? 'failure' : 'error';
 }
 function errorBody(error) {
     const phase = error.phase === undefined ? '' : ` (${error.phase})`;
@@ -93,18 +92,18 @@ function renderResult(result, groups) {
             };
         }
         case 'skipped':
+        case 'interrupted': {
+            // JUnit has no interrupted outcome; a test the run stopped reached no verdict, so it reads as skipped with why.
+            const message = result.status === 'skipped' ? (result.skip?.reason ?? 'skipped') : `interrupted: ${final.final.error?.message ?? 'the run was stopped'}`;
             return {
-                lines: [
-                    `${open}>`,
-                    `  <skipped ${attributes({ message: result.skip?.reason ?? 'skipped' })}/>`,
-                    '</testcase>',
-                ],
+                lines: [`${open}>`, `  <skipped ${attributes({ message })}/>`, '</testcase>'],
                 outcome: 'skipped',
                 durationMs: final.durationMs,
             };
+        }
         default: {
-            const element = verdictElement(final.final.error, result.status);
-            const error = final.final.error;
+            const error = toldAttempt(result, final).error;
+            const element = verdictElement(error);
             const message = error?.message ?? result.status;
             const type = error?.code ?? result.status;
             const body = error === undefined ? result.status : errorBody(error);
@@ -190,4 +189,3 @@ export function renderJunitReport(report) {
  * beside `report.json`, for CI test summaries.
  */
 export const junitReporter = fileReporter('junit', 'JUnit', 'junit.xml', (run) => renderJunitReport(run.report));
-//# sourceMappingURL=junit.js.map

package/dist/report/list-explore.d.ts

@@ -106,4 +106,3 @@ export declare class ExploreView {
     private banner;
 }
 export {};
-//# sourceMappingURL=list-explore.d.ts.map

package/dist/report/list-explore.js

@@ -366,4 +366,3 @@ function wrap(text, width) {
     }
     return lines;
 }
-//# sourceMappingURL=list-explore.js.map

package/dist/report/list-model.d.ts

@@ -91,4 +91,3 @@ export interface SetupInFlight {
     readonly subject: string;
     readonly startedMs: number;
 }
-//# sourceMappingURL=list-model.d.ts.map

package/dist/report/list-model.js

@@ -7,4 +7,3 @@
 export function isShownEvent(event) {
     return event.kind === 'model' || event.kind === 'engine';
 }
-//# sourceMappingURL=list-model.js.map

package/dist/report/list-steps.d.ts

@@ -28,4 +28,3 @@ export declare function stepLine(pc: Colors, step: FinishedStep, options?: StepL
 export declare function eventLine(pc: Colors, event: ShownEvent, options?: {
     maxWidth?: number;
 }): string;
-//# sourceMappingURL=list-steps.d.ts.map

package/dist/report/list-steps.js

@@ -82,4 +82,3 @@ function reasoningExcerpt(reasoning, headWidth, maxWidth) {
         return undefined;
     return fitColumns(collapseText(reasoning), room);
 }
-//# sourceMappingURL=list-steps.js.map

package/dist/report/list.d.ts

@@ -49,6 +49,7 @@ export declare class ListReporter implements Reporter {
     /** Whether a live window paints; without one, finished steps stream permanently. */
     private readonly live;
     private readonly failures;
+    private readonly skippedFailures;
     /** Every finished test's run, for the `Repeats` summary of a `--repeat-each` run. */
     private readonly runs;
     /**
@@ -257,4 +258,3 @@ export declare class ListReporter implements Reporter {
     rows(rows: ReporterSummary): void;
     private runFinished;
 }
-//# sourceMappingURL=list.d.ts.map

package/dist/report/list.js

@@ -8,6 +8,7 @@
 import path from 'node:path';
 import picocolors from 'picocolors';
 import { packageVersion } from '../internal/package-version.js';
+import { failureBeforeSkip } from '../run/records.js';
 import { codeFrame, userFrame } from './code-frame.js';
 import { addCacheTally, addModelTally, addUsage, aiSegment, bounded, cacheText, durationText, fitColumns, emptyCacheTally, emptyCounters, emptyUsage, F_CHECK, F_CROSS, F_POINTER, fileOutcome, formatClock, formatTime, modelsText, padTitle, rule, stateString, statusBucket, stepsCacheTally, repeatSuffix, stepsModelTally, stepsUsage, sumUsage, tally, terminalColumns, usageText, } from './format.js';
 import { ExploreView } from './list-explore.js';
@@ -43,14 +44,16 @@ function pairKey(testId, agent, target, repeat) {
 /** Details of an ordinary result: summed over its attempts, the error from the last. */
 function attemptDetails(attempts) {
     const steps = attempts.map((attempt) => attempt.steps);
+    // A retry the run interrupted tells nothing; the failure before it is the verdict.
+    const told = attempts.findLast((attempt) => attempt.status !== 'interrupted') ?? attempts.at(-1);
     return {
         durationMs: attempts.reduce((total, attempt) => total + attempt.durationMs, 0),
         usage: stepsUsage(steps),
         models: stepsModelTally(steps),
         cache: stepsCacheTally(steps),
-        error: attempts[attempts.length - 1]?.error,
+        error: told?.error,
         videos: videoPaths(attempts),
-        ...failureOf(attempts[attempts.length - 1]),
+        ...failureOf(told),
     };
 }
 /** The failure evidence of one attempt, and the path of the screen text it points at. */
@@ -85,7 +88,7 @@ function serialMemberDetails(group, testId) {
         attempt,
         member: attempt.members.find((member) => member.testId === testId),
     }));
-    const last = runs[runs.length - 1];
+    const last = runs.findLast((run) => run.attempt.status !== 'interrupted') ?? runs.at(-1);
     const own = last?.member;
     const neverRan = own === undefined || own.status === 'skipped';
     const steps = runs.map((run) => run.member?.steps ?? []);
@@ -135,6 +138,7 @@ export class ListReporter {
     /** Whether a live window paints; without one, finished steps stream permanently. */
     live;
     failures = [];
+    skippedFailures = [];
     /** Every finished test's run, for the `Repeats` summary of a `--repeat-each` run. */
     runs = [];
     /**
@@ -550,15 +554,17 @@ export class ListReporter {
         const steps = this.pairs.get(key)?.steps ?? [];
         this.pairs.delete(key);
         const group = this.group(result.test.file, result.target.name);
+        // Read before `detailsOf` releases the result's serial group.
+        const skippedAfter = failureBeforeSkip(result, (id) => this.pendingSerial.get(id)?.group);
         const { durationMs, usage, models, cache, error, videos, failure, screenPath } = this.detailsOf(result);
         addUsage(this.runUsage, usage);
         addModelTally(this.runModels, models);
         addCacheTally(this.runCache, cache);
         const title = this.titledAs(result.test.titlePath.join(' > '), result.agent, result.repeat);
         if (this.explore !== undefined) {
-            // The exploration's verdict is its findings; any other error is a failure of its own.
+            // The exploration's verdict is its findings; any other error is a failure of its own, unless the run stopped it.
             this.explore.result(result.attempts.flatMap((attempt) => attempt.artifacts));
-            if (error !== undefined && !this.explore.isVerdict(error)) {
+            if (error !== undefined && result.status !== 'interrupted' && !this.explore.isVerdict(error)) {
                 this.failures.push({ group, title, status: result.status, error, videos, failure, screenPath });
             }
             this.window.redraw();
@@ -584,6 +590,9 @@ export class ListReporter {
         if (statusBucket(result.status) === 'failed') {
             this.failures.push({ group, title, status: result.status, error, videos, failure, screenPath });
         }
+        if (skippedAfter !== undefined) {
+            this.skippedFailures.push({ group, title, status: result.status, error: skippedAfter.error, videos, ...failureOf(skippedAfter) });
+        }
         if (group.planned !== undefined && group.lines.length >= group.planned)
             this.printGroup(group);
         this.window.redraw();
@@ -623,12 +632,15 @@ export class ListReporter {
         const outcome = fileOutcome(counts);
         const symbol = outcome === 'failed'
             ? pc.red(F_POINTER)
-            : outcome === 'skipped'
-                ? pc.dim(pc.gray(F_DOWN))
-                : pc.green(F_CHECK);
+            : outcome === 'interrupted'
+                ? pc.yellow(F_POINTER)
+                : outcome === 'skipped'
+                    ? pc.dim(pc.gray(F_DOWN))
+                    : pc.green(F_CHECK);
         const state = [
             pc.dim(`${counts.total} test${counts.total === 1 ? '' : 's'}`),
             counts.failed > 0 ? pc.red(`${counts.failed} failed`) : undefined,
+            counts.interrupted > 0 ? pc.yellow(`${counts.interrupted} interrupted`) : undefined,
             counts.flaky > 0 ? pc.yellow(`${counts.flaky} flaky`) : undefined,
             counts.skipped > 0 ? pc.yellow(`${counts.skipped} skipped`) : undefined,
         ]
@@ -647,6 +659,7 @@ export class ListReporter {
             parts.push(pc.dim(ai));
         this.print(parts.join(' '));
         const verbose = counts.failed > 0 ||
+            counts.interrupted > 0 ||
             counts.flaky > 0 ||
             this.groups.size === 1 ||
             (this.live && group.lines.some((line) => line.steps.length > 0));
@@ -678,6 +691,8 @@ export class ListReporter {
                     : pc.dim(pc.gray(` [${line.skipReason}]`));
                 return [`   ${pc.dim(pc.gray(F_DOWN))} ${line.title}${reason}`];
             }
+            case 'interrupted':
+                return [`   ${pc.yellow(F_CROSS)} ${line.title} ${pc.yellow('(interrupted)')} ${duration}${ai}`];
             default: {
                 const status = line.status === 'failed' ? '' : pc.red(` (${line.status})`);
                 const rows = [`   ${pc.red(`${F_CROSS} ${line.title}`)}${status} ${duration}${ai}`];
@@ -716,6 +731,9 @@ export class ListReporter {
             rows.push(padTitle(pc, 'Cache') + cache);
         if (final)
             rows.push(...this.repeatRows());
+        if (this.skippedFailures.length > 0) {
+            rows.push(padTitle(pc, 'Warnings') + pc.yellow(`${this.skippedFailures.length} skipped after failure`));
+        }
         if (this.errors.length > 0) {
             const count = this.errors.length;
             rows.push(padTitle(pc, 'Errors') + pc.bold(pc.red(`${count} error${count === 1 ? '' : 's'}`)));
@@ -736,11 +754,12 @@ export class ListReporter {
         const groups = repeatGroups(this.runs, (entry) => entry);
         if (groups.length === 0)
             return [];
-        const unstable = groups.filter((group) => group.passed < group.runs.length);
+        // A test is listed when it missed a run: a flake first, then one the run cut short.
+        const missed = groups.filter((group) => group.passed < group.runs.length).toSorted((a, b) => Number(b.unstable) - Number(a.unstable));
         const summary = repeatSummary(groups);
         return [
-            padTitle(pc, 'Repeats') + (unstable.length === 0 ? pc.green(summary) : pc.yellow(summary)),
-            ...unstable.map((group) => `${padTitle(pc, '')}${pc.yellow(F_CROSS)} ${group.label}  ${pc.dim(repeatLine(group))}`),
+            padTitle(pc, 'Repeats') + (missed.some((group) => group.unstable) ? pc.yellow(summary) : pc.green(summary)),
+            ...missed.map((group) => `${padTitle(pc, '')}${group.unstable ? pc.yellow(F_CROSS) : pc.dim(pc.gray(F_DOWN))} ${group.label}  ${pc.dim(repeatLine(group))}`),
         ];
     }
     /** A zero counter's label: the plain text, or the interrupt when that is why nothing is counted. */
@@ -808,15 +827,15 @@ export class ListReporter {
             this.print(line);
     }
     /** vitest's `Failed Tests` section: a banner, then each failure with its code frame. */
-    printFailures() {
+    printFailures(heading, failures) {
         const { pc } = this;
-        if (this.failures.length === 0)
+        if (failures.length === 0)
             return;
         this.print('');
-        this.print(this.errorBanner(`Failed Tests ${this.failures.length}`));
+        this.print(this.errorBanner(`${heading} ${failures.length}`));
         this.print('');
-        this.failures.forEach(({ group, title, status, error, videos, failure, screenPath }, index) => {
-            this.print(`${pc.bold(pc.bgRed(' FAIL '))} ${this.badge(group.target)} ${bounded(group.file)}${this.separator}${title}`);
+        failures.forEach(({ group, title, status, error, videos, failure, screenPath }, index) => {
+            this.print(`${pc.bold(pc.bgRed(status === 'skipped' ? ' SKIP ' : ' FAIL '))} ${this.badge(group.target)} ${bounded(group.file)}${this.separator}${title}`);
             if (error === undefined) {
                 this.print(pc.red(`${pc.bold(status)}: no error was recorded`));
             }
@@ -829,7 +848,7 @@ export class ListReporter {
             }
             this.printEvidence(failure, screenPath);
             this.printVideos(videos);
-            const marker = `[${index + 1}/${this.failures.length}]`;
+            const marker = `[${index + 1}/${failures.length}]`;
             const { before, after } = rule(marker, 'right');
             this.print('');
             this.print(pc.red(pc.dim(`${before}${marker}${after}`)));
@@ -925,7 +944,8 @@ export class ListReporter {
                 this.printGroup(group);
         }
         this.printExplore();
-        this.printFailures();
+        this.printFailures('Failed Tests', this.failures);
+        this.printFailures('Skipped After Failure', this.skippedFailures);
         this.printErrors();
         this.print('');
         for (const row of this.summaryRows(true))
@@ -959,4 +979,3 @@ function setupWording(step) {
             return { verb: 'starting', subject: bounded(step.label), done: 'ready' };
     }
 }
-//# sourceMappingURL=list.js.map

package/dist/report/live-window.d.ts

@@ -50,4 +50,3 @@ export declare class LiveWindow {
      */
     stop(): void;
 }
-//# sourceMappingURL=live-window.d.ts.map