ruvim 0.1.0 → 0.3.0

data/lib/ruvim/app.rb

@@ -1,15 +1,39 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
 module RuVim
   class App
-    def initialize(path: nil, paths: nil, stdin: STDIN, stdout: STDOUT, pre_config_actions: [], startup_actions: [], clean: false, skip_user_config: false, config_path: nil, readonly: false, diff_mode: false, quickfix_errorfile: nil, session_file: nil, nomodifiable: false, restricted: false, verbose_level: 0, verbose_io: STDERR, startup_time_path: nil, startup_open_layout: nil, startup_open_count: nil)
+    LARGE_FILE_ASYNC_THRESHOLD_BYTES = 64 * 1024 * 1024
+    LARGE_FILE_STAGED_PREFIX_BYTES = 8 * 1024 * 1024
+    ASYNC_FILE_READ_CHUNK_BYTES = 1 * 1024 * 1024
+    ASYNC_FILE_EVENT_FLUSH_BYTES = 4 * 1024 * 1024
+
+    def initialize(path: nil, paths: nil, stdin: STDIN, ui_stdin: nil, stdin_stream_mode: false, stdout: STDOUT, pre_config_actions: [], startup_actions: [], clean: false, skip_user_config: false, config_path: nil, readonly: false, diff_mode: false, quickfix_errorfile: nil, session_file: nil, nomodifiable: false, restricted: false, verbose_level: 0, verbose_io: STDERR, startup_time_path: nil, startup_open_layout: nil, startup_open_count: nil)
+      startup_paths = Array(paths || path).compact
+      @ui_stdin = ui_stdin || stdin
+      @stdin_stream_mode = !!stdin_stream_mode
+      @stdin_stream_source = @stdin_stream_mode ? stdin : nil
       @editor = Editor.new
-      @terminal = Terminal.new(stdin:, stdout:)
-      @input = Input.new(stdin:)
+      @terminal = Terminal.new(stdin: @ui_stdin, stdout:)
+      @input = Input.new(@ui_stdin)
       @screen = Screen.new(terminal: @terminal)
       @dispatcher = Dispatcher.new
       @keymaps = KeymapManager.new
       @signal_r, @signal_w = IO.pipe
+      @stream_event_queue = nil
+      @stream_reader_thread = nil
+      @stream_buffer_id = nil
+      @stream_stop_requested = false
+      @async_file_loads = {}
       @cmdline_history = Hash.new { |h, k| h[k] = [] }
       @cmdline_history_index = nil
+      @cmdline_completion = nil
+      @pending_key_deadline = nil
+      @pending_ambiguous_invocation = nil
+      @insert_start_location = nil
+      @incsearch_preview = nil
       @needs_redraw = true
       @clean_mode = clean
       @skip_user_config = skip_user_config
@@ -28,6 +52,11 @@ module RuVim
       @startup_open_layout = startup_open_layout
       @startup_open_count = startup_open_count
       @editor.restricted_mode = @restricted_mode
+      @editor.stdin_stream_stop_handler = method(:stdin_stream_stop_command)
+      @editor.open_path_handler = method(:open_path_with_large_file_support)
+      @editor.keymap_manager = @keymaps
+      @editor.app_action_handler = method(:handle_editor_app_action)
+      load_command_line_history!
 
       startup_mark("init.start")
       register_builtins!
@@ -43,8 +72,10 @@ module RuVim
       install_signal_handlers
       startup_mark("signals.installed")
 
-      startup_paths = Array(paths || path).compact
-      if startup_paths.empty?
+      if @stdin_stream_mode && startup_paths.empty?
+        verbose_log(1, "startup: stdin stream buffer")
+        prepare_stdin_stream_buffer!
+      elsif startup_paths.empty?
         verbose_log(1, "startup: intro")
         @editor.show_intro_buffer_if_applicable!
       else
@@ -59,25 +90,45 @@ module RuVim
       verbose_log(1, "startup: run_startup_actions count=#{Array(startup_actions).length}")
       run_startup_actions!(startup_actions)
       startup_mark("startup_actions.done")
+      start_stdin_stream_reader! if @stream_buffer_id
       write_startuptime_log!
     end
 
     def run
       @terminal.with_ui do
         loop do
+          @needs_redraw = true if drain_stream_events!
           if @needs_redraw
             @screen.render(@editor)
             @needs_redraw = false
           end
           break unless @editor.running?
 
-          key = @input.read_key(wakeup_ios: [@signal_r])
-          next if key.nil?
+          key = @input.read_key(
+            wakeup_ios: [@signal_r],
+            timeout: loop_timeout_seconds,
+            esc_timeout: escape_sequence_timeout_seconds
+          )
+          if key.nil?
+            handle_pending_key_timeout if pending_key_timeout_expired?
+            clear_expired_transient_message_if_any
+            next
+          end
 
           handle_key(key)
           @needs_redraw = true
+
+          # Batch insert-mode keystrokes to avoid per-char rendering during paste
+          while @editor.mode == :insert && @input.has_pending_input?
+            batch_key = @input.read_key(timeout: 0, esc_timeout: 0)
+            break unless batch_key
+            handle_key(batch_key)
+          end
         end
       end
+    ensure
+      shutdown_background_readers!
+      save_command_line_history!
     end
 
     def run_startup_actions!(actions, log_prefix: "startup")
@@ -89,6 +140,59 @@ module RuVim
 
     private
 
+    def pending_key_timeout_seconds
+      return nil unless @pending_key_deadline
+
+      [@pending_key_deadline - monotonic_now, 0.0].max
+    end
+
+    def loop_timeout_seconds
+      now = monotonic_now
+      timeouts = []
+      if @pending_key_deadline
+        timeouts << [@pending_key_deadline - now, 0.0].max
+      end
+      if (msg_to = @editor.transient_message_timeout_seconds(now:))
+        timeouts << msg_to
+      end
+      timeouts.min
+    end
+
+    def pending_key_timeout_expired?
+      @pending_key_deadline && monotonic_now >= @pending_key_deadline
+    end
+
+    def escape_sequence_timeout_seconds
+      ms = @editor.global_options["ttimeoutlen"].to_i
+      ms = 50 if ms <= 0
+      ms / 1000.0
+    rescue StandardError
+      0.005
+    end
+
+    def arm_pending_key_timeout
+      ms = @editor.global_options["timeoutlen"].to_i
+      ms = 1000 if ms <= 0
+      @pending_key_deadline = monotonic_now + (ms / 1000.0)
+    end
+
+    def clear_pending_key_timeout
+      @pending_key_deadline = nil
+      @pending_ambiguous_invocation = nil
+    end
+
+    def handle_pending_key_timeout
+      inv = @pending_ambiguous_invocation
+      clear_pending_key_timeout
+      if inv
+        @dispatcher.dispatch(@editor, dup_invocation(inv))
+      elsif @pending_keys && !@pending_keys.empty?
+        @editor.echo_error("Unknown key: #{@pending_keys.join}")
+      end
+      @editor.pending_count = nil
+      @pending_keys = []
+    end
+
     def register_builtins!
       cmd = CommandRegistry.instance
       ex = ExCommandRegistry.instance
@@ -99,6 +203,17 @@ module RuVim
       register_internal_unless(cmd, "cursor.down", call: :cursor_down, desc: "Move cursor down")
       register_internal_unless(cmd, "cursor.page_up", call: :cursor_page_up, desc: "Move one page up")
       register_internal_unless(cmd, "cursor.page_down", call: :cursor_page_down, desc: "Move one page down")
+      register_internal_unless(cmd, "window.scroll_up", call: :window_scroll_up, desc: "Scroll window up")
+      register_internal_unless(cmd, "window.scroll_down", call: :window_scroll_down, desc: "Scroll window down")
+      register_internal_unless(cmd, "cursor.page_up.default", call: :cursor_page_up_default, desc: "Move one page up (view-sized)")
+      register_internal_unless(cmd, "cursor.page_down.default", call: :cursor_page_down_default, desc: "Move one page down (view-sized)")
+      register_internal_unless(cmd, "cursor.page_up.half", call: :cursor_page_up_half, desc: "Move half page up")
+      register_internal_unless(cmd, "cursor.page_down.half", call: :cursor_page_down_half, desc: "Move half page down")
+      register_internal_unless(cmd, "window.scroll_up.line", call: :window_scroll_up_line, desc: "Scroll window up one line")
+      register_internal_unless(cmd, "window.scroll_down.line", call: :window_scroll_down_line, desc: "Scroll window down one line")
+      register_internal_unless(cmd, "window.cursor_line_top", call: :window_cursor_line_top, desc: "Put cursor line at top")
+      register_internal_unless(cmd, "window.cursor_line_center", call: :window_cursor_line_center, desc: "Put cursor line at center")
+      register_internal_unless(cmd, "window.cursor_line_bottom", call: :window_cursor_line_bottom, desc: "Put cursor line at bottom")
       register_internal_unless(cmd, "cursor.line_start", call: :cursor_line_start, desc: "Move to column 1")
       register_internal_unless(cmd, "cursor.line_end", call: :cursor_line_end, desc: "Move to end of line")
       register_internal_unless(cmd, "cursor.first_nonblank", call: :cursor_first_nonblank, desc: "Move to first nonblank")
@@ -124,10 +239,17 @@ module RuVim
       register_internal_unless(cmd, "window.focus_right", call: :window_focus_right, desc: "Focus right window")
       register_internal_unless(cmd, "window.focus_up", call: :window_focus_up, desc: "Focus upper window")
       register_internal_unless(cmd, "window.focus_down", call: :window_focus_down, desc: "Focus lower window")
+      register_internal_unless(cmd, "window.focus_or_split_left", call: :window_focus_or_split_left, desc: "Focus left window or split")
+      register_internal_unless(cmd, "window.focus_or_split_right", call: :window_focus_or_split_right, desc: "Focus right window or split")
+      register_internal_unless(cmd, "window.focus_or_split_up", call: :window_focus_or_split_up, desc: "Focus upper window or split")
+      register_internal_unless(cmd, "window.focus_or_split_down", call: :window_focus_or_split_down, desc: "Focus lower window or split")
       register_internal_unless(cmd, "mode.command_line", call: :enter_command_line_mode, desc: "Enter command-line mode")
       register_internal_unless(cmd, "mode.search_forward", call: :enter_search_forward_mode, desc: "Enter / search")
       register_internal_unless(cmd, "mode.search_backward", call: :enter_search_backward_mode, desc: "Enter ? search")
       register_internal_unless(cmd, "buffer.delete_char", call: :delete_char, desc: "Delete char under cursor")
+      register_internal_unless(cmd, "buffer.substitute_char", call: :substitute_char, desc: "Substitute char(s)")
+      register_internal_unless(cmd, "buffer.swapcase_char", call: :swapcase_char, desc: "Swap case under cursor")
+      register_internal_unless(cmd, "buffer.join_lines", call: :join_lines, desc: "Join lines")
       register_internal_unless(cmd, "buffer.delete_line", call: :delete_line, desc: "Delete current line")
       register_internal_unless(cmd, "buffer.delete_motion", call: :delete_motion, desc: "Delete by motion")
       register_internal_unless(cmd, "buffer.change_motion", call: :change_motion, desc: "Change by motion")
