ruvim 0.2.0 → 0.3.0

data/lib/ruvim/screen.rb

@@ -1,11 +1,15 @@
+# frozen_string_literal: true
+
 module RuVim
   class Screen
     DEFAULT_TABSTOP = 2
     SYNTAX_CACHE_LIMIT = 2048
+    WRAP_SEGMENTS_CACHE_LIMIT = 1024
     def initialize(terminal:)
       @terminal = terminal
       @last_frame = nil
       @syntax_color_cache = {}
+      @wrapped_segments_cache = {}
     end
 
     def invalidate_cache!
@@ -13,6 +17,8 @@ module RuVim
     end
 
     def render(editor)
+      @rich_render_info = nil
+
       rows, cols = @terminal.winsize
       text_rows, text_cols = editor.text_viewport_size(rows:, cols:)
       text_rows = [text_rows, 1].max
@@ -28,15 +34,31 @@ module RuVim
         rect = rects[win_id]
         next unless rect
         content_width = [rect[:width] - number_column_width(editor, win, buf), 1].max
-        win.col_offset = 0 if wrap_enabled?(editor, win, buf)
-        win.ensure_visible(
-          buf,
-          height: [rect[:height], 1].max,
-          width: content_width,
-          tabstop: tabstop_for(editor, win, buf),
-          scrolloff: editor.effective_option("scrolloff", window: win, buffer: buf),
-          sidescrolloff: editor.effective_option("sidescrolloff", window: win, buffer: buf)
-        )
+        if RuVim::RichView.active?(editor)
+          # Vertical scrolling only — keep raw col_offset untouched
+          win.ensure_visible(
+            buf,
+            height: [rect[:height], 1].max,
+            width: content_width,
+            tabstop: tabstop_for(editor, win, buf),
+            scrolloff: editor.effective_option("scrolloff", window: win, buffer: buf),
+            sidescrolloff: editor.effective_option("sidescrolloff", window: win, buffer: buf)
+          )
+          ensure_visible_rich(editor, win, buf, rect, content_width)
+        else
+          win.col_offset = 0 if wrap_enabled?(editor, win, buf)
+          win.ensure_visible(
+            buf,
+            height: [rect[:height], 1].max,
+            width: content_width,
+            tabstop: tabstop_for(editor, win, buf),
+            scrolloff: editor.effective_option("scrolloff", window: win, buffer: buf),
+            sidescrolloff: editor.effective_option("sidescrolloff", window: win, buffer: buf)
+          )
+          if wrap_enabled?(editor, win, buf)
+            ensure_visible_under_wrap(editor, win, buf, height: [rect[:height], 1].max, content_w: content_width)
+          end
+        end
       end
 
       frame = build_frame(editor, rows:, cols:, text_rows:, text_cols:, rects:)
@@ -71,15 +93,19 @@ module RuVim
       lines = {}
       render_window_area(editor, lines, rects, text_rows:, text_cols:)
 
-      status_row = text_rows + 1
-      lines[status_row] = "\e[7m#{truncate(status_line(editor, cols), cols)}\e[m"
-      lines[status_row + 1] = ""
-
-      if editor.command_line_active?
-        cmd = editor.command_line
-        lines[status_row + 1] = truncate("#{cmd.prefix}#{cmd.text}", cols)
-      elsif editor.message_error?
-        lines[status_row + 1] = error_message_line(editor.message.to_s, cols)
+      if editor.hit_enter_active? && editor.hit_enter_lines
+        render_hit_enter_overlay(editor, lines, text_rows:, cols:)
+      else
+        status_row = text_rows + 1
+        lines[status_row] = "\e[7m#{truncate(status_line(editor, cols), cols)}\e[m"
+        lines[status_row + 1] = ""
+
+        if editor.command_line_active?
+          cmd = editor.command_line
+          lines[status_row + 1] = truncate("#{cmd.prefix}#{cmd.text}", cols)
+        elsif editor.message_error?
+          lines[status_row + 1] = error_message_line(editor.message.to_s, cols)
+        end
       end
 
       {
@@ -90,66 +116,129 @@ module RuVim
       }
     end
 
