ruby-progress 1.3.5 → 1.3.7

data/lib/ruby-progress/daemon.rb

@@ -9,14 +9,39 @@ module RubyProgress
   module Daemon
     module_function
 
+    # Return the default PID file path used by ruby-progress daemons.
+    #
+    # @return [String] The filesystem path to the default PID file.
+    # @example
+    #   RubyProgress::Daemon.default_pid_file
+    #   #=> "/tmp/ruby-progress/progress.pid"
     def default_pid_file
       '/tmp/ruby-progress/progress.pid'
     end
 
+    # Return the path for the control message file corresponding to a PID file.
+    # The control message file is used to pass JSON-encoded messages to a running
+    # daemon (for example, success/failure metadata or a final message).
+    #
+    # @param pid_file [String] the path to the pid file
+    # @return [String] the control-message file path (pid_file + ".msg")
+    # @example
+    #   RubyProgress::Daemon.control_message_file('/tmp/foo.pid')
+    #   #=> '/tmp/foo.pid.msg'
     def control_message_file(pid_file)
       "#{pid_file}.msg"
     end
 
+    # Print the daemon status for the given PID file and exit with an appropriate
+    # exit code. If the PID file exists and the process is running this prints
+    # a message and exits 0. If the PID file exists but the process is not
+    # running this prints a warning and exits 1. If the PID file does not
+    # exist this prints that the daemon is not running and exits 1.
+    #
+    # @param pid_file [String] path to the pid file
+    # @return [void]
+    # @example
+    #   RubyProgress::Daemon.show_status('/tmp/ruby-progress/progress.pid')
     def show_status(pid_file)
       if File.exist?(pid_file)
         pid = File.read(pid_file).strip
@@ -29,6 +54,23 @@ module RubyProgress
       end
     end
 
+    # Stop a running daemon by reading its PID from the given pid file. Optionally
+    # write a small JSON control message (containing :checkmark and :message keys)
+    # to the corresponding control message file before signalling the process.
+    # The method attempts to send SIGUSR1 to the running process, sleeps briefly
+    # to allow the process to handle the signal, and then removes the pid file.
+    #
+    # This helper prints user-friendly errors and exits with non-zero status when
+    # the pid file is missing, the process cannot be found, or permission is
+    # denied when sending the signal.
+    #
+    # @param pid_file [String] path to the pid file
+    # @param message [String, nil] optional message to send to the daemon via the control file
+    # @param checkmark [Boolean] whether to include a checkmark flag in the control payload
+    # @param error [Boolean] whether this stop represents an error (affects success flag in payload)
+    # @return [void]
+    # @example
+    #   RubyProgress::Daemon.stop_daemon_by_pid_file('/tmp/ruby-progress/progress.pid', message: 'Stopping', checkmark: true)
     def stop_daemon_by_pid_file(pid_file, message: nil, checkmark: false, error: false)
       unless File.exist?(pid_file)
         puts "PID file #{pid_file} not found"

data/lib/ruby-progress/fill.rb

@@ -3,6 +3,16 @@
 module RubyProgress
   # Determinate progress bar with customizable fill styles
   class Fill
