ibex 0.1.0 → 0.2.0

data/lib/ibex/lsp/document_store.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module Ibex
+  module LSP
+    # Owns open buffers, parsed snapshots, include closures, and reverse dependencies.
+    class DocumentStore
+      include DocumentStoreValidation
+      include DocumentStoreDiagnostics
+
+      # @rbs!
+      #   type snapshot = {
+      #     uri: String,
+      #     path: String,
+      #     version: Integer?,
+      #     source: String,
+      #     open: bool,
+      #     document: Frontend::SourceDocument?
+      #   }
+      #   type publication = {
+      #     uri: String,
+      #     ?version: Integer,
+      #     diagnostics: Array[WorkspaceAnalyzer::lsp_diagnostic]
+      #   }
+
+      attr_reader :loader #: Frontend::SourceLoader
+      attr_reader :workspace #: Workspace
+
+      # @rbs (Workspace workspace, Frontend::SourceLoader loader) -> void
+      def initialize(workspace, loader)
+        @workspace = workspace
+        @loader = loader
+        @analyzer = WorkspaceAnalyzer.new(workspace, loader)
+        @snapshots = {} #: Hash[String, snapshot]
+        @roots = {} #: Hash[String, bool]
+        @closures = {} #: Hash[String, Array[String]]
+        @reverse_dependencies = {} #: Hash[String, Array[String]]
+        @resolutions = {} #: Hash[String, Frontend::Resolution]
+        @document_diagnostics = {} #: Hash[String, Array[WorkspaceAnalyzer::lsp_diagnostic]]
+        @root_diagnostics = {} #: Hash[String, Hash[String, Array[WorkspaceAnalyzer::lsp_diagnostic]]]
+      end
+
+      # @rbs (String uri, Integer version, String source) -> Array[publication]
+      def open(uri, version, source)
+        path = workspace.path(uri)
+        raise ProtocolError.new("document is already open: #{uri}", code: -32_602) if @snapshots.dig(path, :open)
+
+        validate_version(version)
+        validate_source(source)
+        loader.set_overlay(path, source)
+        @snapshots[path] = snapshot(uri, path, version, source, true, nil)
+        refresh(path)
+      end
+
+      # @rbs (String uri, Integer version, String source) -> Array[publication]
+      def change(uri, version, source)
+        path = workspace.path(uri)
+        current = open_snapshot(path, uri)
+        validate_version(version)
+        unless current.fetch(:version) && version > current.fetch(:version)
+          raise ProtocolError.new("document version must increase monotonically", code: -32_602)
+        end
+
+        validate_source(source)
+        loader.set_overlay(path, source)
+        @snapshots[path] = snapshot(uri, path, version, source, true, nil)
+        refresh(path)
+      end
+
+      # @rbs (String uri, ?source: String?) -> Array[publication]
+      def save(uri, source: nil)
+        path = workspace.path(uri)
+        current = open_snapshot(path, uri)
+        if source
+          validate_source(source)
+          loader.set_overlay(path, source)
+          current = snapshot(uri, path, current.fetch(:version), source, true, nil)
+          @snapshots[path] = current
+        end
+        refresh(path)
+      end
+
+      # Clear the open version first, then replace it with a disk snapshot if one exists.
+      # @rbs (String uri) -> Array[publication]
+      def close(uri)
+        path = workspace.path(uri)
+        open_snapshot(path, uri)
+        clear = { uri: uri, diagnostics: [] } #: publication
+        old_files = files_for(path)
+        was_root = @roots[path]
+        disk_path = disk_path_for_close(path, uri)
+        disk_source = loader.disk_source(disk_path) if disk_path && loader.disk_file?(disk_path)
+        loader.delete_overlay(path)
+        if disk_source
+          @snapshots[path] = snapshot(uri, path, nil, disk_source, false, nil)
+          if was_root
+            analyzed = @analyzer.analyze(path)
+            update_snapshot(path, analyzed)
+            remove_root_state(path)
+            [clear] + publish_paths((old_files + [path]).uniq)
+          else
+            [clear] + refresh(path)
+          end
+        else
+          remove_path(path)
+          [clear] + refresh_dependents(path)
+        end
+      end
+
+      # @rbs (String path) -> snapshot?
+      def snapshot_for(path)
+        @snapshots[path]
+      end
+
+      # Preserve the URI spelling used to open a document; closed files use their canonical URI.
+      # @rbs (String path) -> String
+      def uri_for(path)
+        entry = @snapshots[path]
+        return entry.fetch(:uri) if entry&.fetch(:open)
+
+        workspace.uri(path)
+      end
+
+      # @rbs (String path) -> Array[String]
+      def files_for(path)
+        roots = affected_roots(path)
+        files = roots.flat_map { |root| @closures.fetch(root, [root]) }
+        (files + [path]).uniq
+      end
+
+      # @rbs (String path) -> Array[Frontend::Resolution]
+      def resolutions_for(path)
+        affected_roots(path).filter_map { |root| @resolutions[root] }
+      end
+
+      # @rbs (String path) -> Array[String]
+      def roots_for(path)
+        affected_roots(path)
+      end
+
+      private
+
+      # @rbs (String path) -> Array[publication]
+      def refresh(path)
+        old_files = files_for(path)
+        previous_roots = affected_roots(path)
+        was_root = @roots[path]
+        analyzed = @analyzer.analyze(path)
+        update_snapshot(path, analyzed)
+        update_root_membership(path, analyzed.fetch(:document))
+        remove_root_state(path) if was_root && !@roots[path]
+        roots = (previous_roots + affected_roots(path)).uniq
+        roots.delete(path) unless @roots[path]
+        roots.each { |root| refresh_root(root) }
+        publish_paths((old_files + files_for(path) + [path]).uniq)
+      end
+
+      # @rbs (String path) -> Array[publication]
+      def refresh_dependents(path)
+        roots = affected_roots(path)
+        roots.each { |root| refresh_root(root) }
+        publish_paths(roots.flat_map { |root| @closures.fetch(root, [root]) }.uniq)
+      end
+
+      # @rbs (String root) -> void
+      def refresh_root(root)
+        files, analyzed = @analyzer.closure(root)
+        @closures[root] = files
+        rebuild_reverse_dependencies
+        analyzed.each { |path, result| update_snapshot(path, result, own_diagnostics: false) }
+        parse_failed = analyzed.any? do |path, result|
+          !result.fetch(:diagnostics).empty? && loader.file?(path)
+        end
+        resolution, errors = parse_failed ? [nil, []] : @analyzer.resolve(root)
+        resolution ? @resolutions[root] = resolution : @resolutions.delete(root)
+        replace_root_diagnostics(root, files, analyzed, errors)
+      end
+
+      # @rbs () -> void
+      def rebuild_reverse_dependencies
+        reverse = Hash.new { |hash, key| hash[key] = [] } #: Hash[String, Array[String]]
+        @closures.each { |root, files| files.each { |file| reverse[file] << root } }
+        @reverse_dependencies = reverse
+      end
+
+      # @rbs (String path) -> Array[String]
+      def affected_roots(path)
+        roots = @reverse_dependencies.fetch(path, empty_paths).dup
+        roots << path if @roots[path]
+        roots.uniq
+      end
+
+      # @rbs (String path, WorkspaceAnalyzer::analyzed_document analyzed, ?own_diagnostics: bool) -> void
+      def update_snapshot(path, analyzed, own_diagnostics: true)
+        current = @snapshots[path]
+        uri = current&.fetch(:uri) || workspace.uri(path)
+        version = current&.fetch(:version)
+        open = current&.fetch(:open) || false
+        source = open ? current.fetch(:source) : analyzed.fetch(:source)
+        document = analyzed.fetch(:document)
+        @snapshots[path] = snapshot(uri, path, version, source, open, document)
+        @document_diagnostics[path] = analyzed.fetch(:diagnostics) if own_diagnostics
+      end
+
+      # @rbs (String path, Frontend::SourceDocument? document) -> void
+      def update_root_membership(path, document)
+        if document&.ast.is_a?(Frontend::AST::Root)
+          @roots[path] = true
+        else
+          @roots.delete(path)
+        end
+      end
+
+      # @rbs (Array[String] paths) -> Array[publication]
+      def publish_paths(paths)
+        paths.filter_map do |path|
+          entry = @snapshots[path]
+          next unless entry
+
+          publication = {
+            uri: entry.fetch(:uri),
+            diagnostics: aggregated_diagnostics(path)
+          } #: publication
+          publication[:version] = entry.fetch(:version) if entry.fetch(:open) && entry.fetch(:version)
+          publication
+        end
+      end
+
+      # @rbs (String uri, String path, Integer? version, String source, bool open,
+      #   Frontend::SourceDocument? document) -> snapshot
+      def snapshot(uri, path, version, source, open, document)
+        { uri: uri, path: path, version: version, source: source, open: open, document: document }
+      end
+
+      # @rbs (String path, String uri) -> snapshot
+      def open_snapshot(path, uri)
+        entry = @snapshots[path]
+        return entry if entry&.fetch(:open) && entry.fetch(:uri) == uri
+
+        raise ProtocolError.new("document is not open: #{uri}", code: -32_602)
+      end
+
+      # @rbs () -> Array[String]
+      def empty_paths
+        [] #: Array[String]
+      end
+
+      # @rbs (String path) -> void
+      def remove_path(path)
+        @snapshots.delete(path)
+        @document_diagnostics.delete(path)
+        remove_root_state(path)
+      end
+
+      # @rbs (String path) -> void
+      def remove_root_state(path)
+        @roots.delete(path)
+        @closures.delete(path)
+        @resolutions.delete(path)
+        @root_diagnostics.delete(path)
+        rebuild_reverse_dependencies
+      end
+    end
+  end
+end

