@timurproko/a1 0.1.8-dev.290 → 0.1.8-dev.322

package/dist/integrations/pi/components/upstream/components/earendil-announcement.js

@@ -1,10 +1,28 @@
 // Mechanically adapted from Pi commit 914cf14
 // packages/coding-agent/src/modes/interactive/components/earendil-announcement.ts (MIT).
-// Local modifications: remap private imports to public package-root/owned theme boundaries and omit optional package-private imagery.
-import { Container, Spacer, Text } from "#pi-tui";
+// Local modifications: remap private imports to public package-root/owned theme boundaries; load the verified owned copy of the image lazily.
+import { readFileSync } from "node:fs";
+import { Container, Image, Spacer, Text } from "#pi-tui";
 import { DynamicBorder } from "@earendil-works/pi-coding-agent";
 import { piTheme } from "../theme/theme.js";
 const BLOG_URL = "https://mariozechner.at/posts/2026-04-08-ive-sold-out/";
+const IMAGE_FILENAME = "clankolas.png";
+let cachedImageBase64;
+let attemptedImageLoad = false;
+function loadImageBase64() {
+    if (attemptedImageLoad)
+        return cachedImageBase64;
+    attemptedImageLoad = true;
+    try {
+        const resource = JSON.parse(readFileSync(new URL("../assets/earendil-image.json", import.meta.url), "utf8"));
+        if (resource && typeof resource === "object" && "data" in resource && typeof resource.data === "string")
+            cachedImageBase64 = resource.data;
+    }
+    catch {
+        cachedImageBase64 = undefined;
+    }
+    return cachedImageBase64;
+}
 export class EarendilAnnouncementComponent extends Container {
     constructor() {
         super();
@@ -14,6 +32,11 @@ export class EarendilAnnouncementComponent extends Container {
         this.addChild(new Text(piTheme().fg("muted", "Read the blog post:"), 1, 0));
         this.addChild(new Text(piTheme().fg("mdLink", BLOG_URL), 1, 0));
         this.addChild(new Spacer(1));
+        const imageBase64 = loadImageBase64();
+        if (imageBase64) {
+            this.addChild(new Image(imageBase64, "image/png", { fallbackColor: text => piTheme().fg("muted", text) }, { maxWidthCells: 56, filename: IMAGE_FILENAME }));
+            this.addChild(new Spacer(1));
+        }
         this.addChild(new DynamicBorder((text) => piTheme().fg("accent", text)));
     }
 }

package/dist/integrations/pi/components/upstream/components/owned-editor.d.ts

@@ -4,28 +4,32 @@
  * Modifications: A1-owned class name, synchronized keybinding contract, and a semantic
  * bare-A1 prompt-prefix/contextual-suggestion presentation branch.
  */
-import { Editor, type EditorOptions, type EditorTheme, type TUI } from "#pi-tui";
+import { type EditorOptions, type EditorTheme, type TUI } from "#pi-tui";
 import type { AppKeybinding, KeybindingsManager } from "../adjacent/core/keybindings.js";
+import type { EditorSurface } from "../../editor-interaction.js";
 export interface OwnedEditorOptions extends EditorOptions {
+    readonly persistentHistory?: boolean;
+    readonly styleHistoryLabel?: (text: string) => string;
     readonly promptPrefix?: string;
     readonly styleSuggestion?: (text: string) => string;
     readonly styleSuggestionCaret?: (text: string) => string;
     readonly terminalRows?: () => number;
 }
-export declare class OwnedEditor extends Editor {
-    #private;
-    private readonly keybindings;
-    readonly actionHandlers: Map<keyof import("../adjacent/core/keybindings.js").AppKeybindings, () => void>;
+export interface ShellEditorInstance extends EditorSurface {
+    readonly actionHandlers: Map<AppKeybinding, () => void>;
     onEscape?: () => void;
     onCtrlD?: () => void;
     onPasteImage?: () => void;
     onExtensionShortcut?: (data: string) => boolean;
     onPromptSuggestionAccepted?: (text: string) => void;
-    constructor(tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager, options?: OwnedEditorOptions);
     setPromptSuggestion(text: string | null): void;
     canPresentPromptSuggestion(): boolean;
-    setText(text: string): void;
-    render(width: number): string[];
     onAction(action: AppKeybinding, handler: () => void): void;
-    handleInput(data: string): void;
 }
+type EditorConstructor = new (tui: TUI, theme: EditorTheme, options?: EditorOptions) => EditorSurface;
+type ShellEditorConstructor = new (tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager, options?: OwnedEditorOptions) => ShellEditorInstance;
+export declare function createOwnedEditorClass(Base: EditorConstructor): ShellEditorConstructor;
+declare const OwnedEditor_base: ShellEditorConstructor;
+export declare class OwnedEditor extends OwnedEditor_base {
+}
+export {};

package/dist/integrations/pi/components/upstream/components/owned-editor.js

@@ -6,149 +6,153 @@
  */
 import { CURSOR_MARKER, Editor, truncateToWidth, visibleWidth, wrapTextWithAnsi, } from "#pi-tui";
 const PROMPT_GRAPHEMES = new Intl.Segmenter(undefined, { granularity: "grapheme" });
-export class OwnedEditor extends Editor {
-    keybindings;
-    actionHandlers = new Map();
-    onEscape;
-    onCtrlD;
-    onPasteImage;
-    onExtensionShortcut;
-    onPromptSuggestionAccepted;
-    #promptSuggestion = null;
-    #promptPrefix;
-    #styleSuggestion;
-    #styleSuggestionCaret;
-    #terminalRows;
-    constructor(tui, theme, keybindings, options = {}) {
-        super(tui, theme, options);
-        this.keybindings = keybindings;
-        this.#promptPrefix = options.promptPrefix ?? "";
-        this.#styleSuggestion = options.styleSuggestion ?? (text => text);
-        this.#styleSuggestionCaret = options.styleSuggestionCaret ?? (text => `\u001b[7m${text}\u001b[27m`);
-        this.#terminalRows = options.terminalRows ?? (() => 24);
-    }
-    setPromptSuggestion(text) {
-        this.#promptSuggestion = text;
-    }
-    canPresentPromptSuggestion() {
-        return this.#promptPrefix.length > 0
-            && this.focused
-            && !this.disableSubmit
-            && this.getText().length === 0
-            && !this.isShowingAutocomplete();
-    }
-    setText(text) {
-        if (text.length > 0)
-            this.#promptSuggestion = null;
-        super.setText(text);
-    }
-    render(width) {
-        if (this.#promptPrefix.length === 0)
-            return super.render(width);
-        if (this.#promptSuggestion !== null && this.canPresentPromptSuggestion()) {
-            return this.#renderSuggestion(width);
+export function createOwnedEditorClass(Base) {
+    return class extends Base {
+        keybindings;
+        actionHandlers = new Map();
+        onEscape;
+        onCtrlD;
+        onPasteImage;
+        onExtensionShortcut;
+        onPromptSuggestionAccepted;
+        #promptSuggestion = null;
+        #promptPrefix;
+        #styleSuggestion;
+        #styleSuggestionCaret;
+        #terminalRows;
+        constructor(tui, theme, keybindings, options = {}) {
+            super(tui, theme, options);
+            this.keybindings = keybindings;
+            this.#promptPrefix = options.promptPrefix ?? "";
+            this.#styleSuggestion = options.styleSuggestion ?? (text => text);
+            this.#styleSuggestionCaret = options.styleSuggestionCaret ?? (text => `\u001b[7m${text}\u001b[27m`);
+            this.#terminalRows = options.terminalRows ?? (() => 24);
         }
-        return this.#renderPrefixedEditor(width);
-    }
-    onAction(action, handler) { this.actionHandlers.set(action, handler); }
-    handleInput(data) {
-        if (this.onExtensionShortcut?.(data))
-            return;
-        if (this.#promptSuggestion !== null
-            && !this.isShowingAutocomplete()
-            && this.canPresentPromptSuggestion()
-            && this.keybindings.matches(data, "tui.input.submit")) {
-            return;
+        setPromptSuggestion(text) {
+            this.#promptSuggestion = text;
         }
-        if (this.#promptSuggestion !== null
-            && !this.isShowingAutocomplete()
-            && this.canPresentPromptSuggestion()
-            && this.keybindings.matches(data, "tui.input.tab")) {
-            const accepted = this.#promptSuggestion;
-            this.#promptSuggestion = null;
-            super.setText(accepted);
-            this.onPromptSuggestionAccepted?.(accepted);
-            return;
+        canPresentPromptSuggestion() {
+            return this.#promptPrefix.length > 0
+                && this.focused
+                && !this.disableSubmit
+                && this.getText().length === 0
+                && !this.isShowingAutocomplete();
         }
-        if (this.keybindings.matches(data, "app.clipboard.pasteImage")) {
-            this.onPasteImage?.();
-            return;
+        setText(text) {
+            if (text.length > 0)
+                this.#promptSuggestion = null;
+            super.setText(text);
         }
-        if (this.keybindings.matches(data, "app.interrupt")) {
-            if (!this.isShowingAutocomplete()) {
-                const handler = this.onEscape ?? this.actionHandlers.get("app.interrupt");
-                if (handler) {
+        render(width) {
+            if (this.#promptPrefix.length === 0)
+                return super.render(width);
+            if (this.#promptSuggestion !== null && this.canPresentPromptSuggestion()) {
+                return this.#renderSuggestion(width);
+            }
+            return this.#renderPrefixedEditor(width);
+        }
+        onAction(action, handler) { this.actionHandlers.set(action, handler); }
+        handleInput(data) {
+            if (this.onExtensionShortcut?.(data))
+                return;
+            if (this.#promptSuggestion !== null
+                && !this.isShowingAutocomplete()
+                && this.canPresentPromptSuggestion()
+                && this.keybindings.matches(data, "tui.input.submit")) {
+                return;
+            }
+            if (this.#promptSuggestion !== null
+                && !this.isShowingAutocomplete()
+                && this.canPresentPromptSuggestion()
+                && this.keybindings.matches(data, "tui.input.tab")) {
+                const accepted = this.#promptSuggestion;
+                this.#promptSuggestion = null;
+                super.setText(accepted);
+                this.onPromptSuggestionAccepted?.(accepted);
+                return;
+            }
+            if (this.keybindings.matches(data, "app.clipboard.pasteImage")) {
+                this.onPasteImage?.();
+                return;
+            }
+            if (this.keybindings.matches(data, "app.interrupt")) {
+                if (!this.isShowingAutocomplete()) {
+                    const handler = this.onEscape ?? this.actionHandlers.get("app.interrupt");
+                    if (handler) {
+                        handler();
+                        return;
+                    }
+                }
+                super.handleInput(data);
+                return;
+            }
+            if (this.keybindings.matches(data, "app.exit") && this.getText().length === 0) {
+                const handler = this.onCtrlD ?? this.actionHandlers.get("app.exit");
+                if (handler)
+                    handler();
+                return;
+            }
+            if (this.keybindings.matches(data, "tui.editor.historyPrevious") || this.keybindings.matches(data, "tui.editor.historyNext")) {
+                super.handleInput(data);
+                return;
+            }
+            for (const [action, handler] of this.actionHandlers) {
+                if (action !== "app.interrupt" && action !== "app.exit" && this.keybindings.matches(data, action)) {
                     handler();
                     return;
                 }
             }
             super.handleInput(data);
-            return;
         }
-        if (this.keybindings.matches(data, "app.exit") && this.getText().length === 0) {
-            const handler = this.onCtrlD ?? this.actionHandlers.get("app.exit");
-            if (handler)
-                handler();
-            return;
-        }
-        if (this.keybindings.matches(data, "tui.editor.historyPrevious") || this.keybindings.matches(data, "tui.editor.historyNext")) {
-            super.handleInput(data);
-            return;
+        #renderSuggestion(width) {
+            const prefixWidth = visibleWidth(this.#promptPrefix);
+            const innerWidth = Math.max(1, width - prefixWidth);
+            const maxPadding = Math.max(0, Math.floor((innerWidth - 1) / 2));
+            const paddingX = Math.min(this.getPaddingX(), maxPadding);
+            const contentWidth = Math.max(1, innerWidth - paddingX * 2);
+            const layoutWidth = Math.max(1, contentWidth - (paddingX ? 0 : 1));
+            const chunks = wrapTextWithAnsi(this.#promptSuggestion ?? "", layoutWidth).map(text => ({ text }));
+            const maxVisible = Math.max(5, Math.floor(this.#terminalRows() * 0.3));
+            const visible = chunks.slice(0, maxVisible);
+            const horizontal = this.borderColor("─".repeat(Math.max(0, width)));
+            const leftPadding = " ".repeat(paddingX);
+            const rightPadding = leftPadding;
+            const rows = visible.map((chunk, index) => {
+                let content;
+                if (index === 0) {
+                    const first = [...PROMPT_GRAPHEMES.segment(chunk.text)][0]?.segment ?? " ";
+                    const remaining = chunk.text.slice(first === " " && chunk.text.length === 0 ? 0 : first.length);
+                    const marker = this.focused ? CURSOR_MARKER : "";
+                    content = `${marker}${this.#styleSuggestionCaret(first)}${this.#styleSuggestion(remaining)}`;
+                }
+                else {
+                    content = this.#styleSuggestion(chunk.text);
+                }
+                const plainWidth = visibleWidth(chunk.text);
+                const padding = " ".repeat(Math.max(0, contentWidth - plainWidth));
+                const prefix = index === 0 ? this.#promptPrefix : " ".repeat(prefixWidth);
+                return truncateToWidth(`${prefix}${leftPadding}${content}${padding}${rightPadding}`, width);
+            });
+            return [horizontal, ...rows, horizontal];
         }
-        for (const [action, handler] of this.actionHandlers) {
-            if (action !== "app.interrupt" && action !== "app.exit" && this.keybindings.matches(data, action)) {
-                handler();
-                return;
-            }
+        #renderPrefixedEditor(width) {
+            const prefixWidth = visibleWidth(this.#promptPrefix);
+            const innerWidth = Math.max(1, width - prefixWidth);
+            const rows = super.render(innerWidth);
+            const maxPadding = Math.max(0, Math.floor((innerWidth - 1) / 2));
+            const paddingX = Math.min(this.getPaddingX(), maxPadding);
+            const contentWidth = Math.max(1, innerWidth - paddingX * 2);
+            const layoutWidth = Math.max(1, contentWidth - (paddingX ? 0 : 1));
+            const layoutCount = this.getLines().flatMap(line => wrapTextWithAnsi(line, layoutWidth)).length || 1;
+            const visibleCount = Math.min(layoutCount, Math.max(5, Math.floor(this.#terminalRows() * 0.3)));
+            const bottomBorder = visibleCount + 1;
+            return rows.map((row, index) => {
+                if (index === 0 || index === bottomBorder)
+                    return `${row}${this.borderColor("─".repeat(prefixWidth))}`;
+                return `${index === 1 ? this.#promptPrefix : " ".repeat(prefixWidth)}${row}`;
+            });
         }
-        super.handleInput(data);
-    }
-    #renderSuggestion(width) {
-        const prefixWidth = visibleWidth(this.#promptPrefix);
-        const innerWidth = Math.max(1, width - prefixWidth);
-        const maxPadding = Math.max(0, Math.floor((innerWidth - 1) / 2));
-        const paddingX = Math.min(this.getPaddingX(), maxPadding);
-        const contentWidth = Math.max(1, innerWidth - paddingX * 2);
-        const layoutWidth = Math.max(1, contentWidth - (paddingX ? 0 : 1));
-        const chunks = wrapTextWithAnsi(this.#promptSuggestion ?? "", layoutWidth).map(text => ({ text }));
-        const maxVisible = Math.max(5, Math.floor(this.#terminalRows() * 0.3));
-        const visible = chunks.slice(0, maxVisible);
-        const horizontal = this.borderColor("─".repeat(Math.max(0, width)));
-        const leftPadding = " ".repeat(paddingX);
-        const rightPadding = leftPadding;
-        const rows = visible.map((chunk, index) => {
-            let content;
-            if (index === 0) {
-                const first = [...PROMPT_GRAPHEMES.segment(chunk.text)][0]?.segment ?? " ";
-                const remaining = chunk.text.slice(first === " " && chunk.text.length === 0 ? 0 : first.length);
-                const marker = this.focused ? CURSOR_MARKER : "";
-                content = `${marker}${this.#styleSuggestionCaret(first)}${this.#styleSuggestion(remaining)}`;
-            }
-            else {
-                content = this.#styleSuggestion(chunk.text);
-            }
-            const plainWidth = visibleWidth(chunk.text);
-            const padding = " ".repeat(Math.max(0, contentWidth - plainWidth));
-            const prefix = index === 0 ? this.#promptPrefix : " ".repeat(prefixWidth);
-            return truncateToWidth(`${prefix}${leftPadding}${content}${padding}${rightPadding}`, width);
-        });
-        return [horizontal, ...rows, horizontal];
-    }
-    #renderPrefixedEditor(width) {
-        const prefixWidth = visibleWidth(this.#promptPrefix);
-        const innerWidth = Math.max(1, width - prefixWidth);
-        const rows = super.render(innerWidth);
-        const maxPadding = Math.max(0, Math.floor((innerWidth - 1) / 2));
-        const paddingX = Math.min(this.getPaddingX(), maxPadding);
-        const contentWidth = Math.max(1, innerWidth - paddingX * 2);
-        const layoutWidth = Math.max(1, contentWidth - (paddingX ? 0 : 1));
-        const layoutCount = this.getLines().flatMap(line => wrapTextWithAnsi(line, layoutWidth)).length || 1;
-        const visibleCount = Math.min(layoutCount, Math.max(5, Math.floor(this.#terminalRows() * 0.3)));
-        const bottomBorder = visibleCount + 1;
-        return rows.map((row, index) => {
-            if (index === 0 || index === bottomBorder)
-                return `${row}${this.borderColor("─".repeat(prefixWidth))}`;
-            return `${index === 1 ? this.#promptPrefix : " ".repeat(prefixWidth)}${row}`;
-        });
-    }
+    };
+}
+export class OwnedEditor extends createOwnedEditorClass(Editor) {
 }

package/dist/integrations/pi/components/upstream/history/editor-core.d.ts

@@ -0,0 +1,280 @@
+/**
+ * Adapted from @earendil-works/pi-tui 0.84.2, packages/tui/src/components/editor.ts (MIT).
+ * Source commit: 914cf1472e715297caa30db4b9535d534a9eb718.
+ * Modifications: public imports and owned editor-local typed seams; see docs/architecture/history-editor-provenance.md.
+ */
+import { type AutocompleteProvider, type Component, type Focusable, type TUI, type SelectListTheme } from "#pi-tui";
+import type { EditorInteractionPort, EditorRecallPort } from "../../editor-interaction.js";
+/**
+ * Represents a chunk of text for word-wrap layout.
+ * Tracks both the text content and its position in the original line.
+ */
+export interface TextChunk {
+    text: string;
+    startIndex: number;
+    endIndex: number;
+}
+/**
+ * Split a line into word-wrapped chunks.
+ * Wraps at word boundaries when possible, falling back to character-level
+ * wrapping for words longer than the available width.
+ *
+ * @param line - The text line to wrap
+ * @param maxWidth - Maximum visible width per chunk
+ * @param preSegmented - Optional pre-segmented graphemes (e.g. with paste-marker awareness).
+ *                       When omitted the default Intl.Segmenter is used.
+ * @returns Array of chunks with text and position information
+ */
+export declare function wordWrapLine(line: string, maxWidth: number, preSegmented?: Intl.SegmentData[]): TextChunk[];
+export interface EditorTheme {
+    borderColor: (str: string) => string;
+    selectList: SelectListTheme;
+}
+export interface EditorOptions {
+    persistentHistory?: boolean;
+    styleHistoryLabel?: (text: string) => string;
+    paddingX?: number;
+    autocompleteMaxVisible?: number;
+}
+export declare class HistoryEditorCore implements Component, Focusable {
+    private segmentTransform;
+    readonly interaction: EditorInteractionPort;
+    private state;
+    /** Focusable interface - set by TUI when focus changes */
+    focused: boolean;
+    protected tui: TUI;
+    private theme;
+    private paddingX;
+    private lastWidth;
+    private scrollOffset;
+    borderColor: (str: string) => string;
+    private autocompleteProvider?;
+    private autocompleteTriggerCharacters;
+    private autocompleteTriggerPattern;
+    private autocompleteDebouncePattern;
+    private autocompleteList;
+    private autocompleteState;
+    private autocompletePrefix;
+    private autocompleteMaxVisible;
+    private autocompleteAbort;
+    private autocompleteDebounceTimer;
+    private autocompleteRequestTask;
+    private autocompleteStartToken;
+    private autocompleteRequestId;
+    private pastes;
+    private pasteCounter;
+    private pasteBuffer;
+    private isInPaste;
+    private history;
+    private historyIndex;
+    private historyDraft;
+    readonly recall: EditorRecallPort;
+    private persistentHistory;
+    private readonly styleHistoryLabel;
+    private historyPasteDraft;
+    private pendingHistory;
+    onHistoryChange?: (state: {
+        readonly index: number;
+        readonly total: number;
+    }) => void;
+    configurePersistentHistory(enabled: boolean): void;
+    replaceHistoryEntries(entries: readonly string[]): void;
+    getHistoryPosition(): {
+        readonly index: number;
+        readonly total: number;
+    };
+    resetHistoryBrowsing(): void;
+    private applyPendingHistory;
+    private notifyHistory;
+    private killRing;
+    private lastAction;
+    private jumpMode;
+    private preferredVisualCol;
+    private snappedFromCursorCol;
+    private undoStack;
+    onSubmit?: (text: string) => void;
+    onChange?: (text: string) => void;
+    disableSubmit: boolean;
+    constructor(tui: TUI, theme: EditorTheme, options?: EditorOptions);
+    /** Set of currently valid paste IDs, for marker-aware segmentation. */
+    private validPasteIds;
+    /** Segment text with paste-marker awareness, only merging markers with valid IDs. */
+    private segment;
+    getPaddingX(): number;
+    setPaddingX(padding: number): void;
+    getAutocompleteMaxVisible(): number;
+    setAutocompleteMaxVisible(maxVisible: number): void;
+    setAutocompleteProvider(provider: AutocompleteProvider): void;
+    /**
+     * Add a prompt to history for up/down arrow navigation.
+     * Called after successful submission.
+     */
+    addToHistory(text: string): void;
+    private isEditorEmpty;
+    private isOnFirstVisualLine;
+    private isOnLastVisualLine;
+    private navigateHistory;
+    private exitHistoryBrowsing;
+    /** Internal setText that doesn't reset history state - used by navigateHistory */
+    private setTextInternal;
+    invalidate(): void;
+    render(width: number): string[];
+    handleInput(data: string): void;
+    private layoutText;
+    getText(): string;
+    private expandPasteMarkers;
+    /**
+     * Get text with paste markers expanded to their actual content.
+     * Use this when you need the full content (e.g., for external editor).
+     */
+    getExpandedText(): string;
+    getLines(): string[];
+    getCursor(): {
+        line: number;
+        col: number;
+    };
+    setText(text: string): void;
+    /**
+     * Insert text at the current cursor position.
+     * Used for programmatic insertion (e.g., clipboard image markers).
+     * This is atomic for undo - single undo restores entire pre-insert state.
+     */
+    insertTextAtCursor(text: string): void;
+    /**
+     * Normalize text for editor storage:
+     * - Normalize line endings (\r\n and \r -> \n)
+     * - Expand tabs to 4 spaces
+     */
+    private normalizeText;
+    /**
+     * Internal text insertion at cursor. Handles single and multi-line text.
+     * Does not push undo snapshots or trigger autocomplete - caller is responsible.
+     * Normalizes line endings and calls onChange once at the end.
+     */
+    private insertTextAtCursorInternal;
+    private insertCharacter;
+    private handlePaste;
+    private addNewLine;
+    private shouldSubmitOnBackslashEnter;
+    private submitValue;
+    private handleBackspace;
+    /**
+     * Set cursor column and clear preferredVisualCol.
+     * Use this for all non-vertical cursor movements to reset sticky column behavior.
+     */
+    private setCursorCol;
+    /**
+     * Move cursor to a target visual line, applying sticky column logic.
+     * Shared by moveCursor() and pageScroll().
+     */
+    private moveToVisualLine;
+    /**
+     * Compute the target visual column for vertical cursor movement.
+     * Implements the sticky column decision table:
+     *
+     * | P | S | T | U | Scenario                                             | Set Preferred | Move To     |
+     * |---|---|---|---| ---------------------------------------------------- |---------------|-------------|
+     * | 0 | * | 0 | - | Start nav, target fits                               | null          | current     |
+     * | 0 | * | 1 | - | Start nav, target shorter                            | current       | target end  |
+     * | 1 | 0 | 0 | 0 | Clamped, target fits preferred                       | null          | preferred   |
+     * | 1 | 0 | 0 | 1 | Clamped, target longer but still can't fit preferred | keep          | target end  |
+     * | 1 | 0 | 1 | - | Clamped, target even shorter                         | keep          | target end  |
+     * | 1 | 1 | 0 | - | Rewrapped, target fits current                       | null          | current     |
+     * | 1 | 1 | 1 | - | Rewrapped, target shorter than current               | current       | target end  |
+     *
+     * Where:
+     * - P = preferred col is set
+     * - S = cursor in middle of source line (not clamped to end)
+     * - T = target line shorter than current visual col
+     * - U = target line shorter than preferred col
+     */
+    private computeVerticalMoveColumn;
+    private moveToLineStart;
+    private moveToLineEnd;
+    private deleteToStartOfLine;
+    private deleteToEndOfLine;
+    private deleteWordBackwards;
+    private deleteWordForward;
+    private handleForwardDelete;
+    /**
+     * Build a mapping from visual lines to logical positions.
+     * Returns an array where each element represents a visual line with:
+     * - logicalLine: index into this.state.lines
+     * - startCol: starting column in the logical line
+     * - length: length of this visual line segment
+     */
+    private buildVisualLineMap;
+    /**
+     * Find the visual line index that contains the given logical position.
+     */
+    private findVisualLineAt;
+    /**
+     * Find the visual line index for the current cursor position.
+     */
+    private findCurrentVisualLine;
+    private moveCursor;
+    /**
+     * Scroll by a page (direction: -1 for up, 1 for down).
+     * Moves cursor by the page size while keeping it in bounds.
+     */
+    private pageScroll;
+    private moveWordBackwards;
+    /**
+     * Yank (paste) the most recent kill ring entry at cursor position.
+     */
+    private yank;
+    /**
+     * Cycle through kill ring (only works immediately after yank or yank-pop).
+     * Replaces the last yanked text with the previous entry in the ring.
+     */
+    private yankPop;
+    /**
+     * Insert text at cursor position (used by yank operations).
+     */
+    private insertYankedText;
+    /**
+     * Delete the previously yanked text (used by yank-pop).
+     * The yanked text is derived from killRing[end] since it hasn't been rotated yet.
+     */
+    private deleteYankedText;
+    private pushUndoSnapshot;
+    private undo;
+    /**
+     * Jump to the first occurrence of a character in the specified direction.
+     * Multi-line search. Case-sensitive. Skips the current cursor position.
+     */
+    private jumpToChar;
+    private moveWordForwards;
+    private isSlashMenuAllowed;
+    private isAtStartOfMessage;
+    private isInSlashCommandContext;
+    /**
+     * Find the best autocomplete item index for the given prefix.
+     * Returns -1 if no match is found.
+     *
+     * Match priority:
+     * 1. Exact match (prefix === item.value) -> always selected
+     * 2. Prefix match -> first item whose value starts with prefix
+     * 3. No match -> -1 (keep default highlight)
+     *
+     * Matching is case-sensitive and checks item.value only.
+     */
+    private getBestAutocompleteMatchIndex;
+    private createAutocompleteList;
+    private tryTriggerAutocomplete;
+    private handleTabCompletion;
+    private handleSlashCommandCompletion;
+    private forceFileAutocomplete;
+    private requestAutocomplete;
+    private startAutocompleteRequest;
+    private setAutocompleteTriggerCharacters;
+    private getAutocompleteDebounceMs;
+    private runAutocompleteRequest;
+    private isAutocompleteRequestCurrent;
+    private applyAutocompleteSuggestions;
+    private cancelAutocompleteRequest;
+    private clearAutocompleteUi;
+    private cancelAutocomplete;
+    isShowingAutocomplete(): boolean;
+    private updateAutocomplete;
+}