quicsilver 0.3.0 → 0.5.0

data/lib/quicsilver/protocol/response_parser.rb

@@ -1,39 +1,34 @@
 # frozen_string_literal: true
 
-require "stringio"
-require_relative "qpack/header_block_decoder"
+require_relative "frame_parser"
 
 module Quicsilver
   module Protocol
-    class ResponseParser
-      attr_reader :headers, :status
+    class ResponseParser < FrameParser
+      attr_reader :status
 
-      def frames
-        @frames || []
+      # Validate response semantics per RFC 9114 §4.3.2.
+      # Call after parse to check :status is present.
+      def validate_response!
+        raise Protocol::MessageError, "Response missing required :status pseudo-header" unless @status
       end
 
-      DEFAULT_DECODER = Qpack::HeaderBlockDecoder.default
-
       def initialize(data, **opts)
+        decoder = opts.delete(:decoder) || DEFAULT_DECODER
+        super(decoder: decoder, max_body_size: opts[:max_body_size],
+              max_header_size: opts[:max_header_size])
         @data = data
-        if opts.empty?
-          @decoder = DEFAULT_DECODER
-          @use_parse_cache = true
-        else
-          @decoder = opts[:decoder] || DEFAULT_DECODER
-          @max_body_size = opts[:max_body_size]
-          @max_header_size = opts[:max_header_size]
-          @use_parse_cache = @decoder.equal?(DEFAULT_DECODER) && !@max_body_size && !@max_header_size
-        end
+        @use_parse_cache = @decoder.equal?(DEFAULT_DECODER) && !@max_body_size && !@max_header_size
       end
 
       # Reset parser with new data for object reuse (avoids allocation overhead)
       def reset(data)
         @data = data
         @status = nil
-        @headers = nil
+        @headers = {}
+        @trailers = {}
         @frames = nil
-        @body_io = nil
+        @body = nil
         @cached_body_str = nil
       end
 
@@ -55,35 +50,22 @@ module Quicsilver
             @headers = cached[1]
             @frames = cached[2]
             @cached_body_str = cached[3]
+            @trailers = cached[4] || {}
             @last_data = data
             return
           end
         end
         @status = nil
-        @headers = nil
+        @headers = {}
+        @trailers = {}
         @frames = nil
-        @body_io = nil
+        @body = nil
         @cached_body_str = nil
         parse!
         cache_result if @use_parse_cache
       end
 
-      def body
-        if @body_io
-          @body_io.rewind
-          @body_io
-        elsif @cached_body_str
-          @body_io = StringIO.new(@cached_body_str)
-          @body_io.set_encoding(Encoding::ASCII_8BIT)
-          @body_io
-        else
-          EMPTY_BODY
-        end
-      end
-
-      EMPTY_BODY = StringIO.new("".b).tap { |io| io.set_encoding(Encoding::ASCII_8BIT) }
-
-      # Class-level parse result cache: data → [status, headers, frames, body_str]
+      # Class-level parse result cache: data → [status, headers, frames, body_str, trailers]
       PARSE_CACHE = {}
       PARSE_CACHE_MAX = 128
       PARSE_OID_CACHE = {}
@@ -98,6 +80,7 @@ module Quicsilver
             @headers = cached[1]
             @frames = cached[2]
             @cached_body_str = cached[3]
+            @trailers = cached[4] || {}
             return
           end
         end
@@ -108,10 +91,10 @@ module Quicsilver
 
       private def cache_result
         if PARSE_CACHE.size < PARSE_CACHE_MAX && @data.bytesize <= 1024
-          body_str = if @body_io
-            @body_io.rewind
-            s = @body_io.read
-            @body_io.rewind
+          body_str = if @body
+            @body.rewind
+            s = @body.read
+            @body.rewind
             s
           end
           key = @data.frozen? ? @data : @data.dup.freeze
@@ -119,82 +102,14 @@ module Quicsilver
             @status,
             @headers.dup.freeze,
             (@frames || []).freeze,
-            body_str&.freeze
+            body_str&.freeze,
+            (@trailers.empty? ? nil : @trailers.dup.freeze)
           ].freeze
         end
       end
 
       private
 
