ibex-runtime 0.2.0

data/sig/ibex/runtime/cst/validator.rbs

@@ -0,0 +1,108 @@
+# Generated from lib/ibex/runtime/cst/validator.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    module CST
+      # Structured failure raised for an invalid or incompatible CST document.
+      class ValidationError < StandardError
+        attr_reader code: Symbol
+
+        attr_reader path: String
+
+        attr_reader expected: untyped
+
+        attr_reader actual: untyped
+
+        # @rbs (code: Symbol, path: String, message: String, ?expected: untyped, ?actual: untyped) -> void
+        def initialize: (code: Symbol, path: String, message: String, ?expected: untyped, ?actual: untyped) -> void
+      end
+
+      # Validates schema-v1 CST documents while rebuilding all derived Green data.
+      module Validator
+        # rubocop:disable Metrics/ModuleLength -- closed schema checks remain auditable in one boundary.
+        TOP_KEYS: Array[String]
+
+        KIND_KEYS: Array[String]
+
+        KNOWN_FLAGS: Integer
+
+        # @rbs (String source, ?grammar_digest: String?, ?state_count: Integer?,
+        #   ?production_count: Integer?) -> SerializedTree
+        def self?.validate: (String source, ?grammar_digest: String?, ?state_count: Integer?, ?production_count: Integer?) -> SerializedTree
+
+        # @rbs (untyped value) -> Kind
+        def self?.load_kinds: (untyped value) -> Kind
+
+        # @rbs (untyped value, GreenNode root, String digest, Integer state_count, Integer production_count,
+        #   expected_state_count: Integer?, expected_production_count: Integer?) -> ParseMemo?
+        def self?.load_memo: (untyped value, GreenNode root, String digest, Integer state_count, Integer production_count, expected_state_count: Integer?, expected_production_count: Integer?) -> ParseMemo?
+
+        # @rbs (untyped value, Integer state_count) -> Array[Integer?]
+        def self?.load_memo_states: (untyped value, Integer state_count) -> Array[Integer?]
+
+        # @rbs (Array[Integer?] states, GreenNode root) -> void
+        def self?.validate_memo_length!: (Array[Integer?] states, GreenNode root) -> void
+
+        # @rbs (untyped value, Kind kinds, String path) -> (GreenNode | GreenToken)
+        def self?.load_element: (untyped value, Kind kinds, String path) -> (GreenNode | GreenToken)
+
+        # @rbs (untyped value, Kind kinds, String path) -> Array[GreenTrivia]
+        def self?.load_trivia: (untyped value, Kind kinds, String path) -> Array[GreenTrivia]
+
+        # @rbs (untyped value, String path) -> String
+        def self?.decode_text: (untyped value, String path) -> String
+
+        # @rbs (GreenNode | GreenToken element, String path) -> void
+        def self?.validate_derived!: (GreenNode | GreenToken element, String path) -> void
+
+        # @rbs (Integer kind, Kind kinds, String path) -> void
+        def self?.validate_kind!: (Integer kind, Kind kinds, String path) -> void
+
+        # @rbs (untyped value, String path) -> Hash[String, untyped]
+        def self?.object!: (untyped value, String path) -> Hash[String, untyped]
+
+        # @rbs (untyped value, String path) -> Array[untyped]
+        def self?.array!: (untyped value, String path) -> Array[untyped]
+
+        # @rbs (untyped value, String path) -> String
+        def self?.string!: (untyped value, String path) -> String
+
+        # @rbs (untyped value, String path) -> Integer
+        def self?.nonnegative_integer!: (untyped value, String path) -> Integer
+
+        # @rbs (untyped value, String path) -> Integer
+        def self?.positive_integer!: (untyped value, String path) -> Integer
+
+        # @rbs (untyped value, String path) -> Symbol
+        def self?.trivia_policy!: (untyped value, String path) -> Symbol
+
+        # @rbs (untyped value, String path) -> Integer
+        def self?.flags!: (untyped value, String path) -> Integer
+
+        # @rbs (untyped value, String path) -> Array[Integer]
+        def self?.integer_pair!: (untyped value, String path) -> Array[Integer]
+
+        # @rbs (untyped value, String path) -> Hash[String, Integer]
+        def self?.string_integer_map!: (untyped value, String path) -> Hash[String, Integer]
+
+        # @rbs (untyped value, String path) -> Hash[Integer, Integer]
+        def self?.integer_integer_map!: (untyped value, String path) -> Hash[Integer, Integer]
+
+        # @rbs (Kind::metadata metadata) -> void
+        def self?.validate_kind_metadata!: (Kind::metadata metadata) -> void
+
+        # @rbs (Array[Integer] range, Integer limit, String path) -> void
+        def self?.validate_kind_range!: (Array[Integer] range, Integer limit, String path) -> void
+
+        # @rbs (Hash[String, untyped] value, Array[String] expected, String path) -> void
+        def self?.exact_keys!: (Hash[String, untyped] value, Array[String] expected, String path) -> void
+
+        # @rbs (Hash[String, untyped] value, String key, untyped expected, String path) -> void
+        def self?.value!: (Hash[String, untyped] value, String key, untyped expected, String path) -> void
+
+        # @rbs (Symbol code, String path, String message, ?expected: untyped, ?actual: untyped) -> bot
+        def self?.fail_validation: (Symbol code, String path, String message, ?expected: untyped, ?actual: untyped) -> bot
+      end
+    end
+  end
+end

