raptor 0.22.3 → 0.24.0

data/lib/raptor/http1.rb

@@ -11,6 +11,7 @@ require "rack"
 require_relative "detached_body"
 require_relative "http"
 require_relative "raptor_http"
+require_relative "server"
 require_relative "thread_locals"
 
 module Raptor
@@ -29,29 +30,33 @@ module Raptor
 
     HTTP_10 = "HTTP/1.0"
     HTTP_11 = "HTTP/1.1"
-    STATUS_LINE_CACHE_10 = Hash.new do |h, status|
+    STATUS_LINE_CACHE_10 = Hash.new do |cache, status|
       reason = Rack::Utils::HTTP_STATUS_CODES[status]
-      h[status] = "HTTP/1.0 #{status}#{reason ? " #{reason}" : ""}\r\n".freeze
+      cache[status] = "#{HTTP_10} #{status}#{reason ? " #{reason}" : ""}\r\n".freeze
     end
-    STATUS_LINE_CACHE_11 = Hash.new do |h, status|
+    STATUS_LINE_CACHE_11 = Hash.new do |cache, status|
       reason = Rack::Utils::HTTP_STATUS_CODES[status]
-      h[status] = "HTTP/1.1 #{status}#{reason ? " #{reason}" : ""}\r\n".freeze
+      cache[status] = "#{HTTP_11} #{status}#{reason ? " #{reason}" : ""}\r\n".freeze
     end
 
     CONTINUE_RESPONSE = "HTTP/1.1 100 Continue\r\n\r\n"
     BAD_REQUEST_RESPONSE = "HTTP/1.1 400 Bad Request\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
     CONTENT_TOO_LARGE_RESPONSE = "HTTP/1.1 413 Content Too Large\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
     INTERNAL_SERVER_ERROR_RESPONSE = "HTTP/1.1 500 Internal Server Error\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
+    NOT_IMPLEMENTED_RESPONSE = "HTTP/1.1 501 Not Implemented\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
+    CHUNKED_TERMINATOR = "0\r\n\r\n"
 
     CONNECTION_CLOSE = "close"
     CONNECTION_KEEPALIVE = "keep-alive"
     EXPECT_100_CONTINUE = "100-continue"
     TRANSFER_ENCODING_CHUNKED = "chunked"
-    CHUNKED_TERMINATOR = "0\r\n\r\n"
 
     HTTP_CONNECTION = "HTTP_CONNECTION"
     HTTP_EXPECT = "HTTP_EXPECT"
     HTTP_TRANSFER_ENCODING = "HTTP_TRANSFER_ENCODING"
+    HTTP_X_FORWARDED_PROTO = "HTTP_X_FORWARDED_PROTO"
+    HTTP_X_FORWARDED_SCHEME = "HTTP_X_FORWARDED_SCHEME"
+    HTTP_X_FORWARDED_SSL = "HTTP_X_FORWARDED_SSL"
     RACK_HEADER_PREFIX = "rack."
     RACK_HIJACKED = "rack.hijacked"
     RACK_HIJACK_IO = "rack.hijack_io"
@@ -71,31 +76,40 @@ module Raptor
       !http_host || http_host.empty? || http_host.include?(",")
     end
 
-    # Returns true when the message framing shows a request-smuggling vector
-    # per RFC 9112 section 6.3: a `Transfer-Encoding` where `chunked` is
-    # missing, not the final encoding, or duplicated; a `Transfer-Encoding`
-    # paired with a `Content-Length`; or a `Content-Length` containing any
-    # non-digit character.
+    # Rejects ambiguous message framing per RFC 9112 section 6.3 and
+    # transfer codings other than a single `chunked`.
     #
     # @param env [Hash] the Rack environment after header parsing
-    # @return [Boolean]
+    # @return [Symbol, nil] `:malformed`, `:unsupported_encoding`, or nil
     #
-    # @rbs (Hash[String, untyped] env) -> bool
-    def self.request_smuggling?(env)
+    # @rbs (Hash[String, untyped] env) -> Symbol?
+    def self.framing_error(env)
       transfer_encoding = env[HTTP_TRANSFER_ENCODING]
       content_length = env[Http::CONTENT_LENGTH]
 
       if transfer_encoding
-        return true if content_length
+        return :malformed if content_length
 
-        encodings = transfer_encoding.downcase.split(",").map(&:strip)
-        return true if encodings.last != TRANSFER_ENCODING_CHUNKED
-        return true if encodings.count(TRANSFER_ENCODING_CHUNKED) > 1
+        encodings = transfer_encoding.downcase.split(",", -1).map(&:strip)
+        return :malformed if encodings.any?(&:empty?) || encodings.last != TRANSFER_ENCODING_CHUNKED
+        return :malformed if encodings.count(TRANSFER_ENCODING_CHUNKED) > 1
+        return :unsupported_encoding if encodings.size > 1
       elsif content_length
-        return true if content_length.match?(/[^\d]/)
+        return :malformed unless content_length.match?(/\A[0-9]+\z/)
       end
 
