r2ui 0.1.0 → 0.2.0

data/lib/r2ui/renderer.rb

@@ -3,21 +3,34 @@
 module R2UI
   # Lays out a dashboard and draws every panel into a canvas.
   class Renderer
-    HINTS = "tab panel  [ ] scope  g group  s/S sort  / search  ⏎ fold  z zoom  q quit"
+    HINT_PAIRS = [
+      ["tab", "panel"], ["[ ]", "scope"], ["g", "group"], ["s/S", "sort"], ["/", "search"], ["⏎", "fold"],
+      ["z", "zoom"], ["q", "quit"]
+    ].freeze
+    HINTS = HINT_PAIRS.map { |key, label| "#{key} #{label}" }.join("  ").freeze
 
     # The lines each table panel showed in the last frame, for selection and actions.
     attr_reader :lines
+    # Where each panel was drawn in the last frame (panel => Rect), e.g. for mouse hit tests.
+    attr_reader :rects
 
-    def initialize(registry, feeds, states)
+    # `draw_item` draws items the core doesn't know (extension items): called with
+    # (panel, item, width, height), it returns a String, or nil if no extension draws that item.
+    # `motion` (an R2UI::Motion) animates tables declared with `motion: true`.
+    def initialize(registry, feeds, states, draw_item: nil, motion: nil)
       @registry = registry
       @feeds = feeds
       @states = states
+      @draw_item = draw_item
+      @motion = motion
       @lines = {}
+      @rects = {}
     end
 
-    def render(dashboard, width:, height:, focus:, zoomed: false, prompt: nil)
-      canvas = Canvas.new(width, height)
+    def render(dashboard, width:, height:, focus:, zoomed: false, prompt: nil, hints: HINTS, styles: nil)
+      canvas = Canvas.new(width, height, styles:)
       body = Rect.new(x: 0, y: 0, width:, height: height - 1)
+      @rects = {}
       if zoomed
         draw_panel(canvas, body, focus, true)
       else
@@ -25,20 +38,30 @@ module R2UI
           draw_panel(canvas, rect, panel, panel == focus)
         end
       end
-      draw_status(canvas, height - 1, width, focus, prompt)
+      draw_status(canvas, height - 1, width, focus, prompt, hints)
       canvas
     end
 
     private
 
+    # Fixed heights (an Integer, or a callable returning one each frame) are clamped so the rows
+    # never exceed the body; rows without one share what is left.
     def rows_layout(dashboard, body)
-      fixed = dashboard.rows.sum { |r| r.height || 0 }
-      flexible = dashboard.rows.count { |r| r.height.nil? }
-      share = flexible.zero? ? 0 : (body.height - fixed) / flexible
+      room = body.height
+      heights = dashboard.rows.map do |row|
+        h = row.height.respond_to?(:call) ? row.height.call : row.height
+        next nil if h.nil?
+
+        h = Integer(h).clamp(0, room)
+        room -= h
+        h
+      end
+      flexible = heights.count(&:nil?)
+      share = flexible.zero? ? 0 : room / flexible
       y = body.y
       dashboard.rows.each_with_index.flat_map do |row, i|
         last = i == dashboard.rows.size - 1
-        h = last ? body.bottom - y : (row.height || share)
+        h = last ? body.bottom - y : (heights[i] || share)
         rect = Rect.new(x: body.x, y:, width: body.width, height: [h, 0].max)
         y += rect.height
         split(rect, row.panels)
@@ -57,32 +80,64 @@ module R2UI
     end
 
     def draw_panel(canvas, rect, panel, focused)
-      resource = @registry.resource(panel.resource)
-      feed = @feeds.fetch(resource.name)
+      @rects[panel] = rect
+      resource = panel.resource && @registry.resource(panel.resource)
+      feed = resource && @feeds.fetch(resource.name)
       state = @states[panel]
