@xingjisoft/neutrino 0.6.0 → 0.7.0

package/dist/screens/plugins.js

@@ -0,0 +1,196 @@
+import { Screen } from "../terminal/screen.js";
+import { C } from "../colors.js";
+import { drawHeader } from "../header.js";
+import { drawHint } from "../ui.js";
+import { configurePlugin, installPlugin, listPlugins, removePlugin, rollbackPlugin, selectProvider } from "../plugins/manager.js";
+import { invalidateTuiPlugins, terminalUI } from "../plugins/terminal.js";
+import { sanitizeText } from "../sanitize.js";
+export class PluginViewScreen extends Screen {
+    item;
+    offset = 0;
+    constructor(item) {
+        super();
+        this.item = item;
+    }
+    onKey(key) { if (key.name === "escape" || key.name === "backspace") {
+        this.app.popScreen();
+        return;
+    } if (key.name === "down" || key.name === "pagedown")
+        this.offset++; if (key.name === "up" || key.name === "pageup")
+        this.offset = Math.max(0, this.offset - 1); this.app.render(); }
+    onMouse(ev) { if (ev.type === "click" && ev.button === 2)
+        this.app.popScreen(); }
+    render(buf) { drawHeader(buf, this.app.state); buf.writeText(2, 3, this.item.title, { fg: C.accent, bold: true }); const text = sanitizeText(this.item.text ?? "This view is available in the browser. / 此视图可在浏览器中打开。"); text.split("\n").slice(this.offset, this.offset + Math.max(1, buf.height - 8)).forEach((line, i) => buf.writeText(2, 5 + i, line.slice(0, Math.max(1, buf.width - 4)), { fg: C.white })); drawHint(buf, buf.height - 2, "Esc back · ↑/↓ scroll"); }
+}
+export class PluginsScreen extends Screen {
+    profile = "standard";
+    plugins = [];
+    index = 0;
+    detail = false;
+    editing = null;
+    draft = "";
+    message = "";
+    trustPending = false;
+    onActivate() { this.refresh(); }
+    refresh() { try {
+        this.plugins = listPlugins(this.profile).plugins;
+        this.index = Math.min(this.index, Math.max(0, this.plugins.length - 1));
+        invalidateTuiPlugins();
+    }
+    catch (e) {
+        this.message = e.message;
+    } }
+    action(run) { try {
+        run();
+        this.message = "Saved / 已保存";
+        this.refresh();
+    }
+    catch (e) {
+        this.message = e.message;
+    } this.app.render(); }
+    onKey(key) {
+        if (this.editing) {
+            if (key.name === "escape") {
+                this.editing = null;
+                this.app.render();
+                return;
+            }
+            if (key.name === "return") {
+                const type = this.editing;
+                this.editing = null;
+                this.action(() => { if (type === "install")
+                    installPlugin(this.draft);
+                else
+                    configurePlugin(this.plugins[this.index].manifest.id, { config: JSON.parse(this.draft) }, this.profile); });
+                return;
+            }
+            if (key.name === "backspace")
+                this.draft = this.draft.slice(0, -1);
+            else if (!key.ctrl && !key.meta && key.name.length === 1)
+                this.draft += key.name;
+            this.app.render();
+            return;
+        }
+        if (key.name === "escape" || key.name === "backspace") {
+            if (this.detail) {
+                this.detail = false;
+                this.trustPending = false;
+                this.app.render();
+            }
+            else
+                this.app.popScreen();
+            return;
+        }
+        if (key.name === "tab") {
+            this.profile = this.profile === "standard" ? "pro" : "standard";
+            this.refresh();
+            this.app.render();
+            return;
+        }
+        if (key.name === "up") {
+            this.index = Math.max(0, this.index - 1);
+            this.app.render();
+            return;
+        }
+        if (key.name === "down") {
+            this.index = Math.min(this.plugins.length - 1, this.index + 1);
+            this.app.render();
+            return;
+        }
+        if (key.name === "i") {
+            this.editing = "install";
+            this.draft = "";
+            this.app.render();
+            return;
+        }
+        if (key.name === "m") {
+            const items = terminalUI().filter(u => ["app.menu", "workspace.tabs", "settings.sections"].includes(u.slot));
+            if (items.length)
+                this.app.pushScreen(new PluginViewScreen({ ...items[0], text: items.map(i => `${i.title}\n${i.text ?? ""}`).join("\n\n") }));
+            return;
+        }
+        const p = this.plugins[this.index];
+        if (!p)
+            return;
+        if (key.name === "return") {
+            this.detail = !this.detail;
+            this.app.render();
+            return;
+        }
+        if (key.name === "e") {
+            if (!p.enabled && p.manifest.runtime === "native" && p.manifest.entries?.agent) {
+                this.trustPending = true;
+                this.message = "Native plugin can execute unrestricted local code. Press Y to trust this exact revision, Esc to cancel.";
+                this.app.render();
+                return;
+            }
+            this.action(() => configurePlugin(p.manifest.id, { enabled: !p.enabled }, this.profile));
+            return;
+        }
+        if (key.name === "y" && this.trustPending) {
+            this.trustPending = false;
+            this.action(() => configurePlugin(p.manifest.id, { enabled: true, trustNative: true }, this.profile));
+            return;
+        }
+        if (key.name === "c") {
+            this.editing = "config";
+            this.draft = JSON.stringify(p.config);
+            this.app.render();
+            return;
+        }
+        if (key.name === "u") {
+            this.action(() => { installPlugin(p.source); });
+            return;
+        }
+        if (key.name === "r") {
+            this.action(() => rollbackPlugin(p.manifest.id));
+            return;
+        }
+        if (key.name === "d") {
+            this.action(() => removePlugin(p.manifest.id));
+            return;
+        }
+        if (key.name === "v") {
+            const replacements = (p.manifest.contributes?.ui ?? []).filter(u => ["chat.composer", "chat.message.renderer", "chat.card.plan", "chat.card.tool"].includes(u.slot));
+            this.action(() => { for (const u of replacements)
+                selectProvider(u.slot, `${p.manifest.id}/${u.id}`, this.profile); for (const prompt of p.manifest.contributes?.prompts ?? [])
+                if (prompt.replace)
+                    selectProvider("persona", `${p.manifest.id}/${prompt.id}`, this.profile); });
+        }
+    }
+    onPaste(text) { if (this.editing) {
+        this.draft += text;
+        this.app.render();
+    } }
+    onMouse(ev) { if (ev.type === "click" && ev.button === 2)
+        this.app.popScreen();
+    else if (ev.type === "click" && ev.button === 0 && ev.y >= 5) {
+        this.index = Math.min(this.plugins.length - 1, Math.max(0, ev.y - 5));
+        this.app.render();
+    } }
+    render(buf) {
+        drawHeader(buf, this.app.state);
+        buf.writeText(2, 2, `Plugins / 插件 · ${this.profile}`, { fg: C.accent, bold: true });
+        let y = 4;
+        if (this.editing) {
+            buf.writeText(2, y++, this.editing === "install" ? "Local plugin directory / 本机插件目录" : "Configuration JSON / 配置 JSON", { fg: C.white });
+            buf.writeText(2, y++, this.draft.slice(-Math.max(1, buf.width - 5)), { fg: C.accent });
+        }
+        else if (this.detail && this.plugins[this.index]) {
+            const p = this.plugins[this.index];
+            const lines = [p.manifest.name, `${p.manifest.id} @ ${p.manifest.version}`, p.manifest.description ?? "", `Runtime: ${p.manifest.runtime ?? "sandbox"}`, `Permissions: ${(p.manifest.permissions ?? []).join(", ")}`, `Source: ${p.source}`, `Integrity: ${p.integrity}`, p.error ?? "", JSON.stringify(p.config)];
+            for (const line of lines)
+                buf.writeText(2, y++, sanitizeText(line, { singleLine: true }).slice(0, buf.width - 4), { fg: C.white });
+        }
+        else {
+            if (!this.plugins.length)
+                buf.writeText(2, 5, "No plugins. Press I to install a local directory. / 按 I 安装本机插件。", { fg: C.dim });
+            const start = Math.max(0, this.index - Math.max(1, buf.height - 12) + 1);
+            this.plugins.slice(start, start + Math.max(1, buf.height - 12)).forEach((p, i) => buf.writeText(2, 5 + i, `${i + start === this.index ? "›" : " "} ${p.enabled ? "●" : "○"} ${p.manifest.name}  ${p.manifest.version}${p.error ? " !" : ""}`.slice(0, buf.width - 4), { fg: i + start === this.index ? C.accent : C.white, bold: i + start === this.index }));
+        }
+        if (this.message)
+            buf.writeText(2, buf.height - 4, sanitizeText(this.message, { singleLine: true }).slice(0, buf.width - 4), { fg: C.amber });
+        drawHint(buf, buf.height - 3, "↑/↓ select · Enter details · E enable/disable · I install · C config · U update");
+        drawHint(buf, buf.height - 2, "R rollback · D remove · V select providers · M extensions · Tab profile · Esc back");
+    }
+}

