raindown 0.11.0 → 0.13.0

data/lib/raindown/rewriter.rb

@@ -8,26 +8,27 @@ require_relative 'utils'
 module Raindown
   # Rewrites the generated parts of a Markdown file in place before it's rendered:
   # node output, like the TOC, endpoint responses and table alignment.
-  # Each rewriter responds to rewrite(content:, path:, bare:, execute:, metadata:) and returns the new content.
   module Rewriter
-    REWRITERS = [NodeInjector, EndpointRunner, TableFormatter].freeze
+    # The content written back, and the endpoint checks it failed, like "api.md:3: expected status 200, received 404".
+    Rewrite = Data.define(:original, :content, :failures) do
+      def changed?
+        content != original
+      end
+    end
 
     module_function
 
     def rewrite(content:, path:, bare: false, execute: false, metadata: NoMetadata)
-      REWRITERS.reduce(content) do |rewritten, rewriter|
-        rewriter.rewrite(content: rewritten, path:, bare:, execute:, metadata:)
-      end
+      injected = NodeInjector.rewrite(content:, path:, bare:, metadata:)
+      endpoints = EndpointRunner.new(content: injected, path:, bare: BareDirectives.enabled?(path:, content: injected, bare:), execute:)
+      Rewrite.new(original: content, content: TableFormatter.rewrite(content: endpoints.rewrite), failures: endpoints.failures)
     end
 
-    # Returns true when the file changed.
+    # Writes the file only when it changed.
     def update(path:, bare: false, execute: false, metadata: NoMetadata)
-      content = Utils.read_markdown(path)
-      rewritten = rewrite(content:, path:, bare:, execute:, metadata:)
-      return false if rewritten == content
-
-      File.write(path, rewritten)
-      true
+      rewrite(content: Utils.read_markdown(path), path:, bare:, execute:, metadata:).tap do |rewrite|
+        File.write(path, rewrite.content) if rewrite.changed?
+      end
     end
   end
 end

data/lib/raindown/table/markdown_table.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Raindown
+  # Rows of cells as a Markdown table, its first row the header, and back again. A | in a cell is escaped as \|, and
+  # a line break is written as a space, as a table's cells are one line. The TableFormatter lines up its columns.
+  module MarkdownTable
+    SEPARATOR = /\A\|?(\s*:?-+:?\s*\|)*\s*:?-+:?\s*\|?\z/
+    # A | that isn't escaped.
+    PIPE = /(?<!\\)\|/
+
+    module_function
+
+    def format(rows)
+      header, *body = rows.map { |row| "| #{row.map { escape(it) }.join(' | ')} |" }
+      [header, "|#{Array.new(rows.first.length, '---').join('|')}|", *body].join("\n")
+    end
+
+    # The rows of the table in the lines, leaving out its separator, or none when they aren't a table.
+    def parse(lines)
+      return [] unless lines[1]&.strip&.match?(SEPARATOR)
+
+      [lines[0], *lines.drop(2)].take_while { it.strip.start_with?('|') }.map { cells(it.strip) }
+    end
+
+    def cells(line)
+      line.delete_prefix('|').delete_suffix('|').split(PIPE, -1).map { it.strip.gsub('\|', '|') }
+    end
+
+    def escape(cell)
+      cell.gsub('|', '\|').gsub(/\s*\R\s*/, ' ')
+    end
+  end
+end

