shellfie 1.0.0 → 1.1.0

data/lib/shellfie/parser.rb

@@ -4,32 +4,53 @@ require "yaml"
 require_relative "config"
 require_relative "errors"
 require_relative "parser_validation"
+require_relative "yaml_safety"
 
 module Shellfie
   class Parser
+    MAX_INCLUDE_BYTES = 1_048_576
+    MAX_INCLUDE_DEPTH = 50
+    MAX_INCLUDE_FILES = 100
+    MAX_TOTAL_INCLUDE_BYTES = 10 * MAX_INCLUDE_BYTES
+
     class << self
       include ParserValidation
 
       def parse(path)
-        return parse_string($stdin.read, base_dir: Dir.pwd) if path == "-"
-        raise ParseError, "Configuration file not found: #{path}" unless File.exist?(path)
-
-        content = File.read(path)
-        parse_string(content, base_dir: File.dirname(path))
+        return parse_string($stdin.read(MAX_INCLUDE_BYTES + 1), base_dir: Dir.pwd) if path == "-"
+        source_path = File.realpath(path)
+        content = read_config(source_path)
+        state = { files: 1, bytes: content.bytesize, cache: {}, sources: {} }
+        parse_string(content, base_dir: File.dirname(source_path), include_stack: [source_path], source_name: source_path,
+                              include_state: state)
+      rescue Errno::ENOENT
+        raise ParseError, "Configuration file not found: #{path}"
       end
 
-      def parse_string(content, base_dir: nil)
+      def parse_string(content, base_dir: nil, include_stack: [], source_name: nil, include_state: nil)
+        raise ParseError, "Configuration is too large (max #{MAX_INCLUDE_BYTES} bytes)" if content.bytesize > MAX_INCLUDE_BYTES
+
         raw = YAML.safe_load(content, symbolize_names: true, aliases: true)
-        raw = apply_includes(raw, base_dir) if base_dir
+        YamlSafety.validate_tree!(raw)
+        if base_dir
+          include_state ||= { files: 1, bytes: content.bytesize, cache: {}, sources: {} }
+          raw = apply_includes(raw, base_dir, stack: include_stack, root: base_dir, state: include_state)
+        end
         validate_config(raw)
-        build_config(raw)
-      rescue Psych::SyntaxError => e
+        sources = (include_stack + Array(include_state&.dig(:cache)&.keys)).uniq
+        build_config(raw, source_paths: sources)
+      rescue Psych::Exception => e
         raise ParseError, "Invalid YAML syntax: #{e.message}"
+      rescue ValidationError => e
+        raise e unless source_name
+
+        documents = [[source_name, content]] + include_state.fetch(:sources, {}).to_a.reverse
+        raise YamlSafety.annotate_validation_error(e, documents)
       end
 
       private
 
-      def build_config(raw)
+      def build_config(raw, source_paths: [])
         options = {
           version: raw[:version],
           theme: raw[:theme],
@@ -45,29 +66,68 @@ module Shellfie
           cursor: symbolize_hash(raw[:cursor]),
           limits: symbolize_hash(raw[:limits]),
           frames: parse_frames(raw[:frames]),
-          headless: raw[:headless] || false
+          headless: raw[:headless] || false,
+          source_paths: source_paths
         }.compact
 
         Config.new(options)
       end
 
-      def apply_includes(raw, base_dir, depth: 0)
+      def apply_includes(raw, base_dir, stack: [], root: base_dir, policy: nil, state:, depth: 0)
         return raw unless raw.is_a?(Hash) && raw[:include]
-        raise ParseError, "YAML include depth exceeded" if depth > 5
+        raise ParseError, "YAML include depth exceeds #{MAX_INCLUDE_DEPTH}" if depth >= MAX_INCLUDE_DEPTH
 
+        policy ||= raw[:include_policy] || "allow"
+        raise ParseError, "include_policy must be allow or root" unless %w[allow root].include?(policy)
         includes = Array(raw[:include])
         included_config = includes.reduce({}) do |merged, include_path|
