@timurproko/a1 0.1.1-dev.6 → 0.1.1-dev.7

package/dist/src/foundation/ui-apps/contracts.d.ts

@@ -0,0 +1,42 @@
+import type { PaneInputResult, PaneMouseEvent, PaneRect, UiTheme } from "../ui-components/index.js";
+export interface AppSize {
+    readonly width: number;
+    readonly height: number;
+}
+/**
+ * What a host offers a presented app. An app reaches the terminal, the pinned
+ * shell, or another app only through these — never around them.
+ */
+export interface AppHostServices {
+    getSize(): AppSize;
+    requestRender(): void;
+    close(): void;
+    /** Restores the surface that opened this app without closing the host. */
+    returnToPrevious(): void;
+    /** Leaves A1 entirely, as the interrupt chord does from any screen. */
+    exit(): void;
+    /** True once one interrupt has been seen and the chord is waiting for the second. */
+    readonly interruptArmed: boolean;
+    /**
+     * Whether an idle interrupt closes the presented app. Every host chooses
+     * explicitly: a standalone screen closes, a persistent host stays open.
+     */
+    readonly closeOnInterrupt: boolean;
+    /** Colours for the presented app. Absent renders plain text. */
+    readonly theme?: UiTheme;
+}
+export interface UiApp {
+    readonly id: string;
+    render(rect: PaneRect, host: AppHostServices): readonly string[];
+    onInput?(data: string, host: AppHostServices): PaneInputResult;
+    onMouse?(event: PaneMouseEvent, host: AppHostServices): PaneInputResult;
+    onActivate?(host: AppHostServices): void;
+    onClose?(host: AppHostServices): void;
+}
+export interface AppRegistration {
+    readonly id: string;
+    /** Route that opens the app, without its leading slash. */
+    readonly route: string;
+    create(): UiApp;
+}
+export declare function assertAppRegistration(registration: AppRegistration): void;

package/dist/src/foundation/ui-apps/contracts.js

@@ -0,0 +1,12 @@
+const ID_PATTERN = /^[a-z][a-z0-9-]{0,63}$/;
+export function assertAppRegistration(registration) {
+    if (!ID_PATTERN.test(registration.id)) {
+        throw new Error(`owned UI app id is not a bounded slug: ${registration.id}`);
+    }
+    if (!ID_PATTERN.test(registration.route)) {
+        throw new Error(`owned UI app ${registration.id} has an invalid route: ${registration.route}`);
+    }
+    if (typeof registration.create !== "function") {
+        throw new TypeError(`owned UI app ${registration.id} has no create()`);
+    }
+}

package/dist/src/foundation/ui-apps/host.d.ts

@@ -0,0 +1,42 @@
+import { type PaneInputResult, type PaneMouseEvent, type UiTheme } from "../ui-components/index.js";
+import type { AppSize, UiApp } from "./contracts.js";
+import type { UiAppRegistry } from "./registry.js";
+export interface AppHostSurface {
+    /** Current viewport, re-read on every frame so a resize is picked up. */
+    size(): AppSize;
+    /** Asks the surrounding runtime to repaint. */
+    requestRender(): void;
+    /** Presents these rows, or clears the surface when null. */
+    present(lines: readonly string[] | null): void;
+    /** Reports a failure that closed an app. */
+    reportFailure?(appId: string, error: unknown): void;
+    /** Leaves A1 entirely. Invoked by the interrupt chord from a presented app. */
+    exit?(): void;
+}
+export interface AppHostOptions {
+    readonly registry: UiAppRegistry;
+    readonly surface: AppHostSurface;
+    /** Whether an idle interrupt closes the presented app. Chosen explicitly. */
+    readonly closeOnInterrupt: boolean;
+    /** Colours handed to every presented app. Absent renders plain text. */
+    readonly theme?: UiTheme;
+}
+/**
+ * Presents at most one app. Input reaches the presented app first; anything it
+ * does not consume continues to the caller. A failure while rendering or
+ * handling input closes the app rather than leaving a broken surface on screen.
+ */
+export declare class UiAppHost {
+    #private;
+    constructor(options: AppHostOptions);
+    get presented(): UiApp | null;
+    get isPresenting(): boolean;
+    /** Opens a registered app, replacing whatever was presented. */
+    open(id: string): void;
+    openRoute(route: string): boolean;
+    render(): void;
+    handleInput(data: string): PaneInputResult;
+    handleMouse(event: PaneMouseEvent): PaneInputResult;
+    get interruptArmed(): boolean;
+    close(): void;
+}

