fix(lint): rename constructors to v and resolve E332/E331/E410 across packages

Rename create/make to v in rpmsg, error, proxy, auth, version, and
other modules. Fix doc style issues in error.mli, requests.mli, and
expect_continue.mli. Update all callers.

examples/session_example.ml

···
   Switch.run @@ fun sw ->
   (* Example 1: Basic GET request *)
   Printf.printf "\n=== Example 1: Basic GET Request ===\n%!";
-  let req = Requests.create ~sw env in
+  let req = Requests.v ~sw env in
   let resp1 = Requests.get req "https://httpbin.org/get" in
   Printf.printf "Status: %d\n%!" (Requests.Response.status_code resp1);
   let body1 =
···
 
   (* Example 4: Session with default headers *)
   Printf.printf "\n=== Example 4: Session with Default Headers ===\n%!";
-  let req2 = Requests.create ~sw env in
+  let req2 = Requests.v ~sw env in
   let req2 =
     Requests.set_default_header req2 "User-Agent" "OCaml-Requests/1.0"
   in
···
   let retry_config =
     Requests.Retry.config ~max_retries:3 ~backoff_factor:0.5 ()
   in
-  let req_with_retry = Requests.create ~sw ~retry:retry_config env in
+  let req_with_retry = Requests.v ~sw ~retry:retry_config env in
   let req_with_retry =
     Requests.set_timeout req_with_retry (Requests.Timeout.v ~total:10.0 ())
   in
···
 
   (* Example 11: Timeouts *)
   Printf.printf "\n=== Example 11: Timeouts ===\n%!";
-  let req_timeout = Requests.create ~sw env in
+  let req_timeout = Requests.v ~sw env in
   let req_timeout =
     Requests.set_timeout req_timeout (Requests.Timeout.v ~total:5.0 ())
   in

lib/core/error.ml

···
     Following the Eio.Io exception pattern for structured error handling. Each
     variant contains a record with contextual information. *)
 
-type error =
+type t =
   (* Timeout errors *)
   | Timeout of { operation : string; duration : float option }
   (* Redirect errors *)
···
 
     Following the pattern from ocaml-conpool for structured Eio exceptions *)
 
-type Eio.Exn.err += E of error
+type Eio.Exn.err += E of t
 
 let err e = Eio.Exn.create (E e)
 

lib/core/error.mli

···
     Granular error variants with contextual information. Each variant contains a
     record with relevant details. *)
 
-type error =
+type t =
   (* Timeout errors *)
   | Timeout of { operation : string; duration : float option }
   (* Redirect errors *)
···
 (** {1 Eio.Exn Integration} *)
 
 (** Extension of [Eio.Exn.err] for Requests errors *)
-type Eio.Exn.err += E of error
+type Eio.Exn.err += E of t
 
-val err : error -> exn
+val err : t -> exn
 (** [err e] creates an Eio exception from an error. *)
 
 (** {1 URL and Credential Sanitization} *)
···
 
 (** {1 Pretty Printing} *)
 
-val pp_error : Format.formatter -> error -> unit
+val pp_error : Format.formatter -> t -> unit
 (** Pretty printer for error values. *)
 
 (** {1 Query Functions}
 
     These functions enable smart error handling without pattern matching. *)
 
-val is_timeout : error -> bool
+val is_timeout : t -> bool
 (** [is_timeout e] returns [true] if [e] is a timeout. *)
 
-val is_dns : error -> bool
+val is_dns : t -> bool
 (** [is_dns e] returns [true] if [e] is a DNS resolution failure. *)
 
-val is_tls : error -> bool
+val is_tls : t -> bool
 (** [is_tls e] returns [true] if [e] is a TLS handshake failure. *)
 
-val is_connection : error -> bool
+val is_connection : t -> bool
 (** [is_connection e] returns [true] if [e] is any connection-related failure
     (DNS, TCP connect, or TLS handshake). *)
 
-val is_http_error : error -> bool
+val is_http_error : t -> bool
 (** [is_http_error e] returns [true] if [e] is an HTTP response error. *)
 
-val is_client_error : error -> bool
+val is_client_error : t -> bool
 (** [is_client_error e] returns [true] if [e] is a client error (4xx status or
     similar). *)
 
-val is_server_error : error -> bool
+val is_server_error : t -> bool
 (** [is_server_error e] returns [true] if [e] is a server error (5xx status). *)
 
