ibex 0.2.0 → 0.4.0

data/sig/ibex/normalize/expression.rbs

@@ -3,19 +3,21 @@
 module Ibex
   # Deterministically renders frontend EBNF items for production origin metadata.
   module NormalizeExpression
+    type pending_item = String | Frontend::AST::item
+
     # @rbs (Frontend::AST::item item) -> String
     def self.render: (Frontend::AST::item item) -> String
 
-    # @rbs (Array[untyped] pending, Frontend::AST::item item) -> void
-    private def self.push_render_item: (Array[untyped] pending, Frontend::AST::item item) -> void
+    # @rbs (Array[pending_item] pending, Frontend::AST::item item) -> void
+    private def self.push_render_item: (Array[pending_item] pending, Frontend::AST::item item) -> void
 
-    # @rbs (Array[untyped] pending, Frontend::AST::ParameterizedReference item) -> void
-    private def self.push_render_parameterized_reference: (Array[untyped] pending, Frontend::AST::ParameterizedReference item) -> void
+    # @rbs (Array[pending_item] pending, Frontend::AST::ParameterizedReference item) -> void
+    private def self.push_render_parameterized_reference: (Array[pending_item] pending, Frontend::AST::ParameterizedReference item) -> void
 
-    # @rbs (Array[untyped] pending, Frontend::AST::Group item) -> void
-    private def self.push_render_group: (Array[untyped] pending, Frontend::AST::Group item) -> void
+    # @rbs (Array[pending_item] pending, Frontend::AST::Group item) -> void
+    private def self.push_render_group: (Array[pending_item] pending, Frontend::AST::Group item) -> void
 
-    # @rbs (Array[untyped] pending, Array[Frontend::AST::item] items, String separator) -> void
-    private def self.push_render_items: (Array[untyped] pending, Array[Frontend::AST::item] items, String separator) -> void
+    # @rbs (Array[pending_item] pending, Array[Frontend::AST::item] items, String separator) -> void
+    private def self.push_render_items: (Array[pending_item] pending, Array[Frontend::AST::item] items, String separator) -> void
   end
 end

data/sig/ibex/normalize/grammar_builder.rbs

@@ -0,0 +1,11 @@
+# Generated from lib/ibex/normalize/grammar_builder.rb with RBS::Inline
+
+module Ibex
+  # Builds the single current Grammar IR format for every normalized source.
+  module NormalizeGrammarBuilder
+    private
+
+    # @rbs (IR::ParserContract? parser_contract) -> IR::Grammar
+    def build_grammar: (IR::ParserContract? parser_contract) -> IR::Grammar
+  end
+end

data/sig/ibex/normalize/inline_expansion.rbs

@@ -4,6 +4,14 @@ module Ibex
   # Deterministically substitutes inline-rule productions before LR construction.
   # rubocop:disable Metrics/ModuleLength -- expansion, action plans, and id remapping share one invariant.
   module NormalizeInlineExpansion
+    type inline_reference = [ :physical | :step, Integer ]
+
+    type inline_step = { kind: :inline | :rule, rule: String?, code: String?, loc: IR::location, named_refs: Array[IR::named_ref], context_length: Integer, inputs: Array[inline_reference], stack_inputs: Array[inline_reference], lookahead: Integer, result_var: bool, result_type: String? }
+
+    type inline_variant = { rhs: Array[Integer], steps: Array[inline_step], logical_refs: Array[inline_reference], output_ref: inline_reference?, inline_used: bool, inline_rule: String?, precedence_override: Integer?, precedence_contributes: bool, parameter: IR::parameter_expansion? }
+
+    type inline_frame = { production: IR::Production, symbol_id: Integer?, index: Integer, variant: inline_variant }
+
     private
 
     # @rbs () -> void
@@ -13,79 +21,80 @@ module Ibex
     # The single-definition path reuses its accumulated arrays, so a long
     # acyclic chain remains linear in the size of its final action plan.
     # @rbs (IR::Production production, Hash[Integer, Array[IR::Production]] definitions) ->
-    #   Array[Hash[Symbol, untyped]]
-    def expand_inline_production: (IR::Production production, Hash[Integer, Array[IR::Production]] definitions) -> Array[Hash[Symbol, untyped]]
+    #   Array[inline_variant]
+    def expand_inline_production: (IR::Production production, Hash[Integer, Array[IR::Production]] definitions) -> Array[inline_variant]
 
-    # @rbs (Array[Hash[Symbol, untyped]] frames, Hash[Integer, Array[IR::Production]] definitions,
-    #   Array[Array[Hash[Symbol, untyped]]] worklist, Array[Hash[Symbol, untyped]] variants,
+    # @rbs (Array[inline_frame] frames, Hash[Integer, Array[IR::Production]] definitions,
+    #   Array[Array[inline_frame]] worklist, Array[inline_variant] variants,
     #   IR::location? location) -> void
