@timurproko/a1 0.1.8-dev.49ff83a → 0.1.8-dev.508

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

@@ -0,0 +1,1094 @@
+import { ImageAttachmentError, MAX_CLIPBOARD_TEXT_BYTES } from "../../../contracts/owned-ui/index.js";
+import { CURSOR_MARKER, decodeKittyPrintable, visibleWidth, } from "@earendil-works/pi-tui";
+import { promptPathWordRanges } from "./path-word-ranges.js";
+export class OwnedEditorUxInterception {
+    interceptors;
+    fallback;
+    constructor(interceptors, fallback) { this.interceptors = interceptors; this.fallback = fallback; }
+    handleInput(data) {
+        const invoke = (index, input) => {
+            const interceptor = this.interceptors[index];
+            if (interceptor === undefined) {
+                this.fallback.handleInput(input);
+                return;
+            }
+            interceptor.handleInput(input, (replacement = input) => invoke(index + 1, replacement));
+        };
+        invoke(0, data);
+    }
+    render(width) {
+        const invoke = (index) => {
+            const interceptor = this.interceptors[index];
+            return interceptor === undefined
+                ? this.fallback.render(width)
+                : interceptor.render(width, () => invoke(index + 1));
+        };
+        return invoke(0);
+    }
+    reset() {
+        for (const interceptor of this.interceptors)
+            interceptor.reset();
+    }
+    cancelPendingPastes() {
+        for (const interceptor of this.interceptors)
+            interceptor.cancelPendingPastes?.();
+    }
+    handlePointer(event) {
+        return this.interceptors.some(interceptor => interceptor.handlePointer?.(event) === true);
+    }
+    hasSelection() {
+        return this.interceptors.some(interceptor => interceptor.hasSelection?.() === true);
+    }
+    ownsPointer() {
+        return this.interceptors.some(interceptor => interceptor.ownsPointer?.() === true);
+    }
+    pasteClipboard() {
+        return this.interceptors.some(interceptor => interceptor.pasteClipboard?.() === true);
+    }
+}
+const ATOMIC_SEGMENTATION = Symbol("a1.editor.atomicSegmentation");
+const ATOMIC_SPACE_SENTINEL = "\uE000";
+const GRAPHEMES = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+const MULTI_CLICK_MS = 500;
+export function createPromptSelectionInterceptor(editor, keybindings, options) {
+    return new PromptSelectionInterceptor(editor, keybindings, options);
+}
+class PromptSelectionInterceptor {
+    #selection;
+    #pointerSelecting = false;
+    #lastClick;
+    #redoStack = [];
+    #selectionRevision = 0;
+    #pasteGeneration = 0;
+    #terminalPaste;
+    #wordDirection;
+    #geometry;
+    editor;
+    keybindings;
+    options;
+    constructor(editor, keybindings, options) {
+        this.editor = editor;
+        this.keybindings = keybindings;
+        this.options = options;
+        installAtomicSegmentation(editor, options.atomicRanges, () => this.#wordDirection);
+    }
+    handleInput(data, next) {
+        if (this.#handleTerminalPaste(data, next))
+            return;
+        if (this.keybindings.matches(data, "owned.editor.selectAll")) {
+            this.#selectAll();
+            return;
+        }
+        if (this.keybindings.matches(data, "owned.editor.extendLeft")) {
+            this.#extend(-1);
+            return;
+        }
+        if (this.keybindings.matches(data, "owned.editor.extendRight")) {
+            this.#extend(1);
+            return;
+        }
+        if (this.keybindings.matches(data, "tui.input.copy") && this.hasSelection()) {
+            this.options.copyText(this.options.expandCopiedText(this.#selectedText()));
+            this.#collapseCopiedSelection();
+            return;
+        }
+        if (this.keybindings.matches(data, "owned.editor.cut") && this.hasSelection()) {
+            this.options.copyText(this.options.expandCopiedText(this.#selectedText()));
+            if (!this.#deleteSelection())
+                this.#deleteAtomicFocus();
+            return;
+        }
+        if (this.keybindings.matches(data, "owned.editor.paste")) {
+            this.pasteClipboard();
+            return;
+        }
+        if (this.keybindings.matches(data, "owned.editor.redo")) {
+            this.#redo();
+            return;
+        }
+        if (this.keybindings.matches(data, "tui.editor.undo")) {
+            const before = this.#snapshot();
+            this.#clearSelection(false);
+            next();
+            if (!sameSnapshot(before, this.#snapshot()))
+                this.#redoStack.push(before);
+            this.#requestRender();
+            return;
+        }
+        const selection = this.#orderedSelection();
+        if (selection !== undefined) {
+            if (this.keybindings.matches(data, "tui.editor.deleteCharBackward")
+                || this.keybindings.matches(data, "tui.editor.deleteCharForward")
+                || this.keybindings.matches(data, "tui.editor.deleteWordBackward")
+                || this.keybindings.matches(data, "tui.editor.deleteWordForward")) {
+                this.#deleteSelection();
+                return;
+            }
+            const inserted = insertedText(data);
+            if (inserted !== undefined) {
+                this.#replaceSelection(inserted);
+                return;
+            }
+            if (data.includes("\u001b[200~")) {
+                this.#deleteSelection();
+                next();
+                return;
+            }
+            if (this.keybindings.matches(data, "tui.editor.cursorLeft")
+                || this.keybindings.matches(data, "tui.editor.cursorWordLeft")) {
+                this.#setCursor(selection.start);
+                this.#clearSelection();
+                return;
+            }
+            if (this.keybindings.matches(data, "tui.editor.cursorRight")
+                || this.keybindings.matches(data, "tui.editor.cursorWordRight")) {
+                this.#setCursor(selection.end);
+                this.#clearSelection();
+                return;
+            }
+            this.#clearSelection(false);
+        }
+        else if ((this.keybindings.matches(data, "tui.editor.deleteCharBackward")
+            || this.keybindings.matches(data, "tui.editor.deleteCharForward")
+            || this.keybindings.matches(data, "tui.editor.deleteWordBackward")
+            || this.keybindings.matches(data, "tui.editor.deleteWordForward"))
+            && this.#deleteAtomicFocus()) {
+            return;
+        }
+        if (this.keybindings.matches(data, "tui.editor.cursorWordLeft")) {
+            const before = this.#cursor();
+            const startedWithAtomicFocus = this.#atomicFocus() !== undefined;
+            this.#delegateWord(-1, next);
+            let after = this.#cursor();
+            const landedAtomic = this.#atomicRangeAt(after);
+            if (!startedWithAtomicFocus && landedAtomic?.start === after.col && after.col > 0) {
+                const line = editorState(this.editor).lines[after.line] ?? "";
+                const previous = [...GRAPHEMES.segment(line.slice(0, after.col))].at(-1);
+                if (previous !== undefined && !/^\s+$/u.test(previous.segment)) {
+                    this.#delegateWord(-1, next);
+                    after = this.#cursor();
+                }
+            }
+            const line = editorState(this.editor).lines[after.line] ?? "";
+            const landedPath = promptPathWordRanges(line).some(range => range.start === after.col);
+            if (!samePosition(before, after) && !landedPath)
+                this.#moveOntoPreviousSeparator();
+            this.#requestRender();
+            return;
+        }
+        const beforeText = this.editor.getText();
+        const wordDirection = this.#wordDirectionFor(data);
+        if (wordDirection === undefined)
+            next();
+        else
+            this.#delegateWord(wordDirection, next);
+        if (this.editor.getText() !== beforeText)
+            this.#redoStack = [];
+    }
+    render(width, next) {
+        const state = editorState(this.editor);
+        const hidden = state.lines.map(line => this.options.hiddenRanges?.(line) ?? []);
+        if (!hidden.some(ranges => ranges.length > 0))
+            return this.#renderVisible(width, next);
+        const original = { ...state, lines: [...state.lines] };
+        const selection = this.#selection;
+        const project = (position) => ({
+            line: position.line,
+            col: hideColumn(position.col, hidden[position.line] ?? []),
+        });
+        const lines = state.lines.map((line, index) => {
+            for (const range of [...(hidden[index] ?? [])].reverse())
+                line = line.slice(0, range.start) + line.slice(range.end);
+            return line;
+        });
+        // Rationale: project pending clipboard identities out before layout, not after painting.
+        // Keep the semantic draft/undo/submission markers intact and restore them even if rendering throws.
+        try {
+            this.#setRenderState(lines, project({ line: original.cursorLine, col: original.cursorCol }));
+            if (selection !== undefined)
+                this.#selection = { anchor: project(selection.anchor), head: project(selection.head) };
+            const rows = this.#renderVisible(width, next);
+            if (this.#geometry !== undefined) {
+                this.#geometry.hiddenRanges = hidden;
+                this.#geometry.lines = lines;
+            }
+            return rows;
+        }
+        finally {
+            this.#setRenderState(original.lines, { line: original.cursorLine, col: original.cursorCol });
+            this.#selection = selection;
+        }
+    }
+    #setRenderState(lines, cursor) {
+        if (this.editor.interaction !== undefined)
+            this.editor.interaction.replaceLines(lines);
+        else
+            editorState(this.editor).lines = lines;
+        this.#setCursor(cursor);
+    }
+    #renderVisible(width, next) {
+        const rows = next().map(row => row.replaceAll(ATOMIC_SPACE_SENTINEL, " "));
+        const shared = this.options.promptGeometry?.(width, this.editor.getPaddingX());
+        const padding = shared?.paddingX ?? Math.min(this.editor.getPaddingX(), Math.max(0, Math.floor((width - 1) / 2)));
+        const prefixWidth = shared?.prefixWidth ?? 0;
+        const contentWidth = shared?.contentWidth ?? Math.max(1, width - padding * 2);
+        const layoutWidth = shared?.layoutWidth ?? Math.max(1, contentWidth - (padding ? 0 : 1));
+        const visualLines = editorVisualLineMap(this.editor, layoutWidth)
+            ?? buildVisualLineMap(editorState(this.editor).lines, layoutWidth);
+        const scrollOffset = this.editor.interaction?.scrollOffset() ?? numericProperty(this.editor, "scrollOffset");
+        const maxVisibleLines = Math.max(5, Math.floor(this.options.getRows() * 0.3));
+        const textRows = Math.max(0, Math.min(visualLines.length - scrollOffset, maxVisibleLines, rows.length - 2));
+        this.#geometry = { width, padding, prefixWidth, layoutWidth, visualLines, scrollOffset, textRows, hiddenRanges: [] };
+        if (this.#atomicFocus() !== undefined) {
+            for (let row = 0; row < rows.length; row += 1) {
+                rows[row] = (rows[row] ?? "").replaceAll(CURSOR_MARKER, "");
+            }
+        }
+        const selection = this.#orderedSelection();
+        if (selection !== undefined) {
+            for (let row = 0; row < textRows; row += 1) {
+                const visual = visualLines[scrollOffset + row];
+                if (visual === undefined || visual.logicalLine < selection.start.line || visual.logicalLine > selection.end.line)
+                    continue;
+                const segmentStart = visual.startCol;
+                const segmentEnd = visual.startCol + visual.length;
+                const from = visual.logicalLine === selection.start.line ? Math.max(selection.start.col, segmentStart) : segmentStart;
+                const to = visual.logicalLine === selection.end.line ? Math.min(selection.end.col, segmentEnd) : segmentEnd;
+                if (to <= from)
+                    continue;
+                const line = editorState(this.editor).lines[visual.logicalLine] ?? "";
+                const fromColumn = prefixWidth + padding + visibleWidth(line.slice(segmentStart, from));
+                const toColumn = fromColumn + visibleWidth(line.slice(from, to));
+                const rendered = rows[row + 1];
+                if (rendered !== undefined && toColumn > fromColumn) {
+                    rows[row + 1] = this.options.paintSelection(rendered, fromColumn, toColumn, false);
+                }
+            }
+        }
+        return rows.map((row, index) => this.options.decorateRow(row, width, index));
+    }
+    reset() {
+        this.#selection = undefined;
+        this.#pointerSelecting = false;
+        this.#lastClick = undefined;
+        this.#redoStack = [];
+        this.#selectionRevision += 1;
+    }
+    cancelPendingPastes() {
+        this.#pasteGeneration += 1;
+        this.#terminalPaste = undefined;
+    }
+    hasSelection() {
+        return this.#activeRange() !== undefined;
+    }
+    pasteClipboard() {
+        this.#pasteFromClipboard();
+        return true;
+    }
+    ownsPointer() {
+        return this.#pointerSelecting;
+    }
+    handlePointer(event) {
+        if (event.button !== 0)
+            return false;
+        if (event.kind === "press")
+            return this.#pointerPress(event.column, event.row);
+        if (event.kind === "motion") {
+            if (!this.#pointerSelecting)
+                return false;
+            let position = this.#positionAt(event.column, event.row, true);
+            if (position !== undefined && this.#selection !== undefined) {
+                const atomic = this.#atomicRangeAt(position);
+                if (atomic !== undefined) {
+                    const beforeAnchor = position.line < this.#selection.anchor.line
+                        || (position.line === this.#selection.anchor.line && atomic.start < this.#selection.anchor.col);
+                    position = { line: position.line, col: beforeAnchor ? atomic.start : atomic.end };
+                }
+                this.#selection = { ...this.#selection, head: position };
+                this.#selectionRevision += 1;
+                this.#requestRender();
+            }
+            return true;
+        }
+        if (!this.#pointerSelecting)
+            return false;
+        this.#pointerSelecting = false;
+        const ordered = this.#orderedSelection();
+        if (ordered === undefined && this.#selection !== undefined)
+            this.#setCursor(this.#selection.head);
+        if (ordered === undefined)
+            this.#clearSelection(false);
+        this.#requestRender();
+        return true;
+    }
+    #pointerPress(column, row) {
+        const position = this.#positionAt(column, row, false);
+        if (position === undefined)
+            return false;
+        const atomic = this.#atomicRangeAt(position);
+        if (atomic !== undefined) {
+            this.#selection = {
+                anchor: { line: position.line, col: atomic.start },
+                head: { line: position.line, col: atomic.start },
+            };
+            this.#setCursor({ line: position.line, col: atomic.start });
+            this.#pointerSelecting = true;
+            this.#lastClick = undefined;
+            this.#selectionRevision += 1;
+            this.#requestRender();
+            return true;
+        }
+        const now = Date.now();
+        const previous = this.#lastClick;
+        const count = previous !== undefined
+            && now - previous.time <= MULTI_CLICK_MS
+            && previous.line === position.line
+            && Math.abs(previous.col - position.col) <= 1
+            ? previous.count + 1
+            : 1;
+        this.#lastClick = { time: now, ...position, count };
+        const kind = ((count - 1) % 3) + 1;
+        if (kind === 2)
+            this.#selectWord(position);
+        else if (kind === 3)
+            this.#selectLine(position.line);
+        else
+            this.#selection = { anchor: position, head: position };
+        this.#pointerSelecting = true;
+        this.#selectionRevision += 1;
+        this.#requestRender();
+        return true;
+    }
+    #positionAt(column, row, clampRow) {
+        const geometry = this.#geometry;
+        if (geometry === undefined || geometry.textRows === 0)
+            return undefined;
+        let textRow = row - 2;
+        if (clampRow)
+            textRow = clamp(textRow, 0, geometry.textRows - 1);
+        if (textRow < 0 || textRow >= geometry.textRows)
+            return undefined;
+        const visual = geometry.visualLines[geometry.scrollOffset + textRow];
+        if (visual === undefined)
+            return undefined;
+        const line = (geometry.lines ?? editorState(this.editor).lines)[visual.logicalLine] ?? "";
+        const segment = line.slice(visual.startCol, visual.startCol + visual.length);
+        const displayColumn = Math.max(0, column - 1 - geometry.padding - geometry.prefixWidth);
+        return {
+            line: visual.logicalLine,
+            col: restoreColumn(visual.startCol + indexAtDisplayWidth(segment, displayColumn), geometry.hiddenRanges[visual.logicalLine] ?? []),
+        };
+    }
+    #selectWord(position) {
+        const atomic = this.#atomicRangeAt(position);
+        if (atomic !== undefined) {
+            this.#selection = {
+                anchor: { line: position.line, col: atomic.start },
+                head: { line: position.line, col: atomic.end },
+            };
+            return;
+        }
+        const line = editorState(this.editor).lines[position.line] ?? "";
+        const segments = [...GRAPHEMES.segment(line)].map(({ segment, index }) => ({
+            class: charClass(segment), start: index, end: index + segment.length,
+        }));
+        let selected = segments.findIndex(segment => position.col >= segment.start && position.col < segment.end);
+        if (selected < 0 && segments.length > 0 && position.col === line.length)
+            selected = segments.length - 1;
+        if (selected < 0)
+            return;
+        let start = selected;
+        let end = selected;
+        while (start > 0 && segments[start - 1]?.class === segments[selected]?.class)
+            start -= 1;
+        while (end + 1 < segments.length && segments[end + 1]?.class === segments[selected]?.class)
+            end += 1;
+        this.#selection = {
+            anchor: { line: position.line, col: segments[start]?.start ?? position.col },
+            head: { line: position.line, col: segments[end]?.end ?? position.col },
+        };
+    }
+    #selectLine(line) {
+        const text = editorState(this.editor).lines[line] ?? "";
+        this.#selection = { anchor: { line, col: 0 }, head: { line, col: text.length } };
+    }
+    #selectAll() {
+        const lines = editorState(this.editor).lines;
+        const finalLine = Math.max(0, lines.length - 1);
+        this.#selection = {
+            anchor: { line: 0, col: 0 },
+            head: { line: finalLine, col: (lines[finalLine] ?? "").length },
+        };
+        this.#pointerSelecting = false;
+        this.#selectionRevision += 1;
+        this.#requestRender();
+    }
+    #extend(delta) {
+        const cursor = this.#cursor();
+        if (this.#selection === undefined)
+            this.#selection = { anchor: cursor, head: cursor };
+        else if (!samePosition(cursor, this.#selection.head))
+            this.#setCursor(this.#selection.head);
+        this.#moveCursor(delta);
+        this.#selection = { anchor: this.#selection.anchor, head: this.#cursor() };
+        this.#pointerSelecting = false;
+        this.#lastClick = undefined;
+        this.#selectionRevision += 1;
+        this.#requestRender();
+    }
+    #handleTerminalPaste(data, next) {
+        const start = data.indexOf("\x1b[200~");
+        if (this.#terminalPaste === undefined) {
+            if (start < 0)
+                return false;
+            if (start > 0) {
+                const before = data.slice(0, start);
+                this.handleInput(before, (replacement = before) => next(replacement));
+            }
+            this.#terminalPaste = { parts: [], piece: "", tail: "", bytes: 0, oversized: false };
+            data = data.slice(start + 6);
+        }
+        // Protocol: inspect only the new fragment plus a delimiter-sized suffix, not the whole growing body.
+        const pending = this.#terminalPaste;
+        const fragment = pending.tail + data;
+        const end = fragment.indexOf("\x1b[201~");
+        const append = (part) => {
+            if (pending.oversized || part.length === 0)
+                return;
+            if (this.options.beginTextPaste !== undefined) {
+                pending.bytes += Buffer.byteLength(part);
+                if (pending.bytes > MAX_CLIPBOARD_TEXT_BYTES) {
+                    pending.oversized = true;
+                    pending.parts = [];
+                    pending.piece = "";
+                    return;
+                }
+            }
+            // Performance: bound fragment metadata even if a terminal supplies one character per input chunk.
+            pending.piece += part;
+            if (pending.piece.length >= 16_384) {
+                pending.parts.push(pending.piece);
+                pending.piece = "";
+            }
+        };
+        if (end < 0) {
+            let cut = Math.max(0, fragment.length - 5);
+            if (cut > 0 && /[\uD800-\uDBFF]/u.test(fragment[cut - 1]) && /[\uDC00-\uDFFF]/u.test(fragment[cut]))
+                cut--;
+            append(fragment.slice(0, cut));
+            pending.tail = fragment.slice(cut);
+            return true;
+        }
+        append(fragment.slice(0, end));
+        const remaining = fragment.slice(end + 6);
+        this.#terminalPaste = undefined;
+        if (pending.oversized) {
+            this.options.onPasteInput?.(pending.bytes, "framing");
+            this.options.onPasteRejected?.(new ImageAttachmentError("paste-size"));
+            if (remaining.length > 0)
+                this.handleInput(remaining, (replacement = remaining) => next(replacement));
+            return true;
+        }
+        const text = pending.parts.join("") + pending.piece;
+        const deferred = text.length > 0 && this.options.beginTextPaste !== undefined && (this.options.deferTextPaste?.(text) ?? true);
+        this.options.onPasteInput?.(pending.bytes, "framing");
+        if (text.length > 0)
+            this.#redoStack = [];
+        if (text.length === 0)
+            this.pasteClipboard();
+        else if (deferred)
+            this.#pasteFromClipboard(text);
+        else {
+            this.options.onPasteInput?.(pending.bytes, "inserting");
+            const transformed = this.options.transformPastedContent({ kind: "text", text });
+            if (transformed === text && this.#orderedSelection() === undefined)
+                next(`\x1b[200~${text}\x1b[201~`);
+            else {
+                if (this.#orderedSelection() !== undefined)
+                    this.#replaceSelection(transformed);
+                else
+                    this.editor.insertTextAtCursor(transformed);
+                this.#redoStack = [];
+                this.#requestRender();
+            }
+            this.options.onPasteInput?.(pending.bytes, "settled");
+        }
+        if (remaining.length > 0)
+            this.handleInput(remaining, (replacement = remaining) => next(replacement));
+        return true;
+    }
+    #pasteFromClipboard(source) {
+        const begin = source === undefined ? this.options.beginClipboardPaste
+            : this.options.beginTextPaste === undefined ? undefined : () => this.options.beginTextPaste(source);
+        if (begin !== undefined) {
+            const generation = this.#pasteGeneration;
+            const restore = this.#orderedSelection() === undefined ? "" : this.#selectedText();
+            const paste = begin();
+            this.#redoStack = [];
+            if (this.#orderedSelection() !== undefined)
+                this.#replaceSelection(paste.marker);
+            else
+                this.editor.insertTextAtCursor(paste.marker);
+            this.#requestRender();
+            const replace = (text) => {
+                if (generation === this.#pasteGeneration)
+                    this.#replacePasteMarker(paste.marker, paste.isCurrent?.() === false ? restore : text || restore);
+                paste.complete?.();
+            };
+            void paste.result.then(replace).catch(() => replace(restore));
+            return;
+        }
+        const revision = this.#selectionRevision;
+        const selection = this.#orderedSelection();
+        const atomicFocus = this.#atomicFocus();
+        void this.options.readClipboardContent().then(content => {
+            if (content === null)
+                return;
+            const text = this.options.transformPastedContent(content);
+            if (text.length === 0)
+                return;
+            if (selection !== undefined && revision === this.#selectionRevision && this.#orderedSelection() !== undefined) {
+                this.#replaceSelection(text);
+                return;
+            }
+            if (atomicFocus !== undefined && samePosition(this.#cursor(), atomicFocus.start)) {
+                this.editor.insertTextAtCursor(text);
+            }
+            else {
+                this.#clearSelection(false);
+                this.editor.insertTextAtCursor(text);
+            }
+            this.#redoStack = [];
+            this.#requestRender();
+        }).catch(() => { });
+    }
+    #replacePasteMarker(marker, replacement) {
+        const current = this.editor.getText();
+        const from = current.indexOf(marker);
+        const text = normalizeInsertedText(replacement);
+        if (from < 0) {
+            this.#rewritePasteSnapshots(marker, text);
+            return;
+        }
+        const to = from + marker.length;
+        const lines = editorState(this.editor).lines;
+        const remap = (position) => {
+            const offset = positionOffset(lines, position);
+            return offset <= from ? offset : offset >= to ? offset + text.length - marker.length : from + text.length;
+        };
+        const cursor = remap(this.#cursor());
+        const selection = this.#selection === undefined ? undefined : { anchor: remap(this.#selection.anchor), head: remap(this.#selection.head) };
+        const next = current.slice(0, from) + text + current.slice(to);
+        // Compatibility: completing a paste updates its provisional undo snapshots, not the user's undo history.
+        if (this.editor.interaction !== undefined)
+            this.editor.interaction.replaceLines(next.split("\n"));
+        else
+            editorState(this.editor).lines = next.split("\n");
+        this.#rewritePasteSnapshots(marker, text);
+        this.#setCursor(positionAtOffset(next, cursor));
+        this.editor.onChange?.(this.editor.getText());
+        this.editor.invalidate();
+        if (selection !== undefined)
+            this.#selection = { anchor: positionAtOffset(next, selection.anchor), head: positionAtOffset(next, selection.head) };
+        this.#requestRender();
+    }
+    #rewritePasteSnapshots(marker, text) {
+        // Concurrency: even a removed reservation must be retired from redo/undo snapshots, or a canceled paste can reappear.
+        if (this.editor.interaction !== undefined)
+            this.editor.interaction.updateUndoStates(state => replaceSnapshotMarker(state, marker, text));
+        else {
+            const undo = Reflect.get(this.editor, "undoStack");
+            const snapshots = typeof undo === "object" && undo !== null ? Reflect.get(undo, "stack") : undefined;
+            if (Array.isArray(snapshots))
+                for (const snapshot of snapshots) {
+                    const state = typeof snapshot === "object" && snapshot !== null ? Reflect.get(snapshot, "state") : undefined;
+                    if (isEditorState(state))
+                        replaceSnapshotMarker(state, marker, text);
+                }
+        }
+        for (const snapshot of this.#redoStack) {
+            const state = { lines: snapshot.text.split("\n"), cursorLine: snapshot.cursor.line, cursorCol: snapshot.cursor.col };
+            replaceSnapshotMarker(state, marker, text);
+            snapshot.text = state.lines.join("\n");
+            snapshot.cursor = { line: state.cursorLine, col: state.cursorCol };
+        }
+    }
+    #replaceSelection(text) {
+        const selection = this.#orderedSelection();
+        if (selection === undefined) {
+            this.editor.insertTextAtCursor(text);
+            return;
+        }
+        const normalized = normalizeInsertedText(text);
+        const current = this.editor.getText();
+        const lines = editorState(this.editor).lines;
+        const from = positionOffset(lines, selection.start);
+        const to = positionOffset(lines, selection.end);
+        const next = current.slice(0, from) + normalized + current.slice(to);
+        this.editor.setText(next);
+        this.#setCursor(positionAtOffset(next, from + normalized.length));
+        this.#redoStack = [];
+        this.#clearSelection(false);
+        this.#requestRender();
+    }
+    #deleteSelection() {
+        const selection = this.#orderedSelection();
+        if (selection === undefined)
+            return false;
+        const current = this.editor.getText();
+        const lines = editorState(this.editor).lines;
+        const from = positionOffset(lines, selection.start);
+        const to = positionOffset(lines, selection.end);
+        this.editor.setText(current.slice(0, from) + current.slice(to));
+        this.#setCursor(positionAtOffset(this.editor.getText(), from));
+        this.#redoStack = [];
+        this.#clearSelection(false);
+        this.#requestRender();
+        return true;
+    }
+    #deleteAtomicFocus() {
+        const focus = this.#atomicFocus();
+        if (focus === undefined)
+            return false;
+        const current = this.editor.getText();
+        const lines = editorState(this.editor).lines;
+        const from = positionOffset(lines, focus.start);
+        const to = positionOffset(lines, focus.end);
+        this.editor.setText(current.slice(0, from) + current.slice(to));
+        this.#setCursor(positionAtOffset(this.editor.getText(), from));
+        this.#redoStack = [];
+        this.#clearSelection(false);
+        this.#requestRender();
+        return true;
+    }
+    #redo() {
+        const snapshot = this.#redoStack.pop();
+        if (snapshot === undefined)
+            return;
+        this.editor.setText(snapshot.text);
+        this.#setCursor(snapshot.cursor);
+        this.#clearSelection(false);
+        this.#requestRender();
+    }
+    #collapseCopiedSelection() {
+        const selection = this.#activeRange();
+        if (selection === undefined)
+            return;
+        const line = editorState(this.editor).lines[selection.end.line] ?? "";
+        let column = selection.end.col;
+        while (true) {
+            const adjacent = this.options.atomicRanges(line).find(range => range.start === column);
+            if (adjacent === undefined)
+                break;
+            column = adjacent.end;
+        }
+        this.#setCursor({ line: selection.end.line, col: column });
+        this.#clearSelection(false);
+        this.#requestRender();
+    }
+    #selectedText() {
+        const selection = this.#activeRange();
+        if (selection === undefined)
+            return "";
+        const current = this.editor.getText();
+        const lines = editorState(this.editor).lines;
+        return current.slice(positionOffset(lines, selection.start), positionOffset(lines, selection.end));
+    }
+    #activeRange() {
+        return this.#orderedSelection() ?? this.#atomicFocus();
+    }
+    #atomicFocus() {
+        if (this.#orderedSelection() !== undefined)
+            return undefined;
+        const state = editorState(this.editor);
+        const line = state.lines[state.cursorLine] ?? "";
+        const range = this.options.atomicRanges(line).find(candidate => candidate.start === state.cursorCol);
+        return range === undefined ? undefined : {
+            start: { line: state.cursorLine, col: range.start },
+            end: { line: state.cursorLine, col: range.end },
+        };
+    }
+    #orderedSelection() {
+        const selection = this.#selection;
+        if (selection === undefined || samePosition(selection.anchor, selection.head))
+            return undefined;
+        return positionBefore(selection.anchor, selection.head)
+            ? { start: selection.anchor, end: selection.head }
+            : { start: selection.head, end: selection.anchor };
+    }
+    #clearSelection(render = true) {
+        if (this.#selection === undefined && !this.#pointerSelecting)
+            return;
+        this.#selection = undefined;
+        this.#pointerSelecting = false;
+        this.#selectionRevision += 1;
+        if (render)
+            this.#requestRender();
+    }
+    #cursor() {
+        return this.editor.getCursor();
+    }
+    #setCursor(position) {
+        if (this.editor.interaction !== undefined) {
+            this.editor.interaction.setCursor(position.line, position.col);
+            return;
+        }
+        const state = editorState(this.editor);
+        const line = clamp(position.line, 0, Math.max(0, state.lines.length - 1));
+        state.cursorLine = line;
+        state.cursorCol = clamp(position.col, 0, (state.lines[line] ?? "").length);
+    }
+    #moveCursor(delta) {
+        const state = editorState(this.editor);
+        const line = state.lines[state.cursorLine] ?? "";
+        const atomic = this.options.atomicRanges(line).find(range => delta < 0
+            ? state.cursorCol > range.start && state.cursorCol <= range.end
+            : state.cursorCol >= range.start && state.cursorCol < range.end);
+        if (atomic !== undefined) {
+            state.cursorCol = delta < 0 ? atomic.start : atomic.end;
+            this.editor.interaction?.setCursor(state.cursorLine, state.cursorCol);
+            return;
+        }
+        if (delta < 0) {
+            if (state.cursorCol > 0) {
+                const segments = [...GRAPHEMES.segment(line.slice(0, state.cursorCol))];
+                state.cursorCol -= segments.at(-1)?.segment.length ?? 1;
+            }
+            else if (state.cursorLine > 0) {
+                state.cursorLine -= 1;
+                state.cursorCol = (state.lines[state.cursorLine] ?? "").length;
+            }
+            this.editor.interaction?.setCursor(state.cursorLine, state.cursorCol);
+            return;
+        }
+        if (state.cursorCol < line.length) {
+            state.cursorCol += [...GRAPHEMES.segment(line.slice(state.cursorCol))][0]?.segment.length ?? 1;
+        }
+        else if (state.cursorLine < state.lines.length - 1) {
+            state.cursorLine += 1;
+            state.cursorCol = 0;
+        }
+        this.editor.interaction?.setCursor(state.cursorLine, state.cursorCol);
+    }
+    #atomicRangeAt(position) {
+        const line = editorState(this.editor).lines[position.line] ?? "";
+        return this.options.atomicRanges(line).find(range => position.col >= range.start && position.col < range.end);
+    }
+    #moveOntoPreviousSeparator() {
+        const cursor = this.#cursor();
+        if (cursor.col === 0)
+            return;
+        const line = editorState(this.editor).lines[cursor.line] ?? "";
+        const previous = [...GRAPHEMES.segment(line.slice(0, cursor.col))].at(-1);
+        if (previous !== undefined && /^\s+$/u.test(previous.segment))
+            this.#moveCursor(-1);
+    }
+    #snapshot() {
+        return { text: this.editor.getText(), cursor: this.#cursor() };
+    }
+    #wordDirectionFor(data) {
+        if (this.keybindings.matches(data, "tui.editor.deleteWordBackward"))
+            return -1;
+        if (this.keybindings.matches(data, "tui.editor.deleteWordForward")
+            || this.keybindings.matches(data, "tui.editor.cursorWordRight"))
+            return 1;
+        return undefined;
+    }
+    #delegateWord(direction, next) {
+        this.#wordDirection = direction;
+        try {
+            next();
+        }
+        finally {
+            this.#wordDirection = undefined;
+        }
+    }
+    #requestRender() {
+        this.options.requestRender();
+    }
+}
+function installAtomicSegmentation(editor, rangesForText, wordDirection) {
+    const transform = (text, mode, values) => {
+        const ranges = rangesForText(text).map(range => ({ ...range, wordLike: false }));
+        if (mode === "word") {
+            for (const range of contextualPathRanges(editor, text, wordDirection())) {
+                if (!ranges.some(existing => rangesOverlap(existing, range)))
+                    ranges.push({ ...range, wordLike: true });
+            }
+        }
+        ranges.sort((left, right) => left.start - right.start);
+        if (mode === "grapheme" && ranges.length > 0 && hasSegmentLookup(values)) {
+            const indexed = atomicSegmentsByBoundary(text, ranges, offset => values.containing(offset));
+            if (indexed !== undefined)
+                return indexed;
+        }
+        const segments = [...values].filter(isEditorSegment);
+        if (ranges.length === 0)
+            return segments;
+        const merged = [];
+        let rangeIndex = 0;
+        for (const segment of segments) {
+            while ((ranges[rangeIndex]?.end ?? Number.POSITIVE_INFINITY) <= segment.index)
+                rangeIndex += 1;
+            const range = ranges[rangeIndex];
+            if (range !== undefined && segment.index >= range.start && segment.index < range.end) {
+                if (segment.index === range.start) {
+                    const source = text.slice(range.start, range.end);
+                    merged.push({
+                        segment: range.wordLike ? "w".repeat(source.length) : source.replaceAll(" ", ATOMIC_SPACE_SENTINEL),
+                        index: range.start,
+                        input: text,
+                        ...(range.wordLike ? { isWordLike: true } : {}),
+                    });
+                }
+                continue;
+            }
+            merged.push(segment);
+        }
+        return merged;
+    };
+    if (editor.interaction !== undefined) {
+        editor.interaction.setSegmentTransform(transform);
+        return;
+    }
+    if (Reflect.get(editor, ATOMIC_SEGMENTATION) === true)
+        return;
+    const originalValue = Reflect.get(editor, "segment");
+    if (typeof originalValue !== "function")
+        return;
+    const original = originalValue.bind(editor);
+    Reflect.set(editor, "segment", (text, mode) => transform(text, mode, original(text, mode)));
+    Reflect.set(editor, ATOMIC_SEGMENTATION, true);
+}
+/** Narrow the optional indexed segment capability without a dynamic callback invocation. */
+function hasSegmentLookup(values) {
+    return typeof values === "object" && values !== null && "containing" in values && typeof values.containing === "function";
+}
+/** Skip atomic interiors using the supplied segmenter's boundaries; preserve the iterable fallback exactly. */
+function atomicSegmentsByBoundary(text, ranges, containing) {
+    const merged = [];
+    let offset = 0, rangeIndex = 0;
+    while (offset < text.length) {
+        const segment = containing(offset);
+        if (!isEditorSegment(segment) || segment.index !== offset || segment.segment.length === 0)
+            return undefined;
+        while ((ranges[rangeIndex]?.end ?? Number.POSITIVE_INFINITY) <= offset)
+            rangeIndex++;
+        const range = ranges[rangeIndex];
+        if (range !== undefined && offset >= range.start && offset < range.end) {
+            if (range.end > text.length)
+                return undefined;
+            const last = containing(range.end - 1);
+            if (!isEditorSegment(last) || last.index + last.segment.length < range.end)
+                return undefined;
+            if (offset === range.start)
+                merged.push({ segment: text.slice(range.start, range.end).replaceAll(" ", ATOMIC_SPACE_SENTINEL), index: range.start, input: text });
+            // Compatibility: the old iterable consumes the entire final grapheme, even if it crosses the chip end.
+            offset = last.index + last.segment.length;
+        }
+        else {
+            merged.push(segment);
+            offset += segment.segment.length;
+        }
+    }
+    return merged;
+}
+function contextualPathRanges(editor, text, direction) {
+    if (direction === undefined)
+        return promptPathWordRanges(text);
+    const state = editorState(editor);
+    const line = state.lines[state.cursorLine] ?? "";
+    const offset = direction < 0 ? 0 : state.cursorCol;
+    if (text !== (direction < 0 ? line.slice(0, state.cursorCol) : line.slice(state.cursorCol))) {
+        return promptPathWordRanges(text);
+    }
+    const end = offset + text.length;
+    return promptPathWordRanges(line).flatMap(range => {
+        const start = Math.max(range.start, offset);
+        const finish = Math.min(range.end, end);
+        return finish <= start ? [] : [{ start: start - offset, end: finish - offset }];
+    });
+}
+function rangesOverlap(left, right) {
+    return left.start < right.end && right.start < left.end;
+}
+function isEditorSegment(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const segment = Reflect.get(value, "segment");
+    const index = Reflect.get(value, "index");
+    const input = Reflect.get(value, "input");
+    return typeof segment === "string" && typeof index === "number" && typeof input === "string";
+}
+function insertedText(data) {
+    if (!data || data.includes("\u001b[200~"))
+        return undefined;
+    const kitty = decodeKittyPrintable(data);
+    if (kitty !== undefined)
+        return kitty;
+    return data.charCodeAt(0) >= 32 ? data : undefined;
+}
+function indexAtDisplayWidth(text, target) {
+    if (target <= 0)
+        return 0;
+    let width = 0;
+    let index = 0;
+    for (const { segment } of GRAPHEMES.segment(text)) {
+        const next = width + visibleWidth(segment);
+        if (next > target)
+            break;
+        width = next;
+        index += segment.length;
+    }
+    return index;
+}
+function charClass(value) {
+    if (/\s/u.test(value))
+        return 0;
+    if (/[\p{L}\p{N}_]/u.test(value))
+        return 1;
+    return 2;
+}
+function positionBefore(left, right) {
+    return left.line < right.line || (left.line === right.line && left.col <= right.col);
+}
+function samePosition(left, right) {
+    return left.line === right.line && left.col === right.col;
+}
+function sameSnapshot(left, right) {
+    return left.text === right.text && samePosition(left.cursor, right.cursor);
+}
+function hideColumn(column, ranges) {
+    return column - ranges.reduce((removed, range) => removed + Math.max(0, Math.min(column, range.end) - range.start), 0);
+}
+function restoreColumn(column, ranges) {
+    let restored = column;
+    for (const range of ranges)
+        if (restored >= range.start)
+            restored += range.end - range.start;
+    return restored;
+}
+function editorState(editor) {
+    if (editor.interaction !== undefined)
+        return editor.interaction.snapshot();
+    const value = Object.getOwnPropertyDescriptor(editor, "state")?.value;
+    if (!isEditorState(value))
+        throw new Error("Pi editor state is unavailable");
+    return value;
+}
+function isEditorState(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const lines = Object.getOwnPropertyDescriptor(value, "lines")?.value;
+    const cursorLine = Object.getOwnPropertyDescriptor(value, "cursorLine")?.value;
+    const cursorCol = Object.getOwnPropertyDescriptor(value, "cursorCol")?.value;
+    return Array.isArray(lines) && lines.every(line => typeof line === "string")
+        && typeof cursorLine === "number" && typeof cursorCol === "number";
+}
+function numericProperty(target, key) {
+    const value = Object.getOwnPropertyDescriptor(target, key)?.value;
+    return typeof value === "number" ? value : 0;
+}
+/** Shares the existing atomic-aware body layout with prompt/menu composition. */
+export function editorVisualLineCount(editor, width) {
+    return editorVisualLineMap(editor, width)?.length;
+}
+function editorVisualLineMap(editor, width) {
+    if (editor.interaction !== undefined)
+        return editor.interaction.visualLines(width);
+    const builder = Reflect.get(editor, "buildVisualLineMap");
+    if (typeof builder !== "function")
+        return undefined;
+    const value = builder.call(editor, width);
+    if (!Array.isArray(value) || !value.every(isVisualLine))
+        return undefined;
+    return value;
+}
+function isVisualLine(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    return typeof Reflect.get(value, "logicalLine") === "number"
+        && typeof Reflect.get(value, "startCol") === "number"
+        && typeof Reflect.get(value, "length") === "number";
+}
+function buildVisualLineMap(lines, width) {
+    const visualLines = [];
+    for (let logicalLine = 0; logicalLine < lines.length; logicalLine += 1) {
+        const line = lines[logicalLine] ?? "";
+        if (line.length === 0) {
+            visualLines.push({ logicalLine, startCol: 0, length: 0 });
+            continue;
+        }
+        for (const chunk of wrapLine(line, width)) {
+            visualLines.push({ logicalLine, startCol: chunk.start, length: chunk.end - chunk.start });
+        }
+    }
+    return visualLines;
+}
+function wrapLine(line, width) {
+    if (visibleWidth(line) <= width)
+        return [{ start: 0, end: line.length }];
+    const segments = [...GRAPHEMES.segment(line)];
+    const chunks = [];
+    let start = 0;
+    let currentWidth = 0;
+    let wrapAt = -1;
+    let widthAtWrap = 0;
+    for (let index = 0; index < segments.length; index += 1) {
+        const segment = segments[index];
+        if (segment === undefined)
+            continue;
+        const segmentWidth = visibleWidth(segment.segment);
+        if (currentWidth + segmentWidth > width) {
+            if (wrapAt > start && currentWidth - widthAtWrap + segmentWidth <= width) {
+                chunks.push({ start, end: wrapAt });
+                start = wrapAt;
+                currentWidth -= widthAtWrap;
+            }
+            else if (start < segment.index) {
+                chunks.push({ start, end: segment.index });
+                start = segment.index;
+                currentWidth = 0;
+            }
+            wrapAt = -1;
+        }
+        currentWidth += segmentWidth;
+        const next = segments[index + 1];
+        if (/\s/u.test(segment.segment) && next !== undefined && !/\s/u.test(next.segment)) {
+            wrapAt = next.index;
+            widthAtWrap = currentWidth;
+        }
+    }
+    chunks.push({ start, end: line.length });
+    return chunks;
+}
+function positionOffset(lines, position) {
+    let offset = 0;
+    for (let line = 0; line < position.line; line += 1)
+        offset += (lines[line] ?? "").length + 1;
+    return offset + position.col;
+}
+function positionAtOffset(text, requestedOffset) {
+    const offset = clamp(requestedOffset, 0, text.length);
+    const before = text.slice(0, offset).split("\n");
+    return { line: before.length - 1, col: (before.at(-1) ?? "").length };
+}
+function replaceSnapshotMarker(state, marker, replacement) {
+    const text = state.lines.join("\n");
+    const from = text.indexOf(marker);
+    if (from < 0)
+        return;
+    const cursor = positionOffset(state.lines, { line: state.cursorLine, col: state.cursorCol });
+    const offset = cursor <= from ? cursor : cursor >= from + marker.length ? cursor + replacement.length - marker.length : from + replacement.length;
+    const next = text.slice(0, from) + replacement + text.slice(from + marker.length);
+    const position = positionAtOffset(next, offset);
+    state.lines = next.split("\n");
+    state.cursorLine = position.line;
+    state.cursorCol = position.col;
+}
+function normalizeInsertedText(text) {
+    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\t/g, "    ");
+}
+function clamp(value, minimum, maximum) {
+    return Math.max(minimum, Math.min(maximum, value));
+}