diff --git a/.clang-format b/.clang-format
index fb14c1c..4bf0a3c 100644
--- a/.clang-format
+++ b/.clang-format
@@ -1,29 +1,9 @@
-# MIT License
-#
-# Copyright (c) 2026 Andrew Smith
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-
+# SPDX-License-Identifier: MIT; Copyright 2026 Andrew D Smith
 BasedOnStyle: LLVM
 ColumnLimit: 80
 IndentWidth: 2
-AlwaysBreakAfterReturnType: All
+BreakAfterReturnType: All
+AlignAfterOpenBracket: true
 ContinuationIndentWidth: 2
 ConstructorInitializerIndentWidth: 2
 BraceWrapping:
@@ -32,3 +12,7 @@ BraceWrapping:
 BreakBeforeBraces: Custom
 BreakConstructorInitializers: AfterColon
 SpacesBeforeTrailingComments: 2
+PackParameters:
+  BinPack: OnePerLine
+  BreakAfter: 0
+AllowShortFunctionsOnASingleLine: All
diff --git a/.clang-tidy b/.clang-tidy
index 3db09f5..be97404 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -1,9 +1,17 @@
 Checks: "
+  concurrency-*,
   cert-*,
   cppcoreguidelines-*,
   performance-*,
   clang-diagnostic-*,
   clang-analyzer-*,
+  modernize-*,
+  misc-*,
+  portability-*,
+  -misc-include-cleaner,
+  -misc-use-anonymous-namespace,
+  -misc-header-include-cycle,
+  -modernize-use-trailing-return-type,
   -clang-diagnostic-unqualified-std-cast-call,
   -clang-diagnostic-unknown-warning-option,
   -clang-analyzer-unix.BlockInCriticalSection,
@@ -28,17 +36,14 @@ CheckOptions:
   cert-dcl16-c.NewSuffixes: 'L;LL;LU;LLU'
   cert-err33-c.AllowCastToVoid: 'true'
   cert-err33-c.CheckedFunctions: '*'
-  cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField: 'false'
-  cert-str34-c.DiagnoseSignedUnsignedCharComparisons: 'false'
-  cppcoreguidelines-non-private-member-variables-in-classes.IgnorePublicMemberVariables: 'true'
   cppcoreguidelines-rvalue-reference-param-not-moved.AllowPartialMove: 'true'
   cppcoreguidelines-avoid-magic-numbers.IgnoredIntegerValues: '1;2;3;4;10'
   cppcoreguidelines-avoid-magic-numbers.IgnoredFloatingPointValues: '1.0;2.0;10.0;100.0'
   google-readability-braces-around-statements.ShortStatementLines: '1'
-  google-readability-function-size.StatementThreshold: '800'
   google-readability-namespace-comments.ShortNamespaceLines: '10'
   google-readability-namespace-comments.SpacesBeforeComments: '2'
-  llvm-else-after-return.WarnOnConditionVariables: 'false'
-  llvm-else-after-return.WarnOnUnfixable: 'false'
-  llvm-qualified-auto.AddConstToQualified: 'false'
+  llvm-else-after-return.WarnOnConditionVariables: 'true'
+  llvm-else-after-return.WarnOnUnfixable: 'true'
+  llvm-qualified-auto.AddConstToQualified: 'true'
+  modernize-use-trailing-return-type.TransformLambdas: none
 SystemHeaders: 'false'
