pi-chassis 0.0.0-stage → 0.7.1

package/dist/chassis/client.js

@@ -0,0 +1,271 @@
+/**
+ * Widget client: the entry point for widgets that live in other extensions or packages.
+ *
+ *     import { registerWidget } from "pi-chassis/client";
+ *
+ *     registerWidget(pi, { id: "git", render: () => ({ text: "main ●2" }) });
+ *
+ * Same spec and handle as api.ts, but it never loads the registry code: it only looks for the
+ * host on globalThis (the Symbol.for keys below), so it works whichever extension loads first
+ * and it works without chassis installed:
+ *
+ * - chassis already loaded: the widget is registered with it straight away.
+ * - chassis loads later: the widget is queued and chassis registers it when it loads.
+ * - chassis is not installed (checked at session_start, when every extension has loaded): the
+ *   widget falls back to ctx.ui.setStatus(id, "<label> <text>"), updated on `refreshMs`. Only
+ *   the one-line view is shown there: no detail lines, colours or caching.
+ *
+ * Import it as "pi-chassis/client" (the package's `exports` map), which resolves to compiled
+ * JavaScript with type declarations (dist/), so a consumer's plain Node tests and tsc need no
+ * TypeScript loader. pi itself loads this package's extensions from the .ts sources. It loads
+ * two value modules, `./brand.ts` and `./provider.ts`, and `../diff/host.ts` for the diff view API,
+ * and the rest of what it imports is types. To vendor it, copy those four files and keep the
+ * `chassis/` and `diff/` folder layout, or import it from the package instead. Any one of the
+ * three missing fails the load. Those modules import only types themselves, so they add no
+ * further files.
+ */
+import { setBrand } from "./brand.js";
+import { setProviderStatus } from "./provider.js";
+/** The registry API version this client was written for. */
+export const CLIENT_API_VERSION = 1;
+/** The tool row API version this client was written for (`toolRowsVersion` on the registry). */
+export const CLIENT_TOOL_ROWS_VERSION = 1;
+const REGISTRY = Symbol.for("pi-chassis/registry");
+const PENDING = Symbol.for("pi-chassis/pending");
+const PENDING_TOOL_ROWS = Symbol.for("pi-chassis/pendingToolRows");
+const DEFAULT_UPDATE_TIMEOUT_MS = 10_000;
+/** The host registry, if chassis has loaded and speaks an API version this client understands. */
+function findHost() {
+    const reg = globalThis[REGISTRY];
+    if (!reg?.register || typeof reg.apiVersion !== "number" || reg.apiVersion < CLIENT_API_VERSION)
+        return undefined;
+    return { register: reg.register };
+}
+function pending() {
+    const g = globalThis;
+    g[PENDING] ??= [];
+    return g[PENDING];
+}
+/** Plain-pi mode: show the widget as a setStatus() line. */
+function startFallback(spec, ctx) {
+    const timeoutMs = spec.updateTimeoutMs ?? DEFAULT_UPDATE_TIMEOUT_MS;
+    let stopped = false;
+    let inflight = false;
+    const setStatus = (text) => {
+        try {
+            ctx.ui.setStatus(spec.id, text);
+        }
+        catch {
+            // stale ctx after a session switch
+        }
+    };
+    const paint = () => {
+        if (stopped)
+            return;
+        try {
+            const view = spec.render({ theme: ctx.ui.theme, ctx, width: 80 });
+            // Without chassis there is no icon set to ask, so an icon pair gives its plain side.
+            const glyph = typeof view?.icon === "object" ? view.icon.plain : view?.icon;
+            if (!view || (!view.text && !glyph))
+                return setStatus(undefined);
+            setStatus([glyph, view.label ?? spec.title ?? spec.id, view.text].filter(Boolean).join(" "));
+        }
+        catch {
+            setStatus(`${spec.title ?? spec.id} error`);
+        }
+    };
+    const refresh = async () => {
+        if (stopped || inflight)
+            return;
+        inflight = true;
+        let timer;
+        try {
+            if (spec.update) {
+                const timeout = new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(new Error("update timed out")), timeoutMs);
+                    timer.unref?.();
+                });
+                await Promise.race([Promise.resolve(spec.update(ctx)), timeout]);
+            }
+        }
+        catch {
+            // keep showing the last state
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+            inflight = false;
+            paint();
+        }
+    };
+    void refresh();
+    const interval = spec.refreshMs ? setInterval(() => void refresh(), spec.refreshMs) : undefined;
+    interval?.unref?.();
+    return {
+        refresh: () => void refresh(),
+        stop: () => {
+            stopped = true;
+            if (interval)
+                clearInterval(interval);
+            setStatus(undefined);
+        },
+    };
+}
+/**
+ * Register (or replace) a widget with chassis if present, else show it as a plain status.
+ *
+ * Call it from the extension's default export. If you call it from inside a `session_start`
+ * handler instead (to be sure every extension has loaded), pass that handler's `ctx`: the widget
+ * missed that session's `session_start` event, and `ctx` lets chassis run its first `update` and
+ * start its timer now. A call made there when chassis is not installed shows nothing.
+ */
+export function registerWidget(pi, spec, ctx) {
+    let real;
+    let fallback;
+    let disposed = false;
+    const offs = [];
+    const unlisten = () => {
+        for (const off of offs.splice(0)) {
+            try {
+                off();
+            }
+            catch {
+                // the pi instance may already be gone
+            }
+        }
+    };
+    const listen = (off) => {
+        if (typeof off === "function")
+            offs.push(off);
+    };
+    const handle = {
+        refresh: () => (real ? real.refresh() : fallback?.refresh()),
+        dispose: () => {
+            disposed = true;
+            real?.dispose();
+            fallback?.stop();
+            fallback = undefined;
+            unlisten();
+        },
+    };
+    const host = findHost();
+    if (host) {
+        real = host.register(pi, spec, ctx);
+        return handle;
+    }
+    // Host not loaded yet (or absent). Queue for it; if it never shows up, fall back at session_start.
+    const entry = {
+        pi,
+        spec,
+        attach: (h) => {
+            real = h;
+            fallback?.stop();
+            fallback = undefined;
+            unlisten(); // the host owns the lifecycle now
+            if (disposed)
+                h.dispose();
+        },
+    };
+    pending().push(entry);
+    listen(pi.on("session_start", async (_e, ctx) => {
+        if (real || disposed)
+            return; // chassis took it
+        const list = pending();
+        const i = list.indexOf(entry);
+        if (i >= 0)
+            list.splice(i, 1);
+        fallback?.stop();
+        fallback = startFallback(spec, ctx);
+    }));
+    listen(pi.on("session_shutdown", async () => {
+        fallback?.stop();
+        fallback = undefined;
+    }));
+    return handle;
+}
+/**
+ * Draw the rows of tools that belong to your extension the way chassis draws its built-in tool rows:
+ * one line per call, an icon, a title, a short description and a right-aligned outcome, with an
+ * expanded view on ctrl+o. Keyed by tool name. Returns a function that removes the rows again.
+ *
+ *     registerToolRows({
+ *       deploy_status: {
+ *         icon: { nerd: "\u{F0AD}", plain: "#" },
+ *         title: "Deploy",
+ *         describe: (args, _cwd, theme) => theme.fg("muted", String(args.env)),
+ *         summarize: (result) => String(result.details?.state ?? "done"),
+ *       },
+ *     });
+ *
+ * It works whichever package loads first (rows registered before chassis loads are queued and taken
+ * over when it does) and does nothing when chassis is not installed: the tools keep their own rows.
+ * chassis draws the built-in tools (read, write, edit, bash, grep, find, ls) itself and ignores a spec
+ * for those names. See ToolRowSpec in api.ts for what a spec may return.
+ *
+ * Pass `{ id }` if this can run more than once in a process (on every session_start, or after
+ * /reload): registering again with the same id replaces the earlier rows instead of adding more.
+ * Without an id, call the returned function (on session_shutdown, say) before registering again.
+ */
+export function registerToolRows(specs, options) {
+    let undo;
+    let removed = false;
+    const reg = globalThis[REGISTRY];
+    if (typeof reg?.registerToolRows === "function" && typeof reg.toolRowsVersion === "number" && reg.toolRowsVersion >= CLIENT_TOOL_ROWS_VERSION) {
+        undo = reg.registerToolRows(specs, options);
+    }
+    else {
+        const g = globalThis;
+        const entry = {
+            specs,
+            id: options?.id,
+            attach: (unregister) => {
+                undo = unregister;
+                if (removed)
+                    unregister();
+            },
+        };
+        (g[PENDING_TOOL_ROWS] ??= []).push(entry);
+        undo = () => {
+            const list = g[PENDING_TOOL_ROWS];
+            const i = list ? list.indexOf(entry) : -1;
+            if (i >= 0)
+                list.splice(i, 1);
+        };
+    }
+    return () => {
+        if (removed)
+            return;
+        removed = true;
+        undo?.();
+    };
+}
+/**
+ * Layer a brand (name, glyph, tagline, startup art, colours) on top of chassis. Call it from an
+ * extension's default export; it works whichever package loads first, and chassis repaints. The
+ * returned function restores the previous brand. See brand.ts for the fields.
+ */
+export function registerBrand(spec) {
+    const undo = setBrand(spec);
+    requestRender();
+    return () => {
+        undo();
+        requestRender();
+    };
+}
+/**
+ * Add a provider's own facts (a plan or quota bar, a display name, a glyph colour) to the sidebar's
+ * provider section and the footer. See provider.ts. The returned function removes it.
+ */
+export function registerProviderStatus(spec) {
+    const undo = setProviderStatus(spec);
+    requestRender();
+    return () => {
+        undo();
+        requestRender();
+    };
+}
+/** Ask chassis to repaint now (no-op when it isn't loaded). For state a widget changes outside `update`. */
+export function requestRender() {
+    globalThis[REGISTRY]?.requestRender?.();
+}
+export { addDiffAction, openChanges, openDiff } from "../diff/host.js";

