sadr 0.1.0 → 0.2.0

data/lib/sadr/client.rb

@@ -8,8 +8,39 @@ module Sadr
       definition: "definition",
       type_definition: "typeDefinition",
       implementation: "implementation",
-      signature_help: "signatureHelp"
+      signature_help: "signatureHelp",
+      prepare_rename: "prepareRename",
+      document_highlight: "documentHighlight",
+      prepare_call_hierarchy: "prepareCallHierarchy",
+      prepare_type_hierarchy: "prepareTypeHierarchy",
+      linked_editing_range: "linkedEditingRange"
     }.freeze
+    RESPONSE_KINDS = {
+      "completion" => :completion,
+      "hover" => :hover,
+      "definition" => :locations,
+      "typeDefinition" => :locations,
+      "implementation" => :locations,
+      "references" => :locations,
+      "rename" => :workspace_edit,
+      "prepareRename" => :prepare_rename,
+      "documentHighlight" => :document_highlights,
+      "prepareCallHierarchy" => :hierarchy_items,
+      "prepareTypeHierarchy" => :hierarchy_items,
+      "linkedEditingRange" => :linked_editing_ranges,
+      "signatureHelp" => :signature_help,
+      "documentSymbol" => :document_symbols,
+      "formatting" => :text_edits,
+      "rangeFormatting" => :text_edits,
+      "codeAction" => :code_actions,
+      "codeLens" => :code_lenses,
+      "inlayHint" => :inlay_hints,
+      "foldingRange" => :folding_ranges,
+      "documentLink" => :document_links,
+      "diagnostic" => :diagnostic
+    }.freeze
+    RESPONSE_ITEM_LIMIT = 10_000
+    private_constant :RESPONSE_ITEM_LIMIT
 
     attr_reader :capabilities, :transport, :diagnostics, :state, :errors, :server_info, :position_encoding
 
@@ -20,85 +51,93 @@ module Sadr
       @restart = restart
       @env = env
       @initialization_options = initialization_options
-      @configuration = configuration
+      @configuration = json_snapshot(configuration, "configuration must be JSON")
       @pending = {}
       @handlers = {}
       @documents = {}
       @diagnostics = {}
       @semantic = {}
+      @semantic_requests = Hash.new(0)
       @sequence = 0
       @lock = Mutex.new
+      @document_lock = Mutex.new
+      @configuration_lock = Mutex.new
+      @connecting_transport = nil
       @state = :stopped
       @restarts = 0
       @epoch = 0
+      @semantic_generation = 0
       @errors = []
       @capabilities = {}
     end
 
     def start(timeout: 10)
-      raise Error, "language server is already started" if %i[starting running].include?(@state)
+      connect(timeout: timeout, state: :starting)
+      @lock.synchronize do
+        raise Error, "language server closed during initialization" unless @state == :starting
 
-      @closing = false
-      @state = :starting
-      epoch = (@epoch += 1)
-      @semantic.clear
-      @transport = Transport.new(@command, cwd: @root, env: @env) do |message, error|
-        receive(message, error, epoch)
+        @state = :running
       end
-      result = request("initialize", initialize_params).await(timeout: timeout)
-      raise Error, "invalid initialize result" unless result.is_a?(Hash) && result["capabilities"].is_a?(Hash)
-
-      @capabilities = result["capabilities"]
-      @server_info = result["serverInfo"]
-      validate_capabilities
-      notify("initialized", {})
-      @state = :running
-      self
-    rescue StandardError => error
-      @transport&.close if epoch
-      fail_pending(error) if epoch
-      @state = :failed if epoch
-      raise
+      @capabilities
     end
 
     def stop
-      @closing = true
+      running, transport, stop_epoch, connecting, restart_thread = @lock.synchronize do
+        @closing = true
+        [@state == :running, @transport, @epoch, @connecting_transport, @restart_thread]
+      end
+      shutdown = nil
       begin
-        request("shutdown").await(timeout: 2) if @state == :running
-        notify("exit") if @transport&.alive?
-      rescue Error
-        nil
+        shutdown = Thread.new do
+          locked = false
+          begin
+            locked = @document_lock.try_lock
+            next unless locked
+
+            send_request("shutdown", {}, nil, state: :running, epoch: stop_epoch, transport: transport, allow_closing: true).await(timeout: 2)
+            send_notification("exit", {}, state: :running, epoch: stop_epoch, transport: transport, allow_closing: true) if transport&.alive?
+          rescue Error
+            nil
+          ensure
+            @document_lock.unlock if locked
+          end
+        end if running
+        shutdown&.join(2)
       ensure
-        @epoch += 1
-        @documents.clear
-        @semantic.clear
-        @diagnostics.clear
-        @transport&.close
-        fail_pending(Error.new("language server stopped"))
-        @state = :stopped
+        [transport, connecting].compact.uniq.each(&:close)
+        [shutdown, restart_thread].compact.uniq.each { |thread| finish_thread(thread) }
+        pending = @lock.synchronize do
+          next unless @epoch == stop_epoch && @transport.equal?(transport)
+
+          @epoch += 1
+          @documents.clear
+          @semantic.clear
+          @semantic_requests.clear
+          @semantic_generation += 1
+          @diagnostics.clear
+          @connecting_transport = nil
+          @restart_thread = nil
+          @state = :stopped
+          values = @pending.values
+          @pending.clear
+          values
+        end
+        error = Error.new("language server stopped")
+        pending&.each { |future, _| future.fulfill(error: error) }
       end
     end
 
-    def running? = @state == :running && !!@transport&.alive?
+    def running?
+      transport = @lock.synchronize { @transport if @state == :running && !@closing }
+      !!transport&.alive?
+    end
 
     def request(method, params = {})
-      id = @lock.synchronize { @sequence += 1 }
-      future = Future.new(id, on_error: method(:report_error)) { |number| cancel(number) }
-      @lock.synchronize { @pending[id] = future }
-      raise Error, "language server is not connected" unless @transport&.alive?
-
-      @transport.write(jsonrpc: "2.0", id: id, method: method.to_s, params: params)
-      future
-    rescue StandardError => error
-      @lock.synchronize { @pending.delete(id) }
-      future.fulfill(error: error)
-      future
+      send_request(method, params, nil)
     end
 
     def notify(method, params = {})
-      raise Error, "language server is not connected" unless @transport&.alive?
-
-      @transport.write(jsonrpc: "2.0", method: method.to_s, params: params)
+      send_notification(method, params)
     end
 
     def on(method, &handler)
@@ -110,72 +149,100 @@ module Sadr
     def supports?(capability) = !!@capabilities[capability.to_s]
 
     def open(document)
