muxr 0.1.5 → 0.1.7

data/lib/muxr/renderer.rb

@@ -4,13 +4,38 @@ module Muxr
   # new frame against the previous one and only repositions/redraws cells
   # whose contents changed, keeping output volume low between ticks.
   class Renderer
-    BORDER_FOCUSED      = [:c256, 11].freeze  # yellow
+    BORDER_FOCUSED      = [:c256, 11].freeze  # yellow (fallback when no mode color)
     BORDER_UNFOCUSED    = [:c256, 8].freeze   # grey
     BORDER_DRAWER_FOCUS = [:c256, 13].freeze  # magenta
     BORDER_DRAWER_IDLE  = [:c256, 5].freeze   # dark magenta
     STATUS_BG           = [:c256, 236].freeze
     STATUS_FG           = [:c256, 252].freeze
 
+    # Vim-style mode palette. Used in two places: the focused pane border
+    # (so the user can see at a glance what mode they're in) and the
+    # [MODE] chip in the status bar (same color, smaller real estate).
+    # :prefix maps to the same green as :passthrough because :prefix is a
+    # transient sub-state under passthrough — sharing the color avoids a
+    # one-frame border flicker when pressing Ctrl-a.
+    MODE_COLOR = {
+      normal:       [:c256, 51].freeze,   # cyan
+      passthrough:  [:c256, 42].freeze,   # green
+      prefix:       [:c256, 42].freeze,   # green (passthrough sub-state)
+      command:      [:c256, 226].freeze,  # yellow
+      scrollback:   [:c256, 214].freeze,  # orange
+      search:       [:c256, 214].freeze,  # orange (scrollback sub-state)
+      selection:    [:c256, 201].freeze,  # magenta
+      confirm_quit:  [:c256, 196].freeze, # red
+      confirm_close: [:c256, 196].freeze, # red
+      help:          [:c256, 39].freeze   # blue
+    }.freeze
+
+    # Background applied to cells that match the active scrollback search.
+    # Bright enough to stand out over typical foreground SGRs while leaving
+    # the original glyph readable.
+    SEARCH_MATCH_BG = [:c256, 226].freeze # yellow
+    SEARCH_MATCH_FG = [:c256, 16].freeze  # black
+
     HORIZONTAL = "─".freeze
     VERTICAL   = "│".freeze
     TL         = "┌".freeze
@@ -18,9 +43,9 @@ module Muxr
     BL         = "└".freeze
     BR         = "┘".freeze
 
-    Cell = Struct.new(:char, :fg, :bg, :attrs) do
+    Cell = Struct.new(:char, :fg, :bg, :attrs, :hyperlink) do
       def ==(other)
-        other.is_a?(Cell) && char == other.char && fg == other.fg && bg == other.bg && attrs == other.attrs
+        other.is_a?(Cell) && char == other.char && fg == other.fg && bg == other.bg && attrs == other.attrs && hyperlink == other.hyperlink
       end
     end
 
@@ -32,7 +57,10 @@ module Muxr
     end
 
     def enter_alt_screen
-      @out.write("\e[?1049h\e[?25l\e[2J\e[H\e[0m")
+      # Close any stale OSC 8 hyperlink the outer terminal might be carrying
+      # from before we attached, so the first frame's run-tracker matches
+      # reality.
+      @out.write("\e[?1049h\e[?25l\e[2J\e[H\e[0m\e]8;;\e\\")
       @out.flush
       @prev = nil
     end
@@ -46,24 +74,31 @@ module Muxr
       @prev = nil
     end
 
-    def render(session, input_state: :idle, command_buffer: "", message: nil, help: false)
+    def render(session, input_state: :normal, command_buffer: "", search_buffer: "", search_direction: :forward, message: nil, help: false)
       w = session.width
       h = session.height
       return if w < 4 || h < 3
 