package/dist/chassis/commands.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Ctrl+X leader actions and the Ctrl+P command palette (OpenCode keybinds).
+ *
+ * Leader (ctrl+x, then):
+ *   n new session      l sessions (resume)   r resume last    m model
+ *   t theme            b toggle sidebar      d diff view      a toggle Build/Plan
+ *   c compact          x export              g tree           y copy last msg
+ *   s status (/session)  h hotkeys           q quit           ? leader help
+ *
+ * Built-in pi commands (/new, /model, ...) are only reachable by submitting them through the
+ * editor, so leader actions that map to a slash command call the editor's onSubmit, which is
+ * pi's own command dispatcher.
+ */
+import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { type Component, type Focusable } from "@earendil-works/pi-tui";
+export interface LeaderAction {
+    key: string;
+    label: string;
+    /** Slash command submitted through pi's dispatcher, or a function. */
+    run: string | (() => void);
+}
+export declare function leaderActions(hooks: {
+    toggleSidebar: () => void;
+    cycleMode: () => void;
+    showHelp: () => void;
+}): LeaderAction[];
+export interface PaletteItem {
+    value: string;
+    label: string;
+    description?: string;
+    /** Right-aligned hint, e.g. the key binding. */
+    hint?: string;
+}
+/** All slash commands for the palette: built-ins, extension commands, prompts, skills. */
+export declare function paletteItems(pi: ExtensionAPI, builtins: ReadonlyArray<{
+    name: string;
+    description?: string;
+}>, leader: LeaderAction[], widgetItems?: PaletteItem[]): PaletteItem[];
+/** Fuzzy-ish match: every query character in order, scored by compactness and prefix. */
+export declare function fuzzyScore(query: string, text: string): number | undefined;
+export declare function filterPalette(items: PaletteItem[], query: string): PaletteItem[];
+/** Centered command palette: a search input over a filtered list. */
+export declare class CommandPalette implements Component, Focusable {
+    focused: boolean;
+    private readonly input;
+    private readonly items;
+    private readonly theme;
+    private readonly done;
+    private readonly maxVisible;
+    private list;
+    private filtered;
+    constructor(items: PaletteItem[], theme: Theme, done: (value: string | undefined) => void, maxVisible?: number);
+    private makeList;
+    invalidate(): void;
+    handleInput(data: string): void;
+    render(width: number): string[];
+}
+/** Leader help overlay contents. */
+export declare function leaderHelpLines(actions: LeaderAction[], theme: Theme): string[];
+export declare function runPaletteValue(value: string, ctx: ExtensionContext, actions: LeaderAction[], submit: (text: string) => void): void;

