tui-td 0.2.5 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5a923ea75814849ee5cf0633c81c09e2db156e47df52f6f92f2b314f743f3b7
-  data.tar.gz: c5cb55618e38bcc06a477bedce42d61d8f0c497ff38f887462943e8d094863b0
+  metadata.gz: 2f09dac0e163cc0b1f2e699d66fe25fd656003b28ad17867a32154073cec8a62
+  data.tar.gz: a46f622e3a7a89c0451e603e89266575eec49b346af851c8bce393230684c759
 SHA512:
-  metadata.gz: 1d36aac819998194c942dc9fc16c96ef0b4ef9fa7d549649f4bdd78cd59687858939ef7e1303d215a13e1dcd0957350d3839e43af94d4b837eb509ea5541cb58
-  data.tar.gz: 3d9f2fe282a9e32a274cea860ef5592e7666ce48121d590395c926bd0119d0f970ad2d2f232b88b0323742df8ef42b18686cd60ca75007d9f739cc2e8f4bae5b
+  metadata.gz: adb1c08cd89f21f59e270c73d94f8542ada7949069ebb5c6dcad27dc860264df93f09dea8e8c2053e90f909ca9c5405254e0f51d2afbd6dba194e1b3d293e4d3
+  data.tar.gz: 70597354fa770012221aa26f03a2ce4198f13ebb8ea66f1bacba20f7be740b1487d31c6908de19036889ae3ab0f60fc4a7cf57d993c5b938453f51618ecb9b28

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # CHANGELOG
 
+## 0.2.7
+
+- Screenshot rendering for 23 special characters: blocks (▀ ▄ █), triangles (▲ ▼), arrows (↑ ↓ → ←), half blocks (▌ ▐)
+- Screenshot rendering for symbols: checkmarks (✓ ✗ ✖), checkboxes (☐ ☑ ☒), gear (⚙), warning (⚠), info (ℹ)
+- Screenshot rendering for punctuation: ellipsis (…), em dash (—)
+- Cursor drawing support in screenshot renderer
+- Braille character rendering in screenshot
+- Rounded corner box-drawing characters (╭ ╮ ╯ ╰) in screenshot
+- `page_up` / `page_down` key support in test runner and driver
+- Fixed junction pixels in rounded corner box-drawing characters
+
+## 0.2.6
+
+- ISO-2022 charset switching support (G0/G1 designators, Shift Out/In) with DEC Special Character & Line Drawing mapping
+- SGR mouse reporting mode parsing (1000, 1002, 1003, 1006)
+- Mouse reporting and cursor visibility/style reconstruction in build_frame
+- Fixed `state_data` in `driver.rb` to unconditionally refresh terminal state instead of returning stale cache
+- New `cursor_visible`, `cursor_style`, `mouse_mode`, `mouse_format` attributes on `State`
+- HTML and screenshot styling for new cursor/mouse attributes
+
 ## 0.2.5
 
 - MCP smoke test expanded: 20 → 54 assertions, covers all 10 tools plus error paths (88% server coverage)

data/README.md

@@ -417,10 +417,14 @@ Top-level structure returned by `state_data` / `--json`:
 
 ```json
 {
-  "size":   {"rows": 40, "cols": 120},
-  "cursor": {"row": 5, "col": 12},
-  "rows":   [[{"char": "A", "fg": "cyan", ...}]],
-  "raw":    "\e[31mred\e[0m\n..."
+  "size":            {"rows": 40, "cols": 120},
+  "cursor":          {"row": 5, "col": 12},
+  "cursor_visible":  true,
+  "cursor_style":    "block",
+  "mouse_mode":      null,
+  "mouse_format":    null,
+  "rows":            [[{"char": "A", "fg": "cyan", ...}]],
+  "raw":             "\e[31mred\e[0m\n..."
 }
 ```
 

data/lib/tui_td/ansi_parser.rb

@@ -80,6 +80,40 @@ module TUITD
       15 => "bright_white",
     }.freeze
 
+    DEC_MAP = {
+      '`' => '◆',
+      'a' => '▒',
+      'b' => "\u2409",
+      'c' => "\u240C",
+      'd' => "\u240D",
+      'e' => "\u240A",
+      'f' => '°',
+      'g' => '±',
+      'h' => "\u2424",
+      'i' => "\u240B",
+      'j' => '┘',
+      'k' => '┐',
+      'l' => '┌',
+      'm' => '└',
+      'n' => '┼',
+      'o' => '⎺',
+      'p' => '⎻',
+      'q' => '─',
+      'r' => '⎼',
+      's' => '⎽',
+      't' => '├',
+      'u' => '┤',
+      'v' => '┴',
+      'w' => '┬',
+      'x' => '│',
+      'y' => '≤',
+      'z' => '≥',
+      '{' => 'π',
+      '|' => '≠',
+      '}' => '£',
+      '~' => '·'
+    }.freeze
+
     # Parse raw terminal output into a structured state Hash
     def self.parse(raw, rows = 40, cols = 120)
       grid = Array.new(rows) do
@@ -87,11 +121,32 @@ module TUITD
       end
 
       cursor = { row: 0, col: 0 }
-      attrs = { fg: "default", bg: "default", bold: false, italic: false, underline: false }
+      attrs = { fg: "default", bg: "default", bold: false, italic: false, underline: false, blink: false }
       saved_cursor = nil
       scroll_region = { top: 0, bottom: rows - 1 }
       pending_dsr = false
 
+      normal_grid = grid
+      alt_grid = nil
+
+      normal_cursor = cursor
+      alt_cursor = { row: 0, col: 0 }
+
+      normal_saved_cursor = nil
+      alt_saved_cursor = nil
+
+      use_alt_screen = false
+
+      cursor_visible = true
+      cursor_style = 1 # 1 = blinking block (default)
+
+      g0_charset = :ascii
+      g1_charset = :dec
+      active_charset = :g0
+
+      mouse_mode = :none
+      mouse_format = :normal
+
       # Strip everything before the last full clear (if any)
       # to avoid accumulated garbage
       processed = raw
