ibex 0.2.0 → 0.4.0

data/sig/ibex/generation_manifest.rbs

@@ -2,7 +2,10 @@
 
 module Ibex
   # Deterministic description of one published parser generation.
+  # rubocop:disable Metrics/ModuleLength -- manifest schema validation is kept in one auditable unit.
   module GenerationManifest
+    type json_value = String | Integer | Float | bool | nil | Array[json_value] | Hash[String, json_value]
+
     SCHEMA_VERSION: Integer
 
     IDENTIFIER: String
@@ -15,53 +18,53 @@ module Ibex
 
     ARTIFACT_KEYS: Array[String]
 
-    # @rbs (ArtifactSet artifacts, source_records: Array[GenerationInput], options: Hash[String, untyped]) -> String
-    def self?.render: (ArtifactSet artifacts, source_records: Array[GenerationInput], options: Hash[String, untyped]) -> String
+    # @rbs (ArtifactSet artifacts, source_records: Array[GenerationInput], options: Hash[String, Object?]) -> String
+    def self?.render: (ArtifactSet artifacts, source_records: Array[GenerationInput], options: Hash[String, Object?]) -> String
 
     # Validate the manifest shape and, by default, every published artifact digest.
-    # @rbs (String source, ?verify_artifacts: bool) -> Hash[String, untyped]
-    def self?.validate: (String source, ?verify_artifacts: bool) -> Hash[String, untyped]
+    # @rbs (String source, ?verify_artifacts: bool) -> Hash[String, json_value]
+    def self?.validate: (String source, ?verify_artifacts: bool) -> Hash[String, json_value]
 
-    # @rbs (String path, ?verify_artifacts: bool) -> Hash[String, untyped]
-    def self?.validate_file: (String path, ?verify_artifacts: bool) -> Hash[String, untyped]
+    # @rbs (String path, ?verify_artifacts: bool) -> Hash[String, json_value]
+    def self?.validate_file: (String path, ?verify_artifacts: bool) -> Hash[String, json_value]
 
-    # @rbs (Artifact artifact) -> Hash[String, untyped]
-    def self?.artifact_entry: (Artifact artifact) -> Hash[String, untyped]
+    # @rbs (Artifact artifact) -> Hash[String, json_value]
+    def self?.artifact_entry: (Artifact artifact) -> Hash[String, json_value]
 
-    # @rbs (Array[Hash[String, untyped]] files) -> String
-    def self?.input_digest: (Array[Hash[String, untyped]] files) -> String
+    # @rbs (Array[Hash[String, json_value]] files) -> String
+    def self?.input_digest: (Array[Hash[String, json_value]] files) -> String
 
-    # @rbs (Hash[String, untyped] value) -> Hash[String, untyped]
-    def self?.sorted_hash: (Hash[String, untyped] value) -> Hash[String, untyped]
+    # @rbs (Hash[String, Object?] value) -> Hash[String, Object?]
+    def self?.sorted_hash: (Hash[String, Object?] value) -> Hash[String, Object?]
 
-    # @rbs (untyped document) -> void
-    def self?.validate_document: (untyped document) -> void
+    # @rbs (Object? document) -> void
+    def self?.validate_document: (Object? document) -> void
 
-    # @rbs (Hash[untyped, untyped] document) -> void
-    def self?.validate_identity: (Hash[untyped, untyped] document) -> void
+    # @rbs (Hash[Object?, Object?] document) -> void
+    def self?.validate_identity: (Hash[Object?, Object?] document) -> void
 
-    # @rbs (untyped input) -> void
-    def self?.validate_input: (untyped input) -> void
+    # @rbs (Object? input) -> void
+    def self?.validate_input: (Object? input) -> void
 
-    # @rbs (Array[untyped] entries, String label, ?require_kind: bool) -> void
-    def self?.validate_entries: (Array[untyped] entries, String label, ?require_kind: bool) -> void
+    # @rbs (Array[Object?] entries, String label, ?require_kind: bool) -> void
+    def self?.validate_entries: (Array[Object?] entries, String label, ?require_kind: bool) -> void
 
-    # @rbs (untyped entry, String label, bool require_kind) -> void
-    def self?.validate_entry: (untyped entry, String label, bool require_kind) -> void
+    # @rbs (Object? entry, String label, bool require_kind) -> void
+    def self?.validate_entry: (Object? entry, String label, bool require_kind) -> void
 
