ibex-runtime 0.2.0 → 0.4.0

data/lib/ibex/tables/compact_productions.rb

@@ -5,7 +5,7 @@ module Ibex
   module Tables
     # Production metadata with parallel primitive arrays for the direct parser
     # and a compatible Array-of-Hash surface for generic runtime consumers.
-    class CompactProductions < Array #[Hash[Symbol, untyped]]
+    class CompactProductions < Array #[Hash[Symbol, Object?]]
       VALUES_ACTION = 1 #: Integer
       BORROWED_VALUES_ACTION = 2 #: Integer
       LOCATION_ACTION = 4 #: Integer
@@ -24,17 +24,20 @@ module Ibex
       attr_reader :flags #: Array[Integer]
 
       class << self
-        # @rbs (Array[Hash[Symbol, untyped]] productions) -> CompactProductions
+        # @rbs (Array[Hash[Symbol, Object?]] productions) -> CompactProductions
         def build(productions)
           lhs_ids = [] #: Array[Integer]
           lengths = [] #: Array[Integer]
           actions = [] #: Array[Symbol?]
           flags = [] #: Array[Integer]
-          metadata = {} #: Hash[Integer, Hash[Symbol, untyped]]
+          metadata = {} #: Hash[Integer, Hash[Symbol, Object?]]
           productions.each_with_index do |production, index|
