ibex 0.1.0 → 0.3.0

data/sig/ibex/lalr/ielr/annotator.rbs

@@ -0,0 +1,67 @@
+# Generated from lib/ibex/lalr/ielr/annotator.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    module IELR
+      # Finds grammar-relative inadequacies and traces their possible
+      # manifestations through predecessor states.
+      class Annotator
+        attr_reader annotation_lists: Array[Array[Annotation]]
+
+        attr_reader inadequacies: Array[Array[Inadequacy]]
+
+        attr_reader item_lookaheads: ItemLookaheads
+
+        attr_reader split_stable_discarded: Integer
+
+        # @rbs (IR::Grammar grammar, Array[core_set] states, transitions transitions,
+        #   Array[packed_items] items, GotoFollows goto_follows, ?resolver: ConflictResolver?) -> void
+        def initialize: (IR::Grammar grammar, Array[core_set] states, transitions transitions, Array[packed_items] items, GotoFollows goto_follows, ?resolver: ConflictResolver?) -> void
+
+        # @rbs () -> Array[Array[Annotation]]
+        def build: () -> Array[Array[Annotation]]
+
+        private
+
+        # @rbs (Integer state_id) -> Array[Inadequacy]
+        def build_inadequacies: (Integer state_id) -> Array[Inadequacy]
+
+        # @rbs (Integer state_id, Integer token_id) -> Array[[Symbol, Integer?]]
+        def contributions_for: (Integer state_id, Integer token_id) -> Array[[ Symbol, Integer? ]]
+
+        # @rbs (Integer state_id, Inadequacy inadequacy) -> Annotation
+        def annotate_manifestation: (Integer state_id, Inadequacy inadequacy) -> Annotation
+
+        # @rbs (Integer state_id, Integer successor_id, Annotation annotation) -> Annotation
+        def annotate_predecessor: (Integer state_id, Integer successor_id, Annotation annotation) -> Annotation
+
+        # @rbs (Integer state_id, Array[item_core], Integer, Integer) -> bool
+        def always_via_lhs?: (Integer state_id, Array[item_core], Integer, Integer) -> bool
+
+        # @rbs (Integer state_id, Array[item_core], Integer, Integer) -> Integer
+        def project_row: (Integer state_id, Array[item_core], Integer, Integer) -> Integer
+
+        # @rbs (Integer state_id, Integer production_id, Integer length) -> Integer
+        def completed_kernel_mask: (Integer state_id, Integer production_id, Integer length) -> Integer
+
+        # @rbs (Integer state_id, Integer lhs_id, Integer token_id) -> Integer?
+        def compute_lhs_contributions: (Integer state_id, Integer lhs_id, Integer token_id) -> Integer?
+
+        # @rbs (Integer state_id, Annotation annotation) -> bool
+        def register?: (Integer state_id, Annotation annotation) -> bool
+
+        # @rbs (Integer state_id, Integer production_id) -> Integer
+        def lhs_for: (Integer state_id, Integer production_id) -> Integer
+
+        # @rbs (Integer production_id) -> Array[Integer]
+        def rhs_for: (Integer production_id) -> Array[Integer]
+
+        # @rbs (core_set items) -> Array[item_core]
+        def kernel_items: (core_set items) -> Array[item_core]
+
+        # @rbs (Integer state_id, Integer production_id, Integer dot) -> Integer?
+        def kernel_index_of: (Integer state_id, Integer production_id, Integer dot) -> Integer?
+      end
+    end
+  end
+end

data/sig/ibex/lalr/ielr/bits.rbs

@@ -0,0 +1,14 @@
+# Generated from lib/ibex/lalr/ielr/bits.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    module IELR
+      module Bits
+        # @rbs (Integer bits) { (Integer) -> void } -> void
+        # @rbs (Integer bits) -> Enumerator[Integer, void]
+        def self?.each_set_bit: (Integer bits) { (Integer) -> void } -> void
+                              | (Integer bits) -> Enumerator[Integer, void]
+      end
+    end
+  end
+end

data/sig/ibex/lalr/ielr/inadequacy.rbs

