docs: document request body handling and HTTP/2 large body support

- Add Request Body Handling section to request-lifecycle.md
- Document lazy body reading with body_reader
- Explain streaming for large bodies with read_stream()
- Document max_body_size configuration
- Note HTTP/2 flow control is automatic

- Update http2.md client documentation
- Document h2c (cleartext HTTP/2) support
- Add POST request examples
- Document large body handling with flow control
- Fix outdated 'no h2c support' note

- Update basic-requests.md
- Add section on large request body support
- Note automatic HTTP/2 flow control handling

- Add cross-reference in responses.md to body handling

docs/client/basic-requests.md

···
   ~body:{|{"name": "Bob"}|}
 ```
 
+### Large Request Bodies
+
+Both HTTP/1.1 and HTTP/2 handle large request bodies correctly. No special configuration is needed for multi-megabyte uploads:
+
+```ocaml
+(* Upload a large JSON payload *)
+let large_body = generate_report ()  (* Could be several MB *)
+match Client.request_post client url ~body:large_body with
+| Ok resp -> Printf.printf "Uploaded successfully\n"
+| Error _ -> ()
+```
+
+For HTTP/2, flow control is handled automatically—the client respects the server's flow control window and waits for `WINDOW_UPDATE` frames as needed.
+
 ## Configuration
 
 Customize client behavior with config modifiers:

docs/client/http2.md

···
 # HTTP/2 Client
 
-HCS supports HTTP/2 with automatic protocol selection via ALPN.
+HCS supports HTTP/2 over TLS (h2) and cleartext (h2c).
 
 ## Forcing HTTP/2
 
···
 
 This configures:
 - Preferred protocol set to HTTP/2
-- ALPN set to negotiate `h2`
+- ALPN set to negotiate `h2` for HTTPS connections
 
 ## Protocol Selection
 
···
 
 1. **Explicit configuration**: `with_http2` or `with_http11`
 2. **ALPN negotiation**: For HTTPS, if ALPN protocols include `h2`
-3. **Scheme**: HTTP/2 requires HTTPS (no h2c support currently)
+3. **Cleartext h2c**: For HTTP URLs with `preferred_protocol = Some HTTP_2`
 
 ```ocaml
 (* Force HTTP/1.1 *)
···
   Client.default_config
   |> Client.with_http11
 
-(* Force HTTP/2 *)
+(* Force HTTP/2 (h2 for HTTPS, h2c for HTTP) *)
 let h2_config = 
   Client.default_config
   |> Client.with_http2
···
 let auto_config = Client.default_config
 ```
 
+## HTTP/2 Cleartext (h2c)
+
+For local development or internal services, use h2c (HTTP/2 without TLS):
+
+```ocaml
+let config = 
+  { Client.default_config with 
+    preferred_protocol = Some Client.HTTP_2 }
+
+let client = Client.create ~sw ~net ~clock ~config () in
+
+(* This uses h2c *)
+match Client.request client "http://localhost:8080/api" with
+| Ok resp -> Printf.printf "Status: %d\n" resp.status
+| Error _ -> ()
+```
+
 ## Checking Protocol Used
 
 ```ocaml
···
 | Error _ -> ()
 ```
 
+## POST Requests
+
+POST requests work the same as HTTP/1.1:
+
+```ocaml
+let config = Client.default_config |> Client.with_http2 in
+let client = Client.create ~sw ~net ~clock ~config () in
+
+let body = {|{"name": "Alice", "email": "[e-mail]"}|} in
+match Client.request_post client "https://api.example.com/users" ~body with
+| Ok resp -> Printf.printf "Created: %s\n" resp.body
+| Error err -> handle_error err
+```
+
+### Large Request Bodies
+
+HTTP/2 handles large request bodies (multi-megabyte uploads) correctly. Flow control is managed automatically—the client sends data up to the flow control window, waits for `WINDOW_UPDATE` frames from the server, then continues.
+
+```ocaml
+(* Upload a large file *)
+let large_body = load_file "data.json" in  (* Could be several MB *)
+match Client.request_post client url ~body:large_body with
+| Ok resp -> Printf.printf "Uploaded %d bytes\n" (String.length large_body)
+| Error _ -> ()
+```
+
+No special configuration is needed. The default flow control window (64KB) works for any body size.
+
 ## HTTP/2 Benefits
 
 When using HTTP/2:
···
 - **Multiplexing**: Multiple requests share one connection
 - **Header compression**: HPACK reduces header overhead
 - **Binary framing**: More efficient than HTTP/1.1 text format
+- **Flow control**: Automatic back-pressure for large transfers
 
 ## Connection Reuse
 
···
 | Ok resp -> process_response resp
 ```
 