-    def drain_inline_expansion_frames: (Array[Hash[Symbol, untyped]] frames, Hash[Integer, Array[IR::Production]] definitions, Array[Array[Hash[Symbol, untyped]]] worklist, Array[Hash[Symbol, untyped]] variants, IR::location? location) -> void
+    def drain_inline_expansion_frames: (Array[inline_frame] frames, Hash[Integer, Array[IR::Production]] definitions, Array[Array[inline_frame]] worklist, Array[inline_variant] variants, IR::location? location) -> void
 
-    # @rbs (Array[Hash[Symbol, untyped]] frames, Hash[Integer, Array[IR::Production]] definitions,
-    #   Array[Array[Hash[Symbol, untyped]]] worklist, Array[Hash[Symbol, untyped]] variants,
+    # @rbs (Array[inline_frame] frames, Hash[Integer, Array[IR::Production]] definitions,
+    #   Array[Array[inline_frame]] worklist, Array[inline_variant] variants,
     #   IR::location? location) -> bool
-    def advance_inline_expansion_frame?: (Array[Hash[Symbol, untyped]] frames, Hash[Integer, Array[IR::Production]] definitions, Array[Array[Hash[Symbol, untyped]]] worklist, Array[Hash[Symbol, untyped]] variants, IR::location? location) -> bool
+    def advance_inline_expansion_frame?: (Array[inline_frame] frames, Hash[Integer, Array[IR::Production]] definitions, Array[Array[inline_frame]] worklist, Array[inline_variant] variants, IR::location? location) -> bool
 
-    # @rbs (Array[Hash[Symbol, untyped]] frames, Array[IR::Production] choices, Integer symbol_id,
-    #   Array[Array[Hash[Symbol, untyped]]] worklist) -> void
-    def schedule_inline_choice_branches: (Array[Hash[Symbol, untyped]] frames, Array[IR::Production] choices, Integer symbol_id, Array[Array[Hash[Symbol, untyped]]] worklist) -> void
+    # @rbs (Array[inline_frame] frames, Array[IR::Production] choices, Integer symbol_id,
+    #   Array[Array[inline_frame]] worklist) -> void
+    def schedule_inline_choice_branches: (Array[inline_frame] frames, Array[IR::Production] choices, Integer symbol_id, Array[Array[inline_frame]] worklist) -> void
 
-    # @rbs (Array[Hash[Symbol, untyped]] frames, Array[Hash[Symbol, untyped]] variants,
-    #   Array[Array[Hash[Symbol, untyped]]] worklist, IR::location? location) -> bool
-    def complete_inline_expansion_frame?: (Array[Hash[Symbol, untyped]] frames, Array[Hash[Symbol, untyped]] variants, Array[Array[Hash[Symbol, untyped]]] worklist, IR::location? location) -> bool
+    # @rbs (Array[inline_frame] frames, Array[inline_variant] variants,
+    #   Array[Array[inline_frame]] worklist, IR::location? location) -> bool
+    def complete_inline_expansion_frame?: (Array[inline_frame] frames, Array[inline_variant] variants, Array[Array[inline_frame]] worklist, IR::location? location) -> bool
 
-    # @rbs (IR::Production production, Integer? symbol_id) -> Hash[Symbol, untyped]
-    def inline_expansion_frame: (IR::Production production, Integer? symbol_id) -> Hash[Symbol, untyped]
+    # @rbs (IR::Production production, Integer? symbol_id) -> inline_frame
+    def inline_expansion_frame: (IR::Production production, Integer? symbol_id) -> inline_frame
 
-    # @rbs (Array[Hash[Symbol, untyped]] frames) -> Array[Hash[Symbol, untyped]]
-    def clone_inline_expansion_frames: (Array[Hash[Symbol, untyped]] frames) -> Array[Hash[Symbol, untyped]]
+    # @rbs (Array[inline_frame] frames) -> Array[inline_frame]
+    def clone_inline_expansion_frames: (Array[inline_frame] frames) -> Array[inline_frame]
 
-    # @rbs (IR::Production production) -> Hash[Symbol, untyped]
-    def empty_inline_variant: (IR::Production production) -> Hash[Symbol, untyped]
+    # @rbs (IR::Production production) -> inline_variant
+    def empty_inline_variant: (IR::Production production) -> inline_variant
 
-    # @rbs (Hash[Symbol, untyped] variant, Integer symbol_id) -> Hash[Symbol, untyped]
-    def append_inline_symbol: (Hash[Symbol, untyped] variant, Integer symbol_id) -> Hash[Symbol, untyped]
+    # @rbs (inline_variant variant, Integer symbol_id) -> inline_variant
+    def append_inline_symbol: (inline_variant variant, Integer symbol_id) -> inline_variant
 
-    # @rbs (Hash[Symbol, untyped] parent, Hash[Symbol, untyped] child) -> Hash[Symbol, untyped]
-    def combine_inline_variant: (Hash[Symbol, untyped] parent, Hash[Symbol, untyped] child) -> Hash[Symbol, untyped]
+    # @rbs (inline_variant parent, inline_variant child) -> inline_variant
+    def combine_inline_variant: (inline_variant parent, inline_variant child) -> inline_variant
 