+          raise ParseError, "Included configuration path must be a string" unless include_path.is_a?(String)
+
           include_file = File.expand_path(include_path, base_dir)
           raise ParseError, "Included configuration file not found: #{include_path}" unless File.exist?(include_file)
 
-          included_raw = YAML.safe_load(File.read(include_file), symbolize_names: true, aliases: true)
-          included_raw = apply_includes(included_raw, File.dirname(include_file), depth: depth + 1)
+          include_file = File.realpath(include_file)
+          if policy == "root" && include_file != root && !include_file.start_with?("#{root}#{File::SEPARATOR}")
+            raise ParseError, "Included configuration escapes the configuration root: #{include_path}"
+          end
+          if stack.include?(include_file)
+            chain = (stack + [include_file]).map { |path| File.basename(path) }.join(" -> ")
+            raise ParseError, "Circular YAML include: #{chain}"
+          end
+
+          state[:files] += 1
+          raise ParseError, "Too many YAML includes (max #{MAX_INCLUDE_FILES})" if state[:files] > MAX_INCLUDE_FILES
+          included_raw = state[:cache][include_file]
+          unless included_raw
+            included_content = read_config(include_file)
+            state[:sources][include_file] = included_content
+            state[:bytes] += included_content.bytesize
+            if state[:bytes] > MAX_TOTAL_INCLUDE_BYTES
+              raise ParseError, "Included YAML is too large in total (max #{MAX_TOTAL_INCLUDE_BYTES} bytes)"
+            end
+            included_raw = YAML.safe_load(included_content, symbolize_names: true, aliases: true)
+            YamlSafety.validate_tree!(included_raw)
+            state[:cache][include_file] = included_raw
+          end
+          included_raw = apply_includes(
+            included_raw,
+            File.dirname(include_file),
+            stack: stack + [include_file],
+            root: root,
+            policy: policy,
+            state: state,
+            depth: depth + 1
+          )
           deep_merge(merged, included_raw || {})
         end
 
         deep_merge(included_config, raw.reject { |key, _value| key == :include })
       end
 
+      def read_config(path)
+        YamlSafety.read_file(path, max_bytes: MAX_INCLUDE_BYTES)
+      end
+
       def deep_merge(base, overrides)
         base.merge(overrides) do |_key, left, right|
           left.is_a?(Hash) && right.is_a?(Hash) ? deep_merge(left, right) : right
@@ -104,6 +164,7 @@ module Shellfie
             prompt: frame[:prompt],
             type: frame[:type],
             output: frame[:output],
+            screen: frame[:screen],
             delay: frame[:delay] || 0,
             prompt_color: frame[:prompt_color],
             command_color: frame[:command_color],
@@ -147,10 +208,10 @@ module Shellfie
   end
 
   class Frame
-    attr_reader :prompt, :type, :output, :delay, :prompt_color, :command_color, :output_color
+    attr_reader :prompt, :type, :output, :delay, :prompt_color, :command_color, :output_color, :screen
 
     def initialize(prompt: nil, type: nil, output: nil, delay: 0, prompt_color: nil, command_color: nil,
-                   output_color: nil)
+                   output_color: nil, screen: nil)
       @prompt = prompt
       @type = type
       @output = output
@@ -158,6 +219,7 @@ module Shellfie
       @prompt_color = prompt_color
       @command_color = command_color
       @output_color = output_color
+      @screen = screen
       freeze
     end
 
@@ -169,12 +231,13 @@ module Shellfie
         delay: delay,
         prompt_color: prompt_color,
         command_color: command_color,
-        output_color: output_color
+        output_color: output_color,
+        screen: screen
       }.compact
     end
 
     def to_s
-      [prompt, type, output, delay].compact.join("\n")
+      [prompt, type, output, screen, delay].compact.join("\n")
     end
   end
 end

data/lib/shellfie/parser_validation.rb

@@ -1,24 +1,38 @@
 # frozen_string_literal: true
 
+require "did_you_mean"
+
 module Shellfie
   module ParserValidation
