Optimize input handling and cursor movement performance

Status	File	+	-
A	`CLAUDE.md`	149	0
M	`app/main.f90`	27	20
M	`src/commands/command_handler_module.f90`	7	0
M	`src/terminal/input_handler_module.f90`	28	28
M	`src/terminal/raw_mode_module.f90`	28	0
M	`src/terminal/renderer_module.f90`	33	0
M	`src/terminal/terminal_io_module.f90`	16	1
M	`src/terminal/termios_wrapper.c`	119	10

CLAUDE.mdadded

++# CLAUDE.md
++
++This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
++
++## Project Overview
++
++Facsimile (`fac`) is a terminal text editor written in modern Fortran with VSCode-style keybindings. It uses a gap buffer for text storage and pure ANSI escape sequences for terminal rendering.
++
++## Build Commands
++
++```bash
++# Standard build (recommended)
++make
++
++# Clean and rebuild
++make clean && make
++
++# Development build with comprehensive warnings
++make dev
++
++# Debug build with runtime checks
++make debug
++
++# Show compiler info
++make info
++```
++
++The Makefile auto-detects the platform:
++- **macOS arm64**: Uses gfortran-15 or flang-new from Homebrew
++- **macOS Intel/Linux**: Uses standard gfortran
++
++## Version Management
++
++```bash
++# Check current version
++make version
++
++# Bump versions
++make bump-patch    # 0.9.1 -> 0.9.2
++make bump-minor    # 0.9.1 -> 0.10.0
++make bump-major    # 0.9.1 -> 1.0.0
++
++# Full release build with checklist
++make release
++```
++
++The `VERSION` file is the single source of truth. The Makefile auto-generates `src/version_module.f90`.
++
++## Architecture
++
++### Core Data Flow
++
++```
++Input → input_handler_module → command_handler_module → buffer operations → renderer_module → Terminal
++```
++
++### Key Modules
++
++- **`src/buffer/text_buffer_module.f90`**: Gap buffer implementation for text storage. All operations maintain gap position for efficient insertions.
++
++- **`src/editor_state_module.f90`**: Central state management. Contains `editor_state_t` with tabs, panes, cursors, LSP state, and UI panels. This is the "god object" that gets passed around.
++
++- **`src/terminal/input_handler_module.f90`**: Raw keyboard input processing. Handles escape sequences, mouse events, and key combinations.
++
++- **`src/terminal/renderer_module.f90`**: Screen rendering with ANSI escape sequences. Handles syntax highlighting, status bar, and split panes.
++
++- **`src/commands/command_handler_module.f90`**: Main command dispatch. Maps key inputs to editor actions (~7000 lines).
++
++- **`src/terminal/termios_wrapper.c`**: C wrapper for terminal raw mode via termios.
++
++### Module Dependency Order
++
++The Makefile's `SOURCES` list defines the required compilation order. Fortran modules must be compiled before modules that `use` them. The `.NOTPARALLEL` directive enforces sequential builds.
++
++### UTF-8 Handling
++
++All cursor positions use CHARACTER indices, not byte indices. The `utf8_module` provides conversion functions:
++- `utf8_char_count()` - count characters in string
++- `buffer_byte_to_char_col()` - convert byte position to character column
++- `buffer_char_to_byte_col()` - convert character column to byte position
++
++### Pane/Tab Architecture
++
++```
++editor_state_t
++  └── tabs[]           (multiple open files)
++       └── panes[]     (split views of same file)
++            ├── buffer (text content)
++            ├── cursors[] (multiple cursor support)
++            └── viewport (scroll position)
++```
++
++### LSP Integration
++
++Located in `src/lsp/`. Communicates with language servers via JSON-RPC over stdio:
++- `lsp_server_manager_module.f90` - Server lifecycle management
++- `json_module.f90` - JSON parsing/generation
++- `lsp_client_module.f90` - Request/response handling
++
++## Fortran-Specific Constraints
++
++### Line Length Limit
++Fortran has a 132-character line limit. Unicode characters (like box-drawing `═`) count as multiple bytes. Long lines must be split using `&` continuation:
++
++```fortran
++! Bad - will fail compilation
++line = '═══════════════════════════════════════════════════════════════════'
++
++! Good - split across lines
++line = '═══════════════════════' // &
++       '═══════════════════════' // &
++       '═══════════════════════'
++```
++
++### Module Files
++Compilation generates `.mod` files in the root directory. These are binary module interfaces, not source files.
++
++## Distribution
++
++The project is distributed via three channels:
++- **Homebrew**: `homebrew-facsimile` repo with `facsimile.rb` formula
++- **AUR**: Arch User Repository PKGBUILD
++- **RPM**: Spec file at `~/rpmbuild/SPECS/facsimile.spec`
++
++When releasing, update all three with the new version and SHA256 hash from the GitHub release tarball.
++
++## Testing
++
++```bash
++# LSP module tests
++make test-lsp
++
++# Test LSP with editor
++make test-lsp-editor
++
++# Manual key testing
++./keytest      # Basic key codes
++./keytest_fac  # With fac's termios settings
++```
++
++## Running
++
++```bash
++./fac [filename]        # Open file
++./fac --version         # Show version
++./fac --help            # Show help
++```
++
++Key bindings follow VSCode conventions: Ctrl-S save, Ctrl-Q quit, Ctrl-B file tree, Ctrl-F search, Ctrl-Z undo.