-      validate_document(document)
-      stored = Document.new(uri: document.uri.dup.freeze, language_id: document.language_id.dup.freeze,
-        version: document.version, text: document.text.dup.freeze)
-      @documents[stored.uri] = stored
-      notify_open(stored) if open_close?
+      uri, language_id, text = validate_document(document)
+      stored = Document.new(uri: uri.freeze, language_id: language_id.freeze,
+        version: document.version, text: text.freeze)
+      @document_lock.synchronize do
+        send_open = @lock.synchronize do
+          ensure_running!
+          @documents[stored.uri] = stored
+          @diagnostics.delete(stored.uri)
+          @semantic.delete(stored.uri)
+          open_close?
+        end
+        notify_open(stored) if send_open
+      end
       stored.uri
     end
 
     def change(uri, version, changes)
-      document = @documents.fetch(uri) { raise Error, "document is not open" }
-      unless Protocol.uint?(version) && version > document.version
-        raise Error, "document version must increase"
-      end
-      raise Error, "content changes must be a nonempty Array" unless changes.is_a?(Array) && !changes.empty?
-
-      text = document.text
-      wire_changes = changes.map do |change|
-        validate_change(change)
-        if change.range
-          index = DocumentIndex.new(text)
-          first = Protocol.offset(index, change.range.start)
-          last = Protocol.offset(index, change.range.end)
-          raise Error, "invalid content change range" if last < first
-
-          text = text.byteslice(0, first) + change.text + text.byteslice(last, text.bytesize - last)
-          {range: Protocol.range_hash(change.range), text: change.text}
-        else
-          text = change.text
-          {text: change.text}
+      uri = valid_uri(uri)
+      @document_lock.synchronize do
+        updated, notification = @lock.synchronize do
+          ensure_running!
+          document = @documents.fetch(uri) { raise Error, "document is not open" }
+          unless Protocol.uint?(version) && version > document.version
+            raise Error, "document version must increase"
+          end
+          raise Error, "content changes must be a nonempty Array" unless changes.is_a?(Array) && !changes.empty?
+
+          text = document.text
+          wire_changes = changes.map do |change|
+            change_text = validate_change(change)
+            if change.range
+              index = DocumentIndex.new(text)
+              first = Protocol.offset(index, change.range.start)
+              last = Protocol.offset(index, change.range.end)
+              raise Error, "invalid content change range" if last < first
+
+              text = text.byteslice(0, first) + change_text + text.byteslice(last, text.bytesize - last)
+              {range: Protocol.range_hash(change.range), text: change_text}
+            else
+              text = change_text
+              {text: change_text}
+            end
+          end
+          updated = Document.new(uri: document.uri, language_id: document.language_id, version: version, text: text.freeze)
+          @documents[uri] = updated
+
+          mode = sync_mode
+          notification = if [1, 2].include?(mode)
+            content_changes = mode == 2 ? wire_changes : [{text: text}]
+            {textDocument: {uri: uri, version: version}, contentChanges: content_changes}
+          end
+          [updated, notification]
         end
+        notify("textDocument/didChange", notification) if notification
+        updated
       end
-      updated = Document.new(uri: document.uri, language_id: document.language_id, version: version, text: text.freeze)
-      @documents[uri] = updated
-
-      mode = sync_mode
-      return updated unless [1, 2].include?(mode)
-
-      content_changes = mode == 2 ? wire_changes : [{text: text}]
-      notify("textDocument/didChange", {textDocument: {uri: uri, version: version}, contentChanges: content_changes})
-      updated
     rescue KeyError
       raise Error, "document is not open"
     end
 
     def save(uri, text: nil)
-      document = @documents.fetch(uri) { raise Error, "document is not open" }
-      sync = @capabilities["textDocumentSync"]
-      save = sync.is_a?(Hash) ? sync["save"] : sync.is_a?(Integer) && sync.positive?
-      return unless save
-
-      if text
-        raise Error, "saved text must be valid UTF-8" unless text.is_a?(String) && text.valid_encoding?
+      uri = valid_uri(uri)
+      text = utf8_string(text, "saved text must be valid UTF-8") unless text.nil?
+      @document_lock.synchronize do
+        params = @lock.synchronize do
+          ensure_running!
+          document = @documents.fetch(uri) { raise Error, "document is not open" }
+          sync = @capabilities["textDocumentSync"]
+          save = sync.is_a?(Hash) ? sync["save"] : sync.is_a?(Integer) && sync.positive?
+          next unless save
+
+          value = {textDocument: {uri: uri}}
+          value[:text] = text || document.text if save.is_a?(Hash) && save["includeText"]
+          value
+        end
+        notify("textDocument/didSave", params) if params
       end
-      params = {textDocument: {uri: uri}}
-      params[:text] = text || document.text if save.is_a?(Hash) && save["includeText"]
-      notify("textDocument/didSave", params)
     rescue KeyError
       raise Error, "document is not open"
     end
 
     def close(uri)
-      raise Error, "document is not open" unless @documents.delete(uri)
-
-      @diagnostics.delete(uri)
-      @semantic.delete(uri)
-      notify("textDocument/didClose", {textDocument: {uri: uri}}) if open_close?
+      uri = valid_uri(uri)
+      @document_lock.synchronize do
+        send_close = @lock.synchronize do
+          ensure_running!
+          raise Error, "document is not open" unless @documents.delete(uri)
+
+          @diagnostics.delete(uri)
+          @semantic.delete(uri)
+          open_close?
+        end
+        notify("textDocument/didClose", {textDocument: {uri: uri}}) if send_close
+      end
     end
 
     POSITION_METHODS.each do |ruby_name, lsp_name|
@@ -189,7 +256,7 @@ module Sadr
     end
 
     def rename(uri, position, new_name)
-      raise Error, "new name must be a String" unless new_name.is_a?(String) && new_name.valid_encoding?
+      new_name = utf8_string(new_name, "new name must be a valid UTF-8 String")
 
       request_at("rename", uri, position, newName: new_name)
     end
@@ -202,6 +269,10 @@ module Sadr
       request_document("formatting", uri, options: options)
     end
 
+    def range_formatting(uri, range, options)
+      request_document("rangeFormatting", uri, range: Protocol.range_hash(range), options: formatting_options(options))
+    end
+
     def code_action(uri, range, context)
       raise Error, "code action context must be an object" unless context.is_a?(Hash)
 
@@ -210,11 +281,51 @@ module Sadr
 
     def code_lens(uri) = request_document("codeLens", uri)
     def inlay_hint(uri, range) = request_document("inlayHint", uri, range: Protocol.range_hash(range))
