graphomaton 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8992f0a2ab8bf57fc92a7480dc29c39fa94188e952bef61a865f421fde5a9b91
-  data.tar.gz: 1f7b78192ad4e692cff03ce8c45bb0cacf33195d7294612ca06a9bf695b409b3
+  metadata.gz: 168a8c5641230bf2da705a71bbc3156757a0cc820047d47f18c1c69f3ab08f0a
+  data.tar.gz: 52152b9aded87cdae3bca6f47bddd5cded06c91f7c7c4ca8450c0e1b51401084
 SHA512:
-  metadata.gz: 7360eaf0c5ce3676e505559b066d429fa1f1df0219e922c2cacc2d62578a4bf94f07ac51d385abdcf61a5c03979def0f98088ac28e7081841722a2f975b39984
-  data.tar.gz: d8bacee19d445a50d62449970b435ab5917093da8a27b7df7c41b7d59f8aa46c419de2754ddacbddae67b18bc00060e28f204a5c8a377b95c306b8203cef1abb
+  metadata.gz: 3cb2d71e65478459dc6cd4968cffcaeb13681124143116f73a5c175de394f55dc14b1335b6a2cae111f07903ddbd2235aa9b62fd18fed233bcde2b3f266f0b7e
+  data.tar.gz: c86a638ddb2d0c98bb05a39e396abbe541e483de706dba43437a368462cc3f9d2c2d0460b0152780dccf553d3bfa2d25b9f2d2a6dae5dff7a6cfdaa33ce7b5c3

data/CHANGELOG.md

@@ -6,6 +6,44 @@ follows [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.2.0] - 2026-09-08
+
+### Added
+
+- Added a public GitHub Pages landing page for the project.
+- Added CLI selection for reference, FSM-semantic, DFA, and combined validation
+  profiles.
+- Added structured mixed epsilon/symbol labels that retain their semantics
+  through Hash, JSON, and YAML round trips.
+
+### Changed
+
+- Stronger CLI validation profiles now include reference checks, and exporter
+  semantic diagnostics distinguish state and transition tooltips.
+- SVG rendering now reuses immutable state snapshots and linear state ordering
+  while preserving folded-state kinds and unrelated self-loops.
+- Updated the RubyGems trusted-publishing action to 1.4.1.
+
+### Fixed
+
+- Corrected long-word wrapping, explicit-position tracking, duplicate SVG IDs,
+  numeric-root style scoping, auto-sized bounds, and stale clipping diagnostics.
+- Enforced final SVG and scaled PNG dimension limits before conversion, including
+  overflow and non-real numeric inputs.
+- Made metadata-depth checks independent of Hash insertion order and rejected
+  boolean state identifiers consistently at input boundaries.
+- Preserved option-dependent tooltip semantics in strict rendering and retained
+  epsilon meaning in array transition labels.
+- Made `--no-clobber` atomic, including theme-gallery output races and friendly
+  CLI failures.
+
+### Security
+
+- Rejected escaped, comment-obfuscated, and alternate CSS resource functions in
+  themes and per-element SVG styles.
+- Ensured timed-out Unix process groups are terminated even when the direct
+  parent exits first.
+
 ## [1.1.0] - 2026-08-13
 
 ### Added

data/README.md

@@ -220,7 +220,8 @@ The command interface also supports structured workflows:
 ```bash
 graphomaton render automaton.yml diagram.svg
 graphomaton validate automaton.yml --diagnostics json
-graphomaton validate automaton.yml --fail-on-warning
+graphomaton validate automaton.yml --profile fsm_semantics --fail-on-warning
+graphomaton validate automaton.yml --profile dfa
 graphomaton list formats
 graphomaton list layouts
 graphomaton doctor
@@ -239,7 +240,7 @@ svg:
     wrap: true
 ```
 
-The CLI validates state references and hierarchy by default. `--no-validate` is available for intentionally deferred or partial diagrams. Standard input auto-detects JSON documents that start with `{` or `[`, otherwise YAML is assumed; use `--input-format` to override it. `--format` is required when `--output -` is used. Input limits can be lowered with `--max-input-bytes`, `--max-states`, `--max-transitions`, `--max-metadata-depth`, `--max-label-length`, and `--max-group-depth`. Use `--no-clobber` to protect an existing output (and `--force` to opt back into replacement). Usage, parse, validation, conversion, and security failures use distinct exit statuses and are reported without backtraces.
+The CLI validates state references and hierarchy by default. The `validate` command also defaults to that `references` profile; use `--profile fsm_semantics`, `--profile dfa`, or `--profile all` for stronger checks. `--no-validate` is available for intentionally deferred or partial diagrams. Standard input auto-detects JSON documents that start with `{` or `[`, otherwise YAML is assumed; use `--input-format` to override it. `--format` is required when `--output -` is used. Input limits can be lowered with `--max-input-bytes`, `--max-states`, `--max-transitions`, `--max-metadata-depth`, `--max-label-length`, and `--max-group-depth`. Use `--no-clobber` to protect an existing output (and `--force` to opt back into replacement). Usage, parse, validation, conversion, and security failures use distinct exit statuses and are reported without backtraces.
 
 Common SVG options:
 

data/docs/cli.md

@@ -4,9 +4,10 @@
 `graphomaton INPUT OUTPUT` command. Use `-` for stdin or stdout; stdout requires
 `--format`. Rendering validates references by default.
 
-`graphomaton validate INPUT --diagnostics json` validates references, hierarchy,
-FSM warnings, and DFA constraints without writing a diagram. Add
-`--fail-on-warning` for CI. `graphomaton list` reports formats, layouts, themes,
+`graphomaton validate INPUT --diagnostics json` validates references and hierarchy
+without writing a diagram. Select `--profile fsm_semantics`, `--profile dfa`, or
+`--profile all` for stronger checks, and add `--fail-on-warning` for CI.
+`graphomaton list` reports formats, layouts, themes,
 and converters; `doctor` reports the Ruby version plus discovered native renderer
 paths and bounded version probes.
 

data/docs/custom-exporters.md

@@ -34,3 +34,6 @@ Capability omissions are reported by `semantic_diagnostics` and rejected when
 `strict_semantics: true` is used. Set `binary: true` when output must be written in
 binary mode. A temporary registration can be removed with
 `Graphomaton::EXPORTERS.unregister(:text_graph)`.
