ibex-runtime 0.2.0

data/lib/ibex/runtime/parser_sync_recovery.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Ibex
+  module Runtime
+    # Panic-mode synchronization used only when yacc's explicit `error` token
+    # cannot be shifted. Included by Parser to share its table and event paths.
+    module ParserSyncRecovery
+      ERROR_ACTION = [:error].freeze #: [:error]
+
+      private_constant :ERROR_ACTION
+
+      # @rbs!
+      #   private def parser_tables: () -> Hash[Symbol, untyped]
+      #   private def table_lookup: (untyped, Integer, Integer) -> untyped
+      #   private def default_action: (Integer) -> untyped
+      #   private def token_to_str: (untyped) -> String
+      #   private def trace: (String) -> void
+      #   private def continue_recovery: () -> untyped
+      #   private def reject_recovery_eof: () -> [:done, nil]
+      #   private def finish_recovery: (untyped, untyped, untyped, untyped, Integer, Array[untyped],
+      #     Hash[String, untyped]?, String, Array[Proc]?) -> [:continue]
+
+      private
+
+      # @rbs () -> bool
+      def sync_recovery_configured?
+        tokens = parser_tables[:recovery_sync_tokens]
+        tokens.is_a?(Array) && !tokens.empty?
+      end
+
+      # @rbs () -> bool
+      def sync_recovery_active?
+        !@sync_recovery_context.nil?
+      end
+
+      # @rbs (Hash[Symbol, untyped] context, Hash[String, untyped]? token_data,
+      #   Array[Proc]? observers) -> untyped
+      def begin_sync_recovery(context, token_data, observers)
+        @sync_recovery_context = context
+        @sync_recovery_token_data = token_data
+        @sync_recovery_observers = observers
+        continue_sync_recovery
+      end
+
+      # @rbs () -> untyped
+      def continue_sync_recovery
+        return reject_sync_recovery_eof if @lookahead == Parser::EOF_TOKEN
+        return finish_sync_recovery if sync_token?(@lookahead) && synchronize_for_current_token
+
+        continue_recovery
+      end
+
+      # @rbs (untyped token_id) -> bool
+      def sync_token?(token_id)
+        tokens = parser_tables[:recovery_sync_tokens]
+        tokens.is_a?(Array) && tokens.include?(token_id)
+      end
+
+      # @rbs () -> bool
+      def synchronize_for_current_token
+        loop do
+          action = sync_action(@state_stack.last, @lookahead)
+          return true unless action.nil? || action.first == :error
+          return false if @state_stack.length == 1
+
+          trace("recover: pop state #{@state_stack.last} for sync token") if @yydebug
+          @state_stack.pop
+          @value_stack.pop
+          @location_stack&.pop
+        end
+      end
+
+      # @rbs (Integer state, Integer token_id) -> untyped
+      def sync_action(state, token_id)
+        return ERROR_ACTION unless parser_tables.fetch(:token_names).key?(token_id)
+
+        table_lookup(parser_tables.fetch(:actions), state, token_id) || default_action(state) || ERROR_ACTION
+      end
+
+      # @rbs () -> [:continue]
+      def finish_sync_recovery
+        context = @sync_recovery_context || raise(ParseError, "(recovery):1:1: missing synchronization context")
+        token_data = @sync_recovery_token_data
+        observers = @sync_recovery_observers
+        clear_sync_recovery
+        @recovery_shifts = Parser::RECOVERY_SHIFTS
+        trace("recover: synchronized before #{token_to_str(@lookahead)} in state #{@state_stack.last}") if @yydebug
+        finish_recovery(
+          context[:token_id], context[:token_display], context[:value], context[:location], context[:state],
+          context.fetch(:value_stack), token_data, context.fetch(:reason), observers
+        )
+      end
+
+      # @rbs () -> [:done, nil]
+      def reject_sync_recovery_eof
+        clear_sync_recovery
+        reject_recovery_eof
+      end
+
+      # @rbs () -> void
+      def clear_sync_recovery
+        @sync_recovery_context = nil
+        @sync_recovery_token_data = nil
+        @sync_recovery_observers = nil
+      end
+    end
+  end
+end

