@timurproko/a1 0.1.8-dev.de7821a → 0.2.0

package/dist/ui/apps/contracts.d.ts

@@ -0,0 +1,72 @@
+import type { PaneInputResult, PaneMouseEvent, PaneRect, RenderCacheContract, UiTheme } from "../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;
+    /** Optional declared revisions used by the host's shared frame cache. */
+    readonly renderCache?: RenderCacheContract;
+    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;
+}
+/** A neutral owned-app surface mounted by a surrounding presentation runtime. */
+export interface UiRouteSurface {
+    readonly id: string;
+    /** Renders exactly `height` rows of at most `width` columns. */
+    render(width: number, height: number): readonly string[];
+    /** True when the key was consumed; false leaves it to the surrounding shell. */
+    handleInput(data: string): boolean;
+    /** Mouse report in surface-local coordinates. True when consumed. */
+    handleMouse(event: PaneMouseEvent): boolean;
+    isClosed(): boolean;
+    close(): void;
+    onRenderRequested(listener: () => void): void;
+    /** The surface asks to leave A1 entirely, not merely to close itself. */
+    onExitRequested(listener: () => void): void;
+}
+/**
+ * What a shell may hand a route when it opens it. A route that does not use the
+ * input opens exactly as it does without one.
+ */
+export interface UiRouteInput {
+    /** A caller-supplied document for a route that presents documents. */
+    readonly document?: string;
+}
+/** Route lookup seam shared by owned apps and any presentation runtime hosting them. */
+export interface UiRouteHost {
+    claims(route: string): boolean;
+    open(route: string, input?: UiRouteInput): UiRouteSurface | null;
+}
+export declare function assertAppRegistration(registration: AppRegistration): void;

package/dist/ui/apps/host.d.ts

@@ -0,0 +1,42 @@
+import { type PaneInputResult, type PaneMouseEvent, type UiTheme } from "../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/ui/apps/host.js

@@ -0,0 +1,156 @@
+import { FrameCache, finalizeFrame, } from "../components/index.js";
+// Invariant: the interrupt byte is 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;
+    // Invariant: the first interrupt timestamp is null whenever the chord is disarmed.
+    #interruptArmedAt = null;
+    #renderedInterruptArmed;
+    #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 interruptArmed = this.interruptArmed;
+        if (this.#renderedInterruptArmed !== interruptArmed)
+            this.#cache.invalidate();
+        this.#renderedInterruptArmed = interruptArmed;
+        const lines = this.#guard(() => this.#cache.render(app, rect, () => 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;
+    }
+    // Protocol: two interrupts within the chord window leave A1 from every screen.
+    #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;
+        // Invariant: host-owned state participates in the app's next frame independently of
+        // the app's own revision contract.
+        this.#cache.invalidate();
+        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 }),
+        };
+    }
+    // Security: an app failure closes its app and restores the surface.
+    #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/ui/apps/index.d.ts

@@ -0,0 +1,5 @@
+export { assertAppRegistration } from "./contracts.js";
+export type { AppHostServices, AppRegistration, AppSize, UiApp, UiRouteHost, UiRouteInput, UiRouteSurface } from "./contracts.js";
+export { UiAppHost } from "./host.js";
+export type { AppHostOptions, AppHostSurface } from "./host.js";
+export { UiAppRegistry } from "./registry.js";

package/dist/ui/apps/index.js

@@ -0,0 +1,3 @@
+export { assertAppRegistration } from "./contracts.js";
+export { UiAppHost } from "./host.js";
+export { UiAppRegistry } from "./registry.js";

package/dist/ui/apps/registry.d.ts

@@ -0,0 +1,12 @@
+import { type AppRegistration } from "./contracts.js";
+/** Registers owned applications under unique routes and unregisters only the matching definition. */
+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/ui/apps/registry.js

@@ -0,0 +1,33 @@
+import { assertAppRegistration } from "./contracts.js";
+/** Registers owned applications under unique routes and unregisters only the matching definition. */
+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/ui/components/dialog-panel.d.ts

