@workflow-manager/runner 0.6.0 → 0.8.0

package/dist/tui/layout.js

@@ -0,0 +1,245 @@
+// Pure two-pane frame composer for `wfm run --ui`.
+//
+// renderFrame(state) is a plain function: given a TuiFrameState it returns an
+// array of exactly `state.height` display rows, each at most `state.width`
+// visible columns wide (ANSI-aware — see ansi.ts). No I/O, no timers, no
+// Date.now(): every time-dependent value is derived from `state.now`, which
+// callers refresh on their own render loop.
+import { elapsedFrom, formatDurationMs } from "../runFormat.js";
+import { padVisible, truncateVisible, visibleWidth } from "./ansi.js";
+// Below these thresholds the two-pane layout has no room to stay readable;
+// fall back to a single-column stack instead of corrupting column math.
+const DEGRADED_MIN_WIDTH = 60;
+const DEGRADED_MIN_HEIGHT = 12;
+// Fixed chrome rows around the variable-height content area: top border,
+// attach-info row, pane-title separator, footer separator, two footer rows,
+// bottom border.
+const CHROME_ROWS = 7;
+const KEY_HINTS = "↑/↓ select step   f follow current   a approve  r resume  c cancel  q quit";
+const QA_ICONS = {
+    PROCEED: "✓",
+    RETRY_CURRENT: "↻",
+    ROLLBACK_PREVIOUS: "⤺",
+    RESTART_ALL: "⟲",
+};
+export function renderFrame(state) {
+    if (state.width < DEGRADED_MIN_WIDTH || state.height < DEGRADED_MIN_HEIGHT) {
+        return renderDegradedFrame(state);
+    }
+    return renderFullFrame(state);
+}
+// --- generic row-fitting helpers -------------------------------------------------
+/** Truncates or right-pads `text` so visibleWidth(result) === width (never more). */
+function fitExact(text, width) {
+    const w = visibleWidth(text);
+    if (w > width) {
+        return truncateVisible(text, width);
+    }
+    if (w < width) {
+        return padVisible(text, width);
+    }
+    return text;
+}
+/** Pads `text` with trailing box-drawing dashes up to `width` (truncates if it overflows). */
+function fillDashes(text, width) {
+    const w = visibleWidth(text);
+    if (w >= width) {
+        return truncateVisible(text, width);
+    }
+    return text + "─".repeat(width - w);
+}
+// --- full (non-degraded) frame ----------------------------------------------------
+function renderFullFrame(state) {
+    const { width, height } = state;
+    const contentRows = height - CHROME_ROWS;
+    const paneLeftWidth = Math.min(38, Math.floor(width * 0.4));
+    const paneRightWidth = width - 3 - paneLeftWidth;
+    const rows = [];
+    rows.push(buildTopBorder(state, width));
+    rows.push(buildAttachRow(state, width));
+    rows.push(buildPaneTitleRow(state, paneLeftWidth, paneRightWidth));
+    const stepLines = buildStepPaneLines(state, paneLeftWidth, contentRows);
+    const activityLines = buildActivityPaneLines(state, paneRightWidth, contentRows);
+    for (let i = 0; i < contentRows; i++) {
+        rows.push(`│${stepLines[i]}│${activityLines[i]}│`);
+    }
+    rows.push(`├${"─".repeat(paneLeftWidth)}┴${"─".repeat(paneRightWidth)}┤`);
+    rows.push(buildFooterRow(width, buildApprovalOrStatusText(state)));
+    rows.push(buildFooterRow(width, state.theme.dim(KEY_HINTS)));
+    rows.push(`└${"─".repeat(width - 2)}┘`);
+    return rows.map((row) => fitExact(row, width));
+}
+function buildTopBorder(state, width) {
+    const { snapshot, theme } = state;
+    const title = snapshot?.workflowTitle ?? "wfm run";
+    const statusSegment = snapshot
+        ? theme.runStatus(snapshot.status, `● ${snapshot.status.replace(/_/g, " ")} · elapsed ${computeElapsed(snapshot, state.now)}`)
+        : theme.dim("● initializing…");
+    const left = `┌─ ${title} `;
+    const right = ` ${statusSegment} ─┐`;
+    const fill = Math.max(0, width - visibleWidth(left) - visibleWidth(right));
+    return left + "─".repeat(fill) + right;
+}
+function buildAttachRow(state, width) {
+    const { snapshot } = state;
+    const tokenPreview = state.attachToken ? `${state.attachToken.slice(0, 8)}…` : "—";
+    const runPreview = snapshot?.runId ? `${snapshot.runId.slice(0, 8)}…` : "—";
+    const left = `│ Attach: ${state.attachUrl} (token ${tokenPreview})`;
+    const right = `run ${runPreview} │`;
+    const fill = Math.max(1, width - visibleWidth(left) - visibleWidth(right));
+    return left + " ".repeat(fill) + right;
+}
+function buildPaneTitleRow(state, paneLeftWidth, paneRightWidth) {
+    const { snapshot, selectedStepKey } = state;
+    const steps = snapshot?.steps ?? [];
+    const succeeded = steps.filter((s) => s.status === "succeeded").length;
+    const leftTitle = ` Steps (${succeeded}/${steps.length} done) `;
+    const selectedStep = selectedStepKey ? steps.find((s) => s.stepKey === selectedStepKey) : undefined;
+    const rightTitle = selectedStep
+        ? ` Activity: ${selectedStep.stepKey} · ${selectedStep.status.replace(/_/g, " ")} `
+        : " Activity: (none) ";
+    const leftSeg = fillDashes(leftTitle, paneLeftWidth);
+    const rightSeg = fillDashes(rightTitle, paneRightWidth);
+    return `├${leftSeg}┬${rightSeg}┤`;
+}
+function buildFooterRow(width, text) {
+    const inner = width - 2;
+    const content = ` ${text}`;
+    return `│${fitExact(content, inner)}│`;
+}
+function buildApprovalOrStatusText(state) {
+    const { snapshot, theme } = state;
+    const waiting = snapshot?.waitingForApproval;
+    if (waiting) {
+        const actionHint = waiting.validation === "external" ? "[r]esume" : "[a]pprove";
+        const text = `◌ ${waiting.stepKey} waiting for approval — ${actionHint}  [c]ancel`;
+        return theme.runStatus("waiting_for_approval", text);
+    }
+    if (state.statusMessage) {
+        return theme.dim(state.statusMessage);
+    }
+    return "";
+}
+function buildStepPaneLines(state, paneLeftWidth, contentRows) {
+    const { snapshot, theme, selectedStepKey, stepDetails, now } = state;
+    const steps = snapshot?.steps ?? [];
+    const flatItems = [];
+    steps.forEach((step, idx) => {
+        const index1based = idx + 1;
+        flatItems.push({ step, index1based, isBadge: false });
+        const detail = stepDetails.get(step.stepKey);
+        const qaAction = detail?.lastExecution.qaAction ?? null;
+        const showBadge = step.attempt > 1 || (qaAction !== null && qaAction !== "PROCEED");
+        if (showBadge) {
+            flatItems.push({ step, index1based, isBadge: true });
+        }
+    });
+    let windowStart = 0;
+    if (flatItems.length > contentRows) {
+        const selIdx = selectedStepKey
+            ? flatItems.findIndex((item) => !item.isBadge && item.step.stepKey === selectedStepKey)
+            : -1;
+        if (selIdx >= 0) {
+            windowStart = Math.min(Math.max(0, selIdx - Math.floor(contentRows / 2)), flatItems.length - contentRows);
+        }
+    }
+    const lines = [];
+    for (let i = 0; i < contentRows; i++) {
+        const item = flatItems[windowStart + i];
+        if (!item) {
+            if (i === 0 && steps.length === 0 && !snapshot) {
+                lines.push(fitExact(theme.dim(" Initializing…"), paneLeftWidth));
+            }
+            else {
+                lines.push(padVisible("", paneLeftWidth));
+            }
+            continue;
+        }
+        const selected = !item.isBadge && item.step.stepKey === selectedStepKey;
+        lines.push(item.isBadge
+            ? buildBadgeLine(item, paneLeftWidth, theme, stepDetails)
+            : buildStepLine(item, paneLeftWidth, theme, selected, now));
+    }
+    return lines;
+}
+function buildStepLine(item, paneLeftWidth, theme, selected, now) {
+    const { step, index1based } = item;
+    const icon = theme.stepIcon(step.status);
+    const duration = stepDuration(step, now);
+    const raw = `${icon} ${index1based} ${step.stepKey} ${step.adapter} ${duration}`.trimEnd();
+    const fitted = fitExact(raw, paneLeftWidth);
+    return selected ? theme.inverse(fitted) : theme.stepStatus(step.status, fitted);
+}
+function buildBadgeLine(item, paneLeftWidth, theme, stepDetails) {
+    const { step } = item;
+    const detail = stepDetails.get(step.stepKey);
+    const parts = [];
+    if (step.attempt > 1) {
+        parts.push(theme.dim(`attempt ${step.attempt}`));
+    }
+    const qaAction = detail?.lastExecution.qaAction ?? null;
+    if (qaAction && qaAction !== "PROCEED") {
+        parts.push(theme.qaAction(qaAction, `${QA_ICONS[qaAction]} ${qaAction}`));
+    }
+    const raw = `    ${parts.join(" · ")}`;
+    return fitExact(raw, paneLeftWidth);
+}
+function stepDuration(step, now) {
+    if (step.startedAt && step.finishedAt) {
+        return formatDurationMs(Date.parse(step.finishedAt) - Date.parse(step.startedAt));
+    }
+    if (step.startedAt && step.status === "running") {
+        return elapsedFrom(step.startedAt, now);
+    }
+    return "";
+}
+function computeElapsed(snapshot, now) {
+    if (!snapshot.startedAt) {
+        return "0s";
+    }
+    const endTs = snapshot.endedAt ? Date.parse(snapshot.endedAt) : now;
+    return elapsedFrom(snapshot.startedAt, endTs);
+}
+// --- right pane: activity log --------------------------------------------------
+function buildActivityPaneLines(state, paneRightWidth, contentRows) {
+    const { logs, selectedStepKey, theme } = state;
+    const lines = selectedStepKey ? logs.tail(selectedStepKey, contentRows) : [];
+    const rendered = [];
+    for (let i = 0; i < contentRows; i++) {
+        const line = lines[i];
+        if (!line) {
+            rendered.push(padVisible("", paneRightWidth));
+            continue;
+        }
+        const raw = line.kind === "meta" ? `▸ ${line.text}` : line.text;
+        const truncated = truncateVisible(raw, paneRightWidth);
+        const colored = line.kind === "stderr" ? theme.stderrText(truncated) : line.kind === "meta" ? theme.accent(truncated) : truncated;
+        rendered.push(padVisible(colored, paneRightWidth));
+    }
+    return rendered;
+}
+// --- degraded (narrow/short terminal) frame ----------------------------------------
+function renderDegradedFrame(state) {
+    const { snapshot, theme, width, height, selectedStepKey, now } = state;
+    const rows = [];
+    const title = snapshot?.workflowTitle ?? "wfm run";
+    const statusWord = snapshot ? snapshot.status.replace(/_/g, " ") : "initializing";
+    const headerText = snapshot ? theme.runStatus(snapshot.status, `${title} — ${statusWord}`) : theme.dim(`${title} — ${statusWord}`);
+    rows.push(fitExact(headerText, width));
+    const steps = snapshot?.steps ?? [];
+    const stepRowBudget = Math.max(0, height - 1);
+    for (let i = 0; i < stepRowBudget; i++) {
+        const step = steps[i];
+        if (!step) {
+            rows.push(padVisible("", width));
+            continue;
+        }
+        const icon = theme.stepIcon(step.status);
+        const duration = stepDuration(step, now);
+        const raw = `${icon} ${i + 1} ${step.stepKey} ${step.adapter} ${duration}`.trimEnd();
+        const selected = step.stepKey === selectedStepKey;
+        const fitted = fitExact(raw, width);
+        rows.push(selected ? theme.inverse(fitted) : theme.stepStatus(step.status, fitted));
+    }
+    return rows.slice(0, height);
+}