+    def folding_range(uri) = request_document("foldingRange", uri)
+    def document_link(uri) = request_document("documentLink", uri)
+
+    def selection_range(uri, positions)
+      raise Error, "positions must be an Array" unless positions.is_a?(Array)
+
+      wire_positions = positions.map { |position| Protocol.position_hash(position) }
+      params = {textDocument: {uri: valid_uri(uri)}, positions: wire_positions}
+      send_request("textDocument/selectionRange", params, lambda do |value|
+        raise Error, "invalid LSP response" unless valid_selection_ranges?(value, wire_positions)
+
+        value
+      end)
+    end
+
+    def did_change_configuration(settings)
+      settings = json_snapshot(settings, "settings must be JSON")
+      @configuration_lock.synchronize do
+        @lock.synchronize do
+          ensure_running!
+          @configuration = settings
+        end
+        notify("workspace/didChangeConfiguration", settings: settings)
+      end
+    end
+
+    def did_change_watched_files(events)
+      raise Error, "file events must be an Array" unless events.is_a?(Array)
+
+      values = events.map do |event|
+        raise Error, "invalid file event" unless event.is_a?(Hash)
+
+        uri = event.key?(:uri) ? event[:uri] : event["uri"]
+        type = event.key?(:type) ? event[:type] : event["type"]
+        raise Error, "invalid file event" unless type.is_a?(Integer) && type.between?(1, 3)
+
+        {uri: valid_uri(uri), type: type}
+      end
+      notify("workspace/didChangeWatchedFiles", changes: values)
+    end
 
     def diagnostic(uri, previous_result_id: nil)
       params = {}
       if previous_result_id
-        raise Error, "previous result id must be a String" unless previous_result_id.is_a?(String)
+        previous_result_id = utf8_string(previous_result_id, "previous result id must be a valid UTF-8 String")
 
         params[:previousResultId] = previous_result_id
       end
@@ -222,43 +333,60 @@ module Sadr
     end
 
     def semantic_tokens(uri, version:)
-      document = @documents[uri]
-      return [] unless document && document.version == version
-
-      provider = @capabilities["semanticTokensProvider"]
-      return [] unless provider.is_a?(Hash) && provider["full"]
+      document, provider, previous, generation, request_sequence = @lock.synchronize do
+        document = @documents[uri]
+        provider = @capabilities["semanticTokensProvider"]
+        request_sequence = @semantic_requests[uri] += 1 if document&.version == version && provider.is_a?(Hash) && provider["full"]
+        [document, provider, @semantic[uri], @semantic_generation, request_sequence]
+      end
+      return [] unless request_sequence
 
-      previous = @semantic[uri]
       delta = previous && previous[0] && provider["full"].is_a?(Hash) && provider["full"]["delta"]
       method = delta ? "textDocument/semanticTokens/full/delta" : "textDocument/semanticTokens/full"
       params = {textDocument: {uri: uri}}
       params[:previousResultId] = previous[0] if delta
-      result = request(method, params).await
-      current = @documents[uri]
-      return [] unless result && current && current.version == version
+      result = checked_request(method, params, :semantic).await
 
-      valid = result.is_a?(Hash) && (!result.key?("resultId") || result["resultId"].is_a?(String))
-      raise Error, "invalid semantic token result" unless valid
-      raise Error, "unexpected semantic token delta" if !delta && !result.key?("data")
+      @lock.synchronize do
+        current = @documents[uri]
+        current_request = @semantic_requests[uri]
+        return [] unless result && current.equal?(document) && current.version == version &&
+          generation == @semantic_generation && request_sequence == current_request
+
+        raise Error, "unexpected semantic token delta" if !delta && !result.key?("data")
 
-      data = result["data"] || Protocol.semantic_delta(previous[1], result["edits"])
-      tokens = Protocol.semantic_tokens(data, legend: provider["legend"])
-      @semantic[uri] = [result["resultId"], data]
-      tokens
+        data = result["data"] || Protocol.semantic_delta(previous[1], result["edits"])
+        tokens = Protocol.semantic_tokens(data, legend: provider["legend"])
+        @semantic[uri] = [result["resultId"], data]
+        tokens
+      end
     end
 
     def workspace_symbols(query)
-      raise Error, "query must be a String" unless query.is_a?(String)
+      query = utf8_string(query, "query must be a valid UTF-8 String")
 
-      request("workspace/symbol", {query: query})
+      checked_request("workspace/symbol", {query: query}, :workspace_symbols)
     end
 
-    def resolve_completion(item) = resolve("completionItem/resolve", item)
-    def resolve_code_action(action) = resolve("codeAction/resolve", action)
-    def resolve_code_lens(lens) = resolve("codeLens/resolve", lens)
+    def resolve_completion(item) = resolve("completionItem/resolve", item, :completion_item)
+    def resolve_code_action(action) = resolve("codeAction/resolve", action, :code_action)
+    def resolve_code_lens(lens) = resolve("codeLens/resolve", lens, :code_lens)
+
+    def resolve_document_link(link)
+      link = json_snapshot(link, "document link must be JSON")
+      raise Error, "invalid document link" unless valid_document_link?(link)
+
+      checked_request("documentLink/resolve", link, :document_link)
+    end
+
+    def call_hierarchy_incoming_calls(item) = hierarchy_request("callHierarchy/incomingCalls", item, :incoming_calls)
+    def call_hierarchy_outgoing_calls(item) = hierarchy_request("callHierarchy/outgoingCalls", item, :outgoing_calls)
+    def type_hierarchy_supertypes(item) = hierarchy_request("typeHierarchy/supertypes", item, :hierarchy_items)
+    def type_hierarchy_subtypes(item) = hierarchy_request("typeHierarchy/subtypes", item, :hierarchy_items)
 
     def execute_command(command, arguments: [])
-      raise Error, "command must be a nonempty String" unless command.is_a?(String) && !command.empty?
+      command = utf8_string(command, "command must be a nonempty valid UTF-8 String")
+      raise Error, "command must be a nonempty valid UTF-8 String" if command.empty?
       raise Error, "arguments must be an Array" unless arguments.is_a?(Array)
 
       request("workspace/executeCommand", {command: command, arguments: arguments})
@@ -266,6 +394,548 @@ module Sadr
 
     private
 