-    def render_window_area(editor, lines, rects, text_rows:, text_cols:)
-      if rects.values.any? { |r| r[:separator] == :vertical }
-        render_vertical_windows(editor, lines, rects, text_rows:, text_cols:)
-      else
-        render_horizontal_windows(editor, lines, rects, text_rows:, text_cols:)
+    def render_hit_enter_overlay(editor, lines, text_rows:, cols:)
+      msg_lines = editor.hit_enter_lines
+      prompt = "Press ENTER or type command to continue"
+      # Total rows available: text_rows (text area) + 1 (status) + 1 (command) = text_rows + 2
+      total_rows = text_rows + 2
+      # We need msg_lines.length rows for messages + 1 row for the prompt
+      overlay_count = msg_lines.length + 1
+      start_row = [total_rows - overlay_count + 1, 1].max
+      msg_lines.each_with_index do |line, i|
+        row_no = start_row + i
+        break if row_no > total_rows
+        lines[row_no] = truncate(line.to_s, cols)
       end
+      prompt_row = start_row + msg_lines.length
+      prompt_row = [prompt_row, total_rows].min
+      lines[prompt_row] = "\e[7m#{truncate(prompt, cols)}\e[m"
     end
 
-    def render_horizontal_windows(editor, lines, rects, text_rows:, text_cols:)
-      1.upto(text_rows) { |row_no| lines[row_no] = " " * text_cols }
+    def render_window_area(editor, lines, rects, text_rows:, text_cols:)
+      render_tree_windows(editor, lines, rects, text_rows:, text_cols:)
+    end
 
+    def render_tree_windows(editor, lines, rects, text_rows:, text_cols:)
+      # Pre-render each window's rows
+      window_rows_cache = {}
       editor.window_order.each do |win_id|
         rect = rects[win_id]
         next unless rect
-
         window = editor.windows.fetch(win_id)
         buffer = editor.buffers.fetch(window.buffer_id)
         gutter_w = number_column_width(editor, window, buffer)
         content_w = [rect[:width] - gutter_w, 1].max
-        rows = window_render_rows(editor, window, buffer, height: rect[:height], gutter_w:, content_w:)
-        rect[:height].times do |dy|
-          row_no = rect[:top] + dy
-          lines[row_no] = rows[dy] || (" " * rect[:width])
-        end
+        window_rows_cache[win_id] = window_render_rows(editor, window, buffer, height: rect[:height], gutter_w:, content_w:)
       end
 
-      rects.each_value do |rect|
-        next unless rect[:separator] == :horizontal
-        lines[rect[:sep_row]] = ("-" * text_cols)
-      end
-    end
+      # Build a row-plan: for each screen row, collect the pieces to concatenate
+      row_plans = build_row_plans(editor.layout_tree, rects, text_rows, text_cols)
 
-    def render_vertical_windows(editor, lines, rects, text_rows:, text_cols:)
       1.upto(text_rows) do |row_no|
+        plan = row_plans[row_no]
+        unless plan
+          lines[row_no] = " " * text_cols
+          next
+        end
+
         pieces = +""
-        editor.window_order.each_with_index do |win_id, idx|
-          rect = rects[win_id]
-          next unless rect
-          window = editor.windows.fetch(win_id)
-          buffer = editor.buffers.fetch(window.buffer_id)
-          gutter_w = number_column_width(editor, window, buffer)
-          content_w = [rect[:width] - gutter_w, 1].max
-          dy = row_no - rect[:top]
-          text =
-            if dy >= 0 && dy < rect[:height]
-              @__window_rows_cache ||= {}
-              key = [window.id, rect[:height], gutter_w, content_w, window.row_offset, window.col_offset, window.cursor_y, window.cursor_x,
-                     editor.effective_option("wrap", window:, buffer:), editor.effective_option("linebreak", window:, buffer:),
-                     editor.effective_option("breakindent", window:, buffer:), editor.effective_option("showbreak", window:, buffer:)]
-              @__window_rows_cache[key] ||= window_render_rows(editor, window, buffer, height: rect[:height], gutter_w:, content_w:)
-              @__window_rows_cache[key][dy] || (" " * rect[:width])
-            else
-              " " * rect[:width]
-            end
-          pieces << text
-          pieces << "|" if idx < editor.window_order.length - 1
+        plan.each do |piece|
+          case piece[:type]
+          when :window
+            rect = rects[piece[:id]]
+            dy = row_no - rect[:top]
+            rows = window_rows_cache[piece[:id]]
+            text = (rows && dy >= 0 && dy < rect[:height]) ? (rows[dy] || " " * rect[:width]) : " " * rect[:width]
+            pieces << text
+          when :vsep
+            pieces << "|"
+          when :hsep
+            pieces << "-" * piece[:width]
+          when :blank
+            pieces << " " * piece[:width]
+          end
         end
         lines[row_no] = pieces
       end