@@ -153,12 +275,43 @@ module RuVim
       register_internal_unless(cmd, "jump.newer", call: :jump_newer, desc: "Jump newer")
       register_internal_unless(cmd, "editor.buffer_next", call: :buffer_next, desc: "Next buffer")
       register_internal_unless(cmd, "editor.buffer_prev", call: :buffer_prev, desc: "Previous buffer")
+      register_internal_unless(cmd, "editor.buffer_delete", call: :buffer_delete, desc: "Delete buffer")
       register_internal_unless(cmd, "buffer.replace_char", call: :replace_char, desc: "Replace single char")
+      register_internal_unless(cmd, "file.goto_under_cursor", call: :file_goto_under_cursor, desc: "Open file under cursor")
       register_internal_unless(cmd, "ui.clear_message", call: :clear_message, desc: "Clear message")
+      register_internal_unless(cmd, "normal.register_pending_start", call: ->(ctx, **) { ctx.editor.invoke_app_action(:normal_register_pending_start) }, desc: "Select register for next operation")
+      register_internal_unless(cmd, "normal.operator_delete_start", call: ->(ctx, **) { ctx.editor.invoke_app_action(:normal_operator_start, name: :delete) }, desc: "Start delete operator")
+      register_internal_unless(cmd, "normal.operator_yank_start", call: ->(ctx, **) { ctx.editor.invoke_app_action(:normal_operator_start, name: :yank) }, desc: "Start yank operator")
+      register_internal_unless(cmd, "normal.operator_change_start", call: ->(ctx, **) { ctx.editor.invoke_app_action(:normal_operator_start, name: :change) }, desc: "Start change operator")
+      register_internal_unless(cmd, "normal.operator_indent_start", call: ->(ctx, **) { ctx.editor.invoke_app_action(:normal_operator_start, name: :indent) }, desc: "Start indent operator")
+      register_internal_unless(cmd, "buffer.indent_lines", call: :indent_lines, desc: "Auto-indent lines")
+      register_internal_unless(cmd, "buffer.indent_motion", call: :indent_motion, desc: "Auto-indent motion range")
+      register_internal_unless(cmd, "buffer.visual_indent", call: :visual_indent, desc: "Auto-indent visual selection")
+      register_internal_unless(cmd, "normal.replace_pending_start", call: ->(ctx, **) { ctx.editor.invoke_app_action(:normal_replace_pending_start) }, desc: "Start replace-char pending")
+      register_internal_unless(cmd, "normal.find_char_forward_start", call: ->(ctx, **) { ctx.editor.invoke_app_action(:normal_find_pending_start, token: "f") }, desc: "Start char find forward")
+      register_internal_unless(cmd, "normal.find_char_backward_start", call: ->(ctx, **) { ctx.editor.invoke_app_action(:normal_find_pending_start, token: "F") }, desc: "Start char find backward")
+      register_internal_unless(cmd, "normal.find_till_forward_start", call: ->(ctx, **) { ctx.editor.invoke_app_action(:normal_find_pending_start, token: "t") }, desc: "Start till-char find forward")
+      register_internal_unless(cmd, "normal.find_till_backward_start", call: ->(ctx, **) { ctx.editor.invoke_app_action(:normal_find_pending_start, token: "T") }, desc: "Start till-char find backward")
+      register_internal_unless(cmd, "normal.find_repeat", call: ->(ctx, **) { ctx.editor.invoke_app_action(:normal_find_repeat, reverse: false) }, desc: "Repeat last f/t/F/T")
+      register_internal_unless(cmd, "normal.find_repeat_reverse", call: ->(ctx, **) { ctx.editor.invoke_app_action(:normal_find_repeat, reverse: true) }, desc: "Repeat last f/t/F/T in reverse")
+      register_internal_unless(cmd, "normal.change_repeat", call: ->(ctx, **) { ctx.editor.invoke_app_action(:normal_change_repeat) }, desc: "Repeat last change")
+      register_internal_unless(cmd, "normal.macro_record_toggle", call: ->(ctx, **) { ctx.editor.invoke_app_action(:normal_macro_record_toggle) }, desc: "Start/stop macro recording")
+      register_internal_unless(cmd, "normal.macro_play_pending_start", call: ->(ctx, **) { ctx.editor.invoke_app_action(:normal_macro_play_pending_start) }, desc: "Start macro play pending")
+      register_internal_unless(cmd, "normal.mark_pending_start", call: ->(ctx, **) { ctx.editor.invoke_app_action(:normal_mark_pending_start) }, desc: "Start mark set pending")
+      register_internal_unless(cmd, "normal.jump_mark_linewise_pending_start", call: ->(ctx, **) { ctx.editor.invoke_app_action(:normal_jump_pending_start, linewise: true, repeat_token: "'") }, desc: "Start linewise mark jump pending")
+      register_internal_unless(cmd, "normal.jump_mark_exact_pending_start", call: ->(ctx, **) { ctx.editor.invoke_app_action(:normal_jump_pending_start, linewise: false, repeat_token: "`") }, desc: "Start exact mark jump pending")
+      register_internal_unless(
+        cmd,
+        "stdin.stream_stop",
+        call: ->(ctx, **) { ctx.editor.stdin_stream_stop_or_cancel! },
+        desc: "Stop stdin follow stream (or cancel pending state)"
+      )
 
       register_ex_unless(ex, "w", call: :file_write, aliases: %w[write], desc: "Write current buffer", nargs: :maybe_one, bang: true)
       register_ex_unless(ex, "q", call: :app_quit, aliases: %w[quit], desc: "Quit", nargs: 0, bang: true)
+      register_ex_unless(ex, "qa", call: :app_quit_all, aliases: %w[qall], desc: "Quit all", nargs: 0, bang: true)
       register_ex_unless(ex, "wq", call: :file_write_quit, desc: "Write and quit", nargs: :maybe_one, bang: true)
+      register_ex_unless(ex, "wqa", call: :file_write_quit_all, aliases: %w[wqall xa xall], desc: "Write all and quit", nargs: 0, bang: true)
       register_ex_unless(ex, "e", call: :file_edit, aliases: %w[edit], desc: "Edit file / reload", nargs: :maybe_one, bang: true)
       register_ex_unless(ex, "help", call: :ex_help, desc: "Show help / topics", nargs: :any)
       register_ex_unless(ex, "command", call: :ex_define_command, desc: "Define user command", nargs: :any, bang: true)
@@ -167,7 +320,14 @@ module RuVim
       register_ex_unless(ex, "bnext", call: :buffer_next, aliases: %w[bn], desc: "Next buffer", nargs: 0, bang: true)
       register_ex_unless(ex, "bprev", call: :buffer_prev, aliases: %w[bp], desc: "Previous buffer", nargs: 0, bang: true)
       register_ex_unless(ex, "buffer", call: :buffer_switch, aliases: %w[b], desc: "Switch buffer", nargs: 1, bang: true)
+      register_ex_unless(ex, "bdelete", call: :buffer_delete, aliases: %w[bd], desc: "Delete buffer", nargs: :maybe_one, bang: true)
+      register_ex_unless(ex, "args", call: :arglist_show, desc: "Show argument list", nargs: 0)
+      register_ex_unless(ex, "next", call: :arglist_next, desc: "Next argument", nargs: 0)
+      register_ex_unless(ex, "prev", call: :arglist_prev, desc: "Previous argument", nargs: 0)
+      register_ex_unless(ex, "first", call: :arglist_first, desc: "First argument", nargs: 0)
+      register_ex_unless(ex, "last", call: :arglist_last, desc: "Last argument", nargs: 0)
       register_ex_unless(ex, "commands", call: :ex_commands, desc: "List Ex commands", nargs: 0)
+      register_ex_unless(ex, "bindings", call: :ex_bindings, desc: "List active key bindings", nargs: :any)
       register_ex_unless(ex, "set", call: :ex_set, desc: "Set options", nargs: :any)
       register_ex_unless(ex, "setlocal", call: :ex_setlocal, desc: "Set window/buffer local option", nargs: :any)
       register_ex_unless(ex, "setglobal", call: :ex_setglobal, desc: "Set global option", nargs: :any)
@@ -176,6 +336,7 @@ module RuVim
       register_ex_unless(ex, "tabnew", call: :tab_new, desc: "New tab", nargs: :maybe_one)
       register_ex_unless(ex, "tabnext", call: :tab_next, aliases: %w[tabn], desc: "Next tab", nargs: 0)
       register_ex_unless(ex, "tabprev", call: :tab_prev, aliases: %w[tabp], desc: "Prev tab", nargs: 0)
+      register_ex_unless(ex, "tabs", call: :tab_list, desc: "List tabs", nargs: 0)
       register_ex_unless(ex, "vimgrep", call: :ex_vimgrep, desc: "Populate quickfix from regex (minimal)", nargs: :any)
       register_ex_unless(ex, "lvimgrep", call: :ex_lvimgrep, desc: "Populate location list from regex (minimal)", nargs: :any)
       register_ex_unless(ex, "copen", call: :ex_copen, desc: "Open quickfix list", nargs: 0)
@@ -186,6 +347,15 @@ module RuVim
       register_ex_unless(ex, "lclose", call: :ex_lclose, desc: "Close location list window", nargs: 0)
       register_ex_unless(ex, "lnext", call: :ex_lnext, aliases: %w[ln], desc: "Next location item", nargs: 0)
       register_ex_unless(ex, "lprev", call: :ex_lprev, aliases: %w[lp], desc: "Prev location item", nargs: 0)
+      register_ex_unless(ex, "grep", call: :ex_grep, desc: "Search with external grep", nargs: :any)
+      register_ex_unless(ex, "lgrep", call: :ex_lgrep, desc: "Search with external grep (location list)", nargs: :any)
+      register_ex_unless(ex, "d", call: :ex_delete_lines, aliases: %w[delete], desc: "Delete lines", nargs: :any)
+      register_ex_unless(ex, "y", call: :ex_yank_lines, aliases: %w[yank], desc: "Yank lines", nargs: :any)
+      register_ex_unless(ex, "rich", call: :ex_rich, desc: "Open/close Rich View", nargs: :maybe_one)
+      register_internal_unless(cmd, "rich.toggle", call: :rich_toggle, desc: "Toggle Rich View")
+      register_internal_unless(cmd, "quickfix.next", call: :ex_cnext, desc: "Next quickfix item")
+      register_internal_unless(cmd, "quickfix.prev", call: :ex_cprev, desc: "Prev quickfix item")
+      register_internal_unless(cmd, "quickfix.open", call: :ex_copen, desc: "Open quickfix list")
     end
 
     def bind_default_keys!
@@ -193,6 +363,10 @@ module RuVim
       @keymaps.bind(:normal, "j", "cursor.down")
       @keymaps.bind(:normal, "k", "cursor.up")
       @keymaps.bind(:normal, "l", "cursor.right")
+      @keymaps.bind(:normal, ["<Left>"], "cursor.left")
+      @keymaps.bind(:normal, ["<Down>"], "cursor.down")
+      @keymaps.bind(:normal, ["<Up>"], "cursor.up")
+      @keymaps.bind(:normal, ["<Right>"], "cursor.right")
       @keymaps.bind(:normal, "0", "cursor.line_start")
       @keymaps.bind(:normal, "$", "cursor.line_end")
       @keymaps.bind(:normal, "^", "cursor.first_nonblank")