data/lib/ibex/runtime/repair.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Ibex
+  module Runtime
+    # Explicit bounded cost and search policy for automatic token repair.
+    class RepairPolicy
+      attr_reader :insert_cost #: Integer
+      attr_reader :delete_cost #: Integer
+      attr_reader :replace_cost #: Integer
+      attr_reader :max_cost #: Integer
+      attr_reader :max_configurations #: Integer
+      attr_reader :max_lookahead #: Integer
+      attr_reader :success_shifts #: Integer
+      attr_reader :max_stack #: Integer
+
+      # @rbs (?insert_cost: Integer, ?delete_cost: Integer, ?replace_cost: Integer, ?max_cost: Integer,
+      #   ?max_configurations: Integer, ?max_lookahead: Integer, ?success_shifts: Integer,
+      #   ?max_stack: Integer) -> void
+      def initialize(insert_cost: 1, delete_cost: 1, replace_cost: 2, max_cost: 3, max_configurations: 5_000,
+                     max_lookahead: 8, success_shifts: 3, max_stack: 256)
+        values = {
+          insert_cost: insert_cost,
+          delete_cost: delete_cost,
+          replace_cost: replace_cost,
+          max_cost: max_cost,
+          max_configurations: max_configurations,
+          max_lookahead: max_lookahead,
+          success_shifts: success_shifts,
+          max_stack: max_stack
+        }
+        invalid = values.find { |_name, value| !value.is_a?(Integer) || !value.positive? }
+        raise ArgumentError, "#{invalid.first} must be a positive integer" if invalid
+        raise ArgumentError, "success_shifts must not exceed max_lookahead" if success_shifts > max_lookahead
+
+        values.each { |name, value| instance_variable_set(:"@#{name}", value) }
+        freeze
+      end
+    end
+
+    # One immutable insertion, deletion, or replacement.
+    class RepairEdit
+      KINDS = %i[insert delete replace].freeze #: Array[Symbol]
+
+      attr_reader :kind #: Symbol
+      attr_reader :position #: Integer
+      attr_reader :token_id #: Integer
+      attr_reader :token_name #: String
+      attr_reader :cost #: Integer
+
+      # @rbs (kind: Symbol, position: Integer, token_id: Integer, token_name: String, cost: Integer) -> void
+      def initialize(kind:, position:, token_id:, token_name:, cost:)
+        raise ArgumentError, "unknown repair edit #{kind.inspect}" unless KINDS.include?(kind)
+        raise ArgumentError, "repair edit position must be nonnegative" if position.negative?
+        raise ArgumentError, "repair edit cost must be positive" unless cost.positive?
+
+        @kind = kind
+        @position = position
+        @token_id = token_id
+        @token_name = token_name.dup.freeze
+        @cost = cost
+        freeze
+      end
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def to_h
+        { kind: @kind, position: @position, token_id: @token_id, token_name: @token_name, cost: @cost }.freeze
+      end
+    end
+
+    # Deterministically selected repair.
+    class RepairPlan
+      attr_reader :edits #: Array[RepairEdit]
+      attr_reader :cost #: Integer
+      attr_reader :configurations #: Integer
+
+      # @rbs (edits: Array[RepairEdit], configurations: Integer) -> void
+      def initialize(edits:, configurations:)
+        raise ArgumentError, "repair plan must contain an edit" if edits.empty?
+
+        @edits = edits.dup.freeze
+        @cost = @edits.sum(&:cost)
+        @configurations = configurations
+        freeze
+      end
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def to_h
+        { cost: @cost, configurations: @configurations, edits: @edits.map(&:to_h).freeze }.freeze
+      end
+    end
+
+    # Internal normalized input record retained while repair looks ahead.
+    class RepairInput
+      attr_reader :token_id #: Integer
+      attr_reader :token_name #: String
+      attr_reader :value #: untyped
+      attr_reader :location #: untyped
+
+      # @rbs (token_id: Integer, token_name: String, value: untyped, location: untyped) -> void
+      def initialize(token_id:, token_name:, value:, location:)
+        @token_id = token_id
+        @token_name = token_name.dup.freeze
+        @value = value
+        @location = location
+        freeze
+      end
+
+      # @rbs () -> bool
+      def eof? = @token_id.zero?
+    end
+
+    # Internal result of simulating reductions followed by one table action.
+    class RepairAdvance
+      attr_reader :status #: :shift | :accept
+      attr_reader :stack #: Array[Integer]
+
+      # @rbs (status: :shift | :accept, stack: Array[Integer]) -> void
+      def initialize(status:, stack:)
+        @status = status
+        @stack = stack
+        freeze
+      end
+    end
+  end
+end