-      @__window_rows_cache = nil
+    end
+
+    # Build a row-by-row plan for compositing. Each row's plan is an array of
+    # pieces to concatenate left-to-right.
+    def build_row_plans(node, rects, text_rows, text_cols)
+      plans = {}
+      fill_row_plans(node, rects, plans, 1, text_rows)
+      plans
+    end
+
+    def fill_row_plans(node, rects, plans, row_start, row_end)
+      return unless node
+
+      if node[:type] == :window
+        rect = rects[node[:id]]
+        return unless rect
+        rect[:height].times do |dy|
+          row_no = rect[:top] + dy
+          next if row_no < row_start || row_no > row_end
+          plans[row_no] ||= []
+          plans[row_no] << { type: :window, id: node[:id] }
+        end
+        return
+      end
+
+      children = node[:children]
+      if node[:type] == :vsplit
+        children.each_with_index do |child, i|
+          fill_row_plans(child, rects, plans, row_start, row_end)
+          if i < children.length - 1
+            # Insert vsep marker for the rows spanned by these children
+            child_leaves = tree_leaves_for_rects(child)
+            child_rects_list = child_leaves.filter_map { |id| rects[id] }
+            next if child_rects_list.empty?
+            top = child_rects_list.map { |r| r[:top] }.min
+            bottom = child_rects_list.map { |r| r[:top] + r[:height] - 1 }.max
+            top.upto(bottom) do |row_no|
+              next if row_no < row_start || row_no > row_end
+              plans[row_no] ||= []
+              plans[row_no] << { type: :vsep }
+            end
+          end
+        end
+      elsif node[:type] == :hsplit
+        children.each_with_index do |child, i|
+          fill_row_plans(child, rects, plans, row_start, row_end)
+          if i < children.length - 1
+            child_leaves = tree_leaves_for_rects(child)
+            child_rects_list = child_leaves.filter_map { |id| rects[id] }
+            next if child_rects_list.empty?
+            sep_row = child_rects_list.map { |r| r[:top] + r[:height] }.max
+            left = child_rects_list.map { |r| r[:left] }.min
+            right = child_rects_list.map { |r| r[:left] + r[:width] - 1 }.max
+            next unless sep_row >= row_start && sep_row <= row_end
+            plans[sep_row] ||= []
+            plans[sep_row] << { type: :hsep, width: right - left + 1 }
+          end
+        end
+      end
     end
 
     def can_diff_render?(frame)
@@ -301,22 +390,144 @@ module RuVim
     end
 
     def plain_window_render_rows(editor, window, buffer, height:, gutter_w:, content_w:)
+      if RuVim::RichView.active?(editor)
+        return rich_view_render_rows(editor, window, buffer, height:, gutter_w:, content_w:)
+      end
+
       Array.new(height) do |dy|
         buffer_row = window.row_offset + dy
         if buffer_row < buffer.line_count
           render_window_row(editor, window, buffer, buffer_row, gutter_w:, content_w:)
         else
-          line_number_prefix(editor, window, buffer, nil, gutter_w) + pad_plain_display("~", content_w)
+          render_gutter_prefix(editor, window, buffer, nil, gutter_w) + pad_plain_display("~", content_w)
         end
       end
     end
 