@@ -216,198 +390,248 @@ module RuVim
       @keymaps.bind(:normal, ["<C-w>", "j"], "window.focus_down")
       @keymaps.bind(:normal, ["<C-w>", "k"], "window.focus_up")
       @keymaps.bind(:normal, ["<C-w>", "l"], "window.focus_right")
+      @keymaps.bind(:normal, ["<S-Left>"], "window.focus_or_split_left")
+      @keymaps.bind(:normal, ["<S-Right>"], "window.focus_or_split_right")
+      @keymaps.bind(:normal, ["<S-Up>"], "window.focus_or_split_up")
+      @keymaps.bind(:normal, ["<S-Down>"], "window.focus_or_split_down")
       @keymaps.bind(:normal, ":", "mode.command_line")
       @keymaps.bind(:normal, "/", "mode.search_forward")
       @keymaps.bind(:normal, "?", "mode.search_backward")
       @keymaps.bind(:normal, "x", "buffer.delete_char")
+      @keymaps.bind(:normal, "X", "buffer.delete_motion", kwargs: { motion: "h" })
+      @keymaps.bind(:normal, "s", "buffer.substitute_char")
+      @keymaps.bind(:normal, "D", "buffer.delete_motion", kwargs: { motion: "$" })
+      @keymaps.bind(:normal, "C", "buffer.change_motion", kwargs: { motion: "$" })
+      @keymaps.bind(:normal, "S", "buffer.change_line")
+      @keymaps.bind(:normal, "Y", "buffer.yank_line")
+      @keymaps.bind(:normal, "J", "buffer.join_lines")
+      @keymaps.bind(:normal, "~", "buffer.swapcase_char")
+      @keymaps.bind(:normal, "\"", "normal.register_pending_start")
+      @keymaps.bind(:normal, "d", "normal.operator_delete_start")
+      @keymaps.bind(:normal, "y", "normal.operator_yank_start")
+      @keymaps.bind(:normal, "c", "normal.operator_change_start")
+      @keymaps.bind(:normal, "=", "normal.operator_indent_start")
+      @keymaps.bind(:normal, "r", "normal.replace_pending_start")
+      @keymaps.bind(:normal, "f", "normal.find_char_forward_start")
+      @keymaps.bind(:normal, "F", "normal.find_char_backward_start")
+      @keymaps.bind(:normal, "t", "normal.find_till_forward_start")
+      @keymaps.bind(:normal, "T", "normal.find_till_backward_start")
+      @keymaps.bind(:normal, ";", "normal.find_repeat")
+      @keymaps.bind(:normal, ",", "normal.find_repeat_reverse")
+      @keymaps.bind(:normal, ".", "normal.change_repeat")
+      @keymaps.bind(:normal, "q", "normal.macro_record_toggle")
+      @keymaps.bind(:normal, "@", "normal.macro_play_pending_start")
+      @keymaps.bind(:normal, "m", "normal.mark_pending_start")
+      @keymaps.bind(:normal, "'", "normal.jump_mark_linewise_pending_start")
+      @keymaps.bind(:normal, "`", "normal.jump_mark_exact_pending_start")
       @keymaps.bind(:normal, "p", "buffer.paste_after")
       @keymaps.bind(:normal, "P", "buffer.paste_before")
       @keymaps.bind(:normal, "u", "buffer.undo")
       @keymaps.bind(:normal, ["<C-r>"], "buffer.redo")
       @keymaps.bind(:normal, ["<C-o>"], "jump.older")
       @keymaps.bind(:normal, ["<C-i>"], "jump.newer")
+      @keymaps.bind(:normal, ["<C-d>"], "cursor.page_down.half")
+      @keymaps.bind(:normal, ["<C-u>"], "cursor.page_up.half")
+      @keymaps.bind(:normal, ["<C-f>"], "cursor.page_down.default")
+      @keymaps.bind(:normal, ["<C-b>"], "cursor.page_up.default")
+      @keymaps.bind(:normal, ["<C-e>"], "window.scroll_down.line")
+      @keymaps.bind(:normal, ["<C-y>"], "window.scroll_up.line")
+      @keymaps.bind(:normal, "zt", "window.cursor_line_top")
+      @keymaps.bind(:normal, "zz", "window.cursor_line_center")
+      @keymaps.bind(:normal, "zb", "window.cursor_line_bottom")
+      @keymaps.bind(:normal, ["<C-c>"], "stdin.stream_stop")
       @keymaps.bind(:normal, "n", "search.next")
       @keymaps.bind(:normal, "N", "search.prev")
       @keymaps.bind(:normal, "*", "search.word_forward")
       @keymaps.bind(:normal, "#", "search.word_backward")
       @keymaps.bind(:normal, "g*", "search.word_forward_partial")
       @keymaps.bind(:normal, "g#", "search.word_backward_partial")
+      @keymaps.bind(:normal, "gf", "file.goto_under_cursor")
+      @keymaps.bind(:normal, "gr", "rich.toggle")
+      @keymaps.bind(:normal, "Q", "quickfix.open")
+      @keymaps.bind(:normal, ["]", "q"], "quickfix.next")
+      @keymaps.bind(:normal, ["[", "q"], "quickfix.prev")
+      @keymaps.bind(:normal, ["<PageUp>"], "cursor.page_up.default")
+      @keymaps.bind(:normal, ["<PageDown>"], "cursor.page_down.default")
       @keymaps.bind(:normal, "\e", "ui.clear_message")
     end
 
     def handle_key(key)
+      mode_before = @editor.mode
+      clear_stale_message_before_key(key)
       @skip_record_for_current_key = false
       append_dot_change_capture_key(key)
-      if key == :ctrl_c
+      if key == :ctrl_z
+        suspend_to_shell
+        track_mode_transition(mode_before)
+        return
+      end
+      if key == :ctrl_c && @editor.mode != :normal
         handle_ctrl_c
+        track_mode_transition(mode_before)
         record_macro_key_if_needed(key)
         return
       end
 
       case @editor.mode
+      when :hit_enter
+        handle_hit_enter_key(key)
       when :insert
         handle_insert_key(key)
       when :command_line
         handle_command_line_key(key)
       when :visual_char, :visual_line, :visual_block
         handle_visual_key(key)
+      when :rich
+        handle_rich_key(key)
       else
         handle_normal_key(key)
       end
+      track_mode_transition(mode_before)
       load_current_ftplugin!
       record_macro_key_if_needed(key)
+    rescue RuVim::CommandError => e
+      @editor.echo_error(e.message)
     end
 
-    def handle_normal_key(key)
-      if arrow_key?(key)
-        invoke_arrow(key)
-        return
+    def clear_stale_message_before_key(key)
+      return if @editor.message.to_s.empty?
+      return if @editor.command_line_active?
+      return if @editor.hit_enter_active?
+
+      # Keep the error visible while the user is still dismissing/cancelling;
+      # otherwise, the next operation replaces the command-line area naturally.
+      return if key == :ctrl_c
+
+      @editor.clear_message
+    end
+
+    def handle_editor_app_action(name, **kwargs)
+      if @editor.rich_mode?
+        case name.to_sym
+        when :normal_operator_start
+          op = (kwargs[:name] || kwargs["name"]).to_sym
+          return if op == :delete || op == :change
+        when :normal_replace_pending_start, :normal_change_repeat
+          return
+        end
       end
 
-      if paging_key?(key)
-        invoke_page_key(key)
-        return
+      case name.to_sym
+      when :normal_register_pending_start
+        start_register_pending
+      when :normal_operator_start
+        start_operator_pending((kwargs[:name] || kwargs["name"]).to_sym)
+      when :normal_replace_pending_start
+        start_replace_pending
+      when :normal_find_pending_start
+        start_find_pending((kwargs[:token] || kwargs["token"]).to_s)
+      when :normal_find_repeat
+        repeat_last_find(reverse: !!(kwargs[:reverse] || kwargs["reverse"]))
+      when :normal_change_repeat
+        repeat_last_change
+      when :normal_macro_record_toggle
+        toggle_macro_recording_or_start_pending
+      when :normal_macro_play_pending_start
+        start_macro_play_pending
+      when :normal_mark_pending_start
+        start_mark_pending
+      when :normal_jump_pending_start
+        start_jump_pending(
+          linewise: !!(kwargs[:linewise] || kwargs["linewise"]),
+          repeat_token: (kwargs[:repeat_token] || kwargs["repeat_token"]).to_s
+        )
+      else
+        raise RuVim::CommandError, "Unknown app action: #{name}"
+      end
+    end
+
+    def handle_normal_key(key)
+      case
+      when handle_normal_key_pre_dispatch(key)
+      when (token = normalize_key_token(key)).nil?
+      when handle_normal_pending_state(token)
+      when handle_normal_direct_token(token)
+      else
+        @pending_keys ||= []
+        @pending_keys << token
+        resolve_normal_key_sequence
       end
+    end
 
-      if digit_key?(key) && count_digit_allowed?(key)
+    def handle_normal_key_pre_dispatch(key)
+      case
+      when key == :enter && handle_list_window_enter
+      when digit_key?(key) && count_digit_allowed?(key)
         @editor.pending_count = (@editor.pending_count.to_s + key).to_i
         @editor.echo(@editor.pending_count.to_s)
         @pending_keys = []
-        return
+      else
+        return false
       end
+      true
+    end
 
-      token = normalize_key_token(key)
-      return if token.nil?
-
-      if @operator_pending
+    def handle_normal_pending_state(token)
+      case
+      when @pending_keys && !@pending_keys.empty?
+        @pending_keys << token
+        resolve_normal_key_sequence
+      when @operator_pending
         handle_operator_pending_key(token)
-        return
-      end
-
-      if @register_pending
+      when @register_pending
         finish_register_pending(token)
-        return
-      end
-
-      if @mark_pending
+      when @mark_pending
         finish_mark_pending(token)
-        return
-      end
-
-      if @jump_pending
+      when @jump_pending
         finish_jump_pending(token)
-        return
-      end
-
-      if @macro_record_pending
+      when @macro_record_pending
         finish_macro_record_pending(token)
-        return
-      end
-
-      if @macro_play_pending
+      when @macro_play_pending
         finish_macro_play_pending(token)
-        return
-      end
-
-      if @replace_pending
+      when @replace_pending
         handle_replace_pending_key(token)
-        return
-      end
-
-      if @find_pending
+      when @find_pending
         finish_find_pending(token)
-        return
-      end
-
-      if token == "\""
-        start_register_pending
-        return
-      end
-
-      if token == "d"
-        start_operator_pending(:delete)
-        return
-      end
-
-      if token == "y"
-        start_operator_pending(:yank)
-        return
-      end
-
-      if token == "c"
-        start_operator_pending(:change)
-        return
-      end
-
-      if token == "r"
-        start_replace_pending
-        return
-      end
-
-      if %w[f F t T].include?(token)
-        start_find_pending(token)
-        return
-      end
-
-      if token == ";"
-        repeat_last_find(reverse: false)
-        return
-      end
-
-      if token == ","
-        repeat_last_find(reverse: true)
-        return
-      end
-
-      if token == "."
-        repeat_last_change
-        return
-      end
-
-      if token == "q"
-        if @editor.macro_recording?
-          stop_macro_recording
-        else
-          start_macro_record_pending
-        end
-        return
-      end
-
-      if token == "@"
-        start_macro_play_pending
-        return
-      end
-
-      if token == "m"
-        start_mark_pending
-        return
-      end
-
-      if token == "'"
-        start_jump_pending(linewise: true, repeat_token: "'")
-        return
-      end
-
-      if token == "`"
-        start_jump_pending(linewise: false, repeat_token: "`")
-        return
+      else
+        return false
       end
