refactor(http3): merge hackney_quic into hackney_h3

Collapses the thin quic adapter and the h3 high-level module into a
single hackney_h3. Public low-level message tag renamed from
{quic, ConnRef, _} to {h3, ConnRef, _}; public low-level API moves
from hackney_quic: to hackney_h3:. Updates hackney_conn, tests, xref
config, and docs accordingly.

Author: benoitc

DEVELOPMENT.md

@@ -52,7 +52,7 @@ rebar3 eunit
 Run specific test modules:
 
 ```bash
-rebar3 eunit --module=hackney_quic_tests
+rebar3 eunit --module=hackney_h3_low_level_tests
 rebar3 eunit --module=hackney_http3_tests
 ```
 
@@ -87,7 +87,7 @@ docker run --rm hackney-test
 Run specific test modules:
 
 ```bash
-docker run --rm hackney-test bash -c "rebar3 eunit --module=hackney_quic_tests"
+docker run --rm hackney-test bash -c "rebar3 eunit --module=hackney_h3_low_level_tests"
 ```
 
 ### Interactive debugging in Docker
@@ -108,9 +108,7 @@ HTTP/3 support uses a pure Erlang QUIC implementation from the `quic` dependency
 
 ### Source Files
 
-- `src/hackney_quic.erl` - QUIC/HTTP3 transport wrapper
-- `src/hackney_qpack.erl` - QPACK header compression
-- `src/hackney_h3.erl` - HTTP/3 high-level API
+- `src/hackney_h3.erl` - HTTP/3 high-level + low-level adapter over `quic_h3`
 
 The underlying QUIC implementation is in the `quic` dependency which provides:
 - TLS 1.3 handshake

NEWS.md

@@ -8,12 +8,15 @@ UNRELEASED
 - HTTP/3 is now delegated to the `erlang_quic` library's `quic_h3` module
   (branch `feat/http3`). Hackney no longer ships its own HTTP/3 framing,
   QPACK codec, control-stream or unidirectional-stream handling:
-  - `hackney_quic.erl` is now a thin ~270 LOC gen_server adapter that
-    translates `{quic_h3, Conn, _}` events into the existing
-    `{quic, ConnRef, _}' message protocol consumed by `hackney_conn`.
-  - The public `hackney_quic` API now exposes `send_request/3` (atomic
-    stream-open + HEADERS) instead of the separate `open_stream/1` +
-    `send_headers/4` pair; `hackney_h3` updated to use it.
+  - `hackney_quic.erl` has been merged into `hackney_h3.erl`: the single
+    module now holds both the high-level request API and the gen_server
+    adapter that translates `{quic_h3, Conn, _}` events.
+  - The public low-level message tag is now `{h3, ConnRef, _}` (previously
+    `{quic, ConnRef, _}`). External subscribers to these events must retag
+    their receives.
+  - The public low-level API moves from `hackney_quic:` to `hackney_h3:`
+    (`connect/4`, `send_request/3`, `send_data/4`, `reset_stream/3`,
+    `close/2`, `process/1`).
   - `hackney_qpack.erl` removed (~622 LOC); the QPACK codec lives in
     `quic_qpack` in the `quic` dependency.
   - H3 peername/sockname/setopts/peercert now return `{error, not_supported}`:

guides/design.md

@@ -21,8 +21,7 @@ hackney_sup
 └── hackney_altsvc           (Alt-Svc cache for HTTP/3 discovery)
 
 QUIC connections (HTTP/3):
-├── hackney_quic.erl         (HTTP/3 wrapper using pure Erlang QUIC)
-└── hackney_qpack.erl        (QPACK header compression)
+└── hackney_h3.erl           (HTTP/3 high-level + adapter over quic_h3)
 ```
 
 ## Connection Process (hackney_conn)
@@ -304,13 +303,13 @@ Like TCP connections, QUIC uses an event-driven architecture where the owner pro
 │  2. Receives {select, Resource, Ref, ready_input}               │
 │     └── Socket has data ready                                   │
 │                                                                  │
