@umsai/ums-code 0.0.14-v1 → 0.1.4-v2

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

@@ -3,15 +3,13 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import stripAnsi from 'strip-ansi';
-import { spawnSync } from 'child_process';
-import fs from 'fs';
-import os from 'os';
-import pathMod from 'path';
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import pathMod from 'node:path';
 import { useState, useCallback, useEffect, useMemo, useReducer } from 'react';
-import stringWidth from 'string-width';
 import { unescapePath } from '@umsai/ums-code-core';
-import { toCodePoints, cpLen, cpSlice } from '../../utils/textUtils.js';
+import { toCodePoints, cpLen, cpSlice, stripUnsafeCharacters, getCachedStringWidth, } from '../../utils/textUtils.js';
 import { handleVimAction } from './vim-buffer-actions.js';
 // Simple helper for word‑wise ops.
 function isWordChar(ch) {
@@ -20,112 +18,266 @@ function isWordChar(ch) {
     }
     return !/[\s,.;!?]/.test(ch);
 }
-// Vim-specific word boundary functions
-export const findNextWordStart = (text, currentOffset) => {
-    let i = currentOffset;
-    if (i >= text.length)
-        return i;
-    const currentChar = text[i];
+// 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);
+// Check if a character is a combining mark (only diacritics for now)
+export const isCombiningMark = (char) => /\p{M}/u.test(char);
+// Check if a character should be considered part of a word (including combining marks)
+export const isWordCharWithCombining = (char) => isWordCharStrict(char) || isCombiningMark(char);
+// Get the script of a character (simplified for common scripts)
+export const getCharScript = (char) => {
+    if (/[\p{Script=Latin}]/u.test(char))
+        return 'latin'; // All Latin script chars including diacritics
+    if (/[\p{Script=Han}]/u.test(char))
+        return 'han'; // Chinese
+    if (/[\p{Script=Arabic}]/u.test(char))
+        return 'arabic';
+    if (/[\p{Script=Hiragana}]/u.test(char))
+        return 'hiragana';
+    if (/[\p{Script=Katakana}]/u.test(char))
+        return 'katakana';
+    if (/[\p{Script=Cyrillic}]/u.test(char))
+        return 'cyrillic';
+    return 'other';
+};
+// Check if two characters are from different scripts (indicating word boundary)
+export const isDifferentScript = (char1, char2) => {
+    if (!isWordCharStrict(char1) || !isWordCharStrict(char2))
+        return false;
+    return getCharScript(char1) !== getCharScript(char2);
+};
+// Find next word start within a line, starting from col
+export const findNextWordStartInLine = (line, col) => {
+    const chars = toCodePoints(line);
+    let i = col;
+    if (i >= chars.length)
+        return null;
+    const currentChar = chars[i];
     // Skip current word/sequence based on character type
-    if (/\w/.test(currentChar)) {
-        // Skip current word characters
-        while (i < text.length && /\w/.test(text[i])) {
+    if (isWordCharStrict(currentChar)) {
+        while (i < chars.length && isWordCharWithCombining(chars[i])) {
+            // Check for script boundary - if next character is from different script, stop here
+            if (i + 1 < chars.length &&
+                isWordCharStrict(chars[i + 1]) &&
+                isDifferentScript(chars[i], chars[i + 1])) {
+                i++; // Include current character
+                break; // Stop at script boundary
+            }
             i++;
         }
     }
-    else if (!/\s/.test(currentChar)) {
-        // Skip current non-word, non-whitespace characters (like "/", ".", etc.)
-        while (i < text.length && !/\w/.test(text[i]) && !/\s/.test(text[i])) {
+    else if (!isWhitespace(currentChar)) {
+        while (i < chars.length &&
+            !isWordCharStrict(chars[i]) &&
+            !isWhitespace(chars[i])) {
             i++;
         }
     }
     // Skip whitespace
-    while (i < text.length && /\s/.test(text[i])) {
+    while (i < chars.length && isWhitespace(chars[i])) {
         i++;
     }
-    // If we reached the end of text and there's no next word,
-    // vim behavior for dw is to delete to the end of the current word
-    if (i >= text.length) {
-        // Go back to find the end of the last word
-        let endOfLastWord = text.length - 1;
-        while (endOfLastWord >= 0 && /\s/.test(text[endOfLastWord])) {
-            endOfLastWord--;
-        }
-        // For dw on last word, return position AFTER the last character to delete entire word
-        return Math.max(currentOffset + 1, endOfLastWord + 1);
-    }
-    return i;
+    return i < chars.length ? i : null;
 };
-export const findPrevWordStart = (text, currentOffset) => {
-    let i = currentOffset;
-    // If at beginning of text, return current position
-    if (i <= 0) {
-        return currentOffset;
-    }
-    // Move back one character to start searching
+// Find previous word start within a line
+export const findPrevWordStartInLine = (line, col) => {
+    const chars = toCodePoints(line);
+    let i = col;
+    if (i <= 0)
+        return null;
     i--;
     // Skip whitespace moving backwards
-    while (i >= 0 && (text[i] === ' ' || text[i] === '\t' || text[i] === '\n')) {
+    while (i >= 0 && isWhitespace(chars[i])) {
         i--;
     }
-    if (i < 0) {
-        return 0; // Reached beginning of text
-    }
-    const charAtI = text[i];
-    if (/\w/.test(charAtI)) {
+    if (i < 0)
+        return null;
+    if (isWordCharStrict(chars[i])) {
         // We're in a word, move to its beginning
-        while (i >= 0 && /\w/.test(text[i])) {
+        while (i >= 0 && isWordCharStrict(chars[i])) {
+            // Check for script boundary - if previous character is from different script, stop here
+            if (i - 1 >= 0 &&
+                isWordCharStrict(chars[i - 1]) &&
+                isDifferentScript(chars[i], chars[i - 1])) {
+                return i; // Return current position at script boundary
+            }
             i--;
         }
-        return i + 1; // Return first character of word
+        return i + 1;
     }
     else {
         // We're in punctuation, move to its beginning
-        while (i >= 0 &&
-            !/\w/.test(text[i]) &&
-            text[i] !== ' ' &&
-            text[i] !== '\t' &&
-            text[i] !== '\n') {
+        while (i >= 0 && !isWordCharStrict(chars[i]) && !isWhitespace(chars[i])) {
             i--;
         }
-        return i + 1; // Return first character of punctuation sequence
+        return i + 1;
     }
 };
-export const findWordEnd = (text, currentOffset) => {
-    let i = currentOffset;
-    // If we're already at the end of a word, advance to next word
-    if (i < text.length &&
-        /\w/.test(text[i]) &&
-        (i + 1 >= text.length || !/\w/.test(text[i + 1]))) {
-        // We're at the end of a word, move forward to find next word
+// Find word end within a line
+export const findWordEndInLine = (line, col) => {
+    const chars = toCodePoints(line);
+    let i = col;
+    // If we're already at the end of a word (including punctuation sequences), advance to next word
+    // This includes both regular word endings and script boundaries
+    const atEndOfWordChar = i < chars.length &&
+        isWordCharWithCombining(chars[i]) &&
+        (i + 1 >= chars.length ||
+            !isWordCharWithCombining(chars[i + 1]) ||
+            (isWordCharStrict(chars[i]) &&
+                i + 1 < chars.length &&
+                isWordCharStrict(chars[i + 1]) &&
+                isDifferentScript(chars[i], chars[i + 1])));
+    const atEndOfPunctuation = i < chars.length &&
+        !isWordCharWithCombining(chars[i]) &&
+        !isWhitespace(chars[i]) &&
+        (i + 1 >= chars.length ||
+            isWhitespace(chars[i + 1]) ||
+            isWordCharWithCombining(chars[i + 1]));
+    if (atEndOfWordChar || atEndOfPunctuation) {
+        // We're at the end of a word or punctuation sequence, move forward to find next word
         i++;
-        // Skip whitespace/punctuation to find next word
-        while (i < text.length && !/\w/.test(text[i])) {
+        // Skip whitespace to find next word or punctuation
+        while (i < chars.length && isWhitespace(chars[i])) {
             i++;
         }
     }
-    // If we're not on a word character, find the next word
-    if (i < text.length && !/\w/.test(text[i])) {
-        while (i < text.length && !/\w/.test(text[i])) {
+    // If we're not on a word character, find the next word or punctuation sequence
+    if (i < chars.length && !isWordCharWithCombining(chars[i])) {
+        // Skip whitespace to find next word or punctuation
+        while (i < chars.length && isWhitespace(chars[i])) {
             i++;
         }
     }
-    // Move to end of current word
-    while (i < text.length && /\w/.test(text[i])) {
-        i++;
+    // Move to end of current word (including combining marks, but stop at script boundaries)
+    let foundWord = false;
+    let lastBaseCharPos = -1;
+    if (i < chars.length && isWordCharWithCombining(chars[i])) {
+        // Handle word characters
+        while (i < chars.length && isWordCharWithCombining(chars[i])) {
+            foundWord = true;
+            // Track the position of the last base character (not combining mark)
+            if (isWordCharStrict(chars[i])) {
+                lastBaseCharPos = i;
+            }
+            // Check if next character is from a different script (word boundary)
+            if (i + 1 < chars.length &&
+                isWordCharStrict(chars[i + 1]) &&
+                isDifferentScript(chars[i], chars[i + 1])) {
+                i++; // Include current character
+                if (isWordCharStrict(chars[i - 1])) {
+                    lastBaseCharPos = i - 1;
+                }
+                break; // Stop at script boundary
+            }
+            i++;
+        }
     }
-    // Move back one to be on the last character of the word
-    return Math.max(currentOffset, i - 1);
+    else if (i < chars.length && !isWhitespace(chars[i])) {
+        // Handle punctuation sequences (like ████)
+        while (i < chars.length &&
+            !isWordCharStrict(chars[i]) &&
+            !isWhitespace(chars[i])) {
+            foundWord = true;
+            lastBaseCharPos = i;
+            i++;
+        }
+    }
+    // Only return a position if we actually found a word
+    // Return the position of the last base character, not combining marks
+    if (foundWord && lastBaseCharPos >= col) {
+        return lastBaseCharPos;
+    }
+    return null;
 };
-// Helper functions for vim operations
-export const getOffsetFromPosition = (row, col, lines) => {
-    let offset = 0;
-    for (let i = 0; i < row; i++) {
-        offset += lines[i].length + 1; // +1 for newline
+// Find next word across lines
+export const findNextWordAcrossLines = (lines, cursorRow, cursorCol, searchForWordStart) => {
+    // First try current line
+    const currentLine = lines[cursorRow] || '';
+    const colInCurrentLine = searchForWordStart
+        ? findNextWordStartInLine(currentLine, cursorCol)
+        : findWordEndInLine(currentLine, cursorCol);
+    if (colInCurrentLine !== null) {
+        return { row: cursorRow, col: colInCurrentLine };
     }
-    offset += col;
-    return offset;
+    // Search subsequent lines
+    for (let row = cursorRow + 1; row < lines.length; row++) {
+        const line = lines[row] || '';
+        const chars = toCodePoints(line);
+        // For empty lines, if we haven't found any words yet, return the empty line
+        if (chars.length === 0) {
+            // Check if there are any words in remaining lines
+            let hasWordsInLaterLines = false;
+            for (let laterRow = row + 1; laterRow < lines.length; laterRow++) {
+                const laterLine = lines[laterRow] || '';
+                const laterChars = toCodePoints(laterLine);
+                let firstNonWhitespace = 0;
+                while (firstNonWhitespace < laterChars.length &&
+                    isWhitespace(laterChars[firstNonWhitespace])) {
+                    firstNonWhitespace++;
+                }
+                if (firstNonWhitespace < laterChars.length) {
+                    hasWordsInLaterLines = true;
+                    break;
+                }
+            }
+            // If no words in later lines, return the empty line
+            if (!hasWordsInLaterLines) {
+                return { row, col: 0 };
+            }
+            continue;
+        }
+        // Find first non-whitespace
+        let firstNonWhitespace = 0;
+        while (firstNonWhitespace < chars.length &&
+            isWhitespace(chars[firstNonWhitespace])) {
+            firstNonWhitespace++;
+        }
+        if (firstNonWhitespace < chars.length) {
+            if (searchForWordStart) {
+                return { row, col: firstNonWhitespace };
+            }
+            else {
+                // For word end, find the end of the first word
+                const endCol = findWordEndInLine(line, firstNonWhitespace);
+                if (endCol !== null) {
+                    return { row, col: endCol };
+                }
+            }
+        }
+    }
+    return null;
 };
+// Find previous word across lines
+export const findPrevWordAcrossLines = (lines, cursorRow, cursorCol) => {
+    // First try current line
+    const currentLine = lines[cursorRow] || '';
+    const colInCurrentLine = findPrevWordStartInLine(currentLine, cursorCol);
+    if (colInCurrentLine !== null) {
+        return { row: cursorRow, col: colInCurrentLine };
+    }
+    // Search previous lines
+    for (let row = cursorRow - 1; row >= 0; row--) {
+        const line = lines[row] || '';
+        const chars = toCodePoints(line);
+        if (chars.length === 0)
+            continue;
+        // Find last word start
+        let lastWordStart = chars.length;
+        while (lastWordStart > 0 && isWhitespace(chars[lastWordStart - 1])) {
+            lastWordStart--;
+        }
+        if (lastWordStart > 0) {
+            // Find start of this word
+            const wordStart = findPrevWordStartInLine(line, lastWordStart);
+            if (wordStart !== null) {
+                return { row, col: wordStart };
+            }
+        }
+    }
+    return null;
+};
+// Helper functions for vim line operations
 export const getPositionFromOffsets = (startOffset, endOffset, lines) => {
     let offset = 0;
     let startRow = 0;
@@ -218,27 +370,6 @@ export const replaceRangeInternal = (state, startRow, startCol, endRow, endCol,
         preferredCol: null,
     };
 };
-/**
- * Strip characters that can break terminal rendering.
- *
- * Strip ANSI escape codes and control characters except for line breaks.
- * Control characters such as delete break terminal UI rendering.
- */
-function stripUnsafeCharacters(str) {
-    const stripped = stripAnsi(str);
-    return toCodePoints(stripped)
-        .filter((char) => {
-        if (char.length > 1)
-            return false;
-        const code = char.codePointAt(0);
-        if (code === undefined) {
-            return false;
-        }
-        const isUnsafe = code === 127 || (code <= 31 && code !== 13 && code !== 10);
-        return !isUnsafe;
-    })
-        .join('');
-}
 function clamp(v, min, max) {
     return v < min ? min : v > max ? max : v;
 }
@@ -323,12 +454,12 @@ export function logicalPosToOffset(lines, row, col) {
     }
     return offset;
 }
-// Helper to calculate visual lines and map cursor positions
-function calculateVisualLayout(logicalLines, logicalCursor, viewportWidth) {
+// 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) {
     const visualLines = [];
     const logicalToVisualMap = [];
     const visualToLogicalMap = [];
-    let currentVisualCursor = [0, 0];
     logicalLines.forEach((logLine, logIndex) => {
         logicalToVisualMap[logIndex] = [];
         if (logLine.length === 0) {
@@ -336,9 +467,6 @@ function calculateVisualLayout(logicalLines, logicalCursor, viewportWidth) {
             logicalToVisualMap[logIndex].push([visualLines.length, 0]);
             visualToLogicalMap.push([logIndex, 0]);
             visualLines.push('');
-            if (logIndex === logicalCursor[0] && logicalCursor[1] === 0) {
-                currentVisualCursor = [visualLines.length - 1, 0];
-            }
         }
         else {
             // Non-empty logical line
@@ -353,7 +481,7 @@ function calculateVisualLayout(logicalLines, logicalCursor, viewportWidth) {
                 // Iterate through code points to build the current visual line (chunk)
                 for (let i = currentPosInLogLine; i < codePointsInLogLine.length; i++) {
                     const char = codePointsInLogLine[i];
-                    const charVisualWidth = stringWidth(char);
+                    const charVisualWidth = getCachedStringWidth(char);
                     if (currentChunkVisualWidth + charVisualWidth > viewportWidth) {
                         // Character would exceed viewport width
                         if (lastWordBreakPoint !== -1 &&
@@ -419,27 +547,6 @@ function calculateVisualLayout(logicalLines, logicalCursor, viewportWidth) {
                 ]);
                 visualToLogicalMap.push([logIndex, currentPosInLogLine]);
                 visualLines.push(currentChunk);
-                // Cursor mapping logic
-                // Note: currentPosInLogLine here is the start of the currentChunk within the logical line.
-                if (logIndex === logicalCursor[0]) {
-                    const cursorLogCol = logicalCursor[1]; // This is a code point index
-                    if (cursorLogCol >= currentPosInLogLine &&
-                        cursorLogCol < currentPosInLogLine + numCodePointsInChunk // Cursor is within this chunk
-                    ) {
-                        currentVisualCursor = [
-                            visualLines.length - 1,
-                            cursorLogCol - currentPosInLogLine, // Visual col is also code point index within visual line
-                        ];
-                    }
-                    else if (cursorLogCol === currentPosInLogLine + numCodePointsInChunk &&
-                        numCodePointsInChunk > 0) {
-                        // Cursor is exactly at the end of this non-empty chunk
-                        currentVisualCursor = [
-                            visualLines.length - 1,
-                            numCodePointsInChunk,
-                        ];
-                    }
-                }
                 const logicalStartOfThisChunk = currentPosInLogLine;
                 currentPosInLogLine += numCodePointsInChunk;
                 // If the chunk processed did not consume the entire logical line,
@@ -452,20 +559,6 @@ function calculateVisualLayout(logicalLines, logicalCursor, viewportWidth) {
                     currentPosInLogLine++;
                 }
             }
-            // After all chunks of a non-empty logical line are processed,
-            // if the cursor is at the very end of this logical line, update visual cursor.
-            if (logIndex === logicalCursor[0] &&
-                logicalCursor[1] === codePointsInLogLine.length // Cursor at end of logical line
-            ) {
-                const lastVisualLineIdx = visualLines.length - 1;
-                if (lastVisualLineIdx >= 0 &&
-                    visualLines[lastVisualLineIdx] !== undefined) {
-                    currentVisualCursor = [
-                        lastVisualLineIdx,
-                        cpLen(visualLines[lastVisualLineIdx]), // Cursor at end of last visual line for this logical line
-                    ];
-                }
-            }
         }
     });
     // If the entire logical text was empty, ensure there's one empty visual line.
@@ -478,23 +571,46 @@ function calculateVisualLayout(logicalLines, logicalCursor, viewportWidth) {
             logicalToVisualMap[0].push([0, 0]);
             visualToLogicalMap.push([0, 0]);
         }
-        currentVisualCursor = [0, 0];
-    }
-    // Handle cursor at the very end of the text (after all processing)
-    // This case might be covered by the loop end condition now, but kept for safety.
-    else if (logicalCursor[0] === logicalLines.length - 1 &&
-        logicalCursor[1] === cpLen(logicalLines[logicalLines.length - 1]) &&
-        visualLines.length > 0) {
-        const lastVisLineIdx = visualLines.length - 1;
-        currentVisualCursor = [lastVisLineIdx, cpLen(visualLines[lastVisLineIdx])];
     }
     return {
         visualLines,
-        visualCursor: currentVisualCursor,
         logicalToVisualMap,
         visualToLogicalMap,
     };
 }
+// 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 [logicalRow, logicalCol] = logicalCursor;
+    const segmentsForLogicalLine = logicalToVisualMap[logicalRow];
+    if (!segmentsForLogicalLine || segmentsForLogicalLine.length === 0) {
+        // This can happen for an empty document.
+        return [0, 0];
+    }
+    // Find the segment where the logical column fits.
+    // The segments are sorted by startColInLogical.
+    let targetSegmentIndex = segmentsForLogicalLine.findIndex(([, startColInLogical], index) => {
+        const nextStartColInLogical = index + 1 < segmentsForLogicalLine.length
+            ? segmentsForLogicalLine[index + 1][1]
+            : Infinity;
+        return (logicalCol >= startColInLogical && logicalCol < nextStartColInLogical);
+    });
+    // If not found, it means the cursor is at the end of the logical line.
+    if (targetSegmentIndex === -1) {
+        if (logicalCol === 0) {
+            targetSegmentIndex = 0;
+        }
+        else {
+            targetSegmentIndex = segmentsForLogicalLine.length - 1;
+        }
+    }
+    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] ?? ''));
+    return [visualRow, clampedVisualCol];
+}
 const historyLimit = 100;
 export const pushUndo = (currentState) => {
     const snapshot = {
@@ -508,7 +624,7 @@ export const pushUndo = (currentState) => {
     }
     return { ...currentState, undoStack: newStack, redoStack: [] };
 };
-export function textBufferReducer(state, action) {
+function textBufferReducerLogic(state, action) {
     const pushUndoLocal = pushUndo;
     const currentLine = (r) => state.lines[r] ?? '';
     const currentLineLen = (r) => cpLen(currentLine(r));
@@ -595,68 +711,101 @@ export function textBufferReducer(state, action) {
                 preferredCol: null,
             };
         }
-        case 'set_viewport_width': {
-            if (action.payload === state.viewportWidth) {
+        case 'set_viewport': {
+            const { width, height } = action.payload;
+            if (width === state.viewportWidth && height === state.viewportHeight) {
                 return state;
             }
-            return { ...state, viewportWidth: action.payload };
+            return {
+                ...state,
+                viewportWidth: width,
+                viewportHeight: height,
+            };
         }
         case 'move': {
             const { dir } = action.payload;
-            const { lines, cursorRow, cursorCol, viewportWidth } = state;
-            const visualLayout = calculateVisualLayout(lines, [cursorRow, cursorCol], viewportWidth);
-            const { visualLines, visualCursor, visualToLogicalMap } = visualLayout;
-            let newVisualRow = visualCursor[0];
-            let newVisualCol = visualCursor[1];
-            let newPreferredCol = state.preferredCol;
-            const currentVisLineLen = cpLen(visualLines[newVisualRow] ?? '');
-            switch (dir) {
-                case 'left':
-                    newPreferredCol = null;
-                    if (newVisualCol > 0) {
-                        newVisualCol--;
-                    }
-                    else if (newVisualRow > 0) {
-                        newVisualRow--;
-                        newVisualCol = cpLen(visualLines[newVisualRow] ?? '');
-                    }
-                    break;
-                case 'right':
-                    newPreferredCol = null;
-                    if (newVisualCol < currentVisLineLen) {
-                        newVisualCol++;
-                    }
-                    else if (newVisualRow < visualLines.length - 1) {
-                        newVisualRow++;
+            const { cursorRow, cursorCol, lines, visualLayout, preferredCol } = state;
+            // Visual movements
+            if (dir === 'left' ||
+                dir === 'right' ||
+                dir === 'up' ||
+                dir === 'down' ||
+                dir === 'home' ||
+                dir === 'end') {
+                const visualCursor = calculateVisualCursorFromLayout(visualLayout, [
+                    cursorRow,
+                    cursorCol,
+                ]);
+                const { visualLines, visualToLogicalMap } = visualLayout;
+                let newVisualRow = visualCursor[0];
+                let newVisualCol = visualCursor[1];
+                let newPreferredCol = preferredCol;
+                const currentVisLineLen = cpLen(visualLines[newVisualRow] ?? '');
+                switch (dir) {
+                    case 'left':
+                        newPreferredCol = null;
+                        if (newVisualCol > 0) {
+                            newVisualCol--;
+                        }
+                        else if (newVisualRow > 0) {
+                            newVisualRow--;
+                            newVisualCol = cpLen(visualLines[newVisualRow] ?? '');
+                        }
+                        break;
+                    case 'right':
+                        newPreferredCol = null;
+                        if (newVisualCol < currentVisLineLen) {
+                            newVisualCol++;
+                        }
+                        else if (newVisualRow < visualLines.length - 1) {
+                            newVisualRow++;
+                            newVisualCol = 0;
+                        }
+                        break;
+                    case 'up':
+                        if (newVisualRow > 0) {
+                            if (newPreferredCol === null)
+                                newPreferredCol = newVisualCol;
+                            newVisualRow--;
+                            newVisualCol = clamp(newPreferredCol, 0, cpLen(visualLines[newVisualRow] ?? ''));
+                        }
+                        break;
+                    case 'down':
+                        if (newVisualRow < visualLines.length - 1) {
+                            if (newPreferredCol === null)
+                                newPreferredCol = newVisualCol;
+                            newVisualRow++;
+                            newVisualCol = clamp(newPreferredCol, 0, cpLen(visualLines[newVisualRow] ?? ''));
+                        }
+                        break;
+                    case 'home':
+                        newPreferredCol = null;
                         newVisualCol = 0;
+                        break;
+                    case 'end':
+                        newPreferredCol = null;
+                        newVisualCol = currentVisLineLen;
+                        break;
+                    default: {
+                        const exhaustiveCheck = dir;
+                        console.error(`Unknown visual movement direction: ${exhaustiveCheck}`);
+                        return state;
                     }
-                    break;
-                case 'up':
-                    if (newVisualRow > 0) {
-                        if (newPreferredCol === null)
-                            newPreferredCol = newVisualCol;
-                        newVisualRow--;
-                        newVisualCol = clamp(newPreferredCol, 0, cpLen(visualLines[newVisualRow] ?? ''));
-                    }
-                    break;
-                case 'down':
-                    if (newVisualRow < visualLines.length - 1) {
-                        if (newPreferredCol === null)
-                            newPreferredCol = newVisualCol;
-                        newVisualRow++;
-                        newVisualCol = clamp(newPreferredCol, 0, cpLen(visualLines[newVisualRow] ?? ''));
-                    }
-                    break;
-                case 'home':
-                    newPreferredCol = null;
-                    newVisualCol = 0;
-                    break;
-                case 'end':
-                    newPreferredCol = null;
-                    newVisualCol = currentVisLineLen;
-                    break;
+                }
+                if (visualToLogicalMap[newVisualRow]) {
+                    const [logRow, logStartCol] = visualToLogicalMap[newVisualRow];
+                    return {
+                        ...state,
+                        cursorRow: logRow,
+                        cursorCol: clamp(logStartCol + newVisualCol, 0, cpLen(lines[logRow] ?? '')),
+                        preferredCol: newPreferredCol,
+                    };
+                }
+                return state;
+            }
+            // Logical movements
+            switch (dir) {
                 case 'wordLeft': {
-                    const { cursorRow, cursorCol, lines } = state;
                     if (cursorCol === 0 && cursorRow === 0)
                         return state;
                     let newCursorRow = cursorRow;
@@ -695,7 +844,6 @@ export function textBufferReducer(state, action) {
                     };
                 }
                 case 'wordRight': {
-                    const { cursorRow, cursorCol, lines } = state;
                     if (cursorRow === lines.length - 1 &&
                         cursorCol === cpLen(lines[cursorRow] ?? '')) {
                         return state;
@@ -724,18 +872,14 @@ export function textBufferReducer(state, action) {
                     };
                 }
                 default:
-                    break;
-            }
-            if (visualToLogicalMap[newVisualRow]) {
-                const [logRow, logStartCol] = visualToLogicalMap[newVisualRow];
-                return {
-                    ...state,
-                    cursorRow: logRow,
-                    cursorCol: clamp(logStartCol + newVisualCol, 0, cpLen(state.lines[logRow] ?? '')),
-                    preferredCol: newPreferredCol,
-                };
+                    return state;
             }
-            return state;
+        }
+        case 'set_cursor': {
+            return {
+                ...state,
+                ...action.payload,
+            };
         }
         case 'delete': {
             const { cursorRow, cursorCol, lines } = state;
@@ -746,7 +890,11 @@ export function textBufferReducer(state, action) {
                 newLines[cursorRow] =
                     cpSlice(lineContent, 0, cursorCol) +
                         cpSlice(lineContent, cursorCol + 1);
-                return { ...nextState, lines: newLines, preferredCol: null };
+                return {
+                    ...nextState,
+                    lines: newLines,
+                    preferredCol: null,
+                };
             }
             else if (cursorRow < lines.length - 1) {
                 const nextState = pushUndoLocal(state);
@@ -754,7 +902,11 @@ export function textBufferReducer(state, action) {
                 const newLines = [...nextState.lines];
                 newLines[cursorRow] = lineContent + nextLineContent;
                 newLines.splice(cursorRow + 1, 1);
-                return { ...nextState, lines: newLines, preferredCol: null };
+                return {
+                    ...nextState,
+                    lines: newLines,
+                    preferredCol: null,
+                };
             }
             return state;
         }
@@ -762,78 +914,62 @@ export function textBufferReducer(state, action) {
             const { cursorRow, cursorCol } = state;
             if (cursorCol === 0 && cursorRow === 0)
                 return state;
-            if (cursorCol === 0) {
+            const nextState = pushUndoLocal(state);
+            const newLines = [...nextState.lines];
+            let newCursorRow = cursorRow;
+            let newCursorCol = cursorCol;
+            if (newCursorCol > 0) {
+                const lineContent = currentLine(newCursorRow);
+                const prevWordStart = findPrevWordStartInLine(lineContent, newCursorCol);
+                const start = prevWordStart === null ? 0 : prevWordStart;
+                newLines[newCursorRow] =
+                    cpSlice(lineContent, 0, start) + cpSlice(lineContent, newCursorCol);
+                newCursorCol = start;
+            }
+            else {
                 // Act as a backspace
-                const nextState = pushUndoLocal(state);
                 const prevLineContent = currentLine(cursorRow - 1);
                 const currentLineContentVal = currentLine(cursorRow);
                 const newCol = cpLen(prevLineContent);
-                const newLines = [...nextState.lines];
                 newLines[cursorRow - 1] = prevLineContent + currentLineContentVal;
                 newLines.splice(cursorRow, 1);
-                return {
-                    ...nextState,
-                    lines: newLines,
-                    cursorRow: cursorRow - 1,
-                    cursorCol: newCol,
-                    preferredCol: null,
-                };
-            }
-            const nextState = pushUndoLocal(state);
-            const lineContent = currentLine(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--;
+                newCursorRow--;
+                newCursorCol = newCol;
             }
-            const newLines = [...nextState.lines];
-            newLines[cursorRow] =
-                cpSlice(lineContent, 0, start) + cpSlice(lineContent, cursorCol);
             return {
                 ...nextState,
                 lines: newLines,
-                cursorCol: start,
+                cursorRow: newCursorRow,
+                cursorCol: newCursorCol,
                 preferredCol: null,
             };
         }
         case 'delete_word_right': {
             const { cursorRow, cursorCol, lines } = state;
             const lineContent = currentLine(cursorRow);
-            const arr = toCodePoints(lineContent);
-            if (cursorCol >= arr.length && cursorRow === lines.length - 1)
+            const lineLen = cpLen(lineContent);
+            if (cursorCol >= lineLen && cursorRow === lines.length - 1) {
                 return state;
-            if (cursorCol >= arr.length) {
-                // Act as a delete
-                const nextState = pushUndoLocal(state);
+            }
+            const nextState = pushUndoLocal(state);
+            const newLines = [...nextState.lines];
+            if (cursorCol >= lineLen) {
+                // Act as a delete, joining with the next line
                 const nextLineContent = currentLine(cursorRow + 1);
-                const newLines = [...nextState.lines];
                 newLines[cursorRow] = lineContent + nextLineContent;
                 newLines.splice(cursorRow + 1, 1);
-                return { ...nextState, lines: newLines, preferredCol: null };
             }
-            const nextState = pushUndoLocal(state);
-            let end = cursorCol;
-            while (end < arr.length && !isWordChar(arr[end]))
-                end++;
-            while (end < arr.length && isWordChar(arr[end]))
-                end++;
-            const newLines = [...nextState.lines];
-            newLines[cursorRow] =
-                cpSlice(lineContent, 0, cursorCol) + cpSlice(lineContent, end);
-            return { ...nextState, lines: newLines, preferredCol: null };
+            else {
+                const nextWordStart = findNextWordStartInLine(lineContent, cursorCol);
+                const end = nextWordStart === null ? lineLen : nextWordStart;
+                newLines[cursorRow] =
+                    cpSlice(lineContent, 0, cursorCol) + cpSlice(lineContent, end);
+            }
+            return {
+                ...nextState,
+                lines: newLines,
+                preferredCol: null,
+            };
         }
         case 'kill_line_right': {
             const { cursorRow, cursorCol, lines } = state;
@@ -842,7 +978,10 @@ export function textBufferReducer(state, action) {
                 const nextState = pushUndoLocal(state);
                 const newLines = [...nextState.lines];
                 newLines[cursorRow] = cpSlice(lineContent, 0, cursorCol);
-                return { ...nextState, lines: newLines };
+                return {
+                    ...nextState,
+                    lines: newLines,
+                };
             }
             else if (cursorRow < lines.length - 1) {
                 // Act as a delete
@@ -851,7 +990,11 @@ export function textBufferReducer(state, action) {
                 const newLines = [...nextState.lines];
                 newLines[cursorRow] = lineContent + nextLineContent;
                 newLines.splice(cursorRow + 1, 1);
-                return { ...nextState, lines: newLines, preferredCol: null };
+                return {
+                    ...nextState,
+                    lines: newLines,
+                    preferredCol: null,
+                };
             }
             return state;
         }
@@ -962,11 +1105,23 @@ export function textBufferReducer(state, action) {
         }
     }
 }
+export function textBufferReducer(state, action) {
+    const newState = textBufferReducerLogic(state, action);
+    if (newState.lines !== state.lines ||
+        newState.viewportWidth !== state.viewportWidth) {
+        return {
+            ...newState,
+            visualLayout: calculateLayout(newState.lines, newState.viewportWidth),
+        };
+    }
+    return newState;
+}
 // --- End of reducer logic ---
 export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewport, stdin, setRawMode, onChange, isValidPath, shellModeActive = false, }) {
     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);
         return {
             lines: lines.length === 0 ? [''] : lines,
             cursorRow: initialCursorRow,
@@ -977,13 +1132,15 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
             clipboard: null,
             selectionAnchor: null,
             viewportWidth: viewport.width,
+            viewportHeight: viewport.height,
+            visualLayout,
         };
-    }, [initialText, initialCursorOffset, viewport.width]);
+    }, [initialText, initialCursorOffset, viewport.width, viewport.height]);
     const [state, dispatch] = useReducer(textBufferReducer, initialState);
-    const { lines, cursorRow, cursorCol, preferredCol, selectionAnchor } = state;
+    const { lines, cursorRow, cursorCol, preferredCol, selectionAnchor, visualLayout, } = state;
     const text = useMemo(() => lines.join('\n'), [lines]);
-    const visualLayout = useMemo(() => calculateVisualLayout(lines, [cursorRow, cursorCol], state.viewportWidth), [lines, cursorRow, cursorCol, state.viewportWidth]);
-    const { visualLines, visualCursor } = visualLayout;
+    const visualCursor = useMemo(() => calculateVisualCursorFromLayout(visualLayout, [cursorRow, cursorCol]), [visualLayout, cursorRow, cursorCol]);
+    const { visualLines, visualToLogicalMap } = visualLayout;
     const [visualScrollRow, setVisualScrollRow] = useState(0);
     useEffect(() => {
         if (onChange) {
@@ -991,11 +1148,16 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         }
     }, [text, onChange]);
     useEffect(() => {
-        dispatch({ type: 'set_viewport_width', payload: viewport.width });
-    }, [viewport.width]);
+        dispatch({
+            type: 'set_viewport',
+            payload: { width: viewport.width, height: viewport.height },
+        });
+    }, [viewport.width, viewport.height]);
     // Update visual scroll (vertical)
     useEffect(() => {
         const { height } = viewport;
+        const totalVisualLines = visualLines.length;
+        const maxScrollStart = Math.max(0, totalVisualLines - height);
         let newVisualScrollRow = visualScrollRow;
         if (visualCursor[0] < visualScrollRow) {
             newVisualScrollRow = visualCursor[0];
@@ -1003,10 +1165,13 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         else if (visualCursor[0] >= visualScrollRow + height) {
             newVisualScrollRow = visualCursor[0] - height + 1;
         }
+        // When the number of visual lines shrinks (e.g., after widening the viewport),
+        // ensure scroll never starts beyond the last valid start so we can render a full window.
+        newVisualScrollRow = clamp(newVisualScrollRow, 0, maxScrollStart);
         if (newVisualScrollRow !== visualScrollRow) {
             setVisualScrollRow(newVisualScrollRow);
         }
-    }, [visualCursor, visualScrollRow, viewport]);
+    }, [visualCursor, visualScrollRow, viewport, visualLines.length]);
     const insert = useCallback((ch, { paste = false } = {}) => {
         if (/[\n\r]/.test(ch)) {
             dispatch({ type: 'insert', payload: ch });
@@ -1054,7 +1219,7 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
     }, []);
     const move = useCallback((dir) => {
         dispatch({ type: 'move', payload: { dir } });
-    }, []);
+    }, [dispatch]);
     const undo = useCallback(() => {
         dispatch({ type: 'undo' });
     }, []);
@@ -1219,6 +1384,12 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
     }, [text, stdin, setRawMode]);
     const handleInput = useCallback((key) => {
         const { sequence: input } = key;
+        if (key.paste) {
+            // Do not do any other processing on pastes so ensure we handle them
+            // before all other cases.
+            insert(input, { paste: key.paste });
+            return;
+        }
         if (key.name === 'return' ||
             input === '\r' ||
             input === '\n' ||
@@ -1266,10 +1437,24 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
             backspace();
         else if (key.name === 'delete' || (key.ctrl && key.name === 'd'))
             del();
+        else if (key.ctrl && !key.shift && key.name === 'z')
+            undo();
+        else if (key.ctrl && key.shift && key.name === 'z')
+            redo();
         else if (input && !key.ctrl && !key.meta) {
             insert(input, { paste: key.paste });
         }
-    }, [newline, move, deleteWordLeft, deleteWordRight, backspace, del, insert]);
+    }, [
+        newline,
+        move,
+        deleteWordLeft,
+        deleteWordRight,
+        backspace,
+        del,
+        insert,
+        undo,
+        redo,
+    ]);
     const renderedVisualLines = useMemo(() => visualLines.slice(visualScrollRow, visualScrollRow + viewport.height), [visualLines, visualScrollRow, viewport.height]);
     const replaceRange = useCallback((startRow, startCol, endRow, endCol, text) => {
         dispatch({
@@ -1285,7 +1470,7 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
     const moveToOffset = useCallback((offset) => {
         dispatch({ type: 'move_to_offset', payload: { offset } });
     }, []);
-    const returnValue = {
+    const returnValue = useMemo(() => ({
         lines,
         text,
         cursor: [cursorRow, cursorCol],
@@ -1295,6 +1480,7 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         viewportVisualLines: renderedVisualLines,
         visualCursor,
         visualScrollRow,
+        visualToLogicalMap,
         setText,
         insert,
         newline,
@@ -1345,7 +1531,68 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         vimMoveToLastLine,
         vimMoveToLine,
         vimEscapeInsertMode,
-    };
+    }), [
+        lines,
+        text,
+        cursorRow,
+        cursorCol,
+        preferredCol,
+        selectionAnchor,
+        visualLines,
+        renderedVisualLines,
+        visualCursor,
+        visualScrollRow,
+        setText,
+        insert,
+        newline,
+        backspace,
+        del,
+        move,
+        undo,
+        redo,
+        replaceRange,
+        replaceRangeByOffset,
+        moveToOffset,
+        deleteWordLeft,
+        deleteWordRight,
+        killLineRight,
+        killLineLeft,
+        handleInput,
+        openInExternalEditor,
+        vimDeleteWordForward,
+        vimDeleteWordBackward,
+        vimDeleteWordEnd,
+        vimChangeWordForward,
+        vimChangeWordBackward,
+        vimChangeWordEnd,
+        vimDeleteLine,
+        vimChangeLine,
+        vimDeleteToEndOfLine,
+        vimChangeToEndOfLine,
+        vimChangeMovement,
+        vimMoveLeft,
+        vimMoveRight,
+        vimMoveUp,
+        vimMoveDown,
+        vimMoveWordForward,
+        vimMoveWordBackward,
+        vimMoveWordEnd,
+        vimDeleteChar,
+        vimInsertAtCursor,
+        vimAppendAtCursor,
+        vimOpenLineBelow,
+        vimOpenLineAbove,
+        vimAppendAtLineEnd,
+        vimInsertAtLineStart,
+        vimMoveToLineStart,
+        vimMoveToLineEnd,
+        vimMoveToFirstNonWhitespace,
+        vimMoveToFirstLine,
+        vimMoveToLastLine,
+        vimMoveToLine,
+        vimEscapeInsertMode,
+        visualToLogicalMap,
+    ]);
     return returnValue;
 }
 //# sourceMappingURL=text-buffer.js.map