@@ -0,0 +1,24 @@
+# Generated from lib/ibex/lalr/ielr/inadequacy.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    module IELR
+      type contribution = [ Symbol, Integer? ]
+
+      class Inadequacy < Struct[Integer | Array[contribution]]
+        attr_accessor state: Integer
+        attr_accessor token: Integer
+        attr_accessor contributions: Array[contribution]
+        attr_accessor id: Integer
+        def self.new: (state: Integer, token: Integer, contributions: Array[contribution], id: Integer) -> instance
+      end
+
+      class Annotation < Struct[Inadequacy | Array[Integer?]]
+        attr_accessor inadequacy: Inadequacy
+        attr_accessor matrix: Array[Integer?]
+        def self.new: (inadequacy: Inadequacy, matrix: Array[Integer?]) -> instance
+        def key: () -> [ Integer, Array[Integer?] ]
+      end
+    end
+  end
+end

data/sig/ibex/lalr/ielr/item_lookaheads.rbs

@@ -0,0 +1,35 @@
+# Generated from lib/ibex/lalr/ielr/item_lookaheads.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    module IELR
+      # Lazily derives the lookahead of a kernel item from predecessor states
+      # and goto-follow sets.  Memoisation is important: predecessor paths can
+      # share exponentially many suffixes in a real grammar.
+      class ItemLookaheads
+        @memo: Hash[Integer, Integer]
+
+        # @rbs (IR::Grammar grammar, GotoFollows goto_follows, Array[Array[item_core]] kernel_cores,
+        #   Array[Array[Integer]] predecessors, ?start_states: Array[Integer]?) -> void
+        def initialize: (IR::Grammar grammar, GotoFollows goto_follows, Array[Array[item_core]] kernel_cores, Array[Array[Integer]] predecessors, ?start_states: Array[Integer]?) -> void
+
+        # @rbs (Integer state_id, Integer kernel_index) -> Integer
+        def fetch: (Integer state_id, Integer kernel_index) -> Integer
+
+        # @rbs () -> Integer
+        def size: () -> Integer
+
+        private
+
+        # @rbs (Integer state_id, Integer kernel_index) -> Integer
+        def compute: (Integer state_id, Integer kernel_index) -> Integer
+
+        # @rbs (Integer state_id, Integer production_id) -> Integer
+        def goto_follows_for: (Integer state_id, Integer production_id) -> Integer
+
+        # @rbs (Integer production_id) -> Integer
+        def start_seed: (Integer production_id) -> Integer
+      end
+    end
+  end
+end

data/sig/ibex/lalr/ielr/pipeline.rbs

@@ -0,0 +1,17 @@
+# Generated from lib/ibex/lalr/ielr/pipeline.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    module IELR
+      # Coordinates the canonical-free direct IELR phases.  The returned
+      # profile deliberately reports canonical metrics as unavailable.
+      class Pipeline
+        # @rbs (IR::Grammar grammar, Analysis::Sets sets, ?starts: Array[String]?, ?profile: bool) -> void
+        def initialize: (IR::Grammar grammar, Analysis::Sets sets, ?starts: Array[String]?, ?profile: bool) -> void
+
+        # @rbs () -> [Array[packed_items], transitions, LALR::build_collection]
+        def build: () -> [ Array[packed_items], transitions, LALR::build_collection ]
+      end
+    end
+  end
+end

data/sig/ibex/lalr/ielr/split_stability.rbs

@@ -0,0 +1,27 @@
+# Generated from lib/ibex/lalr/ielr/split_stability.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    module IELR
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      module SplitStability
+        MAX_ENUMERATED_POTENTIALS: ::Integer
+
+        # @rbs (Annotation) -> bool
+        def self?.simple?: (Annotation) -> bool
+
+        # @rbs (Annotation, ConflictResolver) -> bool
+        def self?.split_stable?: (Annotation, ConflictResolver) -> bool
+
+        # @rbs (ConflictResolver, Integer, Array[Object]) -> Object?
+        def self?.resolve: (ConflictResolver, Integer, Array[Object]) -> Object?
+
+        # @rbs (Object?) -> Object?
+        def self?.normalize: (Object?) -> Object?
+
+        # @rbs (Array[Integer]) -> Array[Array[Integer]]
+        def self?.subsets: (Array[Integer]) -> Array[Array[Integer]]
+      end
+    end
+  end
+end