data/sig/ibex/runtime/cst.rbs

@@ -0,0 +1,9 @@
+# Generated from lib/ibex/runtime/cst.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    # Current Red/Green concrete-syntax APIs.
+    module CST
+    end
+  end
+end

data/sig/ibex/runtime/event.rbs

@@ -0,0 +1,26 @@
+# Generated from lib/ibex/runtime/event.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    # One immutable versioned parser observation.
+    class Event
+      SCHEMA_VERSION: Integer
+
+      IDENTIFIER: String
+
+      TYPES: Array[Symbol]
+
+      attr_reader type: Symbol
+
+      attr_reader sequence: Integer
+
+      attr_reader data: Hash[String, untyped]
+
+      # @rbs (type: Symbol, sequence: Integer, data: Hash[untyped, untyped]) -> void
+      def initialize: (type: Symbol, sequence: Integer, data: Hash[untyped, untyped]) -> void
+
+      # @rbs () -> Hash[String, untyped]
+      def to_h: () -> Hash[String, untyped]
+    end
+  end
+end

data/sig/ibex/runtime/event_jsonl_tracer.rbs

@@ -0,0 +1,25 @@
+# Generated from lib/ibex/runtime/event_jsonl_tracer.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    # Emits schema-v1 immutable runtime events as JSON Lines.
+    class EventJSONLTracer
+      interface _EventTraceOutput
+        def puts: (String) -> untyped
+      end
+
+      attr_reader parser: Parser
+
+      attr_reader subscription: Observation::Subscription
+
+      # @rbs (Parser parser, _EventTraceOutput output) -> void
+      def initialize: (Parser parser, _EventTraceOutput output) -> void
+
+      # @rbs () -> bool
+      def detach: () -> bool
+
+      # @rbs [P < Parser] (P parser, io: _EventTraceOutput) -> EventJSONLTracer
+      def self.attach: [P < Parser] (P parser, io: _EventTraceOutput) -> EventJSONLTracer
+    end
+  end
+end

data/sig/ibex/runtime/event_sanitizer.rbs