-      frame = Array.new(h) { Array.new(w) { Cell.new(" ", nil, nil, 0) } }
-
-      compose_panes(frame, session)
-      compose_drawer(frame, session) if session.drawer&.visible?
-      compose_status_bar(frame, session, input_state: input_state, command_buffer: command_buffer, message: message)
+      frame = Array.new(h) { Array.new(w) { Cell.new(" ", nil, nil, 0, nil) } }
+
+      compose_panes(frame, session, input_state: input_state)
+      compose_drawer(frame, session, input_state: input_state) if session.drawer&.visible?
+      compose_status_bar(
+        frame, session,
+        input_state: input_state,
+        command_buffer: command_buffer,
+        search_buffer: search_buffer,
+        search_direction: search_direction,
+        message: message
+      )
       compose_help(frame, session) if help
 
-      emit_frame(frame, session, input_state: input_state, command_buffer: command_buffer)
+      emit_frame(frame, session, input_state: input_state, command_buffer: command_buffer, search_buffer: search_buffer)
     end
 
     private
 
-    def compose_panes(frame, session)
+    def compose_panes(frame, session, input_state: :normal)
       win = session.window
       content_area = LayoutManager::Rect.new(0, 0, session.width, session.height - 1)
       rects = LayoutManager.compute(
@@ -99,20 +134,32 @@ module Muxr
         title += " #{pane.id}" if pane.respond_to?(:id) && pane.id.is_a?(String)
         title += " [P]" if pane.respond_to?(:private?) && pane.private?
         title += " ★" if i == win.master_index
-        title += " (" + win.layout.to_s + ")" if i == win.focused_index
+        # Foreground command (e.g. "npm test", "vim"). Set by the poller
+        # thread; nil when the shell itself is foreground. Truncate so a
+        # long invocation doesn't push the title past what draw_box will
+        # render — draw_box silently drops titles that don't fit.
+        if pane.respond_to?(:foreground_command) && pane.foreground_command
+          cmd = pane.foreground_command.to_s[0, 16]
+          title += " · #{cmd}"
+        end
         if pane.terminal.scrolled_back?
           title += " [scrollback #{pane.terminal.view_offset}/#{pane.terminal.scrollback_size}]"
         end
         draw_box(frame, rect,
-                 border: focused ? BORDER_FOCUSED : BORDER_UNFOCUSED,
+                 border: focused ? mode_color(input_state) : BORDER_UNFOCUSED,
                  bold_border: focused,
                  title: title,
                  title_focused: focused)
+        # Mode chip lives in the top-right corner of the focused container
+        # (this pane, or the drawer — see compose_drawer). Showing it on
+        # the same edge as the title but on the opposite side keeps both
+        # readable without one crowding the other.
+        draw_mode_chip(frame, rect, input_state, title) if focused
         copy_terminal(frame, pane, rect.x + 1, rect.y + 1)
       end
     end
 
-    def compose_drawer(frame, session)
+    def compose_drawer(frame, session, input_state: :normal)
       drawer = session.drawer
       return unless drawer&.pane
 
@@ -150,10 +197,50 @@ module Muxr
                bold_border: true,
                title: title,
                title_focused: focused)
+      draw_mode_chip(frame, rect, input_state, title) if focused
       copy_terminal(frame, drawer.pane, rect.x + 1, rect.y + 1)
     end
 
-    def compose_status_bar(frame, session, input_state:, command_buffer:, message:)
+    def mode_color(input_state)
+      MODE_COLOR[input_state] || BORDER_FOCUSED
+    end
+
+    # Paint the " [MODE] " chip on the top border, hugging the right corner.
+    # Skipped when there isn't at least one column of breathing room between
+    # the title (anchored at the top-left) and the chip — otherwise long
+    # titles + a wide chip would overdraw each other and produce garbage.
+    def draw_mode_chip(frame, rect, input_state, title)
+      chip = " [#{mode_label(input_state)}] "
+      chip_start = rect.x + rect.w - 1 - chip.length
+      title_text = " #{title} "
+      title_end = rect.x + 2 + title_text.length - 1
+      return if chip_start <= title_end + 1
+      chip_color = mode_color(input_state)
+      chip.each_char.with_index do |ch, j|
+        set_cell(frame, rect.y, chip_start + j, ch, fg: chip_color, attrs: Terminal::BOLD)
+      end
+    end
+
+    # Two-letter-ish mode label shown in the leftmost slot of the status bar.
+    # Lets the user see at a glance whether single-key bindings are active
+    # (NORMAL) or every key passes through to the focused pane (PASS).
+    def mode_label(input_state)
+      case input_state
+      when :normal       then "NORMAL"
+      when :passthrough  then "PASS"
+      when :prefix       then "^A"
+      when :command      then "CMD"
+      when :scrollback   then "SCROLL"
+      when :search       then "SEARCH"
+      when :selection    then "SEL"
+      when :confirm_quit  then "QUIT?"
+      when :confirm_close then "CLOSE?"
+      when :help          then "HELP"
+      else                    "?"
+      end
+    end
+
+    def compose_status_bar(frame, session, input_state:, command_buffer:, search_buffer: "", search_direction: :forward, message: nil)
       y = session.height - 1
       w = session.width
       win = session.window
