connectrpc 0.1.0

data/lib/connectrpc/get_query.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module ConnectRPC
+  # Private, host-neutral form query processing. Unknown fields are validated
+  # without retaining their values; only the five protocol controls survive.
+  # Keep byte validation, preflight bounds and cooperative checks adjacent.
+  # rubocop:disable-next Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+  class GetQuery # rubocop:disable Metrics/ClassLength
+    KEYS = %w[connect base64 compression encoding message].freeze
+
+    def self.parse(query, limit:, wire_limit:, deadline: nil)
+      Protocol.check_size!(query, limit)
+      new(wire_limit, deadline).parse(query.b)
+    end
+
+    def initialize(wire_limit, deadline)
+      @wire_limit = wire_limit
+      @deadline = deadline
+    end
+
+    def parse(query)
+      values = {} #: Hash[String, String]
+      offset = 0
+      while offset < query.bytesize
+        @deadline&.check!
+        ending, separator = field(query, offset)
+        name = component(query, offset, separator, 12)
+        known = KEYS.include?(name)
+        raise Error.new(:invalid_argument, "Repeated GET parameter") if known && values.key?(name)
+
+        start = [separator + 1, ending].min
+        # Controls need only enough bytes to distinguish every recognized value.
+        cap = name == "message" ? 4 * ((@wire_limit + 2) / 3) : 16
+        value = component(query, start, ending, known ? cap : 0, payload: name == "message")
+        values[name] = value if known
+        offset = ending + 1
+      end
+      @deadline&.check!
+      values
+    end
+
+    def self.payload(values, limit:, deadline: nil)
+      message = values.fetch("message")
+      bytes = if values["base64"] == "1"
+                decode_base64(message, limit)
+              else
+                text = message.dup.force_encoding(Encoding::UTF_8)
+                raise Error.new(:invalid_argument, "Invalid GET message UTF-8") unless text.valid_encoding?
+
+                text
+              end
+      Protocol.check_size!(bytes, limit)
+      deadline&.check!
+      bytes
+    end
+
+    def self.decode_base64(message, limit)
+      raise Error.new(:invalid_argument, "Invalid GET base64") unless /\A[A-Za-z0-9_-]*={0,2}\z/.match?(message)
+
+      unpadded = message.delete_suffix("==").delete_suffix("=")
+      length = unpadded.bytesize
+      if length % 4 == 1 || (message.include?("=") && message.bytesize % 4 != 0)
+        raise Error.new(:invalid_argument, "Invalid GET base64")
+      end
+      raise Error.new(:resource_exhausted, "Message exceeds byte limit") if length * 3 / 4 > limit
+
+      padded = message + ("=" * ((4 - (message.bytesize % 4)) % 4))
+      bytes = padded.tr("-_", "+/").unpack1("m0") #: String
+      unless [bytes].pack("m0").tr("+/", "-_").delete("=") == unpadded
+        raise Error.new(:invalid_argument, "Invalid GET base64")
+      end
+
+      bytes
+    rescue ArgumentError
+      raise Error.new(:invalid_argument, "Invalid GET base64")
+    end
+
+    def self.build(url, bytes, codec:, encoding:, limit:, deadline: nil)
+      base64 = codec == :proto || encoding == :gzip
+      prefix = +"connect=v1&"
+      prefix << "base64=1&" if base64
+      prefix << "compression=gzip&" if encoding == :gzip
+      prefix << "encoding=#{codec}&message="
+      size = base64 ? ((bytes.bytesize * 4) + 2) / 3 : form_size(bytes, deadline)
+      if url.to_s.bytesize + 1 + prefix.bytesize + size > limit
+        raise Error.new(:resource_exhausted, "GET URL exceeds byte limit")
+      end
+
+      deadline&.check!
+      message = base64 ? [bytes].pack("m0").tr("+/", "-_").delete("=") : URI.encode_www_form_component(bytes)
+      url.query = prefix + message
+      deadline&.check!
+      url
+    end
+
+    def self.form_size(bytes, deadline)
+      size = 0
+      bytes.each_byte.with_index do |byte, index|
+        deadline&.check! if (index % 1024).zero?
+        size += byte == 32 || form_safe?(byte) ? 1 : 3
+      end
+      size
+    end
+
+    def self.form_safe?(byte)
+      byte.between?(65, 90) || byte.between?(97, 122) || byte.between?(48, 57) || [42, 45, 46, 95].include?(byte)
+    end
+
+    private
+
+    def field(query, offset)
+      ending = offset
+      separator = nil #: Integer?
+      while ending < query.bytesize && query.getbyte(ending) != 38
+        @deadline&.check! if ((ending - offset) % 1024).zero?
+        separator ||= ending if query.getbyte(ending) == 61
+        ending += 1
+      end
+      [ending, separator || ending]
+    end
+
+    def component(query, start, ending, cap, payload: false)
+      bytes = +"".b
+      index = start
+      while index < ending
+        @deadline&.check! if ((index - start) % 1024).zero?
+        byte = query.getbyte(index) #: Integer
+        if byte == 37
+          raise Error.new(:invalid_argument, "Malformed GET percent encoding") if index + 2 >= ending
+
+          high = hex(query.getbyte(index + 1))
+          low = hex(query.getbyte(index + 2))
+          byte = (high * 16) + low
+          index += 2
+        elsif byte == 43
+          byte = 32
+        end
+        if bytes.bytesize < cap
+          bytes << byte
+        elsif payload
+          raise Error.new(:resource_exhausted, "Message exceeds byte limit")
+        end
+        index += 1
+      end
+      bytes
+    end
+
+    def hex(byte)
+      raise Error.new(:invalid_argument, "Malformed GET percent encoding") unless byte
+
+      return byte - 48 if byte.between?(48, 57)
+      return byte - 55 if byte.between?(65, 70)
+      return byte - 87 if byte.between?(97, 102)
+
+      raise Error.new(:invalid_argument, "Malformed GET percent encoding")
+    end
+  end
+  private_constant :GetQuery
+end