@@ -101,12 +156,76 @@ module TUITD
         if processed[i] == "\e" && processed[i + 1] == "["
           # Find end of CSI sequence
           j = i + 2
-          j += 1 while j < processed.length && !processed[j].match?(/[A-HJ-KP-SX@`fhlmnRrsu]/)
+          j += 1 while j < processed.length && !processed[j].match?(/[A-HJ-KP-SX@\`fhlmnRrsuq]/)
           seq = processed[i..j]
 
-          dsr, new_saved = _apply_csi(seq, cursor, attrs, grid, rows, cols, saved_cursor, scroll_region)
+          dsr, new_saved, action = _apply_csi(seq, cursor, attrs, grid, rows, cols, saved_cursor, scroll_region)
           pending_dsr ||= dsr
-          saved_cursor = new_saved if new_saved
+
+          if new_saved
+            if use_alt_screen
+              alt_saved_cursor = new_saved
+              saved_cursor = alt_saved_cursor
+            else
+              normal_saved_cursor = new_saved
+              saved_cursor = normal_saved_cursor
+            end
+          end
+
+          if action.key?(:alt_screen)
+            new_alt = action[:alt_screen]
+            code = action[:alt_screen_code]
+            if new_alt != use_alt_screen
+              if new_alt
+                # Switch to Alternate Screen
+                # Save normal cursor
+                normal_cursor = { row: cursor[:row], col: cursor[:col] }
+
+                # Lazy initialize alt grid
+                alt_grid ||= Array.new(rows) do
+                  Array.new(cols) { default_cell.dup }
+                end
+
+                # For \e[?1049h, clear alternate screen and reset cursor to 0,0
+                if code == 1049
+                  alt_grid = Array.new(rows) do
+                    Array.new(cols) { default_cell.dup }
+                  end
+                  alt_cursor = { row: 0, col: 0 }
+                end
+
+                grid = alt_grid
+                cursor = alt_cursor
+                saved_cursor = alt_saved_cursor
+                use_alt_screen = true
+              else
+                # Switch to Normal Screen
+                # Save alt cursor
+                alt_cursor = { row: cursor[:row], col: cursor[:col] }
+
+                grid = normal_grid
+                cursor = normal_cursor
+                saved_cursor = normal_saved_cursor
+                use_alt_screen = false
+              end
+            end
+          end
+
+          if action.key?(:cursor_visible)
+            cursor_visible = action[:cursor_visible]
+          end
+
+          if action.key?(:cursor_style)
+            cursor_style = action[:cursor_style]
+          end
+
+          if action.key?(:mouse_mode)
+            mouse_mode = action[:mouse_mode]
+          end
+
+          if action.key?(:mouse_format)
+            mouse_format = action[:mouse_format]
+          end
 
           i = j + 1
         elsif processed[i] == "\n" || processed[i] == "\r\n"
@@ -126,11 +245,23 @@ module TUITD
         elsif processed[i] == "\a"
           # Bell — ignore
           i += 1
+        elsif processed[i] == "\x0e"
+          active_charset = :g1
+          i += 1
+        elsif processed[i] == "\x0f"
+          active_charset = :g0
+          i += 1
         elsif processed[i] == "\e"
           # Handle non-CSI escape sequences
           if processed[i + 1] == "7"
             # DECSC — Save Cursor
-            saved_cursor = { row: cursor[:row], col: cursor[:col] }
+            if use_alt_screen
+              alt_saved_cursor = { row: cursor[:row], col: cursor[:col] }
+              saved_cursor = alt_saved_cursor
+            else
+              normal_saved_cursor = { row: cursor[:row], col: cursor[:col] }
+              saved_cursor = normal_saved_cursor
+            end
             i += 2
           elsif processed[i + 1] == "8"
             # DECRC — Restore Cursor
@@ -139,8 +270,14 @@ module TUITD
               cursor[:col] = saved_cursor[:col]
             end
             i += 2
+          elsif processed[i + 1] == "(" && (processed[i + 2] == "0" || processed[i + 2] == "B")
+            g0_charset = (processed[i + 2] == "0" ? :dec : :ascii)
+            i += 3
+          elsif processed[i + 1] == ")" && (processed[i + 2] == "0" || processed[i + 2] == "B")
+            g1_charset = (processed[i + 2] == "0" ? :dec : :ascii)
+            i += 3
           elsif processed[i + 1] && processed[i + 1].match?(/[()*+\-.\/]/)
-            # ISO 2022 charset: \e( B  \e) 0  etc. (3 chars total)
+            # Other ISO 2022 charset sequences (e.g. G2/G3 or other charsets)
             i += 3
           else
             i += 1
@@ -149,7 +286,12 @@ module TUITD
           # Printable character (including multi-byte UTF-8)
           if cursor[:row] < rows && cursor[:col] < cols
             cell = grid[cursor[:row]][cursor[:col]]
-            cell[:char] = char
+            current_charset = (active_charset == :g1 ? g1_charset : g0_charset)
+            mapped_char = char
+            if current_charset == :dec && DEC_MAP.key?(char)
+              mapped_char = DEC_MAP[char]
+            end
+            cell[:char] = mapped_char
             cell.merge!(attrs)
             cursor[:col] += 1
             cursor[:col] = cols - 1 if cursor[:col] >= cols
@@ -180,9 +322,18 @@ module TUITD
 
       {
         size: { rows: rows, cols: cols },
-        cursor: cursor,
+        cursor: {
+          row: cursor[:row],
+          col: cursor[:col],
+          visible: cursor_visible,
+          style: cursor_style
+        },
         rows: grid,
         pending_dsr: pending_dsr,
+        cursor_visible: cursor_visible,
+        cursor_style: cursor_style,
+        mouse_mode: mouse_mode,
+        mouse_format: mouse_format
       }
     end
 
@@ -192,6 +343,8 @@ module TUITD
       cols = state.dig(:size, :cols) || state["size"]["cols"]
       grid = state[:rows] || state["rows"]
       cursor = state[:cursor] || state["cursor"]
+      mouse_mode = state[:mouse_mode] || state["mouse_mode"] || :none
+      mouse_format = state[:mouse_format] || state["mouse_format"] || :normal
 
       out = +""
       out << "\e[0m"
@@ -205,11 +358,13 @@ module TUITD
           bold = cell[:bold] || cell["bold"] || false
           italic = cell[:italic] || cell["italic"] || false
           underline = cell[:underline] || cell["underline"] || false
+          blink = cell[:blink] || cell["blink"] || false
 
           codes = []
           codes << "1" if bold
           codes << "3" if italic
           codes << "4" if underline
+          codes << "5" if blink
 
           fg_code = _color_code(fg, "38")
           bg_code = _color_code(bg, "48")
@@ -223,6 +378,36 @@ module TUITD
         out << "\n" if ri < rows - 1
       end
 
+      # Reconstruct cursor visibility
+      cursor_vis = true
+      if cursor.is_a?(Hash)
+        cursor_vis = cursor[:visible] != false && cursor["visible"] != false
+      end
+      out << (cursor_vis ? "\e[?25h" : "\e[?25l")
+
+      # Reconstruct cursor style
+      if cursor.is_a?(Hash)
+        style = cursor[:style] || cursor["style"]
+        out << "\e[#{style} q" if style
+      end
+
+      # Reconstruct mouse mode and format
+      if mouse_mode == :normal
+        out << "\e[?1000h"
+      elsif mouse_mode == :drag
+        out << "\e[?1002h"
+      elsif mouse_mode == :all
+        out << "\e[?1003h"
+      else
+        out << "\e[?1000l\e[?1002l\e[?1003l"
+      end
+
+      if mouse_format == :sgr
+        out << "\e[?1006h"
+      else
+        out << "\e[?1006l"
+      end
+
       out << "\e[0m"
       out
     end
@@ -230,13 +415,16 @@ module TUITD
     def self._apply_csi(seq, cursor, attrs, grid, rows, cols, saved_cursor, scroll_region)
       # Strip leading escape char if present
       cleaned = seq.sub(/^\e/, "")
-      match = cleaned.match(/^\[([\d;]*)([A-HJ-KP-SX@`fhlmnRrsu])$/)
-      return [false, nil] unless match
+      match = cleaned.match(/^\[(\??)([\d;]*)( ?)([A-HJ-KP-SX@\`fhlmnRrsuq])$/)
+      return [false, nil, {}] unless match
 
-      params = match[1].split(";").map(&:to_i)
-      command = match[2]
+      is_private = (match[1] == "?")
+      params = match[2].split(";").map(&:to_i)
+      space = match[3]
+      command = match[4]
 
       new_saved = nil
+      action = {}
 
       case command
       when "m"
@@ -309,38 +497,81 @@ module TUITD
         end
         cursor[:row] = 0
         cursor[:col] = 0
-      when "h", "l" # DEC private mode set/reset — skip
-        nil
+      when "h"
+        if is_private
+          params.each do |p|
+            case p
+            when 47, 1047, 1049
+              action[:alt_screen] = true
+              action[:alt_screen_code] = p
+            when 25
+              action[:cursor_visible] = true
+            when 1000
+              action[:mouse_mode] = :normal
+            when 1002
+              action[:mouse_mode] = :drag
+            when 1003
+              action[:mouse_mode] = :all
+            when 1006
+              action[:mouse_format] = :sgr
+            end
+          end
+        end
+      when "l"
+        if is_private
+          params.each do |p|
+            case p
+            when 47, 1047, 1049
+              action[:alt_screen] = false
+              action[:alt_screen_code] = p
+            when 25
+              action[:cursor_visible] = false
+            when 1000, 1002, 1003
+              action[:mouse_mode] = :none
+            when 1006
+              action[:mouse_format] = :normal
+            end
+          end
+        end
+      when "q"
+        if space == " "
+          style_val = params[0] || 0
+          action[:cursor_style] = style_val
+        end
       when "n" # DSR — Device Status Report request
-        return [params[0] == 6, nil]
+        return [params[0] == 6, nil, {}]
       when "R" # DSR response (from terminal side) or CPR — ignore
         nil
       end
 
-      [false, new_saved]
+      [false, new_saved, action]
     end
 
     def self._apply_sgr(params, attrs)
-      return attrs.merge!(fg: "default", bg: "default", bold: false, italic: false, underline: false) if params.empty? || params == [0]
+      return attrs.merge!(fg: "default", bg: "default", bold: false, italic: false, underline: false, blink: false) if params.empty? || params == [0]
 
       i = 0
       while i < params.length
         p = params[i]
         case p
         when 0
-          attrs.merge!(fg: "default", bg: "default", bold: false, italic: false, underline: false)
+          attrs.merge!(fg: "default", bg: "default", bold: false, italic: false, underline: false, blink: false)
         when 1
           attrs[:bold] = true
         when 3
           attrs[:italic] = true
         when 4
           attrs[:underline] = true
+        when 5, 6
+          attrs[:blink] = true
         when 22
           attrs[:bold] = false
         when 23
           attrs[:italic] = false
         when 24
           attrs[:underline] = false
+        when 25
+          attrs[:blink] = false
         when 7
           # Reverse — swap fg and bg
           attrs[:fg], attrs[:bg] = attrs[:bg], attrs[:fg]
@@ -453,7 +684,7 @@ module TUITD
     end
 
     def self.default_cell
-      { char: " ", fg: "default", bg: "default", bold: false, italic: false, underline: false }
+      { char: " ", fg: "default", bg: "default", bold: false, italic: false, underline: false, blink: false }
     end
 
     # Extract a single UTF-8 character at position i in a binary string.

data/lib/tui_td/driver.rb

@@ -77,6 +77,8 @@ module TUITD
       when :backspace then send("\u007f")
       when :ctrl_c then send("\u0003")
       when :ctrl_d then send("\u0004")
+      when :page_up   then send("\e[5~")
+      when :page_down then send("\e[6~")
       else send(keys.to_s)
       end
     end
@@ -142,7 +144,7 @@ module TUITD
 
     # Get structured terminal state as a Hash
     def state_data
-      refresh_state! if @state.nil?
+      refresh_state!
       @state
     end
 

data/lib/tui_td/html_renderer.rb

@@ -72,6 +72,49 @@ module TUITD
           z-index: 1;
           position: relative;
         }
+        .cursor-cell.cursor-hidden {
+          outline: none !important;
+          border: none !important;
+          background-color: transparent !important;
+          color: inherit !important;
+        }
+        .cursor-cell.cursor-block {
+          outline: none;
+          background-color: #fff;
+          color: #000 !important;
+        }
+        .cursor-cell.cursor-block.blink {
+          animation: cursor-block-blink 1s step-end infinite;
+        }
+        .cursor-cell.cursor-underline {
+          outline: none;
+          border-bottom: 2px solid #fff;
+        }
+        .cursor-cell.cursor-underline.blink {
+          animation: cursor-underline-blink 1s step-end infinite;
+        }
+        .cursor-cell.cursor-bar {
+          outline: none;
+          border-left: 2px solid #fff;
+        }
+        .cursor-cell.cursor-bar.blink {
+          animation: cursor-bar-blink 1s step-end infinite;
+        }
+        @keyframes cursor-block-blink {
+          50% { background-color: transparent; color: inherit; }
+        }
+        @keyframes cursor-underline-blink {
+          50% { border-bottom-color: transparent; }
+        }
+        @keyframes cursor-bar-blink {
+          50% { border-left-color: transparent; }
+        }
+        @keyframes term-blink {
+          50% { opacity: 0; }
+        }
+        .term-blink {
+          animation: term-blink 1s step-end infinite;
+        }
       CSS
     end
 
@@ -103,17 +146,20 @@ module TUITD
         bold = cell[:bold] || cell["bold"] || false
         italic = cell[:italic] || cell["italic"] || false
         underline = cell[:underline] || cell["underline"] || false
+        blink = cell[:blink] || cell["blink"] || false
 
-        style_key = [fg, bg, bold, italic, underline]
+        style_key = [fg, bg, bold, italic, underline, blink]
+        is_cur = is_cursor?(ri, ci)
 
-        if current_run && current_run[:key] == style_key
+        if current_run && current_run[:key] == style_key && !current_run[:has_cursor] && !is_cur
           current_run[:chars] << char
         else
           current_run = {
             key: style_key,
             chars: [char],
             style: cell_style(fg, bg, bold, italic, underline),
-            has_cursor: is_cursor?(ri, ci)
+            has_cursor: is_cur,
+            blink: blink
           }
           runs << current_run
         end
@@ -134,17 +180,41 @@ module TUITD
 
     def render_run(run)
       chars = run[:chars].map { |c| escape_html(c) }.join
-      return chars if run[:style].empty? && !run[:has_cursor]
+      return chars if run[:style].empty? && !run[:has_cursor] && !run[:blink]
 
       classes = []
-      classes << "cursor-cell" if run[:has_cursor]
+      if run[:has_cursor]
+        classes << "cursor-cell"
+        cursor_vis = @cursor[:visible] != false && @cursor["visible"] != false
+        if !cursor_vis
+          classes << "cursor-hidden"
+        else
+          style_val = @cursor[:style] || @cursor["style"]
+          case style_val
+          when 0, 1
+            classes << "cursor-block blink"
+          when 2
+            classes << "cursor-block"
+          when 3
+            classes << "cursor-underline blink"
+          when 4
+            classes << "cursor-underline"
+          when 5
+            classes << "cursor-bar blink"
+          when 6
+            classes << "cursor-bar"
+          end
+        end
+      end
+      classes << "term-blink" if run[:blink]
+
       cls = classes.empty? ? "" : %( class="#{classes.join(" ")}")
       style = run[:style].empty? ? "" : %( style="#{run[:style]}")
       %(<span#{cls}#{style}>#{chars}</span>)
     end
 
     def is_cursor?(ri, ci)
-      @cursor[:row] == ri && @cursor[:col] == ci
+      (@cursor[:row] || @cursor["row"]) == ri && (@cursor[:col] || @cursor["col"]) == ci
     end
 
     def css_color(rgb)

data/lib/tui_td/screenshot.rb

@@ -107,6 +107,100 @@ module TUITD
       0x00, 0x70, 0x18, 0x18, 0x18, 0x18, 0x0e, 0x0e, 0x18, 0x18, 0x18, 0x18, 0x70, 0x00, 0x00, 0x00,  # } (125)
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, 0x7e, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  # ~ (126)
     ].freeze
+    BOX_CHARS = {
+      # horizontal
+      "─" => [false, false, true, true, :light],
+      "━" => [false, false, true, true, :heavy],
+      "═" => [false, false, true, true, :double],
+      # vertical
+      "│" => [true, true, false, false, :light],
+      "┃" => [true, true, false, false, :heavy],
+      "║" => [true, true, false, false, :double],
+      # corners
+      "╭" => [false, true, false, true, :light_rounded],
+      "╮" => [false, true, true, false, :light_rounded],
+      "╯" => [true, false, true, false, :light_rounded],
+      "╰" => [true, false, false, true, :light_rounded],
+      "┌" => [false, true, false, true, :light],
+      "┍" => [false, true, false, true, :light],
+      "┎" => [false, true, false, true, :light],
+      "┏" => [false, true, false, true, :heavy],
+      "┐" => [false, true, true, false, :light],
+      "┑" => [false, true, true, false, :light],
+      "┒" => [false, true, true, false, :light],
+      "┓" => [false, true, true, false, :heavy],
+      "└" => [true, false, false, true, :light],
+      "┖" => [true, false, false, true, :light],
+      "┗" => [true, false, false, true, :heavy],
+      "┘" => [true, false, true, false, :light],
+      "┙" => [true, false, true, false, :light],
+      "┚" => [true, false, true, false, :light],
+      "┛" => [true, false, true, false, :heavy],
+      # double corners
+      "╔" => [false, true, false, true, :double],
+      "╗" => [false, true, true, false, :double],
+      "╚" => [true, false, false, true, :double],
+      "╝" => [true, false, true, false, :double],
+      # T-junctions
+      "├" => [true, true, false, true, :light],
+      "┣" => [true, true, false, true, :heavy],
+      "┤" => [true, true, true, false, :light],
+      "┫" => [true, true, true, false, :heavy],
+      "┬" => [false, true, true, true, :light],
+      "┳" => [false, true, true, true, :heavy],
+      "┴" => [true, false, true, true, :light],
+      "┻" => [true, false, true, true, :heavy],
+      # double T-junctions
+      "╠" => [true, true, false, true, :double],
+      "╣" => [true, true, true, false, :double],
+      "╦" => [false, true, true, true, :double],
+      "╩" => [true, false, true, true, :double],
+      # crosses
+      "┼" => [true, true, true, true, :light],
+      "╋" => [true, true, true, true, :heavy],
+      "╬" => [true, true, true, true, :double],
+      # single lines (ends)
+      "╴" => [false, false, true, false, :light],
+      "╵" => [true, false, false, false, :light],
+      "╶" => [false, false, false, true, :light],
+      "╷" => [false, true, false, false, :light],
+      "╸" => [false, false, true, false, :heavy],
+      "╹" => [true, false, false, false, :heavy],
+      "╺" => [false, false, false, true, :heavy],
+      "╻" => [false, true, false, false, :heavy],
+      # mixed corners/junctions
+      "┿" => [true, true, true, true, :light],
+      "╀" => [true, true, true, true, :light],
+      "╁" => [true, true, true, true, :light],
+      "╂" => [true, true, true, true, :light],
+      "╃" => [true, true, true, true, :heavy],
+      "╄" => [true, true, true, true, :heavy],
+      "╅" => [true, true, true, true, :heavy],
+      "╆" => [true, true, true, true, :heavy],
+      "╇" => [true, true, true, true, :heavy],
+      "╈" => [true, true, true, true, :heavy],
+      "╉" => [true, true, true, true, :heavy],
+      "╊" => [true, true, true, true, :heavy],
+      "╒" => [false, true, false, true, :double],
+      "╓" => [false, true, false, true, :double],
+      "╕" => [false, true, true, false, :double],
+      "╖" => [false, true, true, false, :double],
+      "╘" => [true, false, false, true, :double],
+      "╙" => [true, false, false, true, :double],
+      "╛" => [true, false, true, false, :double],
+      "╜" => [true, false, true, false, :double],
+      "╞" => [true, true, false, true, :double],
+      "╟" => [true, true, false, true, :double],
+      "╡" => [true, true, true, false, :double],
+      "╢" => [true, true, true, false, :double],
+      "╤" => [false, true, true, true, :double],
+      "╥" => [false, true, true, true, :double],
+      "╧" => [true, false, true, true, :double],
+      "╨" => [true, false, true, true, :double],
+      "╪" => [true, true, true, true, :double],
+      "╫" => [true, true, true, true, :double]
+    }.freeze
+
     private_constant :FONT
 
     def initialize(state)
@@ -129,6 +223,8 @@ module TUITD
         end
       end
 
+      draw_cursor(image)
+
       image.save(output_path)
       output_path
     end
@@ -151,7 +247,116 @@ module TUITD
 
       fill_rect(image, px, py, CELL_W, CELL_H, bg_rgb)
 
-      return if char == " " || char.ord < 32 || char.ord > 126
+      if box_drawing?(char)
+        draw_box_character(image, px, py, char, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      end
+
+      char_ord = char.ord
+      if char_ord == 10095 # '❯'
+        draw_chevron(image, px, py, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 9210 || char_ord == 9679 # '⏺' or '●'
+        draw_circle(image, px, py, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord >= 0x2800 && char_ord <= 0x28ff # Braille spinner
+        draw_braille(image, px, py, char, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 0x2580 # '▀'
+        fill_rect(image, px, py, CELL_W, 8, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 0x2584 # '▄'
+        fill_rect(image, px, py + 8, CELL_W, 8, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 0x2588 # '█'
+        fill_rect(image, px, py, CELL_W, CELL_H, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 0x25B2 # '▲'
+        draw_up_triangle(image, px, py, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 0x25BC # '▼'
+        draw_down_triangle(image, px, py, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 0x2713 # '✓'
+        draw_checkmark(image, px, py, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 0x2717 # '✗'
+        draw_ballot_x(image, px, py, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 0x2191 # '↑'
+        draw_up_arrow(image, px, py, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 0x2192 # '→'
+        draw_right_arrow(image, px, py, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 0x2193 # '↓'
+        draw_down_arrow(image, px, py, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 0x2699 # '⚙'
+        draw_gear(image, px, py, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 0x26A0 # '⚠'
+        draw_warning(image, px, py, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 0x2026 # '…'
+        draw_ellipsis(image, px, py, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 0x2014 # '—'
+        (px..(px + 7)).each { |x| image[x, py + 8] = ChunkyPNG::Color.rgb(*fg_rgb) }
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 0x2190 # '←'
+        draw_left_arrow(image, px, py, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 0x258C # '▌'
+        draw_left_half_block(image, px, py, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 0x2590 # '▐'
+        draw_right_half_block(image, px, py, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 0x2610 # '☐'
+        draw_empty_checkbox(image, px, py, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 0x2611 # '☑'
+        draw_checked_checkbox(image, px, py, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 0x2612 # '☒'
+        draw_x_checkbox(image, px, py, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 0x2139 # 'ℹ'
+        draw_info_symbol(image, px, py, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      elsif char_ord == 0x2716 # '✖'
+        draw_heavy_x(image, px, py, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      end
+
+      return if char == " " || char_ord < 32 || char_ord > 126
 
       rows_data = glyph_rows(char)
       return unless rows_data
@@ -200,5 +405,453 @@ module TUITD
       w.times { |dx| image[px + dx, y] = color }
     end
 
+    def box_drawing?(char)
+      char_ord = char.ord
+      char_ord >= 0x2500 && char_ord <= 0x257F
+    end
+
+    def draw_box_character(image, px, py, char, fg_rgb)
+      config = BOX_CHARS[char]
+
+      unless config
+        char_ord = char.ord
+        if [0x2500, 0x2501, 0x2504, 0x2505, 0x2508, 0x2509, 0x254c, 0x254d, 0x2550].include?(char_ord)
+          style = [0x2501, 0x2505, 0x2509, 0x254d].include?(char_ord) ? :heavy : (char_ord == 0x2550 ? :double : :light)
+          config = [false, false, true, true, style]
+        elsif [0x2502, 0x2503, 0x2506, 0x2507, 0x250a, 0x250b, 0x254e, 0x254f, 0x2551].include?(char_ord)
+          style = [0x2503, 0x2507, 0x250b, 0x254f].include?(char_ord) ? :heavy : (char_ord == 0x2551 ? :double : :light)
+          config = [true, true, false, false, style]
+        else
+          config = [true, true, true, true, :light]
+        end
+      end
+
+      up, down, left, right, style = config
+      cx = px + 4
+      cy = py + 8
+
+      color = ChunkyPNG::Color.rgb(*fg_rgb)
+
+      if style == :double
+        if left
+          (px..(cx + 2)).each { |x| image[x, py + 6] = color }
+          (px..(cx + 2)).each { |x| image[x, py + 10] = color }
+        end
+        if right
+          ((cx - 2)..(px + 7)).each { |x| image[x, py + 6] = color }
+          ((cx - 2)..(px + 10)).each { |x| image[x, py + 10] = color }
+        end
+        if up
+          (py..(cy + 2)).each { |y| image[px + 2, y] = color }
+          (py..(cy + 2)).each { |y| image[px + 6, y] = color }
+        end
+        if down
+          ((cy - 2)..(py + 15)).each { |y| image[px + 2, y] = color }
+          ((cy - 2)..(py + 15)).each { |y| image[px + 6, y] = color }
+        end
+      elsif style == :heavy
+        if left
+          (px..cx).each do |x|
+            image[x, cy - 1] = color
+            image[x, cy] = color
+            image[x, cy + 1] = color
+          end
+        end
+        if right
+          (cx..(px + 7)).each do |x|
+            image[x, cy - 1] = color
+            image[x, cy] = color
+            image[x, cy + 1] = color
+          end
+        end
+        if up
+          (py..cy).each do |y|
+            image[cx - 1, y] = color
+            image[cx, y] = color
+            image[cx + 1, y] = color
+          end
+        end
+        if down
+          (cy..(py + 15)).each do |y|
+            image[cx - 1, y] = color
+            image[cx, y] = color
+            image[cx + 1, y] = color
+          end
+        end
+      elsif style == :light_rounded
+        case char
+        when "╭"
+          (px + 5..px + 7).each { |x| image[x, py + 8] = color }
+          (py + 10..py + 15).each { |y| image[px + 4, y] = color }
+          image[px + 4, py + 9] = color
+          image[px + 5, py + 9] = color
+        when "╮"
+          (px..px + 3).each { |x| image[x, py + 8] = color }
+          (py + 10..py + 15).each { |y| image[px + 4, y] = color }
+          image[px + 4, py + 9] = color
+          image[px + 3, py + 9] = color
+        when "╯"
+          (px..px + 3).each { |x| image[x, py + 8] = color }
+          (py..py + 6).each { |y| image[px + 4, y] = color }
+          image[px + 4, py + 7] = color
+          image[px + 3, py + 7] = color
+        when "╰"
+          (px + 5..px + 7).each { |x| image[x, py + 8] = color }
+          (py..py + 6).each { |y| image[px + 4, y] = color }
+          image[px + 4, py + 7] = color
+          image[px + 5, py + 7] = color
+        end
+      else # :light
+        if left
+          (px..cx).each { |x| image[x, cy] = color }
+        end
+        if right
+          (cx..(px + 7)).each { |x| image[x, cy] = color }
+        end
+        if up
+          (py..cy).each { |y| image[cx, y] = color }
+        end
+        if down
+          (cy..(py + 15)).each { |y| image[cx, y] = color }
+        end
+      end
+    end
+
+    def draw_cursor(image)
+      cursor_info = @state[:cursor] || @state["cursor"] || {}
+      cursor_vis = @state[:cursor_visible]
+      cursor_vis = cursor_info[:visible] if cursor_vis.nil?
+      cursor_vis = cursor_info["visible"] if cursor_vis.nil?
+      cursor_vis = false if cursor_vis.nil? # default invisible
+
+      return unless cursor_vis
+
+      ri = cursor_info[:row] || cursor_info["row"] || 0
+      ci = cursor_info[:col] || cursor_info["col"] || 0
+
+      return if ri < 0 || ri >= @rows || ci < 0 || ci >= @cols
+
+      style_val = @state[:cursor_style] || cursor_info[:style] || cursor_info["style"] || 1
+
+      px = ci * CELL_W
+      py = ri * CELL_H
+
+      color_rgb = [255, 255, 255] # Weiß standardmäßig
+      color = ChunkyPNG::Color.rgb(*color_rgb)
+
+      case style_val
+      when 1, 2 # Blinking Block oder Steady Block
+        CELL_H.times do |dy|
+          CELL_W.times do |dx|
+            x = px + dx
+            y = py + dy
+            next if x >= image.width || y >= image.height
+            original_color = image[x, y]
+            r = 255 - ChunkyPNG::Color.r(original_color)
+            g = 255 - ChunkyPNG::Color.g(original_color)
+            b = 255 - ChunkyPNG::Color.b(original_color)
+            image[x, y] = ChunkyPNG::Color.rgb(r, g, b)
+          end
+        end
+      when 3, 4 # Underline
+        2.times do |h_offset|
+          y = py + CELL_H - 1 - h_offset
+          next if y >= image.height
+          CELL_W.times do |dx|
+            x = px + dx
+            next if x >= image.width
+            image[x, y] = color
+          end
+        end
+      when 5, 6 # Bar
+        2.times do |w_offset|
+          x = px + w_offset
+          next if x >= image.width
+          CELL_H.times do |dy|
+            y = py + dy
+            next if y >= image.height
+            image[x, y] = color
+          end
+        end
+      end
+    end
+
+    def draw_chevron(image, px, py, fg_rgb)
+      color = ChunkyPNG::Color.rgb(*fg_rgb)
+      (0..3).each do |i|
+        image[px + 2 + i, py + 4 + i] = color
+        image[px + 3 + i, py + 4 + i] = color # bold/thick chevron
+        
+        image[px + 5 - i, py + 8 + i] = color
+        image[px + 6 - i, py + 8 + i] = color # bold/thick chevron
+      end
+    end
+
+    def draw_circle(image, px, py, fg_rgb)
+      color = ChunkyPNG::Color.rgb(*fg_rgb)
+      cx = px + 4
+      cy = py + 8
+      (-3..3).each do |dy|
+        r_width = case dy.abs
+                  when 3 then 1
+                  when 2 then 2
+                  else 3
+                  end
+        (-r_width..r_width).each do |dx|
+          x = cx + dx
+          y = cy + dy
+          next if x < px || x >= px + CELL_W || y < py || y >= py + CELL_H
+          image[x, y] = color
+        end
+      end
+    end
+
+    def draw_braille(image, px, py, char, fg_rgb)
+      color = ChunkyPNG::Color.rgb(*fg_rgb)
+      mask = char.ord - 0x2800
+      dot_coords = [
+        [2, 3],  # Dot 1
+        [2, 6],  # Dot 2
+        [2, 9],  # Dot 3
+        [5, 3],  # Dot 4
+        [5, 6],  # Dot 5
+        [5, 9],  # Dot 6
+        [2, 12], # Dot 7
+        [5, 12]  # Dot 8
+      ]
+      dot_coords.each_with_index do |(dx, dy), idx|
+        if (mask & (1 << idx)) != 0
+          2.times do |ddy|
+            2.times do |ddx|
+              x = px + dx + ddx
+              y = py + dy + ddy
+              next if x >= image.width || y >= image.height
+              image[x, y] = color
+            end
+          end
+        end
+      end
+    end
+
+    def draw_up_triangle(image, px, py, fg_rgb)
+      color = ChunkyPNG::Color.rgb(*fg_rgb)
+      (5..8).each do |dy|
+        width = dy - 5
+        (4 - width..4 + width).each do |dx|
+          image[px + dx, py + dy] = color
+        end
+      end
+    end
+
+    def draw_down_triangle(image, px, py, fg_rgb)
+      color = ChunkyPNG::Color.rgb(*fg_rgb)
+      (5..8).each do |dy|
+        width = 8 - dy
+        (4 - width..4 + width).each do |dx|
+          image[px + dx, py + dy] = color
+        end
+      end
+    end
+
+    def draw_checkmark(image, px, py, fg_rgb)
+      color = ChunkyPNG::Color.rgb(*fg_rgb)
+      image[px + 2, py + 8] = color
+      image[px + 3, py + 9] = color
+      image[px + 4, py + 10] = color
+      image[px + 5, py + 8] = color
+      image[px + 6, py + 6] = color
+      image[px + 7, py + 4] = color
+    end
+
+    def draw_ballot_x(image, px, py, fg_rgb)
+      color = ChunkyPNG::Color.rgb(*fg_rgb)
+      image[px + 2, py + 5] = color
+      image[px + 3, py + 6] = color
+      image[px + 3, py + 7] = color
+      image[px + 4, py + 8] = color
+      image[px + 5, py + 9] = color
+      image[px + 5, py + 10] = color
+      image[px + 6, py + 11] = color
+      image[px + 2, py + 11] = color
+      image[px + 3, py + 10] = color
+      image[px + 3, py + 9] = color
+      image[px + 5, py + 7] = color
+      image[px + 5, py + 6] = color
+      image[px + 6, py + 5] = color
+    end
+
+    def draw_up_arrow(image, px, py, fg_rgb)
+      color = ChunkyPNG::Color.rgb(*fg_rgb)
+      (3..12).each { |dy| image[px + 4, py + dy] = color }
+      image[px + 3, py + 4] = color
+      image[px + 5, py + 4] = color
+      image[px + 2, py + 5] = color
+      image[px + 6, py + 5] = color
+    end
+
+    def draw_down_arrow(image, px, py, fg_rgb)
+      color = ChunkyPNG::Color.rgb(*fg_rgb)
+      (3..12).each { |dy| image[px + 4, py + dy] = color }
+      image[px + 3, py + 11] = color
+      image[px + 5, py + 11] = color
+      image[px + 2, py + 10] = color
+      image[px + 6, py + 10] = color
+    end
+
+    def draw_right_arrow(image, px, py, fg_rgb)
+      color = ChunkyPNG::Color.rgb(*fg_rgb)
+      (1..6).each { |dx| image[px + dx, py + 8] = color }
+      image[px + 5, py + 7] = color
+      image[px + 5, py + 9] = color
+      image[px + 4, py + 6] = color
+      image[px + 4, py + 10] = color
+    end
+
+    def draw_gear(image, px, py, fg_rgb)
+      color = ChunkyPNG::Color.rgb(*fg_rgb)
+      image[px + 4, py + 6] = color
+      image[px + 4, py + 10] = color
+      image[px + 2, py + 8] = color
+      image[px + 6, py + 8] = color
+      image[px + 3, py + 7] = color
+      image[px + 5, py + 7] = color
+      image[px + 3, py + 9] = color
+      image[px + 5, py + 9] = color
+      image[px + 4, py + 5] = color
+      image[px + 4, py + 11] = color
+      image[px + 1, py + 8] = color
+      image[px + 7, py + 8] = color
+      image[px + 2, py + 6] = color
+      image[px + 6, py + 6] = color
+      image[px + 2, py + 10] = color
+      image[px + 6, py + 10] = color
+    end
+
+    def draw_warning(image, px, py, fg_rgb)
+      color = ChunkyPNG::Color.rgb(*fg_rgb)
+      image[px + 4, py + 3] = color
+      image[px + 3, py + 4] = color
+      image[px + 5, py + 4] = color
+      image[px + 3, py + 5] = color
+      image[px + 5, py + 5] = color
+      image[px + 2, py + 6] = color
+      image[px + 6, py + 6] = color
+      image[px + 2, py + 7] = color
+      image[px + 6, py + 7] = color
+      image[px + 1, py + 8] = color
+      image[px + 7, py + 8] = color
+      image[px + 1, py + 9] = color
+      image[px + 7, py + 9] = color
+      (1..7).each { |dx| image[px + dx, py + 10] = color }
+      image[px + 4, py + 5] = color
+      image[px + 4, py + 6] = color
+      image[px + 4, py + 7] = color
+      image[px + 4, py + 9] = color
+    end
+
+    def draw_ellipsis(image, px, py, fg_rgb)
+      color = ChunkyPNG::Color.rgb(*fg_rgb)
+      image[px + 1, py + 12] = color
+      image[px + 4, py + 12] = color
+      image[px + 6, py + 12] = color
+    end
+
+    def draw_left_arrow(image, px, py, fg_rgb)
+      color = ChunkyPNG::Color.rgb(*fg_rgb)
+      (1..6).each { |dx| image[px + dx, py + 8] = color }
+      image[px + 2, py + 7] = color
+      image[px + 2, py + 9] = color
+      image[px + 3, py + 6] = color
+      image[px + 3, py + 10] = color
+    end
+
+    def draw_left_half_block(image, px, py, fg_rgb)
+      fill_rect(image, px, py, 4, CELL_H, fg_rgb)
+    end
+
+    def draw_right_half_block(image, px, py, fg_rgb)
+      fill_rect(image, px + 4, py, 4, CELL_H, fg_rgb)
+    end
+
+    def draw_checkbox_border(image, px, py, color)
+      (1..6).each do |dx|
+        image[px + dx, py + 4] = color
+        image[px + dx, py + 11] = color
+      end
+      (4..11).each do |dy|
+        image[px + 1, py + dy] = color
+        image[px + 6, py + dy] = color
+      end
+    end
+
+    def draw_empty_checkbox(image, px, py, fg_rgb)
+      color = ChunkyPNG::Color.rgb(*fg_rgb)
+      draw_checkbox_border(image, px, py, color)
+    end
+
+    def draw_checked_checkbox(image, px, py, fg_rgb)
+      color = ChunkyPNG::Color.rgb(*fg_rgb)
+      draw_checkbox_border(image, px, py, color)
+      image[px + 2, py + 8] = color
+      image[px + 3, py + 9] = color
+      image[px + 4, py + 7] = color
+      image[px + 5, py + 5] = color
+    end
+
+    def draw_x_checkbox(image, px, py, fg_rgb)
+      color = ChunkyPNG::Color.rgb(*fg_rgb)
+      draw_checkbox_border(image, px, py, color)
+      image[px + 2, py + 5] = color
+      image[px + 2, py + 6] = color
+      image[px + 3, py + 7] = color
+      image[px + 3, py + 8] = color
+      image[px + 4, py + 7] = color
+      image[px + 4, py + 8] = color
+      image[px + 5, py + 9] = color
+      image[px + 5, py + 10] = color
+      image[px + 2, py + 10] = color
+      image[px + 2, py + 9] = color
+      image[px + 5, py + 6] = color
+      image[px + 5, py + 5] = color
+    end
+
+    def draw_info_symbol(image, px, py, fg_rgb)
+      color = ChunkyPNG::Color.rgb(*fg_rgb)
+      (3..5).each do |dx|
+        image[px + dx, py + 4] = color
+        image[px + dx, py + 12] = color
+      end
+      image[px + 2, py + 5] = color
+      image[px + 6, py + 5] = color
+      image[px + 2, py + 11] = color
+      image[px + 6, py + 11] = color
+      (6..10).each do |dy|
+        image[px + 1, py + dy] = color
+        image[px + 7, py + dy] = color
+      end
+      image[px + 4, py + 6] = color
+      (8..10).each do |dy|
+        image[px + 4, py + dy] = color
+      end
+    end
+
+    def draw_heavy_x(image, px, py, fg_rgb)
+      color = ChunkyPNG::Color.rgb(*fg_rgb)
+      [4, 5, 11, 12].each do |dy|
+        image[px + 1, py + dy] = color
+        image[px + 2, py + dy] = color
+        image[px + 5, py + dy] = color
+        image[px + 6, py + dy] = color
+      end
+      [6, 7, 9, 10].each do |dy|
+        image[px + 2, py + dy] = color
+        image[px + 3, py + dy] = color
+        image[px + 4, py + dy] = color
+        image[px + 5, py + dy] = color
+      end
+      image[px + 3, py + 8] = color
+      image[px + 4, py + 8] = color
+    end
+
   end
 end

data/lib/tui_td/state.rb

@@ -4,7 +4,7 @@ module TUITD
   # Represents the parsed state of a terminal screen.
   # Provides high-level query methods for AI consumption.
   class State
-    attr_reader :rows, :cols, :grid, :cursor
+    attr_reader :rows, :cols, :grid, :cursor, :cursor_visible, :cursor_style, :mouse_mode, :mouse_format
 
     def initialize(data)
       raise ArgumentError, "State data must include :size key" unless data[:size]
@@ -14,6 +14,13 @@ module TUITD
       @cols = data[:size][:cols]
       @grid = data[:rows]
       @cursor = data[:cursor]
+
+      cursor_info = data[:cursor].is_a?(Hash) ? data[:cursor] : {}
+      @cursor_visible = data.key?(:cursor_visible) ? data[:cursor_visible] : (cursor_info[:visible] != false)
+      @cursor_style = data.key?(:cursor_style) ? data[:cursor_style] : (cursor_info[:style] || 1)
+
+      @mouse_mode = data[:mouse_mode] || :none
+      @mouse_format = data[:mouse_format] || :normal
     end
 
     # Get plain text of the entire terminal (no ANSI)

data/lib/tui_td/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TUITD
-  VERSION = "0.2.5"
+  VERSION = "0.2.7"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tui-td
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.7
 platform: ruby
 authors:
 - Haluk Durmus