@machina.ai/cell-cli 1.20.2-rc1 → 1.25.0-rc3

package/dist/src/ui/components/shared/text-buffer.js

@@ -7,18 +7,13 @@ import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import pathMod from 'node:path';
+import * as path from 'node:path';
 import { useState, useCallback, useEffect, useMemo, useReducer } from 'react';
-import { unescapePath, coreEvents, CoreEvent } from '@google/gemini-cli-core';
+import { coreEvents, CoreEvent, debugLogger, unescapePath, getEditorCommand, isGuiEditor, } from '@google/gemini-cli-core';
 import { toCodePoints, cpLen, cpSlice, stripUnsafeCharacters, getCachedStringWidth, } from '../../utils/textUtils.js';
+import { parsePastedPaths } from '../../utils/clipboardUtils.js';
+import { keyMatchers, Command } from '../../keyMatchers.js';
 import { handleVimAction } from './vim-buffer-actions.js';
-import { enableSupportedProtocol } from '../../utils/kittyProtocolDetector.js';
-// Simple helper for word‑wise ops.
-function isWordChar(ch) {
-    if (ch === undefined) {
-        return false;
-    }
-    return !/[\s,.;!?]/.test(ch);
-}
 // Helper functions for line-based word navigation
 export const isWordCharStrict = (char) => /[\w\p{L}\p{N}]/u.test(char); // Matches a single character that is any Unicode letter, any Unicode number, or an underscore
 export const isWhitespace = (char) => /\s/.test(char);
@@ -191,6 +186,41 @@ export const findWordEndInLine = (line, col) => {
     }
     return null;
 };
+// Initialize segmenter for word boundary detection
+const segmenter = new Intl.Segmenter(undefined, { granularity: 'word' });
+function findPrevWordBoundary(line, cursorCol) {
+    const codePoints = toCodePoints(line);
+    // Convert cursorCol (CP index) to string index
+    const prefix = codePoints.slice(0, cursorCol).join('');
+    const cursorIdx = prefix.length;
+    let targetIdx = 0;
+    for (const seg of segmenter.segment(line)) {
+        // We want the last word start strictly before the cursor.
+        // If we've reached or passed the cursor, we stop.
+        if (seg.index >= cursorIdx)
+            break;
+        if (seg.isWordLike) {
+            targetIdx = seg.index;
+        }
+    }
+    return toCodePoints(line.slice(0, targetIdx)).length;
+}
+function findNextWordBoundary(line, cursorCol) {
+    const codePoints = toCodePoints(line);
+    const prefix = codePoints.slice(0, cursorCol).join('');
+    const cursorIdx = prefix.length;
+    let targetIdx = line.length;
+    for (const seg of segmenter.segment(line)) {
+        const segEnd = seg.index + seg.segment.length;
+        if (segEnd > cursorIdx) {
+            if (seg.isWordLike) {
+                targetIdx = segEnd;
+                break;
+            }
+        }
+    }
+    return toCodePoints(line.slice(0, targetIdx)).length;
+}
 // Find next word across lines
 export const findNextWordAcrossLines = (lines, cursorRow, cursorCol, searchForWordStart) => {
     // First try current line
@@ -455,24 +485,136 @@ export function logicalPosToOffset(lines, row, col) {
     }
     return offset;
 }