@@ -0,0 +1,92 @@
+# Generated from lib/ibex/runtime/event_sanitizer.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    # Converts application-owned values into bounded, data-only event summaries.
+    # rubocop:disable Metrics/ModuleLength
+    module EventSanitizer
+      MAX_DEPTH: Integer
+
+      MAX_COLLECTION_ENTRIES: Integer
+
+      MAX_STRING_BYTES: Integer
+
+      MAX_INTEGER_BITS: Integer
+
+      STRING_INPUT_BYTES: Integer
+
+      DATA_MAX_DEPTH: Integer
+
+      # Copy a runtime payload into deeply frozen JSON data. Unknown objects are
+      # summarized instead of being retained, so callers cannot smuggle mutable
+      # application identities into an Event.
+      # @rbs (Hash[untyped, untyped] input) -> Hash[String, untyped]
+      def self.data: (Hash[untyped, untyped] input) -> Hash[String, untyped]
+
+      # @rbs (untyped input) -> untyped
+      def self.value: (untyped input) -> untyped
+
+      # @rbs (untyped location) -> Hash[String, untyped]?
+      def self.location: (untyped location) -> Hash[String, untyped]?
+
+      # @rbs (untyped input) -> String
+      def self.string: (untyped input) -> String
+
+      # @rbs (untyped input) -> String
+      def self.class_name: (untyped input) -> String
+
+      # @rbs (untyped input, depth: Integer, seen: Hash[Integer, bool]) -> untyped
+      private def self.summarize: (untyped input, depth: Integer, seen: Hash[Integer, bool]) -> untyped
+
+      # @rbs (untyped input, depth: Integer, seen: Hash[Integer, bool]) -> untyped
+      private def self.json_data: (untyped input, depth: Integer, seen: Hash[Integer, bool]) -> untyped
+
+      # @rbs (Array[untyped] input, depth: Integer, seen: Hash[Integer, bool]) -> untyped
+      private def self.summarize_array: (Array[untyped] input, depth: Integer, seen: Hash[Integer, bool]) -> untyped
+
+      # @rbs (Hash[untyped, untyped] input, depth: Integer, seen: Hash[Integer, bool]) -> untyped
+      private def self.summarize_hash: (Hash[untyped, untyped] input, depth: Integer, seen: Hash[Integer, bool]) -> untyped
+
+      # @rbs (Array[untyped] input, depth: Integer, seen: Hash[Integer, bool]) -> untyped
+      private def self.json_array: (Array[untyped] input, depth: Integer, seen: Hash[Integer, bool]) -> untyped
+
+      # @rbs (Hash[untyped, untyped] input, depth: Integer, seen: Hash[Integer, bool]) -> untyped
+      private def self.json_hash: (Hash[untyped, untyped] input, depth: Integer, seen: Hash[Integer, bool]) -> untyped
+
+      # @rbs (Array[untyped] input, seen: Hash[Integer, bool])
+      #   { (untyped, Hash[Integer, bool]) -> untyped } -> untyped
+      private def self.copy_array: (Array[untyped] input, seen: Hash[Integer, bool]) { (untyped, Hash[Integer, bool]) -> untyped } -> untyped
+
+      # @rbs (untyped input) -> bool
+      private def self.primitive?: (untyped input) -> bool
+
+      # @rbs (Integer input) -> untyped
+      private def self.bounded_integer: (Integer input) -> untyped
+
+      # @rbs (Float input) -> untyped
+      private def self.finite_float: (Float input) -> untyped
+
+      # @rbs (untyped input, Module type) -> bool
+      private def self.core_type?: (untyped input, Module type) -> bool
+
+      # @rbs (untyped key) -> String
+      private def self.data_key: (untyped key) -> String
+
+      # @rbs (String input) -> String
+      private def self.truncate_utf8: (String input) -> String
+
+      # @rbs (untyped input) -> Integer
+      private def self.object_identity: (untyped input) -> Integer
+
+      # @rbs (untyped location, Symbol field) -> untyped
+      private def self.location_field: (untyped location, Symbol field) -> untyped
+
+      # @rbs (String reason) -> Hash[String, untyped]
+      private def self.unavailable: (String reason) -> Hash[String, untyped]
+
+      # @rbs (Module owner, Symbol method_name, untyped receiver, *untyped args, **untyped keywords)
+      #   ?{ (*untyped) -> untyped } -> untyped
+      private def self.core_call: (Module owner, Symbol method_name, untyped receiver, *untyped args, **untyped keywords) ?{ (*untyped) -> untyped } -> untyped
+    end
+  end
+end

data/sig/ibex/runtime/generated_lexer.rbs

