@gajae-code/coding-agent 0.1.1

package/src/vim/engine.ts

@@ -0,0 +1,2409 @@
+import type { FileDiagnosticsResult } from "../lsp";
+import { snapshotEqual, type VimBuffer } from "./buffer";
+import { parseExCommand } from "./commands";
+import { replayTokens } from "./parser";
+import type {
+	Position,
+	VimBufferSnapshot,
+	VimInputMode,
+	VimKeyToken,
+	VimLineRange,
+	VimLoadedFile,
+	VimPendingInput,
+	VimRegister,
+	VimSearchState,
+	VimSelection,
+	VimUndoEntry,
+} from "./types";
+import { clonePosition, maxPosition, minPosition, toPublicMode, VimInputError as VimError } from "./types";
+
+export interface VimSaveResult {
+	loaded: VimLoadedFile;
+	diagnostics?: FileDiagnosticsResult;
+}
+
+export interface VimEngineCallbacks {
+	beforeMutate: (buffer: VimBuffer) => Promise<void>;
+	loadBuffer: (path: string) => Promise<VimLoadedFile>;
+	saveBuffer: (buffer: VimBuffer, options?: { force?: boolean }) => Promise<VimSaveResult>;
+}
+
+interface PendingChange {
+	before: VimBufferSnapshot;
+	tokens: string[];
+	moveCursorLeftOnEscape: boolean;
+	inserted: boolean;
+}
+
+interface MotionResult {
+	nextIndex: number;
+	target: Position;
+	inclusive?: boolean;
+	linewise?: boolean;
+	range?: { start: number; end: number; linewise?: boolean };
+}
+
+const WORD_CHAR = /[A-Za-z0-9_]/;
+const DEFAULT_VIEWPORT_HEIGHT = 10;
+const BRACKET_PAIRS = new Map<string, string>([
+	["(", ")"],
+	["[", "]"],
+	["{", "}"],
+	["<", ">"],
+]);
+const CLOSING_BRACKETS = new Map<string, string>(
+	Array.from(BRACKET_PAIRS.entries()).map(([open, close]) => [close, open]),
+);
+const NOOP_Z_COMMANDS = new Set(["a", "A", "c", "C", "m", "M", "o", "O", "r", "R", "v", "x", "X"]);
+
+function escapeRegex(value: string): string {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function isWhitespace(char: string): boolean {
+	return /\s/.test(char);
+}
+
+function isWordChar(char: string): boolean {
+	return WORD_CHAR.test(char);
+}
+
+function wordCategory(char: string, bigWord: boolean): "space" | "word" | "punct" {
+	if (char.length === 0 || isWhitespace(char)) {
+		return "space";
+	}
+	if (bigWord) {
+		return "word";
+	}
+	return isWordChar(char) ? "word" : "punct";
+}
+
+function decodeReplacement(replacement: string): string {
+	return replacement.replace(/\\\//g, "/").replace(/\\\\/g, "\\");
+}
+
+function literalTextToReplayTokens(text: string): string[] {
+	const tokens: string[] = [];
+	for (const char of text) {
+		if (char === "\n") {
+			tokens.push("CR");
+			continue;
+		}
+		if (char === "\t") {
+			tokens.push("Tab");
+			continue;
+		}
+		tokens.push(char);
+	}
+	return tokens;
+}
+
+// Convert a vim-style search pattern to a JavaScript RegExp.
+// In vim's default ("magic") mode, (, ), {, }, |, + are literal unless backslash-escaped.
+// In JS regex these are metacharacters. Swap the escaping so bare chars are literal
+// and \( etc. become regex groups.
+function vimPatternToJsRegex(pattern: string): string {
+	return pattern.replace(/\\([(){}|+])|([(){}|+])/g, (_match, escaped, bare) => {
+		if (escaped) return escaped; // \( -> ( (regex group)
+		return `\\${bare}`; // ( -> \( (literal paren)
+	});
+}
+
+function createSearchRegex(pattern: string, flags = "g"): RegExp {
+	try {
+		return new RegExp(vimPatternToJsRegex(pattern), flags);
+	} catch {
+		return new RegExp(escapeRegex(pattern), flags);
+	}
+}
+
+function detectIndentUnit(lines: string[]): string {
+	for (const line of lines) {
+		if (line.startsWith("\t")) {
+			return "\t";
+		}
+		if (line.startsWith("  ")) {
+			return "  ";
+		}
+	}
+	return "\t";
+}
+
+function normalizeRange(start: number, end: number): { start: number; end: number } {
+	return {
+		start: Math.min(start, end),
+		end: Math.max(start, end),
+	};
+}
+
+function selectionFromAnchor(buffer: VimBuffer, anchor: Position, linewise: boolean): VimSelection {
+	if (linewise) {
+		const startLine = Math.min(anchor.line, buffer.cursor.line);
+		const endLine = Math.max(anchor.line, buffer.cursor.line);
+		return {
+			kind: "line",
+			start: { line: startLine + 1, col: 1 },
+			end: { line: endLine + 1, col: buffer.getLine(endLine).length + 1 },
+		};
+	}
+	const start = minPosition(anchor, buffer.cursor);
+	const end = maxPosition(anchor, buffer.cursor);
+	return {
+		kind: "char",
+		start: { line: start.line + 1, col: start.col + 1 },
+		end: { line: end.line + 1, col: end.col + 1 },
+	};
+}
+
+function expandVisualOffsets(
+	buffer: VimBuffer,
+	anchor: Position,
+	linewise: boolean,
+): { start: number; end: number; linewise: boolean } {
+	if (linewise) {
+		const startLine = Math.min(anchor.line, buffer.cursor.line);
+		const endLine = Math.max(anchor.line, buffer.cursor.line);
+		const startOffset = buffer.positionToOffset({ line: startLine, col: 0 });
+		const endOffset =
+			endLine >= buffer.lastLineIndex()
+				? buffer.getText().length
+				: buffer.positionToOffset({ line: endLine + 1, col: 0 });
+		return { start: startOffset, end: endOffset, linewise: true };
+	}
+	const anchorOffset = buffer.positionToOffset(anchor);
+	const cursorOffset = buffer.positionToOffset(buffer.cursor);
+	const { start, end } = normalizeRange(anchorOffset, cursorOffset);
+	return { start, end: end + 1, linewise: false };
+}
+
+function nextWordStart(text: string, offset: number, bigWord: boolean): number {
+	let index = Math.min(Math.max(offset, 0), text.length);
+	if (index >= text.length) {
+		return text.length;
+	}
+
+	const currentCategory = wordCategory(text[index] ?? "", bigWord);
+	if (currentCategory === "space") {
+		while (index < text.length && wordCategory(text[index] ?? "", bigWord) === "space") {
+			index += 1;
+		}
+		return index;
+	}
+
+	while (index < text.length && wordCategory(text[index] ?? "", bigWord) === currentCategory) {
+		index += 1;
+	}
+	while (index < text.length && wordCategory(text[index] ?? "", bigWord) === "space") {
+		index += 1;
+	}
+	return index;
+}
+
+function previousWordStart(text: string, offset: number, bigWord: boolean): number {
+	let index = Math.min(Math.max(offset - 1, 0), text.length);
+	while (index > 0 && wordCategory(text[index] ?? "", bigWord) === "space") {
+		index -= 1;
+	}
+	const category = wordCategory(text[index] ?? "", bigWord);
+	while (index > 0 && wordCategory(text[index - 1] ?? "", bigWord) === category) {
+		index -= 1;
+	}
+	return index;
+}
+
+function endOfWord(text: string, offset: number, bigWord: boolean): number {
+	let index = Math.min(Math.max(offset, 0), text.length);
+	while (index < text.length && wordCategory(text[index] ?? "", bigWord) === "space") {
+		index += 1;
+	}
+	const category = wordCategory(text[index] ?? "", bigWord);
+	while (index < text.length && wordCategory(text[index] ?? "", bigWord) === category) {
+		index += 1;
+	}
+	return Math.max(0, index - 1);
+}
+
+function endOfPreviousWord(text: string, offset: number, bigWord: boolean): number {
+	if (text.length === 0) {
+		return 0;
+	}
+
+	let index = Math.min(Math.max(offset - 1, 0), text.length - 1);
+	while (index >= 0 && wordCategory(text[index] ?? "", bigWord) === "space") {
+		index -= 1;
+	}
+	if (index < 0) {
+		return 0;
+	}
+
+	const currentCategory = wordCategory(text[index] ?? "", bigWord);
+	while (index >= 0 && wordCategory(text[index] ?? "", bigWord) === currentCategory) {
+		index -= 1;
+	}
+	while (index >= 0 && wordCategory(text[index] ?? "", bigWord) === "space") {
+		index -= 1;
+	}
+
+	return Math.max(0, index);
+}
+
+function toggleCase(text: string): string {
+	let toggled = "";
+	for (const char of text) {
+		if (char >= "a" && char <= "z") {
+			toggled += char.toUpperCase();
+			continue;
+		}
+		if (char >= "A" && char <= "Z") {
+			toggled += char.toLowerCase();
+			continue;
+		}
+		toggled += char;
+	}
+	return toggled;
+}
+
+function lastNonBlankColumn(line: string): number {
+	for (let index = line.length - 1; index >= 0; index -= 1) {
+		if (!isWhitespace(line[index] ?? "")) {
+			return index;
+		}
+	}
+	return 0;
+}
+
+function findParagraphStart(lines: string[], line: number): number {
+	let index = Math.max(0, line - 1);
+	while (index > 0 && lines[index]!.trim().length > 0) {
+		index -= 1;
+	}
+	while (index > 0 && lines[index - 1]!.trim().length === 0) {
+		index -= 1;
+	}
+	return index;
+}
+
+function findParagraphEnd(lines: string[], line: number): number {
+	let index = Math.min(lines.length - 1, line + 1);
+	while (index < lines.length - 1 && lines[index]!.trim().length > 0) {
+		index += 1;
+	}
+	while (index < lines.length - 1 && lines[index + 1]!.trim().length === 0) {
+		index += 1;
+	}
+	return index;
+}
+
+function cloneUndoStack(stack: VimUndoEntry[]): VimUndoEntry[] {
+	return stack.map(entry => ({
+		before: {
+			...entry.before,
+			lines: [...entry.before.lines],
+			cursor: clonePosition(entry.before.cursor),
+			baseFingerprint: entry.before.baseFingerprint ? { ...entry.before.baseFingerprint } : null,
+		},
+		after: {
+			...entry.after,
+			lines: [...entry.after.lines],
+			cursor: clonePosition(entry.after.cursor),
+			baseFingerprint: entry.after.baseFingerprint ? { ...entry.after.baseFingerprint } : null,
+		},
+	}));
+}
+
+export class VimEngine {
+	buffer: VimBuffer;
+	inputMode: VimInputMode = "normal";
+	selectionAnchor: Position | null = null;
+	register: VimRegister = { kind: "char", text: "" };
+	lastSearch: VimSearchState | null = null;
+	lastCharFind: { char: string; mode: "f" | "F" | "t" | "T" } | null = null;
+	lastVisual: { anchor: Position; cursor: Position; mode: VimInputMode } | null = null;
+	lastCommand?: string;
+	statusMessage?: string;
+	diagnostics?: FileDiagnosticsResult;
+	viewportStart = 1;
+	closed = false;
+
+	#callbacks: VimEngineCallbacks;
+	#undoStack: VimUndoEntry[] = [];
+	#redoStack: VimUndoEntry[] = [];
+	#pendingInput = "";
+	#lastChangeTokens: string[] | null = null;
+	#pendingChange: PendingChange | null = null;
+	#stepCallback?: () => Promise<void>;
+
+	constructor(buffer: VimBuffer, callbacks: VimEngineCallbacks) {
+		this.buffer = buffer;
+		this.#callbacks = callbacks;
+	}
+
+	clone(callbacks?: Partial<VimEngineCallbacks>): VimEngine {
+		const next = new VimEngine(this.buffer.clone(), {
+			beforeMutate: callbacks?.beforeMutate ?? this.#callbacks.beforeMutate,
+			loadBuffer: callbacks?.loadBuffer ?? this.#callbacks.loadBuffer,
+			saveBuffer: callbacks?.saveBuffer ?? this.#callbacks.saveBuffer,
+		});
+		next.inputMode = this.inputMode;
+		next.selectionAnchor = this.selectionAnchor ? clonePosition(this.selectionAnchor) : null;
+		next.register = { ...this.register };
+		next.lastSearch = this.lastSearch ? { ...this.lastSearch } : null;
+		next.lastCharFind = this.lastCharFind ? { ...this.lastCharFind } : null;
+		next.lastVisual = this.lastVisual
+			? {
+					anchor: clonePosition(this.lastVisual.anchor),
+					cursor: clonePosition(this.lastVisual.cursor),
+					mode: this.lastVisual.mode,
+				}
+			: null;
+		next.lastCommand = this.lastCommand;
+		next.statusMessage = this.statusMessage;
+		next.diagnostics = this.diagnostics;
+		next.viewportStart = this.viewportStart;
+		next.closed = this.closed;
+		next.#pendingInput = this.#pendingInput;
+		next.#lastChangeTokens = this.#lastChangeTokens ? [...this.#lastChangeTokens] : null;
+		next.#pendingChange = this.#pendingChange
+			? {
+					before: {
+						...this.#pendingChange.before,
+						lines: [...this.#pendingChange.before.lines],
+						cursor: clonePosition(this.#pendingChange.before.cursor),
+						baseFingerprint: this.#pendingChange.before.baseFingerprint
+							? { ...this.#pendingChange.before.baseFingerprint }
+							: null,
+					},
+					tokens: [...this.#pendingChange.tokens],
+					moveCursorLeftOnEscape: this.#pendingChange.moveCursorLeftOnEscape,
+					inserted: this.#pendingChange.inserted,
+				}
+			: null;
+		next.#undoStack = cloneUndoStack(this.#undoStack);
+		next.#redoStack = cloneUndoStack(this.#redoStack);
+		return next;
+	}
+
+	getPublicMode() {
+		return toPublicMode(this.inputMode);
+	}
+
+	getSelection(): VimSelection | undefined {
+		if (this.selectionAnchor === null) {
+			return undefined;
+		}
+		return selectionFromAnchor(this.buffer, this.selectionAnchor, this.inputMode === "visual-line");
+	}
+
+	getPendingInput(): VimPendingInput | undefined {
+		switch (this.inputMode) {
+			case "insert":
+				return { kind: "insert", text: "" };
+			case "command":
+			case "search-forward":
+			case "search-backward":
+				return { kind: this.inputMode, text: this.#pendingInput };
+			default:
+				return undefined;
+		}
+	}
+
+	rollbackPendingInsert(): void {
+		if (this.#pendingChange) {
+			this.buffer.restore(this.#pendingChange.before);
+			this.#pendingChange = null;
+		}
+		this.inputMode = "normal";
+		this.selectionAnchor = null;
+		this.#pendingInput = "";
+	}
+
+	setCursor(line: number, col: number): void {
+		this.buffer.setCursor({ line, col });
+	}
+
+	async executeTokens(
+		tokens: readonly VimKeyToken[],
+		lastCommand?: string,
+		onStep?: () => Promise<void>,
+	): Promise<void> {
+		const previousStepCallback = this.#stepCallback;
+		this.#stepCallback = onStep ?? previousStepCallback;
+		this.lastCommand = lastCommand;
+		this.statusMessage = undefined;
+		this.diagnostics = undefined;
+
+		try {
+			for (let index = 0; index < tokens.length; ) {
+				switch (this.inputMode) {
+					case "insert":
+						index = await this.#executeInsert(tokens, index);
+						break;
+					case "command":
+					case "search-forward":
+					case "search-backward":
+						index = await this.#executePrompt(tokens, index);
+						break;
+					case "visual":
+					case "visual-line":
+						index = await this.#executeVisual(tokens, index);
+						break;
+					default:
+						index = await this.#executeNormal(tokens, index);
+						break;
+				}
+				if (this.closed) {
+					break;
+				}
+				this.#ensureCursorVisible();
+				await this.#stepCallback?.();
+			}
+		} finally {
+			this.#stepCallback = previousStepCallback;
+		}
+	}
+
+	async close(force: boolean): Promise<void> {
+		if (this.buffer.modified && !force) {
+			throw new VimError("Unsaved changes; use force to discard");
+		}
+		this.closed = true;
+		this.statusMessage = `Closed ${this.buffer.displayPath}`;
+	}
+
+	#ensureCursorVisible(): void {
+		const line = this.buffer.cursor.line + 1;
+		if (line < this.viewportStart) {
+			this.viewportStart = line;
+			return;
+		}
+		const viewportEnd = this.viewportStart + DEFAULT_VIEWPORT_HEIGHT - 1;
+		if (line > viewportEnd) {
+			this.viewportStart = Math.max(1, line - DEFAULT_VIEWPORT_HEIGHT + 1);
+		}
+	}
+
+	centerViewportOnCursor(size = DEFAULT_VIEWPORT_HEIGHT): void {
+		const lineCount = Math.max(this.buffer.lineCount(), 1);
+		const clampedSize = Math.max(1, Math.min(size, lineCount));
+		const maxStart = Math.max(1, lineCount - clampedSize + 1);
+		this.viewportStart = Math.max(1, Math.min(this.buffer.cursor.line + 1 - Math.floor(clampedSize / 2), maxStart));
+	}
+
+	#clearSelection(): void {
+		if (this.selectionAnchor && (this.inputMode === "visual" || this.inputMode === "visual-line")) {
+			this.lastVisual = {
+				anchor: clonePosition(this.selectionAnchor),
+				cursor: clonePosition(this.buffer.cursor),
+				mode: this.inputMode,
+			};
+		}
+		this.selectionAnchor = null;
+		if (this.inputMode === "visual" || this.inputMode === "visual-line") {
+			this.inputMode = "normal";
+		}
+	}
+
+	async #ensureEditable(): Promise<void> {
+		await this.#callbacks.beforeMutate(this.buffer);
+		this.diagnostics = undefined;
+		this.statusMessage = undefined;
+	}
+
+	#pushUndo(entry: VimUndoEntry, changeTokens?: readonly string[]): void {
+		if (snapshotEqual(entry.before, entry.after)) {
+			return;
+		}
+		this.#undoStack.push(entry);
+		this.#redoStack = [];
+		if (changeTokens && changeTokens.length > 0) {
+			this.#lastChangeTokens = [...changeTokens];
+		}
+	}
+
+	#beginPendingChange(prefixTokens: readonly string[], moveCursorLeftOnEscape: boolean): void {
+		this.#pendingChange = {
+			before: this.buffer.createSnapshot(),
+			tokens: [...prefixTokens],
+			moveCursorLeftOnEscape,
+			inserted: false,
+		};
+	}
+
+	#markPendingInserted(): void {
+		if (this.#pendingChange) {
+			this.#pendingChange.inserted = true;
+		}
+	}
+
+	#commitPendingChange(): void {
+		if (!this.#pendingChange) {
+			return;
+		}
+		const entry: VimUndoEntry = {
+			before: this.#pendingChange.before,
+			after: this.buffer.createSnapshot(),
+		};
+		this.#pushUndo(entry, this.#pendingChange.tokens);
+		this.#pendingChange = null;
+	}
+
+	async #applyAtomicChange(tokens: readonly string[], mutator: () => void): Promise<void> {
+		await this.#ensureEditable();
+		const before = this.buffer.createSnapshot();
+		mutator();
+		this.buffer.modified = true;
+		this.#pushUndo({ before, after: this.buffer.createSnapshot() }, tokens);
+	}
+
+	async #startInsertChange(
+		tokens: readonly string[],
+		mutator?: () => void,
+		moveCursorLeftOnEscape = true,
+	): Promise<void> {
+		await this.#ensureEditable();
+		this.#beginPendingChange(tokens, moveCursorLeftOnEscape);
+		mutator?.();
+		this.buffer.modified = true;
+		this.inputMode = "insert";
+	}
+
+	async #executePrompt(tokens: readonly VimKeyToken[], index: number): Promise<number> {
+		const token = tokens[index]!;
+		if (token.value === "Esc") {
+			this.#pendingInput = "";
+			this.inputMode = "normal";
+			return index + 1;
+		}
+		if (token.value === "BS") {
+			this.#pendingInput = this.#pendingInput.slice(0, -1);
+			return index + 1;
+		}
+		if (token.value !== "CR") {
+			this.#pendingInput += token.value === "Tab" ? "\t" : token.value;
+			return index + 1;
+		}
+
+		const input = this.#pendingInput;
+		this.#pendingInput = "";
+		const mode = this.inputMode;
+		this.inputMode = "normal";
+		if (mode === "command") {
+			await this.#executeEx(input);
+		} else {
+			await this.#runSearch(input, mode === "search-forward" ? 1 : -1, true);
+		}
+		return index + 1;
+	}
+
+	#exitInsertMode(): void {
+		if (this.#pendingChange) {
+			this.#pendingChange.tokens.push("Esc");
+			if (this.#pendingChange.moveCursorLeftOnEscape && this.#pendingChange.inserted && this.buffer.cursor.col > 0) {
+				this.buffer.setCursor({ line: this.buffer.cursor.line, col: this.buffer.cursor.col - 1 });
+			}
+		}
+		this.inputMode = "normal";
+		this.#commitPendingChange();
+	}
+
+	async applyLiteralInsert(text: string, exitInsertMode: boolean): Promise<void> {
+		if (this.inputMode !== "insert" || !this.#pendingChange) {
+			throw new VimError("Insert payload requires INSERT mode.");
+		}
+
+		if (text.length > 0) {
+			const offset = this.buffer.currentOffset();
+			this.buffer.replaceOffsets(offset, offset, text, offset + text.length);
+			this.buffer.modified = true;
+			if (text.includes("\n")) {
+				this.buffer.trailingNewline = this.buffer.trailingNewline || text.endsWith("\n");
+			}
+			this.#pendingChange.tokens.push(...literalTextToReplayTokens(text));
+			this.#markPendingInserted();
+		}
+
+		if (exitInsertMode) {
+			this.#exitInsertMode();
+		}
+	}
+
+	async #executeInsert(tokens: readonly VimKeyToken[], index: number): Promise<number> {
+		const token = tokens[index]!;
+		if (token.value === "Esc") {
+			this.#exitInsertMode();
+			return index + 1;
+		}
+		if (token.value === "CR") {
+			const offset = this.buffer.currentOffset();
+			this.buffer.replaceOffsets(offset, offset, "\n", offset + 1);
+			this.buffer.modified = true;
+			this.buffer.trailingNewline = true;
+			this.#pendingChange?.tokens.push(token.value);
+			this.#markPendingInserted();
+			return index + 1;
+		}
+		if (token.value === "BS") {
+			const offset = this.buffer.currentOffset();
+			if (offset > 0) {
+				this.buffer.deleteOffsets(offset - 1, offset);
+				this.buffer.modified = true;
+				this.#pendingChange?.tokens.push(token.value);
+				this.#markPendingInserted();
+			}
+			return index + 1;
+		}
+		if (token.value === "Tab") {
+			const offset = this.buffer.currentOffset();
+			this.buffer.replaceOffsets(offset, offset, "\t", offset + 1);
+			this.buffer.modified = true;
+			this.#pendingChange?.tokens.push(token.value);
+			this.#markPendingInserted();
+			return index + 1;
+		}
+		if (token.value === "C-w") {
+			const offset = this.buffer.currentOffset();
+			const text = this.buffer.getText();
+			let start = previousWordStart(text, offset, false);
+			if (start === offset && start > 0) {
+				start -= 1;
+			}
+			this.buffer.deleteOffsets(start, offset);
+			this.buffer.modified = true;
+			this.#pendingChange?.tokens.push(token.value);
+			this.#markPendingInserted();
+			return index + 1;
+		}
+		if (token.value === "C-u") {
+			const offset = this.buffer.currentOffset();
+			const lineStart = this.buffer.positionToOffset({ line: this.buffer.cursor.line, col: 0 });
+			if (offset > lineStart) {
+				this.buffer.deleteOffsets(lineStart, offset);
+				this.buffer.modified = true;
+				this.#pendingChange?.tokens.push(token.value);
+				this.#markPendingInserted();
+			}
+			return index + 1;
+		}
+		if (token.value === "C-o") {
+			// Execute one normal-mode command, then return to insert
+			const nextToken = tokens[index + 1];
+			if (!nextToken) {
+				return index + 1;
+			}
+			const savedMode = this.inputMode;
+			this.inputMode = "normal";
+			const nextIdx = await this.#executeNormal(tokens, index + 1);
+			this.inputMode = savedMode;
+			return nextIdx;
+		}
+
+		const insertText = token.value;
+		const offset = this.buffer.currentOffset();
+		this.buffer.replaceOffsets(offset, offset, insertText, offset + insertText.length);
+		this.buffer.modified = true;
+		this.#pendingChange?.tokens.push(token.value);
+		this.#markPendingInserted();
+		return index + 1;
+	}
+
+	async #executeVisual(tokens: readonly VimKeyToken[], index: number): Promise<number> {
+		const token = tokens[index]!;
+		if (token.value === "Esc") {
+			this.#clearSelection();
+			return index + 1;
+		}
+		if (token.value === "v") {
+			if (this.inputMode === "visual") {
+				this.#clearSelection();
+			}
+			return index + 1;
+		}
+		if (token.value === "V") {
+			this.inputMode = this.inputMode === "visual-line" ? "visual" : "visual-line";
+			return index + 1;
+		}
+		if (token.value === "o") {
+			if (this.selectionAnchor) {
+				const tmp = clonePosition(this.buffer.cursor);
+				this.buffer.setCursor(this.selectionAnchor);
+				this.selectionAnchor = tmp;
+			}
+			return index + 1;
+		}
+		if (token.value === "J") {
+			const visual = expandVisualOffsets(
+				this.buffer,
+				this.selectionAnchor ?? this.buffer.cursor,
+				this.inputMode === "visual-line",
+			);
+			const startLine = this.buffer.offsetToPosition(visual.start).line;
+			const endLine = this.buffer.offsetToPosition(Math.max(visual.start, visual.end - 1)).line;
+			await this.#applyAtomicChange(["J"], () => {
+				this.buffer.joinLines(startLine, endLine - startLine);
+			});
+			this.#clearSelection();
+			return index + 1;
+		}
+		if (token.value === "u" || token.value === "U") {
+			const visual = expandVisualOffsets(
+				this.buffer,
+				this.selectionAnchor ?? this.buffer.cursor,
+				this.inputMode === "visual-line",
+			);
+			await this.#applyAtomicChange([token.value], () => {
+				const original = this.buffer.getText().slice(visual.start, visual.end);
+				const transformed = token.value === "U" ? original.toUpperCase() : original.toLowerCase();
+				this.buffer.replaceOffsets(visual.start, visual.end, transformed, visual.start);
+			});
+			this.#clearSelection();
+			return index + 1;
+		}
+		if (token.value === "p" || token.value === "P") {
+			const visual = expandVisualOffsets(
+				this.buffer,
+				this.selectionAnchor ?? this.buffer.cursor,
+				this.inputMode === "visual-line",
+			);
+			await this.#applyAtomicChange([token.value], () => {
+				const removed = this.buffer.getText().slice(visual.start, visual.end);
+				const pasteText = this.register.text;
+				this.buffer.replaceOffsets(visual.start, visual.end, pasteText, visual.start + pasteText.length);
+				this.register = { kind: visual.linewise ? "line" : "char", text: removed };
+			});
+			this.#clearSelection();
+			return index + 1;
+		}
+		if (token.value === "g") {
+			const next = tokens[index + 1];
+			if (!next) {
+				throw new VimError("g requires a second key", token);
+			}
+			if (next.value === "J") {
+				const visual = expandVisualOffsets(
+					this.buffer,
+					this.selectionAnchor ?? this.buffer.cursor,
+					this.inputMode === "visual-line",
+				);
+				const startLine = this.buffer.offsetToPosition(visual.start).line;
+				const endLine = this.buffer.offsetToPosition(Math.max(visual.start, visual.end - 1)).line;
+				await this.#applyAtomicChange(["g", "J"], () => {
+					const start = this.buffer.clampLine(startLine);
+					const end = this.buffer.clampLine(endLine);
+					if (start < end) {
+						const joined = this.buffer.lines.slice(start, end + 1).join("");
+						this.buffer.lines.splice(start, end - start + 1, joined);
+						this.buffer.setCursor({ line: start, col: Math.max(0, joined.length - 1) });
+					}
+				});
+				this.#clearSelection();
+				return index + 2;
+			}
+			if (next.value === "u" || next.value === "U" || next.value === "~") {
+				const visual = expandVisualOffsets(
+					this.buffer,
+					this.selectionAnchor ?? this.buffer.cursor,
+					this.inputMode === "visual-line",
+				);
+				await this.#applyAtomicChange(["g", next.value], () => {
+					const original = this.buffer.getText().slice(visual.start, visual.end);
+					const transformed =
+						next.value === "u"
+							? original.toLowerCase()
+							: next.value === "U"
+								? original.toUpperCase()
+								: toggleCase(original);
+					this.buffer.replaceOffsets(visual.start, visual.end, transformed, visual.start);
+				});
+				this.#clearSelection();
+				return index + 2;
+			}
+			throw new VimError(`Unsupported g command: g${next.display}`, next);
+		}
+
+		const { count, hasCount, nextIndex } = this.#readCount(tokens, index);
+		const opToken = tokens[nextIndex];
+		if (!opToken) {
+			return nextIndex;
+		}
+
+		switch (opToken.value) {
+			case "d":
+			case "x":
+			case "X":
+			case "D":
+			case "y":
+			case "c":
+			case "s":
+			case "S":
+			case "C":
+			case ">":
+			case "<":
+			case "~": {
+				const visual = expandVisualOffsets(
+					this.buffer,
+					this.selectionAnchor ?? this.buffer.cursor,
+					this.inputMode === "visual-line",
+				);
+				const consumeExtraIndent =
+					(opToken.value === ">" || opToken.value === "<") && tokens[nextIndex + 1]?.value === opToken.value;
+				const operatorValue =
+					opToken.value === "x" || opToken.value === "X" || opToken.value === "D"
+						? "d"
+						: opToken.value === "s" || opToken.value === "S" || opToken.value === "C"
+							? "c"
+							: opToken.value;
+				const visualTokens = consumeExtraIndent ? [opToken.value, opToken.value] : [opToken.value];
+				await this.#applyVisualOperator(operatorValue, visual, count, visualTokens);
+				return nextIndex + visualTokens.length;
+			}
+			case "r": {
+				const replacement = tokens[nextIndex + 1];
+				if (!replacement || replacement.value.length !== 1) {
+					throw new VimError("Visual replace requires a literal character", opToken);
+				}
+				const visual = expandVisualOffsets(
+					this.buffer,
+					this.selectionAnchor ?? this.buffer.cursor,
+					this.inputMode === "visual-line",
+				);
+				await this.#applyAtomicChange(["r", replacement.value], () => {
+					const original = this.buffer.getText().slice(visual.start, visual.end);
+					let replaced = "";
+					for (const char of original) {
+						replaced += char === "\n" ? "\n" : replacement.value;
+					}
+					this.buffer.replaceOffsets(visual.start, visual.end, replaced, visual.start);
+				});
+				this.#clearSelection();
+				return nextIndex + 2;
+			}
+			default:
+				break;
+		}
+
+		const motion = this.#resolveMotion(tokens, nextIndex, count, hasCount);
+		this.buffer.setCursor(motion.target);
+		return motion.nextIndex;
+	}
+
+	async #applyVisualOperator(
+		operator: string,
+		visual: { start: number; end: number; linewise: boolean },
+		count: number,
+		tokens: readonly string[],
+	): Promise<void> {
+		switch (operator) {
+			case "y": {
+				this.register = {
+					kind: visual.linewise ? "line" : "char",
+					text: this.buffer.getText().slice(visual.start, visual.end),
+				};
+				this.#clearSelection();
+				this.statusMessage = `Yanked ${count} selection${count === 1 ? "" : "s"}`;
+				return;
+			}
+			case "d": {
+				await this.#applyAtomicChange(tokens, () => {
+					this.#yankAndDeleteRange(visual);
+				});
+				this.#clearSelection();
+				return;
+			}
+			case "c": {
+				await this.#startInsertChange(tokens, () => {
+					this.#yankAndDeleteRange(visual);
+				});
+				this.#clearSelection();
+				return;
+			}
+			case ">":
+			case "<": {
+				const startLine = this.buffer.offsetToPosition(visual.start).line;
+				const endLine = this.buffer.offsetToPosition(Math.max(visual.start, visual.end - 1)).line;
+				await this.#applyAtomicChange(tokens, () => {
+					this.buffer.indentLines(
+						startLine,
+						endLine,
+						detectIndentUnit(this.buffer.lines),
+						operator === ">" ? 1 : -1,
+					);
+				});
+				this.#clearSelection();
+				return;
+			}
+			case "~": {
+				await this.#applyAtomicChange(tokens, () => {
+					const original = this.buffer.getText().slice(visual.start, visual.end);
+					this.buffer.replaceOffsets(visual.start, visual.end, toggleCase(original), visual.start);
+				});
+				this.#clearSelection();
+				return;
+			}
+			default:
+				throw new VimError(`Unsupported visual operator: ${operator}`);
+		}
+	}
+
+	async #executeNormal(tokens: readonly VimKeyToken[], index: number): Promise<number> {
+		const { count, hasCount, nextIndex } = this.#readCount(tokens, index);
+		const token = tokens[nextIndex];
+		if (!token) {
+			return nextIndex;
+		}
+
+		switch (token.value) {
+			case "h":
+				this.buffer.setCursor({ line: this.buffer.cursor.line, col: this.buffer.cursor.col - count });
+				return nextIndex + 1;
+			case "j":
+				this.buffer.setCursor({ line: this.buffer.cursor.line + count, col: this.buffer.cursor.col });
+				return nextIndex + 1;
+			case "k":
+				this.buffer.setCursor({ line: this.buffer.cursor.line - count, col: this.buffer.cursor.col });
+				return nextIndex + 1;
+			case "l":
+			case " ":
+				this.buffer.setCursor({ line: this.buffer.cursor.line, col: this.buffer.cursor.col + count });
+				return nextIndex + 1;
+			case "w":
+			case "W":
+			case "b":
+			case "B":
+			case "e":
+			case "E":
+			case "0":
+			case "$":
+			case "^":
+			case "|":
+			case ";":
+			case ",":
+			case "G":
+			case "f":
+			case "F":
+			case "t":
+			case "T":
+			case "{":
+			case "}":
+			case "%":
+			case "H":
+			case "M":
+			case "+":
+			case "-":
+			case "_":
+			case "L": {
+				const motion = this.#resolveMotion(tokens, nextIndex, count, hasCount);
+				this.buffer.setCursor(motion.target);
+				return motion.nextIndex;
+			}
+			case "*":
+			case "#": {
+				const text = this.buffer.getText();
+				const offset = this.buffer.currentOffset();
+				const cat = wordCategory(text[offset] ?? "", false);
+				if (cat === "space") {
+					throw new VimError("No word under cursor", token);
+				}
+				let start = offset;
+				while (start > 0 && wordCategory(text[start - 1] ?? "", false) === cat) start -= 1;
+				let end = offset;
+				while (end < text.length && wordCategory(text[end] ?? "", false) === cat) end += 1;
+				const word = text.slice(start, end);
+				const pattern = `\\b${escapeRegex(word)}\\b`;
+				const direction = token.value === "*" ? 1 : -1;
+				for (let step = 0; step < count; step += 1) {
+					await this.#runSearch(pattern, direction, true);
+				}
+				return nextIndex + 1;
+			}
+			case "n":
+				await this.#repeatSearch(this.lastSearch?.direction ?? 1, count);
+				return nextIndex + 1;
+			case "N":
+				await this.#repeatSearch(((this.lastSearch?.direction ?? 1) * -1) as 1 | -1, count);
+				return nextIndex + 1;
+			case "/":
+				this.inputMode = "search-forward";
+				this.#pendingInput = "";
+				return nextIndex + 1;
+			case "?":
+				this.inputMode = "search-backward";
+				this.#pendingInput = "";
+				return nextIndex + 1;
+			case ":":
+				this.inputMode = "command";
+				this.#pendingInput = "";
+				return nextIndex + 1;
+			case "v":
+				this.inputMode = "visual";
+				this.selectionAnchor = clonePosition(this.buffer.cursor);
+				return nextIndex + 1;
+			case "V":
+				this.inputMode = "visual-line";
+				this.selectionAnchor = clonePosition(this.buffer.cursor);
+				return nextIndex + 1;
+			case "i":
+				// When count > 1 (e.g. `2i`), interpret as `2Gi` — go to line N then insert.
+				// Models confuse `Ni` with `NGi`; bare `i` with a high count is almost never intended.
+				if (hasCount) {
+					this.buffer.setCursor({ line: Math.min(count, this.buffer.lineCount()) - 1, col: 0 });
+				}
+				await this.#startInsertChange(["i"]);
+				return nextIndex + 1;
+			case "a":
+				this.buffer.setCursor({ line: this.buffer.cursor.line, col: this.buffer.cursor.col + 1 });
+				await this.#startInsertChange(["a"]);
+				return nextIndex + 1;
+			case "I":
+				this.buffer.setCursor({
+					line: this.buffer.cursor.line,
+					col: this.buffer.firstNonBlank(this.buffer.cursor.line),
+				});
+				await this.#startInsertChange(["I"]);
+				return nextIndex + 1;
+			case "A":
+				this.buffer.setCursor({
+					line: this.buffer.cursor.line,
+					col: this.buffer.getLine(this.buffer.cursor.line).length,
+				});
+				await this.#startInsertChange(["A"]);
+				return nextIndex + 1;
+			case "o":
+				// When count > 1 (e.g. `13o`), interpret as `13Go` — go to line N then open below.
+				// Models confuse `No` with `NGo`; bare `o` with a high count is almost never intended.
+				if (hasCount) {
+					this.buffer.setCursor({ line: Math.min(count, this.buffer.lineCount()) - 1, col: 0 });
+				}
+				await this.#startInsertChange(["o"], () => {
+					const line = this.buffer.cursor.line + 1;
+					this.buffer.insertLines(line, [""]);
+				});
+				return nextIndex + 1;
+			case "O":
+				if (hasCount) {
+					this.buffer.setCursor({ line: Math.min(count, this.buffer.lineCount()) - 1, col: 0 });
+				}
+				await this.#startInsertChange(["O"], () => {
+					const line = this.buffer.cursor.line;
+					this.buffer.insertLines(line, [""]);
+				});
+				return nextIndex + 1;
+			case "s":
+				await this.#startInsertChange(["s"], () => {
+					this.#deleteCharsForward(count);
+				});
+				return nextIndex + 1;
+			case "S":
+				await this.#changeWholeLines(count, ["S"]);
+				return nextIndex + 1;
+			case "x":
+				await this.#applyAtomicChange(["x"], () => {
+					this.#deleteCharsForward(count);
+				});
+				return nextIndex + 1;
+			case "X":
+				await this.#applyAtomicChange(["X"], () => {
+					const end = this.buffer.currentOffset();
+					const start = Math.max(0, end - count);
+					this.register = { kind: "char", text: this.buffer.deleteOffsets(start, end) };
+				});
+				return nextIndex + 1;
+			case "r": {
+				const replacement = tokens[nextIndex + 1];
+				if (!replacement || replacement.value.length !== 1) {
+					throw new VimError("r requires a replacement character", token);
+				}
+				await this.#applyAtomicChange(["r", replacement.value], () => {
+					const start = this.buffer.currentOffset();
+					this.buffer.replaceOffsets(
+						start,
+						Math.min(this.buffer.getText().length, start + count),
+						replacement.value.repeat(count),
+						start,
+					);
+				});
+				return nextIndex + 2;
+			}
+			case "~":
+				await this.#applyAtomicChange(["~"], () => {
+					const start = this.buffer.currentOffset();
+					const end = Math.min(this.buffer.getText().length, start + count);
+					const text = this.buffer.getText().slice(start, end);
+					this.buffer.replaceOffsets(start, end, toggleCase(text), end);
+				});
+				return nextIndex + 1;
+			case "J":
+				await this.#applyAtomicChange(["J"], () => {
+					this.buffer.joinLines(this.buffer.cursor.line, count);
+				});
+				return nextIndex + 1;
+			case "p":
+			case "P":
+				await this.#applyAtomicChange([token.value], () => {
+					this.#paste(token.value === "p", count);
+				});
+				return nextIndex + 1;
+			case "u":
+				await this.#undo(count);
+				return nextIndex + 1;
+			case "C-r":
+				await this.#redo(count);
+				return nextIndex + 1;
+			case ".":
+				await this.#repeatLastChange(count, token);
+				return nextIndex + 1;
+			case "d":
+			case "c":
+			case "y":
+			case ">":
+			case "<":
+				return this.#executeOperator(tokens, nextIndex, count, hasCount, token.value);
+			case "D":
+				await this.#applyAtomicChange(["D"], () => {
+					const start = this.buffer.currentOffset();
+					const line = this.buffer.getLine(this.buffer.cursor.line);
+					const end = start + (line.length - this.buffer.cursor.col);
+					this.register = { kind: "char", text: this.buffer.deleteOffsets(start, end) };
+				});
+				return nextIndex + 1;
+			case "C":
+				await this.#startInsertChange(["C"], () => {
+					const start = this.buffer.currentOffset();
+					const line = this.buffer.getLine(this.buffer.cursor.line);
+					const end = start + (line.length - this.buffer.cursor.col);
+					this.register = { kind: "char", text: this.buffer.deleteOffsets(start, end) };
+				});
+				return nextIndex + 1;
+			case "z": {
+				const zTarget = tokens[nextIndex + 1];
+				if (!zTarget) {
+					throw new VimError("z requires a second key", token);
+				}
+				if (zTarget.value === "z") {
+					this.centerViewportOnCursor();
+				} else if (zTarget.value === "t" || zTarget.value === "CR") {
+					this.viewportStart = this.buffer.cursor.line + 1;
+					this.buffer.setCursor({
+						line: this.buffer.cursor.line,
+						col: this.buffer.firstNonBlank(this.buffer.cursor.line),
+					});
+				} else if (zTarget.value === "b" || zTarget.value === "-") {
+					this.viewportStart = Math.max(1, this.buffer.cursor.line + 1 - (DEFAULT_VIEWPORT_HEIGHT - 1));
+					this.buffer.setCursor({
+						line: this.buffer.cursor.line,
+						col: this.buffer.firstNonBlank(this.buffer.cursor.line),
+					});
+				} else if (zTarget.value === ".") {
+					this.centerViewportOnCursor();
+					this.buffer.setCursor({
+						line: this.buffer.cursor.line,
+						col: this.buffer.firstNonBlank(this.buffer.cursor.line),
+					});
+				} else if (NOOP_Z_COMMANDS.has(zTarget.value)) {
+					this.statusMessage = `Ignored z${zTarget.display} (folds unsupported)`;
+				} else {
+					throw new VimError(`Unsupported z command: z${zTarget.display}`, zTarget);
+				}
+				return nextIndex + 2;
+			}
+			case "C-f":
+				this.buffer.setCursor({
+					line: this.buffer.cursor.line + Math.max(1, (DEFAULT_VIEWPORT_HEIGHT - 2) * count),
+					col: this.buffer.cursor.col,
+				});
+				return nextIndex + 1;
+			case "C-b":
+				this.buffer.setCursor({
+					line: this.buffer.cursor.line - Math.max(1, (DEFAULT_VIEWPORT_HEIGHT - 2) * count),
+					col: this.buffer.cursor.col,
+				});
+				return nextIndex + 1;
+			case "C-d":
+				this.buffer.setCursor({
+					line: this.buffer.cursor.line + Math.max(1, Math.floor(DEFAULT_VIEWPORT_HEIGHT / 2) * count),
+					col: this.buffer.cursor.col,
+				});
+				return nextIndex + 1;
+			case "C-u":
+				this.buffer.setCursor({
+					line: this.buffer.cursor.line - Math.max(1, Math.floor(DEFAULT_VIEWPORT_HEIGHT / 2) * count),
+					col: this.buffer.cursor.col,
+				});
+				return nextIndex + 1;
+			case "Esc":
+				return nextIndex + 1;
+			case "Y": {
+				const start = this.buffer.cursor.line;
+				const end = this.buffer.clampLine(start + count - 1);
+				this.register = { kind: "line", text: this.buffer.lines.slice(start, end + 1).join("\n") };
+				this.statusMessage = `Yanked ${end - start + 1} line${end === start ? "" : "s"}`;
+				return nextIndex + 1;
+			}
+			case "R":
+				await this.#startInsertChange(["R"], undefined, false);
+				return nextIndex + 1;
+			case "g": {
+				const gNext = tokens[nextIndex + 1];
+				if (!gNext) {
+					throw new VimError("g requires a second key", token);
+				}
+				if (gNext.value === "g") {
+					this.buffer.setCursor({ line: hasCount ? Math.max(0, count - 1) : 0, col: 0 });
+					return nextIndex + 2;
+				}
+				if (gNext.value === "v") {
+					if (this.lastVisual) {
+						this.selectionAnchor = clonePosition(this.lastVisual.anchor);
+						this.buffer.setCursor(this.lastVisual.cursor);
+						this.inputMode = this.lastVisual.mode;
+					}
+					return nextIndex + 2;
+				}
+				if (gNext.value === "*" || gNext.value === "#") {
+					const text = this.buffer.getText();
+					const offset = this.buffer.currentOffset();
+					const cat = wordCategory(text[offset] ?? "", false);
+					if (cat === "space") {
+						throw new VimError("No word under cursor", gNext);
+					}
+					let start = offset;
+					while (start > 0 && wordCategory(text[start - 1] ?? "", false) === cat) start -= 1;
+					let end = offset;
+					while (end < text.length && wordCategory(text[end] ?? "", false) === cat) end += 1;
+					const word = text.slice(start, end);
+					const direction = gNext.value === "*" ? 1 : -1;
+					for (let step = 0; step < count; step += 1) {
+						await this.#runSearch(escapeRegex(word), direction, true);
+					}
+					return nextIndex + 2;
+				}
+				if (gNext.value === "U" || gNext.value === "u") {
+					const caseOp = gNext.value;
+					const {
+						count: motionCount,
+						hasCount: hasMotionCount,
+						nextIndex: motionStart,
+					} = this.#readCount(tokens, nextIndex + 2);
+					const motionToken = tokens[motionStart];
+					if (!motionToken) {
+						throw new VimError(`g${caseOp} requires a motion`, gNext);
+					}
+					if ((motionToken.value === "U" && caseOp === "U") || (motionToken.value === "u" && caseOp === "u")) {
+						const effectiveCount = hasMotionCount ? count * motionCount : count;
+						await this.#applyAtomicChange(["g", caseOp, motionToken.value], () => {
+							const start = this.buffer.cursor.line;
+							const end = this.buffer.clampLine(start + effectiveCount - 1);
+							for (let line = start; line <= end; line++) {
+								const content = this.buffer.getLine(line);
+								this.buffer.replaceLine(line, caseOp === "U" ? content.toUpperCase() : content.toLowerCase());
+							}
+						});
+						return motionStart + 1;
+					}
+					const effectiveCount = hasMotionCount ? count * motionCount : count;
+					const motion = this.#resolveMotion(tokens, motionStart, effectiveCount, hasCount || hasMotionCount);
+					const range = this.#resolveMotionRange(motion);
+					await this.#applyAtomicChange(
+						tokens.slice(nextIndex, motion.nextIndex).map(tokenEntry => tokenEntry.value),
+						() => {
+							const text = this.buffer.getText();
+							const slice = text.slice(range.start, range.end);
+							const transformed = caseOp === "U" ? slice.toUpperCase() : slice.toLowerCase();
+							this.buffer.replaceOffsets(range.start, range.end, transformed, range.start);
+						},
+					);
+					return motion.nextIndex;
+				}
+				if (gNext.value === "~") {
+					const {
+						count: motionCount,
+						hasCount: hasMotionCount,
+						nextIndex: motionStart,
+					} = this.#readCount(tokens, nextIndex + 2);
+					const motionToken = tokens[motionStart];
+					if (!motionToken) {
+						throw new VimError("g~ requires a motion", gNext);
+					}
+					if (motionToken.value === "~") {
+						const effectiveCount = hasMotionCount ? count * motionCount : count;
+						await this.#applyAtomicChange(["g", "~", motionToken.value], () => {
+							const start = this.buffer.cursor.line;
+							const end = this.buffer.clampLine(start + effectiveCount - 1);
+							for (let line = start; line <= end; line += 1) {
+								this.buffer.replaceLine(line, toggleCase(this.buffer.getLine(line)));
+							}
+						});
+						return motionStart + 1;
+					}
+					const effectiveCount = hasMotionCount ? count * motionCount : count;
+					const motion = this.#resolveMotion(tokens, motionStart, effectiveCount, hasCount || hasMotionCount);
+					const range = this.#resolveMotionRange(motion);
+					await this.#applyAtomicChange(
+						tokens.slice(nextIndex, motion.nextIndex).map(tokenEntry => tokenEntry.value),
+						() => {
+							const text = this.buffer.getText();
+							const slice = text.slice(range.start, range.end);
+							this.buffer.replaceOffsets(range.start, range.end, toggleCase(slice), range.start);
+						},
+					);
+					return motion.nextIndex;
+				}
+				if (gNext.value === "J") {
+					await this.#applyAtomicChange(["g", "J"], () => {
+						const start = this.buffer.clampLine(this.buffer.cursor.line);
+						const end = this.buffer.clampLine(start + Math.max(count, 1));
+						if (start < end) {
+							const joined = this.buffer.lines.slice(start, end + 1).join("");
+							this.buffer.lines.splice(start, end - start + 1, joined);
+							this.buffer.setCursor({ line: start, col: Math.max(0, joined.length - 1) });
+						}
+					});
+					return nextIndex + 2;
+				}
+				throw new VimError(`Unsupported g command: g${gNext.display}`, gNext);
+			}
+			case "Z": {
+				const zNext = tokens[nextIndex + 1];
+				if (!zNext) {
+					throw new VimError("Z requires a second key", token);
+				}
+				if (zNext.value === "Z") {
+					await this.#executeEx("wq");
+					return nextIndex + 2;
+				}
+				if (zNext.value === "Q") {
+					await this.#executeEx("q!");
+					return nextIndex + 2;
+				}
+				throw new VimError(`Unsupported Z command: Z${zNext.display}`, zNext);
+			}
+			default:
+				throw new VimError(`Unsupported command: ${token.display}`, token);
+		}
+	}
+
+	async #repeatLastChange(count: number, token: VimKeyToken): Promise<void> {
+		if (!this.#lastChangeTokens || this.#lastChangeTokens.length === 0) {
+			throw new VimError("No previous change to repeat", token);
+		}
+		for (let index = 0; index < count; index += 1) {
+			await this.executeTokens(replayTokens(this.#lastChangeTokens), ".");
+		}
+	}
+
+	async #undo(count: number): Promise<void> {
+		await this.#ensureEditable();
+		let applied = 0;
+		for (let index = 0; index < count; index += 1) {
+			const entry = this.#undoStack.pop();
+			if (!entry) {
+				break;
+			}
+			this.#redoStack.push(entry);
+			this.buffer.restore(entry.before);
+			applied += 1;
+		}
+		this.inputMode = "normal";
+		this.selectionAnchor = null;
+		this.#pendingChange = null;
+		this.statusMessage = `Undid ${applied} change${applied === 1 ? "" : "s"}`;
+	}
+
+	async #redo(count: number): Promise<void> {
+		await this.#ensureEditable();
+		let applied = 0;
+		for (let index = 0; index < count; index += 1) {
+			const entry = this.#redoStack.pop();
+			if (!entry) {
+				break;
+			}
+			this.#undoStack.push(entry);
+			this.buffer.restore(entry.after);
+			applied += 1;
+		}
+		this.inputMode = "normal";
+		this.selectionAnchor = null;
+		this.#pendingChange = null;
+		this.statusMessage = `Redid ${applied} change${applied === 1 ? "" : "s"}`;
+	}
+
+	async #executeOperator(
+		tokens: readonly VimKeyToken[],
+		operatorIndex: number,
+		operatorCount: number,
+		hasOperatorCount: boolean,
+		operator: string,
+	): Promise<number> {
+		const { count: motionCount, hasCount: hasMotionCount, nextIndex } = this.#readCount(tokens, operatorIndex + 1);
+		const token = tokens[nextIndex];
+		if (!token) {
+			throw new VimError(`Operator ${operator} requires a motion`, tokens[operatorIndex]);
+		}
+		const hasAnyCount = hasOperatorCount || hasMotionCount;
+		const effectiveCount = hasMotionCount ? operatorCount * motionCount : operatorCount;
+
+		if (token.value === operator) {
+			if (operator === "d") {
+				await this.#applyAtomicChange([operator, operator], () => {
+					const start = this.buffer.cursor.line;
+					const removed = this.buffer.deleteLines(start, start + Math.max(1, effectiveCount) - 1);
+					this.register = { kind: "line", text: removed.join("\n") };
+				});
+				return nextIndex + 1;
+			}
+			if (operator === "y") {
+				const start = this.buffer.cursor.line;
+				const end = this.buffer.clampLine(start + Math.max(1, effectiveCount) - 1);
+				this.register = { kind: "line", text: this.buffer.lines.slice(start, end + 1).join("\n") };
+				this.statusMessage = `Yanked ${end - start + 1} line${end === start ? "" : "s"}`;
+				return nextIndex + 1;
+			}
+			if (operator === "c") {
+				await this.#changeWholeLines(Math.max(1, effectiveCount), [operator, operator]);
+				return nextIndex + 1;
+			}
+			if (operator === ">" || operator === "<") {
+				await this.#applyAtomicChange([operator, operator], () => {
+					this.buffer.indentLines(
+						this.buffer.cursor.line,
+						this.buffer.cursor.line + Math.max(1, effectiveCount) - 1,
+						detectIndentUnit(this.buffer.lines),
+						operator === ">" ? 1 : -1,
+					);
+				});
+				return nextIndex + 1;
+			}
+		}
+
+		if (token.value === "i" || token.value === "a") {
+			const object = tokens[nextIndex + 1];
+			if (!object) {
+				throw new VimError(`Missing text object after ${operator}${token.value}`, token);
+			}
+			const textObject = this.#resolveTextObject(token.value === "i", object.value, object);
+			await this.#applyOperatorToMotion(
+				operator,
+				{ nextIndex: nextIndex + 2, target: this.buffer.cursor, range: textObject },
+				[operator, token.value, object.value],
+			);
+			return nextIndex + 2;
+		}
+
+		// In vim, `cw` and `cW` act like `ce` and `cE` (don't include trailing whitespace)
+		const motionToken = tokens[nextIndex];
+		let motion: MotionResult;
+		if (operator === "c" && motionToken && (motionToken.value === "w" || motionToken.value === "W")) {
+			const eMotionValue = motionToken.value === "w" ? "e" : "E";
+			const syntheticTokens: readonly VimKeyToken[] = [
+				...tokens.slice(0, nextIndex),
+				{ ...motionToken, value: eMotionValue },
+				...tokens.slice(nextIndex + 1),
+			];
+			motion = this.#resolveMotion(syntheticTokens, nextIndex, effectiveCount, hasAnyCount);
+		} else {
+			motion = this.#resolveMotion(tokens, nextIndex, effectiveCount, hasAnyCount);
+		}
+		await this.#applyOperatorToMotion(
+			operator,
+			motion,
+			tokens.slice(operatorIndex, motion.nextIndex).map(tokenEntry => tokenEntry.value),
+		);
+		return motion.nextIndex;
+	}
+
+	async #applyOperatorToMotion(operator: string, motion: MotionResult, tokens: readonly string[]): Promise<void> {
+		if (operator === "y") {
+			const range = this.#resolveMotionRange(motion);
+			this.register = {
+				kind: range.linewise ? "line" : "char",
+				text: this.buffer.getText().slice(range.start, range.end),
+			};
+			this.statusMessage = `Yanked ${range.linewise ? "line" : "selection"}`;
+			return;
+		}
+
+		if (operator === ">" || operator === "<") {
+			const range = this.#resolveMotionRange(motion);
+			const startLine = this.buffer.offsetToPosition(range.start).line;
+			const endLine = this.buffer.offsetToPosition(Math.max(range.start, range.end - 1)).line;
+			await this.#applyAtomicChange(tokens, () => {
+				this.buffer.indentLines(startLine, endLine, detectIndentUnit(this.buffer.lines), operator === ">" ? 1 : -1);
+			});
+			return;
+		}
+
+		if (operator === "d") {
+			const range = this.#resolveMotionRange(motion);
+			await this.#applyAtomicChange(tokens, () => {
+				this.#yankAndDeleteRange(range);
+			});
+			return;
+		}
+
+		if (operator === "c") {
+			const range = this.#resolveMotionRange(motion);
+			await this.#startInsertChange(tokens, () => {
+				this.#yankAndDeleteRange(range);
+			});
+			return;
+		}
+	}
+
+	#yankAndDeleteRange(range: { start: number; end: number; linewise: boolean }): void {
+		this.register = {
+			kind: range.linewise ? "line" : "char",
+			text: this.buffer.getText().slice(range.start, range.end),
+		};
+		this.buffer.deleteOffsets(range.start, range.end);
+	}
+
+	#deleteCharsForward(count: number): void {
+		const start = this.buffer.currentOffset();
+		this.register = {
+			kind: "char",
+			text: this.buffer.deleteOffsets(start, Math.min(this.buffer.getText().length, start + count)),
+		};
+	}
+
+	async #changeWholeLines(count: number, tokens: readonly string[]): Promise<void> {
+		await this.#startInsertChange(tokens, () => {
+			const start = this.buffer.cursor.line;
+			const end = this.buffer.clampLine(start + count - 1);
+			const removed = this.buffer.lines.slice(start, end + 1);
+			this.register = { kind: "line", text: removed.join("\n") };
+			this.buffer.lines.splice(start, end - start + 1, "");
+			if (this.buffer.lines.length === 0) {
+				this.buffer.lines = [""];
+			}
+			this.buffer.setCursor({ line: Math.min(start, this.buffer.lastLineIndex()), col: 0 });
+		});
+	}
+
+	#resolveMotionRange(motion: MotionResult): { start: number; end: number; linewise: boolean } {
+		if (motion.range) {
+			return {
+				start: motion.range.start,
+				end: motion.range.end,
+				linewise: motion.range.linewise ?? false,
+			};
+		}
+
+		if (motion.linewise) {
+			const startLine = Math.min(this.buffer.cursor.line, motion.target.line);
+			const endLine = Math.max(this.buffer.cursor.line, motion.target.line);
+			const start = this.buffer.positionToOffset({ line: startLine, col: 0 });
+			const end =
+				endLine >= this.buffer.lastLineIndex()
+					? this.buffer.getText().length
+					: this.buffer.positionToOffset({ line: endLine + 1, col: 0 });
+			return { start, end, linewise: true };
+		}
+
+		const from = this.buffer.positionToOffset(this.buffer.cursor);
+		const to = this.buffer.positionToOffset(motion.target);
+		const normalized = normalizeRange(from, to);
+		return {
+			start: normalized.start,
+			end: normalized.end + (motion.inclusive === false ? 0 : 1),
+			linewise: false,
+		};
+	}
+
+	#resolveMotion(tokens: readonly VimKeyToken[], index: number, count: number, hasCount = true): MotionResult {
+		const token = tokens[index];
+		if (!token) {
+			throw new VimError("Missing motion");
+		}
+
+		const text = this.buffer.getText();
+		switch (token.value) {
+			case "h":
+				return {
+					nextIndex: index + 1,
+					target: { line: this.buffer.cursor.line, col: this.buffer.cursor.col - count },
+				};
+			case "j":
+				return {
+					nextIndex: index + 1,
+					target: { line: this.buffer.cursor.line + count, col: this.buffer.cursor.col },
+					linewise: true,
+				};
+			case "k":
+				return {
+					nextIndex: index + 1,
+					target: { line: this.buffer.cursor.line - count, col: this.buffer.cursor.col },
+					linewise: true,
+				};
+			case "l":
+			case " ":
+				return {
+					nextIndex: index + 1,
+					target: { line: this.buffer.cursor.line, col: this.buffer.cursor.col + count },
+				};
+			case "w":
+			case "W": {
+				let offset = this.buffer.currentOffset();
+				for (let step = 0; step < count; step += 1) {
+					offset = nextWordStart(text, step === 0 ? offset + 1 : offset, token.value === "W");
+				}
+				return { nextIndex: index + 1, target: this.buffer.offsetToPosition(offset), inclusive: false };
+			}
+			case "b":
+			case "B": {
+				let offset = this.buffer.currentOffset();
+				for (let step = 0; step < count; step += 1) {
+					offset = previousWordStart(text, offset, token.value === "B");
+				}
+				return { nextIndex: index + 1, target: this.buffer.offsetToPosition(offset) };
+			}
+			case "e":
+			case "E": {
+				let offset = this.buffer.currentOffset();
+				for (let step = 0; step < count; step += 1) {
+					offset = endOfWord(text, step === 0 ? offset : offset + 1, token.value === "E");
+				}
+				return { nextIndex: index + 1, target: this.buffer.offsetToPosition(offset) };
+			}
+			case "0":
+				return { nextIndex: index + 1, target: { line: this.buffer.cursor.line, col: 0 } };
+			case "^":
+				return {
+					nextIndex: index + 1,
+					target: { line: this.buffer.cursor.line, col: this.buffer.firstNonBlank(this.buffer.cursor.line) },
+				};
+			case "|":
+				return {
+					nextIndex: index + 1,
+					target: { line: this.buffer.cursor.line, col: Math.max(0, count - 1) },
+				};
+			case "$":
+				return {
+					nextIndex: index + 1,
+					target: {
+						line: this.buffer.cursor.line,
+						col: Math.max(0, this.buffer.getLine(this.buffer.cursor.line).length - 1),
+					},
+				};
+			case "+": {
+				const targetLine = this.buffer.clampLine(this.buffer.cursor.line + count);
+				return {
+					nextIndex: index + 1,
+					target: { line: targetLine, col: this.buffer.firstNonBlank(targetLine) },
+					linewise: true,
+				};
+			}
+			case "-": {
+				const targetLine = this.buffer.clampLine(this.buffer.cursor.line - count);
+				return {
+					nextIndex: index + 1,
+					target: { line: targetLine, col: this.buffer.firstNonBlank(targetLine) },
+					linewise: true,
+				};
+			}
+			case "_": {
+				const targetLine = this.buffer.clampLine(this.buffer.cursor.line + (count - 1));
+				return {
+					nextIndex: index + 1,
+					target: { line: targetLine, col: this.buffer.firstNonBlank(targetLine) },
+					linewise: true,
+				};
+			}
+			case "g": {
+				const next = tokens[index + 1];
+				if (!next) {
+					throw new VimError("Unsupported g motion", token);
+				}
+				if (next.value === "g") {
+					return {
+						nextIndex: index + 2,
+						target: { line: hasCount ? Math.max(0, count - 1) : 0, col: 0 },
+						linewise: true,
+					};
+				}
+				if (next.value === "e" || next.value === "E") {
+					let offset = this.buffer.currentOffset();
+					for (let step = 0; step < count; step += 1) {
+						offset = endOfPreviousWord(text, offset, next.value === "E");
+					}
+					return { nextIndex: index + 2, target: this.buffer.offsetToPosition(offset) };
+				}
+				if (next.value === "_") {
+					const targetLine = this.buffer.clampLine(this.buffer.cursor.line + (count - 1));
+					return {
+						nextIndex: index + 2,
+						target: { line: targetLine, col: lastNonBlankColumn(this.buffer.getLine(targetLine)) },
+					};
+				}
+				throw new VimError("Unsupported g motion", token);
+			}
+			case "G":
+				return {
+					nextIndex: index + 1,
+					target: { line: hasCount ? count - 1 : this.buffer.lastLineIndex(), col: 0 },
+					linewise: true,
+				};
+			case "f":
+			case "F":
+			case "t":
+			case "T": {
+				const searchToken = tokens[index + 1];
+				if (!searchToken || searchToken.value.length !== 1) {
+					throw new VimError(`${token.value} requires a literal character`, token);
+				}
+				this.lastCharFind = { char: searchToken.value, mode: token.value as "f" | "F" | "t" | "T" };
+				const line = this.buffer.getLine(this.buffer.cursor.line);
+				const cursorCol = this.buffer.cursor.col;
+				let matchIndex = -1;
+				if (token.value === "f" || token.value === "t") {
+					let start = cursorCol + 1;
+					for (let step = 0; step < count; step += 1) {
+						matchIndex = line.indexOf(searchToken.value, start);
+						if (matchIndex === -1) break;
+						start = matchIndex + 1;
+					}
+					if (matchIndex === -1) {
+						throw new VimError(`Character not found: ${searchToken.value}`, searchToken);
+					}
+					if (token.value === "t") {
+						matchIndex -= 1;
+					}
+				} else {
+					let start = Math.max(0, cursorCol - 1);
+					for (let step = 0; step < count; step += 1) {
+						matchIndex = line.lastIndexOf(searchToken.value, start);
+						if (matchIndex === -1) break;
+						start = matchIndex - 1;
+					}
+					if (matchIndex === -1) {
+						throw new VimError(`Character not found: ${searchToken.value}`, searchToken);
+					}
+					if (token.value === "T") {
+						matchIndex += 1;
+					}
+				}
+				return {
+					nextIndex: index + 2,
+					target: { line: this.buffer.cursor.line, col: Math.max(0, matchIndex) },
+				};
+			}
+			case "{":
+				return {
+					nextIndex: index + 1,
+					target: { line: findParagraphStart(this.buffer.lines, this.buffer.cursor.line), col: 0 },
+					linewise: true,
+				};
+			case "}":
+				return {
+					nextIndex: index + 1,
+					target: { line: findParagraphEnd(this.buffer.lines, this.buffer.cursor.line), col: 0 },
+					linewise: true,
+				};
+			case "%": {
+				const match = this.#findMatchingBracket();
+				return { nextIndex: index + 1, target: match };
+			}
+			case "H":
+				return {
+					nextIndex: index + 1,
+					target: { line: Math.max(0, this.viewportStart - 1), col: 0 },
+					linewise: true,
+				};
+			case "M":
+				return {
+					nextIndex: index + 1,
+					target: { line: Math.max(0, this.viewportStart - 1 + 20), col: 0 },
+					linewise: true,
+				};
+			case "L":
+				return {
+					nextIndex: index + 1,
+					target: { line: Math.max(0, this.viewportStart - 1 + 39), col: 0 },
+					linewise: true,
+				};
+			case ";":
+			case ",": {
+				if (!this.lastCharFind) {
+					throw new VimError(
+						"No previous character search. If you meant an ex-command range like `:4,5d`, add the `:` prefix and `<CR>` suffix.",
+						token,
+					);
+				}
+				let mode = this.lastCharFind.mode;
+				if (token.value === ",") {
+					const reverseMap: Record<string, "f" | "F" | "t" | "T"> = { f: "F", F: "f", t: "T", T: "t" };
+					mode = reverseMap[mode]!;
+				}
+				const line = this.buffer.getLine(this.buffer.cursor.line);
+				const cursorCol = this.buffer.cursor.col;
+				let matchIndex = -1;
+				if (mode === "f" || mode === "t") {
+					let start = cursorCol + 1;
+					for (let step = 0; step < count; step += 1) {
+						matchIndex = line.indexOf(this.lastCharFind.char, start);
+						if (matchIndex === -1) break;
+						start = matchIndex + 1;
+					}
+					if (matchIndex !== -1 && mode === "t") matchIndex -= 1;
+				} else {
+					let start = Math.max(0, cursorCol - 1);
+					for (let step = 0; step < count; step += 1) {
+						matchIndex = line.lastIndexOf(this.lastCharFind.char, start);
+						if (matchIndex === -1) break;
+						start = matchIndex - 1;
+					}
+					if (matchIndex !== -1 && mode === "T") matchIndex += 1;
+				}
+				if (matchIndex === -1) {
+					throw new VimError(`Character not found: ${this.lastCharFind.char}`, token);
+				}
+				return {
+					nextIndex: index + 1,
+					target: { line: this.buffer.cursor.line, col: Math.max(0, matchIndex) },
+				};
+			}
+			default:
+				throw new VimError(`Unsupported motion: ${token.display}`, token);
+		}
+	}
+
+	#resolveTextObject(
+		inner: boolean,
+		objectToken: string,
+		sourceToken: VimKeyToken,
+	): { start: number; end: number; linewise?: boolean } {
+		if (objectToken === "w" || objectToken === "W") {
+			return this.#resolveWordTextObject(inner, objectToken === "W");
+		}
+		if (objectToken === '"' || objectToken === "'" || objectToken === "`") {
+			return this.#resolveQuoteTextObject(inner, objectToken, sourceToken);
+		}
+
+		if (objectToken === "p") {
+			return this.#resolveParagraphTextObject(inner);
+		}
+
+		const normalized =
+			objectToken === ")"
+				? "("
+				: objectToken === "}"
+					? "{"
+					: objectToken === "]"
+						? "["
+						: objectToken === ">"
+							? "<"
+							: objectToken;
+		if (!BRACKET_PAIRS.has(normalized)) {
+			throw new VimError(`Unsupported text object: ${objectToken}`, sourceToken);
+		}
+		return this.#resolveBracketTextObject(inner, normalized, sourceToken);
+	}
+
+	#resolveWordTextObject(inner: boolean, bigWord: boolean): { start: number; end: number } {
+		const text = this.buffer.getText();
+		const cursor = this.buffer.currentOffset();
+		let start = cursor;
+		if (wordCategory(text[start] ?? "", bigWord) === "space") {
+			start = nextWordStart(text, start, bigWord);
+		}
+		const category = wordCategory(text[start] ?? "", bigWord);
+		while (start > 0 && wordCategory(text[start - 1] ?? "", bigWord) === category) {
+			start -= 1;
+		}
+		let end = start;
+		while (end < text.length && wordCategory(text[end] ?? "", bigWord) === category) {
+			end += 1;
+		}
+		if (!inner) {
+			while (end < text.length && wordCategory(text[end] ?? "", bigWord) === "space") {
+				end += 1;
+			}
+			while (start > 0 && wordCategory(text[start - 1] ?? "", bigWord) === "space") {
+				start -= 1;
+			}
+		}
+		return { start, end };
+	}
+
+	#resolveParagraphTextObject(inner: boolean): { start: number; end: number; linewise: boolean } {
+		const lines = this.buffer.lines;
+		const cursorLine = this.buffer.cursor.line;
+		let start = cursorLine;
+		let end = cursorLine;
+		// Find paragraph boundaries (delimited by blank lines)
+		if (lines[cursorLine]?.trim().length === 0) {
+			// On a blank line: select contiguous blank lines
+			while (start > 0 && lines[start - 1]!.trim().length === 0) start -= 1;
+			while (end < lines.length - 1 && lines[end + 1]!.trim().length === 0) end += 1;
+			if (!inner) {
+				// Include following non-blank paragraph
+				while (end < lines.length - 1 && lines[end + 1]!.trim().length > 0) end += 1;
+			}
+		} else {
+			// On a non-blank line: select contiguous non-blank lines
+			while (start > 0 && lines[start - 1]!.trim().length > 0) start -= 1;
+			while (end < lines.length - 1 && lines[end + 1]!.trim().length > 0) end += 1;
+			if (!inner) {
+				// Include trailing blank lines
+				while (end < lines.length - 1 && lines[end + 1]!.trim().length === 0) end += 1;
+			}
+		}
+		const startOffset = this.buffer.positionToOffset({ line: start, col: 0 });
+		const endOffset =
+			end >= this.buffer.lastLineIndex()
+				? this.buffer.getText().length
+				: this.buffer.positionToOffset({ line: end + 1, col: 0 });
+		return { start: startOffset, end: endOffset, linewise: true };
+	}
+
+	#resolveQuoteTextObject(inner: boolean, quote: string, sourceToken: VimKeyToken): { start: number; end: number } {
+		const line = this.buffer.getLine(this.buffer.cursor.line);
+		const col = this.buffer.cursor.col;
+		const before = line.lastIndexOf(quote, col);
+		const after = line.indexOf(quote, col + (line[col] === quote ? 1 : 0));
+		if (before === -1 || after === -1 || before === after) {
+			throw new VimError(`Quote text object not found for ${quote}`, sourceToken);
+		}
+		const startCol = inner ? before + 1 : before;
+		const endCol = inner ? after : after + 1;
+		return {
+			start: this.buffer.positionToOffset({ line: this.buffer.cursor.line, col: startCol }),
+			end: this.buffer.positionToOffset({ line: this.buffer.cursor.line, col: endCol }),
+		};
+	}
+
+	#resolveBracketTextObject(inner: boolean, open: string, sourceToken: VimKeyToken): { start: number; end: number } {
+		const close = BRACKET_PAIRS.get(open)!;
+		const text = this.buffer.getText();
+		const cursor = this.buffer.currentOffset();
+		let start = -1;
+		let depth = 0;
+		for (let index = cursor; index >= 0; index -= 1) {
+			const char = text[index] ?? "";
+			if (char === close) {
+				depth += 1;
+			} else if (char === open) {
+				if (depth === 0) {
+					start = index;
+					break;
+				}
+				depth -= 1;
+			}
+		}
+		if (start === -1) {
+			throw new VimError(`Text object ${open}${close} not found`, sourceToken);
+		}
+		let end = -1;
+		depth = 0;
+		for (let index = start; index < text.length; index += 1) {
+			const char = text[index] ?? "";
+			if (char === open) {
+				depth += 1;
+			} else if (char === close) {
+				depth -= 1;
+				if (depth === 0) {
+					end = index;
+					break;
+				}
+			}
+		}
+		if (end === -1) {
+			throw new VimError(`Text object ${open}${close} not found`, sourceToken);
+		}
+		return {
+			start: inner ? start + 1 : start,
+			end: inner ? end : end + 1,
+		};
+	}
+
+	#findMatchingBracket(): Position {
+		const text = this.buffer.getText();
+		const cursor = this.buffer.currentOffset();
+		let offset = cursor;
+		let char = text[offset] ?? "";
+		if (!BRACKET_PAIRS.has(char) && !CLOSING_BRACKETS.has(char)) {
+			offset += 1;
+			char = text[offset] ?? "";
+		}
+		if (BRACKET_PAIRS.has(char)) {
+			const close = BRACKET_PAIRS.get(char)!;
+			let depth = 0;
+			for (let index = offset; index < text.length; index += 1) {
+				const current = text[index] ?? "";
+				if (current === char) depth += 1;
+				if (current === close) {
+					depth -= 1;
+					if (depth === 0) {
+						return this.buffer.offsetToPosition(index);
+					}
+				}
+			}
+		}
+		if (CLOSING_BRACKETS.has(char)) {
+			const open = CLOSING_BRACKETS.get(char)!;
+			let depth = 0;
+			for (let index = offset; index >= 0; index -= 1) {
+				const current = text[index] ?? "";
+				if (current === char) depth += 1;
+				if (current === open) {
+					depth -= 1;
+					if (depth === 0) {
+						return this.buffer.offsetToPosition(index);
+					}
+				}
+			}
+		}
+		throw new VimError("Matching bracket not found");
+	}
+
+	async #runSearch(pattern: string, direction: 1 | -1, updateState: boolean): Promise<void> {
+		const text = this.buffer.getText();
+		const regex = createSearchRegex(pattern, "g");
+		const cursor = this.buffer.currentOffset();
+		let matchOffset = -1;
+
+		if (direction > 0) {
+			regex.lastIndex = Math.min(text.length, cursor + 1);
+			const match = regex.exec(text);
+			if (match && match.index >= 0) {
+				matchOffset = match.index;
+			} else {
+				regex.lastIndex = 0;
+				const wrapMatch = regex.exec(text);
+				if (wrapMatch && wrapMatch.index >= 0) {
+					matchOffset = wrapMatch.index;
+				}
+			}
+		} else {
+			const matches = Array.from(text.matchAll(regex));
+			for (let index = matches.length - 1; index >= 0; index -= 1) {
+				const match = matches[index];
+				if ((match.index ?? -1) < cursor) {
+					matchOffset = match.index ?? -1;
+					break;
+				}
+			}
+			if (matchOffset === -1 && matches.length > 0) {
+				matchOffset = matches[matches.length - 1]?.index ?? -1;
+			}
+		}
+
+		if (matchOffset === -1) {
+			throw new VimError(`Pattern not found: ${pattern}`);
+		}
+
+		this.buffer.setCursor(this.buffer.offsetToPosition(matchOffset));
+		this.statusMessage = `${direction > 0 ? "/" : "?"}${pattern}`;
+		if (updateState) {
+			this.lastSearch = { pattern, direction };
+		}
+	}
+
+	async #repeatSearch(direction: 1 | -1, count: number): Promise<void> {
+		if (!this.lastSearch) {
+			throw new VimError("No previous search");
+		}
+		for (let index = 0; index < count; index += 1) {
+			await this.#runSearch(this.lastSearch.pattern, direction, false);
+		}
+		this.lastSearch = { pattern: this.lastSearch.pattern, direction };
+	}
+
+	#resolveExRange(
+		range: VimLineRange | "all" | undefined,
+		defaultStart: number,
+		defaultEnd = defaultStart,
+	): VimLineRange {
+		const totalLines = Math.max(1, this.buffer.lineCount());
+		if (range === "all") {
+			return { start: 1, end: totalLines };
+		}
+		const next = range ?? { start: defaultStart, end: defaultEnd };
+		const start = Math.max(1, Math.min(next.start, totalLines));
+		const end = Math.max(start, Math.min(next.end, totalLines));
+		return { start, end };
+	}
+
+	async #executeEx(input: string): Promise<void> {
+		const command = parseExCommand(input, {
+			currentLine: this.buffer.cursor.line + 1,
+			lastLine: this.buffer.lineCount(),
+		});
+		switch (command.kind) {
+			case "goto-line":
+				this.buffer.setCursor({ line: Math.max(0, command.line - 1), col: 0 });
+				this.statusMessage = `Line ${command.line}`;
+				return;
+			case "write": {
+				const result = await this.#callbacks.saveBuffer(this.buffer, { force: command.force });
+				this.buffer.markSaved(result.loaded);
+				this.diagnostics = result.diagnostics;
+				this.statusMessage = result.diagnostics
+					? `Wrote ${this.buffer.displayPath} (${result.diagnostics.summary})`
+					: `Wrote ${this.buffer.displayPath}`;
+				this.#undoStack = [];
+				this.#redoStack = [];
+				return;
+			}
+			case "update":
+				if (!this.buffer.modified) {
+					this.statusMessage = `${this.buffer.displayPath} unchanged`;
+					return;
+				}
+				await this.#executeEx(command.force ? "w!" : "w");
+				return;
+			case "write-quit":
+				await this.#executeEx(command.force ? "w!" : "w");
+				this.closed = true;
+				this.statusMessage = `Wrote and closed ${this.buffer.displayPath}`;
+				return;
+			case "quit":
+				if (this.buffer.modified && !command.force) {
+					throw new VimError("Unsaved changes; use :q! to discard");
+				}
+				this.closed = true;
+				this.statusMessage = `Closed ${this.buffer.displayPath}`;
+				return;
+			case "edit": {
+				if (this.buffer.modified && !command.force) {
+					throw new VimError("Unsaved changes; use :e! to reload or force open");
+				}
+				const next = await this.#callbacks.loadBuffer(command.path ?? this.buffer.displayPath);
+				this.buffer.replaceLoadedFile(next);
+				this.inputMode = "normal";
+				this.selectionAnchor = null;
+				this.#pendingInput = "";
+				this.#pendingChange = null;
+				this.#undoStack = [];
+				this.#redoStack = [];
+				this.statusMessage = command.path
+					? `Opened ${this.buffer.displayPath}`
+					: `Reloaded ${this.buffer.displayPath}`;
+				return;
+			}
+			case "substitute": {
+				const range = this.#resolveExRange(command.range, this.buffer.cursor.line + 1);
+				const startLine = range.start;
+				const endLine = range.end;
+				const regexFlags = command.flags.includes("i") ? "gi" : "g";
+				const regex = createSearchRegex(command.pattern, regexFlags);
+				let replacements = 0;
+				await this.#applyAtomicChange([":substitute"], () => {
+					for (let lineIndex = startLine - 1; lineIndex <= endLine - 1; lineIndex += 1) {
+						const line = this.buffer.getLine(lineIndex);
+						let lineReplacements = 0;
+						const nextLine = line.replace(regex, match => {
+							if (!command.flags.includes("g") && lineReplacements > 0) {
+								return match;
+							}
+							lineReplacements += 1;
+							replacements += 1;
+							return decodeReplacement(command.replacement).replace(/&/g, match);
+						});
+						this.buffer.replaceLine(lineIndex, nextLine);
+						regex.lastIndex = 0;
+					}
+				});
+				if (replacements === 0) {
+					throw new VimError(`Pattern not found: ${command.pattern}`);
+				}
+				this.statusMessage = `${replacements} substitution${replacements === 1 ? "" : "s"}`;
+				return;
+			}
+			case "delete": {
+				const range = this.#resolveExRange(command.range, this.buffer.cursor.line + 1);
+				await this.#applyAtomicChange([":delete"], () => {
+					const removed = this.buffer.deleteLines(range.start - 1, range.end - 1);
+					this.register = { kind: "line", text: removed.join("\n") };
+				});
+				this.statusMessage = `Deleted ${range.end - range.start + 1} line${range.end === range.start ? "" : "s"}`;
+				return;
+			}
+			case "yank": {
+				const range = this.#resolveExRange(command.range, this.buffer.cursor.line + 1);
+				this.register = {
+					kind: "line",
+					text: this.buffer.lines.slice(range.start - 1, range.end).join("\n"),
+				};
+				this.statusMessage = `Yanked ${range.end - range.start + 1} line${range.end === range.start ? "" : "s"}`;
+				return;
+			}
+			case "put": {
+				if (!this.register.text) {
+					this.statusMessage = "Register empty";
+					return;
+				}
+				const anchorRange = this.#resolveExRange(command.range, this.buffer.cursor.line + 1);
+				const anchorLine = command.before ? anchorRange.start : anchorRange.end;
+				const lines = this.register.text.split("\n");
+				await this.#applyAtomicChange([":put"], () => {
+					const insertAt = command.before
+						? Math.max(0, anchorLine - 1)
+						: Math.min(anchorLine, this.buffer.lineCount());
+					this.buffer.insertLines(insertAt, lines);
+				});
+				this.statusMessage = `Put ${lines.length} line${lines.length === 1 ? "" : "s"}`;
+				return;
+			}
+			case "copy": {
+				const totalLines = this.buffer.lineCount();
+				const range = this.#resolveExRange(command.range, this.buffer.cursor.line + 1);
+				const dest = Math.max(0, Math.min(command.destination, totalLines));
+				await this.#applyAtomicChange([":copy"], () => {
+					const lines = this.buffer.lines.slice(range.start - 1, range.end);
+					this.buffer.insertLines(dest, lines);
+				});
+				this.statusMessage = `Copied ${range.end - range.start + 1} line${range.end === range.start ? "" : "s"}`;
+				return;
+			}
+			case "move": {
+				const totalLines = this.buffer.lineCount();
+				const range = this.#resolveExRange(command.range, this.buffer.cursor.line + 1);
+				const dest = Math.max(0, Math.min(command.destination, totalLines));
+				await this.#applyAtomicChange([":move"], () => {
+					const lines = this.buffer.lines.splice(range.start - 1, range.end - range.start + 1);
+					const adjustedDest = dest > range.end - 1 ? dest - lines.length : dest;
+					this.buffer.lines.splice(adjustedDest, 0, ...lines);
+					if (this.buffer.lines.length === 0) this.buffer.lines = [""];
+					this.buffer.setCursor({ line: adjustedDest, col: 0 });
+				});
+				this.statusMessage = `Moved ${range.end - range.start + 1} line${range.end === range.start ? "" : "s"}`;
+				return;
+			}
+			case "sort": {
+				const range = this.#resolveExRange(command.range ?? "all", 1, this.buffer.lineCount());
+				const startLine = range.start;
+				const endLine = range.end;
+				const reverse = command.flags.includes("!");
+				const ignoreCase = command.flags.includes("i");
+				await this.#applyAtomicChange([":sort"], () => {
+					const slice = this.buffer.lines.slice(startLine - 1, endLine);
+					slice.sort((a, b) => {
+						const left = ignoreCase ? a.toLowerCase() : a;
+						const right = ignoreCase ? b.toLowerCase() : b;
+						return left < right ? -1 : left > right ? 1 : 0;
+					});
+					if (reverse) slice.reverse();
+					for (let i = 0; i < slice.length; i++) {
+						this.buffer.lines[startLine - 1 + i] = slice[i]!;
+					}
+				});
+				this.statusMessage = `Sorted ${endLine - startLine + 1} line${endLine === startLine ? "" : "s"}`;
+				return;
+			}
+			case "join": {
+				const currentLine = this.buffer.cursor.line + 1;
+				const baseRange = this.#resolveExRange(
+					command.range,
+					currentLine,
+					command.range ? undefined : Math.min(this.buffer.lineCount(), currentLine + 1),
+				);
+				const startLine = baseRange.start;
+				const endLine =
+					baseRange.start === baseRange.end ? Math.min(this.buffer.lineCount(), baseRange.end + 1) : baseRange.end;
+				const lineCount = endLine - startLine + 1;
+				if (lineCount < 2) {
+					this.statusMessage = "Nothing to join";
+					return;
+				}
+				await this.#applyAtomicChange([":join"], () => {
+					const startIndex = startLine - 1;
+					if (command.trimWhitespace) {
+						this.buffer.joinLines(startIndex, lineCount - 1);
+						return;
+					}
+					const joined = this.buffer.lines.slice(startIndex, endLine).join("");
+					this.buffer.lines.splice(startIndex, lineCount, joined);
+					this.buffer.setCursor({ line: startIndex, col: Math.max(0, joined.length - 1) });
+				});
+				this.statusMessage = `Joined ${lineCount} lines`;
+				return;
+			}
+			case "append": {
+				const anchorRange = this.#resolveExRange(command.range, this.buffer.cursor.line + 1);
+				const anchorLine = anchorRange.end;
+				const lines = command.text.length > 0 ? command.text.split("\n") : [""];
+				await this.#applyAtomicChange([":append"], () => {
+					const insertAt = Math.min(anchorLine, this.buffer.lineCount());
+					this.buffer.insertLines(insertAt, lines);
+				});
+				this.statusMessage = `Appended ${lines.length} line${lines.length === 1 ? "" : "s"}`;
+				return;
+			}
+			case "insert-before": {
+				const anchorRange = this.#resolveExRange(command.range, this.buffer.cursor.line + 1);
+				const anchorLine = anchorRange.start;
+				const lines = command.text.length > 0 ? command.text.split("\n") : [""];
+				await this.#applyAtomicChange([":insert"], () => {
+					const insertAt = Math.max(0, anchorLine - 1);
+					this.buffer.insertLines(insertAt, lines);
+				});
+				this.statusMessage = `Inserted ${lines.length} line${lines.length === 1 ? "" : "s"}`;
+				return;
+			}
+			case "global": {
+				const regex = createSearchRegex(command.pattern);
+				const range = this.#resolveExRange(command.range ?? "all", 1, this.buffer.lineCount());
+				await this.#applyAtomicChange([":global"], () => {
+					const linesToProcess: number[] = [];
+					for (let i = range.start - 1; i <= range.end - 1; i += 1) {
+						const matches = regex.test(this.buffer.getLine(i));
+						regex.lastIndex = 0;
+						if (command.invert ? !matches : matches) {
+							linesToProcess.push(i);
+						}
+					}
+					if (command.command === "d" || command.command === "delete") {
+						// Delete matching lines in reverse to preserve indices
+						for (let i = linesToProcess.length - 1; i >= 0; i--) {
+							this.buffer.lines.splice(linesToProcess[i]!, 1);
+						}
+						if (this.buffer.lines.length === 0) this.buffer.lines = [""];
+						this.buffer.clampCursor();
+						this.buffer.trailingNewline = true;
+					} else {
+						throw new VimError(`Unsupported :global sub-command: ${command.command}`);
+					}
+				});
+				this.statusMessage = `Global: processed ${command.pattern}`;
+				return;
+			}
+		}
+	}
+
+	#paste(after: boolean, count: number): void {
+		if (!this.register.text) {
+			return;
+		}
+		if (this.register.kind === "line") {
+			const lines = this.register.text.split("\n");
+			const insertAt = after ? this.buffer.cursor.line + 1 : this.buffer.cursor.line;
+			for (let iteration = 0; iteration < count; iteration += 1) {
+				this.buffer.insertLines(insertAt + iteration * lines.length, lines);
+			}
+			return;
+		}
+		const text = this.register.text.repeat(count);
+		const offset = this.buffer.currentOffset() + (after ? 1 : 0);
+		this.buffer.replaceOffsets(offset, offset, text, offset + text.length);
+	}
+
+	#readCount(tokens: readonly VimKeyToken[], index: number): { count: number; hasCount: boolean; nextIndex: number } {
+		let cursor = index;
+		let digits = "";
+		while (cursor < tokens.length) {
+			const value = tokens[cursor]?.value ?? "";
+			if (!/^\d$/.test(value)) {
+				break;
+			}
+			if (digits.length === 0 && value === "0") {
+				break;
+			}
+			digits += value;
+			cursor += 1;
+		}
+		return {
+			count: digits.length > 0 ? Number.parseInt(digits, 10) : 1,
+			hasCount: digits.length > 0,
+			nextIndex: cursor,
+		};
+	}
+}