data/lib/ibex/lsp/document_store_diagnostics.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Ibex
+  module LSP
+    # Owns per-document and per-root diagnostic aggregation for DocumentStore.
+    module DocumentStoreDiagnostics
+      private
+
+      # @rbs (String root, Array[String] files, Hash[String, WorkspaceAnalyzer::analyzed_document] analyzed,
+      #   Array[WorkspaceAnalyzer::lsp_diagnostic] errors) -> void
+      def replace_root_diagnostics(root, files, analyzed, errors)
+        # @type self: DocumentStore
+        owned = {} #: Hash[String, Array[WorkspaceAnalyzer::lsp_diagnostic]]
+        files.each { |path| owned[path] = analyzed.dig(path, :diagnostics) || [] }
+        errors.each do |diagnostic|
+          file = diagnostic.dig("data", "file")
+          next unless file
+
+          existing = owned[file] || []
+          duplicate = existing.any? do |entry|
+            entry["range"] == diagnostic["range"] && entry["message"] == diagnostic["message"]
+          end
+          owned[file] = existing + [diagnostic] unless duplicate
+        end
+        @root_diagnostics[root] = owned
+      end
+
+      # @rbs (String path) -> Array[WorkspaceAnalyzer::lsp_diagnostic]
+      def aggregated_diagnostics(path)
+        # @type self: DocumentStore
+        diagnostics = @document_diagnostics.fetch(path, empty_diagnostics).dup
+        @root_diagnostics.each_value do |owned|
+          diagnostics.concat(owned.fetch(path, empty_diagnostics))
+        end
+        diagnostics.uniq
+      end
+
+      # @rbs () -> Array[WorkspaceAnalyzer::lsp_diagnostic]
+      def empty_diagnostics
+        [] #: Array[WorkspaceAnalyzer::lsp_diagnostic]
+      end
+    end
+  end
+end

