@andorra-labs/code 0.0.0-stage → 0.1.4

package/dist/vendor/engine/runtime/tui/components/h-stack.d.ts

@@ -0,0 +1,6 @@
+import { AndorraStack, type StackChild, type StackOptions } from "./stack.js";
+export declare class AndorraHStack extends AndorraStack {
+    protected readonly layoutType: "hstack";
+    constructor(children?: StackChild[], options?: StackOptions);
+    render(width: number): string[];
+}

package/dist/vendor/engine/runtime/tui/components/h-stack.js

@@ -0,0 +1,42 @@
+import { andorraCompositeTuiLine } from "../tui.js";
+import { andorraVisibleWidth } from "../utils.js";
+import { andorraAllocateStackSizes, AndorraStack, andorraVisibleStackEntries } from "./stack.js";
+export class AndorraHStack extends AndorraStack {
+    layoutType = "hstack";
+    constructor(children = [], options = {}) {
+        super(children, options);
+    }
+    render(width) {
+        const safeWidth = Math.max(1, width);
+        const viewport = { width: safeWidth, height: Number.MAX_SAFE_INTEGER };
+        const entries = andorraVisibleStackEntries(this.entries, viewport);
+        if (entries.length === 0)
+            return [];
+        const intrinsicWidths = entries.map((entry) => {
+            const lines = entry.component.render(safeWidth);
+            return lines.reduce((max, line) => Math.max(max, andorraVisibleWidth(line)), 0);
+        });
+        const widths = andorraAllocateStackSizes(entries, intrinsicWidths, safeWidth, this.gap);
+        const rendered = entries.map((entry, index) => widths[index] === 0 ? [] : entry.component.render(widths[index]));
+        const height = rendered.reduce((max, lines) => Math.max(max, lines.length), 0);
+        const result = Array.from({ length: height }, () => "");
+        let x = 0;
+        for (let index = 0; index < rendered.length; index++) {
+            const lines = rendered[index];
+            const childWidth = widths[index];
+            let offset = 0;
+            if (this.align === "center")
+                offset = Math.floor((height - lines.length) / 2);
+            else if (this.align === "end")
+                offset = height - lines.length;
+            for (let row = 0; row < lines.length; row++) {
+                const target = row + offset;
+                if (target < 0 || target >= result.length)
+                    continue;
+                result[target] = andorraCompositeTuiLine(result[target], lines[row], x, childWidth, safeWidth);
+            }
+            x += childWidth + this.gap;
+        }
+        return result;
+    }
+}

package/dist/vendor/engine/runtime/tui/components/image.d.ts

@@ -0,0 +1,27 @@
+import { type ImageDimensions } from "../terminal-image.js";
+import type { Component } from "../tui.js";
+export interface ImageTheme {
+    fallbackColor: (str: string) => string;
+}
+export interface ImageOptions {
+    maxWidthCells?: number;
+    maxHeightCells?: number;
+    filename?: string;
+    /** Kitty image ID. If provided, reuses this ID (for animations/updates). */
+    imageId?: number;
+}
+export declare class AndorraImage implements Component {
+    private base64Data;
+    private mimeType;
+    private dimensions;
+    private theme;
+    private options;
+    private imageId?;
+    private cachedLines?;
+    private cachedWidth?;
+    constructor(base64Data: string, mimeType: string, theme: ImageTheme, options?: ImageOptions, dimensions?: ImageDimensions);
+    /** Get the Kitty image ID used by this image (if any). */
+    getImageId(): number | undefined;
+    invalidate(): void;
+    render(width: number): string[];
+}

package/dist/vendor/engine/runtime/tui/components/image.js