+      true
+    end
 
-      @pending_keys ||= []
-      @pending_keys << token
+    def handle_normal_direct_token(token)
+      false
+    end
 
+    def resolve_normal_key_sequence
       match = @keymaps.resolve_with_context(:normal, @pending_keys, editor: @editor)
       case match.status
       when :pending, :ambiguous
+        if match.status == :ambiguous && match.invocation
+          inv = dup_invocation(match.invocation)
+          inv.count = @editor.pending_count
+          @pending_ambiguous_invocation = inv
+        else
+          @pending_ambiguous_invocation = nil
+        end
+        arm_pending_key_timeout
         return
       when :match
+        clear_pending_key_timeout
         matched_keys = @pending_keys.dup
-        repeat_count = @editor.pending_count || 1
+        repeat_count = @editor.pending_count
+        @pending_keys = []
         invocation = dup_invocation(match.invocation)
         invocation.count = repeat_count
+        if @editor.rich_mode? && rich_mode_block_command?(invocation.id)
+          @editor.pending_count = nil
+          @pending_keys = []
+          return
+        end
         @dispatcher.dispatch(@editor, invocation)
         maybe_record_simple_dot_change(invocation, matched_keys, repeat_count)
       else
+        clear_pending_key_timeout
         @editor.echo_error("Unknown key: #{@pending_keys.join}")
       end
       @editor.pending_count = nil
@@ -424,28 +648,27 @@ module RuVim
         @editor.echo("")
       when :backspace
         clear_insert_completion
-        y, x = @editor.current_buffer.backspace(@editor.current_window.cursor_y, @editor.current_window.cursor_x)
-        @editor.current_window.cursor_y = y
-        @editor.current_window.cursor_x = x
+        return unless insert_backspace_allowed?
+        insert_backspace_in_insert_mode
       when :ctrl_n
         insert_complete(+1)
       when :ctrl_p
         insert_complete(-1)
       when :ctrl_i
         clear_insert_completion
-        @editor.current_buffer.insert_char(@editor.current_window.cursor_y, @editor.current_window.cursor_x, "\t")
-        @editor.current_window.cursor_x += 1
+        insert_tab_in_insert_mode
       when :enter
         clear_insert_completion
         y, x = @editor.current_buffer.insert_newline(@editor.current_window.cursor_y, @editor.current_window.cursor_x)
+        x = apply_insert_autoindent(y, x, previous_row: y - 1)
         @editor.current_window.cursor_y = y
         @editor.current_window.cursor_x = x
       when :left
         clear_insert_completion
-        @editor.current_window.move_left(@editor.current_buffer, 1)
+        dispatch_insert_cursor_motion("cursor.left")
       when :right
         clear_insert_completion
-        @editor.current_window.move_right(@editor.current_buffer, 1)
+        dispatch_insert_cursor_motion("cursor.right")
       when :up
         clear_insert_completion
         @editor.current_window.move_up(@editor.current_buffer, 1)
@@ -461,6 +684,8 @@ module RuVim
         clear_insert_completion
         @editor.current_buffer.insert_char(@editor.current_window.cursor_y, @editor.current_window.cursor_x, key)
         @editor.current_window.cursor_x += 1
+        maybe_showmatch_after_insert(key)
+        maybe_dedent_after_insert(key)
       end
     end
 
@@ -506,6 +731,8 @@ module RuVim
       when "d"
         @visual_pending = nil
         @dispatcher.dispatch(@editor, CommandInvocation.new(id: "buffer.visual_delete"))
+      when "="
+        @dispatcher.dispatch(@editor, CommandInvocation.new(id: "buffer.visual_indent"))
       when "\""
         start_register_pending
       when "i", "a"
@@ -551,6 +778,7 @@ module RuVim
       if token == "g"
         @pending_keys ||= []
         @pending_keys << token
+        arm_pending_key_timeout
         return
       end
 
@@ -559,9 +787,11 @@ module RuVim
       end
 
       if id
-        count = @editor.pending_count || 1
+        clear_pending_key_timeout
+        count = @editor.pending_count
         @dispatcher.dispatch(@editor, CommandInvocation.new(id:, count: count))
       else
+        clear_pending_key_timeout
         @editor.echo_error("Unknown visual key: #{token}")
       end
     ensure
@@ -572,29 +802,87 @@ module RuVim
       cmd = @editor.command_line
       case key
       when :escape
+        clear_command_line_completion
+        cancel_incsearch_preview_if_any
         @editor.cancel_command_line
       when :enter
+        clear_command_line_completion
         line = cmd.text.dup
         push_command_line_history(cmd.prefix, line)
         handle_command_line_submit(cmd.prefix, line)
       when :backspace
+        clear_command_line_completion
+        if cmd.text.empty? && cmd.cursor.zero?
+          cancel_incsearch_preview_if_any
+          @editor.cancel_command_line
+          return
+        end
         cmd.backspace
       when :up
+        clear_command_line_completion
         command_line_history_move(-1)
       when :down
+        clear_command_line_completion
         command_line_history_move(1)
       when :left
+        clear_command_line_completion
         cmd.move_left
       when :right
+        clear_command_line_completion
         cmd.move_right
       else
         if key == :ctrl_i
           command_line_complete
         elsif key.is_a?(String)
+          clear_command_line_completion
           @cmdline_history_index = nil
           cmd.insert(key)
         end
       end
+      update_incsearch_preview_if_needed
+    end
+
+    def handle_list_window_enter
+      buffer = @editor.current_buffer
+      return false unless buffer.kind == :quickfix || buffer.kind == :location_list
+
+      item_index = @editor.current_window.cursor_y - 2
+      if item_index.negative?
+        @editor.echo_error("No list item on this line")
+        return true
+      end
+
+      source_window_id = buffer.options["ruvim_list_source_window_id"]
+      source_window_id = source_window_id.to_i if source_window_id
+      source_window_id = nil unless source_window_id && @editor.windows.key?(source_window_id)
+
+      item =
+        if buffer.kind == :quickfix
+          @editor.select_quickfix(item_index)
+        else
+          owner_window_id = source_window_id || @editor.current_window_id
+          @editor.select_location_list(item_index, window_id: owner_window_id)
+        end
+
+      unless item
+        @editor.echo_error("#{buffer.kind == :quickfix ? 'quickfix' : 'location list'} item not found")
+        return true
+      end
+
+      if source_window_id
+        @editor.current_window_id = source_window_id
+      end
+      @editor.jump_to_location(item)
+      @editor.echo(
+        if buffer.kind == :quickfix
+          "qf #{@editor.quickfix_index.to_i + 1}/#{@editor.quickfix_items.length}"
+        else
+          owner_window_id = source_window_id || @editor.current_window_id
+          list = @editor.location_list(owner_window_id)
+          "ll #{list[:index].to_i + 1}/#{list[:items].length}"
+        end
+      )
+      true
     end
 
     def arrow_key?(key)
@@ -612,7 +900,7 @@ module RuVim
         up: "cursor.up",
         down: "cursor.down"
       }.fetch(key)
-      inv = CommandInvocation.new(id:, count: @editor.pending_count || 1)
+      inv = CommandInvocation.new(id:, count: @editor.pending_count)
       @dispatcher.dispatch(@editor, inv)
       @editor.pending_count = nil
       @pending_keys = []
@@ -622,7 +910,7 @@ module RuVim
       id = (key == :pageup ? "cursor.page_up" : "cursor.page_down")
       inv = CommandInvocation.new(
         id: id,
-        count: @editor.pending_count || 1,
+        count: @editor.pending_count,
         kwargs: { page_lines: current_page_step_lines }
       )
       @dispatcher.dispatch(@editor, inv)
@@ -630,13 +918,6 @@ module RuVim
       @pending_keys = []
     end
 
-    def current_page_step_lines
-      height = @screen.current_window_view_height(@editor)
-      [height - 1, 1].max
-    rescue StandardError
-      1
-    end
-
     def digit_key?(key)
       key.is_a?(String) && key.match?(/\A\d\z/)
     end
@@ -653,14 +934,30 @@ module RuVim
       when String then key
       when :escape then "\e"
       when :ctrl_r then "<C-r>"
+      when :ctrl_d then "<C-d>"
+      when :ctrl_u then "<C-u>"
+      when :ctrl_f then "<C-f>"
+      when :ctrl_b then "<C-b>"
+      when :ctrl_e then "<C-e>"
+      when :ctrl_y then "<C-y>"
       when :ctrl_v then "<C-v>"
       when :ctrl_i then "<C-i>"
       when :ctrl_o then "<C-o>"
       when :ctrl_w then "<C-w>"
+      when :ctrl_l then "<C-l>"
+      when :ctrl_c then "<C-c>"
+      when :left then "<Left>"
+      when :right then "<Right>"
+      when :up then "<Up>"
+      when :down then "<Down>"
       when :home then "<Home>"
       when :end then "<End>"
       when :pageup then "<PageUp>"
       when :pagedown then "<PageDown>"
+      when :shift_up then "<S-Up>"
+      when :shift_down then "<S-Down>"
+      when :shift_left then "<S-Left>"
+      when :shift_right then "<S-Right>"
       else nil
       end
     end
@@ -676,23 +973,81 @@ module RuVim
       )
     end
 
+    # Rich mode: delegates to normal mode key handling but blocks mutating operations.
+    RICH_MODE_BLOCKED_COMMANDS = %w[
+      mode.insert mode.append mode.append_line_end mode.insert_nonblank
+      mode.open_below mode.open_above
+      buffer.delete_char buffer.delete_line buffer.delete_motion
+      buffer.change_motion buffer.change_line
+      buffer.paste_after buffer.paste_before
+      buffer.replace_char
+      buffer.visual_delete
+    ].freeze
+
+    def handle_hit_enter_key(key)
+      token = normalize_key_token(key)
+      case token
+      when ":"
+        @editor.exit_hit_enter_mode
+        @editor.enter_command_line_mode(":")
+      when "/", "?"
+        @editor.exit_hit_enter_mode
+        @editor.enter_command_line_mode(token)
+      else
+        @editor.exit_hit_enter_mode
+      end
+    end
+
+    def handle_rich_key(key)
+      token = normalize_key_token(key)
+      if token == "\e"
+        RuVim::RichView.close!(@editor)
+        return
+      end
+
+      handle_normal_key(key)
+    end
+
+    def rich_mode_block_command?(command_id)
+      RICH_MODE_BLOCKED_COMMANDS.include?(command_id.to_s)
+    end
+
     def handle_ctrl_c
       case @editor.mode
+      when :hit_enter
+        @editor.exit_hit_enter_mode
       when :insert
         finish_insert_change_group
         finish_dot_change_capture
         clear_insert_completion
+        clear_pending_key_timeout
         @editor.enter_normal_mode
         @editor.echo("")
       when :command_line