+    def rich_view_render_rows(editor, window, buffer, height:, gutter_w:, content_w:)
+      raw_lines = []
+      height.times do |dy|
+        row = window.row_offset + dy
+        raw_lines << (row < buffer.line_count ? buffer.line_at(row) : nil)
+      end
+
+      non_nil = raw_lines.compact
+      context = rich_view_context(editor, window, buffer)
+      formatted = RuVim::RichView.render_visible_lines(editor, non_nil, context: context)
+      fmt_idx = 0
+      col_offset_sc = @rich_render_info ? @rich_render_info[:col_offset_sc] : 0
+
+      Array.new(height) do |dy|
+        buffer_row = window.row_offset + dy
+        prefix = render_gutter_prefix(editor, window, buffer, buffer_row < buffer.line_count ? buffer_row : nil, gutter_w)
+        if buffer_row < buffer.line_count
+          line = formatted[fmt_idx] || ""
+          fmt_idx += 1
+          body = render_rich_view_line_sc(line, width: content_w, skip_sc: col_offset_sc)
+          prefix + body
+        else
+          prefix + pad_plain_display("~", content_w)
+        end
+      end
+    end
+
+    def rich_view_context(editor, window, buffer)
+      state = editor.rich_state
+      return {} unless state
+
+      format = state[:format]
+      renderer = RuVim::RichView.renderer_for(format)
+      return {} unless renderer && renderer.respond_to?(:needs_pre_context?) && renderer.needs_pre_context?
+
+      # Collect lines before the visible area for state tracking (e.g., code fences)
+      pre_lines = []
+      (0...window.row_offset).each do |row|
+        pre_lines << buffer.line_at(row) if row < buffer.line_count
+      end
+      { pre_context_lines: pre_lines }
+    end
+
+    # Render a formatted rich-view line by skipping `skip_sc` display columns
+    # then showing the next `width` display columns.  Using screen columns
+    # instead of character indices keeps alignment correct when lines mix
+    # CJK and ASCII characters with different char-to-display-width ratios.
+    # ANSI escape sequences (\e[...m) are treated as zero-width and passed
+    # through to the output unchanged.
+    def render_rich_view_line_sc(text, width:, skip_sc:)
+      # Phase 1: skip `skip_sc` display columns
+      # Collect ANSI sequences encountered during skip so active styles carry over.
+      chars = text.to_s
+      pos = 0
+      skipped = 0
+      len = chars.length
+      pending_ansi = +""
+      while pos < len
+        if chars[pos] == "\e"
+          end_pos = find_ansi_end(chars, pos)
+          pending_ansi << chars[pos...end_pos]
+          pos = end_pos
+          next
+        end
+        ch = chars[pos]
+        cw = RuVim::DisplayWidth.cell_width(ch, col: skipped, tabstop: 8)
+        break if skipped + cw > skip_sc
+        skipped += cw
+        pos += 1
+      end
+      # If a wide char straddles the skip boundary, pad with a space
+      leading_pad = skip_sc - skipped
+
+      # Phase 2: collect `width` display columns
+      out = +""
+      out << pending_ansi unless pending_ansi.empty?
+      col = 0
+      if leading_pad > 0
+        out << " " * leading_pad
+        col += leading_pad
+        pos += 1 if pos < len && chars[pos] != "\e"
+      end
+      while pos < len
+        if chars[pos] == "\e"
+          end_pos = find_ansi_end(chars, pos)
+          out << chars[pos...end_pos]
+          pos = end_pos
+          next
+        end
+        ch = chars[pos]
+        cw = RuVim::DisplayWidth.cell_width(ch, col: skipped + col, tabstop: 8)
+        break if col + cw > width
+        out << ch
+        col += cw
+        pos += 1
+      end
+      out << " " * [width - col, 0].max
+      out << "\e[m"
+      out
+    end
+
+    # Find the end position of an ANSI escape sequence starting at `pos`.
+    # Handles CSI sequences (\e[...X) where X is a letter.
+    def find_ansi_end(str, pos)
+      i = pos + 1  # skip \e
+      return i if i >= str.length
+      if str[i] == "["
+        i += 1
+        # Skip parameter bytes and intermediate bytes
+        i += 1 while i < str.length && str[i].ord >= 0x20 && str[i].ord <= 0x3F
+        # Final byte
+        i += 1 if i < str.length && str[i].ord >= 0x40 && str[i].ord <= 0x7E
+      else
+        i += 1
+      end
+      i
+    end
+
     def wrapped_window_render_rows(editor, window, buffer, height:, gutter_w:, content_w:)
       rows = []
       row_idx = window.row_offset
       while rows.length < height
         if row_idx >= buffer.line_count
