voratiq 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/render/transcripts/verify.js

@@ -0,0 +1,409 @@
+import { getRunStatusStyle } from "../../status/colors.js";
+import { TERMINAL_VERIFICATION_STATUSES } from "../../status/index.js";
+import { formatRenderLifecycleDuration } from "../utils/duration.js";
+import { createInteractiveFrameRenderer } from "../utils/interactive-frame.js";
+import { buildStageFrameLines, buildStageFrameSections, } from "../utils/stage-output.js";
+import { renderTable } from "../utils/table.js";
+import { renderTranscript } from "../utils/transcript.js";
+import { buildStandardSessionShellSection, formatTranscriptErrorLine, formatTranscriptStatusLabel, resolveTranscriptShellStyle, resolveTranscriptShellStyleFromWriter, } from "../utils/transcript-shell.js";
+const DASH = "—";
+function formatErrorDetail(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    if (error === null || error === undefined) {
+        return "unknown error";
+    }
+    if (typeof error === "number" ||
+        typeof error === "boolean" ||
+        typeof error === "bigint") {
+        return `${error}`;
+    }
+    if (typeof error === "symbol") {
+        return error.description ?? error.toString();
+    }
+    if (typeof error === "object") {
+        try {
+            const serialized = JSON.stringify(error);
+            if (serialized) {
+                return serialized;
+            }
+        }
+        catch {
+            // Ignore serialization errors and fall back.
+        }
+    }
+    return "unknown error";
+}
+function buildVerifyStageShell(options) {
+    return {
+        metadataLines: buildStandardSessionShellSection({
+            badgeText: options.verificationId,
+            badgeVariant: "verify",
+            status: {
+                value: options.status,
+                color: getRunStatusStyle(options.status).cli,
+            },
+            elapsed: options.elapsed,
+            createdAt: options.createdAt,
+            workspacePath: options.workspacePath,
+            style: options.style,
+        }),
+        statusTableLines: options.tableLines ?? [],
+    };
+}
+function buildVerifyMethodTable(rows) {
+    return renderTable({
+        columns: [
+            {
+                header: "AGENT",
+                accessor: (row) => row.agentLabel ?? DASH,
+            },
+            {
+                header: "VERIFIER",
+                accessor: (row) => row.verifierLabel,
+            },
+            {
+                header: "STATUS",
+                accessor: (row) => row.status,
+            },
+            {
+                header: "DURATION",
+                accessor: (row) => row.duration,
+            },
+        ],
+        rows,
+    });
+}
+function formatVerifierLabel(verifierLabel, status, style) {
+    void status;
+    void style;
+    return verifierLabel;
+}
+export function createVerifyRenderer(options = {}) {
+    const stdout = options.stdout ?? process.stdout;
+    const stderr = options.stderr ?? process.stderr;
+    const now = options.now ?? Date.now.bind(Date);
+    const suppressLeadingBlankLine = options.suppressLeadingBlankLine === true;
+    const suppressTrailingBlankLine = options.suppressTrailingBlankLine === true;
+    let context;
+    let disabled = false;
+    let warningLogged = false;
+    let refreshInterval;
+    let lastElapsedLabel = null;
+    const interactiveFrameRenderer = createInteractiveFrameRenderer(stdout);
+    const methodOrder = [];
+    const methodRecords = new Map();
+    function stopRefreshLoop() {
+        if (!refreshInterval) {
+            return;
+        }
+        clearInterval(refreshInterval);
+        refreshInterval = undefined;
+    }
+    function hasRunningMethods() {
+        for (const method of methodRecords.values()) {
+            if (method.status === "running") {
+                return true;
+            }
+        }
+        return false;
+    }
+    function syncRefreshLoop() {
+        if (!stdout.isTTY || disabled || !context || !hasRunningMethods()) {
+            stopRefreshLoop();
+            return;
+        }
+        if (refreshInterval) {
+            return;
+        }
+        refreshInterval = setInterval(() => {
+            guard(() => {
+                if (!stdout.isTTY || disabled || !context || !hasRunningMethods()) {
+                    stopRefreshLoop();
+                    return;
+                }
+                const nextElapsed = formatVerifyElapsed(context, now());
+                if (nextElapsed === lastElapsedLabel) {
+                    return;
+                }
+                render();
+            });
+        }, 1000);
+        refreshInterval.unref?.();
+    }
+    function guard(action) {
+        if (disabled) {
+            return;
+        }
+        try {
+            action();
+        }
+        catch (error) {
+            disabled = true;
+            stopRefreshLoop();
+            if (!warningLogged) {
+                warningLogged = true;
+                stderr.write(`[voratiq] Progressive verify output disabled: ${formatErrorDetail(error)}\n`);
+            }
+        }
+    }
+    function safeParse(value) {
+        if (!value) {
+            return undefined;
+        }
+        const parsed = Date.parse(value);
+        return Number.isNaN(parsed) ? undefined : parsed;
+    }
+    function formatDuration(record) {
+        if (record.status === "running") {
+            return DASH;
+        }
+        return (formatRenderLifecycleDuration({
+            lifecycle: {
+                status: record.status,
+                startedAt: record.startedAt,
+                completedAt: record.completedAt,
+            },
+            terminalStatuses: TERMINAL_VERIFICATION_STATUSES,
+            now: now(),
+        }) ?? DASH);
+    }
+    function syncContextLifecycleFromMethods() {
+        if (!context) {
+            return;
+        }
+        let earliestStartedAt = safeParse(context.startedAt);
+        let latestCompletedAt = safeParse(context.completedAt);
+        for (const method of methodRecords.values()) {
+            const startedAt = safeParse(method.startedAt);
+            if (startedAt !== undefined &&
+                (earliestStartedAt === undefined || startedAt < earliestStartedAt)) {
+                earliestStartedAt = startedAt;
+            }
+            const completedAt = safeParse(method.completedAt);
+            if (completedAt !== undefined &&
+                (latestCompletedAt === undefined || completedAt > latestCompletedAt)) {
+                latestCompletedAt = completedAt;
+            }
+        }
+        context = {
+            ...context,
+            startedAt: earliestStartedAt === undefined
+                ? undefined
+                : new Date(earliestStartedAt).toISOString(),
+            completedAt: latestCompletedAt === undefined
+                ? undefined
+                : new Date(latestCompletedAt).toISOString(),
+        };
+    }
+    function buildMethodTable(style) {
+        if (methodRecords.size === 0) {
+            return [];
+        }
+        const resolvedStyle = resolveTranscriptShellStyle(style);
+        const rows = methodOrder
+            .filter((methodKey) => methodRecords.has(methodKey))
+            .map((methodKey) => {
+            const method = methodRecords.get(methodKey);
+            return {
+                verifierLabel: formatVerifierLabel(method.verifierLabel, method.status, resolvedStyle),
+                agentLabel: method.agentLabel,
+                status: formatTranscriptStatusLabel(method.status, getRunStatusStyle(method.status).cli, resolvedStyle),
+                duration: formatDuration(method),
+                artifactPath: method.artifactPath,
+            };
+        });
+        return buildVerifyMethodTable(rows);
+    }
+    function render() {
+        if (!context || disabled || !stdout.isTTY) {
+            return;
+        }
+        syncContextLifecycleFromMethods();
+        const style = resolveTranscriptShellStyleFromWriter(stdout, { forceTty: true });
+        const elapsed = formatVerifyElapsed(context, now());
+        lastElapsedLabel = elapsed ?? null;
+        const shell = buildVerifyStageShell({
+            verificationId: context.verificationId,
+            createdAt: context.createdAt,
+            elapsed: elapsed ?? DASH,
+            workspacePath: context.workspacePath,
+            status: context.status,
+            tableLines: buildMethodTable(style),
+            style,
+        });
+        const interactiveLines = buildStageFrameLines({
+            metadataLines: shell.metadataLines,
+            statusTableLines: shell.statusTableLines,
+            leadingBlankLine: !suppressLeadingBlankLine,
+            trailingBlankLine: !suppressTrailingBlankLine,
+        });
+        if (interactiveLines.length === 0) {
+            return;
+        }
+        interactiveFrameRenderer.render(interactiveLines);
+    }
+    function upsertMethod(record) {
+        if (!methodOrder.includes(record.methodKey)) {
+            methodOrder.push(record.methodKey);
+        }
+        const existing = methodRecords.get(record.methodKey);
+        methodRecords.set(record.methodKey, {
+            ...existing,
+            ...record,
+            startedAt: record.startedAt ?? existing?.startedAt,
+            completedAt: record.completedAt ?? existing?.completedAt,
+            artifactPath: record.artifactPath ?? existing?.artifactPath,
+        });
+    }
+    return {
+        onProgressEvent(event) {
+            guard(() => {
+                if (event.stage !== "verify") {
+                    return;
+                }
+                if (event.type === "stage.begin") {
+                    context = { ...event.context };
+                    render();
+                    syncRefreshLoop();
+                    return;
+                }
+                if (event.type === "stage.candidate") {
+                    upsertMethod(event.candidate);
+                    render();
+                    syncRefreshLoop();
+                    return;
+                }
+                if (!context) {
+                    return;
+                }
+                context = {
+                    ...context,
+                    status: event.status,
+                };
+                render();
+                syncRefreshLoop();
+            });
+        },
+        begin(nextContext) {
+            guard(() => {
+                if (!nextContext) {
+                    render();
+                    syncRefreshLoop();
+                    return;
+                }
+                this.onProgressEvent({
+                    type: "stage.begin",
+                    stage: "verify",
+                    context: nextContext,
+                });
+            });
+        },
+        update(record) {
+            this.onProgressEvent({
+                type: "stage.candidate",
+                stage: "verify",
+                candidate: record,
+            });
+        },
+        complete(status, lifecycle) {
+            stopRefreshLoop();
+            guard(() => {
+                if (context && lifecycle) {
+                    context = {
+                        ...context,
+                        startedAt: lifecycle.startedAt ?? context.startedAt,
+                        completedAt: lifecycle.completedAt ?? context.completedAt,
+                    };
+                }
+                if (status) {
+                    this.onProgressEvent({
+                        type: "stage.status",
+                        stage: "verify",
+                        status,
+                    });
+                }
+                else {
+                    render();
+                }
+                disabled = true;
+            });
+        },
+    };
+}
+export function renderVerifyTranscript(options) {
+    const { verificationId, createdAt, elapsed, workspacePath, target, status, methods, suppressHint, warningMessage, hintMessage, isTty, includeSummarySection = true, } = options;
+    const style = { isTty };
+    const resolvedStyle = resolveTranscriptShellStyle(style);
+    const sections = [];
+    if (includeSummarySection) {
+        const metadataLines = buildVerifyStageShell({
+            verificationId,
+            createdAt,
+            elapsed,
+            workspacePath,
+            status,
+            tableLines: methods.length === 0
+                ? []
+                : buildVerifyMethodTable(methods.map((method) => ({
+                    verifierLabel: formatVerifierLabel(method.verifierLabel, method.status, resolvedStyle),
+                    agentLabel: method.agentLabel,
+                    status: formatTranscriptStatusLabel(method.status, getRunStatusStyle(method.status).cli, resolvedStyle),
+                    duration: method.duration,
+                    artifactPath: method.artifactPath,
+                }))),
+            style,
+        });
+        sections.push(...buildStageFrameSections(metadataLines));
+    }
+    if (methods.length > 0) {
+        sections.push(["---"]);
+    }
+    if (target) {
+        sections.push([`Target: ${target.kind}:${target.sessionId}`]);
+        if (methods.length > 0) {
+            sections.push(["---"]);
+        }
+    }
+    methods.forEach((method, index) => {
+        const block = [`Agent: ${method.agentLabel ?? DASH}`];
+        block.push("", `Verifier: ${method.verifierLabel}`);
+        if (method.bodyLines && method.bodyLines.length > 0) {
+            block.push("", ...method.bodyLines);
+        }
+        if (method.errorLine) {
+            block.push("");
+            block.push(formatTranscriptErrorLine(method.errorLine, resolvedStyle));
+        }
+        block.push("", `Output: ${method.artifactPath ?? DASH}`);
+        if (index < methods.length - 1) {
+            block.push("", "---");
+        }
+        sections.push(block);
+    });
+    const footerParts = [
+        ...(warningMessage ? [warningMessage] : []),
+        ...(hintMessage && !suppressHint ? [hintMessage] : []),
+    ];
+    const hint = footerParts.length === 0
+        ? undefined
+        : {
+            message: `---\n\n${footerParts.join("\n\n---\n\n")}`,
+        };
+    return renderTranscript({ sections, hint });
+}
+export function formatVerifyElapsed(source, now) {
+    return formatRenderLifecycleDuration({
+        lifecycle: {
+            status: source.status,
+            startedAt: source.startedAt,
+            completedAt: source.completedAt,
+        },
+        terminalStatuses: TERMINAL_VERIFICATION_STATUSES,
+        now,
+    });
+}