-      title = panel.title || (panel.name == resource.name ? resource.title : panel.name.to_s.tr("_", " ").capitalize)
-      inner = Widgets::Box.draw(canvas, rect, title:, focused:, tabs: state ? state.scope_tabs : [])
+      inner = Widgets::Box.draw(canvas, rect, title: panel_title(panel, resource), focused:,
+                                              tabs: state ? state.scope_tabs : [], style: border_style(panel))
       return if inner.empty?
 
-      if (error = feed.error)
+      if (error = feed&.error)
         canvas.write(inner.x, inner.y, error, :alert, max: inner.width)
         inner = inner.take(1).last
       end
 
-      rows = feed.rows
+      rows = feed ? feed.rows : []
       record = rows.first
       panel.items.each do |item|
         break if inner.empty?
 
         inner = case item
-                when DSL::Gauge then draw_gauge(canvas, inner, resource, record, item)
-                when DSL::Stat then draw_stats(canvas, inner, resource, record, item)
-                when DSL::Sparkline then draw_sparkline(canvas, inner, resource, feed, item)
-                when DSL::Table then draw_table(canvas, inner, resource, feed, rows, panel, state, focused, item)
+                when DSL::Gauge then draw_gauge(canvas, inner, needs(resource, panel), record, item)
+                when DSL::Stat then draw_stats(canvas, inner, needs(resource, panel), record, item)
+                when DSL::Sparkline then draw_sparkline(canvas, inner, needs(resource, panel), feed, item)
+                when DSL::Table
+                  draw_table(canvas, inner, needs(resource, panel), feed, rows, panel, state, focused, item)
+                else draw_extension_item(canvas, inner, panel, item)
                 end
       end
     end
 
+    # `panel(..., border_style: -> { ... })`: a style for the border and title, or nil for the default.
+    def border_style(panel)
+      style = panel.options[:border_style]
+      style.respond_to?(:call) ? style.call : style
+    end
+
+    def panel_title(panel, resource)
+      return panel.title if panel.title
+      return resource.title if resource && panel.name == resource.name
+
+      panel.name.to_s.tr("_", " ").capitalize
+    end
+
+    def needs(resource, panel)
+      resource || raise(Error, "panel #{panel.name} has no resource for its gauge/stat/sparkline/table")
+    end
+
+    def draw_extension_item(canvas, rect, panel, item)
+      text = @draw_item&.call(panel, item, rect.width, rect.height)
+      raise Error, "panel #{panel.name}: no extension draws #{item.class}" if text.nil?
+
+      lines = text.to_s.split("\n")
+      area, rest = rect.take(lines.size)
+      lines.first(area.height).each_with_index do |line, i|
+        canvas.write_ansi(area.x, area.y + i, line, max: area.width)
+      end
+      rest
+    end
+
     def draw_gauge(canvas, rect, resource, record, item)
       line, rest = rect.take(1)
       return rest unless record
@@ -118,17 +173,27 @@ module R2UI
                                         sort: state.sort, collapsed: state.collapsed).lines
       lines = lines.first(item.limit) if item.limit
       @lines[panel] = lines
+      motion = item.motion ? @motion : nil
+      state.follow_selection(lines) if motion
       label_key = state.grouping && !state.grouping.tree? && resource.column(state.grouping.by) ? state.grouping.by : nil
       spark = ->(line, col) { feed.history.sum(line.rows.map { |r| feed.series_id(r) }, col.key) }
-      Widgets::Table.new(resource, lines, state:, focused:, label_key:, spark:).draw(canvas, rect)
+      Widgets::Table.new(resource, lines, state:, focused:, label_key:, spark:, motion:, motion_key: panel.name,
+                                          columns: table_columns(resource, panel, item))
+                    .draw(canvas, rect)
       rect.with(height: 0)
     end
 
