@e2edev/e2e 0.6.0 → 0.7.0

package/dist/report/list.js

@@ -1,67 +1,35 @@
 /**
- * Human-readable list reporter, styled after vitest's
- * default reporter: one block per test file and target, a `Failed Tests`
- * section with code frames, and a padded summary. On a TTY a live window
- * below the log shows the running files, their tests, and the counters.
+ * Human-readable list reporter, styled after vitest's default reporter: one
+ * block per test file and target with each test's agent steps nested, a
+ * `Failed Tests` section with code frames, and a padded summary. On a TTY a
+ * live window below the log shows the running tree (`RunningTree`) and the
+ * counters.
  */
 import path from 'node:path';
 import picocolors from 'picocolors';
-import { sanitizeText, truncateUtf8 } from '../internal/errors.js';
 import { packageVersion } from '../internal/package-version.js';
-import { collapseText } from '../internal/text.js';
 import { codeFrame, userFrame } from './code-frame.js';
-import { addUsage, aiSegment, bounded, ellipsize, emptyCounters, emptyUsage, fileOutcome, formatClock, formatTime, formatTokens, padTitle, rule, stateString, statusBucket, stepsUsage, sumUsage, tally, terminalColumns, terminalRows, } from './format.js';
+import { addUsage, aiSegment, bounded, ellipsize, emptyCounters, emptyUsage, F_CHECK, F_CROSS, F_POINTER, fileOutcome, formatClock, formatTime, padTitle, rule, stateString, statusBucket, stepsUsage, sumUsage, tally, terminalColumns, usageText, } from './format.js';
+import { isShownEvent } from './list-model.js';
+import { stepLine } from './list-steps.js';
 import { LiveWindow } from './live-window.js';
-/** Step labels stay one glanceable line; the report holds the full text. */
-const MAX_STEP_LABEL_BYTES = 72;
-const F_POINTER = '❯';
-const F_CHECK = '✓';
-const F_CROSS = '×';
+import { RunningTree } from './running-tree.js';
 const F_DOWN = '↓';
 const F_RIGHT = '→';
-const F_DOWN_RIGHT = '↳';
-const F_TREE_MIDDLE = '├──';
-const F_TREE_END = '└──';
 /** Indentation under a badge line, matching vitest's banner padding. */
 const BADGE_PADDING = '      ';
+/** Indentation of a test line under its file line. */
+const TEST_INDENT = '   ';
+/** Indentation of a finished agent step under its test line in a file block. */
+const STEP_INDENT = '     ';
 /**
  * Badge backgrounds, assigned to targets in declaration order. Bright variants
  * because GitHub Actions renders plain yellow as dark brown, which swallows the
  * black label.
  */
 const BADGE_COLORS = ['bgYellowBright', 'bgCyanBright', 'bgGreenBright', 'bgMagentaBright'];
-/**
- * Rows the live window spends outside the running tests and the summary: its
- * blank lines, the `… more running` marker, and a margin above the prompt.
- */
-const WINDOW_CHROME_ROWS = 6;
-/** Rows one running test takes before its calls: the test line and its current step. */
-const WINDOW_ROWS_PER_TEST = 2;
 /** Indentation of the `→ first error line` under a failed test in a file block. */
 const ERROR_GLANCE_INDENT = 7;