+
+Tooltip capabilities are `state_tooltip` and `transition_tooltip`. The legacy
+`tooltip` capability continues to declare both.

data/docs/exporters.md

@@ -3,7 +3,9 @@
 | Feature | SVG/PNG/PDF/WebP | DOT | Mermaid | PlantUML |
 | --- | --- | --- | --- | --- |
 | styles and line styles | yes | partial | partial | partial |
-| URL and tooltip | yes | yes | no | no |
+| URL | yes in SVG; no in raster output | yes | no | no |
+| state tooltip | yes in SVG; no in raster output | yes | with `notes: true` | with `notes: true` |
+| transition tooltip | yes in SVG; no in raster output | yes | no | no |
 | visual groups | yes | yes | partial | partial |
 | hierarchy and pseudostates | display | partial | yes | yes |
 | edge bundles | yes | no | no | no |

data/docs/input-schema.md

@@ -19,7 +19,8 @@ default in the CLI.
 State and transition `style` and `metadata` values must be mappings. State labels
 are scalar display text. Transition labels may be scalar text, a symbol array, or
 a structured label with an explicit `type`/`kind`; malformed collections are
-rejected instead of being stringified or ignored.
+rejected instead of being stringified or ignored. Ruby label arrays containing
+`:epsilon` preserve both meanings as a structured `alternatives` label.
 
 YAML aliases are disabled. Parsing limits input bytes, state and transition
 counts, label bytes, metadata depth, and hierarchy depth. Callers handling

data/lib/graphomaton/atomic_file.rb

@@ -4,7 +4,7 @@ require 'tempfile'
 
 class Graphomaton
   class AtomicFile
-    def self.write(filename, content, binary: false)
+    def self.write(filename, content, binary: false, no_clobber: false)
       destination = File.expand_path(filename)
       directory = File.dirname(destination)
       basename = File.basename(destination)
@@ -17,7 +17,11 @@ class Graphomaton
         temporary.flush
         temporary.fsync
         temporary.close
-        File.rename(temporary.path, destination)
+        if no_clobber
+          File.link(temporary.path, destination)
+        else
+          File.rename(temporary.path, destination)
+        end
       end
 
       content.bytesize

data/lib/graphomaton/cli/config.rb