@@ -163,7 +250,8 @@ module Muxr
         else                                  "hidden"
         end
 
-      left = " [#{session.name}]"
+      left = " [#{mode_label(input_state)}]"
+      left << " [#{session.name}]"
       left << " panes:#{win.panes.length}"
       left << " layout:#{win.layout}"
       focused_label =
@@ -190,6 +278,21 @@ module Muxr
         c.attrs = 0
       end
 
+      # Recolor the leading "[MODE]" chip in the mode's accent color. The
+      # chip lives at offset 1 (after one leading space) and runs for
+      # bracket+label+bracket characters. Full-row overlays below will
+      # overwrite this when active (command/scrollback/selection) — that's
+      # fine, those modes already convey themselves loudly.
+      chip = "[#{mode_label(input_state)}]"
+      chip_color = mode_color(input_state)
+      chip_start = 1
+      chip_end = [chip_start + chip.length, w].min
+      (chip_start...chip_end).each do |x|
+        c = frame[y][x]
+        c.fg = chip_color
+        c.attrs |= Terminal::BOLD
+      end
+
       if input_state == :command
         overlay = ":#{command_buffer}"
         overlay = overlay[0, w]
@@ -208,7 +311,25 @@ module Muxr
           c.attrs = 0
         end
       elsif input_state == :scrollback
-        overlay = " SCROLLBACK  j/k line  d/u half  f/b page  g/G top/bot  v select  q quit "
+        overlay = " SCROLLBACK  ↑↓/j/k line  d/u half  f/b page  g/G top/bot  / search  n/N next/prev  v select  q quit "
+        overlay = overlay[0, w]
+        overlay.each_char.with_index do |ch, x|
+          c = frame[y][x]
+          c.char = ch
+          c.fg = [:c256, 232]
+          c.bg = [:c256, 214]
+          c.attrs = Terminal::BOLD
+        end
+        (overlay.length...w).each do |x|
+          c = frame[y][x]
+          c.char = " "
+          c.fg = nil
+          c.bg = [:c256, 214]
+          c.attrs = 0
+        end
+      elsif input_state == :search
+        prefix = search_direction == :backward ? "?" : "/"
+        overlay = "#{prefix}#{search_buffer}"
         overlay = overlay[0, w]
         overlay.each_char.with_index do |ch, x|
           c = frame[y][x]
@@ -231,7 +352,7 @@ module Muxr
           mode = focused.terminal.selection_mode == :block ? "BLOCK" : "CHAR"
         end
         label = mode ? "SELECTION/#{mode}" : "SELECTION (cursor)"
-        overlay = " #{label}  h/j/k/l move  v char  C-v block  y/Enter yank  q cancel "
+        overlay = " #{label}  h/j/k/l move  v/space char  C-v block  y/Enter yank  q cancel "
         overlay = overlay[0, w]
         overlay.each_char.with_index do |ch, x|
           c = frame[y][x]