-      false
+      nil
+    end
+
+    # Returns any pipelined bytes following the request, or nil if none remain.
+    #
+    # @param buffer [String] the raw request bytes
+    # @param offset [Integer] the byte offset where the request ends
+    # @return [String, nil]
+    #
+    # @rbs (String buffer, Integer offset) -> String?
+    def self.pipelined_bytes(buffer, offset)
+      buffer.byteslice(offset..-1) if offset < buffer.bytesize
     end
 
     # Encodes one HTTP/1.1 response chunk.
@@ -128,9 +142,10 @@ module Raptor
 
     # Advances an HTTP/1.x request parse from the state hash's buffered
     # bytes. A complete well-formed request returns with `:complete` set
-    # plus populated `:env` and `:body`; malformed or oversized input flips
-    # `:malformed` or `:too_large`; incomplete input returns the state
-    # so the reactor can wait for more.
+    # plus populated `:env` and `:body`, and records any bytes after it in
+    # the parse data's `:pipelined`. Rejected input sets `:malformed`,
+    # `:too_large`, or `:unsupported_encoding`; incomplete input returns
+    # the state so the reactor can wait for more.
     #
     # @param data [Hash] the current parse state
     # @param env_template [Hash] the Rack env template to seed the request with
@@ -139,11 +154,11 @@ module Raptor
     #
     # @rbs (Hash[Symbol, untyped] data, Hash[String, untyped] env_template, Integer? max_body_size) -> Hash[Symbol, untyped]
     def self.parse(data, env_template, max_body_size)
-      parser = Raptor::HttpParser.new
+      parser = HttpParser.new
       env = env_template.dup
       nread = begin
         parser.execute(env, data[:buffer], 0)
-      rescue Raptor::HttpParserError
+      rescue HttpParserError
         return Ractor.make_shareable(data.merge(complete: true, malformed: true))
       end
       parse_data = if data[:parse_data]
@@ -154,19 +169,21 @@ module Raptor
       parse_data[:parse_count] += 1
 
       message = if parser.finished?
-        if invalid_host?(env) || request_smuggling?(env)
-          data.merge(env: env, body: nil, parse_data: parse_data, complete: true, malformed: true)
+        error = invalid_host?(env) ? :malformed : framing_error(env)
+        if error
+          data.merge(env: env, body: nil, parse_data: parse_data, complete: true, error => true)
         elsif parser.has_body?
           body_buffer = data[:buffer].byteslice(nread..-1) || ""
 
           if max_body_size && parser.content_length > max_body_size
             data.merge(env: env, body: nil, parse_data: parse_data, complete: true, too_large: true)
           elsif parser.chunked?
-            decoded_body, chunked_state = HttpParser.decode_chunked(body_buffer, max_body_size)
+            decoded_body, chunked_state, consumed = HttpParser.decode_chunked(body_buffer, max_body_size)
 
             case chunked_state
             when :complete
               env.delete(HTTP_TRANSFER_ENCODING)
+              parse_data[:pipelined] = pipelined_bytes(body_buffer, consumed)
               data.merge(env: env, body: decoded_body, parse_data: parse_data, complete: true)
             when :too_large
               data.merge(env: env, body: nil, parse_data: parse_data, complete: true, too_large: true)
@@ -178,9 +195,11 @@ module Raptor
           elsif parser.content_length > body_buffer.bytesize
             data.merge(env: env, parse_data: parse_data)
           else
-            data.merge(env: env, body: body_buffer, parse_data: parse_data, complete: true)
+            parse_data[:pipelined] = pipelined_bytes(body_buffer, parser.content_length)
+            data.merge(env: env, body: body_buffer.byteslice(0, parser.content_length), parse_data: parse_data, complete: true)
           end
         else
+          parse_data[:pipelined] = pipelined_bytes(data[:buffer], nread)
           data.merge(env: env, body: nil, parse_data: parse_data, complete: true)
         end
       else
@@ -190,7 +209,6 @@ module Raptor
     end
 
     # @rbs @app: ^(Hash[String, untyped]) -> [Integer, Hash[String, String | Array[String]], untyped]
-    # @rbs @server_port: Integer
     # @rbs @server_port_string: String
     # @rbs @write_timeout: Integer
     # @rbs @max_body_size: Integer?
@@ -199,7 +217,7 @@ module Raptor
     # @rbs @access_log_io: IO?
     # @rbs @clean_thread_locals: bool
     # @rbs @clean_fiber_locals: bool
-    # @rbs @on_error: ^(Hash[String, untyped]?, Exception) -> void | nil
+    # @rbs @on_error: (^(Hash[String, untyped]?, Exception) -> void)?
     # @rbs @running: AtomicBoolean
     # @rbs @env_template: Hash[String, untyped]
 
@@ -219,10 +237,9 @@ module Raptor
     # @param on_error [#call, nil] callback invoked with (env, exception) when the Rack app raises
     # @return [void]
     #