package/dist/render/utils/agents.d.ts

@@ -1,5 +1,6 @@
-import type { AgentEvalEnhanced, AgentInvocationEnhanced } from "../../records/enhanced.js";
-import type { AgentEvalView, AgentReport, AgentStatus } from "../../records/types.js";
+import type { AgentInvocationEnhanced } from "../../domain/run/model/enhanced.js";
+import type { AgentReport, AgentStatus } from "../../domain/run/model/types.js";
+import type { TranscriptShellStyleOptions } from "./transcript-shell.js";
 type AgentHeaderSource = Pick<AgentInvocationEnhanced, "agentId" | "status" | "startedAt" | "completedAt"> | Pick<AgentReport, "agentId" | "status" | "startedAt" | "completedAt">;
 type AgentSectionSource = AgentHeaderSource & {
     diffStatistics?: string;
@@ -8,21 +9,21 @@ type AgentSectionSource = AgentHeaderSource & {
     baseDirectory?: string;
     runtimeManifestPath?: string;
     assets?: AgentInvocationEnhanced["assets"];
-    evals?: (AgentEvalEnhanced | AgentEvalView)[];
 };
 export type AgentSectionInput = AgentSectionSource;
 type AgentMetadataRow = {
     label: string;
     value: string;
 };
-export declare function formatAgentStatusLabel(status: AgentStatus): string;
-export declare function buildAgentSectionHeader(agent: AgentHeaderSource): string;
+export declare function formatAgentStatusLabelWithStyle(status: AgentStatus, style?: TranscriptShellStyleOptions): string;
+export declare function formatAgentErrorLine(error: string, style?: TranscriptShellStyleOptions): string;
+export declare function buildAgentSectionHeader(agent: AgentHeaderSource, style?: TranscriptShellStyleOptions): string;
 export declare function getAgentMetadata(agent: AgentSectionSource): AgentMetadataRow[];
 export declare function buildAgentMetadataSection(agent: AgentSectionSource): string[];
-export declare function buildAgentSection(agent: AgentSectionSource): string[];
+export declare function buildAgentSectionWithStyle(agent: AgentSectionSource, style?: TranscriptShellStyleOptions): string[];
 export declare function buildAgentSectionArtifacts(agent: AgentSectionSource, agentRoot?: string): string[];
-export declare function buildAgentSectionEvals(agent: AgentSectionSource, agentRoot?: string): string[];
 export declare function buildAgentSectionRuntime(agent: AgentSectionSource, agentRoot?: string): string[];
-export declare function formatAgentDuration(agent: AgentHeaderSource): string | undefined;
-export declare function formatDurationLabel(durationMs: number): string | undefined;
+export declare function formatAgentDuration(agent: AgentHeaderSource, options?: {
+    now?: number;
+}): string | undefined;
 export {};

package/dist/render/utils/agents.js

@@ -1,15 +1,21 @@
-import { getAgentStatusStyle, getEvalStatusStyle, } from "../../status/colors.js";
+import { getAgentStatusStyle } from "../../status/colors.js";
+import { TERMINAL_AGENT_STATUSES } from "../../status/index.js";
 import { colorize } from "../../utils/colors.js";
 import { formatAgentBadge } from "./badges.js";
+import { formatRenderLifecycleDuration } from "./duration.js";
 import { renderTable } from "./table.js";
-export function formatAgentStatusLabel(status) {
-    const statusColor = getAgentStatusStyle(status).cli;
-    return colorize(status.toUpperCase(), statusColor);
+import { formatTranscriptErrorLine, formatTranscriptStatusLabel, resolveTranscriptShellStyle, } from "./transcript-shell.js";
+export function formatAgentStatusLabelWithStyle(status, style = {}) {
+    const resolved = resolveTranscriptShellStyle(style);
+    return formatTranscriptStatusLabel(status, getAgentStatusStyle(status).cli, resolved);
 }
-export function buildAgentSectionHeader(agent) {
-    const agentLabel = formatAgentBadge(agent.agentId);
+export function formatAgentErrorLine(error, style = {}) {
+    return formatTranscriptErrorLine(error, resolveTranscriptShellStyle(style));
+}
+export function buildAgentSectionHeader(agent, style = {}) {
+    const agentLabel = formatAgentBadge(agent.agentId, style);
     const status = agent.status;
-    const statusLabel = formatAgentStatusLabel(status);
+    const statusLabel = formatAgentStatusLabelWithStyle(status, style);
     return `  ${agentLabel} ${statusLabel}`;
 }
 export function getAgentMetadata(agent) {
@@ -42,9 +48,10 @@ export function buildAgentMetadataSection(agent) {
     const [, ...bodyLines] = tableLines;
     return bodyLines;
 }
-export function buildAgentSection(agent) {
-    const lines = [buildAgentSectionHeader(agent)];
+export function buildAgentSectionWithStyle(agent, style = {}) {
+    const lines = [buildAgentSectionHeader(agent, style)];
     const agentRoot = getAgentRootPath(agent);
+    const resolvedStyle = resolveTranscriptShellStyle(style);
     const metadataLines = buildAgentMetadataSection(agent);
     if (metadataLines.length > 0) {
         lines.push("", ...indentLines(metadataLines));
@@ -54,15 +61,13 @@ export function buildAgentSection(agent) {
         lines.push("", ...indentLines(runtimeLines));
     }
     if (agent.warnings && agent.warnings.length > 0) {
-        const warningLines = agent.warnings.map((warning) => colorize(`Warning: ${warning}`, "yellow"));
+        const warningLines = agent.warnings.map((warning) => resolvedStyle.isTty
+            ? colorize(`Warning: ${warning}`, "yellow")
+            : `Warning: ${warning}`);
         lines.push("", ...indentLines(warningLines));
     }
     if (agent.error) {
-        lines.push("", ...indentLines([colorize(`Error: ${agent.error}`, "red")]));
-    }
-    const evalLines = buildAgentSectionEvals(agent, agentRoot);
-    if (evalLines.length > 0) {
-        lines.push("", ...indentLines(evalLines));
+        lines.push("", ...indentLines([formatAgentErrorLine(agent.error, style)]));
     }
     const artifactLines = buildAgentSectionArtifacts(agent, agentRoot);
     if (artifactLines.length > 0) {
@@ -101,33 +106,6 @@ export function buildAgentSectionArtifacts(agent, agentRoot) {
     });
     return tableLines;
 }
-export function buildAgentSectionEvals(agent, agentRoot) {
-    const evalResults = agent.evals ?? [];
-    const rows = evalResults.length === 0
-        ? [
-            {
-                slug: "none",
-                status: colorize("SKIPPED", getEvalStatusStyle("skipped").cli),
-                log: "—",
-            },
-        ]
-        : evalResults.map((evaluation) => ({
-            slug: evaluation.slug,
-            status: colorize(evaluation.status.toUpperCase(), getEvalStatusStyle(evaluation.status).cli),
-            log: evaluation.logPath !== undefined
-                ? relativizePath(evaluation.logPath, agentRoot)
-                : "—",
-        }));
-    const tableLines = renderTable({
-        columns: [
-            { header: "EVAL", accessor: (row) => row.slug },
-            { header: "STATUS", accessor: (row) => row.status },
-            { header: "LOG", accessor: (row) => row.log },
-        ],
-        rows,
-    });
-    return tableLines;
-}
 export function buildAgentSectionRuntime(agent, agentRoot) {
     const rows = [];
     if (typeof agent.runtimeManifestPath === "string" &&
@@ -159,46 +137,16 @@ export function buildAgentSectionRuntime(agent, agentRoot) {
     });
     return tableLines;
 }
-export function formatAgentDuration(agent) {
-    const startedAt = safeParse(agent.startedAt);
-    const completedAt = safeParse(agent.completedAt);
-    if (startedAt === undefined ||
-        completedAt === undefined ||
-        completedAt < startedAt) {
-        return undefined;
-    }
-    const durationMs = completedAt - startedAt;
-    return formatDurationLabel(durationMs);
-}
-function safeParse(timestamp) {
-    if (!timestamp) {
-        return undefined;
-    }
-    const parsed = Date.parse(timestamp);
-    if (Number.isNaN(parsed)) {
-        return undefined;
-    }
-    return parsed;
-}
-export function formatDurationLabel(durationMs) {
-    if (!Number.isFinite(durationMs) || durationMs < 0) {
-        return undefined;
-    }
-    const totalSeconds = Math.round(durationMs / 1000);
-    const hours = Math.floor(totalSeconds / 3600);
-    const minutes = Math.floor((totalSeconds % 3600) / 60);
-    const seconds = totalSeconds % 60;
-    const parts = [];
-    if (hours > 0) {
-        parts.push(`${hours}h`);
-    }
-    if (minutes > 0) {
-        parts.push(`${minutes}m`);
-    }
-    if (seconds > 0 || parts.length === 0) {
-        parts.push(`${seconds}s`);
-    }
-    return parts.join(" ");
+export function formatAgentDuration(agent, options = {}) {
+    return formatRenderLifecycleDuration({
+        lifecycle: {
+            status: agent.status,
+            startedAt: agent.startedAt,
+            completedAt: agent.completedAt,
+        },
+        terminalStatuses: TERMINAL_AGENT_STATUSES,
+        now: options.now,
+    });
 }
 function getAgentRootPath(agent) {
     if (typeof agent.baseDirectory === "string") {

package/dist/render/utils/badges.d.ts

@@ -1,20 +1,3 @@
-type AnsiCode = string;
-export interface BadgeStyle {
-    foreground?: AnsiCode;
-    background?: AnsiCode;
-    bold?: boolean;
-    padding?: number;
-}
-export declare const BADGE_STYLES: {
-    readonly run: {
-        readonly foreground: "\u001B[38;2;0;0;0m";
-        readonly background: "\u001B[48;2;164;203;153m";
-        readonly bold: true;
-    };
-    readonly agent: {
-        readonly bold: true;
-    };
-};
-export declare function formatRunBadge(text: string): string;
-export declare function formatAgentBadge(text: string): string;
-export {};
+import type { TranscriptShellStyleOptions } from "./transcript-shell.js";
+export type BadgeRenderOptions = TranscriptShellStyleOptions;
+export declare function formatAgentBadge(text: string, options?: BadgeRenderOptions): string;

package/dist/render/utils/badges.js

@@ -1,37 +1,4 @@
-const ANSI_RESET = "\u001B[0m";
-const ANSI_BOLD = "\u001B[1m";
-const ESC = "\u001B[";
-const BRAND_COLOR = "164;203;153";
-export const BADGE_STYLES = {
-    run: {
-        foreground: `${ESC}38;2;0;0;0m`,
-        background: `${ESC}48;2;${BRAND_COLOR}m`,
-        bold: true,
-    },
-    agent: {
-        bold: true,
-    },
-};
-function applyBadgeStyle(text, style) {
-    const padding = Math.max(0, style.padding ?? 0);
-    const pad = padding === 0 ? "" : " ".repeat(padding);
-    const padded = `${pad}${text}${pad}`;
-    const parts = [];
-    if (typeof style.background === "string" && style.background.length > 0) {
-        parts.push(style.background);
-    }
-    if (typeof style.foreground === "string" && style.foreground.length > 0) {
-        parts.push(style.foreground);
-    }
-    if (style.bold === true) {
-        parts.push(ANSI_BOLD);
-    }
-    parts.push(padded, ANSI_RESET);
-    return parts.join("");
-}
-export function formatRunBadge(text) {
-    return applyBadgeStyle(text, BADGE_STYLES.run);
-}
-export function formatAgentBadge(text) {
-    return applyBadgeStyle(text, BADGE_STYLES.agent);
+import { formatTranscriptBadge, resolveTranscriptShellStyle, } from "./transcript-shell.js";
+export function formatAgentBadge(text, options = {}) {
+    return formatTranscriptBadge(text, "agent", resolveTranscriptShellStyle(options));
 }

package/dist/render/utils/duration.d.ts

@@ -0,0 +1,12 @@
+import { type LifecycleExecutionDurationInput } from "../../domain/shared/lifecycle.js";
+export declare function resolveRenderLifecycleDurationMs<TStatus extends string>(options: {
+    lifecycle: LifecycleExecutionDurationInput<TStatus>;
+    terminalStatuses: readonly TStatus[];
+    now?: number;
+}): number | undefined;
+export declare function formatRenderLifecycleDuration<TStatus extends string>(options: {
+    lifecycle: LifecycleExecutionDurationInput<TStatus>;
+    terminalStatuses: readonly TStatus[];
+    now?: number;
+}): string | undefined;
+export declare function formatDurationLabel(durationMs: number): string | undefined;