opencode-vim 0.0.19 → 0.0.21

package/src/modules/vim/vimee.ts

@@ -1,17 +1,17 @@
 import type { KeyEvent } from "@opentui/core"
-import { TextBuffer, createInitialContext, createKeybindMap, parseKeySequence, processKeystroke, resetContext } from "@vimee/core"
+import { TextBuffer, createInitialContext, createKeybindMap, parseKeySequence, processKeystroke, resetContext, resolveMotion } from "@vimee/core"
 import type { CursorPosition, KeybindDefinition, KeybindMap, MotionRange, Operator, ValidKeySequence, VimAction as VimeeAction, VimContext, VimMode as VimeeMode } from "@vimee/core"
-import type { PromptContext } from "../../prompt/types"
-import { focusedInput, setInput, type EditBufferLike } from "./actions"
+import { focusedInput, setInput, type EditBufferLike, type PromptContext } from "./actions"
 import type { VimConfig } from "./config"
 import type { VimLog } from "./log"
-import { createPromptMap, derivePromptMap, hostOffset, hostPosition, type PromptMap } from "./map"
+import { createGraphemeCodec } from "./graphemes"
+import { charToDisplay, displayToChar, displayWidth, createPromptMap, derivePromptMap, hostOffset, hostPosition, type PromptMap } from "./map"
 import type { createVimState } from "./state"
 
 type VimState = ReturnType<typeof createVimState>
-type HostAction = VimeeAction | { type: "submit" }
-type HostKeybindAction = "normal" | "submit"
-type HostKeybindDefinition = KeybindDefinition & { hostAction?: HostKeybindAction }
+type HostAction = VimeeAction | { type: "submit" } | { type: "command"; command: string }
+type HostKeybindAction = "normal" | "submit" | "command"
+type HostKeybindDefinition = KeybindDefinition & { hostAction?: HostKeybindAction; command?: string }
 type HostRange = { start: number; end: number }
 
 const YANK_FLASH_MS = 250