-    # @rbs (^(Hash[String, untyped]) -> [Integer, Hash[String, String | Array[String]], untyped] app, Integer server_port, ?connection_options: Hash[Symbol, untyped], ?http1_options: Hash[Symbol, untyped], ?access_log_io: IO?, ?clean_thread_locals: bool, ?clean_fiber_locals: bool, ?on_error: ^(Hash[String, untyped]?, Exception) -> void | nil) -> void
+    # @rbs (^(Hash[String, untyped]) -> [Integer, Hash[String, String | Array[String]], untyped] app, Integer server_port, ?connection_options: Hash[Symbol, untyped], ?http1_options: Hash[Symbol, untyped], ?access_log_io: IO?, ?clean_thread_locals: bool, ?clean_fiber_locals: bool, ?on_error: (^(Hash[String, untyped]?, Exception) -> void)?) -> void
     def initialize(app, server_port, connection_options: {}, http1_options: {}, access_log_io: nil, clean_thread_locals: true, clean_fiber_locals: false, on_error: nil)
       @app = app
-      @server_port = server_port
       @server_port_string = server_port.to_s.freeze
       @write_timeout = connection_options[:write_timeout] || Http::WRITE_TIMEOUT
       @max_body_size = connection_options[:max_body_size]
@@ -242,8 +259,7 @@ module Raptor
       }.freeze
     end
 
-    # Instance-level wrapper around {Http.parser_worker} that binds this
-    # handler's env template and body-size limit into the worker proc.
+    # Returns a Ractor-safe proc that parses HTTP/1.x requests.
     #
     # @return [Proc]
     #
@@ -252,32 +268,6 @@ module Raptor
       Http.parser_worker(@env_template, @max_body_size)
     end
 
-    # Instance-level wrapper around {Http.socket_write} that applies the
-    # configured `write_timeout`.
-    #
-    # @param socket [TCPSocket] the socket to write to
-    # @param string [String] the data to write
-    # @return [void]
-    # @raise [Http::WriteError] if the socket is not writable within the timeout or raises IOError
-    #
-    # @rbs (TCPSocket socket, String string) -> void
-    def socket_write(socket, string)
-      Http.socket_write(socket, string, timeout: @write_timeout)
-    end
-
-    # Instance-level wrapper around {Http.socket_writev} that applies the
-    # configured `write_timeout`.
-    #
-    # @param socket [TCPSocket] the socket to write to
-    # @param strings [Array<String>] the buffers to write in order
-    # @return [void]
-    # @raise [Http::WriteError] if the socket is not writable within the timeout or raises IOError
-    #
-    # @rbs (TCPSocket socket, Array[String] strings) -> void
-    def socket_writev(socket, strings)
-      Http.socket_writev(socket, strings, timeout: @write_timeout)
-    end
-
     # Signals eager keep-alive loops to stop processing further requests on
     # their connections. In-flight requests complete normally.
     #
@@ -293,10 +283,10 @@ module Raptor
     # when complete. Falls back to the reactor when more data is needed.
     #
     # @param socket [TCPSocket] the freshly accepted client socket
-    # @param id [Integer] unique client identifier
+    # @param id [Integer] unique connection identifier
     # @param reactor [Reactor] the reactor for fallback registration
     # @param thread_pool [AtomicThreadPool] thread pool for application processing
-    # @param remote_addr [String] client IP address
+    # @param remote_addr [String] the client IP address
     # @param url_scheme [String] "http" or "https"
     # @return [void]
     #
@@ -319,18 +309,12 @@ module Raptor
         return
       end
 
-      if !parser.finished?
+      unless parser.finished?
         fallback_to_reactor(socket, id, buffer, env, parse_data, reactor, 0, remote_addr, url_scheme, persisted: false)
         return
-      elsif Http1.invalid_host?(env) || Http1.request_smuggling?(env)
-        reject_malformed(socket)
-        return
-      elsif parser.has_body? && @max_body_size && parser.content_length > @max_body_size
-        reject_oversized(socket)
-        return
       end
 
-      body = extract_body(buffer, env, parser, nread, decode_chunked: true)
+      body = extract_body(buffer, env, parse_data, parser, nread)
       case body
       when :incomplete
         fallback_to_reactor(socket, id, buffer, env, parse_data, reactor, 0, remote_addr, url_scheme, persisted: false)
@@ -341,6 +325,9 @@ module Raptor
       when :malformed
         reject_malformed(socket)
         return
+      when :unsupported_encoding
+        reject_unsupported_encoding(socket)
+        return
       end
 
       thread_pool << proc do
@@ -370,10 +357,13 @@ module Raptor
         return
       end
 
-      unless parsed_request[:complete]
-        parsed_request = send_continue_if_expected(parsed_request, reactor)
-        reactor.update_state(parsed_request)
-      else
+      if parsed_request[:unsupported_encoding]
+        socket = reactor.remove(parsed_request[:id])
+        reject_unsupported_encoding(socket) if socket
+        return
+      end
+
+      if parsed_request[:complete]
         socket = reactor.remove(parsed_request[:id])
         request_count = (parsed_request[:request_count] || 0) + 1
         remote_addr = parsed_request[:remote_addr] || Server::DEFAULT_REMOTE_ADDR
@@ -393,6 +383,115 @@ module Raptor
             url_scheme
           )
         end