data/lib/ibex/lsp/document_store_validation.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Ibex
+  module LSP
+    # Validates versions, source bounds, and prospective multi-file workspace edits.
+    module DocumentStoreValidation
+      # @rbs (Hash[String, String] replacements) -> bool
+      def valid_replacements?(replacements)
+        # @type self: DocumentStore
+        candidate = Frontend::SourceLoader.new
+        @snapshots.each_value do |entry|
+          candidate.set_overlay(entry.fetch(:path), entry.fetch(:source)) if entry.fetch(:open)
+        end
+        replacements.each do |path, source|
+          candidate.set_overlay(path, source)
+          parse_candidate(path, source)
+        end
+        roots = replacements.keys.flat_map { |path| affected_roots(path) }.uniq
+        roots.each { |root| Frontend::Resolver.new(root, mode: :extended, loader: candidate).resolve }
+        true
+      rescue Ibex::Error, SystemCallError
+        false
+      end
+
+      private
+
+      # @rbs (Integer version) -> void
+      def validate_version(version)
+        raise ProtocolError.new("document version must be a non-negative integer", code: -32_602) unless
+          version.is_a?(Integer) && !version.negative?
+      end
+
+      # @rbs (String source) -> void
+      def validate_source(source)
+        raise ProtocolError.new("document text must be a string", code: -32_602) unless source.is_a?(String)
+        return if source.bytesize <= Limits::MAX_DOCUMENT_BYTES
+
+        raise ProtocolError.new("document exceeds #{Limits::MAX_DOCUMENT_BYTES} bytes", code: -32_602)
+      end
+
+      # @rbs (String path, String source) -> void
+      def parse_candidate(path, source)
+        Frontend::Parser.new(source, file: path, mode: :extended).parse_source_document
+      end
+
+      # Resolve disk independently from overlay aliases before removing an open buffer.
+      # @rbs (String path, String uri) -> String?
+      def disk_path_for_close(path, uri)
+        # @type self: DocumentStore
+        canonical = loader.disk_path(path)
+        return canonical if workspace.root_for(canonical)
+
+        raise ProtocolError.new("document disk target is outside workspace roots: #{uri}", code: -32_602)
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        nil
+      rescue SystemCallError => e
+        raise ProtocolError.new("cannot resolve document disk target #{uri.inspect}: #{e.message}", code: -32_602)
+      end
+    end
+  end
+end