data/lib/ibex/runtime/repair_priority_queue.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Ibex
+  module Runtime
+    # Minimal binary heap ordered by an immutable Array priority.
+    class RepairPriorityQueue
+      # @rbs @entries: Array[[Array[untyped], untyped]]
+
+      # @rbs () -> void
+      def initialize
+        @entries = []
+      end
+
+      # @rbs () -> bool
+      def empty? = @entries.empty?
+
+      # @rbs (Array[untyped] priority, untyped value) -> void
+      def push(priority, value)
+        entry = [priority, value] #: [Array[untyped], untyped]
+        @entries << entry
+        index = @entries.length - 1
+        while index.positive?
+          parent = (index - 1) / 2
+          break if compare(@entries[parent], entry) <= 0
+
+          @entries[index] = @entries[parent]
+          index = parent
+        end
+        @entries[index] = entry
+      end
+
+      # @rbs () -> [Array[untyped], untyped]?
+      def pop
+        first = @entries.first
+        tail = @entries.pop
+        return first if @entries.empty? || !first || !tail
+
+        index = 0
+        while (child = (index * 2) + 1) < @entries.length
+          right = child + 1
+          child = right if right < @entries.length && compare(@entries[right], @entries[child]).negative?
+          break if compare(tail, @entries[child]) <= 0
+
+          @entries[index] = @entries[child]
+          index = child
+        end
+        @entries[index] = tail
+        first
+      end
+
+      private
+
+      # @rbs ([Array[untyped], untyped] left, [Array[untyped], untyped] right) -> Integer
+      def compare(left, right)
+        (left.fetch(0) <=> right.fetch(0)) || 0
+      end
+    end
+  end
+end