data/lib/raindown/table/table.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'csv'
+require 'digest'
+require 'json'
+
+require_relative '../node'
+require_relative 'markdown_table'
+
+module Raindown
+  # The node behind table:, a CSV or TSV file relative to the project as a Markdown table, after a comment of how many
+  # rows it has and a hash of them, as they were when the table and the file last matched:
+  #   table: 'data/team.csv'
+  #   <!-- table 2 rows · 3f2a9c -->
+  #   | name | role     |
+  #   |------|----------|
+  #   | Ada  | engineer |
+  #   | Lin  | design   |
+  # Edit the table and its rows are written back to the file, or edit the file and the table's written again. When
+  # both changed, neither is, and the table's comment says so until they match again.
+  class Table < Node
+    COMMENT = /\A<!-- table (?:conflict|\d+ rows?) · (\h+) -->\z/
+    SEPARATORS = { '.csv' => ',', '.tsv' => "\t" }.freeze
+
+    def initialize(data)
+      @data = data
+    end
+
+    # Written is what it wrote last time, so it can tell which of the table and the file changed since.
+    def replace(written: [], metadata: NoMetadata)
+      path = File.expand_path(@data.to_s, metadata.respond_to?(:root) ? metadata.root : Dir.pwd)
+      return "Can't show #{@data.inspect} as a table: only CSV and TSV files can be" unless SEPARATORS.key?(File.extname(path).downcase)
+      return "Can't show #{@data.inspect} as a table: no such file" unless File.file?(path)
+
+      synced(path, written.map(&:chomp))
+    end
+
+    private
+
+    def synced(path, written)
+      file = read_rows(path)
+      synced_hash = written.first&.[](COMMENT, 1)
+      table = MarkdownTable.parse(written.drop(1))
+      return markdown(file) if synced_hash.nil? || table.empty? || [synced_hash, hash_rows(file)].include?(hash_rows(table))
+      return markdown(write_rows(path, table)) if hash_rows(file) == synced_hash
+
+      warn "raindown: #{@data} and its table both changed, so neither is written until they match"
+      ["<!-- table conflict · #{synced_hash} -->", *written.drop(1)].join("\n")
+    end
+
+    def markdown(rows)
+      return '' if rows.empty?
+
+      count = rows.length - 1
+      "<!-- table #{count} row#{'s' unless count == 1} · #{hash_rows(rows)} -->\n#{MarkdownTable.format(rows)}"
+    end
+
+    def read_rows(path)
+      rows = CSV.read(path, col_sep: SEPARATORS[File.extname(path).downcase], skip_blanks: true, encoding: Encoding::UTF_8)
+      width = rows.map(&:length).max.to_i
+      rows.map { |row| Array.new(width) { row[it].to_s.strip } }
+    end
+
+    def write_rows(path, rows)
+      File.write(path, rows.map { CSV.generate_line(it, col_sep: SEPARATORS[File.extname(path).downcase]) }.join)
+      rows
+    end
+
+    def hash_rows(rows)
+      Digest::SHA256.hexdigest(JSON.generate(rows))[0, 6]
+    end
+  end
+end

data/lib/raindown/tui/blueprints/blueprints_view.rb

@@ -11,7 +11,7 @@ require_relative 'filter'
 
 module Raindown
   module TUI
-    # The blueprints from Claude Code's replies, in the project's .raindown/blueprints.md, newest first, then those in its
+    # The blueprints from Claude Code's replies, in the project's .raindown/data/blueprints.md, newest first, then those in its
     # code's comments, one at a time, of
     # those its Filter's keywords match, each traced to its code: the arrows move between the boxes drawn in one, or a
     # click on one, the code each box names shows below, Space or another click moving on to

