raindown 0.12.0 → 0.14.0

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_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

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative '../../code_blocks'
 require_relative '../events'
 require_relative '../../workers/worker'
 
@@ -9,11 +10,11 @@ module Raindown
     # Worker when it's opened, which scrolls.
     # A key's next step, for the Navigator, is nil, an Open or Edit of its directive, or an Execute of it.
     class EndpointView
-      # The date a response was fetched, on the line after it.
-      FETCHED = /raindown:fetched (\S+)/
+      # The text of the comment above a response, like "response 200 · 142 ms · 2026-10-26".
+      COMMENT = /<!--\s*(.*?)\s*-->/
       FENCE = /\A\s*`{3,}(\S*)/
 
-      attr_reader :endpoint, :response, :language, :fetched, :error
+      attr_reader :endpoint, :response, :language, :comment, :error
 
       def initialize(endpoint, workers:)
         @endpoint = endpoint
@@ -36,7 +37,7 @@ module Raindown
       # Reads the response again, like after the request's run.
       def load
         lines = output_lines
-        @fetched = lines.pop[FETCHED, 1] if lines.last&.match?(FETCHED)
+        @comment = lines.shift[COMMENT, 1] if lines.first&.match?(CodeBlocks::RESPONSE_COMMENT)
         @language = lines.first.to_s[FENCE, 1]
         @response = @language ? lines[1...-1] : lines
         @error = nil

data/lib/raindown/tui.rb

@@ -27,12 +27,16 @@ module Raindown
       # so two projects' nodes of the same name stay apart.
       workers = Project.workers(root:, bare:, execute:)
 
-      # Rouge loads here, rather than with Raindown, which doesn't highlight code outside the TUI.
-      require 'rouge'
-      # Saved files are written back, like when the folder's watched.
-      require_relative 'tui/saves'
-      saves = Saves.new(root)
-      Screen.new(Navigator.new(root:, path: (path unless File.directory?(path)), workers:, saves:, runs_endpoints: execute)).run
+      saves = nil
+      Screen.new do
+        # Rouge loads here, rather than with Raindown, which doesn't highlight code outside the TUI, while the screen shows
+        # the rain cloud.
+        require 'rouge'
+        # Saved files are written back, like when the folder's watched.
+        require_relative 'tui/saves'
+        saves = Saves.new(root)
+        Navigator.new(root:, path: (path unless File.directory?(path)), workers:, saves:, runs_endpoints: execute)
+      end.run
       true
     ensure
       saves&.stop

data/lib/raindown/wiki_links.rb

@@ -5,7 +5,7 @@ require_relative 'front_matter'
 
 module Raindown
   # Obsidian's links between notes, which render as Markdown links to the file they name, by its path in the project,
-  # like files: links, while the file keeps them as they are:
+  # like list: links, while the file keeps them as they are:
   #   [[Reading list]]                   [Reading list](<notes/Reading list.md>)
   #   [[Reading list|books]]             [books](<notes/Reading list.md>)
   #   [[Reading list#To read]]           [Reading list > To read](<notes/Reading list.md#to-read>)

data/lib/raindown.rb

@@ -8,6 +8,7 @@ require_relative 'elements'
 require_relative 'raindown/bare_directives'
 require_relative 'raindown/code'
 require_relative 'raindown/config'
+require_relative 'raindown/context'
 require_relative 'raindown/directives'
 require_relative 'raindown/fragments'
 require_relative 'raindown/front_matter'
@@ -32,7 +33,7 @@ module Raindown
   # Without highlighting, code blocks are left for the browser to highlight, like <pre><code class="language-ruby">.
   UNHIGHLIGHTED_OPTIONS = { render: { **HTML_OPTIONS[:render], github_pre_lang: false } }.freeze
 
-  # Stands in for an app's metadata when there isn't any, so list: and files: list nothing.
+  # Stands in for an app's metadata when there isn't any, so list: lists nothing.
   module NoMetadata
     def self.list(**) = []
   end
@@ -49,13 +50,12 @@ module Raindown
   # Bare directives like "toc:" show in bold in the HTML, and the rest stay hidden, as comments.
   # Code blocks are highlighted, unless highlight_code is false for a site that highlights code in the browser.
   def render(markdown:, metadata: NoMetadata, bare: false, highlight_code: true)
-    bare ||= BareDirectives.front_matter?(markdown)
+    context = Context.new(document: markdown, metadata:, bare: bare || BareDirectives.front_matter?(markdown))
 
     highlighting(highlight_code) do
       Fragments.collect do
         # Components' HTML goes back in, then their headings get unique ids, before nodes like the TOC see it.
-        html = assembled(markdown:, metadata:, bare:)
-        html = Nodes.render_placeholders(html, document: markdown, metadata:, bare:, html:)
+        html = Nodes.render_placeholders(assembled(context), context)
 
         Directives.render("#{html.chomp}\n")
       end
@@ -77,15 +77,14 @@ module Raindown
   end
 
   # The document's HTML with its components' HTML put back, and unique heading ids.
-  def assembled(markdown:, metadata: NoMetadata, bare: false)
-    HeadingIds.unique(Fragments.fill(html(markdown:, variables: variables(markdown:), metadata:, bare:)))
+  def assembled(context)
+    HeadingIds.unique(Fragments.fill(html(context)))
   end
 
   # The document's HTML from Commonmarker, after nodes and the template pass, with components as fragments.
-  def html(markdown:, variables:, metadata: NoMetadata, bare: false)
-    markdown = NodeBlocks.to_rendered(markdown.dup.force_encoding('UTF-8'), metadata:, bare:)
-    markdown = WikiLinks.to_markdown(markdown, metadata:)
-    commonmark(PreRenderer.render(markdown, variables:, metadata:, bare:))
+  def html(context)
+    markdown = WikiLinks.to_markdown(NodeBlocks.to_rendered(context), metadata: context.metadata)
+    commonmark(PreRenderer.render(markdown, variables: context.variables, context:))
   end
 
   # Markdown to HTML, like a document's or a component's slot.
@@ -103,10 +102,6 @@ module Raindown
     doc.to_html(options: UNHIGHLIGHTED_OPTIONS, plugins: { syntax_highlighter: nil })
   end
 
-  def variables(markdown:)
-    Variables.new(FrontMatter.parse(markdown).first)
-  end
-
   # Commonmarker escapes directives, so they're hidden in HTML comments until it's done.
   def hide_directives(markdown:)
     markdown.gsub('<{', '<!-- ANTLERS').gsub('}>', 'ANTLERS -->').force_encoding('UTF-8')

data/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Raindown
-  VERSION = '0.12.0'
+  VERSION = '0.14.0'
 end