raindown 0.7.0 → 0.8.0

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+module Raindown
+  module TUI
+    # How Code feelings' digits move in their cells: the restless ones, the heaviest, now and then flicker one lower, and
+    # the ones beside the method the mouse is over flee from it, to the far side of their cells, where they tremble often,
+    # as if they're trying to escape, while every cell around it is bold.
+    module Motion
+      # The columns a fleeing digit moves by when it trembles, each for a step of FLEEING_TREMBLE_SECONDS, a little longer
+      # than a frame, so none are missed, once every FLEEING_TREMBLE_EVERY of them, about every 0.7 seconds, each cell at its
+      # own moment.
+      TREMBLE = [1, -1, 1, -1].freeze
+      FLEEING_TREMBLE_SECONDS = 0.09
+      FLEEING_TREMBLE_EVERY = 8
+      # The columns a digit flees by, from the method beside it, from the middle of its cell, where it's still.
+      FLEE = 1
+      MIDDLE = 1
+      # A restless digit flickers one lower for FLICKER_SECONDS, once every FLICKER_EVERY of them, about every 30 seconds.
+      FLICKER_SECONDS = 0.5
+      FLICKER_EVERY = 60
+
+      private
+
+      # The column of the cell's digit in its cell: the middle, or fleeing to its edge, where it trembles often.
+      def digit_column(owner, index)
+        away = flee(index)
+        return MIDDLE if away.zero?
+
+        fleeing_column(owner, index, away)
+      end
+
+      # At the edge of its cell it's fled to, trembling often and quickly, but never out of the cell.
+      def fleeing_column(owner, index, away)
+        (MIDDLE + away + tremble(owner, index)).clamp(0, FeelingsRenderer::CELL - 1)
+      end
+
+      # A column either way, during the cell's moment once every FLEEING_TREMBLE_EVERY steps, or else none.
+      def tremble(owner, index)
+        TREMBLE.fetch(((now / FLEEING_TREMBLE_SECONDS).floor + Zlib.crc32("#{owner}:#{index}")) % FLEEING_TREMBLE_EVERY, 0)
+      end
+
+      # One lower, during the restless cell's moment once every FLICKER_EVERY steps of FLICKER_SECONDS, or else none.
+      def flicker(owner, index)
+        return 0 if view.code_methods[owner].drift < FeelingsRenderer::RESTLESS
+        return 0 unless (((now / FLICKER_SECONDS).floor + Zlib.crc32("#{owner}:#{index}")) % FLICKER_EVERY).zero?
+
+        -1
+      end
+
+      # The time the frame's drawn at, in seconds, the same for all its cells.
+      def now = @now ||= Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      # Away from the method the mouse is over, when it's beside the cell in its row.
+      def flee(index)
+        away = 0
+        away += FLEE if beside_hovered?(index, -1)
+        away -= FLEE if beside_hovered?(index, 1)
+        away
+      end
+
+      # Whether the cell a step along its row, -1 to the left or 1 to the right, is the method the mouse is over's, and
+      # this one isn't.
+      def beside_hovered?(index, step)
+        ((index % columns) + step).between?(0, columns - 1) && hovered.include?(index + step) && !hovered.include?(index)
+      end
+
+      # Bold around the method the mouse is over, beside it, above it, below it, or diagonally.
+      def cell_style(index)
+        @nearby ||= hovered.flat_map { around(it) }.to_set - hovered
+        return :nearby if @nearby.include?(index)
+
+        :feelings
+      end
+
+      # The cells around the cell, in the rows above and below it and beside it in its own.
+      def around(index)
+        column = index % columns
+        [-1, 0, 1].product([-1, 0, 1]).filter_map do |down, across|
+          next if (down.zero? && across.zero?) || !(column + across).between?(0, columns - 1)
+
+          index + (down * columns) + across
+        end
+      end
+
+      # The cells of the method the mouse is over, by their index.
+      def hovered
+        @hovered ||= @cells.each_index.select { navigator.hovered == Click.new(pane:, index: @cells[it], action: :focus) }.to_set
+      end
+    end
+  end
+end