-    # @rbs (Hash[Symbol, untyped] parent, Hash[Symbol, untyped] child,
-    #   Integer physical_offset, Integer step_offset) -> Array[Hash[Symbol, untyped]]
-    def combined_inline_steps: (Hash[Symbol, untyped] parent, Hash[Symbol, untyped] child, Integer physical_offset, Integer step_offset) -> Array[Hash[Symbol, untyped]]
+    # @rbs (inline_variant parent, inline_variant child,
+    #   Integer physical_offset, Integer step_offset) -> Array[inline_step]
+    def combined_inline_steps: (inline_variant parent, inline_variant child, Integer physical_offset, Integer step_offset) -> Array[inline_step]
 
-    # @rbs (Array[untyped] left, Array[untyped] right) -> Array[untyped]
-    def append_inline_array: (Array[untyped] left, Array[untyped] right) -> Array[untyped]
+    # The helper is shared by homogeneous integer and step arrays; callers
+    # assert the concrete element type at each use site.
+    # @rbs (Array[Object?] left, Array[Object?] right) -> Array[Object?]
+    def append_inline_array: (Array[Object?] left, Array[Object?] right) -> Array[Object?]
 
-    # @rbs (Hash[Symbol, untyped] parent, Hash[Symbol, untyped] child) -> Integer?
-    def combined_inline_precedence: (Hash[Symbol, untyped] parent, Hash[Symbol, untyped] child) -> Integer?
+    # @rbs (inline_variant parent, inline_variant child) -> Integer?
+    def combined_inline_precedence: (inline_variant parent, inline_variant child) -> Integer?
 
-    # @rbs (Hash[Symbol, untyped] parent, Hash[Symbol, untyped] child,
-    #   Integer physical_offset, Integer step_offset) -> Array[Hash[Symbol, untyped]]
-    def remap_inline_steps: (Hash[Symbol, untyped] parent, Hash[Symbol, untyped] child, Integer physical_offset, Integer step_offset) -> Array[Hash[Symbol, untyped]]
+    # @rbs (inline_variant parent, inline_variant child,
+    #   Integer physical_offset, Integer step_offset) -> Array[inline_step]
+    def remap_inline_steps: (inline_variant parent, inline_variant child, Integer physical_offset, Integer step_offset) -> Array[inline_step]
 
     # @rbs (Array[Symbol | Integer] reference, Integer physical_offset, Integer step_offset) ->
     #   Array[Symbol | Integer]
     def remap_inline_reference: (Array[Symbol | Integer] reference, Integer physical_offset, Integer step_offset) -> Array[Symbol | Integer]
 
-    # @rbs (Hash[Symbol, untyped] variant, IR::Production production) -> Hash[Symbol, untyped]
-    def finish_inline_precedence: (Hash[Symbol, untyped] variant, IR::Production production) -> Hash[Symbol, untyped]
+    # @rbs (inline_variant variant, IR::Production production) -> inline_variant
+    def finish_inline_precedence: (inline_variant variant, IR::Production production) -> inline_variant
 
-    # @rbs (Hash[Symbol, untyped] variant, IR::Production production, Integer symbol_id) ->
-    #   Hash[Symbol, untyped]
-    def finish_inline_choice: (Hash[Symbol, untyped] variant, IR::Production production, Integer symbol_id) -> Hash[Symbol, untyped]
+    # @rbs (inline_variant variant, IR::Production production, Integer symbol_id) -> inline_variant
+    def finish_inline_choice: (inline_variant variant, IR::Production production, Integer symbol_id) -> inline_variant
 
-    # @rbs (IR::Production production, Array[Array[Symbol | Integer]] inputs, Integer lookahead,
-    #   Symbol kind, String? rule) -> Hash[Symbol, untyped]
-    def inline_action_step: (IR::Production production, Array[Array[Symbol | Integer]] inputs, Integer lookahead, Symbol kind, String? rule) -> Hash[Symbol, untyped]
+    # @rbs (IR::Production production, Array[inline_reference] inputs, Integer lookahead,
+    #   :inline | :rule kind, String? rule) -> inline_step
+    def inline_action_step: (IR::Production production, Array[inline_reference] inputs, Integer lookahead, :inline | :rule kind, String? rule) -> inline_step
 
-    # @rbs (IR::Production production, Hash[Symbol, untyped] variant, Integer id) -> IR::Production
-    def composed_inline_production: (IR::Production production, Hash[Symbol, untyped] variant, Integer id) -> IR::Production
+    # @rbs (IR::Production production, inline_variant variant, Integer id) -> IR::Production
+    def composed_inline_production: (IR::Production production, inline_variant variant, Integer id) -> IR::Production
 