data/lib/connectrpc/grpc.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module ConnectRPC
+  # Separate from StreamHead: HTTP/2 END_STREAM is a protocol fact, not body state.
+  class GRPCHead
+    attr_reader :status, :headers, :end_stream
+
+    def initialize(status:, headers:, end_stream:)
+      @status = status
+      @headers = GRPCProtocol.snapshot(headers)
+      @end_stream = end_stream
+      freeze
+    end
+  end
+
+  module GRPCProtocol # rubocop:disable Metrics/ModuleLength
+    CONTENT_TYPE = "application/grpc+proto"
+    FIELD_LIMIT = 65_536
+    UINT32_MAX = 4_294_967_295
+    CODES = ["OK", *Error::HTTP_STATUS.keys].freeze
+    TIME_UNITS = { "n" => 1e-9, "u" => 1e-6, "m" => 0.001, "S" => 1, "M" => 60, "H" => 3600 }.freeze
+
+    def self.media?(value)
+      !!value&.match?(%r{\Aapplication/grpc(?:\+proto)?\z}i)
+    end
+
+    def self.intent?(headers)
+      (headers["content-type"] || []).any? { |value| value.downcase.start_with?("application/grpc") }
+    end
+
+    def self.snapshot(headers)
+      headers.to_h { |key, values| [key.dup.freeze, values.map { |value| value.dup.freeze }.freeze] }.freeze
+    end
+
+    def self.field_size(headers)
+      headers.sum { |key, values| values.sum { |value| key.bytesize + value.bytesize + 32 } }
+    end
+
+    def self.check_fields!(headers, limit = FIELD_LIMIT)
+      return unless field_size(headers) > limit
+
+      raise Error.new(:resource_exhausted, "gRPC field block exceeds byte limit"),
+            cause: nil
+    end
+
+    # Parse incrementally: the budget bounds spelling length, uint32 bounds value.
+    def self.status_number(value)
+      return if value.empty?
+
+      number = 0
+      value.each_byte do |byte|
+        return nil unless byte.between?(48, 57)
+
+        digit = byte - 48
+        return nil if number > (UINT32_MAX - digit) / 10
+
+        number = (number * 10) + digit
+      end
+      number
+    end
+
+    def self.status_value(headers)
+      values = headers["grpc-status"]
+      return unless values
+      raise Error.new(:internal, "Duplicate grpc-status"), cause: nil unless values.size == 1
+
+      status_number(values.first)
+    end
+
+    def self.encode_message(message)
+      message.b.each_byte.map { |byte| byte.between?(32, 126) && byte != 37 ? byte.chr : format("%%%02X", byte) }.join
+    end
+
+    def self.decode_message(value)
+      value.b.gsub(/%([0-9a-fA-F]{2})/n) { [(Regexp.last_match(1) || "").to_i(16)].pack("C") }.force_encoding(Encoding::UTF_8).scrub
+    end
+
+    def self.parse_status(headers, codec:, http_status: 200, metadata: Metadata.new, # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+                          wire_limit: FIELD_LIMIT, limit: FIELD_LIMIT, on_error: nil)
+      check_fields!(headers, wire_limit)
+      trailers = Protocol.metadata(headers).freeze
+      number = status_value(headers)
+      unless headers.key?("grpc-status")
+        failure = status_error(Error::HTTP_FALLBACK.fetch(http_status, "unknown"), "Missing grpc-status", [], metadata,
+                               trailers)
+        return [failure, trailers]
+      end
+      message_fields = headers["grpc-message"] || []
+      raise Error.new(:internal, "Duplicate grpc-message"), cause: nil if message_fields.size > 1
+
+      details = headers["grpc-status-details-bin"]
+      rich = decode_status(details, number, codec, limit, on_error) if details
+      return [nil, trailers] if number&.zero?
+
+      code = (number && CODES[number]) || "unknown"
+      message = rich ? rich.message : decode_message(message_fields.first || "")
+      [status_error(code, message, rich ? rich.details : [], metadata, trailers), trailers]
+    end
+
+    def self.status_error(code, message, details, metadata, trailers)
+      error = Error.new(code, message, details: details, metadata: metadata, trailers: trailers)
+      error.metadata.freeze
+      error.trailers.freeze
+      error
+    end
+
+    def self.decode_status(values, number, codec, limit, on_error)
+      unless number && number != 0 && values.size == 1 && codec
+        raise Error.new(:internal, "Invalid gRPC status details"), cause: nil
+      end
+
+      bytes = Metadata.decode_binary(values.first)
+      Protocol.check_size!(bytes, limit)
+      codec.decode_status(bytes, code: number)
+    rescue CodecError, ArgumentError => e
+      on_error&.call(e)
+      raise Error.new(:internal, "Invalid gRPC status details"), cause: nil
+    end
+
+    def self.status_fields(error, trailers, codec, limit) # rubocop:disable Metrics/AbcSize
+      fields = trailers.to_h.merge("grpc-status" => [(error ? CODES.index(error.code) : 0).to_s])
+      fields["grpc-message"] = [encode_message(error.message)] if error && !error.message.empty?
+      if error && !error.details.empty?
+        bytes = codec.encode_status(error)
+        Protocol.check_size!(bytes, limit)
+        fields["grpc-status-details-bin"] = [Metadata.encode_binary(bytes)]
+      end
+      fields
+    end
+
+    def self.terminal(error, trailers, codec:, wire_limit:, limit:, on_error: nil) # rubocop:disable Metrics/MethodLength
+      fields = status_fields(error, trailers, codec, limit)
+      check_fields!(fields, [wire_limit, FIELD_LIMIT].min)
+      [snapshot(fields), error]
+    rescue CodecError => e
+      on_error&.call(e)
+      terminal(Error.new(:internal, "Cannot encode gRPC status"), Metadata.new, codec: codec,
+                                                                                wire_limit: wire_limit, limit: limit)
+    rescue Error => e
+      raise unless e.code == "resource_exhausted"
+
+      replacement = Error.new(:resource_exhausted, "Status exceeds byte limit")
+      fields = { "grpc-status" => ["8"] }
+      check_fields!(fields, [wire_limit, FIELD_LIMIT].min)
+      [snapshot(fields), replacement]
+    end
+
+    def self.request_deadline(headers) # rubocop:disable Metrics/AbcSize
+      values = headers["grpc-timeout"]
+      return unless values
+      unless values.size == 1 && /\A[0-9]{1,8}[HMSmun]\z/.match?(values.first)
+        raise Error.new(:internal, "Invalid grpc-timeout"), cause: nil
+      end
+
+      value = values.first
+      seconds = value[0...-1].to_i.to_f * TIME_UNITS.fetch(value[-1] || "").to_f
+      seconds.zero? ? Deadline.send(:expired) : Deadline.new(seconds)
+    end
+
+    def self.timeout(deadline)
+      deadline.check!
+      seconds = Float(deadline.remaining) #: Float
+      TIME_UNITS.each do |unit, scale|
+        scaled = seconds / scale
+        next unless scaled.finite? && scaled <= 99_999_999
+
+        amount = scaled.ceil
+        return "#{[amount, 1].max}#{unit}" if amount <= 99_999_999
+      end
+      "99999999H"
+    end
+
+    def self.encoding(headers, request: false, enabled: :gzip) # rubocop:disable Metrics/CyclomaticComplexity
+      values = headers["grpc-encoding"]
+      return :identity unless values
+      unless values.size == 1 && /\A[!#$%&'*+.^_`|~0-9A-Za-z-]+\z/.match?(values.first)
+        raise Error.new(:internal, "Invalid grpc-encoding"), cause: nil
+      end
+      return :identity if values.first == "identity"
+      return :gzip if values.first == "gzip" && enabled == :gzip
+
+      raise Error.new(request ? :unimplemented : :internal, "Unsupported grpc-encoding"), cause: nil
+    end
+
+    def self.response_encoding(headers, enabled)
+      tokens = (headers["grpc-accept-encoding"] || []).flat_map { |value| value.split(",").map(&:strip) }
+      enabled == :gzip && tokens.include?("gzip") ? :gzip : :identity
+    end
+
+    def self.status_codec!(binding, explicit)
+      candidate = explicit || binding #: (_Binding | _GRPCStatusCodec) & _GRPCCapabilityProbe
+      if candidate.respond_to?(:encode_status) && candidate.respond_to?(:decode_status)
+        return explicit || binding #: _GRPCStatusCodec
+      end
+
+      raise ArgumentError, "gRPC requires a status codec"
+    end
+  end
+  private_constant :GRPCProtocol
+end

data/lib/connectrpc/grpc_client.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ConnectRPC
+  class Client
+    private
+
+    def client_stream_strategy(lifecycle = nil)
+      return Streaming::ConnectStrategy.new unless @protocol == :grpc
+
+      GRPCProtocol::Strategy.new(codec: @status_codec, wire_limit: @grpc_status_wire_limit, limit: @grpc_status_limit,
+                                 on_error: ->(error) { lifecycle&.record_failure(error) })
+    end
+
+    def grpc_stream_request(url, metadata, deadline, state, lifecycle)
+      headers = metadata.to_h.merge("content-type" => [GRPCProtocol::CONTENT_TYPE], "te" => ["trailers"],
+                                    "grpc-accept-encoding" => [@accept_encoding.join(",")])
+      headers["grpc-encoding"] = ["gzip"] if @encoding == :gzip
+      headers["grpc-timeout"] = [GRPCProtocol.timeout(deadline)] if deadline
+      StreamRequest.new(url: url, http_method: "POST", headers: headers, deadline: deadline,
+                        cancellation: state, lifecycle: lifecycle)
+    end
+  end
+end

data/lib/connectrpc/grpc_server.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module ConnectRPC
+  module GRPCProtocol
+    class ServerState
+      attr_reader :headers, :codec, :publish, :lifecycle, :cancellation
+      attr_accessor :context, :session, :encoding, :error, :published
+
+      def initialize(headers:, codec:, publish:, lifecycle:, cancellation:)
+        @headers = headers
+        @codec = codec
+        @publish = publish
+        @lifecycle = lifecycle
+        @cancellation = cancellation
+        @encoding = :identity
+        @published = false
+      end
+    end
+  end
+
+  class Server # rubocop:disable Metrics/ClassLength
+    # Native entry point; portable adapters must never opt into HTTP/2 execution.
+    # rubocop:disable-next Metrics/AbcSize
+    def call_grpc(path:, http_method:, headers:, input:, output:, publish:, lifecycle: nil, cancellation: nil, # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+                  http2: false)
+      # @type var owned: bool?
+      owned = nil
+      # @type var error: Exception?
+      error = nil
+      return bare(415, {}, cancellation: cancellation) unless http2 && @protocol.include?(:grpc)
+      return bare(405, { "allow" => ["POST"] }, cancellation: cancellation) unless http_method == "POST"
+
+      values = Protocol.headers(headers)
+      unless GRPCProtocol.media?(Protocol.single(values, "content-type"))
+        return bare(415, { "accept-post" => [GRPCProtocol::CONTENT_TYPE] }, cancellation: cancellation)
+      end
+
+      lifecycle, owned = begin_native_processing(path, values, lifecycle, http_method)
+      work = lambda do
+        process_grpc(path, values, input: input, output: output, publish: publish,
+                                   lifecycle: lifecycle, cancellation: cancellation)
+      end
+      lifecycle ? lifecycle.activate(&work) : work.call
+      nil
+    rescue Exception => e # rubocop:disable Lint/RescueException -- observe the actual escape and preserve it
+      error = e
+      raise
+    ensure
+      finish_native_processing(lifecycle, owned, error) unless owned.nil?
+    end
+
+    private
+
+    def process_grpc(path, headers, input:, output:, publish:, lifecycle:, cancellation:)
+      # @type var state: GRPCProtocol::ServerState?
+      active = state = GRPCProtocol::ServerState.new(headers: headers, codec: :proto, publish: publish,
+                                                     lifecycle: lifecycle, cancellation: cancellation)
+      capture_stream_error(active) { execute_grpc_handler(active, path, input, output) }
+      render_grpc_terminal(active, output)
+    ensure
+      state&.session&.close
+      state&.context&.close
+    end
+
+    def execute_grpc_handler(state, path, input, output) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      GRPCProtocol.check_fields!(state.headers)
+      request_encoding = GRPCProtocol.encoding(state.headers, request: true, enabled: @encoding)
+      state.encoding = GRPCProtocol.response_encoding(state.headers, @encoding)
+      declaration = @methods[path]
+      raise Error.new(:unimplemented, "Unknown method"), cause: nil unless declaration
+      unless declaration.is_a?(Method) || @handlers[path]
+        raise Error.new(:unimplemented, "Unknown streaming method"), cause: nil
+      end
+
+      context = state.context = grpc_context(state, declaration)
+      session = state.session = Streaming::Session.new(
+        binding: @binding, method: declaration, codec: :proto, state: context, input: input, output: output,
+        request_limit: @request_limit, response_limit: @response_limit,
+        request_wire_limit: @request_wire_limit, response_wire_limit: @response_wire_limit,
+        request_encoding: request_encoding, response_encoding: state.encoding,
+        terminal_wire_limit: @grpc_status_wire_limit, terminal_limit: @grpc_status_limit,
+        server: true, context: context, lifecycle: state.lifecycle, publish: -> { publish_grpc_head(state) },
+        strategy: GRPCProtocol::Strategy.new(codec: @status_codec, wire_limit: @grpc_status_wire_limit,
+                                             limit: @grpc_status_limit)
+      )
+      if declaration.is_a?(Method)
+        request = single_stream_request(session)
+        context.check!
+        session.send_message(@invoker.call(declaration, request, context))
+      else
+        streaming = context #: StreamingContext
+        invoke_stream_handler(@handlers.fetch(path), declaration, session, streaming)
+      end
+      context.check!
+    end
+
+    def grpc_context(state, declaration = nil, headers: state.headers)
+      metadata = Protocol.metadata(headers)
+      state.lifecycle.request_metadata = Instrumentation.carrier(metadata) if state.lifecycle
+      options = { request_metadata: metadata, deadline: GRPCProtocol.request_deadline(headers),
+                  cancellation: state.cancellation, lifecycle: state.lifecycle }
+      return Context.new(**options) if declaration.nil? || declaration.is_a?(Method)
+
+      StreamingContext.new(publish: ->(snapshot) { publish_grpc_snapshot(state, snapshot) }, **options)
+    end
+
+    def publish_grpc_snapshot(state, metadata)
+      state.publish.call(grpc_head(metadata, state.encoding))
+      state.published = true
+      nil
+    end
+
+    def publish_grpc_head(state)
+      return if state.published
+
+      context = state.context #: Context
+      if context.is_a?(StreamingContext)
+        context.send(:publish_headers, check: false)
+      else
+        context.response_metadata.freeze
+        publish_grpc_snapshot(state, context.response_metadata)
+      end
+      raise(state.error || Error.new(:internal, "gRPC headers were not published")) unless state.published
+    end
+
+    def grpc_head(metadata, encoding)
+      fields = metadata.to_h.merge("content-type" => [GRPCProtocol::CONTENT_TYPE], "grpc-accept-encoding" => [
+                                     @encoding == :gzip ? "gzip,identity" : "identity"
+                                   ])
+      fields["grpc-encoding"] = ["gzip"] if encoding == :gzip
+      GRPCProtocol.check_fields!(fields.merge(":status" => ["200"]))
+      GRPCHead.new(status: 200, headers: fields, end_stream: false)
+    end
+
+    def grpc_terminal_fields(state, context)
+      merge_stream_error_metadata(state.error, context)
+      codec = @status_codec #: _GRPCStatusCodec
+      GRPCProtocol.terminal(
+        state.error, stream_trailers(state.error, context),
+        codec: codec,
+        wire_limit: @grpc_status_wire_limit, limit: @grpc_status_limit,
+        on_error: lambda { |error|
+          state.lifecycle&.record_failure(error)
+        }
+      )
+    end
+
+    def render_grpc_terminal(state, output)
+      context = state.context ||= grpc_context(state, headers: {})
+      fields, effective = grpc_terminal_fields(state, context)
+      observe_stream_result(state, effective) if state.error
+      publish_grpc_head(state)
+      output.finish(headers: fields)
+      context.commit! unless state.error
+      observe_stream_result(state, effective) unless state.error
+    end
+  end
+end

data/lib/connectrpc/grpc_web.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module ConnectRPC
+  # Server-only wire policy. Native gRPC's final HEADERS and client completion
+  # rules do not apply to a Web body terminal.
+  module GRPCWeb
+    # @type var types: Hash[representation, String]
+    types = { binary: "application/grpc-web+proto", text: "application/grpc-web-text+proto" }
+    CONTENT_TYPES = types.freeze
+    ACCEPT_LIMIT = 8192
+    ACCEPT_ENTRIES = 32
+
+    def self.intent?(headers)
+      (headers["content-type"] || []).any? { |value| value.downcase.start_with?("application/grpc-web") }
+    end
+
+    def self.media(value)
+      return :binary if value&.match?(%r{\Aapplication/grpc-web(?:\+proto)?\z}i)
+      return :text if value&.match?(%r{\Aapplication/grpc-web-text(?:\+proto)?\z}i)
+
+      nil
+    end
+
+    def self.representation(headers, request) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      values = headers.fetch("accept", [])
+      return if values.sum(&:bytesize) > ACCEPT_LIMIT
+      return request if values.empty?
+
+      entries = values.flat_map { |value| value.empty? ? [""] : value.split(",", -1) }
+      return if entries.size > ACCEPT_ENTRIES
+
+      entries.reject! { |entry| entry.strip.empty? }
+      return request if entries.empty?
+
+      parsed = entries.map { |entry| accept_entry(entry) }
+      return if parsed.any?(&:nil?)
+
+      entries = parsed.compact
+      other = (request == :text ? :binary : :text) #: representation
+      selected = quality(entries, request) >= quality(entries, other) ? request : other
+      selected if quality(entries, selected).positive?
+    end
+
+    def self.accept_entry(entry) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      token, *parameters = entry.strip.downcase.split(/\s*;\s*/, -1)
+      return unless token && %r{\A[!#$%&'*+.^_`|~0-9a-z-]+/[!#$%&'*+.^_`|~0-9a-z-]+\z}.match?(token)
+      return [token, 0] unless media(token) || %w[application/* */*].include?(token)
+
+      weights = parameters.grep(/\Aq(?:=|\s|\z)/)
+      return if weights.size > 1
+
+      weight = weights.first
+      match = /\Aq=(0(?:\.[0-9]{0,3})?|1(?:\.0{0,3})?)\z/.match(weight) if weight
+      return if weight && !match
+      # Our representations have no media parameters. Other parameters cannot
+      # match them, but do not invalidate a separate satisfiable list element.
+      return ["", 0] unless parameters.size == weights.size
+
+      [token, match ? (match[1].to_f * 1000).round : 1000]
+    end
+
+    def self.quality(entries, candidate) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      matches = entries.filter_map do |entry|
+        token, quality = entry
+        specificity = if media(token) == candidate
+                        2
+                      elsif token == "application/*"
+                        1
+                      elsif token == "*/*"
+                        0
+                      end
+        [specificity, quality] if specificity
+      end
+      matches.max&.last || 0
+    end
+
+    def self.vary(headers, *names)
+      tokens = headers.fetch("vary", []).flat_map { |value| value.split(",").map(&:strip) }
+      return headers if tokens.include?("*")
+
+      names.each { |name| tokens << name unless tokens.any? { |token| token.casecmp?(name) } }
+      headers["vary"] = tokens
+      headers
+    end
+
+    def self.capabilities!(capabilities)
+      return if capabilities.is_a?(Array) && !capabilities.empty? && capabilities.uniq.size == capabilities.size &&
+                capabilities.all? { |value| %i[unary server_stream].include?(value) }
+
+      raise ArgumentError, "Web capabilities must be distinct unary/server_stream symbols"
+    end
+
+    def self.terminal(error, trailers, codec:, wire_limit:, limit:, on_error:) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      fields, effective = GRPCProtocol.terminal(error, trailers, codec: codec, wire_limit: wire_limit, limit: limit,
+                                                                 on_error: on_error)
+      bytes = fields.flat_map { |key, values| values.map { |value| "#{key}: #{value}\r\n" } }.join.b
+      if bytes.bytesize > wire_limit
+        fields, effective = GRPCProtocol.terminal(Error.new(:resource_exhausted, "Status exceeds byte limit"),
+                                                  Metadata.new, codec: codec, wire_limit: wire_limit, limit: limit)
+        bytes = "grpc-status: #{fields.fetch('grpc-status').first}\r\n".b
+        Protocol.check_size!(bytes, wire_limit)
+      end
+      [[128, bytes.bytesize].pack("CN") + bytes, effective]
+    rescue Error
+      raise
+    rescue StandardError => e
+      on_error&.call(e)
+      terminal(Error.new(:internal, "Cannot encode gRPC status"), Metadata.new, codec: codec,
+                                                                                wire_limit: wire_limit, limit: limit,
+                                                                                on_error: nil)
+    end
+
+    class Framing < Streaming::Framing
+      private
+
+      def validate_flags(flags)
+        protocol_error("Invalid Web envelope flags") unless [0, 1].include?(flags)
+        raise Error.new(:internal, "Unnegotiated compression"), cause: nil if flags == 1
+      end
+    end
+
+    class Strategy
+      def grpc? = false
+      def framing = Framing
+      def wait(timeout) = [timeout || Deadline::MAX_NATIVE_WAIT, Deadline::MAX_NATIVE_WAIT].min
+      def single_response?(method) = method.is_a?(Method)
+      def decode_error(_server) = :invalid_argument
+    end
+  end
+  private_constant :GRPCWeb
+end