-          rows << (line_number_prefix(editor, window, buffer, nil, gutter_w) + pad_plain_display("~", content_w))
+          rows << (render_gutter_prefix(editor, window, buffer, nil, gutter_w) + pad_plain_display("~", content_w))
           next
         end
 
@@ -325,7 +536,7 @@ module RuVim
         segments.each_with_index do |seg, seg_i|
           break if rows.length >= height
 
-          gutter = line_number_prefix(editor, window, buffer, seg_i.zero? ? row_idx : nil, gutter_w)
+          gutter = render_gutter_prefix(editor, window, buffer, seg_i.zero? ? row_idx : nil, gutter_w)
           rows << gutter + render_text_segment(line, editor, buffer_row: row_idx, window:, buffer:, width: content_w,
                                                source_col_start: seg[:source_col_start], display_prefix: seg[:display_prefix])
         end
@@ -334,7 +545,92 @@ module RuVim
       rows
     end
 
+    def ensure_visible_under_wrap(editor, window, buffer, height:, content_w:)
+      return if height.to_i <= 0 || buffer.line_count <= 0
+
+      window.row_offset = [[window.row_offset.to_i, 0].max, buffer.line_count - 1].min
+      return if window.cursor_y < window.row_offset
+
+      cursor_line = buffer.line_at(window.cursor_y)
+      cursor_segs = wrapped_segments_for_line(editor, window, buffer, cursor_line, width: content_w)
+      cursor_seg_index = wrapped_segment_index(cursor_segs, window.cursor_x)
+
+      visual_rows_before = 0
+      row = window.row_offset
+      while row < window.cursor_y
+        visual_rows_before += wrapped_segments_for_line(editor, window, buffer, buffer.line_at(row), width: content_w).length
+        row += 1
+      end
+
+      cursor_visual_row = visual_rows_before + cursor_seg_index
+      while cursor_visual_row >= height && window.row_offset < window.cursor_y
+        dropped = wrapped_segments_for_line(editor, window, buffer, buffer.line_at(window.row_offset), width: content_w).length
+        window.row_offset += 1
+        cursor_visual_row -= dropped
+      end
+    rescue StandardError
+      nil
+    end
+
+    # Compute a screen-column-based horizontal scroll offset for rich mode.
+    # Unlike normal mode (which stores a char index in window.col_offset),
+    # rich mode must scroll by display columns because CJK-padded formatted
+    # lines have different character counts for the same display width.
+    def ensure_visible_rich(editor, win, buf, rect, content_w)
+      state = editor.rich_state
+      unless state
+        @rich_render_info = nil
+        @rich_col_offset_sc = 0
+        return
+      end
+
+      format = state[:format]
+      delimiter = state[:delimiter]
+      renderer = RuVim::RichView.renderer_for(format)
+      height = [rect[:height], 1].max
+
+      raw_lines = height.times.map { |dy|
+        row = win.row_offset + dy
+        row < buf.line_count ? buf.line_at(row) : nil
+      }.compact
+
+      cursor_raw_line = buf.line_at(win.cursor_y)
+
+      if renderer && renderer.respond_to?(:cursor_display_col)
+        cursor_sc = renderer.cursor_display_col(
+          cursor_raw_line, win.cursor_x, visible_lines: raw_lines, delimiter: delimiter
+        )
+      else
+        cursor_sc = RuVim::TextMetrics.screen_col_for_char_index(cursor_raw_line, win.cursor_x)
+      end
+
+      # Use persisted screen-column offset from previous frame
+      offset_sc = @rich_col_offset_sc || 0
+
+      sso = editor.effective_option("sidescrolloff", window: win, buffer: buf).to_i
+      sso = [[sso, 0].max, [content_w - 1, 0].max].min
+
+      if cursor_sc < offset_sc + sso
+        offset_sc = [cursor_sc - sso, 0].max
+      elsif cursor_sc >= offset_sc + content_w - sso
+        offset_sc = cursor_sc - content_w + sso + 1
+      end
+      offset_sc = [offset_sc, 0].max
+
+      @rich_col_offset_sc = offset_sc
+
+      if win == editor.current_window
+        @rich_render_info = {
+          col_offset_sc: offset_sc,
+          cursor_sc: cursor_sc,
+          delimiter: delimiter
+        }
+      end
+    end
+
     def wrap_enabled?(editor, window, buffer)