-    # @rbs (IR::Production production, Integer physical_length, Array[Hash[Symbol, untyped]]) -> IR::Action
-    def composed_inline_action: (IR::Production production, Integer physical_length, Array[Hash[Symbol, untyped]]) -> IR::Action
+    # @rbs (IR::Production production, Integer physical_length, Array[inline_step]) -> IR::Action
+    def composed_inline_action: (IR::Production production, Integer physical_length, Array[inline_step]) -> IR::Action
 
-    # @rbs (Hash[Symbol, untyped] step, Integer physical_length) -> Hash[Symbol, untyped]
-    def composition_plan_step: (Hash[Symbol, untyped] step, Integer physical_length) -> Hash[Symbol, untyped]
+    # @rbs (inline_step step, Integer physical_length) -> IR::action_composition_step
+    def composition_plan_step: (inline_step step, Integer physical_length) -> IR::action_composition_step
 
     # @rbs (Array[Symbol | Integer] reference, Integer physical_length) -> Integer
     def resolve_inline_reference: (Array[Symbol | Integer] reference, Integer physical_length) -> Integer
@@ -96,8 +105,8 @@ module Ibex
     # @rbs (IR::location location) -> IR::source_provenance
     def inline_source_provenance: (IR::location location) -> IR::source_provenance
 
-    # @rbs (IR::Production production, Hash[Symbol, untyped] variant) -> IR::production_expansion
-    def inline_production_expansion: (IR::Production production, Hash[Symbol, untyped] variant) -> IR::production_expansion
+    # @rbs (IR::Production production, inline_variant variant) -> IR::production_expansion
+    def inline_production_expansion: (IR::Production production, inline_variant variant) -> IR::production_expansion
 
     # @rbs (IR::Production production, Integer id) -> IR::Production
     def copy_inline_production: (IR::Production production, Integer id) -> IR::Production

data/sig/ibex/normalize/lexer.rbs

@@ -9,12 +9,12 @@ module Ibex
     def normalize_lexer: () -> IR::Lexer?
 
     # @rbs (Frontend::AST::LexerState definition, Array[String] states, Array[IR::LexerRule] rules,
-    #   Array[Hash[Symbol, untyped]] warnings) -> void
-    def normalize_lexer_state: (Frontend::AST::LexerState definition, Array[String] states, Array[IR::LexerRule] rules, Array[Hash[Symbol, untyped]] warnings) -> void
+    #   Array[IR::lexer_warning] warnings) -> void
+    def normalize_lexer_state: (Frontend::AST::LexerState definition, Array[String] states, Array[IR::LexerRule] rules, Array[IR::lexer_warning] warnings) -> void
 
     # @rbs (Frontend::AST::LexerRule definition, String state, Integer id,
-    #   Array[Hash[Symbol, untyped]] warnings) -> IR::LexerRule
-    def normalize_lexer_rule: (Frontend::AST::LexerRule definition, String state, Integer id, Array[Hash[Symbol, untyped]] warnings) -> IR::LexerRule
+    #   Array[IR::lexer_warning] warnings) -> IR::LexerRule
+    def normalize_lexer_rule: (Frontend::AST::LexerRule definition, String state, Integer id, Array[IR::lexer_warning] warnings) -> IR::LexerRule
 
     # @rbs (Frontend::AST::LexerRule definition) -> void
     def validate_lexer_token: (Frontend::AST::LexerRule definition) -> void

data/sig/ibex/normalize/parameter_ebnf_lowering.rbs

@@ -5,28 +5,29 @@ module Ibex
   module NormalizeParameterEbnfLowering
     private
 
-    # @rbs (Hash[Symbol, untyped] frame,
+    # @rbs (NormalizeParameters::parameter_frame frame,
     #   Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus item) -> void
-    def lower_parameter_suffix: (Hash[Symbol, untyped] frame, Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus item) -> void
+    def lower_parameter_suffix: (NormalizeParameters::parameter_frame frame, Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus item) -> void
 
-    # @rbs (Hash[Symbol, untyped] frame,
+    # @rbs (NormalizeParameters::parameter_frame frame,
     #   Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus item) -> void
-    def finish_parameter_suffix: (Hash[Symbol, untyped] frame, Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus item) -> void
+    def finish_parameter_suffix: (NormalizeParameters::parameter_frame frame, Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus item) -> void
 
-    # @rbs (Hash[Symbol, untyped] frame, Frontend::AST::SeparatedList item) -> void
-    def lower_parameter_separated_list: (Hash[Symbol, untyped] frame, Frontend::AST::SeparatedList item) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame, Frontend::AST::SeparatedList item) -> void
+    def lower_parameter_separated_list: (NormalizeParameters::parameter_frame frame, Frontend::AST::SeparatedList item) -> void
 
-    # @rbs (Hash[Symbol, untyped] frame, Frontend::AST::SeparatedList item) -> void
-    def finish_parameter_separated_list: (Hash[Symbol, untyped] frame, Frontend::AST::SeparatedList item) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame, Frontend::AST::SeparatedList item) -> void
+    def finish_parameter_separated_list: (NormalizeParameters::parameter_frame frame, Frontend::AST::SeparatedList item) -> void
 
