windows-development-sandbox 1.23.1 → 1.25.0

package/dist/guest/boot/progress-view.js

@@ -0,0 +1,456 @@
+// The boot's console (docs/design/parallel-boot.md, "Console output"). A terminal gets one header line and a block of
+// stage rows that redraws in place; anything else (a log, CI, a dry run) gets plain lines, a stage at a time, in stage
+// order, once it has finished. Warnings, the tool list and the ready line come once, at the end. Pure: the boot feeds
+// it the runner's events and its own lines and gives it a screen to write to (boot-console.ts).
+import { duration } from './runner.js';
+/** For Windows Terminal (Cascadia has braille and check marks). */
+export const RICH_GLYPHS = {
+    done: '✓',
+    failed: '✗',
+    warned: '!',
+    skipped: '-',
+    waiting: '·',
+    more: '…',
+    spinner: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'],
+};
+/** For the classic console (Consolas has neither braille nor check marks). */
+export const CONSOLE_GLYPHS = {
+    done: '√',
+    failed: 'x',
+    warned: '!',
+    skipped: '-',
+    waiting: '·',
+    more: '...',
+    spinner: ['-', '\\', '|', '/'],
+};
+/** How a stage row looks in each state: its glyph (a running row spins instead), colour and detail. */
+const MARKS = {
+    waiting: { glyph: 'waiting', colour: 'dim', detail: 'waiting' },
+    running: { glyph: 'waiting', colour: 'cyan', detail: '' },
+    done: { glyph: 'done', colour: 'green', detail: '' },
+    warned: { glyph: 'warned', colour: 'yellow', detail: 'see the warnings' },
+    failed: { glyph: 'failed', colour: 'red', detail: '' },
+    skipped: { glyph: 'skipped', colour: 'dim', detail: 'skipped' },
+};
+const ANSI = {
+    green: '\x1b[32m',
+    red: '\x1b[31m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    dim: '\x1b[2m',
+    bold: '\x1b[1m',
+};
+const RESET = '\x1b[0m';
+/** Moves to the start of the line `n` lines up. */
+const up = (n) => '\r\x1b[' + n + 'A';
+const CLEAR_LINE = '\x1b[2K';
+const CLEAR_BELOW = '\x1b[J';
+const HIDE_CURSOR = '\x1b[?25l';
+const SHOW_CURSOR = '\x1b[?25h';
+const SPIN_MS = 80;
+const TIME_WIDTH = 6;
+/** Warnings shown under the live block (the rest wait for the end). */
+const LIVE_WARNINGS = 4;
+/** The tool names column of the summary (a longer name pushes its detail along). */
+const TOOL_COLUMN = 24;
+/** Tasks under a second are not worth naming as "slowest". */
+const SLOW_MS = 1000;
+const MIN_WIDTH = 40;
+class StageState {
+    stage;
+    name;
+    total;
+    began = null;
+    ended = null;
+    finished = 0;
+    skipped = 0;
+    softFailed = false;
+    error = null;
+    printed = false;
+    /** Task id -> what the row shows for it (its title, or the detail the boot gave it). */
+    running = new Map();
+    lines = [];
+    problems = [];
+    constructor(stage, name, total) {
+        this.stage = stage;
+        this.name = name;
+        this.total = total;
+    }
+    get complete() {
+        return this.finished >= this.total;
+    }
+    mark() {
+        if (this.error !== null)
+            return 'failed';
+        if (this.complete) {
+            if (this.total > 0 && this.skipped === this.total)
+                return 'skipped';
+            return this.softFailed ? 'warned' : 'done';
+        }
+        return this.began === null ? 'waiting' : 'running';
+    }
+    /** How long the stage has run (from its first task's start to its last task's end, or to now). */
+    elapsed(now) {
+        if (this.began === null)
+            return null;
+        return (this.ended ?? now) - this.began;
+    }
+}
+/** "Node, Python, Rust +2 (5/13)": what the toolchain scheduler runs now. */
+export function stepsDetail(active, done, total) {
+    const shown = active.slice(0, 3).join(', ') + (active.length > 3 ? ' +' + (active.length - 3) : '');
+    return (shown || 'Developer tools') + (total > 0 ? ' (' + done + '/' + total + ')' : '');
+}
+/** "Ready in 46.8s (slowest: ...)" and, when work goes on, the line that says what still installs. */
+export function readyLines(info) {
+    const slowest = [...info.outcomes]
+        .filter((o) => o.state !== 'skipped' && o.ms >= SLOW_MS)
+        .sort((a, b) => b.ms - a.ms)
+        .slice(0, 3)
+        .map((o) => o.title + ' ' + duration(o.ms));
+    const later = info.background;
+    const names = later.length > 3 ? later.slice(0, 3).join(', ') + ' and ' + (later.length - 3) + ' more' : later.join(', ');
+    return [
+        'Ready in ' + duration(info.ms) + (slowest.length ? ' (slowest: ' + slowest.join(', ') + ')' : ''),
+        ...(later.length
+            ? ['Still installing in the background: ' + names + ' (a few minutes; it does not hold you up)']
+            : []),
+    ];
+}
+/** Word-wraps `text` to `width` columns; a word longer than that is cut. Linear in the text. */
+export function wrap(text, width) {
+    const lines = [];
+    let line = '';
+    for (let word of text.split(' ')) {
+        while (word.length > width) {
+            if (line)
+                lines.push(line);
+            lines.push(word.slice(0, width));
+            word = word.slice(width);
+            line = '';
+        }
+        if (!line)
+            line = word;
+        else if (line.length + 1 + word.length <= width)
+            line += ' ' + word;
+        else {
+            lines.push(line);
+            line = word;
+        }
+    }
+    lines.push(line);
+    return lines;
+}
+/** One boot's console: fed by the runner's events and the boot's lines, drawn on a screen. */
+export class ProgressView {
+    o;
+    stages;
+    byStage = new Map();
+    taskById = new Map();
+    nameWidth;
+    glyphs;
+    warnings = [];
+    notices = [];
+    tools = [];
+    /** Lines of the live block on the screen now (the cursor is just below them). */
+    drawn = 0;
+    lastFrame = '';
+    asideDepth = 0;
+    released = false;
+    constructor(stages, tasks, o) {
+        this.o = o;
+        this.glyphs = o.glyphs ?? RICH_GLYPHS;
+        this.stages = [...stages]
+            .sort((a, b) => a.stage - b.stage)
+            .map((s) => new StageState(s.stage, s.name, tasks.filter((t) => t.stage === s.stage).length));
+        for (const s of this.stages)
+            this.byStage.set(s.stage, s);
+        for (const t of tasks)
+            this.taskById.set(t.id, t);
+        this.nameWidth = Math.max(0, ...stages.map((s) => s.name.length));
+    }
+    /**
+     * Whether programs should hand their output to the log now: it would draw over the live block, or come out between
+     * the plain stages. Not while a hook has the terminal.
+     */
+    get capturing() {
+        return !this.released && this.asideDepth === 0;
+    }
+    /** The header line, then (live) the first frame. */
+    start(header) {
+        this.o.screen.write(this.paint(header, 'bold') + '\n\n');
+        if (this.o.live) {
+            this.o.screen.write(HIDE_CURSOR);
+            this.draw();
+        }
+    }
+    started(task) {
+        const s = this.byStage.get(task.stage);
+        if (!s)
+            return;
+        s.began ??= this.o.now();
+        s.running.set(task.id, task.title);
+    }
+    finished(task, outcome) {
+        const s = this.byStage.get(task.stage);
+        if (!s)
+            return;
+        s.running.delete(task.id);
+        s.finished++;
+        if (outcome.state === 'skipped') {
+            s.skipped++;
+            s.problems.push(this.glyphs.skipped + ' ' + task.title + ' skipped (' + (outcome.error ?? '') + ')');
+        }
+        else if (outcome.state === 'failed') {
+            if (task.critical) {
+                s.error ??= outcome.error ?? 'failed';
+                s.problems.push(this.glyphs.failed + ' ' + task.title + ' failed: ' + (outcome.error ?? ''));
+            }
+            else
+                s.softFailed = true;
+        }
+        if (s.began !== null && s.complete)
+            s.ended = this.o.now();
+        this.flushPlain();
+    }
+    /** What a running task's place on its row says instead of its title (null: its title again). */
+    detail(taskId, text) {
+        const task = this.taskById.get(taskId);
+        const s = task && this.byStage.get(task.stage);
+        if (!s?.running.has(taskId))
+            return;
+        s.running.set(taskId, text ?? task.title);
+    }
+    /** An info line: the file has it; plain output shows it under its stage (or at once, outside a stage). */
+    line(text, stage) {
+        if (this.released)
+            return;
+        if (this.asideDepth > 0) {
+            this.o.screen.write(text + '\n');
+            return;
+        }
+        if (this.o.live)
+            return;
+        const s = stage === undefined ? undefined : this.byStage.get(stage);
+        if (s && !s.printed)
+            s.lines.push(text);
+        else
+            this.o.screen.write((s ? this.indent() : '') + text + '\n');
+    }
+    warning(text) {
+        if (!this.warnings.includes(text))
+            this.warnings.push(text);
+    }
+    notice(text) {
+        if (!this.notices.includes(text))
+            this.notices.push(text);
+    }
+    /** The tool summary ("name: detail" lines), printed once at the end. */
+    summary(lines) {
+        this.tools = [...lines];
+    }
+    /** Redraws the live block (the boot calls it a few times a second). */
+    tick() {
+        if (this.o.live && !this.released && this.asideDepth === 0)
+            this.draw();
+    }
+    /** Runs `work`, which writes to the terminal itself (the hooks): the live block steps aside until it is done. */
+    aside(work) {
+        if (!this.o.live || this.released)
+            return work();
+        this.erase();
+        this.asideDepth++;
+        const back = () => {
+            this.asideDepth--;
+            this.tick();
+        };
+        let result;
+        try {
+            result = work();
+        }
+        catch (e) {
+            back();
+            throw e;
+        }
+        if (result instanceof Promise)
+            return result.finally(back);
+        back();
+        return result;
+    }
+    /**
+     * The boot is over (`ready`) or failed (null): the final block, warnings, tools, notices and the ready line, once.
+     * The console is free afterwards (the first session takes it); nothing of this view prints again.
+     */
+    release(ready) {
+        if (this.released)
+            return;
+        if (this.o.live)
+            this.erase();
+        this.released = true;
+        const width = this.o.live ? this.width() : Infinity;
+        // Sections, a blank line between them.
+        const sections = [];
+        if (this.warnings.length)
+            sections.push([
+                this.paint('Warnings', 'yellow'),
+                ...this.warnings.flatMap((w) => this.hanging('  ! ', w, width, 'yellow')),
+            ]);
+        if (this.tools.length)
+            sections.push([this.paint('Tools', 'bold'), ...this.toolRows(width)]);
+        if (this.notices.length)
+            sections.push(this.notices.flatMap((n) => this.hanging('', n, width)));
+        if (ready) {
+            const [first, ...rest] = readyLines(ready);
+            sections.push([
+                this.paint(first, 'green'),
+                ...rest.map((l) => this.paint(l, 'cyan')),
+                this.paint('Log: ' + ready.logPath, 'dim'),
+            ]);
+        }
+        const join = (parts) => parts.map((p) => p.join('\n') + '\n').join('\n');
+        if (this.o.live) {
+            // The block again, still (no spinner), where the live one was.
+            const rows = this.stages.map((s) => this.row(s, null));
+            this.o.screen.write(join([rows, ...sections]) + SHOW_CURSOR);
+            return;
+        }
+        // Plain: the stages not printed yet (a failed boot), then the sections after a blank line.
+        const left = this.stages.filter((s) => !s.printed && s.began !== null).flatMap((s) => this.stageBlock(s));
+        const text = (left.length ? left.join('\n') + '\n' : '') + (sections.length ? '\n' + join(sections) : '');
+        if (text)
+            this.o.screen.write(text);
+    }
+    /** The live block as it would be drawn now (no colours when `colour` is false): the tests read it. */
+    frame(colour = true) {
+        const now = this.o.now();
+        const rows = this.stages.map((s) => this.row(s, now, colour));
+        if (!this.warnings.length)
+            return rows;
+        const width = this.width();
+        const shown = this.warnings.slice(-LIVE_WARNINGS);
+        const more = this.warnings.length - shown.length;
+        return [
+            ...rows,
+            '',
+            ...shown.map((w) => this.render([{ text: '  ! ' + w, colour: 'yellow' }], width, colour)),
+            ...(more > 0
+                ? [this.render([{ text: '  + ' + more + ' more (shown when ready)', colour: 'dim' }], width, colour)]
+                : []),
+        ];
+    }
+    draw() {
+        const lines = this.frame();
+        const text = lines.map((l) => CLEAR_LINE + l + '\n').join('');
+        if (text === this.lastFrame && this.drawn === lines.length)
+            return;
+        this.o.screen.write((this.drawn ? up(this.drawn) : '') + text + CLEAR_BELOW);
+        this.lastFrame = text;
+        this.drawn = lines.length;
+    }
+    erase() {
+        if (this.drawn)
+            this.o.screen.write(up(this.drawn) + CLEAR_BELOW);
+        this.drawn = 0;
+        this.lastFrame = '';
+    }
+    /** Plain output: every finished stage whose earlier stages are printed, in stage order. */
+    flushPlain() {
+        if (this.o.live || this.released)
+            return;
+        for (const s of this.stages) {
+            if (s.printed)
+                continue;
+            if (!s.complete)
+                return;
+            this.o.screen.write(this.stageBlock(s).join('\n') + '\n');
+        }
+    }
+    stageBlock(s) {
+        s.printed = true;
+        const time = s.elapsed(this.o.now());
+        const state = s.error !== null ? '  FAILED' : !s.complete ? '  not finished' : s.mark() === 'skipped' ? '  skipped' : '';
+        const head = '[' + s.stage + '/' + this.stages.length + '] ' + s.name.padEnd(this.nameWidth);
+        return [
+            head + (time === null ? '' : '  ' + duration(time).padStart(TIME_WIDTH)) + state,
+            ...s.problems.map((p) => this.indent() + p),
+            ...s.lines.map((l) => this.indent() + l),
+        ];
+    }
+    indent() {
+        return ' '.repeat(('[9/' + this.stages.length + '] ').length);
+    }
+    /** One stage row; `now` null: the final, still row (no spinner). */
+    row(s, now, colour = true) {
+        const mark = s.mark();
+        const look = MARKS[mark];
+        const still = now === null;
+        // A stage still running when the view is released (a failed boot) shows as unfinished, without a spinner.
+        const spinning = mark === 'running' && !still;
+        const glyph = spinning
+            ? this.glyphs.spinner[Math.floor(now / SPIN_MS) % this.glyphs.spinner.length]
+            : this.glyphs[look.glyph];
+        const elapsed = s.elapsed(now ?? this.o.now());
+        const time = elapsed === null || (mark === 'running' && still) ? '' : duration(elapsed);
+        const detail = mark === 'running'
+            ? still
+                ? 'not finished'
+                : [...s.running.values()].join(', ') || 'waiting'
+            : mark === 'failed'
+                ? 'failed: ' + s.error
+                : mark === 'waiting' && still
+                    ? 'not started'
+                    : look.detail;
+        return this.render([
+            { text: '  ' },
+            { text: glyph, colour: mark === 'running' && still ? 'dim' : look.colour },
+            { text: ' ' + s.stage + '  ' },
+            { text: s.name.padEnd(this.nameWidth), ...(mark === 'waiting' ? { colour: 'dim' } : {}) },
+            { text: '  ' + time.padStart(TIME_WIDTH), colour: 'dim' },
+            { text: detail ? '  ' + detail : '', colour: mark === 'failed' ? 'red' : 'dim' },
+        ], now === null ? Infinity : this.width(), colour);
+    }
+    /** The tool summary as two aligned columns, the detail wrapped under itself. */
+    toolRows(width) {
+        const rows = this.tools.map((line) => {
+            const at = line.indexOf(': ');
+            return at > 0 ? { name: line.slice(0, at), detail: line.slice(at + 2) } : { name: line, detail: '' };
+        });
+        const column = Math.min(TOOL_COLUMN, Math.max(0, ...rows.map((r) => r.name.length)));
+        const lead = ' '.repeat(2 + column + 2);
+        return rows.flatMap((r) => {
+            const colour = r.name === 'PROTECTION MISSING' ? 'red' : undefined;
+            if (!r.detail)
+                return [this.paint('  ' + r.name, colour)];
+            // A name longer than the column gets a line of its own; the detail stays in its column.
+            if (r.name.length > column)
+                return [this.paint('  ' + r.name, colour), ...this.hanging(lead, r.detail, width, colour)];
+            return this.hanging('  ' + r.name.padEnd(column) + '  ', r.detail, width, colour);
+        });
+    }
+    /** `lead` + `text`, wrapped to `width` with the next lines indented under the text. */
+    hanging(lead, text, width, colour) {
+        const lines = width === Infinity ? [text] : wrap(text, Math.max(MIN_WIDTH / 2, width - lead.length));
+        return lines.map((l, i) => this.paint((i === 0 ? lead : ' '.repeat(lead.length)) + l, colour));
+    }
+    /** The segments as one line of at most `width` columns, cut with the "more" mark. */
+    render(segments, width, colour = true) {
+        const total = segments.reduce((n, s) => n + s.text.length, 0);
+        let room = total > width ? Math.max(0, width - this.glyphs.more.length) : Infinity;
+        let out = '';
+        for (const s of segments) {
+            if (room <= 0)
+                break;
+            const text = s.text.slice(0, room);
+            room -= text.length;
+            out += colour && s.colour && text.trim() ? ANSI[s.colour] + text + RESET : text;
+        }
+        return total > width ? out.trimEnd() + this.glyphs.more : out.trimEnd();
+    }
+    paint(text, colour) {
+        return this.o.live && colour ? ANSI[colour] + text + RESET : text;
+    }
+    /** The usable width: one column less than the terminal (a full line would wrap the cursor). */
+    width() {
+        return Math.max(MIN_WIDTH, this.o.screen.columns() - 1);
+    }
+}

package/dist/guest/boot/runner.d.ts

@@ -27,9 +27,22 @@ export interface RunnerStatus {
     readonly running: readonly string[];
     readonly message: string;
 }
+/** What the console's progress view hears (foreground tasks only: the background ones are file-only). */
+export interface RunnerObserver {
+    started(task: BootTaskDef): void;
+    /** Also for a task that was skipped (it never started). */
+    finished(task: BootTaskDef, outcome: TaskOutcome): void;
+}
+/** Who logs while a task runs. */
+export interface TaskContext {
+    readonly stage: number;
+    readonly title: string;
+    readonly quiet: boolean;
+}
 export interface RunnerOptions {
+    /** A line for the log file only: when each task started and finished (the console shows the progress view). */
+    trace(line: string): void;
     /** `quiet`: file only (background tasks). */
-    say(line: string, quiet?: boolean): void;
     warn(line: string, quiet?: boolean): void;
     /** Milliseconds. */
     now(): number;
@@ -39,13 +52,12 @@ export interface RunnerOptions {
     stages: number;
     stageTitle(stage: number): string;
     status?(status: RunnerStatus): void;
-    /** Runs a task's work so that its log lines carry the task (`prefix()` is empty while it runs alone). */
-    inContext?<T>(ctx: {
-        prefix: () => string;
-        quiet: boolean;
-    }, work: () => T): T;
+    observer?: RunnerObserver;
+    /** Runs a task's work so that its log lines carry the task (its stage and title, and whether they stay quiet). */
+    inContext?<T>(ctx: TaskContext, work: () => T): T;
 }
-export declare const seconds: (ms: number) => string;
+/** "4.6s" under a minute, "7m02s" from there. */
+export declare function duration(ms: number): string;
 /** Dependencies must exist, ids be unique, the graph acyclic and no foreground task wait for a background one. */
 export declare function checkGraph(defs: readonly BootTaskDef[]): void;
 export declare class BootRunner<Id extends string> {
@@ -55,7 +67,6 @@ export declare class BootRunner<Id extends string> {
     private readonly byId;
     private readonly state;
     private readonly outcomes;
-    private readonly announced;
     private readonly running;
     constructor(defs: readonly BootTaskDef<Id>[], impl: Readonly<Record<Id, TaskRun>>, o: RunnerOptions);
     /** Every outcome so far, in declaration order. */
@@ -68,10 +79,9 @@ export declare class BootRunner<Id extends string> {
     private isFinished;
     /** The task cannot have run properly: skipped, or failed with a critical failure. */
     private isBlocked;
+    private tag;
     private skip;
     private begin;
     private finish;
     private report;
 }
-/** "Boot ready in 31.8s. Slowest: Headroom 28.1s, Developer tools 7.0s. In the background: Visual Studio (...)". */
-export declare function bootSummary(totalMs: number, outcomes: readonly TaskOutcome[], background: readonly string[], logPath: string): string;

package/dist/guest/boot/runner.js

@@ -1,9 +1,15 @@
 // Runs the boot's tasks: each starts when the tasks it comes after are finished, a few at a time, in declaration order.
-// Pure (no runtime imports): the boot injects printing, the clock, the log context and the status.
+// Pure (no runtime imports): the boot injects the log, the clock, the log context, the status and the progress view.
 const PARALLEL = 4;
-const CYAN = '\x1b[36m';
-const RESET = '\x1b[0m';
-export const seconds = (ms) => (ms / 1000).toFixed(1) + 's';
+const MINUTE = 60000;
+/** "4.6s" under a minute, "7m02s" from there. */
+export function duration(ms) {
+    // 59.96 s would round to "60.0s": from there it is "1m00s".
+    if (ms < MINUTE - 50)
+        return (Math.max(0, ms) / 1000).toFixed(1) + 's';
+    const s = Math.round(ms / 1000);
+    return Math.floor(s / 60) + 'm' + String(s % 60).padStart(2, '0') + 's';
+}
 /** Dependencies must exist, ids be unique, the graph acyclic and no foreground task wait for a background one. */
 export function checkGraph(defs) {
     const byId = new Map();
@@ -44,7 +50,6 @@ export class BootRunner {
     byId = new Map();
     state = new Map();
     outcomes = new Map();
-    announced = new Set();
     running = new Set();
     constructor(defs, impl, o) {
         this.defs = defs;
@@ -84,13 +89,12 @@ export class BootRunner {
                 this.state.set(d.id, 'running');
                 this.running.add(d.id);
                 const began = this.o.now();
-                if (!quiet)
-                    this.begin(d);
-                const prefix = () => (this.running.size > 1 && !d.exclusive ? d.title : '');
+                this.begin(d, quiet);
+                const ctx = { stage: d.stage, title: d.title, quiet };
                 const work = async () => {
                     await this.impl[d.id]();
                 };
-                const call = () => (this.o.inContext ? this.o.inContext({ prefix, quiet }, work) : work());
+                const call = () => (this.o.inContext ? this.o.inContext(ctx, work) : work());
                 // A synchronous throw from a task is a failure too: the call starts inside a promise.
                 void Promise.resolve()
                     .then(call)
@@ -115,7 +119,7 @@ export class BootRunner {
                     for (const d of pending()) {
                         const bad = d.after.find((a) => this.isBlocked(a));
                         if (bad) {
-                            this.skip(d, this.byId.get(bad).title + ' failed');
+                            this.skip(d, this.byId.get(bad).title + ' failed', quiet);
                             again = true;
                         }
                     }
@@ -147,43 +151,44 @@ export class BootRunner {
         const s = this.state.get(id);
         return s === 'skipped' || (s === 'failed' && this.byId.get(id).critical);
     }
-    skip(d, why) {
+    tag(d) {
+        return (d.background ? '[background] ' : '[' + d.stage + '/' + this.o.stages + '] ') + d.title;
+    }
+    skip(d, why, quiet) {
         this.state.set(d.id, 'skipped');
-        this.outcomes.set(d.id, { id: d.id, title: d.title, state: 'skipped', ms: 0, error: why });
-        this.o.say('[' + d.stage + '/' + this.o.stages + '] ' + d.title + ': skipped (' + why + ')');
+        const outcome = { id: d.id, title: d.title, state: 'skipped', ms: 0, error: why };
+        this.outcomes.set(d.id, outcome);
+        this.o.trace(this.tag(d) + ': skipped (' + why + ')');
+        if (!quiet)
+            this.o.observer?.finished(d, outcome);
     }
-    begin(d) {
-        if (!this.announced.has(d.stage)) {
-            this.announced.add(d.stage);
-            this.o.say('\n' + CYAN + '[' + d.stage + '/' + this.o.stages + '] ' + this.o.stageTitle(d.stage) + RESET);
-        }
-        this.o.say('[' + d.stage + '/' + this.o.stages + '] ' + d.title + ': started');
+    begin(d, quiet) {
+        this.o.trace(this.tag(d) + ': started');
+        if (quiet)
+            return;
+        this.o.observer?.started(d);
         this.report(d.stage);
     }
     finish(d, began, quiet, error) {
         const ms = this.o.now() - began;
         const message = error === undefined ? undefined : error instanceof Error ? error.message : String(error);
-        this.state.set(d.id, message === undefined ? 'done' : 'failed');
-        this.outcomes.set(d.id, {
+        const outcome = {
             id: d.id,
             title: d.title,
             state: message === undefined ? 'done' : 'failed',
             ms,
             ...(message === undefined ? {} : { error: message }),
-        });
-        const tag = '[' + d.stage + '/' + this.o.stages + '] ' + d.title;
-        if (message === undefined) {
-            if (!quiet)
-                this.o.say(tag + ': done in ' + seconds(ms));
-        }
-        else if (d.critical) {
-            this.o.warn(tag + ': FAILED in ' + seconds(ms) + ': ' + message, quiet);
-        }
-        else {
+        };
+        this.state.set(d.id, outcome.state);
+        this.outcomes.set(d.id, outcome);
+        this.o.trace(this.tag(d) + (message === undefined ? ': done in ' : ': FAILED in ') + duration(ms));
+        // A soft failure is a warning and the boot goes on; a critical one stops the boot, which shows that error.
+        if (message !== undefined && !d.critical)
             this.o.warn(d.title + ' failed (continuing): ' + message, quiet);
-            if (!quiet)
-                this.o.say(tag + ': FAILED in ' + seconds(ms) + ': ' + message);
-        }
+        if (message !== undefined && d.critical)
+            this.o.trace(this.tag(d) + ': ' + message);
+        if (!quiet)
+            this.o.observer?.finished(d, outcome);
     }
     report(stageHint) {
         if (!this.o.status)
@@ -200,16 +205,3 @@ export class BootRunner {
         });
     }
 }
-/** "Boot ready in 31.8s. Slowest: Headroom 28.1s, Developer tools 7.0s. In the background: Visual Studio (...)". */
-export function bootSummary(totalMs, outcomes, background, logPath) {
-    const slowest = [...outcomes]
-        .filter((o) => o.state !== 'skipped')
-        .sort((a, b) => b.ms - a.ms)
-        .slice(0, 3)
-        .map((o) => o.title + ' ' + seconds(o.ms));
-    return ('Boot ready in ' +
-        seconds(totalMs) +
-        '.' +
-        (slowest.length ? ' Slowest: ' + slowest.join(', ') + '.' : '') +
-        (background.length ? ' In the background: ' + background.join(', ') + ' (installing, see ' + logPath + ').' : ''));
-}

package/dist/guest/runtime/log-line.d.ts

@@ -0,0 +1,7 @@
+/** Text without its terminal colour and cursor sequences. */
+export declare function plainText(text: string): string;
+/**
+ * The file lines for one message: each line of it with an ISO timestamp (UTC, zero-padded:
+ * `2026-11-04T12:07:27.930Z`) and the task that logged it, if any; blank lines are dropped.
+ */
+export declare function fileLines(message: string, at?: Date, task?: string): string[];