+        clear_pending_key_timeout
+        cancel_incsearch_preview_if_any
         @editor.cancel_command_line
       when :visual_char, :visual_line, :visual_block
         @visual_pending = nil
         @register_pending = false
         @mark_pending = false
         @jump_pending = nil
+        clear_pending_key_timeout
         @editor.enter_normal_mode
+      when :rich
+        clear_pending_key_timeout
+        @editor.pending_count = nil
+        @pending_keys = []
+        @operator_pending = nil
+        @replace_pending = nil
+        @register_pending = false
+        @mark_pending = false
+        @jump_pending = nil
+        @macro_record_pending = false
+        @macro_play_pending = false
+        RuVim::RichView.close!(@editor)
       else
+        clear_pending_key_timeout
         @editor.pending_count = nil
         @pending_keys = []
         @operator_pending = nil
@@ -706,11 +1061,34 @@ module RuVim
       end
     end
 
+    def handle_normal_ctrl_c
+      clear_pending_key_timeout
+      @editor.pending_count = nil
+      @pending_keys = []
+      @operator_pending = nil
+      @replace_pending = nil
+      @register_pending = false
+      @mark_pending = false
+      @jump_pending = nil
+      @macro_record_pending = false
+      @macro_play_pending = false
+      @editor.clear_message
+    end
+
+    def suspend_to_shell
+      @terminal.suspend_for_tstp
+      @screen.invalidate_cache! if @screen.respond_to?(:invalidate_cache!)
+      @needs_redraw = true
+    rescue StandardError => e
+      @editor.echo_error("suspend failed: #{e.message}")
+    end
+
     def finish_insert_change_group
       @editor.current_buffer.end_change_group
     end
 
     def handle_command_line_submit(prefix, line)
+      clear_incsearch_preview_state(apply: false) if %w[/ ?].include?(prefix)
       case prefix
       when ":"
         verbose_log(2, "ex: #{line}")
@@ -729,7 +1107,7 @@ module RuVim
     end
 
     def start_operator_pending(name)
-      @operator_pending = { name:, count: (@editor.pending_count || 1) }
+      @operator_pending = { name:, count: @editor.pending_count }
       @editor.pending_count = nil
       @pending_keys = []
       @editor.echo(name == :delete ? "d" : name.to_s)
@@ -804,6 +1182,14 @@ module RuVim
       @editor.echo("q")
     end
 
+    def toggle_macro_recording_or_start_pending
+      if @editor.macro_recording?
+        stop_macro_recording
+      else
+        start_macro_record_pending
+      end
+    end
+
     def finish_macro_record_pending(token)
       @macro_record_pending = false
       if token == "\e"
@@ -851,7 +1237,7 @@ module RuVim
         return
       end
 
-      count = @editor.pending_count || 1
+      count = @editor.pending_count
       @editor.pending_count = nil
       play_macro(name, count:)
     end
@@ -873,7 +1259,7 @@ module RuVim
       @last_macro_name = reg
       @macro_play_stack << reg
       @suspend_macro_recording_depth = (@suspend_macro_recording_depth || 0) + 1
-      count.times do
+      [count.to_i, 1].max.times do
         keys.each { |k| handle_key(dup_macro_runtime_key(k)) }
       end
       @editor.echo("@#{reg}")
@@ -944,6 +1330,18 @@ module RuVim
         return
       end
 
+      if op[:name] == :indent && motion == "="
+        inv = CommandInvocation.new(id: "buffer.indent_lines", count: op[:count])
+        @dispatcher.dispatch(@editor, inv)
+        return
+      end
+
+      if op[:name] == :indent
+        inv = CommandInvocation.new(id: "buffer.indent_motion", count: op[:count], kwargs: { motion: motion })
+        @dispatcher.dispatch(@editor, inv)
+        return
+      end
+
       if op[:name] == :change && motion == "c"
         inv = CommandInvocation.new(id: "buffer.change_line", count: op[:count])
         @dispatcher.dispatch(@editor, inv)
@@ -962,7 +1360,7 @@ module RuVim
     end
 
     def start_replace_pending
-      @replace_pending = { count: (@editor.pending_count || 1) }
+      @replace_pending = { count: @editor.pending_count }
       @editor.pending_count = nil
       @pending_keys = []
       @editor.echo("r")
@@ -1003,9 +1401,9 @@ module RuVim
       return if (@dot_replay_depth || 0).positive?
 
       case invocation.id
-      when "buffer.delete_char", "buffer.paste_after", "buffer.paste_before"
+      when "buffer.delete_char", "buffer.delete_motion", "buffer.join_lines", "buffer.swapcase_char", "buffer.paste_after", "buffer.paste_before"
         record_last_change_keys(count_prefixed_keys(count, matched_keys))
-      when "mode.insert", "mode.append", "mode.append_line_end", "mode.insert_nonblank", "mode.open_below", "mode.open_above"
+      when "mode.insert", "mode.append", "mode.append_line_end", "mode.insert_nonblank", "mode.open_below", "mode.open_above", "buffer.substitute_char", "buffer.change_motion", "buffer.change_line"
         begin_dot_change_capture(count_prefixed_keys(count, matched_keys)) if @editor.mode == :insert
       end
     end
@@ -1050,7 +1448,7 @@ module RuVim
       @find_pending = {
         direction: (token == "f" || token == "t") ? :forward : :backward,
         till: (token == "t" || token == "T"),
-        count: (@editor.pending_count || 1)
+        count: @editor.pending_count
       }
       @editor.pending_count = nil
       @pending_keys = []
@@ -1095,7 +1493,7 @@ module RuVim
         else
           last[:direction]
         end
-      count = @editor.pending_count || 1
+      count = @editor.pending_count
       @editor.pending_count = nil
       @pending_keys = []
       moved = perform_find_on_line(char: last[:char], direction:, till: last[:till], count:)
@@ -1109,7 +1507,7 @@ module RuVim
       pos = win.cursor_x
       target = nil
 
-      count.times do
+      [count.to_i, 1].max.times do
         idx =
           if direction == :forward
             line.index(char, pos + 1)
@@ -1163,6 +1561,66 @@ module RuVim
       @cmdline_history_index = nil
     end
 
+    def load_command_line_history!
+      path = command_line_history_file_path
+      return unless path
+      return unless File.file?(path)
+
+      raw = File.read(path)
+      data = JSON.parse(raw)
+      return unless data.is_a?(Hash)
+
+      loaded = Hash.new { |h, k| h[k] = [] }
+      data.each do |prefix, items|
+        key = prefix.to_s
+        next unless [":", "/", "?"].include?(key)
+        next unless items.is_a?(Array)
+
+        hist = loaded[key]
+        items.each do |item|
+          text = item.to_s
+          next if text.empty?
+
+          hist.delete(text)
+          hist << text
+        end
+        hist.shift while hist.length > 100
+      end
+      @cmdline_history = loaded
+    rescue StandardError => e
+      verbose_log(1, "history load error: #{e.message}")
+    end
+
+    def save_command_line_history!
+      path = command_line_history_file_path
+      return unless path
+
+      payload = {
+        ":" => Array(@cmdline_history[":"]).map(&:to_s).last(100),
+        "/" => Array(@cmdline_history["/"]).map(&:to_s).last(100),
+        "?" => Array(@cmdline_history["?"]).map(&:to_s).last(100)
+      }
+
+      FileUtils.mkdir_p(File.dirname(path))
+      tmp = "#{path}.tmp"
+      File.write(tmp, JSON.pretty_generate(payload) + "\n")
+      File.rename(tmp, path)
+    rescue StandardError => e
+      verbose_log(1, "history save error: #{e.message}")
+    end
+
+    def command_line_history_file_path
+      xdg_state_home = ENV["XDG_STATE_HOME"].to_s
+      if !xdg_state_home.empty?
+        return File.join(xdg_state_home, "ruvim", "history.json")
+      end
+
+      home = ENV["HOME"].to_s
+      return nil if home.empty?
+
+      File.join(home, ".ruvim", "history.json")
+    end
+
     def command_line_history_move(delta)
       cmd = @editor.command_line
       hist = @cmdline_history[cmd.prefix]
@@ -1181,6 +1639,7 @@ module RuVim
       else
         cmd.replace_text(hist[@cmdline_history_index])
       end
+      update_incsearch_preview_if_needed
     end
 
     def command_line_complete
@@ -1190,25 +1649,173 @@ module RuVim
       ctx = ex_completion_context(cmd)
       return unless ctx
 
-      matches = ex_completion_candidates(ctx)
+      matches = reusable_command_line_completion_matches(cmd, ctx) || ex_completion_candidates(ctx)
       case matches.length
       when 0
+        clear_command_line_completion
         @editor.echo("No completion")
       when 1
+        clear_command_line_completion
         cmd.replace_span(ctx[:token_start], ctx[:token_end], matches.first)
       else
-        prefix = common_prefix(matches)
-        cmd.replace_span(ctx[:token_start], ctx[:token_end], prefix) if prefix.length > ctx[:prefix].length
-        @editor.echo(matches.join(" "))
+        apply_wildmode_completion(cmd, ctx, matches)
+      end
+      update_incsearch_preview_if_needed
+    end
+
+    def reusable_command_line_completion_matches(cmd, ctx)
+      state = @cmdline_completion
+      return nil unless state
+      return nil unless state[:prefix] == cmd.prefix
+      return nil unless state[:kind] == ctx[:kind]
+      return nil unless state[:command] == ctx[:command]
+      return nil unless state[:arg_index] == ctx[:arg_index]
+      return nil unless state[:token_start] == ctx[:token_start]
+
+      before_text = cmd.text[0...ctx[:token_start]].to_s
+      after_text = cmd.text[ctx[:token_end]..].to_s
+      return nil unless state[:before_text] == before_text
+      return nil unless state[:after_text] == after_text
+
+      matches = Array(state[:matches]).map(&:to_s)
+      return nil if matches.empty?
+
+      current_token = cmd.text[ctx[:token_start]...ctx[:token_end]].to_s
+      return nil unless current_token.empty? || matches.include?(current_token) || common_prefix(matches).start_with?(current_token) || current_token.start_with?(common_prefix(matches))
+
+      matches
+    end
+
+    def clear_command_line_completion
+      @cmdline_completion = nil
+    end
+
+    def apply_wildmode_completion(cmd, ctx, matches)
+      mode_steps = wildmode_steps
+      mode_steps = [:full] if mode_steps.empty?
+      state = @cmdline_completion
+      before_text = cmd.text[0...ctx[:token_start]].to_s
+      after_text = cmd.text[ctx[:token_end]..].to_s
+      same = state &&
+             state[:prefix] == cmd.prefix &&
+             state[:kind] == ctx[:kind] &&
+             state[:command] == ctx[:command] &&
+             state[:arg_index] == ctx[:arg_index] &&
+             state[:token_start] == ctx[:token_start] &&
+             state[:before_text] == before_text &&
+             state[:after_text] == after_text &&
+             state[:matches] == matches
+      unless same
+        state = {
+          prefix: cmd.prefix,
+          kind: ctx[:kind],
+          command: ctx[:command],
+          arg_index: ctx[:arg_index],
+          token_start: ctx[:token_start],
+          before_text: before_text,
+          after_text: after_text,
+          matches: matches.dup,
+          step_index: -1,
+          full_index: nil
+        }
+      end
+
+      state[:step_index] += 1
+      step = mode_steps[state[:step_index] % mode_steps.length]
+      case step
+      when :longest
+        pref = common_prefix(matches)
+        cmd.replace_span(ctx[:token_start], ctx[:token_end], pref) if pref.length > ctx[:prefix].length
+      when :list
+        show_command_line_completion_menu(matches, selected: state[:full_index], force: true)
+      when :full
+        state[:full_index] = state[:full_index] ? (state[:full_index] + 1) % matches.length : 0
+        cmd.replace_span(ctx[:token_start], ctx[:token_end], matches[state[:full_index]])
+        show_command_line_completion_menu(matches, selected: state[:full_index], force: false)
+      else
+        pref = common_prefix(matches)
+        cmd.replace_span(ctx[:token_start], ctx[:token_end], pref) if pref.length > ctx[:prefix].length
       end
