canopus 0.1.0

data/lib/canopus/lazy_rope.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+module Canopus
+  # Read-only UTF-8 rope facade. Newline offsets are packed; document bytes stay
+  # on disk and a bounded LRU serves positioned pages independently of IO position.
+  class LazyRope
+    PAGE_SIZE = 65_536
+    attr_reader :bytesize, :cached_bytes, :line_ending
+    def initialize(path, page_limit: 32)
+      raise ArgumentError, "page limit must be positive" unless page_limit.is_a?(Integer) && page_limit.positive?
+      @file = File.open(path, File::RDONLY | File::BINARY | File::SHARE_DELETE)
+      @positioned_read, @read_lock = true, Mutex.new
+      @stamp = stamp
+      @origin = @file.size >= 3 && read_at(3, 0) == "\xEF\xBB\xBF".b ? 3 : 0
+      @bytesize = @file.size - @origin
+      @pages, @page_limit, @cached_bytes = {}, page_limit, 0
+      @starts = [0].pack("Q<")
+      @checkpoints = [0, 0, 0].pack("Q<3")
+      @length = @utf16_length = 0
+      index_lines
+      @starts.freeze
+      @checkpoints.freeze
+      @line_ending ||= "\n"
+    rescue StandardError
+      @file&.close
+      raise
+    end
+    def lazy? = true
+    def line_count = @starts.bytesize / 8
+    def length = @length
+    def utf16_length = @utf16_length
+    def empty? = @bytesize.zero?
+    def close = (@file.close unless @file.closed?)
+    def line_start(row)
+      raise RangeError, "line outside document" unless row.is_a?(Integer) && row.between?(0, line_count - 1)
+      @starts.unpack1("Q<", offset: row * 8)
+    end
+    def line(row)
+      start = line_start(row)
+      ending = row + 1 < line_count ? line_start(row + 1) : @bytesize
+      read_bytes(start, ending - start).force_encoding(Encoding::UTF_8).sub(/(?:\r\n|[\r\n\u2028\u2029])\z/, "")
+    end
+    def line_end(row)
+      ending = row + 1 < line_count ? line_start(row + 1) : @bytesize
+      return ending if row + 1 == line_count
+      tail = read_bytes([ending - 3, 0].max, [ending, 3].min)
+      ending - (tail.end_with?("\r\n") ? 2 : tail.end_with?("\xE2\x80\xA8".b, "\xE2\x80\xA9".b) ? 3 : 1)
+    end
+    def line_window(row, from: 0, max_bytes: 16_384)
+      start, ending = line_start(row), line_end(row)
+      offset = (start + from).clamp(start, ending)
+      offset -= 1 while offset > start && offset < ending && (read_bytes(offset, 1).getbyte(0) & 0xc0) == 0x80
+      value = read_bytes(offset, [max_bytes, ending - offset].min)
+      value = value.byteslice(0, complete_utf8_length(value)) unless value.empty?
+      [value.force_encoding(Encoding::UTF_8), offset - start]
+    end
+    def byteslice(offset, count = nil)
+      if offset.is_a?(Range)
+        range = offset
+        offset = range.begin
+        count = range.end + (range.exclude_end? ? 0 : 1) - offset
+      end
+      count ||= @bytesize - offset
+      validate_offset(offset)
+      validate_offset(offset + count)
+      raise RangeError, "negative slice length" if count.negative?
+      Denebola::Rope.new(read_bytes(offset, count).force_encoding(Encoding::UTF_8))
+    end
+    def point_at(offset)
+      validate_offset(offset)
+      low, high = 0, line_count
+      while low < high
+        middle = (low + high) / 2
+        line_start(middle) <= offset ? low = middle + 1 : high = middle
+      end
+      row = [low - 1, 0].max
+      Denebola::Point.new(row, prefix_count(offset) - prefix_count(line_start(row)))
+    end
+    def offset_at(point)
+      start, ending = line_start(point.row), line_end(point.row)
+      base = prefix_count(start)
+      raise RangeError, "column outside line" unless point.column.is_a?(Integer) && point.column.between?(0, prefix_count(ending) - base)
+      offset_for_count(base + point.column)
+    end
+    def utf16_point_at(offset)
+      point = point_at(offset)
+      Denebola::Point.new(point.row, prefix_count(offset, utf16: true) - prefix_count(line_start(point.row), utf16: true))
+    end
+    def offset_at_utf16_point(point)
+      base = prefix_count(line_start(point.row), utf16: true)
+      ending = prefix_count(line_end(point.row), utf16: true)
+      raise RangeError, "UTF-16 column outside line" unless point.column.is_a?(Integer) && point.column.between?(0, ending - base)
+      offset_for_count(base + point.column, utf16: true)
+    end
+    def utf16_offset_at(offset)
+      validate_offset(offset)
+      prefix_count(offset, utf16: true)
+    end
+    def offset_at_utf16(units)
+      raise RangeError, "UTF-16 offset outside document" unless units.is_a?(Integer) && units.between?(0, @utf16_length)
+      offset_for_count(units, utf16: true)
+    end
+    def each_chunk
+      return enum_for(__method__) unless block_given?
+      offset = 0
+      while offset < @bytesize
+        value = read_bytes(offset, [PAGE_SIZE, @bytesize - offset].min)
+        finish = complete_utf8_length(value)
+        raise Error, "invalid UTF-8 file" if finish.zero?
+        yield value.byteslice(0, finish).force_encoding(Encoding::UTF_8)
+        offset += finish
+      end
+    end
+    def to_s = each_chunk.to_a.join
+    def apply_edits(*) = raise(Error, "large file is read-only")
+    def check_invariants!
+      raise Error, "invalid line index" unless line_start(0).zero? && @starts.bytesize % 8 == 0
+      true
+    end
+
+    private
+    def checkpoint(value, dimension)
+      low, high = 0, @checkpoints.bytesize / 24
+      while low < high
+        middle = (low + high) / 2
+        @checkpoints.unpack1("Q<", offset: middle * 24 + dimension * 8) <= value ? low = middle + 1 : high = middle
+      end
+      @checkpoints.byteslice([low - 1, 0].max * 24, 24).unpack("Q<3")
+    end
+    def prefix_count(offset, utf16: false)
+      base, chars, units = checkpoint(offset, 0)
+      value = read_bytes(base, offset - base).force_encoding(Encoding::UTF_8)
+      utf16 ? units + (value.ascii_only? ? value.bytesize : value.encode(Encoding::UTF_16LE).bytesize / 2) : chars + value.length
+    end
+    def offset_for_count(count, utf16: false)
+      offset, chars, units = checkpoint(count, utf16 ? 2 : 1)
+      remaining = count - (utf16 ? units : chars)
+      return offset if remaining.zero?
+      value = read_bytes(offset, [PAGE_SIZE + 4, @bytesize - offset].min).force_encoding(Encoding::UTF_8)
+      value = value.byteslice(0, complete_utf8_length(value))
+      value.each_codepoint do |codepoint|
+        break if remaining.zero?
+        remaining -= utf16 && codepoint > 0xffff ? 2 : 1
+        raise RangeError, "inside UTF-16 surrogate pair" if remaining.negative?
+        offset += codepoint < 0x80 ? 1 : codepoint < 0x800 ? 2 : codepoint < 0x10000 ? 3 : 4
+      end
+      raise RangeError, "column outside document" unless remaining.zero?
+      offset
+    end
+    def stamp
+      stat = @file.stat
+      [stat.size, stat.mtime, stat.ctime]
+    end
+    def validate_offset(offset)
+      raise RangeError, "offset outside document" unless offset.is_a?(Integer) && offset.between?(0, @bytesize)
+      raise RangeError, "offset inside UTF-8 character" if offset < @bytesize && (read_bytes(offset, 1).getbyte(0) & 0xC0) == 0x80
+    end
+    def read_bytes(offset, count)
+      raise SaveConflict, "large file changed on disk; reopen it" unless stamp == @stamp
+      output = String.new(capacity: count, encoding: Encoding::BINARY)
+      while count.positive?
+        page, local = offset.divmod(PAGE_SIZE)
+        data = @pages.delete(page)
+        unless data
+          data = read_at([PAGE_SIZE, @bytesize - page * PAGE_SIZE].min, @origin + page * PAGE_SIZE)
+          @cached_bytes += data.bytesize
+          @cached_bytes -= @pages.shift.last.bytesize while @pages.length >= @page_limit
+        end
+        @pages[page] = data
+        length = [count, data.bytesize - local].min
+        raise SaveConflict, "large file was truncated" unless length.positive?
+        output << data.byteslice(local, length)
+        offset += length
+        count -= length
+      end
+      output
+    end
+    def complete_utf8_length(value)
+      index = value.bytesize - 1
+      index -= 1 while index.positive? && (value.getbyte(index) & 0xC0) == 0x80
+      leading = value.getbyte(index)
+      length = leading < 0x80 ? 1 : leading < 0xE0 ? 2 : leading < 0xF0 ? 3 : 4
+      value.bytesize - index < length ? index : value.bytesize
+    end
+    def read_at(count, offset)
+      return @file.pread(count, offset) if @positioned_read
+      @read_lock.synchronize { @file.seek(offset); @file.read(count) }
+    rescue NotImplementedError
+      @positioned_read = false
+      retry
+    end
+    def index_lines
+      offset, pending = 0, +"".b
+      while offset < @bytesize
+        chunk = read_at([PAGE_SIZE, @bytesize - offset].min, @origin + offset)
+        pending << chunk
+        offset += chunk.bytesize
+        complete = complete_utf8_length(pending)
+        complete -= 1 if complete.positive? && pending.getbyte(complete - 1) == 13 && offset < @bytesize
+        text = pending.byteslice(0, complete).force_encoding(Encoding::UTF_8)
+        raise Error, "large-file mode requires valid UTF-8 text" unless text.valid_encoding? && !text.include?("\0")
+        base = offset - pending.bytesize
+        binary = text.b
+        starts = []
+        binary.scan(/\r\n|[\r\n]|\xE2\x80[\xA8\xA9]/n) do |ending|
+          @line_ending ||= ending.dup.force_encoding(Encoding::UTF_8)
+          starts << base + Regexp.last_match.end(0)
+        end
+        @starts << starts.pack("Q<*")
+        @length += text.length
+        @utf16_length += text.ascii_only? ? text.bytesize : text.encode(Encoding::UTF_16LE).bytesize / 2
+        @checkpoints << [base + complete, @length, @utf16_length].pack("Q<3")
+        pending = pending.byteslice(complete..)
+      end
+      raise Error, "truncated UTF-8 file" unless pending.empty?
+    end
+  end
+end

