@sdxc/cli 0.0.0-stage → 2026.10.16

package/dist/session.js

@@ -0,0 +1,219 @@
+/**
+ * One run's process context: its working directory, environment and streams, whether it may
+ * ask questions, the terminal owner tasks and prompts draw through, and the signal Ctrl+C
+ * aborts. Built from `cli.run`'s options, each defaulting to the process's own.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import { failure, isFailure } from "@sdxc/result";
+import { CancelledError } from "./errors.js";
+import { spawnExec } from "./exec.js";
+import { interaction } from "./interactions.js";
+import { isCancel, openKeyboard } from "./keys.js";
+import { Screen } from "./screen.js";
+import { colorEnabled, createStyle } from "./style.js";
+import { Tasks } from "./task.js";
+/** Whether the environment asks for plain task output: in CI or on a dumb terminal. */
+function plainProgress(env) {
+    let ci = env.CI;
+    return (ci !== undefined && ci !== "" && ci !== "0" && ci !== "false") || env.TERM === "dumb";
+}
+/** The process's environment as a plain record. */
+function processEnv() {
+    return { ...process.env };
+}
+/**
+ * Opens the session for one run.
+ *
+ * @param noProgress - Whether `--no-progress` was passed
+ * @param script - How a test answers prompts; `undefined` for a person at a terminal
+ */
+export function openSession(io, noProgress, script) {
+    let env = io.env ?? processEnv();
+    let stdin = io.stdin ?? process.stdin;
+    let stdout = io.stdout ?? process.stdout;
+    let stderr = io.stderr ?? process.stderr;
+    let controller = new AbortController();
+    let unlink = [];
+    if (io.signal !== undefined) {
+        let forward = () => controller.abort(new CancelledError());
+        if (io.signal.aborted)
+            forward();
+        else
+            io.signal.addEventListener("abort", forward, { once: true });
+        unlink.push(() => io.signal?.removeEventListener("abort", forward));
+    }
+    let screen = new Screen(stderr);
+    let raw = false;
+    let restore = () => {
+        screen.restore();
+        if (raw)
+            stdin.setRawMode?.(false);
+        raw = false;
+    };
+    if (io.signal === undefined && io.stderr === undefined) {
+        let onSignal = (name) => () => {
+            if (controller.signal.aborted) {
+                restore();
+                process.exit(name === "SIGINT" ? 130 : 143);
+            }
+            controller.abort(new CancelledError());
+        };
+        let onInt = onSignal("SIGINT");
+        let onTerm = onSignal("SIGTERM");
+        process.on("SIGINT", onInt);
+        process.on("SIGTERM", onTerm);
+        process.on("exit", restore);
+        unlink.push(() => {
+            process.off("SIGINT", onInt);
+            process.off("SIGTERM", onTerm);
+            process.off("exit", restore);
+        });
+    }
+    let terminal = stdin.isTTY === true && stderr.isTTY === true;
+    let interactive = script === undefined ? terminal : script.interactive;
+    let animate = stderr.isTTY === true && !noProgress && !plainProgress(env);
+    let stderrStyle = createStyle(colorEnabled(stderr, env));
+    let style = Object.assign(createStyle(colorEnabled(stdout, env)), { stderr: stderrStyle });
+    let tasks = new Tasks(screen, stderrStyle, animate, controller.signal);
+    let exec = io.exec ?? spawnExec;
+    let answered = 0;
+    let cwd = io.cwd ?? process.cwd();
+    /** A scripted answer for `request`, or `undefined` when the script has none. */
+    let scripted = (request) => {
+        let answers = script?.answers;
+        if (answers === undefined)
+            return undefined;
+        if (Array.isArray(answers)) {
+            if (answered >= answers.length)
+                return undefined;
+            answered += 1;
+            return { value: answers[answered - 1] };
+        }
+        let byName = answers;
+        for (let name of request.names) {
+            if (Object.hasOwn(byName, name))
+                return { value: byName[name] };
+        }
+        return undefined;
+    };
+    /** The line an answered prompt leaves behind. */
+    let summaryLine = (request, answer) => {
+        let shown = interaction(request.kind, request.options, request.initial).summary(answer);
+        let message = stderrStyle.bold(request.options.message);
+        return `${stderrStyle.green("✓")} ${message}${shown === "" ? "" : ` ${stderrStyle.dim(shown)}`}\n`;
+    };
+    /** Asks on the terminal, key by key, until an answer passes its check or the user cancels. */
+    let converse = async (request, keyboard) => {
+        let state = interaction(request.kind, request.options, request.initial);
+        let issue;
+        let header = `${stderrStyle.cyan("?")} ${stderrStyle.bold(request.options.message)}`;
+        screen.hold();
+        try {
+            for (;;) {
+                let lines = state.render(stderrStyle, header);
+                if (issue !== undefined)
+                    lines.push(stderrStyle.red(`  ${issue}`));
+                screen.paint(lines);
+                let key = await keyboard.read(controller.signal);
+                if (key === null) {
+                    screen.paint([]);
+                    if (controller.signal.aborted)
+                        return failure(new CancelledError());
+                    return failure(new Error(`No more keys while asking ${request.label}`));
+                }
+                if (isCancel(key)) {
+                    screen.paint([]);
+                    return failure(new CancelledError());
+                }
+                let step = state.key(key);
+                if (step === undefined) {
+                    issue = undefined;
+                    continue;
+                }
+                if ("error" in step) {
+                    issue = step.error;
+                    continue;
+                }
+                let checked = await request.check(step.submit);
+                if (isFailure(checked)) {
+                    issue = checked.error.message;
+                    continue;
+                }
+                screen.paint([]);
+                stderr.write(summaryLine(request, step.submit));
+                return checked;
+            }
+        }
+        finally {
+            screen.release();
+        }
+    };
+    return {
+        cwd,
+        env,
+        stdin,
+        stdout,
+        stderr,
+        style,
+        screen,
+        tasks,
+        signal: controller.signal,
+        interactive,
+        animate,
+        async ask(request) {
+            if (controller.signal.aborted)
+                return failure(new CancelledError());
+            if (script !== undefined && script.keyboard === undefined) {
+                let answer = scripted(request);
+                if (answer === undefined) {
+                    return failure(new Error(`invoke() has no scripted answer for ${request.label} ("${request.options.message}")`));
+                }
+                let checked = await request.check(answer.value);
+                if (isFailure(checked)) {
+                    return failure(new Error(`invoke()'s answer for ${request.label} was rejected: ${checked.error.message}`));
+                }
+                screen.write(stderr, summaryLine(request, answer.value));
+                return checked;
+            }
+            let keyboard = script?.keyboard?.() ??
+                openKeyboard(stdin, (on) => {
+                    raw = on;
+                });
+            try {
+                return await converse(request, keyboard);
+            }
+            finally {
+                keyboard.close();
+            }
+        },
+        async exec(command, options = {}) {
+            let stdio = options.stdio ?? "inherit";
+            let shares = stdio === "inherit" || stdio === "stderr";
+            if (shares)
+                screen.hold();
+            try {
+                return await exec(command, {
+                    cwd: options.cwd ?? cwd,
+                    env: { ...env, ...options.env },
+                    stdio,
+                    signal: options.signal ?? controller.signal,
+                    input: options.input,
+                    stdout,
+                    stderr,
+                });
+            }
+            finally {
+                if (shares)
+                    screen.release();
+            }
+        },
+        close() {
+            tasks.close();
+            restore();
+            for (let each of unlink)
+                each();
+        },
+    };
+}