+    MAX_FRAME_DELAY_MS = 86_400_000
     TOP_LEVEL_KEYS = %i[
-      version include theme window_theme color_scheme colors window_decoration title window font animation cursor lines frames
+      version include include_policy theme window_theme color_scheme colors window_decoration title window font animation cursor lines frames
       headless limits
     ].freeze
     WINDOW_KEYS = %i[
-      width padding opacity visible_lines max_lines max_height wrap overflow margin exact_size trim tab_width
-      ansi_state background_gradient scroll_offset
+      width height padding opacity visible_lines max_lines max_height wrap overflow margin exact_size trim tab_width
+      ambiguous_width osc_policy graphics_policy ansi_state background_gradient scroll_offset
     ].freeze
     FONT_KEYS = %i[family size line_height fallback_family italic_family emoji_family].freeze
     ANIMATION_KEYS = %i[
-      typing_speed command_delay cursor_blink loop typing_jitter typing_chunk_size output_delay final_delay max_frames
-      dither palette scroll_easing
+      typing_speed command_delay cursor_blink loop typing_jitter seed typing_chunk_size output_delay final_delay max_frames
+      dither palette gif_colors gif_optimize webp_lossless webp_quality webp_method webp_near_lossless
+      apng_prediction loop_count scroll_easing
+      direction loop_offset
+      framerate playback_speed
     ].freeze
     CURSOR_KEYS = %i[style color].freeze
-    LIMIT_KEYS = %i[max_lines max_frames max_render_frames max_characters max_pixels].freeze
+    LIMIT_KEYS = %i[max_lines max_frames max_render_frames max_characters max_pixels max_total_pixels max_temp_bytes].freeze
     LINE_KEYS = %i[prompt command output prompt_color command_color output_color selected].freeze
-    FRAME_KEYS = %i[prompt type output delay prompt_color command_color output_color].freeze
+    FRAME_KEYS = %i[prompt type output screen delay prompt_color command_color output_color].freeze
+    COLOR_KEYS = %i[
+      background foreground title_bar title_text title_bar_border border selection black red green yellow blue magenta cyan
+      white bright_black bright_red bright_green bright_yellow bright_blue bright_magenta bright_cyan bright_white
+    ].freeze
+    WINDOW_DECORATION_KEYS = %i[
+      title_bar_height button_size button_spacing button_width corner_radius shadow
+    ].freeze
+    SHADOW_KEYS = %i[blur offset_x offset_y color].freeze
 
     private
 
@@ -32,11 +46,17 @@ module Shellfie
       validate_nested_hash!(raw, :animation, ANIMATION_KEYS)
       validate_nested_hash!(raw, :cursor, CURSOR_KEYS)
       validate_nested_hash!(raw, :limits, LIMIT_KEYS)
-      validate_nested_hash!(raw, :colors, nil)
-      validate_nested_hash!(raw, :window_decoration, nil)
+      validate_nested_hash!(raw, :colors, COLOR_KEYS)
+      validate_nested_hash!(raw, :window_decoration, WINDOW_DECORATION_KEYS)
+      if raw.dig(:window_decoration, :shadow)
+        validate_nested_hash!(raw[:window_decoration], :shadow, SHADOW_KEYS, "window_decoration.shadow")
+      end
       validate_theme!(raw[:theme]) if raw[:theme]
       validate_window_theme!(raw[:window_theme]) if raw[:window_theme]
       validate_color_scheme!(raw[:color_scheme]) if raw.key?(:color_scheme)
+      if raw[:include_policy] && !%w[allow root].include?(raw[:include_policy])
+        raise ValidationError, "include_policy must be allow or root"
+      end
 
       raise ValidationError, "Configuration must have either 'lines' or 'frames'" if raw[:lines].nil? && raw[:frames].nil?
 
@@ -62,18 +82,23 @@ module Shellfie
       raise ValidationError, "Invalid color_scheme '#{scheme}'"
     end
 
-    def validate_nested_hash!(raw, key, allowed_keys)
+    def validate_nested_hash!(raw, key, allowed_keys, context = key.to_s)
       return unless raw.key?(key)
       raise ValidationError, "#{key} must be a mapping" unless raw[key].is_a?(Hash)
 
