fix: HTTP/2 large body handling and flow control

- Fix H2 server read buffer tracking for bodies >16KB
- Track buf_off/buf_len for partial consumption
- Handle Yield state in read loop
- Compress buffer after partial reads

- Fix H2 client body flushing before close
- Use Body.Writer.flush with callback before closing
- Ensures all data is sent before marking stream done

- Add comprehensive large body test suite
- HTTP/1.1: 1KB-5MB POST, integrity, max_body_size
- HTTP/2 h2c: 1KB-5MB POST, integrity
- WebSocket: 1KB-64KB messages, integrity

- Add benchmark comparison tools
- bench_compare.ml: Compare results across runs
- bench_parser.ml: Parse benchmark output

All tests pass with default H2 window size (65535 bytes),
confirming proper WINDOW_UPDATE flow control.

bench/hcs/bench_compare.ml

···
+open Base
+
+module Bench = struct
+  [@@@warning "-69"]
+
+  type result = {
+    name : string;
+    iterations : int;
+    total_time : float;
+    avg_time_ns : float;
+    ops_per_sec : float;
+    minor_words_per_op : float;
+    major_words_per_op : float;
+    promoted_words_per_op : float;
+  }
+
+  let run ~name ~iterations f =
+    for _ = 1 to Int.min 1000 iterations do
+      ignore (f ())
+    done;
+    Stdlib.Gc.full_major ();
+    Stdlib.Gc.compact ();
+    let gc_before = Stdlib.Gc.quick_stat () in
+    let start = Unix.gettimeofday () in
+    for _ = 1 to iterations do
+      ignore (f ())
+    done;
+    let stop = Unix.gettimeofday () in
+    let gc_after = Stdlib.Gc.quick_stat () in
+    let total_time = stop -. start in
+    let avg_time_ns =
+      total_time /. Float.of_int iterations *. 1_000_000_000.0
+    in
+    let ops_per_sec = Float.of_int iterations /. total_time in
+    let iters = Float.of_int iterations in
+    let minor_words_per_op =
+      (gc_after.minor_words -. gc_before.minor_words) /. iters
+    in
+    let major_words_per_op =
+      (gc_after.major_words -. gc_before.major_words) /. iters
+    in
+    let promoted_words_per_op =
+      (gc_after.promoted_words -. gc_before.promoted_words) /. iters
+    in
+    {
+      name;
+      iterations;
+      total_time;
+      avg_time_ns;
+      ops_per_sec;
+      minor_words_per_op;
+      major_words_per_op;
+      promoted_words_per_op;
+    }
+
+  let total_alloc r = r.minor_words_per_op +. r.major_words_per_op
+
+  let print_result r =
+    Stdio.printf "  %-35s %8.0f ns/op  %10.0f ops/s  %6.0f words/op\n" r.name
+      r.avg_time_ns r.ops_per_sec (total_alloc r)
+
+  let print_comparison ~baseline ~test =
+    let speedup = baseline.avg_time_ns /. test.avg_time_ns in
+    let alloc_ratio =
+      total_alloc baseline /. Float.max 1.0 (total_alloc test)
+    in
+    let faster_slower = if Float.(speedup > 1.0) then "faster" else "slower" in
+    Stdio.printf "    -> %s is %.2fx %s, %.1fx %s allocations\n\n" test.name
+      speedup faster_slower alloc_ratio
+      (if Float.(alloc_ratio > 1.0) then "fewer" else "more")
+end
+
+let small_request = "GET / HTTP/1.1\r\nHost: localhost\r\n\r\n"
+
+let medium_request =
+  "GET /index.html HTTP/1.1\r\n\
+   Host: www.example.com\r\n\
+   User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) \
+   AppleWebKit/537.36\r\n\
+   Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n\
+   Accept-Language: en-US,en;q=0.9\r\n\
+   Accept-Encoding: gzip, deflate, br\r\n\
+   Connection: keep-alive\r\n\
+   Cache-Control: max-age=0\r\n\
+   Cookie: session=abc123; tracking=xyz789\r\n\
+   If-None-Match: \"abc123\"\r\n\
+   If-Modified-Since: Mon, 01 Jan 2024 00:00:00 GMT\r\n\
+   \r\n"
+
+let large_request =
+  "POST /api/v1/users/12345/documents HTTP/1.1\r\n\
+   Host: api.example.com\r\n\
+   User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) \
+   AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36\r\n\
+   Accept: application/json, text/plain, */*\r\n\
+   Accept-Language: en-US,en;q=0.9,de;q=0.8,fr;q=0.7\r\n\
+   Accept-Encoding: gzip, deflate, br\r\n\
+   Content-Type: application/json; charset=utf-8\r\n\
+   Content-Length: 256\r\n\
+   Authorization: Bearer \
+   eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c\r\n\
+   X-Request-ID: 550e8400-e29b-41d4-a716-446655440000\r\n\
+   X-Correlation-ID: 7c9e6679-7425-40de-944b-e07fc1f90ae7\r\n\
+   X-Forwarded-For: 192.168.1.1, 10.0.0.1\r\n\
+   X-Forwarded-Proto: https\r\n\
+   X-Forwarded-Host: www.example.com\r\n\
+   Origin: https://www.example.com\r\n\
+   Referer: https://www.example.com/dashboard\r\n\
+   Cookie: session=abc123def456; csrf_token=xyz789; \
+   preferences=dark_mode%3Dtrue%26lang%3Den; _ga=GA1.2.123456789.1234567890\r\n\
+   Cache-Control: no-cache, no-store, must-revalidate\r\n\
+   Pragma: no-cache\r\n\
+   Connection: keep-alive\r\n\
+   Sec-Fetch-Dest: empty\r\n\
+   Sec-Fetch-Mode: cors\r\n\
+   Sec-Fetch-Site: same-origin\r\n\
+   \r\n"
+
+let buffer_size = 16384
+
+module H1_bench = struct
+  let h1_buf = Bigstringaf.create buffer_size
+
+  let copy_to_buffer data =
+    let len = String.length data in
+    Bigstringaf.blit_from_string data ~src_off:0 h1_buf ~dst_off:0 ~len;
+    len
+
+  let parse_request data =
+    let len = copy_to_buffer data in
+    let request = ref None in
+    let request_handler reqd =
+      let req = H1.Reqd.request reqd in
+      request := Some req;
+      let resp = H1.Response.create `OK in
+      H1.Reqd.respond_with_string reqd resp ""
+    in
+    let error_handler ?request:_ _error _handler = () in
+    let conn = H1.Server_connection.create ~error_handler request_handler in
+    let _ = H1.Server_connection.read conn h1_buf ~off:0 ~len in
+    let _ = !request in
+    ()
+end
+
+module Eio_bufread_bench = struct
+  let parse_request data =
+    let reader = Eio.Buf_read.of_string data in
+    let line = Eio.Buf_read.line reader in
+    let parts = String.split line ~on:' ' in
+    let _meth = List.hd_exn parts in
+    let _target = List.nth_exn parts 1 in
+    let _version = List.nth_exn parts 2 in
+    let headers = ref [] in
+    let rec read_headers () =
+      let header_line = Eio.Buf_read.line reader in
+      if String.is_empty header_line then ()
+      else begin
+        (match String.lsplit2 header_line ~on:':' with
+        | Some (k, v) -> headers := (k, String.lstrip v) :: !headers
+        | None -> ());
+        read_headers ()
+      end
+    in
+    read_headers ();
+    let _ = !headers in
+    ()
+end
+
+let run_size_benchmark ~name ~data ~iterations =
+  Stdio.printf "\n%s (%d bytes, %d iterations)\n" name (String.length data)
+    iterations;
+  Stdio.print_string (String.make 60 '-');
+  Stdio.print_endline "";
+  let h1_result =
+    Bench.run ~name:"h1 (HCS)" ~iterations (fun () ->
+        H1_bench.parse_request data)
+  in
+  Bench.print_result h1_result;
+  let bufread_result =
+    Bench.run ~name:"Buf_read (Eio)" ~iterations (fun () ->
+        Eio_bufread_bench.parse_request data)
+  in
+  Bench.print_result bufread_result;
+  Bench.print_comparison ~baseline:bufread_result ~test:h1_result;
+  (h1_result, bufread_result)
+
+let run_throughput_benchmark () =
+  Stdio.printf "\n\nTHROUGHPUT TEST (1000 iterations per call)\n";
+  Stdio.print_string (String.make 60 '=');
+  Stdio.print_endline "";
+  let iterations = 1000 in
+  let outer_iterations = 1000 in
+  Stdio.printf "\nSmall request throughput:\n";
+  let h1_tp =
+    Bench.run ~name:"h1 throughput" ~iterations:outer_iterations (fun () ->
+        for _ = 1 to iterations do
+          ignore (H1_bench.parse_request small_request)
+        done)
+  in
+  let h1_total_ops = Float.of_int (outer_iterations * iterations) in
+  let h1_ops_per_sec = h1_total_ops /. h1_tp.total_time in
+  Stdio.printf "  h1: %.0f requests/sec\n" h1_ops_per_sec;
+  let bufread_tp =
+    Bench.run ~name:"Buf_read throughput" ~iterations:outer_iterations
+      (fun () ->
+        for _ = 1 to iterations do
+          ignore (Eio_bufread_bench.parse_request small_request)
+        done)
+  in
+  let bufread_total_ops = Float.of_int (outer_iterations * iterations) in
+  let bufread_ops_per_sec = bufread_total_ops /. bufread_tp.total_time in
+  Stdio.printf "  Buf_read: %.0f requests/sec\n" bufread_ops_per_sec;
+  let ratio = h1_ops_per_sec /. bufread_ops_per_sec in
+  Stdio.printf "  -> h1 is %.2fx %s\n" ratio
+    (if Float.(ratio > 1.0) then "faster" else "slower")
+
+let print_summary results =
+  Stdio.printf "\n\nSUMMARY\n";
+  Stdio.print_string (String.make 60 '=');
+  Stdio.print_endline "";
+  Stdio.printf "\n%-15s %12s %12s %10s %10s\n" "Size" "h1 ns/op"
+    "Buf_read ns/op" "Speedup" "Alloc Ratio";
+  Stdio.print_string (String.make 60 '-');
+  Stdio.print_endline "";
+  List.iter results ~f:(fun (name, (h1, bufread)) ->
+      let speedup = bufread.Bench.avg_time_ns /. h1.Bench.avg_time_ns in
+      let alloc_ratio =
+        Bench.total_alloc bufread /. Float.max 1.0 (Bench.total_alloc h1)
+      in
+      Stdio.printf "%-15s %12.0f %12.0f %9.2fx %9.1fx\n" name h1.avg_time_ns
+        bufread.avg_time_ns speedup alloc_ratio)
+
+let () =
+  Stdio.print_endline "";
+  Stdio.print_endline
+    "============================================================";
+  Stdio.print_endline "  HTTP Parser Comparison: h1 (HCS) vs Buf_read (Eio)";
+  Stdio.print_endline
+    "============================================================";
+  Stdio.print_endline "";
+  Stdio.print_endline "h1: State-machine parser used by HCS server";
+  Stdio.print_endline "Buf_read: Simple line-based parsing using Eio";
+  Stdio.print_endline "";
+  let small =
+    ( "Small",
+      run_size_benchmark ~name:"SMALL REQUEST" ~data:small_request
+        ~iterations:500_000 )
+  in
+  let medium =
+    ( "Medium",
+      run_size_benchmark ~name:"MEDIUM REQUEST" ~data:medium_request
+        ~iterations:200_000 )
+  in
+  let large =
+    ( "Large",
+      run_size_benchmark ~name:"LARGE REQUEST" ~data:large_request
+        ~iterations:100_000 )
+  in
+  let results = [ small; medium; large ] in
+  run_throughput_benchmark ();
+  print_summary results;
+  Stdio.print_endline "";
+  Stdio.print_endline
+    "============================================================";
+  Stdio.print_endline "  Benchmark Complete";
+  Stdio.print_endline
+    "============================================================";
+  Stdio.print_endline ""

bench/hcs/bench_parser.ml

···
+open Base
+
+module Bench = struct
+  [@@@warning "-69"]
+
+  type result = {
+    name : string;
+    iterations : int;
+    total_time : float;
+    avg_time_ns : float;
+    ops_per_sec : float;
+    minor_words_per_op : float;
+    major_words_per_op : float;
+    promoted_words_per_op : float;
+  }
+
+  let run ~name ~iterations f =
+    for _ = 1 to Int.min 1000 iterations do
+      ignore (f ())
+    done;
+    Stdlib.Gc.full_major ();
+    Stdlib.Gc.compact ();
+    let gc_before = Stdlib.Gc.quick_stat () in
+    let start = Unix.gettimeofday () in
+    for _ = 1 to iterations do
+      ignore (f ())
+    done;
+    let stop = Unix.gettimeofday () in
+    let gc_after = Stdlib.Gc.quick_stat () in
+    let total_time = stop -. start in
+    let avg_time_ns =
+      total_time /. Float.of_int iterations *. 1_000_000_000.0
+    in
+    let ops_per_sec = Float.of_int iterations /. total_time in
+    let iters = Float.of_int iterations in
+    let minor_words_per_op =
+      (gc_after.minor_words -. gc_before.minor_words) /. iters
+    in
+    let major_words_per_op =
+      (gc_after.major_words -. gc_before.major_words) /. iters
+    in
+    let promoted_words_per_op =
+      (gc_after.promoted_words -. gc_before.promoted_words) /. iters
+    in
+    {
+      name;
+      iterations;
+      total_time;
+      avg_time_ns;
+      ops_per_sec;
+      minor_words_per_op;
+      major_words_per_op;
+      promoted_words_per_op;
+    }
+
+  let total_alloc r = r.minor_words_per_op +. r.major_words_per_op
+
+  let print_result r =
+    Stdio.printf "  %-35s %8.0f ns/op  %10.0f ops/s  %6.0f words/op\n" r.name
+      r.avg_time_ns r.ops_per_sec (total_alloc r)
+end
+
+let minimal_request = "GET / HTTP/1.1\r\nHost: localhost\r\n\r\n"
+
+let simple_request =
+  "GET /path/to/resource HTTP/1.1\r\n\
+   Host: example.com\r\n\
+   User-Agent: Mozilla/5.0\r\n\
+   Accept: text/html\r\n\
+   Connection: keep-alive\r\n\
+   \r\n"
+
+let make_request_with_headers n_headers =
+  let buf = Buffer.create 1024 in
+  Buffer.add_string buf "GET /api/v1/users/12345 HTTP/1.1\r\n";
+  Buffer.add_string buf "Host: api.example.com\r\n";
+  for i = 1 to n_headers do
+    Buffer.add_string buf
+      (Printf.sprintf "X-Custom-Header-%d: value-%d\r\n" i i)
+  done;
+  Buffer.add_string buf "\r\n";
+  Buffer.contents buf
+
+let request_5_headers = make_request_with_headers 5
+let request_10_headers = make_request_with_headers 10
+let request_20_headers = make_request_with_headers 20
+let request_50_headers = make_request_with_headers 50
+
+let make_request_with_body body_size =
+  let body = String.make body_size 'x' in
+  Printf.sprintf
+    "POST /upload HTTP/1.1\r\n\
+     Host: example.com\r\n\
+     Content-Length: %d\r\n\
+     Content-Type: application/octet-stream\r\n\
+     \r\n\
+     %s"
+    body_size body
+
+let request_body_100 = make_request_with_body 100
+let request_body_1k = make_request_with_body 1024
+let request_body_10k = make_request_with_body 10240
+
+let browser_request =
+  "GET /index.html HTTP/1.1\r\n\
+   Host: www.example.com\r\n\
+   User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) \
+   AppleWebKit/537.36\r\n\
+   Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n\
+   Accept-Language: en-US,en;q=0.9\r\n\
+   Accept-Encoding: gzip, deflate, br\r\n\
+   Connection: keep-alive\r\n\
+   Cache-Control: max-age=0\r\n\
+   Cookie: session=abc123; tracking=xyz789\r\n\
+   If-None-Match: \"abc123\"\r\n\
+   If-Modified-Since: Mon, 01 Jan 2024 00:00:00 GMT\r\n\
+   \r\n"
+
+let buffer_size = 16384
+
+let copy_to_buffer buf data =
+  let len = String.length data in
+  Bigstringaf.blit_from_string data ~src_off:0 buf ~dst_off:0 ~len;
+  len
+
+let parse_request_h1 buf data =
+  let len = copy_to_buffer buf data in
+  let request = ref None in
+  let request_handler reqd =
+    let req = H1.Reqd.request reqd in
+    request := Some req;
+    let resp = H1.Response.create `OK in
+    H1.Reqd.respond_with_string reqd resp ""
+  in
+  let error_handler ?request:_ _error _handler = () in
+  let conn = H1.Server_connection.create ~error_handler request_handler in
+  let _ = H1.Server_connection.read conn buf ~off:0 ~len in
+  !request
+
+let just_copy buf data =
+  let len = copy_to_buffer buf data in
+  len
+
+let h1_buf = Bigstringaf.create buffer_size
+
+let run_parsing_benchmarks () =
+  Stdio.print_endline "\nPARSING BENCHMARKS";
+  Stdio.print_endline (String.make 60 '=');
+
+  let tests =
+    [
+      ("h1_noop", 500_000, fun () -> ());
+      ( "h1_just_copy",
+        500_000,
+        fun () -> ignore (just_copy h1_buf minimal_request) );
+      ( "h1_minimal",
+        200_000,
+        fun () -> ignore (parse_request_h1 h1_buf minimal_request) );
+      ( "h1_simple",
+        200_000,
+        fun () -> ignore (parse_request_h1 h1_buf simple_request) );
+      ( "h1_browser",
+        100_000,
+        fun () -> ignore (parse_request_h1 h1_buf browser_request) );
+      ( "h1_5_headers",
+        200_000,
+        fun () -> ignore (parse_request_h1 h1_buf request_5_headers) );
+      ( "h1_10_headers",
+        100_000,
+        fun () -> ignore (parse_request_h1 h1_buf request_10_headers) );
+      ( "h1_20_headers",
+        100_000,
+        fun () -> ignore (parse_request_h1 h1_buf request_20_headers) );
+      ( "h1_50_headers",
+        50_000,
+        fun () -> ignore (parse_request_h1 h1_buf request_50_headers) );
+    ]
+  in
+  List.iter tests ~f:(fun (name, iterations, f) ->
+      let result = Bench.run ~name ~iterations f in
+      Bench.print_result result)
+
+let run_header_benchmarks () =
+  Stdio.print_endline "\nHEADER LOOKUP BENCHMARKS";
+  Stdio.print_endline (String.make 60 '=');
+
+  let buf = Bigstringaf.create buffer_size in
+  let len = copy_to_buffer buf browser_request in
+  let headers = ref H1.Headers.empty in
+  let request_handler reqd =
+    let req = H1.Reqd.request reqd in
+    headers := req.H1.Request.headers;
+    let resp = H1.Response.create `OK in
+    H1.Reqd.respond_with_string reqd resp ""
+  in
+  let error_handler ?request:_ _error _handler = () in
+  let conn = H1.Server_connection.create ~error_handler request_handler in
+  let _ = H1.Server_connection.read conn buf ~off:0 ~len in
+  let hdrs = !headers in
+
+  let tests =
+    [
+      ("h1_find_host", 1_000_000, fun () -> ignore (H1.Headers.get hdrs "host"));
+      ( "h1_find_connection",
+        1_000_000,
+        fun () -> ignore (H1.Headers.get hdrs "connection") );
+      ( "h1_find_user_agent",
+        1_000_000,
+        fun () -> ignore (H1.Headers.get hdrs "user-agent") );
+    ]
+  in
+  List.iter tests ~f:(fun (name, iterations, f) ->
+      let result = Bench.run ~name ~iterations f in
+      Bench.print_result result)
+
+let run_body_benchmarks () =
+  Stdio.print_endline "\nBODY HANDLING BENCHMARKS";
+  Stdio.print_endline (String.make 60 '=');
+
+  let buf = Bigstringaf.create buffer_size in
+  let tests =
+    [
+      ( "h1_body_100B",
+        100_000,
+        fun () -> ignore (parse_request_h1 buf request_body_100) );
+      ( "h1_body_1KB",
+        50_000,
+        fun () -> ignore (parse_request_h1 buf request_body_1k) );
+      ( "h1_body_10KB",
+        20_000,
+        fun () -> ignore (parse_request_h1 buf request_body_10k) );
+    ]
+  in
+  List.iter tests ~f:(fun (name, iterations, f) ->
+      let result = Bench.run ~name ~iterations f in
+      Bench.print_result result)
+
+let run_throughput_benchmarks () =
+  Stdio.print_endline "\nTHROUGHPUT BENCHMARKS (1000 iterations per call)";
+  Stdio.print_endline (String.make 60 '=');
+
+  let buf = Bigstringaf.create buffer_size in
+  let iterations = 1000 in
+  let tests =
+    [
+      ( "h1_1k_simple",
+        1000,
+        fun () ->
+          for _ = 1 to iterations do
+            ignore (parse_request_h1 buf simple_request)
+          done );
+      ( "h1_1k_browser",
+        1000,
+        fun () ->
+          for _ = 1 to iterations do
+            ignore (parse_request_h1 buf browser_request)
+          done );
+      ( "h1_1k_50headers",
+        500,
+        fun () ->
+          for _ = 1 to iterations do
+            ignore (parse_request_h1 buf request_50_headers)
+          done );
+    ]
+  in
+  List.iter tests ~f:(fun (name, outer_iterations, f) ->
+      let result = Bench.run ~name ~iterations:outer_iterations f in
+      let total_ops = Float.of_int (outer_iterations * iterations) in
+      let ops_per_sec = total_ops /. result.total_time in
+      Stdio.printf "  %-35s %10.0f requests/sec\n" name ops_per_sec)
+
+let () =
+  Stdio.print_endline "";
+  Stdio.print_endline
+    "============================================================";
+  Stdio.print_endline "  H1 HTTP Parser Benchmarks (HCS)";
+  Stdio.print_endline
+    "============================================================";
+  Stdio.print_endline "";
+  Stdio.print_endline "h1: HTTP/1.1 parser library used by HCS server";
+  Stdio.print_endline "";
+
+  run_parsing_benchmarks ();
+  run_header_benchmarks ();
+  run_body_benchmarks ();
+  run_throughput_benchmarks ();
+
+  Stdio.print_endline "";
+  Stdio.print_endline
+    "============================================================";
+  Stdio.print_endline "  Benchmark Complete";
+  Stdio.print_endline
+    "============================================================";
+  Stdio.print_endline ""

bench/hcs/dune

···
 (executable
  (name bench_buffers)
  (libraries hcs cstruct bigstringaf unix))
+
+(executable
+ (name bench_parser)
+ (libraries h1 bigstringaf base stdio unix))
+
+(executable
+ (name bench_compare)
+ (libraries h1 bigstringaf base stdio unix eio eio_main))

lib/client.ml

···
     | Error e -> Error (map_h1_error e)
 
 let request_post t url ~body:request_body =
-  match H1_client.post t.h1_client url ~body:request_body with
-  | Ok resp ->
-      Ok
-        {
-          status = h1_status_to_int resp.H1_client.status;
-          headers = h1_headers_to_list resp.headers;
-          body = resp.body;
-          protocol = HTTP_1_1;
-        }
-  | Error e -> Error (map_h1_error e)
+  if should_use_h2 t.config url then
+    match H2_client.post t.h2_client url ~body:request_body with
+    | Ok resp ->
+        Ok
+          {
+            status = h2_status_to_int resp.H2_client.status;
+            headers = h2_headers_to_list resp.headers;
+            body = resp.body;
+            protocol = HTTP_2;
+          }
+    | Error e -> Error (map_h2_error e)
+  else
+    match H1_client.post t.h1_client url ~body:request_body with
+    | Ok resp ->
+        Ok
+          {
+            status = h1_status_to_int resp.H1_client.status;
+            headers = h1_headers_to_list resp.headers;
+            body = resp.body;
+            protocol = HTTP_1_1;
+          }
+    | Error e -> Error (map_h1_error e)
 
 let get ~sw ~net ~clock ?(config = default_config) url =
   let t = create ~sw ~net ~clock ~config () in

lib/h2_client.ml

···
     try Eio.Flow.close (Obj.magic c.flow) with _ -> ()
   end
 
-let do_request flow req =
+let do_request ?(body = "") flow req =
   let response_received = Eio.Promise.create () in
   let body_buffer = Buffer.create 4096 in
   let resolved = ref false in
···
         H2.Client_connection.request conn req ~flush_headers_immediately:true
           ~error_handler ~response_handler
       in
-      H2.Body.Writer.close body_writer
+      if String.length body > 0 then begin
+        H2.Body.Writer.write_string body_writer body;
+        H2.Body.Writer.flush body_writer (fun _result ->
+            H2.Body.Writer.close body_writer)
+      end
+      else H2.Body.Writer.close body_writer
     end
   in
 
···
   with
   | Some result -> result
   | None -> Error Timeout
+
+let post t url ~body:request_body =
+  let uri = Uri.of_string url in
+  let scheme = Uri.scheme uri |> Option.value ~default:"https" in
+  let is_https = String.equal scheme "https" in
+  let host = Uri.host uri |> Option.value ~default:"localhost" in
+  let default_port = if is_https then 443 else 80 in
+  let port = Uri.port uri |> Option.value ~default:default_port in
+  let path = Uri.path_and_query uri in
+  let path = if path = "" then "/" else path in
+
+  let total_timeout = t.config.connect_timeout +. t.config.read_timeout in
+  match
+    t.with_timeout total_timeout (fun () ->
+        match acquire_connection t ~host ~port ~is_https with
+        | Error e -> Error e
+        | Ok conn -> (
+            let content_length = String.length request_body in
+            let headers =
+              H2.Headers.of_list
+                [
+                  (":authority", host);
+                  ("content-length", string_of_int content_length);
+                  ("content-type", "application/octet-stream");
+                ]
+            in
+            let req = H2.Request.create ~headers ~scheme `POST path in
+            match do_request ~body:request_body conn.flow req with
+            | Ok resp ->
+                release_connection t ~host ~port ~is_https conn ~keep_alive:true;
+                Ok resp
+            | Error e ->
+                release_connection t ~host ~port ~is_https conn
+                  ~keep_alive:false;
+                Error e))
+  with
+  | Some result -> result
+  | None -> Error Timeout
+
+let post' ~sw ~net ~clock ?config url ~body =
+  let t = create ~sw ~net ~clock ?config () in
+  let result = post t url ~body in
+  close t;
+  result
 
 (** {1 Backward-compatible stateless API} *)
 

