ibex-runtime 0.2.0 → 0.4.0

data/lib/ibex/runtime/parser.rb

@@ -4,26 +4,34 @@
 require_relative "location_span" unless defined?(Ibex::Runtime::LocationSpan)
 require_relative "observation" unless defined?(Ibex::Runtime::Observation)
 require_relative "resource_limits" unless defined?(Ibex::Runtime::ResourceLimits)
+require_relative "syntax_session" unless defined?(Ibex::Runtime::SyntaxSession)
 require_relative "repair" unless defined?(Ibex::Runtime::RepairPolicy)
 require_relative "repair_search" unless defined?(Ibex::Runtime::RepairSearch)
+require_relative "syntax_repair" unless defined?(Ibex::Runtime::SyntaxRepairer)
 require_relative "parser_sync_recovery" unless defined?(Ibex::Runtime::ParserSyncRecovery)
 require_relative "table_format" unless defined?(Ibex::Runtime::PARSER_TABLE_FORMAT_VERSION)
 
 module Ibex
   module Runtime
+    # Semantic values and lexer locations intentionally cross the runtime
+    # boundary without a closed application type. Keep that boundary named so
+    # the rest of the parser remains structurally typed.
+    # @rbs!
+    #   type runtime_value = untyped
+
     # Raised by the default parser error handler.
     class ParseError < StandardError
       attr_reader :token_id #: Integer?
       attr_reader :token_name #: String?
-      attr_reader :token_value #: untyped
+      attr_reader :token_value #: runtime_value
       attr_reader :expected_tokens #: Array[String]
-      attr_reader :location #: untyped
+      attr_reader :location #: runtime_value
       attr_reader :state #: Integer?
       attr_reader :suggestions #: Array[String]
       attr_reader :error_id #: String?
 
       # rubocop:disable Layout/LineLength
-      # @rbs (?String? message, ?token_id: Integer?, ?token_name: String?, ?token_value: untyped, ?expected_tokens: Array[String], ?location: untyped, ?state: Integer?, ?suggestions: Array[String], ?error_id: String?, ?detail: String?) -> void
+      # @rbs (?String? message, ?token_id: Integer?, ?token_name: String?, ?token_value: runtime_value, ?expected_tokens: Array[String], ?location: runtime_value, ?state: Integer?, ?suggestions: Array[String], ?error_id: String?, ?detail: String?) -> void
       # rubocop:enable Layout/LineLength
       def initialize(
         message = nil,
@@ -72,7 +80,7 @@ module Ibex
         message
       end
 
-      # @rbs (Symbol key) -> untyped
+      # @rbs (Symbol key) -> runtime_value
       def location_value(key)
         return nil unless @location
         return @location.public_send(key) if @location.respond_to?(key)
@@ -88,7 +96,7 @@ module Ibex
       attr_reader :limit #: Integer
       attr_reader :observed #: Integer
 
-      # @rbs (resource: Symbol, limit: Integer, observed: Integer, state: Integer?, location: untyped) -> void
+      # @rbs (resource: Symbol, limit: Integer, observed: Integer, state: Integer?, location: runtime_value) -> void
       def initialize(resource:, limit:, observed:, state:, location:)
         @resource = resource
         @limit = limit
@@ -99,7 +107,7 @@ module Ibex
         )
       end
 