-    def draw_status(canvas, y, width, focus, prompt)
+    # `table(columns: [...])`: those index columns, in that order (nil: all of them).
+    def table_columns(resource, panel, item)
+      item.columns&.map do |key|
+        resource.column(key) || raise(Error, "panel #{panel.name}: #{resource.name} has no column #{key.inspect}")
+      end
+    end
+
+    def draw_status(canvas, y, width, focus, prompt, hints)
       left = prompt || @states[focus]&.status.to_s
       canvas.fill(Rect.new(x: 0, y:, width:, height: 1), " ", :reverse)
       canvas.write(1, y, left, :reverse, max: width - 2)
-      hints = HINTS
       canvas.write(width - hints.length - 1, y, hints, :reverse) if left.length + hints.length + 4 <= width
     end
 

data/lib/r2ui/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module R2UI
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/r2ui/widgets/box.rb

@@ -6,10 +6,13 @@ module R2UI
     module Box
       module_function
 
-      def draw(canvas, rect, title: nil, focused: false, tabs: [])
+      # `style` (a palette Symbol or SGR String) colours the border and title instead of the
+      # :focus/:border and :title defaults.
+      def draw(canvas, rect, title: nil, focused: false, tabs: [], style: nil)
         return rect if rect.width < 2 || rect.height < 2
 
-        style = focused ? :focus : :border
+        title_style = style || :title
+        style ||= focused ? :focus : :border
         right = rect.x + rect.width - 1
         canvas.write(rect.x, rect.y, "╭#{"─" * (rect.width - 2)}╮", style)
         (rect.height - 2).times do |i|
@@ -21,7 +24,7 @@ module R2UI
         x = rect.x + 2
         max = right - 1
         if title
-          canvas.write(x, rect.y, " #{title} ", :title, max: max - x)
+          canvas.write(x, rect.y, " #{title} ", title_style, max: max - x)
           x += title.length + 3
         end
         tabs.each do |label, active|