package/dist/screens/settings.d.ts

@@ -0,0 +1,42 @@
+import type { Buffer } from "../terminal/buffer.js";
+import { Screen } from "../terminal/screen.js";
+import type { Key, MouseEvent } from "../terminal/input.js";
+export declare class SettingsScreen extends Screen {
+    private intensityIdx;
+    /** Levels the current chat model accepts, in canonical order. */
+    private intensityLevels;
+    private contextTokens;
+    private contextChanged;
+    /** 0 = same model as the chat, otherwise index + 1 into `models`. */
+    private approvalModelIdx;
+    /** 0 = off (human only), 1 = on (two independent assessments). */
+    private extremeIdx;
+    /** 0 = silent, 1 = audible cue on turn end and on approval requests. */
+    private soundIdx;
+    /** 0 = web UI off, 1 = mounted alongside the terminal. */
+    private webIdx;
+    /** 0 = terminal only, 1 = the Web console is run by a detached service. */
+    private backgroundIdx;
+    /** Only a row the user actually touched rewrites the saved default. */
+    private webChanged;
+    private backgroundPending;
+    private models;
+    private rowIdx;
+    private lastHoverX;
+    private lastHoverY;
+    private editingPassword;
+    private passwordDraft;
+    private passwordMessage;
+    onActivate(): void;
+    /** Change the value of a row by `delta` steps and persist it immediately. */
+    private cycle;
+    private applyBackground;
+    onKey(key: Key): void;
+    onMouse(ev: MouseEvent): void;
+    onPaste(text: string): void;
+    onDeactivate(): void;
+    private rowTexts;
+    private layout;
+    private save;
+    render(buf: Buffer): void;
+}

