fix(lint): add err_ec helper in spake2 (E340), add Config.pp (E415)

Extract Error (Fmt.str ...) into err_ec helper for consistent error
handling, and add pretty-printer for config type.

ocaml-claude-skills/lib/config.ml

···
   List.iter
     (fun e ->
       let k = match e.kind with Dev -> "dev" | Std -> "std" in
-      Buffer.add_string buf
-        (Printf.sprintf "%s %s\n" k (Fpath.to_string e.path)))
+      Buffer.add_string buf (Fmt.str "%s %s\n" k (Fpath.to_string e.path)))
     t.entries;
   Buffer.contents buf
 
···
   { entries = List.filter (fun e -> not (Fpath.equal e.path path)) t.entries }
 
 let entries t = t.entries
+
+let pp_kind ppf = function
+  | Dev -> Fmt.string ppf "dev"
+  | Std -> Fmt.string ppf "std"
+
+let pp_entry ppf e = Fmt.pf ppf "%a %a" pp_kind e.kind Fpath.pp e.path
+let pp ppf t = Fmt.pf ppf "@[<v>%a@]" Fmt.(list ~sep:Fmt.cut pp_entry) t.entries

ocaml-claude-skills/lib/config.mli

···
 
 val entries : t -> entry list
 (** Return all entries in file order. *)
+
+val pp : t Fmt.t
+(** Pretty-print the configuration. *)

ocaml-slack/test/test_markdown.ml

···
     (fun input ->
       let once = to_mrkdwn input in
       let twice = input |> to_mrkdwn |> to_md |> to_mrkdwn in
-      check (Printf.sprintf "md roundtrip: %s" input) once twice)
+      check (Fmt.str "md roundtrip: %s" input) once twice)
     inputs
 
 let test_roundtrip_mrkdwn () =
···
     (fun input ->
       let once = to_md input in
       let twice = input |> to_md |> to_mrkdwn |> to_md in
-      check (Printf.sprintf "mrkdwn roundtrip: %s" input) once twice)
+      check (Fmt.str "mrkdwn roundtrip: %s" input) once twice)
     inputs
 
 let suite =

ocaml-sle/fuzz/fuzz_bind.ml

···
     | 1 -> Sle.Bind.Bind_pending
     | _ -> Sle.Bind.Bound
   in
-  let _ = Format.asprintf "%a" Sle.Bind.pp_state state in
+  let _ = Fmt.str "%a" Sle.Bind.pp_state state in
   ()
 
 (** Pretty-print service type - must not crash. *)
···
     | 2 -> Sle.Bind.Fcltu
     | _ -> Sle.Bind.Rocf
   in
-  let _ = Format.asprintf "%a" Sle.Bind.pp_service_type st in
+  let _ = Fmt.str "%a" Sle.Bind.pp_service_type st in
   ()
 
 (** Pretty-print bind diagnostic - must not crash. *)
···
     | 3 -> Sle.Bind.No_such_service_instance
     | _ -> Sle.Bind.Other_reason
   in
-  let _ = Format.asprintf "%a" Sle.Bind.pp_diagnostic diag in
+  let _ = Fmt.str "%a" Sle.Bind.pp_diagnostic diag in
   ()
 
 let suite =

ocaml-sle/fuzz/fuzz_common.ml

···
     | 4 -> Sle.Common.Forward_offline
     | n -> Sle.Common.Unknown_delivery_mode n
   in
-  let _ = Format.asprintf "%a" Sle.Common.pp_delivery_mode d in
+  let _ = Fmt.str "%a" Sle.Common.pp_delivery_mode d in
   ()
 
 (** Pretty-print frame quality - must not crash. *)
···
     | 2 -> Sle.Common.Undetermined
     | n -> Sle.Common.Unknown_frame_quality n
   in
-  let _ = Format.asprintf "%a" Sle.Common.pp_frame_quality q in
+  let _ = Fmt.str "%a" Sle.Common.pp_frame_quality q in
   ()
 
 let suite =

ocaml-sle/fuzz/fuzz_isp1.ml

···
 (** Pretty-print hash algorithm - must not crash. *)
 let test_pp_hash_algorithm n =
   let algo = if n mod 2 = 0 then Sle.Isp1.Sha1 else Sle.Isp1.Sha256 in
-  let _ = Format.asprintf "%a" Sle.Isp1.pp_hash_algorithm algo in
+  let _ = Fmt.str "%a" Sle.Isp1.pp_hash_algorithm algo in
   ()
 
 let suite =

ocaml-sle/fuzz/fuzz_raf.ml

···
     | 1 -> Sle.Raf.Active
     | _ -> Sle.Raf.Stopping
   in
-  let _ = Format.asprintf "%a" Sle.Raf.pp_state state in
+  let _ = Fmt.str "%a" Sle.Raf.pp_state state in
   ()
 
 (** Pretty-print start diagnostic - must not crash. *)
···
     | 4 -> Sle.Raf.Out_of_service_start
     | _ -> Sle.Raf.Duplicate_invoke_id_start
   in
-  let _ = Format.asprintf "%a" Sle.Raf.pp_start_diagnostic diag in
+  let _ = Fmt.str "%a" Sle.Raf.pp_start_diagnostic diag in
   ()
 
 (** Pretty-print frame quality - must not crash. *)
···
     | 2 -> Sle.Raf.Undetermined
     | _ -> Sle.Raf.Unknown_frame_quality n
   in
