raindown 0.6.0 → 0.8.0

data/lib/raindown/tui/saves.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../watcher/changes'
+
+module Raindown
+  module TUI
+    # The files saved, added or removed in the terminal UI's folder, like when it's watched, but kept until the Navigator
+    # takes them on its next tick, as Listen tells of them in a thread of its own.
+    class Saves
+      def initialize(root)
+        @queue = Thread::Queue.new
+        @listener = Watcher.listen(root) { |paths| paths.each { @queue << it } }
+        @listener.start
+      end
+
+      # The paths saved since they were last taken, once each.
+      def take = Array.new(@queue.size) { @queue.pop }.uniq
+
+      def stop = @listener.stop
+    end
+  end
+end

data/lib/raindown/tui/search_box.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative 'events'
+require_relative 'text'
+
+module Raindown
+  module TUI
+    # A search in a box, like Teleport's, drawn over the screen's lines below the title: what's typed, then the places
+    # that match it, each with where it is, and the selected one highlighted:
+    #    ┌──────────────── Teleport ────────────────┐
+    #    │ / stp▏                                   │
+    #    │ ## Setup               guides/setup.md:3 │
+    #    │ ## Steps                     notes.md:12 │
+    #    └──────────────────────────────────────────┘
+    # Each place is clicked to open it. Another search, like Blueprints' filter, is drawn the same, under its own title,
+    # from its query, its matches, each with its text and where it is, from the first it lists, and its selected match,
+    # clicked in its pane.
+    class SearchBox
+      include Text
+
+      # The widest the box is, with its border.
+      MAX_WIDTH = 72
+
+      def initialize(search, width:, title: 'Teleport', pane: :teleport, top: 1)
+        @search = search
+        @title = title
+        @pane = pane
+        @top = top
+        @box_width = [width - 4, MAX_WIDTH].min
+        @column = (width - @box_width) / 2
+      end
+
+      # The lines with the box drawn over them, from its top line, below the title.
+      def apply(lines)
+        box.each_with_index do |segments, offset|
+          row = offset + @top
+          lines[row] = overlay_segments(lines[row], segments, column: @column) if lines[row]
+        end
+        lines
+      end
+
+      private
+
+      # The columns inside the border, "│ " and " │".
+      def inner = @box_width - 4
+
+      def box
+        [title_edge, boxed(segment("/ #{@search.query}▏", :menu, width: inner)), *results, edge('└', '┘')]
+      end
+
+      def results
+        matches = @search.matches
+        return [boxed(segment('No matches', :info, width: inner))] if matches.empty?
+
+        first = @search.first_match
+        matches.each_with_index.map { |place, index| place_line(place, first + index) }
+      end
+
+      # The place's text, then where it is, on the right, both highlighted when it's selected.
+      def place_line(place, index)
+        text_style = :menu
+        where_style = :body
+        text_style = where_style = :selected if @search.match == index
+        event = Click.new(pane: @pane, index:, action: :enter)
+        where = " #{place.where}"
+        where_width = [display_width(where), inner / 2].min
+
+        boxed(segment(place.text, text_style, width: inner - where_width, event:),
+              segment(where, where_style, width: where_width, event:))
+      end
+
+      def boxed(*segments) = [segment('│ ', :border, width: 2), *segments, segment(' │', :border, width: 2)]
+
+      # The box's top, with its title in the middle.
+      def title_edge
+        title = " #{@title} "
+        left = (@box_width - 2 - display_width(title)) / 2
+        edge("┌#{'─' * left}#{title}", '┐')
+      end
+
+      def edge(left, right)
+        [segment("#{left}#{'─' * (@box_width - display_width(left) - 1)}#{right}", :border, width: @box_width)]
+      end
+    end
+  end
+end

data/lib/raindown/tui/terminal/input.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
 require 'curses'
-require 'unicode/display_width'
+
+require_relative '../events'
+require_relative '../text'
+require_relative 'quiet'
 
 module Raindown
   module TUI
