ibex 0.1.0 → 0.3.0

data/sig/ibex/ir/lexer_ir.rbs

@@ -0,0 +1,57 @@
+# Generated from lib/ibex/ir/lexer_ir.rb with RBS::Inline
+
+module Ibex
+  module IR
+    LEXER_SCHEMA_VERSION: ::Integer
+
+    SUPPORTED_LEXER_SCHEMA_VERSIONS: Array[Integer]
+
+    # One normalized, state-scoped lexer rule.
+    class LexerRule
+      attr_reader id: Integer
+
+      attr_reader state: String
+
+      attr_reader kind: Symbol
+
+      attr_reader token: String?
+
+      attr_reader pattern: String
+
+      attr_reader pattern_kind: Symbol
+
+      attr_reader options: String
+
+      attr_reader action: String?
+
+      attr_reader location: location
+
+      # @rbs (id: Integer, state: String, kind: Symbol, token: String?, pattern: String, pattern_kind: Symbol,
+      #   options: String, action: String?, location: location) -> void
+      def initialize: (id: Integer, state: String, kind: Symbol, token: String?, pattern: String, pattern_kind: Symbol, options: String, action: String?, location: location) -> void
+
+      # @rbs () -> Hash[Symbol, lexer_rule_document_value]
+      def to_h: () -> Hash[Symbol, lexer_rule_document_value]
+    end
+
+    # Independently versioned lexer contract embedded by the current Grammar IR.
+    class Lexer
+      attr_reader states: Array[String]
+
+      attr_reader rules: Array[LexerRule]
+
+      attr_reader warnings: Array[lexer_warning]
+
+      attr_reader schema_version: Integer
+
+      attr_reader source_provenance: source_provenance?
+
+      # @rbs (states: Array[String], rules: Array[LexerRule], warnings: Array[lexer_warning],
+      #   ?schema_version: Integer, ?source_provenance: source_provenance?) -> void
+      def initialize: (states: Array[String], rules: Array[LexerRule], warnings: Array[lexer_warning], ?schema_version: Integer, ?source_provenance: source_provenance?) -> void
+
+      # @rbs () -> Hash[Symbol, lexer_document_value]
+      def to_h: () -> Hash[Symbol, lexer_document_value]
+    end
+  end
+end

data/sig/ibex/ir/parser_contract.rbs

@@ -0,0 +1,69 @@
+# Generated from lib/ibex/ir/parser_contract.rb with RBS::Inline
+
+module Ibex
+  module IR
+    # Root-owned parser configuration persisted by the current Grammar IR.
+    class ParserContract
+      type definition = { configuration: String, values: Array[Symbol] }
+
+      type entry_location = { file: String?, line: Integer, column: Integer }
+
+      type entry_value = String? | bool | entry_location?
+
+      DEFINITIONS: Hash[Symbol, definition]
+
+      # One specified or explicitly unspecified contract field.
+      class Entry
+        attr_reader key: Symbol
+
+        attr_reader value: Symbol?
+
+        attr_reader location: Location?
+
+        attr_reader explicit: bool
+
+        # @rbs (Symbol key, ?value: Symbol?, ?location: Location?, ?explicit: bool) -> void
+        def initialize: (Symbol key, ?value: Symbol?, ?location: Location?, ?explicit: bool) -> void
+
+        # @rbs () -> Hash[Symbol, entry_value]
+        def to_h: () -> Hash[Symbol, entry_value]
+
+        private
+
+        # @rbs (Symbol key, Array[Symbol] allowed, Symbol? value, Location? location, bool explicit) -> void
+        def validate_state!: (Symbol key, Array[Symbol] allowed, Symbol? value, Location? location, bool explicit) -> void
+
+        # @rbs () -> entry_location?
+        def serialized_location: () -> entry_location?
+      end
+
+      attr_reader algorithm: Entry
+
+      attr_reader entries: Entry
+
+      attr_reader cst_trivia: Entry
+
+      # @rbs (?algorithm: Entry?, ?entries: Entry?, ?cst_trivia: Entry?) -> void
+      def initialize: (?algorithm: Entry?, ?entries: Entry?, ?cst_trivia: Entry?) -> void
+
+      # @rbs () -> Hash[Symbol, Hash[Symbol, entry_value]]
+      def to_h: () -> Hash[Symbol, Hash[Symbol, entry_value]]
+
+      # Values supplied to the typed resolver; unspecified fields are absent.
+      # @rbs () -> Hash[String, Symbol]
+      def configuration_values: () -> Hash[String, Symbol]
+
+      # Source locations supplied to the typed resolver.
+      # @rbs () -> Hash[String, Location]
+      def configuration_locations: () -> Hash[String, Location]
+
+      private
+
+      # @rbs (Symbol key, Entry? entry) -> Entry
+      def normalize_entry: (Symbol key, Entry? entry) -> Entry
+
+      # @rbs () -> Array[Entry]
+      def specified_entries: () -> Array[Entry]
+    end
+  end
+end