+
+      @cmdline_completion = state
     end
 
-    def common_prefix(strings)
-      return "" if strings.empty?
+    def wildmode_steps
+      raw = @editor.effective_option("wildmode").to_s
+      return [:full] if raw.empty?
 
-      prefix = strings.first.dup
-      strings[1..]&.each do |s|
-        while !prefix.empty? && !s.start_with?(prefix)
+      raw.split(",").flat_map do |tok|
+        tok.to_s.split(":").map do |part|
+          case part.strip.downcase
+          when "longest" then :longest
+          when "list" then :list
+          when "full" then :full
+          end
+        end
+      end.compact
+    end
+
+    def show_command_line_completion_menu(matches, selected:, force:)
+      return unless force || @editor.effective_option("wildmenu")
+
+      items = matches.each_with_index.map do |m, i|
+        idx = i
+        idx == selected ? "[#{m}]" : m
+      end
+      @editor.echo(compose_command_line_completion_menu(items))
+    end
+
+    def compose_command_line_completion_menu(items)
+      parts = Array(items).map(&:to_s)
+      return "" if parts.empty?
+
+      width = command_line_completion_menu_width
+      width = [width.to_i, 1].max
+      out = +""
+      shown = 0
+
+      parts.each_with_index do |item, idx|
+        token = shown.zero? ? item : " #{item}"
+        if out.empty? && token.length > width
+          out = token[0, width]
+          shown = 1
+          break
+        end
+        break if out.length + token.length > width
+
+        out << token
+        shown = idx + 1
+      end
+
+      if shown < parts.length
+        ellipsis = (out.empty? ? "..." : " ...")
+        if out.length + ellipsis.length <= width
+          out << ellipsis
+        elsif width >= 3
+          out = out[0, width - 3] + "..."
+        else
+          out = "." * width
+        end
+      end
+
+      out
+    end
+
+    def command_line_completion_menu_width
+      return 80 unless defined?(@terminal) && @terminal && @terminal.respond_to?(:winsize)
+
+      _rows, cols = @terminal.winsize
+      [cols.to_i, 1].max
+    rescue StandardError
+      80
+    end
+
+    def common_prefix(strings)
+      return "" if strings.empty?
+
+      prefix = strings.first.dup
+      strings[1..]&.each do |s|
+        while !prefix.empty? && !s.start_with?(prefix)
           prefix = prefix[0...-1]
         end
       end
@@ -1219,6 +1826,98 @@ module RuVim
       @insert_completion = nil
     end
 
+    def insert_tab_in_insert_mode
+      buf = @editor.current_buffer
+      win = @editor.current_window
+      if @editor.effective_option("expandtab", window: win, buffer: buf)
+        width = @editor.effective_option("softtabstop", window: win, buffer: buf).to_i
+        width = @editor.effective_option("tabstop", window: win, buffer: buf).to_i if width <= 0
+        width = 2 if width <= 0
+        line = buf.line_at(win.cursor_y)
+        current_col = RuVim::TextMetrics.screen_col_for_char_index(line, win.cursor_x, tabstop: effective_tabstop(win, buf))
+        spaces = width - (current_col % width)
+        spaces = width if spaces <= 0
+        _y, x = buf.insert_text(win.cursor_y, win.cursor_x, " " * spaces)
+        win.cursor_x = x
+      else
+        buf.insert_char(win.cursor_y, win.cursor_x, "\t")
+        win.cursor_x += 1
+      end
+    end
+
+    def apply_insert_autoindent(row, x, previous_row:)
+      buf = @editor.current_buffer
+      win = @editor.current_window
+      return x unless @editor.effective_option("autoindent", window: win, buffer: buf)
+      return x if previous_row.negative?
+
+      prev = buf.line_at(previous_row)
+      indent = prev[/\A[ \t]*/].to_s
+      if @editor.effective_option("smartindent", window: win, buffer: buf)
+        trimmed = prev.rstrip
+        needs_indent = trimmed.end_with?("{", "[", "(")
+        if !needs_indent
+          needs_indent = buf.lang_module.indent_trigger?(trimmed)
+        end
+        if needs_indent
+          sw = @editor.effective_option("shiftwidth", window: win, buffer: buf).to_i
+          sw = effective_tabstop(win, buf) if sw <= 0
+          sw = 2 if sw <= 0
+          indent += " " * sw
+        end
+      end
+      return x if indent.empty?
+
+      _y, new_x = buf.insert_text(row, x, indent)
+      new_x
+    end
+
+    def maybe_showmatch_after_insert(key)
+      return unless [")", "]", "}"].include?(key)
+      return unless @editor.effective_option("showmatch")
+
+      mt = @editor.effective_option("matchtime").to_i
+      mt = 5 if mt <= 0
+      @editor.echo_temporary("match", duration_seconds: mt * 0.1)
+    end
+
+    def maybe_dedent_after_insert(key)
+      return unless @editor.effective_option("smartindent", window: @editor.current_window, buffer: @editor.current_buffer)
+
+      buf = @editor.current_buffer
+      lang_mod = buf.lang_module
+
+      pattern = lang_mod.dedent_trigger(key)
+      return unless pattern
+
+      row = @editor.current_window.cursor_y
+      line = buf.line_at(row)
+      m = line.match(pattern)
+      return unless m
+
+      sw = @editor.effective_option("shiftwidth", buffer: buf).to_i
+      sw = 2 if sw <= 0
+      target_indent = lang_mod.calculate_indent(buf.lines, row, sw)
+      return unless target_indent
+
+      current_indent = m[1].length
+      return if current_indent == target_indent
+
+      stripped = line.to_s.strip
+      buf.delete_span(row, 0, row, current_indent) if current_indent > 0
+      buf.insert_text(row, 0, " " * target_indent) if target_indent > 0
+      @editor.current_window.cursor_x = target_indent + stripped.length
+    end
+
+    def clear_expired_transient_message_if_any
+      @needs_redraw = true if @editor.clear_expired_transient_message!(now: monotonic_now)
+    end
+
+    def effective_tabstop(window = @editor.current_window, buffer = @editor.current_buffer)
+      v = @editor.effective_option("tabstop", window:, buffer:).to_i
+      v.positive? ? v : 2
+    end
+
     def insert_complete(direction)
       state = ensure_insert_completion_state
       return unless state
@@ -1229,8 +1928,27 @@ module RuVim
         return
       end
 
+      if state[:index].nil? && insert_completion_noselect? && matches.length > 1
+        show_insert_completion_menu(matches, selected: nil)
+        state[:index] = :pending_select
+        return
+      end
+
+      if state[:index].nil? && insert_completion_noinsert?
+        preview_idx = direction.positive? ? 0 : matches.length - 1
+        state[:index] = :pending_insert
+        state[:pending_index] = preview_idx
+        show_insert_completion_menu(matches, selected: preview_idx, current: matches[preview_idx])
+        return
+      end
+
       idx = state[:index]
-      idx = idx.nil? ? (direction.positive? ? 0 : matches.length - 1) : (idx + direction) % matches.length
+      idx = nil if idx == :pending_select
+      if idx == :pending_insert
+        idx = state.delete(:pending_index) || (direction.positive? ? 0 : matches.length - 1)
+      else
+        idx = idx.nil? ? (direction.positive? ? 0 : matches.length - 1) : (idx + direction) % matches.length
+      end
       replacement = matches[idx]
 
       end_col = state[:current_end_col]
@@ -1241,17 +1959,51 @@ module RuVim
       @editor.current_window.cursor_x = new_x
       state[:index] = idx
       state[:current_end_col] = start_col + replacement.length
-      @editor.echo(matches.length == 1 ? replacement : "#{replacement} (#{idx + 1}/#{matches.length})")
+      if matches.length == 1
+        @editor.echo(replacement)
+      else
+        show_insert_completion_menu(matches, selected: idx, current: replacement)
+      end
     rescue StandardError => e
       @editor.echo_error("Completion error: #{e.message}")
       clear_insert_completion
     end
 
+    def insert_completion_noselect?
+      @editor.effective_option("completeopt").to_s.split(",").map { |s| s.strip.downcase }.include?("noselect")
+    end
+
+    def insert_completion_noinsert?
+      @editor.effective_option("completeopt").to_s.split(",").map { |s| s.strip.downcase }.include?("noinsert")
+    end
+
+    def insert_completion_menu_enabled?
+      opts = @editor.effective_option("completeopt").to_s.split(",").map { |s| s.strip.downcase }
+      opts.include?("menu") || opts.include?("menuone")
+    end
+
+    def show_insert_completion_menu(matches, selected:, current: nil)
+      if insert_completion_menu_enabled?
+        limit = [@editor.effective_option("pumheight").to_i, 1].max
+        items = matches.first(limit).each_with_index.map do |m, i|
+          i == selected ? "[#{m}]" : m
+        end
+        items << "..." if matches.length > limit
+        if current
+          @editor.echo("#{current} (#{selected + 1}/#{matches.length}) | #{items.join(' ')}")
+        else
+          @editor.echo(items.join(" "))
+        end
+      elsif current
+        @editor.echo("#{current} (#{selected + 1}/#{matches.length})")
+      end
+    end
+
     def ensure_insert_completion_state
       row = @editor.current_window.cursor_y
       col = @editor.current_window.cursor_x
       line = @editor.current_buffer.line_at(row)
-      prefix = line[0...col].to_s[/[[:alnum:]_]+\z/]
+      prefix = trailing_keyword_fragment(line[0...col].to_s, @editor.current_window, @editor.current_buffer)
       return nil if prefix.nil? || prefix.empty?
 
       start_col = col - prefix.length
@@ -1280,9 +2032,10 @@ module RuVim
     def collect_buffer_word_completions(prefix, current_word:)
       words = []
       seen = {}
+      rx = keyword_scan_regex(@editor.current_window, @editor.current_buffer)
       @editor.buffers.values.each do |buf|
         buf.lines.each do |line|
-          line.scan(/[[:alnum:]_]+/) do |w|
+          line.scan(rx) do |w|
             next unless w.start_with?(prefix)
             next if w == current_word
             next if seen[w]
@@ -1295,6 +2048,210 @@ module RuVim
       words.sort
     end
 