-      # @rbs () -> Hash[Symbol, untyped]
+      # @rbs () -> Hash[Symbol, runtime_value]
       def to_h
         {
           type: :resource_limit, resource: @resource, limit: @limit, observed: @observed,
@@ -250,14 +258,14 @@ module Ibex
       REPAIR_PENDING_OUTCOME = [:repair_pending].freeze #: [:repair_pending]
       TERMINAL_OUTCOMES = %i[accepted done].freeze #: Array[Symbol]
       COMPACT_ACCEPTED = Object.new.freeze #: Object
-      empty_row = {} # @type var empty_row: Hash[Integer, untyped]
+      empty_row = {} # @type var empty_row: Hash[Integer, runtime_value]
       empty_location_names = {} # @type var empty_location_names: Hash[Symbol, Integer]
-      empty_locations = [] # @type var empty_locations: Array[untyped]
+      empty_locations = [] # @type var empty_locations: Array[runtime_value]
       empty_green_trivia = [] # @type var empty_green_trivia: Array[CST::GreenTrivia]
 
-      EMPTY_ROW = empty_row.freeze #: Hash[Integer, untyped]
+      EMPTY_ROW = empty_row.freeze #: Hash[Integer, runtime_value]
       EMPTY_LOCATION_NAMES = empty_location_names.freeze #: Hash[Symbol, Integer]
-      EMPTY_LOCATIONS = empty_locations.freeze #: Array[untyped]
+      EMPTY_LOCATIONS = empty_locations.freeze #: Array[runtime_value]
       EMPTY_GREEN_TRIVIA = empty_green_trivia.freeze #: Array[CST::GreenTrivia]
       private_constant :ERROR_ACTION, :SYNC_RECOVER_ACTION, :CONTINUE_OUTCOME, :REPAIR_PENDING_OUTCOME,
                        :TERMINAL_OUTCOMES, :COMPACT_ACCEPTED, :FAST_PATH_HOOK_NAMES, :FAST_PATH_HOOK_REFERENCES,
@@ -265,15 +273,15 @@ module Ibex
 
       # @rbs @yydebug: bool
       # @rbs @yydebug_output: IO
-      # @rbs @source: untyped
+      # @rbs @source: runtime_value
       # @rbs @state_stack: Array[Integer]
-      # @rbs @value_stack: Array[untyped]
-      # @rbs @vstack: Array[untyped]
-      # @rbs @racc_vstack: Array[untyped]
-      # @rbs @location_stack: Array[untyped]?
-      # @rbs @lookahead: untyped
-      # @rbs @lookahead_value: untyped
-      # @rbs @lookahead_location: untyped
+      # @rbs @value_stack: Array[runtime_value]
+      # @rbs @vstack: Array[runtime_value]
+      # @rbs @racc_vstack: Array[runtime_value]
+      # @rbs @location_stack: Array[runtime_value]?
+      # @rbs @lookahead: runtime_value
+      # @rbs @lookahead_value: runtime_value
+      # @rbs @lookahead_location: runtime_value
       # @rbs @recovery_shifts: Integer
       # @rbs @semantic_error: bool
       # @rbs @accept_requested: bool
@@ -284,27 +292,27 @@ module Ibex
       # @rbs @runtime_driver_thread: Thread?
       # @rbs @runtime_observers: Hash[Observation::Subscription, Proc]?
       # @rbs @runtime_event_sequence: Integer
-      # @rbs @runtime_lookahead_token_display: untyped
+      # @rbs @runtime_lookahead_token_display: String?
       # @rbs @runtime_observation_mutex: Mutex
       # @rbs @repair_policy: RepairPolicy?
       # @rbs @repair_input_buffer: Array[RepairInput]?
       # @rbs @repair_selected: bool
-      # @rbs @semantic_locations: Array[untyped]?
+      # @rbs @semantic_locations: Array[runtime_value]?
       # @rbs @semantic_location_names: Hash[Symbol, Integer]?
-      # @rbs @semantic_result_location: untyped
-      # @rbs @trace_value_printer: (^(untyped) -> untyped)?
-      # @rbs @sync_recovery_context: Hash[Symbol, untyped]?
-      # @rbs @sync_recovery_token_data: Hash[String, untyped]?
+      # @rbs @semantic_result_location: runtime_value
+      # @rbs @trace_value_printer: (^(runtime_value) -> runtime_value)?
+      # @rbs @sync_recovery_context: Hash[Symbol, runtime_value]?
+      # @rbs @sync_recovery_token_data: Hash[String, runtime_value]?
       # @rbs @sync_recovery_observers: Array[Proc]?
       # @rbs @green_builder: CST::GreenBuilder?
       # @rbs @green_kinds: CST::Kind?
       # @rbs @green_cache: CST::NodeCache?
       # @rbs @syntax_root: CST::SyntaxNode?
-      # @rbs @syntax_diagnostics: Array[untyped]
+      # @rbs @syntax_diagnostics: Array[runtime_value]
       # @rbs @green_pending_skipped: Array[CST::GreenTrivia]
       # @rbs @resource_limits: ResourceLimits
       # @rbs @recovery_attempts: Integer
-      # @rbs @runtime_parser_tables: Hash[Symbol, untyped]?
+      # @rbs @runtime_parser_tables: Hash[Symbol, runtime_value]?
       # @rbs @runtime_fast_path: bool
       # @rbs @runtime_fast_path_tracker_installed: bool
       # @rbs @runtime_fast_path_hooks_mutated: bool
@@ -322,7 +330,41 @@ module Ibex
       attr_reader :syntax_parse_memo #: CST::ParseMemo?
       attr_reader :incremental_reused_descendants #: Integer
 
+      # Report the trust boundary of syntax-only operations for this loaded
+      # parser class. Current generated artifacts can contain user sections
+      # and Ruby lexer actions, so they are always trusted application code.
+      # @rbs skip
+      def self.syntax_execution_profile
+        :trusted_application_code
+      end
+
+      # Open a generated-language syntax session backed by the existing
+      # incremental Red/Green CST engine. The execution profile must be passed
+      # explicitly because generated lexer actions execute in this path.
+      # @rbs skip
+      def self.syntax_session(
+        source,
+        execution_profile: nil,
+        resource_limits: nil,
+        limits: nil,
+        cancellation: nil,
+        blender: true
+      )
+        SyntaxSession.new(
+          self,
+          source,
+          execution_profile: execution_profile,
+          resource_limits: resource_limits,
+          limits: limits,
+          cancellation: cancellation,
+          blender: blender
+        )
+      end
+
       # Start a syntax-only incremental session backed by a generated lexer.
+      # Parser production actions are suppressed, but generated lexer actions
+      # still execute. The generated class is trusted application code, not a
+      # sandbox.
       # @rbs (CST::SourceText source_text, ?resource_limits: ResourceLimits?, ?blender: bool) ->
       #   CST::IncrementalParseSession
       def self.incremental_session(source_text, resource_limits: nil, blender: true)
@@ -403,13 +445,17 @@ module Ibex
         end
       end
 
-      # Pull tokens from `next_token` and parse them.
-      # @rbs () -> untyped
+      # Pull tokens from `next_token` and execute parser production actions.
+      # A generated-lexer `next_token` executes lexer actions; a handwritten
+      # implementation does not invoke the generated lexer.
+      # @rbs () -> runtime_value
       def do_parse
         drive_parser(nil)
       end
 
       # Parse through `next_token` and return both the semantic value and Red root.
+      # Parser production actions execute. Generated lexer actions execute only
+      # when `next_token` is supplied by the generated lexer.
       # @rbs () -> CST::ParseResult
       def parse_with_syntax
         syntax_parse_result(do_parse)
@@ -422,8 +468,10 @@ module Ibex
         @syntax_root
       end
 
-      # Parse tokens yielded by `receiver.method_id`.
-      # @rbs (untyped receiver, Symbol method_id) -> untyped
+      # Parse tokens yielded by `receiver.method_id` and execute parser
+      # production actions. This caller-fed path does not invoke generated
+      # lexer actions.
+      # @rbs (runtime_value receiver, Symbol method_id) -> runtime_value
       def yyparse(receiver, method_id)
         stream = Enumerator.new do |tokens|
           receiver.__send__(method_id) { |token| tokens << token }
@@ -432,11 +480,11 @@ module Ibex
       end
 
       # Supply one token to a caller-driven parser session.
+      # Committed reductions execute parser production actions; this token-fed
+      # path does not invoke generated lexer actions.
       # Returns `:need_more` after consuming it, `[:accepted, result]` after
       # acceptance, or `[:rejected, result]` after recovery terminates.
-      # rubocop:disable Layout/LineLength
-      # @rbs (untyped token, ?untyped value, ?untyped location) -> (:need_more | [:accepted, untyped] | [:rejected, untyped])
-      # rubocop:enable Layout/LineLength
+      # @rbs (runtime_value token, ?runtime_value value, ?runtime_value location) -> runtime_value
       def push(token, value = nil, location = nil)
         raise ParseError, "(input):1:1: push requires a token; call finish for EOF" if token.nil? || token == false
 
@@ -457,7 +505,9 @@ module Ibex
       end
 
       # Supply EOF to a caller-driven parser session and return its result.
-      # @rbs (?location: untyped) -> untyped
+      # Committed reductions execute parser production actions; this token-fed
+      # path does not invoke generated lexer actions.
+      # @rbs (?location: runtime_value) -> runtime_value
       def finish(location: nil)
         run_push_driver do
           start_push_session
@@ -505,14 +555,14 @@ module Ibex
 
       # Override in pull parsers. Return `[token, value]`,
       # `[token, value, location]`, `false`, or `nil`.
-      # @rbs () -> ([untyped, untyped] | [untyped, untyped, untyped] | false | nil)
+      # @rbs () -> ([runtime_value, runtime_value] | [runtime_value, runtime_value, runtime_value] | false | nil)
       def next_token
         raise NotImplementedError, "(input):1:1: next_token must be implemented"
       end
 
       # Override to recover from syntax errors. The default raises unless a
       # bounded automatic repair has already been selected.
-      # @rbs (Integer token_id, untyped value, Array[untyped] value_stack) -> untyped
+      # @rbs (Integer token_id, runtime_value value, Array[runtime_value] value_stack) -> runtime_value
       def on_error(token_id, value, _value_stack)
         return if @repair_selected
         return if cst_enabled?
@@ -537,40 +587,40 @@ module Ibex
 
       # Called after an ordinary input token is shifted. Override to observe
       # the internal token id, semantic value, and destination state.
-      # @rbs (Integer token_id, untyped value, Integer state) -> void
+      # @rbs (Integer token_id, runtime_value value, Integer state) -> void
       def on_shift(_token_id, _value, _state); end
 
       # Location-aware shift observer. The compatible hook above retains its
       # original signature and runs first.
-      # @rbs (Integer token_id, untyped value, Integer state, untyped location) -> void
+      # @rbs (Integer token_id, runtime_value value, Integer state, runtime_value location) -> void
       def on_shift_location(_token_id, _value, _state, _location); end
 
       # Called after a production's semantic action and goto are committed.
       # Override to observe its id, RHS values, and semantic result.
-      # @rbs (Integer production_id, Array[untyped] values, untyped result) -> void
+      # @rbs (Integer production_id, Array[runtime_value] values, runtime_value result) -> void
       def on_reduce(_production_id, _values, _result); end
 
       # Location-aware reduction observer.
-      # @rbs (Integer production_id, Array[untyped] values, untyped result,
-      #   Array[untyped] locations, untyped result_location) -> void
+      # @rbs (Integer production_id, Array[runtime_value] values, runtime_value result,
+      #   Array[runtime_value] locations, runtime_value result_location) -> void
       def on_reduce_location(_production_id, _values, _result, _locations, _result_location); end
 
       # Called after the synthetic error token enters a recovery state.
       # The payload describes the original error before recovery popped stacks.
-      # @rbs (Integer token_id, untyped value, Array[untyped] value_stack) -> void
+      # @rbs (Integer token_id, runtime_value value, Array[runtime_value] value_stack) -> void
       def on_error_recover(_token_id, _value, _value_stack); end
 
       # Location-aware recovery observer.
-      # @rbs (Integer token_id, untyped value, Array[untyped] value_stack,
-      #   untyped location, Integer state) -> void
+      # @rbs (Integer token_id, runtime_value value, Array[runtime_value] value_stack,
+      #   runtime_value location, Integer state) -> void
       def on_error_recover_location(_token_id, _value, _value_stack, _location, _state); end
 
       # Called when yacc recovery discards an application token.
-      # @rbs (Integer token_id, untyped value, untyped location, Symbol reason) -> void
+      # @rbs (Integer token_id, runtime_value value, runtime_value location, Symbol reason) -> void
       def on_discard(_token_id, _value, _location, _reason); end
 
       # Install an opt-in value formatter for human-readable yydebug traces.
-      # @rbs ((^(untyped) -> untyped)? printer) -> (^(untyped) -> untyped)?
+      # @rbs ((^(runtime_value) -> runtime_value)? printer) -> (^(runtime_value) -> runtime_value)?
       def trace_value_printer=(printer)
         ensure_runtime_initialized!
         unless printer.nil? || printer.respond_to?(:call)
@@ -646,7 +696,7 @@ module Ibex
 
       # Return the location of a one-based RHS position or named reference
       # while a semantic action is running.
-      # @rbs (Integer | Symbol | String reference) -> untyped
+      # @rbs (Integer | Symbol | String reference) -> runtime_value
       def loc(reference)
         locations = @semantic_locations
         raise ParseError, "(runtime):1:1: loc is only available inside a semantic action" unless locations
@@ -665,7 +715,7 @@ module Ibex
       end
 
       # Return the synthesized span of the reduction being evaluated.
-      # @rbs () -> untyped
+      # @rbs () -> runtime_value
       def result_loc
         unless @semantic_locations
           raise ParseError, "(runtime):1:1: result_loc is only available inside a semantic action"
@@ -725,6 +775,9 @@ module Ibex
         @repair_policy = nil unless preserve_existing && defined?(@repair_policy)
         @repair_input_buffer = nil unless preserve_existing && defined?(@repair_input_buffer)
         @repair_selected = false unless preserve_existing && defined?(@repair_selected)
+        unless preserve_existing && defined?(@repair_search_results)
+          @repair_search_results = [] #: Array[RepairSearchResult]
+        end
         @semantic_locations = nil unless preserve_existing && defined?(@semantic_locations)
         @semantic_location_names = nil unless preserve_existing && defined?(@semantic_location_names)
         @semantic_result_location = nil unless preserve_existing && defined?(@semantic_result_location)
@@ -736,8 +789,8 @@ module Ibex
         @green_kinds = nil unless preserve_existing && defined?(@green_kinds)
         @green_cache = nil unless preserve_existing && defined?(@green_cache)
         @syntax_root = nil unless preserve_existing && defined?(@syntax_root)
-        @syntax_diagnostics = [] unless preserve_existing && defined?(@syntax_diagnostics)
-        @green_pending_skipped = [] unless preserve_existing && defined?(@green_pending_skipped)
+        @syntax_diagnostics = EMPTY_LOCATIONS unless preserve_existing && defined?(@syntax_diagnostics)
+        @green_pending_skipped = EMPTY_GREEN_TRIVIA unless preserve_existing && defined?(@green_pending_skipped)
         @recovery_attempts = 0 unless preserve_existing && defined?(@recovery_attempts)
         @runtime_parser_tables = nil unless preserve_existing && defined?(@runtime_parser_tables)
         @runtime_fast_path = false unless preserve_existing && defined?(@runtime_fast_path)
@@ -749,8 +802,8 @@ module Ibex
           preserve_existing && defined?(@runtime_fast_path_singleton_ancestors)
         @syntax_only = false unless preserve_existing && defined?(@syntax_only)
         @green_cache_override = nil unless preserve_existing && defined?(@green_cache_override)
-        @green_token_states = [] unless preserve_existing && defined?(@green_token_states)
-        @green_memo_stack = [] unless preserve_existing && defined?(@green_memo_stack)
+        @green_token_states = EMPTY_LOCATIONS unless preserve_existing && defined?(@green_token_states)
+        @green_memo_stack = EMPTY_LOCATIONS unless preserve_existing && defined?(@green_memo_stack)
         @green_parse_memo_valid = false unless preserve_existing && defined?(@green_parse_memo_valid)
         @green_initial_state = 0 unless preserve_existing && defined?(@green_initial_state)
         @syntax_parse_memo = nil unless preserve_existing && defined?(@syntax_parse_memo)
@@ -769,7 +822,7 @@ module Ibex
 
       # Keep the two historical value-stack names as read-compatible aliases.
       # Applications must not mutate or replace these internal arrays.
-      # @rbs (Array[untyped] values) -> void
+      # @rbs (Array[runtime_value] values) -> void
       def install_value_stack(values)
         @value_stack = values
         @vstack = values
@@ -809,7 +862,7 @@ module Ibex
         (stack_depth + parser_state_count(tables) + 1) * (production_count + 1)
       end
 
-      # @rbs (Hash[Symbol, untyped] tables) -> Integer
+      # @rbs (Hash[Symbol, runtime_value] tables) -> Integer
       def parser_state_count(tables)
         state_count = tables[:state_count]
         return state_count if state_count.is_a?(Integer)
@@ -848,7 +901,7 @@ module Ibex
         true
       end
 
-      # @rbs (untyped source, ?initial_state: Integer?) -> untyped
+      # @rbs (runtime_value source, ?initial_state: Integer?) -> runtime_value
       def drive_parser(source, initial_state: nil)
         ensure_runtime_initialized!
         @runtime_observation_mutex.synchronize do
@@ -892,7 +945,7 @@ module Ibex
       # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity
       # Direct comparisons avoid predicate-method dispatch inside the parser loop.
       # rubocop:disable Style/BitwisePredicate, Style/NumericPredicate
-      # @rbs (Hash[Symbol, untyped] tables) -> (Object | [:accepted, untyped] | [:done, untyped])?
+      # @rbs (Hash[Symbol, runtime_value] tables) -> runtime_value
       def drive_compact_fast_parser(tables)
         actions = tables.fetch(:actions)
         gotos = tables.fetch(:gotos)
@@ -1132,7 +1185,7 @@ module Ibex
       # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity
       # rubocop:enable Style/BitwisePredicate, Style/NumericPredicate
 
-      # @rbs (Hash[Symbol, untyped]? tables) -> bool
+      # @rbs (Hash[Symbol, runtime_value]? tables) -> bool
       def compact_fast_driver_eligible?(tables)
         return false unless @runtime_fast_path && tables
         return false unless tables[:compact_fast_driver] == true
@@ -1156,7 +1209,7 @@ module Ibex
         @push_status = :active
       end
 
-      # @rbs () -> (:need_more | [:accepted, untyped] | [:rejected, untyped])
+      # @rbs () -> runtime_value
       def run_push_lookahead
         loop do
           outcome = perform(action_for_current_state)
@@ -1179,7 +1232,7 @@ module Ibex
         end
       end
 
-      # @rbs () { () -> untyped } -> untyped
+      # @rbs () { () -> runtime_value } -> runtime_value
       def run_push_driver
         ensure_runtime_initialized!
         @runtime_observation_mutex.synchronize do
@@ -1225,7 +1278,7 @@ module Ibex
         clear_sync_recovery
       end
 
-      # @rbs ((^() -> untyped)? source, ?initial_state: Integer?) -> void
+      # @rbs ((^() -> runtime_value)? source, ?initial_state: Integer?) -> void
       def prepare_parse(source, initial_state: nil)
         @runtime_parser_tables = load_parser_tables
         tables = validate_parser_table_format!
@@ -1267,10 +1320,11 @@ module Ibex
         @semantic_error = false
         @repair_input_buffer = @repair_policy ? [] : nil
         @repair_selected = false
+        @repair_search_results = [] #: Array[RepairSearchResult]
         clear_sync_recovery
       end
 
-      # @rbs (Hash[Symbol, untyped] tables, Integer? requested) -> Integer
+      # @rbs (Hash[Symbol, runtime_value] tables, Integer? requested) -> Integer
       def resolve_initial_state(tables, requested)
         initial_state = requested || tables[:initial_state] || 0
         return initial_state if initial_state.is_a?(Integer) &&
@@ -1279,7 +1333,7 @@ module Ibex
         raise ParseError, "(tables):1:1: parser initial state #{initial_state.inspect} is invalid"
       end
 
-      # @rbs () -> Hash[Symbol, untyped]
+      # @rbs () -> Hash[Symbol, runtime_value]
       def validate_parser_table_format!
         tables = parser_tables
         unless tables.key?(:format_version)
@@ -1296,19 +1350,19 @@ module Ibex
                 "regenerate the parser with the installed Ibex version"
         end
 
-        validate_current_cst_tables!(tables, actual)
-        if actual >= 3 && !generated_action_contracts_validated?(tables)
-          validate_generated_action_contracts!(tables, actual)
+        validate_current_cst_tables!(tables)
+        unless generated_action_contracts_validated?(tables)
+          validate_generated_action_contracts!(tables)
           cache_generated_action_contracts!(tables)
         end
         tables
       end
 
-      # @rbs (Hash[Symbol, untyped] tables, Integer actual) -> void
-      def validate_current_cst_tables!(tables, actual)
+      # @rbs (Hash[Symbol, runtime_value] tables) -> void
+      def validate_current_cst_tables!(tables)
         cst = tables[:cst]
         return if cst.nil? || cst == false
-        return if actual == PARSER_TABLE_FORMAT_VERSION && cst.is_a?(Hash)
+        return if cst.is_a?(Hash)
 
         raise ParseError,
               "(tables):1:1: legacy CST parser tables are unsupported; " \
@@ -1319,7 +1373,7 @@ module Ibex
       # Ractor boundary. Their action-marker contract only needs one scan per
       # parser class and exact table object, including across parser instances.
       # Mutable application tables remain intentionally uncached.
-      # @rbs (Hash[Symbol, untyped] tables) -> bool
+      # @rbs (Hash[Symbol, runtime_value] tables) -> bool
       def generated_action_contracts_validated?(tables)
         return false unless generated_action_contract_cache_accessible?
 
@@ -1327,7 +1381,7 @@ module Ibex
         cached.equal?(tables)
       end
 
-      # @rbs (Hash[Symbol, untyped] tables) -> void
+      # @rbs (Hash[Symbol, runtime_value] tables) -> void
       def cache_generated_action_contracts!(tables)
         shareable = defined?(Ractor) && Ractor.respond_to?(:shareable?) && Ractor.shareable?(tables)
         return unless shareable
@@ -1353,58 +1407,62 @@ module Ibex
         true
       end
 
-      # @rbs (Hash[Symbol, untyped] tables, Integer version) -> void
-      def validate_generated_action_contracts!(tables, version)
+      # @rbs (Hash[Symbol, runtime_value] tables) -> void
+      def validate_generated_action_contracts!(tables)
         tables.fetch(:productions).each_with_index do |production, index|
-          validate_composition_action_contract!(production, index, version)
-          validate_values_action_contract!(production, index, version)
-          validate_positional_action_contract!(production, index, version)
+          validate_composition_action_contract!(production, index)
+          validate_values_action_contract!(production, index)
+          validate_positional_action_contract!(production, index)
         end
       end
 
-      # @rbs (Hash[Symbol, untyped] production, Integer index, Integer version) -> void
-      def validate_composition_action_contract!(production, index, version)
+      # @rbs (Hash[Symbol, runtime_value] production, Integer index) -> void
+      def validate_composition_action_contract!(production, index)
         return unless production[:composition_action] == true
         return if production[:location_action] == true && generated_action_symbol?(production[:action])
 
         raise ParseError,
-              "(tables):1:1: parser table format version #{version} production #{index} has an inconsistent " \
+              "(tables):1:1: parser table format version #{PARSER_TABLE_FORMAT_VERSION} " \
+              "production #{index} has an inconsistent " \
               ":composition_action marker; a generated action Symbol with :location_action is required"
       end
 
-      # @rbs (Hash[Symbol, untyped] production, Integer index, Integer version) -> void
-      def validate_values_action_contract!(production, index, version)
+      # @rbs (Hash[Symbol, runtime_value] production, Integer index) -> void
+      def validate_values_action_contract!(production, index)
         borrowed = production[:borrowed_values_action] == true
         if borrowed && production[:values_action] != true
           raise ParseError,
-                "(tables):1:1: parser table format version #{version} production #{index} has an inconsistent " \
+                "(tables):1:1: parser table format version #{PARSER_TABLE_FORMAT_VERSION} " \
+                "production #{index} has an inconsistent " \
                 ":borrowed_values_action marker; :values_action is required"
         end
-        return if version < 4 || production[:values_action] != true
+        return if production[:values_action] != true
         return if generated_action_symbol?(production[:action]) &&
                   production[:location_action] != true &&
                   production[:composition_action] != true &&
                   production.fetch(:location_context_length, 0).zero?
 
         raise ParseError,
-              "(tables):1:1: parser table format version #{version} production #{index} has an inconsistent " \
+              "(tables):1:1: parser table format version #{PARSER_TABLE_FORMAT_VERSION} " \
+              "production #{index} has an inconsistent " \
               ":values_action marker; a generated action Symbol without location, composition, or context " \
               "markers is required"
       end
 
-      # @rbs (Hash[Symbol, untyped] production, Integer index, Integer version) -> void
-      def validate_positional_action_contract!(production, index, version)
-        return if version < 5 || production[:positional_action] != true
+      # @rbs (Hash[Symbol, runtime_value] production, Integer index) -> void
+      def validate_positional_action_contract!(production, index)
+        return unless production[:positional_action] == true
 
         return if positional_action_contract?(production)
 
         raise ParseError,
-              "(tables):1:1: parser table format version #{version} production #{index} has an inconsistent " \
+              "(tables):1:1: parser table format version #{PARSER_TABLE_FORMAT_VERSION} " \
+              "production #{index} has an inconsistent " \
               ":positional_action marker; a generated action Symbol with zero to four RHS values and no other " \
               "action ABI markers is required"
       end
 
-      # @rbs (Hash[Symbol, untyped] production) -> bool
+      # @rbs (Hash[Symbol, runtime_value] production) -> bool
       def positional_action_contract?(production)
         production[:length].is_a?(Integer) &&
           production[:length].between?(0, 4) &&
@@ -1416,7 +1474,7 @@ module Ibex
           production.fetch(:location_context_length, 0).zero?
       end
 
-      # @rbs () -> untyped
+      # @rbs () -> runtime_value
       def action_for_current_state
         loop do
           if @lookahead.equal?(NO_LOOKAHEAD)
@@ -1439,7 +1497,7 @@ module Ibex
         end
       end
 
-      # @rbs (untyped action) -> untyped
+      # @rbs (runtime_value action) -> runtime_value
       def perform(action)
         case action.first
         when :shift
@@ -1481,7 +1539,7 @@ module Ibex
         CONTINUE_OUTCOME
       end
 
-      # @rbs (Hash[Symbol, untyped] production, untyped length) -> bool
+      # @rbs (Hash[Symbol, runtime_value] production, runtime_value length) -> bool
       def fast_reduction_eligible?(production, length)
         action = production[:action]
         return false if action && !generated_values_action?(production, action)
@@ -1490,7 +1548,7 @@ module Ibex
           length <= @value_stack.length && length < @state_stack.length
       end
 
-      # @rbs (Integer production_id, Hash[Symbol, untyped] production, Integer length) -> [:continue]
+      # @rbs (Integer production_id, Hash[Symbol, runtime_value] production, Integer length) -> [:continue]
       def fast_reduce(production_id, production, length)
         action = production[:action]
         return fast_values_reduce(production_id, production, length, action) if action
@@ -1511,7 +1569,8 @@ module Ibex
         CONTINUE_OUTCOME
       end
 
-      # @rbs (Integer production_id, Hash[Symbol, untyped] production, Integer length, Symbol action) -> untyped
+      # @rbs (Integer production_id, Hash[Symbol, runtime_value] production, Integer length,
+      #   Symbol action) -> runtime_value
       def fast_values_reduce(production_id, production, length, action)
         hook_values = @value_stack.last(length)
         values = hook_values.dup
@@ -1544,7 +1603,7 @@ module Ibex
         CONTINUE_OUTCOME
       end
 
-      # @rbs (Integer next_state) -> untyped
+      # @rbs (Integer next_state) -> runtime_value
       def shift(next_state)
         token_id = @lookahead
         value = @lookahead_value
@@ -1577,7 +1636,7 @@ module Ibex
         CONTINUE_OUTCOME
       end
 
-      # @rbs (Integer production_id, ?Hash[Symbol, untyped]? prefetched_production) -> untyped
+      # @rbs (Integer production_id, ?Hash[Symbol, runtime_value]? prefetched_production) -> runtime_value
       def reduce(production_id, prefetched_production = nil) # rubocop:disable Metrics -- allocation-free hot path.
         production = prefetched_production || parser_tables.fetch(:productions).fetch(production_id)
         length = production.fetch(:length)
@@ -1622,23 +1681,23 @@ module Ibex
         CONTINUE_OUTCOME
       end
 
-      # @rbs (Integer next_state, untyped result, untyped location) -> void
+      # @rbs (Integer next_state, runtime_value result, runtime_value location) -> void
       def push_reduction_result(next_state, result, location)
         @state_stack << next_state
         push_location(location)
         @value_stack << result
       end
 
-      # @rbs (Integer production_id, Integer length, Integer lhs, untyped result, Integer next_state) -> void
+      # @rbs (Integer production_id, Integer length, Integer lhs, runtime_value result, Integer next_state) -> void
       def trace_reduction(production_id, length, lhs, result, next_state)
         return unless @yydebug
 
         trace("reduce #{production_id} (#{length})#{trace_value_suffix(result, lhs)} -> state #{next_state}")
       end
 
-      # @rbs (Array[Proc]? observers, Integer production_id, Hash[Symbol, untyped] production, Integer length,
-      #   Integer? pre_state, Integer? post_state, Integer next_state, untyped result,
-      #   LocationSpan? location) -> Hash[String, untyped]?
+      # @rbs (Array[Proc]? observers, Integer production_id, Hash[Symbol, runtime_value] production, Integer length,
+      #   Integer? pre_state, Integer? post_state, Integer next_state, runtime_value result,
+      #   LocationSpan? location) -> Hash[String, runtime_value]?
       def build_reduce_event_data(
         observers, production_id, production, length, pre_state, post_state, next_state, result, location
       )
@@ -1649,9 +1708,9 @@ module Ibex
         )
       end
 
