pi-vim 0.1.9 → 0.2.1

package/index.ts

@@ -13,11 +13,12 @@
  * - hjkl: navigation in normal mode
  * - 0/$: line start/end
  * - ^: first non-whitespace char of line
+ * - _: first non-whitespace (with count: down count-1 lines first); linewise with d/c/y
  * - x: delete char under cursor
  * - D: delete to end of line
  * - S: substitute line (delete line content + insert mode)
  * - s: substitute char (delete char + insert mode)
- * - d{motion}: delete with motion (`w/b/e` + `W/B/E`, `$`, `0`, `^`, `dd`, `f/t/F/T{char}`)
+ * - d{motion}: delete with motion (`w/b/e` + `W/B/E`, `$`, `0`, `^`, `dd`/`d_`, `f/t/F/T{char}`)
  * - c{motion}: change with same motion set as `d` (then enter insert mode)
  * - y{motion}: yank with same motion set as `d` (no text mutation)
  * - f{char}: jump to next {char} on line
@@ -72,11 +73,11 @@ import {
   CHAR_MOTION_KEYS,
   ESC_LEFT,
   ESC_RIGHT,
-  ESC_DELETE,
   ESC_UP,
   CTRL_A,
   CTRL_E,
   CTRL_K,
+  CTRL_R,
   CTRL_UNDERSCORE,
   NEWLINE,
   ESC_DOWN,
@@ -86,6 +87,7 @@ import {
   findCharMotionTarget,
   findParagraphMotionTarget,
   findFirstNonWhitespaceColumn,
+  getLineGraphemes,
   type WordMotionClass,
 } from "./motions.js";
 import {
@@ -99,6 +101,24 @@ const BRACKETED_PASTE_END = "\x1b[201~";
 const BRACKETED_PASTE_END_TAIL = BRACKETED_PASTE_END.slice(1);
 const MAX_COUNT = 9999;
 
+type EditorSnapshot = {
+  text: string;
+  cursor: { line: number; col: number };
+};
+
+type TransitionState = "none" | "undo" | "redo";
+
+type ModalEditorInternals = {
+  state?: { lines?: string[]; cursorLine?: number; cursorCol?: number };
+  preferredVisualCol?: number | null;
+  lastAction?: string | null;
+  historyIndex?: number;
+  onChange?: (text: string) => void;
+  tui?: { requestRender?: () => void };
+  pushUndoSnapshot?: () => void;
+  setCursorCol?: (col: number) => void;
+};
+
 export class ModalEditor extends CustomEditor {
   private mode: Mode = "insert";
   private pendingMotion: PendingMotion = null;
@@ -108,10 +128,14 @@ export class ModalEditor extends CustomEditor {
   private operatorCount: string = "";
   private pendingG: boolean = false;
   private pendingGCount: string = "";
+  private pendingReplace: boolean = false;
   private lastCharMotion: LastCharMotion | null = null;
   private discardingBracketedPasteInNormalMode: boolean = false;
   private pendingEscWhileDiscardingBracketedPasteInNormalMode: boolean = false;
-  private readonly wordBoundaryCache = new WordBoundaryCache();
+  private wordBoundaryCache = new WordBoundaryCache();
+  private readonly redoStack: EditorSnapshot[] = [];
+  private currentTransition: TransitionState = "none";
+  private onChangeHooked: boolean = false;
 
   // Unnamed register
   private unnamedRegister: string = "";
@@ -126,6 +150,183 @@ export class ModalEditor extends CustomEditor {
   getMode(): Mode { return this.mode; }
   getText(): string { return this.getLines().join("\n"); }
 
+  override setText(text: string): void {
+    this.clearRedoStack();
+    super.setText(text);
+  }
+
+  private captureSnapshot(): EditorSnapshot {
+    const cursor = this.getCursor();
+    return {
+      text: this.getText(),
+      cursor: { line: cursor.line, col: cursor.col },
+    };
+  }
+
+  private requireRedoRestoreState(
+    editor: ModalEditorInternals,
+  ): { lines: string[]; cursorLine?: number; cursorCol?: number } {
+    const state = editor.state;
+    if (!state || !Array.isArray(state.lines)) {
+      throw new Error("Redo restore prerequisite: editor state unavailable");
+    }
+    return state;
+  }
+
+  private restoreSnapshot(snapshot: EditorSnapshot): void {
+    const editor = this as unknown as ModalEditorInternals;
+    const state = this.requireRedoRestoreState(editor);
+
+    const lines = snapshot.text.split("\n");
+    state.lines = lines.length > 0 ? lines : [""];
+
+    const maxLine = Math.max(0, state.lines.length - 1);
+    const cursorLine = Math.max(0, Math.min(snapshot.cursor.line, maxLine));
+    const line = state.lines[cursorLine] ?? "";
+    const cursorCol = Math.max(0, Math.min(snapshot.cursor.col, line.length));
+
+    state.cursorLine = cursorLine;
+    if (typeof editor.setCursorCol === "function") {
+      editor.setCursorCol(cursorCol);
+    } else {
+      state.cursorCol = cursorCol;
+      editor.preferredVisualCol = null;
+    }
+
+    this.invalidateWordBoundaryCache();
+
+    editor.historyIndex = -1;
+    editor.lastAction = null;
+    editor.onChange?.(this.getText());
+    editor.tui?.requestRender?.();
+  }
+
+  private snapshotChanged(a: EditorSnapshot, b: EditorSnapshot): boolean {
+    return a.text !== b.text
+      || a.cursor.line !== b.cursor.line
+      || a.cursor.col !== b.cursor.col;
+  }
+
+  private withTransition<T>(
+    transition: Exclude<TransitionState, "none">,
+    action: () => T,
+  ): T {
+    const previousTransition = this.currentTransition;
+    this.currentTransition = transition;
+    try {
+      return action();
+    } finally {
+      this.currentTransition = previousTransition;
+    }
+  }
+
+  private performUndo(): void {
+    this.withTransition("undo", () => {
+      const beforeUndo = this.captureSnapshot();
+      super.handleInput(CTRL_UNDERSCORE);
+      const afterUndo = this.captureSnapshot();
+
+      if (this.snapshotChanged(beforeUndo, afterUndo)) {
+        this.redoStack.push(beforeUndo);
+      }
+    });
+  }
+
+  private performRedo(count: number = this.takeTotalCount(1)): void {
+    const maxSteps = Math.max(1, Math.min(MAX_COUNT, count));
+    const editor = this as unknown as ModalEditorInternals;
+
+    for (let i = 0; i < maxSteps; i++) {
+      const snapshot = this.redoStack[this.redoStack.length - 1];
+      if (!snapshot) break;
+
+      this.withTransition("redo", () => {
+        this.requireRedoRestoreState(editor);
+        if (typeof editor.pushUndoSnapshot !== "function") {
+          throw new Error(
+            "Redo restore prerequisite: pushUndoSnapshot unavailable",
+          );
+        }
+        editor.pushUndoSnapshot();
+        this.restoreSnapshot(snapshot);
+        this.redoStack.pop();
+      });
+    }
+  }
+
+  private clearRedoStack(): void {
+    this.redoStack.length = 0;
+  }
+
+  private invalidateWordBoundaryCache(): void {
+    this.wordBoundaryCache = new WordBoundaryCache();
+  }
+
+  private ensureOnChangeHook(): void {
+    if (this.onChangeHooked) return;
+
+    const editor = this as unknown as ModalEditorInternals;
+    const originalOnChange = editor.onChange;
+
+    editor.onChange = (text: string) => {
+      originalOnChange?.(text);
+      this.centralInvalidationCheck();
+    };
+
+    this.onChangeHooked = true;
+  }
+
+  private centralInvalidationCheck(): void {
+    if (this.redoStack.length === 0) return;
+    if (this.currentTransition !== "none") return;
+    this.clearRedoStack();
+  }
+
+  private applySyntheticEdit(mutation: () => void): void {
+    const editor = this as unknown as ModalEditorInternals;
+    if (!editor.state || !Array.isArray(editor.state.lines)) {
+      throw new Error(
+        "Synthetic edit prerequisite: editor state unavailable",
+      );
+    }
+
+    if (typeof editor.pushUndoSnapshot !== "function") {
+      throw new Error(
+        "Synthetic edit prerequisite: pushUndoSnapshot unavailable",
+      );
+    }
+
+    const textBefore = this.getText();
+    const preCursorLine = editor.state.cursorLine;
+    const preCursorCol = editor.state.cursorCol;
+
+    mutation();
+
+    if (this.getText() === textBefore) return;
+
+    // Text changed — push undo boundary for pre-mutation state.
+    // Briefly swap pre-mutation state in for the snapshot, then
+    // restore the post-mutation result.
+    const postLines = editor.state.lines.slice();
+    const postCursorLine = editor.state.cursorLine;
+    const postCursorCol = editor.state.cursorCol;
+    const postPreferredCol = editor.preferredVisualCol;
+
+    const preLines = textBefore.split("\n");
+    editor.state.lines = preLines.length > 0 ? preLines : [""];
+    editor.state.cursorLine = preCursorLine;
+    editor.state.cursorCol = preCursorCol;
+    editor.pushUndoSnapshot();
+
+    editor.state.lines = postLines;
+    editor.state.cursorLine = postCursorLine;
+    editor.state.cursorCol = postCursorCol;
+    editor.preferredVisualCol = postPreferredCol;
+
+    editor.onChange?.(this.getText());
+    editor.tui?.requestRender?.();
+  }
+
   private clearPendingState(): void {
     this.pendingMotion = null;
     this.pendingTextObject = null;
@@ -134,6 +335,7 @@ export class ModalEditor extends CustomEditor {
     this.operatorCount = "";
     this.pendingG = false;
     this.pendingGCount = "";
+    this.pendingReplace = false;
   }
 
   private isEscapeLikeInput(data: string): boolean {
@@ -176,6 +378,8 @@ export class ModalEditor extends CustomEditor {
   }
 
   handleInput(data: string): void {
+    this.ensureOnChangeHook();
+
     if (this.mode !== "insert") {
       if (this.discardingBracketedPasteInNormalMode) {
         if (this.isEscapeLikeInput(data)) {
@@ -227,19 +431,43 @@ export class ModalEditor extends CustomEditor {
       }
       // Alt+o: open new line below (stay in insert mode)
       if (matchesKey(data, Key.alt("o")) || data === "\x1bo") {
-        super.handleInput(CTRL_E);
-        super.handleInput(NEWLINE);
+        this.openLineBelow();
         return;
       }
       // Alt+Shift+o: open new line above (stay in insert mode)
       // \x1bO is the legacy sequence for Alt+Shift+O (VT100 SS3 prefix in non-Kitty terminals)
       if (matchesKey(data, Key.shiftAlt("o")) || data === "\x1bO") {
-        super.handleInput(CTRL_A);
-        super.handleInput(NEWLINE);
-        super.handleInput(ESC_UP);
+        this.openLineAbove();
+        return;
+      }
+      super.handleInput(data);
+      return;
+    }
+
+    if (this.pendingReplace) {
+      this.pendingReplace = false;
+      if (!this.isPrintableInput(data)) {
+        this.prefixCount = "";
+        this.operatorCount = "";
         return;
       }
-      return super.handleInput(data);
+
+      const count = this.takeTotalCount(1);
+      const cursor = this.getCursor();
+      const line = this.getLines()[cursor.line] ?? "";
+      const range = this.getGraphemeRangeAtCol(line, cursor.col, count);
+      if (!range) return;
+
+      const before = line.slice(0, range.start);
+      const after = line.slice(range.end);
+      const replacement = data.repeat(count);
+      const lineStartAbs = this.getAbsoluteIndex(cursor.line, 0);
+      const text = this.getText();
+      const newText = text.slice(0, lineStartAbs) + before + replacement + after
+        + text.slice(lineStartAbs + line.length);
+      const newCursorAbs = lineStartAbs + before.length + data.length * (count - 1);
+      this.replaceTextInBuffer(newText, newCursorAbs);
+      return;
     }
 
     if (this.pendingTextObject) {
@@ -292,6 +520,7 @@ export class ModalEditor extends CustomEditor {
       || this.operatorCount
       || this.pendingG
       || this.pendingGCount
+      || this.pendingReplace
     ) {
       this.clearPendingState();
       return;
@@ -314,7 +543,7 @@ export class ModalEditor extends CustomEditor {
   }
 
   private isPrintableInput(data: string): boolean {
-    return this.isPrintableChunk(data) && Array.from(data).length === 1;
+    return this.isPrintableChunk(data) && getLineGraphemes(data).length === 1;
   }
 
   private isDigit(data: string): boolean {
@@ -464,6 +693,13 @@ export class ModalEditor extends CustomEditor {
       return;
     }
 
+    if (data === "_") {
+      const count = this.takeTotalCount(1);
+      this.deleteLinewiseByDelta(count - 1);
+      this.pendingOperator = null;
+      return;
+    }
+
     if (CHAR_MOTION_KEYS.has(data)) {
       this.pendingMotion = data as PendingMotion;
       return;
@@ -526,6 +762,28 @@ export class ModalEditor extends CustomEditor {
       this.mode = "insert";
       return;
     }
+
+    if (data === "_") {
+      const count = this.takeTotalCount(1);
+      if (count <= 1) {
+        this.cutLine();
+      } else {
+        const currentLine = this.getCursor().line;
+        const lines = this.getLines();
+        const clampedEnd = Math.min(currentLine + count - 1, lines.length - 1);
+        this.writeToRegister(this.getLinewisePayload(currentLine, clampedEnd));
+        const before = lines.slice(0, currentLine);
+        const after = lines.slice(clampedEnd + 1);
+        const newLines = [...before, "", ...after];
+        const newText = newLines.join("\n");
+        const cursorAbs = before.reduce((acc, l) => acc + l.length + 1, 0);
+        this.replaceTextInBuffer(newText, cursorAbs);
+      }
+      this.pendingOperator = null;
+      this.mode = "insert";
+      return;
+    }
+
     if (CHAR_MOTION_KEYS.has(data)) {
       this.pendingMotion = data as PendingMotion;
       return;
@@ -624,6 +882,7 @@ export class ModalEditor extends CustomEditor {
 
       const supportsCountedStandaloneEdit = (
         data === "x"
+        || data === "r"
         || data === "s"
         || data === "S"
         || data === "D"
@@ -631,6 +890,8 @@ export class ModalEditor extends CustomEditor {
         || data === "p"
         || data === "P"
         || data === "J"
+        || data === CTRL_R
+        || matchesKey(data, "ctrl+r")
       );
       const supportsCountedCharMotion = (
         CHAR_MOTION_KEYS.has(data)
@@ -652,6 +913,7 @@ export class ModalEditor extends CustomEditor {
         || data === "k"
         || data === "l"
       );
+      const supportsCountedUnderscore = data === "_";
 
       if (supportsCountedNav) {
         const count = this.takeTotalCount(1);
@@ -661,16 +923,8 @@ export class ModalEditor extends CustomEditor {
         } else if (data === "l") {
           this.moveCursorBy(clamped);
         } else {
-          // j/k: clamp vertical nav to buffer size to prevent TUI stalls
-          const lines = this.getLines();
-          const cursorLine = this.getCursor().line;
-          const safeCount = data === "j"
-            ? Math.min(clamped, lines.length - 1 - cursorLine)
-            : Math.min(clamped, cursorLine);
-          const seq = data === "j" ? ESC_DOWN : ESC_UP;
-          for (let i = 0; i < safeCount; i++) {
-            super.handleInput(seq);
-          }
+          const delta = data === "j" ? clamped : -clamped;
+          this.moveCursorVertically(delta);
         }
         return;
       }
@@ -685,6 +939,7 @@ export class ModalEditor extends CustomEditor {
         && !supportsCountedCharMotion
         && !supportsCountedWordMotion
         && !supportsCountedParagraphMotion
+        && !supportsCountedUnderscore
       ) {
         // Unsupported prefixed forms: drop count and keep processing this key.
         this.prefixCount = "";
@@ -711,6 +966,11 @@ export class ModalEditor extends CustomEditor {
       return;
     }
 
+    if (data === "r") {
+      this.pendingReplace = true;
+      return;
+    }
+
     if (data === "d") {
       this.pendingOperator = "d";
       return;
@@ -754,8 +1014,13 @@ export class ModalEditor extends CustomEditor {
       return;
     }
 
-    if (data === "u") {
-      super.handleInput(CTRL_UNDERSCORE); // ctrl+_ — readline undo
+    if (data === "u" || data === CTRL_UNDERSCORE || matchesKey(data, "ctrl+_")) {
+      this.performUndo();
+      return;
+    }
+
+    if (data === CTRL_R || matchesKey(data, "ctrl+r")) {
+      this.performRedo();
       return;
     }
 
@@ -769,6 +1034,15 @@ export class ModalEditor extends CustomEditor {
       return;
     }
 
+    if (data === "_") {
+      const count = this.takeTotalCount(1);
+      if (count > 1) {
+        this.moveCursorVertically(count - 1);
+      }
+      this.moveCursorToFirstNonWhitespace();
+      return;
+    }
+
     if (data === "w") {
       const count = this.takeTotalCount(1);
       return this.moveWord("forward", "start", count, "word");
@@ -788,6 +1062,17 @@ export class ModalEditor extends CustomEditor {
     super.handleInput(data);
   }
 
+  private openLineBelow(): void {
+    super.handleInput(CTRL_E);
+    super.handleInput(NEWLINE);
+  }
+
+  private openLineAbove(): void {
+    super.handleInput(CTRL_A);
+    super.handleInput(NEWLINE);
+    super.handleInput(ESC_UP);
+  }
+
   private handleMappedKey(key: string): void {
     const seq = NORMAL_KEYS[key];
     switch (key) {
@@ -809,14 +1094,11 @@ export class ModalEditor extends CustomEditor {
         super.handleInput(CTRL_A);
         break;
       case "o":
-        super.handleInput(CTRL_E);
-        super.handleInput(NEWLINE);
+        this.openLineBelow();
         this.mode = "insert";
         break;
       case "O":
-        super.handleInput(CTRL_A);
-        super.handleInput(NEWLINE);
-        super.handleInput(ESC_UP);
+        this.openLineAbove();
         this.mode = "insert";
         break;
       case "D":
@@ -840,6 +1122,12 @@ export class ModalEditor extends CustomEditor {
       case "x":
         this.cutCharUnderCursor();
         break;
+      case "j":
+        this.moveCursorVertically(1);
+        break;
+      case "k":
+        this.moveCursorVertically(-1);
+        break;
       default:
         if (seq) super.handleInput(seq);
     }
@@ -856,7 +1144,7 @@ export class ModalEditor extends CustomEditor {
     }
 
     if (targetCol !== null && targetCol !== col) {
-      this.moveCursorBy(targetCol - col);
+      this.moveCursorToCol(targetCol);
     }
   }
 
@@ -884,10 +1172,12 @@ export class ModalEditor extends CustomEditor {
     const cursorLine = state.cursorLine as number;
     const cursorCol = state.cursorCol as number;
     const line = state.lines[cursorLine] ?? "";
+    if (this.hasMultiCodeUnitGraphemes(line)) return false;
+
     const target = cursorCol + delta;
 
-    // Only short-circuit line-local movement; preserve canonical key replay for
-    // any potential cross-line traversal semantics.
+    // Only short-circuit line-local movement when each grapheme is one code
+    // unit; otherwise let the base editor keep cursor boundaries valid.
     if (target < 0 || target > line.length) return false;
 
     state.cursorCol = target;
@@ -907,38 +1197,100 @@ export class ModalEditor extends CustomEditor {
     }
   }
 
-  private moveCursorToLineStart(lineIndex: number): void {
-    const lines = this.getLines();
-    if (lines.length === 0) {
-      super.handleInput(CTRL_A);
-      return;
-    }
+  private moveCursorVertically(delta: number): void {
+    if (delta === 0) return;
 
-    const targetLine = Math.max(0, Math.min(lineIndex, lines.length - 1));
-    const currentLine = this.getCursor().line;
-    const delta = targetLine - currentLine;
+    const editor = this as unknown as {
+      state?: { lines?: string[]; cursorLine?: number; cursorCol?: number };
+      preferredVisualCol?: number | null;
+      lastAction?: string | null;
+      tui?: { requestRender?: () => void };
+    };
 
-    if (delta > 0) {
-      for (let i = 0; i < delta; i++) {
-        super.handleInput(ESC_DOWN);
-      }
-    } else if (delta < 0) {
+    const state = editor.state;
+    if (!state || !Array.isArray(state.lines) || state.lines.length === 0) {
+      const seq = delta > 0 ? ESC_DOWN : ESC_UP;
       for (let i = 0; i < Math.abs(delta); i++) {
-        super.handleInput(ESC_UP);
+        super.handleInput(seq);
       }
+      return;
     }
 
-    super.handleInput(CTRL_A);
+    const currentLine = state.cursorLine ?? 0;
+    const targetLine = Math.max(0, Math.min(currentLine + delta, state.lines.length - 1));
+    if (targetLine === currentLine) return;
+
+    const preferredCol = editor.preferredVisualCol ?? state.cursorCol ?? 0;
+    const targetLineText = state.lines[targetLine] ?? "";
+    editor.lastAction = null;
+    state.cursorLine = targetLine;
+    state.cursorCol = Math.min(preferredCol, targetLineText.length);
+    editor.preferredVisualCol = preferredCol;
+    editor.tui?.requestRender?.();
+  }
+
+  private moveCursorToCol(col: number): void {
+    const editor = this as unknown as {
+      state?: { lines?: string[]; cursorLine?: number; cursorCol?: number };
+      preferredVisualCol?: number | null;
+      lastAction?: string | null;
+      tui?: { requestRender?: () => void };
+    };
+
+    const state = editor.state;
+    if (!state || !Array.isArray(state.lines)) return;
+
+    editor.lastAction = null;
+    state.cursorCol = col;
+    editor.preferredVisualCol = col;
+    editor.tui?.requestRender?.();
+  }
+
+  private moveCursorToAbsoluteIndex(abs: number): void {
+    const editor = this as unknown as {
+      state?: { lines?: string[]; cursorLine?: number; cursorCol?: number };
+      preferredVisualCol?: number | null;
+      lastAction?: string | null;
+      tui?: { requestRender?: () => void };
+    };
+
+    const state = editor.state;
+    if (!state || !Array.isArray(state.lines)) return;
+
+    const { line, col } = this.getCursorFromAbsoluteIndex(this.getText(), abs);
+    editor.lastAction = null;
+    state.cursorLine = line;
+    state.cursorCol = col;
+    editor.preferredVisualCol = col;
+    editor.tui?.requestRender?.();
+  }
+
+  private moveCursorToLineStart(lineIndex: number): void {
+    const editor = this as unknown as {
+      state?: { lines?: string[]; cursorLine?: number; cursorCol?: number };
+      preferredVisualCol?: number | null;
+      lastAction?: string | null;
+      tui?: { requestRender?: () => void };
+    };
+
+    const state = editor.state;
+    if (!state || !Array.isArray(state.lines) || state.lines.length === 0) {
+      super.handleInput(CTRL_A);
+      return;
+    }
+
+    const targetLine = Math.max(0, Math.min(lineIndex, state.lines.length - 1));
+    editor.lastAction = null;
+    state.cursorLine = targetLine;
+    state.cursorCol = 0;
+    editor.preferredVisualCol = null;
+    editor.tui?.requestRender?.();
   }
 
   private moveCursorToFirstNonWhitespace(): void {
     const { line, col } = this.getCurrentLineAndCol();
     const targetCol = findFirstNonWhitespaceColumn(line);
-    this.moveCursorBy(targetCol - col);
-  }
-
-  private moveCursorToBufferStart(): void {
-    this.moveCursorToLineStart(0);
+    this.moveCursorToCol(targetCol);
   }
 
   private moveCursorToBufferEnd(): void {
@@ -951,43 +1303,39 @@ export class ModalEditor extends CustomEditor {
     const steps = Math.max(0, count - 1);
     if (steps === 0) return;
 
-    const editor = this as unknown as {
-      state?: { lines?: string[]; cursorLine?: number; cursorCol?: number };
-      preferredVisualCol?: number;
-      tui?: { requestRender?: () => void };
-    };
+    this.applySyntheticEdit(() => {
+      const editor = this as unknown as ModalEditorInternals;
+      const state = editor.state;
+      if (!state || !Array.isArray(state.lines)) return;
 
-    const state = editor.state;
-    if (!state || !Array.isArray(state.lines)) return;
+      const currentLine = state.cursorLine ?? 0;
+      let joinPoint = state.cursorCol ?? 0;
 
-    const currentLine = state.cursorLine ?? 0;
-    let joinPoint = state.cursorCol ?? 0;
+      for (let i = 0; i < steps; i++) {
+        if (currentLine >= state.lines.length - 1) break;
 
-    for (let i = 0; i < steps; i++) {
-      if (currentLine >= state.lines.length - 1) break;
+        const left = state.lines[currentLine]!;
+        const right = state.lines[currentLine + 1]!;
+        let joined: string;
 
-      const left = state.lines[currentLine]!;
-      const right = state.lines[currentLine + 1]!;
-      let joined: string;
+        if (normalize) {
+          const trimmedRight = right.trimStart();
+          const leftEndsWithSpace = left.length > 0 && /\s/.test(left[left.length - 1]!);
+          const needsSeparator = !leftEndsWithSpace && trimmedRight.length > 0;
+          joined = needsSeparator ? `${left} ${trimmedRight}` : left + trimmedRight;
+          joinPoint = left.length;
+        } else {
+          joined = left + right;
+          joinPoint = left.length;
+        }
 
-      if (normalize) {
-        const trimmedRight = right.trimStart();
-        const leftEndsWithSpace = left.length > 0 && /\s/.test(left[left.length - 1]!);
-        const needsSeparator = !leftEndsWithSpace && trimmedRight.length > 0;
-        joined = needsSeparator ? `${left} ${trimmedRight}` : left + trimmedRight;
-        joinPoint = left.length;
-      } else {
-        joined = left + right;
-        joinPoint = left.length;
+        state.lines.splice(currentLine, 2, joined);
       }
 
-      state.lines.splice(currentLine, 2, joined);
-    }
-
-    state.cursorLine = currentLine;
-    state.cursorCol = joinPoint;
-    editor.preferredVisualCol = joinPoint;
-    editor.tui?.requestRender?.();
+      state.cursorLine = currentLine;
+      state.cursorCol = joinPoint;
+      editor.preferredVisualCol = joinPoint;
+    });
   }
 
   private isWordChar(ch: string): boolean {
@@ -1133,7 +1481,6 @@ export class ModalEditor extends CustomEditor {
   private tryFindWordTargetLineLocal(
     direction: WordMotionDirection,
     target: WordMotionTarget,
-    allowSameColumn: boolean = false,
     semanticClass: WordMotionClass = "word",
   ): number | null {
     const cursor = this.getCursor();
@@ -1146,7 +1493,7 @@ export class ModalEditor extends CustomEditor {
       col,
       direction,
       target,
-      allowSameColumn,
+      false,
       semanticClass,
     );
     if (targetCol === null) return null;
@@ -1164,10 +1511,10 @@ export class ModalEditor extends CustomEditor {
     semanticClass: WordMotionClass = "word",
   ): boolean {
     const col = this.getCursor().col;
-    const targetCol = this.tryFindWordTargetLineLocal(direction, target, false, semanticClass);
+    const targetCol = this.tryFindWordTargetLineLocal(direction, target, semanticClass);
     if (targetCol === null || targetCol === col) return false;
 
-    this.moveCursorBy(targetCol - col);
+    this.moveCursorToCol(targetCol);
     return true;
   }
 
@@ -1235,7 +1582,7 @@ export class ModalEditor extends CustomEditor {
         semanticClass,
       );
       if (targetAbs !== currentAbs) {
-        this.moveCursorBy(targetAbs - currentAbs);
+        this.moveCursorToAbsoluteIndex(targetAbs);
       }
       return;
     }
@@ -1253,6 +1600,33 @@ export class ModalEditor extends CustomEditor {
     return { line, col };
   }
 
+  private hasMultiCodeUnitGraphemes(line: string): boolean {
+    return getLineGraphemes(line).some((segment) => segment.end - segment.start > 1);
+  }
+
+  private getGraphemeRangeAtCol(
+    line: string,
+    col: number,
+    count: number,
+    clampToLine: boolean = false,
+  ): { start: number; end: number } | null {
+    const clampedCol = Math.max(0, Math.min(col, line.length));
+    const segments = getLineGraphemes(line);
+    const startIndex = segments.findIndex((segment) => clampedCol < segment.end);
+    if (startIndex === -1) return null;
+
+    let endIndex = startIndex + Math.max(1, count) - 1;
+    if (endIndex >= segments.length) {
+      if (!clampToLine) return null;
+      endIndex = segments.length - 1;
+    }
+
+    return {
+      start: segments[startIndex]!.start,
+      end: segments[endIndex]!.end,
+    };
+  }
+
   private isCursorOnNonWhitespace(): boolean {
     const { line, col } = this.getCurrentLineAndCol();
     const ch = line[col];
@@ -1265,13 +1639,19 @@ export class ModalEditor extends CustomEditor {
   }
 
   private cutCharUnderCursor(): void {
-    const count = this.takeTotalCount(1);
-    const { line, col } = this.getCurrentLineAndCol();
-    if (line.length === 0) return; // Don't merge empty lines with x
-    if (col >= line.length) return; // Don't delete past end of line
+    const count = Math.max(1, Math.min(MAX_COUNT, this.takeTotalCount(1)));
+    const cursor = this.getCursor();
+    const line = this.getLines()[cursor.line] ?? "";
+    const range = this.getGraphemeRangeAtCol(line, cursor.col, count, true);
+    if (!range) return;
 
-    const boundedCount = Math.max(1, Math.min(MAX_COUNT, count));
-    this.deleteRange(col, col + boundedCount, false);
+    const lineStartAbs = this.getAbsoluteIndex(cursor.line, 0);
+    const text = this.getText();
+    this.writeToRegister(line.slice(range.start, range.end));
+    this.replaceTextInBuffer(
+      text.slice(0, lineStartAbs + range.start) + text.slice(lineStartAbs + range.end),
+      lineStartAbs + range.start,
+    );
   }
 
   private cutToEndOfLine(): void {
@@ -1352,19 +1732,13 @@ export class ModalEditor extends CustomEditor {
     this.writeToRegister(payload);
 
     if (endAbs > startAbs) {
-      const cursor = this.getCursor();
-      const cursorAbs = this.getAbsoluteIndex(cursor.line, cursor.col);
-      if (cursorAbs !== startAbs) {
-        this.moveCursorBy(startAbs - cursorAbs);
-      }
+      const text = this.getText();
+      const newText = text.slice(0, startAbs) + text.slice(endAbs);
+      this.replaceTextInBuffer(newText, startAbs);
 
-      const count = endAbs - startAbs;
-      for (let i = 0; i < count; i++) {
-        super.handleInput(ESC_DELETE);
-      }
+      // Ensure cursor is at column 0 of the landing line
+      super.handleInput(CTRL_A);
     }
-
-    super.handleInput(CTRL_A);
   }
 
   private yankLineRange(startLine: number, endLine: number): void {
@@ -1427,7 +1801,7 @@ export class ModalEditor extends CustomEditor {
       }
 
       const text = this.getText();
-      const currentAbs = this.getAbsoluteIndex(cursor.line, col);
+      const currentAbs = this.getAbsoluteIndexFromCursor();
       const targetAbs = this.findWordTargetInText(
         text,
         currentAbs,
@@ -1495,6 +1869,13 @@ export class ModalEditor extends CustomEditor {
       return;
     }
 
+    if (data === "_") {
+      const count = this.takeTotalCount(1);
+      this.yankLinewiseByDelta(count - 1);
+      this.pendingOperator = null;
+      return;
+    }
+
     if (CHAR_MOTION_KEYS.has(data)) {
       this.pendingMotion = data as PendingMotion;
       return;
@@ -1555,7 +1936,7 @@ export class ModalEditor extends CustomEditor {
       }
 
       const text = this.getText();
-      const currentAbs = this.getAbsoluteIndex(cursor.line, col);
+      const currentAbs = this.getAbsoluteIndexFromCursor();
       const targetAbs = this.findWordTargetInText(
         text,
         currentAbs,
@@ -1587,7 +1968,12 @@ export class ModalEditor extends CustomEditor {
     const line = this.getLines()[this.getCursor().line] ?? "";
     const start = Math.min(col, targetCol);
     const rawEnd = Math.max(col, targetCol) + (inclusive ? 1 : 0);
-    const end = Math.min(rawEnd, line.length);
+    let end = Math.min(rawEnd, line.length);
+
+    if (inclusive) {
+      const targetRange = this.getGraphemeRangeAtCol(line, Math.max(col, targetCol), 1);
+      end = targetRange?.end ?? end;
+    }
 
     if (end <= start) return;
 
@@ -1604,6 +1990,47 @@ export class ModalEditor extends CustomEditor {
     this.writeToRegister(text.slice(start, end));
   }
 
+  private getCursorFromAbsoluteIndex(text: string, abs: number): { line: number; col: number } {
+    const lines = text.length === 0 ? [""] : text.split("\n");
+    let remaining = Math.max(0, Math.min(abs, text.length));
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+      const line = lines[lineIndex] ?? "";
+      if (remaining <= line.length) return { line: lineIndex, col: remaining };
+      remaining -= line.length + 1;
+    }
+    const lastLine = Math.max(0, lines.length - 1);
+    return { line: lastLine, col: (lines[lastLine] ?? "").length };
+  }
+
+  private replaceTextInBuffer(text: string, cursorAbs: number): void {
+    const editor = this as unknown as {
+      state?: { lines?: string[]; cursorLine?: number; cursorCol?: number };
+      preferredVisualCol?: number | null;
+      historyIndex?: number;
+      lastAction?: string | null;
+      onChange?: (text: string) => void;
+      tui?: { requestRender?: () => void };
+      pushUndoSnapshot?: () => void;
+      autocompleteState?: unknown;
+      updateAutocomplete?: () => void;
+    };
+    const state = editor.state;
+    if (!state) return;
+    const currentText = this.getText();
+    if (currentText !== text) editor.pushUndoSnapshot?.();
+    const nextLines = text.length === 0 ? [""] : text.split("\n");
+    const { line, col } = this.getCursorFromAbsoluteIndex(text, cursorAbs);
+    editor.historyIndex = -1;
+    editor.lastAction = null;
+    state.lines = nextLines;
+    state.cursorLine = line;
+    state.cursorCol = col;
+    editor.preferredVisualCol = null;
+    editor.onChange?.(text);
+    if (editor.autocompleteState) editor.updateAutocomplete?.();
+    editor.tui?.requestRender?.();
+  }
+
   private deleteRangeByAbsolute(currentAbs: number, targetAbs: number, inclusive: boolean = false): void {
     const text = this.getText();
     const start = Math.min(currentAbs, targetAbs);
@@ -1614,16 +2041,7 @@ export class ModalEditor extends CustomEditor {
 
     this.writeToRegister(text.slice(start, end));
 
-    const cursor = this.getCursor();
-    const cursorAbs = this.getAbsoluteIndex(cursor.line, cursor.col);
-    if (cursorAbs !== start) {
-      this.moveCursorBy(start - cursorAbs);
-    }
-
-    const count = end - start;
-    for (let i = 0; i < count; i++) {
-      super.handleInput(ESC_DELETE);
-    }
+    this.replaceTextInBuffer(text.slice(0, start) + text.slice(end), start);
   }
 
   private getWordObjectRange(
@@ -1750,24 +2168,19 @@ export class ModalEditor extends CustomEditor {
   }
 
   private deleteRange(col: number, targetCol: number, inclusive: boolean): void {
-    const line = this.getLines()[this.getCursor().line] ?? "";
-
+    const cursor = this.getCursor();
+    const line = this.getLines()[cursor.line] ?? "";
+    const lineStartAbs = this.getAbsoluteIndex(cursor.line, 0);
     const start = Math.min(col, targetCol);
     const rawEnd = Math.max(col, targetCol) + (inclusive ? 1 : 0);
-    const end = Math.min(rawEnd, line.length);
-
-    if (end <= start) return;
+    let end = Math.min(rawEnd, line.length);
 
-    this.writeToRegister(line.slice(start, end));
-
-    if (start !== col) {
-      this.moveCursorBy(start - col);
+    if (inclusive) {
+      const targetRange = this.getGraphemeRangeAtCol(line, Math.max(col, targetCol), 1);
+      end = targetRange?.end ?? end;
     }
 
-    const count = end - start;
-    for (let i = 0; i < count; i++) {
-      super.handleInput(ESC_DELETE);
-    }
+    this.deleteRangeByAbsolute(lineStartAbs + start, lineStartAbs + end);
   }
 
   render(width: number): string[] {
@@ -1788,6 +2201,9 @@ export class ModalEditor extends CustomEditor {
     const prefixCount = this.prefixCount;
     const operatorCount = this.operatorCount;
 
+    if (this.pendingReplace) {
+      return prefixCount ? ` NORMAL ${prefixCount}r_ ` : " NORMAL r_ ";
+    }
     if (this.pendingOperator && this.pendingMotion) {
       return ` NORMAL ${prefixCount}${this.pendingOperator}${operatorCount}${this.pendingMotion}_ `;
     }