@getorrery/cells 0.0.0-stage → 0.2.1

package/dist/cells.d.ts

@@ -0,0 +1,204 @@
+/**
+ * The terminal design, as cells — a port of the `orrery-cells` crate
+ * (`harness/clients/cells/src/lib.rs`), line for line.
+ *
+ * Every element is a pure function from a view model and a width to
+ * {@link Item}s — rows of {@link Seg}ments, each a run of text and the classes
+ * that say how it is meant. Widths are counted in code points, as the Rust
+ * counts `chars()`.
+ *
+ * Soft and hard fitting: an element is drawn in *soft* mode, where {@link fit}
+ * keeps an overflowing line whole for {@link flow} to wrap. Outside an element
+ * {@link fit} cuts with an ellipsis. {@link hfit} always cuts.
+ */
+/** One run of cells. */
+export type Seg = 
+/** Text, and the classes on it (space separated, possibly empty). */
+{
+    k: "t";
+    text: string;
+    cls: string;
+}
+/**
+ * The 2-cell mark: an animation in one of its states (decision 0043). How it
+ * is drawn (an image, pixels, a glyph) is the client's choice by what the
+ * terminal can show.
+ */
+ | {
+    k: "px";
+    anim: string;
+    state: string;
+}
+/** The 1-cell spinner, with its class. */
+ | {
+    k: "spin";
+    cls: string;
+}
+/** `w` cells the renderer fills itself (the theme preview). */
+ | {
+    k: "blank";
+    w: number;
+};
+/** A row of runs. */
+export type Line = Seg[];
+/** What fills a {@link Blk}. */
+export type Fill = 
+/** The mark, large (15 × 8 cells): an animation and a state. */
+{
+    k: "pixel";
+    anim: string;
+    state: string;
+} | {
+    k: "preview";
+    lines: Item[];
+    theme: string;
+};
+/** A fixed-width block, and the rows beside it. */
+export interface Blk {
+    w: number;
+    h: number | null;
+    fill: Fill;
+    lines: Line[];
+}
+/** What an element draws on one row. */
+export type Item = {
+    k: "line";
+    line: Line;
+} | {
+    k: "blk";
+    blk: Blk;
+} | {
+    k: "skip";
+};
+/** Code points of a string. */
+export declare function cps(s: string): string[];
+/** Cells in a string: its code points. */
+export declare function chars(s: string): number;
+/** How many cells a run takes. */
+export declare function segWidth(s: Seg): number;
+/** A line as an item. */
+export declare function lineItem(line: Line): Item;
+/** A run of text with classes. */
+export declare function t(text: string, cls: string): Seg;
+/** `n` spaces, unstyled. */
+export declare function sp(n: number): Seg;
+/** The Orrery mark in `state`: the one animation the host sends today (decision 0043). */
+export declare function px(state: string, anim?: string): Seg;
+/** The spinner, in a class (`ac` when none). */
+export declare function spin(cls: string): Seg;
+/** The glyph in colour, the `[word]` in mono (bold when an error or a warning). */
+export declare function g(m: boolean, glyph: string, word: string, cls: string): Seg;
+/** The agent-state mark: the pixel mark in colour, `[state]` in mono. */
+export declare function mark(m: boolean, state: string): Seg;
+/** Cells in a line. */
+export declare function len(l: Line): number;
+/** Run `f` in soft mode, where {@link fit} keeps a line whole for {@link flow}. */
+export declare function soft<R>(f: () => R): R;
+/** Cut a line to `w` cells, ending in `…`. */
+export declare function hfit(l: Line, w: number): Line;
+/** {@link hfit}, except in soft mode, where the line is kept for {@link flow}. */
+export declare function fit(l: Line, w: number): Line;
+/** Pad a line to `w` cells, or fit it. */
+export declare function pad(l: Line, w: number): Line;
+/** `a` on the left, `b` on the right. With `keep`, `a` is cut before `b` is dropped. */
+export declare function lr(a: Line, b: Line, w: number, keep: boolean): Line;
+/** A line centred in `w` cells. */
+export declare function center(l: Line, w: number): Line;
+/** Cut text to `n` cells from the right, ending in `…`. */
+export declare function tr(s: string, n: number): string;
+/** Cut text to `n` cells from the left, starting with `…`. */
+export declare function trL(s: string, n: number): string;
+/** Text cut and padded to exactly `n` cells, left-aligned. */
+export declare function ps(s: string, n: number): string;
+/** Text cut and padded to exactly `n` cells, right-aligned. */
+export declare function pr(s: string, n: number): string;
+/** Word-wrap text to `n` cells (at least 4), hard-breaking long words. */
+export declare function wrap(text: string, n0: number): string[];
+/** Which box-drawing set. */
+export type BoxKind = "round" | "square" | "heavy" | "double" | "dashed";
+/** How a box is drawn: its set, its colour class, and what its borders say. */
+export interface BoxOpts {
+    /** The set; round when absent. */
+    k?: BoxKind;
+    /** The border's class; `dd` when empty. */
+    c?: string;
+    /** Top-left label. */
+    t?: Line | null;
+    /** Top-right label. */
+    r?: Line | null;
+    /** Bottom-left label. */
+    bl?: Line | null;
+    /** Bottom-right label. */
+    b?: Line | null;
+}
+/** Rows in a box `w` wide; the rows are flowed to `w - 4` first. */
+export declare function boxed(inner: Line[], w: number, o?: BoxOpts): Line[];
+/** A rule `w` wide, carrying a label on the left and one on the right. */
+export declare function rule(w: number, l: Line | null | undefined, r: Line | null | undefined, c: string, ch: string): Line;
+/** {@link rule} with `─`. */
+export declare function ruleD(w: number, l: Line, r: Line | null | undefined, c: string): Line;
+/** Mark a line selected: every text run gains `sel`. */
+export declare function sel(l: Line): Line;
+/** Dim a line: every text run becomes `dd`. */
+export declare function dim(l: Line): Line;
+/** Every text run of a line in one class. */
+export declare function cls(l: Line, c: string): Line;
+/** Key hints — `enter send|esc stop` — dropping whatever does not fit in `w`. */
+export declare function keys(spec: string, w: number, lead: number): Line;
+/** Text wrapped after a lead-in; continuation rows are indented by its width, or start with `cont`. */
+export declare function para(first: Line, text: string, w: number, c: string, cont?: Seg | null): Line[];
+/** The user's prompt echoed: `> …` on a tinted band. */
+export declare function user(text: string, w: number): Line[];
+/** Model prose under a `●` gutter; with `caret`, the caret after the last character. */
+export declare function prose(text: string, w: number, dimmed: boolean, caret: boolean): Line[];
+/** A tool call's state. */
+export type ToolState = "ok" | "run" | "err" | "wait" | "deny" | "dim";
+/** A tool call's head row: `● Name args      dur`. */
+export declare function tool(name: string, args: string, w: number, m: boolean, st: ToolState, dur: string | null | undefined, selected: boolean): Line[];
+/** A tool result under `⎿` (or aligned under one, when not `first`). */
+export declare function res(text: string, w: number, c: string, first: boolean): Line[];
+/** How a turn ended. */
+export type Outcome = "done" | "interrupted" | "error";
+/** The line that closes a turn. */
+export declare function outcome(k: Outcome, detail: string, w: number, m: boolean): Line;
+/** A table column. */
+export interface Col {
+    /** Header. */
+    h: string;
+    /** Width in cells. */
+    w: number;
+    /** Right-aligned. */
+    right?: boolean;
+    /** Drop priority: the highest goes first; `0` never drops. */
+    p?: number;
+    /** Takes the slack. */
+    flex?: boolean;
+    /** Cuts from the left. */
+    trl?: boolean;
+}
+/** A table row: cells, each with an optional class. */
+export interface TRow {
+    c: [string, string | null][];
+    dis?: boolean;
+    cls?: string | null;
+}
+/** How a table is drawn. */
+export interface TableOpts {
+    /** Cells before the first column; `2` when absent. */
+    lead?: number | null;
+    noHead?: boolean;
+    /** The sorted column, and whether descending. */
+    sort?: [number, boolean] | null;
+    hfocus?: number | null;
+    sel?: number | null;
+}
+/** A table that drops columns by priority rather than wrap. */
+export declare function table(cols: Col[], rows: TRow[], w: number, o?: TableOpts): Line[];
+/** Wrap a line that overflows `w` at word boundaries; the continuation is indented under the text. */
+export declare function flow(l: Line, w: number): Line[];
+/** Flow every line of an element's rows to `w`; blocks pass through. */
+export declare function flowItems(items: Item[], w: number): Item[];
+/** Lines as items. */
+export declare function items(lines: Line[]): Item[];
+/** The text runs of a line, joined — for tests and plain output. */
+export declare function plain(l: Line): string;