-│  3. Calls hackney_quic:process(ConnRef)                         │
+│  3. Calls hackney_h3:process(ConnRef)                         │
 │     └── Receives UDP packets                                    │
 │     └── Processes QUIC frames                                   │
 │     └── Triggers events (headers, data, etc.)                   │
 │     └── Returns next timeout in ms                              │
 │                                                                  │
-│  4. Receives {quic, ConnRef, Event}                             │
+│  4. Receives {h3, ConnRef, Event}                             │
 │     └── {connected, Info}                                       │
 │     └── {stream_headers, StreamId, Headers, Fin}                │
 │     └── {stream_data, StreamId, Data, Fin}                      │
@@ -325,26 +324,16 @@ Like TCP connections, QUIC uses an event-driven architecture where the owner pro
 
 ```
 ┌─────────────────────────────────────────────────────────────────┐
-│                      hackney_quic.erl                            │
-│  - connect/4: Start QUIC connection                             │
-│  - process/1: Process pending I/O                               │
-│  - open_stream/1: Create new HTTP/3 stream                      │
-│  - send_headers/4: Send HTTP/3 request headers                  │
+│                       hackney_h3.erl                             │
+│  - connect/4: Start QUIC connection via quic_h3                 │
+│  - send_request/3: Open stream + send HEADERS                   │
 │  - send_data/4: Send request body                               │
+│  - reset_stream/3: Cancel an in-flight stream                   │
 │  - close/2: Close connection                                    │
 └─────────────────────────────────────────────────────────────────┘
                               │
                               ▼
 ┌─────────────────────────────────────────────────────────────────┐
-│                      hackney_qpack.erl                           │
-│  - encode/1: Encode HTTP headers to QPACK format                │
-│  - decode/1: Decode QPACK-encoded headers                       │
-│  - Static table with 99 predefined headers                      │
-│  - Huffman encoding/decoding                                    │
-└─────────────────────────────────────────────────────────────────┘
-                              │
-                              ▼
-┌─────────────────────────────────────────────────────────────────┐
 │                   quic application (dependency)                  │
 │  - QUIC protocol implementation (RFC 9000)                      │
 │  - TLS 1.3 handshake                                            │
@@ -358,7 +347,7 @@ Like TCP connections, QUIC uses an event-driven architecture where the owner pro
 ```
 Owner Process                         quic library
      │                                     │
-     │  hackney_quic:connect(...)          │
+     │  hackney_h3:connect(...)          │
      ├────────────────────────────────────►│ Create UDP socket
      │                                     │ Generate TLS keys
      │                                     │ Send Initial packet
@@ -367,17 +356,17 @@ Owner Process                         quic library
      │  {select, _, _, ready_input}        │
      │◄────────────────────────────────────┤ UDP packet received
      │                                     │
-     │  hackney_quic:process(ConnRef)      │
+     │  hackney_h3:process(ConnRef)      │
      ├────────────────────────────────────►│ Process QUIC packets
      │                                     │ Continue handshake
-     │  {quic, ConnRef, {connected, Info}} │
+     │  {h3, ConnRef, {connected, Info}} │
      │◄────────────────────────────────────┤
      │                                     │
      │  ... (request/response cycle) ...   │
      │                                     │
-     │  hackney_quic:close(ConnRef, ...)   │
+     │  hackney_h3:close(ConnRef, ...)   │
      ├────────────────────────────────────►│ Send CONNECTION_CLOSE