package/dist/screens/start.d.ts

@@ -0,0 +1,43 @@
+import type { Buffer } from "../terminal/buffer.js";
+import { Screen } from "../terminal/screen.js";
+import type { Key, MouseEvent } from "../terminal/input.js";
+export declare class StartScreen extends Screen {
+    private extensions;
+    private get tabs();
+    private get focusCount();
+    onActivate(): void;
+    private get approvalMode();
+    private toggleApproval;
+    private logoLines;
+    private inputValue;
+    private cursor;
+    private focusIdx;
+    private hoverIdx;
+    private proHover;
+    private webHover;
+    private lastHoverX;
+    private lastHoverY;
+    showsCursor(): boolean;
+    onPaste(text: string): void;
+    onKey(key: Key): void;
+    onMouse(ev: MouseEvent): void;
+    /**
+     * The message box, the tabs below it and the hint row are persistent chrome;
+     * repainting them every frame keeps them self-healing against terminal-side
+     * drift (see Screen.alwaysRepaintRows).
+     */
+    alwaysRepaintRows(): number[];
+    private layout;
+    /**
+     * First content row. The centered block normally floats in the middle, but
+     * it must start below the top-left buttons when they are visible: the boxes
+     * are opaque chrome and would otherwise clip the top of the logo.
+     */
+    private contentTop;
+    private move;
+    /** Move the text cursor by one character, staying within bounds and on
+     *  surrogate-pair boundaries. */
+    private moveCursor;
+    private enterTab;
+    render(buf: Buffer): void;
+}