data/lib/ibex/lsp/initialization_handlers.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Ibex
+  module LSP
+    # Handles initialize/initialized/shutdown/exit lifecycle transitions.
+    module InitializationHandlers
+      include RequestSupport
+
+      private
+
+      # @rbs (untyped raw_params) -> Hash[String, untyped]
+      def initialize_workspace(raw_params)
+        raise ProtocolError.new("server is already initialized", code: -32_600) unless @state == :uninitialized
+
+        params = params_hash(raw_params)
+        loader = Frontend::SourceLoader.new
+        @workspace = Workspace.new(initialization_roots(params), loader)
+        @store = DocumentStore.new(@workspace, loader)
+        @state = :initialized
+        {
+          "capabilities" => capabilities,
+          "serverInfo" => { "name" => "ibex", "version" => Ibex::VERSION }
+        }
+      end
+
+      # @rbs (untyped params) -> nil
+      def initialized_notification(_params)
+        require_state!(:initialized)
+        @state = :running
+        nil
+      end
+
+      # @rbs (untyped params) -> nil
+      def shutdown_request(_params)
+        require_state!(:running)
+        @state = :shutdown
+        nil
+      end
+
+      # @rbs (untyped params) -> nil
+      def exit_notification(_params)
+        @exit_status = @state == :shutdown ? 0 : 1
+        @exit_requested = true
+        nil
+      end
+
+      # @rbs () -> Hash[String, untyped]
+      def capabilities
+        {
+          "positionEncoding" => "utf-16",
+          "textDocumentSync" => { "openClose" => true, "change" => 1, "save" => { "includeText" => true } },
+          "definitionProvider" => true,
+          "referencesProvider" => true,
+          "renameProvider" => { "prepareProvider" => true },
+          "hoverProvider" => true,
+          "workspace" => { "workspaceFolders" => { "supported" => true, "changeNotifications" => false } }
+        }
+      end
+
+      # @rbs (Hash[String, untyped] params) -> Array[String]
+      def initialization_roots(params)
+        folders = params["workspaceFolders"]
+        if folders.is_a?(Array) && !folders.empty?
+          return folders.map do |folder|
+            raise ProtocolError.new("workspaceFolders entries must be objects", code: -32_602) unless folder.is_a?(Hash)
+
+            string_member(folder, "uri")
+          end
+        end
+
+        root = params["rootUri"]
+        return [root] if root.is_a?(String)
+
+        raise ProtocolError.new("initialize requires rootUri or workspaceFolders", code: -32_602)
+      end
+    end
+  end
+end