data/lib/raindown/tui/feelings/waffle/baked_waffle.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Raindown
+  module TUI
+    # A waffle's rows, as [text, style] parts: a grid of pockets between golden ridges, shaded darker at their tops,
+    # under the ridges, so they look deep, with rounded corners, and a pat of butter melting where the middle ridges cross,
+    # with a white shine at its top left, and as many of its pockets as have been filled with syrup, nearest the butter
+    # first:
+    #     ▄███████████████████████▄
+    #     █▓▓▓▓▓█▓▓▓▓▓█▓▓▓▓▓█▓▓▓▓▓█
+    #     █░░░░░█░░░░░█░░░░░█░░░░░█
+    #     █████████████████████████
+    #     █▓▓▓▓▓█▓▓▓▓▓█▓▓▓▓▓█▓▓▓▓▓█
+    #     █░░░░░█░░░▄▄▄▄▄░░░█░░░░░█
+    #     ██████████████████████████
+    module BakedWaffle
+      RIDGE = :code_number
+      POCKET = :bright_orange
+      BUTTER = :button
+      SHINE = :shine
+      SYRUP = :syrup
+      # The pockets across and down, the columns each takes, and the lines a pocket and a ridge take.
+      POCKETS = 4
+      POCKET_WIDTH = 5
+      ROW_LINES = 3
+      # The pat of butter's lines, from the line above the middle ridge, a drip below it, and the shine at its top left, as
+      # its lines and columns.
+      PAT = %w[▄▄▄▄▄ █████ ▀▀█▀▀].freeze
+      DRIP = '▀'
+      SHINE_AT = [[0, 0], [0, 1], [1, 0]].freeze
+
+      module_function
+
+      def rows(syrup: 0)
+        cells = Array.new(down) { |row| Array.new(across) { |column| cell(row, column, across, down) } }
+        buttered(sweetened(cells, syrup), down / 2, across / 2).map { parts(it) }
+      end
+
+      def across = 1 + (POCKETS * (POCKET_WIDTH + 1))
+      def down = 1 + (POCKETS * ROW_LINES)
+
+      # The cells with as many pockets filled with syrup, nearest the middle first, keeping their shading.
+      def sweetened(cells, filled)
+        pockets.first(filled).each do |pocket_row, pocket_column|
+          (1...ROW_LINES).to_a.product((1..POCKET_WIDTH).to_a).each do |line, offset|
+            cells[(pocket_row * ROW_LINES) + line][(pocket_column * (POCKET_WIDTH + 1)) + offset][1] = SYRUP
+          end
+        end
+        cells
+      end
+
+      # The pockets, by their row and column, nearest the middle first.
+      def pockets
+        middle = (POCKETS - 1) / 2.0
+        (0...POCKETS).to_a.product((0...POCKETS).to_a).sort_by { |row, column| [(row - middle).abs + (column - middle).abs, row, column] }
+      end
+
+      # A ridge, rounded at its corners, or a pocket, darker at its top, under the ridge above it, than below.
+      def cell(row, column, across, down)
+        edge = [0, down - 1].include?(row)
+        return [' ', :blank] if edge && [0, across - 1].include?(column)
+        return ['▄', RIDGE] if row.zero? && [1, across - 2].include?(column)
+        return ['▀', RIDGE] if edge && [1, across - 2].include?(column)
+        return ['█', RIDGE] if (row % ROW_LINES).zero? || (column % (POCKET_WIDTH + 1)).zero?
+
+        [%w[▓ ░][(row % ROW_LINES) - 1], POCKET]
+      end
+
+      # The cells with the pat of butter on the middle ridges' cross, its drip, and its shine.
+      def buttered(cells, row, column)
+        PAT.each_with_index do |line, at|
+          line.each_char.with_index { |char, offset| cells[row - 1 + at][column - 2 + offset] = [char, BUTTER] }
+        end
+        cells[row + 2][column] = [DRIP, BUTTER]
+        shine(cells, row, column)
+      end
+
+      # The cells with the butter's top left shining.
+      def shine(cells, row, column)
+        SHINE_AT.each { |line, offset| cells[row - 1 + line][column - 2 + offset][1] = SHINE }
+        cells
+      end
+
+      # The row's cells in runs of the same style, as [text, style] parts.
+      def parts(row) = row.chunk_while { |cell, after| cell[1] == after[1] }.map { [it.map(&:first).join, it[0][1]] }
+    end
+  end
+end

