ibex-runtime 0.2.0

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

@@ -0,0 +1,84 @@
+# Generated from lib/ibex/runtime/cst/green/builder.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    module CST
+      # LR bottom-up builder backed by a Green element stack.
+      # rubocop:disable Naming/PredicateMethod -- mutation methods report whether they found a target.
+      class GreenBuilder
+        type child = GreenNode | GreenToken
+
+        # @type var empty_trivia: Array[GreenTrivia]
+        EMPTY_TRIVIA: Array[GreenTrivia]
+
+        @stack: Array[child]
+
+        @cache: NodeCache
+
+        @kinds: Kind
+
+        # @rbs (kinds: Kind, ?cache: NodeCache) -> void
+        def initialize: (kinds: Kind, ?cache: NodeCache) -> void
+
+        # @rbs (Integer kind, String text, ?leading: Array[GreenTrivia], ?trailing: Array[GreenTrivia],
+        #   ?flags: Integer) -> GreenToken
+        def token: (Integer kind, String text, ?leading: Array[GreenTrivia], ?trailing: Array[GreenTrivia], ?flags: Integer) -> GreenToken
+
+        # Construct an interned token without changing the builder stack.
+        # @rbs (Integer kind, String text, ?leading: Array[GreenTrivia], ?trailing: Array[GreenTrivia],
+        #   ?flags: Integer) -> GreenToken
+        def make_token: (Integer kind, String text, ?leading: Array[GreenTrivia], ?trailing: Array[GreenTrivia], ?flags: Integer) -> GreenToken
+
+        # @rbs (Integer kind, Integer arity, ?flags: Integer) -> GreenNode
+        def node: (Integer kind, Integer arity, ?flags: Integer) -> GreenNode
+
+        # Push one already validated nonterminal without rebuilding its descendants.
+        # @rbs (GreenNode value) -> GreenNode
+        def subtree: (GreenNode value) -> GreenNode
+
+        # @rbs (Integer expected_kind) -> GreenToken
+        def missing: (Integer expected_kind) -> GreenToken
+
+        # @rbs (String text, ?leading: Array[GreenTrivia]) -> GreenToken
+        def lexical_error: (String text, ?leading: Array[GreenTrivia]) -> GreenToken
+
+        # Preserve popped and discarded Green elements in one error node.
+        # @rbs (Integer pop_count, ?skipped: Array[child]) -> GreenNode
+        def absorb_into_error: (Integer pop_count, ?skipped: Array[child]) -> GreenNode
+
+        # Wrap the completed start node and explicit EOF token.
+        # @rbs (GreenToken eof_token, ?incomplete: bool) -> GreenNode
+        def finish_source_file: (GreenToken eof_token, ?incomplete: bool) -> GreenNode
+
+        # Preserve every available fragment when parsing terminates without a start node.
+        # @rbs (?Array[child] trailing, ?incomplete: bool) -> GreenNode
+        def finish_synthetic_root: (?Array[child] trailing, ?incomplete: bool) -> GreenNode
+
+        # Append discarded input to the most recent error node on the stack.
+        # @rbs (child skipped) -> bool
+        def append_to_last_error: (child skipped) -> bool
+
+        # Path-copy the right edge to attach balanced trailing trivia.
+        # @rbs (Array[GreenTrivia] trivia) -> bool
+        def append_trailing_to_last_token: (Array[GreenTrivia] trivia) -> bool
+
+        # @rbs () -> Array[child]
+        def snapshot: () -> Array[child]
+
+        # @rbs (Array[child] elements) -> void
+        def restore: (Array[child] elements) -> void
+
+        # @rbs () -> Integer
+        def size: () -> Integer
+
+        # @rbs () -> Array[child]
+        def elements: () -> Array[child]
+
+        private
+
+        # @rbs (child element, Array[GreenTrivia] trivia) -> child?
+        def with_rightmost_trailing: (child element, Array[GreenTrivia] trivia) -> child?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# Generated from lib/ibex/runtime/cst/green/cache.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    module CST
+      # Session-owned hash-consing cache for immutable Green elements.
+      class NodeCache
+        DEFAULT_NODE_ARITY_LIMIT: Integer
+
+        DEFAULT_NODE_DESCENDANT_LIMIT: Integer
+
+        # @type var empty_trivia: Array[GreenTrivia]
+        EMPTY_TRIVIA: Array[GreenTrivia]
+
+        @nodes: Hash[GreenNode, GreenNode]
+
+        @tokens: Hash[Integer, Array[GreenToken]]
+
+        @trivia: Hash[Integer, Array[GreenTrivia]]
+
+        @node_descendant_limit: Integer
+
+        @node_arity_limit: Integer
+
+        @enabled: bool
+
+        # @rbs (?enabled: bool, ?node_arity_limit: Integer, ?node_descendant_limit: Integer) -> void
+        def initialize: (?enabled: bool, ?node_arity_limit: Integer, ?node_descendant_limit: Integer) -> void
+
+        # Intern trivia before constructing it, using byte-equivalent text within this session.
+        # @rbs (kind: Integer, text: String) -> GreenTrivia
+        def intern_trivia_fields: (kind: Integer, text: String) -> GreenTrivia
+
+        # @rbs (GreenToken token) -> GreenToken
+        def intern_token: (GreenToken token) -> GreenToken
+
+        # Intern a token before constructing it, avoiding discarded duplicate immutable values.
+        # @rbs (kind: Integer, text: String, ?leading: Array[GreenTrivia], ?trailing: Array[GreenTrivia],
+        #   ?flags: Integer, ?expected_kind: Integer?) -> GreenToken
+        def intern_token_fields: (kind: Integer, text: String, ?leading: Array[GreenTrivia], ?trailing: Array[GreenTrivia], ?flags: Integer, ?expected_kind: Integer?) -> GreenToken
+
+        # @rbs (GreenNode node) -> GreenNode
+        def intern_node: (GreenNode node) -> GreenNode
+
+        # @rbs () -> void
+        def clear: () -> void
+
+        private
+
+        # @rbs (Integer kind, String text, Array[GreenTrivia] leading, Array[GreenTrivia] trailing,
+        #   Integer flags, Integer? expected_kind) -> Integer
+        def token_signature: (Integer kind, String text, Array[GreenTrivia] leading, Array[GreenTrivia] trailing, Integer flags, Integer? expected_kind) -> Integer
+
+        # @rbs (Array[GreenToken]? bucket, Integer kind, String text, Array[GreenTrivia] leading,
+        #   Array[GreenTrivia] trailing, Integer flags, Integer? expected_kind) -> GreenToken?
+        def find_token: (Array[GreenToken]? bucket, Integer kind, String text, Array[GreenTrivia] leading, Array[GreenTrivia] trailing, Integer flags, Integer? expected_kind) -> GreenToken?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# Generated from lib/ibex/runtime/cst/green/node.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    module CST
+      # Immutable position-independent syntax node.
+      class GreenNode
+        type child = GreenNode | GreenToken
+
+        attr_reader kind: Integer
+
+        attr_reader children: Array[child]
+
+        attr_reader flags: Integer
+
+        attr_reader intrinsic_flags: Integer
+
+        attr_reader annotations: Array[SyntaxAnnotation]
+
+        attr_reader full_width: Integer
+
+        attr_reader leading_width: Integer
+
+        attr_reader trailing_width: Integer
+
+        attr_reader descendant_count: Integer
+
+        # @rbs (kind: Integer, children: Array[child], ?flags: Integer, ?annotations: Array[SyntaxAnnotation]) -> void
+        def initialize: (kind: Integer, children: Array[child], ?flags: Integer, ?annotations: Array[SyntaxAnnotation]) -> void
+
+        # @rbs () -> String
+        def to_source: () -> String
+
+        # @rbs (untyped other) -> bool
+        def ==: (untyped other) -> bool
+
+        alias eql? ==
+
+        # @rbs () -> Integer
+        def hash: () -> Integer
+
+        private
+
+        # @rbs (Enumerable[child] children, Symbol reader) -> Integer
+        def edge_width: (Enumerable[child] children, Symbol reader) -> Integer
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# Generated from lib/ibex/runtime/cst/green/token.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    module CST
+      # Immutable position-independent terminal occurrence.
+      class GreenToken
+        # @type var empty_trivia: Array[GreenTrivia]
+        EMPTY_TRIVIA: Array[GreenTrivia]
+
+        attr_reader kind: Integer
+
+        attr_reader text: String
+
+        attr_reader leading: Array[GreenTrivia]
+
+        attr_reader trailing: Array[GreenTrivia]
+
+        attr_reader flags: Integer
+
+        attr_reader full_width: Integer
+
+        attr_reader leading_width: Integer
+
+        attr_reader trailing_width: Integer
+
+        attr_reader expected_kind: Integer?
+
+        attr_reader hash: Integer
+
+        # @rbs (kind: Integer, text: String, ?leading: Array[GreenTrivia], ?trailing: Array[GreenTrivia],
+        #   ?flags: Integer, ?expected_kind: Integer?) -> void
+        def initialize: (kind: Integer, text: String, ?leading: Array[GreenTrivia], ?trailing: Array[GreenTrivia], ?flags: Integer, ?expected_kind: Integer?) -> void
+
+        # @rbs (kind: Integer, expected_kind: Integer) -> GreenToken
+        def self.missing: (kind: Integer, expected_kind: Integer) -> GreenToken
+
+        # @rbs (kind: Integer, text: String, ?leading: Array[GreenTrivia]) -> GreenToken
+        def self.lexical_error: (kind: Integer, text: String, ?leading: Array[GreenTrivia]) -> GreenToken
+
+        # @rbs () -> Integer
+        def descendant_count: () -> Integer
+
+        # @rbs () -> String
+        def to_source: () -> String
+
+        # @rbs (untyped other) -> bool
+        def ==: (untyped other) -> bool
+
+        alias eql? ==
+
+        private
+
+        # @rbs (Array[GreenTrivia] trivia) -> Integer
+        def trivia_width: (Array[GreenTrivia] trivia) -> Integer
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# Generated from lib/ibex/runtime/cst/green/trivia.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    module CST
+      # Immutable source text ignored by the grammar but owned by a token.
+      class GreenTrivia
+        attr_reader kind: Integer
+
+        attr_reader text: String
+
+        attr_reader full_width: Integer
+
+        attr_reader hash: Integer
+
+        # @rbs (kind: Integer, text: String) -> void
+        def initialize: (kind: Integer, text: String) -> void
+
+        # @rbs () -> String
+        def to_source: () -> String
+
+        # @rbs (untyped other) -> bool
+        def ==: (untyped other) -> bool
+
+        alias eql? ==
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+# Generated from lib/ibex/runtime/cst/incremental/blender.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    module CST
+      # A Green nonterminal that can replace its old LR shift/reduce sequence.
+      class ReusableSubtree
+        attr_reader green: GreenNode
+
+        attr_reader lhs: Integer
+
+        attr_reader left_state: Integer
+
+        attr_reader left_states: Array[Integer?]
+
+        attr_reader previous_trailing: Array[GreenTrivia]
+
+        # @rbs (green: GreenNode, lhs: Integer, left_state: Integer, left_states: Array[Integer?],
+        #   previous_trailing: Array[GreenTrivia]) -> void
+        def initialize: (green: GreenNode, lhs: Integer, left_state: Integer, left_states: Array[Integer?], previous_trailing: Array[GreenTrivia]) -> void
+      end
+
+      # A state-aware token source that substitutes validated old subtrees.
+      class Blender
+        class Candidate
+          attr_reader entry: ReusableSubtree
+
+          attr_reader token_count: Integer
+
+          # @rbs (entry: ReusableSubtree, token_count: Integer) -> void
+          def initialize: (entry: ReusableSubtree, token_count: Integer) -> void
+        end
+
+        UNSAFE_FLAGS: Integer
+
+        attr_reader reused_descendants: Integer
+
+        attr_reader decomposed_nodes: Integer
+
+        attr_reader fallback_reason: Symbol?
+
+        @token_index: Integer
+
+        @old_tokens: Array[GreenToken]
+
+        @new_offsets: Hash[Integer, Integer]
+
+        @candidates: Hash[Integer, Array[Candidate]]
+
+        @enabled: bool
+
+        @max_decomposed_nodes: Integer
+
+        @edits: Array[TextEdit]
+
+        @lexed: LexedSyntax
+
+        @parse_memo: ParseMemo
+
+        @old_root: SyntaxNode
+
+        # @rbs (old_root: SyntaxNode, parse_memo: ParseMemo, lexed: LexedSyntax, edits: Array[TextEdit],
+        #   max_decomposed_nodes: Integer, ?enabled: bool) -> void
+        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
+        def token_count: () -> Integer
+
+        private
+
+        # @rbs () -> bool
+        def reusable_root?: () -> bool
+
+        # @rbs () -> void
+        def build_candidates: () -> void
+
+        # @rbs (GreenNode | GreenToken element, offset: Integer, preorder: Integer, token_index: Integer) ->
+        #   [Integer, Integer, Integer]
+        def walk: (GreenNode | GreenToken element, offset: Integer, preorder: Integer, token_index: Integer) -> [ Integer, Integer, Integer ]
+
+        # @rbs (GreenNode node, Integer preorder, Integer old_offset, Integer start_token, Integer end_token) -> void
+        def add_candidate: (GreenNode node, Integer preorder, Integer old_offset, Integer start_token, Integer end_token) -> void
+
+        # @rbs (GreenNode node, Integer old_offset) -> bool
+        def reusable_node?: (GreenNode node, Integer old_offset) -> bool
+
+        # @rbs (Integer start_offset, Integer finish_offset) -> bool
+        def outside_damage?: (Integer start_offset, Integer finish_offset) -> bool
+
+        # @rbs (Integer old_offset) -> Integer
+        def translated_offset: (Integer old_offset) -> Integer
+
+        # @rbs (Integer old_index, Integer new_index, Integer count) -> bool
+        def matching_tokens?: (Integer old_index, Integer new_index, Integer count) -> bool
+
+        # @rbs (Integer old_index, Integer new_index) -> bool
+        def matching_follow_token?: (Integer old_index, Integer new_index) -> bool
+
+        # @rbs (Integer token_index) -> Array[GreenTrivia]
+        def previous_trailing: (Integer token_index) -> Array[GreenTrivia]
+
+        # @rbs (Array[Integer] offsets) -> Hash[Integer, Integer]
+        def offset_index: (Array[Integer] offsets) -> Hash[Integer, Integer]
+
+        # @rbs () -> void
+        def consume_decomposition_budget!: () -> void
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# Generated from lib/ibex/runtime/cst/incremental/lexed_syntax.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    module CST
+      # One complete generated-lexer pass, including the explicit EOF token.
+      class LexedSyntax
+        attr_reader raw_tokens: Array[Array[untyped]]
+
+        attr_reader memo: TokenMemo
+
+        # @rbs (raw_tokens: Array[Array[untyped]], memo: TokenMemo) -> void
+        def initialize: (raw_tokens: Array[Array[untyped]], memo: TokenMemo) -> void
+
+        # @rbs (TokenMemo replacement) -> LexedSyntax
+        def with_memo: (TokenMemo replacement) -> LexedSyntax
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# Generated from lib/ibex/runtime/cst/incremental/parse_memo.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    module CST
+      # Parser-state metadata parallel to Green preorder occurrences.
+      class ParseMemo
+        VERSION: Integer
+
+        ENTRY_BYTES: Integer
+
+        attr_reader left_states: Array[Integer?]
+
+        attr_reader grammar_digest: String
+
+        attr_reader state_count: Integer
+
+        attr_reader production_count: Integer
+
+        # @rbs (left_states: Array[Integer?], grammar_digest: String, state_count: Integer,
+        #   production_count: Integer) -> void
+        def initialize: (left_states: Array[Integer?], grammar_digest: String, state_count: Integer, production_count: Integer) -> void
+
+        # @rbs (Integer preorder_index) -> Integer?
+        def left_state: (Integer preorder_index) -> Integer?
+
+        # @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 () -> Integer
+        def estimated_bytes: () -> Integer
+
+        # @rbs () -> Hash[String, untyped]
+        def to_h: () -> Hash[String, untyped]
+
+        # Lightweight construction tree flattened once when a parse completes.
+        class Entry
+          # @type var empty_children: Array[Entry]
+          EMPTY_CHILDREN: Array[Entry]
+
+          @state: Integer?
+
+          @children: Array[Entry]
+
+          @segment: Array[Integer?]?
+
+          # @rbs (Integer? state, ?children: Array[Entry], ?segment: Array[Integer?]?) -> void
+          def initialize: (Integer? state, ?children: Array[Entry], ?segment: Array[Integer?]?) -> void
+
+          # @rbs (Array[Integer?] output) -> void
+          def append_to: (Array[Integer?] output) -> void
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# Generated from lib/ibex/runtime/cst/incremental/relexer.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    module CST
+      # Result of comparing one fresh lexical pass with the prior token memo.
+      class RelexResult
+        attr_reader memo: TokenMemo
+
+        attr_reader reused_count: Integer
+
+        attr_reader scanned_count: Integer
+
+        attr_reader resynchronized_at: Integer?
+
+        # @rbs (memo: TokenMemo, reused_count: Integer, scanned_count: Integer,
+        #   resynchronized_at: Integer?) -> void
+        def initialize: (memo: TokenMemo, reused_count: Integer, scanned_count: Integer, resynchronized_at: Integer?) -> void
+
+        # @rbs () -> Float
+        def reused_ratio: () -> Float
+      end
+
+      # Sound Stage-A comparison: scan from the beginning and reuse only exact
+      # token/state/boundary matches, then recognize a shifted suffix boundary.
+      class Relexer
+        # @rbs (TokenMemo previous, TokenMemo current, Array[TextEdit] edits) -> RelexResult
+        def self.reconcile: (TokenMemo previous, TokenMemo current, Array[TextEdit] edits) -> RelexResult
+
+        # @rbs (Array[TextEdit] edits) -> [Integer, Integer, Integer]
+        def self.edit_window: (Array[TextEdit] edits) -> [ Integer, Integer, Integer ]
+
+        # @rbs (TokenMemo memo) -> Hash[Integer, Integer]
+        def self.offset_index: (TokenMemo memo) -> Hash[Integer, Integer]
+
+        # @rbs (TokenMemo previous, TokenMemo current, Array[GreenToken] tokens,
+        #   Hash[Integer, Integer] old_by_offset, Integer damage, Integer delta, Integer resync_boundary) ->
+        #   [Integer, Integer, Integer?]
+        def self.reuse_tokens: (TokenMemo previous, TokenMemo current, Array[GreenToken] tokens, Hash[Integer, Integer] old_by_offset, Integer damage, Integer delta, Integer resync_boundary) -> [ Integer, Integer, Integer? ]
+
+        # @rbs (TokenMemo previous, TokenMemo current, Integer index, Integer new_offset, Integer delta,
+        #   Integer boundary, Hash[Integer, Integer] old_by_offset) -> [Integer, Integer]?
+        def self.reusable_suffix: (TokenMemo previous, TokenMemo current, Integer index, Integer new_offset, Integer delta, Integer boundary, Hash[Integer, Integer] old_by_offset) -> [ Integer, Integer ]?
+
+        # @rbs (Array[GreenToken] target, Array[GreenToken] source, Integer target_index,
+        #   Integer source_index, Integer length) -> void
+        def self.copy_suffix: (Array[GreenToken] target, Array[GreenToken] source, Integer target_index, Integer source_index, Integer length) -> void
+
+        # @rbs (TokenMemo previous, Integer old_index, TokenMemo current, Integer new_index) -> bool
+        def self.reusable_token?: (TokenMemo previous, Integer old_index, TokenMemo current, Integer new_index) -> bool
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# Generated from lib/ibex/runtime/cst/incremental/session.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    module CST
+      # Raised when incremental parsing cannot preserve its syntax-only contract.
+      class IncrementalUnsupportedError < ArgumentError
+      end
+
+      # A mutable, single-owner session around immutable source and syntax results.
+      class IncrementalParseSession
+        attr_reader source_text: SourceText
+
+        attr_reader result: SyntaxResult
+
+        attr_reader token_memo: TokenMemo
+
+        attr_reader parse_memo: ParseMemo
+
+        attr_reader last_relex_result: RelexResult?
+
+        attr_reader last_blender: Blender?
+
+        @mutex: Mutex
+
+        @blender_enabled: bool
+
+        @cache: NodeCache
+
+        @parser: Parser
+
+        @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
+
+        # Apply edits expressed against the current source and return syntax only.
+        # @rbs (Array[TextEdit] edits) -> SyntaxResult
+        def edit: (Array[TextEdit] edits) -> SyntaxResult
+
+        # Observe parser and incremental runtime events.
+        # @rbs () { (Event) -> void } -> Observation::Subscription
+        def observe: () { (Event) -> void } -> Observation::Subscription
+
+        # @rbs (Observation::Subscription subscription) -> bool
+        def unobserve: (Observation::Subscription subscription) -> bool
+
+        private
+
+        # @rbs (Array[TextEdit] edits) -> SyntaxResult
+        def edit_locked: (Array[TextEdit] edits) -> SyntaxResult
+
+        # @rbs () -> LexedSyntax?
+        def scan_current: () -> LexedSyntax?
+
+        # @rbs (SyntaxNode old_root, ParseMemo old_memo, LexedSyntax lexed, Array[TextEdit] edits) -> Blender
+        def build_blender: (SyntaxNode old_root, ParseMemo old_memo, LexedSyntax lexed, Array[TextEdit] edits) -> Blender
+
+        # @rbs (RelexResult relexed, Blender blender) -> SyntaxResult
+        def finish_blended_edit: (RelexResult relexed, Blender blender) -> SyntaxResult
+
+        # @rbs (Blender blender, GreenNode root, RelexResult relexed) -> Float
+        def blender_reused_ratio: (Blender blender, GreenNode root, RelexResult relexed) -> Float
+
+        # @rbs (Blender blender, RelexResult relexed, Float reused_ratio) -> void
+        def emit_reuse_event: (Blender blender, RelexResult relexed, Float reused_ratio) -> void
+
+        # @rbs () -> void
+        def validate_parser!: () -> void
+
+        # @rbs (Float reused_ratio) -> [SyntaxResult, TokenMemo, ParseMemo]
+        def parse_current: (Float reused_ratio) -> [ SyntaxResult, TokenMemo, ParseMemo ]
+
+        # Error trees cannot be reused, but retain position-aligned disposable memo storage.
+        # @rbs (GreenNode root) -> ParseMemo
+        def empty_parse_memo: (GreenNode root) -> ParseMemo
+
+        # @rbs (Blender blender) -> void
+        def report_blender_fallback: (Blender blender) -> void
+
+        # @rbs (TokenMemo previous_memo, Array[TextEdit] edits, Symbol reason) -> SyntaxResult
+        def finish_full_fallback: (TokenMemo previous_memo, Array[TextEdit] edits, Symbol reason) -> SyntaxResult
+
+        # @rbs () -> void
+        def enforce_memo_budget!: () -> void
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# Generated from lib/ibex/runtime/cst/incremental/token_memo.rb with RBS::Inline
+
+module Ibex
+  module Runtime
+    module CST
+      # Session-local token metadata used to validate lexical resynchronization.
+      class TokenMemo
+        ENTRY_BYTES: Integer
+
+        attr_reader tokens: Array[GreenToken]
+
+        attr_reader offsets: Array[Integer]
+
+        attr_reader states: Array[Symbol]
+
+        # @rbs (tokens: Array[GreenToken], offsets: Array[Integer], states: Array[Symbol]) -> void
+        def initialize: (tokens: Array[GreenToken], offsets: Array[Integer], states: Array[Symbol]) -> void
+
+        # @rbs (SyntaxNode root, ?states: Array[Symbol]) -> TokenMemo
+        def self.from_root: (SyntaxNode root, ?states: Array[Symbol]) -> TokenMemo
+
+        # The first token whose owned full span contains or follows an edit.
+        # @rbs (Array[TextEdit] edits) -> Integer?
+        def damage_index: (Array[TextEdit] edits) -> Integer?
+
+        # @rbs () -> Integer
+        def estimated_bytes: () -> Integer
+      end
+    end
+  end
+end