e2e 0.16.0 → 0.17.0

package/dist/report/repeats.d.ts

@@ -15,6 +15,11 @@ export interface RepeatGroup {
     readonly runs: readonly RepeatRun[];
     /** Runs that passed on their first attempt; a flaky run needed a retry and does not count. */
     readonly passed: number;
+    /**
+     * Whether a run that reached a verdict did not pass: a flake. A run the
+     * run interrupted, or never started, says nothing about the test.
+     */
+    readonly unstable: boolean;
 }
 /**
  * Groups runs by `key`, keeping only tests that ran more than once and did
@@ -27,5 +32,5 @@ export declare function repeatGroups<T>(items: readonly T[], describe: (item: T)
 }): RepeatGroup[];
 /** `2 of 3 tests passed all 5 runs`; the run count is the most any test had. */
 export declare function repeatSummary(groups: readonly RepeatGroup[]): string;
-/** `3/5 passed · repeat 0 ASSERTION_FAILED · repeat 2 flaky`, naming each run that did not pass. */
+/** `3/5 passed · repeat 0 ASSERTION_FAILED · repeat 2 flaky · repeat 4 interrupted`, naming each run that did not pass. */
 export declare function repeatLine(group: RepeatGroup): string;

package/dist/report/repeats.js

@@ -3,6 +3,8 @@
  * of one test, target, and agent side by side, so a flake reads as `3/5
  * passed` with the runs that did not, instead of five results to count.
  */
+/** Statuses of a run that reached no verdict: stopped by the run, or never started. */
+const UNDECIDED = new Set(['interrupted', 'skipped']);
 /**
  * Groups runs by `key`, keeping only tests that ran more than once and did
  * not skip every run, in first-seen order.
@@ -19,7 +21,12 @@ export function repeatGroups(items, describe) {
         .filter((group) => group.runs.length > 1 && group.runs.some((run) => run.status !== 'skipped'))
         .map((group) => {
         const runs = group.runs.toSorted((a, b) => a.repeat - b.repeat);
-        return { label: group.label, runs, passed: runs.filter((run) => run.status === 'passed').length };
+        return {
+            label: group.label,
+            runs,
+            passed: runs.filter((run) => run.status === 'passed').length,
+            unstable: runs.some((run) => run.status !== 'passed' && !UNDECIDED.has(run.status)),
+        };
     });
 }
 /** `2 of 3 tests passed all 5 runs`; the run count is the most any test had. */
@@ -28,13 +35,15 @@ export function repeatSummary(groups) {
     const runs = Math.max(...groups.map((group) => group.runs.length));
     return `${stable} of ${groups.length} test${groups.length === 1 ? '' : 's'} passed all ${runs} runs`;
 }
-/** A run that did not pass, in a word: its error code, or `flaky` with the code its retry recovered from. */
+/** A run that did not pass, in a word: its error code, `flaky` with the code its retry recovered from, or why it reached no verdict. */
 function outcomeOf(run) {
     if (run.status === 'flaky')
         return run.code === undefined ? 'flaky' : `flaky (${run.code})`;
+    if (UNDECIDED.has(run.status))
+        return run.status;
     return run.code ?? run.status;
 }
-/** `3/5 passed · repeat 0 ASSERTION_FAILED · repeat 2 flaky`, naming each run that did not pass. */
+/** `3/5 passed · repeat 0 ASSERTION_FAILED · repeat 2 flaky · repeat 4 interrupted`, naming each run that did not pass. */
 export function repeatLine(group) {
     const misses = group.runs
         .filter((run) => run.status !== 'passed')

package/dist/run/artifacts.d.ts

@@ -56,6 +56,24 @@ export declare function createAttemptArtifacts(options: {
         readonly attemptId?: string;
     };
 }): AttemptArtifacts;