+      return false if editor.rich_state
+
       !!editor.effective_option("wrap", window:, buffer:)
     end
 
@@ -345,15 +641,25 @@ module RuVim
       linebreak = !!editor.effective_option("linebreak", window:, buffer:)
       showbreak = editor.effective_option("showbreak", window:, buffer:).to_s
       breakindent = !!editor.effective_option("breakindent", window:, buffer:)
+      line = line.to_s
+      return [{ source_col_start: 0, display_prefix: "" }] if line.empty?
+
+      cache_key = [line.object_id, line.length, line.hash, width, tabstop, linebreak, showbreak, breakindent]
+      if (cached = @wrapped_segments_cache[cache_key])
+        return cached
+      end
+
       indent_prefix = breakindent ? wrapped_indent_prefix(line, tabstop:, max_width: [width - RuVim::DisplayWidth.display_width(showbreak, tabstop:), 0].max) : ""
+      segs = compute_wrapped_segments(line, width:, tabstop:, linebreak:, showbreak:, indent_prefix:)
+      @wrapped_segments_cache[cache_key] = segs
+      @wrapped_segments_cache.shift while @wrapped_segments_cache.length > WRAP_SEGMENTS_CACHE_LIMIT
+      segs
+    end
 
+    def compute_wrapped_segments(line, width:, tabstop:, linebreak:, showbreak:, indent_prefix:)
       segs = []
       start_col = 0
       first = true
-      line = line.to_s
-      if line.empty?
-        return [{ source_col_start: 0, display_prefix: "" }]
-      end
 
       while start_col < line.length
         display_prefix = first ? "" : "#{showbreak}#{indent_prefix}"
@@ -361,7 +667,7 @@ module RuVim
         avail = [width - prefix_w, 1].max
         cells, = RuVim::TextMetrics.clip_cells_for_width(line[start_col..].to_s, avail, source_col_start: start_col, tabstop:)
         if cells.empty?
-          segs << { source_col_start: start_col, display_prefix: display_prefix }
+          segs << { source_col_start: start_col, display_prefix: display_prefix }.freeze
           break
         end
 
@@ -372,7 +678,7 @@ module RuVim
           end
         end
 
-        segs << { source_col_start: start_col, display_prefix: display_prefix }
+        segs << { source_col_start: start_col, display_prefix: display_prefix }.freeze
         next_start = cells.last.source_col.to_i + 1
         if linebreak
           next_start += 1 while next_start < line.length && line[next_start] == " "
@@ -383,7 +689,20 @@ module RuVim
         first = false
       end
 
-      segs
+      segs.freeze
+    end
+
+    def wrapped_segment_index(segs, cursor_x)
+      x = cursor_x.to_i
+      seg_index = 0
+      segs.each_with_index do |seg, i|
+        nxt = segs[i + 1]
+        if nxt.nil? || x < nxt[:source_col_start]
+          seg_index = i
+          break
+        end
+      end
+      seg_index
     end
 
     def linebreak_break_index(cells, line)
@@ -453,7 +772,7 @@ module RuVim
     def render_window_row(editor, window, buffer, buffer_row, gutter_w:, content_w:)
       line = buffer.line_at(buffer_row)
       line = line[window.col_offset..] || ""
-      prefix = line_number_prefix(editor, window, buffer, buffer_row, gutter_w)
+      prefix = render_gutter_prefix(editor, window, buffer, buffer_row, gutter_w)
       body = render_text_line(line, editor, buffer_row:, window:, buffer:, width: content_w)
       prefix + body
     end
@@ -497,6 +816,15 @@ module RuVim
       sign + num.rjust([num_width - 1, 0].max) + (num_width.positive? ? " " : "")
     end
 
+    def render_gutter_prefix(editor, window, buffer, buffer_row, width)
+      prefix = line_number_prefix(editor, window, buffer, buffer_row, width)
+      return prefix if prefix.empty?
+      return prefix if buffer_row.nil?
+
+      current_line = (buffer_row == window.cursor_y)
+      "#{line_number_fg_seq(editor, current_line: current_line)}#{prefix}\e[m"
+    end
+
     def sign_column_width(editor, window, buffer)
       raw = editor.effective_option("signcolumn", window:, buffer:).to_s
       case raw