package/dist/chassis/commands.js

@@ -0,0 +1,211 @@
+/**
+ * Ctrl+X leader actions and the Ctrl+P command palette (OpenCode keybinds).
+ *
+ * Leader (ctrl+x, then):
+ *   n new session      l sessions (resume)   r resume last    m model
+ *   t theme            b toggle sidebar      d diff view      a toggle Build/Plan
+ *   c compact          x export              g tree           y copy last msg
+ *   s status (/session)  h hotkeys           q quit           ? leader help
+ *
+ * Built-in pi commands (/new, /model, ...) are only reachable by submitting them through the
+ * editor, so leader actions that map to a slash command call the editor's onSubmit, which is
+ * pi's own command dispatcher.
+ */
+import { Input, matchesKey, SelectList, truncateToWidth, visibleWidth, } from "@earendil-works/pi-tui";
+import { parseWidgetActionValue, runWidgetAction } from "./api.js";
+import { getBrand } from "./brand.js";
+import { safeGlyph } from "./icons.js";
+import { fit, primary } from "./palette.js";
+export function leaderActions(hooks) {
+    return [
+        { key: "n", label: "New session", run: "/new" },
+        { key: "l", label: "Sessions", run: "/resume" },
+        { key: "r", label: "Resume last session", run: "/chassis-resume-last" },
+        { key: "m", label: "Models", run: "/model" },
+        { key: "t", label: "Themes", run: "/settings" },
+        { key: "b", label: "Toggle sidebar", run: hooks.toggleSidebar },
+        { key: "d", label: "Diff view", run: "/diff" },
+        { key: "a", label: "Switch Build/Plan", run: hooks.cycleMode },
+        { key: "c", label: "Compact session", run: "/compact" },
+        { key: "x", label: "Export session", run: "/export" },
+        { key: "g", label: "Session tree", run: "/tree" },
+        { key: "y", label: "Copy last message", run: "/copy" },
+        { key: "s", label: "Session status", run: "/session" },
+        { key: "h", label: "Hotkeys", run: "/hotkeys" },
+        { key: "q", label: "Quit", run: "/quit" },
+        { key: "?", label: "Leader help", run: hooks.showHelp },
+    ];
+}
+/** All slash commands for the palette: built-ins, extension commands, prompts, skills. */
+export function paletteItems(pi, builtins, leader, widgetItems = []) {
+    const byName = new Map();
+    const leaderHint = new Map();
+    for (const a of leader)
+        if (typeof a.run === "string")
+            leaderHint.set(a.run.slice(1), `ctrl+x ${a.key}`);
+    for (const c of builtins)
+        byName.set(c.name, { value: `/${c.name}`, label: `/${c.name}`, description: c.description, hint: leaderHint.get(c.name) });
+    for (const c of pi.getCommands()) {
+        if (!c.name || byName.has(c.name))
+            continue;
+        byName.set(c.name, { value: `/${c.name}`, label: `/${c.name}`, description: c.description });
+    }
+    const items = [...byName.values()];
+    // Non-slash actions (sidebar, mode) go first so they're easy to find.
+    const actions = leader
+        .filter((a) => typeof a.run === "function")
+        .map((a) => ({ value: `leader:${a.key}`, label: a.label, hint: `ctrl+x ${a.key}` }));
+    return [...actions, ...widgetItems, ...items.sort((a, b) => a.label.localeCompare(b.label))];
+}
+/** Fuzzy-ish match: every query character in order, scored by compactness and prefix. */
+export function fuzzyScore(query, text) {
+    const q = query.toLowerCase();
+    const t = text.toLowerCase();
+    if (!q)
+        return 0;
+    const idx = t.indexOf(q);
+    if (idx >= 0)
+        return idx === 0 || t[idx - 1] === "/" ? 0 : 1 + idx / 100;
+    let ti = 0;
+    let first = -1;
+    let last = -1;
+    for (const ch of q) {
+        const found = t.indexOf(ch, ti);
+        if (found < 0)
+            return undefined;
+        if (first < 0)
+            first = found;
+        last = found;
+        ti = found + 1;
+    }
+    return 10 + (last - first) / 10;
+}
+export function filterPalette(items, query) {
+    if (!query.trim())
+        return items;
+    return items
+        .map((item) => {
+        const s1 = fuzzyScore(query, item.label);
+        // Descriptions only match as a contiguous substring; subsequence matches there are noise.
+        const s2 = item.description?.toLowerCase().includes(query.toLowerCase()) ? 0 : undefined;
+        const score = s1 ?? (s2 !== undefined ? s2 + 20 : undefined);
+        return score === undefined ? undefined : { item, score };
+    })
+        .filter((x) => x !== undefined)
+        .sort((a, b) => a.score - b.score || a.item.label.localeCompare(b.item.label))
+        .map((x) => x.item);
+}
+/** Centered command palette: a search input over a filtered list. */
+export class CommandPalette {
+    focused = false;
+    input = new Input({ placeholder: "Search commands" });
+    items;
+    theme;
+    done;
+    maxVisible;
+    list;
+    filtered;
+    constructor(items, theme, done, maxVisible = 12) {
+        this.items = items;
+        this.theme = theme;
+        this.done = done;
+        this.maxVisible = maxVisible;
+        this.filtered = items;
+        this.list = this.makeList(items);
+    }
+    makeList(items) {
+        const t = this.theme;
+        const selectItems = items.map((i) => ({
+            value: i.value,
+            label: i.hint ? `${i.label}  ${t.fg("dim", i.hint)}` : i.label,
+            description: i.description,
+        }));
+        const list = new SelectList(selectItems, this.maxVisible, {
+            selectedPrefix: (s) => primary(t, s),
+            selectedText: (s) => t.bold(t.fg("text", s)),
+            description: (s) => t.fg("muted", s),
+            scrollInfo: (s) => t.fg("dim", s),
+            noMatch: (s) => t.fg("dim", s),
+        });
+        list.onSelect = (item) => this.done(item.value);
+        list.onCancel = () => this.done(undefined);
+        return list;
+    }
+    invalidate() {
+        this.list.invalidate();
+    }
+    handleInput(data) {
+        if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+            this.done(undefined);
+            return;
+        }
+        if (matchesKey(data, "up") || matchesKey(data, "down") || matchesKey(data, "pageUp") || matchesKey(data, "pageDown") || matchesKey(data, "enter")) {
+            if (matchesKey(data, "enter") && this.filtered.length === 0)
+                return;
+            this.list.handleInput(data);
+            return;
+        }
+        const before = this.input.getValue();
+        this.input.handleInput(data);
+        const after = this.input.getValue();
+        if (after !== before) {
+            this.filtered = filterPalette(this.items, after);
+            this.list = this.makeList(this.filtered);
+        }
+    }
+    render(width) {
+        const t = this.theme;
+        const inner = Math.max(10, width - 4);
+        this.input.focused = this.focused;
+        const border = (s) => t.fg("borderMuted", s);
+        const lines = [];
+        const title = `${primary(t, safeGlyph(getBrand().glyph))} ${t.bold("Commands")}`;
+        const esc = t.fg("dim", "esc");
+        lines.push(border("╭") + border("─".repeat(width - 2)) + border("╮"));
+        const head = `${title}${" ".repeat(Math.max(1, inner - visibleWidth(title) - visibleWidth(esc)))}${esc}`;
+        lines.push(`${border("│")} ${fit(head, inner)} ${border("│")}`);
+        for (const l of this.input.render(inner))
+            lines.push(`${border("│")} ${fit(l, inner)} ${border("│")}`);
+        lines.push(`${border("│")} ${fit("", inner)} ${border("│")}`);
+        const body = this.filtered.length ? this.list.render(inner) : [t.fg("dim", "No matching commands")];
+        for (const l of body)
+            lines.push(`${border("│")} ${fit(l, inner)} ${border("│")}`);
+        lines.push(border("╰") + border("─".repeat(width - 2)) + border("╯"));
+        return lines.map((l) => truncateToWidth(l, width, ""));
+    }
+}
+/** Leader help overlay contents. */
+export function leaderHelpLines(actions, theme) {
+    return [
+        theme.bold("ctrl+x then…"),
+        "",
+        ...actions.map((a) => `  ${primary(theme, a.key.padEnd(2))} ${a.label}${typeof a.run === "string" ? theme.fg("dim", `  ${a.run}`) : ""}`),
+        "",
+        theme.fg("dim", "tab on an empty prompt: switch Build/Plan"),
+        theme.fg("dim", "shift+tab: cycle thinking level"),
+        theme.fg("dim", "ctrl+p: command palette"),
+    ];
+}
+export function runPaletteValue(value, ctx, actions, submit) {
+    const widgetAction = parseWidgetActionValue(value);
+    if (widgetAction) {
+        void runWidgetAction(widgetAction.widgetId, widgetAction.actionId, ctx).then((err) => {
+            if (err)
+                ctx.ui.notify(err, "warning");
+        });
+        return;
+    }
+    if (value.startsWith("leader:")) {
+        const a = actions.find((x) => `leader:${x.key}` === value);
+        if (a && typeof a.run === "function")
+            a.run();
+        return;
+    }
+    // Commands that take arguments go to the editor so the user can finish them.
+    const needsArgs = /^\/(name|login|thinking|bug|import)$/.test(value);
+    if (needsArgs) {
+        ctx.ui.setEditorText(`${value} `);
+        return;
+    }
+    submit(value);
+}