-            lhs_ids << production.fetch(:lhs)
-            lengths << production.fetch(:length)
-            actions << production[:action]
+            lhs = production.fetch(:lhs) #: Integer
+            length = production.fetch(:length) #: Integer
+            action = production[:action] #: Symbol?
+            lhs_ids << lhs
+            lengths << length
+            actions << action
             flags << flags_for(production)
             extra = production.except(
               :lhs, :length, :action, :values_action, :borrowed_values_action, :location_action, :composition_action
@@ -45,7 +48,7 @@ module Ibex
         end
 
         # @rbs (String lhs_ids, String lengths, String flags,
-        #   ?metadata: Hash[Integer, Hash[Symbol, untyped]]) -> CompactProductions
+        #   ?metadata: Hash[Integer, Hash[Symbol, Object?]]) -> CompactProductions
         def packed(lhs_ids, lengths, flags, metadata: {})
           decoded_flags = PackedIntegers.decode_required(flags)
           actions = decoded_flags.each_index.map do |index|
@@ -62,7 +65,7 @@ module Ibex
 
         private
 
-        # @rbs (Hash[Symbol, untyped] production) -> Integer
+        # @rbs (Hash[Symbol, Object?] production) -> Integer
         def flags_for(production)
           value = 0
           value |= VALUES_ACTION if production[:values_action] == true
@@ -74,7 +77,7 @@ module Ibex
       end
 
       # @rbs (lhs_ids: Array[Integer], lengths: Array[Integer], actions: Array[Symbol?],
-      #   flags: Array[Integer], ?metadata: Hash[Integer, Hash[Symbol, untyped]]) -> void
+      #   flags: Array[Integer], ?metadata: Hash[Integer, Hash[Symbol, Object?]]) -> void
       def initialize(lhs_ids:, lengths:, actions:, flags:, metadata: {})
         size = lhs_ids.length
         unless lengths.length == size && actions.length == size && flags.length == size
@@ -98,21 +101,21 @@ module Ibex
 
       private
 
-      # @rbs (untyped value, String name) -> Integer
+      # @rbs (Object? value, String name) -> Integer
       def nonnegative_integer!(value, name)
         return value if value.is_a?(Integer) && !value.negative?
 
         raise ArgumentError, "compact production #{name} must be a nonnegative Integer"
       end
 
-      # @rbs (untyped value) -> Symbol?
+      # @rbs (Object? value) -> Symbol?
       def action!(value)
         return value if value.nil? || value.is_a?(Symbol)
 
         raise ArgumentError, "compact production action must be a Symbol or nil"
       end
 
-      # @rbs (untyped value) -> Integer
+      # @rbs (Object? value) -> Integer
       def flags!(value)
         return value if value.is_a?(Integer) && !value.negative? && value.nobits?(~VALID_FLAGS)
 
@@ -135,7 +138,7 @@ module Ibex
         end
       end
 
-      # @rbs (Hash[Integer, Hash[Symbol, untyped]] metadata, Integer size) -> void
+      # @rbs (Hash[Integer, Hash[Symbol, Object?]] metadata, Integer size) -> void
       def validate_metadata!(metadata, size)
         metadata.each do |index, entry|
           unless index.is_a?(Integer) && index.between?(0, size - 1) && entry.is_a?(Hash)
@@ -147,9 +150,9 @@ module Ibex
         end
       end
 
-      # @rbs (Integer index, Hash[Symbol, untyped]? metadata) -> Hash[Symbol, untyped]
+      # @rbs (Integer index, Hash[Symbol, Object?]? metadata) -> Hash[Symbol, Object?]
       def decode(index, metadata)
-        entry = {} #: Hash[Symbol, untyped]
+        entry = {} #: Hash[Symbol, Object?]
         entry[:lhs] = @lhs_ids[index]
         entry[:length] = @lengths[index]
         entry[:action] = @actions[index]

data/sig/ibex/runtime/cst/green/node.rbs

@@ -31,8 +31,8 @@ module Ibex
         # @rbs () -> String
         def to_source: () -> String
 
-        # @rbs (untyped other) -> bool
-        def ==: (untyped other) -> bool
+        # @rbs (Object? other) -> bool
+        def ==: (Object? other) -> bool
 
         alias eql? ==
 

data/sig/ibex/runtime/cst/green/token.rbs

@@ -44,8 +44,8 @@ module Ibex
         # @rbs () -> String
         def to_source: () -> String
 
-        # @rbs (untyped other) -> bool
-        def ==: (untyped other) -> bool
+        # @rbs (Object? other) -> bool
+        def ==: (Object? other) -> bool
 
         alias eql? ==
 

data/sig/ibex/runtime/cst/green/trivia.rbs

@@ -19,8 +19,8 @@ module Ibex
         # @rbs () -> String
         def to_source: () -> String
 
-        # @rbs (untyped other) -> bool
-        def ==: (untyped other) -> bool
+        # @rbs (Object? other) -> bool
+        def ==: (Object? other) -> bool
 
         alias eql? ==
       end

data/sig/ibex/runtime/cst/incremental/blender.rbs

@@ -64,8 +64,8 @@ module Ibex
         def initialize: (old_root: SyntaxNode, parse_memo: ParseMemo, lexed: LexedSyntax, edits: Array[TextEdit], max_decomposed_nodes: Integer, ?enabled: bool) -> void
 
         # Return the next token or a whole nonterminal valid in the current LR state.
-        # @rbs (Integer state) -> (Array[untyped] | ReusableSubtree | false)
-        def next_for_state: (Integer state) -> (Array[untyped] | ReusableSubtree | false)
+        # @rbs (Integer state) -> (Array[Object?] | ReusableSubtree | false)
+        def next_for_state: (Integer state) -> (Array[Object?] | ReusableSubtree | false)
 
         # @rbs () -> Integer
         def token_count: () -> Integer

data/sig/ibex/runtime/cst/incremental/lexed_syntax.rbs

@@ -5,12 +5,12 @@ module Ibex
     module CST
       # One complete generated-lexer pass, including the explicit EOF token.
       class LexedSyntax
-        attr_reader raw_tokens: Array[Array[untyped]]
+        attr_reader raw_tokens: Array[Array[Object?]]
 
         attr_reader memo: TokenMemo
 
-        # @rbs (raw_tokens: Array[Array[untyped]], memo: TokenMemo) -> void
-        def initialize: (raw_tokens: Array[Array[untyped]], memo: TokenMemo) -> void
+        # @rbs (raw_tokens: Array[Array[Object?]], memo: TokenMemo) -> void
+        def initialize: (raw_tokens: Array[Array[Object?]], memo: TokenMemo) -> void
 
         # @rbs (TokenMemo replacement) -> LexedSyntax
         def with_memo: (TokenMemo replacement) -> LexedSyntax

data/sig/ibex/runtime/cst/incremental/parse_memo.rbs

@@ -27,14 +27,14 @@ module Ibex
         # @rbs (Integer preorder_index, GreenNode | GreenToken element) -> Array[Integer?]
         def slice: (Integer preorder_index, GreenNode | GreenToken element) -> Array[Integer?]
 
-        # @rbs (Hash[Symbol, untyped] tables) -> bool
-        def compatible?: (Hash[Symbol, untyped] tables) -> bool
+        # @rbs (Hash[Symbol, String | Integer] tables) -> bool
+        def compatible?: (Hash[Symbol, String | Integer] tables) -> bool
 
         # @rbs () -> Integer
         def estimated_bytes: () -> Integer
 
-        # @rbs () -> Hash[String, untyped]
-        def to_h: () -> Hash[String, untyped]
+        # @rbs () -> Hash[String, Integer | Array[Integer?]]
+        def to_h: () -> Hash[String, Integer | Array[Integer?]]
 
         # Lightweight construction tree flattened once when a parse completes.
         class Entry

data/sig/ibex/runtime/cst/incremental/session.rbs

@@ -31,8 +31,9 @@ module Ibex
 
         @resource_limits: ResourceLimits
 
-        # @rbs (Class parser_class, SourceText source_text, ?resource_limits: ResourceLimits?, ?blender: bool) -> void
-        def initialize: (Class parser_class, SourceText source_text, ?resource_limits: ResourceLimits?, ?blender: bool) -> void
+        # @rbs (Class parser_class, SourceText source_text, ?resource_limits: ResourceLimits?,
+        #   ?blender: bool, ?event_observer: Proc?) -> void
+        def initialize: (Class parser_class, SourceText source_text, ?resource_limits: ResourceLimits?, ?blender: bool, ?event_observer: Proc?) -> void
 
         # Apply edits expressed against the current source and return syntax only.
         # @rbs (Array[TextEdit] edits) -> SyntaxResult
@@ -45,6 +46,11 @@ module Ibex
         # @rbs (Observation::Subscription subscription) -> bool
         def unobserve: (Observation::Subscription subscription) -> bool
 
+        # Whether the last completed edit discarded all incremental reuse and
+        # reparsed the current source from a fresh token stream.
+        # @rbs () -> bool
+        def last_full_fallback?: () -> bool
+
         private
 
         # @rbs (Array[TextEdit] edits) -> SyntaxResult

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

@@ -5,31 +5,31 @@ module Ibex
     module CST
       # Immutable result returned by syntax-aware parser entry points.
       class ParseResult
-        attr_reader value: untyped
+        attr_reader value: Object
 
         attr_reader syntax_root: SyntaxNode
 
-        attr_reader diagnostics: Array[untyped]
+        attr_reader diagnostics: Array[Object]
 
-        # @rbs (value: untyped, syntax_root: SyntaxNode, diagnostics: Array[untyped]) -> void
-        def initialize: (value: untyped, syntax_root: SyntaxNode, diagnostics: Array[untyped]) -> void
+        # @rbs (value: Object, syntax_root: SyntaxNode, diagnostics: Array[Object]) -> void
+        def initialize: (value: Object, syntax_root: SyntaxNode, diagnostics: Array[Object]) -> void
       end
 
       # Syntax-only result used by incremental sessions.
       class SyntaxResult
         attr_reader syntax_root: SyntaxNode
 
-        attr_reader diagnostics: Array[untyped]
+        attr_reader diagnostics: Array[Object]
 
         attr_reader reused_ratio: Float
 
-        # @rbs (syntax_root: SyntaxNode, diagnostics: Array[untyped], reused_ratio: Float) -> void
-        def initialize: (syntax_root: SyntaxNode, diagnostics: Array[untyped], reused_ratio: Float) -> void
+        # @rbs (syntax_root: SyntaxNode, diagnostics: Array[Object], reused_ratio: Float) -> void
+        def initialize: (syntax_root: SyntaxNode, diagnostics: Array[Object], reused_ratio: Float) -> void
       end
     end
 
-    ParseResult: untyped
+    ParseResult: singleton(CST::ParseResult)
 
-    SyntaxResult: untyped
+    SyntaxResult: singleton(CST::SyntaxResult)
   end
 end

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

@@ -8,6 +8,8 @@ module Ibex
 
       # Stable JSON serialization for `ibex_cst` schema version 1.
       module Serialize
+        type json_value = String | Integer | bool | nil | Array[json_value] | Hash[String, json_value]
+
         SCHEMA_VERSION: Integer
 
         # @rbs (SyntaxNode | SerializedTree value, ?grammar_digest: String?, ?table_format: Integer?,
@@ -22,14 +24,14 @@ module Ibex
         #   state_count: Integer?, production_count: Integer?, memo: ParseMemo?) -> SerializedTree
         def self?.serialization_tree: (SyntaxNode | SerializedTree value, grammar_digest: String?, table_format: Integer?, state_count: Integer?, production_count: Integer?, memo: ParseMemo?) -> SerializedTree
 
-        # @rbs (Kind kinds) -> Hash[String, untyped]
-        def self?.kinds_document: (Kind kinds) -> Hash[String, untyped]
+        # @rbs (Kind kinds) -> Hash[String, json_value]
+        def self?.kinds_document: (Kind kinds) -> Hash[String, json_value]
 
-        # @rbs (GreenNode | GreenToken element) -> Hash[String, untyped]
-        def self?.element_document: (GreenNode | GreenToken element) -> Hash[String, untyped]
+        # @rbs (GreenNode | GreenToken element) -> Hash[String, json_value]
+        def self?.element_document: (GreenNode | GreenToken element) -> Hash[String, json_value]
 
-        # @rbs (GreenTrivia trivia) -> Array[untyped]
-        def self?.trivia_document: (GreenTrivia trivia) -> Array[untyped]
+        # @rbs (GreenTrivia trivia) -> Array[json_value]
+        def self?.trivia_document: (GreenTrivia trivia) -> Array[json_value]
 
         # @rbs (String text) -> (String | Hash[String, String])
         def self?.encode_text: (String text) -> (String | Hash[String, String])

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

@@ -155,17 +155,17 @@ module Ibex
         # @rbs (SyntaxNode other) -> bool
         def same_node?: (SyntaxNode other) -> bool
 
-        # @rbs (untyped other) -> bool
-        def ==: (untyped other) -> bool
+        # @rbs (Object? other) -> bool
+        def ==: (Object? other) -> bool
 
         # @rbs () -> Array[element]
         def deconstruct: () -> Array[element]
 
-        # @rbs (Array[Symbol]?) -> Hash[Symbol, untyped]
-        def deconstruct_keys: (Array[Symbol]?) -> Hash[Symbol, untyped]
+        # @rbs (Array[Symbol]?) -> Hash[Symbol, Object?]
+        def deconstruct_keys: (Array[Symbol]?) -> Hash[Symbol, Object?]
 
-        # @rbs () -> Hash[Symbol, untyped]
-        def to_h: () -> Hash[Symbol, untyped]
+        # @rbs () -> Hash[Symbol, Object?]
+        def to_h: () -> Hash[Symbol, Object?]
 
         # @rbs (Integer source_offset) -> element?
         def child_covering_offset: (Integer source_offset) -> element?

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

@@ -40,8 +40,8 @@ module Ibex
         # @rbs () -> Array[GreenTrivia]
         def leading_trivia: () -> Array[GreenTrivia]
 
-        # @rbs () -> Array[untyped]
-        def children: () -> Array[untyped]
+        # @rbs () -> Array[Object?]
+        def children: () -> Array[Object?]
 
         # @rbs () -> String
         def full_text: () -> String
@@ -90,17 +90,17 @@ module Ibex
         # @rbs (SyntaxToken other) -> bool
         def same_node?: (SyntaxToken other) -> bool
 
-        # @rbs (untyped other) -> bool
-        def ==: (untyped other) -> bool
+        # @rbs (Object? other) -> bool
+        def ==: (Object? other) -> bool
 
-        # @rbs () -> Array[untyped]
-        def deconstruct: () -> Array[untyped]
+        # @rbs () -> Array[Object?]
+        def deconstruct: () -> Array[Object?]
 
-        # @rbs (Array[Symbol]?) -> Hash[Symbol, untyped]
-        def deconstruct_keys: (Array[Symbol]?) -> Hash[Symbol, untyped]
+        # @rbs (Array[Symbol]?) -> Hash[Symbol, Object?]
+        def deconstruct_keys: (Array[Symbol]?) -> Hash[Symbol, Object?]
 
-        # @rbs () -> Hash[Symbol, untyped]
-        def to_h: () -> Hash[Symbol, untyped]
+        # @rbs () -> Hash[Symbol, Object?]
+        def to_h: () -> Hash[Symbol, Object?]
 
         private
 

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

@@ -30,8 +30,8 @@ module Ibex
         # @rbs () -> Array[element]
         def deconstruct: () -> Array[element]
 
-        # @rbs (Array[Symbol]?) -> Hash[Symbol, untyped]
-        def deconstruct_keys: (Array[Symbol]?) -> Hash[Symbol, untyped]
+        # @rbs (Array[Symbol]?) -> Hash[Symbol, Object?]
+        def deconstruct_keys: (Array[Symbol]?) -> Hash[Symbol, Object?]
 
         # @rbs () -> String
         def to_source: () -> String

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

@@ -3,18 +3,22 @@
 module Ibex
   module Runtime
     module CST
+      type json_value = String | Integer | Float | bool | nil | Array[json_value] | Hash[String, json_value]
+
+      type json_object = Hash[String, json_value]
+
       # 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 expected: json_value
 
-        attr_reader actual: untyped
+        attr_reader actual: json_value
 
-        # @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
+        # @rbs (code: Symbol, path: String, message: String, ?expected: json_value, ?actual: json_value) -> void
+        def initialize: (code: Symbol, path: String, message: String, ?expected: json_value, ?actual: json_value) -> void
       end
 
       # Validates schema-v1 CST documents while rebuilding all derived Green data.
@@ -30,27 +34,27 @@ module Ibex
         #   ?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 (json_value value) -> Kind
+        def self?.load_kinds: (json_value value) -> Kind
 
-        # @rbs (untyped value, GreenNode root, String digest, Integer state_count, Integer production_count,
+        # @rbs (json_value 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?
+        def self?.load_memo: (json_value 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 (json_value value, Integer state_count) -> Array[Integer?]
+        def self?.load_memo_states: (json_value 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 (json_value value, Kind kinds, String path) -> (GreenNode | GreenToken)
+        def self?.load_element: (json_value 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 (json_value value, Kind kinds, String path) -> Array[GreenTrivia]
+        def self?.load_trivia: (json_value value, Kind kinds, String path) -> Array[GreenTrivia]
 
-        # @rbs (untyped value, String path) -> String
-        def self?.decode_text: (untyped value, String path) -> String
+        # @rbs (json_value value, String path) -> String
+        def self?.decode_text: (json_value value, String path) -> String
 
         # @rbs (GreenNode | GreenToken element, String path) -> void
         def self?.validate_derived!: (GreenNode | GreenToken element, String path) -> void
@@ -58,35 +62,35 @@ module Ibex
         # @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 (json_value value, String path) -> json_object
+        def self?.object!: (json_value value, String path) -> json_object
 
-        # @rbs (untyped value, String path) -> Array[untyped]
-        def self?.array!: (untyped value, String path) -> Array[untyped]
+        # @rbs (json_value value, String path) -> Array[json_value]
+        def self?.array!: (json_value value, String path) -> Array[json_value]
 
-        # @rbs (untyped value, String path) -> String
-        def self?.string!: (untyped value, String path) -> String
+        # @rbs (json_value value, String path) -> String
+        def self?.string!: (json_value value, String path) -> String
 
-        # @rbs (untyped value, String path) -> Integer
-        def self?.nonnegative_integer!: (untyped value, String path) -> Integer
+        # @rbs (json_value value, String path) -> Integer
+        def self?.nonnegative_integer!: (json_value value, String path) -> Integer
 
-        # @rbs (untyped value, String path) -> Integer
-        def self?.positive_integer!: (untyped value, String path) -> Integer
+        # @rbs (json_value value, String path) -> Integer
+        def self?.positive_integer!: (json_value value, String path) -> Integer
 
-        # @rbs (untyped value, String path) -> Symbol
-        def self?.trivia_policy!: (untyped value, String path) -> Symbol
+        # @rbs (json_value value, String path) -> Symbol
+        def self?.trivia_policy!: (json_value value, String path) -> Symbol
 
-        # @rbs (untyped value, String path) -> Integer
-        def self?.flags!: (untyped value, String path) -> Integer
+        # @rbs (json_value value, String path) -> Integer
+        def self?.flags!: (json_value value, String path) -> Integer
 
-        # @rbs (untyped value, String path) -> Array[Integer]
-        def self?.integer_pair!: (untyped value, String path) -> Array[Integer]
+        # @rbs (json_value value, String path) -> Array[Integer]
+        def self?.integer_pair!: (json_value 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 (json_value value, String path) -> Hash[String, Integer]
+        def self?.string_integer_map!: (json_value 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 (json_value value, String path) -> Hash[Integer, Integer]
+        def self?.integer_integer_map!: (json_value value, String path) -> Hash[Integer, Integer]
 
         # @rbs (Kind::metadata metadata) -> void
         def self?.validate_kind_metadata!: (Kind::metadata metadata) -> void
@@ -94,14 +98,14 @@ module Ibex
         # @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 (json_object value, Array[String] expected, String path) -> void
+        def self?.exact_keys!: (json_object 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 (json_object value, String key, json_value expected, String path) -> void
+        def self?.value!: (json_object value, String key, json_value 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
+        # @rbs (Symbol code, String path, String message, ?expected: json_value, ?actual: json_value) -> bot
+        def self?.fail_validation: (Symbol code, String path, String message, ?expected: json_value, ?actual: json_value) -> bot
       end
     end
   end

data/sig/ibex/runtime/embedded_source.rbs

@@ -0,0 +1,21 @@
+# Generated from lib/ibex/runtime/embedded_source.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    # Assembles the installed runtime into one dependency-free Ruby source.
+    module EmbeddedSource
+      FILES: Array[String]
+
+      REQUIRE_RELATIVE: ::Regexp
+
+      # @rbs () -> String
+      def self.render: () -> String
+
+      # @rbs (Array[String] paths) -> void
+      def self.validate_manifest!: (Array[String] paths) -> void
+
+      # @rbs (String path) -> String
+      def self.source: (String path) -> String
+    end
+  end
+end

data/sig/ibex/runtime/event.rbs

@@ -4,6 +4,8 @@ module Ibex
   module Runtime
     # One immutable versioned parser observation.
     class Event
+      type json_value = String | Integer | Float | bool | nil | Array[json_value] | Hash[String, json_value]
+
       SCHEMA_VERSION: Integer
 
       IDENTIFIER: String
@@ -14,13 +16,13 @@ module Ibex
 
       attr_reader sequence: Integer
 
-      attr_reader data: Hash[String, untyped]
+      attr_reader data: Hash[String, json_value]
 
-      # @rbs (type: Symbol, sequence: Integer, data: Hash[untyped, untyped]) -> void
-      def initialize: (type: Symbol, sequence: Integer, data: Hash[untyped, untyped]) -> void
+      # @rbs (type: Symbol, sequence: Integer, data: Hash[Object?, Object?]) -> void
+      def initialize: (type: Symbol, sequence: Integer, data: Hash[Object?, Object?]) -> void
 
-      # @rbs () -> Hash[String, untyped]
-      def to_h: () -> Hash[String, untyped]
+      # @rbs () -> Hash[String, json_value]
+      def to_h: () -> Hash[String, json_value]
     end
   end
 end

data/sig/ibex/runtime/event_jsonl_tracer.rbs

@@ -5,7 +5,7 @@ module Ibex
     # Emits schema-v1 immutable runtime events as JSON Lines.
     class EventJSONLTracer
       interface _EventTraceOutput
-        def puts: (String) -> untyped
+        def puts: (String) -> void
       end
 
       attr_reader parser: Parser