package/dist/style.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Text styling for terminal output: colours and weights as ANSI SGR sequences, decided once per
+ * stream, so the same handler writes styled text to a terminal and plain text to a pipe or a
+ * file. Also measures text as a terminal lays it out, which redrawing depends on.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+/** The environment variables the colour decision reads. */
+export type Env = Readonly<Record<string, string | undefined>>;
+/** Wraps text in one ANSI style, or answers it unchanged when styling is off. */
+export type Paint = (text: string) => string;
+/** The styles a command writes with; every one answers its input unchanged when `enabled` is false. */
+export interface Style {
+    /** Whether this stream receives ANSI sequences. */
+    readonly enabled: boolean;
+    readonly bold: Paint;
+    readonly dim: Paint;
+    readonly italic: Paint;
+    readonly underline: Paint;
+    readonly inverse: Paint;
+    readonly red: Paint;
+    readonly green: Paint;
+    readonly yellow: Paint;
+    readonly blue: Paint;
+    readonly magenta: Paint;
+    readonly cyan: Paint;
+    readonly gray: Paint;
+}
+/**
+ * A style set. Nested styles keep the outer one: closing an inner colour re-opens the colour
+ * around it, so `red(\`a ${bold("b")} c\`)` stays red after the bold part.
+ */
+export declare function createStyle(enabled: boolean): Style;
+/**
+ * Whether a stream receives colour: `FORCE_COLOR` (other than `0`) turns it on, `NO_COLOR` or
+ * `TERM=dumb` turns it off, and otherwise it follows whether the stream is a terminal.
+ */
+export declare function colorEnabled(stream: {
+    isTTY?: boolean;
+}, env: Env): boolean;
+/** `text` without ANSI escape sequences. */
+export declare function stripStyle(text: string): string;
+/** `text` as user-perceived characters, the unit a line editor moves and deletes by. */
+export declare function graphemes(text: string): string[];
+/**
+ * How many terminal columns `text` occupies: ANSI sequences take none, and each user-perceived
+ * character takes one, so East Asian wide characters and emoji count as one column.
+ */
+export declare function visibleWidth(text: string): number;