data/lib/ibex/runtime/repair_search.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require_relative "repair_priority_queue" unless defined?(Ibex::Runtime::RepairPriorityQueue)
+
+module Ibex
+  module Runtime
+    # Bounded Dijkstra search over LR state stacks. Semantic actions never run.
+    # rubocop:disable Metrics/ClassLength -- queue policy and LR transitions form one bounded search invariant.
+    class RepairSearch
+      NEED_INPUT = Object.new.freeze #: Object
+      LIMIT = Object.new.freeze #: Object
+      Configuration = Struct.new(:stack, :input_index, :shifts, :cost, :edits, :goal, keyword_init: true)
+
+      # @rbs @tables: Hash[Symbol, untyped]
+      # @rbs @policy: RepairPolicy
+      # @rbs @tokens: Array[RepairInput]
+      # @rbs @complete: bool
+      # @rbs @configurations: Integer
+      # @rbs @heap: RepairPriorityQueue
+      # @rbs @best: Hash[Array[untyped], Array[untyped]]
+      # @rbs @candidate_ids: Array[Integer]
+
+      # @rbs (Hash[Symbol, untyped] tables, RepairPolicy policy, Array[RepairInput] tokens,
+      #   complete: bool) -> void
+      def initialize(tables, policy, tokens, complete:)
+        @tables = tables
+        @policy = policy
+        @tokens = tokens
+        @complete = complete
+        @configurations = 0
+        @heap = RepairPriorityQueue.new
+        @best = {}
+        reserved = [Parser::EOF_TOKEN, Parser::ERROR_TOKEN]
+        @candidate_ids = tables.fetch(:token_names).keys.reject { |id| reserved.include?(id) }.sort.freeze
+      end
+
+      # @rbs (Array[Integer] state_stack) -> (RepairPlan | Object | nil)
+      def search(state_stack)
+        empty_edits = [] #: Array[RepairEdit]
+        push(
+          Configuration.new(
+            stack: state_stack.dup.freeze,
+            input_index: 0,
+            shifts: 0,
+            cost: 0,
+            edits: empty_edits.freeze,
+            goal: false
+          )
+        )
+        needs_input = false
+        until @heap.empty?
+          configuration = pop
+          return nil if configuration.equal?(LIMIT)
+          next unless configuration.is_a?(Configuration)
+
+          result = visit(configuration)
+          return nil if result.equal?(LIMIT)
+          return result if result.is_a?(RepairPlan)
+
+          needs_input = true if result.equal?(NEED_INPUT)
+        end
+        needs_input ? NEED_INPUT : nil
+      end
+
+      private
+
+      # @rbs (Configuration configuration) -> (RepairPlan | Object | nil)
+      def visit(configuration)
+        @configurations += 1
+        return LIMIT if @configurations > @policy.max_configurations
+        return plan(configuration.edits) if configuration.goal
+        if configuration.input_index >= @tokens.length
+          return @complete ? nil : NEED_INPUT
+        end
+
+        expand(configuration)
+      end
+
+      # @rbs (Configuration configuration) -> (RepairPlan | Object | nil)
+      def expand(configuration)
+        current = @tokens.fetch(configuration.input_index)
+        unchanged = advance(configuration.stack, current.token_id)
+        return LIMIT if unchanged.equal?(LIMIT)
+
+        if unchanged.is_a?(RepairAdvance)
+          if unchanged.status == :accept && !configuration.edits.empty?
+            push(configuration_with(configuration, stack: unchanged.stack, goal: true))
+            return
+          end
+
+          if unchanged.status == :shift
+            shifts = configuration.shifts + 1
+            if shifts >= @policy.success_shifts && !configuration.edits.empty?
+              push(configuration_with(configuration, stack: unchanged.stack, shifts: shifts, goal: true))
+              return
+            end
+
+            push(
+              configuration_with(
+                configuration, stack: unchanged.stack, input_index: configuration.input_index + 1, shifts: shifts
+              )
+            )
+          end
+        end
+        return unless configuration.cost < @policy.max_cost
+
+        expand_edits(configuration, current)
+      end
+
+      # @rbs (Configuration configuration, RepairInput current) -> (RepairPlan | Object | nil)
+      def expand_edits(configuration, current)
+        push_delete(configuration, current) unless current.eof?
+        inserted = expand_candidates(configuration, :insert)
+        return inserted if inserted
+
+        unless current.eof?
+          replaced = expand_candidates(configuration, :replace)
+          return replaced if replaced
+        end
+        nil
+      end
+
+      # @rbs (Configuration configuration, :insert | :replace kind)
+      #   -> (RepairPlan | Object | nil)
+      def expand_candidates(configuration, kind)
+        cost = kind == :insert ? @policy.insert_cost : @policy.replace_cost
+        return if configuration.cost + cost > @policy.max_cost
+
+        @candidate_ids.each do |token_id|
+          result = expand_candidate(configuration, kind, token_id, cost)
+          return LIMIT if result.equal?(LIMIT)
+        end
+        nil
+      end
+
+      # @rbs (Configuration configuration, :insert | :replace kind, Integer token_id, Integer cost) -> Object?
+      def expand_candidate(configuration, kind, token_id, cost)
+        advanced = advance(configuration.stack, token_id)
+        return LIMIT if advanced.equal?(LIMIT)
+        return unless advanced
+
+        edits = candidate_edits(configuration, kind, token_id, cost)
+        return unless advanced.is_a?(RepairAdvance)
+
+        shifts = kind == :replace ? configuration.shifts + 1 : configuration.shifts
+        input_index = kind == :replace ? configuration.input_index + 1 : configuration.input_index
+        push(
+          configuration_with(
+            configuration,
+            stack: advanced.stack,
+            input_index: input_index,
+            shifts: shifts,
+            cost: configuration.cost + cost,
+            edits: edits,
+            goal: advanced.status == :accept || shifts >= @policy.success_shifts
+          )
+        )
+        nil
+      end
+
+      # @rbs (Configuration configuration, Symbol kind, Integer token_id, Integer cost) -> Array[RepairEdit]
+      def candidate_edits(configuration, kind, token_id, cost)
+        edit = RepairEdit.new(
+          kind: kind,
+          position: configuration.input_index,
+          token_id: token_id,
+          token_name: token_name(token_id),
+          cost: cost
+        )
+        (configuration.edits + [edit]).freeze
+      end
+
+      # @rbs (Configuration configuration, RepairInput current) -> void
+      def push_delete(configuration, current)
+        cost = configuration.cost + @policy.delete_cost
+        return if cost > @policy.max_cost
+
+        edit = RepairEdit.new(
+          kind: :delete,
+          position: configuration.input_index,
+          token_id: current.token_id,
+          token_name: current.token_name,
+          cost: @policy.delete_cost
+        )
+        push(
+          configuration_with(
+            configuration, input_index: configuration.input_index + 1,
+                           cost: cost,
+                           edits: (configuration.edits + [edit]).freeze
+          )
+        )
+      end
+
+      # @rbs (Array[Integer] stack, Integer token_id) -> (RepairAdvance | Object | nil)
+      def advance(stack, token_id)
+        states = stack.dup
+        seen = {} #: Hash[Array[Integer], bool]
+        loop do
+          return nil if seen[states]
+
+          seen[states.dup.freeze] = true
+          @configurations += 1
+          return LIMIT if @configurations > @policy.max_configurations
+
+          action = action_for(states.last, token_id)
+          case action.first
+          when :shift
+            states << action.fetch(1)
+            return nil if states.length > @policy.max_stack
+
+            return RepairAdvance.new(status: :shift, stack: states.freeze)
+          when :reduce then return nil unless apply_reduction(states, action.fetch(1))
+          when :accept then return RepairAdvance.new(status: :accept, stack: states.freeze)
+          else return nil
+          end
+        end
+      end
+
+      # @rbs (Array[Integer] states, Integer production_id) -> Array[Integer]?
+      def apply_reduction(states, production_id)
+        production = @tables.fetch(:productions).fetch(production_id)
+        length = production.fetch(:length)
+        return if length >= states.length
+
+        states.pop(length)
+        goto = table_lookup(@tables.fetch(:gotos), states.last, production.fetch(:lhs))
+        return unless goto
+
+        states << goto
+        states if states.length <= @policy.max_stack
+      end
+
+      # @rbs (Integer state, Integer token_id) -> untyped
+      def action_for(state, token_id)
+        explicit = table_lookup(@tables.fetch(:actions), state, token_id)
+        return explicit if explicit
+
+        @tables.fetch(:default_actions, Parser::EMPTY_ROW)[state] || [:error]
+      end
+
+      # @rbs (untyped table, Integer row, Integer column) -> untyped
+      def table_lookup(table, row, column)
+        return table.lookup(row, column) if table.respond_to?(:lookup)
+
+        table.fetch(row, Parser::EMPTY_ROW)[column]
+      end
+
+      # @rbs (Configuration source, ?stack: Array[Integer], ?input_index: Integer, ?shifts: Integer,
+      #   ?cost: Integer, ?edits: Array[RepairEdit], ?goal: bool) -> Configuration
+      def configuration_with(source, stack: source.stack, input_index: source.input_index, shifts: source.shifts,
+                             cost: source.cost, edits: source.edits, goal: source.goal)
+        Configuration.new(
+          stack: stack, input_index: input_index, shifts: shifts, cost: cost, edits: edits, goal: goal
+        )
+      end
+
+      # @rbs (Array[RepairEdit] edits) -> RepairPlan
+      def plan(edits)
+        RepairPlan.new(edits: edits, configurations: @configurations)
+      end
+
+      # @rbs (Integer token_id) -> String
+      def token_name(token_id)
+        @tables.fetch(:token_names).fetch(token_id, token_id.to_s)
+      end
+
+      # @rbs (Configuration configuration) -> void
+      def push(configuration)
+        priority = priority_for(configuration)
+        key = [configuration.stack, configuration.input_index, configuration.shifts, configuration.goal]
+        previous = @best[key]
+        comparison = previous <=> priority if previous
+        return if comparison && comparison <= 0
+
+        @best[key] = priority
+        @heap.push(priority, configuration)
+      end
+
+      # @rbs () -> (Configuration | Object)
+      def pop
+        loop do
+          entry = @heap.pop
+          return LIMIT unless entry
+
+          priority, configuration = entry
+          return LIMIT unless configuration.is_a?(Configuration)
+
+          key = [configuration.stack, configuration.input_index, configuration.shifts, configuration.goal]
+          return configuration if @best[key] == priority
+        end
+      end
+
+      # @rbs (Configuration configuration) -> Array[untyped]
+      def priority_for(configuration)
+        edit_key = configuration.edits.map do |edit|
+          rank = { delete: 0, insert: 1, replace: 2 }.fetch(edit.kind)
+          [edit.position, rank, edit.token_id]
+        end
+        goal_rank = configuration.goal ? 0 : 1
+        risk = configuration.edits.sum { |edit| semantic_value_risk(edit) }
+        [
+          configuration.cost, risk, edit_key, goal_rank, -configuration.shifts,
+          configuration.input_index, configuration.stack
+        ]
+      end
+
+      # Prefer punctuation edits when equal-cost repairs are otherwise
+      # ambiguous; inventing or discarding a word-like token is more likely to
+      # fabricate or lose an application semantic value.
+      # @rbs (RepairEdit edit) -> Integer
+      def semantic_value_risk(edit)
+        edit.token_name.delete_prefix(":").match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/) ? 1 : 0
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/ibex/runtime/resource_limits.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Ibex
+  module Runtime
+    # Immutable per-parser-session resource budgets.
+    class ResourceLimits
+      DEFAULT_MAX_STACK_DEPTH = 10_000 #: Integer
+      DEFAULT_MAX_RECOVERY_ATTEMPTS = 100 #: Integer
+      DEFAULT_MAX_INCREMENTAL_DECOMPOSED_NODES = 100_000 #: Integer
+      DEFAULT_MAX_SESSION_MEMO_BYTES = 64 * 1024 * 1024 #: Integer
+
+      attr_reader :max_stack_depth #: Integer
+      attr_reader :max_recovery_attempts #: Integer
+      attr_reader :max_incremental_decomposed_nodes #: Integer
+      attr_reader :max_session_memo_bytes #: Integer
+
+      # @rbs (?max_stack_depth: Integer, ?max_recovery_attempts: Integer,
+      #   ?max_incremental_decomposed_nodes: Integer, ?max_session_memo_bytes: Integer) -> void
+      def initialize(
+        max_stack_depth: DEFAULT_MAX_STACK_DEPTH,
+        max_recovery_attempts: DEFAULT_MAX_RECOVERY_ATTEMPTS,
+        max_incremental_decomposed_nodes: DEFAULT_MAX_INCREMENTAL_DECOMPOSED_NODES,
+        max_session_memo_bytes: DEFAULT_MAX_SESSION_MEMO_BYTES
+      )
+        validate_positive_integer(max_stack_depth, :max_stack_depth)
+        validate_nonnegative_integer(max_recovery_attempts, :max_recovery_attempts)
+        validate_nonnegative_integer(max_incremental_decomposed_nodes, :max_incremental_decomposed_nodes)
+        validate_positive_integer(max_session_memo_bytes, :max_session_memo_bytes)
+        @max_stack_depth = max_stack_depth
+        @max_recovery_attempts = max_recovery_attempts
+        @max_incremental_decomposed_nodes = max_incremental_decomposed_nodes
+        @max_session_memo_bytes = max_session_memo_bytes
+        freeze
+      end
+
+      # @rbs () -> Hash[Symbol, Integer]
+      def to_h
+        {
+          max_stack_depth: @max_stack_depth,
+          max_recovery_attempts: @max_recovery_attempts,
+          max_incremental_decomposed_nodes: @max_incremental_decomposed_nodes,
+          max_session_memo_bytes: @max_session_memo_bytes
+        }.freeze
+      end
+
+      private
+
+      # @rbs (Integer value, Symbol name) -> void
+      def validate_positive_integer(value, name)
+        return if value.is_a?(Integer) && value.positive?
+
+        raise ArgumentError, "#{name} must be a positive Integer"
+      end
+
+      # @rbs (Integer value, Symbol name) -> void
+      def validate_nonnegative_integer(value, name)
+        return if value.is_a?(Integer) && value >= 0
+
+        raise ArgumentError, "#{name} must be a nonnegative Integer"
+      end
+    end
+  end
+end

data/lib/ibex/runtime/table_format.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Ibex
+  module Runtime
+    # Current parser-table shape emitted by the generator.
+    PARSER_TABLE_FORMAT_VERSION = 6 #: Integer
+    # Parser-table shapes this runtime can execute.
+    SUPPORTED_PARSER_TABLE_FORMAT_VERSIONS = [1, 2, 3, 4, 5, PARSER_TABLE_FORMAT_VERSION].freeze #: Array[Integer]
+  end
+end

data/lib/ibex/runtime/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Ibex
+  module Runtime
+    VERSION = "0.2.0"
+  end
+end