@@ -10,27 +13,112 @@ module Raindown
       KEYS = {
         Curses::KEY_UP => :up, 'k' => :up, Curses::KEY_DOWN => :down, 'j' => :down,
         Curses::KEY_LEFT => :left, 'h' => :left, Curses::KEY_RIGHT => :right, 'l' => :right,
+        Curses::KEY_SLEFT => :scroll_left, Curses::KEY_SRIGHT => :scroll_right, Curses::KEY_SR => :scroll_up,
+        Curses::KEY_SF => :scroll_down,
         "\t" => :tab, Curses::KEY_BTAB => :tab, "\r" => :enter, "\n" => :enter, Curses::KEY_ENTER => :enter,
         ' ' => :toggle, 'x' => :execute, 'e' => :edit, 'w' => :write_back, 'r' => :reload, 'd' => :dashboard,
-        'p' => :projects, "\e" => :escape, 'q' => :quit
+        'p' => :projects, 'f' => :feelings, 'b' => :blueprints, "\x14" => :celebrate, '/' => :search,
+        '1' => :bin1, '2' => :bin2, '3' => :bin3, '4' => :bin4, '5' => :bin5, "\e" => :escape, 'q' => :quit
+      }.freeze
+      # While typing, like in Teleport, printable characters are typed, and only these keys do anything else.
+      TYPING_KEYS = {
+        Curses::KEY_UP => :up, Curses::KEY_DOWN => :down, "\r" => :enter, "\n" => :enter, Curses::KEY_ENTER => :enter,
+        "\e" => :escape, Curses::KEY_BACKSPACE => :backspace, "\x7F" => :backspace, "\b" => :backspace
       }.freeze
 
       module_function
 
+      # The next event, or :tick when no key is pressed within the timeout, in milliseconds, or nil for keys without one,
+      # like a resize, which clears the screen to draw it again.
+      def read(timeout, zones:, typing:)
+        Curses.stdscr.timeout = timeout
+        key = Curses.stdscr.getch
+        return :tick if key.nil?
+        return mouse(zones) if key == Curses::KEY_MOUSE
+
+        Curses.stdscr.clear if key == Curses::KEY_RESIZE
+        key_event(key, typing:)
+      end
+
+      # The curses gem warns the first time it makes a MouseEvent, that it's "undefining the allocator" of the class.
+      def mouse(zones)
+        event = Quiet.quietly { Curses.getmouse }
+        mouse_event(event, zones) if event
+      end
+
       # A key from getch, which is a string for a printable character and otherwise a number.
-      # Letters are the same with Shift, as the buttons show them as capitals.
-      def key_event(key)
+      # Letters are the same with Shift, as the buttons show them as capitals, unless they're being typed.
+      def key_event(key, typing: false)
+        return typing_event(key) if typing
+
         key = key.chr if key.is_a?(Integer) && key < 256
         KEYS[key.is_a?(String) ? key.downcase : key]
       end
 
+      def typing_event(key)
+        key = key.chr if key.is_a?(Integer) && key < 256
+        TYPING_KEYS.fetch(key) { Type.new(text: key) if key.is_a?(String) && key.match?(/\A[[:print:]]\z/) }
+      end
+
       # The mouse buttons that click, which are the left button's. Scrolling does nothing, and since older ncurses,
       # like macOS's, has no button for scrolling down, it can't be mistaken for a click.
       CLICKS = Curses::BUTTON1_PRESSED | Curses::BUTTON1_CLICKED
 
-      # A click sends the event of what's under it.
+      # Letting go of the button, which older ncurses, like macOS's, also reports for each move while it's held, as it
+      # doesn't know the moves terminals send then.
+      RELEASE = Curses::BUTTON1_RELEASED
+
+      # Moving the mouse, which terminals report once they're asked to, with any motion tracking.
+      MOTION = Curses::REPORT_MOUSE_POSITION
+      ANY_MOTION = "\e[?1003h"
+      NO_MOTION = "\e[?1003l"
+
+      # The terminal sends the app its mouse events, clicks and moves, so scrolling doesn't scroll the terminal either.
+      # ncurses only asks some terminals to report every move, so it's asked directly too, until untrack_mouse.
+      def track_mouse
+        Curses.mousemask(CLICKS | RELEASE | MOTION)
+        Curses.mouseinterval(0)
+        $stdout.write(ANY_MOTION)
+        $stdout.flush
+      end
+
+      def untrack_mouse
+        $stdout.write(NO_MOTION)
+        $stdout.flush
+      end
+
+      # A click sends the event of what's under it, and moving the mouse a Hover of it, or a Drag by how far it's moved
+      # since the last event while the button's held. Terminals and ncurses versions report that in their own ways: a
+      # move the button's held for, a move after a press, until the release, or with older ncurses and some terminals,
+      # a release somewhere else than the last event, for each move. A release where the mouse already is, which ends a
+      # click or a drag, does nothing.
       def mouse_event(event, zones)