@@ -0,0 +1,169 @@
+# Generated from lib/ibex/runtime/generated_lexer.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    # Runtime contract mixed into parser classes that declare a lexer.
+    # rubocop:disable Metrics/ModuleLength -- matching, actions, state, and positions share one session invariant.
+    # @rbs module-self Parser
+    module GeneratedLexer : Parser
+      NO_EMISSION: Object
+
+      # @type var empty_green_trivia: Array[CST::GreenTrivia]
+      EMPTY_GREEN_TRIVIA: Array[CST::GreenTrivia]
+
+      @lexer_has_token: bool
+
+      @lexer_cst_trivia_kinds: Hash[String, Integer]?
+
+      @lexer_cst_trivia_policy: Symbol
+
+      @lexer_pending_green_trivia: Array[CST::GreenTrivia]
+
+      @lexer_skip_requested: bool
+
+      @lexer_emission: Object | Array[untyped]
+
+      @lexer_lexeme: String?
+
+      @lexer_byte_offset: Integer
+
+      @lexer_byte_column: Integer
+
+      @lexer_column: Integer
+
+      @lexer_line: Integer
+
+      @lexer_states: Array[String]
+
+      @lexer_file: String
+
+      @lexer_input: LexerInput?
+
+      # Reset the generated lexer to the beginning of an input.
+      # @rbs (String | IO | Fiber source, ?file: String) -> self
+      def lex: (String | IO | Fiber source, ?file: String) -> self
+
+      # Lex and parse one String, IO, or Fiber source.
+      # @rbs (String | IO | Fiber source, ?file: String) -> untyped
+      def parse: (String | IO | Fiber source, ?file: String) -> untyped
+
+      # Parse one generated-lexer source and return its semantic and syntax results.
+      # @rbs (String | IO | Fiber source, ?file: String) -> CST::ParseResult
+      def parse_with_syntax: (String | IO | Fiber source, ?file: String) -> CST::ParseResult
+
+      # Parse without executing parser production actions.
+      # Lexer actions still run because they define tokenization and lexer state.
+      # @rbs (String source, ?file: String) -> CST::SyntaxResult
+      def parse_syntax: (String source, ?file: String) -> CST::SyntaxResult
+
+      # Return the current named lexer state.
+      # @rbs () -> Symbol
+      def lexer_state: () -> Symbol
+
+      # Replace the current named lexer state.
+      # @rbs (Symbol | String state) -> Symbol
+      def lexer_state=: (Symbol | String state) -> Symbol
+
+      # Pull one token using longest match and declaration-order tie breaking.
+      # @rbs () -> [untyped, untyped, Hash[Symbol, untyped]]
+      def next_token: () -> [ untyped, untyped, Hash[Symbol, untyped] ]
+
+      private
+
+      # @rbs (CST::SourceText source_text, CST::NodeCache cache) -> CST::SyntaxResult
+      def parse_syntax_with_cache: (CST::SourceText source_text, CST::NodeCache cache) -> CST::SyntaxResult
+
+      # Run the generated lexer once and materialize its exact Green token stream.
+      # @rbs (CST::SourceText source_text, CST::NodeCache cache) -> CST::LexedSyntax
+      def scan_syntax_with_cache: (CST::SourceText source_text, CST::NodeCache cache) -> CST::LexedSyntax
+
+      # @rbs (Integer token_id, untyped value, untyped location, CST::NodeCache cache) -> CST::GreenToken
+      def scanned_green_token: (Integer token_id, untyped value, untyped location, CST::NodeCache cache) -> CST::GreenToken
+
+      # @rbs (Array[CST::GreenToken] tokens, untyped location, CST::NodeCache cache) -> void
+      def replace_previous_scanned_trailing: (Array[CST::GreenToken] tokens, untyped location, CST::NodeCache cache) -> void
+
+      # @rbs (untyped location, Symbol key) -> Array[CST::GreenTrivia]
+      def scanned_green_trivia: (untyped location, Symbol key) -> Array[CST::GreenTrivia]
+
+      # @rbs (LexerInput input) -> bool
+      def ensure_lexer_data?: (LexerInput input) -> bool
+
+      # @rbs (LexerInput input) -> [Hash[Symbol, untyped]?, String?]
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def select_lexer_match: (LexerInput input) -> [ Hash[Symbol, untyped]?, String? ]
+
+      # @rbs () -> Array[Hash[Symbol, untyped]]
+      def lexer_rules: () -> Array[Hash[Symbol, untyped]]
+
+      # @rbs (LexerInput input) -> bot
+      def raise_lexer_no_match: (LexerInput input) -> bot
+
+      # @rbs (LexerInput input, String lexeme) -> Hash[Symbol, untyped]
+      def consume_lexer_match: (LexerInput input, String lexeme) -> Hash[Symbol, untyped]
+
+      # @rbs (Hash[Symbol, untyped] rule, String lexeme, Hash[Symbol, untyped] location) ->
+      #   [untyped, untyped, Hash[Symbol, untyped]]?
+      def apply_lexer_rule: (Hash[Symbol, untyped] rule, String lexeme, Hash[Symbol, untyped] location) -> [ untyped, untyped, Hash[Symbol, untyped] ]?
+
+      # Emit a token from a lexer action.
+      # @rbs (untyped token, ?untyped value) -> untyped
+      def emit: (untyped token, ?untyped value) -> untyped
+
+      # Suppress the current match from a lexer action.
+      # @rbs () -> nil
+      def skip: () -> nil
+
+      # Return the text consumed by the active lexer action.
+      # @rbs () -> String?
+      def lexeme: () -> String?
+
+      # @rbs (String text, Hash[Symbol, untyped] location) -> void
+      def retain_cst_trivia: (String text, Hash[Symbol, untyped] location) -> void
+
+      # @rbs (Hash[Symbol, untyped] location) -> Hash[Symbol, untyped]
+      def attach_cst_trivia: (Hash[Symbol, untyped] location) -> Hash[Symbol, untyped]
+
+      # @rbs () -> Symbol
+      def cst_trivia_policy: () -> Symbol
+
+      # @rbs (String text) -> Integer
+      def cst_trivia_kind: (String text) -> Integer
+
+      # @rbs () -> void
+      def configure_lexer_cst: () -> void
+
+      # @rbs (Array[CST::GreenTrivia] trivia) -> [Array[CST::GreenTrivia], Array[CST::GreenTrivia]]
+      def split_balanced_trivia: (Array[CST::GreenTrivia] trivia) -> [ Array[CST::GreenTrivia], Array[CST::GreenTrivia] ]
+
+      # @rbs () -> CST::SourceText
+      def cst_source_text: () -> CST::SourceText
+
+      # @rbs () -> Array[CST::GreenTrivia]
+      def take_cst_pending_green_trivia: () -> Array[CST::GreenTrivia]
+
+      # @rbs (Array[CST::GreenTrivia] values) -> Array[CST::GreenTrivia]
+      def green_trivia_values: (Array[CST::GreenTrivia] values) -> Array[CST::GreenTrivia]
+
+      # Push a named lexer state.
+      # @rbs (Symbol | String state) -> Symbol
+      def push_state: (Symbol | String state) -> Symbol
+
+      # Pop the current named lexer state.
+      # @rbs () -> Symbol
+      def pop_state: () -> Symbol
+
+      # @rbs (Symbol | String state) -> String
+      def validate_lexer_state: (Symbol | String state) -> String
+
+      # @rbs () -> Hash[Symbol, Integer]
+      def lexer_position: () -> Hash[Symbol, Integer]
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def lexer_zero_width_location: () -> Hash[Symbol, untyped]
+
+      # @rbs (String lexeme) -> void
+      def advance_lexer_position: (String lexeme) -> void
+    end
+  end
+end

