raptor 0.1.0 → 0.3.0

data/lib/raptor/server.rb

@@ -15,16 +15,19 @@ module Raptor
   #
   # Supports TCP, Unix domain, and SSL listeners transparently. TCP_NODELAY is
   # applied only to TCP sockets, and SSL handshakes are performed synchronously
-  # before handing the connection to the reactor.
+  # before the connection is dispatched.
   #
-  # For SSL connections, ALPN negotiation determines the protocol. HTTP/2
-  # connections are added to the reactor with initial SETTINGS and processed
-  # through the same ractor pool pipeline as HTTP/1.1 connections.
+  # For HTTP/1.1 connections the first request is parsed inline on the server
+  # thread and dispatched directly to the thread pool, falling back to the
+  # reactor only when more data is needed. For HTTP/2 connections (negotiated
+  # via ALPN) the server sends initial SETTINGS and registers the connection
+  # with the reactor for frame processing through the ractor pool.
   #
   # @example
   #   binder = Binder.new(["tcp://0.0.0.0:3000"])
   #   reactor = Reactor.new(thread_pool, ractor_pool, client_options: {})
-  #   server = Server.new(binder, reactor, thread_pool)
+  #   request = Request.new(app, 3000)
+  #   server = Server.new(binder, reactor, thread_pool, request)
   #   server.run
   #   # ... later
   #   server.shutdown
@@ -37,6 +40,7 @@ module Raptor
     # @rbs @binder: Binder
     # @rbs @reactor: Reactor
     # @rbs @thread_pool: AtomicThreadPool
+    # @rbs @request: Request
     # @rbs @running: AtomicBoolean
 
     # Creates a new Server instance.
@@ -44,13 +48,15 @@ module Raptor
     # @param binder [Binder] the binder managing listening sockets
     # @param reactor [Reactor] the reactor for handling client connections
     # @param thread_pool [AtomicThreadPool] thread pool for application processing
+    # @param request [Request] the HTTP/1.1 request handler
     # @return [void]
     #
-    # @rbs (Binder binder, Reactor reactor, AtomicThreadPool thread_pool) -> void
-    def initialize(binder, reactor, thread_pool)
+    # @rbs (Binder binder, Reactor reactor, AtomicThreadPool thread_pool, Request request) -> void
+    def initialize(binder, reactor, thread_pool, request)
       @binder = binder
       @reactor = reactor
       @thread_pool = thread_pool
+      @request = request
       @running = AtomicBoolean.new(true)
     end
 
@@ -149,18 +155,21 @@ module Raptor
             socket: ssl_socket,
             remote_addr: remote_addr,
             url_scheme: HTTPS_SCHEME,
-            protocol: :http2
+            protocol: :http2,
+            writer: Http2::Writer.new
           )
 
           return
         end
       end
 