-      # Frame types forbidden on request streams — O(1) lookup
-      CONTROL_ONLY_SET = Protocol::CONTROL_ONLY_FRAMES.each_with_object({}) { |f, h| h[f] = true }.freeze
-
-      def parse!
-        @headers = {}
-        @status = nil
-        @body_io = nil
-        @frames = nil
-        buffer = @data
-        offset = 0
-        headers_received = false
-        buf_size = buffer.bytesize
-
-        while offset < buf_size
-          break if buf_size - offset < 2
-
-          # Inline single-byte varint fast path (covers frame types 0x00-0x3F)
-          type_byte = buffer.getbyte(offset)
-          if type_byte < 0x40
-            type = type_byte
-            type_len = 1
-          else
-            type, type_len = Protocol.decode_varint_str(buffer, offset)
-          end
-
-          len_byte = buffer.getbyte(offset + type_len)
-          if len_byte < 0x40
-            length = len_byte
-            length_len = 1
-          else
-            length, length_len = Protocol.decode_varint_str(buffer, offset + type_len)
-            break if length_len == 0
-          end
-          break if type_len == 0
-
-          header_len = type_len + length_len
-
-          break if buf_size < offset + header_len + length
-
-          payload = buffer.byteslice(offset + header_len, length)
-          (@frames ||= []) << { type: type, length: length, payload: payload }
-
-          if CONTROL_ONLY_SET.key?(type)
-            raise Protocol::FrameError, "Frame type 0x#{type.to_s(16)} not allowed on request streams"
-          end
-
-          case type
-          when 0x01 # HEADERS
-            if @max_header_size && length > @max_header_size
-              raise Protocol::MessageError, "Header block #{length} exceeds limit #{@max_header_size}"
-            end
-            parse_headers(payload)
-            headers_received = true
-          when 0x00 # DATA
-            raise Protocol::FrameError, "DATA frame before HEADERS" unless headers_received
-            unless @body_io
-              @body_io = StringIO.new
-              @body_io.set_encoding(Encoding::ASCII_8BIT)
-            end
-            @body_io.write(payload)
-            if @max_body_size && @body_io.size > @max_body_size
-              raise Protocol::MessageError, "Body size #{@body_io.size} exceeds limit #{@max_body_size}"
-            end
-          end
-
-          offset += header_len + length
-        end
-      end
-
       # Cache for validated response header results
       HEADERS_CACHE = {}
       HEADERS_CACHE_MAX = 256
@@ -227,23 +142,6 @@ module Quicsilver
           HEADERS_CACHE[key] = { status: @status, headers: @headers.dup.freeze }.freeze
         end
       end
-
-      # RFC 9110 §5.3: Combine duplicate header values.
-      # - set-cookie: join with "\n" (Rack convention, MUST NOT combine with comma)
-      # - cookie: join with "; " (RFC 9114 §4.2.1)
-      # - all others: join with ", "
-      def store_header(name, value)
-        if @headers.key?(name)
-          separator = case name
-            when "set-cookie" then "\n"
-            when "cookie" then "; "
-            else ", "
-          end
-          @headers[name] = "#{@headers[name]}#{separator}#{value}"
-        else
-          @headers[name] = value
-        end
-      end
     end
   end
 end