@@ -8,10 +8,10 @@ class Graphomaton
       FORMAT_SECTIONS = %i[svg png pdf webp html mermaid dot plantuml].freeze
       ENUM_KEYS = %i[
         format input_format theme layout direction fit converter initial_position final_position
-        state_shape edge_style arrow_shape state_effect unreachable_zone loop_position diagnostics
+        state_shape edge_style arrow_shape state_effect unreachable_zone loop_position diagnostics profile
       ].freeze
       OPTION_KEYS = %i[
-        input input_format output format validate no_clobber width height scale converter timeout
+        input input_format output format validate profile no_clobber width height scale converter timeout
         max_output_bytes max_input_bytes max_states max_transitions max_metadata_depth max_label_length
         max_group_depth theme theme_file layout_warnings
         layout direction fit padding node_spacing rank_spacing force_iterations layout_seed

data/lib/graphomaton/cli.rb

@@ -18,7 +18,7 @@ class Graphomaton
     COMPLETION_WORDS = %w[
       render validate themes list doctor completion man formats layouts converters
       --input --input-format --output --format --config --no-clobber --force --validate
-      --no-validate --diagnostics --fail-on-warning --strict-semantics --layout-warnings
+      --no-validate --profile --diagnostics --fail-on-warning --strict-semantics --layout-warnings
       --width --height --theme --theme-file --layout --direction --fit --padding
       --node-spacing --rank-spacing --force-iterations --layout-seed --graphviz-command
       --max-metadata-depth --max-label-length --max-group-depth
@@ -327,7 +327,7 @@ def execute_man(arguments)
   end
 
   @stdout.write <<~MANPAGE
-    .TH GRAPHOMATON 1 "2026-08-12" "Graphomaton #{Graphomaton::VERSION}" "User Commands"
+    .TH GRAPHOMATON 1 "2026-09-08" "Graphomaton #{Graphomaton::VERSION}" "User Commands"
     .SH NAME
     graphomaton \- validate, analyze, and render finite-state machines
     .SH SYNOPSIS
@@ -433,7 +433,7 @@ options[:format] = argument_format if argument_format
 
 parser = OptionParser.new do |opts|
   opts.banner = 'Usage: graphomaton [render] --input automaton.yml --output diagram.svg [options]'
-  opts.separator '       graphomaton validate automaton.yml [--diagnostics text|json]'
+  opts.separator '       graphomaton validate automaton.yml [--profile references|fsm_semantics|dfa|all]'
   opts.separator '       graphomaton list formats|layouts|themes|converters'
   opts.separator '       graphomaton themes | doctor'
   opts.separator '       graphomaton --theme-gallery --output theme_gallery.html [options]'
@@ -446,6 +446,7 @@ parser = OptionParser.new do |opts|
   opts.on('--force', 'Allow replacing an existing output file') { options[:no_clobber] = false }
   opts.on('-f', '--format FORMAT', 'Output format override') { |value| options[:format] = value.to_sym }
   opts.on('--[no-]validate', 'Validate automaton references before rendering (default: enabled)') { |value| options[:validate] = value }
+  opts.on('--profile PROFILE', 'Validation profile: references, fsm_semantics, dfa, or all') { |value| options[:profile] = value.to_sym }
   opts.on('--diagnostics FORMAT', 'Diagnostic output: text or json') { |value| options[:diagnostics] = value.to_sym }
   opts.on('--fail-on-warning', 'Return a failure status when warnings are emitted') { options[:fail_on_warning] = true }
   opts.on('--strict-semantics', 'Reject information loss in the selected output format') { options[:strict_semantics] = true }
@@ -612,12 +613,21 @@ if options[:theme_gallery]
 
   themes = Graphomaton::Exporters::Svg::THEMES.dup
   themes = themes.merge(custom: load_theme_file(options[:theme_file])) if options[:theme_file]
-  Graphomaton::Theme.save_gallery_html(
-    output_path,
-    title: options[:title] || 'Graphomaton Theme Gallery',
-    themes: themes,
-    animated: options[:theme_gallery_animated]
-  )
+  begin
+    Graphomaton::Theme.save_gallery_html(
+      output_path,
+      no_clobber: options[:no_clobber],
+      title: options[:title] || 'Graphomaton Theme Gallery',
+      themes: themes,
+      animated: options[:theme_gallery_animated]
+    )
+  rescue Errno::EEXIST
+    warn "Output file already exists: #{output_path}"
+    halt(EXIT_EXPORT)
+  rescue SystemCallError => e
+    report_exception(e)
+    halt(EXIT_EXPORT)
+  end
   halt(EXIT_SUCCESS)
 end
 
@@ -650,7 +660,18 @@ rescue JSON::ParserError, Psych::Exception, ArgumentError, SystemCallError => e
 end
 
 if command == :validate
-  diagnostics = automaton.validation_diagnostics(profile: :all)
+  profile = (options[:profile] || :references).to_s.to_sym
+  profiles = {
+    references: :references,
+    fsm_semantics: %i[references fsm_semantics],
+    dfa: %i[references dfa],
+    all: :all
+  }
+  unless profiles.key?(profile)
+    warn "Unknown validation profile: #{profile}"
+    halt(EXIT_USAGE)
+  end
+  diagnostics = automaton.validation_diagnostics(profile: profiles.fetch(profile))
   emit_diagnostics(diagnostics, format: options[:diagnostics] || :text, stream: @stdout)
   has_errors = diagnostics.any? { |diagnostic| diagnostic.severity == :error }
   has_warnings = diagnostics.any? { |diagnostic| diagnostic.severity == :warning }
@@ -819,7 +840,8 @@ begin
     Graphomaton::AtomicFile.write(
       output_path,
       result.output,
-      binary: Graphomaton::EXPORTERS.fetch(resolved_output_format).binary
+      binary: Graphomaton::EXPORTERS.fetch(resolved_output_format).binary,
+      no_clobber: options[:no_clobber]
     )
   end
 rescue Graphomaton::SecurityError => e

data/lib/graphomaton/exporter_registry.rb

@@ -76,9 +76,9 @@ class Graphomaton
         graph.state_records.any? { |_, state| metadata_value(state.metadata, :url, :href) } ||
           graph.transition_records.any? { |transition| metadata_value(transition.metadata, :url, :href) }
       },
-      tooltip: lambda { |graph|
-        graph.state_records.any? { |_, state| metadata_value(state.metadata, :tooltip, :description) } ||
-          graph.transition_records.any? { |transition| metadata_value(transition.metadata, :tooltip, :description) }
+      state_tooltip: ->(graph) { graph.state_records.any? { |_, state| metadata_value(state.metadata, :tooltip, :description) } },
+      transition_tooltip: lambda { |graph|
+        graph.transition_records.any? { |transition| metadata_value(transition.metadata, :tooltip, :description) }
       },
       group: ->(graph) { graph.state_records.any? { |_, state| metadata_value(state.metadata, :group, :cluster) } },
       parent: ->(graph) { graph.state_records.any? { |_, state| metadata_value(state.metadata, :parent) } },
@@ -92,6 +92,9 @@ class Graphomaton
     }.freeze
 
     def self.losses_for(graph, capabilities)
+      if capabilities.include?(:tooltip)
+        capabilities = capabilities + %i[state_tooltip transition_tooltip]
+      end
       FEATURE_DETECTORS.filter_map do |feature, detector|
         feature if detector.call(graph) && !capabilities.include?(feature)
       end

data/lib/graphomaton/exporters/png.rb

@@ -108,13 +108,14 @@ class Graphomaton
 
       def scaled_dimension(value, scale)
         scaled = value.to_f * scale
+        return scaled unless scaled.finite?
         return scaled.to_i if scaled == scaled.to_i
 
         scaled
       end
 
       def resolve_scale(scale)
-        unless scale.is_a?(Numeric) && scale.finite? && scale.positive?
+        unless scale.is_a?(Numeric) && scale.real? && scale.to_f.finite? && scale.positive?
           raise ArgumentError, 'PNG scale must be a positive finite number'
         end
 
@@ -127,8 +128,11 @@ class Graphomaton
         view_box = root.attributes['viewBox'].to_s.split.map(&:to_f)
         logical_width = numeric_svg_dimension(root.attributes['width'], view_box[2])
         logical_height = numeric_svg_dimension(root.attributes['height'], view_box[3])
-        root.attributes['width'] = scaled_dimension(logical_width, scale).to_s
-        root.attributes['height'] = scaled_dimension(logical_height, scale).to_s
+        pixel_width = scaled_dimension(logical_width, scale)
+        pixel_height = scaled_dimension(logical_height, scale)
+        Graphomaton.validate_canvas_dimensions!(pixel_width, pixel_height)
+        root.attributes['width'] = pixel_width.to_s
+        root.attributes['height'] = pixel_height.to_s
         document.to_s
       end
 

data/lib/graphomaton/exporters/svg.rb

@@ -312,6 +312,7 @@ class Graphomaton
                  fit: Graphomaton::DEFAULT_FIT,
                  title: nil, description: nil, svg_id: nil)
         source_automaton = @automaton
+        @state_records = nil
         @diagnostics = []
         @state_radius = resolve_state_radius(state_radius, auto_state_radius, min_state_radius, max_state_radius)
         @state_shape = resolve_state_shape(state_shape)
@@ -360,12 +361,14 @@ class Graphomaton
         @scc_groups = scc_groups
         @max_transition_label_width = finite_number!(max_transition_label_width, 'max_transition_label_width', nonnegative: true)
         @sort_labels = sort_labels
+        @auto_size = auto_size
         @label_tooltips = label_tooltips
         @html_tooltips = html_tooltips
         @font_family = safe_css_value(font_family, context: 'font_family')
         @state_font_weight = safe_css_value(state_font_weight, context: 'state_font_weight', allow_nil: true)
         @transition_font_weight = safe_css_value(transition_font_weight, context: 'transition_font_weight', allow_nil: true)
         @automaton = folded_automaton(@automaton) if fold_groups