lib/server.ml

···
 (** {1 Internal: HTTP/1.1 Connection Handler} *)
 
 module H1_handler = struct
+  let send_response reqd (response : Response.t) =
+    let date_header = ("date", Date_cache.get ()) in
+    match response.Response.body with
+    | Response.Prebuilt_body prebuilt -> Prebuilt.respond_h1 reqd prebuilt
+    | Response.Empty ->
+        let headers =
+          H1.Headers.of_list
+            (date_header :: ("content-length", "0") :: response.headers)
+        in
+        let resp = H1.Response.create ~headers response.status in
+        H1.Reqd.respond_with_string reqd resp ""
+    | Response.String body ->
+        let headers =
+          H1.Headers.of_list
+            (date_header
+            :: ("content-length", string_of_int (String.length body))
+            :: response.headers)
+        in
+        let resp = H1.Response.create ~headers response.status in
+        H1.Reqd.respond_with_string reqd resp body
+    | Response.Bigstring body ->
+        let headers =
+          H1.Headers.of_list
+            (date_header
+            :: ("content-length", string_of_int (Bigstringaf.length body))
+            :: response.headers)
+        in
+        let resp = H1.Response.create ~headers response.status in
+        H1.Reqd.respond_with_bigstring reqd resp body
+    | Response.Cstruct cs ->
+        let len = Cstruct.length cs in
+        let headers =
+          H1.Headers.of_list
+            (date_header
+            :: ("content-length", string_of_int len)
+            :: response.headers)
+        in
+        let resp = H1.Response.create ~headers response.status in
+        let body_writer = H1.Reqd.respond_with_streaming reqd resp in
+        H1.Body.Writer.write_bigstring body_writer ~off:cs.off ~len cs.buffer;
+        H1.Body.Writer.close body_writer
+    | Response.Stream { content_length; next } ->
+        let headers =
+          match content_length with
+          | Some len ->
+              H1.Headers.of_list
+                (date_header
+                :: ("content-length", Int64.to_string len)
+                :: response.headers)
+          | None ->
+              H1.Headers.of_list
+                (date_header
+                :: ("transfer-encoding", "chunked")
+                :: response.headers)
+        in
+        let resp = H1.Response.create ~headers response.status in
+        let body_writer = H1.Reqd.respond_with_streaming reqd resp in
+        let rec write_chunks () =
+          match next () with
+          | None -> H1.Body.Writer.close body_writer
+          | Some cs ->
+              H1.Body.Writer.write_bigstring body_writer ~off:0
+                ~len:(Cstruct.length cs) (Cstruct.to_bigarray cs);
+              H1.Body.Writer.flush body_writer (fun () -> ());
+              write_chunks ()
+        in
+        write_chunks ()
+
+  let send_error_response reqd status body_str =
+    let headers =
+      H1.Headers.of_list
+        [
+          ("date", Date_cache.get ());
+          ("content-length", string_of_int (String.length body_str));
+        ]
+    in
+    let resp = H1.Response.create ~headers status in
+    H1.Reqd.respond_with_string reqd resp body_str
+
+  let handle_request ~handler reqd req body =
+    let request =
+      {
+        meth = req.H1.Request.meth;
+        target = req.target;
+        headers = h1_headers_to_list req.headers;
+        body;
+        version = HTTP_1_1;
+      }
+    in
+    let response = handler request in
+    send_response reqd response
+
   let handle ~handler ~ws_handler ?(ws_config = default_ws_config)
       ?max_body_size ~initial_data flow =
     let buffer_size = 16384 in