+      else
+        parsed_request = send_continue_if_expected(parsed_request, reactor)
+        reactor.update_state(parsed_request)
+      end
+    end
+
+    # Processes kept-alive requests on application threads, yielding to queued
+    # work and returning idle or incomplete connections to the reactor.
+    #
+    # @param socket [TCPSocket] the client socket
+    # @param id [Integer] unique connection identifier
+    # @param reactor [Reactor] the reactor for fallback registration
+    # @param thread_pool [AtomicThreadPool] thread pool for application processing
+    # @param request_count [Integer] number of requests handled on this connection
+    # @param remote_addr [String] the client IP address
+    # @param url_scheme [String] "http" or "https"
+    # @param resumed [Boolean] whether the reactor queued the connection once its next request became readable
+    # @param pipelined [String, nil] bytes the client sent after the previous request
+    # @return [void]
+    #
+    # @rbs (TCPSocket socket, Integer id, Reactor reactor, AtomicThreadPool thread_pool, Integer request_count, String remote_addr, String url_scheme, ?resumed: bool, ?pipelined: String?) -> void
+    def eager_keepalive(socket, id, reactor, thread_pool, request_count, remote_addr, url_scheme, resumed: false, pipelined: nil)
+      loop do
+        unless @running.true?
+          socket.close rescue nil
+          return
+        end
+
+        if pipelined
+          buffer = pipelined
+        else
+          unless resumed || socket.wait_readable(0)
+            reactor.persist(socket, id, request_count, remote_addr: remote_addr, url_scheme: url_scheme)
+            return
+          end
+
+          begin
+            buffer = read_into_thread_buffer(socket)
+          rescue IO::WaitReadable
+            reactor.persist(socket, id, request_count, remote_addr: remote_addr, url_scheme: url_scheme)
+            return
+          rescue EOFError, IOError, SystemCallError
+            socket.close rescue nil
+            return
+          end
+        end
+
+        env, parse_data, nread, parser = begin
+          parse_next_request(buffer)
+        rescue HttpParserError
+          reject_malformed(socket)
+          return
+        end
+
+        unless parser.finished?
+          fallback_to_reactor(socket, id, buffer, env, parse_data, reactor, request_count, remote_addr, url_scheme)
+          return
+        end
+
+        body = extract_body(buffer, env, parse_data, parser, nread)
+        case body
+        when :incomplete
+          fallback_to_reactor(socket, id, buffer, env, parse_data, reactor, request_count, remote_addr, url_scheme)
+          return
+        when :too_large
+          reject_oversized(socket)
+          return
+        when :malformed
+          reject_malformed(socket)
+          return
+        when :unsupported_encoding
+          reject_unsupported_encoding(socket)
+          return
+        end
+
+        request_count += 1
+
+        if !resumed && thread_pool.queue_size.positive?
+          thread_pool << proc do
+            process_client(
+              socket,
+              id,
+              env,
+              parse_data,
+              body,
+              reactor,
+              thread_pool,
+              request_count,
+              remote_addr,
+              url_scheme
+            )
+          end
+          return
+        end
+
+        resumed = false
+        pipelined = parse_data[:pipelined]
+        keep_alive = process_request(
+          socket,
+          id,
+          env,
+          parse_data,
+          body,
+          reactor,
+          request_count,
+          remote_addr,
+          url_scheme
+        )
+        return unless keep_alive
       end
     end
 
@@ -400,11 +499,12 @@ module Raptor
 
     # Reads pending bytes off `socket` into the thread-local read buffer,
     # draining any additional SSL-buffered bytes so `pending` is empty on
-    # return. Raises `IO::WaitReadable`, `EOFError`, or `IOError` like the
-    # underlying `read_nonblock` does.
+    # return.
     #
     # @param socket [TCPSocket] the socket to read from
     # @return [String] the thread-local buffer, freshly populated
+    # @raise [IO::WaitReadable] if no bytes are ready to read
+    # @raise [EOFError, IOError, SystemCallError] if the connection is closed or fails
     #
     # @rbs (TCPSocket socket) -> String
     def read_into_thread_buffer(socket)
@@ -418,12 +518,11 @@ module Raptor
       buffer
     end
 
-    # Runs a fresh HTTP/1.x parse against `buffer`, returning
-    # `[env, parse_data, nread, parser]`. Raises `HttpParserError` on
-    # malformed input.
+    # Runs a fresh HTTP/1.x parse against `buffer`.
     #
     # @param buffer [String] the raw request bytes
-    # @return [Array(Hash, Hash, Integer, HttpParser)]
+    # @return [Array(Hash, Hash, Integer, HttpParser)] the env, parse data, bytes read, and parser
+    # @raise [HttpParserError] if the request is malformed
     #
     # @rbs (String buffer) -> [Hash[String, untyped], Hash[Symbol, untyped], Integer, HttpParser]
     def parse_next_request(buffer)
@@ -435,51 +534,55 @@ module Raptor
       [env, parse_data, nread, parser]
     end
 
-    # Resolves the request body for a finished parse. Returns the body
-    # `String` (or `nil` when the request has no body), or one of
-    # `:incomplete`, `:too_large`, `:malformed` when the caller must
-    # fall back or reject.
+    # Validates request framing and extracts the body, preserving pipelined bytes.
     #
     # @param buffer [String] the raw request bytes
     # @param env [Hash] the Rack environment being built