data/lib/raindown/tui/feelings/waffle/balloons.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+require_relative '../celebration/rain'
+
+module Raindown
+  module TUI
+    # Balloons floating up either side of the waffle, when a batch of code feelings is refined: one for every so many
+    # columns, left and right in turn, clear of the waffle in the middle, each in a bright colour, shaded where the light
+    # catches it, with a knot and a string that kinks, rising from below the bottom, swaying a column either way, then
+    # round again. Their spaces are see-through:
+    #     ▄███▄
+    #    █░▒████
+    #    █▒█████
+    #     ▀███▀
+    #       ▼
+    #       │
+    #       ╰╮
+    #        │
+    class Balloons
+      BALLOON = [' ▄███▄', '█░▒████', '█▒█████', ' ▀███▀', '   ▼'].freeze
+      STRING = ['   │', '   ╰╮', '    │'].freeze
+      # The columns for each balloon, and the frames each row it rises takes.
+      COLUMNS_A_BALLOON = 20
+      # The columns kept clear in the middle, for the waffle and its text.
+      MIDDLE = 39
+      RISE_FRAMES = 2.1
+      # Where a balloon is, by its left column and its top row, and its colour.
+      Balloon = Data.define(:left, :top, :color)
+
+      attr_reader :width, :height
+
+      def initialize(width:, height:)
+        @width = width
+        @height = height
+      end
+
+      # Draws the balloons where they've floated to by the tick into a Scene's cells.
+      def draw(cells, tick)
+        [width / COLUMNS_A_BALLOON, 2].max.times { balloon(cells, floated(it, Zlib.crc32("balloon #{it}"), tick)) }
+      end
+
+      private
+
+      # Where a balloon's floated to by the tick, from its seed, a checksum of it: where it rises in its side, when it starts,
+      # how it sways, never past an edge, and its colour.
+      def floated(number, seed, tick)
+        sway = (side(number, seed) + Math.sin((tick + seed) / 6.4).round).clamp(0, [width - BALLOON.map(&:length).max, 0].max)
+        Balloon.new(left: sway, top: risen(seed, tick),
+                    color: Rain::COLORS[(seed >> 16) % Rain::COLORS.length])
+      end
+
+      # A column in the left side for the even balloons, and the right for the odd, either side of the middle.
+      def side(number, seed)
+        room = [((width - MIDDLE) / 2) - BALLOON.map(&:length).max, 1].max
+        column = seed % room
+        return column if number.even?
+
+        width - room + column - BALLOON.map(&:length).max
+      end
+
+      # Its top row, a row higher every RISE_FRAMES, from below the bottom to above the top, then round again.
+      def risen(seed, tick) = height - 1 - (((tick / RISE_FRAMES).floor + (seed >> 8)) % (height + BALLOON.length + STRING.length))
+
+      def balloon(cells, balloon)
+        BALLOON.each_with_index { |text, row| put(cells, balloon.top + row, balloon.left, text, balloon.color) }
+        STRING.each_with_index { |text, row| put(cells, balloon.top + BALLOON.length + row, balloon.left, text, :border) }
+      end
+
+      # The text's characters from the left column, leaving the cells under its spaces as they are.
+      def put(cells, row, left, text, style)
+        return unless row.between?(0, height - 1)
+
+        text.each_char.with_index do |char, at|
+          cells[row][left + at] = [char, style] if char != ' ' && (left + at).between?(0, width - 1)
+        end
+      end
+    end
+  end
+end