@@ -554,6 +882,14 @@ module RuVim
       truecolor_enabled?(editor) ? "\e[48;2;58;58;58m" : "\e[48;5;236m"
     end
 
+    def line_number_fg_seq(editor, current_line: false)
+      if truecolor_enabled?(editor)
+        current_line ? "\e[38;2;190;190;190m" : "\e[38;2;120;120;120m"
+      else
+        current_line ? "\e[37m" : "\e[90m"
+      end
+    end
+
     def truecolor_enabled?(editor)
       !!editor.effective_option("termguicolors")
     rescue StandardError
@@ -569,18 +905,47 @@ module RuVim
              when :visual_char then "-- VISUAL --"
              when :visual_line then "-- VISUAL LINE --"
              when :visual_block then "-- VISUAL BLOCK --"
+             when :rich then "-- RICH --"
              else "-- NORMAL --"
              end
 
       path = buffer.display_name
       mod = buffer.modified? ? " [+]" : ""
+      stream = stream_status_token(buffer)
+      loading = file_loading_status_token(buffer)
+      tab = tab_status_token(editor)
       msg = editor.message_error? ? "" : editor.message.to_s
-      left = "#{mode} #{path}#{mod}"
-      right = " #{window.cursor_y + 1}:#{window.cursor_x + 1} "
+      left = "#{mode} #{path}#{mod}#{stream}#{loading}"
+      right = " #{window.cursor_y + 1}:#{window.cursor_x + 1}#{tab} "
       body_width = [width - right.length, 0].max
       "#{compose_status_body(left, msg, body_width)}#{right}"
     end
 
+    def stream_status_token(buffer)
+      return "" unless buffer.respond_to?(:stream_state)
+      return "" unless buffer.kind == :stream
+
+      state = (buffer.stream_state || :live).to_s
+      " [stdin/#{state}]"
+    end
+
+    def file_loading_status_token(buffer)
+      return "" unless buffer.respond_to?(:loading_state)
+      return "" unless buffer.file_buffer?
+
+      state = buffer.loading_state
+      return "" unless state
+      return "" if state.to_sym == :closed
+
+      " [load/#{state}]"
+    end
+
+    def tab_status_token(editor)
+      return "" if editor.tabpage_count <= 1
+
+      " tab:#{editor.current_tabpage_number}/#{editor.tabpage_count}"
+    end
+
     def compose_status_body(left, msg, width)
       w = [width.to_i, 0].max
       return "" if w.zero?
@@ -596,7 +961,8 @@ module RuVim
     end
 
     def truncate(str, width)
-      RuVim::TextMetrics.terminal_safe_text(str).ljust(width)[0, width]
+      safe = RuVim::TextMetrics.terminal_safe_text(str)
+      RuVim::TextMetrics.pad_plain_to_screen_width(safe, width)
     end
 
     def error_message_line(msg, cols)
@@ -614,6 +980,16 @@ module RuVim
     def cursor_screen_position(editor, text_rows, rects)
       window = editor.current_window
 
+      if editor.hit_enter_active? && editor.hit_enter_lines
+        total_rows = text_rows + 2
+        msg_count = editor.hit_enter_lines.length
+        prompt_row = [total_rows - msg_count, 1].max + msg_count
+        prompt_row = [prompt_row, total_rows].min
+        prompt_text = "Press ENTER or type command to continue"
+        col = [prompt_text.length + 1, total_rows].min
+        return [prompt_row, col]
+      end
+
       if editor.command_line_active?
         row = text_rows + 2
         col = 1 + editor.command_line.prefix.length + editor.command_line.cursor
@@ -634,14 +1010,7 @@ module RuVim
           row += 1
         end
         segs = wrapped_segments_for_line(editor, window, buffer, line, width: content_w)
-        seg_index = 0
-        segs.each_with_index do |seg, i|
-          nxt = segs[i + 1]
-          if nxt.nil? || window.cursor_x < nxt[:source_col_start]
-            seg_index = i
-            break
-          end
-        end
+        seg_index = wrapped_segment_index(segs, window.cursor_x)
         seg = segs[seg_index] || { source_col_start: 0, display_prefix: "" }
         row = rect[:top] + visual_rows_before + seg_index
         seg_prefix_w = RuVim::DisplayWidth.display_width(seg[:display_prefix].to_s, tabstop:)
