@prometheus-ai/tui 0.5.3 → 0.5.8

package/dist/types/autocomplete.d.ts

@@ -8,6 +8,7 @@ export interface AutocompleteItem {
 type Awaitable<T> = T | Promise<T>;
 export interface SlashCommand {
     name: string;
+    aliases?: string[];
     description?: string;
     argumentHint?: string;
     getArgumentCompletions?(argumentPrefix: string): Awaitable<AutocompleteItem[] | null>;
@@ -48,9 +49,10 @@ export interface AutocompleteProvider {
         insert: string;
     } | null;
 }
+type CommandEntry = SlashCommand | AutocompleteItem;
 export declare class CombinedAutocompleteProvider implements AutocompleteProvider {
     #private;
-    constructor(commands?: (SlashCommand | AutocompleteItem)[], basePath?: string);
+    constructor(commands?: CommandEntry[], basePath?: string);
     getSuggestions(lines: string[], cursorLine: number, cursorCol: number): Promise<{
         items: AutocompleteItem[];
         prefix: string;

package/dist/types/components/box.d.ts

@@ -13,5 +13,5 @@ export declare class Box implements Component {
     setPaddingY(paddingY: number): void;
     setBgFn(bgFn?: (text: string) => string): void;
     invalidate(): void;
-    render(width: number): string[];
+    render(width: number): readonly string[];
 }

package/dist/types/components/editor.d.ts

@@ -37,9 +37,22 @@ export declare class Editor implements Component, Focusable {
     decorateText: ((text: string) => string) | undefined;
     borderColor: (str: string) => string;
     onAutocompleteUpdate?: () => void;
-    onSubmit?: (text: string) => void;
+    /** Optional pattern matching atomic placeholder tokens (e.g. `[Image #1, 800x600]` or
+     *  `[Paste #2, +30 lines]`) that the editor treats as indivisible: a backspace or forward-delete
+     *  landing on any character of a token removes the whole token instead of corrupting it into
+     *  stray text. MUST be a global regex; the editor recompiles a private copy so its `lastIndex`
+     *  is never shared with the caller. */
+    atomicTokenPattern: RegExp | undefined;
+    onSubmit?: (text: string) => void | Promise<void>;
     onAltEnter?: (text: string) => void;
     onChange?: (text: string) => void;
+    /** Called for a "marker-sized" paste — the point where the editor would otherwise collapse it
+     *  into a `[Paste #N]` token (> 10 lines or > 1000 characters). Return `true` to intercept:
+     *  the editor inserts nothing and records no undo state, leaving insertion to the host (e.g. a
+     *  "wrap in a code block / XML / attach as file" menu for very large pastes), which re-inserts
+     *  via {@link insertPaste} or {@link insertText}. Return `false` (or leave unset) for the
+     *  default collapse-to-marker behavior. `lineCount` is the sanitized paste's line count. */
+    onLargePaste?: (text: string, lineCount: number) => boolean;
     onAutocompleteCancel?: () => void;
     disableSubmit: boolean;
     constructor(theme: EditorTheme);
@@ -75,7 +88,7 @@ export declare class Editor implements Component, Focusable {
      */
     addToHistory(text: string): void;
     invalidate(): void;
-    render(width: number): string[];
+    render(width: number): readonly string[];
     handleInput(data: string): void;
     getText(): string;
     /**
@@ -100,6 +113,26 @@ export declare class Editor implements Component, Focusable {
     setText(text: string): void;
     /** Insert text at the current cursor position */
     insertText(text: string): void;
+    /** Delete up to `count` characters immediately before the cursor on the current line.
+     *  Used to "track back" the auto-repeat spaces that the space-hold push-to-talk gesture
+     *  optimistically inserts before it recognizes the hold. Capped at the cursor column so it
+     *  never crosses a line boundary or under-runs the line. */
+    deleteBeforeCursor(count: number): void;
+    /** Show or replace a volatile speech-to-text preview at the cursor. The text is
+     *  inserted with undo suspended so a long live dictation never floods the undo
+     *  stack; finalize it with {@link commitVolatileText} or drop it with
+     *  {@link clearVolatileText}. Newlines are allowed. */
+    setVolatileText(text: string): void;
+    /** Remove the current volatile preview without committing it. */
+    clearVolatileText(): void;
+    /** Drop any volatile preview, then insert `text` as a single undoable edit. */
+    commitVolatileText(text: string): void;
+    /** Apply terminal paste semantics to text from non-bracketed paste transports. */
+    pasteText(text: string): void;
+    /** Insert `content` as a collapsed `[Paste #N]` marker (stored for expansion on submit via
+     *  {@link getExpandedText}). Hosts that intercept large pastes through {@link onLargePaste} use
+     *  this to re-insert a (possibly transformed) paste without re-triggering the interception hook. */
+    insertPaste(content: string): void;
     isShowingAutocomplete(): boolean;
 }
 export {};

package/dist/types/components/image.d.ts

@@ -48,12 +48,22 @@ export declare class ImageBudget {
      * gets a fresh id every call.
      */
     acquireId(key?: string): number;
-    /** Begin a render pass. Called by the renderer before composing the frame. */
-    beginPass(): void;
+    /**
+     * Begin a render pass. Called by the renderer before composing the frame.
+     * Pass `stable: true` for a partial/throwaway pass that does not walk the
+     * whole tree in display order (the resize viewport fast path): {@link observe}
+     * then replays the last committed per-id decision instead of one derived from
+     * call order, and the pass must NOT be closed with {@link endPass}.
+     */
+    beginPass(stable?: boolean): void;
     /**
      * Record an image in display order and report whether it must render its text
      * fallback this frame. Called by every {@link Image} during render — including
      * on a cache hit, so the image keeps its display-order slot.
+     *
+     * During a `stable` pass ({@link beginPass}) the call order and visible subset
+     * are not authoritative, so the decision is the committed on-terminal split
+     * (`#suppressedIds`) keyed by id — order- and partiality-independent.
      */
     observe(imageId: number): boolean;
     /**
@@ -73,6 +83,15 @@ export declare class ImageBudget {
      * repeated call (e.g. a width-change re-render) never re-sends the data.
      */
     enqueueTransmit(imageId: number, sequence: string): void;
+    /** Whether a frame has image data queued but not yet written to the terminal. */
+    hasPendingTransmits(): boolean;
+    /**
+     * True when the budget has nothing in flight: no live images observed on
+     * the last pass, no queued transmits, no pending purges, and no stricter
+     * threshold left to apply. A component-scoped frame may skip the observe
+     * pass only then — a partial tree walk would under-count display order.
+     */
+    get quiescent(): boolean;
     /** Transmit sequences to write before this frame's placements; clears the queue. */
     takeTransmits(): readonly string[];
 }
@@ -80,5 +99,5 @@ export declare class Image implements Component {
     #private;
     constructor(base64Data: string, mimeType: string, theme: ImageTheme, options?: ImageOptions, dimensions?: ImageDimensions);
     invalidate(): void;
-    render(width: number): string[];
+    render(width: number): readonly string[];
 }

package/dist/types/components/input.d.ts

@@ -4,6 +4,8 @@ import { type Component, type Focusable } from "../tui";
  */
 export declare class Input implements Component, Focusable {
     #private;
+    /** Rendered before the editable area; set to "" for chrome-less embedding. */
+    prompt: string;
     onSubmit?: (value: string) => void;
     onEscape?: () => void;
     /** Focusable interface - set by TUI when focus changes */
@@ -13,6 +15,9 @@ export declare class Input implements Component, Focusable {
     setUseTerminalCursor(useTerminalCursor: boolean): void;
     getUseTerminalCursor(): boolean;
     handleInput(data: string): void;
+    /** Apply terminal paste semantics to text from non-bracketed paste transports
+     *  (e.g. kitty's OSC 5522 enhanced clipboard read). Mirrors `Editor.pasteText`. */
+    pasteText(text: string): void;
     invalidate(): void;
-    render(width: number): string[];
+    render(width: number): readonly string[];
 }

package/dist/types/components/loader.d.ts

@@ -1,13 +1,20 @@
 import type { TUI } from "../tui";
 import { Text } from "./text";
+type ColorFn = (str: string) => string;
+export type LoaderMessageColorFn = ColorFn & {
+    readonly animated?: true;
+};
 export declare class Loader extends Text {
     #private;
     private spinnerColorFn;
     private messageColorFn;
     private message;
-    constructor(ui: TUI, spinnerColorFn: (str: string) => string, messageColorFn: (str: string) => string, message?: string, spinnerFrames?: string[]);
-    render(width: number): string[];
+    constructor(ui: TUI, spinnerColorFn: ColorFn, messageColorFn: LoaderMessageColorFn, message?: string, spinnerFrames?: string[]);
+    render(width: number): readonly string[];
     start(): void;
     stop(): void;
+    /** Lifecycle teardown: stop the animation timer. Idempotent. */
+    dispose(): void;
     setMessage(message: string): void;
 }
+export {};

package/dist/types/components/markdown.d.ts

@@ -52,7 +52,9 @@ export declare class Markdown implements Component {
     constructor(text: string, paddingX: number, paddingY: number, theme: MarkdownTheme, defaultTextStyle?: DefaultTextStyle, codeBlockIndent?: number);
     setText(text: string): void;
     invalidate(): void;
-    render(width: number): string[];
+    get transientRenderCache(): boolean;
+    set transientRenderCache(value: boolean);
+    render(width: number): readonly string[];
 }
 /**
  * Render inline markdown (bold, italic, code, links, strikethrough) to a styled string.

package/dist/types/components/scroll-view.d.ts

@@ -1,4 +1,5 @@
 import type { Component } from "../tui";
+import { Ellipsis } from "../utils";
 type ScrollbarMode = "auto" | "always" | "never";
 export interface ScrollViewTheme {
     track?: (text: string) => string;
@@ -13,6 +14,18 @@ export interface ScrollViewOptions {
     theme?: ScrollViewTheme;
     trackChar?: string;
     thumbChar?: string;
+    /**
+     * Indicator appended when a row overflows `contentWidth`. Defaults to
+     * {@link Ellipsis.Unicode}. Pass {@link Ellipsis.Omit} when callers wrap
+     * lines to width themselves and only trailing padding can overflow (e.g.
+     * the plan-review overlay), so no stray `…` lands on every padded row.
+     */
+    ellipsis?: Ellipsis;
+    /**
+     * Rows moved per keystroke when {@link ScrollView.handleScrollKey} sees a
+     * Shift+Arrow (the "scroll faster" affordance). Defaults to 5.
+     */
+    fastScrollLines?: number;
 }
 /**
  * Fixed-height viewport over pre-rendered lines, with optional right-edge scrollbar.
@@ -34,7 +47,16 @@ export declare class ScrollView implements Component {
     page(delta: number): void;
     scrollToTop(): void;
     scrollToBottom(): void;
+    /**
+     * Apply a standard navigation key to the viewport. Shift+Arrow scrolls by
+     * {@link ScrollViewOptions.fastScrollLines} (the "scroll faster" affordance);
+     * plain Arrow by one line; PageUp/PageDown by a page; Home/End to the ends.
+     * Returns true when the key was consumed, so callers can fall through to
+     * their own (e.g. vim-style) bindings. Generic on purpose: every ScrollView
+     * consumer gets the same scroll keys, including Shift-to-go-faster.
+     */
+    handleScrollKey(data: string): boolean;
     invalidate(): void;
-    render(width: number): string[];
+    render(width: number): readonly string[];
 }
 export {};

package/dist/types/components/select-list.d.ts

@@ -14,6 +14,8 @@ export interface SelectListTheme {
     scrollInfo: (text: string) => string;
     noMatch: (text: string) => string;
     symbols: SymbolTheme;
+    /** Hover band applied to the full row under the mouse pointer. */
+    hovered?: (text: string) => string;
 }
 export interface SelectListTruncatePrimaryContext {
     text: string;
@@ -28,6 +30,14 @@ export interface SelectListLayoutOptions {
     truncatePrimary?: (context: SelectListTruncatePrimaryContext) => string;
     /** Enable type-to-filter search when the item count exceeds maxVisible. Defaults to true. */
     overflowSearch?: boolean;
+    /**
+     * Wrap long descriptions onto continuation rows indented under the
+     * description column instead of truncating. Defaults to false so existing
+     * single-line consumers are unaffected. Navigation remains item-to-item;
+     * the scrollbar tracks visual rows so the thumb stays correct when items
+     * wrap unevenly.
+     */
+    wrapDescription?: boolean;
 }
 export declare class SelectList implements Component {
     #private;
@@ -41,8 +51,16 @@ export declare class SelectList implements Component {
     constructor(items: ReadonlyArray<SelectItem>, maxVisible: number, theme: SelectListTheme, layout?: SelectListLayoutOptions);
     setFilter(filter: string): void;
     setSelectedIndex(index: number): void;
+    /** Resolve a 0-based rendered-line index to a filtered-item index. */
+    hitTest(line: number): number | undefined;
+    /** Highlight the item under the pointer (null clears). */
+    setHoverIndex(index: number | null): void;
+    /** Move the selection one step for a wheel notch. */
+    handleWheel(delta: -1 | 1): void;
+    /** Mouse click: select the item under the pointer and confirm it. */
+    clickItem(index: number): void;
     invalidate(): void;
-    render(width: number): string[];
+    render(width: number): readonly string[];
     handleInput(keyData: string): void;
     getSelectedItem(): SelectItem | null;
 }

package/dist/types/components/settings-list.d.ts

@@ -1,3 +1,4 @@
+import type { SgrMouseEvent } from "../mouse";
 import type { Component } from "../tui";
 export interface SettingItem {
     /** Unique identifier for this setting */
@@ -14,6 +15,8 @@ export interface SettingItem {
     submenu?: (currentValue: string, done: (selectedValue?: string) => void) => Component;
     /** True when the displayed setting differs from its default value. */
     changed?: boolean;
+    /** Render as a non-interactive section heading. Skipped by navigation and search. */
+    heading?: boolean;
 }
 export interface SettingsListTheme {
     label: (text: string, selected: boolean, changed: boolean) => string;
@@ -21,21 +24,98 @@ export interface SettingsListTheme {
     description: (text: string) => string;
     cursor: string;
     hint: (text: string) => string;
+    /** Style for section heading rows (dimmed when outside the active section). Falls back to `hint` when omitted. */
+    heading?: (text: string, dimmed: boolean) => string;
+    /** Style for sidebar section names in the split layout. Falls back to label/hint. */
+    section?: (text: string, active: boolean) => string;
+    /** Hover band applied to the full row under the mouse pointer. */
+    hovered?: (text: string) => string;
 }
+/** Optional behavior overrides for {@link SettingsList}. */
+export interface SettingsListOptions {
+    /**
+     * "auto" (default) renders the section sidebar layout when headings exist
+     * and the width allows; "flat" always renders inline heading rows.
+     */
+    layout?: "auto" | "flat";
+    /**
+     * When false, printable input is ignored (no internal type-to-filter) and
+     * the search status line is never rendered. Use when a parent component
+     * owns the query. Default true.
+     */
+    typeToSearch?: boolean;
+    /** Text shown when the list has no items at all. */
+    emptyText?: string;
+    /**
+     * Footer hint line (hint-styled, replaces the default navigation hint).
+     * An empty string removes the hint row and its leading blank entirely —
+     * use when the host renders its own footer.
+     */
+    hint?: string;
+    /** Fixed split-sidebar width (columns incl. indent+gap); default derives from section names. */
+    sidebarWidth?: number;
+}
+/** Searchable text for a setting item: label, id, value, description, and cycle values. */
+export declare function getSettingItemFilterText(item: SettingItem): string;
 export declare class SettingsList implements Component {
     #private;
-    constructor(items: SettingItem[], maxVisible: number, theme: SettingsListTheme, onChange: (id: string, newValue: string) => void, onCancel: () => void);
+    /** Fired when the selected item changes (navigation, filtering, or setItems). */
+    onSelectionChange?: (item: SettingItem | undefined) => void;
+    constructor(items: SettingItem[], maxVisible: number, theme: SettingsListTheme, onChange: (id: string, newValue: string) => void, onCancel: () => void, options?: SettingsListOptions);
+    /** The currently selected item, or undefined when empty or on a heading. */
+    getSelectedItem(): SettingItem | undefined;
+    /** Move selection to the item with `id`. Returns false when it is not visible. */
+    selectItem(id: string): boolean;
+    /** True while keyboard focus is on the section headings instead of the setting rows. */
+    get sectionFocused(): boolean;
+    /** Whether section focus has anywhere to go: 2+ derived sections in the current view. */
+    hasSectionFocusTargets(): boolean;
+    /**
+     * Toggle keyboard focus between section headings and setting rows. While
+     * focused, Up/Down jump whole sections and Enter/Esc return to the rows.
+     * Engages only when {@link hasSectionFocusTargets}; returns the new state.
+     */
+    toggleSectionFocus(): boolean;
+    /** True while an item submenu owns input. */
+    hasOpenSubmenu(): boolean;
+    /** Resize the visible viewport (fullscreen hosts call this every render). */
+    setMaxVisible(rows: number): void;
+    /** Move the selection one step for a wheel notch. */
+    handleWheel(delta: -1 | 1): void;
+    /** Highlight the item under the pointer (null clears). */
+    setHoverItem(id: string | null): void;
+    /**
+     * Resolve a pointer position against the last rendered frame. `line` is the
+     * 0-based content-line index within this component's render output, `col`
+     * the 0-based column. Sidebar rows resolve to the section's first item.
+     */
+    hitTest(line: number, col: number): string | undefined;
+    /**
+     * Like {@link hitTest}, but only rows the pointer is visually on: sidebar
+     * jump targets are excluded so hovering section names does not light up
+     * pane rows.
+     */
+    hoverTest(line: number, col: number): string | undefined;
+    /**
+     * Route a mouse event into an open submenu (coordinates are local to this
+     * list's rendered lines). Returns false when no submenu is open; submenus
+     * that do not implement {@link MouseRoutable} consume the event silently.
+     */
+    routeSubmenuMouse(event: SgrMouseEvent, line: number, col: number): boolean;
+    getSearchQuery(): string;
+    hasSearchQuery(): boolean;
+    clearSearch(): void;
     /** Update an item's currentValue */
     updateValue(id: string, newValue: string): void;
     /**
-     * Replace the entire items array. Selection is preserved when the prior
-     * index is still valid, otherwise clamped to the last item (or 0 if the
-     * list is now empty). An open submenu is left untouched — its lifetime
-     * is bounded by its own done callback, and `#closeSubmenu` re-clamps the
-     * restored index against the new list on the way out.
+     * Replace the entire items array. Selection is preserved by item id when
+     * the previous selection still survives the active filter, otherwise
+     * clamped to the last filtered item (or 0 if there are no matches).
+     * An open submenu is left untouched — its lifetime is bounded by its own
+     * done callback, and `#closeSubmenu` re-resolves the restored item on exit.
      */
     setItems(items: SettingItem[]): void;
     invalidate(): void;
-    render(width: number): string[];
+    render(width: number): readonly string[];
     handleInput(data: string): void;
 }

package/dist/types/components/spacer.d.ts

@@ -7,5 +7,5 @@ export declare class Spacer implements Component {
     constructor(lines?: number);
     setLines(lines: number): void;
     invalidate(): void;
-    render(_width: number): string[];
+    render(_width: number): readonly string[];
 }

package/dist/types/components/tab-bar.d.ts

@@ -5,6 +5,10 @@ export interface Tab {
     id: string;
     /** Display label shown in the tab bar */
     label: string;
+    /** Compact form (e.g. just the icon) used when the bar must shrink to fit one line. */
+    short?: string;
+    /** Render with the muted style and skip during keyboard navigation. */
+    muted?: boolean;
 }
 /** Theme for styling the tab bar */
 export interface TabBarTheme {
@@ -16,6 +20,10 @@ export interface TabBarTheme {
     inactiveTab: (text: string) => string;
     /** Style for the hint text (e.g., "(tab to cycle)") */
     hint: (text: string) => string;
+    /** Style for muted tabs. Falls back to `inactiveTab` when omitted. */
+    mutedTab?: (text: string) => string;
+    /** Style for the tab under the mouse pointer. Falls back to `inactiveTab` when omitted. */
+    hoverTab?: (text: string) => string;
 }
 /**
  * Horizontal tab bar component.
@@ -34,6 +42,8 @@ export declare class TabBar implements Component {
     #private;
     /** Callback fired when the active tab changes */
     onTabChange?: (tab: Tab, index: number) => void;
+    /** Render the trailing "(tab to cycle)" hint. Disable when the host folds the hint into its own footer. */
+    showHint: boolean;
     constructor(label: string, tabs: Tab[], theme: TabBarTheme, initialIndex?: number);
     /** Get the currently active tab */
     getActiveTab(): Tab;
@@ -41,9 +51,19 @@ export declare class TabBar implements Component {
     getActiveIndex(): number;
     /** Set the active tab by index (clamped to valid range) */
     setActiveIndex(index: number): void;
-    /** Move to the next tab (wraps to first tab after last) */
+    /**
+     * Replace the tab set without firing onTabChange. The active tab is
+     * preserved by id when it survives the swap (or forced via `activeId`);
+     * otherwise the index is clamped.
+     */
+    setTabs(tabs: Tab[], activeId?: string): void;
+    /** Set the active tab by id without firing onTabChange. Returns false when the id is unknown. */
+    setActiveById(id: string): boolean;
+    /** Activate the tab with `id`, firing onTabChange when it changes. Muted tabs are ignored. */
+    selectTab(id: string): boolean;
+    /** Move to the next non-muted tab (wraps to first tab after last) */
     nextTab(): void;
-    /** Move to the previous tab (wraps to last tab before first) */
+    /** Move to the previous non-muted tab (wraps to last tab before first) */
     prevTab(): void;
     invalidate(): void;
     /**
@@ -51,6 +71,19 @@ export declare class TabBar implements Component {
      * @returns true if the input was handled, false otherwise
      */
     handleInput(data: string): boolean;
-    /** Render the tab bar, wrapping to multiple lines if needed */
-    render(width: number): string[];
+    /**
+     * Render the tab bar. When the full labels overflow the width, tabs are
+     * collapsed to their `short` form one by one — starting with the tabs
+     * farthest from the active one — until the bar fits on a single line.
+     * Wrapping to multiple lines is the last resort.
+     */
+    render(width: number): readonly string[];
+    /**
+     * Resolve a pointer position against the last rendered frame. `line` is the
+     * 0-based line index within this component's render output, `col` the
+     * 0-based column.
+     */
+    tabAt(line: number, col: number): Tab | undefined;
+    /** Highlight the tab under the pointer (null clears). */
+    setHoverTab(id: string | null): void;
 }

package/dist/types/components/text.d.ts

@@ -6,8 +6,8 @@ export declare class Text implements Component {
     #private;
     constructor(text?: string, paddingX?: number, paddingY?: number, customBgFn?: (text: string) => string);
     getText(): string;
-    setText(text: string): void;
+    setText(text: string): boolean;
     setCustomBgFn(customBgFn?: (text: string) => string): void;
     invalidate(): void;
-    render(width: number): string[];
+    render(width: number): readonly string[];
 }

package/dist/types/components/truncated-text.d.ts

@@ -6,5 +6,5 @@ export declare class TruncatedText implements Component {
     #private;
     constructor(text: string, paddingX?: number, paddingY?: number);
     invalidate(): void;
-    render(width: number): string[];
+    render(width: number): readonly string[];
 }

package/dist/types/fuzzy.d.ts

@@ -1,15 +1,24 @@
 /**
  * Fuzzy matching utilities.
- * Matches if all query characters appear in order (not necessarily consecutive).
+ *
+ * Matching is deliberately word-local for normal words. This keeps a query like
+ * "image provider" from matching a long setting description only because the
+ * letters i-m-a-g-e appear somewhere in order across unrelated words.
+ *
  * Lower score = better match.
  */
 export interface FuzzyMatch {
     matches: boolean;
     score: number;
 }
+export interface FuzzyFilterResult<T> {
+    item: T;
+    score: number;
+}
 export declare function fuzzyMatch(query: string, text: string): FuzzyMatch;
 /**
  * Filter and sort items by fuzzy match quality (best matches first).
  * Supports space-separated tokens: all tokens must match.
  */
+export declare function fuzzyRank<T>(items: T[], query: string, getText: (item: T) => string): FuzzyFilterResult<T>[];
 export declare function fuzzyFilter<T>(items: T[], query: string, getText: (item: T) => string): T[];

package/dist/types/index.d.ts

@@ -19,6 +19,7 @@ export * from "./fuzzy";
 export * from "./keybindings";
 export * from "./keys";
 export * from "./kitty-graphics";
+export * from "./mouse";
 export * from "./stdin-buffer";
 export type * from "./symbols";
 export * from "./terminal";

package/dist/types/keybindings.d.ts

@@ -102,11 +102,11 @@ export declare const TUI_KEYBINDINGS: {
         readonly description: "Delete character forward";
     };
     readonly "tui.editor.deleteWordBackward": {
-        readonly defaultKeys: ["ctrl+w", "alt+backspace", "ctrl+backspace"];
+        readonly defaultKeys: ["ctrl+w", "alt+backspace", "ctrl+backspace", "super+alt+backspace"];
         readonly description: "Delete word backward";
     };
     readonly "tui.editor.deleteWordForward": {
-        readonly defaultKeys: ["alt+delete", "alt+d"];
+        readonly defaultKeys: ["alt+delete", "alt+d", "super+alt+delete", "super+alt+d"];
         readonly description: "Delete word forward";
     };
     readonly "tui.editor.deleteToLineStart": {
@@ -130,7 +130,7 @@ export declare const TUI_KEYBINDINGS: {
         readonly description: "Undo";
     };
     readonly "tui.input.newLine": {
-        readonly defaultKeys: "shift+enter";
+        readonly defaultKeys: ["shift+enter", "ctrl+j"];
         readonly description: "Insert newline";
     };
     readonly "tui.input.submit": {
@@ -174,6 +174,8 @@ export interface KeybindingConflict {
     key: KeyId;
     keybindings: string[];
 }
+export declare function canonicalKeyId(key: string): string;
+export declare function addKeyAliases(keys: Set<string>, key: KeyId): void;
 export declare class KeybindingsManager {
     #private;
     constructor(definitions: KeybindingDefinitions, userBindings?: KeybindingsConfig);

package/dist/types/keys.d.ts

@@ -62,7 +62,7 @@ export type KeyId = BaseKey | ModifiedKeyId<BaseKey>;
  * modifier methods return precisely-typed concatenations (e.g. `Key.ctrl("c")`
  * is `"ctrl+c"`, not just `string`). This mirrors the upstream
  * `@mariozechner/pi-tui` `Key` export verbatim so plugins built against any
- * scope alias (`@mariozechner`, `@earendil-works`, `@prometheus`) keep working
+ * scope alias (`@mariozechner`, `@earendil-works`, `@Prometheus`) keep working
  * once the specifier shim remaps them to this package.
  */
 export declare const Key: {

package/dist/types/kill-ring.d.ts

@@ -1,10 +1,3 @@
-/**
- * Ring buffer for Emacs-style kill/yank operations.
- *
- * Tracks killed (deleted) text entries. Consecutive kills can accumulate
- * into a single entry. Supports yank (paste most recent) and yank-pop
- * (cycle through older entries).
- */
 export declare class KillRing {
     #private;
     /**