tuile 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdf4dfc626b692fdeeb9dabbcd08fe94a74045ae24340b24074d601856b87bf8
-  data.tar.gz: a38a8d8f04c53341a1bf6adfbf551209fc8e917f6957076bcf291bb4c2f7837f
+  metadata.gz: ffd96aaba12d84ccc9f3417db01f75b3b91f0f89cd7358864fdfd1b0dcaa778b
+  data.tar.gz: fdbc08c48e4b908ee8b3cebc7bf949e88cf6cc2a1bb58260b53c8612bc6060cc
 SHA512:
-  metadata.gz: ee942fd7bd9c9c35212f20ae78d043df5c2fe5c9dfb3e3ca5b1e3acd98a1dfd9d7708c5a8d481f49b690c50c56b8d9f81f771adb668937ae0b45e5244f84fd71
-  data.tar.gz: 2735212649ff50b35814125ce0d91043f91bba7e4a8c4aa4a35b730708f66473536e2c240c70f45197bd89ef36154694119c8dfa0c70527f28e8c6520419dcd5
+  metadata.gz: bc286448b580b3978de8652088f491e989618e0fb63c6063035f8f284ae8b57a2192a3fea7913cb26cfee1147e1bc7108e2288da53a1676acf874a069c8c0249
+  data.tar.gz: 20aa07e2b6b53ed16e55211401277b1d97a87bc47e4fda07d7d0f8d642a36b3238ec46495262541f6b5e164d6fcde7bcf5b574a7cd22fc41f38eec9724a3e76c

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## [Unreleased]
 
+## [0.7.0] - 2026-06-09
+
+- Lower the Ruby floor to 3.3 (was 3.4): replaced the `it` implicit block parameter (3.4+) with `_1` throughout, and added 3.3 to the CI matrix.
+- Fix `Component::Popup#close` raising `Tuile::Error` when the popup was not open — it is now the documented no-op (also covers calling `close` twice). `Screen#remove_popup` honors its "does nothing if not open" contract by guarding on `has_popup?`; `ScreenPane#remove_popup` keeps its strict internal assertion.
+
 ## [0.6.0] - 2026-06-07
 
 - Add `Tuile::Theme` — semantic color tokens for the accents built-in components paint (the list-cursor/focused-input highlight `active_bg_color`, the inactive input well `input_bg_color`, the active window border `active_border_color`, the status-bar `hint_color`), with `DARK`/`LIGHT` presets and rendering helpers (`#active_bg`, `#active_border`, `#input_bg`, `#hint`). The current theme lives at `Screen#theme`; assigning restyles the whole UI in a single invalidate-everything pass. Everything that isn't an accent keeps inheriting the terminal's own default fg/bg.

data/README.md