data/sig/ibex/lalr/ielr/split_state.rbs

@@ -0,0 +1,14 @@
+# Generated from lib/ibex/lalr/ielr/split_state.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    module IELR
+      class SplitState < Struct[Array[item_core] | Array[[ Integer, Integer ]] | Integer]
+        attr_accessor core: Array[item_core]
+        attr_accessor transitions: Array[[ Integer, Integer ]]
+        attr_accessor lalr_isocore: Integer
+        def self.new: (core: Array[item_core], transitions: Array[[ Integer, Integer ]], lalr_isocore: Integer) -> instance
+      end
+    end
+  end
+end

data/sig/ibex/lalr/ielr/state_splitter.rbs

@@ -0,0 +1,76 @@
+# Generated from lib/ibex/lalr/ielr/state_splitter.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    module IELR
+      # Splits LR(0) isocores only where an inadequacy would change the
+      # resolved action.  New states copy their transition arrays; no mutable
+      # transition table is shared between isocores.
+      class StateSplitter
+        attr_reader annotations: Array[Array[Annotation]]
+
+        attr_reader states: Array[SplitState]
+
+        attr_reader lalr_isocores: Array[Integer]
+
+        attr_reader split_states: Integer
+
+        attr_reader inadequacies: Array[Array[Inadequacy]]
+
+        attr_reader split_stable_discarded: Integer
+
+        # @rbs (IR::Grammar grammar, Array[core_set] states, transitions transitions,
+        #   Array[packed_items] items, GotoFollows goto_follows, ?resolver: ConflictResolver?) -> void
+        # rubocop:disable Metrics/AbcSize -- initialization wires the phase tables once.
+        def initialize: (IR::Grammar grammar, Array[core_set] states, transitions transitions, Array[packed_items] items, GotoFollows goto_follows, ?resolver: ConflictResolver?) -> void
+
+        # @rbs () -> [Array[packed_items], transitions]
+        def build: () -> [ Array[packed_items], transitions ]
+
+        private
+
+        # @rbs (Integer from_id, Integer to_id, Integer transition_index) -> void
+        def compute_state: (Integer from_id, Integer to_id, Integer transition_index) -> void
+
+        # @rbs (Integer from_id, Integer to_id) -> Array[Integer]
+        def propagate_lookaheads: (Integer from_id, Integer to_id) -> Array[Integer]
+
+        # @rbs (Integer state_id, Integer nonterminal_id) -> Integer
+        def compute_goto_follow_set: (Integer state_id, Integer nonterminal_id) -> Integer
+
+        # @rbs (Integer state_id) -> Array[Integer]
+        def lookahead_set_filters: (Integer state_id) -> Array[Integer]
+
+        # @rbs (Integer state_id, Array[Integer]) -> bool
+        def compatible?: (Integer state_id, Array[Integer]) -> bool
+
+        # @rbs (Annotation, Array[Integer]) -> Object?
+        def dominant_contribution: (Annotation, Array[Integer]) -> Object?
+
+        # @rbs (Integer after_id, Array[Integer]) -> Integer
+        def append_isocore: (Integer after_id, Array[Integer]) -> Integer
+
+        # @rbs (Integer state_id, Array[Integer]) -> void
+        def merge_lookaheads: (Integer state_id, Array[Integer]) -> void
+
+        # @rbs () -> Array[packed_items]
+        def pack_items: () -> Array[packed_items]
+
+        # @rbs () -> transitions
+        def packed_transitions: () -> transitions
+
+        # @rbs (core_set items) -> Array[item_core]
+        def kernel_items: (core_set items) -> Array[item_core]
+
+        # @rbs (Integer state_id, Integer production_id, Integer dot) -> Integer?
+        def kernel_index_of: (Integer state_id, Integer production_id, Integer dot) -> Integer?
+
+        # @rbs (Integer production_id) -> Integer
+        def lhs_for: (Integer production_id) -> Integer
+
+        # @rbs (Integer production_id) -> Array[Integer]
+        def rhs_for: (Integer production_id) -> Array[Integer]
+      end
+    end
+  end
+end