-      # @rbs (Integer production_id, Hash[Symbol, untyped] production, Integer length,
-      #   Integer? pre_state, Integer? post_state, Integer next_state, untyped result,
-      #   LocationSpan? location) -> Hash[String, untyped]
+      # @rbs (Integer production_id, Hash[Symbol, runtime_value] production, Integer length,
+      #   Integer? pre_state, Integer? post_state, Integer next_state, runtime_value result,
+      #   LocationSpan? location) -> Hash[String, runtime_value]
       def runtime_reduce_data(production_id, production, length, pre_state, post_state, next_state, result, location)
         {
           "production_id" => production_id,
@@ -1665,15 +1724,15 @@ module Ibex
         }.freeze
       end
 
-      # @rbs (untyped result) -> [:accepted, untyped]
+      # @rbs (runtime_value result) -> [:accepted, runtime_value]
       def accept_reduction(result)
         result = finalize_cst(result)
         emit_accept_event(EventSanitizer.value(result), "semantic") if @runtime_observers
         [:accepted, result]
       end
 
-      # @rbs (Integer production_id, Hash[Symbol, untyped] production, Array[untyped] values,
-      #   Array[untyped] locations, LocationSpan? location) -> untyped
+      # @rbs (Integer production_id, Hash[Symbol, runtime_value] production, Array[runtime_value] values,
+      #   Array[runtime_value] locations, LocationSpan? location) -> runtime_value
       def reduction_value(production_id, production, values, locations, location) # rubocop:disable Metrics -- explicit hot path.
         previous_locations = @semantic_locations
         previous_names = @semantic_location_names