-    # @rbs (untyped path, String label) -> void
-    def self?.validate_path: (untyped path, String label) -> void
+    # @rbs (Object? path, String label) -> void
+    def self?.validate_path: (Object? path, String label) -> void
 
-    # @rbs (untyped kind, String label) -> void
-    def self?.validate_kind: (untyped kind, String label) -> void
+    # @rbs (Object? kind, String label) -> void
+    def self?.validate_kind: (Object? kind, String label) -> void
 
-    # @rbs (untyped digest, String label) -> void
-    def self?.validate_digest: (untyped digest, String label) -> void
+    # @rbs (Object? digest, String label) -> void
+    def self?.validate_digest: (Object? digest, String label) -> void
 
-    # @rbs (Hash[untyped, untyped] value, Array[String] expected, String label) -> void
-    def self?.exact_keys!: (Hash[untyped, untyped] value, Array[String] expected, String label) -> void
+    # @rbs (Hash[Object?, Object?] value, Array[String] expected, String label) -> void
+    def self?.exact_keys!: (Hash[Object?, Object?] value, Array[String] expected, String label) -> void
 
-    # @rbs (Array[untyped] entries) -> void
-    def self?.verify_entries: (Array[untyped] entries) -> void
+    # @rbs (Array[Object?] entries) -> void
+    def self?.verify_entries: (Array[Object?] entries) -> void
   end
 end

data/sig/ibex/generation_transaction_recovery.rbs

@@ -21,8 +21,8 @@ module Ibex
     # @rbs () -> Array[String]
     def rollback: () -> Array[String]
 
-    # @rbs (Hash[Symbol, untyped] record) -> void
-    def rollback_record: (Hash[Symbol, untyped] record) -> void
+    # @rbs (Hash[Symbol, Object?] record) -> void
+    def rollback_record: (Hash[Symbol, Object?] record) -> void
 
     # @rbs (preserve_backups: bool) -> Array[String]
     def cleanup_artifacts: (preserve_backups: bool) -> Array[String]

data/sig/ibex/generation_transaction_validation.rbs

@@ -56,8 +56,8 @@ module Ibex
     # @rbs (String phase) -> void
     def validate_current_targets!: (String phase) -> void
 
-    # @rbs (Hash[Symbol, untyped] record, Array[String] sources, String phase) -> void
-    def validate_current_target!: (Hash[Symbol, untyped] record, Array[String] sources, String phase) -> void
+    # @rbs (Hash[Symbol, Object?] record, Array[String] sources, String phase) -> void
+    def validate_current_target!: (Hash[Symbol, Object?] record, Array[String] sources, String phase) -> void
 
     # @rbs () -> void
     def validate_locked_targets!: () -> void

data/sig/ibex/grammar_tests.rbs

@@ -86,8 +86,8 @@ module Ibex
       # @rbs (String output) -> Array[Result]
       def decode_results: (String output) -> Array[Result]
 
-      # @rbs (IR::grammar_test test, untyped document) -> Result
-      def build_result: (IR::grammar_test test, untyped document) -> Result
+      # @rbs (IR::grammar_test test, Object? document) -> Result
+      def build_result: (IR::grammar_test test, Object? document) -> Result
     end
   end
 end

data/sig/ibex/impact/action_impact.rbs