@@ -0,0 +1,89 @@
+import { andorraAllocateImageId, andorraGetCapabilities, andorraGetCellDimensions, andorraGetImageDimensions, andorraImageFallback, andorraRenderImage, } from "../terminal-image.js";
+import { andorraTruncateToWidth } from "../utils.js";
+export class AndorraImage {
+    base64Data;
+    mimeType;
+    dimensions;
+    theme;
+    options;
+    imageId;
+    cachedLines;
+    cachedWidth;
+    constructor(base64Data, mimeType, theme, options = {}, dimensions) {
+        this.base64Data = base64Data;
+        this.mimeType = mimeType;
+        this.theme = theme;
+        this.options = options;
+        this.dimensions = dimensions || andorraGetImageDimensions(base64Data, mimeType) || { widthPx: 800, heightPx: 600 };
+        this.imageId = options.imageId;
+    }
+    /** Get the Kitty image ID used by this image (if any). */
+    getImageId() {
+        return this.imageId;
+    }
+    invalidate() {
+        this.cachedLines = undefined;
+        this.cachedWidth = undefined;
+    }
+    render(width) {
+        if (this.cachedLines && this.cachedWidth === width) {
+            return this.cachedLines;
+        }
+        const maxWidth = Math.max(1, Math.min(width - 2, this.options.maxWidthCells ?? 60));
+        const cellDimensions = andorraGetCellDimensions();
+        const defaultMaxHeight = Math.max(1, Math.ceil((maxWidth * cellDimensions.widthPx) / cellDimensions.heightPx));
+        const maxHeight = this.options.maxHeightCells ?? defaultMaxHeight;
+        const caps = andorraGetCapabilities();
+        let lines;
+        if (caps.images) {
+            if (caps.images === "kitty" && this.imageId === undefined) {
+                this.imageId = andorraAllocateImageId();
+            }
+            const result = andorraRenderImage(this.base64Data, this.dimensions, {
+                maxWidthCells: maxWidth,
+                maxHeightCells: maxHeight,
+                imageId: this.imageId,
+                moveCursor: false,
+            });
+            if (result) {
+                // Store the image ID for later cleanup
+                if (result.imageId) {
+                    this.imageId = result.imageId;
+                }
+                if (caps.images === "kitty") {
+                    // For Kitty: C=1 prevents cursor movement.
+                    // Don't need the cursor movement.
+                    lines = [result.sequence];
+                    // Return `rows` lines so TUI accounts for image height.
+                    for (let i = 0; i < result.rows - 1; i++) {
+                        lines.push("");
+                    }
+                }
+                else {
+                    // Return `rows` lines so TUI accounts for image height.
+                    // First (rows-1) lines are empty and cleared before the image is drawn.
+                    // Last line: move cursor back up, draw the image, then move back down
+                    // so TUI cursor accounting stays inside the scroll area.
+                    lines = [];
+                    for (let i = 0; i < result.rows - 1; i++) {
+                        lines.push("");
+                    }
+                    const rowOffset = result.rows - 1;
+                    const moveUp = rowOffset > 0 ? `\x1b[${rowOffset}A` : "";
+                    lines.push(moveUp + result.sequence);
+                }
+            }
+            else {
+                const fallback = andorraImageFallback(this.mimeType, this.dimensions, this.options.filename);
+                lines = [andorraTruncateToWidth(this.theme.fallbackColor(fallback), width)];
+            }
+        }
+        else {
+            const fallback = andorraImageFallback(this.mimeType, this.dimensions, this.options.filename);
+            lines = [andorraTruncateToWidth(this.theme.fallbackColor(fallback), width)];
+        }
+        this.cachedLines = lines;
+        this.cachedWidth = width;
+        return lines;
+    }
+}

package/dist/vendor/engine/runtime/tui/components/input.d.ts