@@ -1721,8 +1780,8 @@ module Ibex
         @semantic_result_location = previous_result_location
       end
 
-      # @rbs (Hash[Symbol, untyped] production, Symbol action, Array[untyped] values,
-      #   Array[untyped] locations, LocationSpan? location) -> untyped
+      # @rbs (Hash[Symbol, runtime_value] production, Symbol action, Array[runtime_value] values,
+      #   Array[runtime_value] locations, LocationSpan? location) -> runtime_value
       def values_reduction_value(production, action, values, locations, location)
         previous_locations = @semantic_locations
         previous_names = @semantic_location_names
@@ -1737,41 +1796,37 @@ module Ibex
         @semantic_result_location = previous_result_location
       end
 
-      # @rbs (Integer production_id, Hash[Symbol, untyped] production, Array[untyped] values,
-      #   Array[untyped] locations, LocationSpan? location) -> untyped
+      # @rbs (Integer production_id, Hash[Symbol, runtime_value] production, Array[runtime_value] values,
+      #   Array[runtime_value] locations, LocationSpan? location) -> runtime_value
       def actionless_reduction_value(_production_id, _production, values, _locations, _location)
         values.first
       end
 
-      # @rbs (Hash[Symbol, untyped] production, untyped action) -> bool
+      # @rbs (Hash[Symbol, runtime_value] production, runtime_value action) -> bool
       def generated_location_action?(production, action)