data/lib/raindown/tui/feelings/waffle/confetti.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+require_relative '../celebration/rain'
+require_relative 'balloons'
+
+module Raindown
+  module TUI
+    # Confetti falling either side of the waffle, behind the balloons, when a batch of code feelings is refined: flecks in
+    # bright colours, a row or two lower each frame, as fast as the Rain, wavering a column either way, then round again
+    # from the top.
+    #    ▪    ◆
+    #       ·    ▴
+    class Confetti
+      FLECKS = %w[▪ ◆ ▴ ·].freeze
+      # The columns for each fleck, and the frames each column it wavers takes.
+      COLUMNS_A_FLECK = 3
+      WAVER_FRAMES = 11
+
+      attr_reader :width, :height
+
+      def initialize(width:, height:)
+        @width = width
+        @height = height
+      end
+
+      # Draws the confetti where it's drifted to by the tick into a Scene's cells, clear of the waffle in the middle.
+      def draw(cells, tick)
+        (width / COLUMNS_A_FLECK).times { fleck(cells, Zlib.crc32("confetti #{it}"), tick) }
+      end
+
+      private
+
+      def fleck(cells, seed, tick)
+        column = drifted(seed, tick)
+        return if clear?(column)
+
+        cells[((tick * speed(seed)) + (seed >> 8)) % height][column] = look(seed)
+      end
+
+      # A row or two a frame, like the Rain's drops.
+      def speed(seed) = ((seed >> 12) % 2) + 1
+
+      # Its column, wavering a column either way as it falls.
+      def drifted(seed, tick) = (seed % width) + (((tick / WAVER_FRAMES) + seed) % 3) - 1
+
+      # Whether the column's in the middle, kept clear for the waffle, or off the screen.
+      def clear?(column) = (column - (width / 2)).abs <= Balloons::MIDDLE / 2 || !column.between?(0, width - 1)
+
+      # Its fleck and colour.
+      def look(seed) = [FLECKS[(seed >> 4) % FLECKS.length], Rain::COLORS[(seed >> 16) % Rain::COLORS.length]]
+    end
+  end
+end