-     │  {quic, ConnRef, {closed, normal}}  │
+     │  {h3, ConnRef, {closed, normal}}  │
      │◄────────────────────────────────────┤
      │                                     │
 ```

guides/http3_guide.md

@@ -17,7 +17,7 @@ Hackney supports HTTP/3, the latest version of HTTP built on QUIC (UDP-based tra
 
 ## Requirements
 
-HTTP/3 support is provided by the [`erlang_quic`](https://github.com/benoitc/erlang_quic) dependency (module `quic_h3`), which handles the QUIC transport, QPACK header compression, HTTP/3 framing, and control streams. Hackney hosts only a thin adapter (`hackney_quic`) that translates `quic_h3` events into the internal connection protocol. No C dependencies, no external binaries required.
+HTTP/3 support is provided by the [`erlang_quic`](https://github.com/benoitc/erlang_quic) dependency (module `quic_h3`), which handles the QUIC transport, QPACK header compression, HTTP/3 framing, and control streams. Hackney hosts only a thin adapter (`hackney_h3`) that translates `quic_h3` events into the internal connection protocol. No C dependencies, no external binaries required.
 
 ## Quick Start
 
@@ -186,24 +186,24 @@ Like HTTP/2, HTTP/3 multiplexes requests as streams on a single QUIC connection:
 
 The high-level `hackney:get/post/...` functions cover the common case. For
 servers that send streamed responses, or when you want to drive several
-requests concurrently on the same QUIC connection, use the `hackney_quic`
+requests concurrently on the same QUIC connection, use the `hackney_h3`
 adapter directly.
 
 ### Connect
 
 ```erlang
