e2e 0.15.2 → 0.17.0

package/dist/report/live-window.js

@@ -142,4 +142,3 @@ export class LiveWindow {
         this.erase();
     }
 }
-//# sourceMappingURL=live-window.js.map

package/dist/report/markdown-text.d.ts

@@ -26,4 +26,3 @@ export declare function code(text: string, max?: number): string;
 export declare function link(text: string, url: string): string;
 export declare function formatDuration(ms: number): string;
 export declare function plural(count: number, noun: string): string;
-//# sourceMappingURL=markdown-text.d.ts.map

package/dist/report/markdown-text.js

@@ -87,4 +87,3 @@ export function formatDuration(ms) {
 export function plural(count, noun) {
     return `${count} ${noun}${count === 1 ? '' : 's'}`;
 }
-//# sourceMappingURL=markdown-text.js.map

package/dist/report/markdown.d.ts

@@ -50,10 +50,9 @@ export declare function renderMarkdownReport(report: Report1Document, options?:
  * `summary.md` beside `report.json`, with evidence listed as paths from the
  * project root, for a reader with the checkout in front of it: a pull
  * request description, a coding agent's handoff, a wiki page. Every test
- * that did not pass gets a page of its own under `failures/`, with the
+ * that failed or was flaky gets a page of its own under `failures/`, with the
  * screen at failure inline; the run page links each block to its page. The
  * directory is the reporter's: what an earlier run left there is removed
  * first, so a stale page never describes a failure this run did not have.
  */
 export declare const markdownReporter: Reporter;
-//# sourceMappingURL=markdown.d.ts.map

package/dist/report/markdown.js

@@ -45,11 +45,11 @@ const MAX_GOAL_CHARS = 400;
 const TRUNCATED_NOTE = '_Truncated to fit a pull request comment; the full report is in `report.json`._';
 /** Screenshots first, then the recording, then the trace; the compiler fails when a kind is missing here. */
 const KIND_RANK = { screenshot: 0, video: 1, trace: 2, download: 3, log: 4 };
-const ICON = { failed: '🔴', flaky: '⚠️', skipped: '⏭️', passed: '🟢' };
+const ICON = { failed: '🔴', interrupted: '⏹️', flaky: '⚠️', skipped: '⏭️', passed: '🟢' };
 /** Worst first: the order failures are listed, files are sorted, and a file's glyph is chosen in. */
-const WORST_FIRST = ['failed', 'flaky', 'skipped', 'passed'];
-/** The order counts read in: `1 failed, 1 flaky, 3 passed, 1 skipped`. */
-const COUNT_ORDER = ['failed', 'flaky', 'passed', 'skipped'];
+const WORST_FIRST = ['failed', 'interrupted', 'flaky', 'skipped', 'passed'];
+/** The order counts read in: `1 failed, 2 interrupted, 1 flaky, 3 passed, 1 skipped`. */
+const COUNT_ORDER = ['failed', 'interrupted', 'flaky', 'passed', 'skipped'];
 function worstBucket(results) {
     const present = new Set(results.map((result) => statusBucket(result.status)));
     return WORST_FIRST.find((key) => present.has(key)) ?? 'passed';
@@ -65,9 +65,25 @@ function pageName(options) {
     const title = options.title?.trim() ?? '';
     return title === '' ? 'e2e' : `e2e ${cell(title, MAX_ID_CHARS)}`;
 }
+/**
+ * The headline's glyph: red for a failed run or any failed test, the
+ * interrupted glyph for a run or a listed test the run stopped, else green.
+ * A `--last-failed` rerun that passed can still list a test the first pass
+ * never finished, and the page must not read as all green.
+ */
+function runIcon(run, results) {
+    if (run.status !== 'passed' && run.status !== 'interrupted')
+        return ICON.failed;
+    const worst = worstBucket(results);
+    if (worst === 'failed')
+        return ICON.failed;
+    if (worst === 'interrupted' || run.status === 'interrupted')
+        return ICON.interrupted;
+    return ICON.passed;
+}
 function headline(run, results, options) {
     const summary = countText(tally(results)) || (run.errors.length > 0 ? 'no tests ran' : 'no tests selected');
-    return `### ${run.status === 'passed' ? ICON.passed : ICON.failed} ${pageName(options)}: ${summary}`;
+    return `### ${runIcon(run, results)} ${pageName(options)}: ${summary}`;
 }
 /** The model calls an agent step made; the step's metrics are the source of truth. */
 function modelCalls(step) {
@@ -236,6 +252,12 @@ function flakyFold(entries, manyTargets, options) {
     const summary = `${ICON.flaky} ${plural(entries.length, 'flaky test')} passed on a retry`;
     return [['<details>', `<summary>${summary}</summary>`, '', shown.join('\n\n'), '</details>'].join('\n')];
 }
+/** A test that missed a run: flaky when a run failed, else interrupted when the run stopped one, else skipped. */
+function missIcon(group) {
+    if (group.unstable)
+        return ICON.flaky;
+    return group.runs.some((run) => run.status === 'interrupted') ? ICON.interrupted : ICON.skipped;
+}
 /**
  * A `--repeat-each` run's tally: how many tests passed every run, then each
  * test that did not, with the runs that failed. Empty for a run that
@@ -254,10 +276,11 @@ function repeatsSection(entries, manyTargets) {
     }));
     if (groups.length === 0)
         return [];
-    const unstable = groups.filter((group) => group.passed < group.runs.length);
+    // A test is listed when it missed a run: a flake first, then one the run cut short.
+    const missed = groups.filter((group) => group.passed < group.runs.length).toSorted((a, b) => Number(b.unstable) - Number(a.unstable));
     return [
         `**Repeats:** ${repeatSummary(groups)}`,
-        ...(unstable.length === 0 ? [] : ['', ...unstable.map((group) => `- ${ICON.flaky} ${group.label}: ${cell(repeatLine(group))}`)]),
+        ...(missed.length === 0 ? [] : ['', ...missed.map((group) => `- ${missIcon(group)} ${group.label}: ${cell(repeatLine(group))}`)]),
     ];
 }
 /** Results grouped by file and target, the worst file first, then by path. */
@@ -353,12 +376,12 @@ function footer(run, targets, options) {
     return [`<sub>${parts.join(' · ')}</sub>`];
 }
 // --- the exploration record ---
-function exploreHeadline(run, explore, options) {
+function exploreHeadline(run, results, explore, options) {
     const issues = explore.findings.filter((finding) => finding.kind === 'issue').length;
     const warnings = explore.findings.length - issues;
     const counts = [...(issues > 0 ? [plural(issues, 'issue')] : []), ...(warnings > 0 ? [plural(warnings, 'warning')] : [])];
     const summary = counts.length > 0 ? counts.join(', ') : run.status === 'blocked' ? 'explored nothing' : run.status === 'passed' ? 'no findings' : 'did not finish';
-    return `### ${run.status === 'passed' ? ICON.passed : ICON.failed} ${pageName(options)} explore: ${summary}`;
+    return `### ${runIcon(run, results)} ${pageName(options)} explore: ${summary}`;
 }
 /** `3 of 8 steps · 2 passed · 1 failed · the agent covered the goal`. */
 function exploreSteps(explore) {
@@ -448,7 +471,7 @@ export function renderMarkdownReport(report, options = {}) {
         failures.push([`and ${failed.length - failures.length} more failed`]);
     const flaky = flakyFold(notPassed.filter(({ result }) => statusBucket(result.status) === 'flaky'), manyTargets, options);
     const spend = spendLine(run, entries);
-    const head = [explore === undefined ? headline(run, selected, options) : exploreHeadline(run, explore, options), ...(spend === undefined ? [] : [spend]), ''];
+    const head = [explore === undefined ? headline(run, selected, options) : exploreHeadline(run, selected, explore, options), ...(spend === undefined ? [] : [spend]), ''];
     const groups = fileGroups(entries);
     const sections = explore === undefined
         ? [errors, ...failures, flaky, repeatsSection(entries, manyTargets), allTests(groups, selected.length, manyTargets)]
@@ -468,9 +491,9 @@ function failurePageName(result) {
     return `${sanitizePathSegment(`${result.file}-${result.titlePath.join('-')}`)}-${result.id.slice(0, 8)}.md`;
 }
 /**
- * The results that get a page: every one that failed, timed out, was
- * interrupted, or was flaky, except an exploration's own verdict, which its
- * findings already tell.
+ * The results that get a page: every one that failed, timed out, or was
+ * flaky, except an exploration's own verdict, which its findings already
+ * tell. An interrupted test reached no verdict, so it has no failure to tell.
  */
 function pagedResults(report) {
     const explore = report.run.explore;
@@ -487,7 +510,7 @@ function pagedResults(report) {
  * `summary.md` beside `report.json`, with evidence listed as paths from the
  * project root, for a reader with the checkout in front of it: a pull
  * request description, a coding agent's handoff, a wiki page. Every test
- * that did not pass gets a page of its own under `failures/`, with the
+ * that failed or was flaky gets a page of its own under `failures/`, with the
  * screen at failure inline; the run page links each block to its page. The
  * directory is the reporter's: what an earlier run left there is removed
  * first, so a stale page never describes a failure this run did not have.
@@ -526,4 +549,3 @@ export const markdownReporter = {
         return rows;
     },
 };
-//# sourceMappingURL=markdown.js.map

package/dist/report/outcome.d.ts

@@ -32,4 +32,3 @@ export interface Outcome {
 }
 export declare function outcome(result: ReportResult, groups: ReadonlyMap<string, ReportSerialGroup>): Outcome;
 export {};
-//# sourceMappingURL=outcome.d.ts.map

package/dist/report/outcome.js

@@ -47,4 +47,3 @@ function durationOf(result, groups) {
     const last = groups.get(result.serialGroupId)?.attempts.at(-1);
     return last?.members.find((candidate) => candidate.testId === result.testId)?.durationMs ?? 0;
 }
-//# sourceMappingURL=outcome.js.map

package/dist/report/repeats.d.ts

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

package/dist/report/repeats.js

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

package/dist/report/running-tree.d.ts

@@ -49,4 +49,3 @@ export declare class RunningTree {
 }
 /** The work in flight: a spinner and a shimmering status word; see `waitingWord`. */
 export declare function waitingRow(pc: Colors, now: number, word: string): string;
-//# sourceMappingURL=running-tree.d.ts.map

package/dist/report/running-tree.js

@@ -208,4 +208,3 @@ export function waitingRow(pc, now, word) {
     const spinner = pc.cyan(SPINNER_FRAMES[Math.floor(frame / SPINNER_HOLD_FRAMES) % SPINNER_FRAMES.length]);
     return `${spinner} ${shimmer(pc, word, frame)}`;
 }
-//# sourceMappingURL=running-tree.js.map

package/dist/report/write.d.ts

@@ -12,4 +12,3 @@ export declare function toPosixPath(relative: string): string;
  * Nothing to write beside when the report itself was not written.
  */
 export declare function fileReporter(name: string, label: string, fileName: string, render: (run: FinishedRun) => string): Reporter;
-//# sourceMappingURL=write.d.ts.map

package/dist/report/write.js

@@ -32,4 +32,3 @@ export function fileReporter(name, label, fileName, render) {
         },
     };
 }
-//# sourceMappingURL=write.js.map

package/dist/run/app-ports.d.ts

@@ -13,4 +13,3 @@ import { type ResolvedConfig } from '../config/resolve.ts';
  * anything starts.
  */
 export declare function allocateAppPorts(config: ResolvedConfig): Promise<ResolvedConfig>;
-//# sourceMappingURL=app-ports.d.ts.map

package/dist/run/app-ports.js

@@ -58,4 +58,3 @@ function portOf(server) {
 function release(server) {
     return new Promise((resolve) => server.close(() => resolve()));
 }
-//# sourceMappingURL=app-ports.js.map

package/dist/run/artifacts.d.ts

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

package/dist/run/artifacts.js

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

package/dist/run/budget.d.ts

@@ -22,4 +22,3 @@ export declare class AttemptBudget {
      */
     enter(parent: AbortSignal, timeoutMs: number): AbortController;
 }
-//# sourceMappingURL=budget.d.ts.map

package/dist/run/budget.js

@@ -35,4 +35,3 @@ export class AttemptBudget {
         return controller;
     }
 }
-//# sourceMappingURL=budget.js.map

package/dist/run/declared-processes.d.ts

@@ -16,4 +16,3 @@ export interface DeclaredCommand {
 }
 /** Every distinct app command in target order; identity is the command alone, not where it is probed. */
 export declare function declaredCommands(targets: readonly ResolvedTarget[]): readonly DeclaredCommand[];
-//# sourceMappingURL=declared-processes.d.ts.map

package/dist/run/declared-processes.js

@@ -20,4 +20,3 @@ export function declaredCommands(targets) {
     }
     return commands;
 }
-//# sourceMappingURL=declared-processes.js.map

package/dist/run/events.d.ts

@@ -259,4 +259,3 @@ export declare function toEventResult(record: ResultRecord): RunEventResult;
  */
 export declare function createRunEventEmitter(subscribers: readonly (RunEventSubscriber | undefined)[]): (fact: RunEventFact) => void;
 export {};
-//# sourceMappingURL=events.d.ts.map

package/dist/run/events.js

@@ -66,4 +66,3 @@ export function createRunEventEmitter(subscribers) {
         }
     };
 }
-//# sourceMappingURL=events.js.map

package/dist/run/execute.d.ts

@@ -34,6 +34,12 @@ export interface TargetExecutorOptions {
     readonly target: ResolvedTarget;
     readonly runId: string;
     readonly artifactsRoot: string;
+    /**
+     * The directory under `artifactsRoot` a `--last-failed` rerun's attempts
+     * write in (`claimRerunDir`), beside the evidence of the run it reruns;
+     * undefined when the attempts fill the root themselves.
+     */
+    readonly rerunDir?: string | undefined;
     readonly sessionStore: SessionStore;
     readonly headed: boolean;
     /** This worker's slot among the target's workers; see `EngineInitInfo.workerSlot`. */
@@ -103,6 +109,7 @@ export declare class TargetExecutor implements SerialHost {
     get runId(): string;
     get artifactStore(): ArtifactStore | undefined;
     readonly artifactsRoot: string;
+    readonly rerunDir: string | undefined;
     readonly interruptSignal: AbortSignal;
     readonly realms: RealmManager;
     readonly debug: DebugTrace;
@@ -113,6 +120,8 @@ export declare class TargetExecutor implements SerialHost {
     private lastAttemptTestId;
     private readonly models;
     private readonly sessionIdentity;
+    /** The file store's listing under `cache.strict`, read once for every attempt here. */
+    private readonly storedRecordings;
     /** Resolves once the engine's init hook completed for this worker. */
     private engineReady;
     constructor(options: TargetExecutorOptions);
@@ -221,4 +230,3 @@ export declare class TargetExecutor implements SerialHost {
     runAttempt(pair: TestTargetPair, registered: RegisteredTest, realm: Realm, attemptIndex: number, context: AttemptContext): Promise<AttemptRecord>;
     private executeAttempt;
 }
-//# sourceMappingURL=execute.d.ts.map