-        click(zones, column: event.x, row: event.y) if event.bstate.anybits?(CLICKS)
+        from = @last
+        @last = [event.x, event.y]
+        held = hold(event.bstate)
+        return drag(from, event) if from && dragged?(event, held:, moved: from != @last)
+        return if event.bstate.anybits?(RELEASE)
+
+        target = click(zones, column: event.x, row: event.y)
+        return target if event.bstate.anybits?(CLICKS)
+
+        Hover.new(target:) if event.bstate.anybits?(MOTION)
+      end
+
+      # Whether the button was held before this event, which holds it from a press until a release.
+      def hold(bstate)
+        held = @held
+        @held = bstate.anybits?(CLICKS) || (held && !bstate.anybits?(RELEASE))
+        held
+      end
+
+      def drag(from, event) = Drag.new(columns: event.x - from[0], rows: event.y - from[1])
+
+      def dragged?(event, held:, moved:)
+        bstate = event.bstate
+        return held || bstate.anybits?(Curses::BUTTON1_PRESSED) if bstate.anybits?(MOTION)
+
+        moved && bstate.anybits?(RELEASE)
       end
 
       # Where each of a Layout's segments with an event is on the screen, as [row, columns, event].
@@ -38,7 +126,7 @@ module Raindown
         lines.each_with_index.flat_map do |segments, row|
           column = 0
           segments.filter_map do |segment|
-            width = Unicode::DisplayWidth.of(segment.text)
+            width = Text.display_width(segment.text)
             zone = [row, column...(column + width), segment.event] if segment.event
             column += width
             zone

data/lib/raindown/tui/terminal/screen.rb

@@ -4,17 +4,22 @@ require 'curses'
 
 require_relative 'input'
 require_relative '../layout'
-require_relative 'quiet'
 require_relative 'ncurses_shim'
+require_relative 'quiet'
 require_relative 'styles'
+require_relative 'terminal_title'
 
 module Raindown
   module TUI
     # Paints a Navigator's Layout with curses, and sends the Navigator the events of keys and clicks, read with Input.
     # Only this class draws on the terminal, so another library could draw the same Layout.
     class Screen
-      # How often, in milliseconds, the open file is checked for changes while no key is pressed.
-      TICK = 500
+      prepend TerminalTitle
+
+      # How often, in milliseconds, the screen's drawn, and the open file checked for changes, while no key is pressed, by
+      # the view's pace, from when the last frame started drawing: every half second while it's active, at 12 frames a
+      # second while it's reactive, just faster than Code feelings' digits tremble, and at 20 during an animation.
+      TICKS = { active: 500, reactive: 83, animation: 50 }.freeze
 
       def initialize(navigator)
         @navigator = navigator
@@ -31,11 +36,9 @@ module Raindown
         start
 
         loop do
+          drawn_at = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
           draw
-          effect = @navigator.next_step(read)
-          break if effect == :quit
-
-          perform(effect)
+          break if take_events(drawn_at) == :quit
         end
       rescue Interrupt
         nil
@@ -43,6 +46,23 @@ module Raindown
         stop
       end
 
+      # The Navigator takes the next event, then any others already waiting, like the mouse's many moves, before the
+      # screen's drawn again, so drawing doesn't fall further and further behind them.
+      def take_events(drawn_at)
+        event = Input.read(wait(drawn_at), zones: @zones, typing: @navigator.typing?)
+        loop do
+          effect = @navigator.next_step(event)
+          return effect if effect == :quit
+
+          perform(effect)
+          event = Input.read(0, zones: @zones, typing: @navigator.typing?)
+          return if event == :tick
+        end
+      end
+
+      # The milliseconds left of the pace's tick since the frame started drawing, so drawing doesn't slow the pace.
+      def wait(drawn_at) = [TICKS.fetch(@navigator.pace) + drawn_at - Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond), 0].max
+
       # Runs a command, like the editor, then tells the Navigator, or shows a message while a slow task runs.
       def perform(effect)
         case effect