data/sig/ibex/ir/serialize.rbs

@@ -2,49 +2,101 @@
 
 module Ibex
   module IR
-    # Stable JSON serialization for versioned pipeline IR.
+    # Stable JSON serialization for the current pipeline IR.
+    # rubocop:disable Metrics/ModuleLength -- explicit fields keep serialization changes auditable.
+    # rubocop:disable Lint/SelfAssignment -- RBS inline assertions narrow schema-decoded values in place.
     module Serialize
-      private def validate_version: (untyped data) -> untyped
+      private def validate_version: (Hash[String, IR::serialized_value] data) -> void
 
-      private def self.validate_version: (untyped data) -> untyped
+      private def self.validate_version: (Hash[String, IR::serialized_value] data) -> void
 
-      private def load_grammar: (untyped data) -> untyped
+      private def load_grammar: (Hash[String, IR::serialized_value] data) -> Grammar
 
-      private def self.load_grammar: (untyped data) -> untyped
+      private def self.load_grammar: (Hash[String, IR::serialized_value] data) -> Grammar
 
-      private def load_automaton: (untyped data) -> untyped
+      private def load_symbols: (Hash[String, IR::serialized_value] data) -> Array[GrammarSymbol]
 
-      private def self.load_automaton: (untyped data) -> untyped
+      private def self.load_symbols: (Hash[String, IR::serialized_value] data) -> Array[GrammarSymbol]
 
-      private def load_state: (untyped state, untyped grammar) -> untyped
+      private def load_productions: (Hash[String, IR::serialized_value] data) -> Array[Production]
 
-      private def self.load_state: (untyped state, untyped grammar) -> untyped
+      private def self.load_productions: (Hash[String, IR::serialized_value] data) -> Array[Production]
 
-      private def symbol_keyed: (untyped values, untyped grammar, ?actions: untyped) -> untyped
+      private def empty_chunks: () -> Hash[String, IR::serialized_value]
 
-      private def self.symbol_keyed: (untyped values, untyped grammar, ?actions: untyped) -> untyped
+      private def self.empty_chunks: () -> Hash[String, IR::serialized_value]
 
-      private def normalize_action: (untyped value) -> untyped
+      private def empty_parameters: () -> Array[IR::serialized_value]
 
-      private def self.normalize_action: (untyped value) -> untyped
+      private def self.empty_parameters: () -> Array[IR::serialized_value]
 
-      private def load_production: (untyped production) -> untyped
+      private def empty_printers: () -> Array[IR::serialized_value]
 
-      private def self.load_production: (untyped production) -> untyped
+      private def self.empty_printers: () -> Array[IR::serialized_value]
 
-      private def load_user_code_chunks: (untyped chunks) -> untyped
+      private def empty_tests: () -> Array[IR::serialized_value]
 