+    def track_mode_transition(mode_before)
+      mode_after = @editor.mode
+      if mode_before != :insert && mode_after == :insert
+        @insert_start_location = @editor.current_location
+      elsif mode_before == :insert && mode_after != :insert
+        @insert_start_location = nil
+      end
+
+      if mode_before != :command_line && mode_after == :command_line
+        @incsearch_preview = nil
+      elsif mode_before == :command_line && mode_after != :command_line
+        @incsearch_preview = nil
+      end
+    end
+
+    def insert_backspace_allowed?
+      buf = @editor.current_buffer
+      win = @editor.current_window
+      row = win.cursor_y
+      col = win.cursor_x
+      return false if row.zero? && col.zero?
+
+      opt = @editor.effective_option("backspace", window: win, buffer: buf).to_s
+      allow = opt.split(",").map { |s| s.strip.downcase }.reject(&:empty?)
+      allow_all = allow.include?("2")
+      allow_indent = allow_all || allow.include?("indent")
+
+      if col.zero? && row.positive?
+        return true if allow_all || allow.include?("eol")
+
+        @editor.echo_error("backspace=eol required")
+        return false
+      end
+
+      if @insert_start_location
+        same_buf = @insert_start_location[:buffer_id] == buf.id
+        if same_buf && (row < @insert_start_location[:row] || (row == @insert_start_location[:row] && col <= @insert_start_location[:col]))
+          if allow_all || allow.include?("start")
+            return true
+          end
+
+          if allow_indent && same_row_autoindent_backspace?(buf, row, col)
+            return true
+          end
+
+          @editor.echo_error("backspace=start required")
+          return false
+        end
+      end
+
+      true
+    end
+
+    def insert_backspace_in_insert_mode
+      buf = @editor.current_buffer
+      win = @editor.current_window
+      row = win.cursor_y
+      col = win.cursor_x
+
+      if row >= 0 && col.positive? && try_softtabstop_backspace(buf, win)
+        return
+      end
+
+      y, x = buf.backspace(row, col)
+      win.cursor_y = y
+      win.cursor_x = x
+    end
+
+    def dispatch_insert_cursor_motion(id)
+      @dispatcher.dispatch(@editor, CommandInvocation.new(id: id, count: 1))
+    rescue StandardError => e
+      @editor.echo_error("Motion error: #{e.message}")
+    end
+
+    def try_softtabstop_backspace(buf, win)
+      row = win.cursor_y
+      col = win.cursor_x
+      line = buf.line_at(row)
+      return false unless line
+      return false unless @editor.effective_option("expandtab", window: win, buffer: buf)
+
+      sts = @editor.effective_option("softtabstop", window: win, buffer: buf).to_i
+      sts = @editor.effective_option("tabstop", window: win, buffer: buf).to_i if sts <= 0
+      return false if sts <= 0
+
+      prefix = line[0...col].to_s
+      m = prefix.match(/ +\z/)
+      return false unless m
+
+      run = m[0].length
+      return false if run <= 1
+
+      tabstop = effective_tabstop(win, buf)
+      cur_screen = RuVim::TextMetrics.screen_col_for_char_index(line, col, tabstop:)
+      target_screen = [cur_screen - sts, 0].max
+      target_col = RuVim::TextMetrics.char_index_for_screen_col(line, target_screen, tabstop:, align: :floor)
+      delete_cols = col - target_col
+      delete_cols = [delete_cols, run, sts].min
+      return false if delete_cols <= 1
+
+      # Only collapse whitespace run; if target lands before the run, clamp to run start.
+      run_start = col - run
+      target_col = [target_col, run_start].max
+      delete_cols = col - target_col
+      return false if delete_cols <= 1
+
+      buf.delete_span(row, target_col, row, col)
+      win.cursor_x = target_col
+      true
+    rescue StandardError
+      false
+    end
+
+    def same_row_autoindent_backspace?(buf, row, col)
+      return false unless @insert_start_location
+      return false unless row == @insert_start_location[:row]
+      return false unless col <= @insert_start_location[:col]
+
+      line = buf.line_at(row)
+      line[0...@insert_start_location[:col]].to_s.match?(/\A[ \t]*\z/)
+    rescue StandardError
+      false
+    end
+
+    def incsearch_enabled?
+      return false unless @editor.command_line_active?
+      return false unless ["/", "?"].include?(@editor.command_line.prefix)
+
+      !!@editor.effective_option("incsearch")
+    end
+
+    def update_incsearch_preview_if_needed
+      return unless incsearch_enabled?
+
+      cmd = @editor.command_line
+      ensure_incsearch_preview_origin!(direction: (cmd.prefix == "/" ? :forward : :backward))
+      pattern = cmd.text.to_s
+      if pattern.empty?
+        clear_incsearch_preview_state(apply: false)
+        return
+      end
+
+      buf = @editor.current_buffer
+      win = @editor.current_window
+      origin = @incsearch_preview[:origin]
+      tmp_window = RuVim::Window.new(id: -1, buffer_id: buf.id)
+      tmp_window.cursor_y = origin[:row]
+      tmp_window.cursor_x = origin[:col]
+      regex = GlobalCommands.instance.send(:compile_search_regex, pattern, editor: @editor, window: win, buffer: buf)
+      match = GlobalCommands.instance.send(:find_next_match, buf, tmp_window, regex, direction: @incsearch_preview[:direction])
+      if match
+        win.cursor_y = match[:row]
+        win.cursor_x = match[:col]
+        win.clamp_to_buffer(buf)
+      end
+      @incsearch_preview[:active] = true
+    rescue RuVim::CommandError, RegexpError
+      # Keep editing command-line without forcing an error flash on every keystroke.
+    end
+
+    def ensure_incsearch_preview_origin!(direction:)
+      return if @incsearch_preview
+
+      @incsearch_preview = {
+        origin: @editor.current_location,
+        direction: direction,
+        active: false
+      }
+    end
+
+    def cancel_incsearch_preview_if_any
+      clear_incsearch_preview_state(apply: false)
+    end
+
+    def clear_incsearch_preview_state(apply:)
+      return unless @incsearch_preview
+
+      if !apply && @incsearch_preview[:origin]
+        @editor.jump_to_location(@incsearch_preview[:origin])
+      end
+      @incsearch_preview = nil
+    end
+
+    def trailing_keyword_fragment(prefix_text, window, buffer)
+      cls = keyword_char_class(window, buffer)
+      prefix_text.to_s[/[#{cls}]+\z/]
+    rescue RegexpError
+      prefix_text.to_s[/[[:alnum:]_]+\z/]
+    end
+
+    def keyword_scan_regex(window, buffer)
+      cls = keyword_char_class(window, buffer)
+      /[#{cls}]+/
+    rescue RegexpError
+      /[[:alnum:]_]+/
+    end
+
+    def keyword_char_class(window, buffer)
+      raw = @editor.effective_option("iskeyword", window:, buffer:).to_s
+      RuVim::KeywordChars.char_class(raw)
+    rescue StandardError
+      "[:alnum:]_"
+    end
+
     def ex_completion_context(cmd)
       text = cmd.text
       cursor = cmd.cursor
@@ -1363,18 +2320,45 @@ module RuVim
         else
           File.dirname(input)
         end
-      base_dir = "." if base_dir == "."
       partial = input.end_with?("/") ? "" : File.basename(input)
-      pattern = input.empty? ? "*" : File.join(base_dir, "#{partial}*")
-      Dir.glob(pattern, File::FNM_DOTMATCH).sort.filter_map do |p|
+      pattern =
+        if input.empty?
+          "*"
+        elsif base_dir == "."
+          "#{partial}*"
+        else
+          File.join(base_dir, "#{partial}*")
+        end
+      partial_starts_with_dot = partial.start_with?(".")
+      entries = Dir.glob(pattern, File::FNM_DOTMATCH).filter_map do |p|
         next if [".", ".."].include?(File.basename(p))
         next unless p.start_with?(input) || input.empty?
+        next if wildignore_path?(p)
         File.directory?(p) ? "#{p}/" : p
       end
+      entries.sort_by do |p|
+        base = File.basename(p.to_s.sub(%r{/\z}, ""))
+        hidden_rank = (!partial_starts_with_dot && base.start_with?(".")) ? 1 : 0
+        [hidden_rank, p]
+      end
     rescue StandardError
       []
     end
 
+    def wildignore_path?(path)
+      spec = @editor.global_options["wildignore"].to_s
+      return false if spec.empty?
+
+      flags = @editor.global_options["wildignorecase"] ? File::FNM_CASEFOLD : 0
+      name = path.to_s
+      base = File.basename(name)
+      spec.split(",").map(&:strip).reject(&:empty?).any? do |pat|
+        File.fnmatch?(pat, name, flags) || File.fnmatch?(pat, base, flags)
+      end
+    rescue StandardError
+      false
+    end
+
     def buffer_completion_candidates(prefix)
       pfx = prefix.to_s
       items = @editor.buffers.values.flat_map do |b|
@@ -1538,6 +2522,13 @@ module RuVim
       list = Array(paths).compact
       return if list.empty?
 
+      # Remove the bootstrap empty buffer and reset the ID counter
+      # so the first file gets buffer id 1 (Vim-like behavior).
+      evict_bootstrap_buffer!
+
+      # Initialize arglist with all paths
+      @editor.set_arglist(list)
+
       first, *rest = list
       @editor.open_path(first)
       apply_startup_readonly! if @startup_readonly
@@ -1545,20 +2536,38 @@ module RuVim
 
       case @startup_open_layout
       when :horizontal
+        first_win_id = @editor.current_window_id
         rest.each { |p| open_path_in_split!(p, layout: :horizontal) }
+        @editor.focus_window(first_win_id)
       when :vertical
+        first_win_id = @editor.current_window_id
         rest.each { |p| open_path_in_split!(p, layout: :vertical) }
+        @editor.focus_window(first_win_id)
       when :tab
         rest.each { |p| open_path_in_tab!(p) }
+        @editor.tabnext(-(@editor.tabpage_count - 1))
       else
-        # No multi-file layout mode yet; ignore extras if called directly.
+        # Load remaining files as buffers (Vim-like behavior).
+        rest.each { |p| @editor.add_buffer_from_file(p) }
+      end
+    end
+
+    # Remove the bootstrap empty buffer before opening real files,
+    # resetting the buffer ID counter so the first file gets id 1.
+    def evict_bootstrap_buffer!
+      bid = @editor.buffer_ids.find do |id|
+        b = @editor.buffers[id]
+        b.path.nil? && !b.modified? && b.line_count <= 1 && b.kind == :file
       end
+      return unless bid
+
+      @editor.buffers.delete(bid)
+      @editor.instance_variable_set(:@next_buffer_id, 1)
     end
 
     def open_path_in_split!(path, layout:)
       @editor.split_current_window(layout:)
-      buf = @editor.add_buffer_from_file(path)
-      @editor.switch_to_buffer(buf.id)
+      @editor.open_path(path)
       apply_startup_readonly! if @startup_readonly
       apply_startup_nomodifiable! if @startup_nomodifiable
     end
@@ -1569,6 +2578,368 @@ module RuVim
       apply_startup_nomodifiable! if @startup_nomodifiable
     end
 
+    def open_path_with_large_file_support(path)
+      return @editor.open_path_sync(path) unless should_open_path_async?(path)
+      return @editor.open_path_sync(path) unless can_start_async_file_load?
+
+      open_path_asynchronously!(path)
+    end
+
+    def should_open_path_async?(path)
+      p = path.to_s
+      return false if p.empty?
+      return false unless File.file?(p)
+
+      File.size(p) >= large_file_async_threshold_bytes
+    rescue StandardError
+      false
+    end
+
+    def can_start_async_file_load?
+      @async_file_loads.empty?
+    end
+
+    def large_file_async_threshold_bytes
+      raw = ENV["RUVIM_ASYNC_FILE_THRESHOLD_BYTES"]
+      n = raw.to_i if raw
+      return n if n && n.positive?
+
+      LARGE_FILE_ASYNC_THRESHOLD_BYTES
+    end
+
+    def open_path_asynchronously!(path)
+      file_size = File.size(path)
+      buf = @editor.add_empty_buffer(path: path)
+      @editor.switch_to_buffer(buf.id)
+      buf.loading_state = :live
+      buf.modified = false
+
+      ensure_stream_event_queue!
+      io = File.open(path, "rb")
+      state = { path: path, io: io, thread: nil, ended_with_newline: false }
+      staged_prefix_bytes = async_file_staged_prefix_bytes
+      staged_mode = file_size > staged_prefix_bytes
+      if staged_mode
+        prefix = io.read(staged_prefix_bytes) || "".b
+        unless prefix.empty?
+          buf.append_stream_text!(Buffer.decode_text(prefix))
+          state[:ended_with_newline] = prefix.end_with?("\n")
+        end
+      end
+
+      if io.eof?
+        buf.finalize_async_file_load!(ended_with_newline: state[:ended_with_newline])
+        buf.loading_state = :closed
+        io.close unless io.closed?
+        return buf
+      end
+
+      @async_file_loads[buf.id] = state
+      state[:thread] = start_async_file_loader_thread(buf.id, io, bulk_once: staged_mode)
+
+      size_mb = file_size.fdiv(1024 * 1024)
+      if staged_mode
+        @editor.echo(format("\"%s\" loading... (showing first %.0fMB of %.1fMB)", path, staged_prefix_bytes.fdiv(1024 * 1024), size_mb))
+      else
+        @editor.echo(format("\"%s\" loading... (%.1fMB)", path, size_mb))
+      end
+      buf
+    rescue StandardError
+      @async_file_loads.delete(buf.id) if buf
+      raise
+    end
+
+    def async_file_staged_prefix_bytes
+      raw = ENV["RUVIM_ASYNC_FILE_PREFIX_BYTES"]
+      n = raw.to_i if raw
+      return n if n && n.positive?
+
+      LARGE_FILE_STAGED_PREFIX_BYTES
+    end
+
+    def start_async_file_loader_thread(buffer_id, io, bulk_once: false)
+      Thread.new do
+        if bulk_once
+          rest = io.read || "".b
+          unless rest.empty?
+            @stream_event_queue << { type: :file_data, buffer_id: buffer_id, data: Buffer.decode_text(rest) }
+            notify_signal_wakeup
+          end
+          @stream_event_queue << { type: :file_eof, buffer_id: buffer_id, ended_with_newline: rest.end_with?("\n") }
+          notify_signal_wakeup
+          next
+        end
+
+        ended_with_newline = false
+        pending_text = +""
+        loop do
+          chunk = io.readpartial(ASYNC_FILE_READ_CHUNK_BYTES)
+          next if chunk.nil? || chunk.empty?
+
+          ended_with_newline = chunk.end_with?("\n")
+          pending_text << Buffer.decode_text(chunk)
+          next if pending_text.bytesize < ASYNC_FILE_EVENT_FLUSH_BYTES
+
+          @stream_event_queue << { type: :file_data, buffer_id: buffer_id, data: pending_text }
+          pending_text = +""
+          notify_signal_wakeup
+        end
+      rescue EOFError
+        unless pending_text.empty?
+          @stream_event_queue << { type: :file_data, buffer_id: buffer_id, data: pending_text }
+          notify_signal_wakeup
+        end
+        @stream_event_queue << { type: :file_eof, buffer_id: buffer_id, ended_with_newline: ended_with_newline }
+        notify_signal_wakeup
+      rescue StandardError => e
+        @stream_event_queue << { type: :file_error, buffer_id: buffer_id, error: e.message.to_s }
+        notify_signal_wakeup
+      ensure
+        begin
+          io.close unless io.closed?
+        rescue StandardError
+          nil
+        end
+      end
+    end
+
+    def prepare_stdin_stream_buffer!
+      buf = @editor.current_buffer
+      if buf.intro_buffer?
+        @editor.materialize_intro_buffer!
+        buf = @editor.current_buffer
+      end
+
+      buf.replace_all_lines!([""])
+      buf.configure_special!(kind: :stream, name: "[stdin]", readonly: true, modifiable: false)
+      buf.modified = false
+      buf.stream_state = :live
+      buf.options["filetype"] = "text"
+      @stream_stop_requested = false
+      ensure_stream_event_queue!
+      @stream_buffer_id = buf.id
+      move_window_to_stream_end!(@editor.current_window, buf)
+      @editor.echo("[stdin] follow")
+    end
+
+    def stdin_stream_stop_command
+      return if stop_stdin_stream!
+
+      handle_normal_ctrl_c
+    end
+
+    def stop_stdin_stream!
+      buf = @editor.buffers[@stream_buffer_id]
+      return false unless buf&.kind == :stream
+      return false unless (buf.stream_state || :live) == :live
+
+      @stream_stop_requested = true
+      io = @stdin_stream_source
+      @stdin_stream_source = nil
+      begin
+        io.close if io && io.respond_to?(:close) && !(io.respond_to?(:closed?) && io.closed?)
+      rescue StandardError
+        nil
+      end
+      if @stream_reader_thread&.alive?
+        @stream_reader_thread.kill
+        @stream_reader_thread.join(0.05)
+      end
+      @stream_reader_thread = nil
+
+      buf.stream_state = :closed
+      @editor.echo("[stdin] closed")
+      notify_signal_wakeup
+      true
+    end
+
+    def start_stdin_stream_reader!
+      return unless @stdin_stream_source
+      ensure_stream_event_queue!
+      return if @stream_reader_thread&.alive?
+
+      @stream_stop_requested = false
+      io = @stdin_stream_source
+      @stream_reader_thread = Thread.new do
+        loop do
+          chunk = io.readpartial(4096)
+          next if chunk.nil? || chunk.empty?
+
+          @stream_event_queue << { type: :data, data: Buffer.decode_text(chunk) }
+          notify_signal_wakeup
+        end
+      rescue EOFError
+        unless @stream_stop_requested
+          @stream_event_queue << { type: :eof }
+          notify_signal_wakeup
+        end
+      rescue IOError => e
+        unless @stream_stop_requested
+          @stream_event_queue << { type: :error, error: e.message.to_s }
+          notify_signal_wakeup
+        end
+      rescue StandardError => e
+        unless @stream_stop_requested
+          @stream_event_queue << { type: :error, error: e.message.to_s }
+          notify_signal_wakeup
+        end
+      end
+    end
+
+    def drain_stream_events!
+      return false unless @stream_event_queue
+
+      changed = false
+      loop do
+        event = @stream_event_queue.pop(true)
+        case event[:type]
+        when :data
+          changed = apply_stream_chunk!(event[:data]) || changed
+        when :eof
+          if (buf = @editor.buffers[@stream_buffer_id])
+            buf.stream_state = :closed
+          end
+          @editor.echo("[stdin] EOF")
+          changed = true
+        when :error
+          next if ignore_stream_shutdown_error?(event[:error])
+          if (buf = @editor.buffers[@stream_buffer_id])
+            buf.stream_state = :error
+          end
+          @editor.echo_error("[stdin] stream error: #{event[:error]}")
+          changed = true
+        when :file_data
+          changed = apply_async_file_chunk!(event[:buffer_id], event[:data]) || changed
+        when :file_eof
+          changed = finish_async_file_load!(event[:buffer_id], ended_with_newline: event[:ended_with_newline]) || changed
+        when :file_error
+          changed = fail_async_file_load!(event[:buffer_id], event[:error]) || changed
+        end
+      end
+    rescue ThreadError
+      changed
+    end
+
+    def apply_stream_chunk!(text)
+      return false if text.to_s.empty?
+
+      buf = @editor.buffers[@stream_buffer_id]
+      return false unless buf
+
+      follow_window_ids = @editor.windows.values.filter_map do |win|
+        next unless win.buffer_id == buf.id
+        next unless stream_window_following_end?(win, buf)
+
+        win.id
+      end
+
+      buf.append_stream_text!(text)
+
+      follow_window_ids.each do |win_id|
+        win = @editor.windows[win_id]
+        move_window_to_stream_end!(win, buf) if win
+      end
+
+      true
+    end
+
+    def apply_async_file_chunk!(buffer_id, text)
+      return false if text.to_s.empty?
+
+      buf = @editor.buffers[buffer_id]
+      return false unless buf
+
+      buf.append_stream_text!(text)
+      true
+    end
+
+    def finish_async_file_load!(buffer_id, ended_with_newline:)
+      @async_file_loads.delete(buffer_id)
+      buf = @editor.buffers[buffer_id]
+      return false unless buf
+
+      buf.finalize_async_file_load!(ended_with_newline: !!ended_with_newline)
+      buf.loading_state = :closed
+      true
+    end
+
+    def fail_async_file_load!(buffer_id, error)
+      state = @async_file_loads.delete(buffer_id)
+      buf = @editor.buffers[buffer_id]
+      if buf
+        buf.loading_state = :error
+      end
+      @editor.echo_error("\"#{(state && state[:path]) || (buf && buf.display_name) || buffer_id}\" load error: #{error}")
+      true
+    end
+
+    def stream_window_following_end?(win, buf)
+      return false unless win
+
+      last_row = buf.line_count - 1
+      win.cursor_y >= last_row
+    end
+
+    def move_window_to_stream_end!(win, buf)
+      return unless win && buf
+
+      last_row = buf.line_count - 1
+      win.cursor_y = last_row
+      win.cursor_x = buf.line_length(last_row)
+      win.clamp_to_buffer(buf)
+    end
+
+    def shutdown_stream_reader!
+      thread = @stream_reader_thread
+      @stream_reader_thread = nil
+      @stream_stop_requested = true
+      return unless thread
+      return unless thread.alive?
+
+      thread.kill
+      thread.join(0.05)
+    rescue StandardError
+      nil
+    end
+
+    def shutdown_async_file_loaders!
+      loaders = @async_file_loads
+      @async_file_loads = {}
+      loaders.each_value do |state|
+        io = state[:io]
+        thread = state[:thread]
+        begin
+          io.close if io && !io.closed?
+        rescue StandardError
+          nil
+        end
+        next unless thread&.alive?
+
+        thread.kill
+        thread.join(0.05)
+      rescue StandardError
+        nil
+      end
+    end
+
+    def shutdown_background_readers!
+      shutdown_stream_reader!
+      shutdown_async_file_loaders!
+    end
+
+    def ignore_stream_shutdown_error?(message)
+      buf = @editor.buffers[@stream_buffer_id]
+      return false unless buf&.kind == :stream
+      return false unless (buf.stream_state || :live) == :closed
+
+      msg = message.to_s.downcase
+      msg.include?("stream closed") || msg.include?("closed in another thread")
+    end
+
+    def ensure_stream_event_queue!
+      @stream_event_queue ||= Queue.new
+    end
+
     def move_cursor_to_line(line_number)
       win = @editor.current_window
       buf = @editor.current_buffer