+    # @param parse_data [Hash] metadata from the parsing pass
     # @param parser [HttpParser] the parser holding the finished parse state
     # @param nread [Integer] the byte offset where the body begins in `buffer`
-    # @param decode_chunked [Boolean] whether to decode chunked bodies inline; when false chunked bodies signal `:incomplete`
-    # @return [String, nil, Symbol]
+    # @return [String, nil, Symbol] body, nil when absent, or `:incomplete`,
+    #   `:too_large`, `:malformed`, or `:unsupported_encoding`
     #
-    # @rbs (String buffer, Hash[String, untyped] env, HttpParser parser, Integer nread, decode_chunked: bool) -> (String | Symbol)?
-    def extract_body(buffer, env, parser, nread, decode_chunked:)
-      return unless parser.has_body?
+    # @rbs (String buffer, Hash[String, untyped] env, Hash[Symbol, untyped] parse_data, HttpParser parser, Integer nread) -> (String | Symbol)?
+    def extract_body(buffer, env, parse_data, parser, nread)
+      return :malformed if Http1.invalid_host?(env)
+      error = Http1.framing_error(env)
+      return error if error
+
+      unless parser.has_body?
+        parse_data[:pipelined] = Http1.pipelined_bytes(buffer, nread)
+        return
+      end
 
-      body = buffer.byteslice(nread..-1) || ""
+      return :too_large if @max_body_size && parser.content_length > @max_body_size
 
       if parser.chunked?
-        return :incomplete unless decode_chunked
+        body, chunked_state, consumed = HttpParser.decode_chunked(buffer.byteslice(nread..-1), @max_body_size)
+        return chunked_state unless chunked_state == :complete
 
-        body, chunked_state = HttpParser.decode_chunked(body, @max_body_size)
-        case chunked_state
-        when :complete
-          env.delete(HTTP_TRANSFER_ENCODING)
-          body
-        else
-          chunked_state
-        end
-      elsif parser.content_length > body.bytesize
+        env.delete(HTTP_TRANSFER_ENCODING)
+        parse_data[:pipelined] = Http1.pipelined_bytes(buffer, nread + consumed)
+        body
+      elsif nread + parser.content_length > buffer.bytesize
         :incomplete
       else
-        body
+        parse_data[:pipelined] = Http1.pipelined_bytes(buffer, nread + parser.content_length)
+        buffer.byteslice(nread, parser.content_length)
       end
     end
 
-    # Returns true if the request expects a 100 Continue response per
-    # RFC 7231 section 5.1.1.
+    # Returns true when the request expects a 100 Continue response per
+    # RFC 9110 section 10.1.1.
     #
     # @param env [Hash] the parsed Rack environment (possibly incomplete)
     # @return [Boolean]
     #
     # @rbs (Hash[String, untyped] env) -> bool
     def expects_100_continue?(env)
-      (env[Rack::SERVER_PROTOCOL] == HTTP_11) && env[HTTP_EXPECT]&.casecmp?(EXPECT_100_CONTINUE)
+      return false unless env[Rack::SERVER_PROTOCOL] == HTTP_11
+
+      env[HTTP_EXPECT]&.casecmp?(EXPECT_100_CONTINUE) || false
     end
 
     # Sends an HTTP 100 Continue response when the client requested
@@ -508,35 +611,35 @@ module Raptor
     # if keep-alive, eagerly reading subsequent requests inline.
     #
     # @param socket [TCPSocket] the client socket
-    # @param id [Integer] unique client identifier
+    # @param id [Integer] unique connection identifier
     # @param env [Hash] partial env hash from the HTTP parser
     # @param parse_data [Hash] metadata from the parsing pass
     # @param body [String, nil] decoded request body
     # @param reactor [Reactor] the reactor managing the client connection
     # @param thread_pool [AtomicThreadPool] thread pool for application processing
     # @param request_count [Integer] number of requests handled on this connection
-    # @param remote_addr [String] client IP address
+    # @param remote_addr [String] the client IP address
     # @param url_scheme [String] "http" or "https"
     # @return [void]
     #
     # @rbs (TCPSocket socket, Integer id, Hash[String, untyped] env, Hash[Symbol, untyped] parse_data, String? body, Reactor reactor, AtomicThreadPool thread_pool, Integer request_count, String remote_addr, String url_scheme) -> void
     def process_client(socket, id, env, parse_data, body, reactor, thread_pool, request_count, remote_addr, url_scheme)
       keep_alive = process_request(socket, id, env, parse_data, body, reactor, request_count, remote_addr, url_scheme)
-      eager_keepalive(socket, id, reactor, thread_pool, request_count, remote_addr, url_scheme) if keep_alive
+      eager_keepalive(socket, id, reactor, thread_pool, request_count, remote_addr, url_scheme, pipelined: parse_data[:pipelined]) if keep_alive
     end
 
-    # Processes a single request. Builds the Rack env, calls the app,
-    # writes the response, and returns whether the connection stays open
-    # for another request.
+    # Processes a single request, isolating fiber and thread locals as
+    # configured, and returns whether the connection stays open for another
+    # request.
     #
     # @param socket [TCPSocket] the client socket