-      validate_keys!(raw[key], allowed_keys, key.to_s) if allowed_keys
+      validate_keys!(raw[key], allowed_keys, context) if allowed_keys
     end
 
     def validate_keys!(hash, allowed_keys, context)
       unknown_keys = hash.keys - allowed_keys
       return if unknown_keys.empty?
 
-      raise ValidationError, "Unknown #{context} key(s): #{unknown_keys.join(", ")}"
+      suggestions = unknown_keys.filter_map do |key|
+        match = DidYouMean::SpellChecker.new(dictionary: allowed_keys.map(&:to_s)).correct(key.to_s).first
+        "#{key} -> #{match}" if match
+      end
+      hint = suggestions.empty? ? "" : " (did you mean #{suggestions.join(", ")}?)"
+      raise ValidationError, "Unknown #{context} key(s): #{unknown_keys.join(", ")}#{hint}"
     end
 
     def validate_lines!(lines)
@@ -111,17 +136,25 @@ module Shellfie
     def validate_frame_shape!(frame, index)
       raise ValidationError, "frames[#{index}].prompt requires type" if frame[:prompt] && frame[:type].nil?
 
-      if frame.values_at(:type, :output, :delay).all?(&:nil?)
-        raise ValidationError, "frames[#{index}] must include type, output, or delay"
+      if frame.values_at(:type, :output, :screen, :delay).all?(&:nil?)
+        raise ValidationError, "frames[#{index}] must include type, output, screen, or delay"
       end
 
       validate_string_value!(frame[:prompt], "frames[#{index}].prompt") if frame.key?(:prompt)
       validate_string_value!(frame[:type], "frames[#{index}].type") if frame.key?(:type)
       validate_string_value!(frame[:output], "frames[#{index}].output") if frame.key?(:output)
+      if frame.key?(:screen) && (!frame[:screen].is_a?(Array) || !frame[:screen].all?(String))
+        raise ValidationError, "frames[#{index}].screen must be an array of strings"
+      end
       validate_string_value!(frame[:prompt_color], "frames[#{index}].prompt_color") if frame.key?(:prompt_color)
       validate_string_value!(frame[:command_color], "frames[#{index}].command_color") if frame.key?(:command_color)
       validate_string_value!(frame[:output_color], "frames[#{index}].output_color") if frame.key?(:output_color)
-      validate_non_negative_integer!(frame[:delay], "frames[#{index}].delay") if frame.key?(:delay)
+      if frame.key?(:delay)
+        validate_non_negative_integer!(frame[:delay], "frames[#{index}].delay")
+        if frame[:delay] > MAX_FRAME_DELAY_MS
+          raise ValidationError, "frames[#{index}].delay must be at most #{MAX_FRAME_DELAY_MS}"
+        end
+      end
     end
 
     def validate_string_value!(value, name)

data/lib/shellfie/render_geometry.rb

@@ -13,7 +13,7 @@ module Shellfie
       font_config = @theme.font
       line_height = font_config[:size] * font_config[:line_height]
       display_lines, visible_count = display_lines(lines, font_config, line_height)