data/lib/canopus/lsp/client.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+module Canopus
+  module LSP
+    class Client
+      attr_reader :capabilities, :transport, :diagnostics, :state, :errors, :server_info, :position_encoding
+      def initialize(command:, root: Dir.pwd, dispatch: ->(&block) { block.call }, restart: true, env: {}, initialization_options: nil, configuration: {})
+        @command, @root, @dispatch, @restart = command, File.expand_path(root), dispatch, restart
+        @env, @initialization_options, @configuration = env, initialization_options, configuration
+        @pending, @handlers, @documents, @diagnostics, @semantic = {}, {}, {}, {}, {}
+        @sequence, @lock, @state, @restarts, @epoch = 0, Mutex.new, :stopped, 0, 0
+        @errors, @capabilities = [], {}
+      end
+      def start(timeout: 10)
+        raise Error, "language server is already started" if [:starting, :running].include?(@state)
+        @closing = false
+        @state = :starting
+        epoch = (@epoch += 1)
+        @semantic.clear
+        @transport = Transport.new(@command, cwd: @root, env: @env) { |message, error| receive(message, error, epoch) }
+        result = request("initialize", {processId: Process.pid, rootUri: Protocol.uri(@root),
+          clientInfo: {name: "Canopus", version: (defined?(Canopus::VERSION) ? Canopus::VERSION : "0.1.0")},
+          workspaceFolders: [{uri: Protocol.uri(@root), name: File.basename(@root)}], initializationOptions: @initialization_options,
+          capabilities: {general: {positionEncodings: ["utf-16"]},
+            window: {workDoneProgress: true},
+            textDocument: {synchronization: {dynamicRegistration: false, didSave: true},
+              completion: {completionItem: {snippetSupport: true, documentationFormat: %w[markdown plaintext], resolveSupport: {properties: %w[documentation detail additionalTextEdits]}}},
+              hover: {contentFormat: %w[markdown plaintext]},
+              signatureHelp: {signatureInformation: {documentationFormat: %w[markdown plaintext], parameterInformation: {labelOffsetSupport: true}}},
+              documentSymbol: {hierarchicalDocumentSymbolSupport: true},
+              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},
+              inlayHint: {dynamicRegistration: false}, 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"}}}}).await(timeout: timeout)
+        raise Error, "invalid initialize result" unless result.is_a?(Hash) && result["capabilities"].is_a?(Hash)
+        @capabilities, @server_info = result["capabilities"], result["serverInfo"]
+        sync = @capabilities["textDocumentSync"]
+        mode = sync.is_a?(Hash) ? sync.fetch("change", 0) : sync
+        raise Error, "invalid text document synchronization mode" unless mode.nil? || [0, 1, 2].include?(mode)
+        @position_encoding = @capabilities.fetch("positionEncoding", "utf-16")
+        raise Error, "server selected unadvertised position encoding #{@position_encoding}" unless @position_encoding == "utf-16"
+        semantic = @capabilities["semanticTokensProvider"]
+        raise Error, "missing semantic token legend" if semantic && (!semantic.is_a?(Hash) || !semantic["legend"].is_a?(Hash))
+        Protocol.semantic_tokens([], legend: semantic["legend"]) if semantic.is_a?(Hash)
+        notify("initialized", {})
+        @state = :running
+        self
+      rescue StandardError => error
+        @transport&.close if epoch
+        fail_pending(error) if epoch
+        @state = :failed if epoch
+        raise
+      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
+      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)
+      end
+      def on(method, &handler)
+        raise ArgumentError, "handler required" unless handler
+        @handlers[method.to_s] = handler
+      end
+      def supports?(capability) = !!@capabilities[capability.to_s]
+      def workspace_symbols(query) = request("workspace/symbol", {query: query})
+      def resolve_completion(item) = request("completionItem/resolve", item)
+      def resolve_code_action(action) = request("codeAction/resolve", action)
+      def resolve_code_lens(lens) = request("codeLens/resolve", lens)
+      def execute_command(command, arguments: []) = request("workspace/executeCommand", {command: command, arguments: arguments})
+
+      def open_document(buffer, language_id:)
+        raise Error, "LSP document needs a path" unless buffer.path
+        uri = Protocol.uri(buffer.path)
+        @documents[uri]&.last&.detach
+        subscription = buffer.on_edit { |patch| change_document(uri, buffer, patch) }
+        @documents[uri] = [buffer, language_id, subscription]
+        notify("textDocument/didOpen", {textDocument: {uri: uri, languageId: language_id, version: buffer.version, text: buffer.text}}) if open_close?
+        uri
+      end
+      def close_document(uri)
+        @documents.delete(uri)&.last&.detach
+        @diagnostics.delete(uri)
+        @semantic.delete(uri)
+        notify("textDocument/didClose", {textDocument: {uri: uri}}) if open_close?
+      end
+      def save_document(uri)
+        sync = @capabilities["textDocumentSync"]
+        save = sync.is_a?(Hash) ? sync["save"] : sync.is_a?(Integer) && sync.positive?
+        return unless save
+        params = {textDocument: {uri: uri}}
+        params[:text] = @documents.fetch(uri).first.text if save.is_a?(Hash) && save["includeText"]
+        notify("textDocument/didSave", params)
+      end
+      def at(method, buffer, offset, **params)
+        request("textDocument/#{method}", {textDocument: {uri: Protocol.uri(buffer.path)}, position: Protocol.position(buffer.rope, offset), **params})
+      end
+      %w[completion hover definition typeDefinition implementation references rename signatureHelp].each do |method|
+        define_method(method) { |buffer, offset, **params| at(method, buffer, offset, **params) }
+      end
+      %w[documentSymbol formatting codeAction inlayHint codeLens diagnostic].each do |method|
+        define_method(method) { |buffer, **params| request("textDocument/#{method}", {textDocument: {uri: Protocol.uri(buffer.path)}, **params}) }
+      end
+      def semantic_tokens(buffer)
+        uri = Protocol.uri(buffer.path)
+        version = buffer.version
+        provider = @capabilities["semanticTokensProvider"]
+        return [] unless provider.is_a?(Hash) && provider["full"]
+        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
+        return [] unless result && buffer.version == version
+        raise Error, "invalid semantic token result" unless result.is_a?(Hash) && (!result.key?("resultId") || result["resultId"].is_a?(String))
+        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
+      end
+      def apply_text_edits(buffer, edits)
+        changes = edits.map do |edit|
+          raise Error, "invalid LSP text edit" unless edit.is_a?(Hash) && edit["range"].is_a?(Hash) && edit["newText"].is_a?(String) && edit["newText"].valid_encoding?
+          range = edit.fetch("range")
+          [Protocol.offset(buffer.rope, range.fetch("start"))...Protocol.offset(buffer.rope, range.fetch("end")), edit.fetch("newText")]
+        end
+        buffer.edit(changes, kind: :lsp)
+      end
+      def stop
+        @closing = true
+        begin
+          request("shutdown").await(timeout: 2) if @state == :running
+          notify("exit") if @transport&.alive?
+        rescue Error
+          nil
+        ensure
+          @epoch += 1
+          @documents.each_value { |_, _, subscription| subscription.detach }
+          @documents.clear
+          @semantic.clear
+          @diagnostics.clear
+          @transport&.close
+          fail_pending(Error.new("language server stopped"))
+          @state = :stopped
+        end
+      end
+
+      private
+      def open_close?
+        sync = @capabilities["textDocumentSync"]
+        sync.is_a?(Hash) ? sync["openClose"] : sync.is_a?(Integer) && sync.positive?
+      end
+      def change_document(uri, buffer, patch)
+        sync = @capabilities["textDocumentSync"]
+        mode = sync.is_a?(Hash) ? sync["change"] : sync
+        return unless [1, 2].include?(mode)
+        changes = if mode == 2 && patch.is_a?(Patch)
+          patch.edits.reverse.map { |edit| {range: Protocol.range(patch.before, edit.old_range), text: edit.new_text} }
+        else
+          [{text: buffer.text}]
+        end
+        notify("textDocument/didChange", {textDocument: {uri: uri, version: buffer.version}, contentChanges: changes})
+      rescue Error => error
+        report_error(error)
+      end
+      def cancel(id)
+        @lock.synchronize { @pending.delete(id) }
+        notify("$/cancelRequest", {id: id})
+      rescue Error
+        nil
+      end
+      def fail_pending(error)
+        pending = @lock.synchronize { values = @pending.values; @pending.clear; values }
+        pending.each { |future| future.fulfill(error: error) }
+      end
+      def report_error(error)
+        bounded = Error.new("#{error.class}: #{error.message}".scrub.byteslice(0, 2048).scrub(""))
+        @lock.synchronize do
+          @errors << bounded
+          @errors.shift if @errors.length > 200
+        end
+        @dispatch.call do
+          begin
+            @handlers["error"]&.call(bounded)
+          rescue StandardError
+            nil
+          end
+        end
+      rescue StandardError
+        nil
+      end
+      def receive(message, error, epoch = @epoch)
+        return unless epoch == @epoch
+        if error
+          running = @state == :running
+          @state = :failed
+          fail_pending(Error.new(error.message))
+          report_error(error)
+          restart_server if running && @restart && !@closing && @restarts < 3
+        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"]))
+        elsif message["method"]
+          method, params = message["method"], message.fetch("params", {})
+          @dispatch.call do
+            next unless epoch == @epoch && !@closing
+            begin
+              if method == "textDocument/publishDiagnostics"
+                raise Error, "invalid diagnostics notification" unless params.is_a?(Hash) && params["uri"].is_a?(String) && params["diagnostics"].is_a?(Array)
+                document = @documents[params["uri"]]
+                version = params["version"]
+                raise Error, "invalid diagnostic version" if !version.nil? && !version.is_a?(Integer)
+                next if document && version && version < document.first.version
+                @diagnostics[params["uri"]] = Protocol.diagnostics(params["diagnostics"])
+              end
+              known = @handlers.key?(method)
+              result = @handlers[method]&.call(params)
+              next unless message.key?("id")
+              unless known
+                known = true
+                result = case method
+                when "workspace/configuration"
+                  params.fetch("items").map do |item|
+                    section = item["section"]
+                    section ? @configuration.dig(*section.split(".")) : @configuration
+                  end
+                when "workspace/workspaceFolders"
+                  [{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"
+                  nil
+                else
+                  known = false
+                  nil
+                end
+              end
+              if !known
+                reply(message["id"], epoch, error: {code: -32601, message: "unsupported client request #{method}"})
+              elsif result.is_a?(Future)
+                result.then do |value, failure|
+                  failure ? reply(message["id"], epoch, error: {code: -32603, message: failure.message.byteslice(0, 2048).scrub}) : reply(message["id"], epoch, value: value)
+                end
+              else
+                reply(message["id"], epoch, value: result)
+              end
+            rescue StandardError => failure
+              report_error(failure)
+              reply(message["id"], epoch, error: {code: -32603, message: "client request handler failed"}) if message.key?("id")
+            end
+          end
+        end
+      rescue StandardError => failure
+        report_error(failure)
+        reply(message["id"], epoch, error: {code: -32603, message: "client dispatch failed"}) if message&.key?("id") && message.key?("method")
+      end
+      def reply(id, epoch, value: nil, error: nil)
+        return unless epoch == @epoch && !@closing
+        response = {jsonrpc: "2.0", id: id}
+        error ? response[:error] = error : response[:result] = value
+        @transport.write(response)
+      rescue StandardError => failure
+        report_error(failure)
+      end
+      def restart_server
+        return if @restart_thread&.alive?
+        previous = @transport
+        @restart_thread = Thread.new do
+          previous.close
+          until @closing || @restarts >= 3
+            @restarts += 1
+            sleep(0.2 * @restarts)
+            break if @closing
+            begin
+              start
+              @documents.values.dup.each { |buffer, language, _| open_document(buffer, language_id: language) }
+              break
+            rescue StandardError => failure
+              report_error(failure)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/canopus/lsp/error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Canopus
+  module LSP
+    class Error < StandardError; end
+  end
+end

data/lib/canopus/lsp/future/subscription.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Canopus::LSP::Future::Subscription
+  def initialize(&detach) = @detach = detach
+  def detach
+    callback, @detach = @detach, nil
+    callback&.call
+  end
+end

data/lib/canopus/lsp/future.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Canopus
+  module LSP
+    class Future
+      attr_reader :id, :callback_errors
+      def initialize(id, on_error: nil, &cancel)
+        @id, @cancel, @on_error, @lock, @ready = id, cancel, on_error, Mutex.new, ConditionVariable.new
+        @callbacks, @callback_errors = [], []
+      end
+      def fulfill(value = nil, error: nil)
+        callbacks = @lock.synchronize do
+          return if @done
+          @value, @error, @done = value, error, true
+          @ready.broadcast
+          saved, @callbacks = @callbacks, []
+          saved
+        end
+        callbacks.each { |callback| invoke(callback) }
+        self
+      end
+      def then(&callback)
+        raise ArgumentError, "callback required" unless callback
+        on_complete { callback.call(@value, @error) }
+        self
+      end
+      def done? = @lock.synchronize { !!@done }
+      def on_complete(&callback)
+        raise ArgumentError, "callback required" unless callback
+        ready = @lock.synchronize do
+          @callbacks << callback unless @done
+          @done
+        end
+        invoke(callback) if ready
+        Subscription.new { @lock.synchronize { @callbacks.delete(callback) } }
+      end
+      def await(timeout: 10)
+        raise ArgumentError, "timeout must be finite and nonnegative" unless timeout.nil? || (timeout.is_a?(Numeric) && timeout.finite? && timeout >= 0)
+        if defined?(Zaniah::TaskExecutor) && Zaniah::TaskExecutor.current && !done?
+          return Zaniah::TaskExecutor.current.await(self, timeout: timeout)
+        end
+        deadline = timeout && Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+        @lock.synchronize do
+          until @done
+            remaining = deadline && deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            raise Timeout, "LSP request #{@id} timed out" if remaining && remaining <= 0
+            @ready.wait(@lock, remaining)
+          end
+          raise @error if @error
+          @value
+        end
+      rescue StandardError => error
+        if error.is_a?(Timeout) || (defined?(Zaniah::Task::Timeout) && error.is_a?(Zaniah::Task::Timeout))
+          cancel
+          raise Timeout, "LSP request #{@id} timed out"
+        end
+        raise
+      end
+      def cancel
+        callback = @lock.synchronize do
+          return false if @done || @cancelling
+          @cancelling = true
+          @cancel
+        end
+        invoke(-> { callback.call(@id) }) if callback
+        fulfill(error: Error.new("request cancelled"))
+        true
+      end
+
+      private
+      def invoke(callback)
+        callback.call
+      rescue StandardError => error
+        bounded = Error.new("#{error.class}: #{error.message}".scrub.byteslice(0, 2048).scrub(""))
+        @lock.synchronize do
+          @callback_errors << bounded
+          @callback_errors.shift if @callback_errors.length > 32
+        end
+        begin
+          @on_error&.call(bounded)
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end