@@ -47,7 +47,7 @@ Or pin to git directly:
 gem "tuile", git: "https://github.com/mvysny/tuile.git"
 ```
 
-Tuile requires Ruby 3.4+.
+Tuile requires Ruby 3.3+.
 
 API documentation: <https://rubydoc.info/gems/tuile>.
 

data/examples/sampler.rb

@@ -39,7 +39,7 @@ module SamplerExample
     def initialize
       super()
       @entry_list = build_entry_list
-      @left_window = Tuile::Component::Window.new("Components").tap { it.content = @entry_list }
+      @left_window = Tuile::Component::Window.new("Components").tap { _1.content = @entry_list }
       @right_window = Tuile::Component::Window.new
       add(@left_window)
       add(@right_window)
@@ -202,9 +202,9 @@ module SamplerExample
 
     def build_layout
       left = Tuile::Component::Window.new("Left")
-      left.content = Tuile::Component::Label.new.tap { it.text = "Nested left window." }
+      left.content = Tuile::Component::Label.new.tap { _1.text = "Nested left window." }
       right = Tuile::Component::Window.new("Right")
-      right.content = Tuile::Component::Label.new.tap { it.text = "Nested right window." }
+      right.content = Tuile::Component::Label.new.tap { _1.text = "Nested right window." }
       panel(left, right) do |r|
         half = r.width / 2
         left.rect = Tuile::Rect.new(r.left, r.top, half, r.height)

data/lib/tuile/component/layout.rb

@@ -34,7 +34,7 @@ module Tuile
       # @return [void]
       def add(child)
         if child.is_a? Enumerable
-          child.each { add(it) }
+          child.each { add(_1) }
         else
           raise TypeError, "expected Component, got #{child.inspect}" unless child.is_a? Component
           raise ArgumentError, "#{child} already has a parent #{child.parent}" unless child.parent.nil?

data/lib/tuile/component/list.rb

@@ -23,6 +23,7 @@ module Tuile
         @padded_lines = []
         @blank_padded = StyledString::EMPTY
         @auto_scroll = false
+        @follow = true
         @top_line = 0
         @cursor = Cursor::None.new
         @scrollbar_visibility = :gone
@@ -50,9 +51,18 @@ module Tuile
       attr_accessor :on_cursor_changed
 
       # @return [Boolean] if true and a line is added or new content is set,
-      #   auto-scrolls to the bottom.
+      #   auto-scrolls to the bottom — but only while the viewport is already
+      #   pinned to the last line (see {#following?}). Scroll up to read older
+      #   content and appends stop yanking you back down; scroll back to the
+      #   bottom and tailing resumes.
       attr_reader :auto_scroll
 
+      # @return [Boolean] whether {#auto_scroll} is currently tailing. True
+      #   while the viewport sits at the last line; flips to false the moment
+      #   the user scrolls up, and back to true once they scroll to the bottom
+      #   again. Only consulted when {#auto_scroll} is enabled.
+      def following? = @follow
+
       # @return [Integer] top line of the viewport. 0 or positive.
       attr_reader :top_line
 
@@ -87,10 +97,12 @@ module Tuile
         invalidate
       end
 
-      # Sets the new auto_scroll. If true, immediately scrolls to the bottom.
+      # Sets the new auto_scroll. If true, re-engages tailing and immediately
+      # scrolls to the bottom.
       # @param new_auto_scroll [Boolean]
       def auto_scroll=(new_auto_scroll)
         @auto_scroll = new_auto_scroll
+        @follow = true if new_auto_scroll
         update_top_line_if_auto_scroll
       end
 
@@ -113,6 +125,7 @@ module Tuile
         return unless @top_line != new_top_line
 
         @top_line = new_top_line
+        @follow = at_bottom?
         invalidate
       end
 
@@ -163,6 +176,7 @@ module Tuile
       # @return [void]
       def add_line(line)
         raise ArgumentError, "line is nil" if line.nil?
+
         add_lines [line]
       end
 
@@ -417,7 +431,7 @@ module Tuile
           # @param position [Integer] initial position.
           def initialize(positions, position: positions[0])
             @positions = positions.sort
-            position = @positions[@positions.rindex { it < position } || 0] unless @positions.include?(position)
+            position = @positions[@positions.rindex { _1 < position } || 0] unless @positions.include?(position)
             super(position: position)
           end
 
@@ -427,7 +441,7 @@ module Tuile
           # @return [Boolean]
           def handle_mouse(line, event, _line_count)
             if event.button == :left
-              prev_pos = @positions.reverse_each.find { it <= line }
+              prev_pos = @positions.reverse_each.find { _1 <= line }
               return go_to_first if prev_pos.nil?
 
               go(prev_pos)
@@ -439,7 +453,7 @@ module Tuile
           # @param line_count [Integer]
           # @return [Array<Integer>]
           def candidate_positions(line_count)
-            @positions.select { it < line_count }
+            @positions.select { _1 < line_count }
           end
 
           # @param _line_count [Integer]
@@ -454,7 +468,7 @@ module Tuile
           # @param line_count [Integer]
           # @return [Boolean]
           def go_down_by(lines, line_count)
-            next_pos = @positions.find { it >= @position + lines }
+            next_pos = @positions.find { _1 >= @position + lines }
             return go_to_last(line_count) if next_pos.nil?
 
             go(next_pos)
@@ -463,7 +477,7 @@ module Tuile
           # @param lines [Integer]
           # @return [Boolean]
           def go_up_by(lines)
-            prev_pos = @positions.reverse_each.find { it <= @position - lines }
+            prev_pos = @positions.reverse_each.find { _1 <= @position - lines }
             return go_to_first if prev_pos.nil?
 
             go(prev_pos)
@@ -622,16 +636,16 @@ module Tuile
       def order_for_search(candidates, current, include_current:, reverse:)
         if reverse
           before, after = if include_current
-                            [candidates.select { it <= current }, candidates.select { it > current }]
+                            [candidates.select { _1 <= current }, candidates.select { _1 > current }]
                           else
-                            [candidates.select { it < current }, candidates.select { it >= current }]
+                            [candidates.select { _1 < current }, candidates.select { _1 >= current }]
                           end
           before.reverse + after.reverse
         else
           after, before = if include_current
-                            [candidates.select { it >= current }, candidates.select { it < current }]
+                            [candidates.select { _1 >= current }, candidates.select { _1 < current }]
                           else
-                            [candidates.select { it > current }, candidates.select { it <= current }]
+                            [candidates.select { _1 > current }, candidates.select { _1 <= current }]
                           end
           after + before
         end
@@ -653,6 +667,10 @@ module Tuile
       # @return [Integer] the max value of {#top_line}.
       def top_line_max = (@lines.size - rect.height).clamp(0, nil)
 
+      # @return [Boolean] whether the viewport is pinned to the last line.
+      #   Drives {#following?}: re-evaluated on every {#top_line=}.
+      def at_bottom? = @top_line == top_line_max
+
       # @return [Integer] the number of visible lines.
       def viewport_lines = rect.height
 
@@ -675,9 +693,14 @@ module Tuile
       # which would leave `top_line` past the last item once a real rect
       # arrives. {#on_width_changed} re-runs this hook when the rect grows so
       # the snap-to-bottom intent is preserved.
+      #
+      # Gated on {#following?}: once the user scrolls up off the bottom the
+      # cursor snap and viewport pin are both skipped, so reading older
+      # content is not interrupted by incoming lines. {#top_line=} re-arms
+      # `@follow` when the viewport returns to the bottom.
       # @return [void]
       def update_top_line_if_auto_scroll
-        return unless @auto_scroll
+        return unless @auto_scroll && @follow
         return if rect.empty?
 
         notify_cursor_changed if @cursor.go_to_last(@lines.size)

data/lib/tuile/component/log_window.rb

@@ -28,6 +28,7 @@ module Tuile
       # @return [void]
       def log(string)
         return if string.nil?
+
         screen.event_queue.submit do
           content.add_line(string)
         end

data/lib/tuile/component/picker_window.rb

@@ -34,10 +34,10 @@ module Tuile
         raise ArgumentError, "options must not be empty" if options.empty?
 
         super(caption)
-        @options = options.map { Option.new(it[0], it[1]) }
+        @options = options.map { Option.new(_1[0], _1[1]) }
         @block = block
         list = Component::List.new
-        list.lines = @options.map { "#{it.key} #{screen.theme.hint(it.caption)}" }
+        list.lines = @options.map { "#{_1.key} #{screen.theme.hint(_1.caption)}" }
         list.cursor = Component::List::Cursor.new
         list.on_item_chosen = ->(index, _line) { select_option(@options[index].key) }
         self.content = list
@@ -55,7 +55,7 @@ module Tuile
       def handle_key(key)
         return true if super
 
-        if @options.any? { it.key == key }
+        if @options.any? { _1.key == key }
           select_option(key)
           true
         else
@@ -65,7 +65,7 @@ module Tuile
 
       # @return [String]
       def keyboard_hint
-        @options.map { "#{it.key} #{screen.theme.hint(it.caption)}" }.join("  ")
+        @options.map { "#{_1.key} #{screen.theme.hint(_1.caption)}" }.join("  ")
       end
 
       # Opens a picker as a popup. Picking an option fires `block`, then

data/lib/tuile/component/popup.rb

@@ -35,6 +35,21 @@ module Tuile
 
       def focusable? = true
 
+      # Reassigns the popup's rect, escalating to a full scene repaint when an
+      # open popup shrinks or moves so its new rect no longer covers the cells
+      # it previously painted. A popup overdraws the scene without clipping and
+      # nothing clears underneath it, so {Screen#repaint}'s popup-only fast path
+      # would repaint into the new rect and leave the vacated cells showing
+      # stale content. When the new rect fully covers the old one (the popup
+      # only grew), the fast path is correct and the full repaint is skipped.
+      # @param new_rect [Rect]
+      # @return [void]
+      def rect=(new_rect)
+        old_rect = rect
+        super
+        screen.needs_full_repaint if open? && !new_rect.contains_rect?(old_rect)
+      end
+
       # Mounts this popup on the {Screen}. Recomputes the popup's size from
       # the current content first, so reopening a popup whose content has
       # grown or shrunk while closed picks up the new size.
@@ -125,12 +140,18 @@ module Tuile
 
       # Recompute width/height from {#content}'s natural size and recenter
       # if currently open. Called whenever content is (re)assigned.
+      #
+      # Computes the final (centered) rect and assigns it in one step rather
+      # than positioning at the origin and then centering: the intermediate
+      # origin rect rarely covers the previous one, which would make
+      # {#rect=}'s shrink/move detection fire a full repaint on every resize.
       # @return [void]
       def update_rect
         size = @content.content_size.clamp_height(max_height)
         size = size.clamp(Size.new(screen.size.width * 4 / 5, screen.size.height * 4 / 5))
-        self.rect = Rect.new(0, 0, size.width, size.height)
-        center if open?
+        r = Rect.new(0, 0, size.width, size.height)
+        r = r.centered(screen.size) if open?
+        self.rect = r
       end
     end
   end

data/lib/tuile/component/text_view.rb

@@ -53,6 +53,7 @@ module Tuile
         @blank_line = StyledString::EMPTY
         @top_line = 0
         @auto_scroll = false
+        @follow = true
         @scrollbar_visibility = :gone
         # The view always has at least one region — an implicit default. It
         # owns whatever hard lines exist that no later region claims. App
@@ -80,9 +81,18 @@ module Tuile
       attr_reader :scrollbar_visibility
 
       # @return [Boolean] if true, mutating the text scrolls the viewport so
-      #   the last line stays in view. Default `false`.
+      #   the last line stays in view — but only while the viewport is already
+      #   pinned to the last line (see {#following?}). Scroll up to read older
+      #   content and appends stop yanking you back down; scroll back to the
+      #   bottom and tailing resumes. Default `false`.
       attr_reader :auto_scroll
 
+      # @return [Boolean] whether {#auto_scroll} is currently tailing. True
+      #   while the viewport sits at the last line; flips to false the moment
+      #   the user scrolls up, and back to true once they scroll to the bottom
+      #   again. Only consulted when {#auto_scroll} is enabled.
+      def following? = @follow
+
       # Replaces the text. Embedded `\n` characters become hard line breaks.
       # A `String` is parsed via {StyledString.parse} (so embedded ANSI is
       # honored); a `StyledString` is used as-is; `nil` is coerced to an
@@ -347,6 +357,7 @@ module Tuile
         return if @top_line == new_top_line
 
         @top_line = new_top_line
+        @follow = at_bottom?
         invalidate
       end
 
@@ -361,11 +372,13 @@ module Tuile
         invalidate
       end
 
-      # Sets `auto_scroll`. If true, immediately scrolls to the bottom.
+      # Sets `auto_scroll`. If true, re-engages tailing and immediately
+      # scrolls to the bottom.
       # @param value [Boolean]
       # @return [void]
       def auto_scroll=(value)
         @auto_scroll = value ? true : false
+        @follow = true if @auto_scroll
         update_top_line_if_auto_scroll
       end
 
@@ -848,14 +861,22 @@ module Tuile
         self.top_line = clamped unless @top_line == clamped
       end
 
+      # Gated on {#following?}: once the user scrolls up off the bottom the
+      # viewport pin is skipped, so reading older content is not interrupted
+      # by incoming lines. {#top_line=} re-arms `@follow` when the viewport
+      # returns to the bottom.
       # @return [void]
       def update_top_line_if_auto_scroll
-        return unless @auto_scroll
+        return unless @auto_scroll && @follow
 
         target = (@physical_lines.size - viewport_lines).clamp(0, nil)
         self.top_line = target if @top_line != target
       end
 
+      # @return [Boolean] whether the viewport is pinned to the last line.
+      #   Drives {#following?}: re-evaluated on every {#top_line=}.
+      def at_bottom? = @top_line == top_line_max
+
       # @return [Boolean]
       def scrollbar_visible?
         return false if rect.empty?

data/lib/tuile/component.rb

@@ -190,7 +190,7 @@ module Tuile
     # @return [void]
     def on_tree(&block)
       block.call(self)
-      children.each { it.on_tree(&block) }
+      children.each { _1.on_tree(&block) }
     end
 
     # Called when the component receives focus.

data/lib/tuile/keys.rb

@@ -156,9 +156,7 @@ module Tuile
       # sequence is fixed-length: 3 bytes after `\e[M`), drain the remainder
       # with a blocking read so the parser downstream sees a complete event
       # instead of leaking tail bytes as keypresses.
-      if char.start_with?("\e[M") && char.bytesize < 6
-        char += $stdin.read(6 - char.bytesize)
-      end
+      char += $stdin.read(6 - char.bytesize) if char.start_with?("\e[M") && char.bytesize < 6
 
       # Private-mode CSI reports (`\e[?` params… final byte in 0x40..0x7E)
       # can outgrow the 5-byte gulp above — the mode-2031 color-scheme
@@ -166,9 +164,7 @@ module Tuile
       # bytes after the `\e`. Drain to the final byte with blocking 1-byte
       # reads so the tail doesn't surface as phantom keypresses. Keyboard
       # sequences never start with `\e[?`, so this can't eat a regular key.
-      if char.start_with?("\e[?")
-        char += $stdin.read(1) until char.match?(/[\x40-\x7e]\z/)
-      end
+      char += $stdin.read(1) while char.start_with?("\e[?") && !char.match?(/[\x40-\x7e]\z/)
 
       char
     end

data/lib/tuile/rect.rb

@@ -49,6 +49,18 @@ module Tuile
       point.x >= left && point.x < left + width && point.y >= top && point.y < top + height
     end
 
+    # @param other [Rect] another rectangle.
+    # @return [Boolean] true if `other` lies entirely within this rectangle.
+    #   Uses the same half-open edges as {#contains?} (right/bottom exclusive).
+    #   An {#empty? empty} `other` covers no cells, so it is trivially contained.
+    def contains_rect?(other)
+      return true if other.empty?
+
+      other.left >= left && other.top >= top &&
+        other.left + other.width <= left + width &&
+        other.top + other.height <= top + height
+    end
+
     # @return [Size]
     def size = Size.new(width, height)
 

data/lib/tuile/screen.rb

@@ -206,7 +206,7 @@ module Tuile
       check_locked
       if focused.nil?
         @focused = nil
-        @pane.on_tree { it.active = false }
+        @pane.on_tree { _1.active = false }
       else
         raise Tuile::Error, "#{focused} is not attached to this screen" if focused.root != @pane
 
@@ -217,7 +217,7 @@ module Tuile
           active << cursor
           cursor = cursor.parent
         end
-        @pane.on_tree { it.active = active.include?(it) }
+        @pane.on_tree { _1.active = active.include?(_1) }
         @focused.on_focus
       end
       refresh_status_bar
@@ -370,9 +370,7 @@ module Tuile
         raise ArgumentError,
               "#{key == Keys::TAB ? "TAB" : "SHIFT_TAB"} is reserved for focus navigation"
       end
-      unless hint.nil? || hint.is_a?(String)
-        raise ArgumentError, "hint must be a String or nil, got #{hint.inspect}"
-      end
+      raise ArgumentError, "hint must be a String or nil, got #{hint.inspect}" unless hint.nil? || hint.is_a?(String)
 
       @global_shortcuts[key] = Shortcut.new(block: block, over_popups: over_popups, hint: hint)
       refresh_status_bar
@@ -391,7 +389,7 @@ module Tuile
     def active_window
       check_locked
       result = nil
-      @pane.content&.on_tree { result = it if it.is_a?(Component::Window) && it.active? }
+      @pane.content&.on_tree { result = _1 if _1.is_a?(Component::Window) && _1.active? }
       result
     end
 
@@ -404,10 +402,25 @@ module Tuile
     # @return [void]
     def remove_popup(window)
       check_locked
+      return unless @pane.has_popup?(window)
+
       @pane.remove_popup(window)
       needs_full_repaint
     end
 
+    # Invalidates the entire attached tree, forcing every component to repaint
+    # on the next cycle. Needed whenever something overdraws the scene without
+    # clipping and then exposes what was underneath — a closing popup
+    # ({#remove_popup}), or a popup that shrinks or moves so its new {#rect} no
+    # longer covers the cells it previously painted ({Component::Popup#rect=}).
+    # The popup-only fast path in {#repaint} can't clear those vacated cells on
+    # its own, so we accept the cost of a full repaint.
+    # @api private
+    # @return [void]
+    def needs_full_repaint
+      @pane&.on_tree { invalidate _1 }
+    end
+
     # Internal — use {Component::Popup#open?} instead.
     # @api private
     # @param window [Component::Popup]
@@ -495,8 +508,8 @@ module Tuile
           # grandchild (depth 3) sorts after a popup's content (depth 2) and
           # overdraws it.
           popup_tree = Set.new
-          popups.each { |p| p.on_tree { popup_tree << it } }
-          tiled, popup_invalidated = @invalidated.to_a.partition { !popup_tree.include?(it) }
+          popups.each { |p| p.on_tree { popup_tree << _1 } }
+          tiled, popup_invalidated = @invalidated.to_a.partition { !popup_tree.include?(_1) }
 
           # Within the tiled tree, paint parents before children.
           tiled.sort_by!(&:depth)
@@ -600,7 +613,7 @@ module Tuile
     # @return [Array<Component>]
     def collect_subtree(component)
       result = []
-      component.on_tree { result << it }
+      component.on_tree { result << _1 }
       result
     end
 
@@ -626,13 +639,6 @@ module Tuile
       repaint
     end
 
-    # Called after a popup is closed. Since a popup can cover any window,
-    # top-level component or other popups, we need to redraw everything.
-    # @return [void]
-    def needs_full_repaint
-      @pane&.on_tree { invalidate it }
-    end
-
     # A key has been pressed on the keyboard. Handle it, or forward to active
     # window.
     #

data/lib/tuile/screen_pane.rb

@@ -140,7 +140,7 @@ module Tuile
     # @param event [MouseEvent]
     # @return [void]
     def handle_mouse(event)
-      clicked = @popups.reverse_each.find { it.rect.contains?(event.point) }
+      clicked = @popups.reverse_each.find { _1.rect.contains?(event.point) }
       clicked = @content if clicked.nil? && @popups.empty?
       clicked&.handle_mouse(event)
     end

data/lib/tuile/styled_string.rb

@@ -3,7 +3,7 @@
 module Tuile
   # An immutable string-with-styling, modeled as a sequence of {Span}s where
   # each span carries a complete {Style} (`fg`, `bg`, `bold`, `italic`,
-  # `underline`). Spans are non-overlapping and fully tile the string — every
+  # `underline`, `strikethrough`). Spans are non-overlapping and fully tile the string — every
   # character has exactly one resolved style, no overlay layers to merge.
   #
   # Where this differs from threading SGR escapes through a plain `String`:
@@ -43,12 +43,21 @@ module Tuile
   #
   # ## Parser
   #
-  # {.parse} is strict by design: it recognizes only the SGR codes
+  # {.parse} is strict by default: it recognizes only the SGR codes
   # corresponding to {Style}'s supported attributes (fg/bg/bold/italic/
-  # underline). Anything else — unmodeled attributes (dim, blink, reverse,
-  # strike, conceal, double-underline, overline, ...), unknown SGR codes, or
+  # underline/strikethrough). Anything else — unmodeled attributes (dim, blink,
+  # reverse, conceal, double-underline, overline, ...), unknown SGR codes, or
   # non-SGR escapes (cursor moves, OSC) — raises {ParseError}. This keeps the
   # round-trip parse(to_ansi(x)) == x contract honest.
+  #
+  # Pass `lenient: true` to instead **discard** everything the parser can't
+  # model and keep going — recognized fg/bg/bold/italic/underline/strikethrough codes still
+  # apply, and any unmodeled SGR code, malformed extended color, non-SGR CSI
+  # (cursor moves, `\e[K`), OSC/DCS/string sequence, or stray escape is
+  # silently dropped. This is the mode for piping in colored output you don't
+  # control (e.g. `git --color` through a pager): "give me the colors, throw
+  # the rest away." It is lossy by design — `parse(x, lenient: true)` does not
+  # round-trip back to `x`.
   class StyledString
     # Raised by {.parse} on malformed or unsupported escape sequences.
     class ParseError < Error; end
@@ -69,16 +78,19 @@ module Tuile
     #   @return [Boolean]
     # @!attribute [r] underline
     #   @return [Boolean]
-    class Style < Data.define(:fg, :bg, :bold, :italic, :underline)
+    # @!attribute [r] strikethrough
+    #   @return [Boolean]
+    class Style < Data.define(:fg, :bg, :bold, :italic, :underline, :strikethrough)
       # @param fg [Color, Symbol, Integer, Array<Integer>, nil] coerced via {Color.coerce}.
       # @param bg [Color, Symbol, Integer, Array<Integer>, nil] coerced via {Color.coerce}.
       # @param bold [Boolean]
       # @param italic [Boolean]
       # @param underline [Boolean]
+      # @param strikethrough [Boolean]
       # @return [Style]
       # @raise [ArgumentError] when a color is not one of the accepted forms.
-      def self.new(fg: nil, bg: nil, bold: false, italic: false, underline: false)
-        super(fg: Color.coerce(fg), bg: Color.coerce(bg), bold:, italic:, underline:)
+      def self.new(fg: nil, bg: nil, bold: false, italic: false, underline: false, strikethrough: false)
+        super(fg: Color.coerce(fg), bg: Color.coerce(bg), bold:, italic:, underline:, strikethrough:)
       end
 
       # The style with no color and no attributes — what the terminal shows
@@ -117,8 +129,9 @@ module Tuile
     # @api private
     # Hand-rolled SGR parser. State machine over a {StringScanner}: plain
     # text accumulates into the current span; each `\e[...m` flushes the
-    # current span and updates the running {Style}. Anything outside the
-    # supported SGR alphabet raises {ParseError}.
+    # current span and updates the running {Style}. In strict mode anything
+    # outside the supported SGR alphabet raises {ParseError}; in lenient mode
+    # it is consumed and discarded (see {StyledString} "## Parser").
     class Parser
       # @return [Array<Symbol>]
       STANDARD_COLORS = Color::COLOR_SYMBOLS[0, 8].freeze
@@ -128,9 +141,20 @@ module Tuile
       BRIGHT_COLORS = Color::COLOR_SYMBOLS[8, 8].freeze
       private_constant :BRIGHT_COLORS
 
+      # ESC-introducers (the byte after `\e`) whose payload runs until a string
+      # terminator (ST `\e\\` or BEL): OSC `]`, DCS `P`, SOS `X`, PM `^`,
+      # APC `_`. In lenient mode the whole sequence — payload included — is
+      # swallowed so it never leaks into span text.
+      # @return [Array<String>]
+      STRING_INTRODUCERS = %w(] P X ^ _).freeze
+      private_constant :STRING_INTRODUCERS
+
       # @param input [String]
-      def initialize(input)
+      # @param lenient [Boolean] when true, discard unmodeled SGR codes and
+      #   non-SGR escapes instead of raising {ParseError}.
+      def initialize(input, lenient: false)
         @scanner = StringScanner.new(input)
+        @lenient = lenient
         @style = Style::DEFAULT
         @text = +""
         @spans = []
@@ -160,16 +184,70 @@ module Tuile
       # @return [void]
       def consume_escape
         @scanner.getch # \e
-        bracket = @scanner.getch
-        raise ParseError, "expected '[' after ESC, got #{bracket.inspect}" if bracket != "["
+        intro = @scanner.getch
+        case intro
+        when "[" then consume_csi
+        when nil then raise ParseError, "unterminated escape sequence" unless @lenient
+        else
+          raise ParseError, "expected '[' after ESC, got #{intro.inspect}" unless @lenient
+
+          consume_non_csi(intro)
+        end
+      end
 
-        params = @scanner.scan(/[\d;]*/) || ""
+      # Consumes a CSI sequence (`\e[` already eaten). A well-formed SGR
+      # (`\e[...m` with numeric/`;` params and no intermediates) is applied;
+      # anything else is a non-SGR or malformed CSI — raises in strict mode,
+      # swallowed in lenient. Scans the full CSI grammar (parameter bytes
+      # `\x30-\x3F`, intermediate bytes `\x20-\x2F`, final byte) so lenient
+      # mode consumes the whole sequence even for private-marker forms like
+      # `\e[?25l`.
+      # @return [void]
+      def consume_csi
+        params = @scanner.scan(/[\x30-\x3F]*/) || ""
+        intermediates = @scanner.scan(/[\x20-\x2F]*/) || ""
         final = @scanner.getch
-        raise ParseError, "unterminated escape sequence" if final.nil?
-        raise ParseError, "non-SGR CSI sequence (final byte #{final.inspect})" if final != "m"
 
+        if final == "m" && intermediates.empty? && params.match?(/\A[\d;]*\z/)
+          flush
+          return apply_sgr(params)
+        end
+
+        raise ParseError, "unterminated escape sequence" if final.nil? && !@lenient
+        raise ParseError, "non-SGR CSI sequence (final byte #{final.inspect})" unless @lenient
+
+        flush
+      end
+
+      # Lenient-only: discards a non-CSI escape (`\e` and `intro` already
+      # eaten). OSC/DCS/string sequences run to their string terminator; an
+      # nF escape (`\e( B`) eats its intermediates plus one final byte; any
+      # other Fe/Fp/Fs escape was complete in `intro` alone.
+      # @param intro [String] the byte after `\e` (never `"["`).
+      # @return [void]
+      def consume_non_csi(intro)
         flush
-        apply_sgr(params)
+        if STRING_INTRODUCERS.include?(intro)
+          consume_string_sequence
+        elsif intro.match?(/[\x20-\x2F]/)
+          @scanner.scan(/[\x20-\x2F]*/)
+          @scanner.getch
+        end
+      end
+
+      # Lenient-only: swallows an OSC/DCS/string-sequence payload up to and
+      # including its terminator (BEL, or ST `\e\\`), or to EOS if unterminated.
+      # @return [void]
+      def consume_string_sequence
+        until @scanner.eos?
+          ch = @scanner.getch
+          break if ch == "\a"
+
+          if ch == "\e"
+            @scanner.getch if @scanner.peek(1) == "\\"
+            break
+          end
+        end
       end
 
       # @param params_str [String]
@@ -187,6 +265,8 @@ module Tuile
           when 23 then @style = @style.merge(italic: false)
           when 4 then @style = @style.merge(underline: true)
           when 24 then @style = @style.merge(underline: false)
+          when 9 then @style = @style.merge(strikethrough: true)
+          when 29 then @style = @style.merge(strikethrough: false)
           when 30..37 then @style = @style.merge(fg: STANDARD_COLORS[code - 30])
           when 38
             i += consume_extended_color(codes, i, :fg)
@@ -199,7 +279,7 @@ module Tuile
           when 49 then @style = @style.merge(bg: nil)
           when 90..97 then @style = @style.merge(fg: BRIGHT_COLORS[code - 90])
           when 100..107 then @style = @style.merge(bg: BRIGHT_COLORS[code - 100])
-          else raise ParseError, "unsupported SGR code #{code}"
+          else raise ParseError, "unsupported SGR code #{code}" unless @lenient
           end
           i += 1
         end
@@ -208,27 +288,37 @@ module Tuile
       # @param codes [Array<Integer>]
       # @param index [Integer]
       # @param target [Symbol] either `:fg` or `:bg`.
-      # @return [Integer] how many SGR codes were consumed (3 for 256-color, 5 for RGB).
+      # @return [Integer] how many SGR codes were consumed. In lenient mode a
+      #   malformed color is skipped rather than applied, but the same count is
+      #   returned (3 for 256-color, 5 for RGB) so the running index advances
+      #   past its operands; an unknown selector skips just `38`/`48` + the
+      #   selector byte (2), letting the rest be reprocessed.
       def consume_extended_color(codes, index, target)
         mode = codes[index + 1]
         case mode
         when 5
           n = codes[index + 2]
-          raise ParseError, "invalid 256-color index #{n.inspect}" unless n&.between?(0, 255)
-
-          @style = @style.merge(target => n)
+          if n&.between?(0, 255)
+            @style = @style.merge(target => n)
+          elsif !@lenient
+            raise ParseError, "invalid 256-color index #{n.inspect}"
+          end
           3
         when 2
           r = codes[index + 2]
           g = codes[index + 3]
           b = codes[index + 4]
-          [r, g, b].each do |v|
-            raise ParseError, "invalid RGB component #{v.inspect}" unless v&.between?(0, 255)
+          if [r, g, b].all? { |v| v&.between?(0, 255) }
+            @style = @style.merge(target => [r, g, b])
+          elsif !@lenient
+            bad = [r, g, b].find { |v| !v&.between?(0, 255) }
+            raise ParseError, "invalid RGB component #{bad.inspect}"
           end
-          @style = @style.merge(target => [r, g, b])
           5
         else
-          raise ParseError, "unsupported extended-color selector #{mode.inspect}"
+          raise ParseError, "unsupported extended-color selector #{mode.inspect}" unless @lenient
+
+          2
         end
       end
 
@@ -268,10 +358,14 @@ module Tuile
       # default-styled span.
       #
       # @param input [String, StyledString, nil]
+      # @param lenient [Boolean] when true, unmodeled SGR codes and non-SGR
+      #   escapes are discarded instead of raising — see {StyledString}
+      #   "## Parser". Lossy: the result no longer round-trips to `input`.
       # @return [StyledString]
-      # @raise [ParseError] on unsupported or malformed escape sequences.
+      # @raise [ParseError] on unsupported or malformed escape sequences
+      #   (strict mode only).
       # @raise [TypeError] when `input` is none of String, StyledString, nil.
-      def parse(input)
+      def parse(input, lenient: false)
         case input
         when nil then EMPTY
         when StyledString then input
@@ -279,7 +373,7 @@ module Tuile
           return EMPTY if input.empty?
           return new([Span.new(text: input, style: Style::DEFAULT)]) unless input.include?("\e")
 
-          Parser.new(input).parse
+          Parser.new(input, lenient:).parse
         else
           raise TypeError, "cannot parse #{input.class}"
         end
@@ -456,7 +550,7 @@ module Tuile
 
     # Returns a new {StyledString} with `bg` applied to every span, preserving
     # each span's text and other style attributes (`fg`, `bold`, `italic`,
-    # `underline`). Useful for row-level highlights — the new bg overlays
+    # `underline`, `strikethrough`). Useful for row-level highlights — the new bg overlays
     # without dropping foreground colors the original styling carried.
     #
     # @param bg [Color, Symbol, Integer, Array<Integer>, nil] background
@@ -469,7 +563,7 @@ module Tuile
 
     # Returns a new {StyledString} with `fg` applied to every span, preserving
     # each span's text and other style attributes (`bg`, `bold`, `italic`,
-    # `underline`). The new fg overlays without dropping background colors or
+    # `underline`, `strikethrough`). The new fg overlays without dropping background colors or
     # text attributes the original styling carried.
     #
     # @param fg [Color, Symbol, Integer, Array<Integer>, nil] foreground
@@ -528,6 +622,7 @@ module Tuile
       codes << (to.bold ? 1 : 22) if from.bold != to.bold
       codes << (to.italic ? 3 : 23) if from.italic != to.italic
       codes << (to.underline ? 4 : 24) if from.underline != to.underline
+      codes << (to.strikethrough ? 9 : 29) if from.strikethrough != to.strikethrough
       codes.concat(color_codes(to.fg, target: :fg)) if from.fg != to.fg
       codes.concat(color_codes(to.bg, target: :bg)) if from.bg != to.bg
       return "" if codes.empty?

data/lib/tuile/version.rb

@@ -2,5 +2,5 @@
 
 module Tuile
   # @return [String]
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/mise.toml

@@ -0,0 +1,2 @@
+[tools]
+ruby = "3.3"

data/sig/tuile.rbs

@@ -136,6 +136,13 @@ module Tuile
     # _@param_ `point`
     def contains?: (Point point) -> bool
 
+    # _@param_ `other` — another rectangle.
+    # 
+    # _@return_ — true if `other` lies entirely within this rectangle.
+    # Uses the same half-open edges as {#contains?} (right/bottom exclusive).
+    # An {#empty? empty} `other` covers no cells, so it is trivially contained.
+    def contains_rect?: (Rect other) -> bool
+
     def size: () -> Size
 
     def top_left: () -> Point
@@ -665,6 +672,15 @@ module Tuile
     # _@param_ `window`
     def remove_popup: (Component::Popup window) -> void
 
+    # Invalidates the entire attached tree, forcing every component to repaint
+    # on the next cycle. Needed whenever something overdraws the scene without
+    # clipping and then exposes what was underneath — a closing popup
+    # ({#remove_popup}), or a popup that shrinks or moves so its new {#rect} no
+    # longer covers the cells it previously painted ({Component::Popup#rect=}).
+    # The popup-only fast path in {#repaint} can't clear those vacated cells on
+    # its own, so we accept the cost of a full repaint.
+    def needs_full_repaint: () -> void
+
     # Internal — use {Component::Popup#open?} instead.
     # 
     # _@param_ `window`
@@ -755,10 +771,6 @@ module Tuile
     # starts. {#size} provides correct size of the terminal.
     def layout: () -> void
 
-    # Called after a popup is closed. Since a popup can cover any window,
-    # top-level component or other popups, we need to redraw everything.
-    def needs_full_repaint: () -> void
-
     # A key has been pressed on the keyboard. Handle it, or forward to active
     # window.
     # 
@@ -1141,6 +1153,12 @@ module Tuile
     class List < Component
       def initialize: () -> void
 
+      # _@return_ — whether {#auto_scroll} is currently tailing. True
+      # while the viewport sits at the last line; flips to false the moment
+      # the user scrolls up, and back to true once they scroll to the bottom
+      # again. Only consulted when {#auto_scroll} is enabled.
+      def following?: () -> bool
+
       # Sets new lines. Each entry is coerced into a {StyledString} (a
       # `String` is parsed via {StyledString.parse}, so embedded ANSI is
       # honored; a {StyledString} is used as-is; anything else is stringified
@@ -1309,6 +1327,10 @@ module Tuile
       # _@return_ — the max value of {#top_line}.
       def top_line_max: () -> Integer
 
+      # _@return_ — whether the viewport is pinned to the last line.
+      # Drives {#following?}: re-evaluated on every {#top_line=}.
+      def at_bottom?: () -> bool
+
       # _@return_ — the number of visible lines.
       def viewport_lines: () -> Integer
 
@@ -1325,6 +1347,11 @@ module Tuile
       # which would leave `top_line` past the last item once a real rect
       # arrives. {#on_width_changed} re-runs this hook when the rect grows so
       # the snap-to-bottom intent is preserved.
+      # 
+      # Gated on {#following?}: once the user scrolls up off the bottom the
+      # cursor snap and viewport pin are both skipped, so reading older
+      # content is not interrupted by incoming lines. {#top_line=} re-arms
+      # `@follow` when the viewport returns to the bottom.
       def update_top_line_if_auto_scroll: () -> void
 
       # _@return_ — whether the scrollbar should be drawn right now.
@@ -1380,7 +1407,10 @@ module Tuile
       attr_accessor on_cursor_changed: Proc?
 
       # _@return_ — if true and a line is added or new content is set,
-      # auto-scrolls to the bottom.
+      # auto-scrolls to the bottom — but only while the viewport is already
+      # pinned to the last line (see {#following?}). Scroll up to read older
+      # content and appends stop yanking you back down; scroll back to the
+      # bottom and tailing resumes.
       attr_accessor auto_scroll: bool
 
       # _@return_ — top line of the viewport. 0 or positive.
@@ -1597,6 +1627,17 @@ module Tuile
 
       def focusable?: () -> bool
 
+      # Reassigns the popup's rect, escalating to a full scene repaint when an
+      # open popup shrinks or moves so its new rect no longer covers the cells
+      # it previously painted. A popup overdraws the scene without clipping and
+      # nothing clears underneath it, so {Screen#repaint}'s popup-only fast path
+      # would repaint into the new rect and leave the vacated cells showing
+      # stale content. When the new rect fully covers the old one (the popup
+      # only grew), the fast path is correct and the full repaint is skipped.
+      # 
+      # _@param_ `new_rect`
+      def rect=: (Rect new_rect) -> void
+
       # Mounts this popup on the {Screen}. Recomputes the popup's size from
       # the current content first, so reopening a popup whose content has
       # grown or shrunk while closed picks up the new size.
@@ -1652,6 +1693,11 @@ module Tuile
 
       # Recompute width/height from {#content}'s natural size and recenter
       # if currently open. Called whenever content is (re)assigned.
+      # 
+      # Computes the final (centered) rect and assigns it in one step rather
+      # than positioning at the origin and then centering: the intermediate
+      # origin rect rarely covers the previous one, which would make
+      # {#rect=}'s shrink/move detection fire a full repaint on every resize.
       def update_rect: () -> void
 
       # _@param_ `event`
@@ -1659,9 +1705,6 @@ module Tuile
 
       def children: () -> ::Array[Component]
 
-      # _@param_ `rect`
-      def rect=: (Rect rect) -> void
-
       def on_focus: () -> void
     end
 
@@ -1985,6 +2028,12 @@ module Tuile
       # O(total spans).
       def text: () -> StyledString
 
+      # _@return_ — whether {#auto_scroll} is currently tailing. True
+      # while the viewport sits at the last line; flips to false the moment
+      # the user scrolls up, and back to true once they scroll to the bottom
+      # again. Only consulted when {#auto_scroll} is enabled.
+      def following?: () -> bool
+
       # Replaces the text. Embedded `\n` characters become hard line breaks.
       # A `String` is parsed via {StyledString.parse} (so embedded ANSI is
       # honored); a `StyledString` is used as-is; `nil` is coerced to an
@@ -2316,8 +2365,16 @@ module Tuile
       # _@param_ `target` — desired top line; clamped to `[0, top_line_max]`.
       def move_top_line_to: (Integer target) -> void
 
+      # Gated on {#following?}: once the user scrolls up off the bottom the
+      # viewport pin is skipped, so reading older content is not interrupted
+      # by incoming lines. {#top_line=} re-arms `@follow` when the viewport
+      # returns to the bottom.
       def update_top_line_if_auto_scroll: () -> void
 
+      # _@return_ — whether the viewport is pinned to the last line.
+      # Drives {#following?}: re-evaluated on every {#top_line=}.
+      def at_bottom?: () -> bool
+
       def scrollbar_visible?: () -> bool
 
       # Pads `line` with trailing default-styled spaces out to `width` display
@@ -2350,7 +2407,10 @@ module Tuile
       attr_accessor scrollbar_visibility: Symbol
 
       # _@return_ — if true, mutating the text scrolls the viewport so
-      # the last line stays in view. Default `false`.
+      # the last line stays in view — but only while the viewport is already
+      # pinned to the last line (see {#following?}). Scroll up to read older
+      # content and appends stop yanking you back down; scroll back to the
+      # bottom and tailing resumes. Default `false`.
       attr_accessor auto_scroll: bool
 
       # _@return_ — longest hard-line's display width × number of hard
@@ -3252,7 +3312,7 @@ module Tuile
 
   # An immutable string-with-styling, modeled as a sequence of {Span}s where
   # each span carries a complete {Style} (`fg`, `bg`, `bold`, `italic`,
-  # `underline`). Spans are non-overlapping and fully tile the string — every
+  # `underline`, `strikethrough`). Spans are non-overlapping and fully tile the string — every
   # character has exactly one resolved style, no overlay layers to merge.
   # 
   # Where this differs from threading SGR escapes through a plain `String`:
@@ -3292,12 +3352,21 @@ module Tuile
   # 
   # ## Parser
   # 
-  # {.parse} is strict by design: it recognizes only the SGR codes
+  # {.parse} is strict by default: it recognizes only the SGR codes
   # corresponding to {Style}'s supported attributes (fg/bg/bold/italic/
-  # underline). Anything else — unmodeled attributes (dim, blink, reverse,
-  # strike, conceal, double-underline, overline, ...), unknown SGR codes, or
+  # underline/strikethrough). Anything else — unmodeled attributes (dim, blink,
+  # reverse, conceal, double-underline, overline, ...), unknown SGR codes, or
   # non-SGR escapes (cursor moves, OSC) — raises {ParseError}. This keeps the
   # round-trip parse(to_ansi(x)) == x contract honest.
+  # 
+  # Pass `lenient: true` to instead **discard** everything the parser can't
+  # model and keep going — recognized fg/bg/bold/italic/underline/strikethrough codes still
+  # apply, and any unmodeled SGR code, malformed extended color, non-SGR CSI
+  # (cursor moves, `\e[K`), OSC/DCS/string sequence, or stray escape is
+  # silently dropped. This is the mode for piping in colored output you don't
+  # control (e.g. `git --color` through a pager): "give me the colors, throw
+  # the rest away." It is lossy by design — `parse(x, lenient: true)` does not
+  # round-trip back to `x`.
   class StyledString
     EMPTY: StyledString
 
@@ -3317,7 +3386,9 @@ module Tuile
     # default-styled span.
     # 
     # _@param_ `input`
-    def self.parse: ((String | StyledString)? input) -> StyledString
+    # 
+    # _@param_ `lenient` — when true, unmodeled SGR codes and non-SGR escapes are discarded instead of raising — see {StyledString} "## Parser". Lossy: the result no longer round-trips to `input`.
+    def self.parse: ((String | StyledString)? input, ?lenient: bool) -> StyledString
 
     # _@param_ `spans`
     def initialize: (?::Array[Span] spans) -> void
@@ -3404,7 +3475,7 @@ module Tuile
 
     # Returns a new {StyledString} with `bg` applied to every span, preserving
     # each span's text and other style attributes (`fg`, `bold`, `italic`,
-    # `underline`). Useful for row-level highlights — the new bg overlays
+    # `underline`, `strikethrough`). Useful for row-level highlights — the new bg overlays
     # without dropping foreground colors the original styling carried.
     # 
     # _@param_ `bg` — background color, coerced via {Color.coerce}. `nil` clears bg back to the terminal default.
@@ -3412,7 +3483,7 @@ module Tuile
 
     # Returns a new {StyledString} with `fg` applied to every span, preserving
     # each span's text and other style attributes (`bg`, `bold`, `italic`,
-    # `underline`). The new fg overlays without dropping background colors or
+    # `underline`, `strikethrough`). The new fg overlays without dropping background colors or
     # text attributes the original styling carried.
     # 
     # _@param_ `fg` — foreground color, coerced via {Color.coerce}. `nil` clears fg back to the terminal default.
@@ -3505,6 +3576,8 @@ module Tuile
     #   @return [Boolean]
     # @!attribute [r] underline
     #   @return [Boolean]
+    # @!attribute [r] strikethrough
+    #   @return [Boolean]
     class Style
       DEFAULT: Style
 
@@ -3517,12 +3590,15 @@ module Tuile
       # _@param_ `italic`
       # 
       # _@param_ `underline`
+      # 
+      # _@param_ `strikethrough`
       def self.new: (
                       ?fg: (Color | Symbol | Integer | ::Array[Integer])?,
                       ?bg: (Color | Symbol | Integer | ::Array[Integer])?,
                       ?bold: bool,
                       ?italic: bool,
-                      ?underline: bool
+                      ?underline: bool,
+                      ?strikethrough: bool
                     ) -> Style
 
       def default?: () -> bool
@@ -3541,6 +3617,8 @@ module Tuile
       attr_reader italic: bool
 
       attr_reader underline: bool
+
+      attr_reader strikethrough: bool
     end
 
     # A maximal run of text sharing a single {Style}. `text` is plain — it
@@ -3566,14 +3644,18 @@ module Tuile
     # @api private
     # Hand-rolled SGR parser. State machine over a {StringScanner}: plain
     # text accumulates into the current span; each `\e[...m` flushes the
-    # current span and updates the running {Style}. Anything outside the
-    # supported SGR alphabet raises {ParseError}.
+    # current span and updates the running {Style}. In strict mode anything
+    # outside the supported SGR alphabet raises {ParseError}; in lenient mode
+    # it is consumed and discarded (see {StyledString} "## Parser").
     class Parser
       STANDARD_COLORS: ::Array[Symbol]
       BRIGHT_COLORS: ::Array[Symbol]
+      STRING_INTRODUCERS: ::Array[String]
 
       # _@param_ `input`
-      def initialize: (String input) -> void
+      # 
+      # _@param_ `lenient` — when true, discard unmodeled SGR codes and non-SGR escapes instead of raising {ParseError}.
+      def initialize: (String input, ?lenient: bool) -> void
 
       def parse: () -> StyledString
 
@@ -3581,6 +3663,27 @@ module Tuile
 
       def consume_escape: () -> void
 
+      # Consumes a CSI sequence (`\e[` already eaten). A well-formed SGR
+      # (`\e[...m` with numeric/`;` params and no intermediates) is applied;
+      # anything else is a non-SGR or malformed CSI — raises in strict mode,
+      # swallowed in lenient. Scans the full CSI grammar (parameter bytes
+      # `\x30-\x3F`, intermediate bytes `\x20-\x2F`, final byte) so lenient
+      # mode consumes the whole sequence even for private-marker forms like
+      # `\e[?25l`.
+      def consume_csi: () -> void
+
+      # Lenient-only: discards a non-CSI escape (`\e` and `intro` already
+      # eaten). OSC/DCS/string sequences run to their string terminator; an
+      # nF escape (`\e( B`) eats its intermediates plus one final byte; any
+      # other Fe/Fp/Fs escape was complete in `intro` alone.
+      # 
+      # _@param_ `intro` — the byte after `\e` (never `"["`).
+      def consume_non_csi: (String intro) -> void
+
+      # Lenient-only: swallows an OSC/DCS/string-sequence payload up to and
+      # including its terminator (BEL, or ST `\e\\`), or to EOS if unterminated.
+      def consume_string_sequence: () -> void
+
       # _@param_ `params_str`
       def apply_sgr: (String params_str) -> void
 
@@ -3590,7 +3693,11 @@ module Tuile
       # 
       # _@param_ `target` — either `:fg` or `:bg`.
       # 
-      # _@return_ — how many SGR codes were consumed (3 for 256-color, 5 for RGB).
+      # _@return_ — how many SGR codes were consumed. In lenient mode a
+      # malformed color is skipped rather than applied, but the same count is
+      # returned (3 for 256-color, 5 for RGB) so the running index advances
+      # past its operands; an unknown selector skips just `38`/`48` + the
+      # selector byte (2), letting the rest be reprocessed.
       def consume_extended_color: (::Array[Integer] codes, Integer index, Symbol target) -> Integer
 
       def flush: () -> void

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tuile
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Martin Vysny
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -153,6 +154,7 @@ files:
 - lib/tuile/theme_def.rb
 - lib/tuile/version.rb
 - lib/tuile/vertical_scroll_bar.rb
+- mise.toml
 - sig/tuile.rbs
 homepage: https://github.com/mvysny/tuile
 licenses:
@@ -161,6 +163,7 @@ metadata:
   homepage_uri: https://github.com/mvysny/tuile
   changelog_uri: https://github.com/mvysny/tuile/blob/master/CHANGELOG.md
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -168,14 +171,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.4.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: A component-oriented terminal UI toolkit for Ruby.
 test_files: []