data/lib/r2ui/widgets/glyphs.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module R2UI
+  module Widgets
+    # Dense glyphs for charts and colour helpers. Pure functions returning Strings.
+    module Glyphs
+      BLANK = 0x2800
+      # Braille dot bits per column, from the bottom dot up.
+      LEFT = [0x40, 0x04, 0x02, 0x01].freeze
+      RIGHT = [0x80, 0x20, 0x10, 0x08].freeze
+      # The bits of the bottom `n` dots (n = 0..4) per column, and every braille cell by its bits.
+      LEFT_SUMS = (0..4).map { |n| LEFT.first(n).sum }.freeze
+      RIGHT_SUMS = (0..4).map { |n| RIGHT.first(n).sum }.freeze
+      BRAILLE = Array.new(256) { |bits| (BLANK + bits).chr(Encoding::UTF_8).freeze }.freeze
+      PARTIAL = %w[▏ ▎ ▍ ▌ ▋ ▊ ▉].freeze
+      HEAT = ["#5FAF5F", "#E5A50A", "#E5484D"].freeze
+      HEAT_STEPS = 64
+
+      # stops (frozen copy) => the 65 SGRs of `heat`, one per step; HEAT's table is kept apart so
+      # the default needs no hash lookup. Reads take no lock; a miss builds the table outside it.
+      @heat_tables = {}
+      @heat_default = nil
+      # hex => "38;2;r;g;b" / "48;2;r;g;b" (frozen), bounded.
+      @fg_cache = {}
+      @bg_cache = {}
+      SGR_CACHE_LIMIT = 4096
+      HEAT_CACHE_LIMIT = 64
+
+      class << self
+        # A 24-bit foreground SGR for `fraction` (0..1) across the colour `stops`.
+        def heat(fraction, stops: HEAT)
+          step = (fraction.to_f.clamp(0.0, 1.0) * HEAT_STEPS).round
+          table = stops.equal?(HEAT) ? (@heat_default ||= heat_table(HEAT)) : @heat_tables[stops]
+          table ||= begin
+            @heat_tables.clear if @heat_tables.size >= HEAT_CACHE_LIMIT
+            @heat_tables[stops.map { |s| s.dup.freeze }.freeze] = heat_table(stops)
+          end
+          table[step]
+        end
+
+        def fg(hex) = @fg_cache[hex] || remember(@fg_cache, hex, "38;2;#{Motion.rgb(hex).join(";")}")
+
+        def bg(hex) = @bg_cache[hex] || remember(@bg_cache, hex, "48;2;#{Motion.rgb(hex).join(";")}")
+
+        private
+
+        # Dots (0..4) a braille_line sample fills.
+        def line_level(value, top, baseline)
+          if value <= 0 then baseline ? 1 : 0
+          else ((value / top) * 4).round.clamp(1, 4)
+          end
+        end
+
+        def heat_table(stops)
+          Array.new(HEAT_STEPS + 1) { |step| fg(gradient(stops, step / HEAT_STEPS.to_f)) }.freeze
+        end
+
+        def remember(cache, key, value)
+          cache.clear if cache.size >= SGR_CACHE_LIMIT
+          cache[key] = value.freeze
+        end
+      end
+
+      module_function
+
+      # One line of braille, exactly `width` cells, 2 samples per cell, newest at the right.
+      # Each sample fills 1..4 dots from the bottom; zero shows the bottom dot when `baseline`.
+      # (Walks `values` in place, without building a window: it is drawn for every row, every frame.)
+      def braille_line(values, width, max: nil, baseline: true)
+        return "" if width <= 0
+
+        start = [values.size - (width * 2), 0].max
+        top = max
+        unless top
+          (start...values.size).each do |i|
+            v = values[i].to_f
+            top = v if top.nil? || v > top
+          end
+        end
+        top = top.nil? || top <= 0 ? 1.0 : top.to_f
+        pad = (width * 2) - (values.size - start) # samples missing on the left
+        out = String.new(capacity: width * 3, encoding: Encoding::UTF_8)
+        width.times do |cell|
+          left = (cell * 2) - pad
+          right = left + 1
+          bits = 0
+          bits |= LEFT_SUMS[line_level(values[start + left].to_f, top, baseline)] if left >= 0
+          bits |= RIGHT_SUMS[line_level(values[start + right].to_f, top, baseline)] if right >= 0
+          out << BRAILLE[bits]
+        end
+        out
+      end
+
+      # A filled area chart: `height` lines of `width` braille cells, 4 * height levels tall,
+      # 2 samples per cell, newest at the right.
+      def braille_area(values, width, height, max: nil)
+        return Array.new([height, 0].max, "") if width <= 0
+        return [] if height <= 0
+
+        window = values.last(width * 2).map(&:to_f)
+        top = scale(window, max)
+        total = height * 4
+        levels = window.map { |v| v <= 0 ? 0 : ((v / top) * total).round.clamp(1, total) }
+        Array.new(height) do |row|
+          from_bottom = height - 1 - row
+          cells(levels, width) { |level, dots| dots.first((level - (from_bottom * 4)).clamp(0, 4)).sum }
+        end
+      end
+
+      # A horizontal bar exactly `width` chars: full blocks, one eighth-precision partial, spaces.
+      def bar(fraction, width)
+        return "" if width <= 0
+
+        eighths = (fraction.to_f.clamp(0.0, 1.0) * width * 8).round
+        full, rest = eighths.divmod(8)
+        text = "█" * full
+        text += PARTIAL[rest - 1] if rest.positive?
+        text.ljust(width)[0, width]
+      end
+
+      def paint(text, sgr) = sgr ? "\e[#{sgr}m#{text}\e[0m" : text
+
+      def gradient(stops, t)
+        return stops.first if stops.size == 1
+
+        pos = t * (stops.size - 1)
+        i = [pos.floor, stops.size - 2].min
+        Motion.mix_hex(stops[i], stops[i + 1], pos - i)
+      end
+
+      def scale(window, max)
+        top = max || window.max
+        top.nil? || top <= 0 ? 1.0 : top.to_f
+      end
+
+      # Right-aligns the levels into `width` cells (2 per cell, blank padding) and builds each cell
+      # from the dots the block picks for each half.
+      def cells(levels, width)
+        padded = Array.new((width * 2) - levels.size) + levels
+        padded.each_slice(2).map do |left, right|
+          bits = 0
+          bits |= yield(left, LEFT) if left
+          bits |= yield(right, RIGHT) if right
+          (BLANK + bits).chr(Encoding::UTF_8)
+        end.join
+      end
+    end
+  end
+end