@@ -0,0 +1,58 @@
+# Generated from lib/ibex/impact/action_impact.rb with RBS::Inline
+
+module Ibex
+  module Impact
+    # Checks only structured action metadata; action source remains opaque.
+    class ActionImpact
+      # @rbs @before: IR::Grammar
+      # @rbs @after: IR::Grammar
+      # @rbs @affected_names: Array[String]?
+      attr_reader findings: Array[Hash[Symbol, Object?]]
+
+      # @rbs (IR::Grammar before, IR::Grammar after, ?affected_names: Array[String]?) -> void
+      def initialize: (IR::Grammar before, IR::Grammar after, ?affected_names: Array[String]?) -> void
+
+      # @rbs () -> Array[Hash[Symbol, Object?]]
+      def to_a: () -> Array[Hash[Symbol, Object?]]
+
+      private
+
+      # @rbs () -> Array[Hash[Symbol, Object?]]
+      def compare: () -> Array[Hash[Symbol, Object?]]
+
+      # @rbs (String name) -> Array[Hash[Symbol, Object?]]
+      def compare_rule: (String name) -> Array[Hash[Symbol, Object?]]
+
+      # @rbs (Array[IR::Production] before, Array[IR::Production] after) -> Array[[IR::Production, IR::Production]]
+      def pair_productions: (Array[IR::Production] before, Array[IR::Production] after) -> Array[[ IR::Production, IR::Production ]]
+
+      # @rbs (Array[IR::Production] unmatched, Array[IR::Production] after) -> Array[[IR::Production, IR::Production]]
+      def pair_exact_productions: (Array[IR::Production] unmatched, Array[IR::Production] after) -> Array[[ IR::Production, IR::Production ]]
+
+      # @rbs (Array[IR::Production] unmatched, Array[IR::Production] after,
+      #   Array[[IR::Production, IR::Production]]) -> Array[[IR::Production, IR::Production]]
+      def pair_by_location: (Array[IR::Production] unmatched, Array[IR::Production] after, Array[[ IR::Production, IR::Production ]]) -> Array[[ IR::Production, IR::Production ]]
+
+      # @rbs (IR::Grammar grammar, String name) -> Array[IR::Production]
+      def productions_for: (IR::Grammar grammar, String name) -> Array[IR::Production]
+
+      # @rbs (IR::Grammar grammar, IR::Production production) -> [Array[String], String?]
+      def production_signature: (IR::Grammar grammar, IR::Production production) -> [ Array[String], String? ]
+
+      # @rbs (IR::Production production) -> [Integer, Integer]?
+      def action_location_identity: (IR::Production production) -> [ Integer, Integer ]?
+
+      # @rbs (IR::Production before, IR::Production after) -> Hash[Symbol, Object?]
+      def finding_for: (IR::Production before, IR::Production after) -> Hash[Symbol, Object?]
+
+      # @rbs (IR::Action?, Integer, Integer) -> [String, String]
+      def finding_reason: (IR::Action?, Integer, Integer) -> [ String, String ]
+
+      # @rbs (IR::Action?, Integer) -> bool
+      def out_of_range?: (IR::Action?, Integer) -> bool
+
+      # @rbs (IR::Grammar grammar, IR::Production production) -> String
+      def production_name: (IR::Grammar grammar, IR::Production production) -> String
+    end
+  end
+end

data/sig/ibex/impact/automaton_impact.rbs

@@ -0,0 +1,37 @@
+# Generated from lib/ibex/impact/automaton_impact.rb with RBS::Inline
+
+module Ibex
+  module Impact
+    # Maps propagated grammar symbols to parser states and conflict changes.
+    class AutomatonImpact
+      # @rbs @automaton: IR::Automaton
+      # @rbs @symbol_ids: Array[Integer]
+      # @rbs @production_ids: Array[Integer]
+      attr_reader affected_states: Array[Integer]
+
+      attr_reader production_ids: Array[Integer]
+
+      attr_reader conflict_states: Array[Integer]
+
+      # @rbs (IR::Automaton automaton, Array[Integer]) -> void
+      def initialize: (IR::Automaton automaton, Array[Integer]) -> void
+
+      # @rbs (Hash[Symbol, Object?] diff) -> Hash[Symbol, Object?]
+      def conflict_changes: (Hash[Symbol, Object?] diff) -> Hash[Symbol, Object?]
+
+      # @rbs () -> Hash[Symbol, Object?]
+      def to_h: () -> Hash[Symbol, Object?]
+
+      private
+
+      # @rbs () -> Array[Integer]
+      def affected_productions: () -> Array[Integer]
+
+      # @rbs () -> Array[Integer]
+      def affected_state_ids: () -> Array[Integer]
+
+      # @rbs () -> Array[Integer]
+      def conflict_state_ids: () -> Array[Integer]
+    end
+  end
+end

data/sig/ibex/impact/coverage_impact.rbs