data/lib/raindown/tui/feelings/waffle/sparkles.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+require_relative 'baked_waffle'
+
+module Raindown
+  module TUI
+    # Sparkles twinkling around the waffle, when a batch of code feelings is refined: white, on a ring just clear of it,
+    # each growing from a dot to a star and back, then gone for a while, at its own time.
+    #      ·         ✦
+    #    ▄█████████████▄   ✧
+    class Sparkles
+      TWINKLE = %w[· ✧ ✦ ✧ ·].freeze
+      COUNT = 10
+      # The frames each of a twinkle's steps takes, and the steps between a sparkle's twinkles.
+      TWINKLE_FRAMES = 3
+      TWINKLE_EVERY = 16
+      # The columns and lines the ring's clear of the waffle by.
+      MARGIN = 3
+
+      attr_reader :width, :height
+
+      def initialize(width:, height:)
+        @width = width
+        @height = height
+      end
+
+      # Draws the sparkles twinkling by the tick into a Scene's cells.
+      def draw(cells, tick)
+        COUNT.times { sparkle(cells, Zlib.crc32("sparkle #{it}"), tick) }
+      end
+
+      private
+
+      def sparkle(cells, seed, tick)
+        char = TWINKLE[((tick / TWINKLE_FRAMES) + seed) % TWINKLE_EVERY]
+        row, column = spot(seed)
+        cells[row][column] = [char, :shine] if char && row.between?(0, height - 1) && column.between?(0, width - 1)
+      end
+
+      def spot(seed) = ring[seed % ring.length]
+
+      # The spots on a ring just clear of the waffle, in the middle of the screen, by their row and column: along its top
+      # and bottom, and down its sides.
+      def ring
+        @ring ||= begin
+          top, left, bottom, right = corners
+          [*(left..right).flat_map { [[top, it], [bottom, it]] }, *((top + 1)...bottom).flat_map { [[it, left], [it, right]] }]
+        end
+      end
+
+      # The ring's top row, left column, bottom row and right column, MARGIN clear of the waffle.
+      def corners
+        left = (width - BakedWaffle.across) / 2 - MARGIN
+        top = ((height - BakedWaffle.down) / 2) - MARGIN + 1
+        [top, left, top + BakedWaffle.down + MARGIN, left + BakedWaffle.across + (MARGIN * 2) - 1]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'baked_waffle'
+
+module Raindown
+  module TUI
+    # The waffle after the rain, between balloons floating up, when a batch of code is refined, and the week's work is
+    # done: a BakedWaffle, then a blank line, then what's been done. Once it's popped, syrup pours onto its butter, then
+    # fills its pockets.
+    module Waffle
+      TEXT = [[], [['100% refined', :feelings]], [['The work is mysterious and important.', :feelings]]].freeze
+      # The row the waffle pops out from, its butter's on the middle ridge, and the frames each row more above and below
+      # it takes, half a second at the Screen's 20 frames a second while it celebrates.
+      BUTTER_ROW = BakedWaffle::POCKETS * BakedWaffle::ROW_LINES / 2
+      POP_FRAMES = 10
+      # The frames until it's all popped, and then the frames each pocket takes to fill with syrup, once it's poured.
+      POPPED_FRAMES = POP_FRAMES * (BakedWaffle.down + TEXT.length - 1 - BUTTER_ROW)
+      FILL_FRAMES = 10
+
+      private
+
+      # The waffle over the lines, as it pops, by the frames since the rain stopped: the butter's row first, then a row
+      # more above and below it every POP_FRAMES, then its lines of text, and then the syrup.
+      def waffle(lines, frame)
+        top = waffle_top
+        [*BakedWaffle.rows(syrup: filled(frame, top)), *TEXT].each_with_index do |parts, row|
+          next unless popped?(parts, row, frame) && lines[top + row]
+
+          lines[top + row] = over(lines[top + row], parts)
+        end
+        pour(lines, frame, top)
+      end
+
+      def waffle_top = [(height - BakedWaffle.down - TEXT.length) / 2, 0].max
+
+      def popped?(parts, row, frame) = parts.any? && (row - BUTTER_ROW).abs <= frame / POP_FRAMES
+
+      # The syrup's stream, falling a line a frame from the top onto the butter, once it's all popped, until every
+      # pocket's filled.
+      def pour(lines, frame, top)
+        poured = frame - POPPED_FRAMES
+        return lines if poured.negative? || filled(frame, top) >= BakedWaffle::POCKETS**2
+
+        [poured, stream(top)].min.times { lines[it] = overlay_segments(lines[it], [segment('│', :syrup, width: 1)], column: stream_column) }
+        lines
+      end
+
+      # The lines from the top down to the butter, and the column of the waffle's middle, which the syrup falls down.
+      def stream(top) = top + BUTTER_ROW - 1
+      def stream_column = ((width - BakedWaffle.across - 2) / 2) + 1 + (BakedWaffle.across / 2)
+
+      # The pockets filled with syrup by the frame, one every FILL_FRAMES once the stream's reached the butter.
+      def filled(frame, top) = [(frame - POPPED_FRAMES - stream(top)) / FILL_FRAMES, 0].max
+
+      # The parts over the middle of the line, with a space either side, so they're clear of the balloons behind them.
+      def over(line, parts)
+        segments = [[' ', :blank], *parts, [' ', :blank]].map { |text, style| segment(text, style, width: display_width(text)) }
+        overlay_segments(line, segments, column: [(width - segments.sum { display_width(it.text) }) / 2, 0].max)
+      end
+    end
+  end
+end

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

