fix(ocaml-tm): fix naming, Fmt.invalid_arg, and add docs

- Rename get_u8→u8, get_u16_be→u16_be, get_u32_be→u32_be (private helpers)
- Rename get_clcw→find_clcw (returns option type)
- Rename make_header→header, make_clcw→clcw, make→v
- Replace invalid_arg (Fmt.str ...) with Fmt.invalid_arg
- Add docs to tm.mli: pp_clcw, pp, struct_, module_, wire decode/encode fns
- Add module/suite docs to fuzz_tm.mli and test_tm.mli

ocaml-tm/fuzz/fuzz_tm.ml

···
   let fhp = fhp mod 2048 in
   match (Tm.scid scid_val, Tm.vcid vcid_val) with
   | Some scid, Some vcid -> (
-      let hdr = Tm.make_header ~scid ~vcid ~mcfc ~vcfc ~first_hdr_ptr:fhp () in
+      let hdr = Tm.header ~scid ~vcid ~mcfc ~vcfc ~first_hdr_ptr:fhp () in
       let encoded = Tm.encode_header hdr in
       match Tm.decode_header encoded with
       | Ok decoded ->
···
   let farm_b = farm_b mod 4 in
   match Tm.vcid vcid_val with
   | Some vcid -> (
-      let clcw =
-        Tm.make_clcw ~vcid ~report_value:report ~farm_b_counter:farm_b ()
-      in
+      let clcw = Tm.clcw ~vcid ~report_value:report ~farm_b_counter:farm_b () in
       let encoded = Tm.encode_clcw clcw in
       match Tm.decode_clcw encoded with
       | Ok decoded ->
···
   else
     match (Tm.scid 100, Tm.vcid 2) with
     | Some scid, Some vcid -> (
-        let frame = Tm.make ~scid ~vcid ~mcfc:0 ~vcfc:0 ~ocf_flag:false data in
+        let frame = Tm.v ~scid ~vcid ~mcfc:0 ~vcfc:0 ~ocf_flag:false data in
         let encoded = Tm.encode frame in
         match
           Tm.decode ~frame_len:(String.length encoded) ~expect_ocf:false encoded
···
   else
     match (Tm.scid 0, Tm.vcid 0) with
     | Some scid, Some vcid -> (
-        let frame = Tm.make ~scid ~vcid ~mcfc:0 ~vcfc:0 data in
+        let frame = Tm.v ~scid ~vcid ~mcfc:0 ~vcfc:0 data in
         let encoded = Tm.encode frame in
         let len = String.length encoded in
         if len < 3 then ()

ocaml-tm/fuzz/fuzz_tm.mli

···
+(** Fuzz tests for TM frame encoding/decoding. *)
+
 val suite : string * Crowbar.test_case list
+(** Crowbar fuzz test suite. *)

ocaml-tm/lib/tm.ml

···
 
 let scid_exn n =
   if n >= 0 && n <= 1023 then n
-  else invalid_arg (Fmt.str "scid: %d out of range 0-1023" n)
+  else Fmt.invalid_arg "scid: %d out of range 0-1023" n
 
 let scid_to_int s = s
 
···
 let vcid n = if n >= 0 && n <= 7 then Some n else None
 
 let vcid_exn n =
-  if n >= 0 && n <= 7 then n
-  else invalid_arg (Fmt.str "vcid: %d out of range 0-7" n)
+  if n >= 0 && n <= 7 then n else Fmt.invalid_arg "vcid: %d out of range 0-7" n
 
 let vcid_to_int v = v
 
···
 let decode_clcw word = Clcw.decode word
 let encode_clcw clcw = Clcw.encode clcw
 
-let get_clcw frame =
+let find_clcw frame =
   match frame.ocf with None -> None | Some word -> Some (Clcw.decode word)
 
 (* Constructors *)
-let make_header ?(version = 0) ?(ocf_flag = true) ?(sec_hdr = false)
+let header ?(version = 0) ?(ocf_flag = true) ?(sec_hdr = false)
     ?(sync_flag = false) ?(pkt_order = false) ?(seg_len_id = 3)
     ?(first_hdr_ptr = 0) ~scid ~vcid ~mcfc ~vcfc () =
   {
···
     first_hdr_ptr;
   }
 
-let make ?(version = 0) ?(ocf_flag = true) ?(sec_hdr = false)
-    ?(sync_flag = false) ?(pkt_order = false) ?(seg_len_id = 3)
-    ?(first_hdr_ptr = 0) ?sec_hdr_data ?ocf ?fecf ~scid ~vcid ~mcfc ~vcfc data =
+let v ?(version = 0) ?(ocf_flag = true) ?(sec_hdr = false) ?(sync_flag = false)
+    ?(pkt_order = false) ?(seg_len_id = 3) ?(first_hdr_ptr = 0) ?sec_hdr_data
+    ?ocf ?fecf ~scid ~vcid ~mcfc ~vcfc data =
   let header =
-    make_header ~version ~ocf_flag ~sec_hdr ~sync_flag ~pkt_order ~seg_len_id
+    header ~version ~ocf_flag ~sec_hdr ~sync_flag ~pkt_order ~seg_len_id
       ~first_hdr_ptr ~scid ~vcid ~mcfc ~vcfc ()
   in
   { header; sec_hdr_data; data; ocf; fecf }
 
-let make_clcw ?(control_word_type = 0) ?(version = 0) ?(status = Ready)
+let clcw ?(control_word_type = 0) ?(version = 0) ?(status = Ready)
     ?(cop_in_effect = 1) ?(no_rf_available = false) ?(no_bit_lock = false)
     ?(lockout = false) ?(wait = false) ?(retransmit = false)
     ?(farm_b_counter = 0) ~vcid ~report_value () =

ocaml-tm/lib/tm.mli

···
 val encode_clcw : Clcw.t -> int
 (** [encode_clcw clcw] encodes a CLCW to a 32-bit word. *)
 
-val get_clcw : t -> (Clcw.t, Clcw.error) result option
-(** [get_clcw frame] extracts and decodes the CLCW from the frame's OCF if
+val find_clcw : t -> (Clcw.t, Clcw.error) result option
+(** [find_clcw frame] extracts and decodes the CLCW from the frame's OCF if
     present. Returns [None] if no OCF. *)
 
 (** {1 Constructors} *)
 
-val make_header :
+val header :
   ?version:int ->
   ?ocf_flag:bool ->
   ?sec_hdr:bool ->
···
   header
 (** Create a TM frame header with the given parameters. *)
 
-val make :
+val v :
   ?version:int ->
   ?ocf_flag:bool ->
   ?sec_hdr:bool ->
···
   t
 (** [make ~scid ~vcid ~mcfc ~vcfc data] creates a TM frame. *)
 
-val make_clcw :
+val clcw :
   ?control_word_type:int ->
   ?version:int ->
   ?status:clcw_status ->
···
 (** {1 Pretty-printing} *)
 
 val pp_header : Format.formatter -> header -> unit
+
 val pp_clcw : Format.formatter -> clcw -> unit
+(** Pretty-print a CLCW value. *)
+
 val pp : Format.formatter -> t -> unit
+(** Pretty-print a TM frame. *)
 
 (** {1 Packed Header Wire Representation} *)
 
···
 (** {1 Wire Codec} *)
 
 val codec : packed_header Wire.Codec.t
+(** Wire codec for [packed_header]. *)
+
 val struct_ : Wire.struct_
+(** Wire struct descriptor. *)
+
 val module_ : Wire.module_
+(** Wire module descriptor. *)
 
 (** {1 Wire Parse/Encode} *)
 
 val wire_size : int
+(** Wire size of a packed header in bytes. *)
+
 val decode_packed_header : bytes -> int -> packed_header
+(** [decode_packed_header buf off] decodes a packed header from [buf] at offset
+    [off]. *)
+
 val encode_packed_header : packed_header -> bytes -> int -> unit
+(** [encode_packed_header h buf off] encodes [h] into [buf] at offset [off]. *)
+
 val decode_bytes : bytes -> (packed_header, Wire.parse_error) result
+(** [decode_bytes buf] decodes a packed header from [buf]. *)
+
 val decode_string : string -> (packed_header, Wire.parse_error) result
+(** [decode_string s] decodes a packed header from string [s]. *)
+
 val encode_string : packed_header -> string
+(** [encode_string h] encodes [h] as a string. *)
+
 val encode_bytes : packed_header -> bytes
+(** [encode_bytes h] encodes [h] as bytes. *)
 
 (** {1 FFI Code Generation} *)
 
 val c_stubs : unit -> string
+
 val ml_stubs : unit -> string
+(** Generate OCaml FFI stub code. *)

ocaml-tm/test/test_tm.ml

···
 let test_header_roundtrip () =
   let scid = Tm.scid_exn 123 in
   let vcid = Tm.vcid_exn 5 in
-  let hdr =
-    Tm.make_header ~scid ~vcid ~mcfc:42 ~vcfc:99 ~first_hdr_ptr:0x100 ()
-  in
+  let hdr = Tm.header ~scid ~vcid ~mcfc:42 ~vcfc:99 ~first_hdr_ptr:0x100 () in
   let encoded = Tm.encode_header hdr in
   Alcotest.(check int) "header is 6 bytes" 6 (String.length encoded);
   match Tm.decode_header encoded with
···
 let test_clcw_roundtrip () =
   let vcid = Tm.vcid_exn 3 in
   let clcw =
-    Tm.make_clcw ~vcid ~report_value:127 ~lockout:true ~retransmit:true ()
+    Tm.clcw ~vcid ~report_value:127 ~lockout:true ~retransmit:true ()
   in
   let encoded = Tm.encode_clcw clcw in
   match Tm.decode_clcw encoded with
···
   let vcid = Tm.vcid_exn 2 in
   let data = String.make 1103 '\x55' in
   (* 1115 - 6 header - 4 OCF - 2 FECF = 1103 *)
-  let frame = Tm.make ~scid ~vcid ~mcfc:1 ~vcfc:2 ~ocf:0x12345678 data in
+  let frame = Tm.v ~scid ~vcid ~mcfc:1 ~vcfc:2 ~ocf:0x12345678 data in
   let encoded = Tm.encode frame in
   Alcotest.(check int) "encoded length" 1115 (String.length encoded);
   match Tm.decode encoded with
···
   let scid = Tm.scid_exn 0 in
   let vcid = Tm.vcid_exn 0 in
   let data = String.make 1103 '\x00' in
-  let frame = Tm.make ~scid ~vcid ~mcfc:0 ~vcfc:0 ~ocf:0 data in
+  let frame = Tm.v ~scid ~vcid ~mcfc:0 ~vcfc:0 ~ocf:0 data in
   let encoded = Tm.encode frame in
   let frame_len = String.length encoded in
   (* Corrupt the FECF (last 2 bytes) *)
···
 let test_wire_vs_manual () =
   let scid = Tm.scid_exn 123 in
   let vcid = Tm.vcid_exn 5 in
-  let hdr =
-    Tm.make_header ~scid ~vcid ~mcfc:42 ~vcfc:99 ~first_hdr_ptr:0x100 ()
-  in
+  let hdr = Tm.header ~scid ~vcid ~mcfc:42 ~vcfc:99 ~first_hdr_ptr:0x100 () in
   let manual = Tm.encode_header hdr in
   let packed = Tm.to_packed_header hdr in
   let wire = Tm.encode_string packed in
···
   let vcid = Tm.vcid_exn 0 in
   let data = String.make 1103 '\x00' in
   (* mcfc = 255 (max 8-bit value) *)
-  let frame_max = Tm.make ~scid ~vcid ~mcfc:255 ~vcfc:0 ~ocf:0 data in
+  let frame_max = Tm.v ~scid ~vcid ~mcfc:255 ~vcfc:0 ~ocf:0 data in
   let encoded_max = Tm.encode frame_max in
   (match Tm.decode ~frame_len:(String.length encoded_max) encoded_max with
   | Error e -> Alcotest.failf "decode mcfc=255 failed: %a" Tm.pp_error e
   | Ok decoded -> Alcotest.(check int) "mcfc=255" 255 decoded.header.mcfc);
   (* mcfc = 0 (after wraparound) *)
-  let frame_zero = Tm.make ~scid ~vcid ~mcfc:0 ~vcfc:0 ~ocf:0 data in
+  let frame_zero = Tm.v ~scid ~vcid ~mcfc:0 ~vcfc:0 ~ocf:0 data in
   let encoded_zero = Tm.encode frame_zero in
   match Tm.decode ~frame_len:(String.length encoded_zero) encoded_zero with
   | Error e -> Alcotest.failf "decode mcfc=0 failed: %a" Tm.pp_error e
···
   let vcid = Tm.vcid_exn 0 in
   let data = String.make 1103 '\x00' in
   (* vcfc = 255 (max 8-bit value) *)
-  let frame_max = Tm.make ~scid ~vcid ~mcfc:0 ~vcfc:255 ~ocf:0 data in
+  let frame_max = Tm.v ~scid ~vcid ~mcfc:0 ~vcfc:255 ~ocf:0 data in
   let encoded_max = Tm.encode frame_max in
   (match Tm.decode ~frame_len:(String.length encoded_max) encoded_max with
   | Error e -> Alcotest.failf "decode vcfc=255 failed: %a" Tm.pp_error e
   | Ok decoded -> Alcotest.(check int) "vcfc=255" 255 decoded.header.vcfc);
   (* vcfc = 0 (after wraparound) *)
-  let frame_zero = Tm.make ~scid ~vcid ~mcfc:0 ~vcfc:0 ~ocf:0 data in
+  let frame_zero = Tm.v ~scid ~vcid ~mcfc:0 ~vcfc:0 ~ocf:0 data in
   let encoded_zero = Tm.encode frame_zero in
   match Tm.decode ~frame_len:(String.length encoded_zero) encoded_zero with
   | Error e -> Alcotest.failf "decode vcfc=0 failed: %a" Tm.pp_error e

ocaml-tm/test/test_tm.mli

···
+(** Test suite for TM transfer frames. *)
+
 val suite : string * unit Alcotest.test_case list
+(** Alcotest test suite. *)