package/dist/tui/logStore.d.ts

@@ -0,0 +1,22 @@
+import type { RunnerLogChunk } from "../types.js";
+export type TuiLogLineKind = "stdout" | "stderr" | "meta";
+export interface TuiLogLine {
+    kind: TuiLogLineKind;
+    text: string;
+}
+export interface TuiLogStoreOptions {
+    maxLinesPerStep?: number;
+}
+export declare class TuiLogStore {
+    private readonly maxLinesPerStep;
+    private readonly buckets;
+    private readonly partials;
+    constructor(options?: TuiLogStoreOptions);
+    appendChunk(log: RunnerLogChunk): void;
+    appendMeta(stepKey: string | null | undefined, text: string): void;
+    flushPartialLines(): void;
+    tail(stepKey: string | null | undefined, count: number): TuiLogLine[];
+    lineCount(stepKey: string | null | undefined): number;
+    private bucketFor;
+    private pushLine;
+}

package/dist/tui/logStore.js

@@ -0,0 +1,78 @@
+import { splitLines } from "../runFormat.js";
+const DEFAULT_MAX_LINES_PER_STEP = 2000;
+// Sentinel bucket key for chunks/meta with no stepKey (workflow-level output).
+// A symbol can never collide with a real (string) step key.
+const WORKFLOW_BUCKET_KEY = Symbol("workflow");
+function bucketKey(stepKey) {
+    return stepKey ?? WORKFLOW_BUCKET_KEY;
+}
+export class TuiLogStore {
+    maxLinesPerStep;
+    buckets = new Map();
+    // Per-bucket, per-stream partial line remainders awaiting a terminating newline.
+    partials = new Map();
+    constructor(options) {
+        this.maxLinesPerStep = options?.maxLinesPerStep ?? DEFAULT_MAX_LINES_PER_STEP;
+    }
+    appendChunk(log) {
+        const key = bucketKey(log.stepKey);
+        const streamMap = this.partials.get(key) ?? new Map();
+        if (!this.partials.has(key)) {
+            this.partials.set(key, streamMap);
+        }
+        const existing = streamMap.get(log.stream) ?? "";
+        const { lines, remainder } = splitLines(existing + log.text);
+        streamMap.set(log.stream, remainder);
+        if (lines.length === 0) {
+            return;
+        }
+        const bucket = this.bucketFor(key);
+        for (const line of lines) {
+            this.pushLine(bucket, { kind: log.stream, text: line });
+        }
+    }
+    appendMeta(stepKey, text) {
+        const bucket = this.bucketFor(bucketKey(stepKey));
+        this.pushLine(bucket, { kind: "meta", text });
+    }
+    flushPartialLines() {
+        for (const [key, streamMap] of this.partials.entries()) {
+            for (const [stream, text] of streamMap.entries()) {
+                if (!text) {
+                    continue;
+                }
+                const bucket = this.bucketFor(key);
+                this.pushLine(bucket, { kind: stream, text });
+            }
+        }
+        this.partials.clear();
+    }
+    tail(stepKey, count) {
+        const bucket = this.buckets.get(bucketKey(stepKey));
+        if (!bucket || count <= 0) {
+            return [];
+        }
+        if (count >= bucket.length) {
+            return bucket.slice();
+        }
+        return bucket.slice(bucket.length - count);
+    }
+    lineCount(stepKey) {
+        return this.buckets.get(bucketKey(stepKey))?.length ?? 0;
+    }
+    bucketFor(key) {
+        const existing = this.buckets.get(key);
+        if (existing) {
+            return existing;
+        }
+        const bucket = [];
+        this.buckets.set(key, bucket);
+        return bucket;
+    }
+    pushLine(bucket, line) {
+        bucket.push(line);
+        while (bucket.length > this.maxLinesPerStep) {
+            bucket.shift();
+        }
+    }
+}