data/sig/ibex/lalr/ielr_partition.rbs

@@ -0,0 +1,71 @@
+# Generated from lib/ibex/lalr/ielr_partition.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    # Deterministically merges compatible canonical LR(1) states and splits
+    # partitions until their outgoing transitions are congruent.
+    class IELRPartition
+      type contribution_action = [ :shift ] | [ :reduce, Integer ] | [ :accept ]
+
+      AUGMENTED_PRODUCTION: Integer
+
+      @profile: bool
+
+      @final_partition_count: Integer?
+
+      @initial_partition_count: Integer?
+
+      @contributions: Array[Hash[Integer, Set[contribution_action]]]
+
+      @transitions: transitions
+
+      @states: Array[item_set]
+
+      @grammar: IR::Grammar
+
+      attr_reader initial_partition_count: Integer?
+
+      attr_reader final_partition_count: Integer?
+
+      # @rbs (IR::Grammar grammar, Array[item_set] states, transitions transitions, ?profile: bool) -> void
+      def initialize: (IR::Grammar grammar, Array[item_set] states, transitions transitions, ?profile: bool) -> void
+
+      # @rbs () -> [Array[packed_items], transitions]
+      def build: () -> [ Array[packed_items], transitions ]
+
+      private
+
+      # @rbs () -> Array[state_partition]
+      def initial_partitions: () -> Array[state_partition]
+
+      # @rbs (Array[Integer] members) -> Array[state_partition]
+      def compatible_partitions: (Array[Integer] members) -> Array[state_partition]
+
+      # A canonical member may gain an action only where it previously had no
+      # action. Every nonempty member cell must equal the merged cell.
+      # @rbs (state_partition members) -> bool
+      def compatible?: (state_partition members) -> bool
+
+      # @rbs (Array[state_partition] partitions) -> Array[state_partition]
+      def refine_transitions: (Array[state_partition] partitions) -> Array[state_partition]
+
+      # @rbs (Integer state_id, Hash[Integer, Integer] indexes) -> Array[[Integer, Integer]]
+      def transition_signature: (Integer state_id, Hash[Integer, Integer] indexes) -> Array[[ Integer, Integer ]]
+
+      # @rbs (Array[state_partition] partitions) -> Hash[Integer, Integer]
+      def partition_indexes: (Array[state_partition] partitions) -> Hash[Integer, Integer]
+
+      # @rbs (state_partition members) -> packed_items
+      def merge_items: (state_partition members) -> packed_items
+
+      # @rbs (Integer state_id) -> Hash[Integer, Set[contribution_action]]
+      def action_contributions: (Integer state_id) -> Hash[Integer, Set[contribution_action]]
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def rhs_for: (Integer production_id) -> Array[Integer]
+
+      # @rbs (item_set items) -> Array[item_core]
+      def core_key: (item_set items) -> Array[item_core]
+    end
+  end
+end

data/sig/ibex/lalr/inadequacy_report.rbs

@@ -0,0 +1,21 @@
+# Generated from lib/ibex/lalr/inadequacy_report.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    type report_value = String | Symbol | Integer | bool | nil | IR::parser_action | Array[report_value] | Hash[Symbol, report_value]
+
+    # Diagnostic-only report for canonical-vs-LALR action differences.  It is
+    # intentionally separate from normal construction because it enumerates a
+    # canonical LR(1) reference.
+    class InadequacyReport
+      # @rbs (IR::Automaton canonical, IR::Automaton target, ?max_pairs: Integer) -> void
+      def initialize: (IR::Automaton canonical, IR::Automaton target, ?max_pairs: Integer) -> void
+
+      # @rbs () -> Hash[Symbol, report_value]
+      def to_h: () -> Hash[Symbol, report_value]
+
+      # @rbs () -> String
+      def to_json: () -> String
+    end
+  end
+end