package/dist/style.js

@@ -0,0 +1,72 @@
+/**
+ * Text styling for terminal output: colours and weights as ANSI SGR sequences, decided once per
+ * stream, so the same handler writes styled text to a terminal and plain text to a pipe or a
+ * file. Also measures text as a terminal lays it out, which redrawing depends on.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+/** Each style's opening and closing SGR codes; closing codes reset only what they opened. */
+const CODES = {
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    inverse: [7, 27],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    gray: [90, 39],
+};
+/** Every ANSI escape sequence this package or a child process may write: SGR, cursor and erase. */
+// oxlint-disable-next-line eslint/no-control-regex -- ANSI sequences start with the ESC control character
+const ANSI_SEQUENCE = /\u001B\[[0-9;?]*[A-Za-z]/g;
+/**
+ * A style set. Nested styles keep the outer one: closing an inner colour re-opens the colour
+ * around it, so `red(\`a ${bold("b")} c\`)` stays red after the bold part.
+ */
+export function createStyle(enabled) {
+    let entries = Object.entries(CODES).map(([name, [open, close]]) => {
+        let openCode = `\u001B[${open}m`;
+        let closeCode = `\u001B[${close}m`;
+        let paint = enabled
+            ? (text) => `${openCode}${text.split(closeCode).join(`${closeCode}${openCode}`)}${closeCode}`
+            : (text) => text;
+        return [name, paint];
+    });
+    return { enabled, ...Object.fromEntries(entries) };
+}
+/**
+ * Whether a stream receives colour: `FORCE_COLOR` (other than `0`) turns it on, `NO_COLOR` or
+ * `TERM=dumb` turns it off, and otherwise it follows whether the stream is a terminal.
+ */
+export function colorEnabled(stream, env) {
+    let force = env.FORCE_COLOR;
+    if (force !== undefined)
+        return force !== "0" && force !== "false";
+    if (env.NO_COLOR !== undefined && env.NO_COLOR !== "")
+        return false;
+    if (env.TERM === "dumb")
+        return false;
+    return stream.isTTY === true;
+}
+/** `text` without ANSI escape sequences. */
+export function stripStyle(text) {
+    return text.replace(ANSI_SEQUENCE, "");
+}
+/** Splits text into user-perceived characters, so an emoji with modifiers is one character. */
+const SEGMENTER = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+/** `text` as user-perceived characters, the unit a line editor moves and deletes by. */
+export function graphemes(text) {
+    return Array.from(SEGMENTER.segment(text), (segment) => segment.segment);
+}
+/**
+ * How many terminal columns `text` occupies: ANSI sequences take none, and each user-perceived
+ * character takes one, so East Asian wide characters and emoji count as one column.
+ */
+export function visibleWidth(text) {
+    return graphemes(stripStyle(text)).length;
+}

package/dist/suggest.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Closest-name suggestions for a mistyped command or flag, so a usage error can say what the
+ * user most likely meant instead of only what was wrong.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+/**
+ * The candidate nearest to `input` by edit distance, counting a swap of two neighbouring
+ * characters as one edit. A candidate qualifies within a third of the input's length (at least
+ * one edit, at most three), so a short unrelated name suggests nothing.
+ *
+ * @example closest("instal", ["install", "init"]) // "install"
+ */
+export declare function closest(input: string, candidates: Iterable<string>): string | undefined;

package/dist/suggest.js

@@ -0,0 +1,50 @@
+/**
+ * Closest-name suggestions for a mistyped command or flag, so a usage error can say what the
+ * user most likely meant instead of only what was wrong.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+/**
+ * The candidate nearest to `input` by edit distance, counting a swap of two neighbouring
+ * characters as one edit. A candidate qualifies within a third of the input's length (at least
+ * one edit, at most three), so a short unrelated name suggests nothing.
+ *
+ * @example closest("instal", ["install", "init"]) // "install"
+ */
+export function closest(input, candidates) {
+    let limit = Math.min(3, Math.max(1, Math.floor(input.length / 3)));
+    let best;
+    let bestDistance = Infinity;
+    for (let candidate of candidates) {
+        let distance = editDistance(input, candidate);
+        if (distance <= limit && distance < bestDistance) {
+            best = candidate;
+            bestDistance = distance;
+        }
+    }
+    return best;
+}
+/** Optimal string alignment distance: insertions, deletions, substitutions and adjacent swaps. */
+function editDistance(a, b) {
+    let rows = [];
+    for (let i = 0; i <= a.length; i++) {
+        let row = [i];
+        for (let j = 1; j <= b.length; j++)
+            row.push(i === 0 ? j : 0);
+        rows.push(row);
+    }
+    for (let i = 1; i <= a.length; i++) {
+        for (let j = 1; j <= b.length; j++) {
+            let cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            let above = rows[i - 1];
+            let row = rows[i];
+            let value = Math.min(above[j] + 1, row[j - 1] + 1, above[j - 1] + cost);
+            if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+                value = Math.min(value, rows[i - 2][j - 2] + 1);
+            }
+            row[j] = value;
+        }
+    }
+    return rows[a.length][b.length];
+}