data/lib/ibex/lsp/navigation_handlers.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Ibex
+  module LSP
+    # Serves symbol navigation, rename, and hover requests.
+    module NavigationHandlers
+      include RequestSupport
+
+      private
+
+      # @rbs (untyped raw_params) -> Array[Hash[String, untyped]]
+      def definition(raw_params)
+        with_index(raw_params) { |index, path, position| index.definition(path, position) }
+      end
+
+      # @rbs (untyped raw_params) -> Array[Hash[String, untyped]]
+      def references(raw_params)
+        params = params_hash(raw_params)
+        context = hash_member(params, "context")
+        include_declaration = context["includeDeclaration"] == true
+        with_index(params) do |index, path, position|
+          index.references(path, position, include_declaration: include_declaration)
+        end
+      end
+
+      # @rbs (untyped raw_params) -> Hash[String, untyped]?
+      def prepare_rename(raw_params)
+        with_index(raw_params) { |index, path, position| index.prepare_rename(path, position) }
+      end
+
+      # @rbs (untyped raw_params) -> Hash[String, untyped]
+      def rename(raw_params)
+        params = params_hash(raw_params)
+        new_name = string_member(params, "newName")
+        with_index(params) { |index, path, position| index.rename(path, position, new_name) }
+      end
+
+      # @rbs (untyped raw_params) -> Hash[String, untyped]?
+      def hover(raw_params)
+        with_index(raw_params) { |index, path, position| index.hover(path, position) }
+      end
+
+      # @rbs (untyped raw_params) { (SymbolIndex, String, Hash[String, untyped]) -> untyped } -> untyped
+      def with_index(raw_params)
+        require_running!
+        params = params_hash(raw_params)
+        document = hash_member(params, "textDocument")
+        path = workspace.path(string_member(document, "uri"))
+        position = hash_member(params, "position")
+        yield SymbolIndex.new(store, path), path, position
+      rescue ArgumentError => e
+        raise ProtocolError.new(e.message, code: -32_602)
+      end
+    end
+  end
+end

data/lib/ibex/lsp/position_codec.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Ibex
+  module LSP
+    # Converts between frontend byte offsets and zero-based LSP UTF-16 positions.
+    class PositionCodec
+      # @rbs (String source) -> void
+      def initialize(source)
+        @source = Frontend::SourceEncoding.validated_utf8(source, "(lsp)")
+        @line_starts = build_line_starts.freeze #: Array[Integer]
+      end
+
+      # @rbs (Integer byte_offset) -> Hash[String, Integer]
+      def position(byte_offset)
+        validate_byte_offset(byte_offset)
+        prefix = @source.byteslice(0, byte_offset) || ""
+        raise ArgumentError, "byte offset is not on a UTF-8 character boundary" unless prefix.valid_encoding?
+
+        line = (@line_starts.bsearch_index { |start| start > byte_offset } || @line_starts.length) - 1
+        line_start = @line_starts.fetch(line)
+        line_end = content_end(line)
+        raise ArgumentError, "byte offset points inside a line ending" if byte_offset > line_end
+
+        text = @source.byteslice(line_start, byte_offset - line_start) || ""
+        { "line" => line, "character" => utf16_length(text) }
+      end
+
+      # @rbs (Hash[String, untyped] position) -> Integer
+      def byte_offset(position)
+        line = integer_member(position, "line")
+        character = integer_member(position, "character")
+        raise ArgumentError, "line and character must be non-negative" if line.negative? || character.negative?
+
+        line_start = @line_starts[line]
+        raise ArgumentError, "line is outside the document" unless line_start
+
+        text = @source.byteslice(line_start, content_end(line) - line_start) || ""
+        line_start + byte_length_at_utf16(text, character)
+      end
+
+      # @rbs (Frontend::SourceSpan span) -> Hash[String, Hash[String, Integer]]
+      def range(span)
+        { "start" => position(span.start_byte), "end" => position(span.end_byte) }
+      end
+
+      private
+
+      # @rbs () -> Array[Integer]
+      def build_line_starts
+        starts = [0]
+        offset = 0
+        @source.each_char do |character|
+          offset += character.bytesize
+          starts << offset if character == "\n"
+        end
+        starts
+      end
+
+      # @rbs (Integer line) -> Integer
+      def content_end(line)
+        boundary = @line_starts[line + 1] || @source.bytesize
+        return boundary unless @line_starts[line + 1]
+
+        before_newline = boundary - 1
+        @source.getbyte(before_newline - 1) == 13 ? before_newline - 1 : before_newline
+      end
+
+      # @rbs (String text) -> Integer
+      def utf16_length(text)
+        text.each_codepoint.sum { |codepoint| codepoint > 0xFFFF ? 2 : 1 }
+      end
+
+      # @rbs (String text, Integer units) -> Integer
+      def byte_length_at_utf16(text, units)
+        consumed_units = 0
+        consumed_bytes = 0
+        text.each_char do |character|
+          return consumed_bytes if consumed_units == units
+
+          width = character.ord > 0xFFFF ? 2 : 1
+          if consumed_units + width > units
+            raise ArgumentError, "character points into the middle of a UTF-16 surrogate pair"
+          end
+
+          consumed_units += width
+          consumed_bytes += character.bytesize
+        end
+        return consumed_bytes if consumed_units == units
+
+        raise ArgumentError, "character is outside the document line"
+      end
+
+      # @rbs (Hash[String, untyped] position, String name) -> Integer
+      def integer_member(position, name)
+        value = position[name]
+        raise ArgumentError, "#{name} must be an integer" unless value.is_a?(Integer)
+
+        value
+      end
+
+      # @rbs (Integer byte_offset) -> void
+      def validate_byte_offset(byte_offset)
+        return if byte_offset.is_a?(Integer) && byte_offset.between?(0, @source.bytesize)
+
+        raise ArgumentError, "byte offset is outside the document"
+      end
+    end
+  end
+end