-    # @rbs (Hash[Symbol, untyped] frame, Frontend::AST::Group item) -> void
-    def lower_parameter_group: (Hash[Symbol, untyped] frame, Frontend::AST::Group item) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame, Frontend::AST::Group item) -> void
+    def lower_parameter_group: (NormalizeParameters::parameter_frame frame, Frontend::AST::Group item) -> void
 
-    # @rbs (Hash[Symbol, untyped] frame, String helper, Frontend::AST::Group item,
+    # @rbs (NormalizeParameters::parameter_frame frame, String helper, Frontend::AST::Group item,
     #   Array[Frontend::AST::item] alternative) -> void
-    def start_parameter_group_alternative: (Hash[Symbol, untyped] frame, String helper, Frontend::AST::Group item, Array[Frontend::AST::item] alternative) -> void
+    def start_parameter_group_alternative: (NormalizeParameters::parameter_frame frame, String helper, Frontend::AST::Group item, Array[Frontend::AST::item] alternative) -> void
 
-    # @rbs (Hash[Symbol, untyped] frame, String helper, Frontend::AST::Group item, Integer length) -> void
-    def finish_parameter_group_alternative: (Hash[Symbol, untyped] frame, String helper, Frontend::AST::Group item, Integer length) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame, String helper,
+    #   Frontend::AST::Group item, Integer length) -> void
+    def finish_parameter_group_alternative: (NormalizeParameters::parameter_frame frame, String helper, Frontend::AST::Group item, Integer length) -> void
   end
 end

data/sig/ibex/normalize/parameter_lowering.rbs

@@ -5,31 +5,31 @@ module Ibex
   module NormalizeParameterLowering
     private
 
-    # @rbs (Hash[Symbol, untyped] frame) -> void
-    def advance_parameter_alternative: (Hash[Symbol, untyped] frame) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame) -> void
+    def advance_parameter_alternative: (NormalizeParameters::parameter_frame frame) -> void
 
-    # @rbs (Hash[Symbol, untyped] frame) { () -> void } -> void
-    def with_parameter_frame_context: (Hash[Symbol, untyped] frame) { () -> void } -> void
+    # @rbs (NormalizeParameters::parameter_frame frame) { () -> void } -> void
+    def with_parameter_frame_context: (NormalizeParameters::parameter_frame frame) { () -> void } -> void
 
-    # @rbs (Hash[Symbol, untyped] frame) -> bool
-    def parameter_items_remaining?: (Hash[Symbol, untyped] frame) -> bool
+    # @rbs (NormalizeParameters::parameter_frame frame) -> bool
+    def parameter_items_remaining?: (NormalizeParameters::parameter_frame frame) -> bool
 
-    # @rbs (Hash[Symbol, untyped] frame) -> void
-    def start_parameter_item: (Hash[Symbol, untyped] frame) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame) -> void
+    def start_parameter_item: (NormalizeParameters::parameter_frame frame) -> void
 
-    # @rbs (Hash[Symbol, untyped] frame, Array[untyped] operation) -> void
-    def process_parameter_operation: (Hash[Symbol, untyped] frame, Array[untyped] operation) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame, NormalizeParameters::parameter_operation operation) -> void
+    def process_parameter_operation: (NormalizeParameters::parameter_frame frame, NormalizeParameters::parameter_operation operation) -> void
 
-    # @rbs (Hash[Symbol, untyped] frame, Frontend::AST::item item) -> void
-    def lower_parameter_item: (Hash[Symbol, untyped] frame, Frontend::AST::item item) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame, Frontend::AST::item item) -> void
+    def lower_parameter_item: (NormalizeParameters::parameter_frame frame, Frontend::AST::item item) -> void
 
-    # @rbs (Hash[Symbol, untyped] frame, Frontend::AST::ParameterizedReference item) -> void
-    def lower_parameter_call: (Hash[Symbol, untyped] frame, Frontend::AST::ParameterizedReference item) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame, Frontend::AST::ParameterizedReference item) -> void
+    def lower_parameter_call: (NormalizeParameters::parameter_frame frame, Frontend::AST::ParameterizedReference item) -> void
 
-    # @rbs (Hash[Symbol, untyped] frame, Frontend::AST::item item) -> void
-    def finish_parameter_item: (Hash[Symbol, untyped] frame, Frontend::AST::item item) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame, Frontend::AST::item item) -> void
+    def finish_parameter_item: (NormalizeParameters::parameter_frame frame, Frontend::AST::item item) -> void
 
-    # @rbs (Hash[Symbol, untyped] frame) -> void
-    def finish_parameter_alternative: (Hash[Symbol, untyped] frame) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame) -> void
+    def finish_parameter_alternative: (NormalizeParameters::parameter_frame frame) -> void
   end
 end

data/sig/ibex/normalize/parameters.rbs