-        parser_tables.fetch(:format_version) >= 2 &&
-          production[:location_action] == true &&
+        production[:location_action] == true &&
           generated_action_symbol?(action)
       end
 
-      # @rbs (Hash[Symbol, untyped] production, untyped action) -> bool
+      # @rbs (Hash[Symbol, runtime_value] production, runtime_value action) -> bool
       def generated_values_action?(production, action)
-        parser_tables.fetch(:format_version) >= 4 &&
-          production[:values_action] == true &&
+        production[:values_action] == true &&
           generated_action_symbol?(action)
       end
 
-      # @rbs (Hash[Symbol, untyped] production, untyped action) -> bool
+      # @rbs (Hash[Symbol, runtime_value] production, runtime_value action) -> bool
       def generated_positional_action?(production, action)
-        parser_tables.fetch(:format_version) >= 5 &&
-          production[:positional_action] == true &&
+        production[:positional_action] == true &&
           generated_action_symbol?(action)
       end
 
-      # @rbs (Hash[Symbol, untyped] production, untyped action) -> bool
+      # @rbs (Hash[Symbol, runtime_value] production, runtime_value action) -> bool
       def generated_composition_action?(production, action)
-        parser_tables.fetch(:format_version) >= 3 &&
-          production[:composition_action] == true &&
+        production[:composition_action] == true &&
           generated_location_action?(production, action)
       end
 
-      # @rbs (untyped action) -> bool
+      # @rbs (runtime_value action) -> bool
       def generated_action_symbol?(action)
         action.is_a?(Symbol) && action.name.match?(GENERATED_ACTION_NAME)
       end
@@ -1781,7 +1836,7 @@ module Ibex
         parser_tables[:cst].is_a?(Hash)
       end
 
-      # @rbs (Integer token_id, untyped value, untyped location, Symbol reason) -> void
+      # @rbs (Integer token_id, runtime_value value, runtime_value location, Symbol reason) -> void
       def capture_cst_error(token_id, value, location, reason)
         return unless cst_enabled?
         return if token_id == EOF_TOKEN
@@ -1791,7 +1846,7 @@ module Ibex
         }.freeze
       end
 
-      # @rbs (untyped value) -> untyped
+      # @rbs (runtime_value value) -> runtime_value
       def finalize_cst(value)
         return value unless cst_enabled?
 
@@ -1811,7 +1866,7 @@ module Ibex
         nil
       end
 
-      # @rbs (untyped location, Symbol key) -> untyped
+      # @rbs (runtime_value location, Symbol key) -> runtime_value
       def cst_location_value(location, key)
         if location.is_a?(Hash)
           value = location[key]
@@ -1825,20 +1880,28 @@ module Ibex
         nil
       end
 
-      # @rbs (Hash[Symbol, untyped] tables) -> void
-      def prepare_green_cst(tables)
+      # @rbs (Hash[Symbol, runtime_value] tables) -> void
+      def prepare_green_cst(tables) # rubocop:disable Metrics/MethodLength
         @syntax_root = nil
         @syntax_parse_memo = nil
-        @syntax_diagnostics.clear
-        @green_pending_skipped.clear
         config = tables[:cst]
         unless config.is_a?(Hash)
           @green_builder = nil
           @green_kinds = nil
           @green_cache = nil
+          @syntax_diagnostics = EMPTY_LOCATIONS
+          @green_pending_skipped = EMPTY_GREEN_TRIVIA
+          @green_token_states = EMPTY_LOCATIONS
+          @green_memo_stack = EMPTY_LOCATIONS
           return
         end
 