package/dist/src/foundation/ui-apps/host.js

@@ -0,0 +1,152 @@
+import { FrameCache, finalizeFrame, } from "../ui-components/index.js";
+// The interrupt byte, written as an escape: as a raw byte it is invisible to
+// every text tool, and this constant had already been emptied by one.
+const INTERRUPT = "";
+/** How long the first interrupt of the chord stays armed. */
+const INTERRUPT_CHORD_MS = 1_500;
+/**
+ * Presents at most one app. Input reaches the presented app first; anything it
+ * does not consume continues to the caller. A failure while rendering or
+ * handling input closes the app rather than leaving a broken surface on screen.
+ */
+export class UiAppHost {
+    #registry;
+    #surface;
+    #closeOnInterrupt;
+    #theme;
+    /** When the first interrupt of a chord was seen, or null when disarmed. */
+    #interruptArmedAt = null;
+    #cache = new FrameCache();
+    #app = null;
+    constructor(options) {
+        this.#registry = options.registry;
+        this.#surface = options.surface;
+        this.#closeOnInterrupt = options.closeOnInterrupt;
+        this.#theme = options.theme;
+    }
+    get presented() {
+        return this.#app;
+    }
+    get isPresenting() {
+        return this.#app !== null;
+    }
+    /** Opens a registered app, replacing whatever was presented. */
+    open(id) {
+        const registration = this.#registry.get(id);
+        if (registration === null)
+            throw new Error(`owned UI app is not registered: ${id}`);
+        if (this.#app !== null)
+            this.#closeCurrent();
+        const app = registration.create();
+        this.#app = app;
+        this.#cache.invalidate();
+        this.#guard(() => app.onActivate?.(this.#services()));
+        this.render();
+    }
+    openRoute(route) {
+        const registration = this.#registry.forRoute(route);
+        if (registration === null)
+            return false;
+        this.open(registration.id);
+        return true;
+    }
+    render() {
+        const app = this.#app;
+        if (app === null) {
+            this.#surface.present(null);
+            return;
+        }
+        const size = this.#surface.size();
+        const rect = { width: Math.max(0, size.width), height: Math.max(0, size.height) };
+        const lines = this.#guard(() => finalizeFrame(app.render(rect, this.#services()), rect, app.id));
+        this.#surface.present(lines ?? null);
+    }
+    handleInput(data) {
+        const app = this.#app;
+        if (app === null)
+            return { consumed: false };
+        const result = this.#guard(() => app.onInput?.(data, this.#services())) ?? { consumed: false };
+        if (this.#app === null)
+            return { consumed: true, render: true };
+        if (result.consumed) {
+            if (result.render !== false)
+                this.render();
+            return result;
+        }
+        if (data === INTERRUPT)
+            return this.#interrupt();
+        return { consumed: false };
+    }
+    handleMouse(event) {
+        const app = this.#app;
+        if (app === null)
+            return { consumed: false };
+        const result = this.#guard(() => app.onMouse?.(event, this.#services())) ?? { consumed: false };
+        if (result.consumed && result.render !== false)
+            this.render();
+        return result;
+    }
+    /**
+     * Two interrupts leave A1, from any screen. One arms the chord and repaints so
+     * the screen can say so; a second within the window exits rather than merely
+     * closing the screen, which is what the chord means everywhere else.
+     */
+    #interrupt() {
+        const now = Date.now();
+        const armed = this.#interruptArmedAt;
+        if (armed !== null && now - armed <= INTERRUPT_CHORD_MS) {
+            this.#interruptArmedAt = null;
+            this.close();
+            this.#surface.exit?.();
+            return { consumed: true, render: true };
+        }
+        this.#interruptArmedAt = now;
+        return { consumed: true, render: true };
+    }
+    get interruptArmed() {
+        const armed = this.#interruptArmedAt;
+        return armed !== null && Date.now() - armed <= INTERRUPT_CHORD_MS;
+    }
+    close() {
+        if (this.#app === null)
+            return;
+        this.#closeCurrent();
+        this.#surface.present(null);
+    }
+    #closeCurrent() {
+        const app = this.#app;
+        this.#app = null;
+        this.#cache.invalidate();
+        if (app !== null)
+            this.#guard(() => app.onClose?.(this.#services()));
+    }
+    #services() {
+        return {
+            getSize: () => this.#surface.size(),
+            requestRender: () => this.#surface.requestRender(),
+            close: () => this.close(),
+            returnToPrevious: () => this.close(),
+            closeOnInterrupt: this.#closeOnInterrupt,
+            exit: () => {
+                this.close();
+                this.#surface.exit?.();
+            },
+            interruptArmed: this.interruptArmed,
+            ...(this.#theme === undefined ? {} : { theme: this.#theme }),
+        };
+    }
+    /** Contains a failure: the app is closed and the surface restored, never left broken. */
+    #guard(work) {
+        try {
+            return work();
+        }
+        catch (error) {
+            const app = this.#app;
+            this.#app = null;
+            this.#cache.invalidate();
+            this.#surface.present(null);
+            this.#surface.reportFailure?.(app?.id ?? "unknown", error);
+            return undefined;
+        }
+    }
+}