data/sig/ibex/runtime/jsonl_tracer.rbs

@@ -0,0 +1,42 @@
+# Generated from lib/ibex/runtime/jsonl_tracer.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    # Emits committed parser observer events as JSON Lines.
+    module JSONLTracer
+      interface _TraceOutput
+        def puts: (String) -> untyped
+      end
+
+      # Hook layer installed on an individual parser's singleton class.
+      module Hooks
+        def token_to_str: (Integer) -> String
+
+        @ibex_jsonl_trace_output: _TraceOutput?
+
+        # @rbs (Integer token_id, untyped value, Integer state) -> void
+        def on_shift: (Integer token_id, untyped value, Integer state) -> void
+
+        # @rbs (Integer production_id, Array[untyped] values, untyped result) -> void
+        def on_reduce: (Integer production_id, Array[untyped] values, untyped result) -> void
+
+        # @rbs (Integer token_id, untyped value, Array[untyped] value_stack) -> void
+        def on_error_recover: (Integer token_id, untyped value, Array[untyped] value_stack) -> void
+
+        private
+
+        # @rbs (_TraceOutput output) -> void
+        def ibex_jsonl_trace_output=: (_TraceOutput output) -> void
+
+        # @rbs (**untyped event) -> void
+        def write_trace: (**untyped event) -> void
+
+        # @rbs (untyped value) -> String
+        def safe_inspect: (untyped value) -> String
+      end
+
+      # @rbs [P < Parser] (P parser, io: _TraceOutput) -> P
+      def self.attach: [P < Parser] (P parser, io: _TraceOutput) -> P
+    end
+  end
+end

data/sig/ibex/runtime/lexer_input.rbs

