@oh-my-pi/pi-tui 11.2.3 → 11.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-tui",
-	"version": "11.2.3",
+	"version": "11.3.0",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -47,8 +47,8 @@
 		"bun": ">=1.3.7"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "11.2.3",
-		"@oh-my-pi/pi-utils": "11.2.3",
+		"@oh-my-pi/pi-natives": "11.3.0",
+		"@oh-my-pi/pi-utils": "11.3.0",
 		"@types/mime-types": "^3.0.1",
 		"chalk": "^5.6.2",
 		"marked": "^17.0.1",

package/src/autocomplete.ts

@@ -519,6 +519,10 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 				if (!entry.name.toLowerCase().startsWith(searchPrefix.toLowerCase())) {
 					continue;
 				}
+				// Skip .git directory
+				if (entry.name === ".git") {
+					continue;
+				}
 
 				// Check if entry is a directory (or a symlink pointing to a directory)
 				let isDirectory = entry.isDirectory();
@@ -627,11 +631,19 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 				query,
 				path: this.basePath,
 				maxResults: 100,
-				hidden: false,
+				hidden: true,
 				gitignore: true,
 			});
 
-			const scoredEntries = result.matches
+			const filteredMatches = result.matches.filter(entry => {
+				const p = entry.path.endsWith("/") ? entry.path.slice(0, -1) : entry.path;
+				const normalized = p.replaceAll("\\", "/");
+				// Exclude the `.git` directory (including when the path ends with `/.git`).
+				// Must only match a full path segment to avoid excluding `.gitignore`, `foo.git`, etc.
+				return !/(^|\/)\.git(\/|$)/.test(normalized);
+			});
+
+			const scoredEntries = filteredMatches
 				.map(entry => ({
 					path: entry.path,
 					isDirectory: entry.isDirectory,

package/src/components/box.ts

@@ -51,8 +51,18 @@ export class Box implements Component {
 		this.cached = undefined;
 	}
 
+	private static _tmp = new Uint32Array(2);
 	private computeCacheKey(width: number, childLines: string[], bgSample: string | undefined): bigint {
-		return Bun.hash.xxHash64(JSON.stringify([width, bgSample, childLines]));
+		Box._tmp[0] = width;
+		Box._tmp[1] = childLines.length;
+		let h = Bun.hash.xxHash64(Box._tmp);
+		for (const line of childLines) {
+			Box._tmp[0] = line.length;
+			h = Bun.hash.xxHash64(Box._tmp, h);
+			h = Bun.hash.xxHash64(line, h);
+		}
+		h = Bun.hash.xxHash64(bgSample ?? "", h);
+		return h;
 	}
 
 	private matchCache(cacheKey: bigint): boolean {

package/src/components/editor.ts

@@ -306,6 +306,9 @@ export class Editor implements Component, Focusable {
 	// Character jump mode
 	private jumpMode: "forward" | "backward" | null = null;
 
+	// Preferred visual column for vertical cursor movement (sticky column)
+	private preferredVisualCol: number | null = null;
+
 	// Border color (can be changed dynamically)
 	public borderColor: (str: string) => string;
 
@@ -455,7 +458,7 @@ export class Editor implements Component, Focusable {
 		const lines = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
 		this.state.lines = lines.length === 0 ? [""] : lines;
 		this.state.cursorLine = this.state.lines.length - 1;
-		this.state.cursorCol = this.state.lines[this.state.cursorLine]?.length || 0;
+		this.setCursorCol(this.state.lines[this.state.cursorLine]?.length || 0);
 
 		if (this.onChange) {
 			this.onChange(this.getText());
@@ -616,42 +619,6 @@ export class Editor implements Component, Focusable {
 		return result;
 	}
 
-	getCursorPosition(width: number): { row: number; col: number } | null {
-		if (!this.useTerminalCursor) return null;
-
-		const paddingX = this.getEditorPaddingX();
-		const borderWidth = paddingX + 1;
-		const layoutWidth = this.getLayoutWidth(width, paddingX);
-		if (layoutWidth <= 0) return null;
-
-		const layoutLines = this.layoutText(layoutWidth);
-		const visibleContentHeight = this.getVisibleContentHeight(layoutLines.length);
-		this.updateScrollOffset(layoutWidth, layoutLines, visibleContentHeight);
-
-		for (let i = 0; i < layoutLines.length; i++) {
-			if (i < this.scrollOffset || i >= this.scrollOffset + visibleContentHeight) continue;
-			const layoutLine = layoutLines[i];
-			if (!layoutLine || !layoutLine.hasCursor || layoutLine.cursorPos === undefined) continue;
-
-			const lineWidth = visibleWidth(layoutLine.text);
-			const isCursorAtLineEnd = layoutLine.cursorPos === layoutLine.text.length;
-
-			if (isCursorAtLineEnd && lineWidth >= layoutWidth && layoutLine.text.length > 0) {
-				const graphemes = [...segmenter.segment(layoutLine.text)];
-				const lastGrapheme = graphemes[graphemes.length - 1]?.segment || "";
-				const lastWidth = visibleWidth(lastGrapheme) || 1;
-				const colOffset = borderWidth + Math.max(0, lineWidth - lastWidth);
-				return { row: 1 + i - this.scrollOffset, col: colOffset };
-			}
-
-			const before = layoutLine.text.slice(0, layoutLine.cursorPos);
-			const colOffset = borderWidth + visibleWidth(before);
-			return { row: 1 + i - this.scrollOffset, col: colOffset };
-		}
-
-		return null;
-	}
-
 	handleInput(data: string): void {
 		const kb = getEditorKeybindings();
 
@@ -768,7 +735,7 @@ export class Editor implements Component, Focusable {
 
 						this.state.lines = result.lines;
 						this.state.cursorLine = result.cursorLine;
-						this.state.cursorCol = result.cursorCol;
+						this.setCursorCol(result.cursorCol);
 
 						this.cancelAutocomplete();
 
@@ -803,7 +770,7 @@ export class Editor implements Component, Focusable {
 
 							this.state.lines = result.lines;
 							this.state.cursorLine = result.cursorLine;
-							this.state.cursorCol = result.cursorCol;
+							this.setCursorCol(result.cursorCol);
 						}
 						this.cancelAutocomplete();
 					}
@@ -823,7 +790,7 @@ export class Editor implements Component, Focusable {
 
 						this.state.lines = result.lines;
 						this.state.cursorLine = result.cursorLine;
-						this.state.cursorCol = result.cursorCol;
+						this.setCursorCol(result.cursorCol);
 
 						this.cancelAutocomplete();
 
@@ -885,7 +852,7 @@ export class Editor implements Component, Focusable {
 				this.addNewLine();
 			}
 		}
-		// New line shortcuts (but not plain LF/CR which should be submit)
+		// New line
 		else if (
 			(data.charCodeAt(0) === 10 && data.length > 1) || // Ctrl+Enter with modifiers
 			data === "\x1b[13;5u" || // Ctrl+Enter (Kitty protocol)
@@ -896,7 +863,11 @@ export class Editor implements Component, Focusable {
 			(data.length > 1 && data.includes("\x1b") && data.includes("\r")) ||
 			(data === "\n" && data.length === 1) // Shift+Enter from iTerm2 mapping
 		) {
-			// Modifier + Enter = new line
+			if (this.shouldSubmitOnBackslashEnter(data, kb)) {
+				this.handleBackspace();
+				this.submitValue();
+				return;
+			}
 			this.addNewLine();
 		}
 		// Plain Enter - submit (handles both legacy \r and Kitty protocol with lock bits)
@@ -906,46 +877,7 @@ export class Editor implements Component, Focusable {
 				return;
 			}
 
-			// Workaround for terminals without Shift+Enter support:
-			// If char before cursor is \, delete it and insert newline instead of submitting.
-			const currentLine = this.state.lines[this.state.cursorLine] || "";
-			if (this.state.cursorCol > 0 && currentLine[this.state.cursorCol - 1] === "\\") {
-				this.handleBackspace();
-				this.addNewLine();
-				return;
-			}
-
-			this.resetKillSequence();
-
-			// Get text and substitute paste markers with actual content
-			let result = this.state.lines.join("\n").trim();
-
-			// Replace all [paste #N +xxx lines] or [paste #N xxx chars] markers with actual paste content
-			for (const [pasteId, pasteContent] of this.pastes) {
-				// Match formats: [paste #N], [paste #N +xxx lines], or [paste #N xxx chars]
-				const markerRegex = new RegExp(`\\[paste #${pasteId}( (\\+\\d+ lines|\\d+ chars))?\\]`, "g");
-				result = result.replace(markerRegex, pasteContent);
-			}
-
-			// Reset editor and clear pastes
-			this.state = {
-				lines: [""],
-				cursorLine: 0,
-				cursorCol: 0,
-			};
-			this.clearUndoStack();
-			this.pastes.clear();
-			this.pasteCounter = 0;
-			this.historyIndex = -1; // Exit history browsing mode
-
-			// Notify that editor is now empty
-			if (this.onChange) {
-				this.onChange("");
-			}
-
-			if (this.onSubmit) {
-				this.onSubmit(result);
-			}
+			this.submitValue();
 		}
 		// Backspace (including Shift+Backspace)
 		else if (matchesKey(data, "backspace") || matchesKey(data, "shift+backspace")) {
@@ -1155,7 +1087,7 @@ export class Editor implements Component, Focusable {
 		const after = line.slice(this.state.cursorCol);
 
 		this.state.lines[this.state.cursorLine] = before + text + after;
-		this.state.cursorCol += text.length;
+		this.setCursorCol(this.state.cursorCol + text.length);
 
 		if (this.onChange) {
 			this.onChange(this.getText());
@@ -1174,7 +1106,7 @@ export class Editor implements Component, Focusable {
 		const after = line.slice(this.state.cursorCol);
 
 		this.state.lines[this.state.cursorLine] = before + char + after;
-		this.state.cursorCol += char.length; // Fix: increment by the length of the inserted string
+		this.setCursorCol(this.state.cursorCol + char.length);
 
 		if (this.onChange) {
 			this.onChange(this.getText());
@@ -1292,13 +1224,44 @@ export class Editor implements Component, Focusable {
 
 		// Move cursor to start of new line
 		this.state.cursorLine++;
-		this.state.cursorCol = 0;
+		this.setCursorCol(0);
 
 		if (this.onChange) {
 			this.onChange(this.getText());
 		}
 	}
 
+	private shouldSubmitOnBackslashEnter(data: string, kb: ReturnType<typeof getEditorKeybindings>): boolean {
+		if (this.disableSubmit) return false;
+		if (!matchesKey(data, "enter")) return false;
+		const submitKeys = kb.getKeys("submit");
+		const hasShiftEnter = submitKeys.includes("shift+enter") || submitKeys.includes("shift+return");
+		if (!hasShiftEnter) return false;
+
+		const currentLine = this.state.lines[this.state.cursorLine] || "";
+		return this.state.cursorCol > 0 && currentLine[this.state.cursorCol - 1] === "\\";
+	}
+
+	private submitValue(): void {
+		this.resetKillSequence();
+
+		let result = this.state.lines.join("\n").trim();
+		for (const [pasteId, pasteContent] of this.pastes) {
+			const markerRegex = new RegExp(`\\[paste #${pasteId}( (\\+\\d+ lines|\\d+ chars))?\\]`, "g");
+			result = result.replace(markerRegex, pasteContent);
+		}
+
+		this.state = { lines: [""], cursorLine: 0, cursorCol: 0 };
+		this.pastes.clear();
+		this.pasteCounter = 0;
+		this.historyIndex = -1;
+		this.scrollOffset = 0;
+		this.undoStack.length = 0;
+
+		if (this.onChange) this.onChange("");
+		if (this.onSubmit) this.onSubmit(result);
+	}
+
 	private handleBackspace(): void {
 		this.historyIndex = -1; // Exit history browsing mode
 		this.resetKillSequence();
@@ -1318,7 +1281,7 @@ export class Editor implements Component, Focusable {
 			const after = line.slice(this.state.cursorCol);
 
 			this.state.lines[this.state.cursorLine] = before + after;
-			this.state.cursorCol -= graphemeLength;
+			this.setCursorCol(this.state.cursorCol - graphemeLength);
 		} else if (this.state.cursorLine > 0) {
 			// Merge with previous line
 			const currentLine = this.state.lines[this.state.cursorLine] || "";
@@ -1328,7 +1291,7 @@ export class Editor implements Component, Focusable {
 			this.state.lines.splice(this.state.cursorLine, 1);
 
 			this.state.cursorLine--;
-			this.state.cursorCol = previousLine.length;
+			this.setCursorCol(previousLine.length);
 		}
 
 		if (this.onChange) {
@@ -1353,15 +1316,96 @@ export class Editor implements Component, Focusable {
 		}
 	}
 
+	/**
+	 * Set cursor column and clear preferredVisualCol.
+	 * Use this for all non-vertical cursor movements to reset sticky column behavior.
+	 */
+	private setCursorCol(col: number): void {
+		this.state.cursorCol = col;
+		this.preferredVisualCol = null;
+	}
+
+	/**
+	 * Move cursor to a target visual line, applying sticky column logic.
+	 * Shared by moveCursor() and pageScroll().
+	 */
+	private moveToVisualLine(
+		visualLines: Array<{ logicalLine: number; startCol: number; length: number }>,
+		currentVisualLine: number,
+		targetVisualLine: number,
+	): void {
+		const currentVL = visualLines[currentVisualLine];
+		const targetVL = visualLines[targetVisualLine];
+
+		if (currentVL && targetVL) {
+			const currentVisualCol = this.state.cursorCol - currentVL.startCol;
+
+			// For non-last segments, clamp to length-1 to stay within the segment
+			const isLastSourceSegment =
+				currentVisualLine === visualLines.length - 1 ||
+				visualLines[currentVisualLine + 1]?.logicalLine !== currentVL.logicalLine;
+			const sourceMaxVisualCol = isLastSourceSegment ? currentVL.length : Math.max(0, currentVL.length - 1);
+
+			const isLastTargetSegment =
+				targetVisualLine === visualLines.length - 1 ||
+				visualLines[targetVisualLine + 1]?.logicalLine !== targetVL.logicalLine;
+			const targetMaxVisualCol = isLastTargetSegment ? targetVL.length : Math.max(0, targetVL.length - 1);
+
+			const moveToVisualCol = this.computeVerticalMoveColumn(
+				currentVisualCol,
+				sourceMaxVisualCol,
+				targetMaxVisualCol,
+			);
+
+			// Set cursor position
+			this.state.cursorLine = targetVL.logicalLine;
+			const targetCol = targetVL.startCol + moveToVisualCol;
+			const logicalLine = this.state.lines[targetVL.logicalLine] || "";
+			this.state.cursorCol = Math.min(targetCol, logicalLine.length);
+		}
+	}
+
+	/**
+	 * Compute the target visual column for vertical cursor movement.
+	 * Implements the sticky column decision table.
+	 */
+	private computeVerticalMoveColumn(
+		currentVisualCol: number,
+		sourceMaxVisualCol: number,
+		targetMaxVisualCol: number,
+	): number {
+		const hasPreferred = this.preferredVisualCol !== null;
+		const cursorInMiddle = currentVisualCol < sourceMaxVisualCol;
+		const targetTooShort = targetMaxVisualCol < currentVisualCol;
+
+		if (!hasPreferred || cursorInMiddle) {
+			if (targetTooShort) {
+				this.preferredVisualCol = currentVisualCol;
+				return targetMaxVisualCol;
+			}
+			this.preferredVisualCol = null;
+			return currentVisualCol;
+		}
+
+		const targetCantFitPreferred = targetMaxVisualCol < this.preferredVisualCol!;
+		if (targetTooShort || targetCantFitPreferred) {
+			return targetMaxVisualCol;
+		}
+
+		const result = this.preferredVisualCol!;
+		this.preferredVisualCol = null;
+		return result;
+	}
+
 	private moveToLineStart(): void {
 		this.resetKillSequence();
-		this.state.cursorCol = 0;
+		this.setCursorCol(0);
 	}
 
 	private moveToLineEnd(): void {
 		this.resetKillSequence();
 		const currentLine = this.state.lines[this.state.cursorLine] || "";
-		this.state.cursorCol = currentLine.length;
+		this.setCursorCol(currentLine.length);
 	}
 
 	private resetKillSequence(): void {
@@ -1412,6 +1456,7 @@ export class Editor implements Component, Focusable {
 
 		this.historyIndex = -1;
 		this.resetKillSequence();
+		this.preferredVisualCol = null;
 		this.state = {
 			lines: [...snapshot.lines],
 			cursorLine: snapshot.cursorLine,
@@ -1462,7 +1507,7 @@ export class Editor implements Component, Focusable {
 			const before = line.slice(0, this.state.cursorCol);
 			const after = line.slice(this.state.cursorCol);
 			this.state.lines[this.state.cursorLine] = before + normalized + after;
-			this.state.cursorCol += normalized.length;
+			this.setCursorCol(this.state.cursorCol + normalized.length);
 		} else {
 			const currentLine = this.state.lines[this.state.cursorLine] || "";
 			const beforeCursor = currentLine.slice(0, this.state.cursorCol);
@@ -1485,7 +1530,7 @@ export class Editor implements Component, Focusable {
 
 			this.state.lines = newLines;
 			this.state.cursorLine += lines.length - 1;
-			this.state.cursorCol = (lines[lines.length - 1] || "").length;
+			this.setCursorCol((lines[lines.length - 1] || "").length);
 		}
 
 		if (this.onChange) {
@@ -1509,7 +1554,7 @@ export class Editor implements Component, Focusable {
 			// Delete from start of line up to cursor
 			deletedText = currentLine.slice(0, this.state.cursorCol);
 			this.state.lines[this.state.cursorLine] = currentLine.slice(this.state.cursorCol);
-			this.state.cursorCol = 0;
+			this.setCursorCol(0);
 		} else if (this.state.cursorLine > 0) {
 			// At start of line - merge with previous line
 			deletedText = "\n";
@@ -1517,7 +1562,7 @@ export class Editor implements Component, Focusable {
 			this.state.lines[this.state.cursorLine - 1] = previousLine + currentLine;
 			this.state.lines.splice(this.state.cursorLine, 1);
 			this.state.cursorLine--;
-			this.state.cursorCol = previousLine.length;
+			this.setCursorCol(previousLine.length);
 		}
 
 		this.recordKill(deletedText, "backward");
@@ -1567,18 +1612,18 @@ export class Editor implements Component, Focusable {
 				this.state.lines[this.state.cursorLine - 1] = previousLine + currentLine;
 				this.state.lines.splice(this.state.cursorLine, 1);
 				this.state.cursorLine--;
-				this.state.cursorCol = previousLine.length;
+				this.setCursorCol(previousLine.length);
 			}
 		} else {
 			const oldCursorCol = this.state.cursorCol;
 			this.moveWordBackwards();
 			const deleteFrom = this.state.cursorCol;
-			this.state.cursorCol = oldCursorCol;
+			this.setCursorCol(oldCursorCol);
 
 			const deletedText = currentLine.slice(deleteFrom, oldCursorCol);
 			this.state.lines[this.state.cursorLine] =
 				currentLine.slice(0, deleteFrom) + currentLine.slice(this.state.cursorCol);
-			this.state.cursorCol = deleteFrom;
+			this.setCursorCol(deleteFrom);
 			this.recordKill(deletedText, "backward");
 		}
 
@@ -1604,7 +1649,7 @@ export class Editor implements Component, Focusable {
 			const oldCursorCol = this.state.cursorCol;
 			this.moveWordForwards();
 			const deleteTo = this.state.cursorCol;
-			this.state.cursorCol = oldCursorCol;
+			this.setCursorCol(oldCursorCol);
 
 			const deletedText = currentLine.slice(oldCursorCol, deleteTo);
 			this.state.lines[this.state.cursorLine] = currentLine.slice(0, oldCursorCol) + currentLine.slice(deleteTo);
@@ -1723,29 +1768,14 @@ export class Editor implements Component, Focusable {
 
 	private moveCursor(deltaLine: number, deltaCol: number): void {
 		this.resetKillSequence();
-		const contentWidth = this.lastLayoutWidth;
+		const visualLines = this.buildVisualLineMap(this.lastLayoutWidth);
+		const currentVisualLine = this.findCurrentVisualLine(visualLines);
 
 		if (deltaLine !== 0) {
-			// Build visual line map for navigation
-			const visualLines = this.buildVisualLineMap(contentWidth);
-			const currentVisualLine = this.findCurrentVisualLine(visualLines);
-
-			// Calculate column position within current visual line
-			const currentVL = visualLines[currentVisualLine];
-			const visualCol = currentVL ? this.state.cursorCol - currentVL.startCol : 0;
-
-			// Move to target visual line
 			const targetVisualLine = currentVisualLine + deltaLine;
 
 			if (targetVisualLine >= 0 && targetVisualLine < visualLines.length) {
-				const targetVL = visualLines[targetVisualLine];
-				if (targetVL) {
-					this.state.cursorLine = targetVL.logicalLine;
-					// Try to maintain visual column position, clamped to line length
-					const targetCol = targetVL.startCol + Math.min(visualCol, targetVL.length);
-					const logicalLine = this.state.lines[targetVL.logicalLine] || "";
-					this.state.cursorCol = Math.min(targetCol, logicalLine.length);
-				}
+				this.moveToVisualLine(visualLines, currentVisualLine, targetVisualLine);
 			}
 		}
 
@@ -1758,11 +1788,17 @@ export class Editor implements Component, Focusable {
 					const afterCursor = currentLine.slice(this.state.cursorCol);
 					const graphemes = [...segmenter.segment(afterCursor)];
 					const firstGrapheme = graphemes[0];
-					this.state.cursorCol += firstGrapheme ? firstGrapheme.segment.length : 1;
+					this.setCursorCol(this.state.cursorCol + (firstGrapheme ? firstGrapheme.segment.length : 1));
 				} else if (this.state.cursorLine < this.state.lines.length - 1) {
 					// Wrap to start of next logical line
 					this.state.cursorLine++;
-					this.state.cursorCol = 0;
+					this.setCursorCol(0);
+				} else {
+					// At end of last line - can't move, but set preferredVisualCol for up/down navigation
+					const currentVL = visualLines[currentVisualLine];
+					if (currentVL) {
+						this.preferredVisualCol = this.state.cursorCol - currentVL.startCol;
+					}
 				}
 			} else {
 				// Moving left - move by one grapheme (handles emojis, combining characters, etc.)
@@ -1770,12 +1806,12 @@ export class Editor implements Component, Focusable {
 					const beforeCursor = currentLine.slice(0, this.state.cursorCol);
 					const graphemes = [...segmenter.segment(beforeCursor)];
 					const lastGrapheme = graphemes[graphemes.length - 1];
-					this.state.cursorCol -= lastGrapheme ? lastGrapheme.segment.length : 1;
+					this.setCursorCol(this.state.cursorCol - (lastGrapheme ? lastGrapheme.segment.length : 1));
 				} else if (this.state.cursorLine > 0) {
 					// Wrap to end of previous logical line
 					this.state.cursorLine--;
 					const prevLine = this.state.lines[this.state.cursorLine] || "";
-					this.state.cursorCol = prevLine.length;
+					this.setCursorCol(prevLine.length);
 				}
 			}
 		}
@@ -1789,7 +1825,7 @@ export class Editor implements Component, Focusable {
 			if (this.state.cursorLine > 0) {
 				this.state.cursorLine--;
 				const prevLine = this.state.lines[this.state.cursorLine] || "";
-				this.state.cursorCol = prevLine.length;
+				this.setCursorCol(prevLine.length);
 			}
 			return;
 		}
@@ -1822,7 +1858,7 @@ export class Editor implements Component, Focusable {
 			}
 		}
 
-		this.state.cursorCol = newCol;
+		this.setCursorCol(newCol);
 	}
 
 	/**
@@ -1852,7 +1888,7 @@ export class Editor implements Component, Focusable {
 
 			if (idx !== -1) {
 				this.state.cursorLine = lineIdx;
-				this.state.cursorCol = idx;
+				this.setCursorCol(idx);
 				return;
 			}
 		}
@@ -1866,7 +1902,7 @@ export class Editor implements Component, Focusable {
 		if (this.state.cursorCol >= currentLine.length) {
 			if (this.state.cursorLine < this.state.lines.length - 1) {
 				this.state.cursorLine++;
-				this.state.cursorCol = 0;
+				this.setCursorCol(0);
 			}
 			return;
 		}
@@ -1875,10 +1911,11 @@ export class Editor implements Component, Focusable {
 		const segments = segmenter.segment(textAfterCursor);
 		const iterator = segments[Symbol.iterator]();
 		let next = iterator.next();
+		let newCol = this.state.cursorCol;
 
 		// Skip leading whitespace
 		while (!next.done && isWhitespaceChar(next.value.segment)) {
-			this.state.cursorCol += next.value.segment.length;
+			newCol += next.value.segment.length;
 			next = iterator.next();
 		}
 
@@ -1887,17 +1924,19 @@ export class Editor implements Component, Focusable {
 			if (isPunctuationChar(firstGrapheme)) {
 				// Skip punctuation run
 				while (!next.done && isPunctuationChar(next.value.segment)) {
-					this.state.cursorCol += next.value.segment.length;
+					newCol += next.value.segment.length;
 					next = iterator.next();
 				}
 			} else {
 				// Skip word run
 				while (!next.done && !isWhitespaceChar(next.value.segment) && !isPunctuationChar(next.value.segment)) {
-					this.state.cursorCol += next.value.segment.length;
+					newCol += next.value.segment.length;
 					next = iterator.next();
 				}
 			}
 		}
+
+		this.setCursorCol(newCol);
 	}
 
 	// Helper method to check if cursor is at start of message (for slash command detection)
@@ -2000,7 +2039,7 @@ https://github.com/EsotericSoftware/spine-runtimes/actions/runs/19536643416/job/
 
 				this.state.lines = result.lines;
 				this.state.cursorLine = result.cursorLine;
-				this.state.cursorCol = result.cursorCol;
+				this.setCursorCol(result.cursorCol);
 
 				if (this.onChange) {
 					this.onChange(this.getText());