data/lib/r2ui/widgets/table.rb

@@ -3,38 +3,83 @@
 module R2UI
   module Widgets
     # The index table: header, sort marker, grouped/tree labels, inline sparklines, selection.
+    # With a `motion`, a 1-cell gutter on the left marks lines that moved (▴/▾) or are new (•).
     class Table
       SPARK_WIDTH = 10
+      BRAILLE_WIDTH = 5
       MIN_TEXT = 8
-
-      # `spark` is called with (line, column) and returns that line's recent values.
-      def initialize(resource, lines, state:, focused:, label_key: nil, spark: nil)
+      MARKS = { up: "▴", down: "▾", new: "•" }.freeze
+      MARK_SECONDS = { up: 1.5, down: 1.5, new: 2.0 }.freeze
+      MARK_FROM = "#D97757"
+      MARK_TO = "#555555"
+
+      # `spark` is called with (line, column) and returns that line's recent values. `motion` (an
+      # R2UI::Motion) turns on the gutter marks; `motion_key` tells tables sharing a Motion apart.
+      # `columns` (Column objects) draws only those, in that order; default all of the resource's.
+      def initialize(resource, lines, state:, focused:, label_key: nil, spark: nil, motion: nil, motion_key: nil,
+                     columns: nil)
         @resource = resource
+        @columns = columns || resource.columns
         @lines = lines
         @state = state
         @focused = focused
         @spark = spark
-        @label_key = label_key || resource.columns.find { |c| !c.numeric? && c.format != :id }&.key
+        @motion = motion
+        @motion_key = motion_key || state.object_id
+        label_key = nil if label_key && @columns.none? { |c| c.key == label_key }
+        @label_key = label_key || @columns.find { |c| !c.numeric? && c.format != :id }&.key
       end
 
       def draw(canvas, rect)
         return if rect.empty?
 
-        layout = widths(rect.width)
-        draw_header(canvas, rect, layout)
+        gutter = @motion ? 1 : 0
+        marks = @motion ? gutter_marks : {}
+        cols = rect.with(x: rect.x + gutter, width: rect.width - gutter)
+        layout = widths(cols.width)
+        draw_header(canvas, cols, layout)
         body = rect.with(y: rect.y + 1, height: rect.height - 1)
         @state.scroll_to_selection(body.height, @lines.size)
-        @lines.drop(@state.offset).first(body.height).each_with_index do |line, i|
-          index = @state.offset + i
+        offset = @state.offset
+        last = [@lines.size, offset + body.height].min
+        (offset...last).each do |index|
+          line = @lines[index]
+          i = index - offset
           selected = @focused && index == @state.selected
           canvas.fill(body.with(y: body.y + i, height: 1), " ", :selected) if selected
-          draw_line(canvas, rect.x, body.y + i, line, layout, selected)
+          draw_line(canvas, cols.x, body.y + i, line, layout, selected)
+          mark = marks[line.id]
+          canvas.write(rect.x, body.y + i, mark[0], mark[1]) if mark
         end
         draw_footer(canvas, rect) if @lines.size > body.height
       end
 
       private
 