package/dist/tui/screen.d.ts

@@ -0,0 +1,35 @@
+export interface KeyEvent {
+    name?: string;
+    ctrl?: boolean;
+    meta?: boolean;
+    shift?: boolean;
+    sequence?: string;
+}
+export interface TerminalScreenOptions {
+    stdout: NodeJS.WriteStream;
+    stdin: NodeJS.ReadStream;
+    onKey: (key: KeyEvent) => void;
+    onResize: (columns: number, rows: number) => void;
+}
+export declare class TerminalScreen {
+    private readonly stdout;
+    private readonly stdin;
+    private readonly onKey;
+    private readonly onResize;
+    private started;
+    private stopped;
+    private wasRawMode;
+    private readonly handleKeypress;
+    private readonly handleResize;
+    private readonly handleSignal;
+    constructor(options: TerminalScreenOptions);
+    start(): void;
+    paint(rows: string[]): void;
+    size(): {
+        columns: number;
+        rows: number;
+    };
+    stop(): void;
+    private readonly exitRestore;
+    private restore;
+}

package/dist/tui/screen.js

@@ -0,0 +1,99 @@
+// Terminal session manager for the `wfm run --ui` TUI: owns entering/leaving
+// the alt screen, raw-mode keyboard input, resize notifications, and a single
+// buffered full-repaint write. No timers, no rendering/layout logic here.
+import * as readline from "node:readline";
+import { ALT_SCREEN_ENTER, ALT_SCREEN_LEAVE, CLEAR_LINE_END, CLEAR_SCREEN, CURSOR_HIDE, CURSOR_HOME, CURSOR_SHOW, } from "./ansi.js";
+const SIGNALS_TO_RESTORE_ON = ["SIGINT", "SIGTERM"];
+export class TerminalScreen {
+    stdout;
+    stdin;
+    onKey;
+    onResize;
+    started = false;
+    stopped = false;
+    wasRawMode = false;
+    handleKeypress = (str, key) => {
+        this.onKey(key ?? { sequence: str });
+    };
+    handleResize = () => {
+        const { columns, rows } = this.size();
+        this.onResize(columns, rows);
+    };
+    handleSignal = () => {
+        this.restore();
+        // Conservative: restore the terminal only. Do not call process.exit and
+        // do not swallow the signal for other listeners — re-emitting here would
+        // recurse into every listener (including this one) on this signal, so we
+        // simply return and let Node's normal signal delivery / other installed
+        // listeners proceed. If this is the only SIGINT/SIGTERM listener, the
+        // process's default disposition (terminate) still applies once all
+        // listeners for the event have run.
+    };
+    constructor(options) {
+        this.stdout = options.stdout;
+        this.stdin = options.stdin;
+        this.onKey = options.onKey;
+        this.onResize = options.onResize;
+    }
+    start() {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        this.stopped = false;
+        this.stdout.write(ALT_SCREEN_ENTER + CURSOR_HIDE + CLEAR_SCREEN + CURSOR_HOME);
+        if (this.stdin.isTTY) {
+            this.wasRawMode = true;
+            this.stdin.setRawMode(true);
+        }
+        readline.emitKeypressEvents(this.stdin);
+        this.stdin.resume();
+        this.stdin.on("keypress", this.handleKeypress);
+        this.stdout.on("resize", this.handleResize);
+        process.once("exit", this.exitRestore);
+        for (const signal of SIGNALS_TO_RESTORE_ON) {
+            process.on(signal, this.handleSignal);
+        }
+    }
+    paint(rows) {
+        const body = rows.map((row) => row + CLEAR_LINE_END).join("\r\n");
+        this.stdout.write(CURSOR_HOME + body);
+    }
+    size() {
+        // Some PTYs report a 0x0 winsize; treat any non-positive dimension as unknown.
+        const columns = this.stdout.columns;
+        const rows = this.stdout.rows;
+        return {
+            columns: columns && columns > 0 ? columns : 80,
+            rows: rows && rows > 0 ? rows : 24,
+        };
+    }
+    stop() {
+        this.restore();
+        for (const signal of SIGNALS_TO_RESTORE_ON) {
+            process.removeListener(signal, this.handleSignal);
+        }
+    }
+    // Bound reference so `process.once("exit", ...)` can be a no-op re-run of
+    // restore() without re-registering listener removal (exit handlers cannot
+    // usefully remove listeners on a dying process, and restore() is safe to
+    // call multiple times).
+    exitRestore = () => {
+        this.restore();
+    };
+    restore() {
+        if (this.stopped) {
+            return;
+        }
+        this.stopped = true;
+        this.started = false;
+        this.stdin.removeListener("keypress", this.handleKeypress);
+        this.stdout.removeListener("resize", this.handleResize);
+        if (this.wasRawMode) {
+            this.stdin.setRawMode(false);
+            this.wasRawMode = false;
+        }
+        this.stdin.pause();
+        this.stdout.write(CURSOR_SHOW + ALT_SCREEN_LEAVE);
+    }
+}