@@ -61,13 +81,11 @@ module Raindown
         Curses.nonl
         Curses.curs_set(0)
         Curses.stdscr.keypad(true)
-        Curses.stdscr.timeout = TICK
-        # The terminal sends the app its mouse events, so scrolling doesn't scroll the terminal either.
-        Curses.mousemask(Input::CLICKS)
-        Curses.mouseinterval(0)
+        Input.track_mouse
       end
 
       def stop
+        Input.untrack_mouse
         Curses.close_screen
       end
 
@@ -98,7 +116,7 @@ module Raindown
       end
 
       def paint(window, segment)
-        window.attron(@styles.fetch(segment.style, Curses::A_NORMAL)) { window.addstr(segment.text) }
+        window.attron(@styles[segment.style]) { window.addstr(segment.text) }
       end
 
       def last_line(segments)
@@ -106,22 +124,6 @@ module Raindown
         [*rest, last.with(text: last.text[0...-1])]
       end
 
-      # The next event, or :tick when no key is pressed in time, or nil for keys without one, like a resize.
-      def read
-        key = Curses.stdscr.getch
-        return :tick if key.nil?
-        return mouse if key == Curses::KEY_MOUSE
-
-        Curses.stdscr.clear if key == Curses::KEY_RESIZE
-        Input.key_event(key)
-      end
-
-      # The curses gem warns the first time it makes a MouseEvent, that it's "undefining the allocator" of the class.
-      def mouse
-        event = Quiet.quietly { Curses.getmouse }
-        Input.mouse_event(event, @zones) if event
-      end
-
       # Shows a message in the status line while something slow runs, like an endpoint's request.
       def show(message)
         window = Curses.stdscr
@@ -131,13 +133,19 @@ module Raindown
         window.refresh
       end
 
-      # Leaves the screen to the command, like the editor, and comes back to it after.
+      # Leaves the screen to the command, like the editor, and comes back to it after. The command isn't sent the
+      # mouse's moves meanwhile. Ctrl+C, like to leave Claude Code, goes to the TUI too, which waits for the command
+      # rather than quitting, while the command gets Ctrl+C as usual.
       def suspend
+        interrupt = trap('INT') { nil }
         Curses.def_prog_mode
+        Input.untrack_mouse
         Curses.close_screen
         yield
       ensure
+        trap('INT', interrupt)
         Curses.reset_prog_mode
+        Input.track_mouse
         Curses.stdscr.clear
         Curses.refresh
       end

data/lib/raindown/tui/terminal/styles.rb

@@ -4,25 +4,68 @@ require 'curses'
 
 module Raindown
   module TUI
-    # The curses attributes of a Layout's styles. The title is white on blue, and the selected row white on a lighter
-    # blue, or on dark grey in the panes without the focus, while other colours are on the terminal's own background.
+    # The curses attributes of a Layout's styles. Text is periwinkle where there are 256 colours, and the terminal's own
+    # colour otherwise, while the title, headings, and the lines between the panes and beneath the title are cornflower
+    # blue. The selected
+    # row is white on blue, or on dark grey in the panes without the focus, while other colours are on the terminal's own
+    # background.
     # With only 8 colours, there's no dark grey, so those rows are underlined, and without colours,
     # the rest are in reverse.
     module Styles
-      COLORS = { directive: Curses::COLOR_CYAN, button: Curses::COLOR_YELLOW, error: Curses::COLOR_RED,
-                 folder: Curses::COLOR_BLUE }.freeze
+      COLORS = { button: Curses::COLOR_YELLOW, error: Curses::COLOR_RED }.freeze
+      # Directives, like charts' on the Dashboard, in purple, and the folders, projects and pages in the files, the title,
+      # and headings, like the outline's and the Dashboard cards', in cornflower blue, and the waffle's syrup in brown,
+      # from the 256 colours most terminals
+      # have, or magenta and blue with 8.
+      CORNFLOWER = 111
+      ACCENTS = { directive: 141, folder: CORNFLOWER, title: CORNFLOWER, heading: CORNFLOWER, syrup: 130 }.freeze
+      BASIC_ACCENTS = { directive: Curses::COLOR_MAGENTA, folder: Curses::COLOR_BLUE, title: Curses::COLOR_BLUE,
+                        heading: Curses::COLOR_BLUE, syrup: Curses::COLOR_YELLOW }.freeze
+
+      # The green of GET, and of a selected method in Code feelings that's already been felt.
+      GREEN = 34
+
       # The colours of endpoints' HTTP methods, like GET in green, from the 256 colours most terminals have,
       # which are the same in every theme, unlike the 8 they all do, where green can look yellow.
