e2e 0.15.2 → 0.17.0

package/dist/run/execute.js

@@ -10,21 +10,23 @@ 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';
 import { runWithRetries } from './retry.js';
 import { runSerialUnit } from './serial.js';
 import { interruptedSkip, pairKey, pairResult, repeatSegment, unstartedResult } from './units.js';
-import { adoptSecrecy, carriedSecrecy, processSecrets, registerDerivedSecrets, resolveSecretValue, sessionSecrecy } from './secrecy.js';
+import { adoptSecrecy, carriedSecrecy, processSecrets, registerDerivedSecrets, redactForSession, resolveSecretValue, sessionSecrecy, staticSecretLedger } from './secrecy.js';
 import { isSecret } from '../secrets.js';
 import { SessionStaging, SessionStore, targetIdentity } from './sessions.js';
 import { redactTraceArchives } from './trace-redaction.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) => {
@@ -70,9 +76,11 @@ export class TargetExecutor {
             timeout: options.config.timeout,
             cleanupTimeout: options.config.cleanupTimeout,
             runErrors: this.runErrors,
+            redactTitle: staticSecretLedger(options.config.allSecrets).redact,
             debug: this.debug,
         });
         this.sessionIdentity = targetIdentity(options.target);
+        this.storedRecordings = storedRecordingsFor(options.config.cache);
     }
     get config() {
         return this.options.config;
@@ -544,9 +552,10 @@ export class TargetExecutor {
         const shared = context.kind === 'serial' ? context.shared : undefined;
         const onProgress = this.options.events?.onProgress;
         let openSession = null;
-        // Secret values the session has seen never enter an error record; the
-        // ledger is live, so a value resolved mid-attempt is covered too.
-        const redact = (text) => openSession === null ? text : sessionSecrecy(openSession, this.config.allSecrets).ledger.redact(text);
+        // Secret values the session has seen never enter an error record or a
+        // step label; the ledger is live, so a value resolved mid-attempt is
+        // covered too. Before a session opens, the static values still are.
+        const redact = (text) => redactForSession(openSession ?? undefined, this.config.allSecrets, text);
         const steps = new StepRecorder(attemptId, {
             attempt: { id: shared?.attemptId ?? attemptId, index: attemptIndex },
             maxEventsPerStep: this.config.limits.maxEventsPerStep,
@@ -586,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 }),
@@ -612,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).
@@ -662,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
@@ -720,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 {
@@ -749,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
@@ -777,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) => {
@@ -796,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;
@@ -857,6 +883,7 @@ export class TargetExecutor {
             recordFailure(cause, phase);
         }
         finally {
+            bodyPolls.close();
             this.strayFailure = undefined;
             this.lastAttemptTestId = pair.test.id;
             attemptEnd.abort();
@@ -937,4 +964,3 @@ function registerVideos(sink, segments) {
         throw new EngineError('ENGINE_FAILURE', `the engine returned a video link that is not an http(s) URL: ${rejected.join(', ')}`, { retryable: false });
     }
 }
-//# sourceMappingURL=execute.js.map

package/dist/run/extended-fixtures.d.ts

@@ -30,4 +30,3 @@ export interface ExtendedFixtures {
  * fixture is the one the body would otherwise read.
  */
 export declare function createExtendedFixtures(definitions: readonly FixtureDefinition[], fixtures: object, engineName: string): ExtendedFixtures;
-//# sourceMappingURL=extended-fixtures.d.ts.map

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();
@@ -88,4 +92,3 @@ export function createExtendedFixtures(definitions, fixtures, engineName) {
         },
     };
 }
-//# sourceMappingURL=extended-fixtures.js.map

package/dist/run/failure-evidence.d.ts

@@ -33,4 +33,3 @@ export interface FailureEvidenceOptions {
  * captured, so the record carries no empty block.
  */
 export declare function captureFailureEvidence(options: FailureEvidenceOptions): Promise<FailureEvidence | undefined>;
-//# sourceMappingURL=failure-evidence.d.ts.map

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
@@ -157,4 +159,3 @@ function tokens(text) {
         .split(/[^\p{L}\p{N}]+/u)
         .filter((word) => word.length > 1);
 }
-//# sourceMappingURL=failure-evidence.js.map

package/dist/run/fixture-recording.d.ts

@@ -18,4 +18,3 @@ export declare class FixtureRecorder {
     /** Executes one declared operation inside its step and cancellation boundary. */
     private run;
 }
-//# sourceMappingURL=fixture-recording.d.ts.map

package/dist/run/fixture-recording.js

@@ -99,4 +99,3 @@ function propertyDescriptor(surface, key) {
     }
     return undefined;
 }
-//# sourceMappingURL=fixture-recording.js.map

package/dist/run/fixtures.d.ts

@@ -68,4 +68,3 @@ export interface AttemptFixtures {
     readonly agentRuntime: AgentContext;
 }
 export declare function createFixtures(environment: AttemptEnvironment): AttemptFixtures;
-//# sourceMappingURL=fixtures.d.ts.map

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,
@@ -355,4 +353,3 @@ function lazily(build) {
     let built;
     return () => (built ??= { value: build() }).value;
 }
-//# sourceMappingURL=fixtures.js.map

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;
@@ -36,4 +38,3 @@ export interface InProcessRunnerOptions {
 }
 /** Creates the spawn factory the scheduler uses for in-process execution. */
 export declare function inProcessSpawner(options: InProcessRunnerOptions): SpawnUnitRunner;
-//# sourceMappingURL=in-process.d.ts.map

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),
@@ -132,4 +133,3 @@ async function resolveFromSelection(selection, target, unit, registration) {
 export function inProcessSpawner(options) {
     return (targetName, workerSlot, events) => new InProcessRunner(targetName, workerSlot, events, options);
 }
-//# sourceMappingURL=in-process.js.map

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,14 +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>;
-//# sourceMappingURL=last-run.d.ts.map
+/** What a rerun's collection found: the tests it collected by id, and the files it discovered but could not collect. */
+export interface RerunCollection {
+    readonly testIds: ReadonlySet<string>;
+    readonly uncollectedFiles: ReadonlySet<string>;
+}
+/**
+ * What a `--last-failed` rerun carries forward from the report it selected
+ * from: every result that report owed a rerun and this run did not run, as
+ * the run that last ran it reported it; the serial groups those results'
+ * attempts live on; and the suite hook failures whose scope still holds one
+ * of them. A result is owed when it did not pass, or when it is in the scope
+ * of a failed `beforeAll` or `afterAll` this run did not see pass: a hook
+ * whose scope this run ran again without it failing is resolved, and one
+ * that failed again is this run's own error, which still makes its left-out
+ * tests owed. A test this run did not run is one it collected (`collected`,
+ * by test id), on a target the config still has, that it did not select:
+ * left out by a filter, on a target or agent the run did not ask for, or a
+ * setup no selected test needed, which the report lists no row for. A test in
+ * a file the run found but could not collect (`uncollectedFiles`, a narrowed
+ * run past a file that fails to import) is still there and stays carried. A
+ * test the run no longer collects cannot run again and is dropped. A test
+ * this run selected is no longer carried, whatever its outcome: its own
+ * result says it now. Undefined when nothing is carried.
+ */
+export declare function carryForward(lastRun: Report1Document, current: Report1Document, collected: RerunCollection): ReportCarried | undefined;
+/**
+ * The artifact paths a report names, relative to the artifacts root: every
+ * attempt's of its results and serial groups, and of what it carries. What a
+ * `--last-failed` rerun keeps of the tree when it starts.
+ */
+export declare function reportArtifactPaths(document: Report1Document): ReadonlySet<string>;
+export {};

package/dist/run/last-run.js

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

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

@@ -95,4 +95,3 @@ export interface AppProcesses {
      */
     stop(onFailure: (cause: unknown) => void): Promise<void>;
 }
-//# sourceMappingURL=managed-process.d.ts.map

package/dist/run/managed-process.js

@@ -343,4 +343,3 @@ export class ManagedProcess {
         }
     }
 }
-//# sourceMappingURL=managed-process.js.map

package/dist/run/output.d.ts

@@ -17,4 +17,3 @@ export interface OutputLayout {
 }
 /** The fixed paths under the absolute output directory `output`. */
 export declare function outputLayout(output: string): OutputLayout;
-//# sourceMappingURL=output.d.ts.map

package/dist/run/output.js

@@ -14,4 +14,3 @@ export function outputLayout(output) {
         videos: (sessionId) => path.join(output, 'videos', sessionId),
     };
 }
-//# sourceMappingURL=output.js.map

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

@@ -38,4 +38,3 @@ export declare class SharedAppProcesses implements ProcessPool {
     /** Drops `entry` from the pool, unless a fresh start already took its key. */
     private forget;
 }
-//# sourceMappingURL=process-pool.d.ts.map

package/dist/run/process-pool.js

@@ -108,4 +108,3 @@ function cancelled(signal, started) {
         started.then(forget, forget);
     });
 }
-//# sourceMappingURL=process-pool.js.map