package/dist/tui/theme.d.ts

@@ -0,0 +1,13 @@
+import type { QaAction, StepRunStatus, WorkflowRunStatus } from "../types.js";
+export interface Theme {
+    stepStatus(status: StepRunStatus, text: string): string;
+    runStatus(status: WorkflowRunStatus, text: string): string;
+    qaAction(action: QaAction, text: string): string;
+    stepIcon(status: StepRunStatus): string;
+    dim(text: string): string;
+    bold(text: string): string;
+    inverse(text: string): string;
+    accent(text: string): string;
+    stderrText(text: string): string;
+}
+export declare function createTheme(enableColor: boolean): Theme;

package/dist/tui/theme.js

@@ -0,0 +1,55 @@
+import picocolors from "picocolors";
+// Icons stay plain text; callers color them via stepStatus so icon and label
+// share one style. `satisfies` keeps the map exhaustive: a new StepRunStatus
+// member fails the build here instead of rendering blank.
+const STEP_ICONS = {
+    pending: "·",
+    runnable: "·",
+    running: "▶",
+    waiting_for_approval: "◌",
+    succeeded: "✓",
+    failed: "✗",
+    cancelled: "✗",
+};
+// ANSI-16 palette only. createColors(false) yields identity formatters, so a
+// disabled theme returns input text unchanged (tests rely on this).
+export function createTheme(enableColor) {
+    const c = picocolors.createColors(enableColor);
+    const dimGray = (text) => c.dim(c.gray(text));
+    const dimRed = (text) => c.dim(c.red(text));
+    const stepStyles = {
+        pending: dimGray,
+        runnable: dimGray,
+        running: c.cyan,
+        waiting_for_approval: c.yellow,
+        succeeded: c.green,
+        failed: c.red,
+        cancelled: dimRed,
+    };
+    const runStyles = {
+        queued: dimGray,
+        running: c.cyan,
+        waiting_for_approval: c.yellow,
+        paused: c.yellow,
+        succeeded: c.green,
+        failed: c.red,
+        cancelled: c.red,
+    };
+    const qaStyles = {
+        PROCEED: c.green,
+        RETRY_CURRENT: c.yellow,
+        ROLLBACK_PREVIOUS: c.magenta,
+        RESTART_ALL: c.red,
+    };
+    return {
+        stepStatus: (status, text) => stepStyles[status](text),
+        runStatus: (status, text) => runStyles[status](text),
+        qaAction: (action, text) => qaStyles[action](text),
+        stepIcon: (status) => STEP_ICONS[status],
+        dim: (text) => c.dim(text),
+        bold: (text) => c.bold(text),
+        inverse: (text) => c.inverse(text),
+        accent: (text) => c.cyan(text),
+        stderrText: dimRed,
+    };
+}