data/lib/quicsilver/protocol/stream_input.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "protocol/http/body/writable"
+
+module Quicsilver
+  module Protocol
+    # A streaming request body backed by Protocol::HTTP::Body::Writable.
+    #
+    # QUIC RECEIVE events push chunks via {write}, while the application
+    # reads them via {read}. This enables concurrent streaming — the app
+    # can start processing before the full body arrives.
+    #
+    # Follows the protocol-http Body::Writable contract:
+    # - write(chunk) — called by the QUIC transport on RECEIVE events
+    # - close_write  — called on RECEIVE_FIN to signal end of body
+    # - read         — called by the application (blocks until data available)
+    # - close        — called to abort (e.g., stream reset)
+    #
+    # Optional features:
+    # - Back-pressure via Thread::SizedQueue (bounded buffer)
+    # - Read timeout for slow client protection
+    #
+    class StreamInput < ::Protocol::HTTP::Body::Writable
+      class ReadTimeout < Quicsilver::Error; end
+
+      # @param length [Integer, nil] The content-length if known from headers.
+      # @param queue_size [Integer, nil] Maximum buffered chunks for back-pressure.
+      #   nil (default) = unbounded. When bounded, write blocks if queue is full.
+      #   A bounded queue must not block the MsQuic poll thread.
+      # @param read_timeout [Numeric, nil] Seconds to wait for data before raising
+      #   ReadTimeout. nil (default) = wait forever.
+      def initialize(length = nil, queue_size: nil, read_timeout: nil)
+        queue = if queue_size
+          Thread::SizedQueue.new(queue_size)
+        else
+          Thread::Queue.new
+        end
+
+        super(length, queue: queue)
+        @read_timeout = read_timeout
+        @bytes_written = 0
+      end
+
+      # @attribute [Numeric, nil] Read timeout in seconds.
+      attr_reader :read_timeout
+
+      # Track bytes written for content-length validation.
+      def write(chunk)
+        @bytes_written += chunk.bytesize
+        super
+      end
+
+      # Signal that no more data will be written.
+      # Validates content-length if declared (RFC 9114 §4.1.2) — raises
+      # MessageError if total bytes written don't match.
+      def close_write(error = nil)
+        if @length && @bytes_written != @length
+          raise Protocol::MessageError, "Content-length mismatch: header=#{@length}, body=#{@bytes_written}"
+        end
+        super
+      end
+
+      # Read the next available chunk, with optional timeout.
+      #
+      # @returns [String | Nil] The next chunk, or nil if the body is finished.
+      # @raises [ReadTimeout] If no data arrives within the timeout.
+      # @raises [Exception] If the body was closed due to an error.
+      def read
+        if @read_timeout
+          read_with_timeout
+        else
+          super
+        end
+      end
+
+      private
+
+      def read_with_timeout
+        raise @error if @error
+
+        # Thread::Queue#pop(timeout:) blocks efficiently (no busy-wait).
+        # Returns nil on timeout OR on closed empty queue — disambiguate below.
+        chunk = @queue.pop(timeout: @read_timeout)
+
+        raise @error if @error
+
+        # nil means either timeout or body finished (queue closed + empty).
+        # If queue is closed, the body is done — return nil (EOF).
+        # If queue is still open, we timed out waiting for data.
+        if chunk.nil? && !@queue.closed?
+          raise ReadTimeout, "No data received within #{@read_timeout}s"
+        end
+
+        chunk
+      end
+    end
+  end
+end

data/lib/quicsilver/protocol/stream_output.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+
+module Quicsilver
+  module Protocol
+    # Reads from a Protocol::HTTP::Body::Readable response body and writes
+    # HTTP/3 DATA frames to the transport.
+    #
+    # Transport-agnostic: takes a writer block/callable that handles the actual
+    # sending. Works with msquic, kernel QUIC sockets, or any transport that
+    # can send bytes with a FIN flag.
+    #
+    class StreamOutput
+      # @param body [Protocol::HTTP::Body::Readable] The response body to stream.
+      # @param writer [#call] A callable that accepts (data, fin) — sends bytes
+      #   to the transport. `fin: true` signals end of stream.
+      def initialize(body, &writer)
+        @body = body
+        @writer = writer
+      end
+
+      # Stream all chunks from the response body as HTTP/3 DATA frames.
+      #
+      # Each chunk is wrapped in an HTTP/3 DATA frame (type 0x00) and sent
+      # via the writer. The final chunk is sent with fin=true.
+      #
+      # @param send_fin [Boolean] Whether to send FIN after the last chunk.
+      #   Set to false when trailers will follow.
+      # @return [void]
+      def stream(send_fin: true)
+        last_chunk = nil
+
+        while (chunk = @body.read)
+          if last_chunk
+            @writer.call(build_data_frame(last_chunk), false)
+          end
+          last_chunk = chunk
+        end
+
+        if last_chunk
+          @writer.call(build_data_frame(last_chunk), send_fin)
+        elsif send_fin
+          @writer.call("".b, true)
+        end
+      ensure
+        @body.close if @body.respond_to?(:close)
+      end
+
+      private
+
+      def build_data_frame(payload)
+        payload = payload.b
+        Quicsilver::Protocol.encode_varint(Quicsilver::Protocol::FRAME_DATA) +
+          Quicsilver::Protocol.encode_varint(payload.bytesize) +
+          payload
+      end
+    end
+  end
+end

