e2e 0.16.0 → 0.17.0

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/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

@@ -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,8 @@ 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>;

package/dist/run/retry.js

@@ -8,7 +8,9 @@ export function isRetryEligible(attempt) {
  * 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 async function runWithRetries(maxAttempts, interruptSignal, runOnce) {
     let finalStatus = 'failed';
@@ -23,7 +25,7 @@ export async function runWithRetries(maxAttempts, interruptSignal, runOnce) {
         if (attempt.status === 'passed')
             return attemptCount > 1 ? 'flaky' : 'passed';
         if (attempt.status === 'interrupted')
-            return 'interrupted';
+            return attemptCount > 1 ? finalStatus : 'interrupted';
         // A body that skipped itself has decided; a retry would only ask again.
         if (attempt.status === 'skipped')
             return 'skipped';

package/dist/run/runner.d.ts

@@ -5,7 +5,7 @@ import { type Shard, type TagMode } from '../collect/select.ts';
 import type { ExploreProgress } from '../explore/progress.ts';
 import { type Report1Document, type ReportExplore } from '../report/build.ts';
 import { type RunEventSink, type RunExitCode, type RunStatus } from './events.ts';
-import type { ResultRecord } from './records.ts';
+import { type ResultRecord } from './records.ts';
 import type { BuiltinReporter, E2EConfig, RecordingMode } from '../types.ts';
 export interface RunOptions {
     cwd?: string | undefined;

package/dist/run/runner.js

@@ -18,11 +18,13 @@ import { writeJsonReport } from '../report/write.js';
 import { createRunEventEmitter, toEventResult } from './events.js';
 import { allocateAppPorts } from './app-ports.js';
 import { inProcessSpawner } from './in-process.js';
+import { someSkippedAfterFailure } from './records.js';
 import { runUnits } from './scheduler.js';
 import { buildWorkPlans, plannedSlots } from './units.js';
 import { SessionStore } from './sessions.js';
 import { outputLayout } from './output.js';
-import { lastFailedIds, readLastRun } from './last-run.js';
+import { claimRerunDir, pruneArtifacts } from './artifacts.js';
+import { carryForward, lastFailedIds, readLastRun, reportArtifactPaths } from './last-run.js';
 import { childProcessSpawner } from './worker/handle.js';
 import { setSecretRegistry } from '../secrets.js';
 import { withAbort } from '../internal/time.js';
@@ -187,25 +189,38 @@ export async function run(options = {}) {
      */
     const currentExitCode = () => combineExitCodes([
         ...resultExitCodes(results),
+        ...(loaded.config?.failOnSkippedFailure === true && someSkippedAfterFailure(results, serialGroups) ? [1] : []),
         ...runErrors.map((runError) => exitCodeForCategory(runError.error.category)),
         ...(interruptController.signal.aborted ? [130] : []),
     ].filter((code) => code !== 130 || !(runAborted || stoppedEarly)));
     // Detected once the config names the project root; a report written before
     // that (a config failure) has no checkout to describe.
     let vcs;
-    const buildRunReport = (exitCode) => buildReport({
-        runId,
-        config: loaded.config,
-        vcs,
-        startedAt,
-        status: statusOf(exitCode),
-        exitCode,
-        results,
-        serialGroups,
-        runErrors,
-        targetProvenance,
-        explore: options.tests?.explore?.snapshot(),
-    });
+    // The report `--last-failed` selected from, once collection has read it;
+    // reporters get it beside this run's report to fold the rerun into it, and
+    // this run's report carries what it owed that this run left out.
+    let lastRun;
+    // The ids of every test collection found, a setup no selected test needed
+    // among them, and the files it could not collect: what a rerun can still
+    // carry when the report lists no row.
+    let rerunCollection = { testIds: new Set(), uncollectedFiles: new Set() };
+    const buildRunReport = (exitCode) => {
+        const document = buildReport({
+            runId,
+            config: loaded.config,
+            vcs,
+            startedAt,
+            status: statusOf(exitCode),
+            exitCode,
+            results,
+            serialGroups,
+            runErrors,
+            targetProvenance,
+            explore: options.tests?.explore?.snapshot(),
+        });
+        const carried = lastRun === undefined ? undefined : carryForward(lastRun, document, rerunCollection);
+        return carried === undefined ? document : { ...document, run: { ...document.run, carried } };
+    };
     /**
      * Writes the canonical report and returns its path only once the file
      * exists: a host must never be handed a path to a report that was not
@@ -249,9 +264,6 @@ export async function run(options = {}) {
             return undefined;
         }
     };
-    // The report `--last-failed` selected from, once collection has read it;
-    // reporters get it beside this run's report to fold the rerun into it.
-    let lastRun;
     /**
      * Whether the run got as far as its tests. Only such a run writes into the
      * output directory: one that stopped before leaves the previous run's
@@ -364,6 +376,10 @@ export async function run(options = {}) {
                     : collectInMemory(config.projectRoot, options.tests.file, options.tests.registration, consumesSession(options.tests.registration) ? await collectSetups(config) : undefined);
                 const inputs = await selectionInputs(options, config);
                 lastRun = inputs.lastRun;
+                rerunCollection = {
+                    testIds: new Set(collection.tests.map((test) => test.id)),
+                    uncollectedFiles: new Set(collection.uncollected.map((skipped) => skipped.file)),
+                };
                 const selection = repeatEach(select(collection, config, inputs.filters, options.passWithNoTests !== undefined ? { passWithNoTests: options.passWithNoTests } : {}), options.repeatEach ?? 1);
                 return { collection, selection };
             }));
@@ -450,15 +466,26 @@ export async function run(options = {}) {
         // Tests are about to start, and only now is the previous run's evidence
         // given up: the artifact tree is emptied, so what is there once this run
         // ends is its own and nothing a report no longer names, and this run's
-        // report replaces the last. A run that stopped before here (no test
-        // selected, a collection error, a target that cannot record what it asks,
-        // an app that failed to start, an interrupt) leaves both, and
+        // report replaces the last. A `--last-failed` rerun keeps the evidence
+        // the report it reruns names instead, since that report's results fold
+        // into the rerun's and its carried tests do not run again, and files its
+        // own attempts in a fresh `rerun-<n>` directory beside it, so no attempt
+        // overwrites an earlier one's files. A run that stopped before here (no
+        // test selected, a collection error, a target that cannot record what it
+        // asks, an app that failed to start, an interrupt) leaves both, and
         // `--last-failed` still reads the run that executed. A wipe that fails
         // part way has already given up the old evidence, so this run's report
         // records the failure.
         testsStarted = true;
+        let rerunDir;
         try {
-            await rm(layout.artifacts, { recursive: true, force: true });
+            if (lastRun === undefined) {
+                await rm(layout.artifacts, { recursive: true, force: true });
+            }
+            else {
+                await pruneArtifacts(layout.artifacts, reportArtifactPaths(lastRun));
+                rerunDir = await claimRerunDir(layout.artifacts);
+            }
         }
         catch (cause) {
             recordFailure(cause, 'launch');
@@ -482,6 +509,7 @@ export async function run(options = {}) {
                 inMemory: options.tests,
                 runId,
                 artifactsRoot,
+                rerunDir,
                 sessionStore: store,
                 headed: options.headed ?? false,
                 debug,
@@ -495,6 +523,7 @@ export async function run(options = {}) {
                 ports: config.ports,
                 runId,
                 artifactsRoot,
+                rerunDir,
                 headed: options.headed ?? false,
                 sessionsRoot: layout.sessions,
                 sessionKeyBase64: store.exportKeyForWorker(),
@@ -747,13 +776,21 @@ function resultExitCodes(results) {
 /** Why a reporter's `onRunFinished` was given up on: the message is the stderr line. */
 class ReporterAbandoned extends Error {
 }
+/**
+ * The built-in reporters that write files beside `report.json`. A forced
+ * interrupt never abandons them: they are local writes, and giving one up
+ * would leave the previous run's `summary.md` or `junit.xml` beside this
+ * run's report, where CI reads it as this run's.
+ */
+const FILE_REPORTERS = new Set([STATELESS_REPORTERS.junit, STATELESS_REPORTERS.markdown]);
 /**
  * Awaits every reporter's `onRunFinished` at once, each within `timeoutMs`
- * and until a forced interrupt, and collects the summary rows they resolve
- * with. Each reporter gets a signal that aborts on either, so a well-behaved
- * one cancels its own work and leaves no handle holding the process. A
- * reporter that throws, runs out of time, or returns something other than
- * rows is one line on stderr; it can never change the run's outcome.
+ * and, except the built-in file reporters, until a forced interrupt, and
+ * collects the summary rows they resolve with. Each reporter gets a signal
+ * that aborts on either, so a well-behaved one cancels its own work and
+ * leaves no handle holding the process. A reporter that throws, runs out of
+ * time, or returns something other than rows is one line on stderr; it can
+ * never change the run's outcome.
  */
 async function runReporters(reporters, finished, timeoutMs, force) {
     const warn = (reporter, detail) => {
@@ -767,10 +804,12 @@ async function runReporters(reporters, finished, timeoutMs, force) {
         const abandon = new AbortController();
         const timer = setTimeout(() => abandon.abort(new ReporterAbandoned(`did not finish within ${budget}`)), timeoutMs);
         const onForce = () => abandon.abort(new ReporterAbandoned('abandoned: the run was forced to stop'));
-        if (force.aborted)
-            onForce();
-        else
-            force.addEventListener('abort', onForce, { once: true });
+        if (!FILE_REPORTERS.has(reporter)) {
+            if (force.aborted)
+                onForce();
+            else
+                force.addEventListener('abort', onForce, { once: true });
+        }
         try {
             const result = await withAbort(() => Promise.resolve(onRunFinished.call(reporter, finished, abandon.signal)), abandon.signal, () => abandon.signal.reason);
             if (result === undefined)

package/dist/run/serial.d.ts

@@ -37,6 +37,8 @@ export interface SharedSerialSession {
 export interface SerialHost {
     readonly target: ResolvedTarget;
     readonly artifactsRoot: string;
+    /** See `TargetExecutorOptions.rerunDir`. */
+    readonly rerunDir: string | undefined;
     readonly runId: string;
     /** The configured artifact store, so group-owned artifacts (the shared trace) upload like any other. */
     readonly artifactStore: ArtifactStore | undefined;

package/dist/run/serial.js

@@ -3,7 +3,7 @@ import { classifyError, ConfigurationError, serializeError, } from '../internal/
 import { canonicalDigest, timestamp, uuidv7 } from '../internal/ids.js';
 import { groupTitles } from '../collect/registry.js';
 import { pairRecordings } from '../collect/select.js';
-import { createAttemptArtifacts, sanitizePathSegment } from './artifacts.js';
+import { attemptSegments, createAttemptArtifacts, sanitizePathSegment } from './artifacts.js';
 import { findRegistered, RealmManager } from './realm.js';
 import { isFailedStatus } from './records.js';
 import { runWithRetries } from './retry.js';
@@ -35,8 +35,11 @@ export async function runSerialUnit(host, members, file) {
     const finalStatus = await runWithRetries(first.options.retries + 1, host.interruptSignal, async (attemptIndex) => {
         const attempt = await runSerialAttempt(host, members, file, attemptIndex);
         group.attempts.push(attempt);
-        for (const member of attempt.members)
-            memberFinalStatus.set(member.testId, member);
+        // A retry the run interrupted keeps the verdict before it, so each member keeps what that attempt said.
+        const cutRetry = attemptIndex > 0 && attempt.status === 'interrupted';
+        if (!cutRetry)
+            for (const member of attempt.members)
+                memberFinalStatus.set(member.testId, member);
         // A beforeAll failure is not retry-eligible: the
         // attempt stands as recorded and the retry loop stops here.
         if (attempt.error?.code === 'HOOK_FAILED')
@@ -88,13 +91,13 @@ async function runSerialAttempt(host, members, file, attemptIndex) {
     const memberRecords = [];
     const first = members[0];
     const recordings = pairRecordings(first, attemptIndex);
-    const artifactSegments = [
+    const artifactSegments = attemptSegments(host.rerunDir, [
         host.target.name,
         sanitizePathSegment(first.test.serialId ?? first.test.id),
         first.agent,
         ...repeatSegment(first.repeat),
         `attempt-${attemptIndex}`,
-    ];
+    ]);
     const artifacts = createAttemptArtifacts({
         artifactsRoot: host.artifactsRoot,
         segments: artifactSegments,

package/dist/run/steps.d.ts

@@ -271,12 +271,6 @@ export interface StepRecorderOptions {
     /** Replaces secret values in a step's label, and in its error's message and details, before the record keeps them. */
     readonly redact?: (text: string) => string;
 }
-/**
- * Whether an unhandled rejection is an abandoned step's: already recorded as
- * `STEP_NOT_AWAITED`, reaching the process only because the promise the
- * test did not await rejected with it. Such a rejection is not a fault.
- */
-export declare function isAbandonedStepRejection(cause: unknown): boolean;
 export declare class StepRecorder {
     private readonly attemptId;
     private readonly attempt;

package/dist/run/steps.js

@@ -1,6 +1,7 @@
 /** Attempt-scoped step timeline. */
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { isAgentError } from '../agent/error.js';
+import { markAbandonedRejection, relocateStack } from '../internal/abandoned.js';
 import { withAiTraceStep } from '../internal/ai-trace.js';
 import { classifyError, serializeError, TestError, withHint } from '../internal/errors.js';
 import { timestamp } from '../internal/ids.js';
@@ -9,16 +10,6 @@ import { sourceLocation } from '../internal/source.js';
 export const STEP_KINDS = ['agent', 'locator', 'assertion', 'screen', 'app', 'session', 'resource'];
 /** Frames kept when a step captures where it was called from; the user's line is a few frames up. */
 const STEP_STACK_FRAMES = 20;
-/** What abandoned steps rejected with. The promise the test holds rejects with the same value, and nobody awaits it. */
-const ABANDONED_REJECTIONS = new WeakSet();
-/**
- * Whether an unhandled rejection is an abandoned step's: already recorded as
- * `STEP_NOT_AWAITED`, reaching the process only because the promise the
- * test did not await rejected with it. Such a rejection is not a fault.
- */
-export function isAbandonedStepRejection(cause) {
-    return typeof cause === 'object' && cause !== null && ABANDONED_REJECTIONS.has(cause);
-}
 /**
  * The stack at a step's start, or nothing without a project root to read it
  * against. Every step pays the capture, since the failing one is not known
@@ -38,13 +29,6 @@ function stepStack(projectRoot) {
         Error.stackTraceLimit = limit;
     }
 }
-/** Points `error` at the frames of `stack`, keeping its own name and message as the first line. */
-function relocate(error, stack) {
-    if (stack === undefined)
-        return;
-    const frames = stack.split('\n').slice(1).join('\n');
-    error.stack = `${error.name}: ${error.message}\n${frames}`;
-}
 /** Characters of a step label an error message quotes before clipping it. */
 const MAX_QUOTED_LABEL_CHARS = 80;
 function quoted(label) {
@@ -137,8 +121,7 @@ export class StepRecorder {
         }
         catch (cause) {
             if (this.abandoned.has(record.id)) {
-                if (typeof cause === 'object' && cause !== null)
-                    ABANDONED_REJECTIONS.add(cause);
+                markAbandonedRejection(cause);
                 throw cause;
             }
             record.durationMs = Date.now() - startedMs;
@@ -177,7 +160,7 @@ export class StepRecorder {
         for (const step of running) {
             const more = first === undefined && running.length > 1 ? ` and ${running.length - 1} more` : '';
             const error = new TestError('STEP_NOT_AWAITED', withHint(`the test body returned before ${step.api} ${quoted(step.label)}${more} finished`, 'put `await` in front of every step call'));
-            relocate(error, this.stacks.get(step.id));
+            relocateStack(error, this.stacks.get(step.id));
             first ??= error;
             this.abandoned.add(step.id);
             step.status = 'failed';