···
       let req = H1.Reqd.request reqd in
       let h1_body = H1.Reqd.request_body reqd in
 
-      (* Check for WebSocket upgrade *)
       if Option.is_some ws_handler && Websocket.is_upgrade_request req.headers
       then begin
         match
···
         with
         | Error reason ->
             H1.Body.Reader.close h1_body;
-            let body = "Forbidden: " ^ reason in
-            let headers =
-              H1.Headers.of_list
-                [
-                  ("date", Date_cache.get ());
-                  ("content-length", string_of_int (String.length body));
-                ]
-            in
-            let resp = H1.Response.create ~headers `Forbidden in
-            H1.Reqd.respond_with_string reqd resp body
+            send_error_response reqd `Forbidden ("Forbidden: " ^ reason)
         | Ok () -> (
             match Websocket.validate_websocket_version req.headers with
             | Error _reason ->
                 H1.Body.Reader.close h1_body;
-                let body = "Upgrade Required" in
                 let headers =
                   H1.Headers.of_list
                     [
                       ("date", Date_cache.get ());
-                      ("content-length", string_of_int (String.length body));
+                      ("content-length", "16");
                       ( "sec-websocket-version",
                         Websocket.supported_websocket_version );
                     ]
                 in
                 let resp = H1.Response.create ~headers (`Code 426) in
-                H1.Reqd.respond_with_string reqd resp body
+                H1.Reqd.respond_with_string reqd resp "Upgrade Required"
             | Ok () -> (
                 match Websocket.get_websocket_key req.headers with
                 | Some key ->
···
                     H1.Reqd.respond_with_upgrade reqd headers
                 | None ->
                     H1.Body.Reader.close h1_body;
-                    let headers =
-                      H1.Headers.of_list
-                        [
-                          ("date", Date_cache.get ()); ("content-length", "11");
-                        ]
-                    in
-                    let resp = H1.Response.create ~headers `Bad_request in
-                    H1.Reqd.respond_with_string reqd resp "Bad Request"))
+                    send_error_response reqd `Bad_request "Bad Request"))
       end
       else begin
-        (* Regular HTTP/1.1 request *)
-        (* Read body for POST/PUT, skip for GET/HEAD *)
-        let body_result =
-          match req.meth with
-          | `GET | `HEAD | `DELETE | `OPTIONS | `CONNECT | `TRACE ->
-              H1.Body.Reader.close h1_body;
-              Ok ""
-          | `POST | `PUT | `Other _ ->
-              let body_buffer = Buffer.create 4096 in
-              let body_size = ref 0 in
-              let too_large = ref false in
-              let body_done, resolver = Eio.Promise.create () in
-              let rec read_body () =
-                H1.Body.Reader.schedule_read h1_body
-                  ~on_eof:(fun () -> Eio.Promise.resolve resolver ())
-                  ~on_read:(fun buf ~off ~len ->
-                    let new_size = !body_size + len in
-                    match max_body_size with
-                    | Some max when Int64.of_int new_size > max ->
-                        too_large := true;
-                        H1.Body.Reader.close h1_body;
-                        Eio.Promise.resolve resolver ()
-                    | _ ->
-                        body_size := new_size;
-                        Buffer.add_string body_buffer
-                          (Bigstringaf.substring buf ~off ~len);
-                        read_body ())
-              in
-              read_body ();
-              Eio.Promise.await body_done;
-              if !too_large then Error `Body_too_large
-              else Ok (Buffer.contents body_buffer)
-        in
-        match body_result with
-        | Error `Body_too_large ->
-            let body = "Request body too large" in
-            let headers =
-              H1.Headers.of_list
-                [
-                  ("date", Date_cache.get ());
-                  ("content-length", string_of_int (String.length body));
-                ]
-            in
-            let resp = H1.Response.create ~headers (`Code 413) in
-            H1.Reqd.respond_with_string reqd resp body
-        | Ok body -> (
-            let request =
-              {
-                meth = req.meth;
-                target = req.target;
-                headers = h1_headers_to_list req.headers;
-                body;
-                version = HTTP_1_1;
-              }
+        match req.meth with
+        | `GET | `HEAD | `DELETE | `OPTIONS | `CONNECT | `TRACE ->
+            H1.Body.Reader.close h1_body;
+            handle_request ~handler reqd req ""
+        | `POST | `PUT | `Other _ ->
+            let body_buffer = Buffer.create 4096 in
+            let body_size = ref 0 in
+            let rec read_body () =
+              H1.Body.Reader.schedule_read h1_body
+                ~on_eof:(fun () ->
+                  let body = Buffer.contents body_buffer in
+                  handle_request ~handler reqd req body)
+                ~on_read:(fun buf ~off ~len ->
+                  let new_size = !body_size + len in
+                  match max_body_size with
+                  | Some max when Int64.of_int new_size > max ->
+                      H1.Body.Reader.close h1_body;
+                      send_error_response reqd (`Code 413)
+                        "Request body too large"
+                  | _ ->
+                      body_size := new_size;
+                      Buffer.add_string body_buffer
+                        (Bigstringaf.substring buf ~off ~len);
+                      read_body ())
             in
-            let response : Response.t = handler request in
-
-            let date_header = ("date", Date_cache.get ()) in
-            match response.Response.body with
-            | Response.Prebuilt_body prebuilt ->
-                Prebuilt.respond_h1 reqd prebuilt
-            | Response.Empty ->
-                let headers =
-                  H1.Headers.of_list
-                    (date_header :: ("content-length", "0") :: response.headers)
-                in
-                let resp = H1.Response.create ~headers response.status in
-                H1.Reqd.respond_with_string reqd resp ""
-            | Response.String body ->
-                let headers =
-                  H1.Headers.of_list
-                    (date_header
-                    :: ("content-length", string_of_int (String.length body))
-                    :: response.headers)
-                in
-                let resp = H1.Response.create ~headers response.status in
-                H1.Reqd.respond_with_string reqd resp body
-            | Response.Bigstring body ->
-                let headers =
-                  H1.Headers.of_list
-                    (date_header
-                    :: ( "content-length",
-                         string_of_int (Bigstringaf.length body) )
-                    :: response.headers)
-                in
-                let resp = H1.Response.create ~headers response.status in
-                H1.Reqd.respond_with_bigstring reqd resp body
-            | Response.Cstruct cs ->
-                let len = Cstruct.length cs in
-                let headers =
-                  H1.Headers.of_list
-                    (date_header
-                    :: ("content-length", string_of_int len)
-                    :: response.headers)
-                in
-                let resp = H1.Response.create ~headers response.status in
-                let body_writer = H1.Reqd.respond_with_streaming reqd resp in
-                H1.Body.Writer.write_bigstring body_writer ~off:cs.off ~len
-                  cs.buffer;
-                H1.Body.Writer.close body_writer
-            | Response.Stream { content_length; next } ->
-                let headers =
-                  match content_length with
-                  | Some len ->
-                      H1.Headers.of_list
-                        (date_header
-                        :: ("content-length", Int64.to_string len)
-                        :: response.headers)
-                  | None ->
-                      H1.Headers.of_list
-                        (date_header
-                        :: ("transfer-encoding", "chunked")
-                        :: response.headers)
-                in
-                let resp = H1.Response.create ~headers response.status in
-                let body_writer = H1.Reqd.respond_with_streaming reqd resp in
-                let rec write_chunks () =
-                  match next () with
-                  | None -> H1.Body.Writer.close body_writer
-                  | Some cs ->
-                      H1.Body.Writer.write_bigstring body_writer ~off:0
-                        ~len:(Cstruct.length cs) (Cstruct.to_bigarray cs);
-                      (* Flush to ensure data is sent immediately (required for SSE) *)
-                      let flushed, resolve = Eio.Promise.create () in
-                      H1.Body.Writer.flush body_writer (fun () ->
-                          Eio.Promise.resolve resolve ());
-                      Eio.Promise.await flushed;
-                      write_chunks ()
-                in
-                write_chunks ())
+            read_body ()
       end
     in
 
···
         | None -> ())
     | None -> ()
 
-  (** Direct H1 handler - no protocol detection, no initial data buffering *)
   let handle_direct ?max_body_size ~handler flow =
     let buffer_size = 16384 in
     let read_buffer = Bigstringaf.create buffer_size in
···
       let req = H1.Reqd.request reqd in
       let h1_body = H1.Reqd.request_body reqd in
 
-      (* Read body for POST/PUT, skip for GET/HEAD *)
-      let body_result =
-        match req.meth with
-        | `GET | `HEAD | `DELETE | `OPTIONS | `CONNECT | `TRACE ->
-            H1.Body.Reader.close h1_body;
-            Ok ""
-        | `POST | `PUT | `Other _ ->
-            let body_buffer = Buffer.create 4096 in
-            let body_size = ref 0 in
-            let too_large = ref false in
-            let body_done, resolver = Eio.Promise.create () in
-            let rec read_body () =
-              H1.Body.Reader.schedule_read h1_body
-                ~on_eof:(fun () -> Eio.Promise.resolve resolver ())
-                ~on_read:(fun buf ~off ~len ->
-                  let new_size = !body_size + len in
-                  match max_body_size with
-                  | Some max when Int64.of_int new_size > max ->
-                      too_large := true;
-                      H1.Body.Reader.close h1_body;
-                      Eio.Promise.resolve resolver ()
-                  | _ ->
-                      body_size := new_size;
-                      Buffer.add_string body_buffer
-                        (Bigstringaf.substring buf ~off ~len);
-                      read_body ())
-            in
-            read_body ();
-            Eio.Promise.await body_done;
-            if !too_large then Error `Body_too_large
-            else Ok (Buffer.contents body_buffer)
-      in
-      match body_result with
-      | Error `Body_too_large ->
-          let body = "Request body too large" in
-          let headers =
-            H1.Headers.of_list
-              [
-                ("date", Date_cache.get ());
-                ("content-length", string_of_int (String.length body));
-              ]
-          in
-          let resp = H1.Response.create ~headers (`Code 413) in
-          H1.Reqd.respond_with_string reqd resp body
-      | Ok body -> (
-          let request =
-            {
-              meth = req.meth;
-              target = req.target;
-              headers = h1_headers_to_list req.headers;
-              body;
-              version = HTTP_1_1;
-            }
+      match req.meth with
+      | `GET | `HEAD | `DELETE | `OPTIONS | `CONNECT | `TRACE ->
+          H1.Body.Reader.close h1_body;
+          handle_request ~handler reqd req ""
+      | `POST | `PUT | `Other _ ->
+          let body_buffer = Buffer.create 4096 in
+          let body_size = ref 0 in
+          let rec read_body () =
+            H1.Body.Reader.schedule_read h1_body
+              ~on_eof:(fun () ->
+                let body = Buffer.contents body_buffer in
+                handle_request ~handler reqd req body)
+              ~on_read:(fun buf ~off ~len ->
+                let new_size = !body_size + len in
+                match max_body_size with
+                | Some max when Int64.of_int new_size > max ->
+                    H1.Body.Reader.close h1_body;
+                    send_error_response reqd (`Code 413)
+                      "Request body too large"
+                | _ ->
+                    body_size := new_size;
+                    Buffer.add_string body_buffer
+                      (Bigstringaf.substring buf ~off ~len);
+                    read_body ())
           in
-          let response : Response.t = handler request in
-
-          let date_header = ("date", Date_cache.get ()) in
-          match response.Response.body with
-          | Response.Prebuilt_body prebuilt -> Prebuilt.respond_h1 reqd prebuilt
-          | Response.Empty ->
-              let headers =
-                H1.Headers.of_list
-                  (date_header :: ("content-length", "0") :: response.headers)
-              in
-              let resp = H1.Response.create ~headers response.status in
-              H1.Reqd.respond_with_string reqd resp ""
-          | Response.String body ->
-              let headers =
-                H1.Headers.of_list
-                  (date_header
-                  :: ("content-length", string_of_int (String.length body))
-                  :: response.headers)
-              in
-              let resp = H1.Response.create ~headers response.status in
-              H1.Reqd.respond_with_string reqd resp body
-          | Response.Bigstring body ->
-              let headers =
-                H1.Headers.of_list
-                  (date_header
-                  :: ("content-length", string_of_int (Bigstringaf.length body))
-                  :: response.headers)
-              in
-              let resp = H1.Response.create ~headers response.status in
-              H1.Reqd.respond_with_bigstring reqd resp body
-          | Response.Cstruct cs ->
-              let len = Cstruct.length cs in
-              let headers =
-                H1.Headers.of_list
-                  (date_header
-                  :: ("content-length", string_of_int len)
-                  :: response.headers)
-              in
-              let resp = H1.Response.create ~headers response.status in
-              let body_writer = H1.Reqd.respond_with_streaming reqd resp in
-              H1.Body.Writer.write_bigstring body_writer ~off:cs.off ~len
-                cs.buffer;
-              H1.Body.Writer.close body_writer
-          | Response.Stream { content_length; next } ->
-              let headers =
-                match content_length with
-                | Some len ->
-                    H1.Headers.of_list
-                      (date_header
-                      :: ("content-length", Int64.to_string len)
-                      :: response.headers)
-                | None ->
-                    H1.Headers.of_list
-                      (date_header
-                      :: ("transfer-encoding", "chunked")
-                      :: response.headers)
-              in
-              let resp = H1.Response.create ~headers response.status in
-              let body_writer = H1.Reqd.respond_with_streaming reqd resp in
-              let rec write_chunks () =
-                match next () with
-                | None -> H1.Body.Writer.close body_writer
-                | Some cs ->
-                    H1.Body.Writer.write_bigstring body_writer ~off:cs.off
-                      ~len:(Cstruct.length cs) cs.buffer;
-                    let flushed, resolve = Eio.Promise.create () in
-                    H1.Body.Writer.flush body_writer (fun () ->
-                        Eio.Promise.resolve resolve ());
-                    Eio.Promise.await flushed;
-                    write_chunks ()
-              in
-              write_chunks ())
+          read_body ()
     in
 
     let error_handler ?request:_ _error start_response =
···
 end
 
 module H2_handler = struct
+  let send_h2_response reqd (response : Response.t) =
+    let h2_status = (response.Response.status :> H2.Status.t) in
+    match response.Response.body with
+    | Response.Prebuilt_body prebuilt -> Prebuilt.respond_h2 reqd prebuilt
+    | Response.Empty ->
+        let headers =
+          H2.Headers.of_list (("content-length", "0") :: response.headers)
+        in
+        let resp = H2.Response.create ~headers h2_status in
+        H2.Reqd.respond_with_string reqd resp ""
+    | Response.String body ->
+        let headers =
+          H2.Headers.of_list
+            (("content-length", string_of_int (String.length body))
+            :: response.headers)
+        in
+        let resp = H2.Response.create ~headers h2_status in
+        H2.Reqd.respond_with_string reqd resp body
+    | Response.Bigstring body ->
+        let headers =
+          H2.Headers.of_list
+            (("content-length", string_of_int (Bigstringaf.length body))
+            :: response.headers)
+        in
+        let resp = H2.Response.create ~headers h2_status in
+        H2.Reqd.respond_with_bigstring reqd resp body
+    | Response.Cstruct cs ->
+        let len = Cstruct.length cs in
+        let headers =
+          H2.Headers.of_list
+            (("content-length", string_of_int len) :: response.headers)
+        in
+        let resp = H2.Response.create ~headers h2_status in
+        let body_writer = H2.Reqd.respond_with_streaming reqd resp in
+        H2.Body.Writer.write_bigstring body_writer ~off:cs.off ~len cs.buffer;
+        H2.Body.Writer.close body_writer
+    | Response.Stream { content_length; next } ->
+        let headers =
+          match content_length with
+          | Some len ->
+              H2.Headers.of_list
+                (("content-length", Int64.to_string len) :: response.headers)
+          | None -> H2.Headers.of_list response.headers
+        in
+        let resp = H2.Response.create ~headers h2_status in
+        let body_writer = H2.Reqd.respond_with_streaming reqd resp in
+        let rec write_chunks () =
+          match next () with
+          | None -> H2.Body.Writer.close body_writer
+          | Some cs ->
+              H2.Body.Writer.write_bigstring body_writer ~off:cs.off
+                ~len:(Cstruct.length cs) cs.buffer;
+              H2.Body.Writer.flush body_writer (fun _result -> ());
+              write_chunks ()
+        in
+        write_chunks ()
+
+  let handle_h2_request ~handler reqd req body =
+    let target =
+      match H2.Headers.get req.H2.Request.headers ":path" with
+      | Some p -> p
+      | None -> "/"
+    in
+    let request =
+      {
+        meth = req.meth;
+        target;
+        headers = h2_headers_to_list req.headers;
+        body;
+        version = HTTP_2;
+      }
+    in
+    let response = handler request in
+    send_h2_response reqd response
+
   let handle ~handler ~initial_data flow =
     let read_buffer_size = 0x4000 in
     let read_buffer = Bigstringaf.create read_buffer_size in
···
       let req = H2.Reqd.request reqd in
       let body_reader = H2.Reqd.request_body reqd in
 
-      let body =
-        match req.meth with
-        | `GET | `HEAD ->
-            H2.Body.Reader.close body_reader;
-            ""
-        | _ ->
-            let body_buffer = Buffer.create 4096 in
-            let body_done, resolver = Eio.Promise.create () in
-            let rec read_body () =
-              H2.Body.Reader.schedule_read body_reader
-                ~on_eof:(fun () -> Eio.Promise.resolve resolver ())
-                ~on_read:(fun buf ~off ~len ->
-                  Buffer.add_string body_buffer
-                    (Bigstringaf.substring buf ~off ~len);
-                  read_body ())
-            in
-            read_body ();
-            Eio.Promise.await body_done;
-            Buffer.contents body_buffer
-      in
-
-      let target =
-        match H2.Headers.get req.headers ":path" with
-        | Some p -> p
-        | None -> "/"
-      in
-
-      let request =
-        {
-          meth = req.meth;
-          target;
-          headers = h2_headers_to_list req.headers;
-          body;
-          version = HTTP_2;
-        }
-      in
-      let response : Response.t = handler request in
-
-      let h2_status = (response.Response.status :> H2.Status.t) in
-
-      match response.Response.body with
-      | Response.Prebuilt_body prebuilt -> Prebuilt.respond_h2 reqd prebuilt
-      | Response.Empty ->
-          let headers =
-            H2.Headers.of_list (("content-length", "0") :: response.headers)
-          in
-          let resp = H2.Response.create ~headers h2_status in
-          H2.Reqd.respond_with_string reqd resp ""
-      | Response.String body ->
-          let headers =
-            H2.Headers.of_list
-              (("content-length", string_of_int (String.length body))
-              :: response.headers)
+      match req.meth with
+      | `GET | `HEAD ->
+          H2.Body.Reader.close body_reader;
+          handle_h2_request ~handler reqd req ""
+      | _ ->
+          let body_buffer = Buffer.create 4096 in
+          let rec read_body () =
+            H2.Body.Reader.schedule_read body_reader
+              ~on_eof:(fun () ->
+                let body = Buffer.contents body_buffer in
+                handle_h2_request ~handler reqd req body)
+              ~on_read:(fun buf ~off ~len ->
+                Buffer.add_string body_buffer
+                  (Bigstringaf.substring buf ~off ~len);
+                read_body ())
           in
-          let resp = H2.Response.create ~headers h2_status in
-          H2.Reqd.respond_with_string reqd resp body
-      | Response.Bigstring body ->
-          let headers =
-            H2.Headers.of_list
-              (("content-length", string_of_int (Bigstringaf.length body))
-              :: response.headers)
-          in
-          let resp = H2.Response.create ~headers h2_status in
-          H2.Reqd.respond_with_bigstring reqd resp body
-      | Response.Cstruct cs ->
-          let len = Cstruct.length cs in
-          let headers =
-            H2.Headers.of_list
-              (("content-length", string_of_int len) :: response.headers)
-          in
-          let resp = H2.Response.create ~headers h2_status in
-          let body_writer = H2.Reqd.respond_with_streaming reqd resp in
-          H2.Body.Writer.write_bigstring body_writer ~off:cs.off ~len cs.buffer;
-          H2.Body.Writer.close body_writer
-      | Response.Stream { content_length; next } ->
-          let headers =
-            match content_length with
-            | Some len ->
-                H2.Headers.of_list
-                  (("content-length", Int64.to_string len) :: response.headers)
-            | None -> H2.Headers.of_list response.headers
-          in
-          let resp = H2.Response.create ~headers h2_status in
-          let body_writer = H2.Reqd.respond_with_streaming reqd resp in
-          let rec write_chunks () =
-            match next () with
-            | None -> H2.Body.Writer.close body_writer
-            | Some cs ->
-                H2.Body.Writer.write_bigstring body_writer ~off:cs.off
-                  ~len:(Cstruct.length cs) cs.buffer;
-                let flushed, resolve = Eio.Promise.create () in
-                H2.Body.Writer.flush body_writer (fun _result ->
-                    Eio.Promise.resolve resolve ());
-                Eio.Promise.await flushed;
-                write_chunks ()
-          in
-          write_chunks ()
+          read_body ()
     in
 
     let error_handler ?request:_ _error start_response =
···
     let shutdown = ref false in
 
     let read_loop () =
+      let buf_off = ref 0 in
+      let buf_len = ref 0 in
+
+      let compress () =
+        if !buf_len > 0 && !buf_off > 0 then begin
+          Bigstringaf.blit read_buffer ~src_off:!buf_off read_buffer ~dst_off:0
+            ~len:!buf_len;
+          buf_off := 0
+        end
+        else if !buf_len = 0 then buf_off := 0
+      in
+
       let rec loop () =
         if not !shutdown then
           match H2.Server_connection.next_read_operation conn with
           | `Read ->
-              let cs =
-                Cstruct.of_bigarray read_buffer ~off:0 ~len:read_buffer_size
-              in
-              let socket_data =
-                try
-                  let n = Eio.Flow.single_read flow cs in
-                  Cstruct.to_string (Cstruct.sub cs 0 n)
-                with End_of_file -> ""
-              in
-              let data =
-                if String.length !pending_data > 0 then begin
-                  let combined = !pending_data ^ socket_data in
-                  pending_data := "";
-                  combined
-                end
-                else socket_data
-              in
-              let len = String.length data in
-              if len = 0 then begin
-                let _ =
-                  H2.Server_connection.read_eof conn read_buffer ~off:0 ~len:0
+              compress ();
+              let available = read_buffer_size - !buf_off - !buf_len in
+              if available > 0 then begin
+                let cs =
+                  Cstruct.of_bigarray read_buffer ~off:(!buf_off + !buf_len)
+                    ~len:available
                 in
-                shutdown := true
-              end
-              else begin
-                Bigstringaf.blit_from_string data ~src_off:0 read_buffer
-                  ~dst_off:0 ~len;
-                let _ =
-                  H2.Server_connection.read conn read_buffer ~off:0 ~len
+                let n =
+                  try Eio.Flow.single_read flow cs with End_of_file -> 0
                 in
-                loop ()
+                if n = 0 then begin
+                  let _ =
+                    H2.Server_connection.read_eof conn read_buffer ~off:!buf_off
+                      ~len:!buf_len
+                  in
+                  shutdown := true
+                end
+                else begin
+                  buf_len := !buf_len + n;
+                  let consumed =
+                    H2.Server_connection.read conn read_buffer ~off:!buf_off
+                      ~len:!buf_len
+                  in
+                  buf_off := !buf_off + consumed;
+                  buf_len := !buf_len - consumed;
+                  loop ()
+                end
               end
+              else loop ()
           | `Close -> shutdown := true
+          | `Yield ->
+              let continue = Eio.Promise.create () in
+              H2.Server_connection.yield_reader conn (fun () ->
+                  Eio.Promise.resolve (snd continue) ());
+              Eio.Promise.await (fst continue);
+              loop ()
       in
+
+      if String.length !pending_data > 0 then begin
+        let len = String.length !pending_data in
+        Bigstringaf.blit_from_string !pending_data ~src_off:0 read_buffer
+          ~dst_off:0 ~len;
+        buf_len := len;
+        pending_data := "";
+        let consumed = H2.Server_connection.read conn read_buffer ~off:0 ~len in
+        buf_off := consumed;
+        buf_len := len - consumed
+      end;
       loop ()
     in
 
···
                       ~len:iov.H2.IOVec.len iov.H2.IOVec.buffer)
                   iovecs
               in
-              Eio.Flow.write flow cstructs;
               let len =
                 List.fold_left (fun acc iov -> acc + iov.H2.IOVec.len) 0 iovecs
               in
+              Eio.Flow.write flow cstructs;
               H2.Server_connection.report_write_result conn (`Ok len);
               loop ()
           | `Yield ->

test/dune

···
  (name test_websocket)
  (libraries hcs eio_main)
  (modules test_websocket))
+
+(executable
+ (name test_large_body)
+ (libraries hcs eio_main)
+ (modules test_large_body))

test/test_large_body.ml

···
+(** Large Body Test Suite - Regression tests for multi-megabyte handling. Tests
+    HTTP/1.1, HTTP/2 (h2c), and WebSocket with large payloads. *)
+
+let generate_payload size = String.make size 'X'
+
+let generate_pattern_payload size =
+  let buf = Buffer.create size in
+  for i = 0 to size - 1 do
+    Buffer.add_char buf (Char.chr (i mod 256))
+  done;
+  Buffer.contents buf
+
+let error_to_string = function
+  | Hcs.Client.Connection_failed s -> "Connection_failed: " ^ s
+  | Hcs.Client.Tls_error s -> "Tls_error: " ^ s
+  | Hcs.Client.Protocol_error s -> "Protocol_error: " ^ s
+  | Hcs.Client.Timeout -> "Timeout"
+  | Hcs.Client.Invalid_response s -> "Invalid_response: " ^ s
+  | Hcs.Client.Too_many_redirects -> "Too_many_redirects"
+
+let ws_error_to_string = function
+  | Hcs.Websocket.Connection_closed -> "Connection_closed"
+  | Hcs.Websocket.Protocol_error s -> "Protocol_error: " ^ s
+  | Hcs.Websocket.Io_error s -> "Io_error: " ^ s
+  | Hcs.Websocket.Payload_too_large n -> "Payload_too_large: " ^ string_of_int n
+
+module H1_tests = struct
+  let test_post_size ~sw ~net ~clock ~port ~size_kb () =
+    let payload_size = size_kb * 1024 in
+    let payload = generate_payload payload_size in
+    let config =
+      Hcs.Client.
+        { default_config with read_timeout = 60.0; connect_timeout = 5.0 }
+    in
+    let url = Printf.sprintf "http://127.0.0.1:%d/upload" port in
+    Printf.printf "    %6dKB... %!" size_kb;
+    match Hcs.Client.post ~sw ~net ~clock ~config url ~body:payload with
+    | Ok resp ->
+        if resp.status <> 200 then begin
+          Printf.printf "FAIL (status %d)\n%!" resp.status;
+          false
+        end
+        else begin
+          let received =
+            try
+              int_of_string
+                (String.sub resp.body 9 (String.length resp.body - 9))
+            with _ -> -1
+          in
+          if received <> payload_size then begin
+            Printf.printf "FAIL (sent %d, got %d)\n%!" payload_size received;
+            false
+          end
+          else begin
+            Printf.printf "OK\n%!";
+            true
+          end
+        end
+    | Error e ->
+        Printf.printf "FAIL (%s)\n%!" (error_to_string e);
+        false
+
+  let test_integrity ~sw ~net ~clock ~port ~size_kb () =
+    let payload_size = size_kb * 1024 in
+    let payload = generate_pattern_payload payload_size in
+    let config =
+      Hcs.Client.
+        { default_config with read_timeout = 60.0; connect_timeout = 5.0 }
+    in
+    let url = Printf.sprintf "http://127.0.0.1:%d/integrity" port in
+    Printf.printf "    %6dKB integrity... %!" size_kb;
+    match Hcs.Client.post ~sw ~net ~clock ~config url ~body:payload with
+    | Ok resp ->
+        if resp.status = 200 && resp.body = "ok" then begin
+          Printf.printf "OK\n%!";
+          true
+        end
+        else begin
+          Printf.printf "FAIL (%s)\n%!" resp.body;
+          false
+        end
+    | Error e ->
+        Printf.printf "FAIL (%s)\n%!" (error_to_string e);
+        false
+
+  let test_max_body_size ~sw ~net ~clock () =
+    let port = 18301 in
+    let max_size = 1024L in
+    let payload = generate_payload 2048 in
+    let handler_called = ref false in
+    let handler (_req : Hcs.Server.request) =
+      handler_called := true;
+      Hcs.Server.respond "should not reach"
+    in
+    let config =
+      Hcs.Server.
+        {
+          default_config with
+          port;
+          max_body_size = Some max_size;
+          gc_tuning = None;
+        }
+    in
+    Eio.Fiber.fork_daemon ~sw (fun[@warning "-21"] () ->
+        Hcs.Server.run ~sw ~net ~config handler;
+        `Stop_daemon);
+    Eio.Time.sleep clock 0.1;
+    Printf.printf "    max_body_size (1KB limit)... %!";
+    let url = Printf.sprintf "http://127.0.0.1:%d/upload" port in
+    match Hcs.Client.post ~sw ~net ~clock url ~body:payload with
+    | Ok resp ->
+        if resp.status = 413 && not !handler_called then begin
+          Printf.printf "OK (413)\n%!";
+          true
+        end
+        else begin
+          Printf.printf "FAIL (status %d)\n%!" resp.status;
+          false
+        end
+    | Error e ->
+        Printf.printf "FAIL (%s)\n%!" (error_to_string e);
+        false
+
+  let run_all ~sw ~net ~clock ~port () =
+    Printf.printf "\n  POST sizes:\n%!";
+    let sizes = [ 1; 16; 32; 64; 128; 256; 512; 1024; 2048; 5120 ] in
+    let size_results =
+      List.map
+        (fun kb -> test_post_size ~sw ~net ~clock ~port ~size_kb:kb ())
+        sizes
+    in
+    Printf.printf "\n  Data integrity:\n%!";
+    let integrity_results =
+      List.map
+        (fun kb -> test_integrity ~sw ~net ~clock ~port ~size_kb:kb ())
+        [ 64; 256; 1024 ]
+    in
+    Printf.printf "\n  Limits:\n%!";
+    let max_body_ok = test_max_body_size ~sw ~net ~clock () in
+    List.for_all Fun.id size_results
+    && List.for_all Fun.id integrity_results
+    && max_body_ok
+end
+
+module H2_tests = struct
+  let test_post_size ~sw ~net ~clock ~port ~size_kb () =
+    let payload_size = size_kb * 1024 in
+    let payload = generate_payload payload_size in
+    let config =
+      Hcs.Client.
+        {
+          default_config with
+          read_timeout = 60.0;
+          connect_timeout = 5.0;
+          preferred_protocol = Some HTTP_2;
+        }
+    in
+    let url = Printf.sprintf "http://127.0.0.1:%d/upload" port in
+    Printf.printf "    %6dKB... %!" size_kb;
+    match Hcs.Client.post ~sw ~net ~clock ~config url ~body:payload with
+    | Ok resp ->
+        if resp.status <> 200 then begin
+          Printf.printf "FAIL (status %d)\n%!" resp.status;
+          false
+        end
+        else begin
+          let received =
+            try
+              int_of_string
+                (String.sub resp.body 9 (String.length resp.body - 9))
+            with _ -> -1
+          in
+          if received <> payload_size then begin
+            Printf.printf "FAIL (sent %d, got %d)\n%!" payload_size received;
+            false
+          end
+          else begin
+            Printf.printf "OK\n%!";
+            true
+          end
+        end
+    | Error e ->
+        Printf.printf "FAIL (%s)\n%!" (error_to_string e);
+        false
+
+  let test_integrity ~sw ~net ~clock ~port ~size_kb () =
+    let payload_size = size_kb * 1024 in
+    let payload = generate_pattern_payload payload_size in
+    let config =
+      Hcs.Client.
+        {
+          default_config with
+          read_timeout = 60.0;
+          connect_timeout = 5.0;
+          preferred_protocol = Some HTTP_2;
+        }
+    in
+    let url = Printf.sprintf "http://127.0.0.1:%d/integrity" port in
+    Printf.printf "    %6dKB integrity... %!" size_kb;
+    match Hcs.Client.post ~sw ~net ~clock ~config url ~body:payload with
+    | Ok resp ->
+        if resp.status = 200 && resp.body = "ok" then begin
+          Printf.printf "OK\n%!";
+          true
+        end
+        else begin
+          Printf.printf "FAIL (%s)\n%!" resp.body;
+          false
+        end
+    | Error e ->
+        Printf.printf "FAIL (%s)\n%!" (error_to_string e);
+        false
+
+  let run_all ~sw ~net ~clock ~port () =
+    Printf.printf "\n  POST sizes (h2c):\n%!";
+    let sizes = [ 1; 16; 32; 64; 128; 256; 512; 1024; 2048; 5120 ] in
+    let size_results =
+      List.map
+        (fun kb -> test_post_size ~sw ~net ~clock ~port ~size_kb:kb ())
+        sizes
+    in
+    Printf.printf "\n  Data integrity (h2c):\n%!";
+    let integrity_sizes = [ 64; 256; 1024 ] in
+    let integrity_results =
+      List.map
+        (fun kb -> test_integrity ~sw ~net ~clock ~port ~size_kb:kb ())
+        integrity_sizes
+    in
+    List.for_all Fun.id size_results && List.for_all Fun.id integrity_results
+end
+
+module Websocket_tests = struct
+  let test_large_message ~sw ~net ~port ~size_kb () =
+    let payload_size = size_kb * 1024 in
+    let payload = generate_payload payload_size in
+    Printf.printf "    %6dKB message... %!" size_kb;
+    let url = Printf.sprintf "ws://127.0.0.1:%d/" port in
+    match Hcs.Websocket.connect ~sw ~net url with
+    | Ok ws -> (
+        match Hcs.Websocket.send_text ws payload with
+        | Ok () -> (
+            match Hcs.Websocket.recv_message ws with
+            | Ok (_, msg) ->
+                Hcs.Websocket.close ws;
+                let expected =
+                  "echo:" ^ string_of_int (String.length payload)
+                in
+                if msg = expected then begin
+                  Printf.printf "OK\n%!";
+                  true
+                end
+                else begin
+                  Printf.printf "FAIL (got '%s')\n%!"
+                    (String.sub msg 0 (min 50 (String.length msg)));
+                  false
+                end
+            | Error e ->
+                Hcs.Websocket.close ws;
+                Printf.printf "FAIL recv (%s)\n%!" (ws_error_to_string e);
+                false)
+        | Error e ->
+            Hcs.Websocket.close ws;
+            Printf.printf "FAIL send (%s)\n%!" (ws_error_to_string e);
+            false)
+    | Error e ->
+        Printf.printf "FAIL connect (%s)\n%!" (ws_error_to_string e);
+        false
+
+  let test_integrity ~sw ~net ~port ~size_kb () =
+    let payload_size = size_kb * 1024 in
+    let payload = generate_pattern_payload payload_size in
+    Printf.printf "    %6dKB integrity... %!" size_kb;
+    let url = Printf.sprintf "ws://127.0.0.1:%d/" port in
+    match Hcs.Websocket.connect ~sw ~net url with
+    | Ok ws -> (
+        match Hcs.Websocket.send_binary ws payload with
+        | Ok () -> (
+            match Hcs.Websocket.recv_message ws with
+            | Ok (_, msg) ->
+                Hcs.Websocket.close ws;
+                if msg = "integrity:ok" then begin
+                  Printf.printf "OK\n%!";
+                  true
+                end
+                else begin
+                  Printf.printf "FAIL (%s)\n%!" msg;
+                  false
+                end
+            | Error e ->
+                Hcs.Websocket.close ws;
+                Printf.printf "FAIL recv (%s)\n%!" (ws_error_to_string e);
+                false)
+        | Error e ->
+            Hcs.Websocket.close ws;
+            Printf.printf "FAIL send (%s)\n%!" (ws_error_to_string e);
+            false)
+    | Error e ->
+        Printf.printf "FAIL connect (%s)\n%!" (ws_error_to_string e);
+        false
+
+  let run_all ~sw ~net ~port () =
+    Printf.printf "\n  Message sizes:\n%!";
+    let sizes = [ 1; 8; 16; 32; 64 ] in
+    let size_results =
+      List.map
+        (fun kb -> test_large_message ~sw ~net ~port ~size_kb:kb ())
+        sizes
+    in
+    Printf.printf "\n  Data integrity:\n%!";
+    let integrity_results =
+      List.map
+        (fun kb -> test_integrity ~sw ~net ~port ~size_kb:kb ())
+        [ 8; 32 ]
+    in
+    List.for_all Fun.id size_results && List.for_all Fun.id integrity_results
+end
+
+let () =
+  Eio_main.run @@ fun env ->
+  let net = Eio.Stdenv.net env in
+  let clock = Eio.Stdenv.clock env in
+
+  Printf.printf "=== Large Body Regression Tests ===\n%!";
+
+  let h1_ok =
+    Eio.Switch.run @@ fun sw ->
+    let port = 18300 in
+    let handler (req : Hcs.Server.request) =
+      let body_len = String.length req.body in
+      match req.target with
+      | "/upload" -> Hcs.Server.respond (Printf.sprintf "received:%d" body_len)
+      | "/integrity" -> (
+          let mismatch = ref None in
+          for i = 0 to body_len - 1 do
+            if !mismatch = None && Char.code req.body.[i] <> i mod 256 then
+              mismatch := Some i
+          done;
+          match !mismatch with
+          | Some i -> Hcs.Server.respond (Printf.sprintf "mismatch at %d" i)
+          | None -> Hcs.Server.respond "ok")
+      | _ -> Hcs.Server.respond ~status:`Not_found "not found"
+    in
+    let config = Hcs.Server.{ default_config with port; gc_tuning = None } in
+    Eio.Fiber.fork_daemon ~sw (fun[@warning "-21"] () ->
+        Hcs.Server.run ~sw ~net ~config handler;
+        `Stop_daemon);
+    Eio.Time.sleep clock 0.1;
+    Printf.printf "\n--- HTTP/1.1 Tests ---\n%!";
+    H1_tests.run_all ~sw ~net ~clock ~port ()
+  in
+
+  let h2_ok =
+    Eio.Switch.run @@ fun sw ->
+    let port = 18302 in
+    let handler (req : Hcs.Server.request) =
+      match req.target with
+      | "/upload" ->
+          let body_len = String.length req.body in
+          Hcs.Server.respond (Printf.sprintf "received:%d" body_len)
+      | "/integrity" -> (
+          let len = String.length req.body in
+          let mismatch = ref None in
+          for i = 0 to len - 1 do
+            if !mismatch = None && Char.code req.body.[i] <> i mod 256 then
+              mismatch := Some i
+          done;
+          match !mismatch with
+          | Some i ->
+              Hcs.Server.respond ~status:`Bad_request
+                (Printf.sprintf "mismatch at byte %d" i)
+          | None -> Hcs.Server.respond "ok")
+      | _ -> Hcs.Server.respond ~status:`Not_found "not found"
+    in
+    let config =
+      Hcs.Server.
+        { default_config with port; protocol = Http2_only; gc_tuning = None }
+    in
+    Eio.Fiber.fork_daemon ~sw (fun[@warning "-21"] () ->
+        Hcs.Server.run ~sw ~net ~config handler;
+        `Stop_daemon);
+    Eio.Time.sleep clock 0.1;
+    Printf.printf "\n--- HTTP/2 Tests ---\n%!";
+    H2_tests.run_all ~sw ~net ~clock ~port ()
+  in
+
+  let ws_ok =
+    Eio.Switch.run @@ fun sw ->
+    let port = 18303 in
+    let handler (_req : Hcs.Server.request) =
+      Hcs.Server.respond "use websocket"
+    in
+    let ws_handler ws =
+      let rec loop () =
+        match Hcs.Websocket.recv_message ws with
+        | Error Hcs.Websocket.Connection_closed -> ()
+        | Error _ -> ()
+        | Ok (opcode, msg) -> (
+            let response =
+              match opcode with
+              | Hcs.Websocket.Opcode.Text ->
+                  "echo:" ^ string_of_int (String.length msg)
+              | Hcs.Websocket.Opcode.Binary -> (
+                  let len = String.length msg in
+                  let mismatch = ref None in
+                  for i = 0 to len - 1 do
+                    if !mismatch = None && Char.code msg.[i] <> i mod 256 then
+                      mismatch := Some i
+                  done;
+                  match !mismatch with
+                  | Some i -> Printf.sprintf "integrity:mismatch at %d" i
+                  | None -> "integrity:ok")
+              | _ -> "unknown opcode"
+            in
+            match Hcs.Websocket.send_text ws response with
+            | Ok () -> loop ()
+            | Error _ -> ())
+      in
+      loop ()
+    in
+    let config =
+      Hcs.Server.
+        {
+          default_config with
+          port;
+          protocol = Auto_websocket;
+          gc_tuning = None;
+        }
+    in
+    Eio.Fiber.fork_daemon ~sw (fun[@warning "-21"] () ->
+        Hcs.Server.run ~sw ~net ~config ~ws_handler handler;
+        `Stop_daemon);
+    Eio.Time.sleep clock 0.1;
+    Printf.printf "\n--- WebSocket Tests ---\n%!";
+    Websocket_tests.run_all ~sw ~net ~port ()
+  in
+
+  Printf.printf "\n=== Summary ===\n%!";
+  Printf.printf "HTTP/1.1: %s\n%!" (if h1_ok then "PASS" else "FAIL");
+  Printf.printf "HTTP/2:   %s\n%!" (if h2_ok then "PASS" else "FAIL");
+  Printf.printf "WebSocket: %s\n%!" (if ws_ok then "PASS" else "FAIL");
+
+  if h1_ok && h2_ok && ws_ok then Printf.printf "\n*** ALL TESTS PASSED ***\n%!"
+  else begin
+    Printf.printf "\n*** SOME TESTS FAILED ***\n%!";
+    exit 1
+  end