+    # A simple determinate progress bar that can be advanced programmatically
+    # or used with the block-based convenience method {Fill.progress}.
+    #
+    # Public API (instance): #advance, #percent=, #completed?, #render, #complete, #cancel
+    # Public API (class): .progress, .parse_custom_style
+    #
+    # @example
+    #   Fill.progress(length: 10) do |bar|
+    #     10.times { bar.advance; sleep 0.1 }
+    #   end
     # Built-in fill styles with empty and full characters
     FILL_STYLES = {
       blocks: { empty: '▱', full: '▰' },
@@ -19,6 +29,14 @@ module RubyProgress
     attr_reader :length, :style, :current_progress, :start_chars, :end_chars
     attr_accessor :success_message, :error_message
 
+    # Initialize a progress bar instance.
+    #
+    # @param options [Hash] configuration values
+    # @option options [Integer] :length number of cells in the bar (default 20)
+    # @option options [Symbol,String,Hash] :style style name, symbol, or custom hash
+    # @option options [String] :success success message shown on completion
+    # @option options [String] :error error message shown on cancel/exception
+    # @return [void]
     def initialize(options = {})
       @length = options[:length] || 20
       @style = parse_style(options[:style] || :blocks)
@@ -36,7 +54,11 @@ module RubyProgress
       end
     end
 
-    # Advance the progress bar by one step or specified increment
+    # Advance the progress bar by one step or specified increment.
+    #
+    # @param increment [Integer] amount to increase progress by (default 1)
+    # @param percent [Numeric,nil] optional percent to set the bar to (0-100)
+    # @return [Boolean] true if the bar is complete after advancing
     def advance(increment: 1, percent: nil)
       @current_progress = if percent
                             [@length * percent / 100.0, @length].min.round
@@ -48,7 +70,10 @@ module RubyProgress
       completed?
     end
 
-    # Set progress to specific percentage (0-100)
+    # Set progress to specific percentage (0-100).
+    #
+    # @param percent [Numeric] percentage 0..100 to set the bar to
+    # @return [Boolean] true if the bar is complete after setting percent
     def percent=(percent)
       percent = percent.clamp(0, 100) # Clamp between 0-100
       @current_progress = (@length * percent / 100.0).round
@@ -56,22 +81,30 @@ module RubyProgress
       completed?
     end
 
-    # Check if progress bar is complete
+    # Check if progress bar is complete.
+    #
+    # @return [Boolean]
     def completed?
       @current_progress >= @length
     end
 
-    # Get current progress as percentage
+    # Get current progress as percentage.
+    #
+    # @return [Float] percentage (0.0-100.0) rounded to 1 decimal place
     def percent
       (@current_progress.to_f / @length * 100).round(1)
     end
 
-    # Get current progress as float (0.0-100.0) - for scripting
+    # Get current progress as float (0.0-100.0) - for scripting.
+    #
+    # @return [Float]
     def current
       (@current_progress.to_f / @length * 100).round(1)
     end
 
-    # Get detailed progress status information
+    # Get detailed progress status information.
+    #
+    # @return [Hash] structured status information about the bar
     def report
       {
         progress: [@current_progress, @length],
@@ -81,7 +114,9 @@ module RubyProgress
       }
     end
 
-    # Render the current progress bar to stderr
+    # Render the current progress bar to stderr.
+    #
+    # @return [void]
     def render
       # First redraw captured output (if any) so it appears above/below the bar
       @output_capture&.redraw($stderr)
@@ -94,7 +129,11 @@ module RubyProgress
       $stderr.flush
     end
 
-    # Complete the progress bar and show success message
+    # Complete the progress bar and show success message.
+    #
+    # @param message [String,nil] optional override message
+    # @param icons [Hash] optional icons map passed to Utils.display_completion
+    # @return [void]
     def complete(message = nil, icons: {})
       @current_progress = @length
       render
@@ -113,7 +152,10 @@ module RubyProgress
       end
     end
 
-    # Cancel the progress bar and show error message
+    # Cancel the progress bar and show error message.
+    #
+    # @param message [String,nil] optional override message
+    # @return [void]
     def cancel(message = nil)
       $stderr.print "\r\e[2K" # Clear the progress bar
       $stderr.flush

data/lib/ruby-progress/fill_cli.rb

@@ -12,6 +12,10 @@ module RubyProgress
   # rubocop:disable Metrics/ClassLength
   module FillCLI
     class << self
+      # Entrypoint for the `prg fill` CLI. Parses options and dispatches to
+      # the matching behavior (auto-advance, command-run, daemon, report).
+      #
+      # @return [void]
       def run
         trap('INT') do
           Utils.show_cursor

data/lib/ruby-progress/output_capture.rb

@@ -13,11 +13,64 @@ rescue LoadError
 end
 
 module RubyProgress
+  # Shell execution helpers for spawning commands within a PTY
+  module ShellExec
+    module_function
+
+    # Build argv for invoking the user's shell with a command string.
+    # Uses login shells so aliases/functions and environment are available.
+    #
+    # @param shell [String] path to shell executable
+    # @param command [String] command to execute
+    # @return [Array<String>] argv (excluding the shell path for convenience)
+    def build_shell_argv(shell, command)
+      shell_name = File.basename(shell)
+      case shell_name
+      when 'fish'
+        ['-l', '-c', command]
+      else
+        ['-lc', command]
+      end
+    end
+  end
+
+  # Output helpers for reserving terminal space
+  module OutputUI
+    module_function
+
+    def reserve_space(io, position, lines)
+      return unless io.tty?
+
+      if position == :above
+        io.print "\e[#{lines}L"
+      else
+        io.print("\n" * lines)
+        io.print "\e[#{lines}A"
+      end
+
+      io.flush
+    end
+  end
+
   # PTY-based live output capture that reserves a small terminal area
   # for printing captured output while the animation draws elsewhere.
   class OutputCapture
     attr_reader :exit_status
 
+    # Create a new OutputCapture instance.
+    #
+    # @param command [String] the shell command to spawn and capture via PTY
+    # @param lines [Integer] number of reserved lines to keep for captured output (minimum 1)
+    # @param position [Symbol,String] :above/:below (or :top/:bottom) to place the reserved area
+    # @param log_path [String,nil] optional path to append raw captured output
+    # @param stream [Boolean] when true, redraw captured output live into the terminal area
+    # @param debug [Boolean,nil] enable debug logging when true; nil will consult ENV['RUBY_PROGRESS_DEBUG']
+    # @return [OutputCapture]
+    # @example
+    #   oc = RubyProgress::OutputCapture.new(command: 'bundle exec rspec', lines: 4, position: :below)
+    #   oc.start
+    #   oc.wait
+    #   oc.flush_to($stdout)
     def initialize(command:, lines: 3, position: :above, log_path: nil, stream: false, debug: nil)
       @command = command
       # Coerce lines into a positive Integer
@@ -63,30 +116,49 @@ module RubyProgress
     end
 
     # Start capturing the child process. Returns self.
+    #
+    # This spawns the configured command in a PTY and begins a background
+    # reader thread which buffers the most recent lines. When +stream+ is true
+    # the captured lines are redrawn into the terminal area reserved by
+    # {#reserve_space}.
     def start
-      reserve_space($stderr) if @stream
+      OutputUI.reserve_space($stderr, @position, @lines) if @stream
       @reader_thread = Thread.new { spawn_and_read }
       self
     end
 
+    # Signal the reader thread to stop and wait for it to finish.
+    # @return [void]
     def stop
       @stop = true
       @reader_thread&.join
     end
 
+    # Wait for the background reader thread to finish and return control to
+    # the caller. This is a simple join wrapper used by callers that need to
+    # block until the captured command completes.
+    #
+    # @return [Thread, nil] the joined thread or nil if not started
     def wait
       @reader_thread&.join
     end
 
+    # Return a snapshot of the currently buffered lines.
+    # @return [Array<String>]
     def lines
       @buf_mutex.synchronize { @buffer.dup }
     end
 
+    # Return true when the background reader thread is alive.
+    # @return [Boolean]
     def alive?
       @reader_thread&.alive? || false
     end
 
     # Redraw the reserved area using the current buffered lines.
+    #
+    # @param io [IO] the IO stream to draw into (defaults to $stderr)
+    # @return [void]
     def redraw(io = $stderr)
       buf = lines
       debug_log("redraw called; buffer=#{buf.size}; lines=#{@lines}; position=#{@position}")
@@ -154,6 +226,9 @@ module RubyProgress
     # Flush the buffered lines to the given IO (defaults to STDOUT).
     # This is used when capturing non-live output: capture silently during
     # the run and emit all captured output at the end.
+    #
+    # @param io [IO] the IO to write captured lines to (defaults to STDOUT)
+    # @return [void]
     def flush_to(io = $stdout)
       buf = lines
       return if buf.empty?
@@ -171,16 +246,35 @@ module RubyProgress
     private
 
     def spawn_and_read
-      PTY.spawn(@command) do |reader, _writer, pid|
+      # Run the command through the user's login shell so that shell aliases,
+      # functions, and PATH modifications are available.
+      shell = ENV['SHELL'] || '/bin/sh'
+      argv = ShellExec.build_shell_argv(shell, @command)
+
+      debug_log("spawning via shell=#{shell} argv=#{argv.inspect} raw_cmd=#{@command.inspect}")
+
+      PTY.spawn(shell, *argv) do |reader, _writer, pid|
         @child_pid = pid
         debug_log("spawned pid=#{pid} cmd=#{@command}")
 
         until reader.eof? || @stop
-          ready = if reader.respond_to?(:wait_readable)
-                    reader.wait_readable(0.1)
-                  else
-                    IO.select([reader], nil, nil, 0.1)
-                  end
+          # Prefer IO#wait_readable when available (avoids Fiber scheduler issues).
+          # If not available, attempt to use an underlying IO via #to_io, otherwise
+          # fall back to a short sleep to avoid calling deprecated/select APIs.
+          io = if reader.respond_to?(:wait_readable)
+                 reader
+               elsif reader.respond_to?(:to_io)
+                 reader.to_io
+               end
+
+          # Prefer IO#wait_readable when available (use safe navigation).
+          if io.respond_to?(:wait_readable)
+            ready = io.wait_readable(0.1)
+          else
+            # Best-effort fallback: sleep briefly and continue reading loop.
+            sleep 0.1
+            ready = true
+          end
           next unless ready
 
           chunk = reader.read_nonblock(4096, exception: false)
@@ -249,25 +343,6 @@ module RubyProgress
       end
     end
 
-    def reserve_space(io = $stderr)
-      return unless io.tty?
-
-      debug_log("reserve_space called; position=#{@position.inspect}; lines=#{@lines}")
-
-      if @position == :above
-        # Insert lines above current cursor using CSI n L
-        io.print "\e[#{@lines}L"
-        debug_log("reserve_space: inserted #{@lines} lines for :above")
-      else
-        # Print newlines then move cursor back up so animation stays above
-        io.print("\n" * @lines)
-        io.print "\e[#{@lines}A"
-        debug_log("reserve_space: printed #{@lines} newlines and moved up #{@lines} for :below")
-      end
-
-      io.flush
-    rescue StandardError => e
-      debug_log("reserve_space error: #{e.class}: #{e.message}")
-    end
+    # reserve_space moved to RubyProgress::OutputUI
   end
 end

data/lib/ruby-progress/ripple.rb

@@ -56,6 +56,11 @@ module RubyProgress
 
   # String extensions for color support
   module StringExtensions
+    # Extensions that add colorization helpers to String instances.
+    # Methods are dynamically defined from the COLORS map (e.g. #red, #green).
+    #
+    # Example:
+    #   "hello".red #=> "\e[31mhello\e[0m"
     COLORS.each do |color_name, color_code|
       define_method(color_name) do
         "#{color_code}#{self}#{COLORS['reset']}"
@@ -63,6 +68,11 @@ module RubyProgress
     end
 
     def rainbow(index = 0)
+      # Apply a per-character rainbow by cycling through the COLORS map.
+      #
+      # @param index [Integer] an optional offset to shift the colors
+      # @return [String] colorized string where each character is wrapped
+      #   in a terminal color escape sequence
       chars = self.chars
       colored_chars = chars.map.with_index do |char, idx|
         color = COLORS.values[(idx + index) % COLORS.size]
@@ -72,6 +82,11 @@ module RubyProgress
     end
 
     def normalize_type
+      # Attempt to guess a spinner indicator type from this string's
+      # characters. Returns a symbol matching one of INDICATORS keys or
+      # :classic as fallback.
+      #
+      # @return [Symbol]
       spinner_type = :classic
       INDICATORS.each do |spinner, _v|
         spinner_type = spinner if spinner =~ /^#{chars.join('.*?')}/i
@@ -82,9 +97,21 @@ module RubyProgress
 
   # Text ripple animation class
   class Ripple
+    # Public API:
+    # - instance: #advance, #printout
+    # - class: .progress (block-based helper), .complete
     attr_accessor :index, :string, :speed, :format, :inverse, :rainbow, :spinner, :spinner_position, :caps
 
     def initialize(string, options = {})
+      # Create a new Ripple animation for the given string.
+      #
+      # @param string [String] the text to animate
+      # @param options [Hash] configuration options (speed, format, rainbow, etc.)
+      # @option options [Symbol] :speed (:medium) animation speed :fast/:medium/:slow
+      # @option options [Symbol] :format (:bidirectional) :bidirectional/:forward_only
+      # @option options [Boolean] :rainbow (false) colorize characters individually
+      # @option options [Boolean] :spinner (false) use a spinner glyph instead of ripple
+      # @return [void]
       defaults = {
         speed: :medium,
         format: :bidirectional,
@@ -109,6 +136,10 @@ module RubyProgress
     end
 
     def printout
+      # Render a single frame of the ripple to stderr, preserving any
+      # reserved output area managed by OutputCapture.
+      #
+      # @return [void]
       letters = @string.dup.chars
       i = @index
       if @spinner
@@ -154,7 +185,19 @@ module RubyProgress
       RubyProgress::Utils.show_cursor
     end
 
+    # Show the cursor in the terminal. Delegates to Utils.
+    #
+    # @return [void]
+
     def self.complete(string, message, checkmark, success, icons: {})
+      # Display a final completion message for the ripple indicator.
+      #
+      # @param string [String] fallback message
+      # @param message [String,nil] explicit message to show
+      # @param checkmark [Boolean] whether to show a checkmark
+      # @param success [Boolean] whether the result is success
+      # @param icons [Hash] optional icons mapping
+      # @return [void]
       display_message = message || (checkmark ? string : nil)
       return unless display_message
 
@@ -197,6 +240,15 @@ module RubyProgress
     end
 
     def self.progress(string, options = {})
+      # Block-style helper which runs the ripple animation while the
+      # provided block executes. The cursor is hidden for the duration and
+      # restored afterwards. This method attempts to return a sensible
+      # value depending on the :output option (see code).
+      #
+      # @param string [String] the label text to animate
+      # @param options [Hash] configuration options forwarded to Ripple.new
+      # @yield the work to perform while the animation runs
+      # @return [Object,nil] returns block result or boolean depending on :output
       Signal.trap('INT') do
         Thread.current.kill
         nil

data/lib/ruby-progress/utils.rb

@@ -1,17 +1,37 @@
 # frozen_string_literal: true
 
 module RubyProgress
-  # Universal terminal utilities shared between progress indicators
+  # Universal terminal utilities shared between progress indicators.
+  #
+  # This module provides common functionality for terminal manipulation,
+  # cursor control, and output formatting used across all progress indicator types.
   module Utils
-    # Terminal cursor control
+    # Hides the terminal cursor.
+    #
+    # @return [void]
+    # @example
+    #   RubyProgress::Utils.hide_cursor
     def self.hide_cursor
       $stderr.print "\e[?25l"
     end
 
+    # Shows the terminal cursor.
+    #
+    # @return [void]
+    # @example
+    #   RubyProgress::Utils.show_cursor
     def self.show_cursor
       $stderr.print "\e[?25h"
     end
 
+    # Clears the current terminal line.
+    #
+    # @param output_stream [Symbol, IO] Stream to clear (:stdout, :stderr, or IO object)
+    # @return [void]
+    # @example Clear to stderr (default)
+    #   RubyProgress::Utils.clear_line
+    # @example Clear to stdout
+    #   RubyProgress::Utils.clear_line(:stdout)
     def self.clear_line(output_stream = :stderr)
       io = case output_stream
            when :stdout
@@ -26,18 +46,40 @@ module RubyProgress
       io.print "\r\e[K"
     end
 
-    # Enhanced line clearing for daemon mode that handles output interruption
+    # Enhanced line clearing for daemon mode that handles output interruption.
+    #
+    # Clears the current line and the line above it, useful when daemon
+    # output has been interrupted by other command output.
+    #
+    # @return [void]
+    # @example
+    #   RubyProgress::Utils.clear_line_aggressive
     def self.clear_line_aggressive
       $stderr.print "\r\e[2K"    # Clear entire current line
       $stderr.print "\e[1A\e[2K" # Move up one line and clear it too
       $stderr.print "\r"         # Return to start of line
     end
 
-    # Universal completion message display
+    # Displays a completion message with optional icons and formatting.
+    #
+    # Universal completion message display that handles success/error states,
+    # custom icons, and output stream selection.
+    #
     # @param message [String] The message to display
-    # @param success [Boolean] Whether this represents success or failure
+    # @param success [Boolean] Whether this represents success (true) or failure (false)
     # @param show_checkmark [Boolean] Whether to show checkmark/X symbols
-    # @param output_stream [Symbol] Where to output (:stdout, :stderr, :warn)
+    # @param output_stream [Symbol, IO] Where to output (:stdout, :stderr, :warn, or IO object)
+    # @param icons [Hash] Custom icons hash with :success and :error keys
+    # @option icons [String] :success Custom success icon (overrides default ✅)
+    # @option icons [String] :error Custom error icon (overrides default 🛑)
+    # @return [void]
+    # @example Basic success message
+    #   RubyProgress::Utils.display_completion("Done!", success: true, show_checkmark: true)
+    # @example With custom icons
+    #   RubyProgress::Utils.display_completion("Build complete",
+    #     success: true,
+    #     show_checkmark: true,
+    #     icons: { success: '🚀', error: '💥' })
     def self.display_completion(message, success: true, show_checkmark: false, output_stream: :warn, icons: {})
       return unless message
 
@@ -87,16 +129,42 @@ module RubyProgress
       end
     end
 
-    # Clear current line and display completion message
-    # Convenience method that combines line clearing with message display
+    # Clears the current line and displays a completion message.
+    #
+    # Convenience method that combines line clearing with message display.
+    # Note: When output_stream is :warn, line clearing is already included
+    # in display_completion.
+    #
+    # @param message [String] The message to display
+    # @param success [Boolean] Whether this represents success (true) or failure (false)
+    # @param show_checkmark [Boolean] Whether to show checkmark/X symbols
+    # @param output_stream [Symbol, IO] Where to output (:stdout, :stderr, :warn, or IO object)
+    # @param icons [Hash] Custom icons hash with :success and :error keys
+    # @return [void]
+    # @see display_completion
+    # @example
+    #   RubyProgress::Utils.complete_with_clear("Task complete", success: true, show_checkmark: true)
     def self.complete_with_clear(message, success: true, show_checkmark: false, output_stream: :warn, icons: {})
       clear_line(output_stream) if output_stream != :warn # warn already includes clear in display_completion
       display_completion(message, success: success, show_checkmark: show_checkmark, output_stream: output_stream, icons: icons)
     end
 
-    # Parse start/end characters for animation wrapping
-    # @param ends_string [String] Even-length string to split in half for start/end chars
+    # Parses start/end characters for animation wrapping.
+    #
+    # Takes an even-length string and splits it in half to create start
+    # and end decorative characters for progress indicators. Handles
+    # multi-byte characters correctly.
+    #
+    # @param ends_string [String, nil] Even-length string to split in half
     # @return [Array<String>] Array with [start_chars, end_chars]
+    # @example Basic decoration
+    #   RubyProgress::Utils.parse_ends("[]")  # => ["[", "]"]
+    # @example Multi-character decoration
+    #   RubyProgress::Utils.parse_ends("<<>>")  # => ["<<", ">>"]
+    # @example Emoji decoration
+    #   RubyProgress::Utils.parse_ends("🎯🎪")  # => ["🎯", "🎪"]
+    # @example Empty or nil input
+    #   RubyProgress::Utils.parse_ends(nil)  # => ["", ""]
     def self.parse_ends(ends_string)
       return ['', ''] unless ends_string && !ends_string.empty?
 
@@ -110,7 +178,20 @@ module RubyProgress
       [start_chars, end_chars]
     end
 
-    # Validate ends string: must be non-empty and even-length (handles multi-byte chars)
+    # Validates an ends string for proper format.
+    #
+    # Checks that the string is non-empty and has an even number of
+    # characters (handles multi-byte characters correctly).
+    #
+    # @param ends_string [String, nil] String to validate
+    # @return [Boolean] true if valid, false otherwise
+    # @example Valid strings
+    #   RubyProgress::Utils.ends_valid?("[]")  # => true
+    #   RubyProgress::Utils.ends_valid?("🎯🎪")  # => true
+    # @example Invalid strings
+    #   RubyProgress::Utils.ends_valid?("abc")  # => false (odd length)
+    #   RubyProgress::Utils.ends_valid?("")     # => false (empty)
+    #   RubyProgress::Utils.ends_valid?(nil)    # => false (nil)
     def self.ends_valid?(ends_string)
       return false unless ends_string && !ends_string.empty?
 

data/lib/ruby-progress/version.rb

@@ -2,11 +2,18 @@
 
 module RubyProgress
   # Main gem version
-  VERSION = '1.3.5'
+  # Main gem version
+  # @return [String]
+  VERSION = '1.3.7'
 
   # Component-specific versions (patch bumps)
-  WORM_VERSION = '1.1.5'
-  TWIRL_VERSION = '1.1.5'
-  RIPPLE_VERSION = '1.1.5'
-  FILL_VERSION = '1.0.5'
+  # Component-specific versions (patch bumps)
+  # @return [String]
+  WORM_VERSION = '1.1.6'
+  # @return [String]
+  TWIRL_VERSION = '1.1.6'
+  # @return [String]
+  RIPPLE_VERSION = '1.1.6'
+  # @return [String]
+  FILL_VERSION = '1.0.6'
 end