app/main.f90modified

      use renderer_module
      use command_handler_module, only: handle_key_command, init_command_handler, cleanup_command_handler, &
                                        save_initial_state_for_undo, search_pattern, match_case_sensitive, &
--                                      g_lsp_modified_buffer, g_lsp_ui_changed
++                                      g_lsp_modified_buffer, g_lsp_ui_changed, g_cursor_only_move
      use workspace_module
      use backup_module
      use save_prompt_module
              call handle_key_command(key_input, editor, buffer, should_quit)
              ! Sync back to active pane and other instances
--            if (editor%active_tab_index > 0 .and. editor%active_tab_index <= size(editor%tabs)) then
++            ! Skip buffer sync for cursor-only moves (buffer content unchanged)
--                if (allocated(editor%tabs(editor%active_tab_index)%panes) .and. &
++            if (.not. g_cursor_only_move) then
--                    size(editor%tabs(editor%active_tab_index)%panes) > 0) then
++                if (editor%active_tab_index > 0 .and. editor%active_tab_index <= size(editor%tabs)) then
--                    ! Get active pane index
++                    if (allocated(editor%tabs(editor%active_tab_index)%panes) .and. &
--                    status = editor%tabs(editor%active_tab_index)%active_pane_index
++                        size(editor%tabs(editor%active_tab_index)%panes) > 0) then
--                    if (status > 0 .and. status <= size(editor%tabs(editor%active_tab_index)%panes)) then
++                        ! Get active pane index
--                        ! Copy main buffer back to active pane's buffer
++                        status = editor%tabs(editor%active_tab_index)%active_pane_index
--                        call copy_buffer(editor%tabs(editor%active_tab_index)%panes(status)%buffer, buffer)
++                        if (status > 0 .and. status <= size(editor%tabs(editor%active_tab_index)%panes)) then
--
++                            ! Copy main buffer back to active pane's buffer
--                        ! Sync to all instances of this file
++                            call copy_buffer(editor%tabs(editor%active_tab_index)%panes(status)%buffer, buffer)
--                        if (allocated(editor%tabs(editor%active_tab_index)%panes(status)%filename)) then
++
--                            call sync_buffer_to_all_instances(editor, &
++                            ! Sync to all instances of this file
--                                editor%tabs(editor%active_tab_index)%panes(status)%filename, buffer)
++                            if (allocated(editor%tabs(editor%active_tab_index)%panes(status)%filename)) then
++                                call sync_buffer_to_all_instances(editor, &
++                                    editor%tabs(editor%active_tab_index)%panes(status)%filename, buffer)
++                            end if
                          end if
--                    end if
--                    ! Also update tab buffer for backwards compatibility
++                        ! Also update tab buffer for backwards compatibility
--                    call copy_buffer(editor%tabs(editor%active_tab_index)%buffer, buffer)
++                        call copy_buffer(editor%tabs(editor%active_tab_index)%buffer, buffer)
--                    ! Sync modified flag from buffer to tab
++                        ! Sync modified flag from buffer to tab
--                    editor%tabs(editor%active_tab_index)%modified = buffer%modified
++                        editor%tabs(editor%active_tab_index)%modified = buffer%modified
++                    end if
                  end if
              end if
                  running = .false.
              else
                  ! Re-render screen after each command
--                if (editor%fuss_mode_active) then
++                ! Use fast path for cursor-only movements
++                if (g_cursor_only_move) then
++                    call render_cursor_only(buffer, editor, allocated(search_pattern), match_case_sensitive)
++                    g_cursor_only_move = .false.
++                else if (editor%fuss_mode_active) then
                      call render_screen_with_tree(buffer, editor, allocated(search_pattern), match_case_sensitive)
                  else
                      call render_screen(buffer, editor, allocated(search_pattern), match_case_sensitive)

src/commands/command_handler_module.f90modified

      public :: search_pattern, match_case_sensitive  ! Exposed for status bar hint
      public :: g_lsp_modified_buffer  ! Flag for immediate render after LSP edits
      public :: g_lsp_ui_changed       ! Flag for immediate render after LSP UI changes
++    public :: g_cursor_only_move     ! Flag for cursor-only moves (skip full re-render)
      ! Flag to track if LSP modified the buffer (for immediate rendering)
      logical :: g_lsp_modified_buffer = .false.
      ! Flag to track if LSP changed UI panels (for immediate rendering)
      logical :: g_lsp_ui_changed = .false.
++    ! Flag for cursor-only movements (can skip full re-render)
++    logical :: g_cursor_only_move = .false.
      type(yank_stack_t) :: yank_stack
      type(undo_stack_t) :: undo_stack
              end if
              call sync_editor_to_pane(editor)
              call update_viewport(editor)
++            g_cursor_only_move = .true.
          case('down')
              ! If completion popup is visible, navigate it instead
              end if
              call sync_editor_to_pane(editor)
              call update_viewport(editor)
++            g_cursor_only_move = .true.
          case('left')
              ! Hide hover tooltip on movement
              end if
              call sync_editor_to_pane(editor)
              call update_viewport(editor)
++            g_cursor_only_move = .true.
          case('right')
              ! Hide hover tooltip on movement
              end if
              call sync_editor_to_pane(editor)
              call update_viewport(editor)