-      reactor.add(
-        id: client.object_id,
-        socket: client,
-        remote_addr: remote_addr,
-        url_scheme: url_scheme
+      @request.eager_accept(
+        client,
+        client.object_id,
+        reactor,
+        @thread_pool,
+        remote_addr,
+        url_scheme
       )
     end
   end

data/lib/raptor/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Raptor
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/raptor.rb

@@ -5,9 +5,9 @@ require_relative "raptor/version"
 
 # Main module for the Raptor web server.
 #
-# Raptor is a high-performance, multi-threaded, multi-process Ruby web server that
-# leverages Ractors for parallel HTTP/1.1 and HTTP/2 request processing, native C
-# extensions for HTTP parsing and HPACK compression, and NIO for non-blocking I/O.
+# Raptor is a high-performance, preloading, multi-process, multi-threaded Ruby 4+ web server
+# implementing Rack 3+, leveraging Ractors for parallel HTTP/1.1 and HTTP/2 request processing,
+# native C extensions for HTTP parsing and HPACK compression, and NIO for non-blocking I/O.
 #
 module Raptor
 end

data/sig/generated/rackup/handler/raptor.rbs

@@ -0,0 +1,40 @@
+# Generated from lib/rackup/handler/raptor.rb with RBS::Inline
+
+module Rackup
+  module Handler
+    # Rack handler for booting Raptor through Rackup, `rails server`, or any
+    # other host that follows the Rack handler protocol.
+    module Raptor
+      DEFAULT_OPTIONS: untyped
+
+      # Boots a Raptor cluster serving the given Rack application.
+      #
+      # @param app [#call] the Rack application to serve
+      # @param options [Hash] handler options provided by Rackup or the host
+      # @yield [cluster] the cluster instance, before it starts running
+      # @return [void]
+      #
+      # @rbs (^(Hash[String, untyped]) -> [Integer, Hash[String, String | Array[String]], untyped] app, **untyped options) { (::Raptor::Cluster) -> void } -> void
+      def self.run: (^(Hash[String, untyped]) -> [ Integer, Hash[String, String | Array[String]], untyped ] app, **untyped options) { (::Raptor::Cluster) -> void } -> void
+
+      # Returns the handler-specific options surfaced by `rackup --help`.
+      #
+      # @return [Hash{String => String}] option spec to description mapping
+      #
+      # @rbs () -> Hash[String, String]
+      def self.valid_options: () -> Hash[String, String]
+
+      # Builds a Raptor cluster options hash from Rack handler options.
+      #
+      # Options not explicitly supplied by the user (per the `:user_supplied_options`
+      # key) are treated as host-provided defaults.
+      #
+      # @param app [#call] the Rack application to serve
+      # @param options [Hash] handler options provided by Rackup or the host
+      # @return [Hash{Symbol => untyped}] cluster configuration
+      #
+      # @rbs (^(Hash[String, untyped]) -> [Integer, Hash[String, String | Array[String]], untyped] app, Hash[Symbol, untyped] options) -> Hash[Symbol, untyped]
+      def self.build_cluster_options: (^(Hash[String, untyped]) -> [ Integer, Hash[String, String | Array[String]], untyped ] app, Hash[Symbol, untyped] options) -> Hash[Symbol, untyped]
+    end
+  end
+end

data/sig/generated/raptor/cli.rbs

@@ -20,6 +20,19 @@ module Raptor
 
     DEFAULT_OPTIONS: untyped
 
+    # Loads a configuration file and returns the hash it evaluates to.
+    #
+    # The file is evaluated at the top level so constants like `Raptor::*` resolve
+    # the same as in a regular Ruby script. The final expression must be a Hash
+    # of cluster options (the same keys accepted by {Raptor::Cluster#initialize}).
+    #
+    # @param path [String] path to a Ruby file that evaluates to a Hash
+    # @return [Hash{Symbol => untyped}] cluster options
+    # @raise [ArgumentError] if the file does not evaluate to a Hash
+    #
+    # @rbs (String path) -> Hash[Symbol, untyped]
+    def self.load_config_file: (String path) -> Hash[Symbol, untyped]
+
     @command: Symbol
 
     @options: Hash[Symbol, untyped]
@@ -61,6 +74,30 @@ module Raptor
     # @rbs () -> void
     def run_stats: () -> void
 
+    # Scans argv for a `-c`/`--config` flag and returns the configured path.
+    #
+    # The pre-scan runs before the main OptionParser pass so the config file
+    # can be applied as a base layer that CLI args then override. All four
+    # OptionParser-accepted forms (`-c PATH`, `-cPATH`, `--config PATH`,
+    # `--config=PATH`) are recognized.
+    #
+    # @param argv [Array<String>] command-line arguments to scan
+    # @return [String, nil] the config path, or nil if no flag was supplied
+    #
+    # @rbs (Array[String] argv) -> String?
+    def extract_config_path: (Array[String] argv) -> String?
+
+    # Loads a config file and merges it into `@options` over the defaults.
+    #
+    # Top-level keys replace defaults; the nested `:client` hash is merged
+    # key-by-key so a config file does not need to restate every client option.
+    #
+    # @param path [String, nil] path to the config file, or nil to no-op
+    # @return [void]
+    #
+    # @rbs (String? path) -> void
+    def apply_config_file: (String? path) -> void
+
     # Creates the OptionParser instance with all supported command-line options.
     #
     # @return [OptionParser] configured option parser

data/sig/generated/raptor/cluster.rbs

@@ -37,7 +37,9 @@ module Raptor
     # @rbs (Hash[Symbol, untyped] options) -> void
     def self.run: (Hash[Symbol, untyped] options) -> void
 
-    @stats_file: String?
+    @phased_restarting: bool
+
+    @phased_restart_requested: bool
 
     @stats: Stats
 
@@ -51,6 +53,12 @@ module Raptor
 
     @binder: Binder
 
+    @pidfile: String?
+
+    @stats_file: String?
+
+    @on_error: ^(Hash[String, untyped]?, Exception) -> void | nil
+
     @client_options: Hash[Symbol, Integer]
 
     @worker_count: Integer
@@ -70,8 +78,12 @@ module Raptor
     # @option options [Integer] :ractors number of ractors per worker process
     # @option options [Integer] :workers number of worker processes
     # @option options [Array<String>] :binds array of bind URIs
+    # @option options [#call] :app pre-built Rack application
     # @option options [String] :rackup path to Rack configuration file
-    # @option options [Hash] :client client timeout configuration
+    # @option options [Hash] :client client configuration
+    # @option options [#call] :on_error callback invoked with (env, exception) when the Rack app raises
+    # @option options [String, nil] :stats_file path to write per-worker stats JSON, or nil to disable
+    # @option options [String, nil] :pidfile path to write the master PID to, or nil to disable
     # @return [void]
     #
     # @rbs (Hash[Symbol, untyped] options) -> void
@@ -81,7 +93,8 @@ module Raptor
     #
     # Forks the configured number of worker processes and monitors them,
     # automatically restarting any that exit unexpectedly. Handles graceful
-    # shutdown via INT or TERM signals, and stats logging via USR1.
+    # shutdown via INT or TERM signals, stats logging via USR1, and phased
+    # restart via USR2.
     #
     # Each worker process includes:
     # - 1 server thread (continuously accepts connections with backpressure control)
@@ -114,6 +127,22 @@ module Raptor
     # @rbs (Integer index) -> void
     def spawn_worker: (Integer index) -> void
 
+    # Reaps any worker processes that have exited, respawning each one
+    # unless the cluster is shutting down.
+    #
+    # @return [Symbol] :no_children when there are no remaining children, otherwise :reaped
+    #
+    # @rbs () -> Symbol
+    def reap_workers: () -> Symbol
+
+    # Replaces each worker process one at a time, waiting for the new
+    # worker to boot before moving on to the next. Triggered by SIGUSR2.
+    #
+    # @return [void]
+    #
+    # @rbs () -> void
+    def perform_phased_restart: () -> void
+
     # Runs the full server stack inside a worker process.
     #
     # Sets up and coordinates the reactor, server, ractor pool, thread pool,

data/sig/generated/raptor/http2.rbs

@@ -8,6 +8,31 @@ module Raptor
   # It integrates with the same reactor, ractor pool, and thread pool
   # pipeline used by HTTP/1.1 connections.
   class Http2
+    # Lock-free per-connection frame writer.
+    #
+    # Serializes concurrent socket writes from multiple stream workers
+    # without blocking any of them.
+    class Writer
+      IDLE: ::Symbol
+
+      @state: Atom
+
+      # Creates a new Writer.
+      #
+      # @rbs () -> void
+      def initialize: () -> void
+
+      # Writes frames to the socket, coordinating with concurrent writers
+      # so that exactly one thread is actively writing at any time.
+      #
+      # @param socket [OpenSSL::SSL::SSLSocket] the connection socket
+      # @param frames [Array<String>] frame bytes to write in order
+      # @return [void]
+      #
+      # @rbs (OpenSSL::SSL::SSLSocket socket, Array[String] frames) -> void
+      def write_frames: (OpenSSL::SSL::SSLSocket socket, Array[String] frames) -> void
+    end
+
     FLAG_END_STREAM: ::Integer
 
     FLAG_END_HEADERS: ::Integer
@@ -22,6 +47,8 @@ module Raptor
 
     HOP_BY_HOP_HEADERS: untyped
 
+    @on_error: ^(Hash[String, untyped]?, Exception) -> void | nil
+
     @server_port: Integer
 
     @app: ^(Hash[String, untyped]) -> [ Integer, Hash[String, String | Array[String]], untyped ]
@@ -30,10 +57,11 @@ module Raptor
     #
     # @param app [#call] the Rack application to dispatch requests to
     # @param server_port [Integer] port number used to populate SERVER_PORT in the Rack env
+    # @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) -> void
-    def initialize: (^(Hash[String, untyped]) -> [ Integer, Hash[String, String | Array[String]], untyped ] app, Integer server_port) -> void
+    # @rbs (^(Hash[String, untyped]) -> [Integer, Hash[String, String | Array[String]], untyped] app, Integer server_port, ?on_error: ^(Hash[String, untyped]?, Exception) -> void | nil) -> void
+    def initialize: (^(Hash[String, untyped]) -> [ Integer, Hash[String, String | Array[String]], untyped ] app, Integer server_port, ?on_error: ^(Hash[String, untyped]?, Exception) -> void | nil) -> void
 
     # Builds the initial server SETTINGS frame to send on connection establishment.
     #
@@ -88,38 +116,38 @@ module Raptor
     # the response back as HTTP/2 frames.
     #
     # @param socket [OpenSSL::SSL::SSLSocket] the connection socket
-    # @param mutex [Mutex] mutex for serializing writes to the connection socket
+    # @param writer [Writer] lock-free frame writer for the connection
     # @param stream_id [Integer] the HTTP/2 stream identifier
     # @param headers [Array<Array(String, String)>] request headers
     # @param body [String] request body
     # @param remote_addr [String] the client IP address
     # @return [void]
     #
-    # @rbs (OpenSSL::SSL::SSLSocket socket, Mutex mutex, Integer stream_id, Array[[String, String]] headers, String body, remote_addr: String) -> void
-    def dispatch_stream_request: (OpenSSL::SSL::SSLSocket socket, Mutex mutex, Integer stream_id, Array[[ String, String ]] headers, String body, remote_addr: String) -> void
+    # @rbs (OpenSSL::SSL::SSLSocket socket, Writer writer, Integer stream_id, Array[[String, String]] headers, String body, remote_addr: String) -> void
+    def dispatch_stream_request: (OpenSSL::SSL::SSLSocket socket, Writer writer, Integer stream_id, Array[[ String, String ]] headers, String body, remote_addr: String) -> void
 
     # Writes a Rack response as HTTP/2 frames to the socket.
     #
     # @param socket [OpenSSL::SSL::SSLSocket] the connection socket
-    # @param mutex [Mutex] mutex for serializing writes to the connection socket
+    # @param writer [Writer] lock-free frame writer for the connection
     # @param stream_id [Integer] the HTTP/2 stream identifier
     # @param status [Integer] HTTP status code
     # @param headers [Hash] response headers from the Rack application
     # @param body [Object] response body responding to each
     # @return [void]
     #
-    # @rbs (OpenSSL::SSL::SSLSocket socket, Mutex mutex, Integer stream_id, Integer status, Hash[String, String | Array[String]] headers, untyped body) -> void
-    def write_http2_response: (OpenSSL::SSL::SSLSocket socket, Mutex mutex, Integer stream_id, Integer status, Hash[String, String | Array[String]] headers, untyped body) -> void
+    # @rbs (OpenSSL::SSL::SSLSocket socket, Writer writer, Integer stream_id, Integer status, Hash[String, String | Array[String]] headers, untyped body) -> void
+    def write_http2_response: (OpenSSL::SSL::SSLSocket socket, Writer writer, Integer stream_id, Integer status, Hash[String, String | Array[String]] headers, untyped body) -> void
 
     # Writes a 500 error response as HTTP/2 frames.
     #
     # @param socket [OpenSSL::SSL::SSLSocket] the connection socket
-    # @param mutex [Mutex] mutex for serializing writes to the connection socket
+    # @param writer [Writer] lock-free frame writer for the connection
     # @param stream_id [Integer] the HTTP/2 stream identifier
     # @return [void]
     #
-    # @rbs (OpenSSL::SSL::SSLSocket socket, Mutex mutex, Integer stream_id) -> void
-    def write_http2_error_response: (OpenSSL::SSL::SSLSocket socket, Mutex mutex, Integer stream_id) -> void
+    # @rbs (OpenSSL::SSL::SSLSocket socket, Writer writer, Integer stream_id) -> void
+    def write_http2_error_response: (OpenSSL::SSL::SSLSocket socket, Writer writer, Integer stream_id) -> void
 
     # Builds a Rack environment hash from HTTP/2 headers and body.
     #

data/sig/generated/raptor/reactor.rbs

@@ -55,7 +55,7 @@ module Raptor
 
     TIMEOUT_RESPONSE: ::String
 
-    @id_to_mutex: Hash[Integer, Mutex]
+    @id_to_writer: Hash[Integer, untyped]
 
     @id_to_timeout: Hash[Integer, TimeoutClient]
 
@@ -159,13 +159,15 @@ module Raptor
     # @rbs (Integer id) -> TCPSocket?
     def socket_for: (Integer id) -> TCPSocket?
 
-    # Returns the mutex for a given HTTP/2 connection.
+    # Returns the writer object associated with a given connection, if one
+    # was supplied when the connection was added. Used by protocol handlers
+    # that need to coordinate concurrent socket writes.
     #
     # @param id [Integer] unique client identifier
-    # @return [Mutex, nil] the mutex, if found
+    # @return [Object, nil] the writer, if found
     #
-    # @rbs (Integer id) -> Mutex?
-    def mutex_for: (Integer id) -> Mutex?
+    # @rbs (Integer id) -> untyped?
+    def writer_for: (Integer id) -> untyped?
 
     # Updates connection state for an HTTP/2 connection after frame processing.
     #

data/sig/generated/raptor/request.rbs

@@ -13,7 +13,7 @@ module Raptor
 
     FILE_CHUNK_SIZE: untyped
 
-    KEEPALIVE_BUFFER_SIZE: untyped
+    READ_BUFFER_SIZE: untyped
 
     WRITE_TIMEOUT: ::Integer
 
@@ -33,7 +33,9 @@ module Raptor
 
     STATUS_WITH_NO_ENTITY_BODY: untyped
 
-    ERROR_RESPONSE_500: ::String
+    INTERNAL_SERVER_ERROR_RESPONSE: ::String
+
+    CONTENT_TOO_LARGE_RESPONSE: ::String
 
     CONNECTION_CLOSE: ::String
 
@@ -63,6 +65,25 @@ module Raptor
       def message: () -> String
     end
 
+    # Decodes a chunked transfer-encoded body buffer.
+    #
+    # Returns the decoded bytes and a state symbol: `:complete` when the
+    # terminating zero-length chunk was found, `:too_large` when the decoded
+    # size would exceed `max_size`, or `:incomplete` otherwise.
+    #
+    # @param buffer [String] the raw body buffer to decode
+    # @param max_size [Integer, nil] maximum decoded body size, or nil for unlimited
+    # @return [Array(String, Symbol)] decoded body and completion state
+    #
+    # @rbs (String buffer, ?Integer? max_size) -> [String, Symbol]
+    def self.decode_chunked: (String buffer, ?Integer? max_size) -> [ String, Symbol ]
+
+    @on_error: ^(Hash[String, untyped]?, Exception) -> void | nil
+
+    @body_spool_threshold: Integer?
+
+    @max_body_size: Integer?
+
     @server_port: Integer
 
     @app: ^(Hash[String, untyped]) -> [ Integer, Hash[String, String | Array[String]], untyped ]
@@ -71,10 +92,29 @@ module Raptor
     #
     # @param app [#call] the Rack application to dispatch complete requests to
     # @param server_port [Integer] port number used to populate SERVER_PORT in the Rack env
+    # @param client_options [Hash] client limits configuration
+    # @option client_options [Integer, nil] :max_body_size maximum request body size in bytes
+    # @option client_options [Integer, nil] :body_spool_threshold spool bodies larger than this to a tempfile
+    # @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, ?client_options: Hash[Symbol, untyped], ?on_error: ^(Hash[String, untyped]?, Exception) -> void | nil) -> void
+    def initialize: (^(Hash[String, untyped]) -> [ Integer, Hash[String, String | Array[String]], untyped ] app, Integer server_port, ?client_options: Hash[Symbol, untyped], ?on_error: ^(Hash[String, untyped]?, Exception) -> void | nil) -> void
+
+    # Eagerly reads and parses the first request on a freshly accepted
+    # connection on the server thread, dispatching directly to the thread pool
+    # 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 reactor [Reactor] the reactor for fallback registration
+    # @param thread_pool [AtomicThreadPool] thread pool for application processing
+    # @param remote_addr [String] client IP address
+    # @param url_scheme [String] "http" or "https"
     # @return [void]
     #
-    # @rbs (^(Hash[String, untyped]) -> [Integer, Hash[String, String | Array[String]], untyped] app, Integer server_port) -> void
-    def initialize: (^(Hash[String, untyped]) -> [ Integer, Hash[String, String | Array[String]], untyped ] app, Integer server_port) -> void
+    # @rbs (TCPSocket socket, Integer id, Reactor reactor, AtomicThreadPool thread_pool, String remote_addr, String url_scheme) -> void
+    def eager_accept: (TCPSocket socket, Integer id, Reactor reactor, AtomicThreadPool thread_pool, String remote_addr, String url_scheme) -> void
 
     # Returns a Proc for HTTP parsing work in Ractor context.
     #
@@ -154,8 +194,12 @@ module Raptor
     # @rbs (TCPSocket socket, Integer id, Reactor reactor, AtomicThreadPool thread_pool, Integer request_count, String remote_addr, String url_scheme) -> void
     def eager_keepalive: (TCPSocket socket, Integer id, Reactor reactor, AtomicThreadPool thread_pool, Integer request_count, String remote_addr, String url_scheme) -> void
 
-    # Re-registers a socket with the reactor for further processing
-    # when an incomplete request is received during eager keep-alive.
+    # Re-registers a socket with the reactor for further processing when
+    # an incomplete request is received during eager accept or eager keep-alive.
+    #
+    # The persisted flag selects between persistent_data_timeout (for
+    # kept-alive connections awaiting the next request) and chunk_data_timeout
+    # (for fresh connections awaiting the rest of the first request).
     #
     # @param socket [TCPSocket] the client socket
     # @param id [Integer] unique client identifier
@@ -166,10 +210,20 @@ module Raptor
     # @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"
+    # @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
+    def fallback_to_reactor: (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
+
+    # Writes a 413 response and closes the socket. Used when a request body
+    # exceeds the configured maximum size.
+    #
+    # @param socket [TCPSocket] the client socket
     # @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) -> void
-    def fallback_to_reactor: (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) -> void
+    # @rbs (TCPSocket socket) -> void
+    def reject_oversized: (TCPSocket socket) -> void
 
     # Builds a Rack environment hash from parsed HTTP request data.
     #
@@ -187,6 +241,16 @@ module Raptor
     # @rbs (Hash[String, untyped] env, Hash[Symbol, untyped] parse_data, String? body, TCPSocket socket, ?remote_addr: String, ?url_scheme: String) -> Hash[String, untyped]
     def build_rack_env: (Hash[String, untyped] env, Hash[Symbol, untyped] parse_data, String? body, TCPSocket socket, ?remote_addr: String, ?url_scheme: String) -> Hash[String, untyped]
 
+    # 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.
+    #
+    # @param body [String, nil] decoded request body
+    # @return [IO] an IO-like object positioned at the start of the body
+    #
+    # @rbs (String? body) -> IO
+    def build_rack_input: (String? body) -> IO
+
     # Determines whether the connection should be kept alive after the response.
     #
     # Returns false if the request limit has been reached. For HTTP/1.1, keep-alive

data/sig/generated/raptor/server.rbs

@@ -10,16 +10,19 @@ module Raptor
   #
   # Supports TCP, Unix domain, and SSL listeners transparently. TCP_NODELAY is
   # applied only to TCP sockets, and SSL handshakes are performed synchronously
-  # before handing the connection to the reactor.
+  # before the connection is dispatched.
   #
-  # For SSL connections, ALPN negotiation determines the protocol. HTTP/2
-  # connections are added to the reactor with initial SETTINGS and processed
-  # through the same ractor pool pipeline as HTTP/1.1 connections.
+  # For HTTP/1.1 connections the first request is parsed inline on the server
+  # thread and dispatched directly to the thread pool, falling back to the
+  # reactor only when more data is needed. For HTTP/2 connections (negotiated
+  # via ALPN) the server sends initial SETTINGS and registers the connection
+  # with the reactor for frame processing through the ractor pool.
   #
   # @example
   #   binder = Binder.new(["tcp://0.0.0.0:3000"])
   #   reactor = Reactor.new(thread_pool, ractor_pool, client_options: {})
-  #   server = Server.new(binder, reactor, thread_pool)
+  #   request = Request.new(app, 3000)
+  #   server = Server.new(binder, reactor, thread_pool, request)
   #   server.run
   #   # ... later
   #   server.shutdown
@@ -36,6 +39,8 @@ module Raptor
 
     @thread_pool: AtomicThreadPool
 
+    @request: Request
+
     @running: AtomicBoolean
 
     # Creates a new Server instance.
@@ -43,10 +48,11 @@ module Raptor
     # @param binder [Binder] the binder managing listening sockets
     # @param reactor [Reactor] the reactor for handling client connections
     # @param thread_pool [AtomicThreadPool] thread pool for application processing
+    # @param request [Request] the HTTP/1.1 request handler
     # @return [void]
     #
-    # @rbs (Binder binder, Reactor reactor, AtomicThreadPool thread_pool) -> void
-    def initialize: (Binder binder, Reactor reactor, AtomicThreadPool thread_pool) -> void
+    # @rbs (Binder binder, Reactor reactor, AtomicThreadPool thread_pool, Request request) -> void
+    def initialize: (Binder binder, Reactor reactor, AtomicThreadPool thread_pool, Request request) -> void
 
     # Starts the server's main accept loop in a new thread.
     #

data/sig/generated/raptor.rbs

@@ -2,8 +2,8 @@
 
 # Main module for the Raptor web server.
 #
-# Raptor is a high-performance, multi-threaded, multi-process Ruby web server that
-# leverages Ractors for parallel HTTP/1.1 and HTTP/2 request processing, native C
-# extensions for HTTP parsing and HPACK compression, and NIO for non-blocking I/O.
+# Raptor is a high-performance, preloading, multi-process, multi-threaded Ruby 4+ web server
+# implementing Rack 3+, leveraging Ractors for parallel HTTP/1.1 and HTTP/2 request processing,
+# native C extensions for HTTP parsing and HPACK compression, and NIO for non-blocking I/O.
 module Raptor
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: raptor
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Joshua Young
@@ -114,6 +114,7 @@ files:
 - ext/raptor_http2/extconf.rb
 - ext/raptor_http2/huffman_table.h
 - ext/raptor_http2/raptor_http2.c
+- lib/rackup/handler/raptor.rb
 - lib/raptor.rb
 - lib/raptor/binder.rb
 - lib/raptor/cli.rb
@@ -124,6 +125,7 @@ files:
 - lib/raptor/server.rb
 - lib/raptor/stats.rb
 - lib/raptor/version.rb
+- sig/generated/rackup/handler/raptor.rbs
 - sig/generated/raptor.rbs
 - sig/generated/raptor/binder.rbs
 - sig/generated/raptor/cli.rbs