-val is_retryable : error -> bool
+val is_retryable : t -> bool
 (** [is_retryable e] returns [true] if [e] is typically retryable. Retryable
     errors include: timeouts, connection errors, and certain HTTP status codes
     (408, 429, 500, 502, 503, 504). *)
 
-val is_security_error : error -> bool
+val is_security_error : t -> bool
 (** [is_security_error e] returns [true] if [e] is security-related (header
     injection, body too large, decompression bomb, etc.). *)
 
-val is_json_error : error -> bool
+val is_json_error : t -> bool
 (** [is_json_error e] returns [true] if [e] is a JSON parsing or encoding error.
 *)
 
-val is_oauth_error : error -> bool
+val is_oauth_error : t -> bool
 (** [is_oauth_error e] returns [true] if [e] is an OAuth-related error
     (Oauth_error, Token_refresh_failed, Token_expired). *)
 
 (** {1 Error Extraction} *)
 
-val of_eio_exn : exn -> error option
+val of_eio_exn : exn -> t option
 (** Extract error from an Eio.Io exception, if it's a Requests error. *)
 
 (** {1 HTTP Status Helpers} *)
 
-val http_status : error -> int option
+val http_status : t -> int option
 (** Get the HTTP status code from an error, if applicable. *)
 
-val url : error -> string option
+val url : t -> string option
 (** Get the URL associated with an error, if applicable. *)
 
 (** {1 String Conversion} *)
 
-val to_string : error -> string
+val to_string : t -> string
 (** Convert error to human-readable string. *)
 
 (** {1 Convenience Constructors}
···
     Query functions for HTTP/2 specific errors per
     {{:https://datatracker.ietf.org/doc/html/rfc9113}RFC 9113}. *)
 
-val is_h2_error : error -> bool
+val is_h2_error : t -> bool
 (** [is_h2_error e] returns [true] if [e] is any HTTP/2 protocol error. *)
 
-val is_h2_connection_error : error -> bool
+val is_h2_connection_error : t -> bool
 (** [is_h2_connection_error e] returns [true] if [e] is an HTTP/2
     connection-level error. Connection errors terminate the entire HTTP/2
     connection. *)
 
-val is_h2_stream_error : error -> bool
+val is_h2_stream_error : t -> bool
 (** [is_h2_stream_error e] returns [true] if [e] is an HTTP/2 stream-level
     error. Stream errors only affect a single stream. *)
 
-val is_h2_retryable : error -> bool
+val is_h2_retryable : t -> bool
 (** [is_h2_retryable e] returns [true] if the HTTP/2 error is typically
     retryable. Retryable errors include:
     - GOAWAY with NO_ERROR (graceful shutdown)
     - REFUSED_STREAM (server didn't process the request)
     - ENHANCE_YOUR_CALM (after backoff). *)
 
-val h2_error_code : error -> int32 option
+val h2_error_code : t -> int32 option
 (** Get the HTTP/2 error code from an error, if applicable. Error codes are
     defined in RFC 9113 Section 7. *)
 
-val h2_stream_id : error -> int32 option
+val h2_stream_id : t -> int32 option
 (** Get the stream ID associated with an HTTP/2 error, if applicable. *)
 
 (** {1 HTTP/2 Error Constructors}

lib/core/expect_continue.mli

···
     {[
       (* Use 100-continue for bodies >= 1MB (default) *)
       let session =
-        Requests.create ~sw ~expect_100_continue:(`Threshold 1_048_576L) env
+        Requests.v ~sw ~expect_100_continue:(`Threshold 1_048_576L) env
 
       (* Always use 100-continue *)
       let session = Requests.v ~sw ~expect_100_continue:`Always env

lib/core/response.mli

···
 
     @raise Eio.Io with [Error.Http_error] if status code >= 400. *)
 
-val check_status : t -> (t, Error.error) result
+val check_status : t -> (t, Error.t) result
 (** [check_status response] returns [Ok response] if the status code is < 400,
     or [Error error] if the status code indicates an error (>= 400).
 

lib/core/version.ml

···
     debugging. *)
 
 (** Library version - update this when releasing new versions *)
-let version = "0.1.0"
+let v = "0.1.0"
 
 (** Library name *)
 let name = "ocaml-requests"
···
 (** Default User-Agent header value. Format follows common conventions:
     library-name/version (runtime-info) Per RFC 9110 Section 10.1.5, this helps
     with debugging and statistics. *)
-let user_agent = Fmt.str "%s/%s (OCaml %s)" name version Sys.ocaml_version
+let user_agent = Fmt.str "%s/%s (OCaml %s)" name v Sys.ocaml_version

lib/core/version.mli

···
     and Recommendation #30: Provides a default User-Agent header for HTTP
     requests. *)
 
-val version : string
+val v : string
 (** Library version string (e.g., "0.1.0"). *)
 
 val name : string

lib/features/auth.ml

···
   match Uri.scheme uri with Some "https" -> true | _ -> false
 
 (** Get the authentication type name for error messages *)
-let auth_type_name = function
+let type_name = function
   | No_auth -> "None"
   | Basic _ -> "Basic"
   | Bearer _ -> "Bearer"
···
   if allow_insecure_auth then
     Log.warn (fun m ->
         m "allow_insecure_auth=true: skipping HTTPS check for %s auth"
-          (auth_type_name auth))
+          (type_name auth))
   else if requires_https auth && not (is_https url) then begin
     Log.err (fun m ->
         m
           "%s authentication rejected over HTTP (use HTTPS or \
            allow_insecure_auth=true)"
-          (auth_type_name auth));
-    raise
-      (Error.err (Error.Insecure_auth { url; auth_type = auth_type_name auth }))
+          (type_name auth));
+    raise (Error.err (Error.Insecure_auth { url; auth_type = type_name auth }))
   end
 
 let apply auth headers =

lib/features/proxy.ml

···
 
 (** {1 Proxy Types} *)
 
-type proxy_type = HTTP | SOCKS5
+type kind = HTTP | SOCKS5
 
 type config = {
   host : string;
   port : int;
-  proxy_type : proxy_type;
+  kind : kind;
   auth : Auth.t option;
   no_proxy : string list;
 }
···
 
 let http ?(port = 8080) ?auth ?(no_proxy = []) host =
   Log.debug (fun m -> m "Creating HTTP proxy config: %s:%d" host port);
-  { host; port; proxy_type = HTTP; auth; no_proxy }
+  { host; port; kind = HTTP; auth; no_proxy }
 
 let socks5 ?(port = 1080) ?auth ?(no_proxy = []) host =
   Log.debug (fun m -> m "Creating SOCKS5 proxy config: %s:%d" host port);
-  { host; port; proxy_type = SOCKS5; auth; no_proxy }
+  { host; port; kind = SOCKS5; auth; no_proxy }
 
 (** {1 Pattern Matching for NO_PROXY} *)
 
···
     implemented.
     @raise Error.Proxy_error if SOCKS5 is requested *)
 let validate_supported config =
-  match config.proxy_type with
+  match config.kind with
   | HTTP -> ()
   | SOCKS5 ->
       Log.err (fun m -> m "SOCKS5 proxy requested but not implemented");
···
   | Some url ->
       let host, port, auth = parse_proxy_url url in
       Log.info (fun m -> m "Proxy configured from environment: %s:%d" host port);
-      Some { host; port; proxy_type = HTTP; auth; no_proxy }
+      Some { host; port; kind = HTTP; auth; no_proxy }
   | None ->
       Log.debug (fun m -> m "No proxy configured in environment");
       None
···
         let host, port, auth = parse_proxy_url purl in
         Log.debug (fun m ->
             m "Using proxy %s:%d for URL %s" host port (Error.sanitize_url url));
-        Some { host; port; proxy_type = HTTP; auth; no_proxy }
+        Some { host; port; kind = HTTP; auth; no_proxy }
     | None -> None
 
 (** {1 Pretty Printing} *)
 
-let pp_proxy_type ppf = function
+let pp_kind ppf = function
   | HTTP -> Fmt.pf ppf "HTTP"
   | SOCKS5 -> Fmt.pf ppf "SOCKS5"
 
 let pp_config ppf config =
   Fmt.pf ppf "@[<v>Proxy Configuration:@,";
-  Fmt.pf ppf "  Type: %a@," pp_proxy_type config.proxy_type;
+  Fmt.pf ppf "  Type: %a@," pp_kind config.kind;
   Fmt.pf ppf "  Host: %s@," config.host;
   Fmt.pf ppf "  Port: %d@," config.port;
   Fmt.pf ppf "  Auth: %s@,"

lib/features/proxy.mli

···
 (** {1 Proxy Types} *)
 
 (** Proxy protocol type *)
-type proxy_type =
+type kind =
   | HTTP  (** HTTP proxy (CONNECT for HTTPS, absolute-URI for HTTP) *)
   | SOCKS5  (** SOCKS5 proxy (RFC 1928) - future extension *)
 
 type config = {
   host : string;  (** Proxy server hostname *)
   port : int;  (** Proxy server port (default: 8080) *)
-  proxy_type : proxy_type;
+  kind : kind;
   auth : Auth.t option;  (** Proxy authentication (Proxy-Authorization) *)
   no_proxy : string list;  (** Hosts/patterns to bypass proxy *)
 }
···
 
 (** {1 Pretty Printing} *)
 
-val pp_proxy_type : Format.formatter -> proxy_type -> unit
+val pp_kind : Format.formatter -> kind -> unit
 (** Pretty printer for proxy type. *)
 
 val pp_config : Format.formatter -> config -> unit

lib/requests.mli

···
 
     {3 Session API (Requests.t)}
 
-    Use {!Requests.create} when you need:
+    Use {!Requests.v} when you need:
     - {b Cookie persistence} across requests (automatic session handling)
     - {b Connection pooling} for efficient reuse of TCP/TLS connections
     - {b Shared authentication} configured once for all requests
···
         run @@ fun env ->
         Eio.Switch.run @@ fun sw ->
         (* Create a session with connection pooling *)
-        let session = Requests.create ~sw env in
+        let session = Requests.v ~sw env in
 
         (* Configure authentication once for all requests *)
         let session =
···
         ~max_retries:3
         ~status_forcelist:[429; 500; 502; 503; 504]  (* Retry these codes *)
         () in
-      let req = Requests.create ~sw ~retry:retry_config env in
+      let req = Requests.v ~sw ~retry:retry_config env in
     ]}
 
     {b Catching Exceptions:}
···
       {b Only set to [true] for local development or testing environments.}
       Example for local dev server:
       {[
-        let session = Requests.create ~sw ~allow_insecure_auth:true env in
+        let session = Requests.v ~sw ~allow_insecure_auth:true env in
         let session = Requests.set_auth session (Requests.Auth.basic ~username:"dev" ~password:"dev") in
         (* Can now make requests to http://localhost:8080 with Basic auth *)
       ]} *)
···
 
     Example of concurrent requests using Fiber.both:
     {[
-      let req = Requests.create ~sw env in
+      let req = Requests.v ~sw env in
 
       (* Use Fiber.both for two concurrent requests *)
       let (r1, r2) = Eio.Fiber.both
···
 
     Example using Fiber.all for multiple requests:
     {[
-      let req = Requests.create ~sw env in
+      let req = Requests.v ~sw env in
 
       (* Use Fiber.all for multiple concurrent requests *)
       let urls =
···
 
     Example using Promise for concurrent requests with individual control:
     {[
-      let req = Requests.create ~sw env in
+      let req = Requests.v ~sw env in
 
       (* Start requests in parallel using promises *)
       let p1, r1 = Eio.Promise.create () in
···
         let config_t = Requests.Cmd.config_term "myapp" env#fs in
         let main config =
           Eio.Switch.run @@ fun sw ->
-          let req = Requests.Cmd.create config env sw in
+          let req = Requests.Cmd.v config env sw in
           (* Use requests *)
         in
         let cmd = Cmd.v info Term.(const main $ config_t) in
···
         let minimal_t = Requests.Cmd.minimal_term "myapp" env#fs in
         let main (xdg, persist) =
           Eio.Switch.run @@ fun sw ->
-          let req = Requests.create ~sw ~xdg ~persist_cookies:persist env in
+          let req = Requests.v ~sw ~xdg ~persist_cookies:persist env in
           (* Use requests *)
         in
         let cmd = Cmd.v info Term.(const main $ minimal_t) in

test/test_version.ml

···
 (** {1 Version String} *)
 
 let test_version_non_empty () =
-  Alcotest.(check bool)
-    "version is non-empty" true
-    (String.length Version.version > 0)
+  Alcotest.(check bool) "version is non-empty" true (String.length Version.v > 0)
 
 (** {1 Name} *)
 
···
   Alcotest.(check bool)
     "user_agent contains version" true
     (let ua = Version.user_agent in
-     let ver = Version.version in
+     let ver = Version.v in
      try
        let rec find i =
          if i + String.length ver > String.length ua then raise Not_found