@@ -265,28 +386,35 @@ module Muxr
     HELP_LINES = [
       "muxr — keybindings",
       "",
-      "  C-a c       new pane",
-      "  C-a n / p   next / prev pane",
-      "  C-a a       toggle to previously focused pane",
-      "  C-a 1..9    jump to pane by number",
-      "  C-a k       close focused pane",
-      "  C-a Tab     cycle layout (tall → grid → monocle)",
-      "  C-a Enter   promote focused pane to master",
-      "  C-a ~       toggle drawer (shell)",
-      "  C-a C       toggle Claude Code drawer (MCP-aware)",
-      "  C-a P       toggle private flag on focused pane (hides from MCP)",
-      "  C-a [       enter scrollback (j/k d/u f g/G C-b/C-f; v→cursor, q quits)",
-      "              cursor: v select, C-v block, y yank, q cancel",
-      "              motions: h/j/k/l 0/^/$ w/e/b W/E/B H/M/L g/G",
-      "  C-a ]       paste internal copy buffer",
-      "  C-a d       detach (server keeps running)",
-      "  C-a q       kill session (asks y/n)",
-      "  C-a :       command prompt",
-      "  C-a ?       toggle this help",
-      "  C-a C-a     send literal C-a",
+      "NORMAL mode (default; no prefix)",
+      "  h / j / k / l   focus pane left / down / up / right",
+      "  H / J / K / L   move pane left / down / up / right",
+      "  i               drop into passthrough mode",
+      "  c / x           new / close pane (close asks y/n)",
+      "  t / g / m       layout: tall / grid / monocle",
+      "  Tab / Enter     cycle layout / promote to master",
+      "  a / 1..9        last pane / jump by number",
+      "  s               enter scrollback",
+      "  ~ / C / P       drawer / Claude drawer / toggle private",
+      "  : / ?           command prompt / toggle this help",
+      "  ] / d / q       paste buffer / detach / kill session",
+      "",
+      "PASSTHROUGH mode (keys reach the focused pane; prefix is Ctrl-a)",
+      "  C-a Esc         return to normal mode",
+      "  C-a c x t g m   same as normal-mode bindings",
+      "  C-a Tab Enter   cycle layout / promote master",
+      "  C-a n / p / a   next / prev / last pane",
+      "  C-a [ ]         scrollback / paste buffer",
+      "  C-a C-a         send literal Ctrl-a to focused pane",
+      "",
+      "SCROLLBACK mode (exits to the mode you came from)",
+      "  j/k ↑/↓ d/u f/b g/G  scroll  C-b/C-f page  v→cursor",
+      "  / search-fwd  ? search-back  n/N next/prev match",
+      "  cursor: h/j/k/l 0/^/$ w/e/b W/E/B H/M/L g/G",
+      "          v select, C-v block, y/Enter yank, q/Esc cancel",
       "",
-      "Commands: layout {tall|grid|monocle}, drawer {toggle|show|hide|reset}, claude,",
-      "          save, restore, sessions, quit, new, close, next, prev",
+      "Commands: layout {tall|grid|monocle}, drawer {toggle|show|hide|reset},",
+      "          claude, save, restore, sessions, quit, new, close, next, prev",
       "",
       "press any key to dismiss"
     ].freeze
@@ -354,6 +482,7 @@ module Muxr
       rows = term.rows
       cols = term.cols
       selection = term.selection_active?
+      search = term.search_active?
       rows.times do |r|
         fy = dst_y + r
         next if fy < 0 || fy >= frame.length
@@ -366,7 +495,15 @@ module Muxr
           dst.fg = src.fg
           dst.bg = src.bg
           dst.attrs = src.attrs
+          if search && term.cell_in_match?(r, c)
+            # Highlight wins over the cell's own bg so matches stay visible
+            # across whatever SGR the underlying program was using. Selection
+            # still applies on top via REVERSE below.
+            dst.fg = SEARCH_MATCH_FG
+            dst.bg = SEARCH_MATCH_BG
+          end
           dst.attrs |= Terminal::REVERSE if selection && term.selected_at_visible?(r, c)
+          dst.hyperlink = src.hyperlink
         end
       end
     end
@@ -381,7 +518,7 @@ module Muxr
       c.attrs = attrs
     end
 
-    def emit_frame(frame, session, input_state:, command_buffer:)
+    def emit_frame(frame, session, input_state:, command_buffer:, search_buffer: "")
       # \e[?2026h enters synchronized-output mode so terminals that support it
       # (Ghostty, kitty, iTerm2 ≥3.5, WezTerm, Alacritty ≥0.13, foot) present
       # the whole frame atomically instead of repainting incrementally as bytes
@@ -393,6 +530,9 @@ module Muxr
       cur_fg = :unset
       cur_bg = :unset
       cur_attrs = :unset