data/lib/raindown/tui/cloud.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+module Raindown
+  module TUI
+    # Raindown's logo, raindown.dev's rain cloud, in the middle of the screen while the terminal UI loads: bumps and a
+    # rounded base of blocks, each its own blue, lighter at the top, with a few corrupted, and rain falling from under it
+    # to the bottom of the screen, fading and thinning out as it goes:
+    #                   ███████████████▞███▄██████████
+    #                    ██████████████████████████
+    #                   ╎╎,┊ '  ,   ┊ ┊ '   ┊' ╎,
+    #                ╎  │ ││ ,  │   │ , '   ' ┊,
+    # It's drawn like the site's RainCloud, with the same seed, so it's the same cloud, in the nearest of the 256 colours
+    # most terminals have.
+    class Cloud
+      WIDTH = 50
+      ROWS = 19
+      SEED = 5
+      # Bumps as [column, row, radius], and the base under them, with its corners rounded. Rows are stretched, as
+      # characters are taller than they're wide.
+      BUMPS = [[25, 8, 11], [13, 12, 7.5], [37, 11, 8.5]].freeze
+      BASE_ROWS = 12..18
+      BASE_COLUMNS = 7..43
+      CORNER = 5
+      ROW_STRETCH = 1.7
+      SHADES = %w[█ ▓].freeze
+      CORRUPT = %w[▀ ▄ ▚ ▞ ▌ ▐].freeze
+      CORRUPTED = 0.015
+      RAIN = %w[│ ╎ ┊ ' ,].freeze
+      # The rain's blue, as hue, saturation and lightness, which fades in steps as it falls, and thins out.
+      RAIN_BLUE = [212, 100, 70].freeze
+      RAIN_STEPS = 8
+      FADE = 0.11
+      # The levels of red, green and blue in the 256 colours' cube, from 16 to 231, leaving out the greys after it, so
+      # the rain stays blue as it fades.
+      CUBE = [0, 95, 135, 175, 215, 255].freeze
+      XTERM = (16..231).to_h { [it, CUBE.values_at((it - 16) / 36, ((it - 16) / 6) % 6, (it - 16) % 6)] }.freeze
+
+      class << self
+        # Each cell inside the cloud, by its row and column, as its block and its blue's style.
+        def cells = drawing.first
+
+        # The columns it rains from.
+        def rainy = drawing.last
+
+        # The rain's style at each step, from just under the cloud to the bottom of the screen.
+        def rain_styles
+          @rain_styles ||= Array.new(RAIN_STEPS) { |step| style(rgb(*RAIN_BLUE).map { (it * (1 - (step * FADE))).round }) }
+        end
+
+        # Every blue it's drawn in, for the screen's colours.
+        def styles = (cells.values.map(&:last) + rain_styles).uniq
+
+        private
+
+        # Rolled in the site's order, a cell at a time, then the rainy columns.
+        def drawing
+          @drawing ||= begin
+            random = Random.new(SEED)
+            cells = ROWS.times.to_a.product(WIDTH.times.to_a).select { inside?(*it) }.to_h { [it, cell(it.first, random)] }
+            [cells, ((BASE_COLUMNS.begin + 1)..(BASE_COLUMNS.end - 1)).select { random.rand < 0.6 }]
+          end
+        end
+
+        # A corrupted block now and then, and otherwise a shade, denser towards the bottom, with some noise.
+        def cell(row, random)
+          return [CORRUPT.sample(random:), blue(row, random)] if random.rand < CORRUPTED
+
+          depth = (row / ROWS.to_f) + random.rand(-0.25..0.25)
+          [SHADES[(1 - (depth * 2)).round.clamp(0, 1)], blue(row, random)]
+        end
+
+        # A random blue, lighter at the top of the cloud and darker at the bottom.
+        def blue(row, random)
+          light = (82 - (row * 2.4) + random.rand(-12..12)).round.clamp(25, 90)
+          style(rgb(random.rand(198..235), random.rand(65..100), light))
+        end
+
+        # The style of the nearest of the 256 colours.
+        def style(rgb) = :"cloud_#{XTERM.min_by { |_, color| color.zip(rgb).sum { (it[0] - it[1])**2 } }.first}"
+
+        def rgb(hue, saturation, lightness)
+          saturation /= 100.0
+          lightness /= 100.0
+          chroma = saturation * [lightness, 1 - lightness].min
+          [0, 8, 4].map do |offset|
+            k = (offset + (hue / 30.0)) % 12
+            ((lightness - (chroma * [[k - 3, 9 - k, 1].min, -1].max)) * 255).round
+          end
+        end
+
+        def inside?(row, column)
+          BUMPS.any? { |x, y, radius| ((column - x)**2) + (((row - y) * ROW_STRETCH)**2) <= radius**2 } || base?(row, column)
+        end
+
+        def base?(row, column)
+          return false unless BASE_ROWS.cover?(row) && BASE_COLUMNS.cover?(column)
+
+          corner_row, corner_column = corner(row, column)
+          ((column - corner_column)**2) + (((row - corner_row) * ROW_STRETCH)**2) <= CORNER**2
+        end
+
+        # The nearest point to the cell that's a corner's radius in from the base's edges, where its corners curve in
+        # from, reaching at most halfway up the base.
+        def corner(row, column)
+          inset = [CORNER / ROW_STRETCH, (BASE_ROWS.end - BASE_ROWS.begin) / 2.0].min
+          [row.clamp(BASE_ROWS.begin + inset, BASE_ROWS.end - inset), column.clamp(BASE_COLUMNS.begin + CORNER, BASE_COLUMNS.end - CORNER)]
+        end
+      end
+
+      attr_reader :width, :height
+
+      def initialize(width:, height:)
+        @width = width
+        @height = height
+        @left = (width - WIDTH) / 2
+        @top = [(height - ROWS) / 3, 0].max
+      end
+
+      # Draws the cloud and its rain at the tick into a Scene's cells.
+      def draw(cells, tick)
+        self.class.cells.each { |(row, column), (block, style)| put(cells, row, column, block, style) }
+        rain(cells, tick)
+      end
+
+      private
+
+      # Drops in the rainy columns, moving down a row a tick, fading and thinning out in steps below the cloud.
+      def rain(cells, tick)
+        falling = height - @top - ROWS
+        falling.times do |below|
+          step = below * RAIN_STEPS / falling
+          self.class.rainy.each { |column| drop(cells, column, below - tick, ROWS + below, step) }
+        end
+      end
+
+      # The drop in the column at the row, if there's one there at the tick, from a checksum of where it is in the rain.
+      def drop(cells, column, falling, row, step)
+        drop = Zlib.crc32("#{column} #{falling}")
+        return unless (drop % 100) < 90 - (step * 9)
+
+        put(cells, row, column, RAIN[drop % RAIN.length], self.class.rain_styles[step])
+      end
+
+      # The cell at the cloud's row and column, where it's on the screen.
+      def put(cells, row, column, char, style)
+        row += @top
+        column += @left
+        cells[row][column] = [char, style] if row.between?(0, height - 1) && column.between?(0, width - 1)
+      end
+    end
+  end
+end

data/lib/raindown/tui/feelings/celebration/celebration_renderer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../../text'
+require_relative '../waffle/waffle'
+require_relative 'scene'
+
+module Raindown
+  module TUI
+    # A Celebration over the whole screen, in place of the Layout: rain and fireworks, then a waffle popping out, among
+    # confetti, balloons and sparkles.
+    CelebrationRenderer = Struct.new(:celebration, :width, :height) do
+      include Text
+      include Waffle
+
+      def lines
+        return Scene.new(width:, height:).lines(celebration.frame) if celebration.raining?
+
+        waffle(Scene.new(width:, height:, animations: [Confetti, Balloons, Sparkles]).lines(celebration.popping), celebration.popping)
+      end
+    end
+  end
+end

data/lib/raindown/tui/feelings/feelings_log.rb

@@ -22,16 +22,16 @@ module Raindown
       end
     end
 
-    # The feelings everyone's sorted about the code as it is now, kept in .raindown/feelings.csv with the commit they were
+    # The feelings everyone's sorted about the code as it is now, kept in .raindown/data/feelings.csv with the commit they were
     # felt at, which a node can count, like the README's code debt. A feeling about code that's since changed, or gone, moves to
-    # .raindown/memories.csv, so the feelings stay few, and the history's kept.
+    # .raindown/data/memories.csv, so the feelings stay few, and the history's kept.
     class FeelingsLog
       TEMPERS = %w[frolic numb woe dread malice].freeze
       HEADER = %i[timestamp commit checksum location method temper note].freeze
       def initialize(root:)
         @root = root
-        @csv = File.join(root, '.raindown', 'feelings.csv')
-        @memories = File.join(root, '.raindown', 'memories.csv')
+        @csv = File.join(root, '.raindown', 'data', 'feelings.csv')
+        @memories = File.join(root, '.raindown', 'data', 'memories.csv')
       end
 
       # Adds the feeling, as the newest, in place of one about the method before, which moves to the memories if it was

data/lib/raindown/tui/feelings/feelings_renderer.rb

@@ -7,14 +7,11 @@ require_relative 'bins'
 require_relative 'feelings_code_box'
 require_relative 'magnifier'
 require_relative 'motion'
-require_relative 'celebration/scene'
-require_relative 'waffle/waffle'
 
 module Raindown
   module TUI
     # Code feelings, right of the files: the methods as clusters of digits in a grid, with the selected one highlighted
     # and its code below, then why it felt that way while that's typed, then the five bins and how many each holds.
-    # When the batch is refined, it rains over them, then there's a waffle:
     #     0  0  2  2  2  5  5  9  9  9  9  1
     #     1  3  3  7  7  7  6  4  4  0  8  8
     #    ╭─ lib/text.rb:62 · Text#segments_between ──────────── changed 6× ─╮
@@ -29,7 +26,6 @@ module Raindown
       include FeelingsCodeBox
       include Magnifier
       include Motion
-      include Waffle
 
       # The columns a cell takes, on a line of its own, its digit small in the middle, which is magnified in a stat's block
       # digits across the cell and over the cells above and below it when the mouse is over its method.
@@ -66,7 +62,7 @@ module Raindown
         return too_small if too_small?
 
         cells = view.cells(columns, filled_rows)
-        return instead if view.code_methods.empty? || view.celebration
+        return instead if view.code_methods.empty?
 
         below = [*code_box, *bins]
         (grid(cells, below.length) + below).first(height)
@@ -76,20 +72,11 @@ module Raindown
 
       def view = navigator.view
 
-      # Instead of the grid, that there's nothing to feel, as there are no projects or no methods, or the celebration.
+      # Instead of the grid, that there's nothing to feel, as there are no projects or no methods.
       def instead
         return alert(NO_PROJECTS) if navigator.projects.empty?
-        return alert(["No functions or methods in #{File.basename(navigator.root)} to feel."]) if view.code_methods.empty?
 
-        celebration(view.celebration)
-      end
-
-      # Rain and fireworks over the pane when the batch is refined, then a waffle popping out, among confetti, balloons and
-      # sparkles.
-      def celebration(celebration)
-        return Scene.new(width:, height:).lines(celebration.frame) if celebration.raining?
-
-        waffle(Scene.new(width:, height:, animations: [Confetti, Balloons, Sparkles]).lines(celebration.popping), celebration.popping)
+        alert(["No functions or methods in #{File.basename(navigator.root)} to feel."])
       end
 
       # The rows of the grid around the selected method's, between blank lines that leave the first and last rows room to

data/lib/raindown/tui/layout.rb

@@ -5,6 +5,7 @@ require_relative 'text'
 require_relative 'title'
 require_relative 'project_box'
 require_relative 'search_box'
+require_relative 'feelings/celebration/celebration_renderer'
 
 module Raindown
   module TUI
@@ -49,7 +50,7 @@ module Raindown
       def lines
         return [status].first(height) if height < CHROME_HEIGHT + 1
 
-        overlaid([title, *panes, status, button_bar])
+        celebration || overlaid([title, *panes, status, button_bar])
       end
 
       # A third of the width, within NAV_WIDTH, and never more than half of a narrow screen.
@@ -59,6 +60,12 @@ module Raindown
 
       private
 
+      # Code feelings' celebration over the whole screen, while it's on.
+      def celebration
+        celebration = navigator.feelings.celebration
+        CelebrationRenderer.new(celebration, width, height).lines if celebration
+      end
+
       # The project menu or Teleport, drawn over the lines while it's open.
       def overlaid(lines)
         return ProjectBox.new(navigator, width:, column: display_width(name)).apply(lines) if navigator.menu

data/lib/raindown/tui/project.rb

@@ -46,7 +46,7 @@ module Raindown
 
       # A file's lines, headings and directives.
       def outline(path)
-        document = Document.read(path, bare: @bare)
+        document = document(path)
         Outline.new(lines: File.readlines(path, chomp: true), headings: document.headings, directives: document.directives)
       end
 
@@ -66,9 +66,12 @@ module Raindown
       # the ones whose snippet can't be read.
       def endpoints
         Projects.files(root).flat_map do |path|
-          lines = Utils.read_markdown(path).lines
-          runnable = Document.read(path, bare: @bare).directives.select { it.endpoint? && it.writes }
-          runnable.filter_map { |directive| endpoint(path, lines, directive) }
+          document = document(path)
+          # Most files have no endpoint, so they aren't parsed for one.
+          next [] unless document.markdown.include?('endpoint')
+
+          runnable = document.directives.select { it.endpoint? && it.writes }
+          runnable.filter_map { |directive| endpoint(path, document.markdown.lines, directive) }
         rescue StandardError
           []
         end
@@ -96,19 +99,28 @@ module Raindown
       end
 
       def charts_in(path)
-        content = Utils.read_markdown(path)
-        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:)
+        document = document(path)
+        lines = document.markdown.lines
+        # Its headings are only parsed when it has a chart, as most files don't.
+        NodeBlocks.find(lines, front_matter: FrontMatter.parse(document.markdown).first, bare: document.bare)
                   .select { it[:node].respond_to?(:card_lines) }
