raindown 0.6.0 → 0.8.0

data/lib/raindown/tui/navigator/mouse.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Raindown
+  module TUI
+    # What a Navigator does with the mouse: a click where it's clicked, the mouse moving over something, which it keeps
+    # as what's hovered, and dragging with the button held, which the view takes, like a blueprint's canvas, if it can.
+    module Mouse
+      # What the mouse is over, which a click there would send, like a Click on a method's cells, or nil.
+      attr_reader :hovered
+
+      private
+
+      # A click moves the cursor where it's clicked, and does the click's action there, like a key, unless that would
+      # leave the terminal UI, like for the editor, so a stray click only moves the cursor.
+      # While the project menu or Teleport is open, only its items are clicked.
+      def click(click)
+        return if menu && click.pane != :menu
+        return if teleporting? && click.pane != :teleport
+
+        point(click)
+        effect = route(click.action)
+        effect unless effect.is_a?(Run)
+      end
+
+      def point(click)
+        return @menu = click.index if click.pane == :menu
+        return @match = click.index if click.pane == :teleport
+
+        content(click.pane).cursor = click.index
+        @focus = click.pane
+      end
+
+      def hover(hover)
+        @hovered = hover.target
+        nil
+      end
+
+      def drag(drag)
+        view.drag(drag) if view.respond_to?(:drag)
+      end
+    end
+  end
+end

data/lib/raindown/tui/navigator/navigator.rb

@@ -4,12 +4,14 @@ require_relative '../file_tree'
 require_relative 'commands'
 require_relative '../endpoints'
 require_relative 'focus'
+require_relative 'mouse'
 require_relative '../events'
 require_relative '../views/outline_view'
 require_relative '../views/list_view'
 require_relative 'project_menu'
+require_relative 'teleport'
 require_relative 'views'
-require_relative '../workers/workers'
+require_relative '../project'
 
 module Raindown
   module TUI
@@ -20,20 +22,31 @@ module Raindown
       include Commands
       include Views
       include ProjectMenu
+      include Teleport
       include Focus
+      include Mouse
 
       # Keys of the events that move the cursor or the focus, and those that act on what's selected.
       MOVES = { up: -1, down: 1 }.freeze
       PANES = { tab: nil, left: :nav, right: :main }.freeze
       ACTIONS = { execute: :execute, edit: :edit, write_back: :write_back, reload: :reload, tick: :refresh }.freeze
+      # Keys that open Teleport, the project menu, the Dashboard, Code feelings or Blueprints, from anywhere.
+      OPENERS = { search: -> { open_teleport }, projects: -> { toggle_menu }, dashboard: -> { toggle_dashboard },
+                  feelings: -> { open_view(feelings) }, blueprints: -> { open_view(blueprints) } }.freeze
 
       attr_reader :focus, :status
 
-      def initialize(root:, path: nil, workers: Workers.new(root:))
+      # Saves tells of the files saved in the folder, which are written back on the next tick, like when it's watched,
+      # running endpoints with no response as they are when it runs_endpoints, like with -x.
+      def initialize(root:, path: nil, workers: Project.workers(root:), saves: nil, runs_endpoints: false)
         @workers = workers
+        @saves = saves
+        @runs_endpoints = runs_endpoints
         @files = FileTree.new(root:, workers:)
         @endpoints = Endpoints.new(workers:)
         @dashboard = DashboardView.new(root:, workers:)
+        @feelings = FeelingsView.new(root:)
+        @blueprints = BlueprintsView.new(root:)
         @nav = ListView.new { nav_rows }
         first = Projects.files(root, nested: true).first
         # The dashboard is the first page, unless a file is asked for, and "d" goes from it to the first file.
@@ -46,13 +59,18 @@ module Raindown
         case event
         when nil then nil
         when Click then click(event)
+        when Type then type(event)
+        when Hover then hover(event)
+        when Drag then drag(event)
         else route(event)
         end
       end
 
-      # After the editor closes, the file is written back, like a save while it's watched, and read again.
+      # After the editor closes, a Markdown file is written back, like a save while it's watched, and read again.
+      # Other files, like code that was felt, aren't written back, and the view reads them again.
       def ran
-        write_back(@edited)
+        write_back(@edited) if @files.files.include?(@edited)
+        view.load
         @endpoints.load
       end
 
@@ -62,37 +80,39 @@ module Raindown
       # The folder the files are shown from: the chosen project's, or the root's.
       def base = @files.base
 