@@ -0,0 +1,37 @@
+import { type ShortcutHintEntry } from "./shortcut-hints.js";
+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 | readonly ShortcutHintEntry[];
+}
+/** 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/ui/components/dialog-panel.js

@@ -0,0 +1,58 @@
+import { renderShortcutHints, shortcutHintsText } from "./shortcut-hints.js";
+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 contentPadding = Math.min(1, Math.max(0, width));
+    const contentWidth = Math.max(0, width - contentPadding);
+    const inset = " ".repeat(contentPadding);
+    const contentRow = (painted, raw) => `${inset}${pad(truncateToWidth(painted, contentWidth), contentWidth, raw)}`;
+    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}`;
+        // Compatibility: match pinned SettingsList: selected cursor, label, and value all use the
+        // accent role; an unselected label is plain and its value is muted.
+        const painted = selected
+            ? `${theme.fg("accent", cursor)}${theme.fg("accent", padded)}  ${theme.fg("accent", row.value)}`
+            : `${cursor}${padded}  ${theme.fg("muted", row.value)}`;
+        return contentRow(painted, raw);
+    });
+    const description = state.rows[state.index]?.description ?? "";
+    const hint = typeof state.hint === "string"
+        ? theme.fg("dim", state.hint)
+        : renderShortcutHints(state.hint, theme, 0);
+    const plainHint = typeof state.hint === "string" ? state.hint : shortcutHintsText(state.hint, 0);
+    return [
+        rule,
+        ...rows,
+        "",
+        contentRow(theme.fg("dim", `  ${description}`), `  ${description}`),
+        "",
+        contentRow(hint, plainHint),
+        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/ui/components/frame.d.ts

@@ -0,0 +1,22 @@
+export interface PaneRect {
+    readonly width: number;
+    readonly height: number;
+}
+/** Identifies the pane whose bounded frame geometry or rendered rows violated the contract. */
+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/ui/components/frame.js

@@ -0,0 +1,55 @@
+import { displayWidth, truncateToWidth } from "./text.js";
+/** Identifies the pane whose bounded frame geometry or rendered rows violated the contract. */
+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/ui/components/index.d.ts