@@ -0,0 +1,28 @@
+# Generated from lib/ibex/impact/coverage_impact.rb with RBS::Inline
+
+module Ibex
+  module Impact
+    # Selects separated runtime coverage reports for affected productions.
+    class CoverageImpact
+      attr_reader status: String
+
+      attr_reader reports: Array[Hash[Symbol, Object?]]
+
+      attr_reader warnings: Array[String]
+
+      # @rbs (IR::Automaton automaton, Array[Integer], Array[[String, Coverage::Report]]) -> void
+      def initialize: (IR::Automaton automaton, Array[Integer], Array[[ String, Coverage::Report ]]) -> void
+
+      # @rbs () -> Hash[Symbol, Object?]
+      def to_h: () -> Hash[Symbol, Object?]
+
+      private
+
+      # @rbs (Array[[String, Coverage::Report]]) -> Array[Hash[Symbol, Object?]]
+      def select_reports: (Array[[ String, Coverage::Report ]]) -> Array[Hash[Symbol, Object?]]
+
+      # @rbs (Array[[String, Coverage::Report]]) -> String
+      def coverage_status: (Array[[ String, Coverage::Report ]]) -> String
+    end
+  end
+end

data/sig/ibex/impact/graph.rbs

@@ -0,0 +1,67 @@
+# Generated from lib/ibex/impact/graph.rb with RBS::Inline
+
+module Ibex
+  module Impact
+    # A grammar dependency edge with enough origin information for a witness.
+    class Edge
+      attr_reader source: Integer
+
+      attr_reader target: Integer
+
+      attr_reader kind: Symbol
+
+      attr_reader production: Integer?
+
+      attr_reader position: Integer?
+
+      # @rbs (source: Integer, target: Integer, kind: Symbol, production: Integer?, position: Integer?) -> void
+      def initialize: (source: Integer, target: Integer, kind: Symbol, production: Integer?, position: Integer?) -> void
+
+      # @rbs () -> Array[Integer | Symbol | nil]
+      def sort_key: () -> Array[Integer | Symbol | nil]
+    end
+
+    # Combines reference, FIRST, and FOLLOW propagation dependencies.
+    class Graph
+      EDGE_KINDS: Array[Symbol]
+
+      KIND_ALIASES: Hash[Symbol, Array[Symbol]]
+
+      attr_reader grammar: IR::Grammar
+
+      attr_reader sets: Analysis::Sets
+
+      # @rbs (IR::Grammar grammar, ?sets: Analysis::Sets) -> void
+      def initialize: (IR::Grammar grammar, ?sets: Analysis::Sets) -> void
+
+      # @rbs (?Symbol kind) -> untyped
+      def edges: (?Symbol kind) -> untyped
+
+      # @rbs (Symbol kind) -> Array[Array[Integer]]
+      def adjacency: (Symbol kind) -> Array[Array[Integer]]
+
+      private
+
+      # @rbs () -> Hash[Symbol, Array[Edge]]
+      def build_edges: () -> Hash[Symbol, Array[Edge]]
+
+      # @rbs (Hash[Symbol, Array[Edge]], IR::Production) -> void
+      def add_production_edges: (Hash[Symbol, Array[Edge]], IR::Production) -> void
+
+      # @rbs (Hash[Symbol, Array[Edge]], IR::Production, Integer, Integer) -> void
+      def add_first_edge: (Hash[Symbol, Array[Edge]], IR::Production, Integer, Integer) -> void
+
+      # @rbs (Hash[Symbol, Array[Edge]], IR::Production, Integer, Integer) -> void
+      def add_follow_edges: (Hash[Symbol, Array[Edge]], IR::Production, Integer, Integer) -> void
+
+      # @rbs (Hash[Symbol, Array[Edge]], IR::Production, Integer, Integer) -> void
+      def add_follow_first_edges: (Hash[Symbol, Array[Edge]], IR::Production, Integer, Integer) -> void
+
+      # @rbs (Integer source, Integer target, Symbol kind, IR::Production production, Integer position) -> Edge
+      def edge: (Integer source, Integer target, Symbol kind, IR::Production production, Integer position) -> Edge
+
+      # @rbs () -> void
+      def freeze_edges: () -> void
+    end
+  end
+end

data/sig/ibex/impact/propagation.rbs