-/** One-line, quoted step label bounded for the live view. */
-function stepLabel(label) {
-    const flat = collapseText(label);
-    const shown = truncateUtf8(flat, MAX_STEP_LABEL_BYTES);
-    return `"${shown}${shown === flat ? '' : '…'}"`;
-}
-/**
- * Live tail for one step event. Model and engine calls are the ones worth a
- * glance (`tool:` prefixes come from executor tool accounting); polls and
- * policy decisions stay quiet.
- */
-function eventTail(event) {
-    if (event.kind === 'model') {
-        const tokens = event.count !== undefined && event.count > 0 ? ` · ${formatTokens(event.count)} tokens` : '';
-        return `model turn ${formatTime(event.durationMs)}${tokens}`;
-    }
-    if (event.kind === 'engine') {
-        const name = sanitizeText(event.name ?? 'engine').replace(/^tool:/, '');
-        const failed = event.status === 'passed' ? '' : ` ${F_CROSS}`;
-        return `${truncateUtf8(name, 40)} ${formatTime(event.durationMs)}${failed}`;
-    }
-    return undefined;
-}
 /** The identity of one test-target pair across `test-started`, `step`, and `test-finished`. */
 function pairKey(testId, target) {
     return `${testId}@${target}`;
@@ -108,16 +76,25 @@ export class ListReporter {
     output;
     pc;
     window;
+    tree;
     separator;
     projectRoot;
     /** Selected targets in declaration order; decides each badge's color. */
     targets = [];
-    /** When the run began: the summary's `Start at` and the origin of `Duration`. */
-    startedAt = new Date();
+    /** When the run was launched (`run-started`): what a run that never reached `plan` reports. */
+    launchedAt = new Date();
+    /**
+     * When the run began executing (`plan`): the summary's `Start at` and the
+     * origin of `Duration`. Undefined until then, so the clock never ticks
+     * while a first-run download narrates above the live window.
+     */
+    startedAt;
     /** File groups keyed `${target}\u0000${file}`, in first-seen order. */
     groups = new Map();
-    /** Pairs executing right now, keyed by `pairKey`, in start order. */
-    running = new Map();
+    /** Pairs that started and whose result is still to come, keyed by `pairKey`, in start order. */
+    pairs = new Map();
+    /** Whether a live window paints; without one, finished steps stream permanently. */
+    live;
     failures = [];
     /**
      * Serial groups whose members' results are still to come, by group id. The
@@ -127,13 +104,29 @@ export class ListReporter {
     pendingSerial = new Map();
     /** Run-level errors, printed once at the end; the stream carries them as they happen. */
     errors = [];
+    /**
+     * Whether the run was cut short. An interrupt during service or app startup
+     * lands before discovery, so the counters stay at zero; the summary must not
+     * read that as "no test files".
+     */
+    interrupted = false;
+    /**
+     * The setup step in flight, ticking in the live window. `narrated` once a
+     * notice printed under it: a step that said something (a browser download)
+     * prints its total when done, a silent one (an instant `prepare`) does not.
+     */
+    inFlight;
+    /** Time spent starting services and app commands, split out of the summary's `Duration`. */
+    startupMs = 0;
     /** Run-wide model usage, summed from every reported result and serial group. */
     runUsage = emptyUsage();
     constructor(output = DEFAULT_OUTPUT, options = {}) {
         this.output = output;
         const live = (options.live ?? process.stdout.isTTY === true) && output.raw !== undefined;
+        this.live = live;
         this.pc = picocolors.createColors(options.colors ?? (live || picocolors.isColorSupported));
         this.separator = this.pc.dim(' > ');
+        this.tree = new RunningTree(this.pc, (target) => this.badge(target));
         this.window = new LiveWindow(live ? output.raw?.bind(output) : undefined, () => this.renderWindow());
     }
     /**
@@ -149,8 +142,13 @@ export class ListReporter {
                 this.plan(event);
                 break;
             case 'notice':
+                if (this.inFlight !== undefined)
+                    this.inFlight.narrated = true;
                 this.print(`${this.pc.dim('ℹ')} ${bounded(event.message)}`);
                 break;
+            case 'setup':
+                this.setupStep(event);
+                break;
             case 'test-started':
                 this.testStarted(event);
                 break;
@@ -198,7 +196,7 @@ export class ListReporter {
         const key = `${target}\u0000${file}`;
         let group = this.groups.get(key);
         if (group === undefined) {
-            group = { file, target, planned: undefined, lines: [], streamed: false, printed: false };
+            group = { file, target, planned: undefined, lines: [], printed: false };
             this.groups.set(key, group);
         }
         return group;
@@ -207,7 +205,7 @@ export class ListReporter {
         const { pc } = this;
         this.projectRoot = event.projectRoot;
         this.targets = event.targets;
-        this.startedAt = new Date();
+        this.launchedAt = new Date();
         const version = packageVersion(import.meta.url, '../../package.json', '0.0.0');
         this.output.write('');
         this.output.write(`${pc.bold(pc.black(pc.bgCyan(' RUN ')))} ${pc.cyan(`e2e v${version}`)} ${pc.gray(event.projectRoot)}`);
@@ -215,97 +213,144 @@ export class ListReporter {
         if (event.ci)
             details.push('CI');
         this.output.write(BADGE_PADDING + pc.dim(details.join(' · ')));
+        if (event.model !== undefined) {
+            this.output.write(BADGE_PADDING + pc.dim(`model ${bounded(event.model)}`));
+        }
         this.output.write('');
         this.window.start();
     }
+    /**
+     * The plan is settled once collection and every target's `prepare` are
+     * done, so its arrival is when the run starts executing and the clock
+     * starts: a browser downloaded moments earlier is not on it.
+     */
     plan(event) {
+        this.startedAt = new Date();
         for (const planned of event.files) {
             this.group(planned.file, planned.target).planned = planned.tests;
         }
         this.window.redraw();
     }
-    /** Acknowledged immediately, so a bounded teardown is not mistaken for a hang. */
+    /**
+     * The setup stretch before any test: collection, each target's `prepare`,
+     * then the services and app commands. Without this the window showed only
+     * zero counters while a database booted or a browser downloaded. The step
+     * in flight ticks in the live window; a finished process prints once with
+     * its wait, a finished collection or provisioning only when it narrated;
+     * the process waits sum into the summary's startup split.
+     */
+    setupStep(event) {
+        const { pc } = this;
+        const { verb, subject, done } = setupWording(event.step);
+        if (event.state === 'started') {
+            this.inFlight = { step: event.step, verb, subject, startedMs: Date.now(), narrated: false };
+            this.window.redraw();
+            return;
+        }
+        const narrated = this.inFlight?.narrated ?? false;
+        this.inFlight = undefined;
+        const process = event.step.kind === 'service' || event.step.kind === 'app';
+        if (process)
+            this.startupMs += event.durationMs;
+        if (!process && !narrated) {
+            this.window.redraw();
+            return;
+        }
+        const outcome = event.outcome ?? done;
+        this.print(` ${pc.green(F_CHECK)} ${subject} ${pc.dim(`${outcome} ${formatTime(event.durationMs)}`)}`);
+    }
+    /**
+     * Acknowledged immediately, so a bounded teardown is not mistaken for a
+     * hang. An interrupt that lands during setup names the step it cut short
+     * (`interrupted while starting service "postgres"`), since no test was
+     * running to stop.
+     */
     runInterrupted(event) {
-        this.print(this.pc.yellow(event.mode === 'graceful'
-            ? 'interrupted: stopping the running test and tearing down (interrupt again to force)'
-            : 'interrupted again: tearing every worker down now'));
+        this.interrupted = true;
+        const during = this.inFlight === undefined ? undefined : `${this.inFlight.verb} ${this.inFlight.subject}`;
+        this.print(this.pc.yellow(event.mode === 'forced'
+            ? 'interrupted again: tearing every worker down now'
+            : during === undefined
+                ? 'interrupted: stopping the running test and tearing down (interrupt again to force)'
+                : `interrupted while ${during}: tearing down (interrupt again to force)`));
     }
     /**
      * A worker began one test-target pair: show it in the live window. A serial
      * member replaces the previous member of its group, which has finished
-     * executing even though its result only arrives with the whole group.
+     * executing even though its result only arrives with the whole group. A
+     * serial group retries as a whole, so a member starts once per group
+     * attempt; its steps from earlier attempts stay with it, as an ordinary
+     * test's do.
      */
     testStarted(event) {
         if (event.serialId !== undefined) {
-            for (const [key, test] of this.running) {
-                if (test.serialId === event.serialId && test.group.target === event.target) {
-                    this.running.delete(key);
-                }
+            for (const test of this.pairs.values()) {
+                if (test.serialId === event.serialId && test.group.target === event.target)
+                    test.executing = false;
             }
         }
-        this.running.set(pairKey(event.testId, event.target), {
+        const key = pairKey(event.testId, event.target);
+        this.pairs.set(key, {
             group: this.group(event.file, event.target),
             serialId: event.serialId,
             title: bounded(event.title),
             startedMs: Date.now(),
-            step: undefined,
-            events: [],
-            streaming: false,
+            executing: true,
+            current: undefined,
+            steps: this.pairs.get(key)?.steps ?? [],
         });
         this.window.redraw();
     }
     /**
-     * Streams step progress of a running pair. With a single test running, its
-     * agent steps print permanently and chronologically under a header naming
-     * the file and test - the scrollback of a long agentic run reads without
-     * `--debug`. Deterministic steps are fast and many, so they only ever show
-     * in the live window. With parallel tests the stream would interleave, so
-     * each pair instead shows its current step and latest calls transiently in
-     * the live window, and finished agent steps print with the test they
-     * belong to.
+     * Tracks step progress of a running pair. With a live window the pair's
+     * finished agent steps accumulate under its row there and print once, nested
+     * under its line, when the file block prints - so every name appears exactly
+     * once in the scrollback. Without a window (CI logs) nothing is transient, so
+     * each finished agent step prints at once, prefixed with its test. Deterministic
+     * steps are fast and many, so they only ever show in the live window.
      */
     step(event) {
-        const { pc } = this;
-        const running = this.running.get(pairKey(event.testId, event.target));
+        const running = this.pairs.get(pairKey(event.testId, event.target));
         if (running === undefined)
             return;
         const { progress } = event;
         switch (progress.phase) {
             case 'start': {
-                running.step = `${progress.api} ${stepLabel(progress.label)}`;
-                running.events = [];
-                if (progress.kind === 'agent' && this.running.size === 1 && !running.streaming) {
-                    running.streaming = true;
-                    const { group } = running;
-                    group.streamed = true;
-                    this.print(` ${pc.yellow(F_POINTER)} ${this.badge(group.target)} ${pc.dim(bounded(group.file))}${this.separator}${running.title}`);
-                }
+                const { api, label, kind } = progress;
+                running.current = { api, label, kind, events: [], turnStart: 0 };
                 this.window.redraw();
                 break;
             }
             case 'event': {
-                const tail = eventTail(progress.event);
-                if (running.step === undefined || tail === undefined)
+                const { current } = running;
+                if (current === undefined || !isShownEvent(progress.event))
                     break;
-                running.events.push(tail);
+                if (progress.event.kind === 'model') {
+                    current.events.splice(current.turnStart, 0, progress.event);
+                    current.turnStart = current.events.length;
+                }
+                else {
+                    current.events.push(progress.event);
+                }
                 this.window.redraw();
                 break;
             }
             case 'end': {
-                running.step = undefined;
-                running.events = [];
+                running.current = undefined;
                 if (progress.kind !== 'agent') {
                     this.window.redraw();
                     break;
                 }
-                const glyph = progress.status === 'passed' ? pc.green(F_CHECK) : pc.red(F_CROSS);
-                const calls = progress.modelCalls > 0
-                    ? ` · ${progress.modelCalls} model call${progress.modelCalls === 1 ? '' : 's'}`
-                    : '';
-                const outcome = progress.status === 'passed' ? '' : ` ${progress.status}`;
-                const context = running.streaming ? '' : `${pc.dim(running.title)}${this.separator}`;
-                this.print(`   ${glyph} ${context}${pc.dim(progress.api)} ${stepLabel(progress.label)} ` +
-                    pc.dim(`${formatTime(progress.durationMs)}${calls}${outcome}`));
+                const { api, label, status, durationMs, modelCalls } = progress;
+                const step = { api, label, status, durationMs, modelCalls };
+                if (this.live) {
+                    running.steps.push(step);
+                    this.window.redraw();
+                }
+                else {
+                    const context = `${this.pc.dim(running.title)}${this.separator}`;
+                    this.print(`${TEST_INDENT}${stepLine(this.pc, step, { context })}`);
+                }
                 break;
             }
         }
@@ -335,12 +380,14 @@ export class ListReporter {
         // counted them.
         if (!result.selected)
             return;
-        this.running.delete(pairKey(result.test.id, result.target.name));
+        const key = pairKey(result.test.id, result.target.name);
+        const steps = this.pairs.get(key)?.steps ?? [];
+        this.pairs.delete(key);
         const group = this.group(result.test.file, result.target.name);
         const { durationMs, usage, error } = this.detailsOf(result);
         addUsage(this.runUsage, usage);
         const title = bounded(result.test.titlePath.join(' > '));
-        group.lines.push({
+        const line = {
             title,
             declarationIndex: result.test.declarationIndex,
             status: result.status,
@@ -348,7 +395,9 @@ export class ListReporter {
             usage,
             firstErrorLine: error === undefined ? undefined : bounded(error.message).split('\n')[0],
             skipReason: result.skip === undefined ? undefined : bounded(result.skip.reason),
-        });
+            steps,
+        };
+        group.lines.push(line);
         if (statusBucket(result.status) === 'failed') {
             this.failures.push({ group, title, status: result.status, error });
         }
@@ -376,8 +425,11 @@ export class ListReporter {
     }
     /**
      * Prints one file's block: the file line with its counts, then - when the
-     * file failed, had a flaky pass, streamed its steps, or is the run's only
-     * file - one line per test, as vitest lists tests for a failed module.
+     * file failed, had a flaky pass, or is the run's only file - one line per
+     * test with its finished agent steps nested, as vitest lists tests for a
+     * failed module. With a live window the block is also the only permanent
+     * record of a file's agent steps, so a file that has any lists its tests
+     * too; without one the steps already printed as they finished.
      */
     printGroup(group) {
         if (group.printed)
@@ -413,14 +465,16 @@ export class ListReporter {
         this.print(parts.join(' '));
         const verbose = counts.failed > 0 ||
             counts.flaky > 0 ||
-            group.streamed ||
-            this.groups.size === 1;
+            this.groups.size === 1 ||
+            (this.live && group.lines.some((line) => line.steps.length > 0));
         if (!verbose)
             return;
         const ordered = group.lines.toSorted((a, b) => a.declarationIndex - b.declarationIndex);
         for (const line of ordered) {
             for (const rendered of this.testLine(line))
                 this.print(rendered);
+            for (const step of line.steps)
+                this.print(`${STEP_INDENT}${stepLine(pc, step)}`);
         }
     }
     /** One test row under its file line, plus the first error line for a failure. */
@@ -455,89 +509,43 @@ export class ListReporter {
     }
     /**
      * vitest's padded summary, shared by the live window and the final report:
-     * files, tests, model usage, run errors, start time, and elapsed time.
+     * files, tests, model usage, run errors, start time, and elapsed time. The
+     * clock rows wait for `plan`; the final summary of a run that never got
+     * there (a config or collection failure, a failed download) counts from
+     * the launch instead, so the time it took to fail is still on record.
      */
-    summaryRows() {
+    summaryRows(final) {
         const { pc } = this;
         const files = this.fileCounters();
         const tests = this.testCounters();
         const rows = [
-            padTitle(pc, 'Test Files') + (files.total === 0 ? pc.dim('no test files') : stateString(pc, files)),
-            padTitle(pc, 'Tests') + (tests.total === 0 ? pc.dim('no tests executed') : stateString(pc, tests)),
+            padTitle(pc, 'Test Files') + (files.total === 0 ? this.emptyState('no test files', 'none started') : stateString(pc, files)),
+            padTitle(pc, 'Tests') + (tests.total === 0 ? this.emptyState('no tests executed', 'none executed') : stateString(pc, tests)),
         ];
-        const ai = aiSegment(this.runUsage);
+        const ai = usageText(this.runUsage);
         if (ai !== undefined)
             rows.push(padTitle(pc, 'AI') + `${ai} · ${this.runUsage.calls} model calls`);
         if (this.errors.length > 0) {
             const count = this.errors.length;
             rows.push(padTitle(pc, 'Errors') + pc.bold(pc.red(`${count} error${count === 1 ? '' : 's'}`)));
         }
-        rows.push(padTitle(pc, 'Start at') + formatClock(this.startedAt));
-        rows.push(padTitle(pc, 'Duration') + formatTime(Date.now() - this.startedAt.getTime()));
+        const startedAt = this.startedAt ?? (final ? this.launchedAt : undefined);
+        if (startedAt !== undefined) {
+            rows.push(padTitle(pc, 'Start at') + formatClock(startedAt));
+            const startup = this.startupMs > 0 ? pc.dim(` (startup ${formatTime(this.startupMs)})`) : '';
+            rows.push(padTitle(pc, 'Duration') + formatTime(Date.now() - startedAt.getTime()) + startup);
+        }
         return rows;
     }
-    /**
-     * The live window: running files and tests, then the summary. The block
-     * must fit the screen, because repainting more rows than the terminal has
-     * breaks the cursor-up erase: rows left after the summary go to the running
-     * tests, each test's calls share what remains once every test has its own
-     * line, and tests that still do not fit fold into one `more running` marker.
-     */
-    renderWindow() {
+    /** A zero counter's label: the plain text, or the interrupt when that is why nothing is counted. */
+    emptyState(none, cut) {
         const { pc } = this;
-        const now = Date.now();
-        const active = new Map();
-        for (const test of this.running.values()) {
-            const tests = active.get(test.group);
-            if (tests === undefined)
-                active.set(test.group, [test]);
-            else
-                tests.push(test);
-        }
-        const summary = this.summaryRows();
-        let budget = terminalRows() - summary.length - WINDOW_CHROME_ROWS;
-        const spare = budget - active.size - this.running.size * WINDOW_ROWS_PER_TEST;
-        const maxEvents = Math.max(0, Math.floor(spare / Math.max(1, this.running.size)));
-        const lines = [''];
-        let hidden = 0;
-        for (const [group, tests] of active) {
-            if (budget < 2) {
-                hidden += tests.length;
-                continue;
-            }
-            const progress = pc.dim(` ${group.lines.length}/${group.planned ?? '?'}`);
-            lines.push(`${pc.bold(pc.yellow(` ${F_POINTER} `))}${this.badge(group.target)} ${bounded(group.file)}${progress}`);
-            budget -= 1;
-            tests.forEach((test, index) => {
-                if (budget < 1) {
-                    hidden += 1;
-                    return;
-                }
-                const glyph = index === tests.length - 1 ? F_TREE_END : F_TREE_MIDDLE;
-                const elapsed = pc.bold(pc.yellow(formatTime(Math.max(0, now - test.startedMs))));
-                lines.push(`${pc.bold(pc.yellow(`   ${glyph} `))}${test.title} ${elapsed}`);
-                budget -= 1;
-                if (test.step === undefined)
-                    return;
-                const detail = [`       ${pc.dim(`${F_DOWN_RIGHT} ${test.step}`)}`];
-                const overflow = test.events.length - maxEvents;
-                if (overflow > 0) {
-                    detail.push(`         ${pc.dim(`… ${overflow} earlier call${overflow === 1 ? '' : 's'}`)}`);
-                }
-                for (const tail of overflow > 0 ? test.events.slice(overflow) : test.events) {
-                    detail.push(`         ${pc.dim(tail)}`);
-                }
-                const shown = detail.slice(0, budget);
-                lines.push(...shown);
-                budget -= shown.length;
-            });
-        }
-        if (hidden > 0)
-            lines.push(pc.dim(`   … ${hidden} more running`));
-        if (active.size > 0)
-            lines.push('');
-        lines.push(...summary, '');
-        return lines;
+        return this.interrupted ? pc.yellow(`${cut} (interrupted)`) : pc.dim(none);
+    }
+    /** The live window: the running tree, then the summary. */
+    renderWindow() {
+        const running = [...this.pairs.values()].filter((test) => test.executing);
+        return this.tree.render(running, this.summaryRows(false), Date.now(), this.inFlight);
     }
     /** vitest's `Failed Tests` section: a banner, then each failure with its code frame. */
     printFailures() {
@@ -605,6 +613,8 @@ export class ListReporter {
     }
     runFinished(event) {
         const { pc } = this;
+        if (event.status === 'interrupted')
+            this.interrupted = true;
         this.window.stop();
         // An interrupted or crashed run leaves files without their full result
         // set; print what they have so nothing that ran goes unreported.
@@ -615,7 +625,7 @@ export class ListReporter {
         this.printFailures();
         this.printErrors();
         this.print('');
-        for (const row of this.summaryRows())
+        for (const row of this.summaryRows(true))
             this.print(row);
         this.print(padTitle(pc, 'Report') +
             (event.reportPath === undefined ? pc.dim('(not written)') : this.displayPath(event.reportPath)));
@@ -629,4 +639,24 @@ export class ListReporter {
         this.print('');
     }
 }
+/**
+ * How the reporter phrases one setup step: the verb and subject while it
+ * runs (`starting service "postgres"`), and the word for its completion
+ * (`ready`); a reused process says `reused` instead.
+ */
+function setupWording(step) {
+    switch (step.kind) {
+        case 'collect':
+            return { verb: 'collecting', subject: 'tests', done: 'collected' };
+        case 'prepare':
+            return {
+                verb: 'preparing',
+                subject: `${bounded(step.engine)} engine for target "${bounded(step.target)}"`,
+                done: 'prepared',
+            };
+        case 'service':
+        case 'app':
+            return { verb: 'starting', subject: bounded(step.label), done: 'ready' };
+    }
+}
 //# sourceMappingURL=list.js.map