-{ok, ConnRef} = hackney_quic:connect(<<"cloudflare.com">>, 443, #{}, self()).
+{ok, ConnRef} = hackney_h3:connect(<<"cloudflare.com">>, 443, #{}, self()).
 
 receive
-    {quic, ConnRef, {connected, _Info}} -> ok
+    {h3, ConnRef, {connected, _Info}} -> ok
 after 5000 ->
     error(connect_timeout)
 end.
 ```
 
-`hackney_quic:connect/4` registers the calling process as the owner of the
+`hackney_h3:connect/4` registers the calling process as the owner of the
 connection. All events for the connection arrive as messages of the form
-`{quic, ConnRef, Event}`.
+`{h3, ConnRef, Event}`.
 
 ### Send a request
 
@@ -218,15 +218,15 @@ Headers = [
     {<<":authority">>, <<"cloudflare.com">>},
     {<<":path">>, <<"/cdn-cgi/trace">>}
 ],
-{ok, StreamId} = hackney_quic:send_request(ConnRef, Headers, true).
+{ok, StreamId} = hackney_h3:send_request(ConnRef, Headers, true).
 ```
 
 For requests with a body:
 
 ```erlang
-{ok, StreamId} = hackney_quic:send_request(ConnRef, Headers, false),
-ok = hackney_quic:send_data(ConnRef, StreamId, <<"chunk-1">>, false),
-ok = hackney_quic:send_data(ConnRef, StreamId, <<"chunk-2">>, true).  %% Fin
+{ok, StreamId} = hackney_h3:send_request(ConnRef, Headers, false),
+ok = hackney_h3:send_data(ConnRef, StreamId, <<"chunk-1">>, false),
+ok = hackney_h3:send_data(ConnRef, StreamId, <<"chunk-2">>, true).  %% Fin
 ```
 
 ### Receive the response
@@ -237,18 +237,18 @@ the `StreamId`:
 ```erlang
 recv(ConnRef, StreamId, Status, Headers, Body) ->
     receive
-        {quic, ConnRef, {stream_headers, StreamId, RespHeaders, _Fin}} ->
+        {h3, ConnRef, {stream_headers, StreamId, RespHeaders, _Fin}} ->
             {<<":status">>, S} = lists:keyfind(<<":status">>, 1, RespHeaders),
             recv(ConnRef, StreamId, binary_to_integer(S),
                  [H || {K, _} = H <- RespHeaders, K =/= <<":status">>],
                  Body);
-        {quic, ConnRef, {stream_data, StreamId, Chunk, true}} ->
+        {h3, ConnRef, {stream_data, StreamId, Chunk, true}} ->
             {ok, Status, Headers, <<Body/binary, Chunk/binary>>};
-        {quic, ConnRef, {stream_data, StreamId, Chunk, false}} ->
+        {h3, ConnRef, {stream_data, StreamId, Chunk, false}} ->
             recv(ConnRef, StreamId, Status, Headers, <<Body/binary, Chunk/binary>>);
-        {quic, ConnRef, {stream_reset, StreamId, ErrorCode}} ->
+        {h3, ConnRef, {stream_reset, StreamId, ErrorCode}} ->
             {error, {stream_reset, ErrorCode}};
-        {quic, ConnRef, {closed, Reason}} ->
+        {h3, ConnRef, {closed, Reason}} ->
             {error, {closed, Reason}}
     after 30000 ->
         {error, timeout}
@@ -265,9 +265,9 @@ Since each request gets its own `StreamId`, you can have several in flight
 on the same QUIC connection and demultiplex on the StreamId in your receive:
 
 ```erlang
-{ok, S1} = hackney_quic:send_request(ConnRef, headers(<<"/">>), true),
-{ok, S2} = hackney_quic:send_request(ConnRef, headers(<<"/cdn-cgi/trace">>), true),
-{ok, S3} = hackney_quic:send_request(ConnRef, headers(<<"/robots.txt">>), true),
+{ok, S1} = hackney_h3:send_request(ConnRef, headers(<<"/">>), true),
+{ok, S2} = hackney_h3:send_request(ConnRef, headers(<<"/cdn-cgi/trace">>), true),
+{ok, S3} = hackney_h3:send_request(ConnRef, headers(<<"/robots.txt">>), true),
 
 %% Collect responses as they complete; order is not guaranteed.
 collect(ConnRef, sets:from_list([S1, S2, S3]), #{}).
@@ -276,12 +276,12 @@ collect(_ConnRef, Pending, Acc) when map_size(Acc) =:= sets:size(Pending) ->
     Acc;
 collect(ConnRef, Pending, Acc) ->
     receive
-        {quic, ConnRef, {stream_headers, SId, Hs, _}} ->
+        {h3, ConnRef, {stream_headers, SId, Hs, _}} ->
             collect(ConnRef, Pending, Acc#{SId => {Hs, <<>>}});
-        {quic, ConnRef, {stream_data, SId, Chunk, true}} ->
+        {h3, ConnRef, {stream_data, SId, Chunk, true}} ->
             #{SId := {Hs, Body}} = Acc,
             collect(ConnRef, Pending, Acc#{SId => {Hs, <<Body/binary, Chunk/binary>>}});
-        {quic, ConnRef, {stream_data, SId, Chunk, false}} ->
+        {h3, ConnRef, {stream_data, SId, Chunk, false}} ->
             #{SId := {Hs, Body}} = Acc,
             collect(ConnRef, Pending, Acc#{SId => {Hs, <<Body/binary, Chunk/binary>>}})
     end.
@@ -293,13 +293,13 @@ Use `reset_stream/3` to abort a single in-flight request without tearing
 down the connection:
 
 ```erlang
-ok = hackney_quic:reset_stream(ConnRef, StreamId, 16#0102).  %% H3_REQUEST_CANCELLED
+ok = hackney_h3:reset_stream(ConnRef, StreamId, 16#0102).  %% H3_REQUEST_CANCELLED
 ```
 
 ### Close
 
 ```erlang
-hackney_quic:close(ConnRef, normal).
+hackney_h3:close(ConnRef, normal).
 ```
 
 ### Event reference

rebar.config

@@ -31,15 +31,14 @@
   {quic_h3, send_data, 4},
   {quic_h3, cancel, 3},
   {quic_h3, close, 1},
-  %% hackney_quic wrapper functions called by hackney_conn/hackney_h3
-  {hackney_quic, connect, 4},
-  {hackney_quic, close, 2},
-  {hackney_quic, process, 1},
-  {hackney_quic, send_request, 3},
-  {hackney_quic, send_data, 4},
   %% hackney_h3 functions called by hackney_conn
+  {hackney_h3, connect, 4},
+  {hackney_h3, close, 2},
+  {hackney_h3, process, 1},
+  {hackney_h3, send_request, 3},
   {hackney_h3, send_request, 6},
   {hackney_h3, send_request_headers, 5},
+  {hackney_h3, send_data, 4},
   {hackney_h3, send_body_chunk, 4},
   {hackney_h3, finish_send_body, 3},
   {hackney_h3, parse_response_headers, 1}