@@ -0,0 +1,56 @@
+# Generated from lib/ibex/impact/propagation.rb with RBS::Inline
+
+module Ibex
+  module Impact
+    # One shortest witness for a symbol reached by dependency propagation.
+    class Node
+      attr_reader symbol: Integer
+
+      attr_reader distance: Integer
+
+      attr_reader witness: Array[Edge]
+
+      attr_reader kind: Symbol
+
+      attr_reader component: Array[Integer]
+
+      # @rbs (symbol: Integer, distance: Integer, witness: Array[Edge], kind: Symbol, component: Array[Integer]) -> void
+      def initialize: (symbol: Integer, distance: Integer, witness: Array[Edge], kind: Symbol, component: Array[Integer]) -> void
+    end
+
+    # Performs deterministic forward propagation over a dependency graph.
+    class Propagation
+      # @rbs @graph: Graph
+      # @rbs (Graph graph) -> void
+      def initialize: (Graph graph) -> void
+
+      # @rbs (Array[Integer] seeds, Symbol kind, ?max_depth: Integer?) -> Hash[Integer, Node]
+      def propagate: (Array[Integer] seeds, Symbol kind, ?max_depth: Integer?) -> Hash[Integer, Node]
+
+      alias call propagate
+
+      private
+
+      # @rbs (Integer?) -> void
+      def validate_depth: (Integer?) -> void
+
+      # @rbs (Array[Integer]) -> Array[Integer]
+      def normalize_seeds: (Array[Integer]) -> Array[Integer]
+
+      # @rbs (Array[Array[Integer]], Integer) -> Array[Integer]
+      def component_index: (Array[Array[Integer]], Integer) -> Array[Integer]
+
+      # @rbs (Array[Array[Integer]], Array[Integer], Integer) -> Array[Array[Integer]]
+      def component_adjacency: (Array[Array[Integer]], Array[Integer], Integer) -> Array[Array[Integer]]
+
+      # @rbs (Array[Integer], Array[Integer], Array[Array[Integer]], Integer?) -> Hash[Integer, Integer]
+      def traverse_components: (Array[Integer], Array[Integer], Array[Array[Integer]], Integer?) -> Hash[Integer, Integer]
+
+      # @rbs (Array[Integer], Array[Array[Integer]], Symbol) -> Hash[Integer, Array[Edge]]
+      def symbol_witnesses: (Array[Integer], Array[Array[Integer]], Symbol) -> Hash[Integer, Array[Edge]]
+
+      # @rbs (Hash[Integer, Integer], Array[Array[Integer]], Symbol, Hash[Integer, Array[Edge]]) -> Hash[Integer, Node]
+      def build_nodes: (Hash[Integer, Integer], Array[Array[Integer]], Symbol, Hash[Integer, Array[Edge]]) -> Hash[Integer, Node]
+    end
+  end
+end

data/sig/ibex/impact/report.rbs