+    def finish_thread(thread)
+      return if thread == Thread.current || thread.join(1)
+
+      thread.kill
+      thread.join(1)
+    end
+
+    def send_request(method, params, validator, state: :running, epoch: nil, transport: nil, allow_closing: false)
+      target = request_epoch = future = id = nil
+      @lock.synchronize do
+        id = @sequence += 1
+        target = connected_transport(state: state, epoch: epoch, transport: transport, allow_closing: allow_closing)
+        request_epoch = @epoch
+        future = Future.new(id, on_error: method(:report_error)) { |number| cancel(number, target, request_epoch) }
+        @pending[id] = [future, validator] if target
+      end
+      raise Error, "language server is not connected" unless target&.alive?
+
+      target.write(jsonrpc: "2.0", id: id, method: method.to_s, params: params)
+      future
+    rescue StandardError => error
+      @lock.synchronize { @pending.delete(id) }
+      future.fulfill(error: error)
+      future
+    end
+
+    def checked_request(method, params, kind, within: nil, **options)
+      send_request(method, params, ->(value) { validate_response(kind, value, within: within) }, **options)
+    end
+
+    def send_notification(method, params, state: :running, epoch: nil, transport: nil, allow_closing: false)
+      target = @lock.synchronize do
+        connected_transport(state: state, epoch: epoch, transport: transport, allow_closing: allow_closing)
+      end
+      raise Error, "language server is not connected" unless target&.alive?
+
+      target.write(jsonrpc: "2.0", method: method.to_s, params: params)
+    end
+
+    def connected_transport(state:, epoch:, transport:, allow_closing:)
+      return if state && @state != state
+      return if !allow_closing && @closing
+      return if epoch && @epoch != epoch
+      return if transport && !@transport.equal?(transport)
+
+      @transport
+    end
+
+    def connect(timeout:, state:, expected_epoch: nil)
+      transport = nil
+      epoch = @lock.synchronize do
+        if expected_epoch && (@epoch != expected_epoch || @closing || @state != :failed)
+          raise Error, "language server restart was cancelled"
+        end
+        raise Error, "language server is already started" if %i[starting restarting running].include?(@state)
+
+        @closing = false if state == :starting
+        @state = state
+        @epoch += 1
+        @semantic.clear
+        @semantic_requests.clear
+        @semantic_generation += 1
+        @epoch
+      end
+      transport = build_transport(epoch)
+      installed = @lock.synchronize do
+        next false unless @epoch == epoch && @state == state && !@closing
+
+        @transport = transport
+        @connecting_transport = nil if @connecting_transport.equal?(transport)
+        true
+      end
+      raise Error, "language server connection was cancelled" unless installed
+
+      result = checked_request("initialize", initialize_params, :initialize, state: state, epoch: epoch, transport: transport).await(timeout: timeout)
+      @lock.synchronize do
+        unless @epoch == epoch && @state == state && !@closing && @transport.equal?(transport)
+          raise Error, "language server connection was cancelled"
+        end
+        @capabilities = result["capabilities"]
+        @server_info = result["serverInfo"]
+        validate_capabilities
+      end
+      send_notification("initialized", {}, state: state, epoch: epoch, transport: transport)
+      @capabilities
+    rescue StandardError => error
+      transport&.close
+      active = @lock.synchronize do
+        next false unless epoch && @epoch == epoch
+
+        @state = :failed unless @closing
+        !@closing
+      end
+      fail_pending(error) if active
+      raise
+    ensure
+      @lock.synchronize do
+        @connecting_transport = nil if @connecting_transport.equal?(transport)
+      end
+    end
+
+    def build_transport(epoch)
+      Transport.new(@command, cwd: @root, env: @env, on_spawn: ->(transport) {
+        tracked = @lock.synchronize do
+          next false unless @epoch == epoch && !@closing && %i[starting restarting].include?(@state)
+
+          @connecting_transport = transport
+          true
+        end
+        unless tracked
+          transport.close
+          raise Error, "language server connection was cancelled"
+        end
+      }) do |message, error|
+        receive(message, error, epoch)
+      end
+    end
+
+    def fulfill_response(entry, message)
+      return unless entry
+
+      future, validator = entry
+      if message["error"]
+        future.fulfill(error: ServerError.new(message["error"]))
+      else
+        value = validator ? validator.call(message["result"]) : message["result"]
+        future.fulfill(value)
+      end
+    rescue StandardError => error
+      future&.fulfill(error: error)
+    end
+
+    def validate_response(kind, value, within: nil)
+      case kind
+      when :initialize
+        valid = value.is_a?(Hash) && value["capabilities"].is_a?(Hash)
+      when :hover
+        valid = valid_hover?(value)
+      when :signature_help
+        valid = valid_signature_help?(value)
+      when :document_symbols
+        valid = valid_document_symbols?(value)
+      when :workspace_symbols
+        valid = valid_workspace_symbols?(value)
+      when :locations
+        valid = value.nil? || valid_locations?(value)
+      when :prepare_rename
+        valid = valid_prepare_rename?(value)
+      when :document_highlights
+        valid = value.nil? || (value.is_a?(Array) && value.all? { |highlight| valid_document_highlight?(highlight) })
+      when :hierarchy_items
+        valid = value.nil? || (value.is_a?(Array) && value.length <= RESPONSE_ITEM_LIMIT &&
+          value.all? { |item| valid_hierarchy_item?(item) })
+      when :incoming_calls
+        valid = value.nil? || (value.is_a?(Array) && value.length <= RESPONSE_ITEM_LIMIT &&
+          value.all? { |call| valid_incoming_call?(call) })
+      when :outgoing_calls
+        valid = value.nil? || (value.is_a?(Array) && value.length <= RESPONSE_ITEM_LIMIT &&
+          value.all? { |call| valid_outgoing_call?(call, within: within) })
+      when :linked_editing_ranges
+        valid = valid_linked_editing_ranges?(value)
+      when :completion
+        valid = valid_completion?(value)
+      when :completion_item
+        valid = valid_completion_item?(value)
+      when :workspace_edit
+        valid = value.nil?
+        Protocol.workspace_edit(value) unless valid
+        valid = true
+      when :text_edits
+        valid = value.nil?
+        validate_text_edits(value) unless valid
+        valid = true
+      when :code_actions
+        valid = value.nil? || value.is_a?(Array)
+        value&.each do |action|
+          raise Error, "invalid LSP response" unless valid_code_action?(action)
+
+          Protocol.workspace_edit(action["edit"]) if action["edit"]
+        end
+      when :code_action
+        valid = valid_code_action?(value)
+        Protocol.workspace_edit(value["edit"]) if valid && value["edit"]
+      when :code_lenses
+        valid = value.nil? || value.is_a?(Array)
+        value&.each { |lens| validate_code_lens(lens) }
+      when :code_lens
+        valid = value.is_a?(Hash)
+        validate_code_lens(value) if valid
+      when :inlay_hints
+        valid = value.nil? || value.is_a?(Array)
+        value&.each { |hint| validate_inlay_hint(hint) }
+      when :folding_ranges
+        valid = value.nil? || (value.is_a?(Array) && value.all? { |range| valid_folding_range?(range) })
+      when :document_links
+        valid = value.nil? || (value.is_a?(Array) && value.length <= RESPONSE_ITEM_LIMIT &&
+          value.all? { |link| valid_document_link?(link) })
+      when :document_link
+        valid = valid_document_link?(value)
+      when :diagnostic
+        valid = value.nil? || valid_diagnostic_report?(value)
+      when :semantic
+        valid = value.nil? || (value.is_a?(Hash) &&
+          (!value.key?("resultId") || value["resultId"].is_a?(String)) &&
+          (!value.key?("data") || value["data"].is_a?(Array)) &&
+          (!value.key?("edits") || value["edits"].is_a?(Array)))
+      else
+        valid = false
+      end
+      raise Error, "invalid LSP response" unless valid
+
+      value
+    rescue KeyError, NoMethodError
+      raise Error, "invalid LSP response"
+    end
+
+    def valid_completion?(value)
+      return true if value.nil?
+
+      items = if value.is_a?(Hash)
+        return false unless boolean?(value["isIncomplete"])
+
+        value["items"]
+      else
+        value
+      end
+      items.is_a?(Array) && items.all? { |item| valid_completion_item?(item) }
+    end
+
+    def valid_completion_item?(item)
+      item.is_a?(Hash) && item["label"].is_a?(String)
+    end
+
+    def valid_hover?(hover)
+      return true if hover.nil?
+      return false unless hover.is_a?(Hash) && hover.key?("contents") && valid_hover_contents?(hover["contents"])
+
+      Protocol.range_value(hover["range"]) if hover.key?("range")
+      true
+    end
+
+    def valid_hover_contents?(contents)
+      return true if contents.is_a?(String)
+      return contents.all? { |item| valid_marked_string?(item) } if contents.is_a?(Array)
+      return false unless contents.is_a?(Hash)
+
+      if contents.key?("kind")
+        %w[plaintext markdown].include?(contents["kind"]) && contents["value"].is_a?(String)
+      else
+        valid_marked_string?(contents)
+      end
+    end
+
+    def valid_marked_string?(value)
+      value.is_a?(String) || (value.is_a?(Hash) && value["language"].is_a?(String) && value["value"].is_a?(String))
+    end
+
+    def valid_signature_help?(help)
+      return true if help.nil?
+      return false unless help.is_a?(Hash) && help["signatures"].is_a?(Array)
+      return false unless optional_uint?(help, "activeSignature") && optional_uint?(help, "activeParameter")
+
+      help["signatures"].all? { |signature| valid_signature?(signature) }
+    end
+
+    def valid_signature?(signature)
+      return false unless signature.is_a?(Hash) && signature["label"].is_a?(String)
+      return false unless optional_uint?(signature, "activeParameter")
+      return true unless signature.key?("parameters")
+
+      signature["parameters"].is_a?(Array) && signature["parameters"].all? do |parameter|
+        next false unless parameter.is_a?(Hash)
+
+        label = parameter["label"]
+        label.is_a?(String) || (label.is_a?(Array) && label.length == 2 && label.all? { |offset| Protocol.uint?(offset) } && label[0] <= label[1])
+      end
+    end
+
+    def valid_document_symbols?(value)
+      value.nil? || (value.is_a?(Array) && value.all? do |symbol|
+        symbol.is_a?(Hash) && symbol.key?("location") ? valid_symbol_information?(symbol) : valid_document_symbol?(symbol)
+      end)
+    end
+
+    def valid_document_symbol?(symbol)
+      return false unless valid_symbol?(symbol)
+
+      Protocol.range_value(symbol.fetch("range"))
+      Protocol.range_value(symbol.fetch("selectionRange"))
+      !symbol.key?("children") || (symbol["children"].is_a?(Array) && symbol["children"].all? { |child| valid_document_symbol?(child) })
+    end
+
+    def valid_workspace_symbols?(value)
+      value.nil? || (value.is_a?(Array) && value.all? { |symbol| valid_workspace_symbol?(symbol) })
+    end
+
+    def valid_workspace_symbol?(symbol)
+      return false unless valid_symbol?(symbol) && symbol["location"].is_a?(Hash)
+
+      location = symbol["location"]
+      valid_uri(location.fetch("uri"))
+      Protocol.range_value(location["range"]) if location.key?("range")
+      true
+    end
+
+    def valid_symbol_information?(symbol)
+      valid_symbol?(symbol) && valid_location?(symbol["location"])
+    end
+
+    def valid_symbol?(symbol)
+      symbol.is_a?(Hash) && symbol["name"].is_a?(String) && symbol["kind"].is_a?(Integer) && symbol["kind"].between?(1, 26)
+    end
+
+    def valid_locations?(value)
+      locations = value.is_a?(Array) ? value : [value]
+      locations.all? { |location| valid_location?(location) || valid_location_link?(location) }
+    end
+
+    def valid_prepare_rename?(value)
+      return true if value.nil?
+
+      if value.is_a?(Hash) && (value.key?("defaultBehavior") || value.key?(:defaultBehavior))
+        default_behavior = value.key?("defaultBehavior") ? value["defaultBehavior"] : value[:defaultBehavior]
+        return boolean?(default_behavior)
+      end
+
+      if value.is_a?(Hash) && (value.key?("range") || value.key?(:range))
+        range = value["range"] || value[:range]
+        placeholder = value.key?("placeholder") ? value["placeholder"] : value[:placeholder]
+        return false unless placeholder.is_a?(String)
+
+        Protocol.range_value(range)
+      else
+        Protocol.range_value(value)
+      end
+      true
+    rescue Error, KeyError
+      false
+    end
+
+    def valid_document_highlight?(highlight)
+      return false unless highlight.is_a?(Hash)
+
+      Protocol.range_value(highlight.fetch("range"))
+      !highlight.key?("kind") || (highlight["kind"].is_a?(Integer) && highlight["kind"].between?(1, 3))
+    rescue Error, KeyError
+      false
+    end
+
+    def valid_hierarchy_item?(item)
+      return false unless valid_symbol?(item) && item["uri"].is_a?(String)
+
+      valid_uri(item["uri"])
+      range = Protocol.range_value(item.fetch("range"))
+      selection_range = Protocol.range_value(item.fetch("selectionRange"))
+      return false unless range_contains_range?(range, selection_range)
+      return false if item.key?("detail") && !item["detail"].is_a?(String)
+      return false if item.key?("tags") && !(item["tags"].is_a?(Array) && item["tags"].all? { |tag| tag == 1 })
+
+      json_snapshot(item["data"], "invalid LSP response") if item.key?("data")
+
+      true
+    rescue Error, KeyError
+      false
+    end
+
+    def valid_linked_editing_ranges?(value)
+      return true if value.nil?
+      return false unless value.is_a?(Hash) && value["ranges"].is_a?(Array)
+      return false if value.key?("wordPattern") && !value["wordPattern"].is_a?(String)
+
+      ranges = value["ranges"].map { |range| Protocol.range_value(range) }
+      ranges.sort_by! { |range| position_tuple(range.start) }
+      ranges.each_cons(2).all? { |first, last| position_before_or_equal?(first.end, last.start) }
+    rescue Error
+      false
+    end
+
+    def valid_folding_range?(range)
+      return false unless range.is_a?(Hash)
+
+      first = range["startLine"]
+      last = range["endLine"]
+      return false unless Protocol.uint?(first) && Protocol.uint?(last) && first <= last
+      return false unless optional_uint?(range, "startCharacter") && optional_uint?(range, "endCharacter")
+      return false if range.key?("kind") && !range["kind"].is_a?(String)
+      return false if range.key?("collapsedText") && !range["collapsedText"].is_a?(String)
+
+      first != last || !range.key?("startCharacter") || !range.key?("endCharacter") || range["startCharacter"] <= range["endCharacter"]
+    end
+
+    def valid_selection_ranges?(value, positions)
+      return true if value.nil?
+      return false unless value.is_a?(Array) && value.length == positions.length
+
+      pending = value.each_index.map { |index| [value[index], positions[index], nil, 0] }
+      until pending.empty?
+        selection, position, child_range, depth = pending.pop
+        return false unless selection.is_a?(Hash) && depth < 256
+
+        range = Protocol.range_value(selection.fetch("range"))
+        return false unless range_contains_position?(range, position)
+        return false if child_range && !range_contains_range?(range, child_range)
+
+        pending << [selection["parent"], position, range, depth + 1] if selection.key?("parent")
+      end
+      true
+    rescue Error, KeyError
+      false
+    end
+
+    def valid_document_link?(link)
+      return false unless link.is_a?(Hash)
+
+      Protocol.range_value(link.fetch("range"))
+      valid_uri(link["target"]) if link.key?("target")
+      return false if link.key?("tooltip") && !link["tooltip"].is_a?(String)
+
+      json_snapshot(link["data"], "invalid LSP response") if link.key?("data")
+
+      true
+    rescue Error, KeyError
+      false
+    end
+
+    def range_contains_position?(range, position)
+      range = Protocol.range_value(range)
+      position_before_or_equal?(range.start, position) && position_before_or_equal?(position, range.end)
+    end
+
+    def valid_incoming_call?(call)
+      return false unless call.is_a?(Hash) && valid_hierarchy_item?(call["from"])
+
+      valid_ranges?(call["fromRanges"], within: call["from"]["range"])
+    end
+
+    def valid_outgoing_call?(call, within: nil)
+      call.is_a?(Hash) && valid_hierarchy_item?(call["to"]) && valid_ranges?(call["fromRanges"], within: within)
+    end
+
+    def valid_ranges?(values, within: nil)
+      return false unless values.is_a?(Array) && values.length <= RESPONSE_ITEM_LIMIT
+
+      ranges = values.map { |range| Protocol.range_value(range) }
+      !within || ranges.all? { |range| range_contains_range?(within, range) }
+    rescue Error, KeyError
+      false
+    end
+
+    def range_contains_range?(outer, inner)
+      outer = Protocol.range_value(outer)
+      inner = Protocol.range_value(inner)
+      position_before_or_equal?(outer.start, inner.start) && position_before_or_equal?(inner.end, outer.end)
+    end
+
+    def position_before_or_equal?(first, last)
+      (position_tuple(first) <=> position_tuple(last)) <= 0
+    end
+
+    def position_tuple(value)
+      value = Protocol.position_value(value)
+      [value.line, value.character]
+    end
+
+    def valid_location?(location)
+      return false unless location.is_a?(Hash) && location.key?("uri")
+
+      valid_uri(location["uri"])
+      Protocol.range_value(location.fetch("range"))
+      true
+    end
+
+    def valid_location_link?(location)
+      return false unless location.is_a?(Hash) && location.key?("targetUri")
+
+      valid_uri(location["targetUri"])
+      Protocol.range_value(location.fetch("targetRange"))
+      Protocol.range_value(location.fetch("targetSelectionRange"))
+      Protocol.range_value(location["originSelectionRange"]) if location.key?("originSelectionRange")
+      true
+    end
+
+    def valid_code_action?(action)
+      return false unless action.is_a?(Hash) && action["title"].is_a?(String)
+      return valid_command?(action) if action["command"].is_a?(String)
+      return false if action.key?("command") && !valid_command?(action["command"])
+
+      Protocol.diagnostics(action["diagnostics"]) if action.key?("diagnostics")
+      true
+    end
+
+    def valid_command?(command)
+      command.is_a?(Hash) && command["title"].is_a?(String) && command["command"].is_a?(String) &&
+        (!command.key?("arguments") || command["arguments"].is_a?(Array))
+    end
+
+    def validate_code_lens(lens)
+      raise Error, "invalid LSP response" unless lens.is_a?(Hash)
+
+      Protocol.range_value(lens.fetch("range"))
+      raise Error, "invalid LSP response" if lens.key?("command") && !valid_command?(lens["command"])
+    end
+
+    def validate_inlay_hint(hint)
+      label = hint["label"] if hint.is_a?(Hash)
+      valid_label = label.is_a?(String) || (label.is_a?(Array) && label.all? { |part| part.is_a?(Hash) && part["value"].is_a?(String) })
+      raise Error, "invalid LSP response" unless valid_label
+
+      Protocol.position_value(hint.fetch("position"))
+    end
+
+    def valid_diagnostic_report?(report)
+      return false unless report.is_a?(Hash)
+
+      case report["kind"]
+      when "full"
+        Protocol.diagnostics(report.fetch("items"))
+        true
+      when "unchanged"
+        report["resultId"].is_a?(String)
+      else
+        false
+      end
+    end
+
+    def optional_uint?(value, key)
+      !value.key?(key) || Protocol.uint?(value[key])
+    end
+
+    def boolean?(value) = value == true || value == false
+
+    def validate_text_edits(value)
+      raise Error, "invalid LSP response" unless value.is_a?(Array)
+
+      value.each do |edit|
+        valid = edit.is_a?(Hash) && edit["newText"].is_a?(String) && edit["newText"].valid_encoding?
+        raise Error, "invalid LSP response" unless valid
+
+        Protocol.range_value(edit["range"])
+      end
+    end
+
     def initialize_params
       {
         processId: Process.pid,
@@ -282,6 +952,16 @@ module Sadr
             hover: {contentFormat: %w[markdown plaintext]},
             signatureHelp: {signatureInformation: {documentationFormat: %w[markdown plaintext], parameterInformation: {labelOffsetSupport: true}}},
             documentSymbol: {hierarchicalDocumentSymbolSupport: true},
+            documentHighlight: {dynamicRegistration: false},
+            foldingRange: {dynamicRegistration: false, lineFoldingOnly: false},
+            selectionRange: {dynamicRegistration: false},
+            rename: {dynamicRegistration: false, prepareSupport: true, prepareSupportDefaultBehavior: 1},
+            callHierarchy: {dynamicRegistration: false},
+            typeHierarchy: {dynamicRegistration: false},
+            documentLink: {dynamicRegistration: false, tooltipSupport: true},
+            linkedEditingRange: {dynamicRegistration: false},
+            formatting: {dynamicRegistration: false},
+            rangeFormatting: {dynamicRegistration: false},
             codeAction: {codeActionLiteralSupport: {codeActionKind: {valueSet: %w[quickfix refactor refactor.extract refactor.inline refactor.rewrite source source.organizeImports]}}, resolveSupport: {properties: ["edit"]}},
             publishDiagnostics: {relatedInformation: true, versionSupport: true},
             diagnostic: {dynamicRegistration: false, relatedDocumentSupport: false},
@@ -289,7 +969,9 @@ module Sadr
             codeLens: {dynamicRegistration: false},
             semanticTokens: {requests: {full: {delta: true}}, tokenTypes: %w[namespace type class enum interface struct typeParameter parameter variable property enumMember event function method macro keyword modifier comment string number regexp operator decorator], tokenModifiers: %w[declaration definition readonly static deprecated abstract async modification documentation defaultLibrary], formats: ["relative"], overlappingTokenSupport: false, multilineTokenSupport: false}
           },