+      # While Teleport, or the view, like a feeling's note, takes what's typed, rather than keys' events.
+      def typing? = teleporting? || view.typing?
+
+      # How often the screen's drawn, which is up to the view, like faster for Code feelings' rain.
+      def pace = view.pace(hovered)
+
       # What's in a pane: the nav's ListView on the left, or the view on the right, which keeps its own cursor.
       def content(pane) = pane == :nav ? @nav : view
 
       private
 
+      # A typed character goes to Teleport, or to the view while it's typing.
+      def type(event)
+        return type_query(query + event.text) if teleporting?
+
+        view.next_step(event)&.take(self) if view.typing?
+      end
+
       def route(name)
         return :quit if name == :quit
+        return teleport_event(name) if teleporting?
         return menu_event(name) if menu
-        return toggle_menu if name == :projects
-        return toggle_dashboard if name == :dashboard
+        return instance_exec(&OPENERS[name]) if opener?(name)
         return view.next_step(name)&.take(self) if @focus == :main && view.next_step?(name)
 
         browser_event(name)
       end
 
-      # A click moves the cursor where it's clicked, and does the click's action there, like a key, unless that would
-      # leave the terminal UI, like for the editor, so a stray click only moves the cursor.
-      # While the project menu's open, only its projects are clicked.
-      def click(click)
-        return if menu && click.pane != :menu
+      # Whether the key opens something from anywhere, unless the view's focused and keeps the key, like f in Blueprints.
+      def opener?(name)
+        return false if @focus == :main && view.respond_to?(:own_key?) && view.own_key?(name)
 
-        point(click)
-        effect = route(click.action)
-        effect unless effect.is_a?(Run)
-      end
-
-      def point(click)
-        return @menu = click.index if click.pane == :menu
-
-        content(click.pane).cursor = click.index
-        @focus = click.pane
+        OPENERS.key?(name)
       end
 
       def browser_event(name)
@@ -103,11 +123,20 @@ module Raindown
         send(ACTIONS[name]) if ACTIONS.key?(name)
       end
 
-      # The Dashboard, which every terminal draws two columns wide, then the files and the endpoints,
-      # with a blank line between each section that has rows.
+      # The Dashboard, Code feelings and Blueprints, then the files and the endpoints, with a blank line between each section that
+      # has rows.
       def nav_rows
-        dashboard_row = Row.new(text: '📊 Dashboard', depth: 0, kind: :dashboard, target: dashboard, open: OpenView.new(view: dashboard))
-        [[dashboard_row], @files.rows, @endpoints.rows].reject(&:empty?).flat_map { [Row::SEPARATOR, *it] }.drop(1)
+        rows = pages.map { |text, view| Row.new(text:, depth: 0, kind: :page, target: view, open: OpenView.new(view:)) }
+        [rows, @files.rows, @endpoints.rows].reject(&:empty?).flat_map { [Row::SEPARATOR, *it] }.drop(1)
+      end
+
+      # The pages above the files, by how they're shown, in the files and Teleport, with emoji every terminal draws two
+      # columns wide. Blueprints is listed once the project has some, from Claude Code or its code's comments.
+      def pages
+        pages = { '📊 Dashboard' => dashboard, '🎭 Feelings' => feelings }
+        return pages unless blueprints.any?
+
+        pages.merge('🌀 Blueprints' => blueprints)
       end
 
       def selected