@@ -0,0 +1,50 @@
+export { dialogRowAt, dialogValueColumn, renderDialogPanel } from "./dialog-panel.js";
+export type { DialogPanelFrame, DialogPanelState, DialogRow } from "./dialog-panel.js";
+export { FrameContractError, assertPaneRect, finalizeFrame, validateFrame } from "./frame.js";
+export type { PaneRect } from "./frame.js";
+export { humanizeLabel, humanizeTitle } from "./label.js";
+export { LineInput, caretCell, handleLineInputKey, renderInputRow, wordLeft, wordRight } from "./line-input.js";
+export type { InputRow, InputRowOptions, LineInputOutcome, LineInputView } from "./line-input.js";
+export { PROMPT_GLYPH, PROMPT_PREFIX_WIDTH, PromptInput, promptArrow, promptRule, promptRuleText } from "./prompt-input.js";
+export type { PromptInputBody, PromptInputMetrics } from "./prompt-input.js";
+export { blockJumpTarget, blockRowSpan, clampScroll, indexOfKey, layoutList, maxScrollFor, moveSelection, rowKey, scrollForSelection, selectableIndexes, stickyHeaderFor, topPaddingRows, visibleRowCount, } from "./list-block.js";
+export type { ListLayout, ListLayoutOptions, ListRow, ListRowSpan } from "./list-block.js";
+export { STEPPER_RESERVE, placementFor, regionAt, renderGroupHeader, renderListRow, renderNote, valueColumnFor } from "./list-view.js";
+export type { ListRegion, ListRowPlacement, ListRowState, ListViewRow } from "./list-view.js";
+export { MOUSE_TRACKING_OFF, MOUSE_TRACKING_ON, parseMouseInput, routeMouseInput } from "./mouse.js";
+export type { ParsedMouseInput, RoutedMouseInput } from "./mouse.js";
+export { isInsidePane, toPaneLocalMouse } from "./pane.js";
+export type { Pane, PaneInputResult, PaneMouseEvent } from "./pane.js";
+export { progressStatusFrame, progressStatusText } from "./progress-status.js";
+export type { ProgressStatusFrameStyles, ProgressStatusMarker } from "./progress-status.js";
+export { FrameCache, RENDER_REVISION_KINDS, RenderRevisionTracker, ZERO_REVISIONS, normalizeRevisions, revisionsEqual } from "./revision.js";
+export type { RenderCacheContract, RenderRevisionKind, RenderRevisions } from "./revision.js";
+export { MAX_COPY_ROWS, MAX_COPY_SOURCE_UNITS, selectionCopyLineContent, selectionCopyRowText } from "./selection-copy.js";
+export type { SelectionCopyPrompt, SelectionCopyRow, SelectionCopySnapshot } from "./selection-copy.js";
+export { ScrollbarRails, isThumbRow, scrollForThumbRow, scrollForTrackPage, scrollbarGeometry, scrollbarPresentation, scrollbarReservesSpace, scrollbarSelectionRows, scrollbarWheelRows, } from "./scrollbar.js";
+export type { RailPointer, RailPosition, ScrollbarAppearance, ScrollbarGeometry, ScrollbarInput, ScrollbarPresentation, ScrollbarPresentationInput, ScrollbarSpeed, ScrollbarStyle, } from "./scrollbar.js";
+export { renderShortcutHints } from "./shortcut-hints.js";
+export type { ShortcutHintEntry } from "./shortcut-hints.js";
+export { GLOBAL_SCOPE, ShortcutRegistry, assembleShortcuts, assertNoShortcutConflicts } from "./shortcuts.js";
+export type { ShortcutConflict, ShortcutDeclaration, ShortcutRegistryResult } from "./shortcuts.js";
+export { backgroundSgrSpan, heldNativeHyperlinkStyle, hyperlinkSgrSpan, hyperlinkTargetAtColumn, nativeHyperlinkStyle, overlaySpan } from "./spans.js";
+export { readVisibleHyperlinks } from "./visible-hyperlinks.js";
+export type { VisibleHyperlinkRange, VisibleHyperlinkRow } from "./visible-hyperlinks.js";
+export { renderStatusLine, statusText } from "./status-line.js";
+export type { StatusLineInput } from "./status-line.js";
+export { SUBMITTED_PROMPT_PREFIX_WIDTH, composeSubmittedPromptRows, formatSubmittedPromptTime, submittedPromptLayout } from "./submitted-prompt.js";
+export type { SubmittedPromptLayout, SubmittedPromptStyle } from "./submitted-prompt.js";
+export { numericValues, steppedValue, stepperEnds } from "./stepper.js";
+export type { NumericRange } from "./stepper.js";
+export { TranscriptViewport, assertTranscriptViewportFrameDescriptor } from "./transcript-viewport.js";
+export type { TranscriptPromptAnchor, TranscriptViewportConfig, TranscriptViewportFrame, TranscriptViewportFrameDescriptor, TranscriptViewportFrameInput, TranscriptViewportHitRegions, TranscriptViewportTheme, } from "./transcript-viewport.js";
+export { RAIL_COLUMNS, renderEmptyState, withScrollbarRail } from "./surface.js";
+export type { RailOptions } from "./surface.js";
+export { displayColumnSlice, displayWidth, displayWordColumnRange, faint, padToWidth, stripAnsi, truncateToWidth } from "./text.js";
+export type { DisplayColumnRange, DisplayColumnSlice } from "./text.js";
+export { TEXT_SELECTION_MULTI_CLICK_MS, extendTextSelection, orderedTextSelection, plainTextBetweenColumns, pressTextSelection, releaseTextSelection, textSelectionLineExtendColumn, textSelectionPointAt, textSelectionText, usefulTextLineContent, } from "./text-selection.js";
+export type { OrderedTextSelection, TextSelection, TextSelectionClick, TextSelectionLineContent, TextSelectionPoint, TextSelectionPressInput, } from "./text-selection.js";
+export { PLAIN_THEME } from "./theme.js";
+export type { UiTheme, UiThemeToken } from "./theme.js";
+export { menuRowAt, renderValueMenu, valueMenuFrame } from "./value-menu.js";
+export type { ValueMenuAnchor, ValueMenuFrame, ValueMenuLayout, ValueMenuState } from "./value-menu.js";