data/sig/ibex/lalr/lookahead_propagation.rbs

@@ -0,0 +1,38 @@
+# Generated from lib/ibex/lalr/lookahead_propagation.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    # Recomputes item lookaheads on an already-built LR(0) automaton.  This is
+    # Phase 4 of direct IELR and is also useful as an independent cross-check
+    # for DirectLookaheads.
+    class LookaheadPropagation
+      EMPTY: Array[Integer]
+
+      attr_reader propagation_edge_count: Integer
+
+      # @rbs (IR::Grammar grammar, Analysis::Sets sets, Array[core_set] states, transitions transitions,
+      #   seeds: Array[[Integer, item_core, Integer]]) -> Array[packed_items]
+      def initialize: (IR::Grammar grammar, Analysis::Sets sets, Array[core_set] states, transitions transitions, seeds: Array[[ Integer, item_core, Integer ]]) -> Array[packed_items]
+
+      # @rbs () -> Array[packed_items]
+      def build: () -> Array[packed_items]
+
+      private
+
+      # @rbs (Hash[Object, Array[Object]], Integer, Integer, Integer) -> void
+      def add_transition: (Hash[Object, Array[Object]], Integer, Integer, Integer) -> void
+
+      # @rbs (Hash[Object, Array[Object]], Array[packed_items], Integer, Integer, Integer) -> void
+      def add_closure: (Hash[Object, Array[Object]], Array[packed_items], Integer, Integer, Integer) -> void
+
+      # @rbs (Array[packed_items], Hash[Object, Array[Object]]) -> void
+      def propagate: (Array[packed_items], Hash[Object, Array[Object]]) -> void
+
+      # @rbs (Integer bits) -> Array[Integer]
+      def terminal_ids: (Integer bits) -> Array[Integer]
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def rhs_for: (Integer production_id) -> Array[Integer]
+    end
+  end
+end

data/sig/ibex/lalr/lr0_collection.rbs

@@ -0,0 +1,50 @@
+# Generated from lib/ibex/lalr/lr0_collection.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    # Constructs only the LR(0) core collection.  Keeping this separate from
+    # lookahead propagation makes the direct IELR phases reusable and gives
+    # them a stable, canonical-free input representation.
+    class LR0Collection
+      AUGMENTED_PRODUCTION: Integer
+
+      @grammar: IR::Grammar
+
+      @productions_by_lhs: Hash[Integer, Array[IR::Production]]
+
+      @starts: Array[String]
+
+      @augmented_rhs: Hash[Integer, Array[Integer]]
+
+      @production_rhs: Array[Array[Integer]]
+
+      @item_key_stride: Integer
+
+      # @rbs (IR::Grammar grammar, ?starts: Array[String]?) -> void
+      def initialize: (IR::Grammar grammar, ?starts: Array[String]?) -> void
+
+      # @rbs () -> [Array[core_set], transitions]
+      def build: () -> [ Array[core_set], transitions ]
+
+      # @rbs (Integer index) -> Integer
+      def augmented_production: (Integer index) -> Integer
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def rhs_for: (Integer production_id) -> Array[Integer]
+
+      # @rbs (Integer production_id) -> Integer
+      def lhs_for: (Integer production_id) -> Integer
+
+      # @rbs (core_set items) -> Hash[Integer, core_set]
+      def shifted_kernels: (core_set items) -> Hash[Integer, core_set]
+
+      private
+
+      # @rbs (core_set seed) -> core_set
+      def closure: (core_set seed) -> core_set
+
+      # @rbs (core_set items) -> Array[Integer]
+      def item_key: (core_set items) -> Array[Integer]
+    end
+  end
+end

data/sig/ibex/lalr/on_error_reductions.rbs