data/lib/raindown/tui/navigator/teleport.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative '../events'
+require_relative '../views/endpoint_view'
+require_relative '../../workers/worker'
+
+module Raindown
+  module TUI
+    # Teleport: "/" opens a search of the Dashboard, Code feelings, every file, heading and directive in the files, and every endpoint,
+    # matched as it's typed by letters in order, so "stp" finds "## Setup". Up and down move between the matches,
+    # Enter or a click opens the one selected, and Esc closes it. Other keys and clicks do nothing while it's open.
+    module Teleport
+      # The most matches it shows.
+      LIMIT = 10
+
+      # A place to teleport to: its text, where it is, like "guides/setup.md:12", and the step that opens it.
+      Place = Data.define(:text, :where, :open) do
+        # How well the query matches, or nil when it doesn't: in the text alone, which ranks above a match that needs
+        # where it is too, like "setup notes" for "## Setup" in notes.md.
+        def score(query)
+          in_text = letters_score(text, query)
+          return in_text + query.length if in_text
+
+          letters_score("#{text} #{where}", query)
+        end
+
+        private
+
+        # How well the query's letters appear in order in the text, ignoring case: higher for runs of them and for
+        # the starts of words, or nil when they don't all appear.
+        def letters_score(text, query)
+          haystack = text.downcase
+          last = -1
+          score = 0
+          query.downcase.each_char do |char|
+            index = haystack.index(char, last + 1)
+            return nil unless index
+
+            score += 1
+            score += 2 if index == last + 1
+            score += 2 if index.zero? || haystack[index - 1].match?(%r{[\s/#:._-]})
+            last = index
+          end
+          score
+        end
+      end
+
+      # What's typed, while Teleport is open, and the selected match.
+      attr_reader :query, :match
+
+      def teleporting? = !query.nil?
+
+      # The first match the box lists, as it lists them all.
+      def first_match = 0
+
+      # The places that match what's typed, best first, then in the order they're in the files.
+      def matches
+        @places.each_with_index.filter_map { |place, index| (score = place.score(query)) && [-score, index, place] }
+               .min(LIMIT).map(&:last)
+      end
+
+      private
+
+      def open_teleport
+        @places = places
+        @match = 0
+        @query = ''
+        nil
+      end
+
+      def teleport_event(name)
+        case name
+        when :up, :down then move_match(name == :up ? -1 : 1)
+        when :enter then teleport
+        when :escape then close_teleport
+        when :backspace then type_query(query[0...-1])
+        end
+      end
+
+      def type_query(query)
+        @query = query
+        @match = 0
+        nil
+      end
+
+      def move_match(by)
+        @match = (@match + by).clamp(0, [matches.length - 1, 0].max)
+        nil
+      end
+
+      def teleport
+        place = matches[@match]
+        close_teleport
+        place&.open&.take(self)
+      end
+
+      def close_teleport
+        @query = nil
+        nil
+      end
+
+      def places
+        [*pages.map { |text, view| Place.new(text:, where: '', open: OpenView.new(view:)) },
+         *@files.files.flat_map { file_places(it) },
+         *@endpoints.all.map { Place.new(text: it.text, where: "#{relative(it.path)}:#{it.line}", open: open_endpoint(it)) }]
+      end
+
+      # The file, then its headings and directives, in the order they're in it.
+      def file_places(path)
+        outline = @workers.for(path).call(:outline, path)
+        where = relative(path)
+        items = (outline.headings + outline.directives).sort_by(&:line)
+        [Place.new(text: where, where: '', open: Open.new(path:, line: nil)),
+         *items.map { Place.new(text: item_text(it), where: "#{where}:#{it.line}", open: Open.new(path:, line: it.line)) }]
+      rescue Workers::Worker::Error
+        []
+      end
+
+      def item_text(item)
+        return "#{'#' * item.level} #{item.text}" if item.is_a?(Document::Heading)
+
+        "#{item.name}: #{item.args}".strip
+      end
+
+      def open_endpoint(endpoint) = OpenView.new(view: EndpointView.new(endpoint, workers: @workers))
+    end
+  end
+end

data/lib/raindown/tui/navigator/views.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require_relative '../views/dashboard_view'
+require_relative '../blueprints/blueprints_view'
 require_relative '../views/endpoint_view'
+require_relative '../feelings/feelings_view'
 require_relative '../views/outline_view'
 
 module Raindown
@@ -11,7 +13,7 @@ module Raindown
     # A view has the pane that draws it, a next step for the keys it takes while it has the focus, and a target,
     # what's opened it in the files. It loads when it's opened, and again after a change.
     module Views
-      attr_reader :view, :dashboard
+      attr_reader :view, :dashboard, :feelings, :blueprints
 
       # The path of the file the view shows, if any.
       def path = view.path
@@ -27,12 +29,12 @@ module Raindown
         nil
       end
 
-      # Opens the file in the outline, on the directive at the line.
+      # Opens the file in the outline, on the heading or directive at the line.
       def open_at(path, line)
         path = File.expand_path(path)
         @files.reveal(path)
         open_view(OutlineView.new(path, workers: @workers))
-        view.cursor = view.rows.index { it.kind == :directive && it.target.line == line } || 0
+        view.cursor = view.rows.index { %i[heading directive].include?(it.kind) && it.target.line == line } || 0
         nil
       end
 

data/lib/raindown/tui/{workers/project.rb → project.rb}

@@ -1,18 +1,20 @@
 # frozen_string_literal: true
 
-require_relative '../../actions'
-require_relative '../../bare_directives'
-require_relative '../../chart/chart'
-require_relative '../../document'
-require_relative '../../front_matter'
-require_relative '../../node_blocks'
-require_relative '../../nodes'
-require_relative '../../pages'
-require_relative '../../projects'
-require_relative '../card'
-require_relative '../endpoint'
-require_relative '../../code_blocks'
-require_relative '../../endpoint/curl'
+require_relative '../actions'
+require_relative '../bare_directives'
+require_relative '../chart/chart'
+require_relative '../document'
+require_relative '../front_matter'
+require_relative '../node_blocks'
+require_relative '../nodes'
+require_relative '../pages'
+require_relative '../projects'
+require_relative '../workers/workers'
+require_relative '../stat'
+require_relative 'card'
+require_relative 'endpoint'
+require_relative '../code_blocks'
+require_relative '../endpoint/curl'
 
 module Raindown
   module TUI
@@ -23,9 +25,17 @@ module Raindown
 
       attr_reader :root
 
+      # Workers for the projects in the folder, each answering as a Project, which allows bare directives in any file,
+      # and runs endpoints with no response as it writes back, when asked, like with --bare and -x.
+      def self.workers(root:, bare: false, execute: false, **)
+        Workers.new(root:, **) { new(root: it, bare:, execute:) }
+      end
+
       # The projects inside this one have workers of their own, so their files are left out.
-      def initialize(root:)
+      def initialize(root:, bare: false, execute: false)
         @root = root
+        @bare = bare
+        @execute = execute
         @load_errors = []
         @file_errors = []
         Nodes.load(File.join(root, Nodes::FOLDER))
@@ -35,11 +45,12 @@ module Raindown
 
       # A file's lines, headings and directives.
       def outline(path)
-        document = Document.read(path)
+        document = Document.read(path, bare: @bare)
         Outline.new(lines: File.readlines(path, chomp: true), headings: document.headings, directives: document.directives)
       end
 
-      # Every chart in the project's files, drawn from its data, and the files that couldn't be read.
+      # Every chart and stat in the project's files, or any node that draws a card, drawn from its data, and the files
+      # that couldn't be read.
       # The charts are found again when asked, and otherwise drawn again, so they follow changes to their data.
       def charts(find: false)
         if find || @charts.nil?
@@ -50,23 +61,25 @@ module Raindown
         { cards: drawn, errors: @load_errors + @file_errors }
       end
 
-      # Every endpoint in the project's files, by its request, leaving out the ones whose snippet can't be read.
+      # Every endpoint in the project's files that writes its response back, so it can run, by its request, leaving out
+      # the ones whose snippet can't be read.
       def endpoints
         Projects.files(root).flat_map do |path|
           lines = File.readlines(path, encoding: Encoding::UTF_8)
-          Document.read(path).directives.select(&:endpoint?).filter_map { |directive| endpoint(path, lines, directive) }
+          runnable = Document.read(path, bare: @bare).directives.select { it.endpoint? && it.writes }
+          runnable.filter_map { |directive| endpoint(path, lines, directive) }
         rescue StandardError
           []
         end
       end
 
       def write_back(path)
-        Actions.write_back(path)
+        Actions.write_back(path, bare: @bare, execute: @execute)
       end
 
       # Runs the endpoint on the line, replacing its response.
       def execute(path, line)
-        directive = Document.read(path).directives.find { it.line == line && it.endpoint? }
+        directive = Document.read(path, bare: @bare).directives.find { it.line == line && it.endpoint? }
         raise Actions::NotAnEndpoint, "There's no endpoint on line #{line}" unless directive
 
         Actions.execute(path, directive)
@@ -82,12 +95,12 @@ module Raindown
 
       def charts_in(path)
         content = File.read(path, encoding: Encoding::UTF_8)
-        bare = BareDirectives.enabled?(path:, content:)
+        bare = @bare || BareDirectives.enabled?(path:, content:)
         lines = content.lines
         headings = Document.parse(content, bare:).headings
 
         NodeBlocks.find(lines, front_matter: FrontMatter.parse(content).first, bare:)
-                  .select { |block| block[:node].is_a?(Raindown::Chart) }
+                  .select { it[:node].respond_to?(:card_lines) }
                   .map { |block| chart(block, path:, lines:, headings:) }
       rescue StandardError => e
         @file_errors << "#{path.delete_prefix(File.join(root, ''))}: #{e.message}"
@@ -104,16 +117,14 @@ module Raindown
 
       def chart(block, path:, lines:, headings:)
         line = block[:open] + 1
-        directive = lines[block[:open]].strip.delete_prefix('<{').delete_suffix('}>').strip
+        directive = Directives.text(lines[block[:open]])
 
         { path:, line:, heading: headings.select { it.line < line }.last&.text, directive:, node: block[:node] }
       end
 
-      # Draws the chart as its Markdown would be written back, with the files its project lists.
+      # Draws the chart or stat as its Markdown would be written back, with the files its project lists.
       def lines(chart, metadata)
-        node = chart[:node]
-        points = node.points(metadata:)
-        points.empty? ? ['No data'] : node.draw(points).map(&:rstrip)
+        chart[:node].card_lines(metadata:)
       rescue StandardError => e
         ["Can't chart: #{e.message}"]
       end

data/lib/raindown/tui/{menu_overlay.rb → project_box.rb}

@@ -5,13 +5,13 @@ require_relative 'text'
 module Raindown
   module TUI
     # The project menu, drawn over the screen's lines in a box below the header's path:
-    #    🌧 Raindown  ~/dev ▾ › Dashboard
+    #    🌧  Raindown  ~/dev ▾ › Dashboard
     #                 ┌──────────────────────┐
     #                 │ All projects       ✓ │
     #                 │ ~/dev/raindown       │
     #                 └──────────────────────┘
     # Each item is clicked to choose it.
-    class MenuOverlay
+    class ProjectBox
       include Text
 
       def initialize(navigator, width:, column:)

data/lib/raindown/tui/renderers/dashboard_renderer.rb

@@ -15,14 +15,14 @@ module Raindown
     #    ╰─────────────────────────────╯  ╰────────────────────────────────╯
     class DashboardRenderer < Renderer
       BUTTONS = [['Tab', 'Pane', :tab], ['Enter', 'Open', :enter], ['e', 'Edit', :edit], ['r', 'Reload', :reload],
-                 ['q', 'Quit', :quit]].freeze
+                 ['/', 'Search', :search], ['q', 'Quit', :quit]].freeze
       PROJECTS_BUTTON = ['p', 'Projects', :projects].freeze
 
       # Room for the project menu's button, when there's more than one project.
       def buttons
-        if navigator.projects? then BUTTONS.dup.insert(3, PROJECTS_BUTTON)
-        else BUTTONS
-        end
+        return BUTTONS unless navigator.projects?
+
+        BUTTONS.dup.insert(3, PROJECTS_BUTTON)
       end
 
       def page = 'Dashboard'

data/lib/raindown/tui/renderers/endpoint_renderer.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative '../highlighter'
 require_relative 'renderer'
 require_relative 'outline_renderer'
 
@@ -8,7 +9,7 @@ module Raindown
     # An endpoint opened from the files, right of them: its URL in a bar with rounded corners, and a button to run it,
     # then its response:
     #    ╭──────────────────────────────────────────╮
-    #    │ GET https://httpbin.org/uuid     [ Run ] │
+    #    │ GET https://httpbin.org/uuid       [Run] │
     #    ╰──────────────────────────────────────────╯
     #
     #    Response · json · fetched 2026-10-26
@@ -16,7 +17,7 @@ module Raindown
     #      "uuid": "48024974-f1b1-431a-a0cf-5cac0099a1a5"
     #    }
     class EndpointRenderer < Renderer
-      RUN = '[ Run ]'
+      RUN = '[Run]'
       RUN_WIDTH = RUN.length
       BUTTONS = OutlineRenderer::BUTTONS.reject { it.last == :write_back }.freeze
 
@@ -35,9 +36,12 @@ module Raindown
       # A click on the response moves the focus to it, to scroll it.
       def focus = Click.new(pane:, index: 0, action: :focus)
 
+      # The response's lines that fit, highlighted in the language of its code block, like json.
       def response(view, lines)
-        texts = view.visible([lines, 0].max)
-        Array.new([lines, 0].max) { [segment(texts[it] ? " #{texts[it]}" : '', :response, width:, event: focus)] }
+        code = Highlighter.lines(view.visible([lines, 0].max), language: view.language)
+        Array.new([lines, 0].max) do |line|
+          [segment(' ', :response, width: 1, event: focus), *code_segments(code[line] || [], width - 1, event: focus)]
+        end
       end
 
       # The bar is a column in from each side of the pane, with the URL and the button inside its border.
@@ -57,7 +61,7 @@ module Raindown
          run_button, segment(' │', :border, width: 2)]
       end
 
-      def run_button = segment(RUN, :run, width: RUN_WIDTH, event: Click.new(pane:, index: 0, action: :execute))
+      def run_button = segment(RUN, :button, width: RUN_WIDTH, event: Click.new(pane:, index: 0, action: :execute))
 
       def edge(left, right, inner)
         padded([margin, segment("#{left}#{'─' * (inner + 2)}#{right}", :border, width: inner + 4)])
@@ -66,11 +70,11 @@ module Raindown
       def margin = segment('', :blank, width: 1)
 
       def about(view)
-        text = if view.error then view.error
-               elsif view.response.empty? then 'No response yet. X runs the request.'
-               else ['Response', view.language, ("fetched #{view.fetched}" if view.fetched)].reject { it.to_s.empty? }.join(' · ')
-               end
-        [segment(" #{text}", view.error ? :error : :heading, width:)]
+        return [segment(" #{view.error}", :error, width:)] if view.error
+        return [segment(' No response yet. X runs the request.', :heading, width:)] if view.response.empty?
+
+        details = ['Response', view.language, ("fetched #{view.fetched}" if view.fetched)].reject { it.to_s.empty? }
+        [segment(" #{details.join(' · ')}", :heading, width:)]
       end
     end
   end

data/lib/raindown/tui/renderers/outline_renderer.rb

@@ -7,14 +7,14 @@ module Raindown
     # The open file's outline, right of the files: a row on each line, with its buttons.
     class OutlineRenderer < ListRenderer
       BUTTONS = [['Tab', 'Pane', :tab], ['Enter', 'Open', :enter], ['x', 'Run', :execute], ['e', 'Edit', :edit],
-                 ['w', 'Write back', :write_back], ['r', 'Reload', :reload], ['q', 'Quit', :quit]].freeze
+                 ['w', 'Write back', :write_back], ['r', 'Reload', :reload], ['/', 'Search', :search], ['q', 'Quit', :quit]].freeze
 
       def buttons = BUTTONS
 
       def page