+      # {line id => [glyph, sgr]} for lines whose move/new mark is still fading. Keeps the motion
+      # active while any mark shows.
+      def gutter_marks
+        @state.track_positions(@lines)
+        hold = 0.0
+        marks = {}
+        @lines.each_with_index do |line, i|
+          elapsed = @motion.age([:r2ui_table, @motion_key, line.id], i)
+          kind = @state.marks[line.id]
+          next unless kind
+
+          left = MARK_SECONDS[kind] - elapsed
+          if left <= 0 || !@motion.enabled
+            @state.marks.delete(line.id)
+            next
+          end
+          hold = left if left > hold
+          colour = Motion.mix_hex(MARK_FROM, MARK_TO, elapsed / MARK_SECONDS[kind])
+          marks[line.id] = [MARKS[kind], Glyphs.fg(colour)]
+        end
+        @motion.hold(hold) if hold.positive?
+        marks
+      end
+
       def draw_header(canvas, rect, layout)
         sort_key, sort_dir = @state.sort
         x = rect.x
@@ -48,35 +93,70 @@ module R2UI
 
       def draw_line(canvas, x, y, line, layout, selected)
         layout.each do |col, w|
-          text, style = cell(line, col, w)
-          canvas.write(x, y, text, selected ? :selected : style, max: w)
+          draw_cell(canvas, x, y, line, col, w, selected)
           x += w + 1
         end
       end
 
-      def cell(line, col, width)
+      # Draws one cell: one segment, or the sparkline, a space and the number for spark columns.
+      def draw_cell(canvas, x, y, line, col, width, selected)
+        stop = x + width
         if col.key == @label_key && (line.label || line.depth.positive? || line.expandable?)
           prefix, body, suffix = label_parts(line, col)
           body = fit(body, [width - prefix.length - suffix.length, 1].max, Format.truncate_from(col.format))
-          return [fit("#{prefix}#{body}#{suffix}", width, :right), line.label ? :bold : :plain]
+          text = fit("#{prefix}#{body}#{suffix}", width, :right)
+          return segment(canvas, x, stop, y, text, selected ? :selected : (line.label ? :bold : :plain))
         end
 
         value = line.values[col.key]
         value = "×#{line.count}" if col.aggregate == :count && line.label
         text = value.is_a?(String) && col.aggregate == :count ? value : col.render(value)
-        if col.sparkline && @spark
-          text_w = width - SPARK_WIDTH - 1
-          text = "#{Sparkline.line(@spark.call(line, col), SPARK_WIDTH).rjust(SPARK_WIDTH)} #{align(text, text_w, col.align)}"
-          return [text, :plain]
+        return draw_spark(canvas, x, stop, y, line, col, width, value, text, selected) if col.sparkline && @spark
+
+        text = align(fit(text, width, Format.truncate_from(col.format)), width, col.align)
+        style = custom_style(col, value, line) || style_for(col, value)
+        segment(canvas, x, stop, y, text, selected ? :selected : style)
+      end
+
+      # Writes `text` at `at` if the cell (ending before `stop`) has room left; the next x, or nil.
+      def segment(canvas, at, stop, y, text, style)
+        left = stop - at
+        return if left <= 0
+
+        canvas.write(at, y, text, style, max: left)
+        at + text.length
+      end
+
+      # The sparkline and the number, each in its own style.
+      def draw_spark(canvas, x, stop, y, line, col, width, value, text, selected)
+        values = @spark.call(line, col)
+        spark_w = spark_width(col)
+        if col.sparkline == :braille
+          # Fewer than 2 samples have no shape yet: baseline dots only, never a full column.
+          chart = Glyphs.braille_line(values.size < 2 ? values.map { 0 } : values, spark_w, max: col.spark_max)
+          default = :accent
+        else
+          chart = Sparkline.line(values, spark_w, max: col.spark_max)
+          chart = chart.rjust(spark_w) if chart.length < spark_w
+          default = :plain
         end
-        [align(fit(text, width, Format.truncate_from(col.format)), width, col.align), style_for(col, value)]
+        spark_style = col.spark_style.respond_to?(:call) ? col.spark_style.call(values, line) : col.spark_style
+        text = align(text, width - spark_w - 1, col.align)
+        text_style = custom_style(col, value, line) || :plain
+        at = segment(canvas, x, stop, y, chart, selected ? :selected : (spark_style || default))
+        at &&= segment(canvas, at, stop, y, " ", selected ? :selected : :plain)
+        segment(canvas, at, stop, y, text, selected ? :selected : text_style) if at
       end
 