+      # We close any open hyperlink at end-of-frame, so the outer terminal
+      # always starts a new frame in the "no hyperlink" state.
+      cur_hyperlink = nil
       last_y = nil
       last_x = nil
 
@@ -410,13 +550,19 @@ module Muxr
             cur_bg = cell.bg
             cur_attrs = cell.attrs
           end
+          if cell.hyperlink != cur_hyperlink
+            out << "\e]8;;\e\\" if cur_hyperlink
+            out << "\e]#{cell.hyperlink}\e\\" if cell.hyperlink
+            cur_hyperlink = cell.hyperlink
+          end
           out << cell.char
           last_y = y
           last_x = x + cell.char.length
         end
       end
+      out << "\e]8;;\e\\" if cur_hyperlink
       out << "\e[0m"
-      out << cursor_position(session, input_state: input_state, command_buffer: command_buffer)
+      out << cursor_position(session, input_state: input_state, command_buffer: command_buffer, search_buffer: search_buffer)
       out << "\e[?2026l"
       @out.write(out)
       @out.flush
@@ -425,11 +571,15 @@ module Muxr
       @prev_h = frame.length
     end
 
-    def cursor_position(session, input_state:, command_buffer:)
+    def cursor_position(session, input_state:, command_buffer:, search_buffer: "")
       if input_state == :command
         col = 1 + command_buffer.length + 1 # ':' + buffer
         return "\e[#{session.height};#{col}H\e[?25h"
       end
+      if input_state == :search
+        col = 1 + search_buffer.length + 1 # '/' or '?' + buffer
+        return "\e[#{session.height};#{col}H\e[?25h"
+      end
 
       target =
         if session.focus_drawer && session.drawer&.visible? && session.drawer.pane

data/lib/muxr/terminal.rb

@@ -12,6 +12,11 @@ module Muxr
 
     SCROLLBACK_MAX = 5000
 
+    # Cap on the OSC payload we buffer before parsing. URLs in OSC 8 can be
+    # long but rarely exceed a few hundred bytes; 4 KiB lets the parser stay
+    # tolerant of weird inputs without giving an attacker an unbounded sink.
+    OSC_MAX_LEN = 4096
+
     # Inner programs (fzf ≥ 0.41, neovim, helix, …) bracket coherent screen
     # updates with `\e[?2026h … \e[?2026l` (DECSET 2026 — "Synchronized
     # Output"). When we see the open, we know more bytes are coming that
@@ -20,12 +25,13 @@ module Muxr
     # program (which left ?2026h open) cannot wedge the pane indefinitely.
     SYNC_TIMEOUT = 0.2
 
-    Cell = Struct.new(:char, :fg, :bg, :attrs) do
+    Cell = Struct.new(:char, :fg, :bg, :attrs, :hyperlink) do
       def reset!
         self.char = " "
         self.fg = nil
         self.bg = nil
         self.attrs = 0
+        self.hyperlink = nil
       end
 
       def copy_from(other)
@@ -33,6 +39,7 @@ module Muxr
         self.fg = other.fg
         self.bg = other.bg
         self.attrs = other.attrs
+        self.hyperlink = other.hyperlink
       end
     end
 
@@ -53,7 +60,14 @@ module Muxr
       @scroll_bottom = rows - 1
       @parser_state = :ground
       @parser_params = +""
+      @parser_osc = +""
       @feed_remainder = +"".b
+      # Currently-active OSC 8 hyperlink body (the "8;params;URI" payload that
+      # we'll wrap back around runs of cells when rendering), or nil when no
+      # hyperlink is open. Interned via @hyperlink_intern so repeated identical
+      # links share one frozen string for fast equality and small memory.
+      @current_hyperlink = nil
+      @hyperlink_intern = {}
       @dirty = true
       @scrollback = []
       @view_offset = 0
@@ -63,6 +77,10 @@ module Muxr
       @sync_pending = false
       @sync_started_at = nil
       @pending_replies = +"".b
+      @search_query = nil
+      @search_direction = :forward
+      @search_matches = []
+      @search_current = nil
     end
 
     # Bytes the emulator owes back to the inner program in response to a