-    # @param id [Integer] unique client identifier
+    # @param id [Integer] unique connection identifier
     # @param env [Hash] partial env hash from the HTTP parser
     # @param parse_data [Hash] metadata from the parsing pass
     # @param body [String, nil] decoded request body
     # @param reactor [Reactor] the reactor managing the client connection
     # @param request_count [Integer] number of requests handled on this connection
-    # @param remote_addr [String] client IP address
+    # @param remote_addr [String] the client IP address
     # @param url_scheme [String] "http" or "https"
     # @return [Boolean] true if the connection should be kept alive
     #
@@ -554,13 +657,13 @@ module Raptor
     # Calls the Rack app and writes its response for one request.
     #
     # @param socket [TCPSocket] the client socket
-    # @param id [Integer] unique client identifier
+    # @param id [Integer] unique connection identifier
     # @param env [Hash] partial env hash from the HTTP parser
     # @param parse_data [Hash] metadata from the parsing pass
     # @param body [String, nil] decoded request body
     # @param reactor [Reactor] the reactor managing the client connection
     # @param request_count [Integer] number of requests handled on this connection
-    # @param remote_addr [String] client IP address
+    # @param remote_addr [String] the client IP address
     # @param url_scheme [String] "http" or "https"
     # @return [Boolean] true if the connection should be kept alive
     #
@@ -599,7 +702,14 @@ module Raptor
               socket,
               id,
               body,
-              { chunked: chunked, keep_alive: keep_alive, request_count: request_count, remote_addr: remote_addr, url_scheme: url_scheme },
+              {
+                chunked: chunked,
+                keep_alive: keep_alive,
+                request_count: request_count,
+                remote_addr: remote_addr,
+                url_scheme: url_scheme,
+                pipelined: parse_data[:pipelined]
+              },
               finished
             )
           else
@@ -637,14 +747,14 @@ module Raptor
     #
     # @param socket [TCPSocket] the client socket
     # @param rack_env [Hash, nil] the Rack environment, if it was built
-    # @param status [Integer, nil] the status returned by the app, if any
+    # @param status [Object, nil] the status returned by the app, if any
     # @param headers [Hash, nil] the headers returned by the app, if any
     # @param error [Exception] the exception raised
     # @param response_started [Boolean] whether any response bytes have been written
     # @param hijacked [Boolean] whether the app took over the socket
     # @return [void]
     #
-    # @rbs (TCPSocket socket, Hash[String, untyped]? rack_env, Integer? status, Hash[String, String | Array[String]]? headers, Exception error, response_started: bool, hijacked: bool) -> void
+    # @rbs (TCPSocket socket, Hash[String, untyped]? rack_env, untyped status, Hash[String, String | Array[String]]? headers, Exception error, response_started: bool, hijacked: bool) -> void
     def handle_app_error(socket, rack_env, status, headers, error, response_started:, hijacked:)
       Http.call_response_finished(rack_env, status, headers, error)
       socket.write(INTERNAL_SERVER_ERROR_RESPONSE) rescue nil unless response_started || hijacked
@@ -656,112 +766,22 @@ module Raptor
       end
     end
 
-    # Reads and processes subsequent requests inline on a kept-alive
-    # connection. Returns the connection to the reactor when no data is ready
-    # or a request is incomplete, and queues complete requests behind work
-    # that is already waiting.
-    #
-    # @param socket [TCPSocket] the client socket
-    # @param id [Integer] unique client identifier
-    # @param reactor [Reactor] the reactor for fallback registration
-    # @param thread_pool [AtomicThreadPool] thread pool for deprioritization
-    # @param request_count [Integer] number of requests handled on this connection
-    # @param remote_addr [String] client IP address
-    # @param url_scheme [String] "http" or "https"
-    # @return [void]
-    #
-    # @rbs (TCPSocket socket, Integer id, Reactor reactor, AtomicThreadPool thread_pool, Integer request_count, String remote_addr, String url_scheme) -> void
-    def eager_keepalive(socket, id, reactor, thread_pool, request_count, remote_addr, url_scheme)
-      loop do
-        unless @running.true?
-          socket.close rescue nil
-          return
-        end
-
-        unless socket.wait_readable(0)
-          reactor.persist(socket, id, request_count, remote_addr: remote_addr, url_scheme: url_scheme)
-          return
-        end
-
-        begin
-          buffer = read_into_thread_buffer(socket)
-        rescue IO::WaitReadable
-          reactor.persist(socket, id, request_count, remote_addr: remote_addr, url_scheme: url_scheme)
-          return
-        rescue EOFError, IOError, SystemCallError
-          socket.close rescue nil
-          return
-        end
-
-        env, parse_data, nread, parser = begin
-          parse_next_request(buffer)
-        rescue HttpParserError
-          reject_malformed(socket)
-          return
-        end
-
-        if !parser.finished?
-          fallback_to_reactor(socket, id, buffer, env, parse_data, reactor, request_count, remote_addr, url_scheme)
-          return
-        end
-
-        body = extract_body(buffer, env, parser, nread, decode_chunked: false)
-        if body == :incomplete
-          fallback_to_reactor(socket, id, buffer, env, parse_data, reactor, request_count, remote_addr, url_scheme)
-          return
-        end
-
-        request_count += 1
-
-        if thread_pool.queue_size.positive?
-          thread_pool << proc do
-            process_client(
-              socket,
-              id,
-              env,
-              parse_data,
-              body,
-              reactor,
-              thread_pool,
-              request_count,
-              remote_addr,
-              url_scheme
-            )
-          end
-          return
-        end
-
-        keep_alive = process_request(
-          socket,
-          id,
-          env,
-          parse_data,
-          body,
-          reactor,
-          request_count,
-          remote_addr,
-          url_scheme
-        )
-        return unless keep_alive
-      end
-    end
-
     # Re-registers a socket with the reactor for further processing when
     # an incomplete request is received on the fast path.
     #
     # @param socket [TCPSocket] the client socket