-      private def self.load_user_code_chunks: (untyped chunks) -> untyped
+      private def self.empty_tests: () -> Array[IR::serialized_value]
 
-      private def symbolize: (untyped value) -> untyped
+      private def empty_recovery: () -> Hash[String, IR::serialized_value]
 
-      private def self.symbolize: (untyped value) -> untyped
+      private def self.empty_recovery: () -> Hash[String, IR::serialized_value]
 
-      # @rbs (Grammar | Automaton value) -> String
-      def self?.dump: (Grammar | Automaton value) -> String
+      private def load_automaton: (Hash[String, IR::serialized_value] data) -> Automaton
 
-      # @rbs (String source) -> (Grammar | Automaton)
-      def self?.load: (String source) -> (Grammar | Automaton)
+      private def self.load_automaton: (Hash[String, IR::serialized_value] data) -> Automaton
+
+      private def load_lexer: (Hash[String, IR::serialized_value] data) -> Lexer
+
+      private def self.load_lexer: (Hash[String, IR::serialized_value] data) -> Lexer
+
+      private def load_state: (Hash[String, IR::serialized_value] state, Grammar grammar) -> AutomatonState
+
+      private def self.load_state: (Hash[String, IR::serialized_value] state, Grammar grammar) -> AutomatonState
+
+      private def symbol_keyed: (Hash[String, IR::serialized_value] values, Grammar grammar, ?actions: bool) -> Hash[Integer, IR::serialized_value]
+
+      private def self.symbol_keyed: (Hash[String, IR::serialized_value] values, Grammar grammar, ?actions: bool) -> Hash[Integer, IR::serialized_value]
+
+      private def normalize_action: (Hash[String, IR::serialized_value] value) -> parser_action?
+
+      private def self.normalize_action: (Hash[String, IR::serialized_value] value) -> parser_action?
+
+      private def load_production: (Hash[String, IR::serialized_value] production) -> Production
+
+      private def self.load_production: (Hash[String, IR::serialized_value] production) -> Production
+
+      private def load_user_code_chunks: (Hash[String, Array[Hash[String, IR::serialized_value]]] chunks) -> user_code_chunks
+
+      private def self.load_user_code_chunks: (Hash[String, Array[Hash[String, IR::serialized_value]]] chunks) -> user_code_chunks
+
+      private def load_symbol_metadata: (Hash[String, IR::serialized_value] symbol, String field) -> String?
+
+      private def self.load_symbol_metadata: (Hash[String, IR::serialized_value] symbol, String field) -> String?
+
+      private def load_grammar_tests: (Array[Hash[String, IR::serialized_value]] tests) -> Array[grammar_test]
+
+      private def self.load_grammar_tests: (Array[Hash[String, IR::serialized_value]] tests) -> Array[grammar_test]
+
+      private def symbol_source_position: (Hash[String, IR::serialized_value] symbol) -> String
+
+      private def self.symbol_source_position: (Hash[String, IR::serialized_value] symbol) -> String
+
+      private def load_parser_contract: (IR::serialized_value value) -> IR::serialized_value
+
+      private def self.load_parser_contract: (IR::serialized_value value) -> IR::serialized_value
+
+      private def symbolize: (IR::serialized_value value) -> IR::serialized_value
+
+      private def self.symbolize: (IR::serialized_value value) -> IR::serialized_value
+
+      # @rbs (Grammar | Automaton | Lexer value) -> String
+      def self?.dump: (Grammar | Automaton | Lexer value) -> String
+
+      # @rbs (String source) -> (Grammar | Automaton | Lexer)
+      def self?.load: (String source) -> (Grammar | Automaton | Lexer)
+
+      private
     end
   end
 end

data/sig/ibex/ir/validator/automaton.rbs