@@ -0,0 +1,107 @@
+# Generated from lib/ibex/impact/report.rb with RBS::Inline
+
+module Ibex
+  module Impact
+    # Builds the deterministic public impact-v1 document.
+    class Report
+      # @rbs @mode: String
+      # @rbs @algorithm: String
+      # @rbs @grammar: IR::Grammar
+      # @rbs @before: IR::Automaton?
+      # @rbs @after: IR::Automaton?
+      # @rbs @seeds: Array[Hash[Symbol, Object?]]
+      # @rbs @nodes: Hash[Integer, Node]
+      # @rbs @symbol_kinds: Hash[Integer, Array[String]]
+      # @rbs @set_changes: Hash[String, Hash[Symbol, Object?]]
+      # @rbs @metadata_names: Array[String]
+      # @rbs @automaton: Hash[Symbol, Object?]
+      # @rbs @actions: Array[Hash[Symbol, Object?]]
+      # @rbs @coverage: Hash[Symbol, Object?]
+      # @rbs @minimum: String
+      # @rbs @warnings: Array[String]
+      # @rbs (mode: String, algorithm: String, grammar: IR::Grammar, before: IR::Automaton?, after: IR::Automaton?,
+      #   seeds: Array[Hash[Symbol, Object?]], nodes: Hash[Integer, Node], symbol_kinds: Hash[Integer, Array[String]],
+      #   set_changes: Hash[String, Hash[Symbol, Object?]], automaton: Hash[Symbol, Object?],
+      #   actions: Array[Hash[Symbol, Object?]], coverage: Hash[Symbol, Object?], ?metadata_names: Array[String],
+      #   ?minimum: String,
+      #   ?warnings: Array[String]) -> void
+      # rubocop:disable Metrics/ParameterLists
+      def initialize: (mode: String, algorithm: String, grammar: IR::Grammar, before: IR::Automaton?, after: IR::Automaton?, seeds: Array[Hash[Symbol, Object?]], nodes: Hash[Integer, Node], symbol_kinds: Hash[Integer, Array[String]], set_changes: Hash[String, Hash[Symbol, Object?]], automaton: Hash[Symbol, Object?], actions: Array[Hash[Symbol, Object?]], coverage: Hash[Symbol, Object?], ?metadata_names: Array[String], ?minimum: String, ?warnings: Array[String]) -> void
+
+      # @rbs (?minimum: String) -> Hash[Symbol, Object?]
+      def to_h: (?minimum: String) -> Hash[Symbol, Object?]
+
+      private
+
+      # @rbs (String minimum) -> Array[Hash[Symbol, Object?]]
+      def symbol_documents: (String minimum) -> Array[Hash[Symbol, Object?]]
+
+      # @rbs (String) -> Hash[Symbol, Object?]?
+      def symbol_document: (String) -> Hash[Symbol, Object?]?
+
+      # @rbs (String) -> bool
+      def reportable_symbol?: (String) -> bool
+
+      # @rbs (String, Integer?) -> Array[String]
+      def symbol_kinds_for: (String, Integer?) -> Array[String]
+
+      # @rbs (String) -> Array[String]
+      def change_kinds: (String) -> Array[String]
+
+      # @rbs (String, Array[String]) -> String
+      def document_severity: (String, Array[String]) -> String
+
+      # @rbs (Node?, String) -> Array[String]
+      def component_names: (Node?, String) -> Array[String]
+
+      # @rbs (String kind) -> String
+      def kind_severity: (String kind) -> String
+
+      # @rbs (String name, String current) -> String
+      def action_severity: (String name, String current) -> String
+
+      # @rbs (Hash[Symbol, Object?] record) -> String
+      def severity_of: (Hash[Symbol, Object?] record) -> String
+
+      # @rbs () -> Hash[Symbol, Array[String]]
+      def empty_change: () -> Hash[Symbol, Array[String]]
+
+      # @rbs (Array[Edge]) -> Array[Hash[Symbol, Object?]]
+      def witness_documents: (Array[Edge]) -> Array[Hash[Symbol, Object?]]
+
+      # @rbs (Integer) -> String
+      def symbol_name: (Integer) -> String
+
+      # @rbs (IR::Production?) -> String?
+      def production_shape: (IR::Production?) -> String?
+
+      # @rbs (Array[Hash[Symbol, Object?]], Array[Hash[Symbol, Object?]],
+      #   Hash[Symbol, Object?]) -> Hash[Symbol, Integer]
+      def totals: (Array[Hash[Symbol, Object?]], Array[Hash[Symbol, Object?]], Hash[Symbol, Object?]) -> Hash[Symbol, Integer]
+
+      # @rbs (String minimum) -> Array[Hash[Symbol, Object?]]
+      def action_documents: (String minimum) -> Array[Hash[Symbol, Object?]]
+
+      # @rbs (Hash[Symbol, Object?] action) -> String
+      def action_production: (Hash[Symbol, Object?] action) -> String
+
+      # @rbs () -> Hash[Symbol, Object?]
+      def coverage_document: () -> Hash[Symbol, Object?]
+
+      # @rbs (Hash[Symbol, Object?] report) -> String
+      def coverage_report_path: (Hash[Symbol, Object?] report) -> String
+
+      # @rbs () -> Array[String]
+      def stable_warnings: () -> Array[String]
+
+      # @rbs (IR::location?) -> Hash[Symbol, Integer]?
+      def stable_location: (IR::location?) -> Hash[Symbol, Integer]?
+
+      # @rbs (IR::Automaton?) -> String?
+      def stable_grammar_digest: (IR::Automaton?) -> String?
+
+      # @rbs (String) -> String
+      def stable_path: (String) -> String
+    end
+  end
+end