@@ -19,8 +19,9 @@ const YANK_FLASH_MS = 250
 export type VimeeAdapter = ReturnType<typeof createVimeeAdapter>
 
 export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimLog) {
+    const codec = createGraphemeCodec()
     let buffer = new TextBuffer("")
-    let activeMap = createPromptMap("")
+    let activeMap = createPromptMap("", undefined, codec)
     const maps = new Map([[activeMap.vimText, activeMap]])
     let vim = createInitialContext({ line: 0, col: 0 })
     const keybinds = createKeybinds(config, log)
@@ -28,28 +29,36 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
     let yankTimer: ReturnType<typeof setTimeout> | undefined
     let yankFlashActive = false
     let pendingInsert = ""
+    let pendingTarget: { input: EditBufferLike; offset: number } | undefined
+    let pendingContext: PromptContext | undefined
     let nativeInsertUndoSaved = false
+    let historyText: string | undefined
+    let activeInput: EditBufferLike | undefined
+    let mapWidth: number | undefined
+    let mapWrapMode: string | undefined
+    const defaultHistoryKeys = {
+        k: !hasNormalKeyPrefix(config, "k"),
+        j: !hasNormalKeyPrefix(config, "j"),
+    }
+    const appendMapped = hasNormalKeyPrefix(config, "A")
 
     return {
+        attach,
+        suspend,
+        isPending: () => vim.phase !== "idle" || vim.count > 0 || !!keybinds?.isPending(),
         handle(event: KeyEvent, key: string, ctx: PromptContext) {
             const ref = ctx.prompt()
             if (!ref) return false
+            const input = focusedInput(ctx)
+            attach(ctx)
 
             let vimeeKey = keyForVimee(event, key)
             if (!vimeeKey) return false
-
-            if (state.mode() === "normal" && key === "<CR>") {
-                ref.submit()
-                return true
-            }
+            vimeeKey = codec.encode(vimeeKey)
 
             if (state.mode() === "insert") {
-                if (key === "<CR>") {
-                    cancelPendingInsert(ctx)
-                    return false
-                }
                 if (vimeeKey === "Escape") {
-                    cancelPendingInsert(ctx, undefined, false)
+                    cancelPendingInsert(ctx)
                     enterNormal(ctx)
                     state.setPending("")
                     updateTimeout(ctx)
@@ -59,82 +68,172 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
                 return handleInsertKeybind(event, vimeeKey, ctx)
             }
 
-            const input = focusedInput(ctx)
             const text = input?.plainText ?? ref.current.input
-            const offset = clamp(input?.cursorOffset ?? text.length, 0, text.length)
+            const dw = displayWidth(text)
+            const displayOff = clamp(input?.cursorOffset ?? dw, 0, dw)
+            const charOff = displayToChar(text, displayOff)
+
+            const canBrowseHistory = vim.phase === "idle" && vim.count === 0 && !keybinds?.isPending()
+            const historyCommand = canBrowseHistory ? defaultHistoryCommand(vimeeKey, text, historyText, defaultHistoryKeys) : undefined
+            if (historyCommand) {
+                const result = dispatchCommand(historyCommand, ctx)
+                historyText = result.ok ? (focusedInput(ctx)?.plainText ?? ref.current.input) : undefined
+                state.setPending("")
+                updateTimeout(ctx)
+                log("vimee.history", { key, command: historyCommand, handled: result.ok })
+                return true
+            }
+            historyText = undefined
 
             const map = mapForHostText(text, input)
-            const cursor = hostPosition(map, offset)
+            const cursor = hostPosition(map, displayOff)
 
             const wasPending = keybinds?.isPending() ?? false
             const pendingBefore = pendingInsert
             sync(map, cursor)
 
-            if (vimeeKey === "A" && appendVisualLine(input, map)) {
+            if (vimeeKey === "A" && vim.mode === "normal" && vim.phase === "idle" && !wasPending && !appendMapped && appendVisualLine(input, map)) {
                 state.setPending("")
                 updateTimeout(ctx)
                 log("vimee.key", { key, vimeeKey, mode: vim.mode, phase: vim.phase, cursor: vim.cursor, actions: ["mode-change"] })
                 return true
             }
 
-            const hostEnd = vimeeKey === "e" ? endMotionOffset(map.hostText, offset, vim.count || 1) : undefined
+            const hostEnd = vimeeKey === "e" && vim.phase === "idle" ? charToDisplay(map.hostText, endMotionOffset(map.hostText, charOff, vim.count || 1)) : undefined
             const shouldFlashYank = shouldFlashYankFor(vimeeKey)
             const visualYankRange = visualYankRangeFor(map)
             vimeeKey = textObjectAlias(vimeeKey, vim) ?? vimeeKey
             const textObjectHandled = handleTextObject(vimeeKey, ctx, map)
             if (textObjectHandled !== undefined) return textObjectHandled
-            const result = processKeystroke(vimeeKey, vim, buffer, event.ctrl, false, keybinds)
+            const resolved = keybinds?.resolve(vimeeKey, vim.mode, event.ctrl)
+            if (resolved?.status === "pending") {
+                vim = { ...vim, statusMessage: resolved.display }
+                state.setPending(resolved.display)
+                updateTimeout(ctx)
+                log("vimee.key", { key, vimeeKey, mode: vim.mode, phase: vim.phase, cursor: vim.cursor, actions: [] })
+                return true
+            }
+            if (vimeeKey === "Enter" && state.mode() === "normal" && vim.phase === "idle" && !wasPending && resolved?.status !== "matched") {
+                ref.submit()
+                state.setPending("")
+                updateTimeout(ctx)
+                log("vimee.key", { key, vimeeKey, mode: vim.mode, phase: vim.phase, cursor: vim.cursor, actions: ["submit"] })
+                return true
+            }
+
+            let result
+            if (resolved?.status === "matched") {
+                const actions = applyKeybind(resolved.definition, map)
+                result = { newCtx: vim, actions }
+            } else {
+                result = processKey(vimeeKey, event.ctrl)
+            }
             vim = result.newCtx
-            if (hostEnd !== undefined && result.actions.every((action) => action.type === "cursor-move") && hostEnd > hostOffset(map, vim.cursor, "previous")) vim = { ...vim, cursor: hostPosition(map, hostEnd) }
+            const actions = result.actions as HostAction[]
+            if (hostEnd !== undefined && actions.every((action) => action.type === "cursor-move") && hostEnd > hostOffset(map, vim.cursor, "previous")) vim = { ...vim, cursor: hostPosition(map, hostEnd) }
             let clampFinalCursor = true
-            const content = result.actions.find((action) => action.type === "content-change")?.content
-            if (vimeeKey === "x" && content !== undefined) {
+            const content = actions.find((action) => action.type === "content-change")?.content
+            if (vimeeKey === "x" && state.mode() === "normal" && content !== undefined) {
                 const next = nextMap(map, content)
-                const target = clamp(offset, 0, Math.max(0, next.hostText.length - 1))
-                if (offset < map.hostText.length - 1 && map.hostText[offset + 1] !== "\n" && hostOffset(next, vim.cursor, "previous") < target) {
+                const nextDW = displayWidth(next.hostText)
+                const target = clamp(displayOff, 0, Math.max(0, nextDW - 1))
+                if (charOff < map.hostText.length - 1 && map.hostText[charOff + 1] !== "\n" && hostOffset(next, vim.cursor, "previous") < target) {
                     vim = { ...vim, cursor: hostPosition(next, target) }
                     clampFinalCursor = false
                 }
             }
-            applyActions(result.actions as HostAction[], ctx, map, clampFinalCursor)
-            if (shouldFlashYank) flashYank(ctx, activeMap, yankAction(result.actions), visualYankRange)
+            applyActions(actions, ctx, map, clampFinalCursor)
+            if (shouldFlashYank) flashYank(ctx, activeMap, yankAction(actions), visualYankRange)
             syncMode(state, vim.mode)
+
             const keybindPending = keybinds?.isPending() ?? false
-            if (wasPending && !keybindPending && pendingBefore && state.mode() === "insert") flushPendingInsert(ctx, pendingBefore, offset)
+            if (wasPending && !keybindPending && pendingBefore && state.mode() === "insert") flushPendingInsert(ctx, pendingBefore, charOff)
             pendingInsert = keybindPending && state.mode() === "insert" ? plainPending(vim.statusMessage) : ""
             state.setPending(pendingDisplay(vim, keybindPending))
             updateTimeout(ctx)
-            log("vimee.key", { key, vimeeKey, mode: vim.mode, phase: vim.phase, cursor: vim.cursor, actions: result.actions.map((action) => action.type) })
-            return consumesKey(vimeeKey, result.actions, vim, keybindPending)
+            log("vimee.key", { key, vimeeKey, mode: vim.mode, phase: vim.phase, cursor: vim.cursor, actions: actions.map((action) => action.type) })
+            return consumesKey(vimeeKey, actions, vim, keybindPending)
         },
         cleanup() {
-            if (timer) clearTimeout(timer)
-            if (yankTimer) clearTimeout(yankTimer)
+            suspend()
+            maps.clear()
         },
     }
 
+    function attach(ctx: PromptContext) {
+        const input = focusedInput(ctx)
+        if (activeInput === input) return
+        suspend()
+        activeInput = input
+        activeMap = createPromptMap(input?.plainText ?? ctx.prompt()?.current.input ?? "", input, codec)
+        maps.clear()
+        rememberMap(activeMap)
+        buffer = new TextBuffer(activeMap.vimText)
+        nativeInsertUndoSaved = false
+        vim = { ...resetContext(vim), cursor: hostPosition(activeMap, input?.cursorOffset ?? 0), mode: state.mode() }
+        mapWidth = input?.width
+        mapWrapMode = input?.wrapMode
+    }
+
+    function suspend() {
+        if (pendingContext) cancelPendingInsert(pendingContext)
+        if (timer) clearTimeout(timer)
+        timer = undefined
+        keybinds?.cancel()
+        cancelYankFlash()
+        if (activeInput && !activeInput.isDestroyed) clearVisualSelection(activeInput)
+        if (isVisualMode(state.mode())) state.setMode("normal")
+        vim = resetContext(vim)
+        state.setPending("")
+        pendingTarget = undefined
+        pendingContext = undefined
+    }
+
     function sync(map: PromptMap, cursor: CursorPosition) {
         if (buffer.getContent() !== map.vimText) buffer.replaceContent(map.vimText)
         vim = { ...vim, cursor, mode: state.mode() }
     }
 
     function mapForHostText(text: string, input: ReturnType<typeof focusedInput>) {
-        if (activeMap.hostText === text) return activeMap
-        activeMap = createPromptMap(text, input)
+        const textChanged = activeMap.hostText !== text
+        if (!textChanged && mapWidth === input?.width && mapWrapMode === input?.wrapMode) return activeMap
+        if (textChanged && state.mode() === "insert") recordNativeChange(text)
+        activeMap = createPromptMap(text, input, codec)
+        mapWidth = input?.width
+        mapWrapMode = input?.wrapMode
+        if (textChanged && state.mode() !== "insert") maps.clear()
         rememberMap(activeMap)
-        if (state.mode() === "insert") {
+        if (textChanged && state.mode() === "insert") {
             if (!nativeInsertUndoSaved) {
                 buffer.saveUndoPoint(vim.cursor)
                 nativeInsertUndoSaved = true
             }
             buffer.replaceContent(activeMap.vimText)
-        } else {
+        } else if (textChanged) {
             buffer = new TextBuffer(activeMap.vimText)
             nativeInsertUndoSaved = false
+        } else {
+            buffer.replaceContent(activeMap.vimText)
         }
         return activeMap
     }
 
+    function recordNativeChange(text: string) {
+        const before = codec.encode(activeMap.hostText)
+        const after = codec.encode(text)
+        const start = codec.encode(activeMap.hostText.slice(0, displayToChar(activeMap.hostText, hostOffset(activeMap, vim.cursor)))).length
+        let prefix = 0
+        while (prefix < start && prefix < after.length && before[prefix] === after[prefix]) prefix++
+        let suffix = 0
+        while (suffix < before.length - start && suffix < after.length - prefix && before[before.length - suffix - 1] === after[after.length - suffix - 1]) suffix++
+        const keys = [...vim.pendingChange]
+        if (!keys.length) keys.push("i")
+        for (let index = prefix; index < start; index++) keys.push("Backspace")
+        for (let index = start; index < before.length - suffix; index++) keys.push("Delete")
+        for (const key of after.slice(prefix, after.length - suffix)) keys.push(key === "\n" ? "Enter" : key === "\t" ? "Tab" : key)
+        vim = { ...vim, pendingChange: keys }
+    }
+
     function rememberMap(map: PromptMap) {
         maps.set(map.vimText, map)
     }
@@ -166,7 +265,11 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
                     setCursor(input, currentMap, action.position)
                     break
                 case "mode-change":
-                    nativeInsertUndoSaved = false
+                    nativeInsertUndoSaved = action.mode === "insert" && actions.some((item) => item.type === "content-change")
+                    if (action.mode === "insert") {
+                        cancelYankFlash()
+                        if (input) clearVisualSelection(input)
+                    }
                     syncMode(state, action.mode)
                     break
                 case "quit":
@@ -175,6 +278,9 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
                 case "submit":
                     ref.submit()
                     break
+                case "command":
+                    dispatchCommand(action.command, ctx)
+                    return
             }
         }
 
@@ -182,7 +288,7 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
         syncVisualSelection(input, currentMap, ctx)
     }
 
-    function handleInsertKeybind(event: KeyEvent, key: string, ctx: PromptContext) {
+    function handleInsertKeybind(event: KeyEvent, key: string, ctx: PromptContext): boolean {
         if (!keybinds?.hasKeybinds("insert") && !keybinds?.isPending()) return false
 
         const wasPending = keybinds.isPending()
@@ -191,7 +297,12 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
 
         switch (resolved.status) {
             case "pending":
-                pendingInsert = plainPending(resolved.display)
+                if (!wasPending) {
+                    const input = focusedInput(ctx)
+                    pendingTarget = input ? { input, offset: input.cursorOffset ?? 0 } : undefined
+                    pendingContext = ctx
+                }
+                pendingInsert = codec.decode(plainPending(resolved.display))
                 state.setPending(resolved.display)
                 updateTimeout(ctx)
                 return true
@@ -216,7 +327,7 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
                 pendingInsert = ""
                 state.setPending("")
                 updateTimeout(ctx)
-                return false
+                return wasPending ? handleInsertKeybind(event, key, ctx) : false
         }
     }
 
@@ -228,6 +339,9 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
             case "submit":
                 ctx.prompt()?.submit()
                 return true
+            case "command":
+                dispatchCommand((definition as HostKeybindDefinition).command!, ctx)
+                return true
             default:
                 return false
         }
@@ -237,14 +351,20 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
         const ref = ctx.prompt()
         const input = focusedInput(ctx)
         const text = input?.plainText ?? ref?.current.input ?? ""
-        const offset = clamp(input?.cursorOffset ?? text.length, 0, text.length)
+        const map = mapForHostText(text, input)
 
         if (input && text.length > 0) {
-            input.cursorOffset = Math.max(0, offset - 1)
+            const dw = displayWidth(text)
+            const offset = clamp(input?.cursorOffset ?? dw, 0, dw)
+            const charOffset = displayToChar(text, offset)
+            if (charOffset > 0 && text[charOffset - 1] !== "\n") {
+                input.cursorOffset = charToDisplay(text, displayToChar(text, Math.max(0, offset - 1)))
+            }
             clampNormalCursor(input)
         }
 
-        vim = { ...resetContext(vim), mode: "normal", statusMessage: "" }
+        const lastChange = nativeInsertUndoSaved ? [...vim.pendingChange, "Escape"] : vim.lastChange
+        vim = { ...resetContext(vim), cursor: hostPosition(map, input?.cursorOffset ?? 0), mode: "normal", statusMessage: "", lastChange, pendingChange: [] }
         nativeInsertUndoSaved = false
         syncMode(state, "normal")
     }
@@ -266,13 +386,97 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
 
         let actions: HostAction[] = []
         for (const token of parseKeySequence(definition.keys)) {
-            const result = processKeystroke(keyToken(token), vim, buffer, tokenCtrl(token), false)
+            const result = processKey(codec.encode(keyToken(token)), tokenCtrl(token))
             vim = result.newCtx
             actions = [...actions, ...(result.actions as HostAction[])]
         }
         return actions
     }
 
+    function processKey(key: string, ctrl = false): { newCtx: VimContext; actions: HostAction[] } {
+        let wordRange: MotionRange | undefined
+        if (!ctrl && vim.mode !== "insert" && (key === "w" || key === "W") && (vim.phase === "idle" || vim.phase === "operator-pending")) {
+            wordRange = forwardWordRange(key, vim.cursor, buffer, vim.count || 1)
+            if (vim.phase === "idle") {
+                const cursor = { ...wordRange.end, col: Math.min(wordRange.end.col, Math.max(0, buffer.getLineLength(wordRange.end.line) - 1)) }
+                return { newCtx: { ...resetContext(vim), cursor }, actions: [{ type: "cursor-move", position: cursor }] }
+            }
+        }
+        if (key === "." && !ctrl && vim.mode === "normal" && vim.phase === "idle" && vim.lastChange.length) {
+            // A repeated insert/change is one undo step, including native typing.
+            const original = buffer
+            const before = buffer.getContent()
+            const cursor = vim.cursor
+            const keys = [...vim.lastChange]
+            if (vim.count) {
+                while (/^[0-9]$/.test(keys[0] ?? "")) keys.shift()
+                keys.unshift(...String(vim.count))
+            }
+            vim = { ...vim, count: 0 }
+            const actions: HostAction[] = []
+            buffer = new TextBuffer(before)
+            try {
+                for (const token of keys) {
+                    const result = processKey(token)
+                    vim = result.newCtx
+                    actions.push(...result.actions)
+                }
+                if (buffer.getContent() !== before) {
+                    original.saveUndoPoint(cursor)
+                    original.replaceContent(buffer.getContent())
+                }
+            } finally {
+                buffer = original
+            }
+            return { newCtx: { ...vim, lastChange: keys, pendingChange: [] }, actions }
+        }
+
+        let range: MotionRange | undefined
+        const operator = vim.operator
+        if (!ctrl && operator && textObjectOperator(operator)) {
+            if (vim.phase === "operator-pending") {
+                const count = vim.count || 1
+                if (key === "l" || key === "ArrowRight") {
+                    // Vimee 0.3 treats l as inclusive; Vim's operator motion is exclusive.
+                    range = { start: vim.cursor, end: { line: vim.cursor.line, col: Math.min(buffer.getLineLength(vim.cursor.line), vim.cursor.col + count) }, inclusive: false, linewise: false }
+                } else if (key === operator) {
+                    range = { start: { line: vim.cursor.line, col: 0 }, end: { line: Math.min(buffer.getLineCount() - 1, vim.cursor.line + count - 1), col: 0 }, inclusive: true, linewise: true }
+                } else if (operator === "c" && key === "w" && /\S/.test(buffer.getLine(vim.cursor.line)[vim.cursor.col] ?? "")) {
+                    range = resolveMotion("e", { ...vim.cursor, col: vim.cursor.col - 1 }, buffer, count, vim.count > 0, vim)?.range
+                    if (range) range.start = vim.cursor
+                } else if (wordRange) {
+                    range = wordRange
+                    if (operator === "d" && range.end.line > range.start.line && /\S/.test(buffer.getLine(range.start.line)[range.start.col] ?? "") && range.end.col === Math.max(0, buffer.getLine(range.end.line).search(/\S/))) {
+                        range.end = { line: range.end.line - 1, col: buffer.getLineLength(range.end.line - 1) }
+                    }
+                } else if (operator === "c") {
+                    const motion = resolveMotion(key, vim.cursor, buffer, count, vim.count > 0, vim)
+                    if (motion?.range.linewise) range = motion.range
+                }
+            } else if (vim.phase === "text-object-pending" && vim.textObjectModifier) {
+                range = resolvePromptTextObject(vim.textObjectModifier, key, vim.cursor, buffer) ?? undefined
+            }
+        }
+        if (range && operator) {
+            const keys: string[] = []
+            if (vim.count) keys.push(...String(vim.count))
+            for (const token of vim.pendingChange) {
+                if (!/^[0-9]$/.test(token)) keys.push(token)
+            }
+            keys.push(key)
+            const result = executeTextObject(operator, range, buffer, vim)
+            if (operator === "y") result.context.pendingChange = []
+            else if (result.context.mode === "insert") result.context.pendingChange = keys
+            else { result.context.lastChange = keys; result.context.pendingChange = [] }
+            return { newCtx: result.context, actions: result.actions }
+        }
+
+        // The engine saves undo points for yanks too. Run read-only operations
+        // against a disposable buffer so they cannot alter the editing history.
+        const yanking = operator === "y" || (isVisualMode(vim.mode) && key === "y") || (vim.mode === "normal" && key === "Y")
+        return processKeystroke(key, vim, yanking ? new TextBuffer(buffer.getContent()) : buffer, ctrl, false)
+    }
+
     function handleTextObject(key: string, ctx: PromptContext, map: PromptMap) {
         if (vim.phase !== "text-object-pending" || !vim.textObjectModifier) return undefined
         const range = resolvePromptTextObject(vim.textObjectModifier, key, vim.cursor, buffer)
@@ -290,15 +494,10 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
         }
         if (!textObjectOperator(vim.operator)) return undefined
 
-        const originalCursor = vim.cursor
-        const result = executeTextObject(vim.operator, range, buffer, vim)
-        if (vim.operator === "y") {
-            result.context = { ...result.context, cursor: originalCursor }
-            result.actions = result.actions.map((action) => (action.type === "cursor-move" ? { ...action, position: originalCursor } : action))
-        }
-        vim = result.context
+        const result = processKey(key)
+        vim = result.newCtx
         applyActions(result.actions, ctx, map)
-        if (flashRange) flashYank(ctx, activeMap, { type: "yank", text: result.yankedText }, flashRange)
+        if (flashRange) flashYank(ctx, activeMap, result.actions.find((action): action is YankAction => action.type === "yank"), flashRange)
         syncMode(state, vim.mode)
         state.setPending("")
         updateTimeout(ctx)
@@ -326,21 +525,34 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
         keybinds.cancel()
         if (flush) flushPendingInsert(ctx, pendingInsert, offset)
         pendingInsert = ""
+        pendingTarget = undefined
+        pendingContext = undefined
         state.setPending("")
     }
 