package/dist/el/agent.d.ts

@@ -0,0 +1,153 @@
+/**
+ * List 2 · Agent work & control: permission mode, the plan card, pinned todos,
+ * edit approval, tool call cards, background tasks (`/tasks`), background processes, steering —
+ * port of `el/agent.rs`.
+ */
+import { type Item, type Line } from "../cells";
+import { type Block, type ToolSt } from "./block";
+import { type FooterView, type InputView } from "./chrome";
+import { type OutLine, type TaskItemV } from "./content";
+/** The mode notice over the footer, or every mode. */
+export interface ModeView {
+    /** `default` when absent. */
+    mode?: string;
+    next?: string | null;
+    /** `changed`, `all`, `error`, `locked`; `changed` when absent. */
+    state?: string;
+    note?: string | null;
+    footer: FooterView;
+}
+/** shift+tab: a one-row notice naming the mode and the next one. */
+export declare function mode(p: ModeView, w: number, m: boolean): Item[];
+/** The plan the agent proposes in plan mode. */
+export interface PlanView {
+    steps?: string[];
+    selected?: number;
+    /** `proposed`, `approving`, `stale`, `rejected`; `proposed` when absent. */
+    state?: string;
+    note?: string | null;
+}
+/** Numbered steps and a/e/r in a box titled with the step count. */
+export declare function plan(p: PlanView, w: number, m: boolean): Item[];
+/** The agent's task list, pinned in the dock slot. */
+export interface TodosView {
+    items?: TaskItemV[];
+    open?: boolean;
+    focused?: boolean;
+    working?: string | null;
+}
+/** A rule with the count; expanded, the items (two per row at ≥64 columns). */
+export declare function todos(p: TodosView, w: number, m: boolean): Item[];
+/** A proposed hunk. */
+export interface ReviewHunk {
+    header: string;
+    /** `[sign, text]` pairs. */
+    lines: [string, string][];
+    /** `pending`, `accept`, `reject`; `pending` when absent. */
+    decision?: string;
+}
+/** Proposed edits to one file, per hunk. */
+export interface EditApprovalView {
+    path: string;
+    stat?: string;
+    hunks?: ReviewHunk[];
+    /** `0` the file header, `n` the n-th hunk. */
+    focus?: number;
+    /** `review`, `applying`, `error`, `readonly`, `empty`; `review` when absent. */
+    state?: string;
+    note?: string | null;
+}
+/** A diff with accept/reject per file and per hunk. */
+export declare function editApproval(p: EditApprovalView, w: number, m: boolean): Item[];
+/** A tool call as the thread shows it. */
+export interface ToolCardView {
+    name: string;
+    args?: string;
+    state?: ToolSt;
+    dur?: string | null;
+    output?: OutLine[];
+    more?: string | null;
+    selected?: boolean;
+}
+/** The tool card: the head row, `⎿` preview, `+N lines`. */
+export declare function toolcard(p: ToolCardView, w: number, m: boolean): Item[];
+/** The class a row's `✕` carries, naming the task it stops: a zero-width run just before the `✕`. */
+export declare const STOP_MARK = "stop:";
+/** Where a row's `✕` is and the task it stops: its column and the id. */
+export declare function stopMark(l: Line): [number, string] | null;
+/** A background task: a sub-agent or a process. */
+export interface TaskRow {
+    id: string;
+    /** `agent` or `process`. */
+    kind?: string;
+    label?: string;
+    /** `running`, `done`, `stopped`, `killed`, `failed`, `exited`, `lost`. */
+    state?: string;
+    age?: string;
+    port?: number | null;
+}
+/** `/tasks`: the session's background tasks, in the dock. */
+export interface TasksView {
+    items?: TaskRow[];
+    /** The row under the cursor (the client's). */
+    cursor?: number | null;
+    selected?: number | null;
+}
+/** State, kind, label, `:port`, age and `✕` on a running row; the cursor's row selected. Empty, it says so. */
+export declare function tasks(p: TasksView, w: number, m: boolean): Item[];
+/**
+ * One item of an agent's thread in its view: its brief, a message that reached
+ * it, what it said, a tool call (one folded line, decision 0024), a message
+ * typed into the view and not yet in its thread, a note — or a line of a
+ * process's log.
+ */
+export interface ViewItem {
+    /** `brief`, `user`, `text`, `tool`, `sent`, `note`, `log`. */
+    t: string;
+    text?: string;
+    name?: string;
+    arg?: string;
+    /** A tool's state: `running`, `ok`, `failed`, `denied`, `cancelled`. */
+    state?: string;
+}
+/** An agent's view (decision 0031 §4), as the host declares it: whose thread, how it stands, and the thread itself. A process's is its log. */
+export interface AgentViewV {
+    /** `agent` or `process`. */
+    kind?: string;
+    name?: string;
+    state?: string;
+    age?: string;
+    turns?: number | null;
+    port?: number | null;
+    items?: ViewItem[];
+}
+/** The view's header, pinned over its thread: `dir-finder-1 · running · 3m · 8 turns`, the state in the switcher's colour (`done ✓`, `failed ✗`, `stopped ■` in mono; decision 0033 §2), then a rule. */
+export declare function agentViewHead(p: AgentViewV, w: number, m: boolean): Line[];
+/** The view's thread: each item as the main thread draws its kind, a blank row between kinds. A log is its lines as written. Empty, it says what it waits for. */
+export declare function agentViewBody(p: AgentViewV, w: number, m: boolean): Line[];
+/** The whole view: its header over its thread. Clients that pin the header draw `agentViewHead` and `agentViewBody` apart. */
+export declare function agentView(p: AgentViewV, w: number, m: boolean): Item[];
+/** A background process. */
+export interface ProcRow {
+    cmd: string;
+    port?: string;
+    uptime: string;
+    last?: string;
+    /** `running`, `exited`, `killed`. */
+    state: string;
+}
+/** Background shells and servers, pinned in the dock slot. */
+export interface ProcsView {
+    items?: ProcRow[];
+    selected?: number | null;
+    busy?: string | null;
+}
+/** Command, port, last line, uptime. */
+export declare function background(p: ProcsView, w: number, m: boolean): Item[];
+/** A steer, where it landed, and the input when it has focus. */
+export interface SteerView {
+    blocks?: Block[];
+    input?: InputView | null;
+}
+/** `↳ steer: …` inside the turn it changed. */
+export declare function steer(p: SteerView, w: number, m: boolean): Item[];