package/dist/tui/tuiRunRenderer.d.ts

@@ -0,0 +1,83 @@
+import type { RunEvent, RunObserver, RunSnapshot, RunnerLogChunk, StepDetailSnapshot, WorkflowDefinition } from "../types.js";
+import { type KeyEvent } from "./screen.js";
+export interface TuiSessionControls {
+    approve(stepKey?: string, metadata?: {
+        actor?: string;
+        note?: string;
+        source?: string;
+    }): {
+        ok: boolean;
+        reason?: string;
+    };
+    resume(stepKey?: string, metadata?: {
+        actor?: string;
+        note?: string;
+        source?: string;
+    }): {
+        ok: boolean;
+        reason?: string;
+    };
+    cancel(stepKey?: string, metadata?: {
+        actor?: string;
+        note?: string;
+        source?: string;
+    }): {
+        ok: boolean;
+        reason?: string;
+    };
+}
+export interface TuiRunRendererOptions {
+    workflow: WorkflowDefinition;
+    session: TuiSessionControls;
+    attachUrl: string;
+    attachToken: string;
+    stdout?: NodeJS.WriteStream;
+    stdin?: NodeJS.ReadStream;
+    redrawMs?: number;
+    tickMs?: number;
+    now?: () => number;
+    colorEnabled?: boolean;
+}
+export declare class TuiRunRenderer implements RunObserver {
+    private readonly workflow;
+    private readonly session;
+    private readonly attachUrl;
+    private readonly attachToken;
+    private readonly stdout;
+    private readonly stdin;
+    private readonly redrawMs;
+    private readonly tickMs;
+    private readonly nowFn;
+    private readonly theme;
+    private readonly screen;
+    private snapshot;
+    private stepDetails;
+    private readonly logs;
+    private selectedStepKey;
+    private follow;
+    private statusMessage;
+    private statusMessageExpiresAt;
+    private dirty;
+    private redrawTimer;
+    private tickTimer;
+    private started;
+    private stopped;
+    constructor(options: TuiRunRendererOptions);
+    start(): void;
+    stop(): void;
+    onSnapshot(snapshot: RunSnapshot, stepDetails: StepDetailSnapshot[]): void;
+    onEvent(event: RunEvent): void;
+    onLog(log: RunnerLogChunk): void;
+    handleKey: (key: KeyEvent) => void;
+    renderNow(): string[];
+    private handleResize;
+    private handleApprove;
+    private handleResume;
+    private handleCancel;
+    private handleQuit;
+    private moveSelection;
+    private setStatusMessage;
+    private currentStatusMessage;
+    private markDirty;
+    private composeFrame;
+}