+export const imagePathRegex = /@((?:\\.|[^\s\r\n\\])+?\.(?:png|jpg|jpeg|gif|webp|svg|bmp))\b/gi;
+export function getTransformedImagePath(filePath) {
+    const raw = filePath;
+    // Ignore leading @ when stripping directories, but keep it for simple '@file.png'
+    const withoutAt = raw.startsWith('@') ? raw.slice(1) : raw;
+    // Unescape the path to handle escaped spaces and other characters
+    const unescaped = unescapePath(withoutAt);
+    // Find last directory separator, supporting both POSIX and Windows styles
+    const lastSepIndex = Math.max(unescaped.lastIndexOf('/'), unescaped.lastIndexOf('\\'));
+    // If we saw a separator, take the segment after it; otherwise fall back to the unescaped string
+    const fileName = lastSepIndex >= 0 ? unescaped.slice(lastSepIndex + 1) : unescaped;
+    const extension = path.extname(fileName);
+    const baseName = path.basename(fileName, extension);
+    const maxBaseLength = 10;
+    const truncatedBase = baseName.length > maxBaseLength
+        ? `...${baseName.slice(-maxBaseLength)}`
+        : baseName;
+    return `[Image ${truncatedBase}${extension}]`;
+}
+export function calculateTransformationsForLine(line) {
+    const transformations = [];
+    let match;
+    // Reset regex state to ensure clean matching from start of line
+    imagePathRegex.lastIndex = 0;
+    while ((match = imagePathRegex.exec(line)) !== null) {
+        const logicalText = match[0];
+        const logStart = cpLen(line.substring(0, match.index));
+        const logEnd = logStart + cpLen(logicalText);
+        transformations.push({
+            logStart,
+            logEnd,
+            logicalText,
+            collapsedText: getTransformedImagePath(logicalText),
+        });
+    }
+    return transformations;
+}
+export function calculateTransformations(lines) {
+    return lines.map((ln) => calculateTransformationsForLine(ln));
+}
+export function getTransformUnderCursor(row, col, spansByLine) {
+    const spans = spansByLine[row];
+    if (!spans || spans.length === 0)
+        return null;
+    for (const span of spans) {
+        if (col >= span.logStart && col <= span.logEnd) {
+            return span;
+        }
+        if (col < span.logStart)
+            break;
+    }
+    return null;
+}
+export function calculateTransformedLine(logLine, logIndex, logicalCursor, transformations) {
+    let transformedLine = '';
+    const transformedToLogMap = [];
+    let lastLogPos = 0;
+    const cursorIsOnThisLine = logIndex === logicalCursor[0];
+    const cursorCol = logicalCursor[1];
+    for (const transform of transformations) {
+        const textBeforeTransformation = cpSlice(logLine, lastLogPos, transform.logStart);
+        transformedLine += textBeforeTransformation;
+        for (let i = 0; i < cpLen(textBeforeTransformation); i++) {
+            transformedToLogMap.push(lastLogPos + i);
+        }
+        const isExpanded = cursorIsOnThisLine &&
+            cursorCol >= transform.logStart &&
+            cursorCol <= transform.logEnd;
+        const transformedText = isExpanded
+            ? transform.logicalText
+            : transform.collapsedText;
+        transformedLine += transformedText;
+        // Map transformed characters back to logical characters
+        const transformedLen = cpLen(transformedText);
+        if (isExpanded) {
+            for (let i = 0; i < transformedLen; i++) {
+                transformedToLogMap.push(transform.logStart + i);
+            }
+        }
+        else {
+            // Collapsed: distribute transformed positions monotonically across the raw span.
+            // This preserves ordering across wrapped slices so logicalToVisualMap has
+            // increasing startColInLogical and visual cursor mapping remains consistent.
+            const logicalLength = Math.max(0, transform.logEnd - transform.logStart);
+            for (let i = 0; i < transformedLen; i++) {
+                // Map the i-th transformed code point into [logStart, logEnd)
+                const transformationToLogicalOffset = logicalLength === 0
+                    ? 0
+                    : Math.floor((i * logicalLength) / transformedLen);
+                const transformationToLogicalIndex = transform.logStart +
+                    Math.min(transformationToLogicalOffset, Math.max(logicalLength - 1, 0));
+                transformedToLogMap.push(transformationToLogicalIndex);
+            }
+        }
+        lastLogPos = transform.logEnd;
+    }
+    // Append text after last transform
+    const remainingUntransformedText = cpSlice(logLine, lastLogPos);
+    transformedLine += remainingUntransformedText;
+    for (let i = 0; i < cpLen(remainingUntransformedText); i++) {
+        transformedToLogMap.push(lastLogPos + i);
+    }
+    // For a cursor at the very end of the transformed line
+    transformedToLogMap.push(cpLen(logLine));
+    return { transformedLine, transformedToLogMap };
+}
 // Calculates the visual wrapping of lines and the mapping between logical and visual coordinates.
 // This is an expensive operation and should be memoized.