++            g_cursor_only_move = .true.
          ! Selection with shift+motion
          case('shift-up')

src/terminal/input_handler_module.f90modified


 module input_handler_module
     use iso_fortran_env, only: input_unit, int8, error_unit
+    use terminal_io_module, only: terminal_read_char, terminal_read_char_escape
     implicit none
     private
 

         key_str = ''
         status = -1
 
+        ! Read single character using raw mode function (50ms timeout when idle)
         char_code = terminal_read_char()
 
         if (char_code < 0) then

 
         key_str = 'esc'
 
+        ! Try to read next character (with fast 5ms timeout for escape sequences)
+        char_code = terminal_read_char_escape()
         if (char_code < 0) return
         ch1 = achar(char_code)
 
         if (ch1 == '[') then
             ! CSI sequence (or Alt+[ if no valid sequence follows)
+            char_code = terminal_read_char_escape()
             if (char_code < 0) then
                 ! Timeout - no character follows, this is Alt+[
                 key_str = 'alt-['

                 key_str = 'shift-tab'
             case('3')
                 ! Could be delete or Alt+Delete
+                char_code = terminal_read_char_escape()
                 if (char_code >= 0) then
                     ch3 = achar(char_code)
                     if (ch3 == '~') then

                     else if (ch3 == ';') then
                         ! Modified delete: ESC [ 3 ; modifier ~
                         ! Read the modifier
+                        char_code = terminal_read_char_escape()
                         if (char_code >= 0) then
                             modifier_ch = achar(char_code)
                             ! Read the terminating ~
+                            char_code = terminal_read_char_escape()
                             if (char_code >= 0 .and. achar(char_code) == '~') then
                                 ! Check modifier: 3 = Alt
                                 if (modifier_ch == '3') then

                 end if
             case('5')
                 ! Could be page up
+                char_code = terminal_read_char_escape()
                 if (char_code >= 0) then
                     ch3 = achar(char_code)
                     ios = 0

                 end if
             case('6')
                 ! Could be page down
+                char_code = terminal_read_char_escape()
                 if (char_code >= 0) then
                     ch3 = achar(char_code)
                     ios = 0

             case('1')
                 ! Could be function key (F1-F9) or modified arrow/home/end
                 ! Check next character
+                char_code = terminal_read_char_escape()
                 if (char_code >= 0) then
                     ch3 = achar(char_code)
                     if (ch3 == '~') then

                         key_str = 'f1'
                     else if (ch3 == '0') then
                         ! F10 might be ESC [ 2 1 ~, check for tilde
+                        char_code = terminal_read_char_escape()
                         if (char_code >= 0 .and. achar(char_code) == '~') then
                             key_str = 'f10'
                         end if
                     else if (ch3 == '1' .or. ch3 == '2' .or. ch3 == '3' .or. ch3 == '4' .or. &
                              ch3 == '5' .or. ch3 == '7' .or. ch3 == '8' .or. ch3 == '9') then
                         ! Function keys F1-F8: ESC [ 1 X ~ or ESC [ 1 X ; modifier ~
+                        char_code = terminal_read_char_escape()
                         if (char_code >= 0) then
                             ch = achar(char_code)
                             if (ch == '~') then

                 end if
             case('2')
                 ! Could be F9-F12 or alternate modified keys
+                char_code = terminal_read_char_escape()
                 if (char_code >= 0) then
                     ch3 = achar(char_code)
                     if (ch3 == '0' .or. ch3 == '1' .or. ch3 == '3' .or. ch3 == '4') then
                         ! Function keys F9-F12: ESC [ 2 X ~ or ESC [ 2 X ; modifier ~
+                        char_code = terminal_read_char_escape()
                         if (char_code >= 0) then
                             ch = achar(char_code)
                             if (ch == '~') then

                         end if
                     else if (ch3 == ';') then
                         ! ESC [ 2 ; A format (shift+arrow)
+                        char_code = terminal_read_char_escape()
                         if (char_code >= 0) then
                             ch = achar(char_code)
                             key_str = 'shift-'

             end select
         else if (ch1 == 'O') then
             ! SS3 sequence (e.g., function keys F1-F4)
+            char_code = terminal_read_char_escape()
             if (char_code < 0) then
                 ! Timeout - this is just Alt+O
                 key_str = 'alt-o'

             end select
         else if (ch1 == achar(27)) then
             ! ESC ESC - likely Alt+something
+            char_code = terminal_read_char_escape()
             if (char_code >= 0) then
                 ch2 = achar(char_code)
                 if (ch2 == '[') then
                     ! ESC ESC [ - Alt+arrow keys or Alt+modified keys
+                    char_code = terminal_read_char_escape()
                     if (char_code >= 0) then
                         ch3 = achar(char_code)
                         select case(ch3)

                             key_str = 'alt-left'
                         case('3')
                             ! Could be Alt+Delete (ESC ESC [ 3 ~)
+                            char_code = terminal_read_char_escape()
                             if (char_code >= 0 .and. achar(char_code) == '~') then
                                 key_str = 'alt-delete'
                             end if

             read_count = read_count + 1
             if (read_count > 20) exit  ! Safety limit
 
+            char_code = terminal_read_char_escape()
             if (char_code >= 0) then
                 ch = achar(char_code)
                 ios = 0

         read(modifier_char, '(i1)') modifier
 
         ! Read the next character - might be the key or a semicolon
+        char_code = terminal_read_char_escape()
         if (char_code < 0) return
         ch = achar(char_code)
 
         ! Check if there's a semicolon (ESC [ 2 ; A format) or direct key (ESC [ 2 A)
         if (ch == ';') then
             ! Read the actual key
+            char_code = terminal_read_char_escape()
             if (char_code < 0) return
             ch = achar(char_code)
         end if

             read_count = read_count + 1
             if (read_count > 20) exit
 
+            char_code = terminal_read_char_escape()
             if (char_code < 0) exit
 
             ch = achar(char_code)

 
         ! Read modifier sequence (already past the semicolon)
         do
+            char_code = terminal_read_char_escape()
             if (char_code >= 0) then
                 ch = achar(char_code)
                 ios = 0

         end if
 
         ! Read modifier (should be a digit 2-8)
+        char_code = terminal_read_char_escape()
         if (char_code < 0) return
         modifier_ch = achar(char_code)
 
         ! Read terminating ~
+        char_code = terminal_read_char_escape()
         if (char_code < 0 .or. achar(char_code) /= '~') return
 
         ! Parse modifier: 2=Shift, 3=Alt, 4=Alt+Shift, 5=Ctrl, 6=Ctrl+Shift, 7=Alt+Ctrl, 8=Alt+Shift

 
         ! Read until 'M' (press) or 'm' (release)
         do
+            char_code = terminal_read_char_escape()
             if (char_code >= 0) then
                 ch = achar(char_code)
                 ios = 0

src/terminal/raw_mode_module.f90modified

      private
      public :: enable_raw_mode, disable_raw_mode, input_available, read_char_timeout
++    public :: read_char_escape, input_available_count
      ! C function interfaces
      interface
              integer(c_int) :: c_input_available
          end function c_input_available
++        function c_input_available_count() bind(C, name="input_available_count")
++            import :: c_int
++            integer(c_int) :: c_input_available_count
++        end function c_input_available_count
++
          function c_read_char_timeout() bind(C, name="read_char_timeout")
              import :: c_int
              integer(c_int) :: c_read_char_timeout
          end function c_read_char_timeout
++
++        function c_read_char_escape() bind(C, name="read_char_escape")
++            import :: c_int
++            integer(c_int) :: c_read_char_escape
++        end function c_read_char_escape
      end interface
  contains
          available = (result > 0)
      end function input_available
++    function input_available_count() result(count)
++        integer :: count
++        integer(c_int) :: result
++
++        result = c_input_available_count()
++        count = result
++    end function input_available_count
++
      function read_char_timeout() result(ch)
          integer :: ch
          integer(c_int) :: result
          ch = result
      end function read_char_timeout
++    ! Fast read for escape sequences (5ms timeout instead of 50ms)
++    function read_char_escape() result(ch)
++        integer :: ch
++        integer(c_int) :: result
++
++        result = c_read_char_escape()
++        ch = result
++    end function read_char_escape
++
  end module raw_mode_module

src/terminal/renderer_module.f90modified

      public :: render_screen_with_tree, render_screen_with_lsp_panel
      public :: tree_state
      public :: update_syntax_highlighter
++    public :: render_cursor_only  ! Fast path for cursor-only updates
      ! Configuration
      logical :: show_line_numbers = .true.
          end if
      end subroutine render_cursor
++    ! Fast path for cursor-only updates - just update cursor and status bar
++    ! Use this when only cursor position changed, not buffer content
++    subroutine render_cursor_only(buffer, editor, match_mode_active, match_case_sens)
++        type(buffer_t), intent(in) :: buffer
++        type(editor_state_t), intent(inout) :: editor
++        logical, intent(in), optional :: match_mode_active
++        logical, intent(in), optional :: match_case_sens
++
++        ! Just render the status bar and position cursor
++        call render_status_bar(editor, buffer, match_mode_active, match_case_sens)
++
++        ! Handle panes vs single buffer
++        if (size(editor%tabs) > 0 .and. editor%active_tab_index > 0 .and. &
++            editor%active_tab_index <= size(editor%tabs)) then
++            if (allocated(editor%tabs(editor%active_tab_index)%panes)) then
++                if (editor%fuss_mode_active) then
++                    call render_cursor_for_panes_with_tree(editor, 31, editor%screen_cols - 30)
++                else
++                    call render_cursor_for_panes(editor)
++                end if
++                return
++            end if
++        end if
++
++        ! Single buffer mode
++        if (editor%fuss_mode_active) then
++            call render_cursor_in_pane(editor, 31, editor%screen_cols - 30)
++        else
++            call render_cursor(editor, buffer)
++        end if
++    end subroutine render_cursor_only
++
      subroutine update_viewport(editor)
          use editor_state_module, only: pane_t
          type(editor_state_t), intent(inout) :: editor

src/terminal/terminal_io_module.f90modified

      use raw_mode_module, only: raw_enable_raw_mode => enable_raw_mode, &
                                 raw_disable_raw_mode => disable_raw_mode, &
                                 raw_input_available => input_available, &
--                               raw_read_char_timeout => read_char_timeout
++                               raw_read_char_timeout => read_char_timeout, &
++                               raw_read_char_escape => read_char_escape, &
++                               raw_input_available_count => input_available_count
      implicit none
      private
      public :: terminal_get_size, terminal_enable_raw_mode, terminal_disable_raw_mode
      public :: terminal_write, terminal_enable_mouse, terminal_disable_mouse
      public :: terminal_input_available, terminal_read_char
++    public :: terminal_read_char_escape, terminal_input_available_count
      ! ANSI escape codes
      character(len=*), parameter :: ESC = char(27)
          ch = raw_read_char_timeout()
      end function terminal_read_char
++    ! Fast read for escape sequences (5ms timeout)
++    function terminal_read_char_escape() result(ch)
++        integer :: ch
++        ch = raw_read_char_escape()
++    end function terminal_read_char_escape
++
++    ! Get count of available input bytes
++    function terminal_input_available_count() result(count)
++        integer :: count
++        count = raw_input_available_count()
++    end function terminal_input_available_count
++
      subroutine terminal_write(text)
          character(len=*), intent(in) :: text
          write(output_unit, '(a)', advance='no') text

src/terminal/termios_wrapper.cmodified

  #include <stdio.h>
  #include <errno.h>
  #include <sys/ioctl.h>
++#include <sys/select.h>
++#include <string.h>
  static struct termios orig_termios;
  static int raw_mode_enabled = 0;
++// Input buffer for batching reads
++#define INPUT_BUFFER_SIZE 256
++static unsigned char input_buffer[INPUT_BUFFER_SIZE];
++static int buffer_start = 0;
++static int buffer_end = 0;
++
  // Enable raw mode - returns 0 on success, -1 on failure
  int enable_raw_mode(void) {
      if (raw_mode_enabled) return 0;
      // Local flags: disable canonical mode, echo, signals, extended input processing
      raw.c_lflag &= ~(tcflag_t)(ECHO | ICANON | ISIG | IEXTEN);
--    // Control characters: minimum bytes and timeout for read()
++    // Control characters: non-blocking reads
--    raw.c_cc[VMIN] = 0;  // Return each byte, or zero for timeout
++    // We'll use select() for timeout management instead of VTIME
--    raw.c_cc[VTIME] = 1; // 100ms timeout (unit is 1/10 second)
++    raw.c_cc[VMIN] = 0;   // Don't block
++    raw.c_cc[VTIME] = 0;  // No timeout - we use select() instead
      if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw) == -1) {
          return -1;
+     }
      raw_mode_enabled = 1;
++    buffer_start = buffer_end = 0;
      return 0;
+ }
+     }
      raw_mode_enabled = 0;
++    buffer_start = buffer_end = 0;
      return 0;
+ }
  // Check if input is available (non-blocking)
  int input_available(void) {
++    // First check our buffer
++    if (buffer_start < buffer_end) {
++        return 1;
++    }
++
++    // Then check stdin
      int nread;
      if (ioctl(STDIN_FILENO, FIONREAD, &nread) == -1) {
          return 0;
      return nread > 0;
+ }
--// Read a single character (with timeout)
++// Get count of available input bytes
++int input_available_count(void) {
++    int buffered = buffer_end - buffer_start;
++    int pending = 0;
++    if (ioctl(STDIN_FILENO, FIONREAD, &pending) == -1) {
++        pending = 0;
++    }
++    return buffered + pending;
++}
++
++// Fill the input buffer with all available data
++static void fill_input_buffer(void) {
++    // Shift remaining data to start of buffer
++    if (buffer_start > 0 && buffer_start < buffer_end) {
++        memmove(input_buffer, input_buffer + buffer_start, buffer_end - buffer_start);
++        buffer_end -= buffer_start;
++        buffer_start = 0;
++    } else if (buffer_start >= buffer_end) {
++        buffer_start = buffer_end = 0;
++    }
++
++    // Read all available data into buffer
++    int space = INPUT_BUFFER_SIZE - buffer_end;
++    if (space > 0) {
++        ssize_t nread = read(STDIN_FILENO, input_buffer + buffer_end, space);
++        if (nread > 0) {
++            buffer_end += nread;
++        }
++    }
++}
++
++// Read a single character with smart timeout
++// - If data is buffered or available, return immediately
++// - Otherwise wait up to timeout_ms for input
++// - Use short timeout (5ms) for escape sequence continuation
++// - Use longer timeout (50ms) for initial wait when idle
  int read_char_timeout(void) {
--    char c;
++    // Return from buffer if available
--    ssize_t nread = read(STDIN_FILENO, &c, 1);
++    if (buffer_start < buffer_end) {
--    if (nread == 1) {
++        return input_buffer[buffer_start++];
--        return (unsigned char)c;
++    }
--    } else {
++
--        return -1; // No input or error
++    // Try to fill buffer
++    fill_input_buffer();
++    if (buffer_start < buffer_end) {
++        return input_buffer[buffer_start++];
++    }
++
++    // No data available - wait with select()
++    // Use 50ms timeout for responsive feel without busy-waiting
++    fd_set readfds;
++    struct timeval tv;
++
++    FD_ZERO(&readfds);
++    FD_SET(STDIN_FILENO, &readfds);
++    tv.tv_sec = 0;
++    tv.tv_usec = 50000;  // 50ms - good balance of responsiveness and CPU usage
++
++    int ret = select(STDIN_FILENO + 1, &readfds, NULL, NULL, &tv);
++    if (ret > 0) {
++        fill_input_buffer();
++        if (buffer_start < buffer_end) {
++            return input_buffer[buffer_start++];
++        }
++    }
++
++    return -1;  // No input
++}
++
++// Read a character with very short timeout (for escape sequences)
++// This is used when we've already seen ESC and are looking for the rest
++int read_char_escape(void) {
++    // Return from buffer if available
++    if (buffer_start < buffer_end) {
++        return input_buffer[buffer_start++];
++    }
++
++    // Try immediate read first
++    fill_input_buffer();
++    if (buffer_start < buffer_end) {
++        return input_buffer[buffer_start++];
+     }
++
++    // Short wait for escape sequence continuation (5ms)
++    fd_set readfds;
++    struct timeval tv;
++
++    FD_ZERO(&readfds);
++    FD_SET(STDIN_FILENO, &readfds);
++    tv.tv_sec = 0;
++    tv.tv_usec = 5000;  // 5ms - fast escape sequence detection
++
++    int ret = select(STDIN_FILENO + 1, &readfds, NULL, NULL, &tv);
++    if (ret > 0) {
++        fill_input_buffer();
++        if (buffer_start < buffer_end) {
++            return input_buffer[buffer_start++];
++        }
++    }
++
++    return -1;
+ }

`@@ -1,6 +1,6 @@`
1	module input_handler_module	1	module input_handler_module
2	use iso_fortran_env, only: input_unit, int8, error_unit	2	use iso_fortran_env, only: input_unit, int8, error_unit
3	- use terminal_io_module, only: terminal_read_char	3	+ use terminal_io_module, only: terminal_read_char, terminal_read_char_escape
4	implicit none	4	implicit none
5	private	5	private
6		6
`@@ -43,7 +43,7 @@` contains
43	key_str = ''	43	key_str = ''
44	status = -1	44	status = -1
45		45
46	- ! Read single character using raw mode function	46	+ ! Read single character using raw mode function (50ms timeout when idle)
47	char_code = terminal_read_char()	47	char_code = terminal_read_char()
48		48
49	if (char_code < 0) then	49	if (char_code < 0) then
`@@ -90,14 +90,14 @@` contains
90		90
91	key_str = 'esc'	91	key_str = 'esc'
92		92
93	- ! Try to read next character (with timeout)	93	+ ! Try to read next character (with fast 5ms timeout for escape sequences)
94	- char_code = terminal_read_char()	94	+ char_code = terminal_read_char_escape()
95	if (char_code < 0) return	95	if (char_code < 0) return
96	ch1 = achar(char_code)	96	ch1 = achar(char_code)
97		97
98	if (ch1 == '[') then	98	if (ch1 == '[') then
99	! CSI sequence (or Alt+[ if no valid sequence follows)	99	! CSI sequence (or Alt+[ if no valid sequence follows)
100	- char_code = terminal_read_char()	100	+ char_code = terminal_read_char_escape()
101	if (char_code < 0) then	101	if (char_code < 0) then
102	! Timeout - no character follows, this is Alt+[	102	! Timeout - no character follows, this is Alt+[
103	key_str = 'alt-['	103	key_str = 'alt-['
`@@ -123,7 +123,7 @@` contains
123	key_str = 'shift-tab'	123	key_str = 'shift-tab'
124	case('3')	124	case('3')
125	! Could be delete or Alt+Delete	125	! Could be delete or Alt+Delete
126	- char_code = terminal_read_char()	126	+ char_code = terminal_read_char_escape()
127	if (char_code >= 0) then	127	if (char_code >= 0) then
128	ch3 = achar(char_code)	128	ch3 = achar(char_code)
129	if (ch3 == '~') then	129	if (ch3 == '~') then
`@@ -131,11 +131,11 @@` contains
131	else if (ch3 == ';') then	131	else if (ch3 == ';') then
132	! Modified delete: ESC [ 3 ; modifier ~	132	! Modified delete: ESC [ 3 ; modifier ~
133	! Read the modifier	133	! Read the modifier
134	- char_code = terminal_read_char()	134	+ char_code = terminal_read_char_escape()
135	if (char_code >= 0) then	135	if (char_code >= 0) then
136	modifier_ch = achar(char_code)	136	modifier_ch = achar(char_code)
137	! Read the terminating ~	137	! Read the terminating ~
138	- char_code = terminal_read_char()	138	+ char_code = terminal_read_char_escape()
139	if (char_code >= 0 .and. achar(char_code) == '~') then	139	if (char_code >= 0 .and. achar(char_code) == '~') then
140	! Check modifier: 3 = Alt	140	! Check modifier: 3 = Alt
141	if (modifier_ch == '3') then	141	if (modifier_ch == '3') then
`@@ -149,7 +149,7 @@` contains
149	end if	149	end if
150	case('5')	150	case('5')
151	! Could be page up	151	! Could be page up
152	- char_code = terminal_read_char()	152	+ char_code = terminal_read_char_escape()
153	if (char_code >= 0) then	153	if (char_code >= 0) then
154	ch3 = achar(char_code)	154	ch3 = achar(char_code)
155	ios = 0	155	ios = 0
`@@ -164,7 +164,7 @@` contains
164	end if	164	end if
165	case('6')	165	case('6')
166	! Could be page down	166	! Could be page down
167	- char_code = terminal_read_char()	167	+ char_code = terminal_read_char_escape()
168	if (char_code >= 0) then	168	if (char_code >= 0) then
169	ch3 = achar(char_code)	169	ch3 = achar(char_code)
170	ios = 0	170	ios = 0
`@@ -180,7 +180,7 @@` contains
180	case('1')	180	case('1')
181	! Could be function key (F1-F9) or modified arrow/home/end	181	! Could be function key (F1-F9) or modified arrow/home/end
182	! Check next character	182	! Check next character
183	- char_code = terminal_read_char()	183	+ char_code = terminal_read_char_escape()
184	if (char_code >= 0) then	184	if (char_code >= 0) then
185	ch3 = achar(char_code)	185	ch3 = achar(char_code)
186	if (ch3 == '~') then	186	if (ch3 == '~') then
`@@ -188,14 +188,14 @@` contains
188	key_str = 'f1'	188	key_str = 'f1'
189	else if (ch3 == '0') then	189	else if (ch3 == '0') then
190	! F10 might be ESC [ 2 1 ~, check for tilde	190	! F10 might be ESC [ 2 1 ~, check for tilde
191	- char_code = terminal_read_char()	191	+ char_code = terminal_read_char_escape()
192	if (char_code >= 0 .and. achar(char_code) == '~') then	192	if (char_code >= 0 .and. achar(char_code) == '~') then
193	key_str = 'f10'	193	key_str = 'f10'
194	end if	194	end if
195	else if (ch3 == '1' .or. ch3 == '2' .or. ch3 == '3' .or. ch3 == '4' .or. &	195	else if (ch3 == '1' .or. ch3 == '2' .or. ch3 == '3' .or. ch3 == '4' .or. &
196	ch3 == '5' .or. ch3 == '7' .or. ch3 == '8' .or. ch3 == '9') then	196	ch3 == '5' .or. ch3 == '7' .or. ch3 == '8' .or. ch3 == '9') then
197	! Function keys F1-F8: ESC [ 1 X ~ or ESC [ 1 X ; modifier ~	197	! Function keys F1-F8: ESC [ 1 X ~ or ESC [ 1 X ; modifier ~
198	- char_code = terminal_read_char()	198	+ char_code = terminal_read_char_escape()
199	if (char_code >= 0) then	199	if (char_code >= 0) then
200	ch = achar(char_code)	200	ch = achar(char_code)
201	if (ch == '~') then	201	if (ch == '~') then
`@@ -230,12 +230,12 @@` contains
230	end if	230	end if
231	case('2')	231	case('2')
232	! Could be F9-F12 or alternate modified keys	232	! Could be F9-F12 or alternate modified keys
233	- char_code = terminal_read_char()	233	+ char_code = terminal_read_char_escape()
234	if (char_code >= 0) then	234	if (char_code >= 0) then
235	ch3 = achar(char_code)	235	ch3 = achar(char_code)
236	if (ch3 == '0' .or. ch3 == '1' .or. ch3 == '3' .or. ch3 == '4') then	236	if (ch3 == '0' .or. ch3 == '1' .or. ch3 == '3' .or. ch3 == '4') then
237	! Function keys F9-F12: ESC [ 2 X ~ or ESC [ 2 X ; modifier ~	237	! Function keys F9-F12: ESC [ 2 X ~ or ESC [ 2 X ; modifier ~
238	- char_code = terminal_read_char()	238	+ char_code = terminal_read_char_escape()
239	if (char_code >= 0) then	239	if (char_code >= 0) then
240	ch = achar(char_code)	240	ch = achar(char_code)
241	if (ch == '~') then	241	if (ch == '~') then
`@@ -257,7 +257,7 @@` contains
257	end if	257	end if
258	else if (ch3 == ';') then	258	else if (ch3 == ';') then
259	! ESC [ 2 ; A format (shift+arrow)	259	! ESC [ 2 ; A format (shift+arrow)
260	- char_code = terminal_read_char()	260	+ char_code = terminal_read_char_escape()
261	if (char_code >= 0) then	261	if (char_code >= 0) then
262	ch = achar(char_code)	262	ch = achar(char_code)
263	key_str = 'shift-'	263	key_str = 'shift-'
`@@ -297,7 +297,7 @@` contains
297	end select	297	end select
298	else if (ch1 == 'O') then	298	else if (ch1 == 'O') then
299	! SS3 sequence (e.g., function keys F1-F4)	299	! SS3 sequence (e.g., function keys F1-F4)
300	- char_code = terminal_read_char()	300	+ char_code = terminal_read_char_escape()
301	if (char_code < 0) then	301	if (char_code < 0) then
302	! Timeout - this is just Alt+O	302	! Timeout - this is just Alt+O
303	key_str = 'alt-o'	303	key_str = 'alt-o'
`@@ -319,12 +319,12 @@` contains
319	end select	319	end select
320	else if (ch1 == achar(27)) then	320	else if (ch1 == achar(27)) then
321	! ESC ESC - likely Alt+something	321	! ESC ESC - likely Alt+something
322	- char_code = terminal_read_char()	322	+ char_code = terminal_read_char_escape()
323	if (char_code >= 0) then	323	if (char_code >= 0) then
324	ch2 = achar(char_code)	324	ch2 = achar(char_code)
325	if (ch2 == '[') then	325	if (ch2 == '[') then
326	! ESC ESC [ - Alt+arrow keys or Alt+modified keys	326	! ESC ESC [ - Alt+arrow keys or Alt+modified keys
327	- char_code = terminal_read_char()	327	+ char_code = terminal_read_char_escape()
328	if (char_code >= 0) then	328	if (char_code >= 0) then
329	ch3 = achar(char_code)	329	ch3 = achar(char_code)
330	select case(ch3)	330	select case(ch3)
`@@ -338,7 +338,7 @@` contains
338	key_str = 'alt-left'	338	key_str = 'alt-left'
339	case('3')	339	case('3')
340	! Could be Alt+Delete (ESC ESC [ 3 ~)	340	! Could be Alt+Delete (ESC ESC [ 3 ~)
341	- char_code = terminal_read_char()	341	+ char_code = terminal_read_char_escape()
342	if (char_code >= 0 .and. achar(char_code) == '~') then	342	if (char_code >= 0 .and. achar(char_code) == '~') then
343	key_str = 'alt-delete'	343	key_str = 'alt-delete'
344	end if	344	end if
`@@ -406,7 +406,7 @@` contains
406	read_count = read_count + 1	406	read_count = read_count + 1
407	if (read_count > 20) exit ! Safety limit	407	if (read_count > 20) exit ! Safety limit
408		408
409	- char_code = terminal_read_char()	409	+ char_code = terminal_read_char_escape()
410	if (char_code >= 0) then	410	if (char_code >= 0) then
411	ch = achar(char_code)	411	ch = achar(char_code)
412	ios = 0	412	ios = 0
`@@ -506,14 +506,14 @@` contains
506	read(modifier_char, '(i1)') modifier	506	read(modifier_char, '(i1)') modifier
507		507
508	! Read the next character - might be the key or a semicolon	508	! Read the next character - might be the key or a semicolon
509	- char_code = terminal_read_char()	509	+ char_code = terminal_read_char_escape()
510	if (char_code < 0) return	510	if (char_code < 0) return
511	ch = achar(char_code)	511	ch = achar(char_code)
512		512
513	! Check if there's a semicolon (ESC [ 2 ; A format) or direct key (ESC [ 2 A)	513	! Check if there's a semicolon (ESC [ 2 ; A format) or direct key (ESC [ 2 A)
514	if (ch == ';') then	514	if (ch == ';') then
515	! Read the actual key	515	! Read the actual key
516	- char_code = terminal_read_char()	516	+ char_code = terminal_read_char_escape()
517	if (char_code < 0) return	517	if (char_code < 0) return
518	ch = achar(char_code)	518	ch = achar(char_code)
519	end if	519	end if
`@@ -574,7 +574,7 @@` contains
574	read_count = read_count + 1	574	read_count = read_count + 1
575	if (read_count > 20) exit	575	if (read_count > 20) exit
576		576
577	- char_code = terminal_read_char()	577	+ char_code = terminal_read_char_escape()
578	if (char_code < 0) exit	578	if (char_code < 0) exit
579		579
580	ch = achar(char_code)	580	ch = achar(char_code)
`@@ -641,7 +641,7 @@` contains
641		641
642	! Read modifier sequence (already past the semicolon)	642	! Read modifier sequence (already past the semicolon)
643	do	643	do
644	- char_code = terminal_read_char()	644	+ char_code = terminal_read_char_escape()
645	if (char_code >= 0) then	645	if (char_code >= 0) then
646	ch = achar(char_code)	646	ch = achar(char_code)
647	ios = 0	647	ios = 0
`@@ -738,12 +738,12 @@` contains
738	end if	738	end if
739		739
740	! Read modifier (should be a digit 2-8)	740	! Read modifier (should be a digit 2-8)
741	- char_code = terminal_read_char()	741	+ char_code = terminal_read_char_escape()
742	if (char_code < 0) return	742	if (char_code < 0) return
743	modifier_ch = achar(char_code)	743	modifier_ch = achar(char_code)
744		744
745	! Read terminating ~	745	! Read terminating ~
746	- char_code = terminal_read_char()	746	+ char_code = terminal_read_char_escape()
747	if (char_code < 0 .or. achar(char_code) /= '~') return	747	if (char_code < 0 .or. achar(char_code) /= '~') return
748		748
749	! Parse modifier: 2=Shift, 3=Alt, 4=Alt+Shift, 5=Ctrl, 6=Ctrl+Shift, 7=Alt+Ctrl, 8=Alt+Shift	749	! Parse modifier: 2=Shift, 3=Alt, 4=Alt+Shift, 5=Ctrl, 6=Ctrl+Shift, 7=Alt+Ctrl, 8=Alt+Shift
`@@ -784,7 +784,7 @@` contains
784		784
785	! Read until 'M' (press) or 'm' (release)	785	! Read until 'M' (press) or 'm' (release)
786	do	786	do
787	- char_code = terminal_read_char()	787	+ char_code = terminal_read_char_escape()
788	if (char_code >= 0) then	788	if (char_code >= 0) then
789	ch = achar(char_code)	789	ch = achar(char_code)
790	ios = 0	790	ios = 0

fortrangoingonforty/facsimile / `7e7fe23`

8 changed files