@@ -0,0 +1,47 @@
+import { type Component, type Focusable, type TuiMouseEvent, type TuiMouseEventResult } from "../tui.js";
+export interface InputOptions {
+    prompt?: string;
+    placeholder?: string;
+    placeholderStyle?: (text: string) => string;
+}
+/**
+ * Input component - single-line text input with horizontal scrolling
+ */
+export declare class AndorraInput implements Component, Focusable {
+    private value;
+    private cursor;
+    private readonly prompt;
+    private readonly placeholder;
+    private readonly placeholderStyle;
+    private renderedStartColumn;
+    onSubmit?: (value: string) => void;
+    onEscape?: () => void;
+    /** Focusable interface - set by TUI when focus changes */
+    focused: boolean;
+    private pasteBuffer;
+    private isInPaste;
+    private killRing;
+    private lastAction;
+    private undoStack;
+    constructor(options?: InputOptions);
+    getValue(): string;
+    setValue(value: string): void;
+    handleInput(data: string): void;
+    handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined;
+    private insertCharacter;
+    private handleBackspace;
+    private handleForwardDelete;
+    private deleteToLineStart;
+    private deleteToLineEnd;
+    private deleteWordBackwards;
+    private deleteWordForward;
+    private yank;
+    private yankPop;
+    private pushUndo;
+    private undo;
+    private moveWordBackwards;
+    private moveWordForwards;
+    private handlePaste;
+    invalidate(): void;
+    render(width: number): string[];
+}

package/dist/vendor/engine/runtime/tui/components/input.js