package/dist/task.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Tasks: async work the user waits on, shown as a spinner or a progress bar that ends in one
+ * ✓ or ✗ line. A task answers a `Result`, so a thrown error is a failure instead of an
+ * exception, and tasks started inside a task's callback draw as its indented steps.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import type { Result } from "@sdxc/result";
+import type { Screen } from "./screen.js";
+import type { Style } from "./style.js";
+/** What a task's callback shapes it through. */
+export interface Task {
+    /**
+     * Aborts when the user presses Ctrl+C. Pass it to `fetch`, `ctx.exec` or anything else that
+     * takes a signal, so the work stops with the task; nested tasks share it.
+     */
+    readonly signal: AbortSignal;
+    /** Changes what the spinner says; the last label is the one the final line prints. */
+    update(label: string): void;
+    /** Turns the spinner into a bar out of `count`. Call again as the work grows. */
+    total(count: number): void;
+    /** Counts finished work; the count never passes the total. */
+    advance(by?: number): void;
+}
+/** What `ctx.task` answers: a returned `Result` as it is, any other value as its success. */
+export type TaskResult<T> = [T] extends [Result<infer Data, infer Failed extends Error>] ? Result<Data, Failed | Error> : Result<T, Error>;
+/** Runs a task; the label is optional. */
+export interface RunTask {
+    <T>(fn: (task: Task) => T | Promise<T>): Promise<TaskResult<Awaited<T>>>;
+    <T>(label: string, fn: (task: Task) => T | Promise<T>): Promise<TaskResult<Awaited<T>>>;
+}
+/** Every task of one run, and how they draw. */
+export declare class Tasks {
+    #private;
+    /**
+     * @param screen - The terminal owner the frame is drawn through
+     * @param style - Styling for stderr
+     * @param animate - Whether stderr is a terminal that redraws
+     * @param signal - Aborts on Ctrl+C
+     */
+    constructor(screen: Screen, style: Style, animate: boolean, signal: AbortSignal);
+    /** The `ctx.task` function bound to this run. */
+    readonly task: RunTask;
+    /** Stops the spinner and clears the frame, leaving finished lines where they are. */
+    close(): void;
+}

