ruvim 0.2.0 → 0.3.0

data/lib/ruvim/app.rb

@@ -1,13 +1,32 @@
+# 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
@@ -33,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!
@@ -48,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
@@ -64,12 +90,14 @@ 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
@@ -89,8 +117,18 @@ module RuVim
 
           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")
@@ -173,6 +211,9 @@ module RuVim
       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")
@@ -198,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")
@@ -231,10 +279,39 @@ module RuVim
       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)
@@ -244,7 +321,13 @@ module RuVim
       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)
@@ -253,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)
@@ -263,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!
@@ -297,10 +390,40 @@ 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")
@@ -313,6 +436,10 @@ module RuVim
       @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")
@@ -320,6 +447,10 @@ module RuVim
       @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")
@@ -330,7 +461,12 @@ module RuVim
       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)
@@ -338,23 +474,30 @@ module RuVim
       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 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.
@@ -363,6 +506,46 @@ module RuVim
       @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
+
+      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)
@@ -417,43 +600,7 @@ module RuVim
     end
 
     def handle_normal_direct_token(token)
-      case token
-      when "\""
-        start_register_pending
-      when "d"
-        start_operator_pending(:delete)
-      when "y"
-        start_operator_pending(:yank)
-      when "c"
-        start_operator_pending(:change)
-      when "r"
-        start_replace_pending
-      when "f", "F", "t", "T"
-        start_find_pending(token)
-      when ";"
-        repeat_last_find(reverse: false)
-      when ","
-        repeat_last_find(reverse: true)
-      when "."
-        repeat_last_change
-      when "q"
-        if @editor.macro_recording?
-          stop_macro_recording
-        else
-          start_macro_record_pending
-        end
-      when "@"
-        start_macro_play_pending
-      when "m"
-        start_mark_pending
-      when "'"
-        start_jump_pending(linewise: true, repeat_token: "'")
-      when "`"
-        start_jump_pending(linewise: false, repeat_token: "`")
-      else
-        return false
-      end
-      true
+      false
     end
 
     def resolve_normal_key_sequence
@@ -462,7 +609,7 @@ module RuVim
       when :pending, :ambiguous
         if match.status == :ambiguous && match.invocation
           inv = dup_invocation(match.invocation)
-          inv.count = @editor.pending_count || 1
+          inv.count = @editor.pending_count
           @pending_ambiguous_invocation = inv
         else
           @pending_ambiguous_invocation = nil
@@ -472,9 +619,15 @@ module RuVim
       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
@@ -532,6 +685,7 @@ module RuVim
         @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
 
@@ -577,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"
@@ -632,7 +788,7 @@ module RuVim
 
       if id
         clear_pending_key_timeout
-        count = @editor.pending_count || 1
+        count = @editor.pending_count
         @dispatcher.dispatch(@editor, CommandInvocation.new(id:, count: count))
       else
         clear_pending_key_timeout
@@ -744,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 = []
@@ -754,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)
@@ -789,6 +945,7 @@ module RuVim
       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>"
@@ -797,6 +954,10 @@ module RuVim
       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
@@ -812,8 +973,49 @@ 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
@@ -832,6 +1034,18 @@ module RuVim
         @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
@@ -847,6 +1061,28 @@ 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
@@ -871,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)
@@ -946,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"
@@ -993,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
@@ -1015,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}")
@@ -1086,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)
@@ -1104,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")
@@ -1145,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
@@ -1192,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 = []
@@ -1237,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:)
@@ -1251,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)
@@ -1305,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]
@@ -1333,7 +1649,7 @@ 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
@@ -1347,6 +1663,29 @@ module RuVim
       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
@@ -1419,13 +1758,56 @@ module RuVim
     def show_command_line_completion_menu(matches, selected:, force:)
       return unless force || @editor.effective_option("wildmenu")
 
-      limit = [@editor.effective_option("pumheight").to_i, 1].max
-      items = matches.first(limit).each_with_index.map do |m, i|
+      items = matches.each_with_index.map do |m, i|
         idx = i
         idx == selected ? "[#{m}]" : m
       end
-      items << "..." if matches.length > limit
-      @editor.echo(items.join(" "))
+      @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)
@@ -1473,7 +1855,11 @@ module RuVim
       indent = prev[/\A[ \t]*/].to_s
       if @editor.effective_option("smartindent", window: win, buffer: buf)
         trimmed = prev.rstrip
-        if trimmed.end_with?("{", "[", "(")
+        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
@@ -1495,6 +1881,34 @@ module RuVim
       @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
@@ -1906,15 +2320,27 @@ 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
@@ -2096,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
@@ -2103,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
@@ -2127,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