+      def custom_style(col, value, line) = col.style&.call(value, line)
+
+      def spark_width(col) = col.spark_width || (col.sparkline == :braille ? BRAILLE_WIDTH : SPARK_WIDTH)
+
       # [indent and tree marker, the value (truncated to fit), count suffix]
       def label_parts(line, col)
         if line.label
           body = Format.call(col.format, line.label)
-          counted = @resource.columns.any? { |c| c.aggregate == :count }
+          counted = @columns.any? { |c| c.aggregate == :count }
           ["", body.empty? ? "(none)" : body, counted ? "" : " ×#{line.count}"]
         else
           marker = if line.expandable? then line.collapsed ? "▸ " : "▾ " else "  " end
@@ -93,13 +173,13 @@ module R2UI
         end
       end
 
-      # Fixed-width columns get their width; text columns share the rest. Drops columns that don't fit.
+      # Fixed-width columns get their width; text columns share the rest. Drops columns that don't
+      # fit: the lowest priority first, the last declared among equals.
       def widths(total)
-        cols = @resource.columns
-        fixed = cols.to_h do |c|
+        fixed = @columns.to_h do |c|
           w = c.width || Format.default_width(c.format)
           w &&= [w, c.label.length + 1].max
-          w += SPARK_WIDTH + 1 if w && c.sparkline
+          w += spark_width(c) + 1 if w && c.sparkline
           [c, w]
         end
         loop do
@@ -109,7 +189,7 @@ module R2UI
           break if flexible.zero? ? spare >= 0 : spare >= flexible * MIN_TEXT
           break if fixed.size == 1
 
-          fixed.delete(fixed.keys.last)
+          fixed.delete(fixed.keys.reverse.min_by { |c| c.priority || 0 })
         end
         flexible = fixed.count { |_, w| w.nil? }
         spare = total - fixed.values.compact.sum - (fixed.size - 1)
@@ -128,7 +208,11 @@ module R2UI
         from == :left ? "…#{text[-(width - 1)..]}" : "#{text[0, width - 1]}…"
       end
 
-      def align(text, width, side) = side == :right ? text.rjust(width) : text.ljust(width)
+      def align(text, width, side)
+        return text if text.length >= width
+
+        side == :right ? text.rjust(width) : text.ljust(width)
+      end
     end
   end
 end

data/lib/r2ui.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+# r2ui runs on its own pure-Ruby Bubbletea, loaded by path. This doesn't touch $LOAD_PATH:
+# `require "bubbletea"` still means whatever it meant; `require "r2ui/drop_in"` opts into r2ui's.
+require_relative "r2ui/compat/bubbletea"
+
 require_relative "r2ui/version"
 require_relative "r2ui/value"
 require_relative "r2ui/format"
@@ -11,6 +15,8 @@ require_relative "r2ui/registry"
 require_relative "r2ui/search"
 require_relative "r2ui/query"
 require_relative "r2ui/canvas"
+require_relative "r2ui/motion"
+require_relative "r2ui/widgets/glyphs"
 require_relative "r2ui/widgets/box"
 require_relative "r2ui/widgets/table"
 require_relative "r2ui/widgets/gauge"
@@ -20,7 +26,9 @@ require_relative "r2ui/panel_state"
 require_relative "r2ui/feed"
 require_relative "r2ui/renderer"
 require_relative "r2ui/keys"
-require_relative "r2ui/terminal"
+require_relative "r2ui/context"
+require_relative "r2ui/extension"
+require_relative "r2ui/component"
 require_relative "r2ui/app"
 
 # R2UI: declare terminal dashboards the way ActiveAdmin declares admin pages.
@@ -51,3 +59,6 @@ module R2UI
     def reset! = @registry = Registry.new
   end
 end
+
+# Capabilities: one self-registering file each (docs/dsl.md).
+R2UI::Extensions.load_all