pi-vim 0.1.3 → 0.1.7

package/index.ts

@@ -16,16 +16,21 @@
  * - 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 (dw, db, de, d$, d0, dd, df/dt/dF/dT{char})
+ * - d{motion}: delete with motion (`w/b/e` + `W/B/E`, `$`, `0`, `dd`, `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
  * - F{char}: jump to previous {char} on line
  * - t{char}: jump to just before next {char} on line
  * - T{char}: jump to just after previous {char} on line
  * - ;: repeat last f/F/t/T motion (same direction)
  * - ,: repeat last f/F/t/T motion (reverse direction)
- * - w: move to start of next word
- * - b: move to start of previous word
- * - e: move to end of word
+ * - w/b/e: `word` motions (keyword/punctuation aware)
+ * - W/B/E: `WORD` motions (whitespace-delimited non-space runs)
+ * - {/}: paragraph motions to previous/next paragraph start (line start col 0)
+ * - `{count}` prefixes supported for navigation, paragraph motions, and `d/c` word/WORD motions
+ * - operator forms with braces (`d{`, `d}`, `c{`, `c}`, `y{`, `y}`) are out of scope
+ * - counted yank caveat: `y2w`, `2yw`, `y2W`, `2yW` cancel (linewise counts still supported)
  * - Shift+Alt+A: go to end of line (insert mode shortcut)
  * - Shift+Alt+I: go to start of line (insert mode shortcut)
  * - Alt+o: open new line below (insert mode shortcut)
@@ -78,6 +83,8 @@ import {
 import {
   reverseCharMotion,
   findCharMotionTarget,
+  findParagraphMotionTarget,
+  type WordMotionClass,
 } from "./motions.js";
 import {
   WordBoundaryCache,
@@ -88,15 +95,17 @@ import {
 const BRACKETED_PASTE_START = "\x1b[200~";
 const BRACKETED_PASTE_END = "\x1b[201~";
 const BRACKETED_PASTE_END_TAIL = BRACKETED_PASTE_END.slice(1);
+const MAX_COUNT = 9999;
 
 export class ModalEditor extends CustomEditor {
   private mode: Mode = "insert";
   private pendingMotion: PendingMotion = null;
   private pendingTextObject: "i" | "a" | null = null;
   private pendingOperator: PendingOperator = null;
-  private pendingCount: string = "";
-  private pendingCountKind: "prefix" | "operator" | null = null;
+  private prefixCount: string = "";
+  private operatorCount: string = "";
   private pendingG: boolean = false;
+  private pendingGCount: string = "";
   private lastCharMotion: LastCharMotion | null = null;
   private discardingBracketedPasteInNormalMode: boolean = false;
   private pendingEscWhileDiscardingBracketedPasteInNormalMode: boolean = false;
@@ -119,9 +128,10 @@ export class ModalEditor extends CustomEditor {
     this.pendingMotion = null;
     this.pendingTextObject = null;
     this.pendingOperator = null;
-    this.pendingCount = "";
-    this.pendingCountKind = null;
+    this.prefixCount = "";
+    this.operatorCount = "";
     this.pendingG = false;
+    this.pendingGCount = "";
   }
 
   private stripBracketedPasteInNormalMode(data: string): { filtered: string | null; stripped: boolean } {
@@ -272,8 +282,10 @@ export class ModalEditor extends CustomEditor {
       this.pendingMotion
       || this.pendingTextObject
       || this.pendingOperator
-      || this.pendingCount
+      || this.prefixCount
+      || this.operatorCount
       || this.pendingG
+      || this.pendingGCount
     ) {
       this.clearPendingState();
       return;
@@ -307,21 +319,38 @@ export class ModalEditor extends CustomEditor {
     return data.length === 1 && data >= "1" && data <= "9";
   }
 
-  private takePendingCount(defaultValue: number = 1): number {
-    if (!this.pendingCount) return defaultValue;
+  private takeTotalCount(defaultValue: number = 1): number {
+    const prefixRaw = this.prefixCount;
+    const operatorRaw = this.operatorCount;
+    this.prefixCount = "";
+    this.operatorCount = "";
 
-    const parsed = Number.parseInt(this.pendingCount, 10);
-    this.pendingCount = "";
-    this.pendingCountKind = null;
+    if (!prefixRaw && !operatorRaw) return defaultValue;
 
-    if (!Number.isFinite(parsed) || parsed <= 0) return defaultValue;
-    return parsed;
+    const parse = (raw: string): number | null => {
+      if (!raw) return null;
+      const parsed = Number.parseInt(raw, 10);
+      if (!Number.isFinite(parsed) || parsed <= 0) return null;
+      return parsed;
+    };
+
+    const prefix = parse(prefixRaw);
+    const operator = parse(operatorRaw);
+
+    if (prefix === null && operator === null) return defaultValue;
+
+    const total = prefix !== null && operator !== null
+      ? prefix * operator
+      : prefix ?? operator ?? defaultValue;
+
+    if (!Number.isFinite(total) || total <= 0) return defaultValue;
+    return Math.min(MAX_COUNT, total);
   }
 
   private cancelPendingOperator(data: string): void {
     this.pendingOperator = null;
-    this.pendingCount = "";
-    this.pendingCountKind = null;
+    this.prefixCount = "";
+    this.operatorCount = "";
     if (!this.isPrintableChunk(data)) {
       super.handleInput(data);
     }
@@ -358,7 +387,8 @@ export class ModalEditor extends CustomEditor {
       return;
     }
 
-    const range = this.getWordObjectRange(this.pendingTextObject!);
+    const count = this.takeTotalCount(1);
+    const range = this.getWordObjectRange(this.pendingTextObject!, count);
     this.pendingTextObject = null;
     if (!range || !this.pendingOperator) {
       this.pendingOperator = null;
@@ -390,43 +420,35 @@ export class ModalEditor extends CustomEditor {
 
   private handlePendingDelete(data: string): void {
     if (this.isDigit(data)) {
-      if (this.pendingCount.length === 0) {
+      if (this.operatorCount.length === 0) {
         if (data !== "0") {
-          this.pendingCount = data;
-          this.pendingCountKind = "operator";
+          this.operatorCount = data;
           return;
         }
-      } else if (this.pendingCountKind === "operator") {
-        this.pendingCount += data;
-        return;
       } else {
-        // Dual counts like 2d3j are out of scope; fail closed.
-        this.cancelPendingOperator(data);
+        this.operatorCount += data;
         return;
       }
     }
 
     if (data === "d") {
-      const count = this.takePendingCount(1);
+      const count = this.takeTotalCount(1);
       this.deleteLinewiseByDelta(count - 1);
       this.pendingOperator = null;
       return;
     }
 
     if (data === "j" || data === "k") {
-      if (this.pendingCountKind === "prefix") {
-        this.cancelPendingOperator(data);
-        return;
-      }
-
-      const count = this.takePendingCount(1);
-      this.deleteLinewiseByDelta(data === "j" ? count : -count);
+      const hasDualCount = this.prefixCount.length > 0 && this.operatorCount.length > 0;
+      const count = this.takeTotalCount(1);
+      const delta = hasDualCount ? Math.max(0, count - 1) : count;
+      this.deleteLinewiseByDelta(data === "j" ? delta : -delta);
       this.pendingOperator = null;
       return;
     }
 
     if (data === "G") {
-      if (this.pendingCount.length > 0) {
+      if (this.prefixCount.length > 0 || this.operatorCount.length > 0) {
         this.cancelPendingOperator(data);
         return;
       }
@@ -436,22 +458,36 @@ export class ModalEditor extends CustomEditor {
       return;
     }
 
-    if (this.pendingCount.length > 0) {
-      // Counted forms beyond dd and d{count}j/k are intentionally out of scope.
-      this.cancelPendingOperator(data);
+    if (CHAR_MOTION_KEYS.has(data)) {
+      this.pendingMotion = data as PendingMotion;
       return;
     }
 
-    if (data === "i" || data === "a") {
-      this.pendingTextObject = data;
+    const hasCount = this.prefixCount.length > 0 || this.operatorCount.length > 0;
+    const supportsCountedWordMotion = (
+      data === "w"
+      || data === "e"
+      || data === "b"
+      || data === "W"
+      || data === "E"
+      || data === "B"
+    );
+    const supportsCountedTextObject = data === "i" || data === "a";
+
+    if (hasCount && !supportsCountedWordMotion && !supportsCountedTextObject) {
+      // Counted forms beyond dd, d{count}j/k, d{count}{f/F/t/T}, and
+      // d{count}{w/e/b/W/E/B}/{i/a}w are out of scope.
+      this.cancelPendingOperator(data);
       return;
     }
-    if (CHAR_MOTION_KEYS.has(data)) {
-      this.pendingMotion = data as PendingMotion;
+
+    if (supportsCountedTextObject) {
+      this.pendingTextObject = data;
       return;
     }
 
-    if (this.deleteWithMotion(data)) {
+    const motionCount = supportsCountedWordMotion ? this.takeTotalCount(1) : 1;
+    if (this.deleteWithMotion(data, motionCount)) {
       this.pendingOperator = null;
       return;
     }
@@ -461,21 +497,60 @@ export class ModalEditor extends CustomEditor {
   }
 
   private handlePendingChange(data: string): void {
+    if (this.isDigit(data)) {
+      if (this.operatorCount.length === 0) {
+        if (data !== "0") {
+          this.operatorCount = data;
+          return;
+        }
+      } else {
+        this.operatorCount += data;
+        return;
+      }
+    }
+
     if (data === "c") {
+      if (this.prefixCount.length > 0 || this.operatorCount.length > 0) {
+        this.cancelPendingOperator(data);
+        return;
+      }
+
       this.cutLine();
       this.pendingOperator = null;
       this.mode = "insert";
       return;
     }
-    if (data === "i" || data === "a") {
-      this.pendingTextObject = data;
-      return;
-    }
     if (CHAR_MOTION_KEYS.has(data)) {
       this.pendingMotion = data as PendingMotion;
       return;
     }
-    if (this.deleteWithMotion(data)) {
+
+    const hasCount = this.prefixCount.length > 0 || this.operatorCount.length > 0;
+    const supportsCountedWordMotion = (
+      data === "w"
+      || data === "e"
+      || data === "b"
+      || data === "W"
+      || data === "E"
+      || data === "B"
+    );
+    const supportsCountedTextObject = data === "i" || data === "a";
+
+    if (hasCount && !supportsCountedWordMotion && !supportsCountedTextObject) {
+      this.cancelPendingOperator(data);
+      return;
+    }
+
+    if (supportsCountedTextObject) {
+      this.pendingTextObject = data;
+      return;
+    }
+
+    const motionCount = supportsCountedWordMotion ? this.takeTotalCount(1) : 1;
+    const effectiveMotion = data === "W" && this.isCursorOnNonWhitespace()
+      ? "E"
+      : data;
+    if (this.deleteWithMotion(effectiveMotion, motionCount)) {
       this.pendingOperator = null;
       this.mode = "insert";
       return;
@@ -487,35 +562,134 @@ export class ModalEditor extends CustomEditor {
 
   private handleNormalMode(data: string): void {
     if (this.pendingG) {
-      this.pendingG = false;
-      if (data === "g") {
-        this.moveCursorToBufferStart();
+      if (this.isDigit(data)) {
+        this.pendingGCount += data;
         return;
       }
-      // Unsupported g-prefix command: discard prefix and keep processing input.
+
+      this.pendingG = false;
+      const hadGCount = this.pendingGCount.length > 0;
+      this.pendingGCount = "";
+
+      if (!hadGCount) {
+        if (data === "g") {
+          this.takeTotalCount(1);
+          this.moveCursorToBufferStart();
+          return;
+        }
+
+        if (data === "J") {
+          this.joinLines(false);
+          return;
+        }
+      }
+
+      this.clearPendingState();
+      return;
     }
 
-    if (this.pendingCount.length > 0) {
-      if (this.isDigit(data) && this.pendingCountKind === "prefix") {
-        this.pendingCount += data;
+    if (this.prefixCount.length > 0) {
+      if (this.isDigit(data)) {
+        this.prefixCount += data;
         return;
       }
 
-      if ((data === "d" || data === "y") && this.pendingCountKind === "prefix") {
+      if (data === "d" || data === "y") {
         this.pendingOperator = data;
         return;
       }
 
-      // Count prefixes are currently supported for dd/yy only.
-      this.pendingCount = "";
-      this.pendingCountKind = null;
+      if (data === "c") {
+        this.pendingOperator = "c";
+        return;
+      }
+
+      if (data === "g") {
+        this.pendingGCount = "";
+        this.pendingG = true;
+        return;
+      }
+
+      const supportsCountedStandaloneEdit = (
+        data === "x"
+        || data === "s"
+        || data === "S"
+        || data === "D"
+        || data === "C"
+        || data === "p"
+        || data === "P"
+        || data === "J"
+      );
+      const supportsCountedCharMotion = (
+        CHAR_MOTION_KEYS.has(data)
+        || data === ";"
+        || data === ","
+      );
+      const supportsCountedWordMotion = (
+        data === "w"
+        || data === "e"
+        || data === "b"
+        || data === "W"
+        || data === "E"
+        || data === "B"
+      );
+      const supportsCountedParagraphMotion = data === "{" || data === "}";
+      const supportsCountedNav = (
+        data === "h"
+        || data === "j"
+        || data === "k"
+        || data === "l"
+      );
+
+      if (supportsCountedNav) {
+        const count = this.takeTotalCount(1);
+        const clamped = Math.min(count, MAX_COUNT);
+        if (data === "h") {
+          this.moveCursorBy(-clamped);
+        } 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);
+          }
+        }
+        return;
+      }
+
+      if (supportsCountedParagraphMotion) {
+        this.executeParagraphMotion(data === "}" ? "forward" : "backward");
+        return;
+      }
+
+      if (
+        !supportsCountedStandaloneEdit
+        && !supportsCountedCharMotion
+        && !supportsCountedWordMotion
+        && !supportsCountedParagraphMotion
+      ) {
+        // Unsupported prefixed forms: drop count and keep processing this key.
+        this.prefixCount = "";
+        this.operatorCount = "";
+      }
     } else if (this.isCountStarter(data)) {
-      this.pendingCount = data;
-      this.pendingCountKind = "prefix";
+      this.prefixCount = data;
+      return;
+    }
+
+    if (data === "J") {
+      this.joinLines(true);
       return;
     }
 
     if (data === "g") {
+      this.pendingGCount = "";
       this.pendingG = true;
       return;
     }
@@ -573,9 +747,20 @@ export class ModalEditor extends CustomEditor {
       return;
     }
 
-    if (data === "w") return this.moveWord("forward", "start");
-    if (data === "b") return this.moveWord("backward", "start");
-    if (data === "e") return this.moveWord("forward", "end");
+    if (data === "}" || data === "{") {
+      this.executeParagraphMotion(data === "}" ? "forward" : "backward");
+      return;
+    }
+
+    if (data === "w") {
+      const count = this.takeTotalCount(1);
+      return this.moveWord("forward", "start", count, "word");
+    }
+    if (data === "b") return this.moveWord("backward", "start", this.takeTotalCount(1), "word");
+    if (data === "e") return this.moveWord("forward", "end", this.takeTotalCount(1), "word");
+    if (data === "W") return this.moveWord("forward", "start", this.takeTotalCount(1), "WORD");
+    if (data === "B") return this.moveWord("backward", "start", this.takeTotalCount(1), "WORD");
+    if (data === "E") return this.moveWord("forward", "end", this.takeTotalCount(1), "WORD");
 
     if (Object.hasOwn(NORMAL_KEYS, data)) {
       return this.handleMappedKey(data);
@@ -618,13 +803,16 @@ export class ModalEditor extends CustomEditor {
         this.mode = "insert";
         break;
       case "D":
+        this.takeTotalCount(1);
         this.cutToEndOfLine();
         break;
       case "C":
+        this.takeTotalCount(1);
         this.cutToEndOfLine();
         this.mode = "insert";
         break;
       case "S":
+        this.takeTotalCount(1);
         this.cutCurrentLineContent();
         this.mode = "insert";
         break;
@@ -643,7 +831,8 @@ export class ModalEditor extends CustomEditor {
   private executeCharMotion(motion: CharMotion, targetChar: string, saveMotion: boolean = true): void {
     const line = this.getLines()[this.getCursor().line] ?? "";
     const col = this.getCursor().col;
-    const targetCol = findCharMotionTarget(line, col, motion, targetChar, !saveMotion);
+    const count = this.takeTotalCount(1);
+    const targetCol = findCharMotionTarget(line, col, motion, targetChar, !saveMotion, count);
 
     if (targetCol !== null && saveMotion) {
       this.lastCharMotion = { motion, char: targetChar };
@@ -654,6 +843,14 @@ export class ModalEditor extends CustomEditor {
     }
   }
 
+  private executeParagraphMotion(direction: "forward" | "backward"): void {
+    const lines = this.getLines();
+    const fromLine = this.getCursor().line;
+    const count = this.takeTotalCount(1);
+    const targetLine = findParagraphMotionTarget(lines, fromLine, direction, count);
+    this.moveCursorToLineStart(targetLine);
+  }
+
   private tryMoveCursorByState(delta: number): boolean {
     if (delta === 0) return true;
 
@@ -726,16 +923,79 @@ export class ModalEditor extends CustomEditor {
     this.moveCursorToLineStart(Math.max(0, lines.length - 1));
   }
 
+  private joinLines(normalize: boolean): void {
+    const count = this.takeTotalCount(2);
+    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 };
+    };
+
+    const state = editor.state;
+    if (!state || !Array.isArray(state.lines)) return;
+
+    const currentLine = state.cursorLine ?? 0;
+    let joinPoint = state.cursorCol ?? 0;
+
+    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;
+
+      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.cursorLine = currentLine;
+    state.cursorCol = joinPoint;
+    editor.preferredVisualCol = joinPoint;
+    editor.tui?.requestRender?.();
+  }
+
   private isWordChar(ch: string): boolean {
     return /\w/.test(ch);
   }
 
-  private charType(ch: string | undefined): "space" | "word" | "other" {
+  private charType(
+    ch: string | undefined,
+    semanticClass: WordMotionClass = "word",
+  ): "space" | "word" | "other" {
     if (!ch || /\s/.test(ch)) return "space";
+    if (semanticClass === "WORD") return "word";
     if (this.isWordChar(ch)) return "word";
     return "other";
   }
 
+  private resolveWordMotion(
+    motion: string,
+  ): { motion: "w" | "e" | "b"; semanticClass: WordMotionClass } | null {
+    if (motion === "w" || motion === "e" || motion === "b") {
+      return { motion, semanticClass: "word" };
+    }
+
+    if (motion === "W" || motion === "E" || motion === "B") {
+      const normalizedMotion = motion.toLowerCase() as "w" | "e" | "b";
+      return { motion: normalizedMotion, semanticClass: "WORD" };
+    }
+
+    return null;
+  }
+
   private getAbsoluteIndex(line: number, col: number): number {
     const lines = this.getLines();
     let idx = 0;
@@ -755,74 +1015,81 @@ export class ModalEditor extends CustomEditor {
     abs: number,
     direction: "forward" | "backward",
     target: "start" | "end",
+    count: number = 1,
+    semanticClass: WordMotionClass = "word",
   ): number {
     const len = text.length;
     if (len === 0) return 0;
 
+    const steps = Math.max(1, Math.min(MAX_COUNT, count));
     let i = Math.max(0, Math.min(abs, len));
 
-    if (direction === "forward") {
-      if (i >= len) return len;
+    for (let step = 0; step < steps; step++) {
+      let next = i;
 
-      if (target === "start") {
-        const startType = this.charType(text[i]);
-        if (startType !== "space") {
-          while (i < len && this.charType(text[i]) === startType) i++;
+      if (direction === "forward") {
+        if (next >= len) {
+          next = len;
+        } else if (target === "start") {
+          const startType = this.charType(text[next], semanticClass);
+          if (startType !== "space") {
+            while (next < len && this.charType(text[next], semanticClass) === startType) next++;
+          }
+          while (next < len && this.charType(text[next], semanticClass) === "space") next++;
+        } else {
+          if (next < len - 1) next++;
+          while (next < len && this.charType(text[next], semanticClass) === "space") next++;
+          if (next >= len) {
+            next = len;
+          } else {
+            const t = this.charType(text[next], semanticClass);
+            while (next < len - 1 && this.charType(text[next + 1], semanticClass) === t) next++;
+          }
         }
-        while (i < len && this.charType(text[i]) === "space") i++;
-        return i;
+      } else {
+        if (next >= len) next = len - 1;
+        if (next > 0) next--;
+        while (next > 0 && this.charType(text[next], semanticClass) === "space") next--;
+        const t = this.charType(text[next], semanticClass);
+        while (next > 0 && this.charType(text[next - 1], semanticClass) === t) next--;
       }
 
-      if (i < len - 1) i++;
-      while (i < len && this.charType(text[i]) === "space") i++;
-      if (i >= len) return len;
-      const t = this.charType(text[i]);
-      while (i < len - 1 && this.charType(text[i + 1]) === t) i++;
-      return i;
+      if (next === i) break;
+      i = next;
     }
 
-    if (i >= len) i = len - 1;
-    if (i > 0) i--;
-    while (i > 0 && this.charType(text[i]) === "space") i--;
-    const t = this.charType(text[i]);
-    while (i > 0 && this.charType(text[i - 1]) === t) i--;
     return i;
   }
 
-  private tryFindWordTargetLineLocal(
+  private tryFindWordTargetInLine(
+    line: string,
+    col: number,
     direction: WordMotionDirection,
     target: WordMotionTarget,
     allowSameColumn: boolean = false,
+    semanticClass: WordMotionClass = "word",
   ): number | null {
-    const cursor = this.getCursor();
-    const lineIndex = cursor.line;
-    const col = cursor.col;
-    const lineSnapshot = this.getLines()[lineIndex] ?? "";
-
-    if (lineSnapshot.length === 0) return null;
-    if (col < 0 || col > lineSnapshot.length) return null;
+    if (line.length === 0) return null;
+    if (col < 0 || col > line.length) return null;
 
     if (direction === "forward") {
-      if (col >= lineSnapshot.length) return null;
+      if (col >= line.length) return null;
     } else {
       if (col <= 0) return null;
-      if (!/\S/.test(lineSnapshot.slice(0, col))) return null;
+      if (!/\S/.test(line.slice(0, col))) return null;
     }
 
     const targetCol = this.wordBoundaryCache.tryFindTarget(
-      lineSnapshot,
+      line,
       col,
       direction,
       target,
+      semanticClass,
     );
     if (targetCol === null) return null;
 
-    const liveLine = this.getLines()[lineIndex] ?? "";
-    const liveCol = this.getCursor().col;
-    if (liveLine !== lineSnapshot || liveCol !== col) return null;
-
     if (direction === "forward") {
-      if (targetCol >= lineSnapshot.length) return null;
+      if (targetCol >= line.length) return null;
       if (allowSameColumn) {
         if (targetCol < col) return null;
       } else if (targetCol <= col) {
@@ -840,12 +1107,41 @@ export class ModalEditor extends CustomEditor {
     return targetCol;
   }
 
+  private tryFindWordTargetLineLocal(
+    direction: WordMotionDirection,
+    target: WordMotionTarget,
+    allowSameColumn: boolean = false,
+    semanticClass: WordMotionClass = "word",
+  ): number | null {
+    const cursor = this.getCursor();
+    const lineIndex = cursor.line;
+    const col = cursor.col;
+    const lineSnapshot = this.getLines()[lineIndex] ?? "";
+
+    const targetCol = this.tryFindWordTargetInLine(
+      lineSnapshot,
+      col,
+      direction,
+      target,
+      allowSameColumn,
+      semanticClass,
+    );
+    if (targetCol === null) return null;
+
+    const liveLine = this.getLines()[lineIndex] ?? "";
+    const liveCol = this.getCursor().col;
+    if (liveLine !== lineSnapshot || liveCol !== col) return null;
+
+    return targetCol;
+  }
+
   private tryMoveWordLineLocal(
     direction: "forward" | "backward",
     target: "start" | "end",
+    semanticClass: WordMotionClass = "word",
   ): boolean {
     const col = this.getCursor().col;
-    const targetCol = this.tryFindWordTargetLineLocal(direction, target);
+    const targetCol = this.tryFindWordTargetLineLocal(direction, target, false, semanticClass);
     if (targetCol === null || targetCol === col) return false;
 
     this.moveCursorBy(targetCol - col);
@@ -854,29 +1150,71 @@ export class ModalEditor extends CustomEditor {
 
   private tryWordMotionLineLocalRange(
     motion: "w" | "e" | "b",
+    count: number = 1,
+    semanticClass: WordMotionClass = "word",
   ): { col: number; targetCol: number; inclusive: boolean } | null {
-    const col = this.getCursor().col;
+    const cursor = this.getCursor();
+    const lineIndex = cursor.line;
+    const col = cursor.col;
+    const lineSnapshot = this.getLines()[lineIndex] ?? "";
     const direction: WordMotionDirection = motion === "b" ? "backward" : "forward";
     const target: WordMotionTarget = motion === "e" ? "end" : "start";
-    const targetCol = this.tryFindWordTargetLineLocal(direction, target, motion === "e");
+    const steps = Math.max(1, Math.min(MAX_COUNT, count));
+
+    let currentCol = col;
+    for (let step = 0; step < steps; step++) {
+      const nextCol = this.tryFindWordTargetInLine(
+        lineSnapshot,
+        currentCol,
+        direction,
+        target,
+        motion === "e",
+        semanticClass,
+      );
+      if (nextCol === null) return null;
+      if (nextCol === currentCol && step < steps - 1) return null;
+      currentCol = nextCol;
+    }
 
-    if (targetCol === null) return null;
+    const liveLine = this.getLines()[lineIndex] ?? "";
+    const liveCol = this.getCursor().col;
+    if (liveLine !== lineSnapshot || liveCol !== col) return null;
 
     return {
       col,
-      targetCol,
+      targetCol: currentCol,
       inclusive: motion === "e",
     };
   }
 
-  private moveWord(direction: "forward" | "backward", target: "start" | "end"): void {
-    if (this.tryMoveWordLineLocal(direction, target)) return;
+  private moveWord(
+    direction: "forward" | "backward",
+    target: "start" | "end",
+    count: number = 1,
+    semanticClass: WordMotionClass = "word",
+  ): void {
+    let remaining = Math.max(1, Math.min(MAX_COUNT, count));
+
+    while (remaining > 0) {
+      if (this.tryMoveWordLineLocal(direction, target, semanticClass)) {
+        remaining--;
+        continue;
+      }
 
-    const text = this.getText();
-    const currentAbs = this.getAbsoluteIndexFromCursor();
-    const targetAbs = this.findWordTargetInText(text, currentAbs, direction, target);
-    if (targetAbs !== currentAbs) {
-      this.moveCursorBy(targetAbs - currentAbs);
+      const text = this.getText();
+      const currentAbs = this.getAbsoluteIndexFromCursor();
+      const targetAbs = this.findWordTargetInText(
+        text,
+        currentAbs,
+        direction,
+        target,
+        remaining,
+        semanticClass,
+      );
+      if (targetAbs !== currentAbs) {
+        this.moveCursorBy(targetAbs - currentAbs);
+      }
+      return;
     }
   }
 
@@ -892,19 +1230,25 @@ export class ModalEditor extends CustomEditor {
     return { line, col };
   }
 
+  private isCursorOnNonWhitespace(): boolean {
+    const { line, col } = this.getCurrentLineAndCol();
+    const ch = line[col];
+    return ch !== undefined && !/\s/.test(ch);
+  }
+
   private isCursorAtOrPastEol(): boolean {
     const { line, col } = this.getCurrentLineAndCol();
     return col >= line.length;
   }
 
   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 deleted = line.slice(col, col + 1);
-    this.writeToRegister(deleted);
-    super.handleInput(ESC_DELETE);
+    const boundedCount = Math.max(1, Math.min(MAX_COUNT, count));
+    this.deleteRange(col, col + boundedCount, false);
   }
 
   private cutToEndOfLine(): void {
@@ -1023,9 +1367,8 @@ export class ModalEditor extends CustomEditor {
     this.yankLineRange(this.getCursor().line, this.getLines().length - 1);
   }
 
-  private deleteWithMotion(motion: string): boolean {
+  private deleteWithMotion(motion: string, count: number = 1): boolean {
     const cursor = this.getCursor();
-    const line = this.getLines()[cursor.line] ?? "";
     const col = cursor.col;
 
     if (motion === "$") {
@@ -1039,8 +1382,13 @@ export class ModalEditor extends CustomEditor {
       return true;
     }
 
-    if (motion === "w" || motion === "e" || motion === "b") {
-      const lineLocalRange = this.tryWordMotionLineLocalRange(motion);
+    const wordMotion = this.resolveWordMotion(motion);
+    if (wordMotion) {
+      const lineLocalRange = this.tryWordMotionLineLocalRange(
+        wordMotion.motion,
+        count,
+        wordMotion.semanticClass,
+      );
       if (lineLocalRange) {
         this.deleteRange(
           lineLocalRange.col,
@@ -1055,10 +1403,12 @@ export class ModalEditor extends CustomEditor {
       const targetAbs = this.findWordTargetInText(
         text,
         currentAbs,
-        motion === "b" ? "backward" : "forward",
-        motion === "e" ? "end" : "start",
+        wordMotion.motion === "b" ? "backward" : "forward",
+        wordMotion.motion === "e" ? "end" : "start",
+        count,
+        wordMotion.semanticClass,
       );
-      this.deleteRangeByAbsolute(currentAbs, targetAbs, motion === "e");
+      this.deleteRangeByAbsolute(currentAbs, targetAbs, wordMotion.motion === "e");
       return true;
     }
 
@@ -1068,7 +1418,8 @@ export class ModalEditor extends CustomEditor {
   private deleteWithCharMotion(motion: CharMotion, targetChar: string): void {
     const line = this.getLines()[this.getCursor().line] ?? "";
     const col = this.getCursor().col;
-    const targetCol = findCharMotionTarget(line, col, motion, targetChar);
+    const count = this.takeTotalCount(1);
+    const targetCol = findCharMotionTarget(line, col, motion, targetChar, false, count);
 
     if (targetCol === null) return;
 
@@ -1078,43 +1429,35 @@ export class ModalEditor extends CustomEditor {
 
   private handlePendingYank(data: string): void {
     if (this.isDigit(data)) {
-      if (this.pendingCount.length === 0) {
+      if (this.operatorCount.length === 0) {
         if (data !== "0") {
-          this.pendingCount = data;
-          this.pendingCountKind = "operator";
+          this.operatorCount = data;
           return;
         }
-      } else if (this.pendingCountKind === "operator") {
-        this.pendingCount += data;
-        return;
       } else {
-        // Dual counts like 2y3k are out of scope; fail closed.
-        this.cancelPendingOperator(data);
+        this.operatorCount += data;
         return;
       }
     }
 
     if (data === "y") {
-      const count = this.takePendingCount(1);
+      const count = this.takeTotalCount(1);
       this.yankLinewiseByDelta(count - 1);
       this.pendingOperator = null;
       return;
     }
 
     if (data === "j" || data === "k") {
-      if (this.pendingCountKind === "prefix") {
-        this.cancelPendingOperator(data);
-        return;
-      }
-
-      const count = this.takePendingCount(1);
-      this.yankLinewiseByDelta(data === "j" ? count : -count);
+      const hasDualCount = this.prefixCount.length > 0 && this.operatorCount.length > 0;
+      const count = this.takeTotalCount(1);
+      const delta = hasDualCount ? Math.max(0, count - 1) : count;
+      this.yankLinewiseByDelta(data === "j" ? delta : -delta);
       this.pendingOperator = null;
       return;
     }
 
     if (data === "G") {
-      if (this.pendingCount.length > 0) {
+      if (this.prefixCount.length > 0 || this.operatorCount.length > 0) {
         this.cancelPendingOperator(data);
         return;
       }
@@ -1124,8 +1467,13 @@ export class ModalEditor extends CustomEditor {
       return;
     }
 
-    if (this.pendingCount.length > 0) {
-      // Counted forms beyond yy and y{count}j/k are intentionally out of scope.
+    if (CHAR_MOTION_KEYS.has(data)) {
+      this.pendingMotion = data as PendingMotion;
+      return;
+    }
+
+    if (this.prefixCount.length > 0 || this.operatorCount.length > 0) {
+      // Counted forms beyond yy, y{count}j/k, and y{count}{f/F/t/T} are out of scope.
       this.cancelPendingOperator(data);
       return;
     }
@@ -1134,10 +1482,6 @@ export class ModalEditor extends CustomEditor {
       this.pendingTextObject = data;
       return;
     }
-    if (CHAR_MOTION_KEYS.has(data)) {
-      this.pendingMotion = data as PendingMotion;
-      return;
-    }
 
     if (this.yankWithMotion(data)) {
       this.pendingOperator = null;
@@ -1161,8 +1505,13 @@ export class ModalEditor extends CustomEditor {
       return true;
     }
 
-    if (motion === "w" || motion === "e" || motion === "b") {
-      const lineLocalRange = this.tryWordMotionLineLocalRange(motion);
+    const wordMotion = this.resolveWordMotion(motion);
+    if (wordMotion) {
+      const lineLocalRange = this.tryWordMotionLineLocalRange(
+        wordMotion.motion,
+        1,
+        wordMotion.semanticClass,
+      );
       if (lineLocalRange) {
         this.yankRange(
           lineLocalRange.col,
@@ -1177,10 +1526,12 @@ export class ModalEditor extends CustomEditor {
       const targetAbs = this.findWordTargetInText(
         text,
         currentAbs,
-        motion === "b" ? "backward" : "forward",
-        motion === "e" ? "end" : "start",
+        wordMotion.motion === "b" ? "backward" : "forward",
+        wordMotion.motion === "e" ? "end" : "start",
+        1,
+        wordMotion.semanticClass,
       );
-      this.yankRangeByAbsolute(currentAbs, targetAbs, motion === "e");
+      this.yankRangeByAbsolute(currentAbs, targetAbs, wordMotion.motion === "e");
       return true;
     }
 
@@ -1190,7 +1541,8 @@ export class ModalEditor extends CustomEditor {
   private yankWithCharMotion(motion: CharMotion, targetChar: string): void {
     const line = this.getLines()[this.getCursor().line] ?? "";
     const col = this.getCursor().col;
-    const targetCol = findCharMotionTarget(line, col, motion, targetChar);
+    const count = this.takeTotalCount(1);
+    const targetCol = findCharMotionTarget(line, col, motion, targetChar, false, count);
 
     if (targetCol === null) return;
 
@@ -1241,16 +1593,20 @@ export class ModalEditor extends CustomEditor {
     }
   }
 
-  private getWordObjectRange(kind: "i" | "a"): { startAbs: number; endAbs: number } | null {
+  private getWordObjectRange(
+    kind: "i" | "a",
+    count: number = 1,
+  ): { startAbs: number; endAbs: number } | null {
     const lines = this.getLines();
     const cursor = this.getCursor();
     const line = lines[cursor.line] ?? "";
     if (!line) return null;
 
-    let col = Math.min(cursor.col, Math.max(0, line.length - 1));
-
+    const steps = Math.max(1, Math.min(MAX_COUNT, count));
     const hasWordChar = (idx: number) => idx >= 0 && idx < line.length && this.isWordChar(line[idx]!);
 
+    let col = Math.min(cursor.col, Math.max(0, line.length - 1));
+
     if (!hasWordChar(col)) {
       let right = col;
       while (right < line.length && !hasWordChar(right)) right++;
@@ -1270,17 +1626,28 @@ export class ModalEditor extends CustomEditor {
     let end = col + 1;
     while (end < line.length && hasWordChar(end)) end++;
 
+    let remaining = steps - 1;
+    while (remaining > 0) {
+      let nextWordStart = end;
+      while (nextWordStart < line.length && !hasWordChar(nextWordStart)) nextWordStart++;
+      if (nextWordStart >= line.length) break;
+
+      let nextWordEnd = nextWordStart + 1;
+      while (nextWordEnd < line.length && hasWordChar(nextWordEnd)) nextWordEnd++;
+
+      end = nextWordEnd;
+      remaining--;
+    }
+
     if (kind === "a") {
-      let aroundStart = start;
       let aroundEnd = end;
-
       while (aroundEnd < line.length && /\s/.test(line[aroundEnd]!)) aroundEnd++;
-      if (aroundEnd === end) {
-        while (aroundStart > 0 && /\s/.test(line[aroundStart - 1]!)) aroundStart--;
-      }
 
-      start = aroundStart;
-      end = aroundEnd;
+      if (aroundEnd > end) {
+        end = aroundEnd;
+      } else {
+        while (start > 0 && /\s/.test(line[start - 1]!)) start--;
+      }
     }
 
     return {
@@ -1289,23 +1656,32 @@ export class ModalEditor extends CustomEditor {
     };
   }
 
+  private static readonly PUT_SIZE_LIMIT = 512 * 1024; // 512 KB safety cap
+
   private putAfter(): void {
+    const count = this.takeTotalCount(1);
     const text = this.unnamedRegister;
     if (!text) return;
+    const safeCount = Math.min(count, Math.max(1, Math.floor(ModalEditor.PUT_SIZE_LIMIT / text.length)));
 
     if (text.endsWith("\n")) {
-      // Line-wise: insert new line below and fill it
-      super.handleInput(CTRL_E);
-      super.handleInput(NEWLINE);
       const content = text.slice(0, -1);
-      for (const char of content) {
-        super.handleInput(char === "\n" ? NEWLINE : char);
-      }
-    } else {
-      // Character-wise: insert after cursor
-      if (!this.isCursorAtOrPastEol()) {
-        super.handleInput(ESC_RIGHT);
+      for (let i = 0; i < safeCount; i++) {
+        // Line-wise: insert new line below and fill it
+        super.handleInput(CTRL_E);
+        super.handleInput(NEWLINE);
+        for (const char of content) {
+          super.handleInput(char === "\n" ? NEWLINE : char);
+        }
       }
+      return;
+    }
+
+    // Character-wise: insert after cursor
+    if (!this.isCursorAtOrPastEol()) {
+      super.handleInput(ESC_RIGHT);
+    }
+    for (let i = 0; i < safeCount; i++) {
       for (const char of text) {
         super.handleInput(char === "\n" ? NEWLINE : char);
       }
@@ -1313,20 +1689,27 @@ export class ModalEditor extends CustomEditor {
   }
 
   private putBefore(): void {
+    const count = this.takeTotalCount(1);
     const text = this.unnamedRegister;
     if (!text) return;
+    const safeCount = Math.min(count, Math.max(1, Math.floor(ModalEditor.PUT_SIZE_LIMIT / text.length)));
 
     if (text.endsWith("\n")) {
-      // Line-wise: insert new line above and fill it
-      super.handleInput(CTRL_A);
-      super.handleInput(NEWLINE);
-      super.handleInput(ESC_UP);
       const content = text.slice(0, -1);
-      for (const char of content) {
-        super.handleInput(char === "\n" ? NEWLINE : char);
+      for (let i = 0; i < safeCount; i++) {
+        // Line-wise: insert new line above and fill it
+        super.handleInput(CTRL_A);
+        super.handleInput(NEWLINE);
+        super.handleInput(ESC_UP);
+        for (const char of content) {
+          super.handleInput(char === "\n" ? NEWLINE : char);
+        }
       }
-    } else {
-      // Character-wise: insert before cursor (just type it)
+      return;
+    }
+
+    // Character-wise: insert before cursor (just type it)
+    for (let i = 0; i < safeCount; i++) {
       for (const char of text) {
         super.handleInput(char === "\n" ? NEWLINE : char);
       }
@@ -1369,20 +1752,23 @@ export class ModalEditor extends CustomEditor {
   private getModeLabel(): string {
     if (this.mode === "insert") return " INSERT ";
 
-    const count = this.pendingCount;
+    const prefixCount = this.prefixCount;
+    const operatorCount = this.operatorCount;
 
     if (this.pendingOperator && this.pendingMotion) {
-      const prefix = this.pendingCountKind === "prefix" ? count : "";
-      const opCount = this.pendingCountKind === "operator" ? count : "";
-      return ` NORMAL ${prefix}${this.pendingOperator}${opCount}${this.pendingMotion}_ `;
+      return ` NORMAL ${prefixCount}${this.pendingOperator}${operatorCount}${this.pendingMotion}_ `;
     }
     if (this.pendingOperator) {
-      const prefix = this.pendingCountKind === "prefix" ? count : "";
-      const opCount = this.pendingCountKind === "operator" ? count : "";
-      return ` NORMAL ${prefix}${this.pendingOperator}${opCount}_ `;
+      return ` NORMAL ${prefixCount}${this.pendingOperator}${operatorCount}_ `;
     }
     if (this.pendingMotion) return ` NORMAL ${this.pendingMotion}_ `;
-    if (this.pendingG) return " NORMAL g_ ";
+    if (this.pendingG) {
+      return this.pendingGCount
+        ? ` NORMAL g${this.pendingGCount}_ `
+        : " NORMAL g_ ";
+    }
+
+    const count = `${prefixCount}${operatorCount}`;
     if (count) return ` NORMAL ${count}_ `;
     return " NORMAL ";
   }