+        @syntax_diagnostics = [] if @syntax_diagnostics.frozen?
+        @green_pending_skipped = [] if @green_pending_skipped.frozen?
+        @green_token_states = [] if @green_token_states.frozen?
+        @green_memo_stack = [] if @green_memo_stack.frozen?
+        @syntax_diagnostics.clear
+        @green_pending_skipped.clear
         kinds = tables[:cst_kinds]
         kinds = CST::Kind.new(config.fetch(:kinds), slots: config.fetch(:slots)) unless kinds.is_a?(CST::Kind)
         cache = @green_cache_override || CST::NodeCache.new
@@ -1853,13 +1916,13 @@ module Ibex
         @green_builder = CST::GreenBuilder.new(kinds: kinds, cache: cache)
       end
 
-      # @rbs (Hash[Symbol, untyped] tables) -> void
+      # @rbs (Hash[Symbol, runtime_value] tables) -> void
       def reset_cst_results(tables)
         prepare_green_cst(tables)
       end
 
       # rubocop:disable Metrics/PerceivedComplexity -- generated locations have a deliberate allocation-free path.
-      # @rbs (Integer token_id, untyped value, untyped location, Integer from_state) -> void
+      # @rbs (Integer token_id, runtime_value value, runtime_value location, Integer from_state) -> void
       def shift_green_token(token_id, value, location, from_state)
         builder = @green_builder
         kinds = @green_kinds
@@ -1889,7 +1952,7 @@ module Ibex
       # rubocop:enable Metrics/PerceivedComplexity
 
       # @rbs (CST::GreenBuilder builder, CST::Kind kinds, Integer token_id, Integer from_state,
-      #   Array[CST::GreenTrivia] trailing, Array[CST::GreenTrivia] location_leading, untyped repair,
+      #   Array[CST::GreenTrivia] trailing, Array[CST::GreenTrivia] location_leading, runtime_value repair,
       #   String token_text, Symbol lexer_state) -> void
       def commit_green_token_shift(
         builder, kinds, token_id, from_state, trailing, location_leading, repair, token_text, lexer_state
@@ -1918,7 +1981,7 @@ module Ibex
         @green_reused_right_edge = false
       end
 
-      # @rbs (Integer production_id, Hash[Symbol, untyped] production, Integer length, Integer left_state) -> void
+      # @rbs (Integer production_id, Hash[Symbol, runtime_value] production, Integer length, Integer left_state) -> void
       def reduce_green(production_id, production, length, left_state)
         builder = @green_builder
         return unless builder
@@ -1936,7 +1999,7 @@ module Ibex
         @green_memo_stack << entry
       end
 
-      # @rbs (untyped value, untyped location) -> String
+      # @rbs (runtime_value value, runtime_value location) -> String
       def green_token_text(value, location)
         text = if location.is_a?(Hash) && location.key?(:ibex_lexer_start_state)
                  location[:ibex_cst_text]
@@ -1949,7 +2012,7 @@ module Ibex
         ""
       end
 
-      # @rbs (untyped location, Symbol key) -> Array[CST::GreenTrivia]
+      # @rbs (runtime_value location, Symbol key) -> Array[CST::GreenTrivia]
       def green_location_trivia(location, key)
         trivia = if location.is_a?(Hash) && location.key?(:ibex_lexer_start_state)
                    location[key]
@@ -1963,7 +2026,7 @@ module Ibex
         trivia.grep(CST::GreenTrivia)
       end
 
-      # @rbs (untyped value) -> untyped
+      # @rbs (runtime_value value) -> runtime_value
       def finalize_red_green_cst(value)
         builder = @green_builder || raise(ParseError, "(cst):1:1: Green builder is unavailable")
         kinds = @green_kinds || raise(ParseError, "(cst):1:1: kind metadata is unavailable")
@@ -2065,7 +2128,7 @@ module Ibex
         )
       end
 
-      # @rbs (untyped value) -> CST::ParseResult
+      # @rbs (runtime_value value) -> CST::ParseResult
       def syntax_parse_result(value)
         root = @syntax_root
         raise ParseError, "(cst):1:1: parse_with_syntax requires a format-v6 CST parser" unless root
@@ -2095,7 +2158,7 @@ module Ibex
         )
       end
 
-      # @rbs (untyped location) -> Symbol
+      # @rbs (runtime_value location) -> Symbol
       def green_lexer_state(location)
         state = if location.is_a?(Hash) && location.key?(:ibex_lexer_start_state)
                   location[:ibex_lexer_start_state]
@@ -2105,7 +2168,7 @@ module Ibex
         state ? state.to_sym : :INITIAL
       end
 
-      # @rbs (CST::NodeCache cache) { () -> untyped } -> untyped
+      # @rbs (CST::NodeCache cache) { () -> runtime_value } -> runtime_value
       def with_syntax_only(cache)
         previous_mode = @syntax_only
         previous_cache = @green_cache_override
@@ -2118,7 +2181,7 @@ module Ibex
         @green_cache_override = previous_cache
       end
 
-      # @rbs (untyped source, CST::NodeCache cache) -> CST::SyntaxResult
+      # @rbs (runtime_value source, CST::NodeCache cache) -> CST::SyntaxResult
       def parse_syntax_token_source(source, cache)
         with_syntax_only(cache) do
           value = drive_parser(source)
@@ -2152,7 +2215,7 @@ module Ibex
         @incremental_reused_descendants += subtree.green.descendant_count
       end
 
-      # @rbs (Symbol type, Hash[untyped, untyped] data) -> void
+      # @rbs (Symbol type, Hash[runtime_value, runtime_value] data) -> void
       def emit_incremental_event(type, data)
         emit_runtime_event(type, data) if @runtime_observers
       end
@@ -2177,7 +2240,7 @@ module Ibex
         )
       end
 
-      # @rbs (?report: bool) -> untyped
+      # @rbs (?report: bool) -> runtime_value
       def recover(report: true)
         @runtime_fast_path = false
         materialize_lookahead_token_display! unless @lookahead.equal?(NO_LOOKAHEAD)
@@ -2187,7 +2250,7 @@ module Ibex
         begin_recovery(report)
       end
 
-      # @rbs () -> untyped
+      # @rbs () -> runtime_value
       def continue_recovery
         return reject_recovery_eof if @lookahead == EOF_TOKEN
 
@@ -2214,7 +2277,7 @@ module Ibex
         [:done, cst_enabled? ? failed_cst : nil]
       end
 
-      # @rbs (String token_display) -> Hash[String, untyped]
+      # @rbs (String token_display) -> Hash[String, runtime_value]
       def runtime_discard_data(token_display)
         runtime_token_data(
           token_id: @lookahead,
@@ -2225,7 +2288,7 @@ module Ibex
         ).merge("reason" => "recovery").freeze
       end
 
-      # @rbs (bool report) -> untyped
+      # @rbs (bool report) -> runtime_value
       def begin_recovery(report)
         consume_recovery_attempt!
         repair = report ? selected_repair : nil
@@ -2240,7 +2303,7 @@ module Ibex
         fallback_recovery(context, token_data, recovery_observers)
       end
 
-      # @rbs (bool report) -> Hash[Symbol, untyped]
+      # @rbs (bool report) -> Hash[Symbol, runtime_value]
       def recovery_context(report)
         {
           token_id: @lookahead,
@@ -2253,7 +2316,7 @@ module Ibex
         }
       end
 
-      # @rbs (Hash[Symbol, untyped] context) -> [Hash[String, untyped]?, Array[Proc]?]
+      # @rbs (Hash[Symbol, runtime_value] context) -> [Hash[String, runtime_value]?, Array[Proc]?]
       def publish_error_context(context)
         error_observers = runtime_observer_snapshot if @runtime_observers
         if error_observers
@@ -2267,7 +2330,7 @@ module Ibex
         [token_data, (runtime_observer_snapshot if @runtime_observers)]
       end
 
-      # @rbs (Hash[Symbol, untyped] context, untyped repair) -> void
+      # @rbs (Hash[Symbol, runtime_value] context, runtime_value repair) -> void
       def notify_error_handler(context, repair)
         @repair_selected = repair.is_a?(RepairPlan)
         begin