-          workspace: {applyEdit: true, configuration: true, workspaceFolders: true, workspaceEdit: {documentChanges: true, resourceOperations: %w[create rename delete], failureHandling: "abort"}}
+          workspace: {applyEdit: true, configuration: true, workspaceFolders: true,
+            didChangeConfiguration: {dynamicRegistration: false}, didChangeWatchedFiles: {dynamicRegistration: false},
+            workspaceEdit: {documentChanges: true, resourceOperations: %w[create rename delete], failureHandling: "abort"}}
         }
       }
     end
@@ -310,46 +992,118 @@ module Sadr
 
     def validate_document(document)
       raise Error, "expected a Document" unless document.is_a?(Document)
-      valid_uri(document.uri)
-      unless document.language_id.is_a?(String) && !document.language_id.empty?
-        raise Error, "language id must be a nonempty String"
-      end
+      uri = valid_uri(document.uri)
+      language_id = utf8_string(document.language_id, "language id must be a nonempty valid UTF-8 String")
+      raise Error, "language id must be a nonempty valid UTF-8 String" if language_id.empty?
       raise Error, "document version must be an unsigned integer" unless Protocol.uint?(document.version)
-      unless document.text.is_a?(String) && document.text.valid_encoding?
-        raise Error, "document text must be valid UTF-8"
-      end
+      text = utf8_string(document.text, "document text must be valid UTF-8")
+      [uri, language_id, text]
+    end
+
+    def ensure_running!
+      raise Error, "language server is not running" unless @state == :running && !@closing
     end
 
     def validate_change(change)
       raise Error, "expected a ContentChange" unless change.is_a?(ContentChange)