data/sig/ibex/impact/seeds.rbs

@@ -0,0 +1,36 @@
+# Generated from lib/ibex/impact/seeds.rb with RBS::Inline
+
+module Ibex
+  module Impact
+    # Converts command-line symbols and Diff rule ids into analysis seeds.
+    class Seeds
+      # @rbs @grammar: IR::Grammar
+      # @rbs @sets: Analysis::Sets
+      # @rbs @records: Array[Hash[Symbol, Object?]]
+      # @rbs @ids: Array[Integer]
+      attr_reader ids: Array[Integer]
+
+      attr_reader records: Array[Hash[Symbol, Object?]]
+
+      # @rbs (IR::Grammar grammar, Array[String] names, ?origin: String) -> void
+      def initialize: (IR::Grammar grammar, Array[String] names, ?origin: String) -> void
+
+      # @rbs (IR::Grammar grammar, Hash[Symbol, Object?] diff, ?origin: String) -> Seeds
+      def self.from_diff: (IR::Grammar grammar, Hash[Symbol, Object?] diff, ?origin: String) -> Seeds
+
+      private
+
+      # @rbs (Hash[Symbol, Object?] record) -> String
+      def seed_symbol: (Hash[Symbol, Object?] record) -> String
+
+      # @rbs (Hash[Symbol, Object?] record) -> Integer
+      def seed_id: (Hash[Symbol, Object?] record) -> Integer
+
+      # @rbs (String name, String origin) -> Array[Hash[Symbol, Object?]]
+      def resolve: (String name, String origin) -> Array[Hash[Symbol, Object?]]
+
+      # @rbs (Integer) -> bool
+      def nullable_boundary?: (Integer) -> bool
+    end
+  end
+end

data/sig/ibex/impact/severity.rbs

@@ -0,0 +1,55 @@
+# Generated from lib/ibex/impact/severity.rb with RBS::Inline
+
+module Ibex
+  module Impact
+    # Stores only conflict identities so a baseline is stable across state ids.
+    class Baseline
+      # @rbs (String path) -> void
+      def initialize: (String path) -> void
+
+      # @rbs () -> Array[String]
+      def conflicts: () -> Array[String]
+
+      # @rbs (Object?) -> void
+      def validate_document: (Object?) -> void
+
+      # @rbs (Array[String] identities) -> void
+      def write: (Array[String] identities) -> void
+    end
+
+    # Severity ranking and CI gate evaluation for impact findings.
+    module Severity
+      LEVELS: Array[String]
+
+      FAIL_ON: Array[String]
+
+      RANK: Hash[String, Integer]
+
+      GATE_TO_KIND: Hash[String, String]
+
+      # @rbs (String left, String right) -> String
+      def self?.max: (String left, String right) -> String
+
+      # @rbs (Hash[String, Array[String]], Array[Hash[Symbol, String]]) -> Hash[String, String]
+      def self?.symbols: (Hash[String, Array[String]], Array[Hash[Symbol, String]]) -> Hash[String, String]
+
+      # @rbs (String) -> String
+      def self?.level_for_kind: (String) -> String
+
+      # @rbs (Hash[Symbol, Object?] report, Array[String] gates) -> bool
+      def self?.fails?: (Hash[Symbol, Object?] report, Array[String] gates) -> bool
+
+      # @rbs (Hash[Symbol, Object?], Array[String]) -> bool
+      def self?.conflict_gate?: (Hash[Symbol, Object?], Array[String]) -> bool
+
+      # @rbs (Hash[Symbol, Object?], Array[String]) -> bool
+      def self?.unreachable_gate?: (Hash[Symbol, Object?], Array[String]) -> bool
+
+      # @rbs (Hash[Symbol, Object?], Array[String]) -> bool
+      def self?.action_gate?: (Hash[Symbol, Object?], Array[String]) -> bool
+
+      # @rbs (Array[String] gates) -> Array[String]
+      def self?.validate_gates: (Array[String] gates) -> Array[String]
+    end
+  end
+end

data/sig/ibex/impact.rbs

@@ -0,0 +1,6 @@
+# Generated from lib/ibex/impact.rb with RBS::Inline
+
+module Ibex
+  module Impact
+  end
+end

data/sig/ibex/ir/automaton_ir.rbs