@@ -5,8 +5,12 @@ require_relative 'batch'
 module Raindown
   module TUI
     # This week's Batch of a project's code to feel, picked to fill the grid when the view first opens and draws it,
-    # then kept through reloads, like after a method's edited or fixed.
+    # then kept through reloads, like after a method's edited or fixed, until the screen's resized.
     class WeeklyBatch
+      # How long a resized grid keeps its new number of cells before the batch is picked again to fill it, so it isn't
+      # picked for every size the screen passes through while it's dragged.
+      RESIZE_SECONDS = 2
+
       attr_reader :batch
 
       def initialize(log:)
@@ -20,12 +24,27 @@ module Raindown
         @batch = batch.reading(every)
       end
 
-      # Picks the batch to fill the grid's cells, once they're known.
-      def fill(grid_cells)
-        return if @filled
+      # Picks the batch to fill the grid's cells, once they're known, and again once a resized grid's kept its new number
+      # of them for RESIZE_SECONDS, and returns whether it did.
+      def fill(grid_cells, now: Process.clock_gettime(Process::CLOCK_MONOTONIC))
+        return refill(grid_cells) unless @filled_for
+
+        @resizing = nil unless @resizing&.first == grid_cells
+        return false if grid_cells == @filled_for
+
+        @resizing ||= [grid_cells, now]
+        return false if now - @resizing.last < RESIZE_SECONDS
+
+        refill(grid_cells)
+      end
+
+      private
 
-        @filled = true
+      def refill(grid_cells)
+        @filled_for = grid_cells
+        @resizing = nil
         @batch = Batch.pick(@every, log: @log, cells: grid_cells)
+        true
       end
     end
   end

data/lib/raindown/tui/layout.rb

@@ -3,8 +3,8 @@
 require_relative 'events'
 require_relative 'text'
 require_relative 'title'
-require_relative 'menu_overlay'
-require_relative 'search_overlay'
+require_relative 'project_box'
+require_relative 'search_box'
 
 module Raindown
   module TUI
@@ -16,9 +16,9 @@ module Raindown
     #    ┌─ Layout ──────────────────────────────────────────────────┐
     #    │  Raindown  ~/docs › guides/setup.md                       │
     #    │ ┌─ nav pane ──────┐ ┌─ main pane ───────────────────────┐ │
-    #    │ │ Dashboard       ▏ # Setup                             │ │
-    #    │ │ ▾ guides/       ▏   toc: [+3]                         │ │
-    #    │ │   setup.md      ▏   ## Install                        │ │
+    #    │ │ Dashboard       │ # Setup                             │ │
+    #    │ │ ▾ guides/       │   toc: [+3]                         │ │
+    #    │ │   setup.md      │   ## Install                        │ │
     #    │ └─ ListRenderer ──┘ └─ view.renderer ───────────────────┘ │
     #    │  Opened guides/setup.md                                   │
     #    │  Tab Pane  Enter Open  X Run  E dit  W rite back  Q uit   │
@@ -29,9 +29,12 @@ module Raindown
       include Title
 
       NAV_WIDTH = (16..32)
-      # The line between the nav and main panes, at its column's left edge, unlike │ in the middle,
-      # so a highlighted file's row runs up to it.
-      DIVIDER = '▏'
+      # The line between the nav and main panes, and the line beneath the title, along the line above the panes, in the
+      # middle of their rows and columns, joined where they meet, like a box's lines. The divider is never highlighted,
+      # so a highlighted row stops at the edge of its column.
+      DIVIDER = '│'
+      BORDER = '─'
+      JOIN = '┬'
       # The title, status and button lines.
       CHROME_HEIGHT = 3
 
@@ -56,10 +59,10 @@ module Raindown
 
       private
 
-      # The project menu or the search, drawn over the lines while it's open.
+      # The project menu or Teleport, drawn over the lines while it's open.
       def overlaid(lines)