-      METHODS = { get: 40, post: 33, delete: 196, put: 220, patch: 171, head: 44, options: 44 }.freeze
+      METHODS = { get: GREEN, post: 33, delete: 196, put: 220, patch: 171, head: 44, options: 44 }.freeze
       BASIC_METHODS = { get: Curses::COLOR_GREEN, post: Curses::COLOR_BLUE, delete: Curses::COLOR_RED,
                         put: Curses::COLOR_YELLOW, patch: Curses::COLOR_MAGENTA, head: Curses::COLOR_CYAN,
                         options: Curses::COLOR_CYAN }.freeze
-      # The title's and the selected row's blues, from the 256 colours most terminals have, or the 8 they all do.
-      BLUES = { title: 25, selected: 33 }.freeze
-      BASIC_BLUES = { title: Curses::COLOR_BLUE, selected: Curses::COLOR_CYAN }.freeze
+
+      # Highlighted code's colours, by the kind of token, from the 256 colours most terminals have, or the 8 they all do,
+      # where comments are dim instead of grey.
+      CODE = { code_keyword: 204, code_string: 114, code_number: 179, code_function: 75, code_constant: 117,
+               code_comment: 244 }.freeze
+      BASIC_CODE = { code_keyword: Curses::COLOR_MAGENTA, code_string: Curses::COLOR_GREEN, code_number: Curses::COLOR_YELLOW,
+                     code_function: Curses::COLOR_BLUE, code_constant: Curses::COLOR_CYAN, code_comment: Curses::COLOR_WHITE }.freeze
+
+      # Code feelings' bright colours, for its rain and fireworks, from the 256 colours most terminals have, or
+      # the 8 they all do.
+      BRIGHT = { bright_red: 203, bright_orange: 215, bright_yellow: 227, bright_green: 120, bright_cyan: 87,
+                 bright_blue: 75, bright_purple: 177, bright_pink: 213 }.freeze
+      BASIC_BRIGHT = { bright_red: Curses::COLOR_RED, bright_orange: Curses::COLOR_YELLOW, bright_yellow: Curses::COLOR_YELLOW,
+                       bright_green: Curses::COLOR_GREEN, bright_cyan: Curses::COLOR_CYAN, bright_blue: Curses::COLOR_BLUE,
+                       bright_purple: Curses::COLOR_MAGENTA, bright_pink: Curses::COLOR_MAGENTA }.freeze
+
+      # The selected row's blue, the green of a selected method in Code feelings that's already been felt, and the
+      # cornflower blue of the lines between the panes and beneath the title, from the 256 colours most terminals have,
+      # or the 8 they all do.
+      BLUES = { selected: 33, felt: GREEN, line: CORNFLOWER }.freeze
+      BASIC_BLUES = { selected: Curses::COLOR_CYAN, felt: Curses::COLOR_GREEN, line: Curses::COLOR_BLUE }.freeze
+
+      # Text that has no colour of its own, from the 256 colours most terminals have, or the terminal's own with 8.
+      PERIWINKLE = 147
+
+      # Code feelings' text and lines, in lavender, or magenta in 8 colours, and the purple its magnified digits take turns
+      # with, or blue.
+      FEELINGS = { feelings: 183, feelings_purple: 135 }.freeze
+      BASIC_FEELINGS = { feelings: Curses::COLOR_MAGENTA, feelings_purple: Curses::COLOR_BLUE }.freeze
       BRIGHT_WHITE = 15
       DARK_GREY = 238
 
+      # Code feelings' red when the screen's too small for it, or the 8 colours' red.
+      DARK_RED = 88
+
       module_function
 
       # Sets up the colours, once the screen has started, and returns the attribute of each style.