-      raise Error, "change text must be valid UTF-8" unless change.text.is_a?(String) && change.text.valid_encoding?
 
       Protocol.range_value(change.range) if change.range
+      utf8_string(change.text, "change text must be valid UTF-8")
     end
 
     def valid_uri(uri)
-      raise Error, "URI must be a nonempty String" unless uri.is_a?(String) && !uri.empty? && !uri.include?("\0") && uri.valid_encoding?
+      uri = utf8_string(uri, "invalid URI")
+      valid = !uri.empty? && !uri.include?("\0")
+      parsed = URI::DEFAULT_PARSER.parse(uri) if valid
+      raise Error, "invalid URI" unless valid && parsed&.scheme && !parsed.scheme.empty?
 
       uri
+    rescue URI::InvalidURIError
+      raise Error, "invalid URI"
+    end
+
+    def formatting_options(value)
+      value = json_snapshot(value, "formatting options must be JSON")
+      valid = value.is_a?(Hash) && Protocol.uint?(value["tabSize"]) && boolean?(value["insertSpaces"])
+      valid &&= value.all? do |key, item|
+        %w[tabSize insertSpaces].include?(key) || boolean?(item) || item.is_a?(String) ||
+          (item.is_a?(Integer) && item.between?(-0x80000000, 0x7fffffff))
+      end
+      raise Error, "invalid formatting options" unless valid
+
+      value
+    end
+
+    def json_snapshot(value, message)
+      pending = [[value, 0]]
+      until pending.empty?
+        item, depth = pending.pop
+        case item
+        when NilClass, TrueClass, FalseClass
+          next
+        when Integer
+          raise Error, message unless item.between?(-0x80000000, 0x7fffffff)
+        when Float
+          raise Error, message unless item.finite?
+        when String
+          raise Error, message unless item.dup.force_encoding(Encoding::UTF_8).valid_encoding?
+        when Array
+          raise Error, message if depth >= 100
+
+          item.each { |child| pending << [child, depth + 1] }
+        when Hash
+          raise Error, message if depth >= 100
+          raise Error, message unless item.keys.all? { |key| key.is_a?(String) || key.is_a?(Symbol) }
+          raise Error, message unless item.keys.map(&:to_s).uniq.length == item.length
+
+          item.each_key do |key|
+            key = key.to_s
+            raise Error, message unless key.dup.force_encoding(Encoding::UTF_8).valid_encoding?
+          end
+          item.each_value { |child| pending << [child, depth + 1] }
+        else
+          raise Error, message
+        end
+      end
+      JSON.parse(JSON.generate(value), freeze: true)
+    rescue JSON::JSONError, EncodingError, RuntimeError
+      raise Error, message
+    end
+
+    def utf8_string(value, message)
+      raise Error, message unless value.is_a?(String)
+
+      value = value.dup.force_encoding(Encoding::UTF_8)
+      raise Error, message unless value.valid_encoding?
+
+      value
     end
 
     def request_at(method, uri, position, params = {})
       core = {textDocument: {uri: valid_uri(uri)}, position: Protocol.position_hash(position)}