-        return MenuOverlay.new(navigator, width:, column: display_width(name)).apply(lines) if navigator.menu
-        return SearchOverlay.new(navigator, width:).apply(lines) if navigator.searching?
+        return ProjectBox.new(navigator, width:, column: display_width(name)).apply(lines) if navigator.menu
+        return SearchBox.new(navigator, width:).apply(lines) if navigator.teleporting?
 
         lines
       end
@@ -71,16 +74,19 @@ module Raindown
         nav = renderer_in(:nav, nav_width).lines
         main = view_renderer.lines
 
-        [spacer, *Array.new(body_height - 1) { |index| [*nav[index], divider(main[index]), *main[index]] }]
+        [spacer, *Array.new(body_height - 1) { |index| [*nav[index], segment(DIVIDER, :divider, width: 1), *main[index]] }]
       end
 
-      # A line above the panes, for spacing, blank but for what the main pane's renderer puts in its side of it.
-      def spacer = [segment('', :blank, width: nav_width), divider([]), *view_renderer.spacer]
+      # A line above the panes, the border beneath the title, but for what the main pane's renderer puts in its side of it.
+      def spacer
+        [border(segment('', :blank, width: nav_width)), segment(JOIN, :divider, width: 1), *view_renderer.spacer.map { border(it) }]
+      end
+
+      # A blank segment of the line above the panes as the border, in the divider's colour.
+      def border(segment)
+        return segment unless segment.style == :blank
 
-      # The divider is on the background of the outline's row beside it, when that's highlighted, so they meet.
-      def divider(main_line)
-        style = { selected: :selected_divider, cursor: :cursor_divider }.fetch(main_line.first&.style, :divider)
-        segment(DIVIDER, style, width: 1)
+        segment.with(text: segment.text.tr(' ', BORDER), style: :divider)
       end
 
       def view_renderer
@@ -127,5 +133,6 @@ end
 require_relative 'renderers/list_renderer'
 require_relative 'renderers/outline_renderer'
 require_relative 'renderers/dashboard_renderer'
+require_relative 'blueprints/blueprints_renderer'
 require_relative 'renderers/endpoint_renderer'
 require_relative 'feelings/feelings_renderer'

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../../actions'
+require_relative '../../watcher/changes'
 
 module Raindown
   module TUI
@@ -77,12 +78,42 @@ module Raindown
         info('Reloaded')
       end
 
-      # Reads the file again when it's changed, like when it's saved in an editor or a watcher writes back to it.
+      # Writes back the files saved since the last tick, like when they're watched, then reads the open file again when
+      # it's changed, like when it's saved in an editor or written back to.
       def refresh
+        effect = watched(@saves.take) if @saves
         view.load if view.changed?
+        effect
+      end
+
+      # A change to a project's nodes loads them again, and a saved Markdown file's written back, like when it's watched,
+      # and the files and endpoints are read again for the files added, removed or changed. When endpoints run as files
+      # are written back, like with -x, the screen says so while they do, as they can take a while.
+      def watched(paths)
+        changes = Watcher.changes(paths, root:)
+        return reload if changes.any?(&:nodes?)
+        return if changes.empty?
+
+        saved = changes.select(&:saved?).map(&:path)
+        return write_back_all(saved) unless @runs_endpoints && saved.any?
+
+        Wait.new(message: "Writing back #{relative(saved.first)}...", task: -> { write_back_all(saved) })
+      end
+
+      def write_back_all(files)
+        files.each { write_back_saved(it) }
+        @files.load
+        @endpoints.load
         nil
       end
 
+      # A saved file's written back, saying so only when it's changed, as when it's watched.
+      def write_back_saved(file)
+        info("Updated #{relative(file)}") if @workers.for(file).call(:write_back, file)
+      rescue StandardError => e
+        error("#{relative(file)}: #{e.message}")
+      end
+
       def info(message)
         @status = [:info, message]
         nil

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