data/lib/quicsilver/protocol/unidirectional_stream.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Quicsilver
+  module Protocol
+    module UnidirectionalStream
+      CONTROL = 0x00
+      PUSH = 0x01
+      QPACK_ENCODER = 0x02
+      QPACK_DECODER = 0x03
+    end
+  end
+end

data/lib/quicsilver/protocol/web_transport.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module Quicsilver
+  module Protocol
+    module WebTransport
+      SESSION_GONE = 0x170d7b68
+      BUFFERED_STREAM_REJECTED = 0x3994bd84
+
+      BIDI_STREAM_TYPE = 0x41
+      UNI_STREAM_TYPE = 0x54
+      CLOSE_SESSION_CAPSULE = 0x2843
+
+      # draft-ietf-webtrans-http3-16 §4.7. Advisory: either endpoint asks the
+      # other to wind the session down, but the session stays usable until it
+      # is actually closed.
+      DRAIN_SESSION_CAPSULE = 0x78ae
+
+      # Session-level flow control (§5.6). These sit above QUIC's own limits:
+      # QUIC bounds the connection and each stream, these bound one session
+      # across all of its streams.
+      #
+      # MAX_* raise a limit. *_BLOCKED are advisory, saying a limit was hit;
+      # §5.6 forbids waiting for one before raising a limit.
+      MAX_DATA_CAPSULE = 0x190B4D3D
+      MAX_STREAMS_BIDI_CAPSULE = 0x190B4D3F
+      MAX_STREAMS_UNI_CAPSULE = 0x190B4D40
+      DATA_BLOCKED_CAPSULE = 0x190B4D41
+      STREAMS_BLOCKED_BIDI_CAPSULE = 0x190B4D43
+      STREAMS_BLOCKED_UNI_CAPSULE = 0x190B4D44
+
+      # A flow control violation closes the session, not the connection (§5.6).
+      FLOW_CONTROL_ERROR = 0x045d4487
+
+      # Per-stream data limits belong to the HTTP/2 binding. Over HTTP/3 every
+      # WebTransport stream is a real QUIC stream, so QUIC provides them
+      # natively and these two capsules are prohibited: receipt is a session
+      # error (§5.4).
+      #
+      # Defined in draft-ietf-webtrans-http2-14 §6.6 and §6.9, which the HTTP/3
+      # draft cites without restating the code points. They fill the two gaps
+      # in the 0x190B4D3D..0x190B4D44 block the §9.6 registry allocates.
+      #
+      # That draft is not in docs/specs, so these are the only values here
+      # without a local citation. Re-verify them when it is vendored.
+      MAX_STREAM_DATA_CAPSULE = 0x190B4D3E
+      STREAM_DATA_BLOCKED_CAPSULE = 0x190B4D42
+
+      PROHIBITED_CAPSULES = [MAX_STREAM_DATA_CAPSULE, STREAM_DATA_BLOCKED_CAPSULE].freeze
+
+      # Prohibited whether or not flow control was negotiated. §5.1 says to
+      # ignore "flow control capsules" when flow control is off, but §5.6
+      # defines that term as MAX_DATA, MAX_STREAMS, DATA_BLOCKED and
+      # STREAMS_BLOCKED only. These two are never legal over HTTP/3.
+      def self.prohibited_capsule?(type)
+        PROHIBITED_CAPSULES.include?(type)
+      end
+
+      # Stream limits cannot exceed 2^60: a larger count could not be encoded
+      # as a stream ID (§5.6.2, §5.6.3).
+      MAX_STREAMS_LIMIT = 1 << 60
+
+      # Largest value a QUIC variable-length integer can carry (RFC 9000 §16).
+      VARINT_MAX = (1 << 62) - 1
+
+      # Raised for a capsule whose contents break a flow control rule, as
+      # opposed to one we cannot parse. The session is closed with
+      # FLOW_CONTROL_ERROR; the connection survives.
+      class FlowControlError < StandardError
+        def error_code = FLOW_CONTROL_ERROR
+      end
+
+      # We wanted to send but the peer's session limit forbids it (§5.3,
+      # §5.4). Local and recoverable: nothing is wrong on the wire, there is
+      # simply no credit. Distinct from FlowControlError, which means the peer
+      # broke a rule and the session must close.
+      class SendBlocked < StandardError
+        attr_reader :limit, :needed
+
+        def initialize(message, limit:, needed:)
+          super(message)
+          @limit = limit
+          @needed = needed
+        end
+      end
+
+      # What a flow control capsule says. `limit` is cumulative for MAX_DATA
+      # and MAX_STREAMS, and for the BLOCKED capsules it is the limit that was
+      # in force when the sender was blocked.
+      Limit = Data.define(:kind, :direction, :limit) do
+        def max? = kind == :max_data || kind == :max_streams
+        def blocked? = !max?
+      end
+
+      # kind and direction for each flow control capsule type. Direction is nil
+      # where the capsule covers the whole session rather than one stream type.
+      FLOW_CONTROL_CAPSULES = {
+        MAX_DATA_CAPSULE => [:max_data, nil],
+        MAX_STREAMS_BIDI_CAPSULE => [:max_streams, :bidi],
+        MAX_STREAMS_UNI_CAPSULE => [:max_streams, :uni],
+        DATA_BLOCKED_CAPSULE => [:data_blocked, nil],
+        STREAMS_BLOCKED_BIDI_CAPSULE => [:streams_blocked, :bidi],
+        STREAMS_BLOCKED_UNI_CAPSULE => [:streams_blocked, :uni]
+      }.freeze
+
+      def self.flow_control_capsule?(type)
+        FLOW_CONTROL_CAPSULES.key?(type)
+      end
+
+      # Decode a flow control capsule payload: a single varint (§5.6.2-5.6.5).
+      #
+      # Raises Capsule::ParseError when the payload is not exactly one varint,
+      # and FlowControlError when a stream count exceeds what a stream ID can
+      # encode. Those are different outcomes on the wire: the first is a
+      # malformed message, the second a flow control violation.
+      def self.parse_flow_control_capsule(type, payload)
+        kind, direction = FLOW_CONTROL_CAPSULES.fetch(type) do
+          raise ArgumentError, "Not a flow control capsule: 0x#{type.to_s(16)}"
+        end
+
+        value, length = Protocol.decode_varint_str(payload, 0)
+        raise Capsule::ParseError, "Truncated #{kind} capsule" if length == 0
+        raise Capsule::ParseError, "Trailing bytes in #{kind} capsule" unless length == payload.bytesize
+
+        if (kind == :max_streams || kind == :streams_blocked) && value > MAX_STREAMS_LIMIT
+          raise FlowControlError, "#{kind} of #{value} exceeds the 2^60 stream limit"
+        end
+
+        Limit.new(kind: kind, direction: direction, limit: value)
+      end
+
+      def self.build_max_data(limit)
+        Capsule.encode(MAX_DATA_CAPSULE, Protocol.encode_varint(validate_limit!(limit)))
+      end
+
+      def self.build_data_blocked(limit)
+        Capsule.encode(DATA_BLOCKED_CAPSULE, Protocol.encode_varint(validate_limit!(limit)))
+      end
+
+      def self.build_max_streams(direction, limit)
+        type = (direction == :bidi) ? MAX_STREAMS_BIDI_CAPSULE : MAX_STREAMS_UNI_CAPSULE
+        Capsule.encode(type, Protocol.encode_varint(validate_stream_limit!(direction, limit)))
+      end
+
+      def self.build_streams_blocked(direction, limit)
+        type = (direction == :bidi) ? STREAMS_BLOCKED_BIDI_CAPSULE : STREAMS_BLOCKED_UNI_CAPSULE
+        Capsule.encode(type, Protocol.encode_varint(validate_stream_limit!(direction, limit)))
+      end
+
+      # Building a capsule the peer would have to reject is our bug, so these
+      # raise ArgumentError rather than a protocol error.
+      def self.validate_limit!(limit)
+        unless limit.is_a?(Integer) && limit >= 0 && limit <= VARINT_MAX
+          raise ArgumentError, "Limit must be a varint-encodable non-negative integer"
+        end
+
+        limit
+      end
+
+      def self.validate_stream_limit!(direction, limit)
+        unless direction == :bidi || direction == :uni
+          raise ArgumentError, "Direction must be :bidi or :uni"
+        end
+        validate_limit!(limit)
+        raise ArgumentError, "Stream limit #{limit} exceeds 2^60" if limit > MAX_STREAMS_LIMIT
+
+        limit
+      end
+
+      # Extended CONNECT :protocol values.
+      #
+      # draft-ietf-webtrans-http3-16 §3.2 requires "webtransport-h3". The bare
+      # "webtransport" token identifies the capsule-based HTTP/2 binding
+      # (§2.1.2) and was what pre-15 drafts used over HTTP/3. We retain it
+      # for legacy interoperability; the token alone does not identify a
+      # browser version or prove support for every feature of an older draft.
+      PROTOCOL = "webtransport-h3"
+      PROTOCOL_LEGACY = "webtransport"
+
+      def self.protocol?(value)
+        value == PROTOCOL || value == PROTOCOL_LEGACY
+      end
+
+      # WebTransport shares the HTTP/3 error space, so 32-bit application error
+      # codes are mapped into a reserved range (§4.4, §9.5). Codepoints of the
+      # form 0x1f * N + 0x21 are reserved by HTTP/3 §8.1 and skipped, which is
+      # why this is not a plain offset.
+      APPLICATION_ERROR_FIRST = 0x52e4a40fa8db
+      APPLICATION_ERROR_LAST = 0x52e5ac983162
+
+      RESERVED_STRIDE = 0x1f
+      RESERVED_OFFSET = 0x21
+
+      # Application code -> HTTP/3 code, stepping over reserved codepoints.
+      def self.application_error_to_http(code)
+        APPLICATION_ERROR_FIRST + code + (code / 0x1e)
+      end
+
+      # HTTP/3 code -> application code. nil when the code is outside the
+      # reserved range or lands on a reserved codepoint, neither of which a
+      # peer should ever send.
+      def self.http_to_application_error(code)
+        return nil unless code.between?(APPLICATION_ERROR_FIRST, APPLICATION_ERROR_LAST)
+        return nil if reserved_codepoint?(code)
+
+        shifted = code - APPLICATION_ERROR_FIRST
+        shifted - (shifted / RESERVED_STRIDE)
+      end
+
+      def self.reserved_codepoint?(code)
+        (code - RESERVED_OFFSET) % RESERVED_STRIDE == 0
+      end
+    end
+  end
+end