package/dist/el/block.d.ts

@@ -0,0 +1,66 @@
+/** Transcript blocks: the pieces a turn is made of — port of `el/block.rs`. */
+import { type Line, type ToolState } from "../cells";
+import { type FoldView } from "./chrome";
+/** How a turn ended, as the fixtures spell it (`int` and `err` are aliases). */
+export type OutcomeKind = "done" | "interrupted" | "int" | "error" | "err";
+/** A tool call's state, as the fixtures spell it. */
+export type ToolSt = ToolState;
+/** One piece of a turn, tagged by `b`. */
+export type Block = {
+    b: "user";
+    text: string;
+} | {
+    b: "prose";
+    text: string;
+    caret?: boolean;
+    dim?: boolean;
+} | {
+    b: "tool";
+    name: string;
+    args?: string;
+    st?: ToolSt;
+    dur?: string | null;
+    sel?: boolean;
+} | {
+    b: "res";
+    text: string;
+    c?: string;
+    first?: boolean;
+} | {
+    b: "outcome";
+    k: OutcomeKind;
+    detail: string;
+} | {
+    b: "note";
+    text: string;
+    c?: string;
+} | {
+    b: "empty";
+} | {
+    b: "blank";
+} | {
+    b: "keys";
+    spec: string;
+    lead?: number;
+} | ({
+    b: "fold";
+} & FoldView) | {
+    b: "steer";
+    text: string;
+    pending?: boolean;
+} | {
+    b: "done";
+    text: string;
+} | {
+    b: "queued";
+    text: string;
+} | {
+    b: "alert";
+    kind: string;
+    text: string;
+} | {
+    b: "raw";
+    runs: [string, string][];
+};
+/** Draw blocks at `w` columns. */
+export declare function blocks(bs: Block[], w: number, m: boolean): Line[];