+        @state_records = nil if fold_groups
         layout_padding = automatic_layout_padding
         @positions = @automaton.layout_positions(
           width,
@@ -388,6 +391,9 @@ class Graphomaton
         if auto_size
           width, height = auto_size_canvas(width, height)
         end
+        Graphomaton.validate_canvas_dimensions!(width, height)
+        @canvas_x = 0.0
+        @canvas_y = 0.0
         @canvas_width = width.to_f
         @canvas_height = height.to_f
         @label_boxes = state_collision_boxes + group_label_collision_boxes
@@ -411,6 +417,7 @@ class Graphomaton
         @svg_id = svg_id ? svg_id_component(svg_id) : default_svg_id(width, height)
         @arrowhead_id = "#{@svg_id}-arrowhead"
         @element_id_counts = Hash.new(0)
+        @element_ids = Set.new([@svg_id, @arrowhead_id, "#{@svg_id}-title", "#{@svg_id}-desc"])
 
         doc = REXML::Document.new
         svg = doc.add_element('svg', svg_root_attributes(width, height, responsive: responsive))
@@ -441,7 +448,14 @@ class Graphomaton
         output = export(*arguments, **options)
         render_diagnostics = (@diagnostics || []).dup
         render_diagnostics.concat(
-          @automaton.layout_diagnostics_for(@positions, @canvas_width, @canvas_height, @state_radius)
+          @automaton.layout_diagnostics_for(
+            @positions,
+            @canvas_width,
+            @canvas_height,
+            @state_radius,
+            x: @canvas_x,
+            y: @canvas_y
+          )
         )
         RenderResult.new(
           output: output.dup.freeze,
@@ -588,7 +602,7 @@ class Graphomaton
         resolved_rank_spacing = finite_number!(rank_spacing, 'rank_spacing', nonnegative: true)
         return [resolved_node_spacing, resolved_rank_spacing] unless auto_density_spacing
 
-        state_count = @automaton.state_records.size
+        state_count = state_records.size
         return [resolved_node_spacing, resolved_rank_spacing] if state_count <= 4
 
         multiplier = 1.0 + ([[state_count - 4, 16].min, 0].max * 0.06)
@@ -636,6 +650,11 @@ class Graphomaton
         view_y = bounds[:min_y] - margin
         view_width = (bounds[:max_x] - bounds[:min_x]) + (margin * 2)
         view_height = (bounds[:max_y] - bounds[:min_y]) + (margin * 2)
+        Graphomaton.validate_canvas_dimensions!(view_width, view_height)
+        @canvas_x = view_x
+        @canvas_y = view_y
+        @canvas_width = view_width
+        @canvas_height = view_height
         svg.attributes['viewBox'] = "#{view_x} #{view_y} #{view_width} #{view_height}"
         unless responsive
           svg.attributes['width'] = view_width.to_s
@@ -800,7 +819,7 @@ class Graphomaton
       end
 
       def generated_description
-        state_count = @automaton.state_records.size
+        state_count = state_records.size
         transition_count = @automaton.transition_records.size
 
         "Automaton with #{state_count} states and #{transition_count} transitions."
@@ -828,7 +847,7 @@ class Graphomaton
       end
 
       def state_label_radius
-        max_width_units = @automaton.state_records.map do |name, state|
+        max_width_units = state_records.map do |name, state|
           text_display_width_units(state_label(name, state))
         end.max || 0
         return DEFAULT_STATE_RADIUS if max_width_units <= 0
@@ -940,7 +959,7 @@ class Graphomaton
       def add_style(svg)
         style = svg.add_element('style')
         background = theme_css_value(:background, fallback: 'transparent')
-        scope = "##{@svg_id}"
+        scope = %(svg[id="#{@svg_id}"])
         style.text = <<-CSS
 #{css_variables_css}      
       #{scope} .diagram-background { fill: #{background}; }
@@ -1005,7 +1024,7 @@ class Graphomaton
           "#{indentation}  --graphomaton-#{css_variable_name(key)}: #{value};"
         end.join("\n")
 
-        "#{indentation}##{svg_id} {\n#{declarations}\n#{indentation}}\n"
+        %(#{indentation}svg[id="#{svg_id}"] {\n#{declarations}\n#{indentation}}\n)
       end
 
       def theme_css_value(key, fallback: nil)
@@ -1064,7 +1083,7 @@ class Graphomaton
 
       def default_svg_id(width, height)
         components = [
-          @automaton.state_records,
+          state_records,
           @automaton.transition_records,
           @automaton.initial_state,
           @automaton.final_states,
@@ -1304,6 +1323,7 @@ class Graphomaton
         words.each do |word|
           if text_exceeds_width?(word, max_width)
             lines << current unless current.empty?
+            current = +''
             split_words = split_long_word(word, max_width)
             split_words.each do |split_word|
               candidate = current.empty? ? split_word : "#{current} #{split_word}"
@@ -1384,7 +1404,7 @@ class Graphomaton
         if label_box_overlap?(collision_box) || label_box_overlaps_state?(collision_box)
           @diagnostics << layout_diagnostic('label-overlap-unresolved', 'Transition label overlap could not be resolved')
         end
-        if label_box_outside_canvas?(collision_box)
+        if !@auto_size && label_box_outside_canvas?(collision_box)
           @diagnostics << layout_diagnostic('label-outside-canvas', 'Transition label extends outside the SVG canvas')
         end
         box
@@ -1577,7 +1597,7 @@ class Graphomaton
         delta_y = target[:y].to_f - center[:y].to_f
         return [center[:x].to_f, center[:y].to_f] if delta_x.zero? && delta_y.zero?
 
-        shape = state_shape(@automaton.state_records.fetch(name))
+        shape = state_shape(state_records.fetch(name))
         scale = connection_scale(shape, delta_x, delta_y)
         [center[:x].to_f + (delta_x * scale), center[:y].to_f + (delta_y * scale)]
       end
@@ -2039,7 +2059,7 @@ class Graphomaton
 
       def add_initial_arrow(svg)
         init = state_position(@automaton.initial_state)
-        init ||= @automaton.state_records[@automaton.initial_state]
+        init ||= state_records[@automaton.initial_state]
         return unless init
 
         return unless init[:x] && init[:y]
@@ -2102,7 +2122,7 @@ class Graphomaton
 
       def add_final_arrows(svg)
         @automaton.final_states.each do |state_name|
-          state = state_position(state_name) || @automaton.state_records[state_name]
+          state = state_position(state_name) || state_records[state_name]
           next unless state && state[:x] && state[:y]
 
           x1, y1, x2, y2, label_x, label_y, anchor = final_arrow_points(state)
@@ -2184,7 +2204,7 @@ class Graphomaton
       end
 
       def grouped_state_positions
-        groups = @automaton.state_records.each_with_object({}) do |(name, state), grouped|
+        groups = state_records.each_with_object({}) do |(name, state), grouped|
           group_name = state_group_name(state)
           next unless group_name
 
@@ -2244,11 +2264,11 @@ class Graphomaton
       end
 
       def svg_group_decorations?
-        @scc_groups || @automaton.state_records.any? { |_, state| state_group_name(state) }
+        @scc_groups || state_records.any? { |_, state| state_group_name(state) }
       end
 
       def explicit_state_group?(state_name)
-        state = @automaton.state_records[state_name]
+        state = state_records[state_name]
         state && state_group_name(state)
       end
 
@@ -2260,7 +2280,8 @@ class Graphomaton
       end
 
       def folded_automaton(source)
-        groups = source.states.each_with_object({}) do |(name, state), grouped|
+        states = source.states
+        groups = states.each_with_object({}) do |(name, state), grouped|
           group_name = state_group_name(state)
           next unless group_name
 
@@ -2272,20 +2293,23 @@ class Graphomaton
 
         folded = Graphomaton.new
         group_ids = {}
+        reserved_group_ids = Set.new
         member_to_group = {}
 
         groups.each do |group_name, members|
-          group_id = folded_group_state_id(group_name, source.states, group_ids.values)
+          group_id = folded_group_state_id(group_name, states, reserved_group_ids)
           group_ids[group_name] = group_id
+          reserved_group_ids << group_id
           members.each { |member| member_to_group[member] = group_id }
         end
 
-        source.states.each do |name, state|
+        added_groups = Set.new
+        states.each do |name, state|
           group_name = state_group_name(state)
           if group_name && groups.key?(group_name)
-            next if folded.states.key?(group_ids[group_name])
+            next unless added_groups.add?(group_name)
 
-            position = folded_group_position(groups[group_name], source.states)
+            position = folded_group_position(groups[group_name], states)
             folded.add_state(
               group_ids[group_name],
               position[:x],
@@ -2302,15 +2326,19 @@ class Graphomaton
               label: state[:label],
               style: state[:style],
               metadata: state[:metadata],
-              shape: state[:shape]
+              shape: state[:shape],
+              kind: state[:kind]
             )
           end
         end
 
-        source.transitions.each do |transition|
-          from = member_to_group.fetch(transition[:from], transition[:from])
-          to = member_to_group.fetch(transition[:to], transition[:to])
-          next if from == to
+        source.transition_records.each do |transition|
+          from_group = member_to_group[transition.from]
+          to_group = member_to_group[transition.to]
+          next if from_group && from_group == to_group
+
+          from = from_group || transition.from
+          to = to_group || transition.to
 
           folded.add_transition(
             from,
@@ -2429,7 +2457,7 @@ class Graphomaton
       end
 
       def add_states(svg)
-        @automaton.state_records.each do |name, state|
+        state_records.each do |name, state|
           label = state_label(name, state)
           lines = state_label_lines(label)
           position = state_position(name) || state
@@ -2660,12 +2688,7 @@ class Graphomaton
       def safe_css_value(value, context:, allow_nil: false)
         return nil if value.nil? && allow_nil
 
-        css_value = value.to_s
-        if css_value.match?(/[\u0000-\u001f\u007f;{}]/) || css_value.match?(/url\s*\(/i)
-          raise Graphomaton::SecurityError, "Unsafe SVG #{context}: #{value.inspect}"
-        end
-
-        css_value
+        Graphomaton::Theme.safe_css_value(value, context: "SVG #{context}")
       end
 
       def state_group_attributes(name)
@@ -2681,7 +2704,7 @@ class Graphomaton
           'id' => unique_svg_id("state-#{svg_id_component(name)}"),
           'data-state' => name.to_s
         }
-        state = @automaton.state_records[name]
+        state = state_records[name]
         folded_group = state_metadata_value(state, :folded_group) if state
         folded_states = state_metadata_value(state, :folded_states) if state
         attributes['data-folded-group'] = folded_group.to_s if folded_group
@@ -2834,10 +2857,16 @@ class Graphomaton
       end
 
       def unique_svg_id(base_id)
-        @element_id_counts[base_id] += 1
-        return base_id if @element_id_counts[base_id] == 1
+        index = @element_id_counts[base_id] + 1
+        candidate = index == 1 ? base_id : "#{base_id}-#{index}"
+        while @element_ids.include?(candidate)
+          index += 1
+          candidate = "#{base_id}-#{index}"
+        end
 
-        "#{base_id}-#{@element_id_counts[base_id]}"
+        @element_id_counts[base_id] = index
+        @element_ids << candidate
+        candidate
       end
 
       def svg_id_component(value)
@@ -2849,6 +2878,10 @@ class Graphomaton
         @positions[state_name]
       end
 
+      def state_records
+        @state_records ||= @automaton.state_records
+      end
+
       def forward_direction?(x1, y1, x2, y2)
         case @direction
         when :lr

data/lib/graphomaton/input_policy.rb

@@ -25,6 +25,7 @@ class Graphomaton
 
     def self.identifier!(value, context:)
       raise ArgumentError, "#{context} cannot be nil" if value.nil?
+      raise ArgumentError, "#{context} cannot be boolean" if value == true || value == false
 
       text!(value, context: context)
       value
@@ -64,16 +65,16 @@ class Graphomaton
       raise ArgumentError, 'max_metadata_depth must be a positive Integer' unless maximum.is_a?(Integer) && maximum.positive?
 
       stack = [[value, 1]]
-      visited = {}
+      visited_depth = {}
       until stack.empty?
         current, depth = stack.pop
         text!(current, context: context, max_bytes: max_string_bytes) if current.is_a?(String)
         next unless current.is_a?(Hash) || current.is_a?(Array)
-        next if visited[current.object_id]
+        next if visited_depth.fetch(current.object_id, 0) >= depth
 
         raise ArgumentError, "#{context} exceeds max_metadata_depth (#{maximum})" if depth > maximum
 
-        visited[current.object_id] = true
+        visited_depth[current.object_id] = depth
         children = current.is_a?(Hash) ? current.flat_map { |key, item| [key, item] } : current
         children.each { |child| stack << [child, depth + 1] }
       end

data/lib/graphomaton/model.rb

@@ -37,7 +37,7 @@ class Graphomaton
   private_constant :ModelValue
 
   Label = Data.define(:kind, :value) do
-    KINDS = %i[text symbols epsilon uml].freeze
+    KINDS = %i[text symbols epsilon uml alternatives].freeze
 
     def initialize(kind:, value: nil)
       resolved_kind = kind.to_sym
@@ -64,6 +64,11 @@ class Graphomaton
                            raise ArgumentError, 'UML label requires an event' unless uml_value.key?(:event)
 
                            uml_value
+                         when :alternatives
+                           alternatives = Array(value)
+                           raise ArgumentError, 'Alternative label requires at least one label' if alternatives.empty?
+
+                           alternatives
                          end
       super(kind: resolved_kind, value: ModelValue.copy(normalized_value))
     end
@@ -84,6 +89,10 @@ class Graphomaton
       new(kind: :uml, value: { event: event, guard: guard, action: action }.compact)
     end
 
+    def self.alternatives(*values)
+      new(kind: :alternatives, value: values.flatten)
+    end
+
     def to_s
       case kind
       when :symbols
@@ -95,13 +104,16 @@ class Graphomaton
         guard = value[:guard] ? " [#{value[:guard]}]" : ''
         action = value[:action] ? " / #{value[:action]}" : ''
         "#{event}#{guard}#{action}"
+      when :alternatives
+        value.join(', ')
       else
         value.to_s
       end
     end
 
     def to_h
-      { type: kind, value: value }.compact
+      serialized = kind == :alternatives ? value.map { |label| label.is_a?(Label) ? label.to_h : label } : value
+      { type: kind, value: serialized }.compact
     end
   end
 

data/lib/graphomaton/process_runner.rb

@@ -110,13 +110,12 @@ class Graphomaton
     private_class_method :output_reader
 
     def self.terminate(wait_thread)
-      return unless wait_thread.alive?
-
-      signal_process(wait_thread.pid, 'TERM')
-      return if wait_thread.join(0.25)
-
-      signal_process(wait_thread.pid, 'KILL')
-      wait_thread.join
+      pid = wait_thread.pid
+      parent_alive = wait_thread.alive?
+      signal_process(pid, 'TERM')
+      parent_alive ? wait_thread.join(0.25) : sleep(0.25)
+      signal_process(pid, 'KILL')
+      wait_thread.join if wait_thread.alive?
     end
     private_class_method :terminate
 
@@ -137,7 +136,7 @@ class Graphomaton
     private_class_method :signal_process
 
     def self.validate_limit(value, name)
-      return if value.is_a?(Numeric) && value.finite? && value.positive?
+      return if value.is_a?(Numeric) && value.real? && value.to_f.finite? && value.positive?
 
       raise ArgumentError, "#{name} must be a positive finite number"
     end

data/lib/graphomaton/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Graphomaton
-  VERSION = '1.1.0'
+  VERSION = '1.2.0'
 end

data/lib/graphomaton.rb

@@ -90,7 +90,18 @@ class Graphomaton
     end
 
     def self.save_gallery_html(filename, **options)
-      AtomicFile.write(filename, gallery_html(**options))
+      no_clobber = options.delete(:no_clobber) || false
+      AtomicFile.write(filename, gallery_html(**options), no_clobber: no_clobber)
+    end
+
+    def self.safe_css_value(value, context:)
+      string = value.to_s
+      if string.match?(/[\u0000-\u001f\u007f;{}\\]/) ||
+         string.match?(/\/\*|(?:url|src|image(?:-set)?|cross-fade|element|paint)\s*\(/i)
+        raise Graphomaton::SecurityError, "Unsafe #{context}: #{value.inspect}"
+      end
+
+      string
     end
 
     def self.theme_card(name, theme)
@@ -150,10 +161,7 @@ class Graphomaton
     private_class_method :escape_html
 
     def self.validate_value(key, value, context:)
-      string = value.to_s
-      if string.match?(/[\u0000-\u001f\u007f;{}]/) || string.match?(/url\s*\(/i)
-        raise Graphomaton::SecurityError, "Unsafe #{context} value for #{key}: #{value.inspect}"
-      end
+      safe_css_value(value, context: "#{context} value for #{key}")
 
       return unless key == :label_opacity
 
@@ -190,17 +198,18 @@ class Graphomaton
     puml: :plantuml
   }.freeze
   ALL_EXPORT_CAPABILITIES = %i[
-    state_style transition_style url tooltip group parent pseudostate bundle line_style
+    state_style transition_style url state_tooltip transition_tooltip group parent pseudostate bundle line_style
   ].freeze
+  RASTER_EXPORT_CAPABILITIES = (ALL_EXPORT_CAPABILITIES - %i[url state_tooltip transition_tooltip]).freeze
   EXPORTERS = ExporterRegistry.new.tap do |registry|
     registry.register(:svg, extensions: %w[svg], capabilities: ALL_EXPORT_CAPABILITIES) { Exporters::Svg }
-    registry.register(:png, extensions: %w[png], binary: true, capabilities: ALL_EXPORT_CAPABILITIES) { Exporters::Png }
-    registry.register(:pdf, extensions: %w[pdf], binary: true, capabilities: ALL_EXPORT_CAPABILITIES) { Exporters::Pdf }
-    registry.register(:webp, extensions: %w[webp], binary: true, capabilities: ALL_EXPORT_CAPABILITIES) { Exporters::Webp }
-    registry.register(:html, extensions: %w[html], capabilities: %i[group parent pseudostate tooltip]) { Exporters::Mermaid }
-    registry.register(:mermaid, aliases: %i[mmd], extensions: %w[mermaid mmd], capabilities: %i[group parent pseudostate tooltip]) { Exporters::Mermaid }
-    registry.register(:dot, aliases: %i[gv], extensions: %w[dot gv], capabilities: %i[url tooltip group pseudostate bundle line_style]) { Exporters::Dot }
-    registry.register(:plantuml, aliases: %i[puml], extensions: %w[plantuml puml], capabilities: %i[group parent pseudostate tooltip]) { Exporters::Plantuml }
+    registry.register(:png, extensions: %w[png], binary: true, capabilities: RASTER_EXPORT_CAPABILITIES) { Exporters::Png }
+    registry.register(:pdf, extensions: %w[pdf], binary: true, capabilities: RASTER_EXPORT_CAPABILITIES) { Exporters::Pdf }
+    registry.register(:webp, extensions: %w[webp], binary: true, capabilities: RASTER_EXPORT_CAPABILITIES) { Exporters::Webp }
+    registry.register(:html, extensions: %w[html], capabilities: %i[group parent pseudostate]) { Exporters::Mermaid }
+    registry.register(:mermaid, aliases: %i[mmd], extensions: %w[mermaid mmd], capabilities: %i[group parent pseudostate]) { Exporters::Mermaid }
+    registry.register(:dot, aliases: %i[gv], extensions: %w[dot gv], capabilities: %i[url state_tooltip transition_tooltip group pseudostate bundle line_style]) { Exporters::Dot }
+    registry.register(:plantuml, aliases: %i[puml], extensions: %w[plantuml puml], capabilities: %i[group parent pseudostate]) { Exporters::Plantuml }
   end
   DEFAULT_INITIAL_POSITION = :auto
   DEFAULT_FINAL_POSITION = :auto
@@ -212,12 +221,29 @@ class Graphomaton
   DEFAULT_MAX_LABEL_LENGTH = 64 * 1024
   DEFAULT_MAX_GROUP_DEPTH = 64
   DEFAULT_MAX_CANVAS_AREA = 100_000_000
+  DEFAULT_MAX_CANVAS_DIMENSION = 100_000
   DEFAULT_MAX_LAYOUT_ITERATIONS = 10_000
   FORCE_TREE_THRESHOLD = 128
   VALIDATION_MODES = %i[deferred strict].freeze
   VALIDATION_PROFILES = %i[references fsm_semantics dfa].freeze
   UNSET = Object.new.freeze
   EMPTY_TRANSITIONS = [].freeze
+
+  def self.validate_canvas_dimensions!(width, height)
+    { width: width, height: height }.each do |name, value|
+      unless value.is_a?(Numeric) && value.real? && value.to_f.finite? && value.positive?
+        raise ArgumentError, "#{name} must be a positive finite number"
+      end
+    end
+    if width.to_f * height.to_f > DEFAULT_MAX_CANVAS_AREA
+      raise ArgumentError, "canvas area exceeds max_canvas_area (#{DEFAULT_MAX_CANVAS_AREA})"
+    end
+    if width.to_f > DEFAULT_MAX_CANVAS_DIMENSION || height.to_f > DEFAULT_MAX_CANVAS_DIMENSION
+      raise ArgumentError, "canvas dimension exceeds max_canvas_dimension (#{DEFAULT_MAX_CANVAS_DIMENSION})"
+    end
+
+    true
+  end
   attr_reader :initial_state, :revision
 
   def self.png_available?(converter: Exporters::Png::DEFAULT_CONVERTER)
@@ -429,6 +455,9 @@ class Graphomaton
         guard: input_value(value, :guard),
         action: input_value(value, :action)
       )
+    when :alternatives
+      values = Array(input_value(label, :value))
+      Label.alternatives(*values.map { |value| structured_label_from_input(value) })
     else
       raise ArgumentError, "Unknown label type: #{type.inspect}"
     end
@@ -682,10 +711,13 @@ class Graphomaton
       shape: immutable_copy(attributes.fetch(:shape, state.shape)),
       kind: resolve_state_kind(attributes.fetch(:kind, state.kind))
     )
-    return self if updated_state == state
+    coordinates_updated = attributes.key?(:x)
+    manual = !x.nil? && !y.nil?
+    manual_changed = coordinates_updated && @manual_states[name] != manual
+    return self if updated_state == state && !manual_changed
 
     @states[name] = updated_state
-    @manual_states[name] = !x.nil? && !y.nil?
+    @manual_states[name] = manual if coordinates_updated
     graph_changed!
     self
   end
@@ -1058,12 +1090,16 @@ class Graphomaton
     layout_diagnostics_for(positions, width, height, state_radius).map(&:message)
   end
 
-  def layout_diagnostics_for(positions, width, height, state_radius)
+  def layout_diagnostics_for(positions, width, height, state_radius, x: 0, y: 0)
     radius = state_radius.to_f
+    left = x.to_f
+    top = y.to_f
+    right = left + width.to_f
+    bottom = top + height.to_f
     positions.each_with_object([]) do |(name, position), diagnostics|
-      x = position[:x].to_f
-      y = position[:y].to_f
-      if x - radius < 0 || x + radius > width.to_f
+      state_x = position[:x].to_f
+      state_y = position[:y].to_f
+      if state_x - radius < left || state_x + radius > right
         diagnostics << Diagnostic.new(
           code: 'state-clipped-horizontal',
           severity: :warning,
@@ -1072,7 +1108,7 @@ class Graphomaton
           hint: 'Increase the canvas width or use fit: :contain'
         )
       end
-      if y - radius < 0 || y + radius > height.to_f
+      if state_y - radius < top || state_y + radius > bottom
         diagnostics << Diagnostic.new(
           code: 'state-clipped-vertical',
           severity: :warning,
@@ -1092,11 +1128,7 @@ class Graphomaton
                       initial_position: DEFAULT_INITIAL_POSITION, final_position: DEFAULT_FINAL_POSITION,
                       preserve_manual_positions: DEFAULT_PRESERVE_MANUAL_POSITIONS,
                       fit: DEFAULT_FIT)
-    validate_finite_number!(width, 'width', positive: true)
-    validate_finite_number!(height, 'height', positive: true)
-    if width.to_f * height.to_f > DEFAULT_MAX_CANVAS_AREA
-      raise ArgumentError, "canvas area exceeds max_canvas_area (#{DEFAULT_MAX_CANVAS_AREA})"
-    end
+    self.class.validate_canvas_dimensions!(width, height)
     validate_finite_number!(state_radius, 'state_radius', positive: true)
     validate_finite_number!(padding, 'padding', nonnegative: true)
     validate_finite_number!(node_spacing, 'node_spacing', nonnegative: true)
@@ -1222,14 +1254,11 @@ class Graphomaton
   end
 
   def ordered_state_names
-    ordered_states = []
-    ordered_states << @initial_state if @initial_state && @states[@initial_state]
-
-    @states.each_key do |name|
-      ordered_states << name unless ordered_states.include?(name)
-    end
+    states = @states.keys
+    return states unless @states.key?(@initial_state)
 
-    ordered_states
+    states.delete(@initial_state)
+    states.unshift(@initial_state)
   end
 
   def auto_layout(width = 800, height = 600, layout: :linear, direction: :lr,
@@ -1994,9 +2023,10 @@ class Graphomaton
     io.write(output)
   end
 
-  def semantic_diagnostics(format)
+  def semantic_diagnostics(format, **options)
     resolved = resolve_format(format)
-    capabilities = self.class.exporter_capabilities(resolved)
+    capabilities = self.class.exporter_capabilities(resolved).dup
+    capabilities << :state_tooltip if options[:notes] && %i[html mermaid plantuml].include?(resolved)
     ExporterCapabilities.losses_for(self, capabilities).map do |feature|
       Diagnostic.new(
         code: 'unsupported-export-feature',
@@ -2010,7 +2040,7 @@ class Graphomaton
 
   def render(format: :svg, width: 800, height: 600, strict_semantics: false, **options)
     resolved_format = resolve_format(format)
-    losses = semantic_diagnostics(resolved_format)
+    losses = semantic_diagnostics(resolved_format, **options)
     if strict_semantics && losses.any?
       raise ExportError, losses.map(&:message).join("\n")
     end
@@ -2046,10 +2076,28 @@ class Graphomaton
 
   def render_result(format: :svg, width: 800, height: 600, strict_semantics: false, **options)
     resolved = resolve_format(format)
-    return Exporters::Svg.new(self).export_result(width, height, **options) if resolved == :svg
-    return Exporters::Png.new(self).export_result(width, height, **options) if resolved == :png
-    return Exporters::Pdf.new(self).export_result(width, height, **options) if resolved == :pdf
-    return Exporters::Webp.new(self).export_result(width, height, **options) if resolved == :webp
+    losses = semantic_diagnostics(resolved, **options)
+    if strict_semantics && losses.any?
+      raise ExportError, losses.map(&:message).join("\n")
+    end
+
+    exporter = case resolved
+               when :svg then Exporters::Svg
+               when :png then Exporters::Png
+               when :pdf then Exporters::Pdf
+               when :webp then Exporters::Webp
+               end
+    if exporter
+      result = exporter.new(self).export_result(width, height, **options)
+      return result if losses.empty?
+
+      return RenderResult.new(
+        output: result.output,
+        diagnostics: (losses + result.diagnostics).freeze,
+        bounds: result.bounds,
+        layout: result.layout
+      )
+    end
 
     output = render(
       format: resolved,
@@ -2060,7 +2108,7 @@ class Graphomaton
     )
     RenderResult.new(
       output: output,
-      diagnostics: semantic_diagnostics(resolved),
+      diagnostics: losses,
       bounds: nil,
       layout: nil
     )
@@ -2533,6 +2581,11 @@ class Graphomaton
     if label.is_a?(Array)
       labels = label.map { |item| normalize_single_transition_label(item, epsilon_label: epsilon_label) }.uniq
       labels = labels.sort_by(&:to_s) if sort_labels
+      if labels.any? { |item| item.is_a?(Label) && item.kind == :epsilon }
+        return labels.first if labels.one?
+
+        return Label.alternatives(*labels)
+      end
       return Label.symbols(*labels.map(&:to_s))
     end
 
@@ -2670,7 +2723,7 @@ class Graphomaton
     @states.each_key do |from|
       by_symbol = Hash.new { |hash, key| hash[key] = [] }
       @outgoing_by_state[from].each do |transition|
-        if transition.label.is_a?(Label) && transition.label.kind == :epsilon
+        if epsilon_transition_label?(transition.label)
           diagnostics << diagnostic(
             'epsilon-transition-in-dfa',
             :error,
@@ -2695,11 +2748,22 @@ class Graphomaton
   end
 
   def transition_label_symbols(label)
-    return label.value if label.is_a?(Label) && label.kind == :symbols
+    if label.is_a?(Label)
+      return label.value if label.kind == :symbols
+      return [] if label.kind == :epsilon
+      return label.value.flat_map { |item| transition_label_symbols(item) } if label.kind == :alternatives
+    end
 
     [label.to_s]
   end
 
+  def epsilon_transition_label?(label)
+    return false unless label.is_a?(Label)
+    return true if label.kind == :epsilon
+
+    label.kind == :alternatives && label.value.any? { |item| epsilon_transition_label?(item) }
+  end
+
   def diagnostic(code, severity, path, message, hint = nil)
     Diagnostic.new(code: code, severity: severity, path: path.freeze, message: message, hint: hint)
   end

data/sig/graphomaton.rbs

@@ -29,6 +29,7 @@ class Graphomaton
     def self.symbols: (*untyped values) -> Label
     def self.epsilon: (?untyped display) -> Label
     def self.uml: (event: untyped, ?guard: untyped, ?action: untyped) -> Label
+    def self.alternatives: (*untyped values) -> Label
     def to_s: () -> String
     def to_h: () -> Hash[Symbol, untyped]
   end
@@ -108,6 +109,7 @@ class Graphomaton
   def to_json: (*untyped) -> String
   def to_yaml: (**untyped) -> String
   def render: (?format: Symbol | String, ?width: Numeric, ?height: Numeric, ?strict_semantics: bool, **untyped) -> String
+  def semantic_diagnostics: (Symbol | String format, **untyped) -> Array[Diagnostic]
   def render_result: (?format: Symbol | String, ?width: Numeric, ?height: Numeric, ?strict_semantics: bool, **untyped) -> RenderResult
   def render_with: (RenderOptions options) -> String
   def reachable_states: () -> Array[untyped]

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphomaton
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Yudai Takada
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rexml
@@ -76,6 +77,7 @@ metadata:
   documentation_uri: https://rubydoc.info/gems/graphomaton
   bug_tracker_uri: https://github.com/ydah/graphomaton/issues
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -90,7 +92,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 3.4.19
+signing_key:
 specification_version: 4
 summary: Generate and analyze finite state machine diagrams in multiple formats.
 test_files: []