-    # @param id [Integer] unique client identifier
+    # @param id [Integer] unique connection identifier
     # @param buffer [String] the partial request data already read
     # @param env [Hash] partial env hash from the HTTP parser
     # @param parse_data [Hash] metadata from the parsing pass
     # @param reactor [Reactor] the reactor to re-register with
     # @param request_count [Integer] number of requests handled on this connection
-    # @param remote_addr [String] client IP address
+    # @param remote_addr [String] the client IP address
     # @param url_scheme [String] "http" or "https"
     # @param persisted [Boolean] whether the connection has already completed at least one request
     # @return [void]
     #
-    # @rbs (TCPSocket socket, Integer id, String buffer, Hash[String, untyped] env, Hash[Symbol, untyped] parse_data, Reactor reactor, Integer request_count, String remote_addr, String url_scheme, persisted: bool) -> void
+    # @rbs (TCPSocket socket, Integer id, String buffer, Hash[String, untyped] env, Hash[Symbol, untyped] parse_data, Reactor reactor, Integer request_count, String remote_addr, String url_scheme, ?persisted: bool) -> void
     def fallback_to_reactor(socket, id, buffer, env, parse_data, reactor, request_count, remote_addr, url_scheme, persisted: true)
       continued = expects_100_continue?(env)
       socket_write(socket, CONTINUE_RESPONSE) rescue nil if continued
@@ -803,13 +823,24 @@ module Raptor
       socket.close rescue nil
     end
 
+    # Writes a 501 response and closes the socket.
+    #
+    # @param socket [TCPSocket] the client socket
+    # @return [void]
+    #
+    # @rbs (TCPSocket socket) -> void
+    def reject_unsupported_encoding(socket)
+      socket.write(NOT_IMPLEMENTED_RESPONSE) rescue nil
+      socket.close rescue nil
+    end
+
     # Builds a Rack environment hash from parsed HTTP request data.
     #
     # @param env [Hash] partial env hash from the HTTP parser
     # @param parse_data [Hash] metadata from the parsing pass, including content_length
     # @param body [String, nil] decoded request body, or nil if no body
     # @param socket [TCPSocket] the client socket, used for hijack support
-    # @param remote_addr [String] client IP address
+    # @param remote_addr [String] the client IP address
     # @param url_scheme [String] "http" or "https"
     # @return [Hash] fully populated Rack environment hash
     #
@@ -833,7 +864,7 @@ module Raptor
         if scheme_end
           authority_end = request_uri.index("/", scheme_end + 3) || request_uri.bytesize
           path_and_query = request_uri.byteslice(authority_end..-1) || ""
-          if query_delim = path_and_query.index("?")
+          if (query_delim = path_and_query.index("?"))
             env[Rack::PATH_INFO] = query_delim.zero? ? "/" : path_and_query.byteslice(0, query_delim)
             env[Rack::QUERY_STRING] = path_and_query.byteslice(query_delim + 1..-1)
           else
@@ -849,7 +880,6 @@ module Raptor
       end
 
       env[Http::REMOTE_ADDR] = remote_addr
-      env[Http::HTTP_VERSION] = env[Rack::SERVER_PROTOCOL]
 
       behind_tls_proxy = (url_scheme == Server::HTTP_SCHEME) && forwarded_https?(env)
       env[Rack::RACK_URL_SCHEME] = behind_tls_proxy ? Server::HTTPS_SCHEME : url_scheme
@@ -884,7 +914,8 @@ module Raptor
 
     # Builds the `rack.input` IO object for the request body. Returns an
     # in-memory StringIO for bodies up to the spool threshold, or a Tempfile
-    # for larger bodies to bound per-worker memory.
+    # for larger bodies. The complete body is already buffered at this point,
+    # so spooling does not bound peak receive memory.
     #
     # @param body [String, nil] decoded request body
     # @return [IO] an IO-like object positioned at the start of the body
@@ -911,10 +942,10 @@ module Raptor
     #
     # @rbs (Hash[String, untyped] env) -> bool
     def forwarded_https?(env)
-      proto = env["HTTP_X_FORWARDED_PROTO"] || env["HTTP_X_FORWARDED_SCHEME"]
+      proto = env[HTTP_X_FORWARDED_PROTO] || env[HTTP_X_FORWARDED_SCHEME]
       return true if proto && proto.split(",").first&.strip&.casecmp?(Server::HTTPS_SCHEME)
 