diff --git a/src/adapter_matcher.hpp b/src/adapter_matcher.hpp
index 154d6aa..987ecc4 100644
--- a/src/adapter_matcher.hpp
+++ b/src/adapter_matcher.hpp
@@ -71,12 +71,14 @@ struct adapter_matcher {
   get_grade(const std::uint64_t n_reads) const -> std::string;
 
   [[nodiscard]] auto
-  report(const std::uint64_t n_reads, const std::uint64_t max_read_len,
+  report(const std::uint64_t n_reads,
+         const std::uint64_t max_read_len,
          const base_group_vec &groups,
          const file_grades &grades) const -> std::string;
 
   [[nodiscard]] auto
-  html(const std::uint64_t n_reads, const std::uint64_t max_read_len,
+  html(const std::uint64_t n_reads,
+       const std::uint64_t max_read_len,
        const base_group_vec &groups,
        const file_grades &grades) const -> std::string;
 };
diff --git a/src/bam_file.cpp b/src/bam_file.cpp
index bee2257..27d0acc 100644
--- a/src/bam_file.cpp
+++ b/src/bam_file.cpp
@@ -27,30 +27,31 @@
 estimate_n_reads_bam(const std::string &filename)
   -> std::tuple<std::uint64_t, std::uint64_t, std::int64_t> {
   static constexpr auto max_n_reads = 128 * 1024;
-  std::unique_ptr<htsFile, int (*)(htsFile *)> f(
+  const std::unique_ptr<htsFile, int (*)(htsFile *)> in(
     hts_open(std::data(filename), "r"), &hts_close);
-  if (!f)
+  if (!in)
     throw std::system_error(std::make_error_code(std::errc(errno)),
                             "failed to open file: " + filename);
-  std::unique_ptr<sam_hdr_t, void (*)(sam_hdr_t *)> h(sam_hdr_read(f.get()),
-                                                      &sam_hdr_destroy);
+  const std::unique_ptr<sam_hdr_t, void (*)(sam_hdr_t *)> h(
+    sam_hdr_read(in.get()), &sam_hdr_destroy);
   if (!h)
     throw std::system_error(std::make_error_code(std::errc(errno)),
                             "failed to read header: " + filename);
 
-  const auto format = hts_get_format(f.get());
+  const auto format = hts_get_format(in.get());
   if (!format)
     throw std::runtime_error("failed to identify file format: " + filename);
 
   // NOLINTNEXTLINE(cppcoreguidelines-pro-type-union-access)
-  const auto fp = format->format == bam ? f->fp.bgzf->fp : f->fp.hfile;
+  const auto fp = format->format == bam ? in->fp.bgzf->fp : in->fp.hfile;
   const auto pos_after_header = htell(fp);
-  std::unique_ptr<bam1_t, void (*)(bam1_t *)> rec(bam_init1(), &bam_destroy1);
+  const std::unique_ptr<bam1_t, void (*)(bam1_t *)> rec(bam_init1(),
+                                                        &bam_destroy1);
   std::uint64_t n_reads{};
   std::uint64_t total_read_len{};
   int r{};
   while (n_reads++ < max_n_reads &&
-         (r = sam_read1(f.get(), h.get(), rec.get())) >= 0)
+         (r = sam_read1(in.get(), h.get(), rec.get())) >= 0)
     total_read_len += rec->core.l_qseq;
   if (r < -1)  // error
     throw std::system_error(std::make_error_code(std::errc(errno)),
@@ -71,13 +72,13 @@ init_dups(const std::string &filename, const std::uint64_t n_unique)
     return "TNGNNNCNNNNNNNNNNNNA"[x - 'A'];
   };
   static constexpr auto n_unique_multiplier = 10;
-  std::unique_ptr<htsFile, int (*)(htsFile *)> f(
+  const std::unique_ptr<htsFile, int (*)(htsFile *)> in(
     hts_open(std::data(filename), "r"), &hts_close);
-  if (!f)
+  if (!in)
     throw std::system_error(std::make_error_code(std::errc(errno)),
                             "failed to open file: " + filename);
-  std::unique_ptr<sam_hdr_t, void (*)(sam_hdr_t *)> h(sam_hdr_read(f.get()),
-                                                      &sam_hdr_destroy);
+  const std::unique_ptr<sam_hdr_t, void (*)(sam_hdr_t *)> h(
+    sam_hdr_read(in.get()), &sam_hdr_destroy);
   if (!h)
     throw std::system_error(std::make_error_code(std::errc(errno)),
                             "failed to read header: " + filename);
@@ -90,7 +91,7 @@ init_dups(const std::string &filename, const std::uint64_t n_unique)
   std::uint64_t n_reads{};
   const auto max_n_reads = n_unique_multiplier * n_unique;
   while (n_reads++ < max_n_reads && std::size(dups) < n_unique &&
-         (r = sam_read1(f.get(), h.get(), rec.get())) >= 0) {
+         (r = sam_read1(in.get(), h.get(), rec.get())) >= 0) {
     const auto l_qseq = rec->core.l_qseq;
     const auto seq = bam_get_seq(rec.get());
     if (std::ssize(buffer) < l_qseq)
@@ -111,8 +112,8 @@ init_dups(const std::string &filename, const std::uint64_t n_unique)
 }
 
 auto
-bam_file::load_next(const std::int32_t file_id,  //
-                    task_queue &tq,              //
+bam_file::load_next(const std::int32_t file_id,
+                    task_queue &tq,
                     std::atomic_int32_t &n_tasks) -> void {
   is_first_load = false;
   if (output_cursor > 0) {
@@ -133,12 +134,12 @@ bam_file::load_next(const std::int32_t file_id,  //
   input_last = std::distance(std::data(input_buffer), in_itr);
 }
 
-[[nodiscard]] inline auto
-partition(auto itr,                     //
-          const auto end,               //
-          const std::int64_t n_chunks,  //
-          const std::int32_t file_id,   //
-          task_queue &tq,               //
+[[nodiscard]] static inline auto
+partition(auto itr,
+          const auto end,
+          const std::int64_t n_chunks,
+          const std::int32_t file_id,
+          task_queue &tq,
           std::atomic_int32_t &n_tasks) {
   // ADS: this isn't working as desired: the end position of each part should be
   // the first record end past the 'end_itr' below unless end_itr == end
@@ -146,10 +147,10 @@ partition(auto itr,                     //
   const auto chunk_size = (dist + n_chunks - 1) / n_chunks;
   while (itr != end) {
     dist = std::distance(itr, end);
-    auto end_itr = itr + (dist < chunk_size ? dist : chunk_size);
+    const auto end_itr = itr + (dist < chunk_size ? dist : chunk_size);
     // ADS: find_end_pos doesn't find end pos of a record, but of a range, so
     // includes multiple records
-    auto next_itr = bamrec::find_end_pos(itr, end_itr);
+    const auto next_itr = bamrec::find_end_pos(itr, end_itr);
     if (next_itr == itr)
       break;
     ++n_tasks;
@@ -160,9 +161,9 @@ partition(auto itr,                     //
 }
 
 auto
-bam_file::get_chunks(const std::int64_t n_chunks,  //
-                     const std::int32_t file_id,   //
-                     task_queue &tq,               //
+bam_file::get_chunks(const std::int64_t n_chunks,
+                     const std::int32_t file_id,
+                     task_queue &tq,
                      std::atomic_int32_t &n_tasks) -> void {
   // Swap so the input buffer can be used to inflate more data and the former
   // input buffer has been inflated and will provide data for analysis
@@ -179,9 +180,9 @@ bam_file::get_chunks(const std::int64_t n_chunks,  //
 }
 
 auto
-bam_file::make_tasks(const std::int64_t n_threads,  //
-                     const std::int32_t file_id,    //
-                     task_queue &tq,                //
+bam_file::make_tasks(const std::int64_t n_threads,
+                     const std::int32_t file_id,
+                     task_queue &tq,
                      std::atomic_int32_t &n_tasks) -> void {
   static constexpr auto n_chunks_per_thread = 8;
   const auto n_chunks = n_chunks_per_thread * n_threads;
diff --git a/src/bam_file.hpp b/src/bam_file.hpp
index 93b52e4..00a7f27 100644
--- a/src/bam_file.hpp
+++ b/src/bam_file.hpp
@@ -49,9 +49,9 @@ class bam_file {
 
 public:
   bam_file(const std::string &filename, const std::int64_t buf_size) :
-    input_buffer(get_input_buffer_size(buf_size) + min_buf_size),    //
-    output_buffer(get_output_buffer_size(buf_size) + min_buf_size),  //
-    br(filename, get_reader_buffer_size(buf_size))                   //
+    input_buffer(get_input_buffer_size(buf_size) + min_buf_size),
+    output_buffer(get_output_buffer_size(buf_size) + min_buf_size),
+    br(filename, get_reader_buffer_size(buf_size))  //
   {}
 
   // clang-format off
@@ -71,10 +71,10 @@ class bam_file {
   reset(bam_file &reads_file) -> void;
 
   friend auto
-  make_tasks(bam_file &reads_file,          //
-             const std::int64_t n_threads,  //
-             const std::int32_t file_id,    //
-             task_queue &tq,                //
+  make_tasks(bam_file &reads_file,
+             const std::int64_t n_threads,
+             const std::int32_t file_id,
+             task_queue &tq,
              std::atomic_int32_t &n_tasks) -> void;
 
 private:
@@ -88,20 +88,26 @@ class bam_file {
   }
 
   auto
-  get_chunks(const std::int64_t n_chunks, const std::int32_t file_id,
-             task_queue &tq, std::atomic_int32_t &n_tasks) -> void;
+  get_chunks(const std::int64_t n_chunks,
+             const std::int32_t file_id,
+             task_queue &tq,
+             std::atomic_int32_t &n_tasks) -> void;
 
   auto
-  load_next(const std::int32_t file_id, task_queue &tq,
+  load_next(const std::int32_t file_id,
+            task_queue &tq,
             std::atomic_int32_t &n_tasks) -> void;
 
   auto
-  make_tasks_inflate(const std::int32_t file_id, task_queue &tq,
+  make_tasks_inflate(const std::int32_t file_id,
+                     task_queue &tq,
                      std::atomic_int32_t &n_tasks) -> void;
 
   auto
-  make_tasks(const std::int64_t n_chunks, const std::int32_t file_id,
-             task_queue &tq, std::atomic_int32_t &n_tasks) -> void;
+  make_tasks(const std::int64_t n_chunks,
+             const std::int32_t file_id,
+             task_queue &tq,
+             std::atomic_int32_t &n_tasks) -> void;
 
   [[nodiscard]] auto
   inflate_only() const -> bool {
@@ -128,10 +134,10 @@ init_dups(const std::string &filename, const std::uint64_t n_unique)
   -> dups_map_t;
 
 inline auto
-make_tasks(bam_file &reads_file,          //
-           const std::int64_t n_threads,  //
-           const std::int32_t file_id,    //
-           task_queue &tq,                //
+make_tasks(bam_file &reads_file,
+           const std::int64_t n_threads,
+           const std::int32_t file_id,
+           task_queue &tq,
            std::atomic_int32_t &n_tasks) -> void {
   n_tasks = 1;  // for current task, which makes tasks
   if (!reads_file.inflate_only())
diff --git a/src/bam_header.cpp b/src/bam_header.cpp
index 5f7bd3e..13b9275 100644
--- a/src/bam_header.cpp
+++ b/src/bam_header.cpp
@@ -6,8 +6,8 @@
 #include <stdexcept>
 
 [[nodiscard]] auto
-bam_header::update(const_iterator itr,
-                   const const_iterator end) -> const_iterator {
+bam_header::update(const_iterator itr, const const_iterator end)
+  -> const_iterator {
   static constexpr auto msg = "incorrect BAM magic identified: {} at {}";
   const auto update_u32 = [](auto &val, const auto inc, const auto the_byte) {
     // NOLINTNEXTLINE(*-avoid-magic-numbers)
diff --git a/src/bam_header.hpp b/src/bam_header.hpp
index 8f4068f..0905849 100644
--- a/src/bam_header.hpp
+++ b/src/bam_header.hpp
@@ -56,10 +56,14 @@ struct bam_header {
     }
   }
 
-  NLOHMANN_DEFINE_TYPE_INTRUSIVE(bam_header, magic_bytes_remaining,
-                                 l_text_bytes_remaining, l_text,
-                                 n_ref_bytes_remaining, n_ref,
-                                 l_name_bytes_remaining, name_bytes_remaining,
+  NLOHMANN_DEFINE_TYPE_INTRUSIVE(bam_header,
+                                 magic_bytes_remaining,
+                                 l_text_bytes_remaining,
+                                 l_text,
+                                 n_ref_bytes_remaining,
+                                 n_ref,
+                                 l_name_bytes_remaining,
+                                 name_bytes_remaining,
                                  l_ref_bytes_remaining);
 };
 
diff --git a/src/bamrec.cpp b/src/bamrec.cpp
index b951e6c..ed9eb6a 100644
--- a/src/bamrec.cpp
+++ b/src/bamrec.cpp
@@ -64,8 +64,8 @@ assign_sequence(bidir_itr_t first, auto last, output_itr_t d_first) {
 }
 
 [[nodiscard]] auto
-bamrec::get_next(bamrec::pos_t &itr, const bamrec::pos_t end,
-                 bamrec &rec) -> bool {
+bamrec::get_next(bamrec::pos_t &itr, const bamrec::pos_t end, bamrec &rec)
+  -> bool {
   if (std::distance(itr, end) < bam_core_t::sz)
     return false;
   bam_core_t core{};
@@ -80,7 +80,7 @@ bamrec::get_next(bamrec::pos_t &itr, const bamrec::pos_t end,
   auto out_itr = std::begin(rec.buffer);
   std::copy_n(itr + bam_core_t::read_name_offset, rec.name_len, out_itr);
   out_itr += rec.name_len;  // increment data cursor to sequence
-  auto seq_in = itr + core.seq_offset();
+  const auto seq_in = itr + core.seq_offset();
   if (core.bam_is_rev())
     assign_sequence_revcomp(seq_in, core.l_seq, out_itr);
   else
@@ -102,8 +102,8 @@ bamrec::get_next(bamrec::pos_t &itr, const bamrec::pos_t end,
 }
 
 [[nodiscard]] auto
-bamrec::find_end_pos(bamrec::pos_t itr,
-                     const bamrec::pos_t end) -> bamrec::pos_t {
+bamrec::find_end_pos(bamrec::pos_t itr, const bamrec::pos_t end)
+  -> bamrec::pos_t {
   static constexpr std::int64_t record_size_size = sizeof(std::uint32_t);
   std::uint32_t record_size{};
   while (itr != end) {
diff --git a/src/base_groups.cpp b/src/base_groups.cpp
index ab09bbc..331cca7 100644
--- a/src/base_groups.cpp
+++ b/src/base_groups.cpp
@@ -36,7 +36,8 @@ get_linear_interval(const std::uint64_t n_bases,
 }
 
 [[nodiscard]] auto
-make_base_groups(const std::uint64_t n_bases, const std::uint64_t n_initial,
+make_base_groups(const std::uint64_t n_bases,
+                 const std::uint64_t n_initial,
                  const std::uint64_t n_groups_target) -> base_group_vec {
   static constexpr auto make_one_group = [](const auto a, const auto b) {
     return base_group_t{a, b};
diff --git a/src/base_groups.hpp b/src/base_groups.hpp
index 2dcbc06..a07e7f2 100644
--- a/src/base_groups.hpp
+++ b/src/base_groups.hpp
@@ -19,7 +19,8 @@ using base_group_t = std::pair<std::uint64_t, std::uint64_t>;
 using base_group_vec = std::vector<base_group_t>;
 
 [[nodiscard]] auto
-make_base_groups(const std::uint64_t n_bases, const std::uint64_t n_initial,
+make_base_groups(const std::uint64_t n_bases,
+                 const std::uint64_t n_initial,
                  const std::uint64_t n_groups_target) -> base_group_vec;
 
 [[nodiscard]] auto
diff --git a/src/bgzf_block.cpp b/src/bgzf_block.cpp
index d22f1b2..67a106c 100644
--- a/src/bgzf_block.cpp
+++ b/src/bgzf_block.cpp
@@ -6,6 +6,7 @@
 
 #include <cassert>
 #include <cstdlib>
+#include <utility>
 
 auto
 bgzf_block_t::decompress() -> void {
@@ -21,6 +22,6 @@ bgzf_block_t::decompress() -> void {
     size,                                                          //
     &inflated_size);
   assert(result == LIBDEFLATE_SUCCESS &&
-         inflated_size == static_cast<std::size_t>(size));
+         std::cmp_equal(inflated_size, static_cast<std::size_t>(size)));
   libdeflate_free_decompressor(decompressor);
 }
diff --git a/src/bgzf_reader.cpp b/src/bgzf_reader.cpp
index 767a14a..a23f34e 100644
--- a/src/bgzf_reader.cpp
+++ b/src/bgzf_reader.cpp
@@ -34,7 +34,7 @@ get_isize(const auto data, const auto data_size) {
   return data_size < isize_size ? 0 : get_unaligned_le32(data_isize);
 }
 
-auto
+static inline auto
 assign(gzip_header &hdr, const auto data) -> void {
   // ADS: data from the file takes 18 bytes, the fields of the struct take 18
   // bytes, but the struct occupies 20 due to uint32_t members
@@ -75,7 +75,7 @@ bgzf_reader::read_data() -> bool {
   return n_bytes > 0;
 }
 
-[[nodiscard]] inline constexpr auto
+[[nodiscard]] static inline constexpr auto
 get_gzip_body_size(const gzip_header &gh) -> std::uint32_t {
   return (static_cast<std::uint32_t>(gh.size) + 1) - gzip_header_size;
 }
diff --git a/src/duplication_results.cpp b/src/duplication_results.cpp
index a1f6a03..0a33242 100644
--- a/src/duplication_results.cpp
+++ b/src/duplication_results.cpp
@@ -127,8 +127,8 @@ duplication_results::get_overrepresented(const std::uint64_t n_reads) const
 }
 
 auto
-duplication_results::initialize(const run_mode &mode,
-                                const file_info &info) -> void {
+duplication_results::initialize(const run_mode &mode, const file_info &info)
+  -> void {
   read_skip =
     info.n_reads_est < max_n_reads_total
       ? 0
@@ -138,7 +138,8 @@ duplication_results::initialize(const run_mode &mode,
 }
 
 auto
-duplication_results::initialize(const run_mode &mode, const file_info &info,
+duplication_results::initialize(const run_mode &mode,
+                                const file_info &info,
                                 const dups_init_t &dups_init) -> void {
   initialize(mode, info);
   dups = dups_init.dups_zero;
@@ -194,9 +195,10 @@ make_bins(const auto &breaks, const auto &hist) {
 }
 
 // ADS: for original dups, from FastQC extrapolation of dup counts.
-[[nodiscard]] auto
+[[nodiscard]] static auto
 get_corrected_count(const std::uint64_t count_at_limit,
-                    const std::uint64_t n_reads, const std::uint64_t dup_level,
+                    const std::uint64_t n_reads,
+                    const std::uint64_t dup_level,
                     const std::uint64_t n_obs) -> double {
   static constexpr auto epsilon = 0.01;
   if (count_at_limit == n_reads)  // we saw everything
@@ -243,10 +245,10 @@ duplication_results::get_dups_summary(const std::uint64_t n_reads) const
       [](const auto x) { return std::get<0>(x) * std::get<1>(x); }) |
     std::ranges::to<std::vector>();
   return dup_summary_t{
-    max_dup,
-    n_reads,                // number of counted reads
-    std::move(hist_mass),   // move to avoid copying when making tuple
-    std::move(hist_dedup),  // move to avoid copying when making tuple
+    .max_dup = max_dup,
+    .n_reads = n_reads,                   // number of counted reads
+    .hist_mass = std::move(hist_mass),    // move to avoid copy making tuple
+    .hist_dedup = std::move(hist_dedup),  // move to avoid copy making tuple
   };
 }
 
@@ -264,10 +266,10 @@ duplication_results::get_dups_summary() const -> dup_summary_t {
       [](const auto x) { return std::get<0>(x) * std::get<1>(x); }) |
     std::ranges::to<std::vector>();
   return dup_summary_t{
-    max_dup,
-    get_n_counted_reads(),  // number of counted reads
-    std::move(hist_mass),   // move to avoid copying when making tuple
-    std::move(hist_dedup),  // move to avoid copying when making tuple
+    .max_dup = max_dup,
+    .n_reads = get_n_counted_reads(),     // number of counted reads
+    .hist_mass = std::move(hist_mass),    // move to avoid copy making tuple
+    .hist_dedup = std::move(hist_dedup),  // move to avoid copy making tuple
   };
 }
 
@@ -285,8 +287,8 @@ get_grade_duplication(const dup_summary_t &summary) -> std::string {
 }
 
 [[nodiscard]] auto
-duplication_report(const dup_summary_t &summary,
-                   const file_grades &grades) -> std::string {
+duplication_report(const dup_summary_t &summary, const file_grades &grades)
+  -> std::string {
   static constexpr auto label = "duplication";
   static constexpr auto start_tag = ">>Sequence Duplication Levels\t{}\n"
                                     "#Total Deduplicated Percentage\t{:.6f}\n";
@@ -349,8 +351,8 @@ overrepresented_html(const std::vector<overrep_t> &overrep,
 }
 
 [[nodiscard]] auto
-duplication_html(const dup_summary_t &summary,
-                 const file_grades &grades) -> std::string {
+duplication_html(const dup_summary_t &summary, const file_grades &grades)
+  -> std::string {
   static constexpr auto label = "duplication";
   static constexpr auto plot_format = R"(<div id="duplication_plot"></div>
 <script>Plotly.newPlot("duplication_plot",
diff --git a/src/duplication_results.hpp b/src/duplication_results.hpp
index 322b583..4290c98 100644
--- a/src/duplication_results.hpp
+++ b/src/duplication_results.hpp
@@ -62,7 +62,8 @@ struct duplication_results {
   dups_map_t dups;
 
   auto
-  initialize(const run_mode &mode, const file_info &info,
+  initialize(const run_mode &mode,
+             const file_info &info,
              const dups_init_t &dups_init) -> void;
 
   auto
diff --git a/src/falco.cpp b/src/falco.cpp
index cb055eb..6c8fc46 100644
--- a/src/falco.cpp
+++ b/src/falco.cpp
@@ -111,7 +111,8 @@ write_file(const auto &filename, const auto &data) {
 
 static auto
 write_output(
-  const run_mode &mode, std::vector<file_info> &infos,
+  const run_mode &mode,
+  std::vector<file_info> &infos,
   const std::vector<std::string> &outdirs,
   // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
   std::vector<results_collector> &&results) {
@@ -174,7 +175,8 @@ make_reads_file_stdin(const std::vector<file_info> &infos,
 }
 
 [[nodiscard]] static auto
-make_reads_files(const run_mode &mode, const std::vector<file_info> &infos,
+make_reads_files(const run_mode &mode,
+                 const std::vector<file_info> &infos,
                  const std::vector<std::string> &infiles,
                  const std::int64_t buffer_size) -> std::vector<reads_file_t> {
   // ADS: need to do this differently for stdin
@@ -199,7 +201,7 @@ get_file_info_stdin(const std::vector<std::string> &names,
   info.tile_id_position = ft_tile.second;
   info.n_reads_est = n_reads_est;
   info.read_len_est = read_len_est;
-  return std::vector<file_info>(1, info);
+  return std::vector{1, info};
 }
 
 [[nodiscard]] static auto
@@ -237,8 +239,8 @@ get_file_info(const auto &infiles) {
 }
 
 [[nodiscard]] static auto
-make_outdirs(const auto &ins, const auto &outdir,
-             const bool keep_extn = false) -> std::vector<std::string> {
+make_outdirs(const auto &ins, const auto &outdir, const bool keep_extn = false)
+  -> std::vector<std::string> {
   namespace fs = std::filesystem;
   fs::create_directory(outdir);
   const auto compose_dirname = [&](const auto &fname) {
@@ -343,13 +345,13 @@ main(int argc, char *argv[]) {
     argv = app.ensure_utf8(argv);
     app.usage(
       std::format("Usage: {} [options] -o OUTDIR INFILES", PROJECT_NAME));
-    if (argc >= 2)
-      app.footer(std::format(description, falco::get_share_dir()));
+    app.footer(std::format(description, falco::get_share_dir()));
 
     // clang-format off
     // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
     app.get_formatter()->long_option_alignment_ratio(0.2);
     app.set_help_flag("-h,--help", "Print more detailed help");
+    // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
     app.set_version_flag("--version", VERSION, "Print program version");
     app.add_flag("--license", [&](auto) {
       std::print("{}", license_text); throw CLI::Success(); },
@@ -511,7 +513,7 @@ main(int argc, char *argv[]) {
     buffer_size = buffer_size < max_sz ? buffer_size : min_buf_size;
 
     const auto min_buffer_size = get_min_buffer_size(max_read_length);
-    if (min_buffer_size > buffer_size) {
+    if (std::cmp_greater(min_buffer_size, buffer_size)) {
       buffer_size = min_buffer_size;
       if (verbose)
         std::println("buffer size increased to accommodate max read length");
diff --git a/src/falco_analyzer.cpp b/src/falco_analyzer.cpp
index 85672b5..1938fac 100644
--- a/src/falco_analyzer.cpp
+++ b/src/falco_analyzer.cpp
@@ -28,11 +28,13 @@
 class run_mode;
 
 [[nodiscard]] auto
-analyze(const std::uint32_t n_threads, const run_mode &mode,
-        std::vector<file_info> &infos, std::vector<reads_file_t> reads_files,
+analyze(const std::uint32_t n_threads,
+        const run_mode &mode,
+        std::vector<file_info> &infos,
+        std::vector<reads_file_t> reads_files,
         std::vector<dups_init_t> dups_init) -> std::vector<results_collector> {
   assert(std::size(reads_files) == std::size(infos));
-  const std::int32_t n_files = static_cast<std::int32_t>(std::size(infos));
+  const auto n_files = static_cast<std::int32_t>(std::size(infos));
   if (dups_init.empty())
     dups_init.resize(n_files);
   std::atomic_uint32_t n_active_files{static_cast<std::uint32_t>(n_files)};
diff --git a/src/falco_analyzer.hpp b/src/falco_analyzer.hpp
index 851d54c..7b46d60 100644
--- a/src/falco_analyzer.hpp
+++ b/src/falco_analyzer.hpp
@@ -14,8 +14,10 @@ struct dups_init_t;
 struct file_info;
 
 [[nodiscard]] auto
-analyze(const std::uint32_t n_threads, const run_mode &mode,
-        std::vector<file_info> &infos, std::vector<reads_file_t> reads_files,
+analyze(const std::uint32_t n_threads,
+        const run_mode &mode,
+        std::vector<file_info> &infos,
+        std::vector<reads_file_t> reads_files,
         std::vector<dups_init_t> dups_init) -> std::vector<results_collector>;
 
 #endif  // SRC_FALCO_ANALYZER_HPP_
diff --git a/src/falco_config.cpp b/src/falco_config.cpp
index a5f6e76..0c5f5c4 100644
--- a/src/falco_config.cpp
+++ b/src/falco_config.cpp
@@ -22,7 +22,7 @@
 #include <unordered_map>
 #include <vector>
 
-[[nodiscard]] auto
+[[nodiscard]] static auto
 strip(const std::string &s) -> std::string {
   if (s.empty())
     return {};
@@ -34,7 +34,7 @@ strip(const std::string &s) -> std::string {
   return std::string{start, std::cbegin(stop) + 1};
 }
 
-[[nodiscard]] auto
+[[nodiscard]] static auto
 split(const std::string &s) {
   std::istringstream iss(s);
   return std::vector<std::string>{std::istream_iterator<std::string>{iss}, {}};
diff --git a/src/falco_config.hpp b/src/falco_config.hpp
index c65276e..cf5debc 100644
--- a/src/falco_config.hpp
+++ b/src/falco_config.hpp
@@ -9,7 +9,7 @@ class run_mode;
 
 // ADS: run mode is an out-param because it might be partially set already
 auto
-load_config_and_set_graders(const std::string &filename,
-                            run_mode &mode) -> void;
+load_config_and_set_graders(const std::string &filename, run_mode &mode)
+  -> void;
 
 #endif  // SRC_FALCO_CONFIG_HPP_
diff --git a/src/falco_file_format.cpp b/src/falco_file_format.cpp
index ff4d387..e18353d 100644
--- a/src/falco_file_format.cpp
+++ b/src/falco_file_format.cpp
@@ -16,7 +16,7 @@
 [[nodiscard]] auto
 get_file_format(const std::string &filename)
   -> std::tuple<falco::file_format, std::string> {
-  std::unique_ptr<htsFile, int (*)(htsFile *)> fp(
+  const std::unique_ptr<htsFile, int (*)(htsFile *)> fp(
     hts_open(std::data(filename), "r"), &hts_close);
   if (!fp)
     throw std::runtime_error("failed to open file: " + filename);
diff --git a/src/falco_file_format.hpp b/src/falco_file_format.hpp
index b8c0c64..2bb5253 100644
--- a/src/falco_file_format.hpp
+++ b/src/falco_file_format.hpp
@@ -27,20 +27,21 @@ enum class file_format : std::uint8_t {
 
 // clang-format off
 static constexpr auto file_format_names_impl = std::array{
-  "unknown",     //
-  "fastq",       //
-  "fastq_gz",    //
-  "fastq_bgzf",  //
-  "sam",         //
-  "bam",         //
+  "unknown",
+  "fastq",
+  "fastq_gz",
+  "fastq_bgzf",
+  "sam",
+  "bam",
 };
 // clang-format on
 
 static constexpr std::span file_format_names = file_format_names_impl;
 
+// clang-format off
 // NOLINTNEXTLINE
-NLOHMANN_JSON_SERIALIZE_ENUM(  //
-  file_format,                 //
+NLOHMANN_JSON_SERIALIZE_ENUM(
+  file_format,
   {
     {file_format::unknown, "unknown"},
     {file_format::fastq, "fastq"},
@@ -49,6 +50,7 @@ NLOHMANN_JSON_SERIALIZE_ENUM(  //
     {file_format::sam, "SAM"},
     {file_format::bam, "BAM"},
   })
+// clang-format on
 
 [[nodiscard]] constexpr inline auto
 is_mapped_reads(const file_format f) {
diff --git a/src/falco_grade.cpp b/src/falco_grade.cpp
index 8f1a827..61295fa 100644
--- a/src/falco_grade.cpp
+++ b/src/falco_grade.cpp
@@ -71,19 +71,20 @@ file_grades::get_title(const std::string &name) -> std::string {
 
 [[nodiscard]] auto
 grader::identify_grade(const double value) const -> std::string {
+  using std::string_literals::operator""s;
   if (warn < fail) {
     if (value < warn)
-      return "pass";
+      return "pass"s;
     if (value < fail)
-      return "warn";
-    return "fail";
+      return "warn"s;
+    return "fail"s;
   }
   else {
     if (value < fail)
-      return "fail";
+      return "fail"s;
     if (value < warn)
-      return "warn";
-    return "pass";
+      return "warn"s;
+    return "pass"s;
   }
   throw std::runtime_error(
     std::format("value {} outside grade range: {}", value, *this));
@@ -92,7 +93,7 @@ grader::identify_grade(const double value) const -> std::string {
 [[nodiscard]] auto
 grader::to_string() const -> std::string {
   static constexpr auto n_indent = 4;
-  nlohmann::json data = *this;
+  const nlohmann::json data = *this;
   return data.dump(n_indent);
 }
 
@@ -147,8 +148,8 @@ get_grade_gc_sequence(const std::vector<double> &gc_content) -> std::string {
   return grader_set::get_grade(label, sum_deviation_from_normal(gc_content));
 }
 
-[[nodiscard]] inline constexpr auto
-single_delta(const auto a, const auto b, const auto tot) {
+[[nodiscard]] static inline constexpr auto
+single_delta(const auto a, const auto b, const auto tot) -> double {
   return pct(as_frac(a, tot)) - pct(as_frac(b, tot));
 }
 
diff --git a/src/falco_utils.cpp b/src/falco_utils.cpp
index 51525e2..da425d7 100644
--- a/src/falco_utils.cpp
+++ b/src/falco_utils.cpp
@@ -13,6 +13,7 @@
 #include <sstream>
 #include <string>
 #include <tuple>
+#include <utility>
 #include <vector>
 
 [[nodiscard]] auto
@@ -95,7 +96,7 @@ smooth_gc_content(const std::vector<double> &data,
   const auto get_mean = [&](std::ranges::viewable_range auto &&r) {
     return as_frac(std::reduce(std::cbegin(r), std::cend(r)), std::size(r));
   };
-  assert(window_size < static_cast<std::int64_t>(std::size(data)));
+  assert(std::cmp_less(window_size, std::size(data)));
   std::vector<double> smoothed;
   for (auto w = 1; w < (window_size + 1) / 2; ++w)
     smoothed.push_back(get_mean(
@@ -163,6 +164,7 @@ format_program_start_date_and_time() -> std::string {
   const auto t = get_program_start_time();
   const auto t_c = std::chrono::system_clock::to_time_t(t);
   std::ostringstream oss;
+  // NOLINTNEXTLINE(concurrency-mt-unsafe)
   oss << std::put_time(std::localtime(&t_c), "%F %T %Z");
   return oss.str();
 }
diff --git a/src/falco_utils.hpp b/src/falco_utils.hpp
index 104b050..504fa4d 100644
--- a/src/falco_utils.hpp
+++ b/src/falco_utils.hpp
@@ -183,7 +183,8 @@ add(std::ranges::forward_range auto &a1,
 
 inline constexpr auto
 add(std::ranges::forward_range auto &a1,
-    const std::ranges::forward_range auto &a2, const auto adder) {
+    const std::ranges::forward_range auto &a2,
+    const auto adder) {
   std::ranges::transform(a1, a2, std::begin(a1), adder);
 };
 
@@ -225,7 +226,8 @@ add_and_consume(std::ranges::forward_range auto &a1,
 
 inline constexpr auto
 add_and_consume(std::ranges::forward_range auto &a1,
-                std::ranges::forward_range auto a2_sink, const auto adder) {
+                std::ranges::forward_range auto a2_sink,
+                const auto adder) {
   std::ranges::transform(a1, a2_sink, std::begin(a1), adder);
 };
 
@@ -263,7 +265,8 @@ ipow(const auto b, const auto e) -> std::remove_cvref_t<decltype(b)> {
 }
 
 inline constexpr auto
-count_nucs(auto seq_itr, const auto seq_end,
+count_nucs(auto seq_itr,
+           const auto seq_end,
            auto &tab) {  // cppcheck-suppress constParameterReference
   auto out_itr = std::begin(tab);
   while (seq_itr != seq_end)
@@ -271,7 +274,8 @@ count_nucs(auto seq_itr, const auto seq_end,
 }
 
 inline constexpr auto
-count_ns(auto seq_itr, const auto seq_end,
+count_ns(auto seq_itr,
+         const auto seq_end,
          auto &tab) {  // cppcheck-suppress constParameterReference
   auto out_itr = std::begin(tab);
   while (seq_itr != seq_end)
@@ -340,8 +344,8 @@ five_quants(const auto &a) -> std::array<std::uint32_t, 5> {
 // NOLINTEND(cppcoreguidelines-avoid-magic-numbers)
 
 [[nodiscard]] auto
-size_to_units(const std::int64_t s,
-              const std::string &suffix = "iB") -> std::string;
+size_to_units(const std::int64_t s, const std::string &suffix = "iB")
+  -> std::string;
 
 [[nodiscard]] inline auto
 get_max_size(const auto &x) {
@@ -351,8 +355,8 @@ get_max_size(const auto &x) {
 }
 
 [[nodiscard]] inline auto
-estimate_read_length_fastq_chunk(const auto &data,
-                                 const auto n) -> std::uint64_t {
+estimate_read_length_fastq_chunk(const auto &data, const auto n)
+  -> std::uint64_t {
   static constexpr auto fastq_lines_per_read = 4;
   assert(n >= 1);
   const auto valid = [](const auto c) {
diff --git a/src/fastq_bgzf_file.cpp b/src/fastq_bgzf_file.cpp
index 8f5ff82..acd5b6d 100644
--- a/src/fastq_bgzf_file.cpp
+++ b/src/fastq_bgzf_file.cpp
@@ -21,7 +21,7 @@
 #include <ranges>
 #include <string>
 #include <system_error>
-#include <tuple>  // IWYU pragma: keep
+#include <tuple>
 #include <utility>
 #include <vector>
 
@@ -30,15 +30,18 @@ estimate_n_reads_fastq_bgzf(const std::string &filename)
   -> std::tuple<std::uint64_t, std::uint64_t, std::int64_t> {
   static constexpr auto fastq_lines_per_read = 4;
   static constexpr auto n_bytes = 1024 * 1024;
-  std::unique_ptr<BGZF, int (*)(BGZF *)> f(bgzf_open(std::data(filename), "r"),
-                                           &bgzf_close);
+  const std::unique_ptr<BGZF, int (*)(BGZF *)> in(
+    bgzf_open(std::data(filename), "r"), &bgzf_close);
+  if (!in)
+    throw std::system_error(std::make_error_code(std::errc(errno)),
+                            "failed to open file: " + filename);
   std::vector<std::uint8_t> buf(n_bytes);
-  const auto r = bgzf_read(f.get(), std::data(buf), n_bytes);
+  const auto r = bgzf_read(in.get(), std::data(buf), n_bytes);
   if (r < 0)
     throw std::system_error(std::make_error_code(std::errc(errno)),
                             "failed reading gz input file");
   // ADS: 'htell' function works below because 'f' has no threadpool
-  const auto n_compressed_bytes = htell(f.get()->fp);
+  const auto n_compressed_bytes = htell(in.get()->fp);
   const auto total_newlines = std::ranges::count(buf, '\n');
 
   const auto inflation_factor = as_frac(n_bytes, n_compressed_bytes);
@@ -56,9 +59,9 @@ estimate_n_reads_fastq_bgzf(const std::string &filename)
 init_dups_fq(const std::string &filename, const std::uint64_t n_unique)
   -> dups_map_t {
   static constexpr auto n_unique_multiplier = 10;
-  std::unique_ptr<BGZF, int (*)(BGZF *)> f(bgzf_open(std::data(filename), "r"),
-                                           &bgzf_close);
-  if (f.get() == nullptr)
+  const std::unique_ptr<BGZF, int (*)(BGZF *)> in(
+    bgzf_open(std::data(filename), "r"), &bgzf_close);
+  if (!in)
     throw std::system_error(std::make_error_code(std::errc(errno)),
                             "failed to open file: " + filename);
   dups_map_t dups;
@@ -68,7 +71,7 @@ init_dups_fq(const std::string &filename, const std::uint64_t n_unique)
   std::uint64_t n_reads{};
   const auto max_n_reads = n_unique_multiplier * n_unique;
   while (n_reads < max_n_reads && std::size(dups) < n_unique &&
-         (r = bgzf_getline(f.get(), '\n', &s)) >= 0) {
+         (r = bgzf_getline(in.get(), '\n', &s)) >= 0) {
     if (n_lines % 4 == 1) {
       const auto l_qseq = ks_len(&s);
       const auto seq = ks_c_str(&s);
@@ -85,7 +88,8 @@ init_dups_fq(const std::string &filename, const std::uint64_t n_unique)
 }
 
 auto
-fastq_bgzf_file::load_next(const std::int32_t file_id, task_queue &tq,
+fastq_bgzf_file::load_next(const std::int32_t file_id,
+                           task_queue &tq,
                            std::atomic_int32_t &n_tasks) -> void {
   is_first_load = false;
   if (output_cursor > 0) {
@@ -99,7 +103,8 @@ fastq_bgzf_file::load_next(const std::int32_t file_id, task_queue &tq,
   auto in_itr = std::data(input_buffer) + input_last;
   while (br.task_ready() && has_in()) {
     auto task = br.get_decomp_task(in_itr);
-    in_itr += task.size;  // NOLINT(*-pro-bounds-pointer-arithmetic)
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+    in_itr += task.size;
     ++n_tasks;
     tq.push(file_id, std::move(task));
   }
@@ -107,11 +112,10 @@ fastq_bgzf_file::load_next(const std::int32_t file_id, task_queue &tq,
 }
 
 auto
-fastq_bgzf_file::get_chunks(const std::int64_t n_chunks,  //
-                            const std::int32_t file_id,   //
-                            task_queue &tq,               //
-                            std::atomic_int32_t &n_tasks  //
-                            ) -> void {
+fastq_bgzf_file::get_chunks(const std::int64_t n_chunks,
+                            const std::int32_t file_id,
+                            task_queue &tq,
+                            std::atomic_int32_t &n_tasks) -> void {
   static constexpr auto rec_lines = 4;  // FASTQ
   assert(n_chunks > 0);
   std::swap(input_buffer, output_buffer);
@@ -165,7 +169,8 @@ fastq_bgzf_file::get_chunks(const std::int64_t n_chunks,  //
 
 auto
 fastq_bgzf_file::make_tasks(const std::int64_t n_threads,
-                            const std::int32_t file_id, task_queue &tq,
+                            const std::int32_t file_id,
+                            task_queue &tq,
                             std::atomic_int32_t &n_tasks) -> void {
   // ADS: 1 below seems to work best, but not sure why
   static constexpr auto n_chunks_per_thread = 1;
diff --git a/src/fastq_bgzf_file.hpp b/src/fastq_bgzf_file.hpp
index ad010c7..064274d 100644
--- a/src/fastq_bgzf_file.hpp
+++ b/src/fastq_bgzf_file.hpp
@@ -64,16 +64,16 @@ class fastq_bgzf_file {
   ~fastq_bgzf_file() = default;
   // clang-format on
 
-  [[nodiscard]] operator bool() const { return !had_last_chunks; }
+  operator bool() const { return !had_last_chunks; }
 
   friend auto
   reset(fastq_bgzf_file &reads_file) -> void;
 
   friend auto
-  make_tasks(fastq_bgzf_file &reads_file,   //
-             const std::int64_t n_threads,  //
-             const std::int32_t file_id,    //
-             task_queue &tq,                //
+  make_tasks(fastq_bgzf_file &reads_file,
+             const std::int64_t n_threads,
+             const std::int32_t file_id,
+             task_queue &tq,
              std::atomic_int32_t &n_tasks) -> void;
 
 private:
@@ -87,20 +87,26 @@ class fastq_bgzf_file {
   }
 
   auto
-  get_chunks(const std::int64_t n_chunks, const std::int32_t file_id,
-             task_queue &tq, std::atomic_int32_t &n_tasks) -> void;
+  get_chunks(const std::int64_t n_chunks,
+             const std::int32_t file_id,
+             task_queue &tq,
+             std::atomic_int32_t &n_tasks) -> void;
 
   auto
-  load_next(const std::int32_t file_id, task_queue &tq,
+  load_next(const std::int32_t file_id,
+            task_queue &tq,
             std::atomic_int32_t &n_tasks) -> void;
 
   auto
-  make_tasks_inflate(const std::int32_t file_id, task_queue &tq,
+  make_tasks_inflate(const std::int32_t file_id,
+                     task_queue &tq,
                      std::atomic_int32_t &n_tasks) -> void;
 
   auto
-  make_tasks(const std::int64_t n_threads, const std::int32_t file_id,
-             task_queue &tq, std::atomic_int32_t &n_tasks) -> void;
+  make_tasks(const std::int64_t n_threads,
+             const std::int32_t file_id,
+             task_queue &tq,
+             std::atomic_int32_t &n_tasks) -> void;
 
   [[nodiscard]] auto
   inflate_only() const -> bool {
@@ -123,14 +129,14 @@ estimate_n_reads_fastq_bgzf(const std::string &filename)
   -> std::tuple<std::uint64_t, std::uint64_t, std::int64_t>;
 
 [[nodiscard]] auto
-init_dups_fq(const std::string &filename,
-             const std::uint64_t n_unique) -> dups_map_t;
+init_dups_fq(const std::string &filename, const std::uint64_t n_unique)
+  -> dups_map_t;
 
 inline auto
-make_tasks(fastq_bgzf_file &reads_file,   //
-           const std::int64_t n_threads,  //
-           const std::int32_t file_id,    //
-           task_queue &tq,                //
+make_tasks(fastq_bgzf_file &reads_file,
+           const std::int64_t n_threads,
+           const std::int32_t file_id,
+           task_queue &tq,
            std::atomic_int32_t &n_tasks) -> void {
   n_tasks = 1;  // +1 so not to decrement to zero until current thread done
   if (!reads_file.inflate_only())
diff --git a/src/fastq_file.cpp b/src/fastq_file.cpp
index c1fa3a7..b564851 100644
--- a/src/fastq_file.cpp
+++ b/src/fastq_file.cpp
@@ -35,7 +35,7 @@ estimate_n_reads_fastq(const std::string &filename)
   static constexpr auto max_part_size = 1024 * 1024;
   std::vector<char> buffer(max_part_size);
 
-  std::unique_ptr<std::FILE, int (*)(std::FILE *)> in(
+  const std::unique_ptr<std::FILE, int (*)(std::FILE *)> in(
     std::fopen(std::data(filename), "r"), &std::fclose);
   if (!in)
     throw std::system_error(std::make_error_code(std::errc(errno)),
@@ -46,9 +46,10 @@ estimate_n_reads_fastq(const std::string &filename)
   if (filesize < n_parts)
     return {{}, {}, filesize};
 
-  const auto [part_size, remainder] = (filesize < n_parts * max_part_size)
-                                        ? std::ldiv(filesize, n_parts)
-                                        : std::ldiv_t{max_part_size, 0};
+  const auto [part_size, remainder] =
+    (filesize < n_parts * max_part_size)
+      ? std::ldiv(filesize, n_parts)
+      : std::ldiv_t{.quot = max_part_size, .rem = 0};
   auto n_lines = 0LU;
   auto readlen_est = 0LU;
   auto offset = 0L;
@@ -84,17 +85,6 @@ fastq_file::fastq_file(const std::string &filename,
                             "failed to open file: " + filename);
 }
 
-static inline auto
-mmap_fastq(const int fd, const std::int64_t offset, const std::int64_t length,
-           auto &data) {
-  static constexpr auto prot = PROT_READ;
-  static constexpr auto flags = MAP_PRIVATE;
-  data = static_cast<char *>(mmap(nullptr, length, prot, flags, fd, offset));
-  if (data == MAP_FAILED)
-    throw std::system_error(std::make_error_code(std::errc(errno)),
-                            "failed to mmap file");
-}
-
 static inline auto
 cleanup_mmap_fastq(auto &data, std::int64_t &length) {
   if (data == nullptr)
@@ -109,6 +99,17 @@ fastq_file::reset() -> void {
   cleanup_mmap_fastq(mmap_data, length);
 }
 
+static inline auto
+mmap_fastq(const int fd, const std::int64_t offset, const std::int64_t length,
+           auto &data) {
+  static constexpr auto prot = PROT_READ;
+  static constexpr auto flags = MAP_PRIVATE;
+  data = static_cast<char *>(mmap(nullptr, length, prot, flags, fd, offset));
+  if (data == MAP_FAILED)
+    throw std::system_error(std::make_error_code(std::errc(errno)),
+                            "failed to mmap file");
+}
+
 auto
 fastq_file::load_next() -> void {
   // memory mapped data is page aligned but the data we need is not
@@ -129,8 +130,10 @@ fastq_file::load_next() -> void {
 }
 
 auto
-fastq_file::get_chunks(const std::int64_t n_chunks, const std::int32_t file_id,
-                       task_queue &tq, std::atomic_int32_t &n_tasks) -> void {
+fastq_file::get_chunks(const std::int64_t n_chunks,
+                       const std::int32_t file_id,
+                       task_queue &tq,
+                       std::atomic_int32_t &n_tasks) -> void {
   static constexpr auto rec_lines = 4;  // FASTQ
   assert(n_chunks > 0);
   const auto beg_itr = std::begin(buffer);
diff --git a/src/fastq_file.hpp b/src/fastq_file.hpp
index 4a8a126..2d0763c 100644
--- a/src/fastq_file.hpp
+++ b/src/fastq_file.hpp
@@ -60,8 +60,10 @@ struct fastq_file {
   load_next() -> void;
 
   auto
-  get_chunks(const std::int64_t n_chunks, const std::int32_t file_id,
-             task_queue &tq, std::atomic_int32_t &n_tasks) -> void;
+  get_chunks(const std::int64_t n_chunks,
+             const std::int32_t file_id,
+             task_queue &tq,
+             std::atomic_int32_t &n_tasks) -> void;
 };
 
 [[nodiscard]] auto
@@ -69,10 +71,10 @@ estimate_n_reads_fastq(const std::string &filename)
   -> std::tuple<std::uint64_t, std::uint64_t, std::int64_t>;
 
 inline auto
-make_tasks(fastq_file &reads_file,        //
-           const std::int64_t n_threads,  //
-           const std::int32_t file_id,    //
-           task_queue &tq,                //
+make_tasks(fastq_file &reads_file,
+           const std::int64_t n_threads,
+           const std::int32_t file_id,
+           task_queue &tq,
            std::atomic_int32_t &n_tasks) -> void {
   static constexpr auto n_chunks_per_thread = 8;
   const auto n_chunks = n_chunks_per_thread * n_threads;
diff --git a/src/fastq_gz_file.cpp b/src/fastq_gz_file.cpp
index 73460fb..67fdf06 100644
--- a/src/fastq_gz_file.cpp
+++ b/src/fastq_gz_file.cpp
@@ -27,8 +27,8 @@ estimate_n_reads_fastq_gz(const std::string &filename)
   -> std::tuple<std::uint64_t, std::uint64_t, std::int64_t> {
   static constexpr auto fastq_lines_per_read = 4;
   static constexpr auto n_bytes = 1024 * 1024;
-  std::unique_ptr<BGZF, int (*)(BGZF *)> f(bgzf_open(std::data(filename), "r"),
-                                           &bgzf_close);
+  const std::unique_ptr<BGZF, int (*)(BGZF *)> f(
+    bgzf_open(std::data(filename), "r"), &bgzf_close);
   std::vector<std::uint8_t> buf(n_bytes);
   const auto r = bgzf_read(f.get(), std::data(buf), n_bytes);
   if (r < 0)
diff --git a/src/fastq_gz_file.hpp b/src/fastq_gz_file.hpp
index e697cc9..40bf782 100644
--- a/src/fastq_gz_file.hpp
+++ b/src/fastq_gz_file.hpp
@@ -74,7 +74,8 @@ not corrupted please file a bug report at the Falco repo on GitHub.)";
     buf_data = std::data(outbuf);
   }
 
-  [[nodiscard]] operator bool() const {  // does compressed data remain?
+  [[nodiscard]]
+  operator bool() const {  // does compressed data remain?
     return isal_ok && (!std::feof(in.get()) || state.avail_in > 0);
   }
 
@@ -101,8 +102,10 @@ not corrupted please file a bug report at the Falco repo on GitHub.)";
   }
 
   auto
-  get_chunks(const std::int64_t n_chunks, const std::int32_t file_id,
-             task_queue &tq, std::atomic_int32_t &n_tasks) -> void;
+  get_chunks(const std::int64_t n_chunks,
+             const std::int32_t file_id,
+             task_queue &tq,
+             std::atomic_int32_t &n_tasks) -> void;
 
   auto
   reset() -> void {
@@ -203,7 +206,10 @@ class fastq_gz_file {
   ~fastq_gz_file() = default;
   // clang-format on
 
-  [[nodiscard]] operator bool() const { return buf_used == buf_size; }
+  [[nodiscard]]
+  operator bool() const {
+    return buf_used == buf_size;
+  }
 
   auto
   load_next() -> void {
@@ -222,8 +228,10 @@ class fastq_gz_file {
   }
 
   auto
-  get_chunks(const std::int64_t n_chunks, const std::int32_t file_id,
-             task_queue &tq, std::atomic_int32_t &n_tasks) -> void;
+  get_chunks(const std::int64_t n_chunks,
+             const std::int32_t file_id,
+             task_queue &tq,
+             std::atomic_int32_t &n_tasks) -> void;
 
   auto
   reset() -> void {
diff --git a/src/fastq_stdin.cpp b/src/fastq_stdin.cpp
index 6c3c8fb..39f2af0 100644
--- a/src/fastq_stdin.cpp
+++ b/src/fastq_stdin.cpp
@@ -33,8 +33,10 @@ estimate_n_reads_fastq_stdin(const std::string &)
 }
 
 auto
-fastq_stdin::get_chunks(const std::int64_t n_chunks, const std::int32_t file_id,
-                        task_queue &tq, std::atomic_int32_t &n_tasks) -> void {
+fastq_stdin::get_chunks(const std::int64_t n_chunks,
+                        const std::int32_t file_id,
+                        task_queue &tq,
+                        std::atomic_int32_t &n_tasks) -> void {
   static constexpr auto rec_lines = 4;  // FASTQ
   const auto beg_itr = std::begin(buffer);
   const auto end_itr = last;
diff --git a/src/fastq_stdin.hpp b/src/fastq_stdin.hpp
index 6cf2fa8..1603b08 100644
--- a/src/fastq_stdin.hpp
+++ b/src/fastq_stdin.hpp
@@ -40,13 +40,17 @@ struct fastq_stdin {
   }
 
   auto
-  make_tasks(const std::int64_t n_chunks, const std::int32_t file_id,
-             task_queue &tq, std::atomic_int32_t &n_tasks) -> void;
+  make_tasks(const std::int64_t n_chunks,
+             const std::int32_t file_id,
+             task_queue &tq,
+             std::atomic_int32_t &n_tasks) -> void;
 
 private:
   auto
-  get_chunks(const std::int64_t n_chunks, const std::int32_t file_id,
-             task_queue &tq, std::atomic_int32_t &n_tasks) -> void;
+  get_chunks(const std::int64_t n_chunks,
+             const std::int32_t file_id,
+             task_queue &tq,
+             std::atomic_int32_t &n_tasks) -> void;
 
   auto
   shift_output_buffer() -> void;
diff --git a/src/file_info.hpp b/src/file_info.hpp
index f2fb194..c8c6415 100644
--- a/src/file_info.hpp
+++ b/src/file_info.hpp
@@ -33,8 +33,15 @@ struct file_info {
     encoding = e;
   }
 
-  NLOHMANN_DEFINE_TYPE_INTRUSIVE(file_info, name, format, description, size,
-                                 n_reads_est, read_len_est, encoding, has_tiles,
+  NLOHMANN_DEFINE_TYPE_INTRUSIVE(file_info,
+                                 name,
+                                 format,
+                                 description,
+                                 size,
+                                 n_reads_est,
+                                 read_len_est,
+                                 encoding,
+                                 has_tiles,
                                  tile_id_position);
 };
 
diff --git a/src/get_binary_dir.cpp b/src/get_binary_dir.cpp
index 7290a30..3e47bb3 100644
--- a/src/get_binary_dir.cpp
+++ b/src/get_binary_dir.cpp
@@ -5,7 +5,7 @@
 #include <config.h>
 
 #if defined(__linux__)
-#include <limits.h>  // IWYU pragma: keep
+#include <climits>  // IWYU pragma: keep
 #include <unistd.h>
 #elif defined(__APPLE__)
 #include <libproc.h>
diff --git a/src/html.cpp b/src/html.cpp
index ec74c53..3333cd1 100644
--- a/src/html.cpp
+++ b/src/html.cpp
@@ -33,7 +33,7 @@
 #include <utility>  // for pair
 #include <vector>
 
-[[nodiscard]] auto
+[[nodiscard]] static auto
 get_summary(const file_grades &grades) -> std::string {
   static constexpr auto summary_fmt = R"(
 <div class="summary"><h2>Summary</h2>
@@ -53,22 +53,10 @@ get_summary(const file_grades &grades) -> std::string {
 }
 
 [[nodiscard]] auto
-get_html_module(const std::string &label, const std::string &text,
-                const file_grades &grades) -> std::string {
-  static constexpr auto module_fmt =
-    R"(<div class="module">
-<h2 class="{}" id="{}">{}: {}</h2>
-{}
-</div>)";
-  const auto grade = grades.grade(label);
-  const auto title = grades.get_title(label);
-  return fmt::format(module_fmt, label, grade, title, grade, text);
-}
-
-[[nodiscard]] auto
-falco_get_html(const file_info &info, const file_grades &grades,
+falco_get_html(const file_info &info,
+               const file_grades &grades,
                const std::string &analysis_modules) -> std::string {
-  return fmt::format(falco_html_body,                                         //
+  return fmt::format(falco_html_body,
                      fmt::arg("date", format_program_start_date_and_time()),  //
                      fmt::arg("filename", info.name),                         //
                      fmt::arg("style", style),                                //
@@ -342,11 +330,13 @@ yaxis: {{title: "Phred quality", rangemode: "tozero"}},
 }
 
 [[nodiscard]] auto
-basic_stats_html(const file_info &info, const std::uint64_t n_reads,
+basic_stats_html(const file_info &info,
+                 const std::uint64_t n_reads,
                  const std::uint64_t min_read_len,
                  const std::uint64_t max_read_len,
                  const std::uint64_t median_read_len,
-                 const std::uint64_t total_gc, const std::uint64_t total_nucs,
+                 const std::uint64_t total_gc,
+                 const std::uint64_t total_nucs,
                  const file_grades &grades) -> std::string {
   static constexpr auto label = "basic_stats";
   static constexpr auto table_fmt =
@@ -381,8 +371,8 @@ basic_stats_html(const file_info &info, const std::uint64_t n_reads,
 
 [[nodiscard]] auto
 tile_html(const tile_processor::tiles_centered_t &centered,
-          const std::vector<base_group_t> &groups,
-          const file_grades &grades) -> std::string {
+          const std::vector<base_group_t> &groups, const file_grades &grades)
+  -> std::string {
   static constexpr auto label = "tile";
   static constexpr auto n_quants = 20.0;
   // ADS: ??? (-10: red, 0: light blue, +10: dark blue)
@@ -442,8 +432,8 @@ yaxis: {{title: "tile", type: "category"}},
 }
 
 [[nodiscard]] auto
-kmer_html(const std::vector<kmer_result> &results,
-          const file_grades &grades) -> std::string {
+kmer_html(const std::vector<kmer_result> &results, const file_grades &grades)
+  -> std::string {
   static constexpr auto label = "kmer";
   static constexpr auto plot_format = R"(<div id="kmer_plot"></div>
 <script>Plotly.newPlot("kmer_plot",
diff --git a/src/html.hpp b/src/html.hpp
index 7f785b8..2e3fae2 100644
--- a/src/html.hpp
+++ b/src/html.hpp
@@ -26,7 +26,8 @@ static constexpr auto html_module_fmt =
 </div>)";
 
 [[nodiscard]] auto
-falco_get_html(const file_info &info, const file_grades &grades,
+falco_get_html(const file_info &info,
+               const file_grades &grades,
                const std::string &analysis_modules) -> std::string;
 
 [[nodiscard]] auto
@@ -58,11 +59,13 @@ quality_base_html(const std::vector<falco::qual_array> &qual,
                   const file_grades &grades) -> std::string;
 
 [[nodiscard]] auto
-basic_stats_html(const file_info &info, const std::uint64_t n_reads,
+basic_stats_html(const file_info &info,
+                 const std::uint64_t n_reads,
                  const std::uint64_t min_read_len,
                  const std::uint64_t max_read_len,
                  const std::uint64_t median_read_len,
-                 const std::uint64_t total_gc, const std::uint64_t total_nucs,
+                 const std::uint64_t total_gc,
+                 const std::uint64_t total_nucs,
                  const file_grades &grades) -> std::string;
 
 [[nodiscard]] auto
@@ -71,7 +74,7 @@ tile_html(const tile_processor::tiles_centered_t &centered,
           const file_grades &grades) -> std::string;
 
 [[nodiscard]] auto
-kmer_html(const std::vector<kmer_result> &results,
-          const file_grades &grades) -> std::string;
+kmer_html(const std::vector<kmer_result> &results, const file_grades &grades)
+  -> std::string;
 
 #endif  // SRC_HTML_HPP_
diff --git a/src/kmer_counter.cpp b/src/kmer_counter.cpp
index 8048a71..e457cd8 100644
--- a/src/kmer_counter.cpp
+++ b/src/kmer_counter.cpp
@@ -61,6 +61,8 @@ gamma_p_series(const double a, const double x) -> double {
     if (term < eps * sum)
       break;
   }
+  // ADS: std::lgamma is unsafe
+  // NOLINTNEXTLINE(concurrency-mt-unsafe)
   return sum * std::exp(-x + a * std::log(x) - std::lgamma(a));
 }
 
@@ -91,6 +93,8 @@ gamma_q_contfrac(const double a, const double x) {
     if (std::abs(delta - 1.0) < epsilon)
       break;
   }
+  // ADS: std::lgamma is unsafe
+  // NOLINTNEXTLINE(concurrency-mt-unsafe)
   return std::exp(-x + a * std::log(x) - std::lgamma(a)) * h;
 }
 
diff --git a/src/original_duplicates.cpp b/src/original_duplicates.cpp
index fba205e..46585c6 100644
--- a/src/original_duplicates.cpp
+++ b/src/original_duplicates.cpp
@@ -40,7 +40,7 @@ initialize_original_duplicates(
       std::uint64_t file_id{};
       while (true) {
         {
-          std::scoped_lock l(mtx);
+          const std::scoped_lock l(mtx);
           if (n_active_files == 0)
             return;
           file_id = --n_active_files;
diff --git a/src/original_duplicates.hpp b/src/original_duplicates.hpp
index 1745a33..ef524ac 100644
--- a/src/original_duplicates.hpp
+++ b/src/original_duplicates.hpp
@@ -12,8 +12,9 @@
 struct file_info;
 
 [[nodiscard]] auto
-initialize_original_duplicates(
-  const std::vector<std::string> &infiles, const std::vector<file_info> &infos,
-  const std::uint32_t n_threads) -> std::vector<dups_init_t>;
+initialize_original_duplicates(const std::vector<std::string> &infiles,
+                               const std::vector<file_info> &infos,
+                               const std::uint32_t n_threads)
+  -> std::vector<dups_init_t>;
 
 #endif  // SRC_ORIGINAL_DUPLICATES_HPP_
diff --git a/src/quality_score.cpp b/src/quality_score.cpp
index d9e1ce8..c652205 100644
--- a/src/quality_score.cpp
+++ b/src/quality_score.cpp
@@ -6,7 +6,6 @@
 #include "file_info.hpp"
 
 #include <algorithm>
-#include <array>
 #include <cassert>  // IWYU pragma: keep
 #include <format>
 #include <iterator>
@@ -39,20 +38,18 @@ identify_encoding_impl(const auto &qual_counts,
 
 [[nodiscard]] auto
 identify_encoding(const std::vector<falco::qual_array> &qual_counts,
-                  file_info &info) -> falco::encoding {
+                  const file_info &info) -> falco::encoding {
   const auto shift = is_bam(info.format) ? falco::bam_qual_offset : 0;
   return identify_encoding_impl(qual_counts, shift);
 }
 
 [[nodiscard]] auto
 get_quality_score_offset(const falco::encoding e) -> std::int64_t {
-  // NOLINTNEXTLINE (cppcoreguidelines-pro-bounds-constant-array-index)
   return falco::min_qual_offsets[std::to_underlying(e)];
 }
 
 [[nodiscard]] auto
 get_quality_score_label(const falco::encoding e) -> std::string {
-  // NOLINTNEXTLINE (cppcoreguidelines-pro-bounds-constant-array-index)
   return falco::format_labels[std::to_underlying(e)];
 }
 
@@ -74,5 +71,5 @@ adjust_fastq_qual_encoding(std::vector<falco::qual_array> &qual_by_pos,
 encoding_to_string(const falco::encoding e) -> std::string {
   const auto u = std::to_underlying(e);
   assert(u < std::size(falco::format_labels));
-  return falco::format_labels[u];  // NOLINT(*-pro-bounds-constant-array-index)
+  return falco::format_labels[u];
 }
diff --git a/src/quality_score.hpp b/src/quality_score.hpp
index 5da3656..205f9b1 100644
--- a/src/quality_score.hpp
+++ b/src/quality_score.hpp
@@ -9,8 +9,9 @@
 #include <cassert>
 #include <cstdint>
 #include <format>
-#include <initializer_list>  // IWYU pragma: keep
-#include <iterator>          // IWYU pragma: keep
+#include <initializer_list>
+#include <iterator>
+#include <span>
 #include <string>
 #include <vector>  // IWYU pragma: keep
 
@@ -25,7 +26,7 @@ enum class encoding : std::uint8_t {
 
 // NOLINTNEXTLINE
 NLOHMANN_JSON_SERIALIZE_ENUM(  //
-  encoding,                    //
+  encoding,
   {
     {encoding::unknown, "Unknown"},
     {encoding::sanger, "Sanger / Illumina 1.9"},
@@ -37,16 +38,18 @@ static constexpr auto max_qual_val = 126;
 static constexpr auto sanger_min_qual = 33;
 static constexpr auto solexa_min_qual = 64;
 // clang-format off
-static constexpr auto min_qual_offsets = std::array{
+static constexpr auto min_qual_offsets_impl = std::array{
   0,
   sanger_min_qual,  // Sanger / Illumina 1.9
   solexa_min_qual,  // Solexa / Illumina 1.3 / Illumina 1.5
 };
-static constexpr auto format_labels = std::array{
+static constexpr std::span min_qual_offsets = min_qual_offsets_impl;
+static constexpr auto format_labels_impl = std::array{
   "Unknown",
   "Sanger / Illumina 1.9",
   "Solexa / Illumina <= 1.8",
 };
+static constexpr std::span format_labels = format_labels_impl;
 using qual_array = std::array<std::uint64_t, max_qual_val + 1>;
 // clang-format on
 }  // namespace falco
@@ -59,7 +62,7 @@ get_quality_score_offset(const falco::encoding e) -> std::int64_t;
 
 [[nodiscard]] auto
 identify_encoding(const std::vector<falco::qual_array> &qual_counts,
-                  file_info &info) -> falco::encoding;
+                  const file_info &info) -> falco::encoding;
 
 [[nodiscard]] auto
 get_quality_score_label(const falco::encoding e) -> std::string;
@@ -70,7 +73,8 @@ adjust_fastq_qual_encoding(std::vector<falco::qual_array> &qual_by_pos,
                            const falco::encoding enc) -> void;
 
 [[nodiscard]] static inline auto
-count_quals(auto qual_itr, const auto qual_end,
+count_quals(auto qual_itr,
+            const auto qual_end,
             auto &tab) {  // cppcheck-suppress constParameterReference
   auto out_itr = std::begin(tab);
   auto qual_tot = 0;
@@ -84,7 +88,8 @@ count_quals(auto qual_itr, const auto qual_end,
 }
 
 [[nodiscard]] static inline auto
-count_quals_rev(auto qual_itr, const auto qual_end,
+count_quals_rev(auto qual_itr,
+                const auto qual_end,
                 auto &tab) {  // cppcheck-suppress constParameterReference
   auto out_itr = std::begin(tab) + std::distance(qual_itr, qual_end);
   auto qual_tot = 0;
diff --git a/src/reads_file.hpp b/src/reads_file.hpp
index 8dff7aa..928aa3d 100644
--- a/src/reads_file.hpp
+++ b/src/reads_file.hpp
@@ -35,8 +35,10 @@ class reads_file_t {
   }
 
   friend auto
-  make_tasks(auto &reads_file, const std::int64_t n_threads,
-             const std::int32_t file_id, task_queue &tq,
+  make_tasks(auto &reads_file,
+             const std::int64_t n_threads,
+             const std::int32_t file_id,
+             task_queue &tq,
              std::atomic_int32_t &n_tasks) -> void {
     reads_file.self_->make_tasks_(n_threads, file_id, tq, n_tasks);
   }
@@ -56,8 +58,10 @@ class reads_file_t {
     explicit model(T x) : data_(std::move(x)) {}
 
     auto
-    make_tasks_(const std::int64_t n_threads, const std::int32_t file_id,
-                task_queue &tq, std::atomic_int32_t &n_tasks) -> void override {
+    make_tasks_(const std::int64_t n_threads,
+                const std::int32_t file_id,
+                task_queue &tq,
+                std::atomic_int32_t &n_tasks) -> void override {
       make_tasks(data_, n_threads, file_id, tq, n_tasks);
     }
 
diff --git a/src/report.cpp b/src/report.cpp
index 9f576a5..96149bf 100644
--- a/src/report.cpp
+++ b/src/report.cpp
@@ -42,6 +42,7 @@ sequence_length_report(const std::vector<std::uint64_t> &lengths,
   const auto eq0 = [](const auto &x) { return std::get<1>(x) == 0; };
   auto r = std::format(start_tag, grades.grade(label));
   r += header;
+  // NOLINTNEXTLINE(misc-const-correctness)
   auto to_report =
     falco::views::enumerate(lengths) | std::views::drop_while(eq0);
   for (const auto [idx, len] : to_report)
@@ -162,11 +163,13 @@ quality_base_report(const std::vector<falco::qual_array> &qual,
 }
 
 [[nodiscard]] auto
-basic_stats_report(const file_info &info, const std::uint64_t n_reads,
+basic_stats_report(const file_info &info,
+                   const std::uint64_t n_reads,
                    const std::uint64_t min_read_len,
                    const std::uint64_t max_read_len,
                    const std::uint64_t median_read_len,
-                   const std::uint64_t total_gc, const std::uint64_t total_nucs,
+                   const std::uint64_t total_gc,
+                   const std::uint64_t total_nucs,
                    const file_grades &grades) -> std::string {
   static constexpr auto label = "basic_stats";
   static constexpr auto start_tag = "##Falco {}\n"
@@ -206,8 +209,8 @@ basic_stats_report(const file_info &info, const std::uint64_t n_reads,
 
 [[nodiscard]] auto
 tile_report(const tile_processor::tiles_centered_t &centered,
-            const std::vector<base_group_t> &groups,
-            const file_grades &grades) -> std::string {
+            const std::vector<base_group_t> &groups, const file_grades &grades)
+  -> std::string {
   static constexpr auto label = "tile";
   static constexpr auto max_precision{std::numeric_limits<double>::digits10};
   static constexpr auto start_tag = ">>Per tile sequence quality\t{}\n";
@@ -226,8 +229,8 @@ tile_report(const tile_processor::tiles_centered_t &centered,
 }
 
 [[nodiscard]] auto
-kmer_report(const std::vector<kmer_result> &results,
-            const file_grades &grades) -> std::string {
+kmer_report(const std::vector<kmer_result> &results, const file_grades &grades)
+  -> std::string {
   static constexpr auto label = "kmer";
   static constexpr auto start_tag = ">>Kmer Content\t{}\n";
   static constexpr auto header = "#Sequence\t"
diff --git a/src/report.hpp b/src/report.hpp
index 0a79a6d..f5cd801 100644
--- a/src/report.hpp
+++ b/src/report.hpp
@@ -45,11 +45,13 @@ quality_base_report(const std::vector<falco::qual_array> &qual,
                     const file_grades &grades) -> std::string;
 
 [[nodiscard]] auto
-basic_stats_report(const file_info &info, const std::uint64_t n_reads,
+basic_stats_report(const file_info &info,
+                   const std::uint64_t n_reads,
                    const std::uint64_t min_read_len,
                    const std::uint64_t max_read_len,
                    const std::uint64_t median_read_len,
-                   const std::uint64_t total_gc, const std::uint64_t total_nucs,
+                   const std::uint64_t total_gc,
+                   const std::uint64_t total_nucs,
                    const file_grades &grades) -> std::string;
 
 [[nodiscard]] auto
@@ -58,7 +60,7 @@ tile_report(const tile_processor::tiles_centered_t &centered,
             const file_grades &grades) -> std::string;
 
 [[nodiscard]] auto
-kmer_report(const std::vector<kmer_result> &results,
-            const file_grades &grades) -> std::string;
+kmer_report(const std::vector<kmer_result> &results, const file_grades &grades)
+  -> std::string;
 
 #endif  // SRC_REPORT_HPP_
diff --git a/src/results_summary.cpp b/src/results_summary.cpp
index df3172d..6699da3 100644
--- a/src/results_summary.cpp
+++ b/src/results_summary.cpp
@@ -10,7 +10,7 @@
 
 #include <algorithm>
 #include <array>
-#include <assert.h>
+#include <cassert>
 #include <format>
 #include <iterator>
 #include <numeric>
diff --git a/src/sam_file.hpp b/src/sam_file.hpp
index 7832598..a5c5358 100644
--- a/src/sam_file.hpp
+++ b/src/sam_file.hpp
@@ -34,8 +34,10 @@ class sam_file {
   // clang-format on
 
   auto
-  make_tasks(const std::int64_t n_chunks, const std::int32_t file_id,
-             task_queue &tq, std::atomic_int32_t &n_tasks) -> void;
+  make_tasks(const std::int64_t n_chunks,
+             const std::int32_t file_id,
+             task_queue &tq,
+             std::atomic_int32_t &n_tasks) -> void;
 
   auto
   reset() -> void {
@@ -47,8 +49,10 @@ class sam_file {
 
 private:
   auto
-  get_chunks(const std::int64_t n_chunks, const std::int32_t file_id,
-             task_queue &tq, std::atomic_int32_t &n_tasks) -> void;
+  get_chunks(const std::int64_t n_chunks,
+             const std::int32_t file_id,
+             task_queue &tq,
+             std::atomic_int32_t &n_tasks) -> void;
 
   auto
   shift_output_buffer() -> void;
@@ -61,12 +65,11 @@ class sam_file {
 };
 
 inline auto
-make_tasks(sam_file &reads_file,          //
-           const std::int64_t n_threads,  //
-           const std::int32_t file_id,    //
-           task_queue &tq,                //
-           std::atomic_int32_t &n_tasks   //
-           ) -> void {
+make_tasks(sam_file &reads_file,
+           const std::int64_t n_threads,
+           const std::int32_t file_id,
+           task_queue &tq,
+           std::atomic_int32_t &n_tasks) -> void {
   static constexpr auto n_chunks_per_thread = 8;
   const auto n_chunks = n_chunks_per_thread * n_threads;
   reads_file.make_tasks(n_chunks, file_id, tq, n_tasks);
diff --git a/src/sam_stdin.cpp b/src/sam_stdin.cpp
index aa8c8e1..6da6f35 100644
--- a/src/sam_stdin.cpp
+++ b/src/sam_stdin.cpp
@@ -57,9 +57,9 @@ sam_stdin::skip_header() -> void {
 }
 
 auto
-sam_stdin::get_chunks(const std::int64_t n_chunks,  //
-                      const std::int32_t file_id,   //
-                      task_queue &tq,               //
+sam_stdin::get_chunks(const std::int64_t n_chunks,
+                      const std::int32_t file_id,
+                      task_queue &tq,
                       std::atomic_int32_t &n_tasks) -> void {
   assert(n_chunks > 0);
   const auto beg_itr = std::begin(buffer);
@@ -135,9 +135,9 @@ validate_sam(const auto &buffer) -> bool {
 }
 
 auto
-sam_stdin::make_tasks(const std::int64_t n_chunks,  //
-                      const std::int32_t file_id,   //
-                      task_queue &tq,               //
+sam_stdin::make_tasks(const std::int64_t n_chunks,
+                      const std::int32_t file_id,
+                      task_queue &tq,
                       std::atomic_int32_t &n_tasks) -> void {
   n_tasks = 1;  // for current task, which makes more tasks
   shift_output_buffer();
diff --git a/src/sam_stdin.hpp b/src/sam_stdin.hpp
index 1c84316..c9f0bdd 100644
--- a/src/sam_stdin.hpp
+++ b/src/sam_stdin.hpp
@@ -33,8 +33,10 @@ class sam_stdin {
   // clang-format on
 
   auto
-  make_tasks(const std::int64_t n_chunks, const std::int32_t file_id,
-             task_queue &tq, std::atomic_int32_t &n_tasks) -> void;
+  make_tasks(const std::int64_t n_chunks,
+             const std::int32_t file_id,
+             task_queue &tq,
+             std::atomic_int32_t &n_tasks) -> void;
 
   auto
   reset() -> void {
@@ -46,8 +48,10 @@ class sam_stdin {
 
 private:
   auto
-  get_chunks(const std::int64_t n_chunks, const std::int32_t file_id,
-             task_queue &tq, std::atomic_int32_t &n_tasks) -> void;
+  get_chunks(const std::int64_t n_chunks,
+             const std::int32_t file_id,
+             task_queue &tq,
+             std::atomic_int32_t &n_tasks) -> void;
 
   auto
   shift_output_buffer() -> void;
@@ -64,12 +68,11 @@ estimate_n_reads_sam_stdin(const std::string &)
   -> std::tuple<std::uint64_t, std::uint64_t, std::int64_t>;
 
 inline auto
-make_tasks(sam_stdin &reads_file,         //
-           const std::int64_t n_threads,  //
-           const std::int32_t file_id,    //
-           task_queue &tq,                //
-           std::atomic_int32_t &n_tasks   //
-           ) -> void {
+make_tasks(sam_stdin &reads_file,
+           const std::int64_t n_threads,
+           const std::int32_t file_id,
+           task_queue &tq,
+           std::atomic_int32_t &n_tasks) -> void {
   static constexpr auto n_chunks_per_thread = 8;
   const auto n_chunks = n_chunks_per_thread * n_threads;
   reads_file.make_tasks(n_chunks, file_id, tq, n_tasks);
diff --git a/src/samrec.cpp b/src/samrec.cpp
index 14ff8a9..54bab1e 100644
--- a/src/samrec.cpp
+++ b/src/samrec.cpp
@@ -35,7 +35,8 @@ samrec::to_string() const -> std::string {
 }
 
 [[nodiscard]] auto
-samrec::get_next(samrec::pos_t &cursor, const samrec::pos_t end_itr,
+samrec::get_next(samrec::pos_t &cursor,
+                 const samrec::pos_t end_itr,
                  samrec &rec) -> bool {
   static constexpr auto n_fields_to_skip = 7;
   constexpr auto complem = [](const auto x) {
@@ -91,7 +92,7 @@ samrec::get_next(samrec::pos_t &cursor, const samrec::pos_t end_itr,
   if (itr++ == end_itr)
     return false;
 
-  if (qual_len != rec.seq_len)
+  if (qual_len != seq_len)
     throw std::runtime_error("quality scores invalid for record: " +
                              std::string(name_itr, name_itr + name_len));
 
@@ -99,9 +100,9 @@ samrec::get_next(samrec::pos_t &cursor, const samrec::pos_t end_itr,
   if (std::ssize(rec.buffer) < rec_size)
     rec.buffer.resize(rec_size);
 
-  auto out_name_itr = std::begin(rec.buffer);
-  auto out_seq_itr = out_name_itr + name_len;
-  auto out_qual_itr = out_seq_itr + seq_len;
+  const auto out_name_itr = std::begin(rec.buffer);
+  const auto out_seq_itr = out_name_itr + name_len;
+  const auto out_qual_itr = out_seq_itr + seq_len;
   std::copy_n(name_itr, name_len, out_name_itr);
 
   if (bam_is_rev(flag)) {
diff --git a/src/tile_processor.cpp b/src/tile_processor.cpp
index a2cf8f8..995ef35 100644
--- a/src/tile_processor.cpp
+++ b/src/tile_processor.cpp
@@ -16,6 +16,7 @@
 
 #include <algorithm>
 #include <cassert>
+#include <cerrno>
 #include <cstdint>
 #include <cstdlib>
 #include <iterator>
@@ -34,14 +35,14 @@ tile_processor::init(const file_info &info) -> void {
   tile_id_position = info.tile_id_position;
 }
 
-[[nodiscard]] auto
+[[nodiscard]] static auto
 get_names_fastq(const std::string &filename) -> std::vector<std::string> {
   static constexpr auto n_records = 100;
   static constexpr auto n_lines_per_record = 4;
   static constexpr auto n_total_lines = n_records * n_lines_per_record;
   static constexpr auto name_line = 0;
-  std::unique_ptr<BGZF, int (*)(BGZF *)> in(bgzf_open(std::data(filename), "r"),
-                                            &bgzf_close);
+  const std::unique_ptr<BGZF, int (*)(BGZF *)> in(
+    bgzf_open(std::data(filename), "r"), &bgzf_close);
   if (!in)
     throw std::runtime_error("failed to open gz file: " + filename);
   std::vector<std::string> names;
@@ -61,15 +62,18 @@ get_names_fastq(const std::string &filename) -> std::vector<std::string> {
   return names;
 }
 
-[[nodiscard]] auto
+[[nodiscard]] static auto
 get_names_bam(const std::string &filename) -> std::vector<std::string> {
   static constexpr auto n_records = 100;
-  std::unique_ptr<samFile, int (*)(samFile *)> in(
+  const std::unique_ptr<samFile, int (*)(samFile *)> in(
     hts_open(std::data(filename), "r"), &hts_close);
   if (!in)
     throw std::runtime_error("failed to open BAM/SAM file: " + filename);
-  std::unique_ptr<sam_hdr_t, void (*)(sam_hdr_t *)> h(sam_hdr_read(in.get()),
-                                                      &sam_hdr_destroy);
+  const std::unique_ptr<sam_hdr_t, void (*)(sam_hdr_t *)> h(
+    sam_hdr_read(in.get()), &sam_hdr_destroy);
+  if (!h)
+    throw std::system_error(std::make_error_code(std::errc(errno)),
+                            "failed to read header: " + filename);
   std::vector<std::string> names;
   for (auto i = 0; i < n_records; ++i) {
     std::unique_ptr<bam1_t, void (*)(bam1_t *)> b(bam_init1(), &bam_destroy1);
@@ -212,7 +216,7 @@ get_tile_info(const std::string &filename) -> std::uint32_t {
   static constexpr auto colon_cutoff_2 = 4;
   static constexpr auto colon_cutoff_2_val = 2;
 
-  std::unique_ptr<htsFile, int (*)(htsFile *)> fp(
+  const std::unique_ptr<htsFile, int (*)(htsFile *)> fp(
     hts_open(std::data(filename), "r"), &hts_close);
   if (!fp)
     throw std::runtime_error("failed to open file: " + filename);