package/dist/src/foundation/ui-apps/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./contracts.js";
+export * from "./host.js";
+export * from "./registry.js";

package/dist/src/foundation/ui-apps/index.js

@@ -0,0 +1,3 @@
+export * from "./contracts.js";
+export * from "./host.js";
+export * from "./registry.js";

package/dist/src/foundation/ui-apps/registry.d.ts

@@ -0,0 +1,11 @@
+import { type AppRegistration } from "./contracts.js";
+export declare class UiAppRegistry {
+    #private;
+    /** Registering a known id replaces its definition rather than adding a second app. */
+    register(registration: AppRegistration): () => void;
+    get(id: string): AppRegistration | null;
+    forRoute(route: string): AppRegistration | null;
+    ids(): readonly string[];
+    routes(): readonly string[];
+    clear(): void;
+}

package/dist/src/foundation/ui-apps/registry.js

@@ -0,0 +1,32 @@
+import { assertAppRegistration } from "./contracts.js";
+export class UiAppRegistry {
+    #byId = new Map();
+    /** Registering a known id replaces its definition rather than adding a second app. */
+    register(registration) {
+        assertAppRegistration(registration);
+        const existing = [...this.#byId.values()].find(candidate => candidate.route === registration.route && candidate.id !== registration.id);
+        if (existing) {
+            throw new Error(`owned UI route ${registration.route} is already taken by ${existing.id}`);
+        }
+        this.#byId.set(registration.id, registration);
+        return () => {
+            if (this.#byId.get(registration.id) === registration)
+                this.#byId.delete(registration.id);
+        };
+    }
+    get(id) {
+        return this.#byId.get(id) ?? null;
+    }
+    forRoute(route) {
+        return [...this.#byId.values()].find(registration => registration.route === route) ?? null;
+    }
+    ids() {
+        return Object.freeze([...this.#byId.keys()].sort());
+    }
+    routes() {
+        return Object.freeze([...this.#byId.values()].map(registration => registration.route).sort());
+    }
+    clear() {
+        this.#byId.clear();
+    }
+}

package/dist/src/foundation/ui-components/dialog-panel.d.ts

@@ -0,0 +1,36 @@
+import type { UiTheme } from "./theme.js";
+/**
+ * The panel a value with parts is edited in: at the foot of the screen, over the
+ * surface it was opened from, ruled off above and below. It shows every part,
+ * marks the one in hand, says what that part does, and says how to change it.
+ */
+export interface DialogRow {
+    readonly label: string;
+    readonly value: string;
+    /** What this part does, shown while it is the one in hand. */
+    readonly description?: string;
+}
+export interface DialogPanelState {
+    readonly rows: readonly DialogRow[];
+    /** The row in hand. */
+    readonly index: number;
+    /** How to change it, in the words the engine uses. */
+    readonly hint: string;
+}
+/** Where the panel sits, for reading a pointer against its rows. */
+export interface DialogPanelFrame {
+    /** Screen row the panel's first row is drawn on. */
+    readonly firstRow: number;
+    readonly rows: number;
+    /** Column the values start at, so a label stays a label. */
+    readonly valueColumn: number;
+}
+/** The column values start at: past the widest label, capped so one long name cannot push them off. */
+export declare function dialogValueColumn(rows: readonly DialogRow[]): number;
+/**
+ * The panel's lines. The first line is its rule, so the row at index N is drawn
+ * one line below the panel's top.
+ */
+export declare function renderDialogPanel(state: DialogPanelState, width: number, theme: UiTheme): readonly string[];
+/** The row a pointer report lands on, or null when it is not on one. */
+export declare function dialogRowAt(frame: DialogPanelFrame, row: number, column: number, valueWidth: number): number | null;

package/dist/src/foundation/ui-components/dialog-panel.js

@@ -0,0 +1,47 @@
+import { displayWidth, truncateToWidth } from "./text.js";
+const LABEL_COLUMN_CAP = 30;
+/** The column values start at: past the widest label, capped so one long name cannot push them off. */
+export function dialogValueColumn(rows) {
+    const widest = Math.min(LABEL_COLUMN_CAP, Math.max(0, ...rows.map(row => displayWidth(row.label))));
+    return 2 + widest + 2;
+}
+/**
+ * The panel's lines. The first line is its rule, so the row at index N is drawn
+ * one line below the panel's top.
+ */
+export function renderDialogPanel(state, width, theme) {
+    const labelColumn = Math.min(LABEL_COLUMN_CAP, Math.max(0, ...state.rows.map(row => displayWidth(row.label))));
+    const rule = theme.fg("border", "─".repeat(Math.max(0, width)));
+    const rows = state.rows.map((row, index) => {
+        const selected = index === state.index;
+        const padded = `${row.label}${" ".repeat(Math.max(0, labelColumn - displayWidth(row.label)))}`;
+        const cursor = selected ? "→ " : "  ";
+        const raw = `${cursor}${padded}  ${row.value}`;
+        // An unselected label is left unpainted and its value quietened, both lifted
+        // to the accent on the row the cursor is on — as the engine paints its own.
+        const painted = `${theme.fg("accent", cursor)}${selected ? theme.fg("accent", padded) : padded}  ${theme.fg("muted", row.value)}`;
+        return pad(truncateToWidth(painted, width), width, raw);
+    });
+    const description = state.rows[state.index]?.description ?? "";
+    return [
+        rule,
+        ...rows,
+        "",
+        pad(truncateToWidth(theme.fg("dim", `  ${description}`), width), width, `  ${description}`),
+        "",
+        pad(truncateToWidth(theme.fg("dim", `  ${state.hint}`), width), width, `  ${state.hint}`),
+        rule,
+    ];
+}
+/** The row a pointer report lands on, or null when it is not on one. */
+export function dialogRowAt(frame, row, column, valueWidth) {
+    const at = row - frame.firstRow;
+    if (at < 0 || at >= frame.rows)
+        return null;
+    const start = frame.valueColumn + 1;
+    return column >= start && column < start + valueWidth ? at : null;
+}
+function pad(line, width, raw) {
+    const visible = displayWidth(raw);
+    return visible >= width ? line : line + " ".repeat(width - visible);
+}

package/dist/src/foundation/ui-components/frame.d.ts

@@ -0,0 +1,21 @@
+export interface PaneRect {
+    readonly width: number;
+    readonly height: number;
+}
+export declare class FrameContractError extends Error {
+    readonly pane: string;
+    constructor(pane: string, message: string);
+}
+export declare function assertPaneRect(rect: PaneRect, pane?: string): void;
+/**
+ * A pane owns its rectangle exactly: one row per row of height, each within
+ * width, and never an embedded newline — the host counts rows to place
+ * everything below, so a miscount corrupts the surrounding layout.
+ */
+export declare function validateFrame(lines: readonly string[], rect: PaneRect, pane?: string): void;
+/**
+ * Brings a rendered body up to the contract: truncates overlong rows, pads a
+ * short body with blank rows, and drops rows beyond the rectangle. Panes that
+ * compose other panes use this so one child cannot break the parent's layout.
+ */
+export declare function finalizeFrame(lines: readonly string[], rect: PaneRect, pane?: string): readonly string[];

package/dist/src/foundation/ui-components/frame.js

@@ -0,0 +1,54 @@
+import { displayWidth, truncateToWidth } from "./text.js";
+export class FrameContractError extends Error {
+    pane;
+    constructor(pane, message) {
+        super(`${pane}: ${message}`);
+        this.pane = pane;
+        this.name = "FrameContractError";
+    }
+}
+const MAX_DIMENSION = 10_000;
+export function assertPaneRect(rect, pane = "pane") {
+    for (const [name, value] of [["width", rect.width], ["height", rect.height]]) {
+        if (!Number.isInteger(value) || value < 0 || value > MAX_DIMENSION) {
+            throw new FrameContractError(pane, `${name} must be an integer between 0 and ${MAX_DIMENSION}, received ${value}`);
+        }
+    }
+}
+/**
+ * A pane owns its rectangle exactly: one row per row of height, each within
+ * width, and never an embedded newline — the host counts rows to place
+ * everything below, so a miscount corrupts the surrounding layout.
+ */
+export function validateFrame(lines, rect, pane = "pane") {
+    assertPaneRect(rect, pane);
+    if (lines.length !== rect.height) {
+        throw new FrameContractError(pane, `rendered ${lines.length} rows for a height of ${rect.height}`);
+    }
+    lines.forEach((line, index) => {
+        if (line.includes("\n") || line.includes("\r")) {
+            throw new FrameContractError(pane, `row ${index} contains a line break`);
+        }
+        const width = displayWidth(line);
+        if (width > rect.width) {
+            throw new FrameContractError(pane, `row ${index} is ${width} columns wide for a width of ${rect.width}`);
+        }
+    });
+}
+/**
+ * Brings a rendered body up to the contract: truncates overlong rows, pads a
+ * short body with blank rows, and drops rows beyond the rectangle. Panes that
+ * compose other panes use this so one child cannot break the parent's layout.
+ */
+export function finalizeFrame(lines, rect, pane = "pane") {
+    assertPaneRect(rect, pane);
+    const rows = [];
+    for (let index = 0; index < rect.height; index++) {
+        const line = lines[index] ?? "";
+        if (line.includes("\n") || line.includes("\r")) {
+            throw new FrameContractError(pane, `row ${index} contains a line break`);
+        }
+        rows.push(displayWidth(line) > rect.width ? truncateToWidth(line, rect.width) : line);
+    }
+    return Object.freeze(rows);
+}

package/dist/src/foundation/ui-components/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./dialog-panel.js";
+export * from "./frame.js";
+export * from "./label.js";
+export * from "./line-input.js";
+export * from "./list-block.js";
+export * from "./list-view.js";
+export * from "./mouse.js";
+export * from "./pane.js";
+export * from "./revision.js";
+export * from "./scrollbar.js";
+export * from "./shortcuts.js";
+export * from "./spans.js";
+export * from "./status-line.js";
+export * from "./stepper.js";
+export * from "./surface.js";
+export * from "./text.js";
+export * from "./theme.js";
+export * from "./value-menu.js";

package/dist/src/foundation/ui-components/index.js

@@ -0,0 +1,18 @@
+export * from "./dialog-panel.js";
+export * from "./frame.js";
+export * from "./label.js";
+export * from "./line-input.js";
+export * from "./list-block.js";
+export * from "./list-view.js";
+export * from "./mouse.js";
+export * from "./pane.js";
+export * from "./revision.js";
+export * from "./scrollbar.js";
+export * from "./shortcuts.js";
+export * from "./spans.js";
+export * from "./status-line.js";
+export * from "./stepper.js";
+export * from "./surface.js";
+export * from "./text.js";
+export * from "./theme.js";
+export * from "./value-menu.js";

package/dist/src/foundation/ui-components/label.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Setting identifiers are written for code; a screen shows them to a person.
+ * `httpIdleTimeoutMs` reads as "Http Idle Timeout Ms", not as itself.
+ */
+/** Splits camelCase, snake_case, and kebab-case into display words. */
+export declare function humanizeLabel(identifier: string): string;
+/** Section titles use the same rules, so `owned-ui` reads as "Owned UI". */
+export declare function humanizeTitle(identifier: string): string;

package/dist/src/foundation/ui-components/label.js

@@ -0,0 +1,36 @@
+/**
+ * Setting identifiers are written for code; a screen shows them to a person.
+ * `httpIdleTimeoutMs` reads as "Http Idle Timeout Ms", not as itself.
+ */
+const ACRONYMS = {
+    ui: "UI",
+    url: "URL",
+    api: "API",
+    id: "ID",
+    ms: "Ms",
+    cli: "CLI",
+    tui: "TUI",
+    sgr: "SGR",
+    ansi: "ANSI",
+};
+/** Splits camelCase, snake_case, and kebab-case into display words. */
+export function humanizeLabel(identifier) {
+    const words = identifier
+        .replace(/[_-]+/g, " ")
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
+        .split(/\s+/)
+        .filter(word => word.length > 0);
+    if (words.length === 0)
+        return identifier;
+    return words.map(word => {
+        const known = ACRONYMS[word.toLowerCase()];
+        if (known !== undefined)
+            return known;
+        return word.charAt(0).toUpperCase() + word.slice(1);
+    }).join(" ");
+}
+/** Section titles use the same rules, so `owned-ui` reads as "Owned UI". */
+export function humanizeTitle(identifier) {
+    return humanizeLabel(identifier);
+}

package/dist/src/foundation/ui-components/line-input.d.ts

@@ -0,0 +1,74 @@
+export type LineInputOutcome = {
+    readonly kind: "editing";
+} | {
+    readonly kind: "accepted";
+    readonly value: string;
+} | {
+    readonly kind: "cancelled";
+};
+export interface LineInputView {
+    /** Visible slice of the value, already fitted to the width. */
+    readonly text: string;
+    /** Zero-based column of the caret within the visible slice. */
+    readonly caretColumn: number;
+}
+/**
+ * Where a word jump to the left lands: past any whitespace, then past the run of
+ * characters of one class, so a word and a run of punctuation each count as one.
+ */
+export declare function wordLeft(text: string, from: number): number;
+/** Where a word jump to the right lands, by the same rules mirrored. */
+export declare function wordRight(text: string, from: number): number;
+/**
+ * A single-line editable value with a caret and horizontal scrolling. Accept and
+ * cancel are reported distinctly so a caller can commit or discard; cancelling
+ * never changes the caller's value.
+ */
+export declare class LineInput {
+    #private;
+    constructor(value?: string);
+    get value(): string;
+    get caret(): number;
+    setValue(value: string): void;
+    insert(text: string): void;
+    backspace(): void;
+    deleteForward(): void;
+    moveCaret(delta: number): void;
+    /** Moves the caret one word, in whichever direction the sign says. */
+    moveCaretByWord(direction: -1 | 1): void;
+    /** Removes the word before the caret, leaving the caret where it began. */
+    deleteWordBefore(): void;
+    /** Removes the word after the caret, leaving the caret where it is. */
+    deleteWordAfter(): void;
+    moveCaretToStart(): void;
+    moveCaretToEnd(): void;
+    /** Visible slice for a width, scrolled so the caret stays on screen. */
+    view(width: number): LineInputView;
+}
+/** Applies one key to the input and reports whether the caller should commit. */
+export declare function handleLineInputKey(input: LineInput, data: string): LineInputOutcome;
+/**
+ * The prompt the reference draws at the head of an input row, in the grey it
+ * uses for one (#9AA0A6), painted foreground-only so anything drawn behind the
+ * row survives.
+ */
+/** A rule drawn in the prompt's own grey, as the reference rules an input row. */
+export declare function promptRule(width: number): string;
+export declare const PROMPT_GLYPH = "\u001B[38;2;154;160;166m\u276F\u001B[39m ";
+/**
+ * The caret the reference draws: the cell under it is reversed rather than given
+ * a colour of its own, so it reads as a block in whatever theme is in use.
+ */
+export declare function caretCell(text: string): string;
+export interface InputRowOptions {
+    /** Shown quietly while nothing has been typed, with the caret on its first cell. */
+    readonly placeholder?: string;
+    /** Rules above and below, in the prompt's own grey. Default true. */
+    readonly ruled?: boolean;
+}
+export interface InputRow {
+    /** The rows to draw, already padded to the width. */
+    readonly lines: readonly string[];
+}
+/** The input row as the reference draws one, padded to exactly the width. */
+export declare function renderInputRow(input: LineInput, width: number, options?: InputRowOptions): InputRow;