-## Streaming (Not Yet Supported)
+## Response Handling
+
+Responses are buffered in memory. For large responses, configure a size limit:
+
+```ocaml
+let config = 
+  Client.default_config
+  |> Client.with_http2
+  |> Client.with_max_response_body (Int64.of_int (50 * 1024 * 1024))  (* 50MB *)
+```
 
-Currently, responses are buffered in memory. Streaming support for HTTP/2 is planned for a future release.
+Streaming response support is planned for a future release.

docs/guides/request-lifecycle.md

···
 type request = {
   meth : H1.Method.t;           (* GET, POST, etc. *)
   target : string;              (* Path + query string *)
-  headers : (string * string) list;
-  body : string;
-  version : protocol_version;   (* HTTP_1_1 or HTTP_2 *)
+  headers : H1.Headers.t;
+  body_reader : body_reader;    (* Lazy body reader *)
 }
 ```
 
 The `target` contains the raw request target. For `/users?id=5`, the target is `/users?id=5`.
+
+## Request Body Handling
+
+Request bodies are read lazily—they're only fetched from the network when you access them. This allows efficient handling of requests where the body might not be needed.
+
+### Reading the Entire Body
+
+For most cases, read the full body as a string:
+
+```ocaml
+let handler _params req =
+  let body = Request.body req in
+  (* Process body... *)
+  Response.ok "Received"
+```
+
+Or equivalently:
+
+```ocaml
+let body = req.body_reader.read ()
+```
+
+The body is buffered in memory. For very large bodies, consider streaming.
+
+### Streaming Large Bodies
+
+For large uploads (files, bulk data), read the body in chunks to avoid memory pressure:
+
+```ocaml
+let handler _params req =
+  let stream = Request.body_reader req in
+  let rec process () =
+    match stream.read_stream () with
+    | None -> ()  (* End of body *)
+    | Some chunk ->
+        (* Process chunk (Cstruct.t) *)
+        write_to_file chunk;
+        process ()
+  in
+  process ();
+  Response.ok "Upload complete"
+```
+
+Each call to `read_stream ()` returns:
+- `Some chunk` - A `Cstruct.t` containing the next chunk of data
+- `None` - End of body reached
+
+### Ignoring the Body
+
+If you don't need the body (e.g., for GET requests), you can ignore it. For methods that typically have no body (GET, HEAD, OPTIONS), HCS automatically closes the body reader.
+
+For other methods where you want to explicitly skip the body:
+
+```ocaml
+let handler _params req =
+  req.body_reader.close ();
+  Response.ok "Ignored body"
+```
+
+### Body Size Limits
+
+Configure `max_body_size` to reject bodies exceeding a threshold:
+
+```ocaml
+let config = 
+  Server.default_config
+  |> Server.with_max_body_size (Int64.of_int (10 * 1024 * 1024))  (* 10MB *)
+```
+
+If a request body exceeds this limit, HCS returns `413 Request Entity Too Large`.
+
+### Large Bodies and HTTP/2
+
+Both HTTP/1.1 and HTTP/2 support arbitrarily large request bodies. HTTP/2 uses flow control with a default window size of 64KB—HCS handles `WINDOW_UPDATE` frames automatically, so large uploads work without configuration.
+
+### Form Data
+
+For `application/x-www-form-urlencoded` bodies:
+
+```ocaml
+let handler _params req =
+  let data = Request.form_data req in
+  let name = List.assoc_opt "name" data in
+  (* ... *)
+```
+
+### Multipart Forms
+
+For file uploads with `multipart/form-data`, see the [Multipart module](../recipes/file-upload.md).
 
 ## Three-Layer Plug Architecture
 

docs/guides/responses.md

···
 ```
 
 Or use the `Negotiate` plug for automatic handling.
+
+## See Also
+
+- [Request Body Handling](request-lifecycle.md#request-body-handling) - Reading and streaming request bodies