@@ -649,6 +1018,9 @@ module RuVim
         cursor_sc = RuVim::TextMetrics.screen_col_for_char_index(line, window.cursor_x, tabstop:) + extra_virtual
         seg_sc = RuVim::TextMetrics.screen_col_for_char_index(line, seg[:source_col_start], tabstop:)
         col = rect[:left] + gutter_w + seg_prefix_w + [cursor_sc - seg_sc, 0].max
+      elsif @rich_render_info
+        row = rect[:top] + (window.cursor_y - window.row_offset)
+        col = rect[:left] + gutter_w + [@rich_render_info[:cursor_sc] - @rich_render_info[:col_offset_sc], 0].max
       else
         row = rect[:top] + (window.cursor_y - window.row_offset)
         extra_virtual = [window.cursor_x - line.length, 0].max
@@ -666,39 +1038,64 @@ module RuVim
     end
 
     def window_rects(editor, text_rows:, text_cols:)
+      tree = editor.layout_tree
+      return {} if tree.nil?
       ids = editor.window_order
       return {} if ids.empty?
-      return { ids.first => { top: 1, left: 1, height: text_rows, width: text_cols } } if ids.length == 1 || editor.window_layout == :single
-
-      if editor.window_layout == :vertical
-        sep = ids.length - 1
-        usable = [text_cols - sep, ids.length].max
-        widths = split_sizes(usable, ids.length)
-        left = 1
-        rects = {}
-        ids.each_with_index do |id, i|
+      return { ids.first => { top: 1, left: 1, height: text_rows, width: text_cols } } if ids.length == 1
+
+      compute_tree_rects(tree, top: 1, left: 1, height: text_rows, width: text_cols)
+    end
+
+    def compute_tree_rects(node, top:, left:, height:, width:)
+      if node[:type] == :window
+        return { node[:id] => { top: top, left: left, height: height, width: width } }
+      end
+
+      children = node[:children]
+      n = children.length
+      rects = {}
+
+      case node[:type]
+      when :vsplit
+        sep_count = n - 1
+        usable = [width - sep_count, n].max
+        widths = split_sizes(usable, n)
+        cur_left = left
+        children.each_with_index do |child, i|
           w = widths[i]
-          rects[id] = { top: 1, left: left, height: text_rows, width: w, separator: :vertical }
-          left += w + 1
+          child_rects = compute_tree_rects(child, top: top, left: cur_left, height: height, width: w)
+          child_rects.each_value { |r| r[:separator] = :vertical }
+          rects.merge!(child_rects)
+          cur_left += w + 1
         end
-        rects
-      else
-        sep = ids.length - 1
-        usable = [text_rows - sep, ids.length].max
-        heights = split_sizes(usable, ids.length)
-        top = 1
-        rects = {}
-        ids.each_with_index do |id, i|
+      when :hsplit
+        sep_count = n - 1
+        usable = [height - sep_count, n].max
+        heights = split_sizes(usable, n)
+        cur_top = top
+        children.each_with_index do |child, i|
           h = heights[i]
-          rects[id] = { top: top, left: 1, height: h, width: text_cols, separator: :horizontal }
-          top += h
-          if i < ids.length - 1
-            rects[id][:sep_row] = top
-            top += 1
+          child_rects = compute_tree_rects(child, top: cur_top, left: left, height: h, width: width)
+          child_rects.each_value { |r| r[:separator] = :horizontal }
+          rects.merge!(child_rects)
+          if i < n - 1
+            # Mark separator row for the last window in this child
+            child_leaves = tree_leaves_for_rects(child)
+            last_leaf = child_leaves.last
+            rects[last_leaf][:sep_row] = cur_top + h if last_leaf && rects[last_leaf]
           end
+          cur_top += h + 1
         end
-        rects
       end
+
+      rects
+    end
+
+    def tree_leaves_for_rects(node)
+      return [node[:id]] if node[:type] == :window
+
+      node[:children].flat_map { |c| tree_leaves_for_rects(c) }
     end
 
     def split_sizes(total, n)