@@ -0,0 +1,112 @@
+# Generated from lib/ibex/ir/validator/automaton.rb with RBS::Inline
+
+module Ibex
+  module IR
+    module Validator
+      # Structural and referential validation for a current Automaton IR JSON object.
+      # rubocop:disable Metrics/ClassLength -- inline type contracts accompany one cohesive document validator.
+      class AutomatonDocument < Base
+        ROOT_REQUIRED: Array[String]
+
+        ROOT_OPTIONAL: Array[String]
+
+        STATE_REQUIRED: Array[String]
+
+        ACTION_TYPES: Array[String]
+
+        RESOLUTION_KINDS: Array[String]
+
+        @version: Integer
+
+        @grammar: GrammarDocument
+
+        @states_by_id: Hash[Integer, json_object]
+
+        @data: json_object
+
+        # @rbs (json_object data, ?version: Integer) -> void
+        def initialize: (json_object data, ?version: Integer) -> void
+
+        # @rbs () -> self
+        def validate: () -> self
+
+        private
+
+        # @rbs () -> void
+        def validate_entry_states: () -> void
+
+        # @rbs (Hash[String, untyped] grammar) -> void
+        def validate_construction_contract: (Hash[String, untyped] grammar) -> void
+
+        # @rbs () -> void
+        def validate_digest: () -> void
+
+        # @rbs () -> void
+        def validate_state_records: () -> void
+
+        # @rbs () -> void
+        def validate_state_contents: () -> void
+
+        # @rbs (json_value value, String path) -> void
+        def validate_items: (json_value value, String path) -> void
+
+        # @rbs (Integer production_id, json_value dot_value, String path) -> void
+        def validate_item_production: (Integer production_id, json_value dot_value, String path) -> void
+
+        # @rbs (json_value value, String path) -> void
+        def validate_lookaheads: (json_value value, String path) -> void
+
+        # @rbs (json_value value, String path) -> void
+        def validate_transitions: (json_value value, String path) -> void
+
+        # @rbs (json_value value, String path) -> void
+        def validate_actions: (json_value value, String path) -> void
+
+        # @rbs (json_value value, String path) -> void
+        def validate_gotos: (json_value value, String path) -> void
+
+        # @rbs (json_value value, String path, ?kind: String?) { (json_value, String, json_object) -> void } -> void
+        def symbol_map: (json_value value, String path, ?kind: String?) { (json_value, String, json_object) -> void } -> void
+
+        # @rbs (json_value value, String path) -> void
+        def validate_state_reference: (json_value value, String path) -> void
+
+        # @rbs (json_value value, String path, ?nullable: bool) -> void
+        def validate_parser_action: (json_value value, String path, ?nullable: bool) -> void
+
+        # @rbs (json_value value, String path) -> void
+        def validate_production_reference: (json_value value, String path) -> void
+
+        # @rbs (json_value value, String path) -> void
+        def validate_conflicts: (json_value value, String path) -> void
+
+        # @rbs (json_object conflict, String path) -> void
+        def validate_shift_reduce: (json_object conflict, String path) -> void
+
+        # @rbs (json_object conflict, String path) -> void
+        def validate_reduce_reduce: (json_object conflict, String path) -> void
+
+        # @rbs (json_object conflict, String path) -> void
+        def validate_conflict_entries: (json_object conflict, String path) -> void
+
+        # @rbs (json_value value, String path) -> void
+        def validate_midrule_origins: (json_value value, String path) -> void
+
+        # @rbs (json_value value, String path) -> void
+        def validate_conflict_symbol: (json_value value, String path) -> void
+
+        # @rbs (json_value value, String path, ?reductions: Array[Integer]?) -> void
+        def validate_resolution: (json_value value, String path, ?reductions: Array[Integer]?) -> void
+
+        # @rbs () -> void
+        def validate_conflict_summary: () -> void
+
+        # @rbs (json_object summary, String path) -> void
+        def validate_conflict_counts: (json_object summary, String path) -> void
+
+        # @rbs (json_object summary, String path) -> void
+        def validate_expectation: (json_object summary, String path) -> void
+      end
+    end
+  end
+end