data/lib/ibex/lsp/protocol_error.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Ibex
+  module LSP
+    # Resource bounds shared by transport and open-document validation.
+    module Limits
+      MAX_HEADER_BYTES = 16 * 1024
+      MAX_MESSAGE_BYTES = 1024 * 1024
+      MAX_DOCUMENT_BYTES = 2 * 1024 * 1024
+      MAX_OUTPUT_BYTES = 1024 * 1024
+      MAX_ERROR_MESSAGE_CHARACTERS = 1024
+      MAX_REQUEST_ID_BYTES = 256
+    end
+
+    # Bounded protocol and workspace failures with their JSON-RPC error code.
+    class ProtocolError < Ibex::Error
+      attr_reader :code #: Integer
+      attr_reader :request_id #: String | Integer | nil
+      attr_reader :fatal #: bool
+
+      # @rbs (String message, ?code: Integer, ?request_id: String | Integer | nil, ?fatal: bool) -> void
+      def initialize(message, code: -32_600, request_id: nil, fatal: false)
+        normalized = message.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+        bounded = normalized[0, Limits::MAX_ERROR_MESSAGE_CHARACTERS] || ""
+        bounded += "…" if bounded.length < normalized.length
+        super("(lsp):1:1: #{bounded}")
+        @code = code
+        @request_id = request_id
+        @fatal = fatal
+      end
+    end
+  end
+end

data/lib/ibex/lsp/request_handlers.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Ibex
+  module LSP
+    # Dispatches the finite LSP surface to focused lifecycle, document, and navigation handlers.
+    module RequestHandlers
+      include InitializationHandlers
+      include DocumentHandlers
+      include NavigationHandlers
+      include RequestSupport
+
+      HANDLERS = {
+        "initialize" => :initialize_workspace,
+        "initialized" => :initialized_notification,
+        "shutdown" => :shutdown_request,
+        "exit" => :exit_notification,
+        "textDocument/didOpen" => :did_open,
+        "textDocument/didChange" => :did_change,
+        "textDocument/didSave" => :did_save,
+        "textDocument/didClose" => :did_close,
+        "textDocument/definition" => :definition,
+        "textDocument/references" => :references,
+        "textDocument/prepareRename" => :prepare_rename,
+        "textDocument/rename" => :rename,
+        "textDocument/hover" => :hover,
+        "$/cancelRequest" => :cancel_request
+      }.freeze #: Hash[String, Symbol]
+
+      private
+
+      # @rbs (String method, untyped params) -> untyped
+      def dispatch(method, params)
+        handler = HANDLERS[method]
+        raise ProtocolError.new("method not found: #{method}", code: -32_601) unless handler
+
+        send(handler, params)
+      end
+
+      # @rbs (untyped params) -> nil
+      def cancel_request(_params)
+        nil
+      end
+    end
+  end
+end