@@ -0,0 +1,44 @@
+# Generated from lib/ibex/runtime/lexer_input.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    # Incremental String, IO, or Fiber input used by generated lexers.
+    class LexerInput
+      DEFAULT_CHUNK_SIZE: Integer
+
+      attr_reader buffer: String
+
+      # @rbs (String | IO | Fiber source, ?chunk_size: Integer) -> void
+      def initialize: (String | IO | Fiber source, ?chunk_size: Integer) -> void
+
+      # @rbs () -> bool
+      def eof?: () -> bool
+
+      # Return every source byte read so far, including the unconsumed buffer.
+      # @rbs () -> String
+      def source_bytes: () -> String
+
+      # Read until at least one byte is added or EOF is observed.
+      # @rbs () -> bool
+      def read_more?: () -> bool
+
+      # @rbs (String prefix) -> void
+      def consume: (String prefix) -> void
+
+      # Return one source line, reading ahead only to its line boundary.
+      # @rbs (Integer line) -> String
+      def source_line: (Integer line) -> String
+
+      private
+
+      # @rbs () -> void
+      def read_chunk: () -> void
+
+      # @rbs (Fiber source) -> untyped
+      def resume_fiber: (Fiber source) -> untyped
+
+      # @rbs (String chunk) -> void
+      def append: (String chunk) -> void
+    end
+  end
+end

data/sig/ibex/runtime/location_span.rbs

@@ -0,0 +1,64 @@
+# Generated from lib/ibex/runtime/location_span.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    # The deterministic source span assigned to a reduced nonterminal.
+    #
+    # Terminal stack entries retain the application-owned location object
+    # supplied by the lexer. A reduction wraps the outer boundaries in this
+    # immutable value so actions can distinguish synthesized spans.
+    class LocationSpan
+      attr_reader start: untyped
+
+      attr_reader finish: untyped
+
+      # @rbs (start: untyped, finish: untyped, ?empty: bool) -> void
+      def initialize: (start: untyped, finish: untyped, ?empty: bool) -> void
+
+      # Build a span for an LR reduction. Nonempty reductions cover the first
+      # through last located RHS entry. Empty reductions are zero-width at the
+      # current lookahead location.
+      # @rbs (Array[untyped] locations, lookahead: untyped) -> LocationSpan?
+      def self.for_reduction: (Array[untyped] locations, lookahead: untyped) -> LocationSpan?
+
+      # Whether this is the zero-width span of an empty production.
+      # @rbs () -> bool
+      def empty?: () -> bool
+
+      # @rbs () -> untyped
+      def file: () -> untyped
+
+      # @rbs () -> untyped
+      def line: () -> untyped
+
+      # @rbs () -> untyped
+      def column: () -> untyped
+
+      # @rbs () -> untyped
+      def source_line: () -> untyped
+
+      # @rbs () -> untyped
+      def end_file: () -> untyped
+
+      # @rbs () -> untyped
+      def end_line: () -> untyped
+
+      # @rbs () -> untyped
+      def end_column: () -> untyped
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def to_h: () -> Hash[Symbol, untyped]
+
+      # @rbs (untyped location) -> untyped
+      private def self.boundary_start: (untyped location) -> untyped
+
+      # @rbs (untyped location) -> untyped
+      private def self.boundary_finish: (untyped location) -> untyped
+
+      private
+
+      # @rbs (untyped location, Symbol key) -> untyped
+      def location_value: (untyped location, Symbol key) -> untyped
+    end
+  end
+end

data/sig/ibex/runtime/observation.rbs

@@ -0,0 +1,35 @@
+# Generated from lib/ibex/runtime/observation.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    # Registration and ordered synchronous dispatch for parser observers.
+    module Observation
+      # Opaque identity returned by Parser#observe.
+      class Subscription
+        # @rbs () -> Subscription
+        private def self.new: () -> Subscription
+
+        # @rbs () -> Subscription
+        # rubocop:disable Lint/UselessMethodDefinition -- explicit override keeps runtime and generated RBS private.
+        private def self.allocate: () -> Subscription
+      end
+
+      # @rbs () { (Event) -> void } -> Subscription
+      def observe: () { (Event) -> void } -> Subscription
+
+      # @rbs (Subscription subscription) -> bool
+      def unobserve: (Subscription subscription) -> bool
+
+      private
+
+      # @rbs (Symbol type, Hash[untyped, untyped] data, ?observers: Array[Proc]?) -> void
+      def emit_runtime_event: (Symbol type, Hash[untyped, untyped] data, ?observers: Array[Proc]?) -> void
+
+      # @rbs () -> Array[Proc]?
+      def runtime_observer_snapshot: () -> Array[Proc]?
+
+      # @rbs () -> void
+      def ensure_observation_thread!: () -> void
+    end
+  end
+end