hyperion-rb 1.0.0.rc17

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bcb08723cb65420d073fe0e239c039946649ed4b2d5ec913391edaa9f9022f5c
+  data.tar.gz: 87f88b3956f6879defe23ba4f9e4b6a5b41bcf4db787b553ed7a3608ef9f6760
+SHA512:
+  metadata.gz: b0fecfb34f4cd2a2b272858305fc43a46a9f09d0ac9a77e13b2977c0793bd92a5eac024d8d6f080eaaa565f99f87e092d919a1ff4662eb3a205a29cefa9826fd
+  data.tar.gz: 4a86ffdf69d7ba24e3dbac045c26c26aed00ee07f43db3eaabe725c3ce5a52b9b3af7f94cfefa80ca743a75db0c882d931e1ae4953131acc70a20b5104ccdbf0

data/CHANGELOG.md

@@ -0,0 +1,133 @@
+# Changelog
+
+## [1.0.0.rc17] - 2026-04-26
+
+### Performance
+- **C-extension response head builder** (`Hyperion::CParser.build_response_head`).
+  Per-response status-line, normalized hash, and per-header String#<< allocations now happen in C — same wire output, ~44% faster on the synthetic head-build microbench (430 k vs 298 k writes/sec on macOS).
+- `ResponseWriter` keeps a pure-Ruby `build_head_ruby` fallback for JRuby / TruffleRuby / build failures; behaviour is identical.
+- Ships alongside the frozen `HTTP_KEY_CACHE` Rack-adapter optimisation already on the rc16 tip.
+
+## [1.0.0.rc16] - 2026-04-26
+
+### Changed
+- **Logger split (12-factor)**: `info` / `debug` route to stdout; `warn` / `error` / `fatal` route to stderr. Previously everything went to stderr.
+- `Logger.new` accepts `out:` and `err:` kwargs (default `$stdout` / `$stderr`); `io:` kwarg still works as a back-compat alias for tests.
+- Per-request access logs go to **stdout** (info level).
+
+All notable changes to Hyperion are documented here.
+
+## [1.0.0.rc15] - 2026-04-26
+
+### Added
+- **Per-OS worker model**: master auto-detects host OS and picks the right multi-worker strategy.
+  - **macOS / BSD**: master binds the listening socket once, forks workers that inherit the FD (Puma's pattern). Single accept queue, race-fair across workers.
+  - **Linux**: each worker independently binds with `SO_REUSEPORT` (kernel-fair distribution, no thundering herd).
+  - Override via `HYPERION_WORKER_MODEL=share|reuseport`.
+- macOS `-w 4` now scales correctly: hello-world bench at `-w 4 -t 10` serves 44 k r/s vs Puma's 38 k r/s (1.17× throughput, 15× lower p99).
+
+### Fixed
+- macOS `SO_REUSEPORT` distribution issue (Darwin's kernel funnels connections to one socket, never load-balancing siblings). The share-model fix sidesteps it entirely.
+
+## [1.0.0.rc14] - 2026-04-26
+
+### Added
+- **Ruby DSL config file** (`config/hyperion.rb`) with the same shape as Puma's `config/puma.rb`. Auto-loaded if present in cwd; explicit path via `-C / --config PATH`.
+- **Lifecycle hooks**: `before_fork`, `on_worker_boot`, `on_worker_shutdown`. Same API as Puma's hooks.
+- DSL settings: `bind`, `port`, `workers`, `thread_count`, `tls_cert_path`, `tls_key_path`, `read_timeout`, `idle_keepalive`, `graceful_timeout`, `max_header_bytes`, `max_body_bytes`, `log_level`, `log_format`, `log_requests`, `fiber_local_shim`.
+- `config/hyperion.example.rb` with documented sample config.
+- Strict DSL: unknown methods raise `NoMethodError` at boot — typos surface immediately.
+
+### Changed
+- Precedence: explicit CLI flag > env var > config file > built-in default.
+
+## [1.0.0.rc13] - 2026-04-26
+
+### Changed
+- **Per-request access logs default ON** (matches Puma + Rails operator expectations). Disable with `--no-log-requests` or `HYPERION_LOG_REQUESTS=0`.
+- Logger emit is now lock-free: dropped the per-write mutex (POSIX `write(2)` is atomic for writes ≤ PIPE_BUF).
+- Access-log hot path: per-thread cached iso8601 timestamp, hand-rolled single-interpolation line builder, per-thread 4 KiB write buffer flushed in Connection's `ensure`.
+
+### Performance
+- Default-ON Hyperion still beats Puma: hello-world at `-t 16` serves 20 k r/s vs Puma's 19 k r/s, with 24× lower p99 — and Hyperion emits 200 k+ access lines that Puma doesn't.
+
+## [1.0.0.rc12] - 2026-04-26
+
+### Added
+- `--log-requests` flag (initially default OFF) emitting one structured INFO line per response.
+
+## [1.0.0.rc11] - 2026-04-26
+
+### Added
+- Smart log format auto-detect: `--log-format auto` (default).
+  - `RAILS_ENV` / `RACK_ENV` / `HYPERION_ENV` ∈ `{production, staging}` → JSON.
+  - Stderr is a TTY → colored text (ANSI level colors).
+  - Otherwise (piped output, no env hint) → JSON.
+
+## [1.0.0.rc10] - 2026-04-26
+
+### Changed
+- **Lock-free per-thread metrics counters**, no global mutex. Hot-path cost: one TLS lookup + one Hash op per increment.
+- Connection caches `Hyperion.logger` and `Hyperion.metrics` once at init so the request loop skips method dispatch.
+
+## [1.0.0.rc9] - 2026-04-26
+
+### Added
+- `Hyperion::Logger` — structured logger with levels (`debug`, `info`, `warn`, `error`, `fatal`), text + JSON formats. Hash-based payload: `logger.info { { message: 'foo', key: val } }`.
+- `Hyperion::Metrics` — `Hyperion.stats` returns a hash of counters: `connections_accepted`, `connections_active`, `requests_total`, `requests_in_flight`, `responses_<code>`, `parse_errors`, `app_errors`, `read_timeouts`.
+
+## [1.0.0.rc8] - 2026-04-26
+
+### Changed
+- **Worker thread owns the HTTP/1.1 connection** (Puma's model). The `app.call(env)` per-request hop through a cross-thread Queue is gone.
+- `ThreadPool#submit_connection(socket, app)` hands the entire connection to a worker thread; workers run `Connection#serve` directly with no pool indirection.
+- HTTP/2 path keeps fiber-per-stream (correct because h2 multiplexes streams onto one socket).
+
+### Performance
+- Microbench: per-connection serve goes from 12 k r/s (rc7 hop-per-request) to 29 k r/s (rc8 worker-owns).
+- Hello-world `-t 16`: 1.27× Puma throughput, 30× lower p99.
+
+## [1.0.0.rc7] - 2026-04-26
+
+### Performance
+- Pooled the per-call reply `Queue` in `ThreadPool` (was `Queue.new` on every dispatch).
+- Inlined `Connection#read_chunk`'s hot path.
+
+## [1.0.0.rc6] - 2026-04-26
+
+### Added
+- Production-mode Rails benchmark suite. At Puma's default 3-thread config Hyperion `-t 16` serves 3.18× Puma's throughput with 2.10× lower p99.
+
+## [1.0.0.rc5] - 2026-04-26
+
+### Added
+- **Hybrid async/thread-pool architecture**: accept/parse/write stays on fibers; `app.call(env)` dispatched to OS-thread pool (default 5, `-t/--threads N`).
+
+## [1.0.0.rc4] - 2026-04-26
+
+### Fixed
+- Adapter sets `REMOTE_ADDR` from socket peer (was missing — broke Rack::Attack and any IP-based middleware).
+- Pinned `openssl < 4.0` so apps mutating `OpenSSL::SSL::SSLContext::DEFAULT_PARAMS` (e.g. AWS SDK initializers) don't crash on boot.
+
+## [1.0.0.rc3] - 2026-04-26
+
+### Added
+- HTTP/2 dispatch via `protocol-http2` with per-stream fiber multiplexing and WINDOW_UPDATE-aware flow control.
+- rake-compiler integration: `bundle exec rake compile` builds the C ext.
+
+## [1.0.0.rc1] - 2026-04-26
+
+### Added
+- TLS + ALPN (HTTPS over HTTP/1.1; HTTP/2 via ALPN handshake).
+- FiberLocal compatibility shim (`Hyperion::FiberLocal.install!`) for Rails apps using `Thread.current.thread_variable_*`.
+- Object pooling for Rack `env` Hash and `rack.input` StringIO.
+- Vendored llhttp 9.3.0 C parser (`Hyperion::CParser`); falls back to pure-Ruby `Hyperion::Parser`.
+- Pre-fork cluster (`-w N`); graceful shutdown with 30 s drain.
+- `Async::Scheduler` integration; fiber per connection.
+- HTTP/1.1 keep-alive, pipelining, chunked Transfer-Encoding.
+- Smuggling defenses: `Content-Length` + `Transfer-Encoding` together → 400; non-chunked TE → 501.
+
+## v0.0.1 - 2026-04-26
+
+### Added
+- Phase 1 skeleton: pure-Ruby HTTP/1.1 parser, Rack 3 adapter, Connection state machine, Server accept loop, CLI.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andrey Lobanov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,260 @@
+# Hyperion
+
+High-performance Ruby HTTP server. Falcon-class fiber concurrency, Puma-class compatibility.
+
+[![Specs](https://img.shields.io/badge/specs-114%20passing-brightgreen)]()
+[![Ruby](https://img.shields.io/badge/ruby-%3E%3D%203.2-red)]()
+[![License](https://img.shields.io/badge/license-MIT-blue)]()
+
+```sh
+gem install hyperion
+bundle exec hyperion config.ru
+```
+
+## Highlights
+
+- **HTTP/1.1 + HTTP/2 + TLS** out of the box (HTTP/2 with per-stream fiber multiplexing, WINDOW_UPDATE-aware flow control, ALPN auto-negotiation).
+- **Pre-fork cluster** with per-OS worker model: `SO_REUSEPORT` on Linux, master-bind + worker-fd-share on macOS/BSD (Darwin's `SO_REUSEPORT` doesn't load-balance).
+- **Hybrid concurrency**: fiber-per-connection for I/O, OS-thread pool for `app.call(env)` — synchronous Rack handlers (Rails, ActiveRecord, anything holding a global mutex) get true OS-thread concurrency.
+- **Vendored llhttp 9.3.0** C parser; pure-Ruby fallback for non-MRI runtimes.
+- **Default-ON structured access logs** (one JSON or text line per request) with hot-path optimisations: per-thread cached timestamp, hand-rolled line builder, lock-free per-thread write buffer.
+- **12-factor logger split**: info/debug → stdout, warn/error/fatal → stderr.
+- **Ruby DSL config file** (`config/hyperion.rb`) with lifecycle hooks (`before_fork`, `on_worker_boot`, `on_worker_shutdown`).
+- **Object pooling** for the Rack `env` hash and `rack.input` IO — amortizes per-request allocations across the worker's lifetime.
+- **`Hyperion::FiberLocal`** opt-in shim for older Rails idioms that store request-scoped data via `Thread.current.thread_variable_*`.
+
+## Benchmarks
+
+All numbers are real wrk runs against published Hyperion configs. Hyperion ships **with default-ON structured access logs**; Puma comparisons use Puma defaults (no per-request log emission).
+
+### Hello-world Rack app
+
+`bench/hello.ru`, single worker, parity threads (`-t 16` vs Puma `-t 16:16`), 4 wrk threads / 50 connections / 10s, macOS arm64 / Ruby 3.3.3:
+
+| | r/s | p99 |
+|---|---:|---:|
+| **Hyperion default (logs ON)** | **23,885** | **1.05 ms** |
+| Hyperion `--no-log-requests` | 24,222 | 1.00 ms |
+| Puma `-t 16:16` | 18,794 | 30.89 ms |
+
+**1.27× Puma throughput, ~30× lower p99 — while emitting structured JSON access logs Puma doesn't.**
+
+### Production cluster config (`-w 4`)
+
+Same bench app, `-w 4` cluster, parity threads. macOS arm64:
+
+| | r/s | p99 |
+|---|---:|---:|
+| **Hyperion `-w 4 -t 10`** | **44,221** | **1.15 ms** |
+| Puma `-w 4 -t 10:10` | 37,929 | 17.06 ms |
+
+**1.17× Puma throughput, ~15× lower p99.**
+
+### Linux production-config (DB-backed Rack)
+
+`-w 4 -t 10` on Ubuntu 24.04 / Ruby 3.3.3. Rack app does one Postgres `SELECT 1` + one Redis `GET` per request, real network round-trip. wrk `-t4 -c50 -d10s` × 3 runs (median):
+
+| | r/s (median) | vs Puma default |
+|---|---:|---:|
+| **Hyperion default (rc17, logs ON)** | **5,786** | **1.012×** |
+| Hyperion `--no-log-requests` | 6,364 | 1.114× |
+| Puma `-w 4 -t 10:10` (no per-req logs) | 5,715 | 1.000× |
+
+Bench is network-bound (~3-4 ms median is the PG + Redis round-trip). Hyperion's lead comes from cheaper per-request CPU: lock-free per-thread metrics, per-thread cached iso8601 timestamps in the access log, hand-rolled single-interpolation log line builder, no logger mutex (POSIX `write(2)` atomicity), C-extension response-head builder.
+
+### Real Rails 8.1 app (single worker, parity threads `-t 16`)
+
+Health endpoint that traverses the full middleware chain (rack-attack, locale redirect, structured tagger, geo-location, etc.). Plus a Grape API endpoint reading cached data, and a Rails controller doing a Redis GET + an ActiveRecord query.
+
+| endpoint | server | r/s | p99 | wrk timeouts |
+|---|---|---:|---:|---:|
+| `/up` (health) | **Hyperion** | **19.03** | **1.12 s** | **0** |
+| `/up` (health) | Puma `-t 16:16` | 16.64 | 1.95 s | **138** |
+| Grape `/api/v1/cached_data` | **Hyperion** | **16.15** | **779 ms** | 16 |
+| Grape `/api/v1/cached_data` | Puma `-t 16:16` | 10.90 | (>2 s, censored) | **110** |
+| Rails `/api/v1/health` | **Hyperion** | **15.95** | **992 ms** | 16 |
+| Rails `/api/v1/health` | Puma `-t 16:16` | 11.29 | (>2 s, censored) | **114** |
+
+On Grape and Rails-controller workloads Puma hits wrk's 2 s timeout cap on ~⅔ of requests — its real p99 is censored above 2 s. Hyperion serves all of its requests under 1.2 s with 0 to 16 timeouts. **1.14–1.48× Puma throughput** depending on endpoint.
+
+### Reproduce
+
+```sh
+# hello-world
+bundle exec ruby bench/compare.rb
+HYPERION_WORKERS=4 PUMA_WORKERS=4 FALCON_COUNT=4 bundle exec ruby bench/compare.rb
+
+# Real Rails / Grape: see bench/db.ru for the schema
+```
+
+## Quick start
+
+```sh
+bundle install
+bundle exec rake compile                              # build the llhttp C ext
+bundle exec hyperion config.ru                        # single-process default
+bundle exec hyperion -w 4 -t 10 config.ru             # 4-worker cluster, 10 threads each
+bundle exec hyperion -w 0 config.ru                   # 1 worker per CPU
+bundle exec hyperion --tls-cert cert.pem --tls-key key.pem -p 9443 config.ru   # HTTPS
+curl http://127.0.0.1:9292/                            # => hello
+
+# Chunked POST works:
+curl -X POST -H "Transfer-Encoding: chunked" --data-binary @file http://127.0.0.1:9292/
+
+# HTTP/2 (over TLS, ALPN-negotiated):
+curl --http2 -k https://127.0.0.1:9443/
+```
+
+`bundle exec rake spec` (and the `default` task) auto-invoke `compile`, so a fresh checkout just needs `bundle install && bundle exec rake` to get a green run.
+
+## Configuration
+
+Three layers, in precedence order: explicit CLI flag > environment variable > `config/hyperion.rb` > built-in default.
+
+### CLI flags
+
+| Flag | Default | Notes |
+|---|---|---|
+| `-b, --bind HOST` | `127.0.0.1` | |
+| `-p, --port PORT` | `9292` | |
+| `-w, --workers N` | `1` | `0` → `Etc.nprocessors` |
+| `-t, --threads N` | `5` | OS-thread Rack handler pool per worker. `0` → run inline (no pool, debugging only). |
+| `-C, --config PATH` | `config/hyperion.rb` if present | Ruby DSL file. |
+| `--tls-cert PATH` | nil | PEM certificate. |
+| `--tls-key PATH` | nil | PEM private key. |
+| `--log-level LEVEL` | `info` | `debug` / `info` / `warn` / `error` / `fatal`. |
+| `--log-format FORMAT` | `auto` | `text` / `json` / `auto`. Auto: JSON when `RAILS_ENV`/`RACK_ENV` is `production`/`staging`, colored text on TTY, JSON otherwise. |
+| `--[no-]log-requests` | ON | Per-request access log. |
+| `--fiber-local-shim` | off | Patches `Thread#thread_variable_*` to fiber storage for older Rails idioms. |
+
+### Environment variables
+
+`HYPERION_LOG_LEVEL`, `HYPERION_LOG_FORMAT`, `HYPERION_LOG_REQUESTS` (`0|1|true|false|yes|no|on|off`), `HYPERION_ENV`, `HYPERION_WORKER_MODEL` (`share|reuseport`).
+
+### Config file
+
+`config/hyperion.rb` — same shape as Puma's `puma.rb`. Auto-loaded if present.
+
+```ruby
+# config/hyperion.rb
+bind '0.0.0.0'
+port 9292
+
+workers      4
+thread_count 10
+
+# tls_cert_path 'config/cert.pem'
+# tls_key_path  'config/key.pem'
+
+read_timeout      30
+idle_keepalive     5
+graceful_timeout  30
+
+max_header_bytes  64 * 1024
+max_body_bytes    16 * 1024 * 1024
+
+log_level    :info
+log_format   :auto
+log_requests true
+
+fiber_local_shim false
+
+before_fork do
+  ActiveRecord::Base.connection_handler.clear_all_connections! if defined?(ActiveRecord)
+end
+
+on_worker_boot do |worker_index|
+  ActiveRecord::Base.establish_connection if defined?(ActiveRecord)
+end
+
+on_worker_shutdown do |worker_index|
+  ActiveRecord::Base.connection_handler.clear_all_connections! if defined?(ActiveRecord)
+end
+```
+
+Strict DSL: unknown methods raise `NoMethodError` at boot — typos surface immediately rather than getting silently ignored.
+
+A documented sample lives at [`config/hyperion.example.rb`](config/hyperion.example.rb).
+
+## Logging
+
+Default behaviour (rc16+):
+
+- **`info` / `debug` → stdout**, **`warn` / `error` / `fatal` → stderr** (12-factor).
+- **One structured access-log line per response**, info level, on stdout. Disable with `--no-log-requests` or `HYPERION_LOG_REQUESTS=0`.
+- **Format auto-selects**: production envs → JSON (line-delimited, parseable by every log aggregator); TTY → coloured text; piped output without env hint → JSON.
+
+### Sample access log lines
+
+Text format (TTY default):
+
+```
+2026-04-26T18:40:04.112Z INFO  [hyperion] message=request method=GET path=/api/v1/health status=200 duration_ms=46.63 remote_addr=127.0.0.1 http_version=HTTP/1.1
+2026-04-26T18:40:04.123Z INFO  [hyperion] message=request method=GET path=/api/v1/cached_data query="currency=USD" status=200 duration_ms=43.87 remote_addr=127.0.0.1 http_version=HTTP/1.1
+```
+
+JSON format (auto-selected on `RAILS_ENV=production`/`staging` or piped output):
+
+```json
+{"ts":"2026-04-26T18:38:49.405Z","level":"info","source":"hyperion","message":"request","method":"GET","path":"/api/v1/health","status":200,"duration_ms":46.63,"remote_addr":"127.0.0.1","http_version":"HTTP/1.1"}
+{"ts":"2026-04-26T18:38:49.411Z","level":"info","source":"hyperion","message":"request","method":"GET","path":"/api/v1/cached_data","query":"currency=USD","status":200,"duration_ms":40.64,"remote_addr":"127.0.0.1","http_version":"HTTP/1.1"}
+```
+
+### Hot-path optimisations
+
+The default-ON access log path is engineered to stay near-zero cost:
+
+- **Per-thread cached `iso8601(3)` timestamp** — one allocation per millisecond per thread, reused across all requests in that millisecond.
+- **Hand-rolled single-interpolation line builder** — bypasses generic `Hash#map.join`.
+- **Per-thread 4 KiB write buffer** — flushes to stdout when full or on connection close. Cuts ~32× the syscalls under load.
+- **Lock-free emit** — POSIX `write(2)` is atomic for writes ≤ PIPE_BUF (4096 B); a log line is ~200 B. No logger mutex.
+
+## Metrics
+
+`Hyperion.stats` returns a snapshot Hash with the following counters (lock-free per-thread aggregation):
+
+| Counter | Meaning |
+|---|---|
+| `connections_accepted` | Lifetime accept count. |
+| `connections_active` | Currently in-flight connections. |
+| `requests_total` | Lifetime request count. |
+| `requests_in_flight` | Currently in-flight requests. |
+| `responses_<code>` | One counter per status code emitted (`responses_200`, `responses_400`, …). |
+| `parse_errors` | HTTP parse failures → 400. |
+| `app_errors` | Rack app raised → 500. |
+| `read_timeouts` | Per-connection read deadline hit. |
+
+```ruby
+require 'hyperion'
+Hyperion.stats
+# => {connections_accepted: 1234, connections_active: 7, requests_total: 8910, …}
+```
+
+## TLS + HTTP/2
+
+Provide a PEM cert + key:
+
+```sh
+bundle exec hyperion --tls-cert config/cert.pem --tls-key config/key.pem -p 9443 config.ru
+```
+
+ALPN auto-negotiates `h2` (HTTP/2) or `http/1.1` per connection. HTTP/2 multiplexes streams onto fibers within a single connection — slow handlers don't head-of-line-block other streams. Cluster-mode TLS works (`-w N` + `--tls-cert` / `--tls-key`).
+
+Smuggling defenses for HTTP/1.1: `Content-Length` + `Transfer-Encoding` together → 400; non-chunked `Transfer-Encoding` → 501; CRLF in response header values → `ArgumentError` (response-splitting guard).
+
+## Compatibility
+
+- **Ruby 3.2+** required.
+- **Rack 3** (auto-sets `SERVER_SOFTWARE`, `rack.version`, `REMOTE_ADDR`, IPv6-safe `Host` parsing, CRLF guard).
+- **`Hyperion::FiberLocal.install!`** opt-in shim for older Rails apps that store request-scoped data via `Thread.current.thread_variable_*` (modern Rails 7.1+ already uses Fiber storage natively; the shim handles the residual footgun).
+- **`Hyperion::FiberLocal.verify_environment!`** runtime check that `Thread.current[:k]` is fiber-local on the current Ruby (it is on 3.2+).
+
+## Credits
+
+- Vendored [llhttp](https://github.com/nodejs/llhttp) (Node.js's HTTP parser, MIT) under `ext/hyperion_http/llhttp/`.
+- HTTP/2 framing and HPACK via [`protocol-http2`](https://github.com/socketry/protocol-http2).
+- Fiber scheduler via [`async`](https://github.com/socketry/async).
+
+## License
+
+MIT.

data/bin/hyperion

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+require 'hyperion/cli'
+Hyperion::CLI.run(ARGV)

data/ext/hyperion_http/extconf.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+
+# llhttp source files vendored under ext/hyperion_http/llhttp/.
+# We compile them in-tree (single static unit) rather than linking a
+# system library, so the gem builds standalone on any host with a C
+# compiler + Ruby headers.
+$srcs = %w[
+  parser.c
+  llhttp.c
+  api.c
+  http.c
+]
+$VPATH << '$(srcdir)/llhttp'
+$INCFLAGS << ' -I$(srcdir)/llhttp'
+$CFLAGS << ' -O2 -fno-strict-aliasing'
+
+create_makefile('hyperion_http/hyperion_http')