-    function flushPendingInsert(ctx: PromptContext, value: string, offset?: number) {
+    function flushPendingInsert(ctx: PromptContext, value: string, charOffset?: number) {
         if (!value || state.mode() !== "insert") return
+        if (pendingTarget?.input.isDestroyed) return
+        if (pendingTarget?.input.insertText && !pendingTarget.input.isDestroyed) {
+            const { input, offset } = pendingTarget
+            const cursor = input.cursorOffset ?? 0
+            input.clearSelection?.()
+            input.cursorOffset = offset
+            input.insertText!(value)
+            input.cursorOffset = cursor >= offset ? cursor + displayWidth(value) : cursor
+            return
+        }
         const ref = ctx.prompt()
         if (!ref) return
         const input = focusedInput(ctx)
         const text = input?.plainText ?? ref.current.input
-        const insertAt = clamp(offset ?? input?.cursorOffset ?? text.length, 0, text.length)
-        const currentOffset = input?.cursorOffset ?? insertAt
-        const next = text.slice(0, insertAt) + value + text.slice(insertAt)
+        const currentDisplayOff = input?.cursorOffset ?? 0
+        const currentCharOff = displayToChar(text, currentDisplayOff)
+        const insertAtChar = charOffset ?? currentCharOff
+        const next = text.slice(0, insertAtChar) + value + text.slice(insertAtChar)
         setInput(ref, next)
-        const nextOffset = currentOffset >= insertAt ? currentOffset + value.length : currentOffset
-        if (input) input.cursorOffset = nextOffset
+        const nextCharOff = currentCharOff >= insertAtChar ? currentCharOff + value.length : currentCharOff
+        if (input) input.cursorOffset = displayWidth(next.slice(0, nextCharOff))
     }
 
     function cursorOffset(map: PromptMap, position: CursorPosition) {
@@ -357,7 +569,7 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
         if (!input?.gotoVisualLineEnd) return false
         clearVisualSelection(input)
         input.gotoVisualLineEnd()
-        vim = { ...vim, cursor: hostPosition(map, input.cursorOffset ?? map.hostText.length), mode: "insert", phase: "idle", count: 0, operator: null, statusMessage: "-- INSERT --" }
+        vim = { ...vim, cursor: hostPosition(map, input.cursorOffset ?? displayWidth(map.hostText)), mode: "insert", phase: "idle", count: 0, operator: null, pendingChange: ["A"], statusMessage: "-- INSERT --" }
         nativeInsertUndoSaved = false
         syncMode(state, "insert")
         return true
@@ -417,6 +629,30 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
     }
 }
 