package/dist/task.js

@@ -0,0 +1,213 @@
+/**
+ * Tasks: async work the user waits on, shown as a spinner or a progress bar that ends in one
+ * ✓ or ✗ line. A task answers a `Result`, so a thrown error is a failure instead of an
+ * exception, and tasks started inside a task's callback draw as its indented steps.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import { AsyncLocalStorage } from "node:async_hooks";
+import { failure, isFailure, success } from "@sdxc/result";
+import { CancelledError } from "./errors.js";
+/** The spinner's frames, one every {@link FRAME_MS}. */
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/** How long each spinner frame shows. */
+const FRAME_MS = 80;
+/** How many cells the progress bar takes. */
+const BAR_WIDTH = 20;
+/** Whether a callback returned a `Result` rather than a plain value. */
+function isResult(value) {
+    if (typeof value !== "object" || value === null || !("status" in value))
+        return false;
+    return ((value.status === "success" && "data" in value) ||
+        (value.status === "failure" && "error" in value));
+}
+/** How long a task took, as its final line prints it. */
+function duration(ms) {
+    return ms < 1000 ? `${Math.round(ms)} ms` : `${(ms / 1000).toFixed(1)} s`;
+}
+/** Every task of one run, and how they draw. */
+export class Tasks {
+    #screen;
+    #style;
+    /** Spinner frames and bars redraw in place; otherwise each task prints two plain lines. */
+    #animate;
+    #signal;
+    #roots = [];
+    #current = new AsyncLocalStorage();
+    #frame = 0;
+    #timer;
+    /**
+     * @param screen - The terminal owner the frame is drawn through
+     * @param style - Styling for stderr
+     * @param animate - Whether stderr is a terminal that redraws
+     * @param signal - Aborts on Ctrl+C
+     */
+    constructor(screen, style, animate, signal) {
+        this.#screen = screen;
+        this.#style = style;
+        this.#animate = animate;
+        this.#signal = signal;
+        screen.onRefresh(() => this.#draw());
+    }
+    /** The `ctx.task` function bound to this run. */
+    task = (async (labelOrFn, maybeFn) => {
+        let label = typeof labelOrFn === "string" ? labelOrFn : undefined;
+        let fn = (typeof labelOrFn === "string" ? maybeFn : labelOrFn);
+        return this.#run(label, fn);
+    });
+    /** Stops the spinner and clears the frame, leaving finished lines where they are. */
+    close() {
+        this.#stopTimer();
+        this.#roots = [];
+        if (this.#animate && !this.#screen.held)
+            this.#screen.paint([]);
+    }
+    async #run(label, fn) {
+        let parent = this.#current.getStore();
+        let node = {
+            label,
+            count: 0,
+            total: undefined,
+            depth: parent === undefined ? 0 : parent.depth + 1,
+            children: [],
+            status: "running",
+            started: performance.now(),
+            ended: 0,
+        };
+        if (parent === undefined)
+            this.#roots.push(node);
+        else
+            parent.children.push(node);
+        if (this.#animate) {
+            this.#startTimer();
+            this.#draw();
+        }
+        else if (label !== undefined) {
+            this.#screen.write(this.#screen.stderr, `${this.#indent(node)}${label}\n`);
+        }
+        let task = {
+            signal: this.#signal,
+            update: (next) => {
+                node.label = next;
+                if (this.#animate)
+                    this.#draw();
+            },
+            total: (count) => {
+                node.total = Math.max(0, count);
+                node.count = Math.min(node.count, node.total);
+                if (this.#animate)
+                    this.#draw();
+            },
+            advance: (by = 1) => {
+                node.count += by;
+                if (node.total !== undefined)
+                    node.count = Math.min(node.count, node.total);
+                if (this.#animate)
+                    this.#draw();
+            },
+        };
+        let outcome;
+        try {
+            let value = await this.#current.run(node, () => fn(task));
+            outcome = isResult(value) ? value : success(value);
+        }
+        catch (error) {
+            outcome = failure(error instanceof Error ? error : new Error(String(error)));
+        }
+        if (isFailure(outcome) && this.#signal.aborted && !(outcome.error instanceof CancelledError)) {
+            outcome = failure(new CancelledError());
+        }
+        node.status = isFailure(outcome) ? "failure" : "success";
+        node.ended = performance.now();
+        this.#finish(node);
+        return outcome;
+    }
+    /** Prints a finished task: a root leaves the frame for good, a step stays drawn in it. */
+    #finish(node) {
+        if (!this.#animate) {
+            if (node.label !== undefined) {
+                this.#screen.write(this.#screen.stderr, `${this.#finalLine(node)}\n`);
+            }
+            return;
+        }
+        if (node.depth > 0) {
+            this.#draw();
+            return;
+        }
+        this.#roots = this.#roots.filter((root) => root !== node);
+        let lines = this.#finalLines(node);
+        if (this.#roots.length === 0)
+            this.#stopTimer();
+        if (!this.#screen.held)
+            this.#screen.paint([]);
+        if (lines.length > 0)
+            this.#screen.write(this.#screen.stderr, `${lines.join("\n")}\n`);
+        this.#draw();
+    }
+    /** Redraws the frame: every running root and its steps. */
+    #draw() {
+        if (!this.#animate || this.#screen.held)
+            return;
+        let lines = [];
+        for (let root of this.#roots)
+            this.#collect(root, lines);
+        this.#screen.paint(lines);
+    }
+    /** Adds `node` and its steps to the frame. */
+    #collect(node, lines) {
+        if (node.status !== "running") {
+            if (node.label !== undefined)
+                lines.push(this.#finalLine(node));
+        }
+        else {
+            let spinner = this.#style.cyan(SPINNER[this.#frame % SPINNER.length]);
+            let text = node.label === undefined ? "" : ` ${node.label}`;
+            lines.push(`${this.#indent(node)}${spinner}${text}${this.#bar(node)}`);
+        }
+        for (let child of node.children)
+            this.#collect(child, lines);
+    }
+    /** A finished root and its steps, as they stay on screen. */
+    #finalLines(node) {
+        let lines = [];
+        if (node.label !== undefined)
+            lines.push(this.#finalLine(node));
+        for (let child of node.children)
+            lines.push(...this.#finalLines(child));
+        return lines;
+    }
+    /** `✓ label 3/3 (240 ms)`; the time only when animating, so plain output stays stable. */
+    #finalLine(node) {
+        let style = this.#style;
+        let mark = node.status === "success" ? style.green("✓") : style.red("✗");
+        let count = node.total === undefined ? "" : ` ${node.count}/${node.total}`;
+        let time = this.#animate ? ` ${style.dim(`(${duration(node.ended - node.started)})`)}` : "";
+        return `${this.#indent(node)}${mark} ${node.label ?? ""}${count}${time}`;
+    }
+    /** The progress bar of a counted task, empty for one without a total. */
+    #bar(node) {
+        if (node.total === undefined)
+            return "";
+        let filled = node.total === 0 ? BAR_WIDTH : Math.round((node.count / node.total) * BAR_WIDTH);
+        let bar = `${"█".repeat(filled)}${this.#style.dim("░".repeat(BAR_WIDTH - filled))}`;
+        return ` ${bar} ${node.count}/${node.total}`;
+    }
+    #indent(node) {
+        return "  ".repeat(node.depth);
+    }
+    #startTimer() {
+        if (this.#timer !== undefined)
+            return;
+        this.#timer = setInterval(() => {
+            this.#frame += 1;
+            this.#draw();
+        }, FRAME_MS);
+        this.#timer.unref?.();
+    }
+    #stopTimer() {
+        if (this.#timer !== undefined)
+            clearInterval(this.#timer);
+        this.#timer = undefined;
+    }
+}