data/sig/ibex/ir/validator/base.rbs

@@ -0,0 +1,69 @@
+# Generated from lib/ibex/ir/validator/base.rb with RBS::Inline
+
+module Ibex
+  module IR
+    module Validator
+      type json_value = String | Integer | Float | bool | nil | Array[json_value] | Hash[String, json_value]
+
+      type json_object = Hash[String, json_value]
+
+      # Shared JSON-shape checks for current IR documents.
+      class Base
+        POSITION: ::String
+
+        private
+
+        # @rbs (json_value value, String path, Array[String] required, ?Array[String] optional) -> json_object
+        def record: (json_value value, String path, Array[String] required, ?Array[String] optional) -> json_object
+
+        # @rbs (json_value value, String path) -> json_object
+        def object: (json_value value, String path) -> json_object
+
+        # @rbs (json_value value, String path) -> Array[json_value]
+        def array: (json_value value, String path) -> Array[json_value]
+
+        # @rbs (json_value value, String path) -> String
+        def string: (json_value value, String path) -> String
+
+        # @rbs (json_value value, String path) -> String
+        def nonempty_string: (json_value value, String path) -> String
+
+        # @rbs (json_value value, String path) -> Integer
+        def integer: (json_value value, String path) -> Integer
+
+        # @rbs (json_value value, String path) -> Integer
+        def nonnegative_integer: (json_value value, String path) -> Integer
+
+        # @rbs (json_value value, String path) -> bool
+        def boolean: (json_value value, String path) -> bool
+
+        # @rbs (json_value value, String path, json_value expected) -> void
+        def literal: (json_value value, String path, json_value expected) -> void
+
+        # @rbs (json_value value, String path, Array[String] values) -> String
+        def enum: (json_value value, String path, Array[String] values) -> String
+
+        # @rbs (json_value value, String path, ?nullable: bool) -> void
+        def location: (json_value value, String path, ?nullable: bool) -> void
+
+        # @rbs (json_value value, String path) -> Integer
+        def positive_integer: (json_value value, String path) -> Integer
+
+        # @rbs (json_value value, String path) -> String?
+        def nullable_string: (json_value value, String path) -> String?
+
+        # @rbs (json_value value, String path) -> void
+        def metadata: (json_value value, String path) -> void
+
+        # @rbs (json_object value, String key, String path) -> json_value
+        def field: (json_object value, String key, String path) -> json_value
+
+        # @rbs (String path, String key) -> String
+        def child_path: (String path, String key) -> String
+
+        # @rbs (String path, String message) -> bot
+        def invalid: (String path, String message) -> bot
+      end
+    end
+  end
+end

data/sig/ibex/ir/validator/grammar.rbs