-      total_height = title_bar_height + [visible_count, 1].max * line_height + padding * 2
+      total_height = @config.window[:height] || title_bar_height + [visible_count, 1].max * line_height + padding * 2
       margin = canvas_margin(scale, shadow && !exact_size?)
       geometry = geometry_hash(
         display_lines,
@@ -66,6 +66,7 @@ module Shellfie
         scaled_title_bar: (title_bar_height * scale).to_i,
         scaled_radius: (corner_radius * scale).to_i,
         scroll_offset: @config.window[:scroll_offset].to_f,
+        ambiguous_width: @config.window[:ambiguous_width],
         margin: margin,
         canvas_width: (width * scale).to_i + margin * 2,
         canvas_height: (total_height * scale).ceil + margin * 2,

data/lib/shellfie/render_segment.rb

@@ -3,10 +3,11 @@
 module Shellfie
   class RenderSegment
     ATTRIBUTES = %i[
-      foreground background bold italic underline dim reverse strikethrough overline
+      foreground background bold italic underline underline_style underline_color dim reverse strikethrough overline blink conceal link
     ].freeze
 
-    attr_reader :text, :foreground, :background, :bold, :italic, :underline, :dim, :reverse, :strikethrough, :overline
+    attr_reader :text, :foreground, :background, :bold, :italic, :underline, :underline_style, :underline_color,
+                :dim, :reverse, :strikethrough, :overline, :blink, :conceal, :link
 
     def self.from_segment(segment, default_color:)
       new(
@@ -16,10 +17,15 @@ module Shellfie
         bold: segment.bold,
         italic: segment.italic,
         underline: segment.underline,
+        underline_style: segment.underline_style,
+        underline_color: segment.underline_color,
         dim: segment.dim,
         reverse: segment.reverse,
         strikethrough: segment.strikethrough,
-        overline: segment.overline
+        overline: segment.overline,
+        blink: segment.blink,
+        conceal: segment.conceal,
+        link: segment.link
       )
     end
 
@@ -37,18 +43,24 @@ module Shellfie
       end
     end
 
-    def initialize(text:, foreground: nil, background: nil, bold: false, italic: false, underline: false, dim: false,
-                   reverse: false, strikethrough: false, overline: false)
+    def initialize(text:, foreground: nil, background: nil, bold: false, italic: false, underline: false,
+                   underline_style: nil, underline_color: nil, dim: false, reverse: false, strikethrough: false,
+                   overline: false, blink: false, conceal: false, link: nil)
       @text = text
       @foreground = foreground
       @background = background
       @bold = bold
       @italic = italic
       @underline = underline
+      @underline_style = underline_style
+      @underline_color = underline_color
       @dim = dim
       @reverse = reverse
       @strikethrough = strikethrough
       @overline = overline
+      @blink = blink
+      @conceal = conceal
+      @link = link
       freeze
     end
 

data/lib/shellfie/renderer.rb

@@ -5,12 +5,14 @@ require_relative "ansi_parser"
 require_relative "dependency_checker"
 require_relative "font_resolver"
 require_relative "format_resolver"
+require_relative "html_renderer"
 require_relative "output_writer"
 require_relative "raster_painter"
 require_relative "render_chrome_cache"
 require_relative "render_geometry"
 require_relative "render_segment"
 require_relative "svg_raster_wrapper"
+require_relative "svg_renderer"
 require_relative "theme_registry"
 
 module Shellfie
@@ -21,16 +23,21 @@ module Shellfie
       @config = config
       @chrome_cache = chrome_cache
       @theme = ThemeRegistry.build(config)
-      @ansi_parser = AnsiParser.new(state_mode: config.window[:ansi_state] || :persistent)
+      @ansi_parser = AnsiParser.new(
+        state_mode: config.window[:ansi_state] || :persistent,
+        tab_width: config.window[:tab_width],
+        osc_policy: config.window[:osc_policy],
+        graphics_policy: config.window[:graphics_policy]
+      )
       @font_resolver = FontResolver.new(-> { imagemagick_command })
     end
 
-    def render(output_path, scale: 1, shadow: true, transparent: false, format: nil)
-      check_dependencies!
-      lines = build_lines
+    def render(output_path, scale: 1, shadow: true, transparent: false, format: nil, io: nil)
       extension = FormatResolver.resolve(output_path, explicit: format, default: "png")
-      OutputWriter.write(output_path, extension: extension) do |temporary_path|
-        render_method = (extension == "svg") ? :create_svg_image : :create_image
+      check_dependencies! unless %w[svg html].include?(extension)
+      lines = build_lines
+      OutputWriter.write(output_path, extension: extension, io: io) do |temporary_path|
+        render_method = { "svg" => :create_svg_image, "svg-raster" => :create_svg_raster_image, "html" => :create_html }.fetch(extension, :create_image)
         send(render_method, lines, temporary_path, scale: scale, shadow: shadow, transparent: transparent)
       end
     rescue MiniMagick::Error => e
@@ -42,6 +49,10 @@ module Shellfie
       geometry.slice(:canvas_width, :canvas_height, :scaled_width, :scaled_height, :logical_width, :logical_height, :scale)
     end
 
+    def font_info
+      font_resolver.details(theme.font)
+    end
+
     private
 
     def check_dependencies!
@@ -76,7 +87,7 @@ module Shellfie
     end
 
     def parse_with_default(text, default_color)
-      @ansi_parser.parse(expand_tabs(text)).map do |segment|
+      @ansi_parser.parse(text).map do |segment|
         RenderSegment.from_segment(segment, default_color: default_color)
       end
     end
@@ -85,10 +96,6 @@ module Shellfie
       RenderSegment.coalesce(segments)
     end
 
-    def expand_tabs(text)
-      text.to_s.gsub("\t", " " * config.window[:tab_width])
-    end
-
     def create_image(lines, output_path, scale:, shadow:, transparent:)
       geometry = build_geometry(lines, scale: scale, shadow: shadow)
 
@@ -96,9 +103,19 @@ module Shellfie
     end
 
     def create_svg_image(lines, output_path, scale:, shadow:, transparent:)
+      geometry = build_geometry(lines, scale: scale, shadow: shadow)
+      SvgRenderer.new(config: config, theme: theme).render(geometry, output_path, transparent: transparent)
+    end
+
+    def create_svg_raster_image(lines, output_path, scale:, shadow:, transparent:)
       SvgRasterWrapper.write(output_path) { |png_path| create_image(lines, png_path, scale: scale, shadow: shadow, transparent: transparent) }
     end
 
+    def create_html(lines, output_path, scale:, shadow:, transparent:)
+      geometry = build_geometry(lines, scale: scale, shadow: shadow)
+      HtmlRenderer.new(config: config, theme: theme).render(geometry, output_path, transparent: transparent)
+    end
+
     def build_geometry(lines, scale:, shadow:)
       geometry_builder.build(lines, scale: scale, shadow: shadow)
     end

data/lib/shellfie/rendering/text_painter.rb

@@ -31,7 +31,7 @@ module Shellfie
           text = segment.text.to_s
           next if text.empty?
 
-          width = TextMetrics.pixel_width(text, geometry[:scaled_font_size])
+          width = TextMetrics.pixel_width(text, geometry[:scaled_font_size], ambiguous_width: geometry[:ambiguous_width])
           top = baseline - geometry[:scaled_font_size]
           foreground, background = segment_colors(segment)
           result << {
@@ -63,17 +63,19 @@ module Shellfie
 
       def draw_positioned_segments(convert, positioned_segments, geometry)
         positioned_segments.each do |item|
-          draw_text(
-            convert,
-            item[:text],
-            item[:x],
-            item[:top],
-            item[:foreground],
-            geometry[:scaled_font_size],
-            geometry[:font_config],
-            bold: item[:segment].bold,
-            italic: item[:segment].italic
-          )
+          unless item[:segment].conceal
+            draw_text(
+              convert,
+              item[:text],
+              item[:x],
+              item[:top],
+              item[:foreground],
+              geometry[:scaled_font_size],
+              geometry[:font_config],
+              bold: item[:segment].bold,
+              italic: item[:segment].italic
+            )
+          end
           draw_text_decoration(
             convert,
             item[:segment],
@@ -110,15 +112,20 @@ module Shellfie
       end
 
       def draw_text_decoration(convert, segment, x, width, baseline, geometry)
+        return if segment.conceal
         return unless segment.underline || segment.strikethrough || segment.overline
 
         line_width = [(geometry[:scaled_font_size] / 12.0).ceil, 1].max
-        convert.stroke segment_colors(segment).first
+        decoration_color = segment.underline_color ? theme.color_for(segment.underline_color) : segment_colors(segment).first
+        convert.stroke decoration_color
         convert.strokewidth line_width
+        convert.stroke_dasharray "#{line_width},#{line_width * 2}" if segment.underline_style == :dotted
+        convert.stroke_dasharray "#{line_width * 3},#{line_width * 2}" if segment.underline_style == :dashed
 
         if segment.underline
           y = baseline + (geometry[:scaled_font_size] * 0.12).ceil
           ImageMagickCommandBuilder.line(convert, x, y, x + width, y)
+          ImageMagickCommandBuilder.line(convert, x, y + line_width * 2, x + width, y + line_width * 2) if segment.underline_style == :double
         end
         if segment.strikethrough
           y = baseline - (geometry[:scaled_font_size] * 0.35).ceil
@@ -130,6 +137,7 @@ module Shellfie
         end
 
         convert.stroke "none"
+        convert.stroke_dasharray "none" if %i[dotted dashed].include?(segment.underline_style)
       end
 
       def draw_selected_backgrounds(convert, geometry, content_y)
@@ -158,10 +166,10 @@ module Shellfie
 
       def fit_text(text, max_width, font_size)
         return "" if max_width <= 0
-        return text if TextMetrics.pixel_width(text, font_size) <= max_width
+        return text if TextMetrics.pixel_width(text, font_size, ambiguous_width: config.window[:ambiguous_width]) <= max_width
 
         max_cells = [(max_width / (font_size * 0.6)).floor - 3, 0].max
-        "#{TextMetrics.take_cells(text, max_cells)}..."
+        "#{TextMetrics.take_cells(text, max_cells, ambiguous_width: config.window[:ambiguous_width])}..."
       end
 
       def color_with_opacity(color, opacity, allow_rgba)

data/lib/shellfie/rendering/window_chrome.rb

@@ -159,12 +159,12 @@ module Shellfie
         reserve_right = theme.buttons_position == :right ? group_width + (12 * geometry[:scale]).to_i : (12 * geometry[:scale]).to_i
         available_width = geometry[:scaled_width] - reserve_left - reserve_right
         title = fit_text(config.title.to_s, available_width, scaled_font_size)
-        title_width = TextMetrics.pixel_width(title, scaled_font_size)
+        title_width = TextMetrics.pixel_width(title, scaled_font_size, ambiguous_width: config.window[:ambiguous_width])
         min_x = geometry[:margin] + reserve_left
         max_x = geometry[:margin] + geometry[:scaled_width] - reserve_right - title_width
         centered_x = geometry[:margin] + (geometry[:scaled_width] - title_width) / 2
         x = title_x(min_x, max_x, centered_x)
-        y = geometry[:margin] + geometry[:scaled_title_bar] / 2 + scaled_font_size / 3
+        y = geometry[:margin] + geometry[:scaled_title_bar] / 2 + (scaled_font_size * 0.6).round
 
         draw_text(convert, title, x, y - scaled_font_size, theme.colors[:title_text], scaled_font_size, geometry[:font_config])
       end

data/lib/shellfie/reproducibility_manifest.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+require "rbconfig"
+
+module Shellfie
+  class ReproducibilityManifest
+    def self.build(config, output_path:, format:)
+      renderer = Renderer.new(config)
+      {
+        schema: 1,
+        config_sha256: Digest::SHA256.hexdigest(JSON.generate(config.to_h)),
+        output: output_path,
+        output_sha256: output_digest(output_path),
+        format: format,
+        ruby: RUBY_DESCRIPTION,
+        platform: RbConfig::CONFIG["host_os"],
+        unicode: {
+          version: TextMetrics::UNICODE_VERSION,
+          width_table: TextMetrics::WIDTH_TABLE_VERSION,
+          ambiguous_width: config.window[:ambiguous_width]
+        },
+        imagemagick: DependencyChecker.imagemagick_details[:version],
+        ffmpeg: DependencyChecker.ffmpeg_version,
+        fonts: renderer.font_info
+      }
+    end
+
+    def self.output_digest(path)
+      return Digest::SHA256.file(path).hexdigest if File.file?(path)
+      return unless File.directory?(path)
+
+      digest = Digest::SHA256.new
+      Dir.glob(File.join(path, "**", "*"), File::FNM_DOTMATCH).select { |entry| File.file?(entry) }.sort.each do |entry|
+        digest << entry.delete_prefix("#{path}#{File::SEPARATOR}") << "\0" << Digest::SHA256.file(entry).digest
+      end
+      digest.hexdigest
+    end
+  end
+end