+function forwardWordRange(key: string, start: CursorPosition, buffer: TextBuffer, count: number): MotionRange {
+    let { line, col } = start
+    for (let index = 0; index < count; index++) {
+        const text = buffer.getLine(line)
+        const kind = wordClass(text[col], key === "W")
+        while (col < text.length && wordClass(text[col], key === "W") === kind) col++
+        while (col < text.length && /\s/.test(text[col])) col++
+        while (col >= buffer.getLineLength(line) && line < buffer.getLineCount() - 1) {
+            line++
+            col = 0
+            const next = buffer.getLine(line)
+            if (!next.length) break
+            while (col < next.length && /\s/.test(next[col])) col++
+            if (col < next.length) break
+        }
+    }
+    return { start, end: { line, col }, linewise: false, inclusive: false }
+}
+
+function wordClass(char: string | undefined, big: boolean) {
+    if (!char || /\s/.test(char)) return "space"
+    return big || /\w/.test(char) ? "word" : "punctuation"
+}
+
 function visualCharRange(map: PromptMap, anchor: CursorPosition, cursor: CursorPosition): HostRange | undefined {
     const anchorOffset = hostOffset(map, anchor, "next")
     const cursorOffset = hostOffset(map, cursor, "previous")
@@ -457,14 +693,15 @@ function vimOffsetRange(map: PromptMap, left: number, right: number): HostRange
 
 function hostRange(map: PromptMap, left: number, right: number): HostRange | undefined {
     if (!map.hostText) return undefined
-    const start = clamp(Math.min(left, right), 0, Math.max(0, map.hostText.length - 1))
-    const end = clamp(Math.max(left, right), 0, Math.max(0, map.hostText.length - 1))
+    const dw = displayWidth(map.hostText)
+    const start = clamp(Math.min(left, right), 0, Math.max(0, dw - 1))
+    const end = clamp(Math.max(left, right), 0, Math.max(0, dw - 1))
     return { start, end }
 }
 
 type YankAction = Extract<VimeeAction, { type: "yank" }>
 
-function yankAction(actions: VimeeAction[]): YankAction | undefined {
+function yankAction(actions: HostAction[]): YankAction | undefined {
     return actions.find((action): action is YankAction => action.type === "yank")
 }
 
@@ -521,32 +758,71 @@ function vimOffsetFromPosition(text: string, position: CursorPosition) {
 
 function hostFromVimOffset(map: PromptMap, offset: number, bias: "previous" | "next") {
     const current = clamp(offset, 0, map.vimText.length)
-    if (current === map.vimText.length) return map.hostText.length
+    if (current === map.vimText.length) return displayWidth(map.hostText)
 
     const host = map.vimToHost[current]
-    if (host !== undefined) return host
+    if (host !== undefined) return charToDisplay(map.hostText, host)
 
     if (bias === "previous") {
         for (let previous = current - 1; previous >= 0; previous--) {
             const previousHost = map.vimToHost[previous]
-            if (previousHost !== undefined) return previousHost
+            if (previousHost !== undefined) return charToDisplay(map.hostText, previousHost)
         }
     }
 
     for (let next = current + 1; next < map.vimToHost.length; next++) {
         const nextHost = map.vimToHost[next]
-        if (nextHost !== undefined) return nextHost
+        if (nextHost !== undefined) return charToDisplay(map.hostText, nextHost)
     }
-    return map.hostText.length
+    return displayWidth(map.hostText)
 }
 
 function clampNormalCursor(input: EditBufferLike) {
     const cursor = input.visualCursor
-    const eol = input.editorView?.getVisualEOL?.()
     const offset = input.cursorOffset
-    if (!cursor || !eol || offset === undefined) return
+    const text = input.plainText
+    if (!cursor || offset === undefined || text === undefined) return
     if (cursor.visualCol === 0) return
-    if (cursor.visualRow === eol.visualRow && (cursor.offset === eol.offset || offset === eol.offset)) input.cursorOffset = Math.max(0, offset - 1)
+    const dw = displayWidth(text)
+    if (offset >= dw) {
+        input.cursorOffset = charToDisplay(text, displayToChar(text, Math.max(0, dw - 1)))
+        return
+    }
+    const charIdx = displayToChar(text, offset)
+    if (charIdx < text.length && text[charIdx] === '\n') {
+        input.cursorOffset = charToDisplay(text, displayToChar(text, Math.max(0, offset - 1)))
+    }
+}
+
+function dispatchCommand(command: string, ctx: PromptContext) {
+    const input = focusedInput(ctx)
+    if (command === "prompt.history.previous" && input) input.cursorOffset = 0
+    if (command === "prompt.history.next" && input) input.cursorOffset = input.plainText?.length ?? 0
+
+    const result = ctx.api.keymap.dispatchCommand(command)
+
+    // The host currently checks history-next using character length, then leaves
+    // the cursor in that unit. Restore the display-width offset after dispatch.
+    if (command !== "prompt.history.next" || !result.ok) return result
+    const nextInput = focusedInput(ctx)
+    if (nextInput?.plainText !== undefined) nextInput.cursorOffset = displayWidth(nextInput.plainText)
+    return result
+}
+
+function defaultHistoryCommand(key: string, text: string, historyText: string | undefined, enabled: Record<"j" | "k", boolean>) {
+    if (key !== "j" && key !== "k") return
+    if (!enabled[key]) return
+    if (text.length > 0 && text !== historyText) return
+    return key === "k" ? "prompt.history.previous" : "prompt.history.next"
+}
+
+function hasNormalKeyPrefix(config: VimConfig, key: string) {
+    for (const sequence of Object.keys(config.keymaps.normal ?? {})) {
+        try {
+            if (keyToken(parseKeySequence(sequence)[0] ?? "") === key) return true
+        } catch {}
+    }
+    return false
 }
 
 function endMotionOffset(text: string, offset: number, count: number) {
@@ -578,6 +854,8 @@ function createKeybinds(config: VimConfig, log: VimLog): KeybindMap | undefined
         if (!keymaps) continue
         for (const [keys, action] of Object.entries(keymaps)) {
             try {
+                const tokens = parseKeySequence(keys)
+                if (tokens.length > 1 && tokens[0] === "<CR>") throw new Error("<CR> cannot start a multi-key mapping")
                 map.addKeybind(mode, keys as ValidKeySequence<typeof keys>, keybindAction(action))
                 count++
             } catch (error) {
@@ -590,6 +868,15 @@ function createKeybinds(config: VimConfig, log: VimLog): KeybindMap | undefined
 }
 
 function keybindAction(action: string): HostKeybindDefinition {
+    if (action.startsWith("command:")) {
+        const command = action.slice(8).trim()
+        if (!command) throw new Error("Command name is required")
+        return {
+            execute: () => [{ type: "command", command } as unknown as VimeeAction],
+            hostAction: "command",
+            command,
+        }
+    }
     switch (action) {
         case "normal":
             return { keys: "<Esc>", hostAction: "normal" }
@@ -603,6 +890,7 @@ function keybindAction(action: string): HostKeybindDefinition {
 }
 
 function keyForVimee(event: KeyEvent, key: string) {
+    if (key === "<C-[>") return "Escape"
     if (event.ctrl) return event.name?.toLowerCase()
     const token = keyToken(key)
     return token.startsWith("<") ? undefined : token
@@ -634,17 +922,19 @@ function syncMode(state: VimState, mode: VimContext["mode"]) {
 }
 
 function pendingDisplay(ctx: VimContext, keybindPending: boolean) {
-    if (ctx.phase === "operator-pending") return ctx.operator ?? ""
-    if (ctx.phase === "text-object-pending") return ctx.textObjectModifier ?? ""
+    const count = ctx.count > 0 ? String(ctx.count) : ""
+    if (ctx.phase === "operator-pending") return count + (ctx.operator ?? "")
+    if (ctx.phase === "text-object-pending") return count + (ctx.operator ?? "") + (ctx.textObjectModifier ?? "")
+    if (ctx.phase === "char-pending") return count + (ctx.operator ?? "") + (ctx.charCommand ?? "")
     if (keybindPending) return ctx.statusMessage
-    return ""
+    return count
 }
 
 function plainPending(value: string) {
     return value.includes("<") || value.includes(">") ? "" : value
 }
 
-function consumesKey(key: string, actions: VimeeAction[], ctx: VimContext, keybindPending: boolean) {
+function consumesKey(key: string, actions: HostAction[], ctx: VimContext, keybindPending: boolean) {
     if (actions.length > 0) return true
     if (keybindPending) return true
     if (ctx.phase !== "idle") return true
@@ -677,7 +967,7 @@ function quoteRange(modifier: "i" | "a", cursor: CursorPosition, buffer: TextBuf
         start: { line: cursor.line, col: start },
         end: { line: cursor.line, col: Math.max(start, end) },
         linewise: false,
-        inclusive: true,
+        inclusive: end >= start,
     }
 }
 
@@ -769,7 +1059,7 @@ function quotePair(cursor: CursorPosition, buffer: TextBuffer, quote: string) {
 }
 
 function executeTextObject(operator: Operator, range: MotionRange, buffer: TextBuffer, ctx: VimContext) {
-    buffer.saveUndoPoint(ctx.cursor)
+    if (operator !== "y") buffer.saveUndoPoint(ctx.cursor)
     const result = range.linewise ? executeLinewiseTextObject(operator, range, buffer) : executeCharwiseTextObject(operator, range, buffer)
     const registers = ctx.selectedRegister ? { ...ctx.registers, [ctx.selectedRegister]: result.yankedText } : ctx.registers
     const context = {
@@ -794,9 +1084,9 @@ function executeLinewiseTextObject(operator: Operator, range: MotionRange, buffe
     }
 
     buffer.deleteLines(startLine, lineCount)
-    if (buffer.getLineCount() === 0) buffer.insertLine(0, "")
+    if (operator === "c") buffer.insertLine(startLine, "")
+    else if (buffer.getLineCount() === 0) buffer.insertLine(0, "")
     const line = Math.min(startLine, buffer.getLineCount() - 1)
-    if (operator === "c") buffer.insertLine(line, "")
     return {
         actions: [{ type: "content-change", content: buffer.getContent() }] as VimeeAction[],
         cursor: { line, col: 0 },