-                  .map { |block| chart(block, path:, lines:, headings:) }
+                  .map { |block| chart(block, path:, lines:, headings: document.headings) }
       rescue StandardError => e
         @file_errors << "#{path.delete_prefix(File.join(root, ''))}: #{e.message}"
         []
       end
 
+      # The file's Document, read and parsed again only once the file's changed, so its endpoints, charts and outline
+      # share it, and finding them again only parses the files that changed.
+      def document(path)
+        stat = File.stat(path)
+        changed = [stat.mtime, stat.size]
+        cached_at, document = (@documents ||= {})[path]
+        return document if cached_at == changed
+
+        Document.read(path, bare: @bare).tap { @documents[path] = [changed, it] }
+      end
+
       def drawn
         pages = {}
         @charts.map do |chart|

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

@@ -12,7 +12,7 @@ module Raindown
     #    │ GET https://httpbin.org/uuid       [Run] │
     #    ╰──────────────────────────────────────────╯
     #
-    #    Response · json · fetched 2026-10-26
+    #    response 200 · 142 ms · 2026-10-26 · json
     #    {
     #      "uuid": "48024974-f1b1-431a-a0cf-5cac0099a1a5"
     #    }
@@ -73,8 +73,9 @@ module Raindown
         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:)]
+        # As its comment in the file reads, or just response when it has none, then its language.
+        heading = [view.comment || 'response', view.language].reject { it.to_s.empty? }.join(' · ')
+        [segment(" #{heading}", :heading, width:)]
       end
     end
   end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../cloud'