@@ -0,0 +1,416 @@
+import { andorraGetKeybindings } from "../keybindings.js";
+import { andorraDecodeKittyPrintable } from "../keys.js";
+import { AndorraKillRing } from "../kill-ring.js";
+import { CURSOR_MARKER } from "../tui.js";
+import { AndorraUndoStack } from "../undo-stack.js";
+import { andorraGetGraphemeSegmenter, andorraIsWhitespaceChar, andorraSliceByColumn, andorraTruncateToWidth, andorraVisibleWidth } from "../utils.js";
+import { andorraFindWordBackward, andorraFindWordForward } from "../word-navigation.js";
+const segmenter = andorraGetGraphemeSegmenter();
+/**
+ * Input component - single-line text input with horizontal scrolling
+ */
+export class AndorraInput {
+    value = "";
+    cursor = 0; // Cursor position in the value
+    prompt;
+    placeholder;
+    placeholderStyle;
+    renderedStartColumn = 0;
+    onSubmit;
+    onEscape;
+    /** Focusable interface - set by TUI when focus changes */
+    focused = false;
+    // Bracketed paste mode buffering
+    pasteBuffer = "";
+    isInPaste = false;
+    // Kill ring for Emacs-style kill/yank operations
+    killRing = new AndorraKillRing();
+    lastAction = null;
+    // Undo support
+    undoStack = new AndorraUndoStack();
+    constructor(options = {}) {
+        this.prompt = options.prompt ?? "> ";
+        this.placeholder = options.placeholder ?? "";
+        this.placeholderStyle = options.placeholderStyle ?? ((text) => text);
+    }
+    getValue() {
+        return this.value;
+    }
+    setValue(value) {
+        this.value = value;
+        this.cursor = Math.min(this.cursor, value.length);
+    }
+    handleInput(data) {
+        // Handle bracketed paste mode
+        // Start of paste: \x1b[200~
+        // End of paste: \x1b[201~
+        // Check if we're starting a bracketed paste
+        if (data.includes("\x1b[200~")) {
+            this.isInPaste = true;
+            this.pasteBuffer = "";
+            data = data.replace("\x1b[200~", "");
+        }
+        // If we're in a paste, buffer the data
+        if (this.isInPaste) {
+            // Check if this chunk contains the end marker
+            this.pasteBuffer += data;
+            const endIndex = this.pasteBuffer.indexOf("\x1b[201~");
+            if (endIndex !== -1) {
+                // Extract the pasted content
+                const pasteContent = this.pasteBuffer.substring(0, endIndex);
+                // Process the complete paste
+                this.handlePaste(pasteContent);
+                // Reset paste state
+                this.isInPaste = false;
+                // Handle any remaining input after the paste marker
+                const remaining = this.pasteBuffer.substring(endIndex + 6); // 6 = length of \x1b[201~
+                this.pasteBuffer = "";
+                if (remaining) {
+                    this.handleInput(remaining);
+                }
+            }
+            return;
+        }
+        const kb = andorraGetKeybindings();
+        // Escape/Cancel
+        if (kb.matches(data, "tui.select.cancel")) {
+            if (this.onEscape)
+                this.onEscape();
+            return;
+        }
+        // Undo
+        if (kb.matches(data, "tui.editor.undo")) {
+            this.undo();
+            return;
+        }
+        // Submit
+        if (kb.matches(data, "tui.input.submit") || data === "\n") {
+            if (this.onSubmit)
+                this.onSubmit(this.value);
+            return;
+        }
+        // Deletion
+        if (kb.matches(data, "tui.editor.deleteCharBackward")) {
+            this.handleBackspace();
+            return;
+        }
+        if (kb.matches(data, "tui.editor.deleteCharForward")) {
+            this.handleForwardDelete();
+            return;
+        }
+        if (kb.matches(data, "tui.editor.deleteWordBackward")) {
+            this.deleteWordBackwards();
+            return;
+        }
+        if (kb.matches(data, "tui.editor.deleteWordForward")) {
+            this.deleteWordForward();
+            return;
+        }
+        if (kb.matches(data, "tui.editor.deleteToLineStart")) {
+            this.deleteToLineStart();
+            return;
+        }
+        if (kb.matches(data, "tui.editor.deleteToLineEnd")) {
+            this.deleteToLineEnd();
+            return;
+        }
+        // Kill ring actions
+        if (kb.matches(data, "tui.editor.yank")) {
+            this.yank();
+            return;
+        }
+        if (kb.matches(data, "tui.editor.yankPop")) {
+            this.yankPop();
+            return;
+        }
+        // Cursor movement
+        if (kb.matches(data, "tui.editor.cursorLeft")) {
+            this.lastAction = null;
+            if (this.cursor > 0) {
+                const beforeCursor = this.value.slice(0, this.cursor);
+                const graphemes = [...segmenter.segment(beforeCursor)];
+                const lastGrapheme = graphemes[graphemes.length - 1];
+                this.cursor -= lastGrapheme ? lastGrapheme.segment.length : 1;
+            }
+            return;
+        }
+        if (kb.matches(data, "tui.editor.cursorRight")) {
+            this.lastAction = null;
+            if (this.cursor < this.value.length) {
+                const afterCursor = this.value.slice(this.cursor);
+                const graphemes = [...segmenter.segment(afterCursor)];
+                const firstGrapheme = graphemes[0];
+                this.cursor += firstGrapheme ? firstGrapheme.segment.length : 1;
+            }
+            return;
+        }
+        if (kb.matches(data, "tui.editor.cursorLineStart")) {
+            this.lastAction = null;
+            this.cursor = 0;
+            return;
+        }
+        if (kb.matches(data, "tui.editor.cursorLineEnd")) {
+            this.lastAction = null;
+            this.cursor = this.value.length;
+            return;
+        }
+        if (kb.matches(data, "tui.editor.cursorWordLeft")) {
+            this.moveWordBackwards();
+            return;
+        }
+        if (kb.matches(data, "tui.editor.cursorWordRight")) {
+            this.moveWordForwards();
+            return;
+        }
+        // Kitty CSI-u printable character (e.g. \x1b[97u for 'a').
+        // Terminals with Kitty protocol flag 1 (disambiguate) send CSI-u for all keys,
+        // including plain printable characters. Decode before the control-char check
+        // since CSI-u sequences contain \x1b which would be rejected.
+        const kittyPrintable = andorraDecodeKittyPrintable(data);
+        if (kittyPrintable !== undefined) {
+            this.insertCharacter(kittyPrintable);
+            return;
+        }
+        // Regular character input - accept printable characters including Unicode,
+        // but reject control characters (C0: 0x00-0x1F, DEL: 0x7F, C1: 0x80-0x9F)
+        const hasControlChars = [...data].some((ch) => {
+            const code = ch.charCodeAt(0);
+            return code < 32 || code === 0x7f || (code >= 0x80 && code <= 0x9f);
+        });
+        if (!hasControlChars) {
+            this.insertCharacter(data);
+        }
+    }
+    handleMouse(event) {
+        if (event.type !== "press" || event.button !== "left" || event.y !== 0)
+            return undefined;
+        const visibleColumn = Math.max(0, event.x - 2);
+        const targetColumn = this.renderedStartColumn + visibleColumn;
+        let currentColumn = 0;
+        this.cursor = this.value.length;
+        for (const grapheme of segmenter.segment(this.value)) {
+            const nextColumn = currentColumn + andorraVisibleWidth(grapheme.segment);
+            if (targetColumn < nextColumn) {
+                this.cursor = grapheme.index;
+                break;
+            }
+            currentColumn = nextColumn;
+        }
+        this.lastAction = null;
+        return { handled: true, focus: true };
+    }
+    insertCharacter(char) {
+        // Undo coalescing: consecutive word chars coalesce into one undo unit
+        if (andorraIsWhitespaceChar(char) || this.lastAction !== "type-word") {
+            this.pushUndo();
+        }
+        this.lastAction = "type-word";
+        this.value = this.value.slice(0, this.cursor) + char + this.value.slice(this.cursor);
+        this.cursor += char.length;
+    }
+    handleBackspace() {
+        this.lastAction = null;
+        if (this.cursor > 0) {
+            this.pushUndo();
+            const beforeCursor = this.value.slice(0, this.cursor);
+            const graphemes = [...segmenter.segment(beforeCursor)];
+            const lastGrapheme = graphemes[graphemes.length - 1];
+            const graphemeLength = lastGrapheme ? lastGrapheme.segment.length : 1;
+            this.value = this.value.slice(0, this.cursor - graphemeLength) + this.value.slice(this.cursor);
+            this.cursor -= graphemeLength;
+        }
+    }
+    handleForwardDelete() {
+        this.lastAction = null;
+        if (this.cursor < this.value.length) {
+            this.pushUndo();
+            const afterCursor = this.value.slice(this.cursor);
+            const graphemes = [...segmenter.segment(afterCursor)];
+            const firstGrapheme = graphemes[0];
+            const graphemeLength = firstGrapheme ? firstGrapheme.segment.length : 1;
+            this.value = this.value.slice(0, this.cursor) + this.value.slice(this.cursor + graphemeLength);
+        }
+    }
+    deleteToLineStart() {
+        if (this.cursor === 0)
+            return;
+        this.pushUndo();
+        const deletedText = this.value.slice(0, this.cursor);
+        this.killRing.push(deletedText, { prepend: true, accumulate: this.lastAction === "kill" });
+        this.lastAction = "kill";
+        this.value = this.value.slice(this.cursor);
+        this.cursor = 0;
+    }
+    deleteToLineEnd() {
+        if (this.cursor >= this.value.length)
+            return;
+        this.pushUndo();
+        const deletedText = this.value.slice(this.cursor);
+        this.killRing.push(deletedText, { prepend: false, accumulate: this.lastAction === "kill" });
+        this.lastAction = "kill";
+        this.value = this.value.slice(0, this.cursor);
+    }
+    deleteWordBackwards() {
+        if (this.cursor === 0)
+            return;
+        // Save lastAction before cursor movement (moveWordBackwards resets it)
+        const wasKill = this.lastAction === "kill";
+        this.pushUndo();
+        const oldCursor = this.cursor;
+        this.moveWordBackwards();
+        const deleteFrom = this.cursor;
+        this.cursor = oldCursor;
+        const deletedText = this.value.slice(deleteFrom, this.cursor);
+        this.killRing.push(deletedText, { prepend: true, accumulate: wasKill });
+        this.lastAction = "kill";
+        this.value = this.value.slice(0, deleteFrom) + this.value.slice(this.cursor);
+        this.cursor = deleteFrom;
+    }
+    deleteWordForward() {
+        if (this.cursor >= this.value.length)
+            return;
+        // Save lastAction before cursor movement (moveWordForwards resets it)
+        const wasKill = this.lastAction === "kill";
+        this.pushUndo();
+        const oldCursor = this.cursor;
+        this.moveWordForwards();
+        const deleteTo = this.cursor;
+        this.cursor = oldCursor;
+        const deletedText = this.value.slice(this.cursor, deleteTo);
+        this.killRing.push(deletedText, { prepend: false, accumulate: wasKill });
+        this.lastAction = "kill";
+        this.value = this.value.slice(0, this.cursor) + this.value.slice(deleteTo);
+    }
+    yank() {
+        const text = this.killRing.peek();
+        if (!text)
+            return;
+        this.pushUndo();
+        this.value = this.value.slice(0, this.cursor) + text + this.value.slice(this.cursor);
+        this.cursor += text.length;
+        this.lastAction = "yank";
+    }
+    yankPop() {
+        if (this.lastAction !== "yank" || this.killRing.length <= 1)
+            return;
+        this.pushUndo();
+        // Delete the previously yanked text (still at end of ring before rotation)
+        const prevText = this.killRing.peek() || "";
+        this.value = this.value.slice(0, this.cursor - prevText.length) + this.value.slice(this.cursor);
+        this.cursor -= prevText.length;
+        // Rotate and insert new entry
+        this.killRing.rotate();
+        const text = this.killRing.peek() || "";
+        this.value = this.value.slice(0, this.cursor) + text + this.value.slice(this.cursor);
+        this.cursor += text.length;
+        this.lastAction = "yank";
+    }
+    pushUndo() {
+        this.undoStack.push({ value: this.value, cursor: this.cursor });
+    }
+    undo() {
+        const snapshot = this.undoStack.pop();
+        if (!snapshot)
+            return;
+        this.value = snapshot.value;
+        this.cursor = snapshot.cursor;
+        this.lastAction = null;
+    }
+    moveWordBackwards() {
+        if (this.cursor === 0)
+            return;
+        this.lastAction = null;
+        this.cursor = andorraFindWordBackward(this.value, this.cursor);
+    }
+    moveWordForwards() {
+        if (this.cursor >= this.value.length)
+            return;
+        this.lastAction = null;
+        this.cursor = andorraFindWordForward(this.value, this.cursor);
+    }
+    handlePaste(pastedText) {
+        this.lastAction = null;
+        this.pushUndo();
+        // Clean the pasted text - remove newlines and carriage returns
+        const cleanText = pastedText.replace(/\r\n/g, "").replace(/\r/g, "").replace(/\n/g, "").replace(/\t/g, "    ");
+        // Insert at cursor position
+        this.value = this.value.slice(0, this.cursor) + cleanText + this.value.slice(this.cursor);
+        this.cursor += cleanText.length;
+    }
+    invalidate() {
+        // No cached state to invalidate currently
+    }
+    render(width) {
+        // Calculate visible window
+        const availableWidth = width - andorraVisibleWidth(this.prompt);
+        if (availableWidth <= 0) {
+            return [andorraTruncateToWidth(this.prompt, width, "")];
+        }
+        if (this.value.length === 0 && this.placeholder) {
+            const placeholder = andorraTruncateToWidth(this.placeholder, availableWidth, "");
+            const graphemes = [...segmenter.segment(placeholder)];
+            const atCursor = graphemes[0]?.segment ?? " ";
+            const afterCursor = placeholder.slice(atCursor.length);
+            const marker = this.focused ? CURSOR_MARKER : "";
+            const cursorChar = `\x1b[7m${this.placeholderStyle(atCursor)}\x1b[27m`;
+            const textWithCursor = marker + cursorChar + this.placeholderStyle(afterCursor);
+            const padding = " ".repeat(Math.max(0, availableWidth - andorraVisibleWidth(textWithCursor)));
+            return [this.prompt + textWithCursor + padding];
+        }
+        let visibleText = "";
+        let cursorDisplay = this.cursor;
+        this.renderedStartColumn = 0;
+        const totalWidth = andorraVisibleWidth(this.value);
+        if (totalWidth < availableWidth) {
+            // Everything fits (leave room for cursor at end)
+            visibleText = this.value;
+        }
+        else {
+            // Need horizontal scrolling
+            // Reserve one column for cursor if it's at the end
+            const scrollWidth = this.cursor === this.value.length ? availableWidth - 1 : availableWidth;
+            const cursorCol = andorraVisibleWidth(this.value.slice(0, this.cursor));
+            if (scrollWidth > 0) {
+                const halfWidth = Math.floor(scrollWidth / 2);
+                let startCol = 0;
+                if (cursorCol < halfWidth) {
+                    // Cursor near start
+                    startCol = 0;
+                }
+                else if (cursorCol > totalWidth - halfWidth) {
+                    // Cursor near end
+                    startCol = Math.max(0, totalWidth - scrollWidth);
+                }
+                else {
+                    // Cursor in middle
+                    startCol = Math.max(0, cursorCol - halfWidth);
+                }
+                this.renderedStartColumn = startCol;
+                visibleText = andorraSliceByColumn(this.value, startCol, scrollWidth, true);
+                const beforeCursor = andorraSliceByColumn(this.value, startCol, Math.max(0, cursorCol - startCol), true);
+                cursorDisplay = beforeCursor.length;
+            }
+            else {
+                visibleText = "";
+                cursorDisplay = 0;
+            }
+        }
+        // Build line with fake cursor
+        // Insert cursor character at cursor position
+        const graphemes = [...segmenter.segment(visibleText.slice(cursorDisplay))];
+        const cursorGrapheme = graphemes[0];
+        const beforeCursor = visibleText.slice(0, cursorDisplay);
+        const atCursor = cursorGrapheme?.segment ?? " "; // Character at cursor, or space if at end
+        const afterCursor = visibleText.slice(cursorDisplay + atCursor.length);
+        // Hardware cursor marker (zero-width, emitted before fake cursor for IME positioning)
+        const marker = this.focused ? CURSOR_MARKER : "";
+        // Use inverse video to show cursor
+        const cursorChar = `\x1b[7m${atCursor}\x1b[27m`; // ESC[7m = reverse video, ESC[27m = normal
+        const textWithCursor = beforeCursor + marker + cursorChar + afterCursor;
+        // Calculate visual width
+        const visualLength = andorraVisibleWidth(textWithCursor);
+        const padding = " ".repeat(Math.max(0, availableWidth - visualLength));
+        const line = this.prompt + textWithCursor + padding;
+        return [line];
+    }
+}

package/dist/vendor/engine/runtime/tui/components/loader.d.ts

@@ -0,0 +1,32 @@
+import type { TUI } from "../tui.js";
+import { AndorraText } from "./text.js";
+export interface LoaderIndicatorOptions {
+    /** Animation frames. Use an empty array to hide the indicator. */
+    frames?: string[];
+    /** Frame interval in milliseconds for animated indicators. */
+    intervalMs?: number;
+}
+/**
+ * Loader component that updates with an optional spinning animation.
+ */
+export declare class AndorraLoader extends AndorraText {
+    private frames;
+    private intervalMs;
+    private currentFrame;
+    private intervalId;
+    private ui;
+    private renderIndicatorVerbatim;
+    private spinnerColorFn;
+    private messageColorFn;
+    private message;
+    constructor(ui: TUI, spinnerColorFn: (str: string) => string, messageColorFn: (str: string) => string, message?: string, indicator?: LoaderIndicatorOptions);
+    render(width: number): string[];
+    start(): void;
+    stop(): void;
+    setMessage(message: string): void;
+    invalidate(): void;
+    setIndicator(indicator?: LoaderIndicatorOptions): void;
+    private restartAnimation;
+    protected getRenderedIndicator(): string;
+    private updateDisplay;
+}