+/**
+ * Empties an artifact tree down to the files `keep` names, by their report
+ * paths, and removes the directories left empty. A `--last-failed` rerun
+ * starts this way rather than from an empty tree: the evidence the report it
+ * reruns names stays, since that report's results fold into the rerun's and
+ * its carried tests are not run again.
+ */
+export declare function pruneArtifacts(root: string, keep: ReadonlySet<string>): Promise<void>;
+/**
+ * Claims the directory a `--last-failed` rerun's attempts write under, beside
+ * the evidence it kept, and returns its name: `rerun-<n>`, past every number
+ * already there, so the tree reads in run order. The directory is created
+ * exclusively, so no attempt of the rerun writes into a directory an earlier
+ * run's report still names.
+ */
+export declare function claimRerunDir(root: string): Promise<string>;
+/** An attempt's report segments, under the rerun's directory on a `--last-failed` rerun. */
+export declare function attemptSegments(rerunDir: string | undefined, segments: readonly string[]): readonly string[];
 /**
  * Restricts a report path segment to a safe filename alphabet and length. A
  * value that is already safe and within the cap is unchanged. Any other value

package/dist/run/artifacts.js

@@ -1,7 +1,7 @@
 /** Attempt-scoped artifact directory and report registration. */
 import { createHash } from 'node:crypto';
 import { createReadStream, mkdirSync } from 'node:fs';
-import { readFile, stat } from 'node:fs/promises';
+import { mkdir, readdir, readFile, rm, rmdir, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { pipeline } from 'node:stream/promises';
 import { writeFileAtomic } from '../internal/atomic-write.js';
@@ -156,6 +156,73 @@ export function createAttemptArtifacts(options) {
     };
     return { dir, records, sink, settle };
 }
+/** What a `--last-failed` rerun's attempt directory is called, `rerun-<n>`, numbered from 1. */
+const RERUN_DIR = /^rerun-([1-9][0-9]*)$/;
+/**
+ * Empties an artifact tree down to the files `keep` names, by their report
+ * paths, and removes the directories left empty. A `--last-failed` rerun
+ * starts this way rather than from an empty tree: the evidence the report it
+ * reruns names stays, since that report's results fold into the rerun's and
+ * its carried tests are not run again.
+ */
+export async function pruneArtifacts(root, keep) {
+    const prune = async (dir, relative) => {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch (cause) {
+            if (cause.code === 'ENOENT')
+                return true;
+            throw cause;
+        }
+        let empty = true;
+        for (const entry of entries) {
+            const reportPath = relative === '' ? entry.name : `${relative}/${entry.name}`;
+            const absolute = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (await prune(absolute, reportPath))
+                    await rmdir(absolute);
+                else
+                    empty = false;
+            }
+            else if (keep.has(reportPath)) {
+                empty = false;
+            }
+            else {
+                await rm(absolute, { force: true });
+            }
+        }
+        return empty;
+    };
+    await prune(root, '');
+}
+/**
+ * Claims the directory a `--last-failed` rerun's attempts write under, beside
+ * the evidence it kept, and returns its name: `rerun-<n>`, past every number
+ * already there, so the tree reads in run order. The directory is created
+ * exclusively, so no attempt of the rerun writes into a directory an earlier
+ * run's report still names.
+ */
+export async function claimRerunDir(root) {
+    await mkdir(root, { recursive: true });
+    const taken = (await readdir(root)).map((name) => Number(RERUN_DIR.exec(name)?.[1] ?? 0));
+    for (let n = Math.max(0, ...taken) + 1;; n += 1) {
+        const name = `rerun-${n}`;
+        try {
+            await mkdir(path.join(root, name));
+            return name;
+        }
+        catch (cause) {
+            if (cause.code !== 'EEXIST')
+                throw cause;
+        }
+    }
+}
+/** An attempt's report segments, under the rerun's directory on a `--last-failed` rerun. */
+export function attemptSegments(rerunDir, segments) {
+    return rerunDir === undefined ? segments : [rerunDir, ...segments];
+}
 /**
  * Rewrites a text-like download through the session's ledger, the way a
  * trace's text entries are, and returns the redaction the record can claim:

package/dist/run/execute.d.ts

@@ -34,6 +34,12 @@ export interface TargetExecutorOptions {
     readonly target: ResolvedTarget;
     readonly runId: string;
     readonly artifactsRoot: string;
+    /**
+     * The directory under `artifactsRoot` a `--last-failed` rerun's attempts
+     * write in (`claimRerunDir`), beside the evidence of the run it reruns;
+     * undefined when the attempts fill the root themselves.
+     */
+    readonly rerunDir?: string | undefined;
     readonly sessionStore: SessionStore;
     readonly headed: boolean;
     /** This worker's slot among the target's workers; see `EngineInitInfo.workerSlot`. */