@@ -2,7 +2,12 @@
 
 module Ibex
   # Iterative, hygienic specialization of validated parameterized user rules.
+  # rubocop:disable Metrics/ModuleLength -- parameter-frame transitions are kept together for auditability.
   module NormalizeParameters
+    type parameter_operation = [ :item | :finish_item, Frontend::AST::item ] | [ :value, String ] | [ :finish_suffix, Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus ] | [ :finish_separated, Frontend::AST::SeparatedList ] | [ :group_alternative, String, Frontend::AST::Group, Array[Frontend::AST::item] ] | [ :finish_group_alternative, String, Frontend::AST::Group, Integer ]
+
+    type parameter_frame = { reference: Frontend::AST::ParameterizedReference, arguments: Array[Frontend::AST::item], helper: String, bindings: Hash[String, Frontend::AST::item], rendered_arguments: Array[String], templates: Array[Frontend::AST::Rule], template_index: Integer, alternative_index: Integer, current: [ Frontend::AST::Rule, Frontend::AST::Rule, Frontend::AST::Alternative ]?, item_index: Integer, rhs: Array[String], named_refs: Array[IR::named_ref], operations: Array[parameter_operation], values: Array[String] }
+
     private
 
     # @rbs (Frontend::AST::ParameterizedReference reference) -> String
@@ -28,19 +33,19 @@ module Ibex
 
     # @rbs (Frontend::AST::ParameterizedReference reference, String helper,
     #   Array[Frontend::AST::item] arguments, Array[String] rendered_arguments) ->
-    #   Hash[Symbol, untyped]
-    def parameter_frame: (Frontend::AST::ParameterizedReference reference, String helper, Array[Frontend::AST::item] arguments, Array[String] rendered_arguments) -> Hash[Symbol, untyped]
+    #   NormalizeParameters::parameter_frame
+    def parameter_frame: (Frontend::AST::ParameterizedReference reference, String helper, Array[Frontend::AST::item] arguments, Array[String] rendered_arguments) -> NormalizeParameters::parameter_frame
 
     # @rbs () -> void
     def drain_parameter_worklist: () -> void
 
-    # @rbs (Hash[Symbol, untyped] frame) -> bool
-    def prepare_parameter_alternative?: (Hash[Symbol, untyped] frame) -> bool
+    # @rbs (NormalizeParameters::parameter_frame frame) -> bool
+    def prepare_parameter_alternative?: (NormalizeParameters::parameter_frame frame) -> bool
 
-    # @rbs (Hash[Symbol, untyped] frame, Frontend::AST::Rule template, Integer index) -> void
-    def prepare_parameter_alternative_entry: (Hash[Symbol, untyped] frame, Frontend::AST::Rule template, Integer index) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame, Frontend::AST::Rule template, Integer index) -> void
+    def prepare_parameter_alternative_entry: (NormalizeParameters::parameter_frame frame, Frontend::AST::Rule template, Integer index) -> void
 
-    # @rbs (Hash[Symbol, untyped] frame) -> void
-    def clear_parameter_alternative: (Hash[Symbol, untyped] frame) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame) -> void
+    def clear_parameter_alternative: (NormalizeParameters::parameter_frame frame) -> void
   end
 end

data/sig/ibex/normalize/parser_configuration.rbs

@@ -0,0 +1,23 @@
+# Generated from lib/ibex/normalize/parser_configuration.rb with RBS::Inline
+
+module Ibex
+  # Converts a root parser declaration into the explicit current Grammar IR contract.
+  module NormalizeParserConfiguration
+    private
+
+    # @rbs (Frontend::AST::ParserConfiguration declaration) -> void
+    def read_parser_configuration: (Frontend::AST::ParserConfiguration declaration) -> void
+
+    # @rbs () -> IR::ParserContract?
+    def normalized_parser_contract: () -> IR::ParserContract?
+
+    # @rbs (Frontend::AST::ParserSetting setting) -> Hash[Symbol, Object?]
+    def validated_parser_setting_definition: (Frontend::AST::ParserSetting setting) -> Hash[Symbol, Object?]
+
+    # @rbs (Frontend::AST::ParserConfiguration declaration) -> void
+    def validate_isolated_entries: (Frontend::AST::ParserConfiguration declaration) -> void
+
+    # @rbs (Frontend::AST::ParserSetting setting) -> Location
+    def parser_setting_location: (Frontend::AST::ParserSetting setting) -> Location
+  end
+end

data/sig/ibex/normalize.rbs

@@ -5,6 +5,10 @@ module Ibex
   class Normalizer
     include NormalizeDeclarations
 
+    include NormalizeParserConfiguration
+
+    include NormalizeGrammarBuilder
+
     include NormalizeLexer
 
     include NormalizeRecoveryDeclarations
@@ -41,6 +45,8 @@ module Ibex
 
     @explicit_starts: Array[String]?
 
+    @parser_configuration: Frontend::AST::ParserConfiguration?
+
     @lexer_declaration: Frontend::AST::Lexer?
 
     @grammar_tests: Array[IR::grammar_test]