-function calculateLayout(logicalLines, viewportWidth) {
+function calculateLayout(logicalLines, viewportWidth, logicalCursor) {
     const visualLines = [];
     const logicalToVisualMap = [];
     const visualToLogicalMap = [];
+    const transformedToLogicalMaps = [];
+    const visualToTransformedMap = [];
     logicalLines.forEach((logLine, logIndex) => {
         logicalToVisualMap[logIndex] = [];
-        if (logLine.length === 0) {
+        const transformations = calculateTransformationsForLine(logLine);
+        const { transformedLine, transformedToLogMap } = calculateTransformedLine(logLine, logIndex, logicalCursor, transformations);
+        transformedToLogicalMaps[logIndex] = transformedToLogMap;
+        if (transformedLine.length === 0) {
             // Handle empty logical line
             logicalToVisualMap[logIndex].push([visualLines.length, 0]);
             visualToLogicalMap.push([logIndex, 0]);
+            visualToTransformedMap.push(0);
             visualLines.push('');
         }
         else {
             // Non-empty logical line
             let currentPosInLogLine = 0; // Tracks position within the current logical line (code point index)
-            const codePointsInLogLine = toCodePoints(logLine);
+            const codePointsInLogLine = toCodePoints(transformedLine);
             while (currentPosInLogLine < codePointsInLogLine.length) {
                 let currentChunk = '';
                 let currentChunkVisualWidth = 0;
@@ -542,11 +684,13 @@ function calculateLayout(logicalLines, viewportWidth) {
                     currentChunk = codePointsInLogLine[currentPosInLogLine];
                     numCodePointsInChunk = 1;
                 }
+                const logicalStartCol = transformedToLogMap[currentPosInLogLine] ?? 0;
                 logicalToVisualMap[logIndex].push([
                     visualLines.length,
-                    currentPosInLogLine,
+                    logicalStartCol,
                 ]);
-                visualToLogicalMap.push([logIndex, currentPosInLogLine]);
+                visualToLogicalMap.push([logIndex, logicalStartCol]);
+                visualToTransformedMap.push(currentPosInLogLine);
                 visualLines.push(currentChunk);
                 const logicalStartOfThisChunk = currentPosInLogLine;
                 currentPosInLogLine += numCodePointsInChunk;
@@ -571,18 +715,21 @@ function calculateLayout(logicalLines, viewportWidth) {
                 logicalToVisualMap[0] = [];
             logicalToVisualMap[0].push([0, 0]);
             visualToLogicalMap.push([0, 0]);
+            visualToTransformedMap.push(0);
         }
     }
     return {
         visualLines,
         logicalToVisualMap,
         visualToLogicalMap,
+        transformedToLogicalMaps,
+        visualToTransformedMap,
     };
 }
 // Calculates the visual cursor position based on a pre-calculated layout.
 // This is a lightweight operation.
 function calculateVisualCursorFromLayout(layout, logicalCursor) {
-    const { logicalToVisualMap, visualLines } = layout;
+    const { logicalToVisualMap, visualLines, transformedToLogicalMaps } = layout;
     const [logicalRow, logicalCol] = logicalCursor;
     const segmentsForLogicalLine = logicalToVisualMap[logicalRow];
     if (!segmentsForLogicalLine || segmentsForLogicalLine.length === 0) {
@@ -607,9 +754,26 @@ function calculateVisualCursorFromLayout(layout, logicalCursor) {
         }
     }
     const [visualRow, startColInLogical] = segmentsForLogicalLine[targetSegmentIndex];
-    const visualCol = logicalCol - startColInLogical;
-    // The visual column should not exceed the length of the visual line.
-    const clampedVisualCol = Math.min(visualCol, cpLen(visualLines[visualRow] ?? ''));
+    // Find the coordinates in transformed space in order to conver to visual
+    const transformedToLogicalMap = transformedToLogicalMaps[logicalRow] ?? [];
+    let transformedCol = 0;
+    for (let i = 0; i < transformedToLogicalMap.length; i++) {
+        if (transformedToLogicalMap[i] > logicalCol) {
+            transformedCol = Math.max(0, i - 1);
+            break;
+        }
+        if (i === transformedToLogicalMap.length - 1) {
+            transformedCol = transformedToLogicalMap.length - 1;
+        }
+    }
+    let startColInTransformed = 0;
+    while (startColInTransformed < transformedToLogicalMap.length &&
+        transformedToLogicalMap[startColInTransformed] < startColInLogical) {
+        startColInTransformed++;
+    }
+    const clampedTransformedCol = Math.min(transformedCol, Math.max(0, transformedToLogicalMap.length - 1));
+    const visualCol = clampedTransformedCol - startColInTransformed;
+    const clampedVisualCol = Math.min(Math.max(visualCol, 0), cpLen(visualLines[visualRow] ?? ''));
     return [visualRow, clampedVisualCol];
 }
 const historyLimit = 100;
@@ -799,16 +963,25 @@ function textBufferReducerLogic(state, action, options = {}) {
                         break;
                     default: {
                         const exhaustiveCheck = dir;
-                        console.error(`Unknown visual movement direction: ${exhaustiveCheck}`);
+                        debugLogger.error(`Unknown visual movement direction: ${exhaustiveCheck}`);
                         return state;
                     }
                 }
                 if (visualToLogicalMap[newVisualRow]) {
-                    const [logRow, logStartCol] = visualToLogicalMap[newVisualRow];
+                    const [logRow, logicalStartCol] = visualToLogicalMap[newVisualRow];
+                    const transformedToLogicalMap = visualLayout.transformedToLogicalMaps?.[logRow] ?? [];
+                    let transformedStartCol = 0;
+                    while (transformedStartCol < transformedToLogicalMap.length &&
+                        transformedToLogicalMap[transformedStartCol] < logicalStartCol) {
+                        transformedStartCol++;
+                    }
+                    const clampedTransformedCol = Math.min(transformedStartCol + newVisualCol, Math.max(0, transformedToLogicalMap.length - 1));
+                    const newLogicalCol = transformedToLogicalMap[clampedTransformedCol] ??
+                        cpLen(lines[logRow] ?? '');
                     return {
                         ...state,
                         cursorRow: logRow,
-                        cursorCol: clamp(logStartCol + newVisualCol, 0, cpLen(lines[logRow] ?? '')),
+                        cursorCol: newLogicalCol,
                         preferredCol: newPreferredCol,
                     };
                 }
@@ -827,25 +1000,7 @@ function textBufferReducerLogic(state, action, options = {}) {
                     }
                     else {
                         const lineContent = lines[cursorRow];
-                        const arr = toCodePoints(lineContent);
-                        let start = cursorCol;
-                        let onlySpaces = true;
-                        for (let i = 0; i < start; i++) {
-                            if (isWordChar(arr[i])) {
-                                onlySpaces = false;
-                                break;
-                            }
-                        }
-                        if (onlySpaces && start > 0) {
-                            start--;
-                        }
-                        else {
-                            while (start > 0 && !isWordChar(arr[start - 1]))
-                                start--;
-                            while (start > 0 && isWordChar(arr[start - 1]))
-                                start--;
-                        }
-                        newCursorCol = start;
+                        newCursorCol = findPrevWordBoundary(lineContent, cursorCol);
                     }
                     return {
                         ...state,
@@ -855,25 +1010,20 @@ function textBufferReducerLogic(state, action, options = {}) {
                     };
                 }
                 case 'wordRight': {
+                    const lineContent = lines[cursorRow] ?? '';
                     if (cursorRow === lines.length - 1 &&
-                        cursorCol === cpLen(lines[cursorRow] ?? '')) {
+                        cursorCol === cpLen(lineContent)) {
                         return state;
                     }
                     let newCursorRow = cursorRow;
                     let newCursorCol = cursorCol;
-                    const lineContent = lines[cursorRow] ?? '';
-                    const arr = toCodePoints(lineContent);
-                    if (cursorCol >= arr.length) {
+                    const lineLen = cpLen(lineContent);
+                    if (cursorCol >= lineLen) {
                         newCursorRow++;
                         newCursorCol = 0;
                     }
                     else {
-                        let end = cursorCol;
-                        while (end < arr.length && !isWordChar(arr[end]))
-                            end++;
-                        while (end < arr.length && isWordChar(arr[end]))
-                            end++;
-                        newCursorCol = end;
+                        newCursorCol = findNextWordBoundary(lineContent, cursorCol);
                     }
                     return {
                         ...state,
@@ -1111,32 +1261,51 @@ function textBufferReducerLogic(state, action, options = {}) {
             return handleVimAction(state, action);
         default: {
             const exhaustiveCheck = action;
-            console.error(`Unknown action encountered: ${exhaustiveCheck}`);
+            debugLogger.error(`Unknown action encountered: ${exhaustiveCheck}`);
             return state;
         }
     }
 }
 export function textBufferReducer(state, action, options = {}) {
     const newState = textBufferReducerLogic(state, action, options);
+    const newTransformedLines = newState.lines !== state.lines
+        ? calculateTransformations(newState.lines)
+        : state.transformationsByLine;
+    const oldTransform = getTransformUnderCursor(state.cursorRow, state.cursorCol, state.transformationsByLine);
+    const newTransform = getTransformUnderCursor(newState.cursorRow, newState.cursorCol, newTransformedLines);
+    const oldInside = oldTransform !== null;
+    const newInside = newTransform !== null;
+    const movedBetweenTransforms = oldTransform !== newTransform &&
+        (oldTransform !== null || newTransform !== null);
     if (newState.lines !== state.lines ||
-        newState.viewportWidth !== state.viewportWidth) {
+        newState.viewportWidth !== state.viewportWidth ||
+        oldInside !== newInside ||
+        movedBetweenTransforms) {
+        const shouldResetPreferred = oldInside !== newInside || movedBetweenTransforms;
         return {
             ...newState,
-            visualLayout: calculateLayout(newState.lines, newState.viewportWidth),
+            preferredCol: shouldResetPreferred ? null : newState.preferredCol,
+            visualLayout: calculateLayout(newState.lines, newState.viewportWidth, [
+                newState.cursorRow,
+                newState.cursorCol,
+            ]),
+            transformationsByLine: newTransformedLines,
         };
     }
     return newState;
 }
 // --- End of reducer logic ---
-export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewport, stdin, setRawMode, onChange, isValidPath, shellModeActive = false, inputFilter, singleLine = false, }) {
+export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewport, stdin, setRawMode, onChange, isValidPath, shellModeActive = false, inputFilter, singleLine = false, getPreferredEditor, }) {
     const initialState = useMemo(() => {
         const lines = initialText.split('\n');
         const [initialCursorRow, initialCursorCol] = calculateInitialCursorPosition(lines.length === 0 ? [''] : lines, initialCursorOffset);
-        const visualLayout = calculateLayout(lines.length === 0 ? [''] : lines, viewport.width);
+        const transformationsByLine = calculateTransformations(lines.length === 0 ? [''] : lines);
+        const visualLayout = calculateLayout(lines.length === 0 ? [''] : lines, viewport.width, [initialCursorRow, initialCursorCol]);
         return {
             lines: lines.length === 0 ? [''] : lines,
             cursorRow: initialCursorRow,
             cursorCol: initialCursorCol,
+            transformationsByLine,
             preferredCol: null,
             undoStack: [],
             redoStack: [],
@@ -1148,10 +1317,10 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         };
     }, [initialText, initialCursorOffset, viewport.width, viewport.height]);
     const [state, dispatch] = useReducer((s, a) => textBufferReducer(s, a, { inputFilter, singleLine }), initialState);
-    const { lines, cursorRow, cursorCol, preferredCol, selectionAnchor, visualLayout, } = state;
+    const { lines, cursorRow, cursorCol, preferredCol, selectionAnchor, visualLayout, transformationsByLine, } = state;
     const text = useMemo(() => lines.join('\n'), [lines]);
     const visualCursor = useMemo(() => calculateVisualCursorFromLayout(visualLayout, [cursorRow, cursorCol]), [visualLayout, cursorRow, cursorCol]);
-    const { visualLines, visualToLogicalMap } = visualLayout;
+    const { visualLines, visualToLogicalMap, transformedToLogicalMaps, visualToTransformedMap, } = visualLayout;
     const [visualScrollRow, setVisualScrollRow] = useState(0);
     useEffect(() => {
         if (onChange) {
@@ -1198,8 +1367,9 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
                 potentialPath = quoteMatch[1];
             }
             potentialPath = potentialPath.trim();
-            if (isValidPath(unescapePath(potentialPath))) {
-                ch = `@${potentialPath} `;
+            const processed = parsePastedPaths(potentialPath, isValidPath);
+            if (processed) {
+                ch = processed;
             }
         }
         let currentText = '';
@@ -1353,19 +1523,32 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
     const vimEscapeInsertMode = useCallback(() => {
         dispatch({ type: 'vim_escape_insert_mode' });
     }, []);
-    const openInExternalEditor = useCallback(async (opts = {}) => {
-        const editor = opts.editor ??
-            process.env['VISUAL'] ??
-            process.env['EDITOR'] ??
-            (process.platform === 'win32' ? 'notepad' : 'vi');
+    const openInExternalEditor = useCallback(async () => {
         const tmpDir = fs.mkdtempSync(pathMod.join(os.tmpdir(), 'gemini-edit-'));
         const filePath = pathMod.join(tmpDir, 'buffer.txt');
         fs.writeFileSync(filePath, text, 'utf8');
+        let command = undefined;
+        const args = [filePath];
+        const preferredEditorType = getPreferredEditor?.();
+        if (!command && preferredEditorType) {
+            command = getEditorCommand(preferredEditorType);
+            if (isGuiEditor(preferredEditorType)) {
+                args.unshift('--wait');
+            }
+        }
+        if (!command) {
+            command =
+                (process.env['VISUAL'] ??
+                    process.env['EDITOR'] ??
+                    process.platform === 'win32')
+                    ? 'notepad'
+                    : 'vi';
+        }
         dispatch({ type: 'create_undo_snapshot' });
         const wasRaw = stdin?.isRaw ?? false;
         try {
             setRawMode?.(false);
-            const { status, error } = spawnSync(editor, [filePath], {
+            const { status, error } = spawnSync(command, args, {
                 stdio: 'inherit',
             });
             if (error)
@@ -1377,10 +1560,9 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
             dispatch({ type: 'set_text', payload: newText, pushToUndo: false });
         }
         catch (err) {
-            console.error('[useTextBuffer] external editor error', err);
+            coreEvents.emitFeedback('error', '[useTextBuffer] external editor error', err);
         }
         finally {
-            enableSupportedProtocol();
             coreEvents.emit(CoreEvent.ExternalEditorClosed);
             if (wasRaw)
                 setRawMode?.(true);
@@ -1397,7 +1579,7 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
                 /* ignore */
             }
         }
-    }, [text, stdin, setRawMode]);
+    }, [text, stdin, setRawMode, getPreferredEditor]);
     const handleInput = useCallback((key) => {
         const { sequence: input } = key;
         if (key.paste) {
@@ -1413,50 +1595,33 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
                 input === '\\r') // VSCode terminal represents shift + enter this way
         )
             newline();
-        else if (key.name === 'left' && !key.meta && !key.ctrl)
-            move('left');
-        else if (key.ctrl && key.name === 'b')
+        else if (keyMatchers[Command.MOVE_LEFT](key))
             move('left');
-        else if (key.name === 'right' && !key.meta && !key.ctrl)
-            move('right');
-        else if (key.ctrl && key.name === 'f')
+        else if (keyMatchers[Command.MOVE_RIGHT](key))
             move('right');
         else if (key.name === 'up')
             move('up');
         else if (key.name === 'down')
             move('down');
-        else if ((key.ctrl || key.meta) && key.name === 'left')
+        else if (keyMatchers[Command.MOVE_WORD_LEFT](key))
             move('wordLeft');
-        else if (key.meta && key.name === 'b')
-            move('wordLeft');
-        else if ((key.ctrl || key.meta) && key.name === 'right')
-            move('wordRight');
-        else if (key.meta && key.name === 'f')
+        else if (keyMatchers[Command.MOVE_WORD_RIGHT](key))
             move('wordRight');
-        else if (key.name === 'home')
+        else if (keyMatchers[Command.HOME](key))
             move('home');
-        else if (key.ctrl && key.name === 'a')
-            move('home');
-        else if (key.name === 'end')
-            move('end');
-        else if (key.ctrl && key.name === 'e')
+        else if (keyMatchers[Command.END](key))
             move('end');
-        else if (key.ctrl && key.name === 'w')
+        else if (keyMatchers[Command.DELETE_WORD_BACKWARD](key))
             deleteWordLeft();
-        else if ((key.meta || key.ctrl) &&
-            (key.name === 'backspace' || input === '\x7f'))
-            deleteWordLeft();
-        else if ((key.meta || key.ctrl) && key.name === 'delete')
+        else if (keyMatchers[Command.DELETE_WORD_FORWARD](key))
             deleteWordRight();
-        else if (key.name === 'backspace' ||
-            input === '\x7f' ||
-            (key.ctrl && key.name === 'h'))
+        else if (keyMatchers[Command.DELETE_CHAR_LEFT](key))
             backspace();
-        else if (key.name === 'delete' || (key.ctrl && key.name === 'd'))
+        else if (keyMatchers[Command.DELETE_CHAR_RIGHT](key))
             del();
-        else if (key.ctrl && !key.shift && key.name === 'z')
+        else if (keyMatchers[Command.UNDO](key))
             undo();
-        else if (key.ctrl && key.shift && key.name === 'z')
+        else if (keyMatchers[Command.REDO](key))
             redo();
         else if (key.insertable) {
             insert(input, { paste: key.paste });
@@ -1489,12 +1654,16 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         dispatch({ type: 'move_to_offset', payload: { offset } });
     }, []);
     const moveToVisualPosition = useCallback((visRow, visCol) => {
-        const { visualLines, visualToLogicalMap } = visualLayout;
+        const { visualLines, visualToLogicalMap, transformedToLogicalMaps, visualToTransformedMap, } = visualLayout;
         // Clamp visRow to valid range
         const clampedVisRow = Math.max(0, Math.min(visRow, visualLines.length - 1));
         const visualLine = visualLines[clampedVisRow] || '';
         if (visualToLogicalMap[clampedVisRow]) {
-            const [logRow, logStartCol] = visualToLogicalMap[clampedVisRow];
+            const [logRow] = visualToLogicalMap[clampedVisRow];
+            const transformedToLogicalMap = transformedToLogicalMaps?.[logRow] ?? [];
+            // Where does this visual line begin within the transformed line?
+            const startColInTransformed = visualToTransformedMap?.[clampedVisRow] ?? 0;
+            // Handle wide characters: convert visual X position to character offset
             const codePoints = toCodePoints(visualLine);
             let currentVisX = 0;
             let charOffset = 0;
@@ -1513,8 +1682,10 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
             }
             // Clamp charOffset to length
             charOffset = Math.min(charOffset, codePoints.length);
+            // Map character offset through transformations to get logical position
+            const transformedCol = Math.min(startColInTransformed + charOffset, Math.max(0, transformedToLogicalMap.length - 1));
             const newCursorRow = logRow;
-            const newCursorCol = logStartCol + charOffset;
+            const newCursorCol = transformedToLogicalMap[transformedCol] ?? cpLen(lines[logRow] ?? '');
             dispatch({
                 type: 'set_cursor',
                 payload: {
@@ -1524,7 +1695,7 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
                 },
             });
         }
-    }, [visualLayout]);
+    }, [visualLayout, lines]);
     const getOffset = useCallback(() => logicalPosToOffset(lines, cursorRow, cursorCol), [lines, cursorRow, cursorCol]);
     const returnValue = useMemo(() => ({
         lines,
@@ -1537,6 +1708,9 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         visualCursor,
         visualScrollRow,
         visualToLogicalMap,
+        transformedToLogicalMaps,
+        visualToTransformedMap,
+        transformationsByLine,
         setText,
         insert,
         newline,
@@ -1600,6 +1774,10 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         renderedVisualLines,
         visualCursor,
         visualScrollRow,
+        visualToLogicalMap,
+        transformedToLogicalMaps,
+        visualToTransformedMap,
+        transformationsByLine,
         setText,
         insert,
         newline,
@@ -1651,7 +1829,6 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         vimMoveToLastLine,
         vimMoveToLine,
         vimEscapeInsertMode,
-        visualToLogicalMap,
     ]);
     return returnValue;
 }