@@ -13,8 +13,8 @@ module Ibex
       # @rbs (production: Integer, dot: Integer, lookaheads: Array[Integer]) -> void
       def initialize: (production: Integer, dot: Integer, lookaheads: Array[Integer]) -> void
 
-      # @rbs (Grammar grammar) -> Hash[Symbol, untyped]
-      def to_h: (Grammar grammar) -> Hash[Symbol, untyped]
+      # @rbs (Grammar grammar) -> Hash[Symbol, Object?]
+      def to_h: (Grammar grammar) -> Hash[Symbol, Object?]
     end
 
     # A deterministic LALR automaton state.
@@ -38,13 +38,13 @@ module Ibex
       #   ?conflicts: Array[conflict]) -> void
       def initialize: (id: Integer, items: Array[AutomatonItem], transitions: Hash[Integer, Integer], actions: Hash[Integer, parser_action], gotos: Hash[Integer, Integer], ?default_action: parser_action?, ?conflicts: Array[conflict]) -> void
 
-      # @rbs (Grammar grammar) -> Hash[Symbol, untyped]
-      def to_h: (Grammar grammar) -> Hash[Symbol, untyped]
+      # @rbs (Grammar grammar) -> Hash[Symbol, Object?]
+      def to_h: (Grammar grammar) -> Hash[Symbol, Object?]
 
       private
 
-      # @rbs (Hash[Integer, untyped] values, Grammar grammar) -> Hash[String, untyped]
-      def named_keys: (Hash[Integer, untyped] values, Grammar grammar) -> Hash[String, untyped]
+      # @rbs (Hash[Integer, Object?] values, Grammar grammar) -> Hash[String, Object?]
+      def named_keys: (Hash[Integer, Object?] values, Grammar grammar) -> Hash[String, Object?]
     end
 
     # Immutable LALR automaton and its source grammar.
@@ -63,13 +63,20 @@ module Ibex
 
       attr_reader schema_version: Integer
 
+      attr_reader entry_construction: String
+
+      # @rbs (grammar: Grammar, states: Array[AutomatonState], conflict_summary: conflict_summary,
+      #   ?algorithm: String, ?grammar_digest: String?, ?entry_states: Hash[String, Integer]?,
+      #   ?entry_construction: String) -> void
+      def initialize: (grammar: Grammar, states: Array[AutomatonState], conflict_summary: conflict_summary, ?algorithm: String, ?grammar_digest: String?, ?entry_states: Hash[String, Integer]?, ?entry_construction: String) -> void
+
       # @rbs (grammar: Grammar, states: Array[AutomatonState], conflict_summary: conflict_summary,
-      #   ?algorithm: String, ?grammar_digest: String?, ?schema_version: Integer,
-      #   ?entry_states: Hash[String, Integer]?) -> void
-      def initialize: (grammar: Grammar, states: Array[AutomatonState], conflict_summary: conflict_summary, ?algorithm: String, ?grammar_digest: String?, ?schema_version: Integer, ?entry_states: Hash[String, Integer]?) -> void
+      #   algorithm: String, grammar_digest: String?, entry_states: Hash[String, Integer]?,
+      #   entry_construction: String) -> void
+      def initialize_current: (grammar: Grammar, states: Array[AutomatonState], conflict_summary: conflict_summary, algorithm: String, grammar_digest: String?, entry_states: Hash[String, Integer]?, entry_construction: String) -> void
 
-      # @rbs () -> Hash[Symbol, untyped]
-      def to_h: () -> Hash[Symbol, untyped]
+      # @rbs () -> Hash[Symbol, Object?]
+      def to_h: () -> Hash[Symbol, Object?]
 
       private
 
@@ -78,6 +85,18 @@ module Ibex
 
       # @rbs (Grammar grammar) -> String
       def digest_for: (Grammar grammar) -> String
+
+      # @rbs (String value) -> String
+      def validate_entry_construction: (String value) -> String
+
+      # @rbs () -> void
+      def validate_parser_contract: () -> void
+
+      # @rbs (ParserContract contract) -> void
+      def validate_parser_algorithm: (ParserContract contract) -> void
+
+      # @rbs (ParserContract contract) -> void
+      def validate_parser_entries: (ParserContract contract) -> void
     end
   end
 end