package/dist/chassis/editor.d.ts

@@ -0,0 +1,70 @@
+/**
+ * OpenCode-style prompt editor.
+ *
+ *   ┃ ask anything…
+ *   ┃
+ *   ┃ 󰚩 BUILD   Opus 5.5  Anthropic  medium
+ *                      tab mode · ctrl+p commands · ctrl+x leader
+ *
+ * A shaded panel with a heavy left rail in the mode colour (the brand primary for build,
+ * the brand plan colour for plan) and the mode pill and model inside, like OpenCode's prompt; key hints sit under it.
+ * pi's working status (spinner, retry countdown, compaction) is shown in the footer instead.
+ *
+ * Keys handled here before pi sees them:
+ *   - Tab on an empty prompt (and no autocomplete open): switch Build/Plan mode. Shift+Tab is left to
+ *     pi, which cycles the thinking level with it.
+ *   - Ctrl+X: leader key; the next key runs a leader action (see commands.ts)
+ *   - Ctrl+P: command palette. pi binds ctrl+p to model cycling, a reserved action that
+ *     registerShortcut() can't take over, so the editor intercepts it (model cycling stays on
+ *     ctrl+x m / ctrl+l).
+ * Everything else goes to pi's CustomEditor, so app keybindings keep working.
+ */
+import { CustomEditor, type KeybindingsManager, type Theme } from "@earendil-works/pi-coding-agent";
+import { type EditorTheme, type TUI } from "@earendil-works/pi-tui";
+import { type ModelParts } from "./prompt-row.ts";
+import type { UiState } from "./state.ts";
+export interface EditorHooks {
+    state: UiState;
+    theme: () => Theme;
+    /** The model, provider and thinking level for the bottom row. */
+    modelParts: () => ModelParts;
+    /** Muted hint shown after the cursor while the prompt is empty (home screen). */
+    placeholder?: () => string | undefined;
+    /** Left side of the key-hint row under the box (home screen brand line). */
+    hintLeft?: () => string | undefined;
+    /** Blink the cursor (home screen only). */
+    blink?: () => boolean;
+    onModeCycle: () => void;
+    /** Called for the key after the leader. Return true if it was a leader action. */
+    onLeaderKey: (data: string) => boolean;
+    /** Leader key pressed (show a hint) or cleared. */
+    onLeaderState: (pending: boolean) => void;
+    /** Ctrl+P: open the command palette. */
+    onPalette: () => void;
+    /** The working/retry indicator changed (footer repaint). */
+    onStatusChange?: () => void;
+    leaderTimeoutMs: number;
+}
+export declare class PromptEditor extends CustomEditor {
+    private leaderPending;
+    private leaderTimer;
+    private readonly hooks;
+    constructor(tui: TUI, editorTheme: EditorTheme, keybindings: KeybindingsManager, hooks: EditorHooks);
+    setPaddingX(_padding: number): void;
+    /**
+     * pi passes its working/retry/compaction indicator here (embedWorkingStatus). Keep it in shared
+     * state for the footer instead of drawing it in the editor's top border.
+     */
+    setWorkingStatusIndicator(indicator: Parameters<CustomEditor["setWorkingStatusIndicator"]>[0]): void;
+    private clearLeader;
+    /** Cursor blink: off phase hides the editor's reverse-video cursor; a keypress resets it. */
+    private blinkOff;
+    private blinkTimer;
+    private static readonly BLINK_MS;
+    private syncBlink;
+    private stopBlink;
+    dispose(): void;
+    handleInput(data: string): void;
+    private modeColor;
+    render(width: number): string[];
+}