-        if navigator.path then navigator.relative(navigator.path)
-        else 'No Markdown files'
-        end
+        return 'No Markdown files' unless navigator.path
+
+        navigator.relative(navigator.path)
       end
     end
   end

data/lib/raindown/tui/renderers/renderer.rb

@@ -7,9 +7,13 @@ require_relative '../text'
 module Raindown
   module TUI
     # Draws what's in a pane, :nav or :main, as lines of the pane's width and height, which the Layout puts in it.
+    # Like the Layout, it's made again for each draw, so it draws what the Navigator and its view hold then.
     Renderer = Struct.new(:navigator, :pane, :width, :height) do
       include Rows
       include Text
+
+      # Its side of the line above the panes, which is blank unless it has something to say there, like a progress.
+      def spacer = [segment('', :blank)]
     end
   end
 end

data/lib/raindown/tui/row.rb

@@ -5,8 +5,10 @@ module Raindown
     # A line of a pane. Target is what it's about: a folder or file path, a Heading or Directive, or a line number.
     # Buttons are [label, event] pairs, like ['[Run]', :execute], and a tag is an Endpoint, whose method is before its text.
     # Open is the Navigator's next step on Enter, like an Open of a file, and fold, a block that folds or expands the row.
-    Row = Data.define(:text, :depth, :kind, :target, :buttons, :tag, :open, :fold) do
-      def initialize(buttons: [], tag: nil, open: nil, fold: nil, **) = super
+    # Code is the text highlighted, as [text, style] parts, for a line of code, like a directive's body.
+    # Each optional field has a default, which is why initialize takes so many.
+    Row = Data.define(:text, :depth, :kind, :target, :buttons, :tag, :open, :fold, :code) do
+      def initialize(buttons: [], tag: nil, open: nil, fold: nil, code: nil, **) = super # rubocop:disable Metrics/ParameterLists
 
       # A separator is space between a pane's sections, which the cursor skips and clicks don't reach.
       def selectable? = kind != :separator

data/lib/raindown/tui/rows.rb

@@ -29,9 +29,10 @@ module Raindown
         parts.zip(spread(parts.map(&:first), width)).map { |(text, style), part| segment(text, style, width: part, event:) }
       end
 
-      # The row's text, after its tag in the tag's style, unless the row's selected.
+      # The row's text, after its tag in the tag's style, or highlighted when it's code, unless the row's selected.
       def row_parts(row, style, selected)
         lead = " #{Text::INDENT * row.depth}"
+        return [[lead, style], *row.code] if row.code && !selected
         return [["#{lead}#{row.text}", style]] unless row.tag
 
         [["#{lead}#{row.tag.method} ", selected ? style : row.tag.style], [row.text, style]]