@@ -0,0 +1,195 @@
+# Generated from lib/ibex/ir/validator/grammar.rb with RBS::Inline
+
+module Ibex
+  module IR
+    module Validator
+      # Structural and referential validation for a current Grammar IR JSON object.
+      # rubocop:disable Metrics/ClassLength -- inline type contracts accompany one cohesive document validator.
+      class GrammarDocument < Base
+        ROOT_REQUIRED: Array[String]
+
+        ROOT_OPTIONAL: Array[String]
+
+        SYMBOL_REQUIRED: Array[String]
+
+        SYMBOL_OPTIONAL: Array[String]
+
+        SYMBOL_METADATA_REQUIRED: Array[String]
+
+        PRODUCTION_REQUIRED: Array[String]
+
+        PRODUCTION_METADATA_REQUIRED: Array[String]
+
+        ACTION_COMPOSITION_REQUIRED: Array[String]
+
+        ORIGIN_KINDS: Array[String]
+
+        RUBY_KEYWORDS: Array[String]
+
+        attr_reader symbols_by_id: Hash[Integer, json_object]
+
+        attr_reader symbols_by_name: Hash[String, json_object]
+
+        attr_reader productions_by_id: Hash[Integer, json_object]
+
+        @version: Integer
+
+        @path: String
+
+        @data: json_object
+
+        # @rbs (json_object data, ?path: String, ?version: Integer) -> void
+        def initialize: (json_object data, ?path: String, ?version: Integer) -> void
+
+        # @rbs () -> self
+        def validate: () -> self
+
+        private
+
+        # @rbs () -> void
+        def validate_root_record: () -> void
+
+        # @rbs () -> void
+        def validate_optional_parser_metadata: () -> void
+
+        # @rbs () -> void
+        def validate_parser_parameters_if_present: () -> void
+
+        # @rbs () -> void
+        def validate_optional_source_metadata: () -> void
+
+        # @rbs () -> void
+        def validate_envelope: () -> void
+
+        # @rbs () -> void
+        def validate_header: () -> void
+
+        # @rbs () -> void
+        def validate_options: () -> void
+
+        # @rbs () -> void
+        def validate_parser_parameters: () -> void
+
+        # @rbs () -> void
+        def validate_value_printers: () -> void
+
+        # @rbs () -> void
+        def validate_grammar_tests: () -> void
+
+        # @rbs () -> void
+        def validate_symbols: () -> void
+
+        # @rbs (json_value value, Integer index) -> void
+        def validate_symbol: (json_value value, Integer index) -> void
+
+        # @rbs (json_value value, String path) -> void
+        def validate_precedence: (json_value value, String path) -> void
+
+        # @rbs () -> void
+        def validate_reserved_symbols: () -> void
+
+        # @rbs (Integer id, String name) -> void
+        def validate_reserved_symbol: (Integer id, String name) -> void
+
+        # @rbs () -> void
+        def validate_start: () -> void
+
+        # @rbs (String start) -> void
+        def validate_multiple_starts: (String start) -> void
+
+        # @rbs () -> void
+        def validate_recovery: () -> void
+
+        # @rbs (json_value values, String path, kind: String) -> void
+        def validate_recovery_symbols: (json_value values, String path, kind: String) -> void
+
+        # @rbs (json_value value, String path, kind: String, seen: Hash[String, bool]) -> void
+        def validate_recovery_symbol: (json_value value, String path, kind: String, seen: Hash[String, bool]) -> void
+
+        # @rbs () -> void
+        def validate_productions: () -> void
+
+        # @rbs (json_value value, Integer index) -> void
+        def validate_production: (json_value value, Integer index) -> void
+
+        # @rbs (json_value value, String path, rhs_length: Integer) -> void
+        def validate_node_annotation: (json_value value, String path, rhs_length: Integer) -> void
+
+        # @rbs (json_value value, String path) -> void
+        def validate_lhs: (json_value value, String path) -> void
+
+        # @rbs (json_value value, String path) -> void
+        def validate_rhs: (json_value value, String path) -> void
+
+        # @rbs (json_value value, String path, rhs_length: Integer) -> void
+        def validate_action: (json_value value, String path, rhs_length: Integer) -> void
+
+        # @rbs (json_value value, String path, limit: Integer) -> void
+        def validate_named_refs: (json_value value, String path, limit: Integer) -> void
+
+        # @rbs (json_value value, String path) -> void
+        def validate_precedence_override: (json_value value, String path) -> void
+
+        # @rbs (json_value value, String path) -> void
+        def validate_origin: (json_value value, String path) -> void
+
+        # @rbs (json_value value, String path) -> void
+        def validate_string_map: (json_value value, String path) -> void
+
+        # @rbs () -> void
+        def validate_warnings: () -> void
+
+        # @rbs (json_value value, String path) -> void
+        def validate_warning: (json_value value, String path) -> void
+
+        # @rbs (json_object warning, String path) -> void
+        def validate_warning_symbol: (json_object warning, String path) -> void
+
+        # @rbs (json_object warning, String field_name, String path) -> void
+        def validate_warning_production: (json_object warning, String field_name, String path) -> void
+
+        # @rbs () -> void
+        def validate_lexer: () -> void
+
+        # @rbs () -> void
+        def validate_user_code_chunks: () -> void
+
+        # @rbs (json_value value, String path, ?nullable: bool) -> void
+        def validate_source_provenance: (json_value value, String path, ?nullable: bool) -> void
+
+        # @rbs (json_value value, String path) -> void
+        def validate_byte_span: (json_value value, String path) -> void
+
+        # @rbs () -> void
+        def validate_parser_contract: () -> void
+
+        # @rbs (untyped value, String, Array[String]) -> Hash[String, untyped]
+        def validate_contract_entry: (untyped value, String, Array[String]) -> Hash[String, untyped]
+
+        # @rbs (json_value value, String path) -> void
+        def validate_expansion: (json_value value, String path) -> void
+
+        # @rbs (json_value value, String path) -> void
+        def validate_parameter_expansion: (json_value value, String path) -> void
+
+        # @rbs (json_value value, String path) -> void
+        def validate_inline_expansion: (json_value value, String path) -> void
+
+        # @rbs (json_value value, String path, rhs_length: Integer) -> void
+        def validate_action_composition: (json_value value, String path, rhs_length: Integer) -> void
+
+        # @rbs (json_value value, String path, Integer rhs_length, Array[json_value] fragments) -> void
+        def validate_action_composition_plan: (json_value value, String path, Integer rhs_length, Array[json_value] fragments) -> void
+
+        # @rbs (json_value value, String path, Integer physical, Integer step_index) -> void
+        def validate_action_composition_step: (json_value value, String path, Integer physical, Integer step_index) -> void
+
+        # @rbs (Array[json_value] inputs, String path, Integer limit) -> void
+        def validate_action_slots: (Array[json_value] inputs, String path, Integer limit) -> void
+
+        # @rbs (json_value value, String path, Integer physical) -> void
+        def validate_action_lookahead: (json_value value, String path, Integer physical) -> void
+      end
+    end
+  end
+end