-      request("textDocument/#{method}", params.merge(core))
+      checked_request("textDocument/#{method}", params.merge(core), RESPONSE_KINDS.fetch(method))
     end
 
     def request_document(method, uri, **params)
-      request("textDocument/#{method}", params.merge(textDocument: {uri: valid_uri(uri)}))
+      checked_request("textDocument/#{method}", params.merge(textDocument: {uri: valid_uri(uri)}), RESPONSE_KINDS.fetch(method))
+    end
+
+    def hierarchy_request(method, item, kind)
+      item = json_snapshot(item, "hierarchy item must be JSON")
+      raise Error, "invalid hierarchy item" unless valid_hierarchy_item?(item)
+
+      checked_request(method, {item: item}, kind, within: item["range"])
     end
 
-    def resolve(method, value)
+    def resolve(method, value, kind)
       raise Error, "resolve value must be an object" unless value.is_a?(Hash)
 
-      request(method, value)
+      checked_request(method, value, kind)
     end
 
     def notify_open(document)
-      notify("textDocument/didOpen", {textDocument: {uri: document.uri, languageId: document.language_id, version: document.version, text: document.text}})
+      state, epoch, transport = @lock.synchronize { [@state, @epoch, @transport] }
+      send_notification("textDocument/didOpen", {textDocument: {uri: document.uri, languageId: document.language_id, version: document.version, text: document.text}}, state: state, epoch: epoch, transport: transport)
     end
 
     def sync_mode
@@ -362,9 +1116,12 @@ module Sadr
       sync.is_a?(Hash) ? sync["openClose"] : sync.is_a?(Integer) && sync.positive?
     end
 
-    def cancel(id)
-      @lock.synchronize { @pending.delete(id) }
-      notify("$/cancelRequest", {id: id})
+    def cancel(id, transport, epoch)
+      target = @lock.synchronize do
+        @pending.delete(id)
+        connected_transport(state: nil, epoch: epoch, transport: transport, allow_closing: false)
+      end
+      target&.try_write(jsonrpc: "2.0", method: "$/cancelRequest", params: {id: id})
     rescue Error
       nil
     end
@@ -375,7 +1132,7 @@ module Sadr
         @pending.clear
         values
       end