@@ -0,0 +1,22 @@
+# Generated from lib/ibex/lalr/on_error_reductions.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    # Delays syntax-error detection by filling only otherwise erroneous table
+    # cells with one uniquely highest-priority declared reduction.
+    module OnErrorReductions
+      # @rbs (IR::Grammar grammar, Array[IR::AutomatonState] states) -> Array[IR::AutomatonState]
+      def self?.apply: (IR::Grammar grammar, Array[IR::AutomatonState] states) -> Array[IR::AutomatonState]
+
+      # @rbs (IR::Grammar grammar) -> Hash[Integer, Integer]
+      def self?.reduction_priorities: (IR::Grammar grammar) -> Hash[Integer, Integer]
+
+      # @rbs (IR::Grammar grammar, IR::AutomatonState state, Hash[Integer, Integer] priorities,
+      #   Array[Integer] terminal_ids) -> IR::AutomatonState
+      def apply_state: (IR::Grammar grammar, IR::AutomatonState state, Hash[Integer, Integer] priorities, Array[Integer] terminal_ids) -> IR::AutomatonState
+
+      # @rbs (IR::Grammar grammar, IR::AutomatonState state, Hash[Integer, Integer] priorities) -> Integer?
+      def selected_production: (IR::Grammar grammar, IR::AutomatonState state, Hash[Integer, Integer] priorities) -> Integer?
+    end
+  end
+end

data/sig/ibex/lalr/unreachable_states.rbs

@@ -0,0 +1,25 @@
+# Generated from lib/ibex/lalr/unreachable_states.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    # Optional post-resolution compaction.  It is intentionally off by
+    # default because state numbers are part of diagnostics and golden output.
+    module UnreachableStates
+      # @rbs (Array[IR::AutomatonState] states, Array[Integer] start_states) ->
+      #   [Array[IR::AutomatonState], Hash[Integer, Integer]]
+      def self?.remove: (Array[IR::AutomatonState] states, Array[Integer] start_states) -> [ Array[IR::AutomatonState], Hash[Integer, Integer] ]
+
+      # @rbs (Array[IR::AutomatonState], Array[Integer]) -> Array[Integer]
+      def self?.reachable_states: (Array[IR::AutomatonState], Array[Integer]) -> Array[Integer]
+
+      # @rbs (Hash[Integer, Integer], Hash[Integer, Integer]) -> Hash[Integer, Integer]
+      def self?.remap_edges: (Hash[Integer, Integer], Hash[Integer, Integer]) -> Hash[Integer, Integer]
+
+      # @rbs (IR::parser_action?, Hash[Integer, Integer]) -> IR::parser_action?
+      def self?.remap_action: (IR::parser_action?, Hash[Integer, Integer]) -> IR::parser_action?
+
+      # @rbs (IR::conflict, Hash[Integer, Integer]) -> IR::conflict
+      def self?.remap_conflict: (IR::conflict, Hash[Integer, Integer]) -> IR::conflict
+    end
+  end
+end

data/sig/ibex/lalr.rbs

@@ -6,18 +6,34 @@ module Ibex
 
     type item_core = [ Integer, Integer ]
 
+    type core_set = Set[item_core]
+
     type item_set = Set[lr_item]
 
     type packed_items = Hash[item_core, Set[Integer]]
 
     type transitions = Array[Hash[Integer, Integer]]
 
-    type derivation_node = Hash[Symbol, untyped]
+    type build_collection = { construction_states: Integer, canonical_states: Integer?, strategy: Symbol, lr0_states: Integer?, lr0_items: Integer?, canonical_items: Integer?, propagation_edges: Integer?, ielr_initial_partitions: Integer?, ielr_final_partitions: Integer?, ielr_annotations: Integer?, ielr_annotated_states: Integer?, ielr_inadequacies: Integer?, ielr_split_stable_discarded: Integer?, ielr_lalr_states: Integer?, ielr_split_states: Integer?, ielr_unreachable_removed: Integer?, ielr_remergeable_candidates: Integer? }
+
+    type conflict_fingerprint = [ Symbol, String, Array[Integer] ]
+
+    type lookahead_node = [ Integer, Integer, Integer ]
+
+    type state_partition = Array[Integer]
+
+    type derivation_node = Hash[Symbol, Object?]
 
     type search_status = :conflict | :shifted | :accepted
 
     type search_entry = [ search_status, ConflictSearch::Configuration ]
 
     type search_result = { sentence_ids: Array[Integer], lookahead_index: Integer, interpretations: Array[IR::interpretation] }