@@ -337,6 +355,81 @@ module Muxr
       @dirty = true
     end
 
+    # ---------- search ----------
+    #
+    # Substring search over the full timeline (scrollback + live buffer).
+    # Smart-case: case-insensitive if the query is all-lowercase, sensitive
+    # otherwise. Matches are kept in timeline coordinates so they stay
+    # anchored to the same text as the user pages history.
+
+    attr_reader :search_query, :search_matches, :search_current, :search_direction
+
+    def search(query, direction: :forward)
+      query = query.to_s
+      if query.empty?
+        clear_search
+        return 0
+      end
+      @search_query = query
+      @search_direction = direction
+      @search_matches = collect_matches(query)
+      if @search_matches.empty?
+        @search_current = nil
+        @dirty = true
+        return 0
+      end
+      @search_current = nearest_match_in_direction(current_search_anchor_row, direction, inclusive: true)
+      @search_current ||= direction == :forward ? 0 : @search_matches.length - 1
+      scroll_view_to_match(@search_current)
+      @dirty = true
+      @search_matches.length
+    end
+
+    # Move to the next/previous match in the given direction, wrapping.
+    # Returns the new current match index, or nil if there are no matches.
+    # Anchors on the current match (not the viewport top) so n always
+    # advances even when scroll_view_to_match has centered the previous
+    # hit and dragged the viewport top behind it.
+    def find_in_direction(direction)
+      return nil if @search_matches.empty?
+      anchor_tr =
+        if @search_current && @search_matches[@search_current]
+          @search_matches[@search_current][0]
+        else
+          current_search_anchor_row
+        end
+      idx = strict_next_in_direction(anchor_tr, direction)
+      if idx.nil?
+        # Wrap: pick the far end depending on direction.
+        idx = direction == :forward ? 0 : @search_matches.length - 1
+      end
+      @search_current = idx
+      scroll_view_to_match(idx)
+      @dirty = true
+      idx
+    end
+
+    def cell_in_match?(visible_r, c)
+      return false if @search_matches.empty?
+      tr = timeline_row_for_visible(visible_r)
+      # Linear scan is fine: SCROLLBACK_MAX caps matches at O(rows*cols), and
+      # the renderer touches each visible cell once per frame. A row-indexed
+      # cache would matter at much larger buffer sizes than ours.
+      @search_matches.any? { |mr, sc, ec| mr == tr && c >= sc && c <= ec }
+    end
+
+    def search_active?
+      !(@search_query.nil? || @search_matches.empty?)
+    end
+
+    def clear_search
+      return if @search_query.nil? && @search_matches.empty?
+      @search_query = nil
+      @search_matches = []
+      @search_current = nil
+      @dirty = true
+    end
+
     def selected_at_visible?(r, c)
       return false unless @selection_anchor
       tr = timeline_row_for_visible(r)
@@ -448,7 +541,25 @@ module Muxr
     private
 
     def blank_cell
-      Cell.new(" ", nil, nil, 0)
+      Cell.new(" ", nil, nil, 0, nil)
+    end
+
+    # Parse the just-completed OSC payload. We only care about OSC 8
+    # (hyperlinks): `8;params;URI`. An empty URI closes the active link.
+    # Anything else (window-title OSC 0/1/2, palette OSC 4, …) is silently
+    # consumed — the emulator doesn't model it.
+    def finalize_osc
+      payload = @parser_osc
+      @parser_osc = +""
+      return if payload.empty?
+      return unless payload.start_with?("8;")
+      parts = payload.split(";", 3)
+      uri = parts[2]
+      if uri.nil? || uri.empty?
+        @current_hyperlink = nil
+      else
+        @current_hyperlink = (@hyperlink_intern[payload] ||= payload.dup.freeze)
+      end
     end
 
     def process_char(ch)
@@ -462,11 +573,18 @@ module Muxr
         csi_char(ch, b)
       when :osc
         if b == 0x07 || b == 0x9c
+          finalize_osc
           @parser_state = :ground
         elsif b == 0x1b
           @parser_state = :osc_esc
+        elsif @parser_osc.bytesize < OSC_MAX_LEN
+          @parser_osc << ch
         end
       when :osc_esc