data/sig/ibex/ir/validator/lexer.rbs

@@ -0,0 +1,37 @@
+# Generated from lib/ibex/ir/validator/lexer.rb with RBS::Inline
+
+module Ibex
+  module IR
+    module Validator
+      # Structural validation for the independently versioned Lexer IR.
+      class LexerDocument < Base
+        ROOT_REQUIRED: Array[String]
+
+        RULE_REQUIRED: Array[String]
+
+        # @rbs (json_object data, ?path: String) -> void
+        def initialize: (json_object data, ?path: String) -> void
+
+        # @rbs () -> self
+        def validate: () -> self
+
+        private
+
+        # @rbs () -> void
+        def validate_states: () -> void
+
+        # @rbs () -> void
+        def validate_rules: () -> void
+
+        # @rbs (json_object rule, String path, String options) -> void
+        def validate_pattern: (json_object rule, String path, String options) -> void
+
+        # @rbs () -> void
+        def validate_warnings: () -> void
+
+        # @rbs () -> void
+        def validate_source_provenance: () -> void
+      end
+    end
+  end
+end

data/sig/ibex/ir/validator.rbs

@@ -0,0 +1,16 @@
+# Generated from lib/ibex/ir/validator.rb with RBS::Inline
+
+module Ibex
+  module IR
+    # Validates a serialized public IR document before constructing immutable IR objects.
+    module Validator
+      POSITION: ::String
+
+      # @rbs (String source) -> (Grammar | Automaton | Lexer)
+      def self?.validate: (String source) -> (Grammar | Automaton | Lexer)
+
+      # @rbs (Automaton automaton) -> void
+      def self?.validate_automaton_digest: (Automaton automaton) -> void
+    end
+  end
+end