+
+    type search_bounds = { max_tokens: Integer, max_configurations: Integer }
+
+    type search_outcome = { status: :found | :not_found | :exhausted, result: search_result?, explored: Integer, exhausted: bool, bounds: search_bounds }
+
+    type search_counterexample = { state: Integer, type: Symbol, symbol_path: Array[String], sentence: Array[String], lookahead_index: Integer, unifying: bool, inconclusive: bool, search: search_outcome, interpretations: Array[IR::interpretation] }
   end
 end

data/sig/ibex/location.rbs

@@ -0,0 +1,67 @@
+# Generated from lib/ibex/location.rb with RBS::Inline
+
+module Ibex
+  # Immutable source range suitable for lexer tokens and parser diagnostics.
+  #
+  # Coordinates are one-based. Byte offsets are optional, zero-based, and
+  # half-open. Keeping both forms lets Unicode-aware lexers report human
+  # columns without losing an exact source slice.
+  class Location
+    attr_reader file: String?
+
+    attr_reader line: Integer
+
+    attr_reader column: Integer
+
+    attr_reader end_line: Integer
+
+    attr_reader end_column: Integer
+
+    attr_reader start_byte: Integer?
+
+    attr_reader end_byte: Integer?
+
+    attr_reader source_line: String?
+
+    # @rbs (?file: String?, line: Integer, column: Integer, ?end_line: Integer?,
+    #   ?end_column: Integer?, ?start_byte: Integer?, ?end_byte: Integer?, ?source_line: String?) -> void
+    def initialize: (line: Integer, column: Integer, ?file: String?, ?end_line: Integer?, ?end_column: Integer?, ?start_byte: Integer?, ?end_byte: Integer?, ?source_line: String?) -> void
+
+    # Return the smallest range covering both locations.
+    # @rbs (Location other) -> Location
+    def join: (Location other) -> Location
+
+    # Fold a nonempty collection into one covering range.
+    # @rbs (Enumerable[Location] locations) -> Location
+    def self.join: (Enumerable[Location] locations) -> Location
+
+    # @rbs () -> bool
+    def empty?: () -> bool
+
+    # @rbs () -> Hash[Symbol, String | Integer]
+    def to_h: () -> Hash[Symbol, String | Integer]
+
+    private
+
+    # @rbs (Symbol name, Object? value) -> Integer
+    def positive_coordinate: (Symbol name, Object? value) -> Integer
+
+    # @rbs (Symbol name, Object? value) -> Integer?
+    def optional_offset: (Symbol name, Object? value) -> Integer?
+
+    # @rbs () -> void
+    def validate_order!: () -> void
+
+    # @rbs (Location left, Location right) -> bool
+    def before_or_equal?: (Location left, Location right) -> bool
+
+    # @rbs (Location left, Location right) -> bool
+    def before_or_equal_end?: (Location left, Location right) -> bool
+
+    # @rbs (Location other) -> Integer?
+    def joined_start_byte: (Location other) -> Integer?
+
+    # @rbs (Location other) -> Integer?
+    def joined_end_byte: (Location other) -> Integer?
+  end
+end

data/sig/ibex/lsp/document_handlers.rbs

@@ -0,0 +1,24 @@
+# Generated from lib/ibex/lsp/document_handlers.rb with RBS::Inline
+
+module Ibex
+  module LSP
+    # Applies full-text LSP document notifications to the overlay-backed store.
+    module DocumentHandlers
+      include RequestSupport
+
+      private
+
+      # @rbs (lsp_value? raw_params) -> nil
+      def did_open: (lsp_value? raw_params) -> nil
+
+      # @rbs (lsp_value? raw_params) -> nil
+      def did_change: (lsp_value? raw_params) -> nil
+
+      # @rbs (lsp_value? raw_params) -> nil
+      def did_save: (lsp_value? raw_params) -> nil
+
+      # @rbs (lsp_value? raw_params) -> nil
+      def did_close: (lsp_value? raw_params) -> nil
+    end
+  end
+end