package/dist/screens/start.js

@@ -1,17 +1,21 @@
+import { terminalUI } from "../plugins/terminal.js";
 import { Screen } from "../terminal/screen.js";
 import { C } from "../colors.js";
 import { loadLogo, loadVersion, loadConfig, saveConfig, normalizeApprovalMode } from "../config.js";
 import { drawHeader } from "../header.js";
 import { centerVertically, computeInputWindow, cursorFromColumn, drawHint, drawInputBox, drawTabButton, inRect, approvalToggle, drawApprovalToggle, drawHeaderButton, proModeButton, webModeButton, } from "../ui.js";
-const TABS = ["Model", "History", "Settings"];
+const TABS = ["Model", "History", "Settings", "Plugins"];
 const LOGO = loadLogo();
-const FOCUS_COUNT = TABS.length + 2; // input box + 3 tabs + approval mode
 const INPUT_H = 3;
 const TAB_H = 3;
 function isLowSurrogate(code) {
     return code >= 0xdc00 && code <= 0xdfff;
 }
 export class StartScreen extends Screen {
+    extensions = [];
+    get tabs() { return [...TABS, ...this.extensions.slice(0, Math.max(0, Math.floor(((this.app?.width ?? 80) - 2) / 10) - TABS.length)).map(item => item.title)]; }
+    get focusCount() { return this.tabs.length + 2; }
+    onActivate() { this.extensions = terminalUI().filter(item => item.slot === "app.menu" || item.slot === "workspace.tabs"); }
     get approvalMode() {
         return normalizeApprovalMode(loadConfig().approval_mode);
     }
@@ -81,7 +85,7 @@ export class StartScreen extends Screen {
                 if (text)
                     this.app.startNewChat(text);
             }
-            else if (this.focusIdx === FOCUS_COUNT - 1) {
+            else if (this.focusIdx === this.focusCount - 1) {
                 this.toggleApproval();
             }
             else {
@@ -149,7 +153,7 @@ export class StartScreen extends Screen {
             // must not light up.
             if (!proHover && !webHover) {
                 if (inRect(ev.x, ev.y, approvalToggle(this.app.width, this.app.height - 4, this.approvalMode))) {
-                    hover = FOCUS_COUNT - 1;
+                    hover = this.focusCount - 1;
                 }
                 else if (layout && inRect(ev.x, ev.y, { x: layout.inputX, y: layout.inputY, w: layout.inputW, h: INPUT_H })) {
                     hover = 0;
@@ -191,7 +195,7 @@ export class StartScreen extends Screen {
                 return;
             }
             if (ev.y >= 1 && inRect(ev.x, ev.y, approvalToggle(this.app.width, this.app.height - 4, this.approvalMode))) {
-                this.focusIdx = FOCUS_COUNT - 1;
+                this.focusIdx = this.focusCount - 1;
                 this.toggleApproval();
                 return;
             }
@@ -256,12 +260,12 @@ export class StartScreen extends Screen {
         const inputY = this.contentTop(h, contentH) + logoLines.length + logoGap;
         const tabY = inputY + INPUT_H + gap;
         const tabGap = 2;
-        const tabInner = inputW - tabGap * (TABS.length - 1);
-        const baseW = Math.floor(tabInner / TABS.length);
-        const extra = tabInner - baseW * TABS.length;
+        const tabInner = inputW - tabGap * (this.tabs.length - 1);
+        const baseW = Math.floor(tabInner / this.tabs.length);
+        const extra = tabInner - baseW * this.tabs.length;
         const tabs = [];
         let tx = inputX;
-        for (let i = 0; i < TABS.length; i++) {
+        for (let i = 0; i < this.tabs.length; i++) {
             const tw = baseW + (i < extra ? 1 : 0);
             tabs.push({ x: tx, w: tw });
             tx += tw + tabGap;
@@ -279,7 +283,7 @@ export class StartScreen extends Screen {
         return pro ? Math.max(top, pro.y + pro.h) : top;
     }
     move(delta) {
-        this.focusIdx = (this.focusIdx + delta + FOCUS_COUNT) % FOCUS_COUNT;
+        this.focusIdx = (this.focusIdx + delta + this.focusCount) % this.focusCount;
         this.hoverIdx = -1;
         this.app.render();
     }
@@ -306,8 +310,12 @@ export class StartScreen extends Screen {
             this.app.openModelConfig();
         else if (this.focusIdx === 2)
             this.app.openHistory();
-        else
+        else if (this.focusIdx === 3)
             this.app.openSettings();
+        else if (this.focusIdx === 4)
+            this.app.openPlugins();
+        else if (this.extensions[this.focusIdx - 5])
+            this.app.openPluginContribution(this.extensions[this.focusIdx - 5]);
     }
     render(buf) {
         drawHeader(buf, this.app.state);
@@ -335,14 +343,14 @@ export class StartScreen extends Screen {
         });
         y += INPUT_H + gap;
         const tabGap = 2;
-        const tabInner = inputW - tabGap * (TABS.length - 1);
-        const baseW = Math.floor(tabInner / TABS.length);
-        const extra = tabInner - baseW * TABS.length;
+        const tabInner = inputW - tabGap * (this.tabs.length - 1);
+        const baseW = Math.floor(tabInner / this.tabs.length);
+        const extra = tabInner - baseW * this.tabs.length;
         let tx = inputX;
-        for (let i = 0; i < TABS.length; i++) {
+        for (let i = 0; i < this.tabs.length; i++) {
             const tw = baseW + (i < extra ? 1 : 0);
             const selected = i === this.focusIdx - 1 || i === this.hoverIdx - 1;
-            drawTabButton(buf, tx, y, tw, TABS[i], selected);
+            drawTabButton(buf, tx, y, tw, this.tabs[i], selected);
             tx += tw + tabGap;
         }
         // The version label is pinned one row above the very bottom of the screen,
@@ -363,7 +371,7 @@ export class StartScreen extends Screen {
         if (showVersion) {
             buf.centerText(versionY, `v${version}`, { fg: C.dim });
         }
-        drawApprovalToggle(buf, approvalY, this.approvalMode, this.focusIdx === FOCUS_COUNT - 1 || this.hoverIdx === FOCUS_COUNT - 1);
+        drawApprovalToggle(buf, approvalY, this.approvalMode, this.focusIdx === this.focusCount - 1 || this.hoverIdx === this.focusCount - 1);
         // Painted last so their opaque footprints are never clipped by the
         // decorative content drawn before them. Hit testing shares the geometry.
         drawHeaderButton(buf, proModeButton(w, h), this.proHover);

package/dist/screens/updatePrompt.d.ts

@@ -0,0 +1,41 @@
+import type { Buffer } from "../terminal/buffer.js";
+import { Screen } from "../terminal/screen.js";
+import type { Key, MouseEvent } from "../terminal/input.js";
+import { type UpdateStatus } from "../update.js";
+/**
+ * The "a newer Neutrino is published" notice.
+ *
+ * It is pushed over the start screen only, never over a conversation: the
+ * answer arrives a moment after launch, and stealing a chat the user has
+ * already opened would be worse than a missed notice.
+ *
+ * Confirming runs npm here, in this process; the running code is not replaced,
+ * so a successful update ends by telling the user to restart. A failed one
+ * shows the command to run by hand, because npm usually fails for a reason the
+ * user has to fix (permissions, a proxy, an offline machine).
+ */
+export declare class UpdatePromptScreen extends Screen {
+    private phase;
+    /** Why the install failed, or which version landed. */
+    private detail;
+    private selectedIdx;
+    private lastHoverX;
+    private lastHoverY;
+    private readonly current;
+    private readonly latest;
+    constructor(status: UpdateStatus);
+    /** The buttons drawn right now; a click always lands on one of these. */
+    private buttons;
+    private buttonRow;
+    /** Columns the body paragraphs may use before wrapping. */
+    private bodyWidth;
+    private start;
+    private close;
+    private activate;
+    private move;
+    onKey(key: Key): void;
+    onMouse(ev: MouseEvent): void;
+    /** What the dialog says, in the order it is drawn. */
+    private body;
+    render(buf: Buffer): void;
+}

package/dist/selection.d.ts

@@ -0,0 +1,75 @@
+import type { Buffer } from "./terminal/buffer.js";
+export interface Point {
+    x: number;
+    y: number;
+}
+/** A point in *content* space: a line of the scrollable log, plus a column. */
+export interface LinePoint {
+    line: number;
+    x: number;
+}
+/**
+ * A mouse text selection. `anchor` is the cell where the drag started and
+ * `cursor` is the cell currently under the pointer; either may be above/left of
+ * the other, so consumers normalise before use.
+ */
+export interface Selection {
+    anchor: Point;
+    cursor: Point;
+}
+/** Order the two ends of a selection into reading order (top-left first). */
+export declare function normalizeSelection(sel: Selection): {
+    start: Point;
+    end: Point;
+};
+/** Order the two ends of a line-space selection into reading order. */
+export declare function orderLinePoints(a: LinePoint, b: LinePoint): {
+    start: LinePoint;
+    end: LinePoint;
+};
+/**
+ * Paint the selection highlight directly onto the rendered buffer. Working on
+ * the buffer (rather than on each screen) means the highlight automatically
+ * follows whatever is on screen — chat output, the input box, menus, …
+ *
+ * Intermediate lines stop at the last non-blank cell so a multi-line selection
+ * doesn't paint a block out to the right edge of the terminal.
+ */
+export declare function applySelection(buf: Buffer, sel: Selection): void;
+/**
+ * Extract the plain text covered by a selection.
+ *
+ * Three kinds of cell are skipped so the result is clean, pasteable text:
+ *   - UI chrome (the scrollbar), which is never content;
+ *   - wide-character continuation cells (`""`), which would duplicate a CJK
+ *     glyph;
+ *   - trailing blanks, trimmed per line (shell-style).
+ *
+ * Intermediate lines are copied out to the buffer's full width and only then
+ * trimmed, which keeps indentation intact while dropping the padding on the
+ * right. Skipping the scrollbar *before* trimming is what lets that trim
+ * actually reach the end of the text instead of stopping at the bar.
+ */
+export declare function selectionText(buf: Buffer, sel: Selection): string;
+/**
+ * One buffer row as column-indexed text: `cells[x]` is what column `x` holds,
+ * or `""` for a cell that never copies (UI chrome, and the tail of a
+ * double-width glyph).
+ *
+ * Keeping the column index is the point: it lets a row be sliced by column
+ * later, after the frame it came from is long gone. A drag that scrolls the log
+ * needs exactly that, because the rows it started on leave the screen while the
+ * selection keeps growing.
+ */
+export declare function rowCells(buf: Buffer, y: number): string[];
+/**
+ * Extract the text of a selection expressed in content lines (`rowSelectionText`
+ * is to `selectionText` what `LinePoint` is to `Point`).
+ *
+ * `getRow` supplies the cells of a line — from the current frame while the line
+ * is on screen, from the snapshot taken during the drag once it has scrolled
+ * away, or `null` for a line that was never captured. Trailing blanks and edge
+ * blank lines are trimmed exactly like `selectionText`, so both paths produce
+ * the same text for a selection that fits on one screen.
+ */
+export declare function rowSelectionText(getRow: (line: number) => readonly string[] | null, start: LinePoint, end: LinePoint): string;

package/dist/state.d.ts

@@ -0,0 +1,26 @@
+import type { Selection } from "./selection.js";
+export interface AppState {
+    selectedProvider: string;
+    selectedModelName: string;
+    selectedModelUrl: string;
+    selectedModelApiKey: string;
+    selectedModelStreaming: boolean;
+    selectedIntensity: string;
+    isThinking: boolean;
+    /** Blink phase for the "thinking" indicator in the top status bar. */
+    blinkOn: boolean;
+    /** Blink phase for the text cursors (true = lit, false = hidden). */
+    cursorOn: boolean;
+    /** Pending human approval; while set the top bar turns orange. */
+    approval: {
+        tool: string;
+        level: "high" | "extreme";
+    } | null;
+    /** URL of the running browser UI, or null when it is not mounted. */
+    webUrl: string | null;
+    /** True when that console is owned by the detached background service. */
+    webBackground: boolean;
+    /** Active mouse text selection, or null when nothing is selected. */
+    selection: Selection | null;
+}
+export declare function defaultState(): AppState;

package/dist/terminal/buffer.d.ts

@@ -0,0 +1,47 @@
+import { type Style } from "../colors.js";
+export interface Cell {
+    ch: string;
+    style: Style;
+    /**
+     * True for UI chrome (scrollbars, borders, …). Chrome is drawn like any
+     * other cell, but is deliberately *not* copied: extracting a selection
+     * skips it, so a copied line never ends up with a scrollbar glued to its
+     * right edge.
+     */
+    chrome?: boolean;
+}
+export declare class Buffer {
+    width: number;
+    height: number;
+    cells: Cell[][];
+    constructor(width: number, height: number);
+    /**
+     * Write a single cell, keeping the wide-glyph invariant intact. The renderer
+     * (and the selection logic) rely on the rule that a `""` cell is *always* the
+     * right half of a double-width glyph at `x - 1`. If the invariant is broken an
+     * orphan tail is left behind: the renderer skips it, so that column is never
+     * repainted and a stale glyph from the previous frame stays on screen (the
+     * "residual line" bug). To preserve it we blank the *other* half whenever we
+     * overwrite one half of a wide glyph.
+     */
+    private overwriteCell;
+    /**
+     * Mark `x` as the tail (`""`) of the wide glyph at `x - 1`. Unlike
+     * `overwriteCell` this never blanks the cell to the left, because that cell is
+     * the glyph we are currently writing.
+     */
+    private writeTail;
+    private writeChar;
+    set(x: number, y: number, ch: string, style?: Style): void;
+    writeText(x: number, y: number, text: string, style?: Style): void;
+    centerText(y: number, text: string, style?: Style): void;
+    fillRect(x: number, y: number, w: number, h: number, style?: Style): void;
+    drawBox(x: number, y: number, w: number, h: number, style?: Style): void;
+    /**
+     * Flag a cell as non-copyable chrome (e.g. a scrollbar). The flag lives on
+     * the cell and is cleared automatically whenever the cell is written again,
+     * since every frame starts from a fresh buffer.
+     */
+    markChrome(x: number, y: number): void;
+    clear(): void;
+}

package/dist/terminal/input.d.ts

@@ -0,0 +1,70 @@
+export interface Key {
+    name: string;
+    ctrl: boolean;
+    meta: boolean;
+    shift: boolean;
+    char: string;
+    sequence: string;
+}
+export type MouseEvent = {
+    type: "wheel";
+    dir: -1 | 1;
+    x: number;
+    y: number;
+} | {
+    type: "click";
+    x: number;
+    y: number;
+    button: number;
+} | {
+    type: "move";
+    x: number;
+    y: number;
+    drag: boolean;
+} | {
+    type: "release";
+    x: number;
+    y: number;
+    button: number;
+};
+export type InputEvent = {
+    type: "key";
+    key: Key;
+} | {
+    type: "paste";
+    text: string;
+} | {
+    type: "mouse";
+    event: MouseEvent;
+};
+export declare class InputReader {
+    private decoder;
+    private pending;
+    private state;
+    private csiBuf;
+    private escTimer;
+    private inPaste;
+    private pasteBuf;
+    private handler;
+    private dataHandler;
+    start(handler: (ev: InputEvent) => void): void;
+    stop(): void;
+    private onData;
+    private process;
+    private scheduleEscTimeout;
+    private cancelEscTimeout;
+    private finishCsi;
+    /**
+     * Parse SGR (extended) mouse sequences: ESC [ < b ; x ; y M/m
+     *
+     * `b` is a bit field: the low two bits are the button (0 left, 1 middle,
+     * 2 right, 3 none/release), bit 5 (32) marks a motion event and bit 6 (64)
+     * marks a wheel event. A trailing `M` is a press/motion while `m` is a
+     * release. So motion with the left button held (a drag) is `b = 32`, whereas
+     * plain hover is `b = 35` (32 | 3).
+     */
+    private handleMouse;
+    private emitKey;
+    private emitPaste;
+    private emitMouse;
+}