@@ -33,33 +76,72 @@ module Raindown
         colored
       end
 
+      # Without colours, a style that isn't here is the terminal's own.
       def plain
-        { title: Curses::A_REVERSE | Curses::A_BOLD, selected: Curses::A_REVERSE, selected_button: Curses::A_REVERSE,
+        Hash.new(Curses::A_NORMAL).merge(
+          title: Curses::A_REVERSE | Curses::A_BOLD, selected: Curses::A_REVERSE, too_small: Curses::A_REVERSE,
+          feelings_selected: Curses::A_REVERSE | Curses::A_BOLD, felt_selected: Curses::A_REVERSE | Curses::A_BOLD,
+          selected_button: Curses::A_REVERSE,
           cursor: Curses::A_UNDERLINE, cursor_button: Curses::A_UNDERLINE | Curses::A_BOLD, heading: Curses::A_BOLD,
-          body: Curses::A_DIM, error: Curses::A_BOLD, button: Curses::A_BOLD, folder: Curses::A_BOLD, project: Curses::A_BOLD, dashboard: Curses::A_BOLD,
-          key: Curses::A_REVERSE, border: Curses::A_DIM, run: Curses::A_REVERSE | Curses::A_BOLD, divider: Curses::A_BOLD,
-          selected_divider: Curses::A_REVERSE, cursor_divider: Curses::A_BOLD }
+          body: Curses::A_DIM, error: Curses::A_BOLD, button: Curses::A_BOLD, folder: Curses::A_BOLD, project: Curses::A_BOLD, page: Curses::A_BOLD,
+          key: Curses::A_REVERSE, border: Curses::A_DIM, divider: Curses::A_BOLD,
+          code_keyword: Curses::A_BOLD, code_comment: Curses::A_DIM
+        )
       end
 
       def colored