-      env["HTTP_X_FORWARDED_SSL"]&.casecmp?("on") || false
+      env[HTTP_X_FORWARDED_SSL]&.casecmp?("on") || false
     end
 
     # Returns true when the connection should be kept alive after the
@@ -928,13 +959,10 @@ module Raptor
     def keep_alive?(env, request_count)
       return false if request_count >= @max_keepalive_requests
 
-      connection_header = env[HTTP_CONNECTION]
+      connection_tokens = env[HTTP_CONNECTION].to_s.downcase.split(",").map(&:strip)
+      return false if connection_tokens.include?(CONNECTION_CLOSE)
 
-      if env[Rack::SERVER_PROTOCOL] == HTTP_11
-        !connection_header&.casecmp?(CONNECTION_CLOSE)
-      else
-        connection_header&.casecmp?(CONNECTION_KEEPALIVE) || false
-      end
+      env[Rack::SERVER_PROTOCOL] == HTTP_11 || connection_tokens.include?(CONNECTION_KEEPALIVE)
     end
 
     # Sends an HTTP 103 Early Hints response, skipping any entries with
@@ -1037,14 +1065,13 @@ module Raptor
     # @raise [TypeError] if status is not an Integer
     # @raise [ArgumentError] if status is less than 100
     #
-    # @rbs (Integer status) -> void
+    # @rbs (untyped status) -> void
     def validate_status(status)
       raise TypeError, "status must be an Integer" unless status.is_a?(Integer)
-
       raise ArgumentError, "status must be >= 100" unless status >= 100
     end
 
-    # Returns a normalised copy of the response headers with lowercased
+    # Returns a normalized copy of the response headers with lowercased
     # keys and illegal/`rack.*`/`status` entries dropped.
     #
     # @param headers [Hash] raw headers from the Rack application
@@ -1083,7 +1110,6 @@ module Raptor
     def validate_headers(headers, status, no_entity_body)
       if no_entity_body
         raise ArgumentError, "content-type must not be present for status #{status}" if headers.key?(Rack::CONTENT_TYPE)
-
         raise ArgumentError, "content-length must not be present for status #{status}" if headers.key?(Rack::CONTENT_LENGTH)
       end
     end
@@ -1103,8 +1129,8 @@ module Raptor
       response
     end
 
-    # Writes the response headers, uncorks the socket, and hands the raw
-    # socket to the hijack callback.
+    # Writes the response headers and hands the raw socket to the hijack
+    # callback.
     #
     # @param socket [TCPSocket] the client socket
     # @param response [String] the status line accumulated so far
@@ -1117,7 +1143,6 @@ module Raptor
       HttpParser.format_headers(response, headers)
       response << "\r\n"
       socket_write(socket, response)
-      uncork_socket(socket)
       response_hijack.call(socket)
     end
 
@@ -1152,10 +1177,11 @@ module Raptor
     # @param body [Object] the response body
     # @param http_version [String] "HTTP/1.1" or "HTTP/1.0"
     # @return [void]
+    # @raise [TypeError] if the body responds to none of `each`, `to_ary`, or `to_path`
     #
     # @rbs (TCPSocket socket, String response, Hash[String, String | Array[String]] headers, untyped body, String http_version) -> void
     def write_full_response(socket, response, headers, body, http_version)
-      if body.respond_to?(:call)
+      if body.respond_to?(:call) && !body.respond_to?(:each)
         HttpParser.format_headers(response, headers)
         response << "\r\n"
         socket_write(socket, response)
@@ -1211,8 +1237,6 @@ module Raptor
         array.sum { |chunk| chunk.is_a?(String) ? chunk.bytesize : 0 }
       elsif body.respond_to?(:to_path) && (path = body.to_path) && File.readable?(path)
         File.size(path)
-      else
-        nil
       end
     end
 
@@ -1352,8 +1376,31 @@ module Raptor
       end
     end
 
-    # Instance-level wrapper around {Http.write_access_log} that routes to
-    # the configured `@access_log_io`.
+    # Writes response bytes within the configured write timeout.
+    #
+    # @param socket [TCPSocket] the socket to write to
+    # @param string [String] the data to write
+    # @return [void]
+    # @raise [Http::WriteError] if the socket is not writable within the timeout or raises IOError
+    #
+    # @rbs (TCPSocket socket, String string) -> void
+    def socket_write(socket, string)
+      Http.socket_write(socket, string, timeout: @write_timeout)
+    end
+
+    # Writes response buffers in order within the configured write timeout.
+    #
+    # @param socket [TCPSocket] the socket to write to
+    # @param strings [Array<String>] the buffers to write in order
+    # @return [void]
+    # @raise [Http::WriteError] if the socket is not writable within the timeout or raises IOError
+    #
+    # @rbs (TCPSocket socket, Array[String] strings) -> void
+    def socket_writev(socket, strings)
+      Http.socket_writev(socket, strings, timeout: @write_timeout)
+    end
+
+    # Writes a completed request to the access log.
     #
     # @param env [Hash] the Rack environment
     # @param status [Integer] the response status code