package/dist/ui/components/index.js

@@ -0,0 +1,26 @@
+export { dialogRowAt, dialogValueColumn, renderDialogPanel } from "./dialog-panel.js";
+export { FrameContractError, assertPaneRect, finalizeFrame, validateFrame } from "./frame.js";
+export { humanizeLabel, humanizeTitle } from "./label.js";
+export { LineInput, caretCell, handleLineInputKey, renderInputRow, wordLeft, wordRight } from "./line-input.js";
+export { PROMPT_GLYPH, PROMPT_PREFIX_WIDTH, PromptInput, promptArrow, promptRule, promptRuleText } from "./prompt-input.js";
+export { blockJumpTarget, blockRowSpan, clampScroll, indexOfKey, layoutList, maxScrollFor, moveSelection, rowKey, scrollForSelection, selectableIndexes, stickyHeaderFor, topPaddingRows, visibleRowCount, } from "./list-block.js";
+export { STEPPER_RESERVE, placementFor, regionAt, renderGroupHeader, renderListRow, renderNote, valueColumnFor } from "./list-view.js";
+export { MOUSE_TRACKING_OFF, MOUSE_TRACKING_ON, parseMouseInput, routeMouseInput } from "./mouse.js";
+export { isInsidePane, toPaneLocalMouse } from "./pane.js";
+export { progressStatusFrame, progressStatusText } from "./progress-status.js";
+export { FrameCache, RENDER_REVISION_KINDS, RenderRevisionTracker, ZERO_REVISIONS, normalizeRevisions, revisionsEqual } from "./revision.js";
+export { MAX_COPY_ROWS, MAX_COPY_SOURCE_UNITS, selectionCopyLineContent, selectionCopyRowText } from "./selection-copy.js";
+export { ScrollbarRails, isThumbRow, scrollForThumbRow, scrollForTrackPage, scrollbarGeometry, scrollbarPresentation, scrollbarReservesSpace, scrollbarSelectionRows, scrollbarWheelRows, } from "./scrollbar.js";
+export { renderShortcutHints } from "./shortcut-hints.js";
+export { GLOBAL_SCOPE, ShortcutRegistry, assembleShortcuts, assertNoShortcutConflicts } from "./shortcuts.js";
+export { backgroundSgrSpan, heldNativeHyperlinkStyle, hyperlinkSgrSpan, hyperlinkTargetAtColumn, nativeHyperlinkStyle, overlaySpan } from "./spans.js";
+export { readVisibleHyperlinks } from "./visible-hyperlinks.js";
+export { renderStatusLine, statusText } from "./status-line.js";
+export { SUBMITTED_PROMPT_PREFIX_WIDTH, composeSubmittedPromptRows, formatSubmittedPromptTime, submittedPromptLayout } from "./submitted-prompt.js";
+export { numericValues, steppedValue, stepperEnds } from "./stepper.js";
+export { TranscriptViewport, assertTranscriptViewportFrameDescriptor } from "./transcript-viewport.js";
+export { RAIL_COLUMNS, renderEmptyState, withScrollbarRail } from "./surface.js";
+export { displayColumnSlice, displayWidth, displayWordColumnRange, faint, padToWidth, stripAnsi, truncateToWidth } from "./text.js";
+export { TEXT_SELECTION_MULTI_CLICK_MS, extendTextSelection, orderedTextSelection, plainTextBetweenColumns, pressTextSelection, releaseTextSelection, textSelectionLineExtendColumn, textSelectionPointAt, textSelectionText, usefulTextLineContent, } from "./text-selection.js";
+export { PLAIN_THEME } from "./theme.js";
+export { menuRowAt, renderValueMenu, valueMenuFrame } from "./value-menu.js";

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

@@ -0,0 +1,68 @@
+import type { UiTheme } from "./theme.js";
+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 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;
+    readonly theme?: Pick<UiTheme, "fg">;
+}
+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;