package/dist/el/chrome.d.ts

@@ -0,0 +1,240 @@
+/**
+ * List 1 · Chrome, Tier 1: banner, thread, turn, status pin, reasoning fold,
+ * dock, consent bar, input, slash completion, queued messages, footer — port
+ * of `el/chrome.rs`.
+ */
+import { type Item, type Line } from "../cells";
+import { type Block } from "./block";
+import { type FormView } from "./content";
+/** The input's own box: `› typed▏`, accent (heavy in mono). */
+export declare function inputBox(row: Line, w: number, m: boolean): Line[];
+/** What the banner shows. */
+export interface BannerView {
+    harness: string;
+    version: string;
+    path: string;
+    branch?: string | null;
+    trusted?: unknown;
+    model?: string | null;
+    provider?: string | null;
+    /** `idle`, `loading` or `error`; `idle` when absent. */
+    state?: string;
+    error?: string | null;
+    /** The client drawing it (`ratatui`, `ink`), shown beside the version. */
+    client?: string | null;
+}
+/** The banner: the pixel logo beside the facts at ≥64 columns in colour, a box below that. */
+export declare function banner(p: BannerView, w: number, m: boolean): Item[];
+/** How the thread's viewport stands. */
+export type ThreadMode = "follow" | "scrolled" | "loading" | "empty" | "error" | "dim";
+/** The thread's viewport. */
+export interface ThreadView {
+    mode?: ThreadMode;
+    blocks?: Block[];
+    /** Rows in view; 10 when absent. */
+    height?: number;
+    top?: number;
+    track?: [number, number] | null;
+    new_count?: number;
+    error?: string | null;
+}
+/** The `── ↓ N new · end ──` row. */
+export declare function newPill(n: number, w: number): Line;
+/** The thread: a window on its rows, the last column kept for the scroll track. */
+export declare function thread(p: ThreadView, w: number, m: boolean): Item[];
+/** One turn. */
+export interface MessageView {
+    blocks: Block[];
+    selected?: boolean;
+    rewound?: boolean;
+}
+/** A turn: the prompt, what came back, the outcome. */
+export declare function message(p: MessageView, w: number, m: boolean): Item[];
+/** The agent's state, pinned to the newest turn. */
+export interface StatusView {
+    state: string;
+    title: string;
+    elapsed: string;
+    detail?: string;
+    tokens?: string | null;
+    spinner?: boolean;
+}
+/** The class of an agent state. */
+export declare function stateClass(st: string): string;
+/** Two rows: mark, title and time (tokens on the right); the detail under. */
+export declare function status(p: StatusView, w: number, m: boolean): Item[];
+/** A turn's reasoning. */
+export interface FoldView {
+    /** `streaming`, `done`, `hidden`, `redacted`, `cut`; `done` when absent. */
+    state?: string;
+    seconds?: number;
+    open?: unknown;
+    selected?: boolean;
+    text?: string;
+    rows?: number | null;
+}
+/** `✻ Thought for Ns ▸`, and the text under a `│` when open. */
+export declare function fold(p: FoldView, w: number, m: boolean): Item[];
+/** An option in the dock's list. */
+export interface DockItem {
+    label: string;
+    detail?: string;
+}
+/** What a flow is asking, above the input. */
+export interface DockView {
+    title: string;
+    step?: string | null;
+    /** `asking`, `busy`, `empty`, `error`, `locked`, `answered`; `asking` when absent. */
+    state?: string;
+    prompt?: string;
+    items?: DockItem[];
+    selected?: number;
+    busy?: string | null;
+    note?: string | null;
+    error?: string | null;
+    summary?: string | null;
+    form?: FormView | null;
+}
+/** The dock: a rule with title and step, the question, its body. */
+export declare function dock(p: DockView, w: number, m: boolean): Item[];
+/** A choice on the consent bar. */
+export interface ConsentChoice {
+    key: string;
+    label: string;
+}
+/** A permission request, minted by the host. */
+export interface ConsentView {
+    tool: string;
+    command: string;
+    detail: string;
+    choices: ConsentChoice[];
+    /** `asking`, `busy`, `blocked`, `no-allow`; `asking` when absent. */
+    state?: string;
+    selected?: number;
+    queued?: number;
+    /** Seconds left to answer, when the request has a deadline (plan 37). */
+    seconds?: number | null;
+}
+/** The consent bar: a box, the command, why, and the choices. */
+export declare function consent(p: ConsentView, w: number, m: boolean): Item[];
+/** The input box. */
+export interface InputView {
+    focus?: unknown;
+    disabled?: boolean;
+    label?: string | null;
+    text?: string | null;
+    secret?: boolean;
+    lines?: string[] | null;
+    placeholder?: string;
+    hint?: string;
+    error?: string | null;
+    chip?: string | null;
+    vim?: string | null;
+}
+/** The input: a box with its prefix, the text or placeholder, the caret, and the hint row (or the error). */
+export declare function input(p: InputView, w: number, m: boolean): Item[];
+/** {@link input} as lines. */
+export declare function inputLines(p: InputView, w: number, m: boolean): Line[];
+/** A command in the completion list. */
+export interface CmdItem {
+    name: string;
+    usage?: string;
+    desc?: string;
+    disabled?: boolean;
+    when?: string;
+    when_short?: string;
+}
+/** The completion popup above the input. */
+export interface SlashView {
+    query: string;
+    items?: CmdItem[];
+    selected?: number;
+    /** `ready`, `loading`, `error`, `shell`; `ready` when absent. */
+    state?: string;
+    error?: string | null;
+    loading?: string | null;
+    shell?: string | null;
+}
+/** The completion popup and the input under it. */
+/** How many commands the popup shows at once; the rest scroll. */
+export declare const SLASH_ROWS = 6;
+export declare function slash(p: SlashView, w: number, m: boolean): Item[];
+/** A message typed while a turn runs. */
+export interface QueueItem {
+    text: string;
+    /** `queued`, `held`, `sending`, `dropped`; `queued` when absent. */
+    state?: string;
+}
+/** The queue under the thread. */
+export interface QueueView {
+    items: QueueItem[];
+    selected?: number | null;
+    note?: string | null;
+}
+/** `⎿ queued: …`, one row each. */
+export declare function queue(p: QueueView, w: number, m: boolean): Item[];
+/** The bottom row. */
+export interface FooterView {
+    /** `default`, `accept`, `plan`, `bypass`; `default` when absent. */
+    mode?: string;
+    hints?: string;
+    tokens?: string | null;
+    cost?: string;
+    model?: string | null;
+    model_error?: unknown;
+    ctx?: number | null;
+    armed?: unknown;
+    /** Background tasks running — processes (decisions 0027, 0031). */
+    tasks?: number | null;
+    /** Agents running, attached ones included (decision 0031). */
+    agents?: number | null;
+    /** The indicator has focus (the client's): drawn inverse, or `›` in mono. */
+    indicator?: unknown;
+    /** The views the switcher offers (decisions 0031 §4, 0033 §1), from the host: `main`, the agents that run, the view on screen; empty (or main's alone) hides it. */
+    views?: string[];
+    /** The view on screen, from the host; absent is main's. */
+    view?: string | null;
+    /** How each view is doing, by name (decision 0033 §2), from the host: `running`, `done`, `failed`, `stopped`; missing is running. */
+    view_states?: Record<string, string> | null;
+    /** The switcher has focus, with its cursor on this view (the client's). */
+    switcher?: number | null;
+}
+/**
+ * How a view's state is drawn (decision 0033 §2), for the switcher and the
+ * view's header: its class and its no-colour glyph. Running is plain, done
+ * green `✓`, failed — a budget stop, a kill, a lost process — red `✗`,
+ * stopped by a person dim `■`.
+ */
+export declare function viewState(state: string): [string, string];
+/** How many characters of a view's name the switcher keeps under 64 columns (plan 34 part C). */
+export declare const SWITCHER_NARROW = 8;
+/**
+ * The view switcher (decisions 0031 §4, 0033 §2): every view in its state's
+ * colour — running plain, done green, failed red, stopped dim; in mono
+ * `name ✓`, `name ✗`, `name ■` — the one on screen selected: inverse, `›name`
+ * in mono. While it has focus the cursor is underlined, `[name]` in mono.
+ * Under 64 columns each name keeps its first 8 characters; when even that does
+ * not fit, only the cursor's (or the screen's) view is drawn, between `‹ ›`,
+ * with where it is in the list. `null` while there is one view.
+ */
+export declare function switcher(views: string[], view: string | null | undefined, states: Record<string, string> | null | undefined, cursor: number | null | undefined, w: number, m: boolean): Line | null;
+/** The zero-width run in front of the task indicator, so a client finds it for a click (decision 0031 §3). */
+export declare const INDICATOR_MARK = "open:tasks";
+/** Where the task indicator is on a row: its column and its width. */
+export declare function indicatorMark(l: Line): [number, number] | null;
+/**
+ * The task indicator (decision 0031 §1): what runs, by kind —
+ * `2 agents · 1 background task`, `2a · 1bg` under 64 columns — hidden when
+ * nothing does. Focused, it is inverse, or `›` in mono.
+ */
+export declare function indicator(agents: number | null | undefined, tasks: number | null | undefined, w: number, focused: boolean, m: boolean): Line | null;
+/** A permission mode's badge: glyph and label, class, and its mono word. */
+export declare function modeBadge(mode: string): [string, string, string];
+/** A 10-cell meter: `━` in colour, `[####......]` in mono. */
+export declare function ctxMeter(pct: number, m: boolean): Line;
+/** Rust's `f64::round`: half away from zero. */
+export declare function roundHalfAway(x: number): number;
+/** The footer rows: one at ≥64 columns, two below. */
+export declare function footerLines(p: FooterView, w: number, m: boolean): Line[];
+/** The footer. */
+export declare function footer(p: FooterView, w: number, m: boolean): Item[];