data/lib/quicsilver/rack/context.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Quicsilver
+  module Rack
+    # Rack-visible Quicsilver transport context.
+    #
+    # This is the single env capability object for HTTP/3/QUIC-specific state.
+    # Normal Rack apps can ignore it; Quicsilver-aware apps can use it to opt into
+    # transport features like WebTransport.
+    class Context
+      attr_reader :stream_id, :webtransport
+
+      def initialize(stream_id: nil, early_data: false, webtransport: nil, metadata: {})
+        @stream_id = stream_id
+        @early_data = early_data
+        @webtransport = webtransport
+        @metadata = metadata || {}
+      end
+
+      def early_data?
+        !!@early_data
+      end
+
+      def webtransport?
+        !!@webtransport
+      end
+
+      def [](key)
+        @metadata[key]
+      end
+    end
+  end
+end

data/lib/quicsilver/response.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Quicsilver
+  # Unified HTTP/3 response object returned by the client.
+  #
+  # Used for both buffered and streaming responses:
+  # - Buffered: body is a String
+  # - Streaming: body is a StreamInput (call body.read in a loop)
+  #
+  #   response = client.get("/users")
+  #   response.status   # => 200
+  #   response.headers   # => {"content-type" => "application/json"}
+  #   response.body      # => '{"users":["alice"]}'
+  #   response.trailers  # => {}
+  #
+  #   # Streaming
+  #   req = client.build_request("GET", "/stream")
+  #   response = req.streaming_response(timeout: 10)
+  #   response.status   # => 200
+  #   while (chunk = response.body.read)
+  #     process(chunk)
+  #   end
+  #
+  class Response
+    attr_reader :status, :headers, :body, :trailers
+
+    def initialize(status:, headers: {}, body: nil, trailers: {})
+      @status = status
+      @headers = headers
+      @body = body
+      @trailers = trailers
+    end
+
+    def ok? = status == 200
+    def success? = status >= 200 && status < 300
+    def redirect? = status >= 300 && status < 400
+    def client_error? = status >= 400 && status < 500
+    def server_error? = status >= 500 && status < 600
+  end
+end