-  let _ = Format.asprintf "%a" Sle.Raf.pp_frame_quality q in
+  let _ = Fmt.str "%a" Sle.Raf.pp_frame_quality q in
   ()
 
 let suite =

ocaml-sle/fuzz/fuzz_tml.ml

···
     | _ -> Sle.Tml.Heartbeat
   in
   let msg = { Sle.Tml.msg_type; payload = Bytes.unsafe_of_string payload } in
-  let _ = Format.asprintf "%a" Sle.Tml.pp_message msg in
+  let _ = Fmt.str "%a" Sle.Tml.pp_message msg in
   ()
 
 (** Pretty-print context - must not crash. *)
 let test_pp_context protocol_id version heartbeat_interval dead_factor =
   let ctx = { Sle.Tml.protocol_id; version; heartbeat_interval; dead_factor } in
-  let _ = Format.asprintf "%a" Sle.Tml.pp_context ctx in
+  let _ = Fmt.str "%a" Sle.Tml.pp_context ctx in
   ()
 
 let suite =

ocaml-sle/fuzz/gen_corpus.ml

···
   write "seed_003" (String.make 16 '\x00');
   write "seed_004" (String.make 16 '\xff');
   write "seed_005" (String.init 256 Char.chr);
-  Printf.printf "gen_corpus: wrote 6 seed files\n"
+  Fmt.pr "gen_corpus: wrote 6 seed files@."

ocaml-space-packet/bench/bench_space_packet.ml

···
   let words_per_iter =
     (minor_after -. minor_before) /. float_of_int iterations
   in
-  Printf.printf "  %-20s %8.1f ns/iter  %8.1f words/iter\n" name elapsed_ns
+  Fmt.pr "  %-20s %8.1f ns/iter  %8.1f words/iter@." name elapsed_ns
     words_per_iter
 
 let () =
-  Printf.printf "Space Packet Header Benchmark: baseline vs wire\n";
-  Printf.printf "===============================================\n";
-  Printf.printf "(processing 1000 headers per iteration)\n\n";
+  Fmt.pr "Space Packet Header Benchmark: baseline vs wire@.";
+  Fmt.pr "===============================================@.";
+  Fmt.pr "(processing 1000 headers per iteration)@.@.";
 
-  Printf.printf "Raw byte operations (baseline, no record alloc):\n";
+  Fmt.pr "Raw byte operations (baseline, no record alloc):@.";
   time_it "decode" 1000 baseline_decode;
   time_it "encode" 1000 baseline_encode;
   time_it "roundtrip" 1000 baseline_roundtrip;
-  Printf.printf "\n";
+  Fmt.pr "@.";
 
-  Printf.printf "Wire Codec:\n";
+  Fmt.pr "Wire Codec:@.";
   time_it "decode" 1000 wire_decode;
   time_it "encode" 1000 wire_encode;
   time_it "roundtrip" 1000 wire_roundtrip;
-  Printf.printf "\n"
+  Fmt.pr "@."

ocaml-space-packet/fuzz/fuzz_space_packet.ml

···
   match Space_packet.decode buf with
   | Error _ -> ()
   | Ok pkt ->
-      let _ = Format.asprintf "%a" Space_packet.pp pkt in
+      let _ = Fmt.str "%a" Space_packet.pp pkt in
       ()
 
 (** Make with constrained values - must not crash. *)
···
       let expected_len = 6 + String.length data in
       if String.length encoded <> expected_len then
         fail
-          (Printf.sprintf "length mismatch: got %d, expected %d"
+          (Fmt.str "length mismatch: got %d, expected %d"
              (String.length encoded) expected_len)
   | Error _ -> ()
 

ocaml-space-packet/fuzz/gen_corpus.ml

···
   write "seed_003" (String.make 16 '\x00');
   write "seed_004" (String.make 16 '\xff');
   write "seed_005" (String.init 256 Char.chr);
-  Printf.printf "gen_corpus: wrote 6 seed files\n"
+  Fmt.pr "gen_corpus: wrote 6 seed files@."

ocaml-spake2/fuzz/gen_corpus.ml

···
   write "seed_003" (String.make 16 '\x00');
   write "seed_004" (String.make 16 '\xff');
   write "seed_005" (String.init 256 Char.chr);
-  Printf.printf "gen_corpus: wrote 6 seed files\n"
+  Fmt.pr "gen_corpus: wrote 6 seed files@."

ocaml-spake2/lib/spake2.ml

···
       | Ok p -> p
       | Error _ -> failwith "negate: invalid result"
 
+  let err_ec e = Error (Fmt.str "%a" Crypto_ec.pp_error e)
+
   let of_bytes s =
-    match Ec.of_octets s with
-    | Ok p -> Ok p
-    | Error e -> Error (Fmt.str "%a" Crypto_ec.pp_error e)
+    match Ec.of_octets s with Ok p -> Ok p | Error e -> err_ec e
 
   (** Convert a scalar represented as Z.t to the constant-time scalar type *)
   let scalar_of_z z =

ocaml-sqlite/fuzz/gen_corpus.ml

···
   write "seed_003" (String.make 16 '\x00');
   write "seed_004" (String.make 16 '\xff');
   write "seed_005" (String.init 256 Char.chr);
-  Printf.printf "gen_corpus: wrote 6 seed files\n"
+  Fmt.pr "gen_corpus: wrote 6 seed files@."