@@ -2284,8 +2347,8 @@ module Ibex
         CONTINUE_OUTCOME
       end
 
-      # @rbs (Hash[Symbol, untyped] context, Hash[String, untyped]? token_data,
-      #   Array[Proc]? recovery_observers) -> untyped
+      # @rbs (Hash[Symbol, runtime_value] context, Hash[String, runtime_value]? token_data,
+      #   Array[Proc]? recovery_observers) -> runtime_value
       # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       # Green restoration mirrors the existing state/value/location transactional fallback.
       def fallback_recovery(context, token_data, recovery_observers)
@@ -2316,8 +2379,8 @@ module Ibex
       end
       # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-      # @rbs (untyped token_id, untyped token_display, untyped value, untyped location,
-      #   Integer state) -> Hash[String, untyped]
+      # @rbs (runtime_value token_id, runtime_value token_display, runtime_value value, runtime_value location,
+      #   Integer state) -> Hash[String, runtime_value]
       def runtime_original_token_data(token_id, token_display, value, location, state)
         runtime_token_data(
           token_id: token_id,
@@ -2328,8 +2391,8 @@ module Ibex
         )
       end
 
-      # @rbs (untyped token_id, untyped token_display, untyped value, untyped location,
-      #   Integer original_state, Hash[String, untyped]? token_data,
+      # @rbs (runtime_value token_id, runtime_value token_display, runtime_value value, runtime_value location,
+      #   Integer original_state, Hash[String, runtime_value]? token_data,
       #   Array[Proc]? observers) -> [:done, nil]
       def reject_without_recovery(token_id, token_display, value, location, original_state, token_data, observers)
         if observers
@@ -2345,8 +2408,8 @@ module Ibex
         [:done, cst_enabled? ? failed_cst : nil]
       end
 
-      # @rbs (untyped token_id, untyped token_display, untyped value, untyped location,
-      #   Integer original_state, Array[untyped] value_stack, Hash[String, untyped]? token_data,
+      # @rbs (runtime_value token_id, runtime_value token_display, runtime_value value, runtime_value location,
+      #   Integer original_state, Array[runtime_value] value_stack, Hash[String, runtime_value]? token_data,
       #   String reason, Array[Proc]? observers) -> [:continue]
       def finish_recovery(
         token_id, token_display, value, location, original_state, value_stack, token_data, reason, observers
@@ -2372,8 +2435,8 @@ module Ibex
         CONTINUE_OUTCOME
       end
 
-      # @rbs (token_id: untyped, token_display: untyped, value: untyped,
-      #   location: untyped, state: Integer) -> Hash[String, untyped]
+      # @rbs (token_id: runtime_value, token_display: runtime_value, value: runtime_value,
+      #   location: runtime_value, state: Integer) -> Hash[String, runtime_value]
       def runtime_token_data(token_id:, token_display:, value:, location:, state:)
         if token_id.equal?(NO_LOOKAHEAD)
           return {
@@ -2394,7 +2457,7 @@ module Ibex
         }.freeze
       end
 
-      # @rbs () -> Hash[String, untyped]
+      # @rbs () -> Hash[String, runtime_value]
       def runtime_current_token_data
         runtime_token_data(
           token_id: @lookahead,
@@ -2405,7 +2468,7 @@ module Ibex
         )
       end
 
-      # @rbs (untyped result_summary, String reason) -> void
+      # @rbs (runtime_value result_summary, String reason) -> void
       def emit_accept_event(result_summary, reason)
         emit_runtime_event(
           :accept,
@@ -2413,7 +2476,7 @@ module Ibex
         )
       end
 
-      # @rbs (String reason, Hash[String, untyped] token_data, ?observers: Array[Proc]?) -> void
+      # @rbs (String reason, Hash[String, runtime_value] token_data, ?observers: Array[Proc]?) -> void
       def emit_reject_event(reason, token_data, observers: runtime_observer_snapshot)
         emit_runtime_event(
           :reject,
@@ -2434,10 +2497,13 @@ module Ibex
             @state_stack << action.fetch(1)
             push_location(@lookahead_location)
             @value_stack << nil
-            @green_builder&.absorb_into_error(popped)
-            empty = [] #: Array[CST::ParseMemo::Entry]
-            children = popped.zero? ? empty : @green_memo_stack.pop(popped)
-            @green_memo_stack << CST::ParseMemo::Entry.new(@state_stack.last, children: children)
+            builder = @green_builder
+            if builder
+              builder.absorb_into_error(popped)
+              empty = [] #: Array[CST::ParseMemo::Entry]
+              children = popped.zero? ? empty : @green_memo_stack.pop(popped)
+              @green_memo_stack << CST::ParseMemo::Entry.new(@state_stack.last, children: children)
+            end
             return true
           end
           return false if @state_stack.length == 1
@@ -2480,8 +2546,21 @@ module Ibex
         return unless policy
 
         tokens, complete = repair_search_tokens(policy)
-        RepairSearch.new(parser_tables, policy, tokens, complete: complete).search(@state_stack)
+        result = RepairSearch.new(parser_tables, policy, tokens, complete: complete).search_result(@state_stack)
+        @repair_search_results << result
+        return result.plan if result.selected?
+        return RepairSearch::NEED_INPUT if result.status == :need_input
+
+        nil
+      end
+
+      # @rbs skip
+      # steep:ignore Ruby::UndeclaredMethodDefinition
+      # steep:ignore:start
+      def syntax_repair_search_results
+        @repair_search_results.dup.freeze
       end
+      # steep:ignore:end
 
       # @rbs (RepairPolicy policy) -> [Array[RepairInput], bool]
       def repair_search_tokens(policy)
@@ -2520,6 +2599,16 @@ module Ibex
         )
       end
 
+      # Snapshot the original buffered prefix before a selected repair is
+      # replayed. Syntax tooling consumes locations and token identities only.
+      # @rbs skip
+      # steep:ignore Ruby::UndeclaredMethodDefinition
+      # steep:ignore:start
+      def syntax_repair_inputs
+        ([current_repair_input] + (@repair_input_buffer || [])).freeze
+      end
+      # steep:ignore:end
+
       # @rbs (Array[RepairInput] source, Array[RepairEdit] edits) -> Array[RepairInput]
       def replay_repair_edits(source, edits)
         by_position = edits.group_by(&:position)
@@ -2578,13 +2667,13 @@ module Ibex
         @runtime_lookahead_token_display = nil
       end
 
-      # @rbs (RepairEdit edit, value: untyped, location: untyped) -> RepairInput
+      # @rbs (RepairEdit edit, value: runtime_value, location: runtime_value) -> RepairInput
       def synthetic_repair_input(edit, value:, location:)
         location = cst_repair_location(location, edit.kind) if cst_enabled?
         RepairInput.new(token_id: edit.token_id, token_name: edit.token_name, value: value, location: location)
       end
 
-      # @rbs (untyped location, Symbol kind) -> Hash[Symbol, untyped]
+      # @rbs (runtime_value location, Symbol kind) -> Hash[Symbol, runtime_value]
       def cst_repair_location(location, kind)
         return location.merge(ibex_repair: kind).freeze if location.is_a?(Hash)
 
@@ -2626,7 +2715,7 @@ module Ibex
       def read_compatible_lookahead
         token = read_external_token
         refresh_runtime_fast_path_after_user_code!
-        if token.is_a?(CST::ReusableSubtree)
+        if defined?(CST::ReusableSubtree) && token.is_a?(CST::ReusableSubtree)
           push_reusable_green_subtree(token)
           return
         end
@@ -2665,7 +2754,7 @@ module Ibex
         @runtime_lookahead_token_display = token_to_str(@lookahead)
       end
 
-      # @rbs (untyped external_token, untyped value, untyped location) -> RepairInput
+      # @rbs (runtime_value external_token, runtime_value value, runtime_value location) -> RepairInput
       def repair_input(external_token, value, location)
         token_id = parser_tables.fetch(:tokens)[external_token]
         if token_id
@@ -2682,7 +2771,7 @@ module Ibex
         )
       end
 