+        # ST is `ESC \`. Anything else is malformed but we still flush — most
+        # terminals are lenient here, and being strict would swallow the
+        # payload on slightly buggy emitters.
+        finalize_osc
         @parser_state = :ground
       when :charset
         @parser_state = :ground
@@ -505,6 +623,7 @@ module Muxr
         @parser_params = +""
       when 0x5d # ]
         @parser_state = :osc
+        @parser_osc = +""
       when 0x28, 0x29, 0x2a, 0x2b # ( ) * +
         @parser_state = :charset
       when 0x37 # 7  save cursor
@@ -699,6 +818,7 @@ module Muxr
       cell.fg = @fg
       cell.bg = @bg
       cell.attrs = @attrs
+      cell.hyperlink = @current_hyperlink
       if @cursor_col >= @cols - 1
         @autowrap_pending = true
       else
@@ -729,6 +849,11 @@ module Muxr
             @selection_anchor[0] = [@selection_anchor[0] - 1, 0].max
             @selection_cursor[0] = [@selection_cursor[0] - 1, 0].max
           end
+          unless @search_matches.empty?
+            @search_matches.each { |m| m[0] -= 1 }
+            @search_matches.reject! { |m| m[0] < 0 }
+            @search_current = nil if @search_current && @search_current >= @search_matches.length
+          end
         end
         # Keep the user's view frozen on the same content when new rows arrive
         # while they're scrolled back.
@@ -832,6 +957,73 @@ module Muxr
       end
     end
 
+    def collect_matches(query)
+      case_sensitive = query.match?(/[A-Z]/)
+      needle = case_sensitive ? query : query.downcase
+      matches = []
+      timeline_size.times do |tr|
+        row = timeline_row(tr)
+        next if row.nil?
+        line = String.new(capacity: @cols)
+        @cols.times { |c| line << (row[c]&.char || " ") }
+        haystack = case_sensitive ? line : line.downcase
+        start = 0
+        while (idx = haystack.index(needle, start))
+          matches << [tr, idx, idx + needle.length - 1]
+          # Advance past the start of this match so overlapping needles
+          # ("aa" in "aaaa") still emit one match per starting position.
+          start = idx + 1
+        end
+      end
+      matches
+    end
+
+    # Top of the current viewport in timeline coordinates. Used as the
+    # reference point for "search from where the user is looking now".
+    def current_search_anchor_row
+      timeline_row_for_visible(0)
+    end
+
+    # Smallest match index whose row is >= anchor_tr (forward) or largest
+    # match index whose row is <= anchor_tr (backward). Used by search() so
+    # the first jump lands on the nearest match in the search direction
+    # without forcing the user to press n.
+    def nearest_match_in_direction(anchor_tr, direction, inclusive:)
+      if direction == :forward
+        @search_matches.each_with_index do |(mr, _, _), i|
+          return i if inclusive ? mr >= anchor_tr : mr > anchor_tr
+        end
+        nil
+      else
+        best = nil
+        @search_matches.each_with_index do |(mr, _, _), i|
+          if (inclusive ? mr <= anchor_tr : mr < anchor_tr)
+            best = i
+          else
+            break
+          end
+        end
+        best
+      end
+    end
+
+    # Strict next match (n/N) — never matches the current row; that would
+    # leave the user stuck on the same line they're already on.
+    def strict_next_in_direction(anchor_tr, direction)
+      nearest_match_in_direction(anchor_tr, direction, inclusive: false)
+    end
+
+    # Center the match in the viewport when possible. set_view_offset clamps
+    # to [0, scrollback.size] so recent matches end up showing the live
+    # buffer at the bottom and very old ones pin to the top.
+    def scroll_view_to_match(idx)
+      match = @search_matches[idx]
+      return unless match
+      tr = match[0]
+      desired = @scrollback.size - tr + (@rows / 2)
+      set_view_offset(desired)
+    end
+
     def ensure_selection_cursor_visible
       return unless @selection_cursor
       tr = @selection_cursor[0]
@@ -1020,6 +1212,7 @@ module Muxr
       @scroll_top = 0
       @scroll_bottom = @rows - 1
       @autowrap_pending = false
+      @current_hyperlink = nil
     end
   end
 end