e2e 0.16.0 → 0.18.0

package/dist/run/execute.d.ts

@@ -9,17 +9,33 @@ import type { AttemptRecordings } from '../internal/recording-modes.ts';
 import type { ArtifactStore } from '../types.ts';
 import { type ArtifactSink } from './fixtures.ts';
 import { RealmManager, type FileRef, type Realm } from './realm.ts';
-import type { AttemptRecord, ResultRecord, RunError, SerialGroupRecord } from './records.ts';
-import { type SerialHost, type SharedSerialSession } from './serial.ts';
+import type { AttemptRecord, ResultRecord, RunError, SerialGroupRecord, SerialMemberRecord } from './records.ts';
+import { type SerialAttemptRun, type SerialAttemptStart, type SerialHost, type SharedSerialSession } from './serial.ts';
 import { SessionStaging, SessionStore } from './sessions.ts';
 import { type StepProgress } from './steps.ts';
 export interface ExecutionEvents {
     onResult?(result: ResultRecord): void;
     onSerialGroup?(group: SerialGroupRecord): void;
+    /** An attempt of an ordinary or setup pair begins, its realm and `beforeAll` hooks included. */
+    onAttemptStart?(pair: TestTargetPair, attemptIndex: number): void;
+    /** One finished attempt of an ordinary or setup pair, ahead of the pair's result. */
+    onAttempt?(pair: TestTargetPair, attempt: AttemptRecord): void;
+    /** One member that finished in a serial group attempt, ahead of the group. */
+    onSerialMember?(groupId: string, attempt: SerialAttemptStart, member: SerialMemberRecord): void;
+    /** One finished serial group attempt, ahead of the group. */
+    onSerialAttempt?(groupId: string, run: SerialAttemptRun): void;
     /** Fires before a runnable pair starts; a serial unit announces each member as it begins. */
     onPairStart?(pair: TestTargetPair): void;
     /** Live step progress of one running attempt, for reporters. */
     onProgress?(pair: TestTargetPair, progress: StepProgress): void;
+    /** An attempt's test timeout started, as its `beforeEach` hooks and body begin. */
+    onAttemptDeadline?(pair: TestTargetPair, attempt: {
+        readonly index: number;
+        readonly id: string;
+        readonly startedAt: string;
+    }): void;
+    /** The attempt `onAttemptDeadline` announced has ended, or one that never got that far has. */
+    onAttemptEnd?(): void;
     /** One line of progress the engine's `init` reported, already naming the target and worker slot. */
     onNotice?(message: string): void;
     /**
@@ -34,6 +50,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 +125,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 +136,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);
@@ -123,6 +148,10 @@ export declare class TargetExecutor implements SerialHost {
     pairStarted(pair: TestTargetPair): void;
     /** Emits one finished serial group, ahead of its members' results (SerialHost). */
     emitSerialGroup(group: SerialGroupRecord): void;
+    /** Streams one member finished in a serial group attempt (SerialHost). */
+    serialMemberFinished(groupId: string, attempt: SerialAttemptStart, member: SerialMemberRecord): void;
+    /** Streams one finished serial group attempt (SerialHost). */
+    serialAttemptFinished(groupId: string, run: SerialAttemptRun): void;
     /** Builds one engine operation context. */
     private op;
     /** Run-level errors recorded so far, in order. */
@@ -187,9 +216,9 @@ export declare class TargetExecutor implements SerialHost {
      * hands the app (basic-auth credentials). Registered for the session's and
      * the process's redaction by `resolveSecretValue`, with every value the
      * engine derives from it (the base64 credential an `Authorization` header
-     * carries) under the same name. The session's exposure rises to `engine`:
-     * its text is redacted and its trace and text downloads rewritten, while
-     * its pixels stay as they are, since nothing was typed.
+     * carries) under the same name, so its text, trace, and text downloads
+     * are redacted of them. Its pixels stay as they are, since nothing was
+     * typed.
      */
     private resolveEngineSecret;
     /**

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, redactForSession, resolveSecretValue, sessionSecrecy, staticSecretLedger } from './secrecy.js';
+import { adoptSecrecy, carriedSecrecy, processSecrets, registerDerivedSecrets, redactForSession, redactsRecordings, 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) => {
@@ -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;
@@ -90,6 +97,14 @@ export class TargetExecutor {
     emitSerialGroup(group) {
         this.options.events?.onSerialGroup?.(group);
     }
+    /** Streams one member finished in a serial group attempt (SerialHost). */
+    serialMemberFinished(groupId, attempt, member) {
+        this.options.events?.onSerialMember?.(groupId, attempt, member);
+    }
+    /** Streams one finished serial group attempt (SerialHost). */
+    serialAttemptFinished(groupId, run) {
+        this.options.events?.onSerialAttempt?.(groupId, run);
+    }
     /** Builds one engine operation context. */
     op(attemptId, timeoutMs, signal) {
         return { signal, timeoutMs, runId: this.options.runId, attemptId, origin: 'test' };
@@ -249,6 +264,7 @@ export class TargetExecutor {
         let realm = incomingRealm;
         let hookFailure;
         const finalStatus = await runWithRetries(pair.options.retries + 1, this.interruptSignal, async (attemptIndex) => {
+            this.options.events?.onAttemptStart?.(pair, attemptIndex);
             if (realm === null)
                 realm = await this.realms.create(file);
             const registered = findRegistered(realm, pair.test);
@@ -263,6 +279,7 @@ export class TargetExecutor {
                 kind: 'ordinary',
             });
             attempts.push(attempt);
+            this.options.events?.onAttempt?.(pair, attempt);
             if (isFailedStatus(attempt.status)) {
                 // A failed realm is never reused, but afterAll still runs for every
                 // scope whose beforeAll started in it. A body that skipped itself
@@ -309,6 +326,7 @@ export class TargetExecutor {
         const attempts = [];
         let hookFailure;
         const finalStatus = await runWithRetries(pair.options.retries + 1, this.interruptSignal, async (attemptIndex) => {
+            this.options.events?.onAttemptStart?.(pair, attemptIndex);
             const realm = attemptIndex === 0 && freshRegistration !== undefined
                 ? this.realms.adopt(freshRegistration, file)
                 : await this.realms.create(file);
@@ -327,15 +345,17 @@ export class TargetExecutor {
                 kind: 'setup',
                 staging,
             });
+            const missing = attempt.status === 'passed' ? staging.missing() : [];
+            if (missing.length > 0) {
+                attempt.status = 'failed';
+                attempt.error = serializeError(new E2EError('test', 'SESSION_CONTRACT', `setup must save each declared session exactly once; missing: [${missing.join(', ')}]`), { phase: 'body' });
+            }
             attempts.push(attempt);
+            // Sent before teardown and the session saves, as in runOrdinaryPair:
+            // a crash in either then lands on this attempt instead of erasing it.
+            this.options.events?.onAttempt?.(pair, attempt);
             await this.realms.leave(realm);
             if (attempt.status === 'passed') {
-                const missing = staging.missing();
-                if (missing.length > 0) {
-                    attempt.status = 'failed';
-                    attempt.error = serializeError(new E2EError('test', 'SESSION_CONTRACT', `setup must save each declared session exactly once; missing: [${missing.join(', ')}]`), { phase: 'body' });
-                    return attempt;
-                }
                 for (const [name, saved] of staging.entries()) {
                     await this.options.sessionStore.save(name, this.sessionIdentity, saved);
                 }
@@ -412,9 +432,9 @@ export class TargetExecutor {
      * hands the app (basic-auth credentials). Registered for the session's and
      * the process's redaction by `resolveSecretValue`, with every value the
      * engine derives from it (the base64 credential an `Authorization` header
-     * carries) under the same name. The session's exposure rises to `engine`:
-     * its text is redacted and its trace and text downloads rewritten, while
-     * its pixels stay as they are, since nothing was typed.
+     * carries) under the same name, so its text, trace, and text downloads
+     * are redacted of them. Its pixels stay as they are, since nothing was
+     * typed.
      */
     async resolveEngineSecret(session, secret, options) {
         const engine = this.target.engine;
@@ -425,7 +445,6 @@ export class TargetExecutor {
         const secrecy = sessionSecrecy(session, this.config.allSecrets);
         const plaintext = await resolveSecretValue(secret, this.config.allSecrets, secrecy.ledger);
         registerDerivedSecrets(secret.name, options?.derived?.(plaintext) ?? [], secrecy.ledger);
-        secrecy.exposure.raise('engine');
         return plaintext;
     }
     /**
@@ -472,14 +491,14 @@ export class TargetExecutor {
                 }
                 // An engine records what happened, filled secrets included, so the
                 // trace is the runner's to redact before anything hashes or stores
-                // it. Only a session a secret reached (filled, or held by the engine
-                // for an option, which a trace records the attempt opening with) can
-                // have recorded one: an unexposed trace needs no rewriting, and an
-                // exposed one is kept only once rewritten. Its screencast frames go
-                // only where pixels are withheld, after a fill.
+                // it. Any value the ledger holds may be in it, filled or not (a URL
+                // the test spelled it into, an engine option), so a trace is kept
+                // only once rewritten; only a session that knows no value skips it.
+                // Its screencast frames go only where pixels are withheld, after a
+                // fill.
                 const secrecy = sessionSecrecy(session, this.config.allSecrets);
                 let redaction = 'not-required';
-                if (secrecy.exposure.redactsRecordings) {
+                if (redactsRecordings(secrecy)) {
                     try {
                         await redactTraceArchives(artifactSink.dir, archives, secrecy.ledger, { keepFrames: !secrecy.exposure.withholdsPixels });
                     }
@@ -533,7 +552,14 @@ export class TargetExecutor {
             target: this.target.name,
             agent: pair.agent,
             attempt: attemptIndex,
-        }, () => this.executeAttempt(pair, registered, realm, attemptIndex, context));
+        }, async () => {
+            try {
+                return await this.executeAttempt(pair, registered, realm, attemptIndex, context);
+            }
+            finally {
+                this.options.events?.onAttemptEnd?.();
+            }
+        });
     }
     async executeAttempt(pair, registered, realm, attemptIndex, context) {
         const attemptId = uuidv7();
@@ -588,7 +614,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 +646,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).
@@ -639,9 +673,13 @@ export class TargetExecutor {
         // One more look at the app the moment the failure lands: what the screen
         // held then is the evidence the message lacks. Taken before teardown, so
         // an `afterEach` that navigates away or resets state cannot replace it.
+        // Once per attempt: a screen that yielded nothing within the budget is
+        // not asked again, so a hung app costs the budget once.
+        let evidenceTried = false;
         const captureEvidence = async () => {
-            if (failure === undefined || record.failure !== undefined || openSession === null || this.interruptSignal.aborted)
+            if (failure === undefined || evidenceTried || openSession === null || this.interruptSignal.aborted)
                 return;
+            evidenceTried = true;
             const evidence = await captureFailureEvidence({
                 session: openSession,
                 error: failure,
@@ -664,6 +702,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
@@ -684,6 +723,7 @@ export class TargetExecutor {
                 (await this.launchSession({ session: pair.options.session, recordings }, attemptId, artifacts.dir, attemptAbort.signal));
             openSession = session;
             const testDeadline = new Deadline(pair.options.timeout);
+            this.options.events?.onAttemptDeadline?.(pair, { index: attemptIndex, id: attemptId, startedAt });
             const budget = new AttemptBudget(attemptAbort.signal, testDeadline);
             const saveSession = context.kind !== 'setup'
                 ? undefined
@@ -722,22 +762,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 +794,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 +825,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 +844,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 +907,7 @@ export class TargetExecutor {
             recordFailure(cause, phase);
         }
         finally {
+            bodyPolls.close();
             this.strayFailure = undefined;
             this.lastAttemptTestId = pair.test.id;
             attemptEnd.abort();
@@ -911,7 +960,7 @@ export class TargetExecutor {
 function classifyAttemptStatus(failure, timedOut, interrupted) {
     if (interrupted && !timedOut)
         return 'interrupted';
-    if (timedOut || failure instanceof TestTimeoutError || failure.code === 'TEST_TIMEOUT') {
+    if (timedOut || failure.code === 'TEST_TIMEOUT') {
         return 'timed-out';
     }
     return 'failed';

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

@@ -14,6 +14,7 @@ import path from 'node:path';
 import { formatNode, prepareObservation } from '../agent/observation.js';
 import { truncateUtf8 } from '../internal/errors.js';
 import { isTypoOf } from '../internal/suggest.js';
+import { withAbort } from '../internal/time.js';
 /** The whole capture, observation and screenshot together, gets this long. */
 const EVIDENCE_TIMEOUT_MS = 5_000;
 /** Screen lines a locator failure lists as its nearest nodes, and the bytes each keeps; the wire schema caps both. */
@@ -37,9 +38,12 @@ export async function captureFailureEvidence(options) {
         return finish(evidence);
     const operation = options.operation(signal, EVIDENCE_TIMEOUT_MS);
     const { redact, redactCut } = options.secrecy.ledger;
+    // The engine is handed the budget, and the wait is abandoned at its end
+    // either way: an engine stuck on a hung app may never honor it.
+    const bounded = (work) => withAbort(work, signal, () => new Error('failure evidence ran out of budget'));
     let observation;
     try {
-        const raw = await options.session.observe(operation);
+        const raw = await bounded(() => options.session.observe(operation));
         observation = prepareObservation(raw, {
             redact,
             redactCut,
@@ -73,7 +77,7 @@ export async function captureFailureEvidence(options) {
     // prove a tainted viewport redacted.
     if (!options.secrecy.exposure.withholdsPixels && !signal.aborted) {
         try {
-            const relative = await options.session.artifacts.screenshot('failure', operation);
+            const relative = await bounded(() => options.session.artifacts.screenshot('failure', operation));
             evidence.screenshot = options.artifacts.register('screenshot', relative);
         }
         catch {
@@ -109,7 +113,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 +145,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

@@ -5,6 +5,7 @@
  * `TargetWorker` core; only the transport and pair resolution differ, and the
  * scheduler is capped at one worker so nothing overlaps in this process.
  */
+import { isAbandonedRejection } from '../internal/abandoned.js';
 import { classifyError, ConfigurationError, serializeError } from '../internal/errors.js';
 import { pairKey } from './units.js';
 import { TargetWorker } from './worker/session.js';
@@ -18,6 +19,22 @@ class InProcessRunner {
     finish;
     exited = false;
     closing = false;
+    /**
+     * Set by a fatal error: the worker is dead to the scheduler from then on,
+     * as a crashed process would be, so nothing it reports about its unit
+     * while it winds down counts, and the unit's results are synthesized when
+     * it exits. Unlike a dead process it still disposes its engine, so the
+     * failures of that disposal (`shutdown-done`) are still reported.
+     */
+    crashed = false;
+    /** Takes what this process failed to catch while the runner lives; see `catchStrays`. */
+    onRejection = (cause) => {
+        if (isAbandonedRejection(cause))
+            return;
+        if (!this.worker.strayRejection(cause))
+            this.fail(cause);
+    };
+    onException = (cause) => this.fail(cause);
     constructor(targetName, workerSlot, events, options) {
         this.targetName = targetName;
         this.workerSlot = workerSlot;
@@ -30,20 +47,14 @@ class InProcessRunner {
         this.finish = finish;
         this.worker = new TargetWorker({
             emit: (message) => {
-                if (!this.exited)
-                    this.events.onMessage(message);
-            },
-            fatal: (cause) => {
-                if (this.exited)
+                if (this.exited || (this.crashed && message.type !== 'shutdown-done'))
                     return;
-                this.events.onMessage({
-                    type: 'fatal',
-                    error: serializeError(classifyError(cause)),
-                });
-                this.close();
+                this.events.onMessage(message);
             },
+            fatal: (cause) => this.fail(cause),
             finished: () => this.end('shut down'),
         }, () => this.bootstrap());
+        this.catchStrays();
         this.worker.start();
     }
     get alive() {
@@ -75,6 +86,34 @@ class InProcessRunner {
     kill() {
         this.close();
     }
+    /**
+     * Catches what a test leaves uncaught the way a worker process does
+     * (`worker/entry.ts`): a rejection nobody handled is charged to the attempt
+     * in flight, or recorded against the last test that finished, and is
+     * otherwise fatal to this worker, as an uncaught exception is (see
+     * `fail`). The
+     * listeners live exactly as long as the runner, so a host process keeps its
+     * own handling before and after the run. The scheduler keeps at most one
+     * in-process runner alive at a time, so nothing is charged twice.
+     */
+    catchStrays() {
+        process.on('unhandledRejection', this.onRejection);
+        process.on('uncaughtException', this.onException);
+    }
+    /**
+     * Reports an unrecoverable failure and ends the worker the way a process
+     * dies: its unit is interrupted and nothing more it reports is passed on,
+     * so on exit the scheduler fails the test in flight with `WORKER_CRASH`
+     * and skips the unit's others, as it does for a worker process.
+     */
+    fail(cause) {
+        if (this.exited || this.crashed)
+            return;
+        this.events.onMessage({ type: 'fatal', error: serializeError(classifyError(cause)) });
+        this.crashed = true;
+        this.worker.handle({ type: 'interrupt' });
+        this.close();
+    }
     /** Stops accepting work and asks the queue to wind down. */
     close() {
         if (this.exited || this.closing)
@@ -86,6 +125,8 @@ class InProcessRunner {
         if (this.exited)
             return;
         this.exited = true;
+        process.off('unhandledRejection', this.onRejection);
+        process.off('uncaughtException', this.onException);
         this.events.onExit(detail);
         this.finish();
     }
@@ -101,6 +142,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),