-      # @rbs (untyped token) -> RepairInput
+      # @rbs (runtime_value token) -> RepairInput
       def repair_input_from_external(token)
         if token.nil? || token == false
           return RepairInput.new(token_id: EOF_TOKEN, token_name: token_to_str(EOF_TOKEN), value: nil, location: nil)
@@ -2723,7 +2812,7 @@ module Ibex
         trace("read #{input.token_name}") if @yydebug
       end
 
-      # @rbs () -> untyped
+      # @rbs () -> runtime_value
       def read_external_token
         source = @source
         return next_token unless source
@@ -2734,7 +2823,7 @@ module Ibex
         false
       end
 
-      # @rbs (untyped external_token) -> Integer
+      # @rbs (runtime_value external_token) -> Integer
       def internal_token_id(external_token)
         token_id = parser_tables.fetch(:tokens)[external_token]
         return token_id if token_id
@@ -2743,7 +2832,7 @@ module Ibex
         @unknown_token_id = -external_token.object_id.abs
       end
 
-      # @rbs () -> Hash[Symbol, untyped]
+      # @rbs () -> Hash[Symbol, runtime_value]
       def parser_tables
         tables = @runtime_parser_tables
         return tables if tables
@@ -2751,19 +2840,19 @@ module Ibex
         load_parser_tables
       end
 
-      # @rbs () -> Hash[Symbol, untyped]
+      # @rbs () -> Hash[Symbol, runtime_value]
       def load_parser_tables
         self.class.__send__(:parser_tables)
       rescue NoMethodError
         raise ParseError, "(tables):1:1: #{self.class} must define .parser_tables"
       end
 
-      # @rbs (untyped action) -> bool
+      # @rbs (runtime_value action) -> bool
       def error_action?(action)
         action.nil? || action.first == :error
       end
 
-      # @rbs (untyped configured) -> [String?, String?]
+      # @rbs (runtime_value configured) -> [String?, String?]
       def configured_error_message(configured)
         return [nil, configured] unless configured.is_a?(Hash)
 
@@ -2807,17 +2896,17 @@ module Ibex
         previous.last
       end
 
-      # @rbs (Integer state) -> untyped
+      # @rbs (Integer state) -> runtime_value
       def default_action(state)
         parser_tables.fetch(:default_actions, EMPTY_ROW)[state]
       end
 
-      # @rbs (Hash[Symbol, untyped] tables) -> bool
+      # @rbs (Hash[Symbol, runtime_value] tables) -> bool
       def track_locations?(tables)
         tables.fetch(:uses_locations, false) || !@runtime_observers.nil?
       end
 
-      # @rbs (Hash[Symbol, untyped] tables) -> void
+      # @rbs (Hash[Symbol, runtime_value] tables) -> void
       def initialize_runtime_fast_path(tables)
         @location_stack = track_locations?(tables) ? [] : nil
         @runtime_fast_path = runtime_fast_path_eligible?(tables)
@@ -2829,11 +2918,29 @@ module Ibex
 
       # @rbs (?Class? singleton) -> void
       def install_runtime_fast_path_tracker!(singleton = nil)
-        singleton ||= Object.instance_method(:singleton_class).bind_call(self)
-        Module.instance_method(:prepend).bind_call(singleton, FastPathMutationTracker)
+        if singleton
+          prepend_lookup = Module.instance_method(:prepend)
+        elsif RUBY_ENGINE == "ruby"
+          thread = ::Thread.current
+          singleton_lookup = thread.thread_variable_get(:__ibex_runtime_parser_singleton_class_lookup)
+          unless singleton_lookup.is_a?(UnboundMethod)
+            singleton_lookup = Object.instance_method(:singleton_class)
+            thread.thread_variable_set(:__ibex_runtime_parser_singleton_class_lookup, singleton_lookup)
+          end
+          singleton = singleton_lookup.bind_call(self)
+          prepend_lookup = thread.thread_variable_get(:__ibex_runtime_parser_module_prepend_lookup)
+          unless prepend_lookup.is_a?(UnboundMethod)
+            prepend_lookup = Module.instance_method(:prepend)
+            thread.thread_variable_set(:__ibex_runtime_parser_module_prepend_lookup, prepend_lookup)
+          end
+        else
+          singleton = Object.instance_method(:singleton_class).bind_call(self)
+          prepend_lookup = Module.instance_method(:prepend)
+        end
+        prepend_lookup.bind_call(singleton, FastPathMutationTracker)
         @runtime_fast_path_tracker_installed = true
         @runtime_fast_path_hooks_mutated = false
-        @runtime_fast_path_singleton_ancestors = singleton.ancestors.freeze
+        @runtime_fast_path_singleton_ancestors = nil
       rescue FrozenError, TypeError
         @runtime_fast_path = false
       end
@@ -2844,7 +2951,9 @@ module Ibex
         return if parser_class.instance_variable_get(:@__ibex_fast_path_class_tracker_installed) == true
 
         singleton = parser_class.singleton_class
-        singleton.prepend(FastPathClassMutationTracker)
+        # Keep the same module object out of both a class and its superclass
+        # callback chains; TruffleRuby can re-enter `super` in that topology.
+        singleton.prepend(FastPathClassMutationTracker.dup)
         parser_class.instance_variable_set(:@__ibex_fast_path_hook_version, 0)
         parser_class.instance_variable_set(:@__ibex_fast_path_class_tracker_installed, true)
       rescue FrozenError, TypeError
@@ -2853,7 +2962,7 @@ module Ibex
 
       # The generic driver remains authoritative whenever a public runtime
       # extension can observe a committed shift or reduction.
-      # @rbs (Hash[Symbol, untyped] tables) -> bool
+      # @rbs (Hash[Symbol, runtime_value] tables) -> bool
       def runtime_fast_path_eligible?(tables)
         !@syntax_only &&
           !@yydebug &&
@@ -2866,11 +2975,20 @@ module Ibex
       end
 
       # @rbs () -> bool
-      def runtime_fast_path_hooks_eligible?
+      def runtime_fast_path_hooks_eligible? # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         cached = cached_runtime_fast_path_hooks_eligibility
         return cached unless cached.nil?
 
         lookup = Object.instance_method(:method)
+        if RUBY_ENGINE == "ruby"
+          thread = ::Thread.current
+          cached_lookup = thread.thread_variable_get(:__ibex_runtime_parser_object_method_lookup)
+          if cached_lookup.is_a?(UnboundMethod)
+            lookup = cached_lookup
+          else
+            thread.thread_variable_set(:__ibex_runtime_parser_object_method_lookup, lookup)
+          end
+        end
         hooks_unchanged =
           runtime_method_unchanged?(lookup, :on_shift, :__ibex_fast_path_on_shift) &&
           runtime_method_unchanged?(lookup, :on_shift_location, :__ibex_fast_path_on_shift_location) &&
@@ -2970,7 +3088,7 @@ module Ibex
       # Keep allocation out of the ordinary two-element lexer path. If a
       # location first appears after values have already shifted, backfill the
       # parallel prefix with nil exactly once.
-      # @rbs (untyped location) -> void
+      # @rbs (runtime_value location) -> void
       def push_location(location)
         stack = @location_stack
         if stack
@@ -2982,7 +3100,7 @@ module Ibex
         end
       end
 
-      # @rbs (Integer length) -> Array[untyped]
+      # @rbs (Integer length) -> Array[runtime_value]
       def pop_reduction_locations(length)
         stack = @location_stack
         return Array.new(length) unless stack
@@ -2992,7 +3110,7 @@ module Ibex
         locations
       end
 
-      # @rbs (untyped table, Integer row, Integer column) -> untyped
+      # @rbs (runtime_value table, Integer row, Integer column) -> runtime_value
       def table_lookup(table, row, column)
         return table.lookup(row, column) if table.respond_to?(:lookup)
 
@@ -3004,7 +3122,7 @@ module Ibex
         @yydebug_output.puts("ibex: #{message}") if @yydebug
       end
 
-      # @rbs (untyped value, Integer symbol_id) -> String
+      # @rbs (runtime_value value, Integer symbol_id) -> String
       def trace_value_suffix(value, symbol_id)
         return "" unless @yydebug