+require_relative '../feelings/celebration/scene'
+
+module Raindown
+  module TUI
+    # The Screen's first frames, which it's prepended to: Raindown's rain cloud over the whole screen while the Navigator's
+    # made in another thread, like while Rouge loads.
+    module Loading
+      private
+
+      def start
+        super
+        loading = Thread.new(&@loading)
+        loading.report_on_exception = false
+        rain_until(loading)
+        @navigator = loading.value
+      end
+
+      # The rain cloud, a frame each animation tick, until the thread's done.
+      def rain_until(thread)
+        scene = Scene.new(width: Curses.cols, height: Curses.lines, animations: [Cloud])
+        tick = 0
+        loop do
+          draw(scene.lines(tick))
+          break if thread.join(Screen::TICKS[:animation] / 1000.0)
+
+          tick += 1
+        end
+      end
+    end
+  end
+end

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

@@ -3,6 +3,7 @@
 require 'curses'
 
 require_relative 'input'
+require_relative 'loading'
 require_relative '../layout'
 require_relative 'ncurses_shim'
 require_relative 'quiet'
@@ -15,15 +16,16 @@ module Raindown
     # Only this class draws on the terminal, so another library could draw the same Layout.
     class Screen
       prepend TerminalTitle
+      prepend Loading
 
       # 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