@@ -103,6 +109,7 @@ export declare class TargetExecutor implements SerialHost {
     get runId(): string;
     get artifactStore(): ArtifactStore | undefined;
     readonly artifactsRoot: string;
+    readonly rerunDir: string | undefined;
     readonly interruptSignal: AbortSignal;
     readonly realms: RealmManager;
     readonly debug: DebugTrace;
@@ -113,6 +120,8 @@ export declare class TargetExecutor implements SerialHost {
     private lastAttemptTestId;
     private readonly models;
     private readonly sessionIdentity;
+    /** The file store's listing under `cache.strict`, read once for every attempt here. */
+    private readonly storedRecordings;
     /** Resolves once the engine's init hook completed for this worker. */
     private engineReady;
     constructor(options: TargetExecutorOptions);

package/dist/run/execute.js

@@ -10,14 +10,16 @@ import { timestamp, uuidv7 } from '../internal/ids.js';
 import { engineAppInfo } from '../config/app.js';
 import { Deadline, NEVER_ABORTS, withAbort, withScopedBudget, withTimeout } from '../internal/time.js';
 import { createAgentCacheContext, flushStagedTraces } from '../cache/context.js';
+import { storedRecordingsFor } from '../cache/rekeyed.js';
 import { pairRecordings } from '../collect/select.js';
-import { createAttemptArtifacts, sanitizePathSegment } from './artifacts.js';
+import { attemptSegments, createAttemptArtifacts, sanitizePathSegment } from './artifacts.js';
 import { AttemptBudget } from './budget.js';
 import { createEngineSession } from '../engine/session.js';
 import { createExtendedFixtures } from './extended-fixtures.js';
 import { captureFailureEvidence } from './failure-evidence.js';
 import { createFixtures } from './fixtures.js';
 import { publishAttempt } from '../expect/attempt.js';
+import { PollScope, runInPollScope } from '../expect/poll-scope.js';
 import { SoftFailures } from '../expect/soft.js';
 import { findRegistered, RealmManager, runHook } from './realm.js';
 import { isFailedStatus } from './records.js';
@@ -43,6 +45,7 @@ export class TargetExecutor {
         return this.config.artifactStore;
     }
     artifactsRoot;
+    rerunDir;
     interruptSignal;
     realms;
     debug;
@@ -53,12 +56,15 @@ export class TargetExecutor {
     lastAttemptTestId;
     models;
     sessionIdentity;
+    /** The file store's listing under `cache.strict`, read once for every attempt here. */
+    storedRecordings;
     /** Resolves once the engine's init hook completed for this worker. */
     engineReady;
     constructor(options) {
         this.options = options;
         this.target = options.target;
         this.artifactsRoot = options.artifactsRoot;
+        this.rerunDir = options.rerunDir;
         this.interruptSignal = options.interruptSignal;
         this.debug = options.debug ?? new DebugTrace(false);
         this.models = new WorkerModels((error) => {
@@ -74,6 +80,7 @@ export class TargetExecutor {
             debug: this.debug,
         });
         this.sessionIdentity = targetIdentity(options.target);
+        this.storedRecordings = storedRecordingsFor(options.config.cache);
     }
     get config() {
         return this.options.config;
@@ -588,7 +595,13 @@ export class TargetExecutor {
             // agent and repeat segments keep a test run as several agents, or
             // several times, from overwriting itself.
             segments: shared?.artifactSegments ??
-                [this.target.name, sanitizePathSegment(registered.artifactName ?? pair.test.id), pair.agent, ...repeatSegment(pair.repeat), `attempt-${attemptIndex}`],
+                attemptSegments(this.rerunDir, [
+                    this.target.name,
+                    sanitizePathSegment(registered.artifactName ?? pair.test.id),
+                    pair.agent,
+                    ...repeatSegment(pair.repeat),
+                    `attempt-${attemptIndex}`,
+                ]),
             attemptId,
             currentStepId: () => steps.currentStepId,
             ...(this.config.artifactStore === undefined ? {} : { store: this.config.artifactStore }),
@@ -614,6 +627,8 @@ export class TargetExecutor {
         let skipped;
         let phase = 'launch';
         let timedOut = false;
+        // The polls the fixtures, the beforeEach hooks, and the body start.
+        const bodyPolls = new PollScope('the test body');
         // Captured the moment the primary failure lands: steps that pass later —
         // afterEach cleanup, teardown — must not confirm traces the failure
         // implicated (a cleanup assertion says nothing about the failed flow).
@@ -664,6 +679,7 @@ export class TargetExecutor {
                 testId: pair.test.id,
                 target: this.sessionIdentity,
                 attemptIndex,
+                recordings: this.storedRecordings,
             })
             : undefined;
         // A rejection nobody caught, handed in by the process while this attempt
@@ -722,22 +738,25 @@ export class TargetExecutor {
             // object, whichever `test` they were registered through.
             const extended = createExtendedFixtures(registered.fixtures, fixtures, this.target.engine?.name ?? 'none');
             /**
-             * Steps the body left running when it settled were not awaited. Each
-             * is recorded as failed at its call, cancelled through the attempt
-             * signal the way a timeout cancels the body, and waited for within one
-             * cleanup budget, so teardown starts on a quiet session. Left alone,
-             * such a step would fail once the session closed with nobody to catch
-             * it and take the worker down.
+             * Steps and polls the body left running when it settled were not
+             * awaited. A step is recorded as failed at its call, cancelled through
+             * the attempt signal the way a timeout cancels the body, and waited for
+             * within one cleanup budget, so teardown starts on a quiet session.
+             * Left alone, such a step would fail once the session closed with
+             * nobody to catch it and take the worker down. A poll is cancelled
+             * alone; left alone, its timeout would fail whatever ran then.
+             * Returns their errors, steps first.
              */
             const abandonNotAwaited = async () => {
                 if (attemptEnd.signal.aborted)
-                    return undefined;
-                const notAwaited = steps.abandonRunning();
-                if (notAwaited === undefined)
-                    return undefined;
-                attemptAbort.abort();
-                await withTimeout(steps.settleAbandoned(), this.config.cleanupTimeout, () => new Error('abandoned steps did not settle')).catch(() => undefined);
-                return notAwaited;
+                    return [];
+                const pollsNotAwaited = bodyPolls.close();
+                const stepsNotAwaited = steps.abandonRunning();
+                if (stepsNotAwaited !== undefined) {
+                    attemptAbort.abort();
+                    await withTimeout(steps.settleAbandoned(), this.config.cleanupTimeout, () => new Error('abandoned steps did not settle')).catch(() => undefined);
+                }
+                return [stepsNotAwaited, pollsNotAwaited].filter((error) => error !== undefined);
             };
             const mainWork = async () => {
                 try {
@@ -751,19 +770,22 @@ export class TargetExecutor {
                 }
                 catch (cause) {
                     // The body's own failure stays the verdict; the step it abandoned
-                    // and the soft failures it kept are noted beside it.
+                    // and the soft failures it kept are noted beside it. A skip keeps
+                    // only the soft failures: a step or poll it left running is not one.
                     const notAwaited = await abandonNotAwaited();
                     const softFailure = soft.close();
-                    if (!isRuntimeSkip(cause)) {
-                        for (const secondary of [notAwaited, softFailure]) {
-                            if (secondary !== undefined) {
-                                secondaryErrors.push(serializeError(secondary, { phase: 'body', projectRoot: this.config.projectRoot, redact }));
-                            }
+                    const kept = isRuntimeSkip(cause) ? [softFailure] : [...notAwaited, softFailure];
+                    for (const secondary of kept) {
+                        if (secondary !== undefined) {
+                            secondaryErrors.push(serializeError(secondary, { phase: 'body', projectRoot: this.config.projectRoot, redact }));
                         }
                     }
                     throw cause;
                 }
-                const notAwaited = await abandonNotAwaited();
+                const [notAwaited, ...moreNotAwaited] = await abandonNotAwaited();
+                for (const secondary of moreNotAwaited) {
+                    secondaryErrors.push(serializeError(secondary, { phase: 'body', projectRoot: this.config.projectRoot, redact }));
+                }
                 if (notAwaited !== undefined)
                     throw notAwaited;
                 // Soft failures fail the attempt once the body has settled, before
@@ -779,8 +801,8 @@ export class TargetExecutor {
             // down with the worker process; the attempt records the interrupt and
             // moves to cleanup.
             const work = this.options.isolated
-                ? withAbort(mainWork(), this.interruptSignal, () => new E2EError('interrupted', 'INTERRUPTED', `run interrupted in phase ${phase}`))
-                : mainWork();
+                ? withAbort(runInPollScope(bodyPolls, mainWork), this.interruptSignal, () => new E2EError('interrupted', 'INTERRUPTED', `run interrupted in phase ${phase}`))
+                : runInPollScope(bodyPolls, mainWork);
             const body = Promise.race([
                 work,
                 new Promise((_, reject) => {
@@ -798,6 +820,8 @@ export class TargetExecutor {
                 // The race has settled: a rejection surfacing while the evidence is
                 // captured is recorded, not aimed at it.
                 cutBody = undefined;
+                // A body cut short may have been awaiting its polls; they end with it.
+                bodyPolls.close();
                 // `skipRunningTest` has already refused the cases that may not skip.
                 if (isRuntimeSkip(cause))
                     skipped = cause;
@@ -859,6 +883,7 @@ export class TargetExecutor {
             recordFailure(cause, phase);
         }
         finally {
+            bodyPolls.close();
             this.strayFailure = undefined;
             this.lastAttemptTestId = pair.test.id;
             attemptEnd.abort();

package/dist/run/extended-fixtures.js

@@ -1,4 +1,5 @@
 /** The fixtures a test's `test.extend()` chain adds to one attempt. */
+import { pollLineage } from '../expect/poll-scope.js';
 import { ConfigurationError } from '../internal/errors.js';
 /**
  * Binds a chain of fixture definitions to one attempt's fixture object. The
@@ -50,8 +51,10 @@ export function createExtendedFixtures(definitions, fixtures, engineName) {
             ready();
             return released;
         };
+        // The function's polls are the body's until `use` returns, then its teardown's.
+        const polls = pollLineage();
         const run = Promise.resolve()
-            .then(() => definition.fn(fixtures, use))
+            .then(() => polls.run(() => definition.fn(fixtures, use)))
             .then(() => {
             if (!used) {
                 failed(new ConfigurationError('TEST_SETUP_FAILED', `fixture "${name}" returned without calling use(); a fixture awaits use(value) to hand its value to the test`));
@@ -66,7 +69,7 @@ export function createExtendedFixtures(definitions, fixtures, engineName) {
         run.catch(() => undefined);
         await provided;
         if (!abandoned)
-            active.push({ name, run, release, misuse: () => misuse });
+            active.push({ name, run, release, polls, misuse: () => misuse });
     };
     return {
         async setUp() {
@@ -78,6 +81,7 @@ export function createExtendedFixtures(definitions, fixtures, engineName) {
             return active.toReversed().map((state) => ({
                 name: state.name,
                 run: async () => {
+                    state.polls.handOver();
                     state.release();
                     await state.run;
                     const misuse = state.misuse();

package/dist/run/failure-evidence.js

@@ -109,7 +109,9 @@ function locatorCandidates(error, observation, redact, appOrigin) {
         return [];
     if (error.code !== 'LOCATOR_NOT_FOUND' && error.code !== 'LOCATOR_AMBIGUOUS')
         return [];
-    const { role, testId, name } = error.details ?? {};
+    const details = error.details ?? {};
+    // The nodes are redacted; the query is compared in the same form, so a secret test id still finds its node.
+    const [role, testId, name] = [details.role, details.testId, details.name].map((value) => (value === undefined ? undefined : redact(value)));
     const words = tokens(name ?? '');
     if (role === undefined && testId === undefined && words.length === 0)
         return [];
@@ -139,7 +141,7 @@ function locatorCandidates(error, observation, redact, appOrigin) {
     return scored
         .toSorted((a, b) => b.score - a.score)
         .slice(0, MAX_CANDIDATES)
-        .map(({ node }) => truncateUtf8(formatNode(node, 0, redact, appOrigin), MAX_CANDIDATE_BYTES));
+        .map(({ node }) => truncateUtf8(formatNode(node, 0, appOrigin), MAX_CANDIDATE_BYTES));
 }
 /**
  * Whether a word on screen is a near miss for one asked for: a typo or an

package/dist/run/fixtures.js

@@ -311,20 +311,18 @@ function createApp(environment, engine, exposure) {
      * `app.open()` on a target with no URL and no `navigate`, a device: it
      * launches the pinned app fresh, the way Maestro's `launchApp` does, and is
      * what a test calls before it looks at the screen. A path has nowhere to
-     * go there; a link goes through `device.openLink`.
+     * go there; a link goes through `device.openLink`. An engine without a
+     * relaunch hook is refused here; one with a hook reports its own reason it
+     * cannot launch, such as a build not installed yet.
      */
     const launchPinnedApp = (openPath) => steps.run('app', 'app.open', '', async () => {
         if (openPath !== undefined) {
             throw new ConfigurationError('APP_URL_REQUIRED', `app.open("${openPath}") needs an app URL and target "${target.name}" has none: on a device app.open() launches the pinned app, and a link goes through device.openLink`);
         }
-        try {
-            await engine.session.app.restart(engine.operation(config.timeout));
-        }
-        catch (cause) {
-            if (cause.code !== 'UNSUPPORTED_CAPABILITY')
-                throw cause;
-            throw new ConfigurationError('UNSUPPORTED_CAPABILITY', `app.open() has no app to launch on target "${target.name}": pin one with the target's app.bundleId or app.appPath, or bring one up with device.openApp`);
+        if (target.engine?.session?.restart === undefined) {
+            throw new ConfigurationError('UNSUPPORTED_CAPABILITY', `app.open() has nothing to open on target "${target.name}": it has no app URL, and engine ${target.engine?.name ?? 'none'} does not relaunch a pinned app`);
         }
+        await engine.session.app.restart(engine.operation(config.timeout));
     });
     return {
         baseUrl: target.app.base?.href,

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

@@ -28,6 +28,8 @@ export interface InProcessRunnerOptions {
     }) | undefined;
     readonly runId: string;
     readonly artifactsRoot: string;
+    /** See `TargetExecutorOptions.rerunDir`. */
+    readonly rerunDir: string | undefined;
     readonly sessionStore: SessionStore;
     readonly headed: boolean;
     readonly debug: DebugTrace;

package/dist/run/in-process.js

@@ -101,6 +101,7 @@ class InProcessRunner {
             sessionStore: this.options.sessionStore,
             runId: this.options.runId,
             artifactsRoot: this.options.artifactsRoot,
+            rerunDir: this.options.rerunDir,
             headed: this.options.headed,
             workerSlot: this.workerSlot,
             env: this.options.envFor(this.targetName),

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 {};