e2e 0.16.0 → 0.18.0

package/dist/run/serial.js

@@ -3,56 +3,80 @@ import { classifyError, ConfigurationError, serializeError, } from '../internal/
 import { canonicalDigest, timestamp, uuidv7 } from '../internal/ids.js';
 import { groupTitles } from '../collect/registry.js';
 import { pairRecordings } from '../collect/select.js';
-import { createAttemptArtifacts, sanitizePathSegment } from './artifacts.js';
+import { attemptSegments, createAttemptArtifacts, sanitizePathSegment } from './artifacts.js';
 import { findRegistered, RealmManager } from './realm.js';
 import { isFailedStatus } from './records.js';
-import { runWithRetries } from './retry.js';
+import { isRetryEligible, retryVerdict, runWithRetries } from './retry.js';
 import { interruptedSkip, pairResult, repeatSegment } from './units.js';
+/** The report id of one serial group variant: a group runs once per agent and per repeat. */
+export function serialGroupId(serialId, targetName, agent, repeat) {
+    return canonicalDigest(repeat === 0 ? { serialId, targetId: targetName, agent } : { serialId, targetId: targetName, agent, repeat });
+}
 /** Runs one serial unit to completion and emits every member result. */
 export async function runSerialUnit(host, members, file) {
+    const group = newSerialGroup(members, host.target);
+    const runs = [];
+    const finalStatus = await runWithRetries(members[0].options.retries + 1, host.interruptSignal, async (attemptIndex) => {
+        const run = await runSerialAttempt(host, group.id, members, file, attemptIndex);
+        runs.push(run);
+        group.attempts.push(run.record);
+        host.serialAttemptFinished(group.id, run);
+        // A beforeAll failure is not retry-eligible: the
+        // attempt stands as recorded and the retry loop stops here.
+        if (run.record.error?.code === 'HOOK_FAILED')
+            return undefined;
+        return run.record;
+    });
+    if (group.attempts.length === 0) {
+        group.status = 'skipped';
+        group.skip = interruptedSkip(host.interruptSignal);
+    }
+    else {
+        group.status = finalStatus;
+    }
+    host.emitSerialGroup(group);
+    for (const result of memberResults(group, members, runs))
+        host.emit(result);
+    return group;
+}
+/** A group record with no attempts yet. */
+function newSerialGroup(members, target) {
     const first = members[0];
     const serialId = first.test.serialId;
     // Every member of a unit runs as the same agent (selection guarantees it),
     // so the group is one variant of the flow and is identified as such.
-    const agent = first.agent;
-    const { repeat } = first;
-    const groupRecordId = canonicalDigest(repeat === 0 ? { serialId, targetId: host.target.name, agent } : { serialId, targetId: host.target.name, agent, repeat });
-    const group = {
-        id: groupRecordId,
+    const { agent, repeat } = first;
+    return {
+        id: serialGroupId(serialId, target.name, agent, repeat),
         serialId,
         declarationIndex: first.test.declarationIndex,
         file: first.test.file,
         titlePath: serialTitlePath(first.test),
-        targetId: host.target.name,
-        platform: host.target.platform,
+        targetId: target.name,
+        platform: target.platform,
         agent,
         repeat,
         memberTestIds: members.map((member) => member.test.id),
         status: 'failed',
         attempts: [],
     };
-    const memberFinalStatus = new Map();
-    const finalStatus = await runWithRetries(first.options.retries + 1, host.interruptSignal, async (attemptIndex) => {
-        const attempt = await runSerialAttempt(host, members, file, attemptIndex);
-        group.attempts.push(attempt);
-        for (const member of attempt.members)
-            memberFinalStatus.set(member.testId, member);
-        // A beforeAll failure is not retry-eligible: the
-        // attempt stands as recorded and the retry loop stops here.
-        if (attempt.error?.code === 'HOOK_FAILED')
-            return undefined;
-        return attempt;
-    });
-    if (group.attempts.length === 0) {
-        group.status = 'skipped';
-        group.skip = interruptedSkip(host.interruptSignal);
-    }
-    else {
-        group.status = finalStatus;
+}
+/**
+ * Each member's result once its group is decided. Members carry no attempts
+ * of their own; the verdict is the member's record in the last attempt that
+ * counts. A retry the run interrupted, or one that never reached its
+ * members, keeps the verdict before it.
+ */
+function memberResults(group, members, runs) {
+    const verdicts = new Map();
+    for (const [attemptIndex, run] of runs.entries()) {
+        const cutRetry = attemptIndex > 0 && (run.record.status === 'interrupted' || !run.reachedMembers);
+        if (!cutRetry)
+            for (const member of run.record.members)
+                verdicts.set(member.testId, member);
     }
-    host.emitSerialGroup(group);
-    for (const member of members) {
-        const memberRecord = memberFinalStatus.get(member.test.id);
+    return members.map((member) => {
+        const memberRecord = verdicts.get(member.test.id);
         let status;
         let skip;
         // A member that skipped itself stays skipped whatever the group did: a
@@ -71,30 +95,153 @@ export async function runSerialUnit(host, members, file) {
         else {
             status = memberRecord.status;
         }
-        host.emit(pairResult(member, {
+        return pairResult(member, {
             status,
             selected: true,
             ...(skip !== undefined ? { skip } : {}),
             attempts: [],
-            serialGroupId: groupRecordId,
-        }));
+            serialGroupId: group.id,
+        });
+    });
+}
+/**
+ * What the runner heard of one serial group a worker is running: the
+ * attempts it finished, and the members finished so far in the attempt
+ * running now. When the worker dies before reporting the group, this is
+ * what the report keeps.
+ */
+export class SerialGroupProgress {
+    finished = [];
+    current;
+    currentMembers = [];
+    /** The member whose body is running now, by test id, until its record arrives. */
+    running;
+    /** A member of the group announced its start. */
+    memberStarted(testId) {
+        this.running = testId;
+    }
+    /** A member finished in the attempt running now. */
+    memberFinished(attempt, member) {
+        this.current = attempt;
+        this.currentMembers.push(member);
+        if (this.running === member.testId)
+            this.running = undefined;
+    }
+    /** A group attempt finished; the next one starts empty. */
+    attemptFinished(run) {
+        this.finished.push(run);
+        this.current = undefined;
+        this.currentMembers = [];
+        this.running = undefined;
+    }
+    /**
+     * The group after its worker died with `error`, or undefined when the
+     * runner heard nothing of it running. The finished attempts stand, and the
+     * attempt in flight fails: the member whose body was running ends `status`
+     * with `error` (`timed-out` when the watchdog killed a worker that hung in
+     * it) and the ones after it skip. A crash between members (a hook,
+     * the session closing) fails the attempt and leaves its finished members
+     * as they were; one in a retry before any member ran fails the first, as a
+     * launch failure does. A crash after the last attempt, when no retry
+     * follows it, is recorded on that attempt.
+     */
+    crashed(members, target, error, status) {
+        const last = this.finished.at(-1);
+        if (!this.inFlight) {
+            if (last === undefined)
+                return undefined;
+            if (!retryFollows(last.record, this.finished.length, members)) {
+                const closed = {
+                    ...last,
+                    record: { ...last.record, secondaryErrors: [...last.record.secondaryErrors, error], cleanup: 'forced' },
+                };
+                return this.settled([...this.finished.slice(0, -1), closed], members, target);
+            }
+            const record = this.attemptInFlight('failed', error);
+            endBeforeMembers(record, members, error, NEVER_INTERRUPTED);
+            return this.settled([...this.finished, { record, reachedMembers: false }], members, target);
+        }
+        const next = this.currentMembers.length;
+        const wasRunning = this.running !== undefined && this.running === members[next]?.test.id;
+        const record = this.attemptInFlight(wasRunning ? status : 'failed', error);
+        const skip = wasRunning
+            ? predecessorFailed(next)
+            : { cause: 'infrastructure-unavailable', reason: 'worker process exited during this group attempt' };
+        for (const [memberIndex, member] of members.entries()) {
+            if (memberIndex < next)
+                continue;
+            record.members.push(wasRunning && memberIndex === next
+                ? memberFailedWith(record, memberIndex, member.test.id, error, status)
+                : skippedMember(record.id, memberIndex, member.test.id, skip));
+        }
+        return this.settled([...this.finished, { record, reachedMembers: true }], members, target);
+    }
+    /**
+     * The group after the run's interrupt stopped its worker, or undefined
+     * when the runner heard nothing of it running. The finished attempts
+     * stand, and an attempt in flight is interrupted: the members it finished
+     * keep their records and the rest skip with `skip`. The verdict is the one
+     * those attempts reach, as for a retry the interrupt cut short.
+     */
+    interrupted(members, target, skip) {
+        if (!this.inFlight)
+            return this.finished.length === 0 ? undefined : this.settled(this.finished, members, target);
+        const record = this.attemptInFlight('interrupted', undefined);
+        for (const [memberIndex, member] of members.entries()) {
+            if (memberIndex >= this.currentMembers.length)
+                record.members.push(skippedMember(record.id, memberIndex, member.test.id, skip));
+        }
+        return this.settled([...this.finished, { record, reachedMembers: true }], members, target);
+    }
+    /** Whether a member of the attempt in flight started or finished. */
+    get inFlight() {
+        return this.currentMembers.length > 0 || this.running !== undefined;
+    }
+    /** The record of the attempt in flight as it stood, with the members it finished. */
+    attemptInFlight(status, error) {
+        return {
+            id: this.current?.id ?? uuidv7(),
+            index: this.finished.length,
+            status,
+            startedAt: this.current?.startedAt ?? timestamp(),
+            durationMs: 0,
+            members: [...this.currentMembers],
+            artifacts: [],
+            ...(error === undefined ? {} : { error }),
+            secondaryErrors: [],
+            cleanup: 'forced',
+        };
+    }
+    settled(runs, members, target) {
+        const group = newSerialGroup(members, target);
+        group.status = retryVerdict(runs.map((run) => run.record));
+        group.attempts = runs.map((run) => run.record);
+        return { group, results: memberResults(group, members, runs) };
     }
-    return group;
 }
-async function runSerialAttempt(host, members, file, attemptIndex) {
+/**
+ * Whether the group retries after `record`, its attempt number `attempts`:
+ * the retry policy allows it, and a hook failure never retries.
+ */
+function retryFollows(record, attempts, members) {
+    return attempts < members[0].options.retries + 1 && isRetryEligible(record) && record.error?.code !== 'HOOK_FAILED';
+}
+/** An abort signal that never fires. */
+const NEVER_INTERRUPTED = new AbortController().signal;
+async function runSerialAttempt(host, groupId, members, file, attemptIndex) {
     const attemptId = uuidv7();
     const startedAt = timestamp();
     const startedMs = Date.now();
     const memberRecords = [];
     const first = members[0];
     const recordings = pairRecordings(first, attemptIndex);
-    const artifactSegments = [
+    const artifactSegments = attemptSegments(host.rerunDir, [
         host.target.name,
         sanitizePathSegment(first.test.serialId ?? first.test.id),
         first.agent,
         ...repeatSegment(first.repeat),
         `attempt-${attemptIndex}`,
-    ];
+    ]);
     const artifacts = createAttemptArtifacts({
         artifactsRoot: host.artifactsRoot,
         segments: artifactSegments,
@@ -115,15 +262,20 @@ async function runSerialAttempt(host, members, file, attemptIndex) {
         secondaryErrors: [],
         cleanup: 'complete',
     };
+    const start = { id: attemptId, index: attemptIndex, startedAt };
+    /** Records one member and streams it, so a worker that dies later in the attempt does not take it along. */
+    const finishMember = (member) => {
+        memberRecords.push(member);
+        host.serialMemberFinished(groupId, start, member);
+    };
     let realm;
     try {
         realm = await host.realms.create(file);
     }
     catch (cause) {
-        record.status = 'failed';
-        record.error = serializeError(classifyError(cause), { phase: 'collection' });
+        endBeforeMembers(record, members, serializeError(classifyError(cause), { phase: 'collection' }), host.interruptSignal);
         record.durationMs = Date.now() - startedMs;
-        return record;
+        return { record, reachedMembers: false };
     }
     let shared;
     try {
@@ -137,18 +289,10 @@ async function runSerialAttempt(host, members, file, attemptIndex) {
         };
     }
     catch (cause) {
-        const error = classifyError(cause);
-        record.status = 'failed';
-        record.error = serializeError(error, { phase: 'launch' });
-        for (let memberIndex = 0; memberIndex < members.length; memberIndex += 1) {
-            memberRecords.push(skippedMember(attemptId, memberIndex, members[memberIndex].test.id, {
-                cause: 'infrastructure-unavailable',
-                reason: error.message,
-            }));
-        }
+        endBeforeMembers(record, members, serializeError(classifyError(cause), { phase: 'launch' }), host.interruptSignal);
         record.durationMs = Date.now() - startedMs;
         await host.realms.leave(realm);
-        return record;
+        return { record, reachedMembers: false };
     }
     let skipRemaining;
     let hookFailure;
@@ -156,18 +300,15 @@ async function runSerialAttempt(host, members, file, attemptIndex) {
         const member = members[memberIndex];
         const memberId = `${attemptId}:member:${memberIndex}`;
         if (skipRemaining === undefined && host.interruptSignal.aborted) {
-            skipRemaining = interruptedSkip(host.interruptSignal, {
-                cause: 'infrastructure-unavailable',
-                reason: 'run interrupted during this group attempt',
-            });
+            skipRemaining = interruptedMemberSkip(host.interruptSignal);
         }
         if (skipRemaining !== undefined) {
-            memberRecords.push(skippedMember(attemptId, memberIndex, member.test.id, skipRemaining));
+            finishMember(skippedMember(attemptId, memberIndex, member.test.id, skipRemaining));
             continue;
         }
         const registered = findRegistered(realm, member.test);
         if (registered === undefined) {
-            memberRecords.push({
+            finishMember({
                 id: memberId,
                 index: memberIndex,
                 testId: member.test.id,
@@ -187,7 +328,7 @@ async function runSerialAttempt(host, members, file, attemptIndex) {
         hookFailure = await host.realms.enterScopes(realm, registered);
         if (hookFailure !== undefined) {
             skipRemaining = { cause: 'hook-failed', reason: hookFailure.message };
-            memberRecords.push(skippedMember(attemptId, memberIndex, member.test.id, skipRemaining));
+            finishMember(skippedMember(attemptId, memberIndex, member.test.id, skipRemaining));
             continue;
         }
         host.pairStarted(member);
@@ -196,7 +337,7 @@ async function runSerialAttempt(host, members, file, attemptIndex) {
             shared,
         });
         shared.priorSteps.push(...memberAttempt.steps);
-        memberRecords.push({
+        finishMember({
             id: memberId,
             index: memberIndex,
             testId: member.test.id,
@@ -247,11 +388,54 @@ async function runSerialAttempt(host, members, file, attemptIndex) {
     await host.closeSession(shared.session, { attemptId, recordings }, record, artifacts.sink, record.secondaryErrors);
     await artifacts.settle();
     record.durationMs = Date.now() - startedMs;
-    return record;
+    return { record, reachedMembers: true };
+}
+/**
+ * Ends a group attempt that stopped before any member ran (its file would not
+ * load, its session would not launch). The first member fails with the
+ * attempt's error, as an ordinary test whose attempt failed the same way
+ * would, and the rest skip behind it. When the run's interrupt is what
+ * stopped it, the attempt is interrupted and every member skips.
+ */
+function endBeforeMembers(record, members, error, interruptSignal) {
+    record.error = error;
+    if (interruptSignal.aborted) {
+        record.status = 'interrupted';
+        const skip = interruptedMemberSkip(interruptSignal);
+        members.forEach((member, memberIndex) => record.members.push(skippedMember(record.id, memberIndex, member.test.id, skip)));
+        return;
+    }
+    record.status = 'failed';
+    members.forEach((member, memberIndex) => {
+        record.members.push(memberIndex === 0
+            ? memberFailedWith(record, 0, member.test.id, error, 'failed')
+            : skippedMember(record.id, memberIndex, member.test.id, predecessorFailed(0)));
+    });
+}
+/** A member that failed with an error of its group attempt's, having run no step of its own. */
+function memberFailedWith(record, index, testId, error, status) {
+    return {
+        id: `${record.id}:member:${index}`,
+        index,
+        testId,
+        status,
+        startedAt: record.startedAt,
+        durationMs: 0,
+        steps: [],
+        error,
+        secondaryErrors: [],
+    };
 }
 function isFailedMember(member) {
     return isFailedStatus(member.status);
 }
+/** Why a member the run's interrupt kept from running in this group attempt skipped. */
+function interruptedMemberSkip(interruptSignal) {
+    return interruptedSkip(interruptSignal, {
+        cause: 'infrastructure-unavailable',
+        reason: 'run interrupted during this group attempt',
+    });
+}
 function predecessorFailed(memberIndex) {
     return {
         cause: 'serial-predecessor-failed',

package/dist/run/standalone.js

@@ -49,7 +49,7 @@ export async function openStandaloneAttempt(options) {
     const finishEngines = (onFailure) => engines.finish({ runId, env: options.env, timeoutMs: config.cleanupTimeout, notice, onFailure });
     try {
         // One worker on one target: one slot to provision.
-        prepared = await engines.prepare(target, 1, { runId, projectRoot: config.projectRoot, env: options.env, signal, notice });
+        prepared = await engines.prepare(target, 1, { runId, projectRoot: config.projectRoot, env: options.env, signal, headed: options.headed, notice });
         const hooks = { ci: config.ci, notice: (message) => notice('app', message) };
         processes = await startDeclaredProcesses([target], config.projectRoot, () => hooks, signal, debug, options.processes);
         if (signal.aborted) {

package/dist/run/steps.d.ts

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

package/dist/run/steps.js

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

package/dist/run/trace-redaction.d.ts

@@ -12,12 +12,11 @@ import type { SecretLedger } from '../internal/redact.ts';
  * returned from `stopTrace`, relative to `dir`; one that resolves outside
  * `dir` is refused before anything is touched. An archive that cannot be
  * rewritten is deleted together with the rest of the trace, and the failure
- * is thrown: the runner keeps no trace it cannot vouch for. A trace comes
- * here from a session a secret was filled on, whose pixels are withheld, so
- * its screencast frames are dropped as a screenshot would be denied; or from
- * one whose engine holds a secret in its options and where nothing was
- * filled, which the caller passes `keepFrames` for: an engine-held secret is
- * protected as text only.
+ * is thrown: the runner keeps no trace it cannot vouch for. After a secret
+ * fill the session's pixels are withheld, so its screencast frames are
+ * dropped as a screenshot would be denied; with nothing filled the caller
+ * passes `keepFrames`: a value that reached the app otherwise (an engine
+ * option, a URL the test spelled it into) is protected as text only.
  */
 export declare function redactTraceArchives(dir: string, paths: readonly string[], ledger: SecretLedger, options?: {
     readonly keepFrames?: boolean;

package/dist/run/trace-redaction.js

@@ -16,12 +16,11 @@ import { inflateEntry, readZip, writeZip, zipEntry } from '../internal/zip.js';
  * returned from `stopTrace`, relative to `dir`; one that resolves outside
  * `dir` is refused before anything is touched. An archive that cannot be
  * rewritten is deleted together with the rest of the trace, and the failure
- * is thrown: the runner keeps no trace it cannot vouch for. A trace comes
- * here from a session a secret was filled on, whose pixels are withheld, so
- * its screencast frames are dropped as a screenshot would be denied; or from
- * one whose engine holds a secret in its options and where nothing was
- * filled, which the caller passes `keepFrames` for: an engine-held secret is
- * protected as text only.
+ * is thrown: the runner keeps no trace it cannot vouch for. After a secret
+ * fill the session's pixels are withheld, so its screencast frames are
+ * dropped as a screenshot would be denied; with nothing filled the caller
+ * passes `keepFrames`: a value that reached the app otherwise (an engine
+ * option, a URL the test spelled it into) is protected as text only.
  */
 export async function redactTraceArchives(dir, paths, ledger, options = {}) {
     const root = path.resolve(dir);

package/dist/run/worker/entry.js

@@ -14,21 +14,31 @@ import { AiTraceRecorder, registerAiTraceRecorder } from '../../internal/ai-trac
 import { DebugTrace } from '../../internal/debug.js';
 import { classifyError, ConfigurationError, serializeError } from '../../internal/errors.js';
 import { StreamRedactor } from '../../internal/redact.js';
+import { ConfigLoadHold } from '../process-output.js';
 import { processSecrets, registerStaticSecrets, staticSecretLedger } from '../secrecy.js';
 import { SessionStore } from '../sessions.js';
 import { TargetWorker } from './session.js';
-import { isAbandonedStepRejection } from '../steps.js';
+import { isAbandonedRejection } from '../../internal/abandoned.js';
 /**
  * Outbound messages in flight. `process.send` is asynchronous and a
  * `process.exit` right behind it can drop the message, so exiting waits for
  * the queue to flush: the runner must see the worker's last word.
  */
 let outbox = Promise.resolve();
+/** Holds what the process prints while `bootstrap` loads the config, until its secrets are known. */
+const configLoad = new ConfigLoadHold();
 /** How long an exit waits for the outbox: a channel whose runner is gone may never acknowledge. */
 const FLUSH_GRACE_MS = 2_000;
-/** Queues one message; resolves once the channel has taken it (or is gone). */
+/**
+ * Hands one message to the channel at once; resolves once the channel has
+ * taken it and every message before it (or is gone). The channel keeps the
+ * order. Waiting for the previous message's ack would take an event-loop
+ * turn: a `pair-start` sent right before a body that exits the process, or an
+ * `attempt-deadline` sent right before one that blocks the loop, would never
+ * leave.
+ */
 function send(message) {
-    outbox = outbox.then(() => new Promise((resolve) => {
+    const taken = new Promise((resolve) => {
         try {
             if (process.send === undefined || !process.connected)
                 resolve();
@@ -39,7 +49,8 @@ function send(message) {
             // channel already closed; nothing left to deliver
             resolve();
         }
-    }));
+    });
+    outbox = outbox.then(() => taken);
     return outbox;
 }
 /**
@@ -79,6 +90,11 @@ function captureOutput(pairInFlight) {
         flushes.push(() => void output(redactor.flush(), heldFor));
         const write = (chunk, encoding, callback) => {
             const done = typeof encoding === 'function' ? encoding : callback;
+            if (configLoad.hold(name, chunk)) {
+                if (done !== undefined)
+                    process.nextTick(done);
+                return true;
+            }
             const pair = pairInFlight();
             pending += 1;
             void output(redactor.push(chunk), pair).then(() => {
@@ -117,17 +133,22 @@ async function bootstrap(message, debug, aiTrace) {
     // process-wide, so calls from either module instance land in one trace.
     if (aiTrace !== undefined)
         await registerAiTraceRecorder(aiTrace, loadAiSdk);
-    const raw = await loadConfigModule(message.configPath);
-    const config = assignPorts(resolveConfig(raw, { projectRoot: message.projectRoot, configPath: message.configPath, env: process.env, cli: message.cli }), message.ports);
-    if (config.configDigest !== message.configDigest) {
-        throw new ConfigurationError('CONFIG_NOT_DETERMINISTIC', 'worker resolved a different config digest than the runner; config must be deterministic');
-    }
-    const target = config.targets.find((candidate) => candidate.name === message.targetName);
-    if (target === undefined) {
-        throw new ConfigurationError('UNKNOWN_TARGET', `unknown target "${message.targetName}"`);
-    }
-    setSecretRegistry(config);
-    registerStaticSecrets(config.allSecrets);
+    // What the config's top-level code prints is held until its secrets are
+    // registered, so it is redacted like a test's output.
+    const { config, target } = await configLoad.during(async () => {
+        const raw = await loadConfigModule(message.configPath);
+        const resolved = assignPorts(resolveConfig(raw, { projectRoot: message.projectRoot, configPath: message.configPath, env: process.env, cli: message.cli }), message.ports);
+        if (resolved.configDigest !== message.configDigest) {
+            throw new ConfigurationError('CONFIG_NOT_DETERMINISTIC', 'worker resolved a different config digest than the runner; config must be deterministic');
+        }
+        const named = resolved.targets.find((candidate) => candidate.name === message.targetName);
+        if (named === undefined) {
+            throw new ConfigurationError('UNKNOWN_TARGET', `unknown target "${message.targetName}"`);
+        }
+        setSecretRegistry(resolved);
+        registerStaticSecrets(resolved.allSecrets);
+        return { config: resolved, target: named };
+    }, (stream, chunk) => process[stream].write(chunk), (line) => process.stderr.write(`e2e: [warning] ${line}\n`));
     let collectCounter = 0;
     const resolvePairs = async (unit) => {
         collectCounter += 1;
@@ -152,6 +173,7 @@ async function bootstrap(message, debug, aiTrace) {
         sessionStore: SessionStore.forWorker(message.runId, message.sessionsRoot, Buffer.from(message.sessionKeyBase64, 'base64')),
         runId: message.runId,
         artifactsRoot: message.artifactsRoot,
+        rerunDir: message.rerunDir,
         headed: message.headed,
         workerSlot: message.workerSlot,
         env: process.env,
@@ -169,13 +191,13 @@ function main() {
     process.on('SIGINT', () => undefined);
     process.on('SIGTERM', () => undefined);
     process.on('uncaughtException', (cause) => fatal(cause));
-    // A step the body did not await rejects on a promise nobody holds once it
-    // is cancelled; the attempt has already recorded it as STEP_NOT_AWAITED.
+    // A step or poll the test did not await rejects on a promise nobody holds
+    // once it is cancelled; the attempt has already recorded it as STEP_NOT_AWAITED.
     // Any other rejection nobody caught is charged to the attempt in flight,
     // or recorded against the last test that finished; only before any test
     // has finished is it the worker's.
     process.on('unhandledRejection', (cause) => {
-        if (isAbandonedStepRejection(cause))
+        if (isAbandonedRejection(cause))
             return;
         if (worker?.strayRejection(cause) !== true)
             fatal(cause);