@@ -71,8 +77,6 @@ module Ibex
 
     @precedence_locations: Hash[String, IR::location]
 
-    @precedence: Hash[String, IR::precedence]
-
     @node_shapes: Hash[String, Array[String]]
 
     @inline_expansion_count: Integer
@@ -93,7 +97,7 @@ module Ibex
 
     @parameter_worklist_active: bool
 
-    @parameter_worklist: Array[Hash[Symbol, untyped]]
+    @parameter_worklist: Array[NormalizeParameters::parameter_frame]
 
     @parameter_specializations: Hash[[ String, Array[String] ], String]
 
@@ -107,6 +111,8 @@ module Ibex
 
     @start_names: Array[String]
 
+    @precedence: Hash[String, IR::precedence]
+
     @declared_tokens: Hash[String, IR::location]
 
     @helper_sequence: Integer
@@ -137,8 +143,8 @@ module Ibex
 
     private
 
-    # @rbs (Symbol name, untyped value) -> void
-    def validate_positive_limit!: (Symbol name, untyped value) -> void
+    # @rbs (Symbol name, Object value) -> void
+    def validate_positive_limit!: (Symbol name, Object value) -> void
 
     # @rbs () -> void
     def intern_reserved_symbols: () -> void

data/sig/ibex/racc_migration/report.rbs

@@ -2,6 +2,8 @@
 
 module Ibex
   module RaccMigration
+    type json_value = String | Integer | Float | bool | nil | Array[json_value] | Hash[String, json_value]
+
     # One immutable migration compatibility observation.
     class Finding
       SEVERITIES: Array[Symbol]
@@ -20,8 +22,8 @@ module Ibex
       #   suggestion: String) -> void
       def initialize: (code: String, severity: Symbol, message: String, location: Frontend::Location?, suggestion: String) -> void
 
-      # @rbs () -> Hash[String, untyped]
-      def to_h: () -> Hash[String, untyped]
+      # @rbs () -> Hash[String, json_value]
+      def to_h: () -> Hash[String, json_value]
     end
 
     # Versioned result of checking one grammar without executing its code.
@@ -40,11 +42,11 @@ module Ibex
       # @rbs () -> bool
       def compatible?: () -> bool
 
-      # @rbs () -> Hash[String, untyped]
-      def to_h: () -> Hash[String, untyped]
+      # @rbs () -> Hash[String, json_value]
+      def to_h: () -> Hash[String, json_value]
 
-      # @rbs (*untyped) -> String
-      def to_json: (*untyped) -> String
+      # @rbs (*Object?) -> String
+      def to_json: (*Object?) -> String
 
       # @rbs () -> String
       def to_text: () -> String

data/sig/ibex/rake_task.rbs

@@ -43,7 +43,7 @@ module Rake
 
   class Task
     def self.define_task: (Hash[String | Symbol, String | Array[String]]) -> Task
-                        | (Hash[String | Symbol, String | Array[String]]) { (untyped, untyped) -> void } -> Task
+                        | (Hash[String | Symbol, String | Array[String]]) { (Object?, Object?) -> void } -> Task
   end
 
   class FileTask < Task

data/sig/ibex/samples.rbs

@@ -6,8 +6,8 @@ module Ibex
     DEFAULT_MAX_EXPANSIONS: Integer
 
     # @rbs (IR::Grammar grammar, ?seed: Integer, ?max_tokens: Integer, ?max_depth: Integer,
-    #   ?max_expansions: Integer) -> void
-    def initialize: (IR::Grammar grammar, ?seed: Integer, ?max_tokens: Integer, ?max_depth: Integer, ?max_expansions: Integer) -> void
+    #   ?max_expansions: Integer, ?strategy: Symbol | String, ?path_length: Integer) -> void
+    def initialize: (IR::Grammar grammar, ?seed: Integer, ?max_tokens: Integer, ?max_depth: Integer, ?max_expansions: Integer, ?strategy: Symbol | String, ?path_length: Integer) -> void
 
     # @rbs (?count: Integer) -> Array[Array[String]]
     def generate: (?count: Integer) -> Array[Array[String]]
@@ -36,8 +36,17 @@ module Ibex
     # @rbs (IR::GrammarSymbol start, Integer remaining_expansions) -> [Array[String], Integer]
     def expand: (IR::GrammarSymbol start, Integer remaining_expansions) -> [ Array[String], Integer ]
 