-        plain.merge(
-          title: pair(:title) | Curses::A_BOLD, selected: pair(:selected) | white_bold,
-          selected_button: pair(:selected_button) | Curses::A_BOLD, directive: pair(:directive),
-          error: pair(:error) | Curses::A_BOLD, button: pair(:button) | Curses::A_BOLD, divider: pair(:divider),
-          selected_divider: pair(:selected_divider), run: pair(:run) | Curses::A_BOLD, **files, **unfocused
+        in_text_color.merge(
+          title: pair(:title) | Curses::A_BOLD, directive: pair(:directive), error: pair(:error) | Curses::A_BOLD,
+          button: pair(:button) | Curses::A_BOLD, **selections, **emphasis, **dividers, **code_tokens, **bright, **files,
+          **unfocused
         )
       end
 
+      # The selected row, its buttons, Code feelings' selected method, bold, on green when it's already been felt, and its
+      # red when the screen's too small for it.
+      def selections
+        { selected: pair(:selected) | white_bold, feelings_selected: pair(:selected) | Curses::A_BOLD,
+          felt_selected: pair(:felt_selected) | Curses::A_BOLD,
+          too_small: pair(:too_small) | white_bold, selected_button: pair(:selected_button) | Curses::A_BOLD }
+      end
+
+      # The styles without a colour of their own, or that are only bold, dim or the like, in the text's colour, which is
+      # also any style that isn't here.
+      def in_text_color
+        text = pair(:text)
+        Hash.new(text).merge(plain.transform_values { it | text })
+      end
+
+      # Headings, the waffle's butter's shine and its syrup, and Code feelings' text and lines, bold around the method the
+      # mouse is over, and its purple.
+      def emphasis
+        { heading: pair(:heading) | Curses::A_BOLD, feelings: pair(:feelings), nearby: pair(:feelings) | Curses::A_BOLD,
+          feelings_purple: pair(:feelings_purple), shine: pair(:shine) | Curses::A_BOLD, syrup: pair(:syrup) }
+      end
+
+      # Highlighted code's tokens, like keywords and comments, with comments dim in 8 colours, where there's no grey.
+      def code_tokens
+        tokens = CODE.keys.to_h { [it, pair(it)] }
+        tokens[:code_comment] |= Curses::A_DIM if Curses.colors < 256
+        tokens
+      end
+
+      # The bright colours, bold, so they're bright in 8 colours too.
+      def bright = BRIGHT.keys.to_h { [it, pair(it) | Curses::A_BOLD] }
+
+      # The lines between the panes and beneath the title.
+      def dividers = { divider: pair(:divider) }
+
       def files
-        { folder: pair(:folder) | Curses::A_BOLD, project: pair(:directive) | Curses::A_BOLD,
-          dashboard: pair(:directive) | Curses::A_BOLD, **METHODS.keys.to_h { [:"method_#{it}", pair(:"method_#{it}") | Curses::A_BOLD] } }
+        { folder: pair(:folder) | Curses::A_BOLD, project: pair(:folder) | Curses::A_BOLD,
+          page: pair(:folder) | Curses::A_BOLD, **METHODS.keys.to_h { [:"method_#{it}", pair(:"method_#{it}") | Curses::A_BOLD] } }
       end
 
       # The selected rows of the panes without the focus, on dark grey where there's one.
       def unfocused
-        return { cursor_button: pair(:button) | Curses::A_BOLD, cursor_divider: pair(:divider) } unless Curses.colors >= 256
+        return { cursor_button: pair(:button) | Curses::A_BOLD } unless Curses.colors >= 256
 
-        { cursor: pair(:cursor), cursor_button: pair(:cursor_button) | Curses::A_BOLD, cursor_divider: pair(:cursor_divider) }
+        { cursor: pair(:cursor), cursor_button: pair(:cursor_button) | Curses::A_BOLD }
       end
 
       # Each colour pair as [name, foreground, background], where -1 is the terminal's own background.
@@ -67,14 +149,17 @@ module Raindown
         many = Curses.colors >= 256
         blues = many ? BLUES : BASIC_BLUES
         white = many ? BRIGHT_WHITE : Curses::COLOR_WHITE
+        text = many ? PERIWINKLE : -1
 
         [*COLORS.map { |name, color| [name, color, -1] },
          *(many ? METHODS : BASIC_METHODS).map { |name, color| [:"method_#{name}", color, -1] },
-         [:title, white, blues[:title]],
-         [:selected, white, blues[:selected]], [:selected_button, Curses::COLOR_YELLOW, blues[:selected]],
-         [:cursor, white, DARK_GREY], [:cursor_button, Curses::COLOR_YELLOW, DARK_GREY], [:divider, blues[:title], -1],
-         [:selected_divider, blues[:title], blues[:selected]], [:cursor_divider, blues[:title], DARK_GREY],
-         [:run, white, Curses::COLOR_GREEN]]
+         *(many ? CODE.merge(BRIGHT, FEELINGS, ACCENTS) : BASIC_CODE.merge(BASIC_BRIGHT, BASIC_FEELINGS, BASIC_ACCENTS))
+           .map { |name, color| [name, color, -1] },
+         [:text, text, -1],
+         [:selected, white, blues[:selected]], [:felt_selected, white, blues[:felt]], [:too_small, white, many ? DARK_RED : Curses::COLOR_RED],
+         [:selected_button, Curses::COLOR_YELLOW, blues[:selected]],
+         [:cursor, white, DARK_GREY], [:cursor_button, Curses::COLOR_YELLOW, DARK_GREY], [:divider, blues[:line], -1],
+         [:shine, white, -1]]
       end
 
       def pair(name)

data/lib/raindown/tui/terminal/terminal_title.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Raindown
+  module TUI
+    # The terminal's title while the Screen's open, which it's prepended to: blank, rather than the command's name,
+    # saving the title it had, then putting it back, which terminals that can't ignore. It's a space, as terminals like
+    # Ghostty take an empty title to mean their own.
+    module TerminalTitle
+      BLANK_TITLE = "\e]2; \a"
+      SAVE_TITLE = "\e[22;2t"
+      RESTORE_TITLE = "\e[23;2t"
+
+      private
+
+      def start
+        super
+        terminal("#{SAVE_TITLE}#{BLANK_TITLE}")
+      end
+
+      def stop
+        terminal(RESTORE_TITLE)
+        super
+      end
+
+      def terminal(sequence)
+        $stdout.write(sequence)
+        $stdout.flush
+      end
+    end
+  end
+end