-        @zones = []
+      # Loading makes the Navigator, while the rain cloud's drawn.
+      def initialize(&loading)
+        @loading = loading
       end
 
       def run
@@ -89,8 +91,7 @@ module Raindown
         Curses.close_screen
       end
 
-      def draw
-        lines = Layout.new(@navigator, width: Curses.cols, height: Curses.lines).lines
+      def draw(lines = Layout.new(@navigator, width: Curses.cols, height: Curses.lines).lines)
         @zones = Input.zones(lines)
         window = Curses.stdscr
         window.erase

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

@@ -2,6 +2,8 @@
 
 require 'curses'
 
+require_relative '../cloud'
+
 module Raindown
   module TUI
     # The curses attributes of a Layout's styles. Text is periwinkle where there are 256 colours, and the terminal's own
@@ -92,7 +94,7 @@ module Raindown
       def colored
         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,
+          button: pair(:button) | Curses::A_BOLD, **selections, **emphasis, **dividers, **code_tokens, **bright, **cloud, **files,
           **unfocused
         )
       end
@@ -130,6 +132,8 @@ module Raindown
       # The bright colours, bold, so they're bright in 8 colours too.
       def bright = BRIGHT.keys.to_h { [it, pair(it) | Curses::A_BOLD] }
 
+      def cloud = Cloud.styles.to_h { [it, pair(it)] }
+
       # The lines between the panes and beneath the title.
       def dividers = { divider: pair(:divider) }
 
@@ -156,6 +160,7 @@ module Raindown
          *(many ? METHODS : BASIC_METHODS).map { |name, color| [:"method_#{name}", color, -1] },
          *(many ? CODE.merge(BRIGHT, FEELINGS, ACCENTS) : BASIC_CODE.merge(BASIC_BRIGHT, BASIC_FEELINGS, BASIC_ACCENTS))
            .map { |name, color| [name, color, -1] },
+         *cloud_pairs,
          [: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]],
@@ -163,6 +168,13 @@ module Raindown
          [:shine, white, -1]]
       end
 
+      # The rain cloud's blues while the terminal UI loads, each the 256 colour its style's named after, or cyan with 8.
+      def cloud_pairs
+        return Cloud.styles.map { [it, Curses::COLOR_CYAN, -1] } if Curses.colors < 256
+
+        Cloud.styles.map { [it, it.to_s.delete_prefix('cloud_').to_i, -1] }
+      end
+
       def pair(name)
         Curses.color_pair(pairs.index { it.first == name } + 1)
       end