-      pending.each { |future| future.fulfill(error: error) }
+      pending.each { |future, _| future.fulfill(error: error) }
     end
 
     def report_error(error)
@@ -396,13 +1153,13 @@ module Sadr
     end
 
     def receive(message, error, epoch = @epoch)
-      return unless epoch == @epoch
+      return unless @lock.synchronize { epoch == @epoch }
 
       if error
-        receive_error(error)
+        receive_error(error, epoch)
       elsif message.key?("id") && !message.key?("method")
-        future = @lock.synchronize { @pending.delete(message["id"]) }
-        future&.fulfill(message["result"], error: message["error"] && ServerError.new(message["error"]))
+        entry = @lock.synchronize { @pending.delete(message["id"]) }
+        fulfill_response(entry, message)
       elsif message["method"]
         receive_call(message, epoch)
       end
@@ -413,19 +1170,38 @@ module Sadr
       end
     end
 
-    def receive_error(error)
-      running = @state == :running
-      @state = :failed
-      fail_pending(Error.new(error.message))
+    def receive_error(error, epoch)
+      pending, restart_epoch = @lock.synchronize do
+        next unless epoch == @epoch
+
+        running = @state == :running && !@closing
+        @state = :failed unless @closing
+        values = @pending.values
+        @pending.clear
+        [values, (@epoch if running && @restart && @restarts < 3)]
+      end
+      return unless pending
+
+      pending.each { |future, _| future.fulfill(error: Error.new(error.message)) }
       report_error(error)
-      restart_server if running && @restart && !@closing && @restarts < 3
+      restart_server(restart_epoch) if restart_epoch
     end
 
     def receive_call(message, epoch)
       method = message["method"]
       params = message.fetch("params", {})
+      if method == "workspace/semanticTokens/refresh"
+        active = @lock.synchronize do
+          next false unless epoch == @epoch && !@closing
+
+          @semantic.clear
+          @semantic_generation += 1
+          true
+        end
+        return unless active
+      end
       @dispatch.call do
-        next unless epoch == @epoch && !@closing
+        next unless @lock.synchronize { epoch == @epoch && !@closing }
 
         begin
           receive_diagnostics(params) if method == "textDocument/publishDiagnostics"
@@ -445,15 +1221,20 @@ module Sadr
     end
 
     def receive_diagnostics(params)
-      valid = params.is_a?(Hash) && params["uri"].is_a?(String) && params["diagnostics"].is_a?(Array)
+      valid = params.is_a?(Hash) && params["diagnostics"].is_a?(Array)
       raise Error, "invalid diagnostics notification" unless valid
 
-      document = @documents[params["uri"]]
+      uri = valid_uri(params["uri"])
       version = params["version"]
-      raise Error, "invalid diagnostic version" if !version.nil? && !version.is_a?(Integer)
-      return if document && version && version < document.version
+      valid_version = version.nil? || (version.is_a?(Integer) && version.between?(-0x80000000, 0x7fffffff))
+      raise Error, "invalid diagnostic version" unless valid_version
+      diagnostics = Protocol.diagnostics(params["diagnostics"])
+      @lock.synchronize do
+        document = @documents[uri]
+        return if document && version && version < document.version
 
-      @diagnostics[params["uri"]] = Protocol.diagnostics(params["diagnostics"])
+        @diagnostics[uri] = diagnostics
+      end
     end
 
     def built_in_request(method, params)
@@ -461,15 +1242,15 @@ module Sadr
       when "workspace/configuration"
         items = params.fetch("items")
         raise Error, "invalid configuration request" unless items.is_a?(Array)
+        configuration = @configuration_lock.synchronize { @configuration }
 
         [true, items.map do |item|
           section = item["section"]
-          section ? @configuration.dig(*section.split(".")) : @configuration
+          section && configuration.is_a?(Hash) ? configuration.dig(*section.split(".")) : (configuration unless section)
         end]
       when "workspace/workspaceFolders"
         [true, [{uri: Protocol.uri(@root), name: File.basename(@root)}]]
       when "window/workDoneProgress/create", "workspace/semanticTokens/refresh", "workspace/inlayHint/refresh", "workspace/codeLens/refresh", "workspace/diagnostic/refresh"
-        @semantic.clear if method == "workspace/semanticTokens/refresh"
         [true, nil]
       else
         [false, nil]
@@ -495,33 +1276,71 @@ module Sadr
     end
 
     def reply(id, epoch, value: nil, error: nil)
-      return unless epoch == @epoch && !@closing
+      transport = @lock.synchronize do
+        connected_transport(state: nil, epoch: epoch, transport: nil, allow_closing: false)
+      end
+      return unless transport
 
       response = {jsonrpc: "2.0", id: id}
       error ? response[:error] = error : response[:result] = value
-      @transport.write(response)
+      transport.write(response)
     rescue StandardError => failure
       report_error(failure)
     end
 
-    def restart_server
-      return if @restart_thread&.alive?
+    def restart_server(epoch)
+      @lock.synchronize do
+        return unless @epoch == epoch && @state == :failed && !@closing
+        return if @restart_thread&.alive?
+
+        previous = @transport
+        @restart_thread = Thread.new { restart_loop(previous, epoch) }
+      end
+    end
+
+    def restart_loop(previous, epoch)
+      previous.close
+      loop do
+        attempt = @lock.synchronize do
+          next if @closing || @state != :failed || @epoch != epoch || @restarts >= 3
 
-      previous = @transport
-      @restart_thread = Thread.new do
-        previous.close
-        until @closing || @restarts >= 3
           @restarts += 1
-          sleep(0.2 * @restarts)
-          break if @closing
+          [@restarts, epoch]
+        end
+        break unless attempt
 
-          begin
-            start
-            @documents.values.dup.each { |document| notify_open(document) if open_close? }
-            break
-          rescue StandardError => failure
-            report_error(failure)
+        sleep(0.2 * attempt[0])
+        begin
+          connect(timeout: 10, state: :restarting, expected_epoch: attempt[1])
+          @document_lock.synchronize do
+            documents, send_open, connected_epoch = @lock.synchronize do
+              raise Error, "language server restart was cancelled" if @closing || @state != :restarting
+
+              [@documents.values.dup, open_close?, @epoch]
+            end
+            documents.each { |document| notify_open(document) } if send_open
+            @lock.synchronize do
+              if @closing || @state != :restarting || @epoch != connected_epoch
+                raise Error, "language server restart was cancelled"
+              end
+              @state = :running
+            end
           end
+          retry_epoch = @lock.synchronize do
+            if @state == :failed && !@closing
+              @epoch
+            else
+              @restart_thread = nil if @restart_thread == Thread.current
+              nil
+            end
+          end
+          break unless retry_epoch
+
+          epoch = retry_epoch
+        rescue StandardError => failure
+          report_error(failure)
+          epoch = @lock.synchronize { @epoch if @state == :failed && !@closing }
+          break unless epoch
         end
       end
     end