-    # @rbs (Integer nonterminal_id, Integer budget, Integer depth) -> IR::Production
-    def choose_production: (Integer nonterminal_id, Integer budget, Integer depth) -> IR::Production
+    # @rbs (Integer nonterminal_id, Integer budget, Integer depth, Array[Integer] path) -> IR::Production
+    def choose_production: (Integer nonterminal_id, Integer budget, Integer depth, Array[Integer] path) -> IR::Production
+
+    # @rbs (Integer nonterminal_id, Integer budget) -> Array[IR::Production]
+    def bounded_productions: (Integer nonterminal_id, Integer budget) -> Array[IR::Production]
+
+    # @rbs (Array[IR::Production] candidates) -> Array[IR::Production]
+    def minimum_height_productions: (Array[IR::Production] candidates) -> Array[IR::Production]
+
+    # @rbs (Array[Integer] path, IR::Production production) -> Integer
+    def path_count: (Array[Integer] path, IR::Production production) -> Integer
 
     # @rbs (Integer symbol_id) -> Integer
     def minimum_cost!: (Integer symbol_id) -> Integer

data/sig/ibex/table_artifact/builder.rbs

@@ -0,0 +1,93 @@
+# Generated from lib/ibex/table_artifact/builder.rb with RBS::Inline
+
+module Ibex
+  module TableArtifact
+    # Projects validated Automaton IR into an action-free executable sidecar.
+    class Builder
+      type json_value = String | Integer | Float | bool | nil | Array[json_value] | Hash[String, json_value]
+
+      type json_hash = Hash[String, untyped]
+
+      type action_rows = Array[Hash[Integer, IR::runtime_action]]
+
+      type action_table = action_rows | Tables::CompactActions
+
+      type goto_rows = Array[Hash[Integer, Integer]]
+
+      type goto_table = goto_rows | Tables::Compact
+
+      include CSTProjection
+
+      REPRESENTATIONS: Array[Symbol]
+
+      # @rbs (IR::Automaton automaton, ?representation: Symbol | String, ?cst_trivia: Symbol | String?,
+      #   ?omit_action_call: bool?) -> void
+      def initialize: (IR::Automaton automaton, ?representation: Symbol | String, ?cst_trivia: Symbol | String?, ?omit_action_call: bool?) -> void
+
+      # @rbs () -> Document
+      def build: () -> Document
+
+      private
+
+      # @rbs (Hash[String, String] source_identity) -> json_hash
+      def build_payload: (Hash[String, String] source_identity) -> json_hash
+
+      # @rbs () -> String
+      def automaton_digest: () -> String
+
+      # @rbs () -> json_hash
+      def table_format: () -> json_hash
+
+      # @rbs () -> Array[json_hash]
+      def symbols: () -> Array[json_hash]
+
+      # @rbs () -> Array[json_hash]
+      def tokens: () -> Array[json_hash]
+
+      # @rbs () -> Array[json_hash]
+      def entry_states: () -> Array[json_hash]
+
+      # @rbs () -> json_hash
+      def tables: () -> json_hash
+
+      # @rbs (action_table table) -> json_hash
+      def action_table: (action_table table) -> json_hash
+
+      # @rbs (Tables::CompactActions table) -> json_hash
+      def compact_action_table: (Tables::CompactActions table) -> json_hash
+
+      # @rbs (goto_table table) -> json_hash
+      def goto_table: (goto_table table) -> json_hash
+
+      # @rbs (Tables::Compact table) -> json_hash
+      def compact_goto_table: (Tables::Compact table) -> json_hash
+
+      # @rbs () -> Array[json_hash]
+      def productions: () -> Array[json_hash]
+
+      # @rbs (IR::Production production) -> bool
+      def action_slot?: (IR::Production production) -> bool
+
+      # @rbs () -> json_hash
+      def semantic_actions: () -> json_hash
+
+      # @rbs () -> json_hash
+      def recovery: () -> json_hash
+
+      # @rbs (json_hash payload) -> json_hash
+      def build_cost: (json_hash payload) -> json_hash
+
+      # @rbs (json_hash table, String values_key) -> Integer
+      def occupied_cells: (json_hash table, String values_key) -> Integer
+
+      # @rbs () -> String
+      def lookup_cost: () -> String
+
+      # @rbs () -> String
+      def recognition_cost: () -> String
+
+      # @rbs (Symbol | String? requested) -> Symbol
+      def effective_cst_trivia: (Symbol | String? requested) -> Symbol
+    end
+  end
+end

data/sig/ibex/table_artifact/cst_projection.rbs

@@ -0,0 +1,20 @@
+# Generated from lib/ibex/table_artifact/cst_projection.rb with RBS::Inline
+
+module Ibex
+  module TableArtifact
+    # Converts code-generation CST metadata into closed JSON records.
+    module CSTProjection
+      private def cst: () -> Hash[String, Builder::json_value]?
+
+      private def normalize_cst: (Codegen::CSTMetadata::metadata metadata) -> Hash[String, Builder::json_value]
+
+      private def normalize_cst_kinds: (Codegen::CSTMetadata::kinds kinds) -> Hash[String, Builder::json_value]
+
+      private def named_kinds: (Hash[String, Integer] values) -> Array[Hash[String, String | Integer]]
+
+      private def normalize_cst_slot: (Integer production_id, Codegen::CSTMetadata::slot slot) -> Hash[String, Builder::json_value]
+
+      private
+    end
+  end
+end