From 784ef4b30b0540e030eabc187891b252aff45b40 Mon Sep 17 00:00:00 2001
From: "J. Sebastian Paez" <jspaezp@gmail.com>
Date: Thu, 27 Aug 2026 19:08:19 -0700
Subject: [PATCH 01/19] refactor: make a source id polymorphic, keeping the
 shape the file used

An id is an id whether the source wrote an integer or a string, so
`SourceId`/`OwnedSourceId` carry either and `#[serde(untagged)]` renders each as
what it is. Carafe's `"id": 7` stays a JSON number; a DIA-NN
`transition_group_id` will stay a string rather than being coerced into a u64 or
replaced by one we made up.

`SourceIds` gains a `Text` arm, stored blob+offsets like `seq_strip_blob`, and
`SourceIds::owned` keeps an all-numeric library on the dense integer column
rather than paying for a blob.

The parquet `library_id` and `decoy_group_id` columns become Utf8, format
version 3. `HasQueryData::id` is gone -- it returned a u64 nothing consumed.

No behaviour change on its own: every id is still Numeric until the readers
start propagating.
---
 python/timsquery_pyo3/src/chromatogram.rs     |   4 +-
 python/timsquery_pyo3/src/elution_group.rs    |   4 +-
 python/timsquery_pyo3/src/iterator.rs         |  10 +-
 python/timsquery_pyo3/src/lib.rs              |  15 ++
 python/timsquery_pyo3/src/spectrum.rs         |   8 +-
 rust/apex_sim/src/sim.rs                      |   2 +-
 .../models/aggregators/chromatogram_agg.rs    |  10 +-
 .../src/models/aggregators/point_agg.rs       |   8 +-
 .../src/models/aggregators/spectrum_agg.rs    |  10 +-
 rust/timsquery/src/models/mod.rs              |   2 +
 rust/timsquery/src/models/query_handle.rs     |   7 +-
 rust/timsquery/src/models/source_id.rs        | 197 ++++++++++++++++--
 rust/timsquery/src/models/target.rs           |  15 +-
 rust/timsquery/src/models/target_columns.rs   |  43 +++-
 .../src/serde/chromatogram_output.rs          |   4 +-
 rust/timsquery/src/serde/library_file.rs      |   8 +-
 rust/timsquery/src/traits/queriable_data.rs   |   5 -
 rust/timsquery/src/traits/query_geom.rs       |  18 +-
 rust/timsquery/tests/carafe_contract/main.rs  |   9 +-
 rust/timsquery_cli/src/processing.rs          |   6 +-
 rust/timsquery_viewer/src/calibration.rs      |   2 +-
 rust/timsquery_viewer/src/plot_renderer.rs    |   4 +-
 .../src/data_sources/reference_library.rs     |  23 +-
 rust/timsseek/src/ml/qvalues.rs               |  25 +--
 rust/timsseek/src/models/sequence.rs          |   2 +-
 rust/timsseek/src/scoring/apex_finding.rs     |   7 +-
 rust/timsseek/src/scoring/blocks/identity.rs  |  31 +--
 rust/timsseek/src/scoring/parquet_writer.rs   |   6 +-
 rust/timsseek/src/scoring/pipeline.rs         |   5 +-
 rust/timsseek_cli/src/processing.rs           |  38 ++--
 30 files changed, 372 insertions(+), 156 deletions(-)

diff --git a/python/timsquery_pyo3/src/chromatogram.rs b/python/timsquery_pyo3/src/chromatogram.rs
index 99464447..471e8c81 100644
--- a/python/timsquery_pyo3/src/chromatogram.rs
+++ b/python/timsquery_pyo3/src/chromatogram.rs
@@ -63,8 +63,8 @@ impl PyChromatogramResult {
     }
 
     #[getter]
-    fn id(&self) -> u64 {
-        self.collector.id
+    fn id<'py>(&self, py: pyo3::Python<'py>) -> pyo3::PyResult<pyo3::Bound<'py, pyo3::PyAny>> {
+        crate::source_id_to_py(py, &self.collector.id)
     }
 
     fn __repr__(&self) -> String {
diff --git a/python/timsquery_pyo3/src/elution_group.rs b/python/timsquery_pyo3/src/elution_group.rs
index 2fe68c6a..66ad74db 100644
--- a/python/timsquery_pyo3/src/elution_group.rs
+++ b/python/timsquery_pyo3/src/elution_group.rs
@@ -60,8 +60,8 @@ impl PyElutionGroup {
     }
 
     #[getter]
-    fn id(&self) -> u64 {
-        self.inner.id()
+    fn id<'py>(&self, py: pyo3::Python<'py>) -> pyo3::PyResult<pyo3::Bound<'py, pyo3::PyAny>> {
+        crate::source_id_to_py(py, &self.inner.id().to_owned_id())
     }
 
     #[getter]
diff --git a/python/timsquery_pyo3/src/iterator.rs b/python/timsquery_pyo3/src/iterator.rs
index 44c09c36..a6a65a22 100644
--- a/python/timsquery_pyo3/src/iterator.rs
+++ b/python/timsquery_pyo3/src/iterator.rs
@@ -26,8 +26,7 @@ pub enum ToleranceSource {
 /// collector pool is never exposed — it reuses Rust-side buffers across chunks.
 #[pyclass(frozen)]
 pub struct PyChromatogramArrays {
-    #[pyo3(get)]
-    id: u64,
+    id: timsquery::models::OwnedSourceId,
     precursor_intensities: Py<PyAny>,
     fragment_intensities: Py<PyAny>,
     #[pyo3(get)]
@@ -42,6 +41,11 @@ pub struct PyChromatogramArrays {
 
 #[pymethods]
 impl PyChromatogramArrays {
+    #[getter]
+    fn id<'py>(&self, py: pyo3::Python<'py>) -> pyo3::PyResult<pyo3::Bound<'py, pyo3::PyAny>> {
+        crate::source_id_to_py(py, &self.id)
+    }
+
     #[getter]
     fn precursor_intensities<'py>(&self, py: Python<'py>) -> Bound<'py, PyAny> {
         self.precursor_intensities.clone_ref(py).into_bound(py)
@@ -72,7 +76,7 @@ fn extract_arrays(
     let rt = collector.rt_range_milis();
 
     Ok(PyChromatogramArrays {
-        id: collector.id,
+        id: collector.id.clone(),
         precursor_intensities: prec_np.into_any().unbind(),
         fragment_intensities: frag_np.into_any().unbind(),
         precursor_labels: collector
diff --git a/python/timsquery_pyo3/src/lib.rs b/python/timsquery_pyo3/src/lib.rs
index a74908a2..c12151b7 100644
--- a/python/timsquery_pyo3/src/lib.rs
+++ b/python/timsquery_pyo3/src/lib.rs
@@ -21,6 +21,21 @@ mod spectrum;
 mod tolerance;
 
 use pyo3::prelude::*;
+use timsquery::models::OwnedSourceId;
+
+/// A source id keeps the shape the library gave it, so Python sees an `int`
+/// for a numeric id and a `str` for a text one (DIA-NN's
+/// `transition_group_id`) rather than one coerced into the other.
+pub(crate) fn source_id_to_py<'py>(
+    py: Python<'py>,
+    id: &OwnedSourceId,
+) -> PyResult<Bound<'py, PyAny>> {
+    use pyo3::IntoPyObject;
+    match id {
+        OwnedSourceId::Numeric(n) => Ok(n.into_pyobject(py)?.into_any()),
+        OwnedSourceId::Text(s) => Ok(s.into_pyobject(py)?.into_any()),
+    }
+}
 
 #[pymodule]
 fn timsquery_pyo3(m: &Bound<'_, PyModule>) -> PyResult<()> {
diff --git a/python/timsquery_pyo3/src/spectrum.rs b/python/timsquery_pyo3/src/spectrum.rs
index 1661ecce..9a962a14 100644
--- a/python/timsquery_pyo3/src/spectrum.rs
+++ b/python/timsquery_pyo3/src/spectrum.rs
@@ -61,8 +61,8 @@ impl PySpectralResult {
 
     /// The elution group id.
     #[getter]
-    fn id(&self) -> u64 {
-        self.collector.id
+    fn id<'py>(&self, py: pyo3::Python<'py>) -> pyo3::PyResult<pyo3::Bound<'py, pyo3::PyAny>> {
+        crate::source_id_to_py(py, &self.collector.id)
     }
 
     fn __repr__(&self) -> String {
@@ -153,8 +153,8 @@ impl PyMzMobilityResult {
 
     /// The elution group id.
     #[getter]
-    fn id(&self) -> u64 {
-        self.collector.id
+    fn id<'py>(&self, py: pyo3::Python<'py>) -> pyo3::PyResult<pyo3::Bound<'py, pyo3::PyAny>> {
+        crate::source_id_to_py(py, &self.collector.id)
     }
 
     fn __repr__(&self) -> String {
diff --git a/rust/apex_sim/src/sim.rs b/rust/apex_sim/src/sim.rs
index d1d1428e..6174ddda 100644
--- a/rust/apex_sim/src/sim.rs
+++ b/rust/apex_sim/src/sim.rs
@@ -340,7 +340,7 @@ pub fn build(params: &SimParams) -> SimData {
         TupleRange::try_new(map(0), map(n - 1)).expect("start < end for positive period");
 
     let chromatograms = ChromatogramCollector::<String, f32> {
-        id: 0,
+        id: Default::default(),
         mobility_ook0: 1.0,
         rt_seconds: (map((realized_apex as usize).min(n - 1)) as f32) / 1000.0,
         precursor_mono_mz: dummy_mz,
diff --git a/rust/timsquery/src/models/aggregators/chromatogram_agg.rs b/rust/timsquery/src/models/aggregators/chromatogram_agg.rs
index 80b186aa..35244c6a 100644
--- a/rust/timsquery/src/models/aggregators/chromatogram_agg.rs
+++ b/rust/timsquery/src/models/aggregators/chromatogram_agg.rs
@@ -26,7 +26,7 @@ use timscentroid::utils::TupleRange;
 #[derive(Debug, Clone, Serialize)]
 pub struct ChromatogramCollector<T: KeyLike, V: ArrayElement + ValueLike> {
     // Query scalars carried from the eg at reset time.
-    pub id: u64,
+    pub id: crate::models::OwnedSourceId,
     pub mobility_ook0: f32,
     pub rt_seconds: f32,
     pub precursor_mono_mz: f64,
@@ -90,7 +90,7 @@ impl<T: KeyLike, V: ValueLike + ArrayElement> ChromatogramCollector<T, V> {
         let fragments =
             MzMajorIntensityArray::try_new_empty(fragment_order, num_cycles, start.index())?;
         Ok(Self {
-            id: eg.output_id(),
+            id: eg.output_id().to_owned_id(),
             mobility_ook0: eg.mobility_ook0(),
             rt_seconds: eg.rt_seconds(),
             precursor_mono_mz: eg.mono_precursor_mz(),
@@ -136,7 +136,7 @@ impl<T: KeyLike, V: ValueLike + ArrayElement> ChromatogramCollector<T, V> {
             return Err(DataProcessingError::ExpectedNonEmptyData);
         }
 
-        self.id = eg.output_id();
+        self.id = eg.output_id().to_owned_id();
         self.mobility_ook0 = mobility_override.unwrap_or_else(|| eg.mobility_ook0());
         self.rt_seconds = rt_override.unwrap_or_else(|| eg.rt_seconds());
         self.precursor_mono_mz = eg.mono_precursor_mz();
@@ -219,10 +219,6 @@ impl<T: KeyLike, V: ValueLike + ArrayElement> ChromatogramCollector<T, V> {
 }
 
 impl<T: KeyLike, V: ArrayElement + ValueLike> HasQueryData<T> for ChromatogramCollector<T, V> {
-    fn id(&self) -> u64 {
-        self.id
-    }
-
     fn precursor_mz_limits(&self) -> (f64, f64) {
         self.precursor_mz_limits
     }
diff --git a/rust/timsquery/src/models/aggregators/point_agg.rs b/rust/timsquery/src/models/aggregators/point_agg.rs
index 672c55e4..17caac9f 100644
--- a/rust/timsquery/src/models/aggregators/point_agg.rs
+++ b/rust/timsquery/src/models/aggregators/point_agg.rs
@@ -10,7 +10,7 @@ const POINT_INLINE_CAP: usize = 13;
 
 #[derive(Debug, Clone, Serialize)]
 pub struct PointIntensityAggregator<T: KeyLike> {
-    pub id: u64,
+    pub id: crate::models::OwnedSourceId,
     pub mobility_ook0: f32,
     pub rt_seconds: f32,
     pub precursor_mono_mz: f64,
@@ -42,7 +42,7 @@ impl<T: KeyLike> PointIntensityAggregator<T> {
             fragment_mzs.push(mz);
         }
         Self {
-            id: eg.output_id(),
+            id: eg.output_id().to_owned_id(),
             mobility_ook0: eg.mobility_ook0(),
             rt_seconds: eg.rt_seconds(),
             precursor_mono_mz: eg.mono_precursor_mz(),
@@ -58,10 +58,6 @@ impl<T: KeyLike> PointIntensityAggregator<T> {
 }
 
 impl<T: KeyLike> HasQueryData<T> for PointIntensityAggregator<T> {
-    fn id(&self) -> u64 {
-        self.id
-    }
-
     fn precursor_mz_limits(&self) -> (f64, f64) {
         self.precursor_mz_limits
     }
diff --git a/rust/timsquery/src/models/aggregators/spectrum_agg.rs b/rust/timsquery/src/models/aggregators/spectrum_agg.rs
index b30514df..38fa564e 100644
--- a/rust/timsquery/src/models/aggregators/spectrum_agg.rs
+++ b/rust/timsquery/src/models/aggregators/spectrum_agg.rs
@@ -33,7 +33,7 @@ const SPEC_INLINE_CAP: usize = 13;
 #[derive(Debug, Clone, Serialize)]
 pub struct SpectralCollector<T: KeyLike, V: Default + ValueLike> {
     // Query scalars carried from eg at construction / reset.
-    pub id: u64,
+    pub id: crate::models::OwnedSourceId,
     pub mobility_ook0: f32,
     pub rt_seconds: f32,
     pub precursor_mono_mz: f64,
@@ -53,7 +53,7 @@ pub struct SpectralCollector<T: KeyLike, V: Default + ValueLike> {
 impl<T: KeyLike, V: ValueLike + Default> SpectralCollector<T, V> {
     pub fn new(eg: &impl QueryGeom<Label = T>) -> Self {
         let mut out = Self {
-            id: 0,
+            id: Default::default(),
             mobility_ook0: 0.0,
             rt_seconds: 0.0,
             precursor_mono_mz: 0.0,
@@ -82,7 +82,7 @@ impl<T: KeyLike, V: ValueLike + Default> SpectralCollector<T, V> {
         rt_override: Option<f32>,
         mobility_override: Option<f32>,
     ) {
-        self.id = eg.output_id();
+        self.id = eg.output_id().to_owned_id();
         self.mobility_ook0 = mobility_override.unwrap_or_else(|| eg.mobility_ook0());
         self.rt_seconds = rt_override.unwrap_or_else(|| eg.rt_seconds());
         self.precursor_mono_mz = eg.mono_precursor_mz();
@@ -144,10 +144,6 @@ impl<T: KeyLike, V: ValueLike + Default> SpectralCollector<T, V> {
 }
 
 impl<T: KeyLike, V: Default + ValueLike> HasQueryData<T> for SpectralCollector<T, V> {
-    fn id(&self) -> u64 {
-        self.id
-    }
-
     fn precursor_mz_limits(&self) -> (f64, f64) {
         self.precursor_mz_limits
     }
diff --git a/rust/timsquery/src/models/mod.rs b/rust/timsquery/src/models/mod.rs
index c1cf353e..ad8c5544 100644
--- a/rust/timsquery/src/models/mod.rs
+++ b/rust/timsquery/src/models/mod.rs
@@ -28,6 +28,8 @@ pub use query_handle::{
 };
 pub use source_id::{
     LibraryId,
+    OwnedSourceId,
+    SourceId,
     SourceIdError,
     SourceIds,
 };
diff --git a/rust/timsquery/src/models/query_handle.rs b/rust/timsquery/src/models/query_handle.rs
index f786302f..576b8a83 100644
--- a/rust/timsquery/src/models/query_handle.rs
+++ b/rust/timsquery/src/models/query_handle.rs
@@ -87,11 +87,11 @@ impl<Lib: Deref<Target = TargetColumns<L>>, L: KeyLike + DecoyShift> Query<Lib,
 impl<Lib: Deref<Target = TargetColumns<L>>, L: KeyLike + DecoyShift> QueryGeom for Query<Lib, L> {
     type Label = L;
 
-    fn source_id(&self) -> Option<crate::models::LibraryId> {
+    fn source_id(&self) -> Option<crate::models::SourceId<'_>> {
         self.geom().source_id(self.row())
     }
 
-    fn output_id(&self) -> u64 {
+    fn output_id(&self) -> crate::models::SourceId<'_> {
         self.geom().output_id(self.row())
     }
 
@@ -158,6 +158,7 @@ mod tests {
     use crate::IonAnnot;
     use crate::models::TargetColumns;
     use crate::models::capabilities::*;
+    use crate::models::source_id::SourceId;
     use crate::traits::QueryGeom;
 
     fn one_target_lib() -> TargetColumns<IonAnnot> {
@@ -191,7 +192,7 @@ mod tests {
     fn target_variant_is_unshifted() {
         let lib = one_target_lib();
         let q = Query::new(&lib, RowIdx::new(0), 0);
-        assert_eq!(q.output_id(), 0);
+        assert_eq!(q.output_id(), SourceId::Numeric(0));
         assert!((q.mono_precursor_mz() - 654.855).abs() < 1e-9);
         let frags: Vec<_> = q.iter_fragments_refs().collect();
         assert!((frags[1].1 - 896.5).abs() < 1e-9);
diff --git a/rust/timsquery/src/models/source_id.rs b/rust/timsquery/src/models/source_id.rs
index ad518459..b95d26a7 100644
--- a/rust/timsquery/src/models/source_id.rs
+++ b/rust/timsquery/src/models/source_id.rs
@@ -1,9 +1,14 @@
 //! Source ids, as opposed to arena positions.
 //!
 //! The arena position is self-incremental and feeds decoy grouping and the
-//! q-value determinism key, so it stays private to the arena. [`LibraryId`] is
-//! what the source file called the row. Separate types so user-supplied values
-//! cannot reach the machinery that needs positions.
+//! q-value determinism key, so it stays private to the arena. A source id is
+//! what the source file called the row, carried through verbatim.
+//!
+//! Ids are polymorphic because formats disagree: JSON targets carry integers,
+//! DIA-NN carries `transition_group_id` / the `.speclib` entry name, which are
+//! strings. Neither is coerced into the other's shape — a numeric id stays a
+//! JSON number so Carafe's `"id": 7` is unchanged, and a text id stays a
+//! string.
 
 use serde::{
     Deserialize,
@@ -11,8 +16,7 @@ use serde::{
 };
 use thiserror::Error;
 
-/// `#[serde(transparent)]` keeps the wire format a bare integer, so Carafe's
-/// `"id": 7` is unchanged.
+/// `#[serde(transparent)]` keeps the wire format a bare integer.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
 #[serde(transparent)]
 pub struct LibraryId(u64);
@@ -27,15 +31,98 @@ impl LibraryId {
     }
 }
 
+/// One row's id, borrowed from the arena that stores it.
+///
+/// `#[serde(untagged)]` so it serializes as the shape it is — a bare number or
+/// a bare string — rather than as a tagged union.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
+#[serde(untagged)]
+pub enum SourceId<'a> {
+    Numeric(u64),
+    Text(&'a str),
+}
+
+impl SourceId<'_> {
+    pub fn to_owned_id(self) -> OwnedSourceId {
+        match self {
+            Self::Numeric(n) => OwnedSourceId::Numeric(n),
+            Self::Text(s) => OwnedSourceId::Text(s.to_string()),
+        }
+    }
+}
+
+impl std::fmt::Display for SourceId<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Numeric(n) => write!(f, "{n}"),
+            Self::Text(s) => f.write_str(s),
+        }
+    }
+}
+
+/// [`SourceId`] detached from the arena, for result structs that outlive the
+/// borrow.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum OwnedSourceId {
+    Numeric(u64),
+    Text(String),
+}
+
+impl OwnedSourceId {
+    pub fn as_ref(&self) -> SourceId<'_> {
+        match self {
+            Self::Numeric(n) => SourceId::Numeric(*n),
+            Self::Text(s) => SourceId::Text(s),
+        }
+    }
+}
+
+impl From<u64> for OwnedSourceId {
+    fn from(n: u64) -> Self {
+        Self::Numeric(n)
+    }
+}
+
+impl From<String> for OwnedSourceId {
+    fn from(s: String) -> Self {
+        Self::Text(s)
+    }
+}
+
+impl From<&str> for OwnedSourceId {
+    fn from(s: &str) -> Self {
+        Self::Text(s.to_string())
+    }
+}
+
+impl Default for OwnedSourceId {
+    fn default() -> Self {
+        Self::Numeric(0)
+    }
+}
+
+impl std::fmt::Display for OwnedSourceId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.as_ref().fmt(f)
+    }
+}
+
 /// Which kind of id a library carries is a property of the format, not of a
-/// row: JSON targets and the native speclib carry integers, the DIA-NN tabular
-/// formats carry strings (`transition_group_id`), Spectronaut/Skyline carry
-/// nothing. `Text` arrives with the reader work that needs it.
+/// row: JSON targets carry integers, DIA-NN carries strings
+/// (`transition_group_id`, or the `.speclib` entry name), Spectronaut/Skyline
+/// carry nothing.
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
 pub enum SourceIds {
     #[default]
     Absent,
     Numeric(Vec<LibraryId>),
+    /// CSR over one blob, like `seq_strip_blob`: `offsets` has `n_rows + 1`
+    /// entries.
+    Text {
+        blob: String,
+        offsets: Vec<u32>,
+    },
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Error)]
@@ -44,7 +131,9 @@ pub enum SourceIdError {
     LengthMismatch { ids: usize, rows: usize },
     /// Callers key results by this id, so a repeat makes one row unreachable.
     #[error("duplicate source id {id}; ids must be unique per row")]
-    Duplicate { id: u64 },
+    Duplicate { id: String },
+    #[error("source id blob exceeds u32 offset range")]
+    BlobTooLarge,
 }
 
 impl SourceIds {
@@ -58,12 +147,63 @@ impl SourceIds {
         let mut seen = std::collections::HashSet::with_capacity(ids.len());
         for id in &ids {
             if !seen.insert(*id) {
-                return Err(SourceIdError::Duplicate { id: id.get() });
+                return Err(SourceIdError::Duplicate {
+                    id: id.get().to_string(),
+                });
             }
         }
         Ok(Self::Numeric(ids))
     }
 
+    /// Ids the file spelled as text, carried through verbatim.
+    pub fn text<I, S>(ids: I, n_rows: usize) -> Result<Self, SourceIdError>
+    where
+        I: IntoIterator<Item = S>,
+        S: AsRef<str>,
+    {
+        let mut blob = String::new();
+        let mut offsets = vec![0u32];
+        let mut seen = std::collections::HashSet::with_capacity(n_rows);
+        for id in ids {
+            let id = id.as_ref();
+            if !seen.insert(id.to_string()) {
+                return Err(SourceIdError::Duplicate { id: id.to_string() });
+            }
+            blob.push_str(id);
+            offsets.push(u32::try_from(blob.len()).map_err(|_| SourceIdError::BlobTooLarge)?);
+        }
+        if offsets.len() - 1 != n_rows {
+            return Err(SourceIdError::LengthMismatch {
+                ids: offsets.len() - 1,
+                rows: n_rows,
+            });
+        }
+        Ok(Self::Text { blob, offsets })
+    }
+
+    /// Ids of whichever shape the file used, kept as they came.
+    pub fn owned(ids: Vec<OwnedSourceId>, n_rows: usize) -> Result<Self, SourceIdError> {
+        if ids.len() != n_rows {
+            return Err(SourceIdError::LengthMismatch {
+                ids: ids.len(),
+                rows: n_rows,
+            });
+        }
+        // All-numeric stays numeric so the common JSON path keeps its dense
+        // integer column instead of paying for a blob.
+        if ids.iter().all(|id| matches!(id, OwnedSourceId::Numeric(_))) {
+            let nums = ids
+                .iter()
+                .map(|id| match id {
+                    OwnedSourceId::Numeric(n) => LibraryId::new(*n),
+                    OwnedSourceId::Text(_) => unreachable!("checked above"),
+                })
+                .collect();
+            return Self::numeric(nums, n_rows);
+        }
+        Self::text(ids.iter().map(|id| id.to_string()), n_rows)
+    }
+
     /// Self-incremental ids for a format that carries none, so results still
     /// have something to be keyed by. Numerically equal to the row positions
     /// they are minted from, but they are ids from here on: stored in the
@@ -72,10 +212,15 @@ impl SourceIds {
         Self::Numeric((0..n_rows as u64).map(LibraryId::new).collect())
     }
 
-    pub fn get(&self, row: usize) -> Option<LibraryId> {
+    pub fn get(&self, row: usize) -> Option<SourceId<'_>> {
         match self {
             Self::Absent => None,
-            Self::Numeric(ids) => ids.get(row).copied(),
+            Self::Numeric(ids) => ids.get(row).map(|id| SourceId::Numeric(id.get())),
+            Self::Text { blob, offsets } => {
+                let start = *offsets.get(row)? as usize;
+                let end = *offsets.get(row + 1)? as usize;
+                Some(SourceId::Text(&blob[start..end]))
+            }
         }
     }
 }
@@ -89,12 +234,34 @@ mod tests {
         let ids = vec![LibraryId::new(7), LibraryId::new(7)];
         assert_eq!(
             SourceIds::numeric(ids, 2),
-            Err(SourceIdError::Duplicate { id: 7 })
+            Err(SourceIdError::Duplicate {
+                id: "7".to_string()
+            })
+        );
+        assert_eq!(
+            SourceIds::text(["AAAK2", "AAAK2"], 2),
+            Err(SourceIdError::Duplicate {
+                id: "AAAK2".to_string()
+            })
+        );
+    }
+
+    /// Carafe reads `id` with fastjson and keys results by it, so a numeric id
+    /// must stay a JSON number even though the type can also hold a string.
+    #[test]
+    fn each_id_serializes_as_its_own_shape() {
+        assert_eq!(serde_json::to_string(&SourceId::Numeric(7)).unwrap(), "7");
+        assert_eq!(
+            serde_json::to_string(&SourceId::Text("AAAK2")).unwrap(),
+            r#""AAAK2""#
         );
     }
 
     #[test]
-    fn library_id_serializes_transparently() {
-        assert_eq!(serde_json::to_string(&LibraryId::new(7)).unwrap(), "7");
+    fn text_ids_round_trip_through_the_blob() {
+        let ids = SourceIds::text(["AAAK2", "PEPTIDEK3"], 2).unwrap();
+        assert_eq!(ids.get(0), Some(SourceId::Text("AAAK2")));
+        assert_eq!(ids.get(1), Some(SourceId::Text("PEPTIDEK3")));
+        assert_eq!(ids.get(2), None);
     }
 }
diff --git a/rust/timsquery/src/models/target.rs b/rust/timsquery/src/models/target.rs
index b01943ba..b55dea69 100644
--- a/rust/timsquery/src/models/target.rs
+++ b/rust/timsquery/src/models/target.rs
@@ -16,7 +16,8 @@ use tinyvec::TinyVec;
 #[derive(Debug, Serialize, Deserialize, Clone, bon::Builder)]
 #[builder(finish_fn(vis = "", name = try_build_internal))]
 pub struct Target<T: KeyLike> {
-    id: u64,
+    #[builder(into)]
+    id: crate::models::OwnedSourceId,
     #[serde(alias = "mobility")]
     mobility_ook0: f32,
     rt_seconds: f32,
@@ -89,7 +90,7 @@ impl<T: KeyLike + Default> Target<T> {
     /// every query, so the zeroed initial state is never observed.
     pub fn empty_like() -> Self {
         Self {
-            id: 0,
+            id: Default::default(),
             mobility_ook0: 0.0,
             rt_seconds: 0.0,
             precursor_mono_mz: 0.0,
@@ -102,8 +103,8 @@ impl<T: KeyLike + Default> Target<T> {
 }
 
 impl<T: KeyLike> Target<T> {
-    pub fn id(&self) -> u64 {
-        self.id
+    pub fn id(&self) -> crate::models::SourceId<'_> {
+        self.id.as_ref()
     }
 
     pub fn precursor_count(&self) -> usize {
@@ -143,7 +144,7 @@ impl<T: KeyLike> Target<T> {
     /// flyweight), not necessarily `Self` — the body reads `src` only
     /// through trait methods.
     pub fn reset_from<G: crate::traits::QueryGeom<Label = T>>(&mut self, src: &G) {
-        self.set_id_internal(src.output_id());
+        self.set_id_internal(src.output_id().to_owned_id());
         self.mobility_ook0 = src.mobility_ook0();
         self.rt_seconds = src.rt_seconds();
         self.precursor_mono_mz = src.mono_precursor_mz();
@@ -163,7 +164,7 @@ impl<T: KeyLike> Target<T> {
     /// Private setter for the otherwise-read-only `id` field — used by
     /// `reset_from` since a generic `G: QueryGeom` source only exposes `id()`
     /// through the trait, not direct field access.
-    fn set_id_internal(&mut self, id: u64) {
+    fn set_id_internal(&mut self, id: crate::models::OwnedSourceId) {
         self.id = id;
     }
 
@@ -231,7 +232,7 @@ impl<T: KeyLike> Target<T> {
             self.fragment_labels.iter().map(f).collect();
 
         Target {
-            id: self.id,
+            id: self.id.clone(),
             mobility_ook0: self.mobility_ook0,
             rt_seconds: self.rt_seconds,
             precursor_mono_mz: self.precursor_mono_mz,
diff --git a/rust/timsquery/src/models/target_columns.rs b/rust/timsquery/src/models/target_columns.rs
index 3e1f89b4..d4cd4cd0 100644
--- a/rust/timsquery/src/models/target_columns.rs
+++ b/rust/timsquery/src/models/target_columns.rs
@@ -6,6 +6,8 @@ use crate::models::capabilities::{
 use crate::models::query_handle::QueryRef;
 use crate::models::source_id::{
     LibraryId,
+    OwnedSourceId,
+    SourceId,
     SourceIdError,
     SourceIds,
 };
@@ -99,7 +101,7 @@ pub struct TargetColumns<L: KeyLike> {
     /// derived from the row position: group membership is a property of the
     /// analytes, and reading it off the arena layout only works for as long as
     /// the layout happens to encode it.
-    decoy_groups: Vec<u64>,
+    decoy_groups: Vec<OwnedSourceId>,
     // CSR prefix offsets (n+1)
     pub(crate) frag_off: Vec<u32>,
     pub(crate) seq_strip_off: Vec<u32>,
@@ -225,6 +227,12 @@ impl<L: KeyLike> TargetColumns<L> {
         Ok(())
     }
 
+    /// Attach ids of whichever shape the file used.
+    pub fn set_source_ids_owned(&mut self, ids: Vec<OwnedSourceId>) -> Result<(), SourceIdError> {
+        self.source_ids = SourceIds::owned(ids, self.n_rows())?;
+        Ok(())
+    }
+
     /// The rows of this arena, in storage order.
     pub fn rows(&self) -> impl Iterator<Item = RowIdx> + use<L> {
         (0..self.n_rows() as u32).map(RowIdx::new)
@@ -233,7 +241,7 @@ impl<L: KeyLike> TargetColumns<L> {
     /// Attach the competition groups a file declared. Call before `seal`,
     /// which otherwise mints one group per row. Rows sharing a value compete,
     /// so unlike source ids these are not required to be unique.
-    pub fn set_decoy_groups(&mut self, groups: Vec<u64>) -> Result<(), SourceIdError> {
+    pub fn set_decoy_groups(&mut self, groups: Vec<OwnedSourceId>) -> Result<(), SourceIdError> {
         if groups.len() != self.n_rows() {
             return Err(SourceIdError::LengthMismatch {
                 ids: groups.len(),
@@ -244,17 +252,27 @@ impl<L: KeyLike> TargetColumns<L> {
         Ok(())
     }
 
-    pub fn source_id(&self, tgt: RowIdx) -> Option<LibraryId> {
+    pub fn source_id(&self, tgt: RowIdx) -> Option<SourceId<'_>> {
         self.source_ids.get(tgt.get())
     }
 
     /// The id a result for row `tgt` carries. Always a source id: [`Self::seal`]
     /// mints them for formats that carry none, so a row position has no route
     /// into output.
-    pub fn output_id(&self, tgt: RowIdx) -> u64 {
+    pub fn output_id(&self, tgt: RowIdx) -> SourceId<'_> {
         self.source_id(tgt)
             .expect("sealed targets have source ids; seal() mints any that are missing")
-            .get()
+    }
+
+    /// Attach ids the file spelled as text, e.g. DIA-NN's
+    /// `transition_group_id`. Call after every `push_row`, before `seal`.
+    pub fn set_source_ids_text<I, S>(&mut self, ids: I) -> Result<(), SourceIdError>
+    where
+        I: IntoIterator<Item = S>,
+        S: AsRef<str>,
+    {
+        self.source_ids = SourceIds::text(ids, self.n_rows())?;
+        Ok(())
     }
 
     pub fn charge(&self, tgt: RowIdx) -> u8 {
@@ -348,7 +366,10 @@ impl<L: KeyLike> TargetColumns<L> {
                 "input declares no decoy groups; minting one per row, named by the row's \
                  own id. Stored decoys therefore compete alone, not against their target."
             );
-            self.decoy_groups = self.rows().map(|r| self.output_id(r)).collect();
+            self.decoy_groups = self
+                .rows()
+                .map(|r| self.output_id(r).to_owned_id())
+                .collect();
         }
         if matches!(self.caps.decoys, DecoyStrategy::LazyMassShift { .. })
             && self.is_decoy.iter().any(|&d| d)
@@ -457,8 +478,8 @@ impl<L: KeyLike + DecoyShift> TargetColumns<L> {
     /// The competition group this row belongs to, as an id — not a position.
     /// A row's decoy variants share its group, so exactly one member survives
     /// competition.
-    pub fn decoy_group(&self, tgt: RowIdx) -> u64 {
-        self.decoy_groups[tgt.get()]
+    pub fn decoy_group(&self, tgt: RowIdx) -> SourceId<'_> {
+        self.decoy_groups[tgt.get()].as_ref()
     }
 }
 
@@ -487,8 +508,8 @@ mod tests {
         }
         assert_eq!(c.source_id(RowIdx::new(0)), None);
         c.seal();
-        assert_eq!(c.output_id(RowIdx::new(0)), 0);
-        assert_eq!(c.output_id(RowIdx::new(1)), 1);
+        assert_eq!(c.output_id(RowIdx::new(0)), SourceId::Numeric(0));
+        assert_eq!(c.output_id(RowIdx::new(1)), SourceId::Numeric(1));
     }
 
     #[test]
@@ -510,7 +531,7 @@ mod tests {
         assert!(c.is_target(FlatIdx::new(0))); // variant 0
         assert!(!c.is_target(FlatIdx::new(1))); // +decoy
         assert!(!c.is_target(FlatIdx::new(2))); // -decoy
-        assert_eq!(c.decoy_group(RowIdx::new(0)), 0);
+        assert_eq!(c.decoy_group(RowIdx::new(0)), SourceId::Numeric(0));
     }
 
     #[test]
diff --git a/rust/timsquery/src/serde/chromatogram_output.rs b/rust/timsquery/src/serde/chromatogram_output.rs
index d2a30de3..75e3870d 100644
--- a/rust/timsquery/src/serde/chromatogram_output.rs
+++ b/rust/timsquery/src/serde/chromatogram_output.rs
@@ -20,7 +20,7 @@ type UnzippedFragmentTraces = ((Vec<f64>, Vec<Vec<f32>>), Vec<String>);
 /// in the logic so we keep them as buffers, so only 1 exists at a time.
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ChromatogramOutput {
-    pub id: u64,
+    pub id: crate::models::OwnedSourceId,
     pub mobility_ook0: f32,
     pub rt_seconds: f32,
     pub precursor_mzs: Vec<f64>,
@@ -125,7 +125,7 @@ impl ChromatogramOutput {
                 .unzip();
 
         Ok(ChromatogramOutput {
-            id: collector.id,
+            id: collector.id.clone(),
             mobility_ook0: collector.mobility_ook0,
             rt_seconds: collector.rt_seconds,
             precursor_mzs,
diff --git a/rust/timsquery/src/serde/library_file.rs b/rust/timsquery/src/serde/library_file.rs
index 675e23a0..006e20c7 100644
--- a/rust/timsquery/src/serde/library_file.rs
+++ b/rust/timsquery/src/serde/library_file.rs
@@ -25,7 +25,6 @@ use super::spectronaut_io::{
 };
 use crate::ion::IonAnnot;
 use crate::models::{
-    LibraryId,
     SourceIdError,
     TargetCapabilities,
     TargetColumns,
@@ -408,8 +407,11 @@ fn set_source_ids_from<L: KeyLike, T: KeyLike>(
     geom: &mut TargetColumns<L>,
     egs: &[Target<T>],
 ) -> Result<(), TargetReadingError> {
-    let ids = egs.iter().map(|eg| LibraryId::new(eg.id())).collect();
-    geom.set_source_ids(ids)
+    let ids = egs
+        .iter()
+        .map(|eg| eg.id().to_owned_id())
+        .collect::<Vec<_>>();
+    geom.set_source_ids_owned(ids)
         .map_err(TargetReadingError::SourceId)
 }
 
diff --git a/rust/timsquery/src/traits/queriable_data.rs b/rust/timsquery/src/traits/queriable_data.rs
index eeac36bc..e1f79a52 100644
--- a/rust/timsquery/src/traits/queriable_data.rs
+++ b/rust/timsquery/src/traits/queriable_data.rs
@@ -23,7 +23,6 @@ use timscentroid::rt_mapping::RTIndex;
 /// by `Target` as well as by aggregators that carry their own
 /// query scalars.
 pub trait HasQueryData<FH: KeyLike> {
-    fn id(&self) -> u64;
     fn precursor_mz_limits(&self) -> (f64, f64);
     fn mobility_ook0(&self) -> f32;
     /// The kind of mobility axis the LIBRARY entry carries. Defaults to `Ook0`
@@ -42,10 +41,6 @@ pub trait HasQueryData<FH: KeyLike> {
 }
 
 impl<FH: KeyLike> HasQueryData<FH> for Target<FH> {
-    fn id(&self) -> u64 {
-        Target::id(self)
-    }
-
     fn precursor_mz_limits(&self) -> (f64, f64) {
         self.precursor_mz_limits()
     }
diff --git a/rust/timsquery/src/traits/query_geom.rs b/rust/timsquery/src/traits/query_geom.rs
index f9f69d56..049adfa2 100644
--- a/rust/timsquery/src/traits/query_geom.rs
+++ b/rust/timsquery/src/traits/query_geom.rs
@@ -9,14 +9,14 @@ pub trait QueryGeom {
 
     /// What the source file called this row, when it said. `None` for formats
     /// that carry no id.
-    fn source_id(&self) -> Option<crate::models::LibraryId> {
+    fn source_id(&self) -> Option<crate::models::SourceId<'_>> {
         None
     }
 
     /// The id a result carries; always present, since callers key results by
     /// it. Not defaulted: a default would need a position accessor on this
     /// trait, and the position belongs to whoever stores the row.
-    fn output_id(&self) -> u64;
+    fn output_id(&self) -> crate::models::SourceId<'_>;
     fn mono_precursor_mz(&self) -> f64;
     fn precursor_charge(&self) -> u8;
     fn rt_seconds(&self) -> f32;
@@ -33,11 +33,11 @@ pub trait QueryGeom {
 impl<T: KeyLike> QueryGeom for Target<T> {
     type Label = T;
 
-    fn source_id(&self) -> Option<crate::models::LibraryId> {
-        Some(crate::models::LibraryId::new(self.id()))
+    fn source_id(&self) -> Option<crate::models::SourceId<'_>> {
+        Some(self.id())
     }
 
-    fn output_id(&self) -> u64 {
+    fn output_id(&self) -> crate::models::SourceId<'_> {
         self.id()
     }
 
@@ -85,8 +85,8 @@ mod tests {
     use super::*;
     use crate::models::target::Target;
 
-    fn via_trait<G: QueryGeom>(g: &G) -> u64 {
-        g.output_id()
+    fn via_trait<G: QueryGeom>(g: &G) -> crate::models::OwnedSourceId {
+        g.output_id().to_owned_id()
     }
 
     #[test]
@@ -101,7 +101,7 @@ mod tests {
             .precursor(500.0, 2)
             .try_build()
             .unwrap();
-        assert_eq!(via_trait(&eg), 7);
+        assert_eq!(via_trait(&eg), crate::models::OwnedSourceId::Numeric(7));
     }
 
     #[test]
@@ -124,6 +124,6 @@ mod tests {
             .unwrap();
         let mut dst = src.clone();
         reset_via_trait(&mut dst, &src);
-        assert_eq!(dst.id(), 3);
+        assert_eq!(dst.id(), crate::models::SourceId::Numeric(3));
     }
 }
diff --git a/rust/timsquery/tests/carafe_contract/main.rs b/rust/timsquery/tests/carafe_contract/main.rs
index 553217c0..c72b4136 100644
--- a/rust/timsquery/tests/carafe_contract/main.rs
+++ b/rust/timsquery/tests/carafe_contract/main.rs
@@ -9,6 +9,7 @@
 //! `tests/carafe_e2e.rs`, which runs the built binary over a generated mzML.
 
 use std::io::Write;
+use timsquery::models::SourceId;
 use timsquery::models::tolerance::{
     MobilityTolerance,
     MzTolerance,
@@ -93,8 +94,12 @@ fn non_sequential_ids_survive_the_reader() {
     let TargetTable::Mzpaf { geom, .. } = arena else {
         panic!("mzpaf labels")
     };
-    let ids: Vec<u64> = geom.rows().map(|r| geom.output_id(r)).collect();
-    assert_eq!(ids, vec![7, 42], "the caller's ids, not 0..n-1");
+    let ids: Vec<SourceId<'_>> = geom.rows().map(|r| geom.output_id(r)).collect();
+    assert_eq!(
+        ids,
+        vec![SourceId::Numeric(7), SourceId::Numeric(42)],
+        "the caller's ids, not 0..n-1"
+    );
 }
 
 /// Carafe keys results by `id`, so a repeat makes one row unreachable.
diff --git a/rust/timsquery_cli/src/processing.rs b/rust/timsquery_cli/src/processing.rs
index fe95b203..0ebeb3c4 100644
--- a/rust/timsquery_cli/src/processing.rs
+++ b/rust/timsquery_cli/src/processing.rs
@@ -40,7 +40,7 @@ use tracing::{
 /// Represents the output format for an aggregated spectrum.
 #[derive(Debug, Serialize, Deserialize)]
 pub struct SpectrumOutput {
-    id: u64,
+    id: timsquery::models::OwnedSourceId,
     mobility_ook0: f32,
     rt_seconds: f32,
     precursor_mz: f64,
@@ -64,7 +64,7 @@ impl<T: KeyLike + Display> From<&SpectralCollector<T, f32>> for SpectrumOutput {
             .unzip();
 
         SpectrumOutput {
-            id: agg.id,
+            id: agg.id.clone(),
             mobility_ook0: agg.mobility_ook0,
             rt_seconds: agg.rt_seconds,
             precursor_mz: agg.precursor_mono_mz,
@@ -153,7 +153,7 @@ impl<T: KeyLike + Display> AggregatorContainer<T> {
                 let converted_results: Vec<ChromatogramOutput> = aggregators
                     .par_drain(..)
                     .filter_map(|mut agg| {
-                        let agg_id = agg.id;
+                        let agg_id = agg.id.clone();
                         match ChromatogramOutput::try_new(&mut agg, ref_rts) {
                             Ok(output) => Some(output),
                             Err(e) => {
diff --git a/rust/timsquery_viewer/src/calibration.rs b/rust/timsquery_viewer/src/calibration.rs
index e0882680..d4bfcffc 100644
--- a/rust/timsquery_viewer/src/calibration.rs
+++ b/rust/timsquery_viewer/src/calibration.rs
@@ -548,7 +548,7 @@ impl ViewerCalibrationState {
                                 score: apex.score,
                                 apex_rt: ObservedRTSeconds(apex.retention_time_ms as f32 / 1000.0),
                                 speclib_index: elution_groups.flat(eg_idx),
-                                library_id: elution_group.id(),
+                                library_id: elution_group.id().to_owned_id(),
                                 library_rt: LibraryRT(elution_group.rt_seconds()),
                             });
                         }
diff --git a/rust/timsquery_viewer/src/plot_renderer.rs b/rust/timsquery_viewer/src/plot_renderer.rs
index 70471382..0c94adb3 100644
--- a/rust/timsquery_viewer/src/plot_renderer.rs
+++ b/rust/timsquery_viewer/src/plot_renderer.rs
@@ -51,7 +51,7 @@ pub enum AutoZoomMode {
 pub struct ChromatogramLines {
     precursor_lines: Vec<ChromatogramLine>,
     fragment_lines: Vec<ChromatogramLine>,
-    pub reference_id: u64,
+    pub reference_id: timsquery::models::OwnedSourceId,
     pub reference_ook0: f64,
     pub reference_rt_seconds: f64,
     intensity_max: f64,
@@ -355,7 +355,7 @@ impl ChromatogramLines {
         Self {
             precursor_lines,
             fragment_lines,
-            reference_id: chromatogram.id,
+            reference_id: chromatogram.id.clone(),
             reference_ook0: chromatogram.mobility_ook0 as f64,
             reference_rt_seconds: chromatogram.rt_seconds as f64,
             intensity_max: global_max_intensity as f64,
diff --git a/rust/timsseek/src/data_sources/reference_library.rs b/rust/timsseek/src/data_sources/reference_library.rs
index 324fb016..e365eb1c 100644
--- a/rust/timsseek/src/data_sources/reference_library.rs
+++ b/rust/timsseek/src/data_sources/reference_library.rs
@@ -10,6 +10,7 @@ use timsquery::models::capabilities::{
 };
 use timsquery::models::{
     FlatIdx,
+    OwnedSourceId,
     Query,
     RowIdx,
     TargetColumns,
@@ -121,7 +122,7 @@ impl<'a> RefQuery<'a> {
     /// time), else `None`. Parsing the modified (not stripped) form preserves
     /// the mod set the `n_mods` feature reads. Lazy decoys are mass-shift
     /// decoys, so any non-target variant is `MassShiftedDecoy`.
-    pub fn materialize_peptide_in_group(&self, decoy_group: u64) -> Peptide {
+    pub fn materialize_peptide_in_group(&self, decoy_group: OwnedSourceId) -> Peptide {
         let tgt = self.geom.row();
         let coll = &self.lib.geom;
         let raw: Arc<str> = coll.seq_mod(tgt).into();
@@ -168,11 +169,11 @@ impl<'a> ExpectedIntensity for RefQuery<'a> {
 impl<'a> QueryGeom for RefQuery<'a> {
     type Label = IonAnnot;
 
-    fn source_id(&self) -> Option<timsquery::models::LibraryId> {
+    fn source_id(&self) -> Option<timsquery::models::SourceId<'_>> {
         self.geom.source_id()
     }
 
-    fn output_id(&self) -> u64 {
+    fn output_id(&self) -> timsquery::models::SourceId<'_> {
         self.geom.output_id()
     }
 
@@ -222,12 +223,12 @@ pub trait ScoredIdentity {
     /// The id this result carries, so a caller can map it onto the row they
     /// asked about: the source id where the file gave one, otherwise the id
     /// minted for it at load.
-    fn library_id(&self) -> u64;
+    fn library_id(&self) -> OwnedSourceId;
     /// Whether this item is a target (vs a decoy variant).
     fn is_target(&self) -> bool;
     /// Competition group id. Declared by the file when it says, minted at load
     /// otherwise — never the row's position.
-    fn decoy_group(&self) -> u64;
+    fn decoy_group(&self) -> OwnedSourceId;
     /// The row this result came from. Opaque and unprintable, so it can order
     /// the q-value tie-break without any caller-supplied value reaching it.
     fn row(&self) -> RowIdx;
@@ -236,8 +237,8 @@ pub trait ScoredIdentity {
 }
 
 impl<'a> ScoredIdentity for RefQuery<'a> {
-    fn library_id(&self) -> u64 {
-        self.geom().output_id()
+    fn library_id(&self) -> OwnedSourceId {
+        self.geom().output_id().to_owned_id()
     }
 
     fn row(&self) -> RowIdx {
@@ -251,8 +252,8 @@ impl<'a> ScoredIdentity for RefQuery<'a> {
         !self.lib.geom.is_decoy(tgt) && self.geom().variant() == 0
     }
 
-    fn decoy_group(&self) -> u64 {
-        self.lib.geom.decoy_group(self.geom().row())
+    fn decoy_group(&self) -> OwnedSourceId {
+        self.lib.geom.decoy_group(self.geom().row()).to_owned_id()
     }
 
     fn materialize_peptide(&self) -> Peptide {
@@ -384,8 +385,8 @@ mod tests {
         let lib = tiny_ref_lib();
         let scored = lib.item_at(flat(&lib, 0));
         assert!(scored.is_target());
-        assert_eq!(scored.library_id(), 0); // flat index 0 -> target 0
-        assert_eq!(scored.decoy_group(), 0);
+        assert_eq!(scored.library_id(), OwnedSourceId::Numeric(0)); // flat 0 -> target 0
+        assert_eq!(scored.decoy_group(), OwnedSourceId::Numeric(0));
         let got_frags: Vec<(IonAnnot, f32)> = scored.iter_expected_fragments().collect();
         assert_eq!(got_frags.len(), 2);
         assert!((got_frags[0].1 - 1.0).abs() < 1e-6);
diff --git a/rust/timsseek/src/ml/qvalues.rs b/rust/timsseek/src/ml/qvalues.rs
index 21ae53d4..0936200f 100644
--- a/rust/timsseek/src/ml/qvalues.rs
+++ b/rust/timsseek/src/ml/qvalues.rs
@@ -36,6 +36,7 @@ use crate::scoring::results::{
 use crate::utils::maybe_par;
 use rand::prelude::*;
 use std::sync::Arc;
+use timsquery::models::OwnedSourceId;
 
 #[cfg(test)]
 use super::cv::RowMajorDataset;
@@ -1027,7 +1028,7 @@ mod feature_tests {
         let peptide = Peptide {
             raw: Arc::from("PEPTIDEK"),
             decoy: DecoyMarking::Target,
-            decoy_group: 0,
+            decoy_group: OwnedSourceId::Numeric(0),
             sequence_features,
         };
         CompetedCandidate {
@@ -1151,7 +1152,7 @@ mod feature_tests {
         (0..n)
             .map(|i| {
                 let mut c = sample_competed_candidate(true);
-                c.scoring.identity.library_id = i as u64;
+                c.scoring.identity.library_id = OwnedSourceId::Numeric(i as u64);
                 let is_target = i % 2 == 0;
                 c.scoring.identity.is_target = is_target;
                 let base: u8 = if is_target { 20 } else { 8 };
@@ -1272,12 +1273,12 @@ mod feature_tests {
             assert!((0.0..=1.0).contains(&r.qvalue));
         }
 
-        let key = |out: &[FinalResult]| -> Vec<(u64, u32)> {
-            let mut v: Vec<(u64, u32)> = out
+        let key = |out: &[FinalResult]| -> Vec<(OwnedSourceId, u32)> {
+            let mut v: Vec<(OwnedSourceId, u32)> = out
                 .iter()
                 .map(|r| {
                     (
-                        r.scoring.identity.library_id,
+                        r.scoring.identity.library_id.clone(),
                         r.discriminant_score.to_bits(),
                     )
                 })
@@ -1459,12 +1460,12 @@ mod feature_tests {
     #[test]
     fn rescore_mlp_is_deterministic() {
         let n = 90;
-        let key = |out: &[FinalResult]| -> Vec<(u64, u32)> {
-            let mut v: Vec<(u64, u32)> = out
+        let key = |out: &[FinalResult]| -> Vec<(OwnedSourceId, u32)> {
+            let mut v: Vec<(OwnedSourceId, u32)> = out
                 .iter()
                 .map(|r| {
                     (
-                        r.scoring.identity.library_id,
+                        r.scoring.identity.library_id.clone(),
                         r.discriminant_score.to_bits(),
                     )
                 })
@@ -1567,12 +1568,12 @@ mod feature_tests {
             );
         }
 
-        let key = |out: &[FinalResult]| -> Vec<(u64, u32)> {
-            let mut v: Vec<(u64, u32)> = out
+        let key = |out: &[FinalResult]| -> Vec<(OwnedSourceId, u32)> {
+            let mut v: Vec<(OwnedSourceId, u32)> = out
                 .iter()
                 .map(|r| {
                     (
-                        r.scoring.identity.library_id,
+                        r.scoring.identity.library_id.clone(),
                         r.discriminant_score.to_bits(),
                     )
                 })
@@ -1719,7 +1720,7 @@ mod feature_tests {
         (0..n)
             .map(|i| {
                 let mut c = sample_competed_candidate(true);
-                c.scoring.identity.library_id = i as u64;
+                c.scoring.identity.library_id = OwnedSourceId::Numeric(i as u64);
                 c.scoring.identity.is_target = i % 2 == 0;
                 c
             })
diff --git a/rust/timsseek/src/models/sequence.rs b/rust/timsseek/src/models/sequence.rs
index b53d1a21..eae4deaf 100644
--- a/rust/timsseek/src/models/sequence.rs
+++ b/rust/timsseek/src/models/sequence.rs
@@ -107,7 +107,7 @@ impl ParsedSequence {
 pub struct Peptide {
     pub raw: Arc<str>,
     pub decoy: DecoyMarking,
-    pub decoy_group: u64,
+    pub decoy_group: timsquery::models::OwnedSourceId,
     /// Whether the source library exposes sequence features. Gates [`Self::parse`]:
     /// a library without them yields no residues, so the sequence lanes stay NaN.
     pub sequence_features: bool,
diff --git a/rust/timsseek/src/scoring/apex_finding.rs b/rust/timsseek/src/scoring/apex_finding.rs
index d8454f48..064d612a 100644
--- a/rust/timsseek/src/scoring/apex_finding.rs
+++ b/rust/timsseek/src/scoring/apex_finding.rs
@@ -25,7 +25,10 @@
 //! ```
 
 use std::fmt::Display;
-use timsquery::models::RowIdx;
+use timsquery::models::{
+    OwnedSourceId,
+    RowIdx,
+};
 
 use super::apex::ApexConfig;
 use super::{
@@ -90,7 +93,7 @@ pub struct PeptideMetadata {
 
     pub charge: u8,
 
-    pub library_id: u64,
+    pub library_id: OwnedSourceId,
 
     /// The arena row scored, carried for the q-value determinism sort.
     pub row: RowIdx,
diff --git a/rust/timsseek/src/scoring/blocks/identity.rs b/rust/timsseek/src/scoring/blocks/identity.rs
index 83722546..7d868ab4 100644
--- a/rust/timsseek/src/scoring/blocks/identity.rs
+++ b/rust/timsseek/src/scoring/blocks/identity.rs
@@ -3,7 +3,10 @@
 //! never add a *score* here.
 
 use std::sync::Arc;
-use timsquery::models::RowIdx;
+use timsquery::models::{
+    OwnedSourceId,
+    RowIdx,
+};
 
 use crate::models::DecoyMarking;
 use crate::models::sequence::Peptide;
@@ -18,8 +21,8 @@ use crate::scoring::blocks::{
 #[derive(Debug, Clone, serde::Serialize)]
 pub struct Identity {
     pub peptide: Peptide,
-    pub library_id: u64,
-    pub decoy_group_id: u64,
+    pub library_id: OwnedSourceId,
+    pub decoy_group_id: OwnedSourceId,
     /// The arena row this result came from. Opaque and unserializable, so it
     /// can order the q-value tie-break without a caller-supplied id reaching
     /// the sort (`library_id` is caller-supplied whenever the file had one).
@@ -43,8 +46,8 @@ impl Identity {
     pub fn compute(metadata: &PeptideMetadata) -> Self {
         Self {
             peptide: metadata.digest.clone(),
-            library_id: metadata.library_id,
-            decoy_group_id: metadata.digest.decoy_group,
+            library_id: metadata.library_id.clone(),
+            decoy_group_id: metadata.digest.decoy_group.clone(),
             row: metadata.row,
             precursor_mz: metadata.ref_precursor_mz,
             precursor_charge: metadata.charge,
@@ -64,8 +67,8 @@ impl Identity {
         self.competition_key() == other.competition_key()
     }
 
-    pub fn competition_key(&self) -> (u64, u8) {
-        (self.decoy_group_id, self.precursor_charge)
+    pub fn competition_key(&self) -> (&OwnedSourceId, u8) {
+        (&self.decoy_group_id, self.precursor_charge)
     }
 
     /// The observed mobility is a sentinel on non-scoreable axes; drop the
@@ -92,11 +95,11 @@ impl Identity {
             peptide: Peptide {
                 raw: Arc::from("PEPTIDEK"),
                 decoy: DecoyMarking::Target,
-                decoy_group: 0,
+                decoy_group: OwnedSourceId::Numeric(0),
                 sequence_features: false,
             },
-            library_id: 1,
-            decoy_group_id: 0,
+            library_id: OwnedSourceId::Numeric(1),
+            decoy_group_id: OwnedSourceId::Numeric(0),
             row: RowIdx::default(),
             precursor_mz: 500.0,
             precursor_charge: 2,
@@ -109,8 +112,8 @@ impl Identity {
 impl ScoreBlock for Identity {
     fn columns(&self, o: &mut ColSink) {
         o.str("sequence", self.peptide.as_str());
-        o.u64("library_id", self.library_id);
-        o.u64("decoy_group_id", self.decoy_group_id);
+        o.str("library_id", &self.library_id.to_string());
+        o.str("decoy_group_id", &self.decoy_group_id.to_string());
         o.f64("precursor_mz", self.precursor_mz);
         o.u8("precursor_charge", self.precursor_charge);
         o.f32("precursor_mobility", self.precursor_mobility);
@@ -119,8 +122,8 @@ impl ScoreBlock for Identity {
 
     fn column_schema(o: &mut SchemaSink) {
         o.str("sequence");
-        o.u64("library_id");
-        o.u64("decoy_group_id");
+        o.str("library_id");
+        o.str("decoy_group_id");
         o.f64("precursor_mz");
         o.u8("precursor_charge");
         o.f32("precursor_mobility");
diff --git a/rust/timsseek/src/scoring/parquet_writer.rs b/rust/timsseek/src/scoring/parquet_writer.rs
index 979b1856..5b43d9fb 100644
--- a/rust/timsseek/src/scoring/parquet_writer.rs
+++ b/rust/timsseek/src/scoring/parquet_writer.rs
@@ -26,7 +26,7 @@ use super::results::FinalResult;
 ///   already the caller's id but was truncated to 32 bits; `decoy_group_id`
 ///   used to be the arena row position and is now an id declared by the input
 ///   or minted at load.
-pub const RESULTS_FORMAT_VERSION: u32 = 2;
+pub const RESULTS_FORMAT_VERSION: u32 = 3;
 
 // ---------------------------------------------------------------------------
 // Build a RecordBatch from a slice of FinalResult
@@ -175,8 +175,8 @@ mod tests {
     /// keeping it stable.
     const GOLDEN_SCHEMA: &[(&str, &str, bool)] = &[
         ("sequence", "Utf8", false),
-        ("library_id", "UInt64", false),
-        ("decoy_group_id", "UInt64", false),
+        ("library_id", "Utf8", false),
+        ("decoy_group_id", "Utf8", false),
         ("is_target", "Boolean", false),
         ("precursor_mz", "Float64", false),
         ("precursor_charge", "UInt8", false),
diff --git a/rust/timsseek/src/scoring/pipeline.rs b/rust/timsseek/src/scoring/pipeline.rs
index e3a97b41..059b3e10 100644
--- a/rust/timsseek/src/scoring/pipeline.rs
+++ b/rust/timsseek/src/scoring/pipeline.rs
@@ -42,6 +42,7 @@ use timscentroid::rt_mapping::{
 };
 use timsquery::models::{
     FlatIdx,
+    OwnedSourceId,
     RowIdx,
 };
 use timsquery::traits::QueryGeom;
@@ -123,7 +124,7 @@ pub struct CalibrantCandidate {
     /// The id this row reports, carried alongside the position because the
     /// calibration dashboard keys on something a human can recognise and a
     /// position must not leave the crate.
-    pub library_id: u64,
+    pub library_id: OwnedSourceId,
     pub library_rt: LibraryRT<f32>,
 }
 
@@ -600,7 +601,7 @@ impl<I: ScorerQueriable> Scorer<I> {
         Ok(super::apex_finding::PeptideMetadata {
             digest,
             charge: query.precursor_charge(),
-            library_id: extr.chromatograms.id,
+            library_id: extr.chromatograms.id.clone(),
             row,
             library_rt: original_irt.0,
             calibrated_rt_seconds: calibrated_rt.0,
diff --git a/rust/timsseek_cli/src/processing.rs b/rust/timsseek_cli/src/processing.rs
index e4922d3e..08c91494 100644
--- a/rust/timsseek_cli/src/processing.rs
+++ b/rust/timsseek_cli/src/processing.rs
@@ -1,5 +1,6 @@
 use super::config::OutputConfig;
 use indicatif::ProgressIterator;
+use timsquery::models::OwnedSourceId;
 use timsquery::models::tolerance::{
     MobilityTolerance,
     MzTolerance,
@@ -1153,7 +1154,12 @@ mod tests {
     use timsseek::models::sequence::Peptide;
     use timsseek::scoring::results::ScoringFields;
 
-    fn candidate(seq: &str, mz: f64, is_target: bool, decoy_group: u64) -> ScoredCandidate {
+    fn candidate(
+        seq: &str,
+        mz: f64,
+        is_target: bool,
+        decoy_group: OwnedSourceId,
+    ) -> ScoredCandidate {
         let decoy = if is_target {
             DecoyMarking::Target
         } else {
@@ -1162,7 +1168,7 @@ mod tests {
         let peptide = Peptide {
             raw: Arc::from(seq),
             decoy,
-            decoy_group,
+            decoy_group: decoy_group.clone(),
             sequence_features: false,
         };
         let mut scoring = ScoringFields::sample(peptide);
@@ -1195,14 +1201,14 @@ mod tests {
         // and charge, distinct precursor m/z. Two input orderings differing ONLY
         // in the tie order must produce identical (ordered) survivors.
         let order_a = vec![
-            candidate("PEPTIDEK", 501.0, true, 0),
-            candidate("PEPTIDEK", 500.0, false, 0),
-            candidate("PEPTIDEK", 502.0, false, 0),
+            candidate("PEPTIDEK", 501.0, true, OwnedSourceId::Numeric(0)),
+            candidate("PEPTIDEK", 500.0, false, OwnedSourceId::Numeric(0)),
+            candidate("PEPTIDEK", 502.0, false, OwnedSourceId::Numeric(0)),
         ];
         let order_b = vec![
-            candidate("PEPTIDEK", 502.0, false, 0),
-            candidate("PEPTIDEK", 500.0, false, 0),
-            candidate("PEPTIDEK", 501.0, true, 0),
+            candidate("PEPTIDEK", 502.0, false, OwnedSourceId::Numeric(0)),
+            candidate("PEPTIDEK", 500.0, false, OwnedSourceId::Numeric(0)),
+            candidate("PEPTIDEK", 501.0, true, OwnedSourceId::Numeric(0)),
         ];
 
         let sa = survivors(order_a);
@@ -1221,9 +1227,9 @@ mod tests {
 
     #[test]
     fn competition_features_match_their_ln1p_names() {
-        let mut best = candidate("BEST", 501.0, true, 7);
+        let mut best = candidate("BEST", 501.0, true, OwnedSourceId::Numeric(7));
         best.scoring.primary.main_score = 8.0;
-        let mut runner_up = candidate("RUNNER", 502.0, false, 7);
+        let mut runner_up = candidate("RUNNER", 502.0, false, OwnedSourceId::Numeric(7));
         runner_up.scoring.primary.main_score = 3.0;
 
         let competed = target_decoy_compete(vec![runner_up, best]);
@@ -1241,11 +1247,11 @@ mod tests {
     /// to come from the runner-up, not from the worst member.
     #[test]
     fn a_three_member_group_separates_the_winner_from_the_runner_up() {
-        let mut best = candidate("BEST", 501.0, true, 7);
+        let mut best = candidate("BEST", 501.0, true, OwnedSourceId::Numeric(7));
         best.scoring.primary.main_score = 8.0;
-        let mut middle = candidate("MIDDLE", 502.0, false, 7);
+        let mut middle = candidate("MIDDLE", 502.0, false, OwnedSourceId::Numeric(7));
         middle.scoring.primary.main_score = 3.0;
-        let mut worst = candidate("WORST", 503.0, false, 7);
+        let mut worst = candidate("WORST", 503.0, false, OwnedSourceId::Numeric(7));
         worst.scoring.primary.main_score = 1.0;
 
         let competed = target_decoy_compete(vec![worst, middle, best]);
@@ -1261,7 +1267,7 @@ mod tests {
     /// existed.
     #[test]
     fn a_lone_group_member_reports_no_separation() {
-        let mut only = candidate("ALONE", 501.0, true, 7);
+        let mut only = candidate("ALONE", 501.0, true, OwnedSourceId::Numeric(7));
         only.scoring.primary.main_score = 8.0;
 
         let competed = target_decoy_compete(vec![only]);
@@ -1275,9 +1281,9 @@ mod tests {
     /// neighbour's.
     #[test]
     fn separate_groups_do_not_bleed_into_each_other() {
-        let mut a = candidate("A", 501.0, true, 1);
+        let mut a = candidate("A", 501.0, true, OwnedSourceId::Numeric(1));
         a.scoring.primary.main_score = 8.0;
-        let mut b = candidate("B", 502.0, true, 2);
+        let mut b = candidate("B", 502.0, true, OwnedSourceId::Numeric(2));
         b.scoring.primary.main_score = 3.0;
 
         let competed = target_decoy_compete(vec![a, b]);

From 1fb627437b2cd212f35ca41af32010698166b06a Mon Sep 17 00:00:00 2001
From: "J. Sebastian Paez" <jspaezp@gmail.com>
Date: Thu, 27 Aug 2026 19:16:17 -0700
Subject: [PATCH 02/19] feat(timsquery): propagate DIA-NN's own precursor name
 into results

DIA-NN names every precursor and we were throwing it away, so a search result
could not be matched back to a row in the library it came from. Both DIA-NN
paths now carry that name through:

- `.speclib`: the entry name was already parsed and discarded after the charge
  suffix was stripped off it. It is the same string as `transition_group_id`.
- tsv/parquet: `transition_group_id` is read where present. It is absent from
  some DIA-NN variants (`sample_lib.txt` has no such column), and those fall
  back to the minted id, which is what they got before.

Spectronaut and Skyline carry no per-precursor name at all, so they keep
minting rather than being handed a synthesized one.

`Target::reset_from` overwrites the id in place, reusing the `String`
capacity: it runs per query on the scoring hot path, where a text id would
otherwise allocate every time. That path goes away entirely with the
`IsotopeOffset` decorator.
---
 rust/timsquery/src/models/source_id.rs       | 15 +++++++++
 rust/timsquery/src/models/target.rs          |  9 +----
 rust/timsquery/src/serde/diann_io.rs         | 35 +++++++++++++++++++-
 rust/timsquery/src/serde/diann_speclib_io.rs | 30 +++++++++++++----
 rust/timsquery/src/serde/library_file.rs     |  5 +++
 rust/timsseek/src/ml/qvalues.rs              |  2 +-
 6 files changed, 80 insertions(+), 16 deletions(-)

diff --git a/rust/timsquery/src/models/source_id.rs b/rust/timsquery/src/models/source_id.rs
index b95d26a7..40a5d30e 100644
--- a/rust/timsquery/src/models/source_id.rs
+++ b/rust/timsquery/src/models/source_id.rs
@@ -78,6 +78,21 @@ impl OwnedSourceId {
     }
 }
 
+impl OwnedSourceId {
+    /// Overwrite in place, reusing the existing `String` capacity when both
+    /// sides are text. `Target::reset_from` runs per query on the scoring hot
+    /// path, so a fresh allocation there is a per-query cost.
+    pub fn set_from(&mut self, src: SourceId<'_>) {
+        match (&mut *self, src) {
+            (Self::Text(dst), SourceId::Text(s)) => {
+                dst.clear();
+                dst.push_str(s);
+            }
+            (_, other) => *self = other.to_owned_id(),
+        }
+    }
+}
+
 impl From<u64> for OwnedSourceId {
     fn from(n: u64) -> Self {
         Self::Numeric(n)
diff --git a/rust/timsquery/src/models/target.rs b/rust/timsquery/src/models/target.rs
index b55dea69..687e4b33 100644
--- a/rust/timsquery/src/models/target.rs
+++ b/rust/timsquery/src/models/target.rs
@@ -144,7 +144,7 @@ impl<T: KeyLike> Target<T> {
     /// flyweight), not necessarily `Self` — the body reads `src` only
     /// through trait methods.
     pub fn reset_from<G: crate::traits::QueryGeom<Label = T>>(&mut self, src: &G) {
-        self.set_id_internal(src.output_id().to_owned_id());
+        self.id.set_from(src.output_id());
         self.mobility_ook0 = src.mobility_ook0();
         self.rt_seconds = src.rt_seconds();
         self.precursor_mono_mz = src.mono_precursor_mz();
@@ -161,13 +161,6 @@ impl<T: KeyLike> Target<T> {
             .extend(src.iter_precursors().map(|(iso, _mz)| iso));
     }
 
-    /// Private setter for the otherwise-read-only `id` field — used by
-    /// `reset_from` since a generic `G: QueryGeom` source only exposes `id()`
-    /// through the trait, not direct field access.
-    fn set_id_internal(&mut self, id: crate::models::OwnedSourceId) {
-        self.id = id;
-    }
-
     pub fn mobility_ook0(&self) -> f32 {
         self.mobility_ook0
     }
diff --git a/rust/timsquery/src/serde/diann_io.rs b/rust/timsquery/src/serde/diann_io.rs
index dbeb31e3..bb66b87f 100644
--- a/rust/timsquery/src/serde/diann_io.rs
+++ b/rust/timsquery/src/serde/diann_io.rs
@@ -127,6 +127,11 @@ struct DiannLibraryRow {
     #[serde(rename = "RelativeIntensity")]
     #[serde(alias = "LibraryIntensity")]
     relative_intensity: f32,
+    /// DIA-NN's own name for the precursor. Optional: the column is absent
+    /// from some DIA-NN variants, and those rows fall back to a minted id.
+    #[serde(rename = "transition_group_id")]
+    #[serde(default)]
+    transition_group_id: Option<String>,
 }
 
 impl DiannLibraryRow {
@@ -412,8 +417,15 @@ fn parse_precursor_group(
         relative_intensities,
     };
 
+    // DIA-NN names the precursor itself; carry that through so results say what
+    // the library says. Variants without the column fall back to the counter,
+    // which `seal` treats as any other minted id.
+    let source_id: crate::models::OwnedSourceId = match &first_row.transition_group_id {
+        Some(name) => name.as_str().into(),
+        None => id.into(),
+    };
     let eg = Target::builder()
-        .id(id)
+        .id(source_id)
         .mobility_ook0(mobility)
         .rt_seconds(rt_seconds)
         .fragment_labels(buffers.fragment_labels.as_slice().into())
@@ -767,6 +779,27 @@ mod tests {
         );
     }
 
+    /// The two DIA-NN TSV variants differ in whether they name the precursor:
+    /// `sample_lib.tsv` carries `transition_group_id`, `sample_lib.txt` does
+    /// not. The named one must come through as the library spelled it; the
+    /// unnamed one must still load and fall back.
+    #[test]
+    fn transition_group_id_is_propagated_when_the_file_has_one() {
+        let dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("tests")
+            .join("diann_io_files");
+
+        let named = read_targets(dir.join("sample_lib.tsv")).expect("named variant loads");
+        assert_eq!(
+            named[0].0.id(),
+            crate::models::SourceId::Text("AAAAAAALQAK2"),
+            "DIA-NN's own name for the precursor, not a counter"
+        );
+
+        let unnamed = read_targets(dir.join("sample_lib.txt")).expect("unnamed variant loads");
+        assert_eq!(unnamed[0].0.id(), crate::models::SourceId::Numeric(0));
+    }
+
     #[test]
     fn test_read_targets() {
         let manifest_dir = env!("CARGO_MANIFEST_DIR");
diff --git a/rust/timsquery/src/serde/diann_speclib_io.rs b/rust/timsquery/src/serde/diann_speclib_io.rs
index d9f5096d..f82ae1a9 100644
--- a/rust/timsquery/src/serde/diann_speclib_io.rs
+++ b/rust/timsquery/src/serde/diann_speclib_io.rs
@@ -476,7 +476,7 @@ impl SpecLib {
         // slot is a per-worker dedup scratch buffer reused across every entry
         // that worker maps (see `map_entry`), so the hot loop allocates only the
         // persistent output, not a fresh dedup Vec per entry.
-        let (geom, frag_intens, stats, _scratch) = offsets
+        let (mut geom, frag_intens, stats, _scratch, source_ids) = offsets
             .par_iter()
             .try_fold(
                 || {
@@ -485,16 +485,24 @@ impl SpecLib {
                         Vec::<f32>::new(),
                         SpeclibDecodeStats::default(),
                         Vec::new(),
+                        Vec::<String>::new(),
                     )
                 },
-                |(mut geom, mut frag_intens, mut stats, mut scratch),
+                |(mut geom, mut frag_intens, mut stats, mut scratch, mut ids),
                  &off|
                  -> Result<_, TargetReadingError> {
                     let mut cur = Cursor::new(self.data.bytes());
                     cur.pos = off;
                     let view = read_entry(&mut cur, self.version, &self.pg_ids)?;
-                    map_entry(view, &mut geom, &mut frag_intens, &mut stats, &mut scratch)?;
-                    Ok((geom, frag_intens, stats, scratch))
+                    map_entry(
+                        view,
+                        &mut geom,
+                        &mut frag_intens,
+                        &mut ids,
+                        &mut stats,
+                        &mut scratch,
+                    )?;
+                    Ok((geom, frag_intens, stats, scratch, ids))
                 },
             )
             .try_reduce(
@@ -504,17 +512,23 @@ impl SpecLib {
                         Vec::<f32>::new(),
                         SpeclibDecodeStats::default(),
                         Vec::new(),
+                        Vec::<String>::new(),
                     )
                 },
-                |(mut a_geom, mut a_int, sa, scratch), (b_geom, b_int, sb, _)| {
+                |(mut a_geom, mut a_int, sa, scratch, mut a_ids), (b_geom, b_int, sb, _, b_ids)| {
                     append_arena(&mut a_geom, b_geom);
                     a_int.extend(b_int);
+                    a_ids.extend(b_ids);
                     let mut merged = sa;
                     merged.merge(&sb);
-                    Ok((a_geom, a_int, merged, scratch))
+                    Ok((a_geom, a_int, merged, scratch, a_ids))
                 },
             )?;
 
+        // The entry name is DIA-NN's `transition_group_id`, so results name the
+        // precursor the way the library does rather than by a minted counter.
+        geom.set_source_ids_text(source_ids)?;
+
         Ok((geom, frag_intens, stats, at_eof))
     }
 }
@@ -682,6 +696,9 @@ fn map_entry(
     entry: EntryView,
     geom: &mut TargetColumns<IonAnnot>,
     frag_intens: &mut Vec<f32>,
+    // The entry name, kept so the library's own id reaches the results
+    // instead of one we minted. Parallel to the pushed rows.
+    source_ids: &mut Vec<String>,
     stats: &mut SpeclibDecodeStats,
     scratch: &mut Vec<(IonAnnot, f64, f32)>,
 ) -> Result<(), TargetReadingError> {
@@ -824,6 +841,7 @@ fn map_entry(
         &modified_peptide,
         &[],
     );
+    source_ids.push(name);
     // `entry.protein_id` is intentionally dropped: the columnar arena has no
     // protein column.
     let _ = &entry.protein_id;
diff --git a/rust/timsquery/src/serde/library_file.rs b/rust/timsquery/src/serde/library_file.rs
index 006e20c7..7866c07f 100644
--- a/rust/timsquery/src/serde/library_file.rs
+++ b/rust/timsquery/src/serde/library_file.rs
@@ -62,6 +62,11 @@ impl From<serde_json::Error> for TargetReadingError {
         TargetReadingError::SerdeJsonError(err)
     }
 }
+impl From<SourceIdError> for TargetReadingError {
+    fn from(err: SourceIdError) -> Self {
+        TargetReadingError::SourceId(err)
+    }
+}
 impl From<ElutionGroupInputError> for TargetReadingError {
     fn from(err: ElutionGroupInputError) -> Self {
         TargetReadingError::ElutionGroupInputError(err)
diff --git a/rust/timsseek/src/ml/qvalues.rs b/rust/timsseek/src/ml/qvalues.rs
index 0936200f..af16d1e7 100644
--- a/rust/timsseek/src/ml/qvalues.rs
+++ b/rust/timsseek/src/ml/qvalues.rs
@@ -36,7 +36,6 @@ use crate::scoring::results::{
 use crate::utils::maybe_par;
 use rand::prelude::*;
 use std::sync::Arc;
-use timsquery::models::OwnedSourceId;
 
 #[cfg(test)]
 use super::cv::RowMajorDataset;
@@ -1016,6 +1015,7 @@ mod feature_tests {
         ScoringFields,
     };
     use std::sync::Arc;
+    use timsquery::models::OwnedSourceId;
 
     fn base_scoring_fields(peptide: Peptide) -> ScoringFields {
         ScoringFields::sample(peptide)

From b3744afc909431a2292c39858568209c62623423 Mon Sep 17 00:00:00 2001
From: "J. Sebastian Paez" <jspaezp@gmail.com>
Date: Thu, 27 Aug 2026 20:05:57 -0700
Subject: [PATCH 03/19] fix(calib_dash): carry the id as text, since an id is
 no longer always a number

`cargo check -p timsseek_cli --features calib-dashboard` is a separate CI leg
that `--workspace --all-targets` does not build, so it missed the id change the
same way it missed the FlatIdx one.

calib_dash has no timsquery dependency and its fixtures build entries from
plain values, so it takes the id as a `String` and the conversion happens at the
timsseek_cli boundary. It only diffs and displays, so text is enough.
`CalibrantPoint` gives up `Copy` for `Clone` as a result.
---
 rust/calib_dash/src/app.rs            |  8 ++++----
 rust/calib_dash/src/bin/calib_dash.rs |  2 +-
 rust/calib_dash/src/frames.rs         | 10 +++++-----
 rust/calib_dash/src/metrics.rs        |  6 +++---
 rust/timsseek_cli/src/processing.rs   |  2 +-
 5 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/rust/calib_dash/src/app.rs b/rust/calib_dash/src/app.rs
index b76e517d..c16f67ad 100644
--- a/rust/calib_dash/src/app.rs
+++ b/rust/calib_dash/src/app.rs
@@ -593,7 +593,7 @@ impl CalibDash {
         self.current_points.extend(points.take(self.n_calibrants));
 
         self.frames
-            .record(chunk, self.current_points.iter().copied());
+            .record(chunk, self.current_points.iter().cloned());
         self.sync_frame_summary();
 
         let metrics = self.refit_live(chunk);
@@ -688,7 +688,7 @@ impl CalibDash {
 
         let (admitted, evicted) = churn(&self.prev_points, &self.current_points);
         self.prev_points.clear();
-        self.prev_points.extend(self.current_points.iter().copied());
+        self.prev_points.extend(self.current_points.iter().cloned());
 
         BatchMetrics {
             chunk,
@@ -832,7 +832,7 @@ mod tests {
             .map(|i| CalibrantPoint {
                 library_rt: i as f64 + 0.5,
                 observed_rt: (i as f64 + 0.5) * slope,
-                library_id: (chunk * n + i) as u64,
+                library_id: (chunk * n + i).to_string(),
             })
             .collect()
     }
@@ -846,7 +846,7 @@ mod tests {
             .map(|(i, &idx)| CalibrantPoint {
                 library_rt: i as f64 + 0.5,
                 observed_rt: i as f64 + 0.5,
-                library_id: idx as u64,
+                library_id: idx.to_string(),
             })
             .collect()
     }
diff --git a/rust/calib_dash/src/bin/calib_dash.rs b/rust/calib_dash/src/bin/calib_dash.rs
index 4bf7ebf7..036cf022 100644
--- a/rust/calib_dash/src/bin/calib_dash.rs
+++ b/rust/calib_dash/src/bin/calib_dash.rs
@@ -43,7 +43,7 @@ fn main() {
         .map(|(i, p)| CalibrantPoint {
             library_rt: p[0],
             observed_rt: p[1],
-            library_id: i as u64,
+            library_id: i.to_string(),
         })
         .collect();
     let n_calibrants = points.len();
diff --git a/rust/calib_dash/src/frames.rs b/rust/calib_dash/src/frames.rs
index 3d352c35..687f983d 100644
--- a/rust/calib_dash/src/frames.rs
+++ b/rust/calib_dash/src/frames.rs
@@ -24,11 +24,11 @@ pub const REPLAY_BUDGET_BYTES: usize = 1 << 20;
 /// needs a stable identity for a calibrant: RT coordinates are not unique and
 /// cannot distinguish "same peptide, re-scored" from "different peptide, same
 /// RT".
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct CalibrantPoint {
     pub library_rt: f64,
     pub observed_rt: f64,
-    pub library_id: u64,
+    pub library_id: String,
 }
 
 struct FrameIndex {
@@ -73,7 +73,7 @@ impl FrameStore {
             CalibrantPoint {
                 library_rt: 0.0,
                 observed_rt: 0.0,
-                library_id: 0
+                library_id: String::new()
             };
             (stride_capacity + 1) * n_calibrants
         ];
@@ -148,7 +148,7 @@ mod tests {
         CalibrantPoint {
             library_rt: i as f64,
             observed_rt: i as f64 * 2.0,
-            library_id: i as u64,
+            library_id: i.to_string(),
         }
     }
 
@@ -156,7 +156,7 @@ mod tests {
     /// pass for another's.
     fn pt_in(chunk: usize, i: usize) -> CalibrantPoint {
         CalibrantPoint {
-            library_id: (chunk * 100 + i) as u64,
+            library_id: (chunk * 100 + i).to_string(),
             ..pt(i)
         }
     }
diff --git a/rust/calib_dash/src/metrics.rs b/rust/calib_dash/src/metrics.rs
index 69eceb22..03c12a97 100644
--- a/rust/calib_dash/src/metrics.rs
+++ b/rust/calib_dash/src/metrics.rs
@@ -59,8 +59,8 @@ pub fn curve_delta(
 
 /// `(admitted, evicted)` between two heap snapshots, by `library_id`.
 pub fn churn(prev: &[CalibrantPoint], cur: &[CalibrantPoint]) -> (usize, usize) {
-    let prev_set: HashSet<u64> = prev.iter().map(|p| p.library_id).collect();
-    let cur_set: HashSet<u64> = cur.iter().map(|p| p.library_id).collect();
+    let prev_set: HashSet<&str> = prev.iter().map(|p| p.library_id.as_str()).collect();
+    let cur_set: HashSet<&str> = cur.iter().map(|p| p.library_id.as_str()).collect();
     let admitted = cur_set.difference(&prev_set).count();
     let evicted = prev_set.difference(&cur_set).count();
     (admitted, evicted)
@@ -78,7 +78,7 @@ mod tests {
         CalibrantPoint {
             library_rt: 1.0,
             observed_rt: 1.0,
-            library_id: idx as u64,
+            library_id: idx.to_string(),
         }
     }
 
diff --git a/rust/timsseek_cli/src/processing.rs b/rust/timsseek_cli/src/processing.rs
index 08c91494..4ed6528f 100644
--- a/rust/timsseek_cli/src/processing.rs
+++ b/rust/timsseek_cli/src/processing.rs
@@ -174,7 +174,7 @@ mod calib_dash_hook {
                 calibrants.map(|c| calib_dash::CalibrantPoint {
                     library_rt: c.library_rt.0 as f64,
                     observed_rt: c.apex_rt.0 as f64,
-                    library_id: c.library_id,
+                    library_id: c.library_id.to_string(),
                 }),
             );
             if matches!(flow, calib_dash::Flow::Abort) {

From a75ae0a29f3843e5fbb767c274d45493889338a2 Mon Sep 17 00:00:00 2001
From: "J. Sebastian Paez" <jspaezp@gmail.com>
Date: Thu, 27 Aug 2026 20:24:10 -0700
Subject: [PATCH 04/19] fix: close the gaps a review found in the id
 propagation

- **The DIA-NN parquet variant was never wired up.** Only the TSV row struct
  gained the column, so a parquet library still got counter ids while the PR
  claimed otherwise. DIA-NN 2.2 spells it `Precursor.Id` there, not
  `transition_group_id`; the Carafe-written fixture has no such column, so both
  the propagating and the falling-back path now have a test.

- **A partially-named file could refuse to load.** A blank id cell made one
  group fall back to a counter while its neighbours kept names, and
  `SourceIds::owned` then coerced the whole library to text -- turning
  `Numeric(7)` into `"7"`, which is exactly the coercion this type exists to
  prevent, and which can collide with a real name of `"7"`. `owned` now refuses
  a mixed set outright, and the readers decide once per file: a library names
  every precursor or none, and a half-named one falls back to minting with a
  warning.

- **The per-query allocation fix was applied in one place and missed two.**
  The chromatogram and spectrum collectors are reset on the same scoring path as
  `Target::reset_from` and still built a fresh `String` per query per collector,
  up to three per scored candidate. They use `set_from` as well now.

- **`target_decoy_compete` cloned a group id two or three times per candidate**
  purely to build comparison keys, across both of its passes. It compares by
  index. `timsquery_cli` likewise cloned an id on the success path to use it
  only on the error path.

Two tests fill gaps the review named rather than restating what the code says:
the speclib ids are checked row-by-row against the property that defines them
(modified sequence + charge), since they ride through a rayon fold where a
permutation would mislabel every result silently; and `owned` gets the
mixed-shape case it had no coverage for.
---
 .../models/aggregators/chromatogram_agg.rs    |  2 +-
 .../src/models/aggregators/spectrum_agg.rs    |  2 +-
 rust/timsquery/src/models/source_id.rs        | 36 +++++++++-
 rust/timsquery/src/models/target.rs           |  4 ++
 rust/timsquery/src/serde/diann_io.rs          | 72 ++++++++++++++++++-
 rust/timsquery/src/serde/diann_speclib_io.rs  | 21 ++++++
 rust/timsquery_cli/src/processing.rs          |  5 +-
 rust/timsseek_cli/src/processing.rs           |  2 +-
 8 files changed, 134 insertions(+), 10 deletions(-)

diff --git a/rust/timsquery/src/models/aggregators/chromatogram_agg.rs b/rust/timsquery/src/models/aggregators/chromatogram_agg.rs
index 35244c6a..2e627bab 100644
--- a/rust/timsquery/src/models/aggregators/chromatogram_agg.rs
+++ b/rust/timsquery/src/models/aggregators/chromatogram_agg.rs
@@ -136,7 +136,7 @@ impl<T: KeyLike, V: ValueLike + ArrayElement> ChromatogramCollector<T, V> {
             return Err(DataProcessingError::ExpectedNonEmptyData);
         }
 
-        self.id = eg.output_id().to_owned_id();
+        self.id.set_from(eg.output_id());
         self.mobility_ook0 = mobility_override.unwrap_or_else(|| eg.mobility_ook0());
         self.rt_seconds = rt_override.unwrap_or_else(|| eg.rt_seconds());
         self.precursor_mono_mz = eg.mono_precursor_mz();
diff --git a/rust/timsquery/src/models/aggregators/spectrum_agg.rs b/rust/timsquery/src/models/aggregators/spectrum_agg.rs
index 38fa564e..9f4399f2 100644
--- a/rust/timsquery/src/models/aggregators/spectrum_agg.rs
+++ b/rust/timsquery/src/models/aggregators/spectrum_agg.rs
@@ -82,7 +82,7 @@ impl<T: KeyLike, V: ValueLike + Default> SpectralCollector<T, V> {
         rt_override: Option<f32>,
         mobility_override: Option<f32>,
     ) {
-        self.id = eg.output_id().to_owned_id();
+        self.id.set_from(eg.output_id());
         self.mobility_ook0 = mobility_override.unwrap_or_else(|| eg.mobility_ook0());
         self.rt_seconds = rt_override.unwrap_or_else(|| eg.rt_seconds());
         self.precursor_mono_mz = eg.mono_precursor_mz();
diff --git a/rust/timsquery/src/models/source_id.rs b/rust/timsquery/src/models/source_id.rs
index 40a5d30e..6603bf3b 100644
--- a/rust/timsquery/src/models/source_id.rs
+++ b/rust/timsquery/src/models/source_id.rs
@@ -149,6 +149,11 @@ pub enum SourceIdError {
     Duplicate { id: String },
     #[error("source id blob exceeds u32 offset range")]
     BlobTooLarge,
+    /// A library names its rows or it does not. Storing both shapes together
+    /// would mean rendering the numbers as strings, which is the coercion the
+    /// whole type exists to avoid.
+    #[error("source ids mix numeric and text shapes; a format carries one or the other")]
+    MixedShapes,
 }
 
 impl SourceIds {
@@ -206,7 +211,14 @@ impl SourceIds {
         }
         // All-numeric stays numeric so the common JSON path keeps its dense
         // integer column instead of paying for a blob.
-        if ids.iter().all(|id| matches!(id, OwnedSourceId::Numeric(_))) {
+        let n_numeric = ids
+            .iter()
+            .filter(|id| matches!(id, OwnedSourceId::Numeric(_)))
+            .count();
+        if n_numeric != 0 && n_numeric != ids.len() {
+            return Err(SourceIdError::MixedShapes);
+        }
+        if n_numeric == ids.len() {
             let nums = ids
                 .iter()
                 .map(|id| match id {
@@ -272,6 +284,28 @@ mod tests {
         );
     }
 
+    /// A library names its rows or it does not. Storing a mixed set would mean
+    /// rendering `Numeric(7)` as `"7"`, which is the coercion this type exists
+    /// to avoid -- and would then collide with a genuine name of `"7"`.
+    #[test]
+    fn mixed_shapes_are_refused_rather_than_coerced() {
+        let mixed = vec![
+            OwnedSourceId::Numeric(7),
+            OwnedSourceId::Text("AAAK2".into()),
+        ];
+        assert_eq!(SourceIds::owned(mixed, 2), Err(SourceIdError::MixedShapes));
+
+        // Either shape on its own is fine, and numeric keeps the dense column.
+        assert!(matches!(
+            SourceIds::owned(vec![OwnedSourceId::Numeric(7)], 1),
+            Ok(SourceIds::Numeric(_))
+        ));
+        assert!(matches!(
+            SourceIds::owned(vec![OwnedSourceId::Text("AAAK2".into())], 1),
+            Ok(SourceIds::Text { .. })
+        ));
+    }
+
     #[test]
     fn text_ids_round_trip_through_the_blob() {
         let ids = SourceIds::text(["AAAK2", "PEPTIDEK3"], 2).unwrap();
diff --git a/rust/timsquery/src/models/target.rs b/rust/timsquery/src/models/target.rs
index 687e4b33..e7d45873 100644
--- a/rust/timsquery/src/models/target.rs
+++ b/rust/timsquery/src/models/target.rs
@@ -107,6 +107,10 @@ impl<T: KeyLike> Target<T> {
         self.id.as_ref()
     }
 
+    pub(crate) fn set_id(&mut self, id: crate::models::OwnedSourceId) {
+        self.id = id;
+    }
+
     pub fn precursor_count(&self) -> usize {
         self.precursor_labels.len()
     }
diff --git a/rust/timsquery/src/serde/diann_io.rs b/rust/timsquery/src/serde/diann_io.rs
index bb66b87f..67d9e3cd 100644
--- a/rust/timsquery/src/serde/diann_io.rs
+++ b/rust/timsquery/src/serde/diann_io.rs
@@ -267,6 +267,9 @@ struct ParquetColumnData<'a> {
     fragment_loss_types: &'a [String],
     protein_groups: &'a [String],
     decoys: &'a [i64],
+    /// DIA-NN 2.2 names the precursor in `Precursor.Id`. `None` when the file
+    /// has no such column, which is the minted-id fallback.
+    precursor_ids: Option<&'a [String]>,
 }
 
 pub fn read_targets<T: AsRef<Path>>(
@@ -314,10 +317,33 @@ pub fn read_targets<T: AsRef<Path>>(
         elution_groups.push(eg);
     }
 
+    unify_source_ids(&mut elution_groups);
     info!("Parsed {} elution groups", elution_groups.len());
     Ok(elution_groups)
 }
 
+/// A DIA-NN library names every precursor or none of them. A file that names
+/// only some is malformed (a blank `transition_group_id` cell, say), and the
+/// arena cannot hold both shapes at once, so fall the whole file back to minted
+/// ids rather than half-labelling it.
+fn unify_source_ids(egs: &mut [(Target<IonAnnot>, DiannPrecursorExtras)]) {
+    let named = egs
+        .iter()
+        .filter(|(eg, _)| matches!(eg.id(), crate::models::SourceId::Text(_)))
+        .count();
+    if named == 0 || named == egs.len() {
+        return;
+    }
+    warn!(
+        "{named} of {} precursors carry a name; the rest do not. Falling back to \
+         minted ids for the whole library.",
+        egs.len()
+    );
+    for (i, (eg, _)) in egs.iter_mut().enumerate() {
+        eg.set_id(crate::models::OwnedSourceId::Numeric(i as u64));
+    }
+}
+
 fn parse_precursor_group(
     id: u64,
     rows: &[DiannLibraryRow],
@@ -420,8 +446,12 @@ fn parse_precursor_group(
     // DIA-NN names the precursor itself; carry that through so results say what
     // the library says. Variants without the column fall back to the counter,
     // which `seal` treats as any other minted id.
-    let source_id: crate::models::OwnedSourceId = match &first_row.transition_group_id {
-        Some(name) => name.as_str().into(),
+    let source_id: crate::models::OwnedSourceId = match first_row
+        .transition_group_id
+        .as_deref()
+        .filter(|name| !name.is_empty())
+    {
+        Some(name) => name.into(),
         None => id.into(),
     };
     let eg = Target::builder()
@@ -564,6 +594,9 @@ pub fn read_parquet_library_file<T: AsRef<Path>>(
     let fragment_numbers = get_int_column(&all_batches, "Fragment.Series.Number")?;
     let fragment_loss_types = get_string_column(&all_batches, "Fragment.Loss.Type")?;
     let protein_groups = get_string_column(&all_batches, "Protein.Group")?;
+    // Optional: absent from libraries written by other tools (the Carafe
+    // fixture has no such column), which then fall back to minted ids.
+    let precursor_ids = get_string_column(&all_batches, "Precursor.Id").ok();
     let decoys = get_int_column(&all_batches, "Decoy")?;
 
     let num_rows = modified_sequences.len();
@@ -584,6 +617,7 @@ pub fn read_parquet_library_file<T: AsRef<Path>>(
         fragment_loss_types: &fragment_loss_types,
         protein_groups: &protein_groups,
         decoys: &decoys,
+        precursor_ids: precursor_ids.as_deref(),
     };
 
     // Group fragments by precursor (same logic as TSV reader)
@@ -635,6 +669,7 @@ pub fn read_parquet_library_file<T: AsRef<Path>>(
         elution_groups.push(eg);
     }
 
+    unify_source_ids(&mut elution_groups);
     info!(
         "Parsed {} elution groups from parquet file",
         elution_groups.len()
@@ -740,8 +775,18 @@ fn parse_precursor_group_from_parquet(
         relative_intensities: rel_intensities,
     };
 
+    // DIA-NN names the precursor in `Precursor.Id`; carry that through when the
+    // file has it, else fall back to the counter as the TSV path does.
+    let source_id: crate::models::OwnedSourceId = match columns
+        .precursor_ids
+        .map(|ids| ids[first_idx].as_str())
+        .filter(|name| !name.is_empty())
+    {
+        Some(name) => name.into(),
+        None => id.into(),
+    };
     let eg = Target::builder()
-        .id(id)
+        .id(source_id)
         .mobility_ook0(mobility)
         .rt_seconds(rt_seconds)
         .fragment_labels(buffers.fragment_labels.as_slice().into())
@@ -800,6 +845,27 @@ mod tests {
         assert_eq!(unnamed[0].0.id(), crate::models::SourceId::Numeric(0));
     }
 
+    /// Same for the parquet variant, where DIA-NN 2.2 spells the name
+    /// `Precursor.Id`. The Carafe-written fixture has no such column, so it
+    /// exercises the fallback.
+    #[test]
+    fn precursor_id_is_propagated_from_parquet_when_present() {
+        let dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("tests")
+            .join("diann_io_files");
+
+        let named = read_parquet_library_file(dir.join("sample_pq_speclib.parquet"))
+            .expect("named variant loads");
+        assert_eq!(
+            named[0].0.id(),
+            crate::models::SourceId::Text("GREEWESAALQNANTK3")
+        );
+
+        let unnamed = read_parquet_library_file(dir.join("carafe_pq_speclib.parquet"))
+            .expect("unnamed variant loads");
+        assert_eq!(unnamed[0].0.id(), crate::models::SourceId::Numeric(0));
+    }
+
     #[test]
     fn test_read_targets() {
         let manifest_dir = env!("CARGO_MANIFEST_DIR");
diff --git a/rust/timsquery/src/serde/diann_speclib_io.rs b/rust/timsquery/src/serde/diann_speclib_io.rs
index f82ae1a9..bcb6a8ca 100644
--- a/rust/timsquery/src/serde/diann_speclib_io.rs
+++ b/rust/timsquery/src/serde/diann_speclib_io.rs
@@ -987,6 +987,27 @@ mod tests {
         );
     }
 
+    /// Entries are parsed in parallel and the names ride in the same rayon
+    /// accumulator as the rows, so a permutation would mislabel every result
+    /// without failing anything else. Pin it against the property that defines
+    /// the name: it is the modified sequence plus the charge, for every row.
+    #[test]
+    fn every_source_id_stays_paired_with_its_own_row() {
+        let file = std::fs::File::open(fixture_path()).unwrap();
+        let (geom, _frag_intens, _stats, _eof) =
+            parse_speclib_reader(std::io::BufReader::new(file)).unwrap();
+
+        assert!(geom.n_rows() > 1, "one row would not catch a permutation");
+        for row in geom.rows() {
+            let expected = format!("{}{}", geom.seq_mod(row), geom.charge(row));
+            assert_eq!(
+                geom.output_id(row),
+                crate::models::SourceId::Text(&expected),
+                "source id is not the one belonging to this row"
+            );
+        }
+    }
+
     #[test]
     fn test_first_entry_fields_and_fragments() {
         let file = std::fs::File::open(fixture_path()).unwrap();
diff --git a/rust/timsquery_cli/src/processing.rs b/rust/timsquery_cli/src/processing.rs
index 0ebeb3c4..007feed5 100644
--- a/rust/timsquery_cli/src/processing.rs
+++ b/rust/timsquery_cli/src/processing.rs
@@ -153,7 +153,6 @@ impl<T: KeyLike + Display> AggregatorContainer<T> {
                 let converted_results: Vec<ChromatogramOutput> = aggregators
                     .par_drain(..)
                     .filter_map(|mut agg| {
-                        let agg_id = agg.id.clone();
                         match ChromatogramOutput::try_new(&mut agg, ref_rts) {
                             Ok(output) => Some(output),
                             Err(e) => {
@@ -161,14 +160,14 @@ impl<T: KeyLike + Display> AggregatorContainer<T> {
                                     timsquery::errors::DataProcessingError::ExpectedNonEmptyData => {
                                         warn!(
                                             "Skipping chromatogram for elution group id {}: {:?}",
-                                            agg_id, e
+                                            agg.id, e
                                         );
                                         None
                                     }
                                     _ => {
                                         error!(
                                             "Error generating chromatogram for elution group id {}: {:?}",
-                                            agg_id, e
+                                            agg.id, e
                                         );
                                         panic!("Terminating due to unexpected error");
                                     }
diff --git a/rust/timsseek_cli/src/processing.rs b/rust/timsseek_cli/src/processing.rs
index 4ed6528f..71601608 100644
--- a/rust/timsseek_cli/src/processing.rs
+++ b/rust/timsseek_cli/src/processing.rs
@@ -1,6 +1,5 @@
 use super::config::OutputConfig;
 use indicatif::ProgressIterator;
-use timsquery::models::OwnedSourceId;
 use timsquery::models::tolerance::{
     MobilityTolerance,
     MzTolerance,
@@ -1150,6 +1149,7 @@ pub fn run_pipeline(
 mod tests {
     use super::*;
     use std::sync::Arc;
+    use timsquery::models::OwnedSourceId;
     use timsseek::models::DecoyMarking;
     use timsseek::models::sequence::Peptide;
     use timsseek::scoring::results::ScoringFields;

From e1c7572901389ef5252b9f5bc8940ad5cd4be748 Mon Sep 17 00:00:00 2001
From: "J. Sebastian Paez" <jspaezp@gmail.com>
Date: Thu, 27 Aug 2026 21:40:21 -0700
Subject: [PATCH 05/19] fix(timsquery): the DIA-NN ids never reached the arena

The readers set `Target::id` from `transition_group_id` / `Precursor.Id`
correctly, and then `mzpaf_with_intensities` sealed the arena without carrying
it over -- and that is the arm every DIA-NN library takes, because those readers
always return `Some(FileReadingExtras::Diann(..))`. `seal()` saw
`SourceIds::Absent` and minted `0..n` over the names it had just parsed. Only
the `.speclib` path worked, because it writes ids onto the arena itself.

Setting the ids and sealing are now one function, so the three arms cannot seal
without deciding about ids, which is the shape of the mistake.

The tests missed it by asserting on `Target::id()` -- the value the readers
produce, one layer above the thing that discarded it. They are replaced by two
in `library_file`, at the arena layer, reading back through `read_targets` what
a result would actually be keyed by. Reverting the wiring fails them with
`["0"]` against `["AAAAAAALQAK2"]`.
---
 rust/timsquery/src/serde/diann_io.rs     | 42 -------------
 rust/timsquery/src/serde/library_file.rs | 79 ++++++++++++++++++++----
 2 files changed, 68 insertions(+), 53 deletions(-)

diff --git a/rust/timsquery/src/serde/diann_io.rs b/rust/timsquery/src/serde/diann_io.rs
index 67d9e3cd..9cf0d91a 100644
--- a/rust/timsquery/src/serde/diann_io.rs
+++ b/rust/timsquery/src/serde/diann_io.rs
@@ -824,48 +824,6 @@ mod tests {
         );
     }
 
-    /// The two DIA-NN TSV variants differ in whether they name the precursor:
-    /// `sample_lib.tsv` carries `transition_group_id`, `sample_lib.txt` does
-    /// not. The named one must come through as the library spelled it; the
-    /// unnamed one must still load and fall back.
-    #[test]
-    fn transition_group_id_is_propagated_when_the_file_has_one() {
-        let dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-            .join("tests")
-            .join("diann_io_files");
-
-        let named = read_targets(dir.join("sample_lib.tsv")).expect("named variant loads");
-        assert_eq!(
-            named[0].0.id(),
-            crate::models::SourceId::Text("AAAAAAALQAK2"),
-            "DIA-NN's own name for the precursor, not a counter"
-        );
-
-        let unnamed = read_targets(dir.join("sample_lib.txt")).expect("unnamed variant loads");
-        assert_eq!(unnamed[0].0.id(), crate::models::SourceId::Numeric(0));
-    }
-
-    /// Same for the parquet variant, where DIA-NN 2.2 spells the name
-    /// `Precursor.Id`. The Carafe-written fixture has no such column, so it
-    /// exercises the fallback.
-    #[test]
-    fn precursor_id_is_propagated_from_parquet_when_present() {
-        let dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-            .join("tests")
-            .join("diann_io_files");
-
-        let named = read_parquet_library_file(dir.join("sample_pq_speclib.parquet"))
-            .expect("named variant loads");
-        assert_eq!(
-            named[0].0.id(),
-            crate::models::SourceId::Text("GREEWESAALQNANTK3")
-        );
-
-        let unnamed = read_parquet_library_file(dir.join("carafe_pq_speclib.parquet"))
-            .expect("unnamed variant loads");
-        assert_eq!(unnamed[0].0.id(), crate::models::SourceId::Numeric(0));
-    }
-
     #[test]
     fn test_read_targets() {
         let manifest_dir = env!("CARGO_MANIFEST_DIR");
diff --git a/rust/timsquery/src/serde/library_file.rs b/rust/timsquery/src/serde/library_file.rs
index 7866c07f..ba65a5ee 100644
--- a/rust/timsquery/src/serde/library_file.rs
+++ b/rust/timsquery/src/serde/library_file.rs
@@ -321,7 +321,7 @@ impl TargetTable {
             )));
         }
 
-        geom.seal();
+        seal_with_source_ids(&mut geom, &egs)?;
         Ok(TargetTable::Mzpaf {
             geom,
             frag_intens: Some(frag_intens),
@@ -364,8 +364,7 @@ impl TargetTable {
                         &[],
                     );
                 }
-                set_source_ids_from(&mut geom, &egs)?;
-                geom.seal();
+                seal_with_source_ids(&mut geom, &egs)?;
                 Ok(TargetTable::Mzpaf {
                     geom,
                     frag_intens: None,
@@ -392,8 +391,7 @@ impl TargetTable {
                         &[],
                     );
                 }
-                set_source_ids_from(&mut geom, &egs)?;
-                geom.seal();
+                seal_with_source_ids(&mut geom, &egs)?;
                 Ok(TargetTable::Str { geom })
             }
             ElutionGroupCollection::TinyIntLabels(..) | ElutionGroupCollection::IntLabels(..) => {
@@ -404,11 +402,14 @@ impl TargetTable {
     }
 }
 
-/// Carry the caller's `id` from the JSON payload into the arena.
+/// Carry the rows' ids into the arena, then seal it.
 ///
-/// Only this path has one: the tabular readers identify precursors by string
-/// (DIA-NN's `transition_group_id`) or not at all, and neither is stored yet.
-fn set_source_ids_from<L: KeyLike, T: KeyLike>(
+/// The two steps are one function because separating them is how the ids got
+/// lost: `mzpaf_with_intensities` sealed without them, so every DIA-NN library
+/// -- the formats that actually name their precursors -- minted `0..n` over the
+/// names it had just parsed, and the reader-level tests passed because they
+/// asserted on the `Target` rather than on the arena.
+fn seal_with_source_ids<L: KeyLike, T: KeyLike>(
     geom: &mut TargetColumns<L>,
     egs: &[Target<T>],
 ) -> Result<(), TargetReadingError> {
@@ -416,8 +417,9 @@ fn set_source_ids_from<L: KeyLike, T: KeyLike>(
         .iter()
         .map(|eg| eg.id().to_owned_id())
         .collect::<Vec<_>>();
-    geom.set_source_ids_owned(ids)
-        .map_err(TargetReadingError::SourceId)
+    geom.set_source_ids_owned(ids)?;
+    geom.seal();
+    Ok(())
 }
 
 /// A single spectral-library format reader. Adding a format = one struct + one
@@ -586,3 +588,58 @@ pub fn read_targets<T: AsRef<Path>>(path: T) -> Result<TargetTable, TargetReadin
     // defensive fallback.
     Err(last_err.unwrap_or(TargetReadingError::UnableToParseElutionGroups))
 }
+
+#[cfg(test)]
+mod tests {
+    use std::path::{
+        Path,
+        PathBuf,
+    };
+
+    /// What a result would actually be keyed by: the ids the sealed arena
+    /// holds, read back through the public funnel.
+    ///
+    /// Every id assertion belongs at this layer. The readers were setting
+    /// `Target::id` correctly the whole time while `mzpaf_with_intensities`
+    /// sealed without carrying it over, so tests one layer up passed against an
+    /// arena full of minted counters.
+    fn arena_ids(path: &Path) -> Vec<String> {
+        match super::read_targets(path).expect("fixture loads") {
+            super::TargetTable::Mzpaf { geom, .. } => {
+                geom.rows().map(|r| geom.output_id(r).to_string()).collect()
+            }
+            super::TargetTable::Str { geom } => {
+                geom.rows().map(|r| geom.output_id(r).to_string()).collect()
+            }
+        }
+    }
+
+    fn fixture(name: &str) -> PathBuf {
+        PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("tests/diann_io_files")
+            .join(name)
+    }
+
+    /// `sample_lib.tsv` carries `transition_group_id`; `sample_lib.txt` does
+    /// not, so between them they cover propagation and the minted fallback.
+    #[test]
+    fn a_diann_tsv_name_survives_into_the_arena() {
+        assert_eq!(
+            arena_ids(&fixture("sample_lib.tsv")),
+            ["AAAAAAALQAK2"],
+            "DIA-NN's own name for the precursor, not a counter"
+        );
+        assert_eq!(arena_ids(&fixture("sample_lib.txt")), ["0", "1"]);
+    }
+
+    /// Same, for the parquet variant, where DIA-NN 2.2 spells it
+    /// `Precursor.Id`. The Carafe-written fixture has no such column.
+    #[test]
+    fn a_diann_parquet_name_survives_into_the_arena() {
+        assert_eq!(
+            arena_ids(&fixture("sample_pq_speclib.parquet"))[0],
+            "GREEWESAALQNANTK3"
+        );
+        assert_eq!(arena_ids(&fixture("carafe_pq_speclib.parquet"))[0], "0");
+    }
+}

From 26c8632aa0c87075e8952e12dc4e2967640890c8 Mon Sep 17 00:00:00 2001
From: "J. Sebastian Paez" <jspaezp@gmail.com>
Date: Thu, 27 Aug 2026 21:43:05 -0700
Subject: [PATCH 06/19] refactor(timsquery): one source-id setter instead of
 three

`set_source_ids` took `Vec<LibraryId>` and had no callers. The other two
differed only in the shape they accepted, so they collapse into one generic over
`Into<OwnedSourceId>` -- which is what the two live call sites were reaching
for. Also puts them back beside each other; `set_source_ids_text` had been
appended 38 lines away, past unrelated accessors.
---
 rust/timsquery/src/models/target_columns.rs  | 28 ++++++--------------
 rust/timsquery/src/serde/diann_speclib_io.rs |  2 +-
 rust/timsquery/src/serde/library_file.rs     |  2 +-
 3 files changed, 10 insertions(+), 22 deletions(-)

diff --git a/rust/timsquery/src/models/target_columns.rs b/rust/timsquery/src/models/target_columns.rs
index d4cd4cd0..45e150d9 100644
--- a/rust/timsquery/src/models/target_columns.rs
+++ b/rust/timsquery/src/models/target_columns.rs
@@ -5,7 +5,6 @@ use crate::models::capabilities::{
 };
 use crate::models::query_handle::QueryRef;
 use crate::models::source_id::{
-    LibraryId,
     OwnedSourceId,
     SourceId,
     SourceIdError,
@@ -221,14 +220,14 @@ impl<L: KeyLike> TargetColumns<L> {
         self.charge.len()
     }
 
-    /// Attach caller-supplied ids. Call after every `push_row`, before `seal`.
-    pub fn set_source_ids(&mut self, ids: Vec<LibraryId>) -> Result<(), SourceIdError> {
-        self.source_ids = SourceIds::numeric(ids, self.n_rows())?;
-        Ok(())
-    }
-
-    /// Attach ids of whichever shape the file used.
-    pub fn set_source_ids_owned(&mut self, ids: Vec<OwnedSourceId>) -> Result<(), SourceIdError> {
+    /// Attach the ids the file gave its rows, in whichever shape it used.
+    /// Call after every `push_row`, before `seal`.
+    pub fn set_source_ids<I, S>(&mut self, ids: I) -> Result<(), SourceIdError>
+    where
+        I: IntoIterator<Item = S>,
+        S: Into<OwnedSourceId>,
+    {
+        let ids: Vec<OwnedSourceId> = ids.into_iter().map(Into::into).collect();
         self.source_ids = SourceIds::owned(ids, self.n_rows())?;
         Ok(())
     }
@@ -264,17 +263,6 @@ impl<L: KeyLike> TargetColumns<L> {
             .expect("sealed targets have source ids; seal() mints any that are missing")
     }
 
-    /// Attach ids the file spelled as text, e.g. DIA-NN's
-    /// `transition_group_id`. Call after every `push_row`, before `seal`.
-    pub fn set_source_ids_text<I, S>(&mut self, ids: I) -> Result<(), SourceIdError>
-    where
-        I: IntoIterator<Item = S>,
-        S: AsRef<str>,
-    {
-        self.source_ids = SourceIds::text(ids, self.n_rows())?;
-        Ok(())
-    }
-
     pub fn charge(&self, tgt: RowIdx) -> u8 {
         self.charge[tgt.get()]
     }
diff --git a/rust/timsquery/src/serde/diann_speclib_io.rs b/rust/timsquery/src/serde/diann_speclib_io.rs
index bcb6a8ca..7e2131b0 100644
--- a/rust/timsquery/src/serde/diann_speclib_io.rs
+++ b/rust/timsquery/src/serde/diann_speclib_io.rs
@@ -527,7 +527,7 @@ impl SpecLib {
 
         // The entry name is DIA-NN's `transition_group_id`, so results name the
         // precursor the way the library does rather than by a minted counter.
-        geom.set_source_ids_text(source_ids)?;
+        geom.set_source_ids(source_ids)?;
 
         Ok((geom, frag_intens, stats, at_eof))
     }
diff --git a/rust/timsquery/src/serde/library_file.rs b/rust/timsquery/src/serde/library_file.rs
index ba65a5ee..e27d2852 100644
--- a/rust/timsquery/src/serde/library_file.rs
+++ b/rust/timsquery/src/serde/library_file.rs
@@ -417,7 +417,7 @@ fn seal_with_source_ids<L: KeyLike, T: KeyLike>(
         .iter()
         .map(|eg| eg.id().to_owned_id())
         .collect::<Vec<_>>();
-    geom.set_source_ids_owned(ids)?;
+    geom.set_source_ids(ids)?;
     geom.seal();
     Ok(())
 }

From 1bb7dc1b7f23cb9fd07e2d19dd9c2b41799b0309 Mon Sep 17 00:00:00 2001
From: "J. Sebastian Paez" <jspaezp@gmail.com>
Date: Thu, 27 Aug 2026 21:45:29 -0700
Subject: [PATCH 07/19] docs: correct the format-version list, the shape claim,
 and stale comments

- `RESULTS_FORMAT_VERSION` was bumped to 3 with no `- 3:` entry, leaving the
  one thing that tells a reader why an old file misreads stopping at 2.
- `source_id`'s module doc claimed no id is ever coerced into the other's shape
  while the parquet writer coerces both to Utf8. Say where the shape is
  preserved and where it is not.
- `set_source_ids_from`'s doc said the tabular readers store no ids, which this
  branch is what made false.
- Two comments narrated the diff rather than the invariant.
---
 rust/timsquery/src/models/source_id.rs      | 11 ++++++++---
 rust/timsseek/src/scoring/parquet_writer.rs |  3 +++
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/rust/timsquery/src/models/source_id.rs b/rust/timsquery/src/models/source_id.rs
index 6603bf3b..e594faf5 100644
--- a/rust/timsquery/src/models/source_id.rs
+++ b/rust/timsquery/src/models/source_id.rs
@@ -6,9 +6,14 @@
 //!
 //! Ids are polymorphic because formats disagree: JSON targets carry integers,
 //! DIA-NN carries `transition_group_id` / the `.speclib` entry name, which are
-//! strings. Neither is coerced into the other's shape — a numeric id stays a
-//! JSON number so Carafe's `"id": 7` is unchanged, and a text id stays a
-//! string.
+//! strings.
+//!
+//! The shape is preserved where a consumer distinguishes the two, which today
+//! is the JSON result path only: Carafe reads `id` with fastjson and keys
+//! results by it, so `"id": 7` must stay a bare number. The parquet writer does
+//! not distinguish — both id columns are `Utf8` and a numeric id is written as
+//! its digits — because a search result is read by column type, not by the
+//! shape of one value.
 
 use serde::{
     Deserialize,
diff --git a/rust/timsseek/src/scoring/parquet_writer.rs b/rust/timsseek/src/scoring/parquet_writer.rs
index 5b43d9fb..89bad0b0 100644
--- a/rust/timsseek/src/scoring/parquet_writer.rs
+++ b/rust/timsseek/src/scoring/parquet_writer.rs
@@ -26,6 +26,9 @@ use super::results::FinalResult;
 ///   already the caller's id but was truncated to 32 bits; `decoy_group_id`
 ///   used to be the arena row position and is now an id declared by the input
 ///   or minted at load.
+/// - 3: both became Utf8, because an id keeps the shape its source used and
+///   DIA-NN names its precursors with a string (`transition_group_id`). A
+///   numeric id is written as its digits.
 pub const RESULTS_FORMAT_VERSION: u32 = 3;
 
 // ---------------------------------------------------------------------------

From 17f82e63b5b2bd86fbf362eb90188f734dbd1967 Mon Sep 17 00:00:00 2001
From: "J. Sebastian Paez" <jspaezp@gmail.com>
Date: Thu, 27 Aug 2026 21:48:08 -0700
Subject: [PATCH 08/19] fix(timsquery): make a dropped column a compile error,
 and shrink decoy_groups

`append_arena` handled columns by hand and silently skipped `source_ids` and
`decoy_groups`. Harmless today -- the speclib path sets both on the merged
arena, so a shard never holds any -- but the next column added would have been
dropped on every merge with nothing to say so. It now destructures
`TargetColumns` exhaustively, so adding a column fails to compile here.

`decoy_groups` was also missing from `seal`'s shrink list.
---
 rust/timsquery/src/models/target_columns.rs  |  3 ++-
 rust/timsquery/src/serde/diann_speclib_io.rs | 25 ++++++++++++++++++++
 2 files changed, 27 insertions(+), 1 deletion(-)

diff --git a/rust/timsquery/src/models/target_columns.rs b/rust/timsquery/src/models/target_columns.rs
index 45e150d9..11ac3c51 100644
--- a/rust/timsquery/src/models/target_columns.rs
+++ b/rust/timsquery/src/models/target_columns.rs
@@ -100,7 +100,7 @@ pub struct TargetColumns<L: KeyLike> {
     /// derived from the row position: group membership is a property of the
     /// analytes, and reading it off the arena layout only works for as long as
     /// the layout happens to encode it.
-    decoy_groups: Vec<OwnedSourceId>,
+    pub(crate) decoy_groups: Vec<OwnedSourceId>,
     // CSR prefix offsets (n+1)
     pub(crate) frag_off: Vec<u32>,
     pub(crate) seq_strip_off: Vec<u32>,
@@ -389,6 +389,7 @@ impl<L: KeyLike> TargetColumns<L> {
         self.seq_strip_blob.shrink_to_fit();
         self.seq_mod_blob.shrink_to_fit();
         self.mods.shrink_to_fit();
+        self.decoy_groups.shrink_to_fit();
         self.mod_registry.shrink_to_fit();
     }
 }
diff --git a/rust/timsquery/src/serde/diann_speclib_io.rs b/rust/timsquery/src/serde/diann_speclib_io.rs
index 7e2131b0..3132ebf5 100644
--- a/rust/timsquery/src/serde/diann_speclib_io.rs
+++ b/rust/timsquery/src/serde/diann_speclib_io.rs
@@ -683,6 +683,31 @@ fn append_arena(dst: &mut TargetColumns<IonAnnot>, mut src: TargetColumns<IonAnn
     dst.mod_off.extend(src.mod_off[1..].iter().map(|&o| {
         u32::try_from(o as usize + mods_base).expect("mods arena exceeds u32 offset range")
     }));
+
+    // Exhaustive on purpose: a column added to `TargetColumns` fails to compile
+    // here instead of being silently dropped on every merge. `source_ids` and
+    // `decoy_groups` are deliberately not merged -- the caller sets them on the
+    // finished arena, so a shard never holds any.
+    let TargetColumns {
+        caps: _,
+        precursor_mz: _,
+        charge: _,
+        rt_seconds: _,
+        mobility: _,
+        is_decoy: _,
+        source_ids: _,
+        decoy_groups: _,
+        frag_off: _,
+        seq_strip_off: _,
+        seq_mod_off: _,
+        mod_off: _,
+        frag_labels: _,
+        frag_mzs: _,
+        seq_strip_blob: _,
+        seq_mod_blob: _,
+        mods: _,
+        mod_registry: _,
+    } = src;
 }
 
 /// Map a decoded target `EntryView` directly into the columnar arena, folding

From f964c489d420a80b453fb5a0439324260553650b Mon Sep 17 00:00:00 2001
From: "J. Sebastian Paez" <jspaezp@gmail.com>
Date: Thu, 27 Aug 2026 21:52:20 -0700
Subject: [PATCH 09/19] style: use the imports that are already in scope

Fully-qualified `crate::models::` and `pyo3::` paths inline where a `use` (or
the pyo3 prelude) was already there, `Default::default()` at a struct-literal
field where the type name says more, and a `let` binding that only existed to
name what `#[builder(into)]` already accepts.
---
 python/timsquery_pyo3/src/chromatogram.rs     |  2 +-
 python/timsquery_pyo3/src/elution_group.rs    |  2 +-
 python/timsquery_pyo3/src/iterator.rs         |  2 +-
 python/timsquery_pyo3/src/spectrum.rs         |  4 +--
 rust/apex_sim/src/sim.rs                      |  3 +-
 .../src/models/aggregators/spectrum_agg.rs    |  2 +-
 rust/timsquery/src/serde/diann_io.rs          | 28 ++++++++-----------
 7 files changed, 20 insertions(+), 23 deletions(-)

diff --git a/python/timsquery_pyo3/src/chromatogram.rs b/python/timsquery_pyo3/src/chromatogram.rs
index 471e8c81..427b1f97 100644
--- a/python/timsquery_pyo3/src/chromatogram.rs
+++ b/python/timsquery_pyo3/src/chromatogram.rs
@@ -63,7 +63,7 @@ impl PyChromatogramResult {
     }
 
     #[getter]
-    fn id<'py>(&self, py: pyo3::Python<'py>) -> pyo3::PyResult<pyo3::Bound<'py, pyo3::PyAny>> {
+    fn id<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
         crate::source_id_to_py(py, &self.collector.id)
     }
 
diff --git a/python/timsquery_pyo3/src/elution_group.rs b/python/timsquery_pyo3/src/elution_group.rs
index 66ad74db..0724d342 100644
--- a/python/timsquery_pyo3/src/elution_group.rs
+++ b/python/timsquery_pyo3/src/elution_group.rs
@@ -60,7 +60,7 @@ impl PyElutionGroup {
     }
 
     #[getter]
-    fn id<'py>(&self, py: pyo3::Python<'py>) -> pyo3::PyResult<pyo3::Bound<'py, pyo3::PyAny>> {
+    fn id<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
         crate::source_id_to_py(py, &self.inner.id().to_owned_id())
     }
 
diff --git a/python/timsquery_pyo3/src/iterator.rs b/python/timsquery_pyo3/src/iterator.rs
index a6a65a22..2e051b1e 100644
--- a/python/timsquery_pyo3/src/iterator.rs
+++ b/python/timsquery_pyo3/src/iterator.rs
@@ -42,7 +42,7 @@ pub struct PyChromatogramArrays {
 #[pymethods]
 impl PyChromatogramArrays {
     #[getter]
-    fn id<'py>(&self, py: pyo3::Python<'py>) -> pyo3::PyResult<pyo3::Bound<'py, pyo3::PyAny>> {
+    fn id<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
         crate::source_id_to_py(py, &self.id)
     }
 
diff --git a/python/timsquery_pyo3/src/spectrum.rs b/python/timsquery_pyo3/src/spectrum.rs
index 9a962a14..305ded54 100644
--- a/python/timsquery_pyo3/src/spectrum.rs
+++ b/python/timsquery_pyo3/src/spectrum.rs
@@ -61,7 +61,7 @@ impl PySpectralResult {
 
     /// The elution group id.
     #[getter]
-    fn id<'py>(&self, py: pyo3::Python<'py>) -> pyo3::PyResult<pyo3::Bound<'py, pyo3::PyAny>> {
+    fn id<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
         crate::source_id_to_py(py, &self.collector.id)
     }
 
@@ -153,7 +153,7 @@ impl PyMzMobilityResult {
 
     /// The elution group id.
     #[getter]
-    fn id<'py>(&self, py: pyo3::Python<'py>) -> pyo3::PyResult<pyo3::Bound<'py, pyo3::PyAny>> {
+    fn id<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
         crate::source_id_to_py(py, &self.collector.id)
     }
 
diff --git a/rust/apex_sim/src/sim.rs b/rust/apex_sim/src/sim.rs
index 6174ddda..e77c472d 100644
--- a/rust/apex_sim/src/sim.rs
+++ b/rust/apex_sim/src/sim.rs
@@ -17,6 +17,7 @@ use rand::{
 };
 use rand_chacha::ChaCha8Rng;
 
+use timsquery::models::OwnedSourceId;
 use timsquery::{
     ChromatogramCollector,
     MzMajorIntensityArray,
@@ -340,7 +341,7 @@ pub fn build(params: &SimParams) -> SimData {
         TupleRange::try_new(map(0), map(n - 1)).expect("start < end for positive period");
 
     let chromatograms = ChromatogramCollector::<String, f32> {
-        id: Default::default(),
+        id: OwnedSourceId::default(),
         mobility_ook0: 1.0,
         rt_seconds: (map((realized_apex as usize).min(n - 1)) as f32) / 1000.0,
         precursor_mono_mz: dummy_mz,
diff --git a/rust/timsquery/src/models/aggregators/spectrum_agg.rs b/rust/timsquery/src/models/aggregators/spectrum_agg.rs
index 9f4399f2..8e7c70f7 100644
--- a/rust/timsquery/src/models/aggregators/spectrum_agg.rs
+++ b/rust/timsquery/src/models/aggregators/spectrum_agg.rs
@@ -53,7 +53,7 @@ pub struct SpectralCollector<T: KeyLike, V: Default + ValueLike> {
 impl<T: KeyLike, V: ValueLike + Default> SpectralCollector<T, V> {
     pub fn new(eg: &impl QueryGeom<Label = T>) -> Self {
         let mut out = Self {
-            id: Default::default(),
+            id: crate::models::OwnedSourceId::default(),
             mobility_ook0: 0.0,
             rt_seconds: 0.0,
             precursor_mono_mz: 0.0,
diff --git a/rust/timsquery/src/serde/diann_io.rs b/rust/timsquery/src/serde/diann_io.rs
index 9cf0d91a..dbf3a973 100644
--- a/rust/timsquery/src/serde/diann_io.rs
+++ b/rust/timsquery/src/serde/diann_io.rs
@@ -3,6 +3,10 @@ use crate::ion::{
     IonAnnot,
     IonParsingError,
 };
+use crate::models::{
+    OwnedSourceId,
+    SourceId,
+};
 use arrow::array::{
     Float32Array,
     Float64Array,
@@ -329,7 +333,7 @@ pub fn read_targets<T: AsRef<Path>>(
 fn unify_source_ids(egs: &mut [(Target<IonAnnot>, DiannPrecursorExtras)]) {
     let named = egs
         .iter()
-        .filter(|(eg, _)| matches!(eg.id(), crate::models::SourceId::Text(_)))
+        .filter(|(eg, _)| matches!(eg.id(), SourceId::Text(_)))
         .count();
     if named == 0 || named == egs.len() {
         return;
@@ -340,7 +344,7 @@ fn unify_source_ids(egs: &mut [(Target<IonAnnot>, DiannPrecursorExtras)]) {
         egs.len()
     );
     for (i, (eg, _)) in egs.iter_mut().enumerate() {
-        eg.set_id(crate::models::OwnedSourceId::Numeric(i as u64));
+        eg.set_id(OwnedSourceId::Numeric(i as u64));
     }
 }
 
@@ -446,16 +450,12 @@ fn parse_precursor_group(
     // DIA-NN names the precursor itself; carry that through so results say what
     // the library says. Variants without the column fall back to the counter,
     // which `seal` treats as any other minted id.
-    let source_id: crate::models::OwnedSourceId = match first_row
+    let name = first_row
         .transition_group_id
         .as_deref()
-        .filter(|name| !name.is_empty())
-    {
-        Some(name) => name.into(),
-        None => id.into(),
-    };
+        .filter(|name| !name.is_empty());
     let eg = Target::builder()
-        .id(source_id)
+        .id(name.map_or_else(|| id.into(), OwnedSourceId::from))
         .mobility_ook0(mobility)
         .rt_seconds(rt_seconds)
         .fragment_labels(buffers.fragment_labels.as_slice().into())
@@ -777,16 +777,12 @@ fn parse_precursor_group_from_parquet(
 
     // DIA-NN names the precursor in `Precursor.Id`; carry that through when the
     // file has it, else fall back to the counter as the TSV path does.
-    let source_id: crate::models::OwnedSourceId = match columns
+    let name = columns
         .precursor_ids
         .map(|ids| ids[first_idx].as_str())
-        .filter(|name| !name.is_empty())
-    {
-        Some(name) => name.into(),
-        None => id.into(),
-    };
+        .filter(|name| !name.is_empty());
     let eg = Target::builder()
-        .id(source_id)
+        .id(name.map_or_else(|| id.into(), OwnedSourceId::from))
         .mobility_ook0(mobility)
         .rt_seconds(rt_seconds)
         .fragment_labels(buffers.fragment_labels.as_slice().into())

From d1efdb77fb8b0d4d8d48183bc0a891a424bd0a58 Mon Sep 17 00:00:00 2001
From: "J. Sebastian Paez" <jspaezp@gmail.com>
Date: Thu, 27 Aug 2026 22:06:30 -0700
Subject: [PATCH 10/19] fix(calib_dash): compare calibrant identity by hash,
 restoring the budget

`FrameStore::new` sizes its slab from `size_of::<CalibrantPoint>()`, which was
exact while the id was a `u64`. Carrying it as a `String` made `size_of` report
40 bytes for a point that costs 40 plus the id text, so both budgets
(`REPLAY_BUDGET_BYTES` 1 MiB, `DEFAULT_RUN_BUDGET_BYTES` 64 MiB) under-counted
by roughly 40% -- and the slab, preallocated with empty `String`s, grew past the
budget as frames filled it rather than being bounded up front.

The crate never displays the field: every use is set membership for churn
diffing. So it takes an opaque hash of the id, computed at the timsseek_cli
boundary. `CalibrantPoint` is `Copy` again, `size_of` is the true cost, and this
debugging view stops shaping the production id type.
---
 rust/calib_dash/src/app.rs            | 10 +++++-----
 rust/calib_dash/src/bin/calib_dash.rs |  2 +-
 rust/calib_dash/src/frames.rs         | 24 +++++++++++++++---------
 rust/calib_dash/src/metrics.rs        |  6 +++---
 rust/timsseek_cli/src/processing.rs   | 19 ++++++++++++++++++-
 5 files changed, 42 insertions(+), 19 deletions(-)

diff --git a/rust/calib_dash/src/app.rs b/rust/calib_dash/src/app.rs
index c16f67ad..4af6073f 100644
--- a/rust/calib_dash/src/app.rs
+++ b/rust/calib_dash/src/app.rs
@@ -593,7 +593,7 @@ impl CalibDash {
         self.current_points.extend(points.take(self.n_calibrants));
 
         self.frames
-            .record(chunk, self.current_points.iter().cloned());
+            .record(chunk, self.current_points.iter().copied());
         self.sync_frame_summary();
 
         let metrics = self.refit_live(chunk);
@@ -688,7 +688,7 @@ impl CalibDash {
 
         let (admitted, evicted) = churn(&self.prev_points, &self.current_points);
         self.prev_points.clear();
-        self.prev_points.extend(self.current_points.iter().cloned());
+        self.prev_points.extend(self.current_points.iter().copied());
 
         BatchMetrics {
             chunk,
@@ -832,12 +832,12 @@ mod tests {
             .map(|i| CalibrantPoint {
                 library_rt: i as f64 + 0.5,
                 observed_rt: (i as f64 + 0.5) * slope,
-                library_id: (chunk * n + i).to_string(),
+                identity: (chunk * n + i) as u64,
             })
             .collect()
     }
 
-    /// Points at explicit `library_id`es, so a test can choose the two sets `churn`
+    /// Points at explicit `identity`s, so a test can choose the two sets `churn`
     /// diffs. On the identity line, so the fit succeeds.
     fn indexed_points(indices: &[usize]) -> Vec<CalibrantPoint> {
         indices
@@ -846,7 +846,7 @@ mod tests {
             .map(|(i, &idx)| CalibrantPoint {
                 library_rt: i as f64 + 0.5,
                 observed_rt: i as f64 + 0.5,
-                library_id: idx.to_string(),
+                identity: idx as u64,
             })
             .collect()
     }
diff --git a/rust/calib_dash/src/bin/calib_dash.rs b/rust/calib_dash/src/bin/calib_dash.rs
index 036cf022..2e1f306b 100644
--- a/rust/calib_dash/src/bin/calib_dash.rs
+++ b/rust/calib_dash/src/bin/calib_dash.rs
@@ -43,7 +43,7 @@ fn main() {
         .map(|(i, p)| CalibrantPoint {
             library_rt: p[0],
             observed_rt: p[1],
-            library_id: i.to_string(),
+            identity: i as u64,
         })
         .collect();
     let n_calibrants = points.len();
diff --git a/rust/calib_dash/src/frames.rs b/rust/calib_dash/src/frames.rs
index 687f983d..eb2f47ea 100644
--- a/rust/calib_dash/src/frames.rs
+++ b/rust/calib_dash/src/frames.rs
@@ -20,15 +20,21 @@ pub const DEFAULT_RUN_BUDGET_BYTES: usize = 64 * 1024 * 1024;
 /// has to clear one frame's worth of points.
 pub const REPLAY_BUDGET_BYTES: usize = 1 << 20;
 
-/// One heap entry, flattened. `library_id` is carried because churn diffing
-/// needs a stable identity for a calibrant: RT coordinates are not unique and
-/// cannot distinguish "same peptide, re-scored" from "different peptide, same
-/// RT".
-#[derive(Debug, Clone, PartialEq)]
+/// One heap entry, flattened.
+///
+/// `identity` exists because churn diffing needs to tell "same calibrant,
+/// re-scored" from "different calibrant, same RT", and RT coordinates are not
+/// unique. It is an opaque hash of the caller's id, never displayed -- this is
+/// a debugging view, so it compares identity without carrying it. Keeping it a
+/// plain integer is what lets `size_of` below be the true cost of a point, and
+/// what keeps this type `Copy`.
+///
+/// Only meaningful within one process: the hash is not stable across runs.
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub struct CalibrantPoint {
     pub library_rt: f64,
     pub observed_rt: f64,
-    pub library_id: String,
+    pub identity: u64,
 }
 
 struct FrameIndex {
@@ -73,7 +79,7 @@ impl FrameStore {
             CalibrantPoint {
                 library_rt: 0.0,
                 observed_rt: 0.0,
-                library_id: String::new()
+                identity: 0
             };
             (stride_capacity + 1) * n_calibrants
         ];
@@ -148,7 +154,7 @@ mod tests {
         CalibrantPoint {
             library_rt: i as f64,
             observed_rt: i as f64 * 2.0,
-            library_id: i.to_string(),
+            identity: i as u64,
         }
     }
 
@@ -156,7 +162,7 @@ mod tests {
     /// pass for another's.
     fn pt_in(chunk: usize, i: usize) -> CalibrantPoint {
         CalibrantPoint {
-            library_id: (chunk * 100 + i).to_string(),
+            identity: (chunk * 100 + i) as u64,
             ..pt(i)
         }
     }
diff --git a/rust/calib_dash/src/metrics.rs b/rust/calib_dash/src/metrics.rs
index 03c12a97..6f1f3fb5 100644
--- a/rust/calib_dash/src/metrics.rs
+++ b/rust/calib_dash/src/metrics.rs
@@ -59,8 +59,8 @@ pub fn curve_delta(
 
 /// `(admitted, evicted)` between two heap snapshots, by `library_id`.
 pub fn churn(prev: &[CalibrantPoint], cur: &[CalibrantPoint]) -> (usize, usize) {
-    let prev_set: HashSet<&str> = prev.iter().map(|p| p.library_id.as_str()).collect();
-    let cur_set: HashSet<&str> = cur.iter().map(|p| p.library_id.as_str()).collect();
+    let prev_set: HashSet<u64> = prev.iter().map(|p| p.identity).collect();
+    let cur_set: HashSet<u64> = cur.iter().map(|p| p.identity).collect();
     let admitted = cur_set.difference(&prev_set).count();
     let evicted = prev_set.difference(&cur_set).count();
     (admitted, evicted)
@@ -78,7 +78,7 @@ mod tests {
         CalibrantPoint {
             library_rt: 1.0,
             observed_rt: 1.0,
-            library_id: idx.to_string(),
+            identity: idx as u64,
         }
     }
 
diff --git a/rust/timsseek_cli/src/processing.rs b/rust/timsseek_cli/src/processing.rs
index 71601608..aeb85d3f 100644
--- a/rust/timsseek_cli/src/processing.rs
+++ b/rust/timsseek_cli/src/processing.rs
@@ -89,7 +89,24 @@ mod calib_dash_hook {
             CalibrationConfig,
             CalibrationResult,
         };
+        use std::hash::{
+            DefaultHasher,
+            Hash,
+            Hasher,
+        };
         use std::io::IsTerminal;
+        use timsquery::models::OwnedSourceId;
+
+        /// The dashboard compares calibrant identity across batches but never
+        /// displays it, so it takes a hash instead of the id. That keeps its
+        /// point type `Copy` and, more importantly, keeps `size_of` the true
+        /// cost of a point — which is what its replay memory budget is computed
+        /// from. Only meaningful within one process.
+        fn identity_hash(id: &OwnedSourceId) -> u64 {
+            let mut hasher = DefaultHasher::new();
+            id.hash(&mut hasher);
+            hasher.finish()
+        }
 
         /// The dashboard for a whole run. Stays `None` inside unless
         /// `TIMSSEEK_CALIB_DASHBOARD` asks for it, so an ordinary run of a
@@ -173,7 +190,7 @@ mod calib_dash_hook {
                 calibrants.map(|c| calib_dash::CalibrantPoint {
                     library_rt: c.library_rt.0 as f64,
                     observed_rt: c.apex_rt.0 as f64,
-                    library_id: c.library_id.to_string(),
+                    identity: identity_hash(&c.library_id),
                 }),
             );
             if matches!(flow, calib_dash::Flow::Abort) {

From 52d84bd12c3b5b49123a4e328c96736c7fec45cb Mon Sep 17 00:00:00 2001
From: "J. Sebastian Paez" <jspaezp@gmail.com>
Date: Thu, 27 Aug 2026 22:31:43 -0700
Subject: [PATCH 11/19] fix(timsquery): name the row that breaks a mixed-shape
 library, and pin the rule

An id keeps the shape its source used, per library: integer in, integer out;
string in, string out; a library that mixes them is an error. That was the
behaviour already but nothing tested it, so the JSON path silently gained
string ids and could have silently lost them again.

Pinned in `carafe_contract/`, where a decision about the `id` field belongs:
a numeric id still serializes as a bare number (Carafe reads it with fastjson
and keys results by it), a text id round-trips as a string, and a mixed library
fails to load.

`MixedShapes` now names the offending row and value. The check runs over a whole
library, so a hand-assembled file with one bad row gave no way to find it.
Deciding the shape by collecting `Option<Vec<_>>` also drops the count-then-
rematch and its `unreachable!`.
---
 rust/timsquery/src/models/source_id.rs       | 77 ++++++++++++++------
 rust/timsquery/tests/carafe_contract/main.rs | 71 ++++++++++++++++++
 2 files changed, 125 insertions(+), 23 deletions(-)

diff --git a/rust/timsquery/src/models/source_id.rs b/rust/timsquery/src/models/source_id.rs
index e594faf5..2d9f82bb 100644
--- a/rust/timsquery/src/models/source_id.rs
+++ b/rust/timsquery/src/models/source_id.rs
@@ -154,11 +154,22 @@ pub enum SourceIdError {
     Duplicate { id: String },
     #[error("source id blob exceeds u32 offset range")]
     BlobTooLarge,
-    /// A library names its rows or it does not. Storing both shapes together
-    /// would mean rendering the numbers as strings, which is the coercion the
-    /// whole type exists to avoid.
-    #[error("source ids mix numeric and text shapes; a format carries one or the other")]
-    MixedShapes,
+    /// A library names its rows one way or the other. Storing both shapes
+    /// together would mean rendering the numbers as strings, which is the
+    /// coercion this type exists to avoid, and would make `7` and `"7"` two
+    /// different ids in one column.
+    ///
+    /// Names the offending row: the check runs over the whole library, so
+    /// without it a caller has no way to find the row that broke it.
+    #[error(
+        "row {row} has a text id ({value:?}) but row {first_text_free_row} has a numeric one; \
+         a library names its rows one way or the other"
+    )]
+    MixedShapes {
+        row: usize,
+        value: String,
+        first_text_free_row: usize,
+    },
 }
 
 impl SourceIds {
@@ -215,25 +226,37 @@ impl SourceIds {
             });
         }
         // All-numeric stays numeric so the common JSON path keeps its dense
-        // integer column instead of paying for a blob.
-        let n_numeric = ids
+        // integer column instead of paying for a blob. Collecting decides the
+        // shape and reports the first row that disagrees in one pass.
+        let numeric: Option<Vec<LibraryId>> = ids
             .iter()
-            .filter(|id| matches!(id, OwnedSourceId::Numeric(_)))
-            .count();
-        if n_numeric != 0 && n_numeric != ids.len() {
-            return Err(SourceIdError::MixedShapes);
-        }
-        if n_numeric == ids.len() {
-            let nums = ids
-                .iter()
-                .map(|id| match id {
-                    OwnedSourceId::Numeric(n) => LibraryId::new(*n),
-                    OwnedSourceId::Text(_) => unreachable!("checked above"),
-                })
-                .collect();
-            return Self::numeric(nums, n_rows);
+            .map(|id| match id {
+                OwnedSourceId::Numeric(n) => Some(LibraryId::new(*n)),
+                OwnedSourceId::Text(_) => None,
+            })
+            .collect();
+
+        match numeric {
+            Some(nums) => Self::numeric(nums, n_rows),
+            None => {
+                if let Some((row, value)) = ids.iter().enumerate().find_map(|(i, id)| match id {
+                    OwnedSourceId::Text(s) => Some((i, s.clone())),
+                    OwnedSourceId::Numeric(_) => None,
+                }) && ids.iter().any(|id| matches!(id, OwnedSourceId::Numeric(_)))
+                {
+                    let first_text_free_row = ids
+                        .iter()
+                        .position(|id| matches!(id, OwnedSourceId::Numeric(_)))
+                        .expect("just checked one exists");
+                    return Err(SourceIdError::MixedShapes {
+                        row,
+                        value,
+                        first_text_free_row,
+                    });
+                }
+                Self::text(ids.iter().map(|id| id.to_string()), n_rows)
+            }
         }
-        Self::text(ids.iter().map(|id| id.to_string()), n_rows)
     }
 
     /// Self-incremental ids for a format that carries none, so results still
@@ -298,7 +321,15 @@ mod tests {
             OwnedSourceId::Numeric(7),
             OwnedSourceId::Text("AAAK2".into()),
         ];
-        assert_eq!(SourceIds::owned(mixed, 2), Err(SourceIdError::MixedShapes));
+        assert_eq!(
+            SourceIds::owned(mixed, 2),
+            Err(SourceIdError::MixedShapes {
+                row: 1,
+                value: "AAAK2".to_string(),
+                first_text_free_row: 0,
+            }),
+            "the error has to name the row that broke it"
+        );
 
         // Either shape on its own is fine, and numeric keeps the dense column.
         assert!(matches!(
diff --git a/rust/timsquery/tests/carafe_contract/main.rs b/rust/timsquery/tests/carafe_contract/main.rs
index c72b4136..9e11a239 100644
--- a/rust/timsquery/tests/carafe_contract/main.rs
+++ b/rust/timsquery/tests/carafe_contract/main.rs
@@ -173,3 +173,74 @@ fn a_negative_low_tolerance_edge_is_accepted() {
         range.end()
     );
 }
+
+/// An `id` keeps the shape the caller sent: an integer comes back an integer,
+/// a string comes back a string. Carafe sends integers and keys results by
+/// them, so narrowing this back to a number-only `id` would be invisible here
+/// without the string half, and widening it to always-text would break Carafe.
+///
+/// The rule is per library, not per row: see
+/// [`a_library_may_not_mix_id_shapes`].
+#[test]
+fn an_id_comes_back_in_the_shape_it_arrived() {
+    let numeric = write_targets(
+        r#"[
+      { "id": 7, "mobility": 0.95, "rt_seconds": 1234.5, "precursor": 650.32,
+        "precursor_charge": 2, "precursor_isotopes": [0],
+        "fragments": [175.1], "fragment_labels": ["y1"] }
+    ]"#,
+    );
+    let TargetTable::Mzpaf { geom, .. } = read_targets(numeric.path()).expect("loads") else {
+        panic!("mzpaf labels")
+    };
+    let row = geom.rows().next().unwrap();
+    assert_eq!(geom.output_id(row), SourceId::Numeric(7));
+    assert_eq!(
+        serde_json::to_string(&geom.output_id(row)).unwrap(),
+        "7",
+        "Carafe reads `id` with fastjson and keys results by it: a number must \
+         stay a bare number, not become \"7\""
+    );
+
+    let text = write_targets(
+        r#"[
+      { "id": "PEPTIDEK2", "mobility": 0.95, "rt_seconds": 1234.5, "precursor": 650.32,
+        "precursor_charge": 2, "precursor_isotopes": [0],
+        "fragments": [175.1], "fragment_labels": ["y1"] }
+    ]"#,
+    );
+    let TargetTable::Mzpaf { geom, .. } = read_targets(text.path()).expect("loads") else {
+        panic!("mzpaf labels")
+    };
+    let row = geom.rows().next().unwrap();
+    assert_eq!(geom.output_id(row), SourceId::Text("PEPTIDEK2"));
+    assert_eq!(
+        serde_json::to_string(&geom.output_id(row)).unwrap(),
+        r#""PEPTIDEK2""#
+    );
+}
+
+/// A library names its rows one way or the other. Accepting both in one file
+/// would make `7` and `"7"` two different ids in the same column, which breaks
+/// any caller that keys results by `id`.
+#[test]
+fn a_library_may_not_mix_id_shapes() {
+    let f = write_targets(
+        r#"[
+      { "id": 7, "mobility": 0.95, "rt_seconds": 1234.5, "precursor": 650.32,
+        "precursor_charge": 2, "precursor_isotopes": [0],
+        "fragments": [175.1], "fragment_labels": ["y1"] },
+      { "id": "PEPTIDEK2", "mobility": 0.80, "rt_seconds": 999.0, "precursor": 500.0,
+        "precursor_charge": 2, "precursor_isotopes": [0],
+        "fragments": [200.0], "fragment_labels": ["y2"] }
+    ]"#,
+    );
+    let Err(err) = read_targets(f.path()) else {
+        panic!("a mixed library must not load")
+    };
+    let msg = format!("{err:?}");
+    assert!(
+        msg.contains("row: 1") && msg.contains("PEPTIDEK2"),
+        "the error has to name the offending row and value, got: {msg}"
+    );
+}

From 2598991b9c0df8a6941e61bdf19eed1f90e6b067 Mon Sep 17 00:00:00 2001
From: "J. Sebastian Paez" <jspaezp@gmail.com>
Date: Thu, 27 Aug 2026 23:18:38 -0700
Subject: [PATCH 12/19] refactor(timsquery): intern decoy groups behind an
 opaque code

A competition group was carried as an `OwnedSourceId` per row, which is wrong in
both directions. Rows that compete *share* a group, so a label per row stores
the same string once per member -- the opposite of `source_ids`, where ids are
unique and CSR fits. And no consumer reads the value: grouping sorts by it and
compares it, nothing else.

So a group is now a `GroupCode`: an opaque, `Copy`, `Ord` handle into a
deduplicated label set. Sorting and comparing need no arena and no allocation;
the label is resolved from the arena only where it is actually written out.

Nothing is stored when the input declares no groups, which is every format
today. A row is then its own group, so both the code and the label are derived
from the row -- `decoy_group_code` returns the row, `decoy_group` returns the
row's own id. Previously `seal` materialised a `Vec` of one `String` per row for
this, which for a text library meant an allocation per row duplicating a column
that already existed.

`seal`'s warning now fires only for the case that actually loses information: a
library that ships its own decoys and declares no groups, where a stored decoy
really does compete alone. It used to fire on every load, including
`LazyMassShift`, where minting is simply correct.

Handle construction is `pub(super)` throughout, so the arena is the only thing
that mints one -- `GroupCode` and `FlatIdx` outright, `RowIdx` bar the flyweight
that unpacks it.
---
 rust/timsquery/src/models/target_columns.rs  | 200 +++++++++++++++----
 rust/timsquery/src/serde/diann_speclib_io.rs |  13 +-
 2 files changed, 169 insertions(+), 44 deletions(-)

diff --git a/rust/timsquery/src/models/target_columns.rs b/rust/timsquery/src/models/target_columns.rs
index 11ac3c51..ac4ba03b 100644
--- a/rust/timsquery/src/models/target_columns.rs
+++ b/rust/timsquery/src/models/target_columns.rs
@@ -14,16 +14,22 @@ use crate::traits::DecoyShift;
 
 pub use index::{
     FlatIdx,
+    GroupCode,
     RowIdx,
 };
 
-/// How the arena reaches its own memory.
+/// The handles the arena hands out: two ways of addressing its memory, and one
+/// way of naming a competition group.
 ///
-/// Both types are opaque outside this crate: no constructor from an integer,
-/// no accessor yielding one, no `Display` and no `Serialize`. A position can
-/// therefore not be invented by a caller, confused with an id, or written to
-/// an output file — it can only be obtained from the arena that owns the rows
-/// and handed straight back to it.
+/// All three are opaque: no constructor from an integer, no accessor yielding
+/// one, no `Display`, no `Serialize`. So none of them can be invented by a
+/// caller, confused with an id, or written to an output file — a handle can
+/// only be obtained from the arena and handed straight back to it.
+///
+/// Construction is `pub(super)`, i.e. this file, so the arena is the only thing
+/// that mints one. `RowIdx` is `pub(in crate::models)` only because the
+/// flyweight in `query_handle` packs and unpacks it; unpacking is the last
+/// place outside here that builds one.
 mod index {
     /// A stored row: `0..n_rows()`.
     #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -36,22 +42,43 @@ mod index {
     #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
     pub struct FlatIdx(u32);
 
+    /// Which competition group a row belongs to, as a handle rather than a
+    /// value. Rows that compete share one, and that is all a consumer needs:
+    /// grouping sorts by it and compares it, and never reads it. Opaque for the
+    /// same reason as the indices above — a handle that could be printed would
+    /// end up in an output file as though it meant something.
+    ///
+    /// `Ord` because grouping works by sorting competitors adjacent; any total
+    /// order does, since only equality carries meaning.
+    #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    pub struct GroupCode(u32);
+
     impl RowIdx {
-        pub(crate) fn new(row: u32) -> Self {
+        pub(in crate::models) fn new(row: u32) -> Self {
             Self(row)
         }
 
-        pub(crate) fn get(self) -> usize {
+        pub(in crate::models) fn get(self) -> usize {
+            self.0 as usize
+        }
+    }
+
+    impl GroupCode {
+        pub(super) fn new(code: u32) -> Self {
+            Self(code)
+        }
+
+        pub(super) fn get(self) -> usize {
             self.0 as usize
         }
     }
 
     impl FlatIdx {
-        pub(crate) fn new(flat: u32) -> Self {
+        pub(super) fn new(flat: u32) -> Self {
             Self(flat)
         }
 
-        pub(crate) fn get(self) -> usize {
+        pub(super) fn get(self) -> usize {
             self.0 as usize
         }
     }
@@ -73,6 +100,14 @@ mod index {
     }
 }
 
+/// Interned competition groups: `codes[row]` points at `labels`, so rows that
+/// compete share one label rather than each storing a copy.
+#[derive(Debug, Clone)]
+pub struct DecoyGroups {
+    codes: Vec<GroupCode>,
+    labels: SourceIds,
+}
+
 #[derive(Debug, Clone)]
 pub struct ModDefinition {
     pub token: String, // verbatim, e.g. "[UNIMOD:4]"
@@ -95,12 +130,15 @@ pub struct TargetColumns<L: KeyLike> {
     /// columns. Minted at [`Self::seal`] for formats that carry no ids, so a
     /// sealed arena always has one per row.
     pub(crate) source_ids: SourceIds,
-    /// Which competition group each row belongs to, one entry per row. Empty
-    /// until [`Self::seal`], which mints it when the input did not say. Not
-    /// derived from the row position: group membership is a property of the
-    /// analytes, and reading it off the arena layout only works for as long as
-    /// the layout happens to encode it.
-    pub(crate) decoy_groups: Vec<OwnedSourceId>,
+    /// The competition groups the input declared, interned: a code per row,
+    /// plus the labels those codes point at. Rows that compete share a code, so
+    /// the label is stored once per group rather than once per row.
+    ///
+    /// `None` when the input declared none, which is every format today. A
+    /// group is then a singleton -- the row competes with its own decoy
+    /// variants and nothing else -- so both the code and the label are
+    /// derivable from the row and nothing is stored.
+    pub(crate) decoy_groups: Option<DecoyGroups>,
     // CSR prefix offsets (n+1)
     pub(crate) frag_off: Vec<u32>,
     pub(crate) seq_strip_off: Vec<u32>,
@@ -127,7 +165,7 @@ impl<L: KeyLike> TargetColumns<L> {
             mobility: Vec::new(),
             is_decoy: Vec::new(),
             source_ids: SourceIds::default(),
-            decoy_groups: Vec::new(),
+            decoy_groups: None,
             frag_off: vec![0],
             seq_strip_off: vec![0],
             seq_mod_off: vec![0],
@@ -237,20 +275,70 @@ impl<L: KeyLike> TargetColumns<L> {
         (0..self.n_rows() as u32).map(RowIdx::new)
     }
 
-    /// Attach the competition groups a file declared. Call before `seal`,
-    /// which otherwise mints one group per row. Rows sharing a value compete,
-    /// so unlike source ids these are not required to be unique.
-    pub fn set_decoy_groups(&mut self, groups: Vec<OwnedSourceId>) -> Result<(), SourceIdError> {
+    /// Attach the competition groups a file declared, interning them. Rows
+    /// sharing a value compete, so unlike source ids these are expected to
+    /// repeat -- which is why they are stored as a code per row against a
+    /// deduplicated label set rather than a label per row.
+    ///
+    /// Without this, a group is a singleton and is derived from the row.
+    pub fn set_decoy_groups<I, S>(&mut self, groups: I) -> Result<(), SourceIdError>
+    where
+        I: IntoIterator<Item = S>,
+        S: Into<OwnedSourceId>,
+    {
+        let groups: Vec<OwnedSourceId> = groups.into_iter().map(Into::into).collect();
         if groups.len() != self.n_rows() {
             return Err(SourceIdError::LengthMismatch {
                 ids: groups.len(),
                 rows: self.n_rows(),
             });
         }
-        self.decoy_groups = groups;
+
+        let mut seen: std::collections::HashMap<OwnedSourceId, GroupCode> =
+            std::collections::HashMap::new();
+        let mut labels: Vec<OwnedSourceId> = Vec::new();
+        let mut codes = Vec::with_capacity(groups.len());
+        for group in groups {
+            let code = *seen.entry(group.clone()).or_insert_with(|| {
+                labels.push(group);
+                GroupCode::new((labels.len() - 1) as u32)
+            });
+            codes.push(code);
+        }
+
+        let n_labels = labels.len();
+        self.decoy_groups = Some(DecoyGroups {
+            codes,
+            labels: SourceIds::owned(labels, n_labels)?,
+        });
         Ok(())
     }
 
+    /// Which competition group this row is in, as an opaque handle. Rows that
+    /// compete share one; nothing else about it is meaningful.
+    ///
+    /// Derived from the row when the input declared no groups -- a row then
+    /// competes only with its own decoy variants, so it is its own group and
+    /// there is nothing to store.
+    pub fn decoy_group_code(&self, tgt: RowIdx) -> GroupCode {
+        match &self.decoy_groups {
+            Some(g) => g.codes[tgt.get()],
+            None => GroupCode::new(tgt.get() as u32),
+        }
+    }
+
+    /// The group's id, for output. Resolved here rather than carried alongside
+    /// every result, which is the whole point of the code above.
+    pub fn decoy_group(&self, tgt: RowIdx) -> SourceId<'_> {
+        match &self.decoy_groups {
+            Some(g) => g
+                .labels
+                .get(g.codes[tgt.get()].get())
+                .expect("every code indexes a label"),
+            None => self.output_id(tgt),
+        }
+    }
+
     pub fn source_id(&self, tgt: RowIdx) -> Option<SourceId<'_>> {
         self.source_ids.get(tgt.get())
     }
@@ -349,15 +437,14 @@ impl<L: KeyLike> TargetColumns<L> {
             );
             self.source_ids = SourceIds::minted(n);
         }
-        if self.decoy_groups.is_empty() {
+        // Nothing to build when no groups were declared: a row is then its own
+        // group, which `decoy_group_code` derives. Only the case that actually
+        // loses information is worth a word.
+        if self.decoy_groups.is_none() && matches!(self.caps.decoys, DecoyStrategy::Passthrough) {
             tracing::warn!(
-                "input declares no decoy groups; minting one per row, named by the row's \
-                 own id. Stored decoys therefore compete alone, not against their target."
+                "library ships its own decoys but declares no competition groups, so each \
+                 stored decoy competes alone rather than against its target"
             );
-            self.decoy_groups = self
-                .rows()
-                .map(|r| self.output_id(r).to_owned_id())
-                .collect();
         }
         if matches!(self.caps.decoys, DecoyStrategy::LazyMassShift { .. })
             && self.is_decoy.iter().any(|&d| d)
@@ -389,7 +476,6 @@ impl<L: KeyLike> TargetColumns<L> {
         self.seq_strip_blob.shrink_to_fit();
         self.seq_mod_blob.shrink_to_fit();
         self.mods.shrink_to_fit();
-        self.decoy_groups.shrink_to_fit();
         self.mod_registry.shrink_to_fit();
     }
 }
@@ -463,13 +549,6 @@ impl<L: KeyLike + DecoyShift> TargetColumns<L> {
         let (row, variant) = self.split_flat(flat);
         !self.is_decoy[row.get()] && variant == 0
     }
-
-    /// The competition group this row belongs to, as an id — not a position.
-    /// A row's decoy variants share its group, so exactly one member survives
-    /// competition.
-    pub fn decoy_group(&self, tgt: RowIdx) -> SourceId<'_> {
-        self.decoy_groups[tgt.get()].as_ref()
-    }
 }
 
 #[cfg(test)]
@@ -478,6 +557,53 @@ mod tests {
     use crate::IonAnnot;
     use crate::models::capabilities::DecoyStrategy;
 
+    fn two_rows() -> TargetColumns<IonAnnot> {
+        let mut c = TargetColumns::with_capabilities(TargetCapabilities::default_diann());
+        for _ in 0..2 {
+            c.push_target(
+                500.0,
+                2,
+                1.0,
+                0.8,
+                &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
+                "PEP",
+                "PEP",
+                &[],
+            );
+        }
+        c
+    }
+
+    /// Declared groups are interned, so two rows in one group share a code and
+    /// the label is stored once rather than per row.
+    #[test]
+    fn rows_in_one_declared_group_share_a_code() {
+        let mut c = two_rows();
+        c.set_decoy_groups(["g1", "g1"]).unwrap();
+        c.seal();
+
+        let (a, b) = (c.rows().next().unwrap(), c.rows().nth(1).unwrap());
+        assert_eq!(c.decoy_group_code(a), c.decoy_group_code(b));
+        assert_eq!(c.decoy_group(a), SourceId::Text("g1"));
+    }
+
+    /// Without declared groups a row is its own group, derived rather than
+    /// stored -- so nothing is allocated and the label is the row's own id.
+    #[test]
+    fn undeclared_groups_are_derived_not_stored() {
+        let mut c = two_rows();
+        c.seal();
+
+        let (a, b) = (c.rows().next().unwrap(), c.rows().nth(1).unwrap());
+        assert!(c.decoy_groups.is_none(), "nothing stored for minted groups");
+        assert_ne!(
+            c.decoy_group_code(a),
+            c.decoy_group_code(b),
+            "each row competes alone"
+        );
+        assert_eq!(c.decoy_group(a), c.output_id(a));
+    }
+
     /// `output_id` expects a source id on every row; this is what makes that
     /// safe for the formats that carry none.
     #[test]
diff --git a/rust/timsquery/src/serde/diann_speclib_io.rs b/rust/timsquery/src/serde/diann_speclib_io.rs
index 3132ebf5..b598d058 100644
--- a/rust/timsquery/src/serde/diann_speclib_io.rs
+++ b/rust/timsquery/src/serde/diann_speclib_io.rs
@@ -974,7 +974,6 @@ pub fn read_diann_speclib_library_file<T: AsRef<Path>>(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::models::target_columns::RowIdx;
     use std::path::PathBuf;
 
     fn fixture_path() -> PathBuf {
@@ -1040,11 +1039,11 @@ mod tests {
             parse_speclib_reader(std::io::BufReader::new(file)).unwrap();
 
         assert_eq!(
-            &geom.seq_mod_blob[geom.seq_mod_range(RowIdx::new(0))],
+            &geom.seq_mod_blob[geom.seq_mod_range(geom.rows().nth(0).unwrap())],
             "AAAGAAATHLEVAR"
         );
         assert_eq!(
-            &geom.seq_strip_blob[geom.seq_strip_range(RowIdx::new(0))],
+            &geom.seq_strip_blob[geom.seq_strip_range(geom.rows().nth(0).unwrap())],
             "AAAGAAATHLEVAR"
         );
         assert_eq!(geom.charge[0], 2);
@@ -1056,7 +1055,7 @@ mod tests {
         // The fixture has Peptide.length == 0, so y-series is recovered from the
         // sequence length (14). ExcludeFromAssay fragments are kept; only
         // neutral-loss/dup drop, so all 12 remain.
-        let range = geom.frag_range(RowIdx::new(0));
+        let range = geom.frag_range(geom.rows().nth(0).unwrap());
         assert_eq!(range.len(), 12, "all non-loss fragments kept");
 
         // First few fragments in file order, sourced independently. y9 carries
@@ -1101,14 +1100,14 @@ mod tests {
             parse_speclib_reader(std::io::BufReader::new(file)).unwrap();
 
         assert_eq!(
-            &geom.seq_mod_blob[geom.seq_mod_range(RowIdx::new(532))],
+            &geom.seq_mod_blob[geom.seq_mod_range(geom.rows().nth(532).unwrap())],
             "LEGNSPQGSNQGVK"
         );
         assert_eq!(geom.charge[532], 2);
         assert!((geom.precursor_mz[532] - 707.85052).abs() < 1e-3);
         assert!((geom.rt_seconds[532] - (-31.935_83)).abs() < 1e-3);
         assert!((geom.mobility[532] - 0.9704546).abs() < 1e-4);
-        assert_eq!(geom.frag_range(RowIdx::new(532)).len(), 6);
+        assert_eq!(geom.frag_range(geom.rows().nth(532).unwrap()).len(), 6);
     }
 
     #[test]
@@ -1145,7 +1144,7 @@ mod tests {
         // Exclude-flagged fragments are present in the output, not dropped:
         // entry[0] keeps its flagged y9.
         assert!(
-            geom.frag_labels[geom.frag_range(RowIdx::new(0))]
+            geom.frag_labels[geom.frag_range(geom.rows().nth(0).unwrap())]
                 .iter()
                 .any(|l| *l == IonAnnot::try_new('y', Some(9), 1, 0).unwrap()),
             "flagged y9 must be kept"

From b4ba00779e4a8b15bb5721528b7cda65cff055e1 Mon Sep 17 00:00:00 2001
From: "J. Sebastian Paez" <jspaezp@gmail.com>
Date: Thu, 27 Aug 2026 23:54:37 -0700
Subject: [PATCH 13/19] refactor(timsseek): stop the id at the arena, carry
 handles instead

A scored candidate carried `library_id` and `decoy_group_id` from Phase 3 to
the writer, which then stringified both. Five `String` clones per candidate to
move a value nothing on that path read.

The scoring path now carries opaque handles -- the arena row plus a
`GroupCode` -- and the Parquet writer resolves both ids from the arena at the
end. `Identity`, `PeptideMetadata`, `Peptide` and `CalibrantCandidate` each
lose their id field; competition keys off `GroupCode`, which is what it always
wanted (equality and ordering, never the value).

The two id columns move from `Identity::columns` to `FinalResult`, in the same
position, because they are no longer on the result. The cost is that a
`FinalResult` is no longer self-describing: interpreting one needs the arena it
came from. That is fine while writing, and it is what keeps a position from
ever reaching an output file.

The q-value determinism sort already keyed on the row rather than the id; its
doc comment still described the old key.

`timsquery`'s new `test-support` feature exposes handle constructors for
downstream tests, which assemble results without an arena. It is enabled only
through a dev-dependency -- verified that a `cargo build` of the CLI compiles
timsquery with `feature="mzdata"` alone -- so a shipped build still cannot mint
a handle.

Closes review items 3 and 7.
---
 rust/timsquery/Cargo.toml                     |   3 +
 rust/timsquery/src/models/mod.rs              |   3 +
 rust/timsquery/src/models/target_columns.rs   |  33 +++++
 rust/timsquery_viewer/src/calibration.rs      |   1 -
 rust/timsseek/Cargo.toml                      |   3 +
 .../src/data_sources/reference_library.rs     |  59 ++++----
 rust/timsseek/src/ml/qvalues.rs               |  57 +++-----
 rust/timsseek/src/models/sequence.rs          |   1 -
 rust/timsseek/src/scoring/apex_finding.rs     |  14 +-
 rust/timsseek/src/scoring/blocks/identity.rs  |  35 ++---
 rust/timsseek/src/scoring/parquet_writer.rs   | 133 ++++++++++++++++--
 rust/timsseek/src/scoring/pipeline.rs         |  31 ++--
 rust/timsseek/src/scoring/results.rs          |  12 +-
 rust/timsseek_cli/Cargo.toml                  |   6 +
 rust/timsseek_cli/src/processing.rs           |  60 ++++----
 15 files changed, 291 insertions(+), 160 deletions(-)

diff --git a/rust/timsquery/Cargo.toml b/rust/timsquery/Cargo.toml
index 01ff008a..e4c50ca4 100644
--- a/rust/timsquery/Cargo.toml
+++ b/rust/timsquery/Cargo.toml
@@ -31,6 +31,9 @@ thiserror = { workspace = true }
 # Forward mzML/mzdata ingest support down to timscentroid, where the reader lives.
 # Not defaulted here (see timsseek_cli) so `--no-default-features` stays lean.
 mzdata = ["timscentroid/mzdata"]
+# Constructors for the opaque arena handles (`models::test_handles`). Enabled
+# only through a `dev-dependency`, so a shipped build still cannot mint one.
+test-support = []
 
 [dev-dependencies]
 tempfile = { workspace = true }
diff --git a/rust/timsquery/src/models/mod.rs b/rust/timsquery/src/models/mod.rs
index ad8c5544..1aa3fb21 100644
--- a/rust/timsquery/src/models/mod.rs
+++ b/rust/timsquery/src/models/mod.rs
@@ -33,8 +33,11 @@ pub use source_id::{
     SourceIdError,
     SourceIds,
 };
+#[cfg(feature = "test-support")]
+pub use target_columns::test_handles;
 pub use target_columns::{
     FlatIdx,
+    GroupCode,
     ModDefinition,
     RowIdx,
     TargetColumns,
diff --git a/rust/timsquery/src/models/target_columns.rs b/rust/timsquery/src/models/target_columns.rs
index ac4ba03b..f3f08a0e 100644
--- a/rust/timsquery/src/models/target_columns.rs
+++ b/rust/timsquery/src/models/target_columns.rs
@@ -98,6 +98,39 @@ mod index {
             Self(u32::MAX)
         }
     }
+
+    /// Same reasoning, and the same placeholder value: a defaulted group is one
+    /// nothing has assigned yet. `u32::MAX` makes such rows compete with each
+    /// other and with nothing real, which is visible; 0 would silently fold
+    /// them into the arena's first group.
+    impl Default for GroupCode {
+        fn default() -> Self {
+            Self(u32::MAX)
+        }
+    }
+}
+
+/// Handles for tests in downstream crates, which score against a real arena in
+/// production but assemble results directly in tests.
+///
+/// Feature-gated, and the feature is only ever enabled by a `dev-dependency`,
+/// so "only the arena mints a handle" still holds in every shipped build. The
+/// values are dense from 0 because the callers need them *distinct* (a sort key,
+/// a competition group) and never resolve them against an arena.
+#[cfg(feature = "test-support")]
+pub mod test_handles {
+    use super::index::{
+        GroupCode,
+        RowIdx,
+    };
+
+    pub fn row(i: u32) -> RowIdx {
+        RowIdx::new(i)
+    }
+
+    pub fn group(i: u32) -> GroupCode {
+        GroupCode::new(i)
+    }
 }
 
 /// Interned competition groups: `codes[row]` points at `labels`, so rows that
diff --git a/rust/timsquery_viewer/src/calibration.rs b/rust/timsquery_viewer/src/calibration.rs
index d4bfcffc..179a6c62 100644
--- a/rust/timsquery_viewer/src/calibration.rs
+++ b/rust/timsquery_viewer/src/calibration.rs
@@ -548,7 +548,6 @@ impl ViewerCalibrationState {
                                 score: apex.score,
                                 apex_rt: ObservedRTSeconds(apex.retention_time_ms as f32 / 1000.0),
                                 speclib_index: elution_groups.flat(eg_idx),
-                                library_id: elution_group.id().to_owned_id(),
                                 library_rt: LibraryRT(elution_group.rt_seconds()),
                             });
                         }
diff --git a/rust/timsseek/Cargo.toml b/rust/timsseek/Cargo.toml
index 6834cb80..24f14574 100644
--- a/rust/timsseek/Cargo.toml
+++ b/rust/timsseek/Cargo.toml
@@ -36,6 +36,9 @@ smallvec = { workspace = true }
 
 [dev-dependencies]
 tempfile = { workspace = true }
+# Constructors for the opaque arena handles, for tests that assemble a result
+# without an arena behind it. Dev-only, so a shipped build cannot mint one.
+timsquery = { path = "../timsquery", features = ["test-support"] }
 
 [features]
 default = ["rayon"]
diff --git a/rust/timsseek/src/data_sources/reference_library.rs b/rust/timsseek/src/data_sources/reference_library.rs
index e365eb1c..867921a6 100644
--- a/rust/timsseek/src/data_sources/reference_library.rs
+++ b/rust/timsseek/src/data_sources/reference_library.rs
@@ -10,7 +10,7 @@ use timsquery::models::capabilities::{
 };
 use timsquery::models::{
     FlatIdx,
-    OwnedSourceId,
+    GroupCode,
     Query,
     RowIdx,
     TargetColumns,
@@ -122,7 +122,7 @@ impl<'a> RefQuery<'a> {
     /// time), else `None`. Parsing the modified (not stripped) form preserves
     /// the mod set the `n_mods` feature reads. Lazy decoys are mass-shift
     /// decoys, so any non-target variant is `MassShiftedDecoy`.
-    pub fn materialize_peptide_in_group(&self, decoy_group: OwnedSourceId) -> Peptide {
+    pub fn materialize_peptide(&self) -> Peptide {
         let tgt = self.geom.row();
         let coll = &self.lib.geom;
         let raw: Arc<str> = coll.seq_mod(tgt).into();
@@ -134,7 +134,6 @@ impl<'a> RefQuery<'a> {
         Peptide {
             raw,
             decoy,
-            decoy_group,
             sequence_features: coll.caps.sequence_features == SeqFeatureState::Available,
         }
     }
@@ -219,30 +218,34 @@ impl<'a> QueryGeom for RefQuery<'a> {
 /// flyweight so the batch scoring loop stays generic (monomorphized,
 /// zero-heap) over the concrete type — see
 /// `Scorer::{prescore,score_calibrated}_batch_impl`.
+/// Which row a scored result came from, and which group it competes in.
+///
+/// The two travel together because the scorer holds the run's raw-data index,
+/// not the library arena, so it cannot derive one from the other. Both are
+/// opaque, so neither can reach an output file or be confused with an id — the
+/// writer resolves them against the arena at the end.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct RowHandles {
+    pub row: RowIdx,
+    pub group: GroupCode,
+}
+
 pub trait ScoredIdentity {
-    /// The id this result carries, so a caller can map it onto the row they
-    /// asked about: the source id where the file gave one, otherwise the id
-    /// minted for it at load.
-    fn library_id(&self) -> OwnedSourceId;
     /// Whether this item is a target (vs a decoy variant).
     fn is_target(&self) -> bool;
-    /// Competition group id. Declared by the file when it says, minted at load
-    /// otherwise — never the row's position.
-    fn decoy_group(&self) -> OwnedSourceId;
-    /// The row this result came from. Opaque and unprintable, so it can order
-    /// the q-value tie-break without any caller-supplied value reaching it.
-    fn row(&self) -> RowIdx;
+    /// The arena handles this result carries onward. See [`RowHandles`].
+    fn handles(&self) -> RowHandles;
     /// Materialize the output identity `Peptide`.
     fn materialize_peptide(&self) -> Peptide;
 }
 
 impl<'a> ScoredIdentity for RefQuery<'a> {
-    fn library_id(&self) -> OwnedSourceId {
-        self.geom().output_id().to_owned_id()
-    }
-
-    fn row(&self) -> RowIdx {
-        self.geom().row()
+    fn handles(&self) -> RowHandles {
+        let row = self.geom().row();
+        RowHandles {
+            row,
+            group: self.lib.geom.decoy_group_code(row),
+        }
     }
 
     fn is_target(&self) -> bool {
@@ -252,13 +255,8 @@ impl<'a> ScoredIdentity for RefQuery<'a> {
         !self.lib.geom.is_decoy(tgt) && self.geom().variant() == 0
     }
 
-    fn decoy_group(&self) -> OwnedSourceId {
-        self.lib.geom.decoy_group(self.geom().row()).to_owned_id()
-    }
-
     fn materialize_peptide(&self) -> Peptide {
-        let dg = self.decoy_group();
-        RefQuery::materialize_peptide_in_group(self, dg)
+        RefQuery::materialize_peptide(self)
     }
 }
 
@@ -385,8 +383,15 @@ mod tests {
         let lib = tiny_ref_lib();
         let scored = lib.item_at(flat(&lib, 0));
         assert!(scored.is_target());
-        assert_eq!(scored.library_id(), OwnedSourceId::Numeric(0)); // flat 0 -> target 0
-        assert_eq!(scored.decoy_group(), OwnedSourceId::Numeric(0));
+        // flat 0 -> row 0, and the id it reports is resolved from the arena,
+        // not carried on the result.
+        let handles = scored.handles();
+        assert_eq!(handles.row, row(&lib, 0));
+        assert_eq!(handles.group, lib.geom.decoy_group_code(row(&lib, 0)));
+        assert_eq!(
+            lib.geom.output_id(handles.row),
+            timsquery::models::SourceId::Numeric(0)
+        );
         let got_frags: Vec<(IonAnnot, f32)> = scored.iter_expected_fragments().collect();
         assert_eq!(got_frags.len(), 2);
         assert!((got_frags[0].1 - 1.0).abs() < 1e-6);
diff --git a/rust/timsseek/src/ml/qvalues.rs b/rust/timsseek/src/ml/qvalues.rs
index af16d1e7..130a12a9 100644
--- a/rust/timsseek/src/ml/qvalues.rs
+++ b/rust/timsseek/src/ml/qvalues.rs
@@ -179,14 +179,14 @@ const RESCORE_SHUFFLE_SEED: u64 = 42;
 /// peak-bucket layouts produce identical features but different vec orderings).
 /// Without a stable sort here, the seeded shuffle sees different inputs across
 /// runs -> different fold assignment -> different q-values -> drifting target
-/// counts across equivalent configs. `(library_id, precursor_charge)` is a
-/// non-FP composite key that should be unique per candidate after target-decoy
-/// competition.
+/// counts across equivalent configs. `(row, precursor_charge)` is a non-FP
+/// composite key that should be unique per candidate after target-decoy
+/// competition: a target and its ±decoy variants share a row, but competition
+/// leaves exactly ONE candidate per (row, charge), so the key stays unique
+/// among the survivors that reach here.
 ///
-/// NOTE: `library_id` is the POSITIONAL target index (lazy arena) / materialized
-/// eg id — a target and its ±decoy variants share it, but target-decoy
-/// competition leaves exactly ONE candidate per (target, charge), so the key
-/// stays unique among survivors here.
+/// The key is the arena row rather than the id the row reports, so a
+/// caller-supplied id can never reach the sort and change the fold assignment.
 ///
 /// The shuffle is NOT cosmetic: every fold partition below is positional, so an
 /// unshuffled (library-ordered) input would make folds correlate with library
@@ -1015,7 +1015,10 @@ mod feature_tests {
         ScoringFields,
     };
     use std::sync::Arc;
-    use timsquery::models::OwnedSourceId;
+    use timsquery::models::{
+        RowIdx,
+        test_handles,
+    };
 
     fn base_scoring_fields(peptide: Peptide) -> ScoringFields {
         ScoringFields::sample(peptide)
@@ -1028,7 +1031,6 @@ mod feature_tests {
         let peptide = Peptide {
             raw: Arc::from("PEPTIDEK"),
             decoy: DecoyMarking::Target,
-            decoy_group: OwnedSourceId::Numeric(0),
             sequence_features,
         };
         CompetedCandidate {
@@ -1152,7 +1154,7 @@ mod feature_tests {
         (0..n)
             .map(|i| {
                 let mut c = sample_competed_candidate(true);
-                c.scoring.identity.library_id = OwnedSourceId::Numeric(i as u64);
+                c.scoring.identity.row = test_handles::row(i);
                 let is_target = i % 2 == 0;
                 c.scoring.identity.is_target = is_target;
                 let base: u8 = if is_target { 20 } else { 8 };
@@ -1273,15 +1275,10 @@ mod feature_tests {
             assert!((0.0..=1.0).contains(&r.qvalue));
         }
 
-        let key = |out: &[FinalResult]| -> Vec<(OwnedSourceId, u32)> {
-            let mut v: Vec<(OwnedSourceId, u32)> = out
+        let key = |out: &[FinalResult]| -> Vec<(RowIdx, u32)> {
+            let mut v: Vec<(RowIdx, u32)> = out
                 .iter()
-                .map(|r| {
-                    (
-                        r.scoring.identity.library_id.clone(),
-                        r.discriminant_score.to_bits(),
-                    )
-                })
+                .map(|r| (r.scoring.identity.row, r.discriminant_score.to_bits()))
                 .collect();
             v.sort_unstable();
             v
@@ -1460,15 +1457,10 @@ mod feature_tests {
     #[test]
     fn rescore_mlp_is_deterministic() {
         let n = 90;
-        let key = |out: &[FinalResult]| -> Vec<(OwnedSourceId, u32)> {
-            let mut v: Vec<(OwnedSourceId, u32)> = out
+        let key = |out: &[FinalResult]| -> Vec<(RowIdx, u32)> {
+            let mut v: Vec<(RowIdx, u32)> = out
                 .iter()
-                .map(|r| {
-                    (
-                        r.scoring.identity.library_id.clone(),
-                        r.discriminant_score.to_bits(),
-                    )
-                })
+                .map(|r| (r.scoring.identity.row, r.discriminant_score.to_bits()))
                 .collect();
             v.sort_unstable();
             v
@@ -1568,15 +1560,10 @@ mod feature_tests {
             );
         }
 
-        let key = |out: &[FinalResult]| -> Vec<(OwnedSourceId, u32)> {
-            let mut v: Vec<(OwnedSourceId, u32)> = out
+        let key = |out: &[FinalResult]| -> Vec<(RowIdx, u32)> {
+            let mut v: Vec<(RowIdx, u32)> = out
                 .iter()
-                .map(|r| {
-                    (
-                        r.scoring.identity.library_id.clone(),
-                        r.discriminant_score.to_bits(),
-                    )
-                })
+                .map(|r| (r.scoring.identity.row, r.discriminant_score.to_bits()))
                 .collect();
             v.sort_unstable();
             v
@@ -1720,7 +1707,7 @@ mod feature_tests {
         (0..n)
             .map(|i| {
                 let mut c = sample_competed_candidate(true);
-                c.scoring.identity.library_id = OwnedSourceId::Numeric(i as u64);
+                c.scoring.identity.row = test_handles::row(i);
                 c.scoring.identity.is_target = i % 2 == 0;
                 c
             })
diff --git a/rust/timsseek/src/models/sequence.rs b/rust/timsseek/src/models/sequence.rs
index eae4deaf..2ac4bb0f 100644
--- a/rust/timsseek/src/models/sequence.rs
+++ b/rust/timsseek/src/models/sequence.rs
@@ -107,7 +107,6 @@ impl ParsedSequence {
 pub struct Peptide {
     pub raw: Arc<str>,
     pub decoy: DecoyMarking,
-    pub decoy_group: timsquery::models::OwnedSourceId,
     /// Whether the source library exposes sequence features. Gates [`Self::parse`]:
     /// a library without them yields no residues, so the sequence lanes stay NaN.
     pub sequence_features: bool,
diff --git a/rust/timsseek/src/scoring/apex_finding.rs b/rust/timsseek/src/scoring/apex_finding.rs
index 064d612a..6812b18a 100644
--- a/rust/timsseek/src/scoring/apex_finding.rs
+++ b/rust/timsseek/src/scoring/apex_finding.rs
@@ -25,10 +25,8 @@
 //! ```
 
 use std::fmt::Display;
-use timsquery::models::{
-    OwnedSourceId,
-    RowIdx,
-};
+
+use crate::data_sources::reference_library::RowHandles;
 
 use super::apex::ApexConfig;
 use super::{
@@ -93,10 +91,10 @@ pub struct PeptideMetadata {
 
     pub charge: u8,
 
-    pub library_id: OwnedSourceId,
-
-    /// The arena row scored, carried for the q-value determinism sort.
-    pub row: RowIdx,
+    /// The arena row scored and the group it competes in. The ids a reader
+    /// wants are resolved from these at the writer, so a scored candidate never
+    /// carries a copy.
+    pub handles: RowHandles,
 
     /// Retention time from spectral library (unit-agnostic: iRT, minutes, or seconds).
     pub library_rt: f32,
diff --git a/rust/timsseek/src/scoring/blocks/identity.rs b/rust/timsseek/src/scoring/blocks/identity.rs
index 7d868ab4..b1132228 100644
--- a/rust/timsseek/src/scoring/blocks/identity.rs
+++ b/rust/timsseek/src/scoring/blocks/identity.rs
@@ -4,7 +4,7 @@
 
 use std::sync::Arc;
 use timsquery::models::{
-    OwnedSourceId,
+    GroupCode,
     RowIdx,
 };
 
@@ -21,13 +21,15 @@ use crate::scoring::blocks::{
 #[derive(Debug, Clone, serde::Serialize)]
 pub struct Identity {
     pub peptide: Peptide,
-    pub library_id: OwnedSourceId,
-    pub decoy_group_id: OwnedSourceId,
-    /// The arena row this result came from. Opaque and unserializable, so it
-    /// can order the q-value tie-break without a caller-supplied id reaching
-    /// the sort (`library_id` is caller-supplied whenever the file had one).
+    /// The arena row this result came from, and the group it competes in. Both
+    /// opaque and unserializable: the row orders the q-value tie-break without
+    /// a caller-supplied id reaching the sort, and the group is only ever
+    /// compared. The ids a reader wants are resolved from the arena at the
+    /// writer — see [`crate::scoring::parquet_writer`].
     #[serde(skip)]
     pub row: RowIdx,
+    #[serde(skip)]
+    pub group: GroupCode,
     pub precursor_mz: f64,
     pub precursor_charge: u8,
     pub precursor_mobility: f32,
@@ -39,16 +41,15 @@ impl Identity {
     /// field is a linear-lane feature.
     pub const LINEAR_LEN: usize = 0;
     /// `precursor_mz_round5`, `precursor_charge`, `precursor_mobility` — the
-    /// context features. `library_id` / `decoy_group_id` / `is_target` are
-    /// Parquet-only.
+    /// context features. `is_target` is Parquet-only, as are the ids the writer
+    /// resolves from `row`.
     pub const NONLINEAR_LEN: usize = 3;
 
     pub fn compute(metadata: &PeptideMetadata) -> Self {
         Self {
             peptide: metadata.digest.clone(),
-            library_id: metadata.library_id.clone(),
-            decoy_group_id: metadata.digest.decoy_group.clone(),
-            row: metadata.row,
+            row: metadata.handles.row,
+            group: metadata.handles.group,
             precursor_mz: metadata.ref_precursor_mz,
             precursor_charge: metadata.charge,
             precursor_mobility: metadata.ref_mobility_ook0,
@@ -67,8 +68,8 @@ impl Identity {
         self.competition_key() == other.competition_key()
     }
 
-    pub fn competition_key(&self) -> (&OwnedSourceId, u8) {
-        (&self.decoy_group_id, self.precursor_charge)
+    pub fn competition_key(&self) -> (GroupCode, u8) {
+        (self.group, self.precursor_charge)
     }
 
     /// The observed mobility is a sentinel on non-scoreable axes; drop the
@@ -95,12 +96,10 @@ impl Identity {
             peptide: Peptide {
                 raw: Arc::from("PEPTIDEK"),
                 decoy: DecoyMarking::Target,
-                decoy_group: OwnedSourceId::Numeric(0),
                 sequence_features: false,
             },
-            library_id: OwnedSourceId::Numeric(1),
-            decoy_group_id: OwnedSourceId::Numeric(0),
             row: RowIdx::default(),
+            group: GroupCode::default(),
             precursor_mz: 500.0,
             precursor_charge: 2,
             precursor_mobility: 0.9,
@@ -112,8 +111,6 @@ impl Identity {
 impl ScoreBlock for Identity {
     fn columns(&self, o: &mut ColSink) {
         o.str("sequence", self.peptide.as_str());
-        o.str("library_id", &self.library_id.to_string());
-        o.str("decoy_group_id", &self.decoy_group_id.to_string());
         o.f64("precursor_mz", self.precursor_mz);
         o.u8("precursor_charge", self.precursor_charge);
         o.f32("precursor_mobility", self.precursor_mobility);
@@ -122,8 +119,6 @@ impl ScoreBlock for Identity {
 
     fn column_schema(o: &mut SchemaSink) {
         o.str("sequence");
-        o.str("library_id");
-        o.str("decoy_group_id");
         o.f64("precursor_mz");
         o.u8("precursor_charge");
         o.f32("precursor_mobility");
diff --git a/rust/timsseek/src/scoring/parquet_writer.rs b/rust/timsseek/src/scoring/parquet_writer.rs
index 89bad0b0..068ae6ec 100644
--- a/rust/timsseek/src/scoring/parquet_writer.rs
+++ b/rust/timsseek/src/scoring/parquet_writer.rs
@@ -11,6 +11,11 @@ use parquet::file::properties::WriterProperties;
 use std::fs::File;
 use std::path::Path;
 use std::sync::Arc;
+use timsquery::IonAnnot;
+use timsquery::models::{
+    SourceId,
+    TargetColumns,
+};
 use tracing::debug;
 
 use super::blocks::{
@@ -35,11 +40,26 @@ pub const RESULTS_FORMAT_VERSION: u32 = 3;
 // Build a RecordBatch from a slice of FinalResult
 // ---------------------------------------------------------------------------
 
+/// Write one id column, without rendering a text id through `Display` first.
+fn emit_id(sink: &mut ColSink, name: &str, id: SourceId<'_>) {
+    match id {
+        SourceId::Text(s) => sink.str(name, s),
+        SourceId::Numeric(n) => sink.str(name, &n.to_string()),
+    }
+}
+
 /// Emit one result's columns into the sink (all scoring blocks, then the
-/// post-model meta block).
-fn emit_row(r: &FinalResult, sink: &mut ColSink) {
+/// post-model meta block, then the ids resolved from the arena).
+///
+/// The ids are not on the result: a candidate carries opaque handles so nothing
+/// on the scoring path can print one or invent one, and this is the boundary
+/// where they become the values a reader joins on.
+fn emit_row(r: &FinalResult, geom: &TargetColumns<IonAnnot>, sink: &mut ColSink) {
     r.scoring.columns(sink);
     r.result_meta().columns(sink);
+    let row = r.scoring.identity.row;
+    emit_id(sink, "library_id", geom.output_id(row));
+    emit_id(sink, "decoy_group_id", geom.decoy_group(row));
     sink.end_row();
 }
 
@@ -64,13 +84,16 @@ fn empty_batch() -> std::io::Result<RecordBatch> {
 /// `#[derive(ScoreBlock)]` in `timsseek_macros`), so a new field cannot
 /// silently skip the Parquet projection — there is no hand-written destructure
 /// to fall out of sync.
-pub fn build_record_batch(results: &[FinalResult]) -> std::io::Result<RecordBatch> {
+pub fn build_record_batch(
+    results: &[FinalResult],
+    geom: &TargetColumns<IonAnnot>,
+) -> std::io::Result<RecordBatch> {
     if results.is_empty() {
         return empty_batch();
     }
     let mut sink = ColSink::new();
     for r in results {
-        emit_row(r, &mut sink);
+        emit_row(r, geom, &mut sink);
     }
 
     let (fields, arrays) = sink.finish();
@@ -83,17 +106,22 @@ pub fn build_record_batch(results: &[FinalResult]) -> std::io::Result<RecordBatc
 // Buffered Parquet writer
 // ---------------------------------------------------------------------------
 
-pub struct ResultParquetWriter {
+/// Borrows the arena the results were scored against, because a `FinalResult`
+/// carries opaque handles rather than ids and the arena is what turns them back
+/// into the values a reader joins on.
+pub struct ResultParquetWriter<'a> {
     writer: ArrowWriter<File>,
     buffer: Vec<FinalResult>,
     row_group_size: usize,
+    geom: &'a TargetColumns<IonAnnot>,
 }
 
-impl ResultParquetWriter {
+impl<'a> ResultParquetWriter<'a> {
     pub fn new(
         path: impl AsRef<Path>,
         row_group_size: usize,
         parsable_sequences: bool,
+        geom: &'a TargetColumns<IonAnnot>,
     ) -> std::io::Result<Self> {
         let file = match File::create_new(path.as_ref()) {
             Ok(f) => f,
@@ -104,7 +132,7 @@ impl ResultParquetWriter {
         };
 
         // Build schema from a zero-row batch
-        let empty_batch = build_record_batch(&[])?;
+        let empty_batch = build_record_batch(&[], geom)?;
         let schema = empty_batch.schema();
 
         let kv = vec![
@@ -129,6 +157,7 @@ impl ResultParquetWriter {
             writer,
             buffer: Vec::with_capacity(row_group_size),
             row_group_size,
+            geom,
         })
     }
 
@@ -145,7 +174,7 @@ impl ResultParquetWriter {
             return Ok(());
         }
         debug!("Flushing {} results to parquet", self.buffer.len());
-        let batch = build_record_batch(&self.buffer)?;
+        let batch = build_record_batch(&self.buffer, self.geom)?;
         self.writer.write(&batch).map_err(std::io::Error::other)?;
         self.buffer.clear();
         Ok(())
@@ -166,6 +195,32 @@ mod tests {
         SerializedFileReader,
     };
     use std::fs::File;
+    use timsquery::models::capabilities::TargetCapabilities;
+
+    /// A one-row arena for the writer to resolve ids against.
+    fn one_row_arena() -> TargetColumns<IonAnnot> {
+        let mut geom = TargetColumns::with_capabilities(TargetCapabilities::default_diann());
+        geom.push_target(
+            900.4,
+            2,
+            1.0,
+            1.0,
+            &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
+            "PEPTIDEK",
+            "PEPTIDEK",
+            &[],
+        );
+        geom.seal();
+        geom
+    }
+
+    /// `FinalResult::sample()` carries a placeholder row, which by design reads
+    /// no arena. Point it at a real one before writing.
+    fn sample_in(geom: &TargetColumns<IonAnnot>) -> FinalResult {
+        let mut r = FinalResult::sample();
+        r.scoring.identity.row = geom.rows().next().expect("one row");
+        r
+    }
 
     /// Golden byte-compat contract for the Parquet schema.
     ///
@@ -193,8 +248,9 @@ mod tests {
         // The writer's schema comes from the empty (SchemaSink) batch; real data
         // goes through the ColSink path. They MUST have identical schemas (name,
         // dtype, nullability, ORDER) or the writer rejects populated batches.
-        let empty = build_record_batch(&[]).expect("empty");
-        let populated = build_record_batch(&[FinalResult::sample()]).expect("populated");
+        let geom = one_row_arena();
+        let empty = build_record_batch(&[], &geom).expect("empty");
+        let populated = build_record_batch(&[sample_in(&geom)], &geom).expect("populated");
         assert_eq!(
             empty.schema(),
             populated.schema(),
@@ -202,10 +258,60 @@ mod tests {
         );
     }
 
+    /// The ids are not carried on a result any more, so this is what pins that
+    /// they still reach the file — and that the row a result points at is the
+    /// row whose id gets written.
+    #[test]
+    fn each_row_s_ids_are_resolved_from_the_arena() {
+        use arrow::array::StringArray;
+
+        let mut geom = TargetColumns::with_capabilities(TargetCapabilities::default_diann());
+        for seq in ["PEPTIDEK", "AAAAAAALQAK"] {
+            geom.push_target(
+                900.4,
+                2,
+                1.0,
+                1.0,
+                &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
+                seq,
+                seq,
+                &[],
+            );
+        }
+        // The names DIA-NN would give these rows, which is the case that must
+        // not come back as digits.
+        geom.set_source_ids(["PEPTIDEK2", "AAAAAAALQAK2"])
+            .expect("two ids for two rows");
+        geom.seal();
+
+        let second = geom.rows().nth(1).expect("two rows");
+        let mut result = FinalResult::sample();
+        result.scoring.identity.row = second;
+
+        let batch = build_record_batch(&[result], &geom).expect("batch");
+        let ids = batch
+            .column_by_name("library_id")
+            .expect("library_id column")
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .expect("library_id is Utf8");
+        assert_eq!(ids.value(0), "AAAAAAALQAK2");
+
+        // No declared groups, so the row is its own group and the group id is
+        // the id the row reports.
+        let groups = batch
+            .column_by_name("decoy_group_id")
+            .expect("decoy_group_id column")
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .expect("decoy_group_id is Utf8");
+        assert_eq!(groups.value(0), "AAAAAAALQAK2");
+    }
+
     #[test]
     fn parquet_schema_contains_maintained_subset() {
         use std::collections::BTreeMap;
-        let batch = build_record_batch(&[]).expect("schema");
+        let batch = build_record_batch(&[], &one_row_arena()).expect("schema");
         let got: BTreeMap<String, (String, bool)> = batch
             .schema()
             .fields()
@@ -232,7 +338,7 @@ mod tests {
 
     #[test]
     fn delta_columns_name_their_ln1p_formulas() {
-        let batch = build_record_batch(&[]).expect("schema");
+        let batch = build_record_batch(&[], &one_row_arena()).expect("schema");
         let schema = batch.schema();
 
         assert!(schema.index_of("delta_group_ln1p_diff").is_ok());
@@ -250,7 +356,8 @@ mod tests {
         //  but NamedTempFile holds it open; drop it first).
         drop(tmp);
         {
-            let writer = ResultParquetWriter::new(&path, 1024, true).expect("create writer");
+            let geom = one_row_arena();
+            let writer = ResultParquetWriter::new(&path, 1024, true, &geom).expect("create writer");
             writer.close().expect("close");
         }
         let file = File::open(&path).expect("open");
diff --git a/rust/timsseek/src/scoring/pipeline.rs b/rust/timsseek/src/scoring/pipeline.rs
index 059b3e10..605f9237 100644
--- a/rust/timsseek/src/scoring/pipeline.rs
+++ b/rust/timsseek/src/scoring/pipeline.rs
@@ -25,6 +25,7 @@
 
 use crate::data_sources::reference_library::{
     ExpectedIntensity,
+    RowHandles,
     ScoredIdentity,
 };
 use crate::data_sources::speclib::Speclib;
@@ -40,11 +41,7 @@ use timscentroid::rt_mapping::{
     MS1CycleIndex,
     RTIndex,
 };
-use timsquery::models::{
-    FlatIdx,
-    OwnedSourceId,
-    RowIdx,
-};
+use timsquery::models::FlatIdx;
 use timsquery::traits::QueryGeom;
 use timsquery::utils::TupleRange;
 use timsquery::{
@@ -121,10 +118,6 @@ pub struct CalibrantCandidate {
     pub score: f32,
     pub apex_rt: ObservedRTSeconds<f32>,
     pub speclib_index: FlatIdx,
-    /// The id this row reports, carried alongside the position because the
-    /// calibration dashboard keys on something a human can recognise and a
-    /// position must not leave the crate.
-    pub library_id: OwnedSourceId,
     pub library_rt: LibraryRT<f32>,
 }
 
@@ -568,9 +561,9 @@ impl<I: ScorerQueriable> Scorer<I> {
     fn build_calibrated_extraction_into(
         &self,
         query: &Target<IonAnnot>,
-        // The flyweight's row: the scratch `Target` is a reused buffer and
-        // cannot carry one.
-        row: RowIdx,
+        // The flyweight's handles: the scratch `Target` is a reused buffer and
+        // cannot carry them.
+        handles: RowHandles,
         expected: &ExpectedIntensities<IonAnnot>,
         digest: Peptide,
         calibration: &CalibrationResult,
@@ -594,15 +587,10 @@ impl<I: ScorerQueriable> Scorer<I> {
             Some(TOP_N_FRAGMENTS),
         )?;
 
-        let extr = worker
-            .extraction
-            .as_ref()
-            .expect("extraction set by build_extraction_into");
         Ok(super::apex_finding::PeptideMetadata {
             digest,
             charge: query.precursor_charge(),
-            library_id: extr.chromatograms.id.clone(),
-            row,
+            handles,
             library_rt: original_irt.0,
             calibrated_rt_seconds: calibrated_rt.0,
             ref_mobility_ook0: query.mobility_ook0(),
@@ -620,7 +608,7 @@ impl<I: ScorerQueriable> Scorer<I> {
     pub fn score_calibrated_extraction(
         &self,
         query: &Target<IonAnnot>,
-        row: RowIdx,
+        handles: RowHandles,
         expected: &ExpectedIntensities<IonAnnot>,
         digest: Peptide,
         calibration: &CalibrationResult,
@@ -634,7 +622,7 @@ impl<I: ScorerQueriable> Scorer<I> {
             tracing::span!(tracing::Level::TRACE, "score_calibrated::extraction").in_scope(|| self
                 .build_calibrated_extraction_into(
                     query,
-                    row,
+                    handles,
                     expected,
                     digest,
                     calibration,
@@ -777,7 +765,7 @@ impl<I: ScorerQueriable> Scorer<I> {
                     let digest = q.materialize_peptide();
                     let result = self.score_calibrated_extraction(
                         &scratch.eg,
-                        q.row(),
+                        q.handles(),
                         &scratch.expected,
                         digest,
                         calibration,
@@ -926,7 +914,6 @@ impl<I: ScorerQueriable> Scorer<I> {
                             score: loc.score,
                             apex_rt: ObservedRTSeconds(loc.retention_time_ms as f32 / 1000.0),
                             speclib_index: flat,
-                            library_id: q.library_id(),
                             library_rt: LibraryRT(q.rt_seconds()),
                         };
                         if let Err(reason) = heap.push(cand) {
diff --git a/rust/timsseek/src/scoring/results.rs b/rust/timsseek/src/scoring/results.rs
index 5110f3b2..d8a38a9b 100644
--- a/rust/timsseek/src/scoring/results.rs
+++ b/rust/timsseek/src/scoring/results.rs
@@ -206,11 +206,19 @@ impl FinalResult {
         }
     }
 
-    /// Value-free Parquet schema: scoring blocks (composition order) then the
-    /// post-model meta block — mirrors `emit_row`'s column order exactly.
+    /// Value-free Parquet schema: scoring blocks (composition order), the
+    /// post-model meta block, then the ids — mirrors `emit_row`'s column order
+    /// exactly, which the writer's `schema_first_matches_populated_data_path`
+    /// test pins.
+    ///
+    /// The ids are declared here rather than in the `Identity` block because
+    /// they are not on the result: `emit_row` resolves them from the arena. A
+    /// column added here needs the matching `emit_id` there, in this position.
     pub fn column_schema(o: &mut SchemaSink) {
         <ScoringFields as ScoreBlock>::column_schema(o);
         <ResultMeta as ScoreBlock>::column_schema(o);
+        o.str("library_id");
+        o.str("decoy_group_id");
     }
 }
 
diff --git a/rust/timsseek_cli/Cargo.toml b/rust/timsseek_cli/Cargo.toml
index 89d32fd0..3d9e78bd 100644
--- a/rust/timsseek_cli/Cargo.toml
+++ b/rust/timsseek_cli/Cargo.toml
@@ -61,3 +61,9 @@ mzdata = ["timsseek/mzdata"]
 # `rescore_dash`/`ratatui`. Without this feature, `TIMSSEEK_RESCORE_DASHBOARD`
 # does nothing.
 dashboard = ["dep:rescore_dash"]
+
+[dev-dependencies]
+# Constructors for the opaque arena handles, for the competition tests, which
+# assemble candidates without an arena behind them. Dev-only, so a shipped
+# build cannot mint one.
+timsquery = { path = "../timsquery", features = ["test-support"] }
diff --git a/rust/timsseek_cli/src/processing.rs b/rust/timsseek_cli/src/processing.rs
index aeb85d3f..b0b09bc3 100644
--- a/rust/timsseek_cli/src/processing.rs
+++ b/rust/timsseek_cli/src/processing.rs
@@ -95,16 +95,16 @@ mod calib_dash_hook {
             Hasher,
         };
         use std::io::IsTerminal;
-        use timsquery::models::OwnedSourceId;
 
         /// The dashboard compares calibrant identity across batches but never
-        /// displays it, so it takes a hash instead of the id. That keeps its
-        /// point type `Copy` and, more importantly, keeps `size_of` the true
-        /// cost of a point — which is what its replay memory budget is computed
-        /// from. Only meaningful within one process.
-        fn identity_hash(id: &OwnedSourceId) -> u64 {
+        /// displays it, so it takes a hash of the arena handle rather than the
+        /// id that handle resolves to. That keeps its point type `Copy` and,
+        /// more importantly, keeps `size_of` the true cost of a point — which is
+        /// what its replay memory budget is computed from. Only meaningful
+        /// within one process.
+        fn identity_hash(handle: impl Hash) -> u64 {
             let mut hasher = DefaultHasher::new();
-            id.hash(&mut hasher);
+            handle.hash(&mut hasher);
             hasher.finish()
         }
 
@@ -190,7 +190,7 @@ mod calib_dash_hook {
                 calibrants.map(|c| calib_dash::CalibrantPoint {
                     library_rt: c.library_rt.0 as f64,
                     observed_rt: c.apex_rt.0 as f64,
-                    identity: identity_hash(&c.library_id),
+                    identity: identity_hash(c.speclib_index),
                 }),
             );
             if matches!(flow, calib_dash::Flow::Abort) {
@@ -599,6 +599,7 @@ pub fn execute_pipeline<I: ScorerQueriable>(
         &out_path_pq,
         20_000,
         speclib.parsable_sequences(),
+        &speclib.geom,
     )
     .map_err(|e| TimsSeekError::Io {
         path: out_path_pq.clone().into(),
@@ -1166,17 +1167,15 @@ pub fn run_pipeline(
 mod tests {
     use super::*;
     use std::sync::Arc;
-    use timsquery::models::OwnedSourceId;
+    use timsquery::models::test_handles;
     use timsseek::models::DecoyMarking;
     use timsseek::models::sequence::Peptide;
     use timsseek::scoring::results::ScoringFields;
 
-    fn candidate(
-        seq: &str,
-        mz: f64,
-        is_target: bool,
-        decoy_group: OwnedSourceId,
-    ) -> ScoredCandidate {
+    /// `group` names the competition group: candidates sharing one compete.
+    /// Production reads it off the arena as an opaque code; a fixture only needs
+    /// the codes to differ where the test wants different groups.
+    fn candidate(seq: &str, mz: f64, is_target: bool, group: u32) -> ScoredCandidate {
         let decoy = if is_target {
             DecoyMarking::Target
         } else {
@@ -1185,13 +1184,12 @@ mod tests {
         let peptide = Peptide {
             raw: Arc::from(seq),
             decoy,
-            decoy_group: decoy_group.clone(),
             sequence_features: false,
         };
         let mut scoring = ScoringFields::sample(peptide);
         scoring.identity.precursor_mz = mz;
         scoring.identity.is_target = is_target;
-        scoring.identity.decoy_group_id = decoy_group;
+        scoring.identity.group = test_handles::group(group);
         // All fixtures tie on score so the (seq, score, is_target) tiebreak arm
         // is what orders them.
         scoring.primary.main_score = 5.0;
@@ -1218,14 +1216,14 @@ mod tests {
         // and charge, distinct precursor m/z. Two input orderings differing ONLY
         // in the tie order must produce identical (ordered) survivors.
         let order_a = vec![
-            candidate("PEPTIDEK", 501.0, true, OwnedSourceId::Numeric(0)),
-            candidate("PEPTIDEK", 500.0, false, OwnedSourceId::Numeric(0)),
-            candidate("PEPTIDEK", 502.0, false, OwnedSourceId::Numeric(0)),
+            candidate("PEPTIDEK", 501.0, true, 0),
+            candidate("PEPTIDEK", 500.0, false, 0),
+            candidate("PEPTIDEK", 502.0, false, 0),
         ];
         let order_b = vec![
-            candidate("PEPTIDEK", 502.0, false, OwnedSourceId::Numeric(0)),
-            candidate("PEPTIDEK", 500.0, false, OwnedSourceId::Numeric(0)),
-            candidate("PEPTIDEK", 501.0, true, OwnedSourceId::Numeric(0)),
+            candidate("PEPTIDEK", 502.0, false, 0),
+            candidate("PEPTIDEK", 500.0, false, 0),
+            candidate("PEPTIDEK", 501.0, true, 0),
         ];
 
         let sa = survivors(order_a);
@@ -1244,9 +1242,9 @@ mod tests {
 
     #[test]
     fn competition_features_match_their_ln1p_names() {
-        let mut best = candidate("BEST", 501.0, true, OwnedSourceId::Numeric(7));
+        let mut best = candidate("BEST", 501.0, true, 7);
         best.scoring.primary.main_score = 8.0;
-        let mut runner_up = candidate("RUNNER", 502.0, false, OwnedSourceId::Numeric(7));
+        let mut runner_up = candidate("RUNNER", 502.0, false, 7);
         runner_up.scoring.primary.main_score = 3.0;
 
         let competed = target_decoy_compete(vec![runner_up, best]);
@@ -1264,11 +1262,11 @@ mod tests {
     /// to come from the runner-up, not from the worst member.
     #[test]
     fn a_three_member_group_separates_the_winner_from_the_runner_up() {
-        let mut best = candidate("BEST", 501.0, true, OwnedSourceId::Numeric(7));
+        let mut best = candidate("BEST", 501.0, true, 7);
         best.scoring.primary.main_score = 8.0;
-        let mut middle = candidate("MIDDLE", 502.0, false, OwnedSourceId::Numeric(7));
+        let mut middle = candidate("MIDDLE", 502.0, false, 7);
         middle.scoring.primary.main_score = 3.0;
-        let mut worst = candidate("WORST", 503.0, false, OwnedSourceId::Numeric(7));
+        let mut worst = candidate("WORST", 503.0, false, 7);
         worst.scoring.primary.main_score = 1.0;
 
         let competed = target_decoy_compete(vec![worst, middle, best]);
@@ -1284,7 +1282,7 @@ mod tests {
     /// existed.
     #[test]
     fn a_lone_group_member_reports_no_separation() {
-        let mut only = candidate("ALONE", 501.0, true, OwnedSourceId::Numeric(7));
+        let mut only = candidate("ALONE", 501.0, true, 7);
         only.scoring.primary.main_score = 8.0;
 
         let competed = target_decoy_compete(vec![only]);
@@ -1298,9 +1296,9 @@ mod tests {
     /// neighbour's.
     #[test]
     fn separate_groups_do_not_bleed_into_each_other() {
-        let mut a = candidate("A", 501.0, true, OwnedSourceId::Numeric(1));
+        let mut a = candidate("A", 501.0, true, 1);
         a.scoring.primary.main_score = 8.0;
-        let mut b = candidate("B", 502.0, true, OwnedSourceId::Numeric(2));
+        let mut b = candidate("B", 502.0, true, 2);
         b.scoring.primary.main_score = 3.0;
 
         let competed = target_decoy_compete(vec![a, b]);

From 645190487b119ae86ddb191e1505a79d03e6367e Mon Sep 17 00:00:00 2001
From: "J. Sebastian Paez" <jspaezp@gmail.com>
Date: Fri, 28 Aug 2026 00:00:51 -0700
Subject: [PATCH 14/19] fix(timsquery): name the precursor that costs a library
 its ids

A blank `transition_group_id` in one cell falls the whole DIA-NN library back
to minted ids, because the arena holds one id shape and not two. That trade
stays, but the warning only reported how many rows were named -- and the
fallback then rewrites every id, so nothing was left to find the offending row
from.

The warning now names the first unnamed precursor and says what the fallback
costs. `first_unnamed` is split out so what it reports is testable, and the
mixed-shape path has a test at all for the first time.
---
 rust/timsquery/src/serde/diann_io.rs | 73 +++++++++++++++++++++++++---
 1 file changed, 66 insertions(+), 7 deletions(-)

diff --git a/rust/timsquery/src/serde/diann_io.rs b/rust/timsquery/src/serde/diann_io.rs
index dbf3a973..e174e015 100644
--- a/rust/timsquery/src/serde/diann_io.rs
+++ b/rust/timsquery/src/serde/diann_io.rs
@@ -330,24 +330,48 @@ pub fn read_targets<T: AsRef<Path>>(
 /// only some is malformed (a blank `transition_group_id` cell, say), and the
 /// arena cannot hold both shapes at once, so fall the whole file back to minted
 /// ids rather than half-labelling it.
+///
+/// One blank cell therefore costs the whole library its names, which is a large
+/// consequence for a small defect — so the warning names the row that triggered
+/// it. The check is library-wide, and without that the caller gets a warning
+/// they cannot act on.
 fn unify_source_ids(egs: &mut [(Target<IonAnnot>, DiannPrecursorExtras)]) {
-    let named = egs
-        .iter()
-        .filter(|(eg, _)| matches!(eg.id(), SourceId::Text(_)))
-        .count();
+    let named = egs.iter().filter(|(eg, _)| is_named(eg)).count();
     if named == 0 || named == egs.len() {
         return;
     }
+    let total = egs.len();
+    let (index, extras) = first_unnamed(egs).expect("named < total, so some precursor is unnamed");
     warn!(
-        "{named} of {} precursors carry a name; the rest do not. Falling back to \
-         minted ids for the whole library.",
-        egs.len()
+        "{named} of {total} DIA-NN precursors carry a name and {} do not, so the whole \
+         library falls back to minted ids: every result's `library_id` will be a row \
+         number instead of the name the file gave it. The first unnamed one is precursor \
+         {index}, {:?} — fill in its `transition_group_id` / `Precursor.Id` to keep the \
+         file's own names.",
+        total - named,
+        extras,
     );
     for (i, (eg, _)) in egs.iter_mut().enumerate() {
         eg.set_id(OwnedSourceId::Numeric(i as u64));
     }
 }
 
+fn is_named(eg: &Target<IonAnnot>) -> bool {
+    matches!(eg.id(), SourceId::Text(_))
+}
+
+/// The first precursor the file left unnamed, as `(index, modified peptide)`.
+///
+/// Split out from the warning so what it reports is testable: the fallback
+/// rewrites every id, so by the time a caller sees the library there is nothing
+/// left to identify the row from.
+fn first_unnamed(egs: &[(Target<IonAnnot>, DiannPrecursorExtras)]) -> Option<(usize, &str)> {
+    egs.iter()
+        .enumerate()
+        .find(|(_, (eg, _))| !is_named(eg))
+        .map(|(i, (_, extras))| (i, extras.modified_peptide.as_str()))
+}
+
 fn parse_precursor_group(
     id: u64,
     rows: &[DiannLibraryRow],
@@ -800,6 +824,41 @@ mod tests {
     use super::*;
     use std::path::PathBuf;
 
+    /// One blank `transition_group_id` costs the *whole* library its names,
+    /// because the arena holds one id shape and not two. That trade is
+    /// deliberate; what it must not be is quiet. This pins both halves: the
+    /// fallback rewrites every id, and the precursor that triggered it is
+    /// identifiable before it does.
+    #[test]
+    fn one_unnamed_precursor_downgrades_the_library_and_is_named_first() {
+        // This fixture has no `transition_group_id` column, so both precursors
+        // come back minted. Naming one of them is the mixed library a blank cell
+        // produces.
+        let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("tests")
+            .join("diann_io_files")
+            .join("sample_lib.txt");
+        let mut egs = read_targets(path).expect("reads");
+        assert_eq!(egs.len(), 2, "fixture should hold two precursors");
+        egs[0].0.set_id(OwnedSourceId::Text("MGRYSGK2".into()));
+
+        let named = egs[1].1.modified_peptide.clone();
+        assert_eq!(
+            first_unnamed(&egs),
+            Some((1, named.as_str())),
+            "the warning has to name the precursor that caused the downgrade"
+        );
+
+        unify_source_ids(&mut egs);
+        for (i, (eg, _)) in egs.iter().enumerate() {
+            assert_eq!(
+                eg.id(),
+                SourceId::Numeric(i as u64),
+                "a mixed library falls back to minted ids for every row"
+            );
+        }
+    }
+
     #[test]
     fn test_sniff_diann_library_file() {
         let manifest_dir = env!("CARGO_MANIFEST_DIR");

From ab67e5f4692ba51c352fc6fb1007dda394990955 Mon Sep 17 00:00:00 2001
From: "J. Sebastian Paez" <jspaezp@gmail.com>
Date: Fri, 28 Aug 2026 00:44:56 -0700
Subject: [PATCH 15/19] refactor(timsquery): build a flyweight from the handle
 that already names a slot

`Query::new(lib, row, variant)` let a caller pair a row with a decoy variant by
hand, which is what `FlatIdx` exists to prevent -- it *is* the name of a
(row, variant) pair, and `split_flat` is documented as the single authority for
that encoding. The `u8` was never checked against `variants_per_row` either, so
naming a variant the library does not expand into read a real but wrong slot.

The flyweight now takes a `FlatIdx` and splits it once at construction, so:

- nothing outside the arena mints a `RowIdx`; `RowIdx::new` drops from
  `pub(in crate::models)` to `pub(super)`, the same as the other two handles.
- `flat_for` gives the arena the inverse transform, with the range check the
  loose pair never had. It is now the only way to name a specific variant, which
  in practice means test fixtures; production only ever goes through `item_at`.

The fields stay unpacked rather than deriving from the stored flat, because
`row()` is on the path of every geometry accessor and deriving costs a division
by a non-const `variants_per_row`. Measured: the flyweight is two words before
and after, and `the_flyweight_stays_two_words` now pins that.

Also, the `Default` audit: `FlatIdx`'s had no callers at all and is gone.
`RowIdx`'s and `GroupCode`'s have exactly one, `Identity::sample_default()`,
which `#[derive(ScoreBlock)]` deliberately leaves un-gated; the doc records
that instead of the `#[serde(skip)]` reason it used to claim, which was never
true (`Identity` only derives `Serialize`).
---
 rust/timsquery/src/models/query_handle.rs     | 81 +++++++++++++------
 rust/timsquery/src/models/target_columns.rs   | 66 ++++++++-------
 .../src/data_sources/reference_library.rs     | 29 ++++---
 rust/timsseek/src/data_sources/speclib.rs     | 12 ++-
 4 files changed, 118 insertions(+), 70 deletions(-)

diff --git a/rust/timsquery/src/models/query_handle.rs b/rust/timsquery/src/models/query_handle.rs
index 576b8a83..927fe416 100644
--- a/rust/timsquery/src/models/query_handle.rs
+++ b/rust/timsquery/src/models/query_handle.rs
@@ -6,7 +6,10 @@ use crate::models::capabilities::{
     DecoyStrategy,
     IsotopeStrategy,
 };
-use crate::models::target_columns::RowIdx;
+use crate::models::target_columns::{
+    FlatIdx,
+    RowIdx,
+};
 use crate::traits::{
     DecoyShift,
     KeyLike,
@@ -15,42 +18,55 @@ use crate::traits::{
 use crate::utils::constants::C13_C12_MASS_DIFF;
 
 /// Flyweight handle over a `TargetColumns` arena: `lib` borrows (or owns via
-/// `Arc`) the arena, `handle` packs the target index and decoy variant. No
+/// `Arc`) the arena, and `row`/`variant` say which scored slot this is. No
 /// decoy geometry is stored anywhere; variants 1/2 compute a ±CH2 mass shift
 /// on the fly from `TargetCapabilities::decoys`.
+///
+/// A flyweight is built from a [`FlatIdx`] and nothing else, because that is
+/// already the name of a `(row, variant)` pair — see
+/// [`TargetColumns::split_flat`], the single authority for the encoding. The
+/// pair is split once at construction and stored unpacked, so the accessors
+/// every geometry method calls stay field reads rather than a division by
+/// `variants_per_row`.
+///
+/// The fields used to be packed into a `u64`. That cost nothing in size (the
+/// `Lib` pointer's alignment pads the struct to two words either way — see
+/// `the_flyweight_stays_two_words`) and cost the arena its monopoly on minting
+/// a `RowIdx`, since unpacking had to build one.
 #[derive(Debug, Clone, Copy)]
 pub struct Query<Lib, L> {
     lib: Lib,
-    handle: u64,
+    row: RowIdx,
+    variant: u8,
     _label: PhantomData<L>,
 }
 
 pub type QueryRef<'a, L> = Query<&'a TargetColumns<L>, L>;
 
 impl<Lib, L> Query<Lib, L> {
-    pub const VARIANT_BITS: u32 = 2;
-    const VARIANT_MASK: u64 = 0b11;
-
-    pub fn new(lib: Lib, tgt: RowIdx, variant: u8) -> Self {
-        debug_assert!(u64::from(variant) <= Self::VARIANT_MASK);
-        Self {
-            lib,
-            handle: ((tgt.get() as u64) << Self::VARIANT_BITS) | u64::from(variant),
-            _label: PhantomData,
-        }
-    }
-
     /// The stored row this handle points at.
     pub fn row(&self) -> RowIdx {
-        RowIdx::new((self.handle >> Self::VARIANT_BITS) as u32)
+        self.row
     }
 
     pub fn variant(&self) -> u8 {
-        (self.handle & Self::VARIANT_MASK) as u8
+        self.variant
     }
 }
 
 impl<Lib: Deref<Target = TargetColumns<L>>, L: KeyLike + DecoyShift> Query<Lib, L> {
+    /// Prefer [`TargetColumns::item_at`]; this exists for the owning `Lib`
+    /// flavours, which cannot borrow the arena to call it.
+    pub fn new(lib: Lib, flat: FlatIdx) -> Self {
+        let (row, variant) = lib.split_flat(flat);
+        Self {
+            lib,
+            row,
+            variant,
+            _label: PhantomData,
+        }
+    }
+
     pub fn geom(&self) -> &TargetColumns<L> {
         &self.lib
     }
@@ -161,6 +177,25 @@ mod tests {
     use crate::models::source_id::SourceId;
     use crate::traits::QueryGeom;
 
+    /// Rows come from the arena; there is no constructor from an integer.
+    fn first_row<L: KeyLike>(lib: &TargetColumns<L>) -> RowIdx {
+        lib.rows().next().expect("fixture has a row")
+    }
+
+    /// The flyweight is `Copy` and built once per scored slot, so its size is a
+    /// real cost. Two words: the arena pointer, then the row and variant inside
+    /// the pointer's alignment padding. This is what makes storing the handles
+    /// free relative to packing them into a `u64`.
+    #[test]
+    fn the_flyweight_stays_two_words() {
+        let word = size_of::<usize>();
+        assert_eq!(size_of::<QueryRef<'_, IonAnnot>>(), 2 * word);
+        assert_eq!(
+            size_of::<Query<std::sync::Arc<TargetColumns<IonAnnot>>, IonAnnot>>(),
+            2 * word
+        );
+    }
+
     fn one_target_lib() -> TargetColumns<IonAnnot> {
         let mut c = TargetColumns::with_capabilities(TargetCapabilities {
             sequence_features: SeqFeatureState::Available,
@@ -191,7 +226,7 @@ mod tests {
     #[test]
     fn target_variant_is_unshifted() {
         let lib = one_target_lib();
-        let q = Query::new(&lib, RowIdx::new(0), 0);
+        let q = Query::new(&lib, lib.flat_for(first_row(&lib), 0));
         assert_eq!(q.output_id(), SourceId::Numeric(0));
         assert!((q.mono_precursor_mz() - 654.855).abs() < 1e-9);
         let frags: Vec<_> = q.iter_fragments_refs().collect();
@@ -201,7 +236,7 @@ mod tests {
     #[test]
     fn plus_decoy_shifts_precursor_and_high_ordinal_only() {
         let lib = one_target_lib();
-        let q = Query::new(&lib, RowIdx::new(0), 1); // +shift
+        let q = Query::new(&lib, lib.flat_for(first_row(&lib), 1)); // +shift
         // precursor: +14.0/2
         assert!((q.mono_precursor_mz() - (654.855 + 14.0 / 2.0)).abs() < 1e-9);
         let frags: Vec<_> = q.iter_fragments_refs().collect();
@@ -214,7 +249,7 @@ mod tests {
     #[test]
     fn minus_decoy_shifts_negative() {
         let lib = one_target_lib();
-        let q = Query::new(&lib, RowIdx::new(0), 2); // -shift
+        let q = Query::new(&lib, lib.flat_for(first_row(&lib), 2)); // -shift
         assert!((q.mono_precursor_mz() - (654.855 - 14.0 / 2.0)).abs() < 1e-9);
     }
 
@@ -223,7 +258,7 @@ mod tests {
         // n_isotopes=3, charge 2, mono 654.855 -> limits span isotopes 0..3,
         // i.e. (mono, mono + 2*C13_C12_MASS_DIFF/2).
         let lib = one_target_lib();
-        let q = Query::new(&lib, RowIdx::new(0), 0);
+        let q = Query::new(&lib, lib.flat_for(first_row(&lib), 0));
         let step = C13_C12_MASS_DIFF / 2.0;
         let (lo, hi) = q.precursor_mz_limits();
         assert!((lo - 654.855).abs() < 1e-9);
@@ -259,7 +294,7 @@ mod tests {
             false,
         );
         c.seal();
-        let q = Query::new(&c, RowIdx::new(0), 0);
+        let q = Query::new(&c, c.flat_for(first_row(&c), 0));
         let frags: Vec<_> = q.iter_fragments_refs().collect();
         assert!((frags[0].1 - 300.0).abs() < 1e-9);
     }
@@ -269,7 +304,7 @@ mod tests {
         // +decoy (variant 1) shifts the mono by offset/charge; the envelope
         // limits shift by the same amount and keep the same width.
         let lib = one_target_lib();
-        let q = Query::new(&lib, RowIdx::new(0), 1);
+        let q = Query::new(&lib, lib.flat_for(first_row(&lib), 1));
         let step = C13_C12_MASS_DIFF / 2.0;
         let mono = 654.855 + 14.0 / 2.0;
         let (lo, hi) = q.precursor_mz_limits();
diff --git a/rust/timsquery/src/models/target_columns.rs b/rust/timsquery/src/models/target_columns.rs
index f3f08a0e..4112c08a 100644
--- a/rust/timsquery/src/models/target_columns.rs
+++ b/rust/timsquery/src/models/target_columns.rs
@@ -27,9 +27,8 @@ pub use index::{
 /// only be obtained from the arena and handed straight back to it.
 ///
 /// Construction is `pub(super)`, i.e. this file, so the arena is the only thing
-/// that mints one. `RowIdx` is `pub(in crate::models)` only because the
-/// flyweight in `query_handle` packs and unpacks it; unpacking is the last
-/// place outside here that builds one.
+/// that mints one — including a `RowIdx`, since the flyweight now stores the
+/// handle it was given rather than packing and rebuilding it.
 mod index {
     /// A stored row: `0..n_rows()`.
     #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -54,11 +53,11 @@ mod index {
     pub struct GroupCode(u32);
 
     impl RowIdx {
-        pub(in crate::models) fn new(row: u32) -> Self {
+        pub(super) fn new(row: u32) -> Self {
             Self(row)
         }
 
-        pub(in crate::models) fn get(self) -> usize {
+        pub(super) fn get(self) -> usize {
             self.0 as usize
         }
     }
@@ -83,26 +82,22 @@ mod index {
         }
     }
 
-    /// `u32::MAX`, not 0. A defaulted index exists only as a placeholder — a
-    /// `#[serde(skip)]` field, a test fixture — and 0 is a valid row in every
-    /// non-empty arena, so a placeholder that leaked would read row 0 and look
-    /// right. `u32::MAX` panics on access instead.
+    /// `u32::MAX`, not 0, because 0 is a valid row in every non-empty arena: a
+    /// placeholder that leaked would read row 0 and look right, where `u32::MAX`
+    /// panics on access. A defaulted group likewise competes with the other
+    /// placeholders and with nothing real, rather than folding into the arena's
+    /// first group.
+    ///
+    /// These exist for exactly one caller: `Identity::sample_default()`, which
+    /// `#[derive(ScoreBlock)]` deliberately leaves un-gated so other crates'
+    /// tests can build a fixture. Nothing in production defaults a handle. There
+    /// is no `Default for FlatIdx` because nothing ever wanted one.
     impl Default for RowIdx {
         fn default() -> Self {
             Self(u32::MAX)
         }
     }
 
-    impl Default for FlatIdx {
-        fn default() -> Self {
-            Self(u32::MAX)
-        }
-    }
-
-    /// Same reasoning, and the same placeholder value: a defaulted group is one
-    /// nothing has assigned yet. `u32::MAX` makes such rows compete with each
-    /// other and with nothing real, which is visible; 0 would silently fold
-    /// them into the arena's first group.
     impl Default for GroupCode {
         fn default() -> Self {
             Self(u32::MAX)
@@ -485,15 +480,15 @@ impl<L: KeyLike> TargetColumns<L> {
             tracing::warn!("library ships decoys; downgrading LazyMassShift -> Passthrough");
             self.caps.decoys = DecoyStrategy::Passthrough;
         }
-        // The flyweight packs the decoy variant into `VARIANT_BITS` bits. Fail
-        // loud here (where the invariant is established) rather than silently
-        // corrupting the packed handle in a release build. The free fn is used
-        // because `seal` is not bounded on `DecoyShift`.
+        // A decoy variant is a `u8` all the way from `split_flat`'s `% vpr`
+        // cast to the flyweight. Fail loud here, where the invariant is
+        // established, rather than silently truncating a variant index in a
+        // release build. The free fn is used because `seal` is not bounded on
+        // `DecoyShift`.
         let vpr = variants_per_row_for(self.caps.decoys);
         assert!(
-            vpr <= (1usize << QueryRef::<'_, L>::VARIANT_BITS),
-            "variants_per_row {vpr} exceeds the {}-bit decoy-variant packing budget",
-            QueryRef::<'_, L>::VARIANT_BITS,
+            vpr <= u8::MAX as usize + 1,
+            "variants_per_row {vpr} exceeds what a u8 decoy variant can name"
         );
         self.precursor_mz.shrink_to_fit();
         self.charge.shrink_to_fit();
@@ -570,10 +565,25 @@ impl<L: KeyLike + DecoyShift> TargetColumns<L> {
         (RowIdx::new(row), (flat % vpr) as u8)
     }
 
+    /// The inverse of [`Self::split_flat`]: name one of a row's scored slots.
+    ///
+    /// Both directions live here so the encoding has one owner. This is also the
+    /// only way to pair a row with a variant, and it checks the pairing — a
+    /// caller that could build the pair itself could name a variant the library
+    /// does not expand into, which would read a real but wrong slot.
+    pub fn flat_for(&self, row: RowIdx, variant: u8) -> FlatIdx {
+        let vpr = self.variants_per_row();
+        assert!(
+            (variant as usize) < vpr,
+            "variant {variant} does not exist in a library with {vpr} variants per row"
+        );
+        assert!(row.get() < self.n_rows(), "row is out of range");
+        FlatIdx::new((row.get() * vpr + variant as usize) as u32)
+    }
+
     /// Scored slot -> `(row, variant)` flyweight.
     pub fn item_at(&self, flat: FlatIdx) -> QueryRef<'_, L> {
-        let (row, variant) = self.split_flat(flat);
-        QueryRef::new(self, row, variant)
+        QueryRef::new(self, flat)
     }
 
     /// A slot is a target iff its stored row is a target AND it is the
diff --git a/rust/timsseek/src/data_sources/reference_library.rs b/rust/timsseek/src/data_sources/reference_library.rs
index 867921a6..da211b2d 100644
--- a/rust/timsseek/src/data_sources/reference_library.rs
+++ b/rust/timsseek/src/data_sources/reference_library.rs
@@ -51,11 +51,10 @@ impl ReferenceLibrary {
         self.len() == 0
     }
 
-    /// Maps a flat `0..len()` index to a `(row, variant)` `RefQuery`, delegating
-    /// the flat->(row,variant) math to the arena's `split_flat` transform.
+    /// Maps a scored slot to its `RefQuery`; the flat->(row, variant) transform
+    /// belongs to the arena.
     pub fn item_at(&self, flat: FlatIdx) -> RefQuery<'_> {
-        let (row, variant) = self.geom.split_flat(flat);
-        RefQuery::new(self, row, variant)
+        RefQuery::new(self, flat)
     }
 
     pub fn iter(&self) -> impl Iterator<Item = RefQuery<'_>> {
@@ -103,10 +102,10 @@ impl TryFrom<TargetTable> for ReferenceLibrary {
 }
 
 impl<'a> RefQuery<'a> {
-    pub fn new(lib: &'a ReferenceLibrary, tgt: RowIdx, variant: u8) -> Self {
+    pub fn new(lib: &'a ReferenceLibrary, flat: FlatIdx) -> Self {
         Self {
             lib,
-            geom: Query::new(&lib.geom, tgt, variant),
+            geom: Query::new(&lib.geom, flat),
         }
     }
 
@@ -213,11 +212,6 @@ impl<'a> QueryGeom for RefQuery<'a> {
     }
 }
 
-/// Arm-neutral identity accessors the scoring loop needs but that are NOT part
-/// of `QueryGeom` / `ExpectedIntensity`. Implemented by the `RefQuery`
-/// flyweight so the batch scoring loop stays generic (monomorphized,
-/// zero-heap) over the concrete type — see
-/// `Scorer::{prescore,score_calibrated}_batch_impl`.
 /// Which row a scored result came from, and which group it competes in.
 ///
 /// The two travel together because the scorer holds the run's raw-data index,
@@ -230,6 +224,11 @@ pub struct RowHandles {
     pub group: GroupCode,
 }
 
+/// Arm-neutral identity accessors the scoring loop needs but that are NOT part
+/// of `QueryGeom` / `ExpectedIntensity`. Implemented by the `RefQuery`
+/// flyweight so the batch scoring loop stays generic (monomorphized,
+/// zero-heap) over the concrete type — see
+/// `Scorer::{prescore,score_calibrated}_batch_impl`.
 pub trait ScoredIdentity {
     /// Whether this item is a target (vs a decoy variant).
     fn is_target(&self) -> bool;
@@ -337,7 +336,7 @@ mod tests {
     #[test]
     fn expected_fragments_pair_labels_with_intensities() {
         let lib = tiny_ref_lib();
-        let q = RefQuery::new(&lib, row(&lib, 0), 0);
+        let q = RefQuery::new(&lib, lib.geom.flat_for(row(&lib, 0), 0));
         let pairs: Vec<_> = q.iter_expected_fragments().collect();
         assert_eq!(pairs.len(), 2);
         assert_eq!(pairs[0].0, IonAnnot::try_from("y3").unwrap());
@@ -348,7 +347,7 @@ mod tests {
     #[test]
     fn precursor_envelope_is_max_normalized_three_peaks() {
         let lib = tiny_ref_lib();
-        let q = RefQuery::new(&lib, row(&lib, 0), 0);
+        let q = RefQuery::new(&lib, lib.geom.flat_for(row(&lib, 0), 0));
         let env = q.expected_precursor_envelope();
         assert_eq!(env.len(), 3);
         // Envelopes are MAX-normalized (base peak = 1.0), matching the
@@ -366,10 +365,10 @@ mod tests {
     #[test]
     fn decoy_variant_reuses_target_intensities() {
         let lib = tiny_ref_lib();
-        let t: Vec<_> = RefQuery::new(&lib, row(&lib, 0), 0)
+        let t: Vec<_> = RefQuery::new(&lib, lib.geom.flat_for(row(&lib, 0), 0))
             .iter_expected_fragments()
             .collect();
-        let d: Vec<_> = RefQuery::new(&lib, row(&lib, 0), 1)
+        let d: Vec<_> = RefQuery::new(&lib, lib.geom.flat_for(row(&lib, 0), 1))
             .iter_expected_fragments()
             .collect();
         assert_eq!(t, d, "intensities are variant-independent");
diff --git a/rust/timsseek/src/data_sources/speclib.rs b/rust/timsseek/src/data_sources/speclib.rs
index 87e5c35b..4c94a2b0 100644
--- a/rust/timsseek/src/data_sources/speclib.rs
+++ b/rust/timsseek/src/data_sources/speclib.rs
@@ -972,7 +972,11 @@ mod tests {
         assert_eq!(n_target_indices, 2, "Should have 2 unique targets");
         for tgt in lib.geom.rows() {
             let variants: Vec<u8> = (0..3)
-                .map(|v| RefQuery::new(lib, tgt, v).geom().variant())
+                .map(|v| {
+                    RefQuery::new(lib, lib.geom.flat_for(tgt, v))
+                        .geom()
+                        .variant()
+                })
                 .collect();
             assert_eq!(
                 variants,
@@ -1004,9 +1008,9 @@ mod tests {
         use timsquery::models::capabilities::DECOY_CH2_OFFSET_DA;
 
         for tgt in lib.geom.rows() {
-            let target = RefQuery::new(lib, tgt, 0);
-            let plus = RefQuery::new(lib, tgt, 1);
-            let minus = RefQuery::new(lib, tgt, 2);
+            let target = RefQuery::new(lib, lib.geom.flat_for(tgt, 0));
+            let plus = RefQuery::new(lib, lib.geom.flat_for(tgt, 1));
+            let minus = RefQuery::new(lib, lib.geom.flat_for(tgt, 2));
 
             let target_mz = target.mono_precursor_mz();
             let charge = target.precursor_charge();

From 1feff7cf87a73de6200d1a121ff491f74f4fbcc2 Mon Sep 17 00:00:00 2001
From: "J. Sebastian Paez" <jspaezp@gmail.com>
Date: Fri, 28 Aug 2026 01:17:47 -0700
Subject: [PATCH 16/19] chore: address the second review round's mechanical
 findings

Clippy is back to main's 19-warning baseline: the branch had added four
`iter_nth_zero` warnings in `diann_speclib_io`'s tests, where closing off
`RowIdx::new` turned `RowIdx::new(0)` into `.rows().nth(0).unwrap()`. Those go
through a `row(geom, i)` helper now.

The id columns get a `ScoreBlock` (`parquet_writer::Ids`) instead of two
hand-written `o.str` calls in the writer and two matching declarations in
`FinalResult::column_schema`. That split was the schema/data drift the derive
exists to prevent, reintroduced by hand.

`SourceIds`: `LibraryId` is deleted (it had no callers left, and its
`#[serde(transparent)]` doc described a wire format with no call site);
`numeric`/`text` are private so `owned` is the only way in and the length check
lives in one place; `owned` decides the shape from two `position` calls instead
of a collect plus two scans plus an `expect`; `text` dedups over the finished
blob rather than cloning each id into a `HashSet<String>`. `MixedShapes`'
`first_text_free_row` is renamed `first_numeric_row`, which is what it holds.
Decoy groups get their own length-mismatch variant, so the message stops calling
them source ids.

`Serialize` is off the borrowed `SourceId`: the result path writes an
`OwnedSourceId` (`ChromatogramOutput.id`), and the contract tests were pinning
Carafe's `"id": 7` against the sibling type. They now serialize what production
serializes, and the borrowed impl had no other caller.

`seal`'s `variants_per_row <= u8::MAX + 1` assert cannot fire (`n_decoys` is a
`u8`), and `variants_per_row_for` existed only to serve it from an unbounded
`impl`. Both gone; `variants_per_row` is the single definition.

Also: `identity_hash` takes `FlatIdx` rather than `impl Hash`, which also
accepted `score.to_bits()`; `materialize_peptide` loses the trait-to-inherent
forward; three byte-identical determinism-key closures in `qvalues` become one
`determinism_key`; two assertions that restated the function body they were
checking now assert values; duplicated test arenas share a builder.

Three comments this branch's own renames had made false (`calib_dash`'s
`metrics.rs` and `frames.rs`, `qvalues`' fixture doc) say what the code does,
and the comments that narrated the change rather than the invariant are trimmed
to the invariant. `RESULTS_FORMAT_VERSION` now records that `decoy_group_id`
equals `library_id` until a format declares groups, so a reader can tell the
duplication is expected.
---
 rust/calib_dash/src/frames.rs                 |   9 +-
 rust/calib_dash/src/metrics.rs                |   2 +-
 rust/timsquery/src/models/mod.rs              |   1 -
 rust/timsquery/src/models/query_handle.rs     |   7 +-
 rust/timsquery/src/models/source_id.rs        | 162 +++++++++---------
 rust/timsquery/src/models/target_columns.rs   |  57 ++----
 rust/timsquery/src/serde/diann_io.rs          |   6 +-
 rust/timsquery/src/serde/diann_speclib_io.rs  |  20 ++-
 rust/timsquery/src/serde/library_file.rs      |  29 ++--
 rust/timsquery/tests/carafe_contract/main.rs  |   7 +-
 rust/timsquery_viewer/src/file_loader.rs      |   4 +-
 .../src/data_sources/reference_library.rs     |  50 ++----
 rust/timsseek/src/ml/qvalues.rs               |  53 +++---
 rust/timsseek/src/scoring/blocks/identity.rs  |   8 +-
 rust/timsseek/src/scoring/parquet_writer.rs   | 107 ++++++++----
 rust/timsseek/src/scoring/results.rs          |  13 +-
 rust/timsseek_cli/src/processing.rs           |   8 +-
 17 files changed, 264 insertions(+), 279 deletions(-)

diff --git a/rust/calib_dash/src/frames.rs b/rust/calib_dash/src/frames.rs
index eb2f47ea..aa251822 100644
--- a/rust/calib_dash/src/frames.rs
+++ b/rust/calib_dash/src/frames.rs
@@ -24,10 +24,11 @@ pub const REPLAY_BUDGET_BYTES: usize = 1 << 20;
 ///
 /// `identity` exists because churn diffing needs to tell "same calibrant,
 /// re-scored" from "different calibrant, same RT", and RT coordinates are not
-/// unique. It is an opaque hash of the caller's id, never displayed -- this is
-/// a debugging view, so it compares identity without carrying it. Keeping it a
-/// plain integer is what lets `size_of` below be the true cost of a point, and
-/// what keeps this type `Copy`.
+/// unique. It is an opaque hash of whatever handle the producer keys on (today
+/// the arena's `FlatIdx`), never displayed -- this is a debugging view, so it
+/// compares identity without carrying it. Keeping it a plain integer is what
+/// lets `size_of` below be the true cost of a point, and what keeps this type
+/// `Copy`.
 ///
 /// Only meaningful within one process: the hash is not stable across runs.
 #[derive(Debug, Clone, Copy, PartialEq)]
diff --git a/rust/calib_dash/src/metrics.rs b/rust/calib_dash/src/metrics.rs
index 6f1f3fb5..9fcc4115 100644
--- a/rust/calib_dash/src/metrics.rs
+++ b/rust/calib_dash/src/metrics.rs
@@ -57,7 +57,7 @@ pub fn curve_delta(
     }
 }
 
-/// `(admitted, evicted)` between two heap snapshots, by `library_id`.
+/// `(admitted, evicted)` between two heap snapshots, by `identity`.
 pub fn churn(prev: &[CalibrantPoint], cur: &[CalibrantPoint]) -> (usize, usize) {
     let prev_set: HashSet<u64> = prev.iter().map(|p| p.identity).collect();
     let cur_set: HashSet<u64> = cur.iter().map(|p| p.identity).collect();
diff --git a/rust/timsquery/src/models/mod.rs b/rust/timsquery/src/models/mod.rs
index 1aa3fb21..6d486550 100644
--- a/rust/timsquery/src/models/mod.rs
+++ b/rust/timsquery/src/models/mod.rs
@@ -27,7 +27,6 @@ pub use query_handle::{
     QueryRef,
 };
 pub use source_id::{
-    LibraryId,
     OwnedSourceId,
     SourceId,
     SourceIdError,
diff --git a/rust/timsquery/src/models/query_handle.rs b/rust/timsquery/src/models/query_handle.rs
index 927fe416..37bab1cb 100644
--- a/rust/timsquery/src/models/query_handle.rs
+++ b/rust/timsquery/src/models/query_handle.rs
@@ -29,10 +29,9 @@ use crate::utils::constants::C13_C12_MASS_DIFF;
 /// every geometry method calls stay field reads rather than a division by
 /// `variants_per_row`.
 ///
-/// The fields used to be packed into a `u64`. That cost nothing in size (the
-/// `Lib` pointer's alignment pads the struct to two words either way — see
-/// `the_flyweight_stays_two_words`) and cost the arena its monopoly on minting
-/// a `RowIdx`, since unpacking had to build one.
+/// Storing the pair costs nothing over bit-packing it: the `Lib` pointer's
+/// alignment pads the struct to two words either way, which
+/// `the_flyweight_stays_two_words` pins.
 #[derive(Debug, Clone, Copy)]
 pub struct Query<Lib, L> {
     lib: Lib,
diff --git a/rust/timsquery/src/models/source_id.rs b/rust/timsquery/src/models/source_id.rs
index 2d9f82bb..5bf981ce 100644
--- a/rust/timsquery/src/models/source_id.rs
+++ b/rust/timsquery/src/models/source_id.rs
@@ -21,27 +21,13 @@ use serde::{
 };
 use thiserror::Error;
 
-/// `#[serde(transparent)]` keeps the wire format a bare integer.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
-#[serde(transparent)]
-pub struct LibraryId(u64);
-
-impl LibraryId {
-    pub fn new(id: u64) -> Self {
-        Self(id)
-    }
-
-    pub fn get(self) -> u64 {
-        self.0
-    }
-}
-
 /// One row's id, borrowed from the arena that stores it.
 ///
-/// `#[serde(untagged)]` so it serializes as the shape it is — a bare number or
-/// a bare string — rather than as a tagged union.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
-#[serde(untagged)]
+/// Deliberately not `Serialize`: the result path writes an [`OwnedSourceId`]
+/// (`ChromatogramOutput.id`), and having both be serializable meant the wire
+/// contract could be pinned against whichever one a test reached for. Call
+/// [`Self::to_owned_id`] to serialize.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum SourceId<'a> {
     Numeric(u64),
     Text(&'a str),
@@ -81,9 +67,7 @@ impl OwnedSourceId {
             Self::Text(s) => SourceId::Text(s),
         }
     }
-}
 
-impl OwnedSourceId {
     /// Overwrite in place, reusing the existing `String` capacity when both
     /// sides are text. `Target::reset_from` runs per query on the scoring hot
     /// path, so a fresh allocation there is a per-query cost.
@@ -136,7 +120,7 @@ impl std::fmt::Display for OwnedSourceId {
 pub enum SourceIds {
     #[default]
     Absent,
-    Numeric(Vec<LibraryId>),
+    Numeric(Vec<u64>),
     /// CSR over one blob, like `seq_strip_blob`: `offsets` has `n_rows + 1`
     /// entries.
     Text {
@@ -149,6 +133,10 @@ pub enum SourceIds {
 pub enum SourceIdError {
     #[error("{ids} source ids for {rows} rows")]
     LengthMismatch { ids: usize, rows: usize },
+    /// Its own variant so the message says "groups" when the caller supplied
+    /// groups; `LengthMismatch` rendered them as "source ids".
+    #[error("{groups} decoy groups for {rows} rows")]
+    GroupLengthMismatch { groups: usize, rows: usize },
     /// Callers key results by this id, so a repeat makes one row unreachable.
     #[error("duplicate source id {id}; ids must be unique per row")]
     Duplicate { id: String },
@@ -162,62 +150,55 @@ pub enum SourceIdError {
     /// Names the offending row: the check runs over the whole library, so
     /// without it a caller has no way to find the row that broke it.
     #[error(
-        "row {row} has a text id ({value:?}) but row {first_text_free_row} has a numeric one; \
+        "row {row} has a text id ({value:?}) but row {first_numeric_row} has a numeric one; \
          a library names its rows one way or the other"
     )]
     MixedShapes {
         row: usize,
         value: String,
-        first_text_free_row: usize,
+        first_numeric_row: usize,
     },
 }
 
 impl SourceIds {
-    pub fn numeric(ids: Vec<LibraryId>, n_rows: usize) -> Result<Self, SourceIdError> {
-        if ids.len() != n_rows {
-            return Err(SourceIdError::LengthMismatch {
-                ids: ids.len(),
-                rows: n_rows,
-            });
-        }
+    /// All-numeric. Kept dense rather than rendered into the blob, so the common
+    /// JSON path does not pay for one.
+    fn numeric(ids: Vec<u64>) -> Result<Self, SourceIdError> {
         let mut seen = std::collections::HashSet::with_capacity(ids.len());
         for id in &ids {
             if !seen.insert(*id) {
-                return Err(SourceIdError::Duplicate {
-                    id: id.get().to_string(),
-                });
+                return Err(SourceIdError::Duplicate { id: id.to_string() });
             }
         }
         Ok(Self::Numeric(ids))
     }
 
     /// Ids the file spelled as text, carried through verbatim.
-    pub fn text<I, S>(ids: I, n_rows: usize) -> Result<Self, SourceIdError>
+    fn text<I, S>(ids: I) -> Result<Self, SourceIdError>
     where
         I: IntoIterator<Item = S>,
         S: AsRef<str>,
     {
         let mut blob = String::new();
         let mut offsets = vec![0u32];
-        let mut seen = std::collections::HashSet::with_capacity(n_rows);
         for id in ids {
-            let id = id.as_ref();
-            if !seen.insert(id.to_string()) {
-                return Err(SourceIdError::Duplicate { id: id.to_string() });
-            }
-            blob.push_str(id);
+            blob.push_str(id.as_ref());
             offsets.push(u32::try_from(blob.len()).map_err(|_| SourceIdError::BlobTooLarge)?);
         }
-        if offsets.len() - 1 != n_rows {
-            return Err(SourceIdError::LengthMismatch {
-                ids: offsets.len() - 1,
-                rows: n_rows,
-            });
+        // Dedup over the finished blob, so a row's id is borrowed rather than
+        // cloned into the set.
+        let mut seen = std::collections::HashSet::with_capacity(offsets.len() - 1);
+        for w in offsets.windows(2) {
+            let id = &blob[w[0] as usize..w[1] as usize];
+            if !seen.insert(id) {
+                return Err(SourceIdError::Duplicate { id: id.to_string() });
+            }
         }
         Ok(Self::Text { blob, offsets })
     }
 
-    /// Ids of whichever shape the file used, kept as they came.
+    /// Ids of whichever shape the file used, kept as they came. The only way in;
+    /// the length check lives here, once.
     pub fn owned(ids: Vec<OwnedSourceId>, n_rows: usize) -> Result<Self, SourceIdError> {
         if ids.len() != n_rows {
             return Err(SourceIdError::LengthMismatch {
@@ -225,37 +206,32 @@ impl SourceIds {
                 rows: n_rows,
             });
         }
-        // All-numeric stays numeric so the common JSON path keeps its dense
-        // integer column instead of paying for a blob. Collecting decides the
-        // shape and reports the first row that disagrees in one pass.
-        let numeric: Option<Vec<LibraryId>> = ids
+        let first_numeric = ids
             .iter()
-            .map(|id| match id {
-                OwnedSourceId::Numeric(n) => Some(LibraryId::new(*n)),
-                OwnedSourceId::Text(_) => None,
-            })
-            .collect();
+            .position(|id| matches!(id, OwnedSourceId::Numeric(_)));
+        let first_text = ids
+            .iter()
+            .position(|id| matches!(id, OwnedSourceId::Text(_)));
 
-        match numeric {
-            Some(nums) => Self::numeric(nums, n_rows),
-            None => {
-                if let Some((row, value)) = ids.iter().enumerate().find_map(|(i, id)| match id {
-                    OwnedSourceId::Text(s) => Some((i, s.clone())),
-                    OwnedSourceId::Numeric(_) => None,
-                }) && ids.iter().any(|id| matches!(id, OwnedSourceId::Numeric(_)))
-                {
-                    let first_text_free_row = ids
-                        .iter()
-                        .position(|id| matches!(id, OwnedSourceId::Numeric(_)))
-                        .expect("just checked one exists");
-                    return Err(SourceIdError::MixedShapes {
-                        row,
-                        value,
-                        first_text_free_row,
-                    });
-                }
-                Self::text(ids.iter().map(|id| id.to_string()), n_rows)
-            }
+        match (first_numeric, first_text) {
+            // No text at all, including the empty library.
+            (_, None) => Self::numeric(
+                ids.iter()
+                    .map(|id| match id {
+                        OwnedSourceId::Numeric(n) => *n,
+                        OwnedSourceId::Text(_) => unreachable!("no row holds text"),
+                    })
+                    .collect(),
+            ),
+            (None, Some(_)) => Self::text(ids.iter().map(|id| match id {
+                OwnedSourceId::Text(s) => s.as_str(),
+                OwnedSourceId::Numeric(_) => unreachable!("no row holds a number"),
+            })),
+            (Some(first_numeric_row), Some(row)) => Err(SourceIdError::MixedShapes {
+                row,
+                value: ids[row].to_string(),
+                first_numeric_row,
+            }),
         }
     }
 
@@ -264,13 +240,13 @@ impl SourceIds {
     /// they are minted from, but they are ids from here on: stored in the
     /// column, reported in output, and no longer tied to where the row sits.
     pub fn minted(n_rows: usize) -> Self {
-        Self::Numeric((0..n_rows as u64).map(LibraryId::new).collect())
+        Self::Numeric((0..n_rows as u64).collect())
     }
 
     pub fn get(&self, row: usize) -> Option<SourceId<'_>> {
         match self {
             Self::Absent => None,
-            Self::Numeric(ids) => ids.get(row).map(|id| SourceId::Numeric(id.get())),
+            Self::Numeric(ids) => ids.get(row).copied().map(SourceId::Numeric),
             Self::Text { blob, offsets } => {
                 let start = *offsets.get(row)? as usize;
                 let end = *offsets.get(row + 1)? as usize;
@@ -284,30 +260,46 @@ impl SourceIds {
 mod tests {
     use super::*;
 
+    fn owned(ids: Vec<OwnedSourceId>) -> Result<SourceIds, SourceIdError> {
+        let n = ids.len();
+        SourceIds::owned(ids, n)
+    }
+
+    /// A caller keys results by this id, so a repeat makes one row unreachable.
     #[test]
     fn duplicate_ids_are_rejected() {
-        let ids = vec![LibraryId::new(7), LibraryId::new(7)];
         assert_eq!(
-            SourceIds::numeric(ids, 2),
+            owned(vec![OwnedSourceId::Numeric(7), OwnedSourceId::Numeric(7)]),
             Err(SourceIdError::Duplicate {
                 id: "7".to_string()
             })
         );
         assert_eq!(
-            SourceIds::text(["AAAK2", "AAAK2"], 2),
+            owned(vec!["AAAK2".into(), "AAAK2".into()]),
             Err(SourceIdError::Duplicate {
                 id: "AAAK2".to_string()
             })
         );
     }
 
+    #[test]
+    fn a_row_count_that_disagrees_with_the_ids_is_rejected() {
+        assert_eq!(
+            SourceIds::owned(vec![OwnedSourceId::Numeric(7)], 2),
+            Err(SourceIdError::LengthMismatch { ids: 1, rows: 2 })
+        );
+    }
+
     /// Carafe reads `id` with fastjson and keys results by it, so a numeric id
     /// must stay a JSON number even though the type can also hold a string.
     #[test]
     fn each_id_serializes_as_its_own_shape() {
-        assert_eq!(serde_json::to_string(&SourceId::Numeric(7)).unwrap(), "7");
         assert_eq!(
-            serde_json::to_string(&SourceId::Text("AAAK2")).unwrap(),
+            serde_json::to_string(&OwnedSourceId::Numeric(7)).unwrap(),
+            "7"
+        );
+        assert_eq!(
+            serde_json::to_string(&OwnedSourceId::Text("AAAK2".into())).unwrap(),
             r#""AAAK2""#
         );
     }
@@ -326,7 +318,7 @@ mod tests {
             Err(SourceIdError::MixedShapes {
                 row: 1,
                 value: "AAAK2".to_string(),
-                first_text_free_row: 0,
+                first_numeric_row: 0,
             }),
             "the error has to name the row that broke it"
         );
@@ -344,7 +336,7 @@ mod tests {
 
     #[test]
     fn text_ids_round_trip_through_the_blob() {
-        let ids = SourceIds::text(["AAAK2", "PEPTIDEK3"], 2).unwrap();
+        let ids = owned(vec!["AAAK2".into(), "PEPTIDEK3".into()]).unwrap();
         assert_eq!(ids.get(0), Some(SourceId::Text("AAAK2")));
         assert_eq!(ids.get(1), Some(SourceId::Text("PEPTIDEK3")));
         assert_eq!(ids.get(2), None);
diff --git a/rust/timsquery/src/models/target_columns.rs b/rust/timsquery/src/models/target_columns.rs
index 4112c08a..ac3fadf9 100644
--- a/rust/timsquery/src/models/target_columns.rs
+++ b/rust/timsquery/src/models/target_columns.rs
@@ -27,8 +27,7 @@ pub use index::{
 /// only be obtained from the arena and handed straight back to it.
 ///
 /// Construction is `pub(super)`, i.e. this file, so the arena is the only thing
-/// that mints one — including a `RowIdx`, since the flyweight now stores the
-/// handle it was given rather than packing and rebuilding it.
+/// that mints one.
 mod index {
     /// A stored row: `0..n_rows()`.
     #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -316,8 +315,8 @@ impl<L: KeyLike> TargetColumns<L> {
     {
         let groups: Vec<OwnedSourceId> = groups.into_iter().map(Into::into).collect();
         if groups.len() != self.n_rows() {
-            return Err(SourceIdError::LengthMismatch {
-                ids: groups.len(),
+            return Err(SourceIdError::GroupLengthMismatch {
+                groups: groups.len(),
                 rows: self.n_rows(),
             });
         }
@@ -480,16 +479,6 @@ impl<L: KeyLike> TargetColumns<L> {
             tracing::warn!("library ships decoys; downgrading LazyMassShift -> Passthrough");
             self.caps.decoys = DecoyStrategy::Passthrough;
         }
-        // A decoy variant is a `u8` all the way from `split_flat`'s `% vpr`
-        // cast to the flyweight. Fail loud here, where the invariant is
-        // established, rather than silently truncating a variant index in a
-        // release build. The free fn is used because `seal` is not bounded on
-        // `DecoyShift`.
-        let vpr = variants_per_row_for(self.caps.decoys);
-        assert!(
-            vpr <= u8::MAX as usize + 1,
-            "variants_per_row {vpr} exceeds what a u8 decoy variant can name"
-        );
         self.precursor_mz.shrink_to_fit();
         self.charge.shrink_to_fit();
         self.rt_seconds.shrink_to_fit();
@@ -512,21 +501,18 @@ impl<L: KeyLike> TargetColumns<L> {
 /// `LazyMassShift`), and expanded/flat indices fan each row out into its
 /// target + decoy variants. Bounded on `DecoyShift` so `item_at` can hand out a
 /// `QueryRef` (the flyweight that computes decoy geometry on the fly).
-/// Variants each stored row expands into, from the decoy strategy alone:
-/// `LazyMassShift` adds `n_decoys` mass-shifted variants (+1 for the target);
-/// `Passthrough`/`None` are 1:1. Free fn (no `DecoyShift` bound) so both the
-/// bounded `variants_per_row` and the unbounded `seal` share one definition.
-pub fn variants_per_row_for(decoys: DecoyStrategy) -> usize {
-    match decoys {
-        DecoyStrategy::LazyMassShift { n_decoys, .. } => n_decoys as usize + 1,
-        DecoyStrategy::Passthrough | DecoyStrategy::None => 1,
-    }
-}
-
 impl<L: KeyLike + DecoyShift> TargetColumns<L> {
-    /// Variants each stored row expands into (see [`variants_per_row_for`]).
+    /// Variants each stored row expands into, from the decoy strategy alone:
+    /// `LazyMassShift` adds `n_decoys` mass-shifted variants (+1 for the
+    /// target); `Passthrough`/`None` are 1:1.
+    ///
+    /// `n_decoys` is a `u8`, which is what keeps a variant index inside the
+    /// `u8` that [`Self::split_flat`] casts it to.
     pub fn variants_per_row(&self) -> usize {
-        variants_per_row_for(self.caps.decoys)
+        match self.caps.decoys {
+            DecoyStrategy::LazyMassShift { n_decoys, .. } => n_decoys as usize + 1,
+            DecoyStrategy::Passthrough | DecoyStrategy::None => 1,
+        }
     }
 
     /// Logical count after decoy expansion: the flat iterator length, i.e. how
@@ -644,26 +630,15 @@ mod tests {
             c.decoy_group_code(b),
             "each row competes alone"
         );
-        assert_eq!(c.decoy_group(a), c.output_id(a));
+        assert_eq!(c.decoy_group(a), SourceId::Numeric(0));
+        assert_eq!(c.decoy_group(b), SourceId::Numeric(1));
     }
 
     /// `output_id` expects a source id on every row; this is what makes that
     /// safe for the formats that carry none.
     #[test]
     fn seal_mints_ids_when_the_input_carried_none() {
-        let mut c = TargetColumns::with_capabilities(TargetCapabilities::default_diann());
-        for _ in 0..2 {
-            c.push_target(
-                500.0,
-                2,
-                1.0,
-                0.8,
-                &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
-                "PEP",
-                "PEP",
-                &[],
-            );
-        }
+        let mut c = two_rows();
         assert_eq!(c.source_id(RowIdx::new(0)), None);
         c.seal();
         assert_eq!(c.output_id(RowIdx::new(0)), SourceId::Numeric(0));
diff --git a/rust/timsquery/src/serde/diann_io.rs b/rust/timsquery/src/serde/diann_io.rs
index e174e015..00c38dcb 100644
--- a/rust/timsquery/src/serde/diann_io.rs
+++ b/rust/timsquery/src/serde/diann_io.rs
@@ -331,10 +331,8 @@ pub fn read_targets<T: AsRef<Path>>(
 /// arena cannot hold both shapes at once, so fall the whole file back to minted
 /// ids rather than half-labelling it.
 ///
-/// One blank cell therefore costs the whole library its names, which is a large
-/// consequence for a small defect — so the warning names the row that triggered
-/// it. The check is library-wide, and without that the caller gets a warning
-/// they cannot act on.
+/// The check is library-wide, so the warning names the precursor that triggered
+/// the fallback; without that a caller cannot act on it.
 fn unify_source_ids(egs: &mut [(Target<IonAnnot>, DiannPrecursorExtras)]) {
     let named = egs.iter().filter(|(eg, _)| is_named(eg)).count();
     if named == 0 || named == egs.len() {
diff --git a/rust/timsquery/src/serde/diann_speclib_io.rs b/rust/timsquery/src/serde/diann_speclib_io.rs
index b598d058..618fce61 100644
--- a/rust/timsquery/src/serde/diann_speclib_io.rs
+++ b/rust/timsquery/src/serde/diann_speclib_io.rs
@@ -974,6 +974,8 @@ pub fn read_diann_speclib_library_file<T: AsRef<Path>>(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::KeyLike;
+    use crate::models::RowIdx;
     use std::path::PathBuf;
 
     fn fixture_path() -> PathBuf {
@@ -983,6 +985,12 @@ mod tests {
             .join("diann-hela-diapasef-lib.speclib")
     }
 
+    /// The arena hands out rows; there is no constructor from an integer. These
+    /// tests assert on m/z and sequence values, so the lookup is noise.
+    fn row<L: KeyLike>(geom: &TargetColumns<L>, i: usize) -> RowIdx {
+        geom.rows().nth(i).expect("row is in range")
+    }
+
     // All expected values below are sourced from `reference_parser.py` (an
     // independent decoder), not from this reader — so the test is not circular.
 
@@ -1039,11 +1047,11 @@ mod tests {
             parse_speclib_reader(std::io::BufReader::new(file)).unwrap();
 
         assert_eq!(
-            &geom.seq_mod_blob[geom.seq_mod_range(geom.rows().nth(0).unwrap())],
+            &geom.seq_mod_blob[geom.seq_mod_range(row(&geom, 0))],
             "AAAGAAATHLEVAR"
         );
         assert_eq!(
-            &geom.seq_strip_blob[geom.seq_strip_range(geom.rows().nth(0).unwrap())],
+            &geom.seq_strip_blob[geom.seq_strip_range(row(&geom, 0))],
             "AAAGAAATHLEVAR"
         );
         assert_eq!(geom.charge[0], 2);
@@ -1055,7 +1063,7 @@ mod tests {
         // The fixture has Peptide.length == 0, so y-series is recovered from the
         // sequence length (14). ExcludeFromAssay fragments are kept; only
         // neutral-loss/dup drop, so all 12 remain.
-        let range = geom.frag_range(geom.rows().nth(0).unwrap());
+        let range = geom.frag_range(row(&geom, 0));
         assert_eq!(range.len(), 12, "all non-loss fragments kept");
 
         // First few fragments in file order, sourced independently. y9 carries
@@ -1100,14 +1108,14 @@ mod tests {
             parse_speclib_reader(std::io::BufReader::new(file)).unwrap();
 
         assert_eq!(
-            &geom.seq_mod_blob[geom.seq_mod_range(geom.rows().nth(532).unwrap())],
+            &geom.seq_mod_blob[geom.seq_mod_range(row(&geom, 532))],
             "LEGNSPQGSNQGVK"
         );
         assert_eq!(geom.charge[532], 2);
         assert!((geom.precursor_mz[532] - 707.85052).abs() < 1e-3);
         assert!((geom.rt_seconds[532] - (-31.935_83)).abs() < 1e-3);
         assert!((geom.mobility[532] - 0.9704546).abs() < 1e-4);
-        assert_eq!(geom.frag_range(geom.rows().nth(532).unwrap()).len(), 6);
+        assert_eq!(geom.frag_range(row(&geom, 532)).len(), 6);
     }
 
     #[test]
@@ -1144,7 +1152,7 @@ mod tests {
         // Exclude-flagged fragments are present in the output, not dropped:
         // entry[0] keeps its flagged y9.
         assert!(
-            geom.frag_labels[geom.frag_range(geom.rows().nth(0).unwrap())]
+            geom.frag_labels[geom.frag_range(row(&geom, 0))]
                 .iter()
                 .any(|l| *l == IonAnnot::try_new('y', Some(9), 1, 0).unwrap()),
             "flagged y9 must be kept"
diff --git a/rust/timsquery/src/serde/library_file.rs b/rust/timsquery/src/serde/library_file.rs
index e27d2852..9b10a54c 100644
--- a/rust/timsquery/src/serde/library_file.rs
+++ b/rust/timsquery/src/serde/library_file.rs
@@ -404,11 +404,10 @@ impl TargetTable {
 
 /// Carry the rows' ids into the arena, then seal it.
 ///
-/// The two steps are one function because separating them is how the ids got
-/// lost: `mzpaf_with_intensities` sealed without them, so every DIA-NN library
-/// -- the formats that actually name their precursors -- minted `0..n` over the
-/// names it had just parsed, and the reader-level tests passed because they
-/// asserted on the `Target` rather than on the arena.
+/// One function, not two calls: `seal` mints `0..n` for a library that arrived
+/// without ids, so sealing before attaching them silently overwrites the names
+/// the reader parsed. Every arm goes through here so that ordering cannot be
+/// got wrong.
 fn seal_with_source_ids<L: KeyLike, T: KeyLike>(
     geom: &mut TargetColumns<L>,
     egs: &[Target<T>],
@@ -597,20 +596,16 @@ mod tests {
     };
 
     /// What a result would actually be keyed by: the ids the sealed arena
-    /// holds, read back through the public funnel.
-    ///
-    /// Every id assertion belongs at this layer. The readers were setting
-    /// `Target::id` correctly the whole time while `mzpaf_with_intensities`
-    /// sealed without carrying it over, so tests one layer up passed against an
-    /// arena full of minted counters.
+    /// holds, read back through the public funnel. Asserting on a `Target`
+    /// instead would pass even if sealing dropped the ids.
     fn arena_ids(path: &Path) -> Vec<String> {
+        // Both arms read the same way; the label type is what differs.
+        fn ids<L: crate::KeyLike>(geom: &crate::models::TargetColumns<L>) -> Vec<String> {
+            geom.rows().map(|r| geom.output_id(r).to_string()).collect()
+        }
         match super::read_targets(path).expect("fixture loads") {
-            super::TargetTable::Mzpaf { geom, .. } => {
-                geom.rows().map(|r| geom.output_id(r).to_string()).collect()
-            }
-            super::TargetTable::Str { geom } => {
-                geom.rows().map(|r| geom.output_id(r).to_string()).collect()
-            }
+            super::TargetTable::Mzpaf { geom, .. } => ids(&geom),
+            super::TargetTable::Str { geom } => ids(&geom),
         }
     }
 
diff --git a/rust/timsquery/tests/carafe_contract/main.rs b/rust/timsquery/tests/carafe_contract/main.rs
index 9e11a239..9ce2a6a4 100644
--- a/rust/timsquery/tests/carafe_contract/main.rs
+++ b/rust/timsquery/tests/carafe_contract/main.rs
@@ -196,10 +196,11 @@ fn an_id_comes_back_in_the_shape_it_arrived() {
     let row = geom.rows().next().unwrap();
     assert_eq!(geom.output_id(row), SourceId::Numeric(7));
     assert_eq!(
-        serde_json::to_string(&geom.output_id(row)).unwrap(),
+        serde_json::to_string(&geom.output_id(row).to_owned_id()).unwrap(),
         "7",
         "Carafe reads `id` with fastjson and keys results by it: a number must \
-         stay a bare number, not become \"7\""
+         stay a bare number, not become \"7\". Serialized as `OwnedSourceId`, \
+         which is what `ChromatogramOutput.id` holds on the real result path"
     );
 
     let text = write_targets(
@@ -215,7 +216,7 @@ fn an_id_comes_back_in_the_shape_it_arrived() {
     let row = geom.rows().next().unwrap();
     assert_eq!(geom.output_id(row), SourceId::Text("PEPTIDEK2"));
     assert_eq!(
-        serde_json::to_string(&geom.output_id(row)).unwrap(),
+        serde_json::to_string(&geom.output_id(row).to_owned_id()).unwrap(),
         r#""PEPTIDEK2""#
     );
 }
diff --git a/rust/timsquery_viewer/src/file_loader.rs b/rust/timsquery_viewer/src/file_loader.rs
index 30418b2f..e151c5b7 100644
--- a/rust/timsquery_viewer/src/file_loader.rs
+++ b/rust/timsquery_viewer/src/file_loader.rs
@@ -234,7 +234,7 @@ impl ElutionGroupData {
         use std::fmt::Write;
         buffer.clear();
         let q = self.item_at(idx);
-        let peptide = ScoredIdentity::materialize_peptide(&q);
+        let peptide = q.materialize_peptide();
         let _ = write!(
             buffer,
             "{}|{}|{}",
@@ -348,7 +348,7 @@ impl ElutionGroupData {
     ) {
         let q = self.item_at(idx);
         let is_selected = Some(idx) == *selected_index;
-        let peptide = ScoredIdentity::materialize_peptide(&q);
+        let peptide = q.materialize_peptide();
 
         let mut clicked = false;
         let mut add_col = |ui: &mut egui::Ui, text: &str| {
diff --git a/rust/timsseek/src/data_sources/reference_library.rs b/rust/timsseek/src/data_sources/reference_library.rs
index da211b2d..66869bf2 100644
--- a/rust/timsseek/src/data_sources/reference_library.rs
+++ b/rust/timsseek/src/data_sources/reference_library.rs
@@ -1,5 +1,4 @@
 use smallvec::SmallVec;
-use std::sync::Arc;
 use timsquery::IonAnnot;
 use timsquery::serde::TargetTable;
 
@@ -112,30 +111,6 @@ impl<'a> RefQuery<'a> {
     pub fn geom(&self) -> &Query<&'a TargetColumns<IonAnnot>, IonAnnot> {
         &self.geom
     }
-
-    /// Materialize the output identity `Peptide` for this flyweight.
-    ///
-    /// `raw` is the modified-sequence blob slice. `parsed` is filled by
-    /// normalizing the modified sequence to ProForma and parsing it — but ONLY when sequence
-    /// features are `Available` (the whole-library parse gate passed at build
-    /// time), else `None`. Parsing the modified (not stripped) form preserves
-    /// the mod set the `n_mods` feature reads. Lazy decoys are mass-shift
-    /// decoys, so any non-target variant is `MassShiftedDecoy`.
-    pub fn materialize_peptide(&self) -> Peptide {
-        let tgt = self.geom.row();
-        let coll = &self.lib.geom;
-        let raw: Arc<str> = coll.seq_mod(tgt).into();
-        let decoy = if self.geom.variant() == 0 {
-            DecoyMarking::Target
-        } else {
-            DecoyMarking::MassShiftedDecoy
-        };
-        Peptide {
-            raw,
-            decoy,
-            sequence_features: coll.caps.sequence_features == SeqFeatureState::Available,
-        }
-    }
 }
 
 impl<'a> ExpectedIntensity for RefQuery<'a> {
@@ -254,8 +229,22 @@ impl<'a> ScoredIdentity for RefQuery<'a> {
         !self.lib.geom.is_decoy(tgt) && self.geom().variant() == 0
     }
 
+    /// `raw` is the modified-sequence blob slice; parsing is deferred to
+    /// `Peptide::parse` and gated on the whole-library parse check. The modified
+    /// (not stripped) form is what the `n_mods` feature reads. Lazy decoys are
+    /// mass-shift decoys, so any non-target variant is `MassShiftedDecoy`.
     fn materialize_peptide(&self) -> Peptide {
-        RefQuery::materialize_peptide(self)
+        let tgt = self.geom.row();
+        let coll = &self.lib.geom;
+        Peptide {
+            raw: coll.seq_mod(tgt).into(),
+            decoy: if self.geom.variant() == 0 {
+                DecoyMarking::Target
+            } else {
+                DecoyMarking::MassShiftedDecoy
+            },
+            sequence_features: coll.caps.sequence_features == SeqFeatureState::Available,
+        }
     }
 }
 
@@ -382,13 +371,10 @@ mod tests {
         let lib = tiny_ref_lib();
         let scored = lib.item_at(flat(&lib, 0));
         assert!(scored.is_target());
-        // flat 0 -> row 0, and the id it reports is resolved from the arena,
-        // not carried on the result.
-        let handles = scored.handles();
-        assert_eq!(handles.row, row(&lib, 0));
-        assert_eq!(handles.group, lib.geom.decoy_group_code(row(&lib, 0)));
+        // The id is not on the result; it resolves from the arena via the row
+        // the handles carry.
         assert_eq!(
-            lib.geom.output_id(handles.row),
+            lib.geom.output_id(scored.handles().row),
             timsquery::models::SourceId::Numeric(0)
         );
         let got_frags: Vec<(IonAnnot, f32)> = scored.iter_expected_fragments().collect();
diff --git a/rust/timsseek/src/ml/qvalues.rs b/rust/timsseek/src/ml/qvalues.rs
index 130a12a9..cb0f872c 100644
--- a/rust/timsseek/src/ml/qvalues.rs
+++ b/rust/timsseek/src/ml/qvalues.rs
@@ -1024,6 +1024,19 @@ mod feature_tests {
         ScoringFields::sample(peptide)
     }
 
+    /// Pairs each candidate with the score it got, sorted, so two runs are
+    /// comparable regardless of output order. Keyed on the arena row because
+    /// that is what `canonicalize_and_shuffle` sorts by, so a run that assigned
+    /// the same set of scores to different candidates still fails.
+    fn determinism_key(out: &[FinalResult]) -> Vec<(RowIdx, u32)> {
+        let mut v: Vec<(RowIdx, u32)> = out
+            .iter()
+            .map(|r| (r.scoring.identity.row, r.discriminant_score.to_bits()))
+            .collect();
+        v.sort_unstable();
+        v
+    }
+
     /// A target candidate over `PEPTIDEK` — 8 residues, no mods. With
     /// `sequence_features` set the sequence lanes carry those counts; without it
     /// they stay NaN, which is the only difference between the two cases.
@@ -1141,7 +1154,7 @@ mod feature_tests {
     }
 
     /// Build a non-degenerate synthetic candidate set: `n` rows, alternating
-    /// target/decoy, distinct `library_id`, with the LINEAR-lane count fields
+    /// target/decoy, distinct arena rows, with the LINEAR-lane count fields
     /// varied by label + row so the cross-fit LDA has real within-class scatter
     /// and a class-mean gap (i.e. it actually fits, exercising the score path).
     ///
@@ -1275,15 +1288,11 @@ mod feature_tests {
             assert!((0.0..=1.0).contains(&r.qvalue));
         }
 
-        let key = |out: &[FinalResult]| -> Vec<(RowIdx, u32)> {
-            let mut v: Vec<(RowIdx, u32)> = out
-                .iter()
-                .map(|r| (r.scoring.identity.row, r.discriminant_score.to_bits()))
-                .collect();
-            v.sort_unstable();
-            v
-        };
-        assert_eq!(key(&out_a), key(&out_b), "lda rescore not deterministic");
+        assert_eq!(
+            determinism_key(&out_a),
+            determinism_key(&out_b),
+            "lda rescore not deterministic"
+        );
     }
 
     #[test]
@@ -1457,14 +1466,6 @@ mod feature_tests {
     #[test]
     fn rescore_mlp_is_deterministic() {
         let n = 90;
-        let key = |out: &[FinalResult]| -> Vec<(RowIdx, u32)> {
-            let mut v: Vec<(RowIdx, u32)> = out
-                .iter()
-                .map(|r| (r.scoring.identity.row, r.discriminant_score.to_bits()))
-                .collect();
-            v.sort_unstable();
-            v
-        };
 
         for seed in [7u64, 13, 42, 1234] {
             let run = || rescore_mlp_with(synthetic_competed(n), mlp_test_cfg(seed));
@@ -1481,8 +1482,8 @@ mod feature_tests {
                 assert!((0.0..=1.0).contains(&r.qvalue));
             }
             assert_eq!(
-                key(&out_a),
-                key(&out_b),
+                determinism_key(&out_a),
+                determinism_key(&out_b),
                 "seed {seed}: mlp rescore not deterministic"
             );
 
@@ -1560,17 +1561,9 @@ mod feature_tests {
             );
         }
 
-        let key = |out: &[FinalResult]| -> Vec<(RowIdx, u32)> {
-            let mut v: Vec<(RowIdx, u32)> = out
-                .iter()
-                .map(|r| (r.scoring.identity.row, r.discriminant_score.to_bits()))
-                .collect();
-            v.sort_unstable();
-            v
-        };
         assert_eq!(
-            key(&out_a),
-            key(&out_b),
+            determinism_key(&out_a),
+            determinism_key(&out_b),
             "hybrid rescore not deterministic across runs"
         );
     }
diff --git a/rust/timsseek/src/scoring/blocks/identity.rs b/rust/timsseek/src/scoring/blocks/identity.rs
index b1132228..02a46f28 100644
--- a/rust/timsseek/src/scoring/blocks/identity.rs
+++ b/rust/timsseek/src/scoring/blocks/identity.rs
@@ -59,11 +59,9 @@ impl Identity {
 
     /// Whether two results compete: same decoy group, same charge.
     ///
-    /// Paired with [`Self::competition_key`], which is the key this is a
-    /// comparison of, so sorting by the key leaves competing results adjacent.
-    /// Competition previously spelled the sort key and the grouping predicate
-    /// separately; if those drifted, nothing failed and the groups were simply
-    /// wrong.
+    /// Defined in terms of [`Self::competition_key`], so sorting by that key
+    /// always leaves competing results adjacent — the predicate and the sort
+    /// order cannot drift apart.
     pub fn competes_with(&self, other: &Self) -> bool {
         self.competition_key() == other.competition_key()
     }
diff --git a/rust/timsseek/src/scoring/parquet_writer.rs b/rust/timsseek/src/scoring/parquet_writer.rs
index 068ae6ec..47c6fdaa 100644
--- a/rust/timsseek/src/scoring/parquet_writer.rs
+++ b/rust/timsseek/src/scoring/parquet_writer.rs
@@ -13,6 +13,7 @@ use std::path::Path;
 use std::sync::Arc;
 use timsquery::IonAnnot;
 use timsquery::models::{
+    RowIdx,
     SourceId,
     TargetColumns,
 };
@@ -20,6 +21,8 @@ use tracing::debug;
 
 use super::blocks::{
     ColSink,
+    NameSink,
+    SchemaSink,
     ScoreBlock,
 };
 use super::results::FinalResult;
@@ -34,18 +37,60 @@ use super::results::FinalResult;
 /// - 3: both became Utf8, because an id keeps the shape its source used and
 ///   DIA-NN names its precursors with a string (`transition_group_id`). A
 ///   numeric id is written as its digits.
+///
+/// `decoy_group_id` equals `library_id` on every row until a library format
+/// declares competition groups: no reader parses them today, so a row competes
+/// only with its own decoy variants and is its own group. The duplication is
+/// expected, not a bug.
 pub const RESULTS_FORMAT_VERSION: u32 = 3;
 
 // ---------------------------------------------------------------------------
 // Build a RecordBatch from a slice of FinalResult
 // ---------------------------------------------------------------------------
 
-/// Write one id column, without rendering a text id through `Display` first.
-fn emit_id(sink: &mut ColSink, name: &str, id: SourceId<'_>) {
-    match id {
-        SourceId::Text(s) => sink.str(name, s),
-        SourceId::Numeric(n) => sink.str(name, &n.to_string()),
+/// The ids a reader joins on, resolved from the arena.
+///
+/// A block rather than two hand-written `o.str` calls in `emit_row` plus two in
+/// `FinalResult::column_schema`: that split is exactly the schema/data drift
+/// `#[derive(ScoreBlock)]` exists to prevent. A block keeps the pair adjacent,
+/// so the two bodies cannot disagree about names, types, or order.
+///
+/// Hand-written, like `Identity`, because the derive works on owned scalar
+/// fields and these are borrowed from the arena.
+pub(crate) struct Ids<'a> {
+    library_id: SourceId<'a>,
+    decoy_group_id: SourceId<'a>,
+}
+
+impl<'a> Ids<'a> {
+    fn for_row(geom: &'a TargetColumns<IonAnnot>, row: RowIdx) -> Self {
+        Self {
+            library_id: geom.output_id(row),
+            decoy_group_id: geom.decoy_group(row),
+        }
+    }
+
+    /// A text id goes in borrowed; only a numeric one is rendered.
+    fn emit(o: &mut ColSink, name: &str, id: SourceId<'_>) {
+        match id {
+            SourceId::Text(s) => o.str(name, s),
+            SourceId::Numeric(n) => o.str(name, &n.to_string()),
+        }
+    }
+}
+
+impl ScoreBlock for Ids<'_> {
+    fn columns(&self, o: &mut ColSink) {
+        Self::emit(o, "library_id", self.library_id);
+        Self::emit(o, "decoy_group_id", self.decoy_group_id);
+    }
+
+    fn column_schema(o: &mut SchemaSink) {
+        o.str("library_id");
+        o.str("decoy_group_id");
     }
+
+    fn nonlinear_feature_names(_: &mut NameSink) {}
 }
 
 /// Emit one result's columns into the sink (all scoring blocks, then the
@@ -57,9 +102,7 @@ fn emit_id(sink: &mut ColSink, name: &str, id: SourceId<'_>) {
 fn emit_row(r: &FinalResult, geom: &TargetColumns<IonAnnot>, sink: &mut ColSink) {
     r.scoring.columns(sink);
     r.result_meta().columns(sink);
-    let row = r.scoring.identity.row;
-    emit_id(sink, "library_id", geom.output_id(row));
-    emit_id(sink, "decoy_group_id", geom.decoy_group(row));
+    Ids::for_row(geom, r.scoring.identity.row).columns(sink);
     sink.end_row();
 }
 
@@ -197,19 +240,27 @@ mod tests {
     use std::fs::File;
     use timsquery::models::capabilities::TargetCapabilities;
 
-    /// A one-row arena for the writer to resolve ids against.
-    fn one_row_arena() -> TargetColumns<IonAnnot> {
+    /// An unsealed arena holding one row per sequence, for the writer to
+    /// resolve ids against. Left unsealed so a caller can attach source ids.
+    fn arena_of(seqs: &[&str]) -> TargetColumns<IonAnnot> {
         let mut geom = TargetColumns::with_capabilities(TargetCapabilities::default_diann());
-        geom.push_target(
-            900.4,
-            2,
-            1.0,
-            1.0,
-            &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
-            "PEPTIDEK",
-            "PEPTIDEK",
-            &[],
-        );
+        for seq in seqs {
+            geom.push_target(
+                900.4,
+                2,
+                1.0,
+                1.0,
+                &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
+                seq,
+                seq,
+                &[],
+            );
+        }
+        geom
+    }
+
+    fn one_row_arena() -> TargetColumns<IonAnnot> {
+        let mut geom = arena_of(&["PEPTIDEK"]);
         geom.seal();
         geom
     }
@@ -262,22 +313,10 @@ mod tests {
     /// they still reach the file — and that the row a result points at is the
     /// row whose id gets written.
     #[test]
-    fn each_row_s_ids_are_resolved_from_the_arena() {
+    fn ids_resolve_from_the_arena_row() {
         use arrow::array::StringArray;
 
-        let mut geom = TargetColumns::with_capabilities(TargetCapabilities::default_diann());
-        for seq in ["PEPTIDEK", "AAAAAAALQAK"] {
-            geom.push_target(
-                900.4,
-                2,
-                1.0,
-                1.0,
-                &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
-                seq,
-                seq,
-                &[],
-            );
-        }
+        let mut geom = arena_of(&["PEPTIDEK", "AAAAAAALQAK"]);
         // The names DIA-NN would give these rows, which is the case that must
         // not come back as digits.
         geom.set_source_ids(["PEPTIDEK2", "AAAAAAALQAK2"])
diff --git a/rust/timsseek/src/scoring/results.rs b/rust/timsseek/src/scoring/results.rs
index d8a38a9b..83797080 100644
--- a/rust/timsseek/src/scoring/results.rs
+++ b/rust/timsseek/src/scoring/results.rs
@@ -207,18 +207,15 @@ impl FinalResult {
     }
 
     /// Value-free Parquet schema: scoring blocks (composition order), the
-    /// post-model meta block, then the ids — mirrors `emit_row`'s column order
-    /// exactly, which the writer's `schema_first_matches_populated_data_path`
-    /// test pins.
+    /// post-model meta block, then the ids — the same three blocks `emit_row`
+    /// writes, in the same order.
     ///
-    /// The ids are declared here rather than in the `Identity` block because
-    /// they are not on the result: `emit_row` resolves them from the arena. A
-    /// column added here needs the matching `emit_id` there, in this position.
+    /// The ids are their own block because they are not on the result; the
+    /// writer resolves them from the arena. See `parquet_writer::Ids`.
     pub fn column_schema(o: &mut SchemaSink) {
         <ScoringFields as ScoreBlock>::column_schema(o);
         <ResultMeta as ScoreBlock>::column_schema(o);
-        o.str("library_id");
-        o.str("decoy_group_id");
+        <crate::scoring::parquet_writer::Ids<'_> as ScoreBlock>::column_schema(o);
     }
 }
 
diff --git a/rust/timsseek_cli/src/processing.rs b/rust/timsseek_cli/src/processing.rs
index b0b09bc3..653ff54c 100644
--- a/rust/timsseek_cli/src/processing.rs
+++ b/rust/timsseek_cli/src/processing.rs
@@ -95,6 +95,7 @@ mod calib_dash_hook {
             Hasher,
         };
         use std::io::IsTerminal;
+        use timsquery::models::FlatIdx;
 
         /// The dashboard compares calibrant identity across batches but never
         /// displays it, so it takes a hash of the arena handle rather than the
@@ -102,9 +103,12 @@ mod calib_dash_hook {
         /// more importantly, keeps `size_of` the true cost of a point — which is
         /// what its replay memory budget is computed from. Only meaningful
         /// within one process.
-        fn identity_hash(handle: impl Hash) -> u64 {
+        ///
+        /// Concrete in `FlatIdx` rather than `impl Hash`, which would also
+        /// accept `score.to_bits()` — compiles, means nothing.
+        fn identity_hash(slot: FlatIdx) -> u64 {
             let mut hasher = DefaultHasher::new();
-            handle.hash(&mut hasher);
+            slot.hash(&mut hasher);
             hasher.finish()
         }
 

From 5518c2aa8675017b7a2cc4b520acceb87e21c94e Mon Sep 17 00:00:00 2001
From: "J. Sebastian Paez" <jspaezp@gmail.com>
Date: Fri, 28 Aug 2026 07:58:03 -0700
Subject: [PATCH 17/19] refactor(timsquery): push a row's id with the row

A row could be stored without its name and the names zipped on afterwards by
position. That is why `6451904` had a bug to fix: `mzpaf_with_intensities`
sealed before attaching the ids, so `seal` minted `0..n` over the names the
reader had just parsed.

`push_row` now takes a `Row` struct carrying `id: Option<OwnedSourceId>`, and
`seal` builds the id column from what the rows arrived with. The whole
attach-afterwards layer goes:

- `set_source_ids` and `library_file::seal_with_source_ids` are deleted, along
  with the doc comment that had to explain the bug to justify fusing them.
- `push_target` is deleted; `Row`'s `Default` covers the optional half, so the
  `// precursor_mz` comments annotating positional args at call sites go too.
- `.speclib`'s rayon accumulator loses its fifth element and `map_entry` loses
  a `&mut Vec<String>` out-param -- the names ride with their rows now.
- `append_arena` merges ids like any other column, so its "deliberately not
  merged" carve-out goes.
- `Target::set_id`, a `pub(crate)` mutator added only for the post-pass, is
  gone and `Target.id` is read-only again.

`seal` is fallible, because building the id column is what rejects a duplicate
or a mixed-shape library. It stays idempotent: timsseek seals a second time
after stamping the decoy strategy, and the id column is built by the first
call.

DIA-NN naming is now decided per file rather than inferred per row. Whether the
`transition_group_id` / `Precursor.Id` column exists is read once from the
header (`csv::Reader::headers()` caches and consumes no record); if it does,
every row must have a name and a blank cell is an error. That deletes
`unify_source_ids`, `is_named` and `first_unnamed`, and removes the implicit
"numeric means unnamed" encoding -- which held only as long as DIA-NN spells
its ids as text, and would have read a named row as unnamed the day one
writes integers. A file with no name column is unaffected: minted ids, as
before.

The native speclib reader was the fifth path and still discarded the id it
held. `ReferenceEG::id` and `PrecursorEntry::decoy_group` were both parsed and
never read; both are now carried, which also gives `set_decoy_groups` its
first non-test caller.

`OwnedSourceId::Default` (`Numeric(0)`) is replaced by an explicit
`placeholder()`. Every `u64` is a valid id, so a numeric placeholder that
leaked looked like a real result keyed on 0 -- the same reason
`RowIdx::default()` is `u32::MAX`. It is `Text` so the scratch buffer's first
`set_from` reuses the allocation rather than making one.

Closes review items 2, 3 and 4.
---
 rust/apex_sim/src/sim.rs                      |   2 +-
 .../src/models/aggregators/spectrum_agg.rs    |   2 +-
 rust/timsquery/src/models/mod.rs              |   1 +
 rust/timsquery/src/models/query_handle.rs     |  50 +--
 rust/timsquery/src/models/source_id.rs        |  17 +-
 rust/timsquery/src/models/target.rs           |   6 +-
 rust/timsquery/src/models/target_columns.rs   | 383 ++++++++++--------
 rust/timsquery/src/serde/diann_io.rs          | 209 ++++++----
 rust/timsquery/src/serde/diann_speclib_io.rs  |  76 ++--
 rust/timsquery/src/serde/library_file.rs      |  92 ++---
 rust/timsquery_viewer/src/file_loader.rs      |  27 +-
 .../src/data_sources/reference_library.rs     |  47 +--
 rust/timsseek/src/data_sources/speclib.rs     |  67 +--
 rust/timsseek/src/errors.rs                   |  11 +
 rust/timsseek/src/scoring/parquet_writer.rs   |  43 +-
 rust/timsseek/src/scoring/pipeline.rs         |  27 +-
 16 files changed, 583 insertions(+), 477 deletions(-)

diff --git a/rust/apex_sim/src/sim.rs b/rust/apex_sim/src/sim.rs
index e77c472d..30734543 100644
--- a/rust/apex_sim/src/sim.rs
+++ b/rust/apex_sim/src/sim.rs
@@ -341,7 +341,7 @@ pub fn build(params: &SimParams) -> SimData {
         TupleRange::try_new(map(0), map(n - 1)).expect("start < end for positive period");
 
     let chromatograms = ChromatogramCollector::<String, f32> {
-        id: OwnedSourceId::default(),
+        id: OwnedSourceId::placeholder(),
         mobility_ook0: 1.0,
         rt_seconds: (map((realized_apex as usize).min(n - 1)) as f32) / 1000.0,
         precursor_mono_mz: dummy_mz,
diff --git a/rust/timsquery/src/models/aggregators/spectrum_agg.rs b/rust/timsquery/src/models/aggregators/spectrum_agg.rs
index 8e7c70f7..c50af072 100644
--- a/rust/timsquery/src/models/aggregators/spectrum_agg.rs
+++ b/rust/timsquery/src/models/aggregators/spectrum_agg.rs
@@ -53,7 +53,7 @@ pub struct SpectralCollector<T: KeyLike, V: Default + ValueLike> {
 impl<T: KeyLike, V: ValueLike + Default> SpectralCollector<T, V> {
     pub fn new(eg: &impl QueryGeom<Label = T>) -> Self {
         let mut out = Self {
-            id: crate::models::OwnedSourceId::default(),
+            id: crate::models::OwnedSourceId::placeholder(),
             mobility_ook0: 0.0,
             rt_seconds: 0.0,
             precursor_mono_mz: 0.0,
diff --git a/rust/timsquery/src/models/mod.rs b/rust/timsquery/src/models/mod.rs
index 6d486550..82b4596d 100644
--- a/rust/timsquery/src/models/mod.rs
+++ b/rust/timsquery/src/models/mod.rs
@@ -38,6 +38,7 @@ pub use target_columns::{
     FlatIdx,
     GroupCode,
     ModDefinition,
+    Row,
     RowIdx,
     TargetColumns,
 };
diff --git a/rust/timsquery/src/models/query_handle.rs b/rust/timsquery/src/models/query_handle.rs
index 37bab1cb..93217f12 100644
--- a/rust/timsquery/src/models/query_handle.rs
+++ b/rust/timsquery/src/models/query_handle.rs
@@ -174,6 +174,7 @@ mod tests {
     use crate::models::TargetColumns;
     use crate::models::capabilities::*;
     use crate::models::source_id::SourceId;
+    use crate::models::target_columns::Row;
     use crate::traits::QueryGeom;
 
     /// Rows come from the arena; there is no constructor from an integer.
@@ -205,20 +206,20 @@ mod tests {
                 n_decoys: 2,
             },
         });
-        c.push_target(
-            654.855,
-            2,
-            1.0,
-            1.0,
-            &[
+        c.push_row(Row {
+            precursor_mz: 654.855,
+            charge: 2,
+            rt_seconds: 1.0,
+            mobility: 1.0,
+            frags: &[
                 (IonAnnot::try_from("y1").unwrap(), 200.0), // ordinal 1 -> NOT shifted
-                (IonAnnot::try_from("y8").unwrap(), 896.5),
-            ], // ordinal 8 -> shifted
-            "PEPTIDEK",
-            "PEPTIDEK",
-            &[],
-        );
-        c.seal();
+                (IonAnnot::try_from("y8").unwrap(), 896.5), // ordinal 8 -> shifted
+            ],
+            seq_strip: "PEPTIDEK",
+            seq_mod: "PEPTIDEK",
+            ..Default::default()
+        });
+        c.seal().expect("fixture ids are usable");
         c
     }
 
@@ -281,18 +282,17 @@ mod tests {
             isotopes: IsotopeStrategy::FromComposition { n_isotopes: 3 },
             decoys: DecoyStrategy::None,
         });
-        c.push_row(
-            500.0,
-            2,
-            1.0,
-            1.0,
-            &[(Arc::<str>::from("f"), 300.0)],
-            "PEP",
-            "PEP",
-            &[],
-            false,
-        );
-        c.seal();
+        c.push_row(Row {
+            precursor_mz: 500.0,
+            charge: 2,
+            rt_seconds: 1.0,
+            mobility: 1.0,
+            frags: &[(Arc::<str>::from("f"), 300.0)],
+            seq_strip: "PEP",
+            seq_mod: "PEP",
+            ..Default::default()
+        });
+        c.seal().expect("fixture ids are usable");
         let q = Query::new(&c, c.flat_for(first_row(&c), 0));
         let frags: Vec<_> = q.iter_fragments_refs().collect();
         assert!((frags[0].1 - 300.0).abs() < 1e-9);
diff --git a/rust/timsquery/src/models/source_id.rs b/rust/timsquery/src/models/source_id.rs
index 5bf981ce..f2043652 100644
--- a/rust/timsquery/src/models/source_id.rs
+++ b/rust/timsquery/src/models/source_id.rs
@@ -100,9 +100,20 @@ impl From<&str> for OwnedSourceId {
     }
 }
 
-impl Default for OwnedSourceId {
-    fn default() -> Self {
-        Self::Numeric(0)
+impl OwnedSourceId {
+    /// For a scratch buffer that is refilled before it is read (see
+    /// [`crate::Target::empty_like`]).
+    ///
+    /// Deliberately not `Default`, and deliberately not `Numeric(0)`: every
+    /// `u64` is a valid id, so a numeric placeholder that leaked would look
+    /// exactly like a real result keyed on 0 — the same reason
+    /// `RowIdx::default()` is `u32::MAX` rather than 0. This one is visible in
+    /// any output that would wrongly carry it.
+    ///
+    /// It is `Text` so the first [`Self::set_from`] with a text id reuses this
+    /// allocation instead of making one; a `Numeric` placeholder could not.
+    pub fn placeholder() -> Self {
+        Self::Text("<unset>".to_string())
     }
 }
 
diff --git a/rust/timsquery/src/models/target.rs b/rust/timsquery/src/models/target.rs
index e7d45873..1dbf1259 100644
--- a/rust/timsquery/src/models/target.rs
+++ b/rust/timsquery/src/models/target.rs
@@ -90,7 +90,7 @@ impl<T: KeyLike + Default> Target<T> {
     /// every query, so the zeroed initial state is never observed.
     pub fn empty_like() -> Self {
         Self {
-            id: Default::default(),
+            id: crate::models::OwnedSourceId::placeholder(),
             mobility_ook0: 0.0,
             rt_seconds: 0.0,
             precursor_mono_mz: 0.0,
@@ -107,10 +107,6 @@ impl<T: KeyLike> Target<T> {
         self.id.as_ref()
     }
 
-    pub(crate) fn set_id(&mut self, id: crate::models::OwnedSourceId) {
-        self.id = id;
-    }
-
     pub fn precursor_count(&self) -> usize {
         self.precursor_labels.len()
     }
diff --git a/rust/timsquery/src/models/target_columns.rs b/rust/timsquery/src/models/target_columns.rs
index ac3fadf9..b699f58e 100644
--- a/rust/timsquery/src/models/target_columns.rs
+++ b/rust/timsquery/src/models/target_columns.rs
@@ -135,6 +135,64 @@ pub struct DecoyGroups {
     labels: SourceIds,
 }
 
+/// One row's worth of input to [`TargetColumns::push_row`].
+///
+/// A struct rather than ten positional arguments, and it carries the row's `id`,
+/// which is the point: a row cannot be stored apart from the name its file gave
+/// it. Attaching ids afterwards, zipped on by position, is how the DIA-NN names
+/// got dropped -- `seal` minted `0..n` over them.
+///
+/// `Default` covers the optional half, so a caller names only what it has:
+///
+/// ```ignore
+/// geom.push_row(Row {
+///     precursor_mz: 900.4,
+///     charge: 2,
+///     rt_seconds: 1.0,
+///     mobility: 0.8,
+///     frags: &frags,
+///     seq_mod: "PEPTIDEK",
+///     ..Default::default()
+/// });
+/// ```
+#[derive(Debug, Clone)]
+pub struct Row<'a, L: KeyLike> {
+    pub precursor_mz: f64,
+    pub charge: u8,
+    pub rt_seconds: f32,
+    pub mobility: f32,
+    pub frags: &'a [(L, f64)],
+    pub seq_strip: &'a str,
+    pub seq_mod: &'a str,
+    pub mods: &'a [(u8, u16)],
+    /// A stored decoy, as opposed to one the arena derives. Default `false`:
+    /// timsquery never invents a decoy, so a row is a target unless its reader
+    /// says otherwise.
+    pub is_decoy: bool,
+    /// What the source file called this row, in the shape it used. `None` for a
+    /// format that names nothing (Spectronaut, Skyline), and for a row whose
+    /// name cell was blank. [`TargetColumns::seal`] mints ids only when *every*
+    /// row arrived `None`.
+    pub id: Option<OwnedSourceId>,
+}
+
+impl<L: KeyLike> Default for Row<'_, L> {
+    fn default() -> Self {
+        Self {
+            precursor_mz: 0.0,
+            charge: 0,
+            rt_seconds: 0.0,
+            mobility: 0.0,
+            frags: &[],
+            seq_strip: "",
+            seq_mod: "",
+            mods: &[],
+            is_decoy: false,
+            id: None,
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct ModDefinition {
     pub token: String, // verbatim, e.g. "[UNIMOD:4]"
@@ -153,9 +211,16 @@ pub struct TargetColumns<L: KeyLike> {
     pub(crate) mobility: Vec<f32>,
     // per-row decoy flag (len = n_rows)
     pub(crate) is_decoy: Vec<bool>,
+    /// Each row's id as it was pushed, before [`Self::seal`] decides what the
+    /// column becomes. Parallel to the row columns, and merged by
+    /// [`Self::append_arena`] like any other, so a shard cannot separate a row
+    /// from its name.
+    ///
+    /// Emptied by `seal`, which is the only reader.
+    pub(crate) pending_ids: Vec<Option<OwnedSourceId>>,
     /// What the source file called each row, when it said. Parallel to the row
-    /// columns. Minted at [`Self::seal`] for formats that carry no ids, so a
-    /// sealed arena always has one per row.
+    /// columns. Built at [`Self::seal`] from `pending_ids`, minted there for
+    /// formats that carry no ids, so a sealed arena always has one per row.
     pub(crate) source_ids: SourceIds,
     /// The competition groups the input declared, interned: a code per row,
     /// plus the labels those codes point at. Rows that compete share a code, so
@@ -191,6 +256,7 @@ impl<L: KeyLike> TargetColumns<L> {
             rt_seconds: Vec::new(),
             mobility: Vec::new(),
             is_decoy: Vec::new(),
+            pending_ids: Vec::new(),
             source_ids: SourceIds::default(),
             decoy_groups: None,
             frag_off: vec![0],
@@ -209,22 +275,24 @@ impl<L: KeyLike> TargetColumns<L> {
     /// Append one row. `mods` are (position, registry_idx) pairs; the caller
     /// is responsible for having registered the mod tokens in `mod_registry`.
     #[allow(clippy::too_many_arguments)]
-    pub fn push_row(
-        &mut self,
-        precursor_mz: f64,
-        charge: u8,
-        rt_seconds: f32,
-        mobility: f32,
-        frags: &[(L, f64)],
-        seq_strip: &str,
-        seq_mod: &str,
-        mods: &[(u8, u16)],
-        is_decoy: bool,
-    ) {
+    pub fn push_row(&mut self, row: Row<'_, L>) {
+        let Row {
+            precursor_mz,
+            charge,
+            rt_seconds,
+            mobility,
+            frags,
+            seq_strip,
+            seq_mod,
+            mods,
+            is_decoy,
+            id,
+        } = row;
         self.precursor_mz.push(precursor_mz);
         self.charge.push(charge);
         self.rt_seconds.push(rt_seconds);
         self.mobility.push(mobility);
+        self.pending_ids.push(id);
         for (lab, mz) in frags {
             self.frag_labels.push(lab.clone());
             self.frag_mzs.push(*mz);
@@ -252,31 +320,6 @@ impl<L: KeyLike> TargetColumns<L> {
     }
 
     /// Append one target (defaults `is_decoy = false`).
-    #[allow(clippy::too_many_arguments)]
-    pub fn push_target(
-        &mut self,
-        precursor_mz: f64,
-        charge: u8,
-        rt_seconds: f32,
-        mobility: f32,
-        frags: &[(L, f64)],
-        seq_strip: &str,
-        seq_mod: &str,
-        mods: &[(u8, u16)],
-    ) {
-        self.push_row(
-            precursor_mz,
-            charge,
-            rt_seconds,
-            mobility,
-            frags,
-            seq_strip,
-            seq_mod,
-            mods,
-            false,
-        );
-    }
-
     /// Number of *physical stored rows*, i.e. how many analytes are held in
     /// memory before decoy expansion. Under `LazyMassShift` every row is a
     /// target; under `Passthrough` the count includes any stored decoy rows.
@@ -285,18 +328,6 @@ impl<L: KeyLike> TargetColumns<L> {
         self.charge.len()
     }
 
-    /// Attach the ids the file gave its rows, in whichever shape it used.
-    /// Call after every `push_row`, before `seal`.
-    pub fn set_source_ids<I, S>(&mut self, ids: I) -> Result<(), SourceIdError>
-    where
-        I: IntoIterator<Item = S>,
-        S: Into<OwnedSourceId>,
-    {
-        let ids: Vec<OwnedSourceId> = ids.into_iter().map(Into::into).collect();
-        self.source_ids = SourceIds::owned(ids, self.n_rows())?;
-        Ok(())
-    }
-
     /// The rows of this arena, in storage order.
     pub fn rows(&self) -> impl Iterator<Item = RowIdx> + use<L> {
         (0..self.n_rows() as u32).map(RowIdx::new)
@@ -455,15 +486,58 @@ impl<L: KeyLike> TargetColumns<L> {
     /// on-the-fly ±CH2 index transform, never stored). If the library shipped
     /// materialized decoys, downgrade to `Passthrough` so the stored rows are
     /// honored 1:1 instead of being silently re-decoyed.
-    pub fn seal(&mut self) {
+    /// Fails when the pushed ids cannot make a column: two rows sharing an id
+    /// (a caller keys results by it, so a repeat hides a row), or a library
+    /// mixing numeric and text ids (storing both would coerce the numbers to
+    /// strings, and `7` and `"7"` would become two ids in one column).
+    pub fn seal(&mut self) -> Result<(), SourceIdError> {
+        // Sealing twice is normal: a reader seals the arena it built, and
+        // timsseek seals again after stamping the decoy strategy onto `caps`.
+        // The id column is built by the first call, which drains `pending_ids`.
         if matches!(self.source_ids, SourceIds::Absent) {
-            let n = self.n_rows();
-            tracing::warn!(
-                "input carries no per-target id; minting {n} self-incremental ids (0..{n}). \
-                 Result ids are ours, not the input file's."
-            );
-            self.source_ids = SourceIds::minted(n);
+            self.build_source_ids()?;
         }
+        self.apply_decoy_downgrades();
+        self.shrink();
+        Ok(())
+    }
+
+    fn build_source_ids(&mut self) -> Result<(), SourceIdError> {
+        let n = self.n_rows();
+        debug_assert_eq!(self.pending_ids.len(), n, "an id per row, or none");
+        let named = self.pending_ids.iter().filter(|id| id.is_some()).count();
+        self.source_ids = if named == n {
+            SourceIds::owned(self.pending_ids.drain(..).map(Option::unwrap).collect(), n)?
+        } else {
+            if named > 0 {
+                // A library names all its rows or none. One blank cell costs the
+                // whole library its names, so say which row did it -- minting
+                // overwrites every id, leaving nothing to trace it from.
+                let row = self
+                    .pending_ids
+                    .iter()
+                    .position(Option::is_none)
+                    .expect("named < n, so some row is unnamed");
+                tracing::warn!(
+                    "{named} of {n} rows carry an id and {} do not, so the whole library falls \
+                     back to minted ids: results will be keyed by row number instead of the \
+                     names the file gave. First unnamed row is {row}.",
+                    n - named,
+                );
+            } else {
+                tracing::warn!(
+                    "input carries no per-target id; minting {n} self-incremental ids (0..{n}). \
+                     Result ids are ours, not the input file's."
+                );
+            }
+            self.pending_ids.clear();
+            SourceIds::minted(n)
+        };
+        self.pending_ids.shrink_to_fit();
+        Ok(())
+    }
+
+    fn apply_decoy_downgrades(&mut self) {
         // Nothing to build when no groups were declared: a row is then its own
         // group, which `decoy_group_code` derives. Only the case that actually
         // loses information is worth a word.
@@ -479,6 +553,9 @@ impl<L: KeyLike> TargetColumns<L> {
             tracing::warn!("library ships decoys; downgrading LazyMassShift -> Passthrough");
             self.caps.decoys = DecoyStrategy::Passthrough;
         }
+    }
+
+    fn shrink(&mut self) {
         self.precursor_mz.shrink_to_fit();
         self.charge.shrink_to_fit();
         self.rt_seconds.shrink_to_fit();
@@ -589,16 +666,16 @@ mod tests {
     fn two_rows() -> TargetColumns<IonAnnot> {
         let mut c = TargetColumns::with_capabilities(TargetCapabilities::default_diann());
         for _ in 0..2 {
-            c.push_target(
-                500.0,
-                2,
-                1.0,
-                0.8,
-                &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
-                "PEP",
-                "PEP",
-                &[],
-            );
+            c.push_row(Row {
+                precursor_mz: 500.0,
+                charge: 2,
+                rt_seconds: 1.0,
+                mobility: 0.8,
+                frags: &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
+                seq_strip: "PEP",
+                seq_mod: "PEP",
+                ..Default::default()
+            });
         }
         c
     }
@@ -609,7 +686,7 @@ mod tests {
     fn rows_in_one_declared_group_share_a_code() {
         let mut c = two_rows();
         c.set_decoy_groups(["g1", "g1"]).unwrap();
-        c.seal();
+        c.seal().expect("fixture ids are usable");
 
         let (a, b) = (c.rows().next().unwrap(), c.rows().nth(1).unwrap());
         assert_eq!(c.decoy_group_code(a), c.decoy_group_code(b));
@@ -621,7 +698,7 @@ mod tests {
     #[test]
     fn undeclared_groups_are_derived_not_stored() {
         let mut c = two_rows();
-        c.seal();
+        c.seal().expect("fixture ids are usable");
 
         let (a, b) = (c.rows().next().unwrap(), c.rows().nth(1).unwrap());
         assert!(c.decoy_groups.is_none(), "nothing stored for minted groups");
@@ -640,7 +717,7 @@ mod tests {
     fn seal_mints_ids_when_the_input_carried_none() {
         let mut c = two_rows();
         assert_eq!(c.source_id(RowIdx::new(0)), None);
-        c.seal();
+        c.seal().expect("fixture ids are usable");
         assert_eq!(c.output_id(RowIdx::new(0)), SourceId::Numeric(0));
         assert_eq!(c.output_id(RowIdx::new(1)), SourceId::Numeric(1));
     }
@@ -648,17 +725,17 @@ mod tests {
     #[test]
     fn lazy_massshift_expands_len_and_flags_targets() {
         let mut c = TargetColumns::with_capabilities(TargetCapabilities::test_lazy_decoys());
-        c.push_target(
-            500.0,
-            2,
-            1.0,
-            0.8,
-            &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
-            "PEP",
-            "PEP",
-            &[],
-        );
-        c.seal();
+        c.push_row(Row {
+            precursor_mz: 500.0,
+            charge: 2,
+            rt_seconds: 1.0,
+            mobility: 0.8,
+            frags: &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
+            seq_strip: "PEP",
+            seq_mod: "PEP",
+            ..Default::default()
+        });
+        c.seal().expect("fixture ids are usable");
         assert_eq!(c.variants_per_row(), 3);
         assert_eq!(c.expanded_len(), 3);
         assert!(c.is_target(FlatIdx::new(0))); // variant 0
@@ -672,29 +749,28 @@ mod tests {
         let mut caps = TargetCapabilities::default_diann();
         caps.decoys = DecoyStrategy::Passthrough;
         let mut c = TargetColumns::with_capabilities(caps);
-        c.push_row(
-            500.0,
-            2,
-            1.0,
-            0.8,
-            &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
-            "PEP",
-            "PEP",
-            &[],
-            false,
-        );
-        c.push_row(
-            510.0,
-            2,
-            1.0,
-            0.8,
-            &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
-            "PEP",
-            "PEP",
-            &[],
-            true,
-        );
-        c.seal();
+        c.push_row(Row {
+            precursor_mz: 500.0,
+            charge: 2,
+            rt_seconds: 1.0,
+            mobility: 0.8,
+            frags: &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
+            seq_strip: "PEP",
+            seq_mod: "PEP",
+            ..Default::default()
+        });
+        c.push_row(Row {
+            precursor_mz: 510.0,
+            charge: 2,
+            rt_seconds: 1.0,
+            mobility: 0.8,
+            frags: &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
+            seq_strip: "PEP",
+            seq_mod: "PEP",
+            is_decoy: true,
+            ..Default::default()
+        });
+        c.seal().expect("fixture ids are usable");
         assert_eq!(c.variants_per_row(), 1);
         assert_eq!(c.expanded_len(), 2);
         assert!(c.is_target(FlatIdx::new(0)));
@@ -705,42 +781,34 @@ mod tests {
     fn csr_ranges_recover_per_target_fragments() {
         let mut c = TargetColumns::with_capabilities(TargetCapabilities::default_diann());
         // target 0: 2 frags; target 1: 3 frags
-        c.push_target(
-            // precursor_mz
-            500.0,
-            // charge
-            2,
-            // rt
-            1.0,
-            // mob
-            0.8,
-            // frags
-            &[
+        c.push_row(Row {
+            precursor_mz: 500.0,
+            charge: 2,
+            rt_seconds: 1.0,
+            mobility: 0.8,
+            frags: &[
                 (IonAnnot::try_from("y3").unwrap(), 300.0),
                 (IonAnnot::try_from("y4").unwrap(), 400.0),
             ],
-            // strip
-            "PEPTIDEK",
-            // modified
-            "PEPTIDEK",
-            // mods
-            &[],
-        );
-        c.push_target(
-            600.0,
-            3,
-            2.0,
-            0.9,
-            &[
+            seq_strip: "PEPTIDEK",
+            seq_mod: "PEPTIDEK",
+            ..Default::default()
+        });
+        c.push_row(Row {
+            precursor_mz: 600.0,
+            charge: 3,
+            rt_seconds: 2.0,
+            mobility: 0.9,
+            frags: &[
                 (IonAnnot::try_from("y2").unwrap(), 200.0),
                 (IonAnnot::try_from("y5").unwrap(), 500.0),
                 (IonAnnot::try_from("y6").unwrap(), 600.0),
             ],
-            "SAMPLERK",
-            "SAMPLERK",
-            &[],
-        );
-        c.seal();
+            seq_strip: "SAMPLERK",
+            seq_mod: "SAMPLERK",
+            ..Default::default()
+        });
+        c.seal().expect("fixture ids are usable");
         assert_eq!(c.n_rows(), 2);
         assert_eq!(c.frag_range(RowIdx::new(0)), 0..2);
         assert_eq!(c.frag_range(RowIdx::new(1)), 2..5);
@@ -760,31 +828,28 @@ mod tests {
         use std::sync::Arc;
         let mut c: TargetColumns<Arc<str>> =
             TargetColumns::with_capabilities(TargetCapabilities::default_diann());
-        c.push_row(
-            500.0,
-            2,
-            1.0,
-            0.8,
-            &[(Arc::<str>::from("frag_a"), 300.0)],
-            "PEP",
-            "PEP",
-            &[],
-            // is_decoy
-            false,
-        );
-        c.push_row(
-            600.0,
-            2,
-            1.0,
-            0.8,
-            &[(Arc::<str>::from("frag_b"), 400.0)],
-            "TIDE",
-            "TIDE",
-            &[],
-            // is_decoy
-            true,
-        );
-        c.seal();
+        c.push_row(Row {
+            precursor_mz: 500.0,
+            charge: 2,
+            rt_seconds: 1.0,
+            mobility: 0.8,
+            frags: &[(Arc::<str>::from("frag_a"), 300.0)],
+            seq_strip: "PEP",
+            seq_mod: "PEP",
+            ..Default::default()
+        });
+        c.push_row(Row {
+            precursor_mz: 600.0,
+            charge: 2,
+            rt_seconds: 1.0,
+            mobility: 0.8,
+            frags: &[(Arc::<str>::from("frag_b"), 400.0)],
+            seq_strip: "TIDE",
+            seq_mod: "TIDE",
+            is_decoy: true,
+            ..Default::default()
+        });
+        c.seal().expect("fixture ids are usable");
         assert_eq!(c.n_rows(), 2);
         assert_eq!(c.is_decoy, vec![false, true]);
         assert_eq!(
diff --git a/rust/timsquery/src/serde/diann_io.rs b/rust/timsquery/src/serde/diann_io.rs
index 00c38dcb..826519e8 100644
--- a/rust/timsquery/src/serde/diann_io.rs
+++ b/rust/timsquery/src/serde/diann_io.rs
@@ -3,10 +3,7 @@ use crate::ion::{
     IonAnnot,
     IonParsingError,
 };
-use crate::models::{
-    OwnedSourceId,
-    SourceId,
-};
+use crate::models::OwnedSourceId;
 use arrow::array::{
     Float32Array,
     Float64Array,
@@ -53,6 +50,9 @@ impl std::error::Error for DiannReadingError {}
 #[derive(Debug)]
 pub enum DiannPrecursorParsingError {
     IonParsingError,
+    /// A library that names its other precursors left this one blank. See
+    /// [`Naming`].
+    UnnamedPrecursor,
     IonOverCapacity,
     EmptyIonString,
     Other,
@@ -287,6 +287,17 @@ pub fn read_targets<T: AsRef<Path>>(
 
     info!("Reading file content from {}", file.as_ref().display());
 
+    // Whether the file names its precursors is a property of the file, so read
+    // it once from the header. `headers()` caches and consumes no record, so
+    // the streaming loop below is unaffected. Asking per row cannot answer this:
+    // csv maps an empty cell to `visit_none`, so a `None` there means "blank
+    // cell" and "column absent" alike.
+    let naming = if rdr.headers()?.iter().any(|h| h == "transition_group_id") {
+        Naming::Present
+    } else {
+        Naming::Absent
+    };
+
     // Optimization: Stream rows and group adjacent ones instead of loading everything into memory
     let mut elution_groups = Vec::new();
     let mut current_group: Vec<DiannLibraryRow> = Vec::with_capacity(20);
@@ -304,7 +315,7 @@ pub fn read_targets<T: AsRef<Path>>(
             && !row.is_same_precursor(last_row)
         {
             // New group found, parse the collected group
-            let eg = parse_precursor_group(group_id, &current_group, &mut buffers)?;
+            let eg = parse_precursor_group(group_id, naming, &current_group, &mut buffers)?;
             elution_groups.push(eg);
 
             // Start new group
@@ -317,61 +328,62 @@ pub fn read_targets<T: AsRef<Path>>(
 
     // Process the last group
     if !current_group.is_empty() {
-        let eg = parse_precursor_group(group_id, &current_group, &mut buffers)?;
+        let eg = parse_precursor_group(group_id, naming, &current_group, &mut buffers)?;
         elution_groups.push(eg);
     }
 
-    unify_source_ids(&mut elution_groups);
     info!("Parsed {} elution groups", elution_groups.len());
     Ok(elution_groups)
 }
 
-/// A DIA-NN library names every precursor or none of them. A file that names
-/// only some is malformed (a blank `transition_group_id` cell, say), and the
-/// arena cannot hold both shapes at once, so fall the whole file back to minted
-/// ids rather than half-labelling it.
+/// Whether a DIA-NN file names its precursors at all, and what to do with a row
+/// that breaks the promise.
 ///
-/// The check is library-wide, so the warning names the precursor that triggered
-/// the fallback; without that a caller cannot act on it.
-fn unify_source_ids(egs: &mut [(Target<IonAnnot>, DiannPrecursorExtras)]) {
-    let named = egs.iter().filter(|(eg, _)| is_named(eg)).count();
-    if named == 0 || named == egs.len() {
-        return;
-    }
-    let total = egs.len();
-    let (index, extras) = first_unnamed(egs).expect("named < total, so some precursor is unnamed");
-    warn!(
-        "{named} of {total} DIA-NN precursors carry a name and {} do not, so the whole \
-         library falls back to minted ids: every result's `library_id` will be a row \
-         number instead of the name the file gave it. The first unnamed one is precursor \
-         {index}, {:?} — fill in its `transition_group_id` / `Precursor.Id` to keep the \
-         file's own names.",
-        total - named,
-        extras,
-    );
-    for (i, (eg, _)) in egs.iter_mut().enumerate() {
-        eg.set_id(OwnedSourceId::Numeric(i as u64));
-    }
-}
-
-fn is_named(eg: &Target<IonAnnot>) -> bool {
-    matches!(eg.id(), SourceId::Text(_))
+/// The column is per *file*, not per row: absent means the whole library is
+/// unnamed and every row is keyed by a minted counter. Present means every row
+/// must have a name — a blank cell is an error, not a row to quietly downgrade,
+/// because a half-named library cannot be stored (the arena holds one id shape)
+/// and silently renumbering the named rows loses information the file had.
+///
+/// Deciding per file is also what keeps "unnamed" from being inferred from an
+/// id's *shape*. Inferring it works only as long as DIA-NN spells
+/// `transition_group_id` as text; the day one writes integers, a named row would
+/// read as unnamed.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum Naming {
+    /// No `transition_group_id` / `Precursor.Id` column at all.
+    Absent,
+    Present,
 }
 
-/// The first precursor the file left unnamed, as `(index, modified peptide)`.
-///
-/// Split out from the warning so what it reports is testable: the fallback
-/// rewrites every id, so by the time a caller sees the library there is nothing
-/// left to identify the row from.
-fn first_unnamed(egs: &[(Target<IonAnnot>, DiannPrecursorExtras)]) -> Option<(usize, &str)> {
-    egs.iter()
-        .enumerate()
-        .find(|(_, (eg, _))| !is_named(eg))
-        .map(|(i, (_, extras))| (i, extras.modified_peptide.as_str()))
+impl Naming {
+    /// The id for one precursor, given the cell the file had for it.
+    fn id_for(
+        self,
+        counter: u64,
+        cell: Option<&str>,
+        modified_peptide: &str,
+    ) -> Result<OwnedSourceId, DiannPrecursorParsingError> {
+        match self {
+            Self::Absent => Ok(OwnedSourceId::Numeric(counter)),
+            Self::Present => match cell.filter(|name| !name.is_empty()) {
+                Some(name) => Ok(OwnedSourceId::from(name)),
+                None => {
+                    error!(
+                        "precursor {counter} ({modified_peptide:?}) has an empty \
+                         `transition_group_id` / `Precursor.Id` in a library that names its \
+                         other precursors; a library names all its rows or none"
+                    );
+                    Err(DiannPrecursorParsingError::UnnamedPrecursor)
+                }
+            },
+        }
+    }
 }
 
 fn parse_precursor_group(
     id: u64,
+    naming: Naming,
     rows: &[DiannLibraryRow],
     buffers: &mut ParsingBuffers,
 ) -> Result<(Target<IonAnnot>, DiannPrecursorExtras), DiannPrecursorParsingError> {
@@ -469,15 +481,12 @@ fn parse_precursor_group(
         relative_intensities,
     };
 
-    // DIA-NN names the precursor itself; carry that through so results say what
-    // the library says. Variants without the column fall back to the counter,
-    // which `seal` treats as any other minted id.
-    let name = first_row
-        .transition_group_id
-        .as_deref()
-        .filter(|name| !name.is_empty());
     let eg = Target::builder()
-        .id(name.map_or_else(|| id.into(), OwnedSourceId::from))
+        .id(naming.id_for(
+            id,
+            first_row.transition_group_id.as_deref(),
+            &first_row.modified_peptide,
+        )?)
         .mobility_ook0(mobility)
         .rt_seconds(rt_seconds)
         .fragment_labels(buffers.fragment_labels.as_slice().into())
@@ -619,6 +628,11 @@ pub fn read_parquet_library_file<T: AsRef<Path>>(
     // Optional: absent from libraries written by other tools (the Carafe
     // fixture has no such column), which then fall back to minted ids.
     let precursor_ids = get_string_column(&all_batches, "Precursor.Id").ok();
+    let naming = if precursor_ids.is_some() {
+        Naming::Present
+    } else {
+        Naming::Absent
+    };
     let decoys = get_int_column(&all_batches, "Decoy")?;
 
     let num_rows = modified_sequences.len();
@@ -667,6 +681,7 @@ pub fn read_parquet_library_file<T: AsRef<Path>>(
             // Parse the collected group
             let eg = parse_precursor_group_from_parquet(
                 group_id,
+                naming,
                 &current_group_indices,
                 &columns,
                 &mut buffers,
@@ -684,6 +699,7 @@ pub fn read_parquet_library_file<T: AsRef<Path>>(
     if !current_group_indices.is_empty() {
         let eg = parse_precursor_group_from_parquet(
             group_id,
+            naming,
             &current_group_indices,
             &columns,
             &mut buffers,
@@ -691,7 +707,6 @@ pub fn read_parquet_library_file<T: AsRef<Path>>(
         elution_groups.push(eg);
     }
 
-    unify_source_ids(&mut elution_groups);
     info!(
         "Parsed {} elution groups from parquet file",
         elution_groups.len()
@@ -701,6 +716,7 @@ pub fn read_parquet_library_file<T: AsRef<Path>>(
 
 fn parse_precursor_group_from_parquet(
     id: u64,
+    naming: Naming,
     indices: &[usize],
     columns: &ParquetColumnData,
     buffers: &mut ParsingBuffers,
@@ -797,14 +813,12 @@ fn parse_precursor_group_from_parquet(
         relative_intensities: rel_intensities,
     };
 
-    // DIA-NN names the precursor in `Precursor.Id`; carry that through when the
-    // file has it, else fall back to the counter as the TSV path does.
-    let name = columns
-        .precursor_ids
-        .map(|ids| ids[first_idx].as_str())
-        .filter(|name| !name.is_empty());
     let eg = Target::builder()
-        .id(name.map_or_else(|| id.into(), OwnedSourceId::from))
+        .id(naming.id_for(
+            id,
+            columns.precursor_ids.map(|ids| ids[first_idx].as_str()),
+            &columns.modified_sequences[first_idx],
+        )?)
         .mobility_ook0(mobility)
         .rt_seconds(rt_seconds)
         .fragment_labels(buffers.fragment_labels.as_slice().into())
@@ -820,40 +834,61 @@ fn parse_precursor_group_from_parquet(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::models::SourceId;
     use std::path::PathBuf;
 
-    /// One blank `transition_group_id` costs the *whole* library its names,
-    /// because the arena holds one id shape and not two. That trade is
-    /// deliberate; what it must not be is quiet. This pins both halves: the
-    /// fallback rewrites every id, and the precursor that triggered it is
-    /// identifiable before it does.
+    /// A file with the `transition_group_id` column promises every row has one.
+    /// A blank cell breaks that promise, and the two ways to carry on are both
+    /// wrong: storing a half-named library is impossible (one id shape per
+    /// column), and renumbering every row throws away the names the file did
+    /// give. So it is an error.
     #[test]
-    fn one_unnamed_precursor_downgrades_the_library_and_is_named_first() {
-        // This fixture has no `transition_group_id` column, so both precursors
-        // come back minted. Naming one of them is the mixed library a blank cell
-        // produces.
+    fn a_blank_name_in_a_naming_library_is_an_error() {
+        let with_names = "\
+ModifiedPeptide\tStrippedPeptide\tPrecursorMz\tPrecursorCharge\tTr_recalibrated\tIonMobility\t\
+ProteinID\tDecoy\tFragmentMz\tFragmentType\tFragmentNumber\tFragmentCharge\tFragmentLossType\t\
+RelativeIntensity\ttransition_group_id
+PEPTIDEK\tPEPTIDEK\t500.0\t2\t10.0\t0.8\tP1\t0\t200.0\ty\t2\t1\tnoloss\t1.0\tPEPTIDEK2
+AAAAAAALQAK\tAAAAAAALQAK\t478.7\t2\t11.0\t0.9\tP2\t0\t300.0\ty\t3\t1\tnoloss\t1.0\t{second_id}
+";
+        let write = |content: &str| {
+            let f = tempfile::Builder::new()
+                .suffix(".tsv")
+                .tempfile()
+                .expect("tmpfile");
+            std::fs::write(f.path(), content).expect("write");
+            f
+        };
+
+        // Both named: the file's own names reach the targets.
+        let ok = write(&with_names.replace("{second_id}", "AAAAAAALQAK2"));
+        let egs = read_targets(ok.path()).expect("a fully named library loads");
+        assert_eq!(egs.len(), 2);
+        assert_eq!(egs[1].0.id(), SourceId::Text("AAAAAAALQAK2"));
+
+        // One blank: rejected, rather than silently costing row 0 its name.
+        let blank = write(&with_names.replace("{second_id}", ""));
+        assert!(
+            matches!(
+                read_targets(blank.path()),
+                Err(DiannReadingError::DiannPrecursorParsingError)
+            ),
+            "a blank name in a naming library must not load"
+        );
+    }
+
+    /// The column being absent is the other case, and is fine: the library names
+    /// nothing, so every row is keyed by a minted counter.
+    #[test]
+    fn a_library_without_the_name_column_gets_minted_ids() {
         let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
             .join("tests")
             .join("diann_io_files")
             .join("sample_lib.txt");
-        let mut egs = read_targets(path).expect("reads");
+        let egs = read_targets(path).expect("reads");
         assert_eq!(egs.len(), 2, "fixture should hold two precursors");
-        egs[0].0.set_id(OwnedSourceId::Text("MGRYSGK2".into()));
-
-        let named = egs[1].1.modified_peptide.clone();
-        assert_eq!(
-            first_unnamed(&egs),
-            Some((1, named.as_str())),
-            "the warning has to name the precursor that caused the downgrade"
-        );
-
-        unify_source_ids(&mut egs);
         for (i, (eg, _)) in egs.iter().enumerate() {
-            assert_eq!(
-                eg.id(),
-                SourceId::Numeric(i as u64),
-                "a mixed library falls back to minted ids for every row"
-            );
+            assert_eq!(eg.id(), SourceId::Numeric(i as u64));
         }
     }
 
diff --git a/rust/timsquery/src/serde/diann_speclib_io.rs b/rust/timsquery/src/serde/diann_speclib_io.rs
index 618fce61..4df9cc23 100644
--- a/rust/timsquery/src/serde/diann_speclib_io.rs
+++ b/rust/timsquery/src/serde/diann_speclib_io.rs
@@ -31,6 +31,7 @@ use super::library_file::{
 };
 use crate::ion::IonAnnot;
 use crate::models::{
+    Row,
     TargetCapabilities,
     TargetColumns,
 };
@@ -472,11 +473,12 @@ impl SpecLib {
         // short-circuit on the first error and, on an indexed iterator, preserve
         // file order. Each worker owns a `(TargetColumns, frag_intens)` shard
         // it pushes rows into; the reduce step concatenates shards with
-        // `append_arena` (which rebases every CSR offset). The 4th accumulator
+        // `append_arena` (which rebases every CSR offset, and carries each row's
+        // id along with it). The 4th accumulator
         // slot is a per-worker dedup scratch buffer reused across every entry
         // that worker maps (see `map_entry`), so the hot loop allocates only the
         // persistent output, not a fresh dedup Vec per entry.
-        let (mut geom, frag_intens, stats, _scratch, source_ids) = offsets
+        let (geom, frag_intens, stats, _scratch) = offsets
             .par_iter()
             .try_fold(
                 || {
@@ -485,24 +487,16 @@ impl SpecLib {
                         Vec::<f32>::new(),
                         SpeclibDecodeStats::default(),
                         Vec::new(),
-                        Vec::<String>::new(),
                     )
                 },
-                |(mut geom, mut frag_intens, mut stats, mut scratch, mut ids),
+                |(mut geom, mut frag_intens, mut stats, mut scratch),
                  &off|
                  -> Result<_, TargetReadingError> {
                     let mut cur = Cursor::new(self.data.bytes());
                     cur.pos = off;
                     let view = read_entry(&mut cur, self.version, &self.pg_ids)?;
-                    map_entry(
-                        view,
-                        &mut geom,
-                        &mut frag_intens,
-                        &mut ids,
-                        &mut stats,
-                        &mut scratch,
-                    )?;
-                    Ok((geom, frag_intens, stats, scratch, ids))
+                    map_entry(view, &mut geom, &mut frag_intens, &mut stats, &mut scratch)?;
+                    Ok((geom, frag_intens, stats, scratch))
                 },
             )
             .try_reduce(
@@ -512,23 +506,17 @@ impl SpecLib {
                         Vec::<f32>::new(),
                         SpeclibDecodeStats::default(),
                         Vec::new(),
-                        Vec::<String>::new(),
                     )
                 },
-                |(mut a_geom, mut a_int, sa, scratch, mut a_ids), (b_geom, b_int, sb, _, b_ids)| {
+                |(mut a_geom, mut a_int, sa, scratch), (b_geom, b_int, sb, _)| {
                     append_arena(&mut a_geom, b_geom);
                     a_int.extend(b_int);
-                    a_ids.extend(b_ids);
                     let mut merged = sa;
                     merged.merge(&sb);
-                    Ok((a_geom, a_int, merged, scratch, a_ids))
+                    Ok((a_geom, a_int, merged, scratch))
                 },
             )?;
 
-        // The entry name is DIA-NN's `transition_group_id`, so results name the
-        // precursor the way the library does rather than by a minted counter.
-        geom.set_source_ids(source_ids)?;
-
         Ok((geom, frag_intens, stats, at_eof))
     }
 }
@@ -652,6 +640,7 @@ fn append_arena(dst: &mut TargetColumns<IonAnnot>, mut src: TargetColumns<IonAnn
     dst.rt_seconds.append(&mut src.rt_seconds);
     dst.mobility.append(&mut src.mobility);
     dst.is_decoy.append(&mut src.is_decoy);
+    dst.pending_ids.append(&mut src.pending_ids);
     dst.frag_labels.append(&mut src.frag_labels);
     dst.frag_mzs.append(&mut src.frag_mzs);
     dst.seq_strip_blob.push_str(&src.seq_strip_blob);
@@ -686,8 +675,8 @@ fn append_arena(dst: &mut TargetColumns<IonAnnot>, mut src: TargetColumns<IonAnn
 
     // Exhaustive on purpose: a column added to `TargetColumns` fails to compile
     // here instead of being silently dropped on every merge. `source_ids` and
-    // `decoy_groups` are deliberately not merged -- the caller sets them on the
-    // finished arena, so a shard never holds any.
+    // `decoy_groups` are built by `seal`, which runs on the merged arena, so a
+    // shard never holds either.
     let TargetColumns {
         caps: _,
         precursor_mz: _,
@@ -695,6 +684,7 @@ fn append_arena(dst: &mut TargetColumns<IonAnnot>, mut src: TargetColumns<IonAnn
         rt_seconds: _,
         mobility: _,
         is_decoy: _,
+        pending_ids: _,
         source_ids: _,
         decoy_groups: _,
         frag_off: _,
@@ -721,9 +711,6 @@ fn map_entry(
     entry: EntryView,
     geom: &mut TargetColumns<IonAnnot>,
     frag_intens: &mut Vec<f32>,
-    // The entry name, kept so the library's own id reaches the results
-    // instead of one we minted. Parallel to the pushed rows.
-    source_ids: &mut Vec<String>,
     stats: &mut SpeclibDecodeStats,
     scratch: &mut Vec<(IonAnnot, f64, f32)>,
 ) -> Result<(), TargetReadingError> {
@@ -854,19 +841,21 @@ fn map_entry(
 
     // Record charge is i32; `push_target` wants u8. Charge was range-checked to
     // 1..=255 above, so the cast is safe.
-    geom.push_target(
-        pep.mz() as f64,
-        charge as u8,
+    geom.push_row(Row {
+        precursor_mz: pep.mz() as f64,
+        charge: charge as u8,
         // Library iRT is dimensionless here; keep it raw (no minute->second
         // scaling) — Phase 1 RT tolerance is unrestricted.
-        pep.i_rt(),
-        pep.i_im(),
-        &frags,
-        &stripped_peptide,
-        &modified_peptide,
-        &[],
-    );
-    source_ids.push(name);
+        rt_seconds: pep.i_rt(),
+        mobility: pep.i_im(),
+        frags: &frags,
+        seq_strip: &stripped_peptide,
+        seq_mod: &modified_peptide,
+        // The entry name is DIA-NN's `transition_group_id`, so results name the
+        // precursor the way the library does rather than by a minted counter.
+        id: Some(name.into()),
+        ..Default::default()
+    });
     // `entry.protein_id` is intentionally dropped: the columnar arena has no
     // protein column.
     let _ = &entry.protein_id;
@@ -964,7 +953,7 @@ pub fn read_diann_speclib_library_file<T: AsRef<Path>>(
         geom.frag_labels.len(),
         "reference-intensity sidecar must stay parallel to the fragment-label arena"
     );
-    geom.seal();
+    geom.seal()?;
     Ok(TargetTable::Mzpaf {
         geom,
         frag_intens: Some(frag_intens),
@@ -1019,15 +1008,16 @@ mod tests {
         );
     }
 
-    /// Entries are parsed in parallel and the names ride in the same rayon
-    /// accumulator as the rows, so a permutation would mislabel every result
-    /// without failing anything else. Pin it against the property that defines
-    /// the name: it is the modified sequence plus the charge, for every row.
+    /// Entries are parsed in parallel and merged by `append_arena`, which
+    /// rebases each shard's rows. A permutation there would mislabel every
+    /// result without failing anything else. Pin it against the property that
+    /// defines the name: modified sequence plus charge, for every row.
     #[test]
     fn every_source_id_stays_paired_with_its_own_row() {
         let file = std::fs::File::open(fixture_path()).unwrap();
-        let (geom, _frag_intens, _stats, _eof) =
+        let (mut geom, _frag_intens, _stats, _eof) =
             parse_speclib_reader(std::io::BufReader::new(file)).unwrap();
+        geom.seal().expect("the fixture's entry names are usable");
 
         assert!(geom.n_rows() > 1, "one row would not catch a permutation");
         for row in geom.rows() {
diff --git a/rust/timsquery/src/serde/library_file.rs b/rust/timsquery/src/serde/library_file.rs
index 9b10a54c..25065f37 100644
--- a/rust/timsquery/src/serde/library_file.rs
+++ b/rust/timsquery/src/serde/library_file.rs
@@ -23,16 +23,14 @@ use super::spectronaut_io::{
     read_targets as read_spectronaut_tsv,
     sniff_spectronaut_library_file,
 };
+use crate::Target;
 use crate::ion::IonAnnot;
 use crate::models::{
+    Row,
     SourceIdError,
     TargetCapabilities,
     TargetColumns,
 };
-use crate::{
-    KeyLike,
-    Target,
-};
 use std::path::Path;
 use std::sync::Arc;
 use tracing::{
@@ -300,17 +298,18 @@ impl TargetTable {
                 })?;
                 frag_intens.push(*intensity);
             }
-            geom.push_row(
-                eg.precursor_mz(),
-                eg.precursor_charge(),
-                eg.rt_seconds(),
-                eg.mobility_ook0(),
-                &frags,
-                &row.stripped,
-                &row.modified,
-                &[],
-                row.is_decoy,
-            );
+            geom.push_row(Row {
+                precursor_mz: eg.precursor_mz(),
+                charge: eg.precursor_charge(),
+                rt_seconds: eg.rt_seconds(),
+                mobility: eg.mobility_ook0(),
+                frags: &frags,
+                seq_strip: &row.stripped,
+                seq_mod: &row.modified,
+                is_decoy: row.is_decoy,
+                id: Some(eg.id().to_owned_id()),
+                ..Default::default()
+            });
         }
 
         if frag_intens.len() != geom.frag_labels.len() {
@@ -321,7 +320,7 @@ impl TargetTable {
             )));
         }
 
-        seal_with_source_ids(&mut geom, &egs)?;
+        geom.seal()?;
         Ok(TargetTable::Mzpaf {
             geom,
             frag_intens: Some(frag_intens),
@@ -353,18 +352,17 @@ impl TargetTable {
                 for eg in &egs {
                     let frags: Vec<(IonAnnot, f64)> =
                         eg.iter_fragments().map(|(l, mz)| (*l, mz)).collect();
-                    geom.push_target(
-                        eg.precursor_mz(),
-                        eg.precursor_charge(),
-                        eg.rt_seconds(),
-                        eg.mobility_ook0(),
-                        &frags,
-                        "",
-                        "",
-                        &[],
-                    );
+                    geom.push_row(Row {
+                        precursor_mz: eg.precursor_mz(),
+                        charge: eg.precursor_charge(),
+                        rt_seconds: eg.rt_seconds(),
+                        mobility: eg.mobility_ook0(),
+                        frags: &frags,
+                        id: Some(eg.id().to_owned_id()),
+                        ..Default::default()
+                    });
                 }
-                seal_with_source_ids(&mut geom, &egs)?;
+                geom.seal()?;
                 Ok(TargetTable::Mzpaf {
                     geom,
                     frag_intens: None,
@@ -380,18 +378,17 @@ impl TargetTable {
                         .iter_fragments()
                         .map(|(l, mz)| (Arc::<str>::from(l.as_str()), mz))
                         .collect();
-                    geom.push_target(
-                        eg.precursor_mz(),
-                        eg.precursor_charge(),
-                        eg.rt_seconds(),
-                        eg.mobility_ook0(),
-                        &frags,
-                        "",
-                        "",
-                        &[],
-                    );
+                    geom.push_row(Row {
+                        precursor_mz: eg.precursor_mz(),
+                        charge: eg.precursor_charge(),
+                        rt_seconds: eg.rt_seconds(),
+                        mobility: eg.mobility_ook0(),
+                        frags: &frags,
+                        id: Some(eg.id().to_owned_id()),
+                        ..Default::default()
+                    });
                 }
-                seal_with_source_ids(&mut geom, &egs)?;
+                geom.seal()?;
                 Ok(TargetTable::Str { geom })
             }
             ElutionGroupCollection::TinyIntLabels(..) | ElutionGroupCollection::IntLabels(..) => {
@@ -402,25 +399,6 @@ impl TargetTable {
     }
 }
 
-/// Carry the rows' ids into the arena, then seal it.
-///
-/// One function, not two calls: `seal` mints `0..n` for a library that arrived
-/// without ids, so sealing before attaching them silently overwrites the names
-/// the reader parsed. Every arm goes through here so that ordering cannot be
-/// got wrong.
-fn seal_with_source_ids<L: KeyLike, T: KeyLike>(
-    geom: &mut TargetColumns<L>,
-    egs: &[Target<T>],
-) -> Result<(), TargetReadingError> {
-    let ids = egs
-        .iter()
-        .map(|eg| eg.id().to_owned_id())
-        .collect::<Vec<_>>();
-    geom.set_source_ids(ids)?;
-    geom.seal();
-    Ok(())
-}
-
 /// A single spectral-library format reader. Adding a format = one struct + one
 /// line in [`registry`], instead of editing an enum, a method, and an ordered
 /// try-chain.
diff --git a/rust/timsquery_viewer/src/file_loader.rs b/rust/timsquery_viewer/src/file_loader.rs
index e151c5b7..935c5a08 100644
--- a/rust/timsquery_viewer/src/file_loader.rs
+++ b/rust/timsquery_viewer/src/file_loader.rs
@@ -405,8 +405,11 @@ impl ElutionGroupData {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use timsquery::models::TargetColumns;
     use timsquery::models::capabilities::TargetCapabilities;
+    use timsquery::models::{
+        Row,
+        TargetColumns,
+    };
     use timsquery::utils::constants::PROTON_MASS;
     use timsseek::fragment_mass::isotope_dist_or_averagine;
 
@@ -415,20 +418,20 @@ mod tests {
     /// averagine isotope path.
     fn uncountable_lib() -> ReferenceLibrary {
         let mut geom = TargetColumns::with_capabilities(TargetCapabilities::default_diann());
-        geom.push_target(
-            600.0,
-            1,
-            10.0,
-            1.0,
-            &[
+        geom.push_row(Row {
+            precursor_mz: 600.0,
+            charge: 1,
+            rt_seconds: 10.0,
+            mobility: 1.0,
+            frags: &[
                 (IonAnnot::try_from("y3").unwrap(), 300.0),
                 (IonAnnot::try_from("y5").unwrap(), 500.0),
             ],
-            "PEPBK",
-            "PEPBK",
-            &[],
-        );
-        geom.seal();
+            seq_strip: "PEPBK",
+            seq_mod: "PEPBK",
+            ..Default::default()
+        });
+        geom.seal().expect("fixture ids are usable");
         ReferenceLibrary {
             geom,
             frag_intens: vec![1.0, 0.5],
diff --git a/rust/timsseek/src/data_sources/reference_library.rs b/rust/timsseek/src/data_sources/reference_library.rs
index 66869bf2..7f9d153c 100644
--- a/rust/timsseek/src/data_sources/reference_library.rs
+++ b/rust/timsseek/src/data_sources/reference_library.rs
@@ -252,6 +252,7 @@ impl<'a> ScoredIdentity for RefQuery<'a> {
 mod tests {
     use super::*;
     use timsquery::IonAnnot;
+    use timsquery::models::Row;
 
     /// Indices come from the arena; there is no constructor from an integer.
     fn row(lib: &ReferenceLibrary, i: usize) -> RowIdx {
@@ -271,20 +272,20 @@ mod tests {
         let mut caps = TargetCapabilities::default_diann();
         caps.decoys = crate::models::map_decoy_strategy(crate::models::DecoyPolicy::Force, false);
         let mut geom = TargetColumns::with_capabilities(caps);
-        geom.push_target(
-            900.4,
-            2,
-            1.0,
-            1.0,
-            &[
+        geom.push_row(Row {
+            precursor_mz: 900.4,
+            charge: 2,
+            rt_seconds: 1.0,
+            mobility: 1.0,
+            frags: &[
                 (IonAnnot::try_from("y3").unwrap(), 300.0),
                 (IonAnnot::try_from("y8").unwrap(), 800.0),
             ],
-            "PEPTIDEK",
-            "PEPTIDEK",
-            &[],
-        );
-        geom.seal();
+            seq_strip: "PEPTIDEK",
+            seq_mod: "PEPTIDEK",
+            ..Default::default()
+        });
+        geom.seal().expect("fixture ids are usable");
         ReferenceLibrary {
             geom,
             frag_intens: vec![1.0, 0.5],
@@ -297,17 +298,17 @@ mod tests {
         use timsquery::models::capabilities::TargetCapabilities;
         use timsquery::serde::TargetTable;
         let mut geom = TargetColumns::with_capabilities(TargetCapabilities::default_diann());
-        geom.push_target(
-            900.4,
-            2,
-            1.0,
-            1.0,
-            &[(timsquery::IonAnnot::try_from("y3").unwrap(), 300.0)],
-            "PEP",
-            "PEP",
-            &[],
-        );
-        geom.seal();
+        geom.push_row(Row {
+            precursor_mz: 900.4,
+            charge: 2,
+            rt_seconds: 1.0,
+            mobility: 1.0,
+            frags: &[(timsquery::IonAnnot::try_from("y3").unwrap(), 300.0)],
+            seq_strip: "PEP",
+            seq_mod: "PEP",
+            ..Default::default()
+        });
+        geom.seal().expect("fixture ids are usable");
         let arena = TargetTable::Mzpaf {
             geom,
             frag_intens: Some(vec![1.0]),
@@ -317,7 +318,7 @@ mod tests {
 
         let mut sgeom: TargetColumns<std::sync::Arc<str>> =
             TargetColumns::with_capabilities(TargetCapabilities::default_diann());
-        sgeom.seal();
+        sgeom.seal().expect("an empty arena seals");
         let s = TargetTable::Str { geom: sgeom };
         assert!(ReferenceLibrary::try_from(s).is_err());
     }
diff --git a/rust/timsseek/src/data_sources/speclib.rs b/rust/timsseek/src/data_sources/speclib.rs
index 4c94a2b0..51a951bd 100644
--- a/rust/timsseek/src/data_sources/speclib.rs
+++ b/rust/timsseek/src/data_sources/speclib.rs
@@ -22,8 +22,12 @@ use std::path::{
     Path,
     PathBuf,
 };
-use timsquery::models::TargetColumns;
 use timsquery::models::capabilities::SeqFeatureState;
+use timsquery::models::{
+    OwnedSourceId,
+    Row,
+    TargetColumns,
+};
 use timsquery::serde::read_targets as read_timsquery_library;
 use timsquery::utils::constants::PROTON_MASS;
 
@@ -200,10 +204,10 @@ fn finalize_reference_library(
     mut geom: TargetColumns<IonAnnot>,
     frag_intens: Vec<f32>,
     policy: crate::models::DecoyPolicy,
-) -> (ReferenceLibrary, LoadReport) {
+) -> Result<(ReferenceLibrary, LoadReport), TargetReadingError> {
     let n_stored_decoys = geom.n_stored_decoys();
     geom.caps.decoys = crate::models::map_decoy_strategy(policy, n_stored_decoys > 0);
-    geom.seal();
+    geom.seal()?;
 
     let n_rows = geom.n_rows();
 
@@ -284,7 +288,7 @@ fn finalize_reference_library(
         sequence_features,
     };
 
-    (ReferenceLibrary { geom, frag_intens }, report)
+    Ok((ReferenceLibrary { geom, frag_intens }, report))
 }
 
 /// The spectral library store. Collapsed to the single columnar
@@ -518,7 +522,7 @@ impl Speclib {
         // all live in the one shared finalize path (see
         // `finalize_reference_library`); the report is logged there, so we drop
         // it here.
-        let (lib, _report) = finalize_reference_library(geom, frag_intens, decoy_policy);
+        let (lib, _report) = finalize_reference_library(geom, frag_intens, decoy_policy)?;
         lib.log_entry_stats();
         Ok(lib)
     }
@@ -545,6 +549,7 @@ impl Speclib {
             timsquery::models::TargetCapabilities::default_diann(),
         );
         let mut frag_intens: Vec<f32> = Vec::new();
+        let mut decoy_groups: Vec<u64> = Vec::new();
 
         for elem in reader {
             let elem = elem?;
@@ -575,22 +580,28 @@ impl Speclib {
             // annotations for the composition-isotope path.
             let modified = &elem.precursor.sequence;
             let stripped = strip_mods(modified);
-            geom.push_row(
-                eg.precursor_mz,
-                elem.precursor.charge,
-                eg.rt_seconds,
-                eg.mobility_ook0,
-                &frags,
-                &stripped,
-                modified,
-                &[],
-                elem.precursor.decoy,
-            );
+            geom.push_row(Row {
+                precursor_mz: eg.precursor_mz,
+                charge: elem.precursor.charge,
+                rt_seconds: eg.rt_seconds,
+                mobility: eg.mobility_ook0,
+                frags: &frags,
+                seq_strip: &stripped,
+                seq_mod: modified,
+                is_decoy: elem.precursor.decoy,
+                // The format names its own precursors and declares its own
+                // competition groups; carry both rather than minting over them.
+                id: Some(OwnedSourceId::Numeric(eg.id as u64)),
+                ..Default::default()
+            });
+            decoy_groups.push(u64::from(elem.precursor.decoy_group));
         }
 
+        geom.set_decoy_groups(decoy_groups)?;
+
         // Decoy resolution + seal happen inside the one shared finalize path,
         // exactly as the `.speclib` bridge above.
-        let (lib, _report) = finalize_reference_library(geom, frag_intens, decoy_policy);
+        let (lib, _report) = finalize_reference_library(geom, frag_intens, decoy_policy)?;
         lib.log_entry_stats();
         Ok(lib)
     }
@@ -1289,17 +1300,17 @@ mod tests {
         use timsquery::serde::TargetTable;
 
         let mut geom = TargetColumns::with_capabilities(TargetCapabilities::default_diann());
-        geom.push_target(
-            900.4,
-            2,
-            1.0,
-            1.0,
-            &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
-            "PEP",
-            "PEP",
-            &[],
-        );
-        geom.seal();
+        geom.push_row(Row {
+            precursor_mz: 900.4,
+            charge: 2,
+            rt_seconds: 1.0,
+            mobility: 1.0,
+            frags: &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
+            seq_strip: "PEP",
+            seq_mod: "PEP",
+            ..Default::default()
+        });
+        geom.seal().expect("fixture ids are usable");
         let arena = TargetTable::Mzpaf {
             geom,
             frag_intens: None,
diff --git a/rust/timsseek/src/errors.rs b/rust/timsseek/src/errors.rs
index ef65d772..4d4d09a7 100644
--- a/rust/timsseek/src/errors.rs
+++ b/rust/timsseek/src/errors.rs
@@ -55,6 +55,17 @@ impl From<timsquery::serde::TargetReadingError> for TargetReadingError {
     }
 }
 
+/// Sealing an arena builds its id column, which fails on ids that cannot serve
+/// as a result key. Routed through timsquery's reader error so the message a
+/// caller sees is the same whichever crate did the sealing.
+impl From<timsquery::models::SourceIdError> for TargetReadingError {
+    fn from(source: timsquery::models::SourceIdError) -> Self {
+        Self::TimsQueryLibraryError {
+            source: source.into(),
+        }
+    }
+}
+
 impl From<TQDataProcessingError> for DataProcessingError {
     fn from(x: TQDataProcessingError) -> Self {
         Self::TimsQueryDataProcessingError {
diff --git a/rust/timsseek/src/scoring/parquet_writer.rs b/rust/timsseek/src/scoring/parquet_writer.rs
index 47c6fdaa..73628c23 100644
--- a/rust/timsseek/src/scoring/parquet_writer.rs
+++ b/rust/timsseek/src/scoring/parquet_writer.rs
@@ -238,31 +238,32 @@ mod tests {
         SerializedFileReader,
     };
     use std::fs::File;
+    use timsquery::models::Row;
     use timsquery::models::capabilities::TargetCapabilities;
 
-    /// An unsealed arena holding one row per sequence, for the writer to
-    /// resolve ids against. Left unsealed so a caller can attach source ids.
-    fn arena_of(seqs: &[&str]) -> TargetColumns<IonAnnot> {
+    /// A sealed arena with one row per `(sequence, id)`, for the writer to
+    /// resolve ids against. `None` for an id leaves the row to be minted.
+    fn arena_of(rows: &[(&str, Option<&str>)]) -> TargetColumns<IonAnnot> {
         let mut geom = TargetColumns::with_capabilities(TargetCapabilities::default_diann());
-        for seq in seqs {
-            geom.push_target(
-                900.4,
-                2,
-                1.0,
-                1.0,
-                &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
-                seq,
-                seq,
-                &[],
-            );
+        for (seq, id) in rows {
+            geom.push_row(Row {
+                precursor_mz: 900.4,
+                charge: 2,
+                rt_seconds: 1.0,
+                mobility: 1.0,
+                frags: &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
+                seq_strip: seq,
+                seq_mod: seq,
+                id: id.map(Into::into),
+                ..Default::default()
+            });
         }
+        geom.seal().expect("fixture ids are usable");
         geom
     }
 
     fn one_row_arena() -> TargetColumns<IonAnnot> {
-        let mut geom = arena_of(&["PEPTIDEK"]);
-        geom.seal();
-        geom
+        arena_of(&[("PEPTIDEK", None)])
     }
 
     /// `FinalResult::sample()` carries a placeholder row, which by design reads
@@ -316,12 +317,12 @@ mod tests {
     fn ids_resolve_from_the_arena_row() {
         use arrow::array::StringArray;
 
-        let mut geom = arena_of(&["PEPTIDEK", "AAAAAAALQAK"]);
         // The names DIA-NN would give these rows, which is the case that must
         // not come back as digits.
-        geom.set_source_ids(["PEPTIDEK2", "AAAAAAALQAK2"])
-            .expect("two ids for two rows");
-        geom.seal();
+        let geom = arena_of(&[
+            ("PEPTIDEK", Some("PEPTIDEK2")),
+            ("AAAAAAALQAK", Some("AAAAAAALQAK2")),
+        ]);
 
         let second = geom.rows().nth(1).expect("two rows");
         let mut result = FinalResult::sample();
diff --git a/rust/timsseek/src/scoring/pipeline.rs b/rust/timsseek/src/scoring/pipeline.rs
index 605f9237..1eb096de 100644
--- a/rust/timsseek/src/scoring/pipeline.rs
+++ b/rust/timsseek/src/scoring/pipeline.rs
@@ -953,27 +953,30 @@ mod tests {
         ReferenceLibrary,
     };
     use timsquery::Target;
-    use timsquery::models::TargetColumns;
     use timsquery::models::capabilities::TargetCapabilities;
+    use timsquery::models::{
+        Row,
+        TargetColumns,
+    };
 
     fn tiny_lazy_lib() -> ReferenceLibrary {
         let mut caps = TargetCapabilities::default_diann();
         caps.decoys = crate::models::map_decoy_strategy(crate::models::DecoyPolicy::Force, false);
         let mut geom = TargetColumns::with_capabilities(caps);
-        geom.push_target(
-            900.4,
-            2,
-            1.0,
-            1.0,
-            &[
+        geom.push_row(Row {
+            precursor_mz: 900.4,
+            charge: 2,
+            rt_seconds: 1.0,
+            mobility: 1.0,
+            frags: &[
                 (IonAnnot::try_from("y3").unwrap(), 300.0),
                 (IonAnnot::try_from("y8").unwrap(), 800.0),
             ],
-            "PEPTIDEK",
-            "PEPTIDEK",
-            &[],
-        );
-        geom.seal();
+            seq_strip: "PEPTIDEK",
+            seq_mod: "PEPTIDEK",
+            ..Default::default()
+        });
+        geom.seal().expect("fixture ids are usable");
         ReferenceLibrary {
             geom,
             frag_intens: vec![1.0, 0.5],

From 6d88c00764802824f41a34aa020744dd37ef5c2a Mon Sep 17 00:00:00 2001
From: "J. Sebastian Paez" <jspaezp@gmail.com>
Date: Fri, 28 Aug 2026 08:47:30 -0700
Subject: [PATCH 18/19] docs: trim the comments flagged in review, and stop the
 placeholder allocating

Six comments cut to what a reader cannot get from the code: the `CalibrantPoint`
identity rationale, the flyweight's bit-packing history, `Row`'s account of the
bug that motivated it, `is_decoy`/`pending_ids`/`source_ids` field docs, and the
justification on the blank-name test for a case that does not occur in practice.

`OwnedSourceId::placeholder()` returns `Text(String::new())` rather than
`Text("<unset>")`. An empty `String` owns no buffer, so the two scratch
constructors allocate nothing to store bytes nothing reads -- and the previous
claim that `"<unset>"` let `set_from` reuse the allocation was wrong: a 7-byte
capacity does not hold a real id, so it reallocated anyway.
---
 rust/calib_dash/src/frames.rs               | 14 ++-----
 rust/timsquery/src/models/query_handle.rs   | 13 ++-----
 rust/timsquery/src/models/source_id.rs      | 24 ++++++------
 rust/timsquery/src/models/target_columns.rs | 43 ++++++++-------------
 rust/timsquery/src/serde/diann_io.rs        |  9 ++---
 5 files changed, 39 insertions(+), 64 deletions(-)

diff --git a/rust/calib_dash/src/frames.rs b/rust/calib_dash/src/frames.rs
index aa251822..6c08051d 100644
--- a/rust/calib_dash/src/frames.rs
+++ b/rust/calib_dash/src/frames.rs
@@ -22,15 +22,9 @@ pub const REPLAY_BUDGET_BYTES: usize = 1 << 20;
 
 /// One heap entry, flattened.
 ///
-/// `identity` exists because churn diffing needs to tell "same calibrant,
-/// re-scored" from "different calibrant, same RT", and RT coordinates are not
-/// unique. It is an opaque hash of whatever handle the producer keys on (today
-/// the arena's `FlatIdx`), never displayed -- this is a debugging view, so it
-/// compares identity without carrying it. Keeping it a plain integer is what
-/// lets `size_of` below be the true cost of a point, and what keeps this type
-/// `Copy`.
-///
-/// Only meaningful within one process: the hash is not stable across runs.
+/// `identity` tells "same calibrant, re-scored" from "different calibrant, same
+/// RT" during churn diffing; RT alone is not unique. Compared, never displayed,
+/// and only within one process -- the hash is not stable across runs.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct CalibrantPoint {
     pub library_rt: f64,
@@ -191,7 +185,7 @@ mod tests {
         }
     }
 
-    /// Retained frames exceed the *stride* budget by exactly one — the reserved
+    /// Retained frames exceed the *stride* budget by exactly one -- the reserved
     /// final span, which is what makes the last chunk always replayable however
     /// the stride falls. Points are asserted per frame, and made
     /// chunk-distinguishable to do it: with the same `pt(i)` in every frame the
diff --git a/rust/timsquery/src/models/query_handle.rs b/rust/timsquery/src/models/query_handle.rs
index 93217f12..98893b6b 100644
--- a/rust/timsquery/src/models/query_handle.rs
+++ b/rust/timsquery/src/models/query_handle.rs
@@ -22,16 +22,9 @@ use crate::utils::constants::C13_C12_MASS_DIFF;
 /// decoy geometry is stored anywhere; variants 1/2 compute a ±CH2 mass shift
 /// on the fly from `TargetCapabilities::decoys`.
 ///
-/// A flyweight is built from a [`FlatIdx`] and nothing else, because that is
-/// already the name of a `(row, variant)` pair — see
-/// [`TargetColumns::split_flat`], the single authority for the encoding. The
-/// pair is split once at construction and stored unpacked, so the accessors
-/// every geometry method calls stay field reads rather than a division by
-/// `variants_per_row`.
-///
-/// Storing the pair costs nothing over bit-packing it: the `Lib` pointer's
-/// alignment pads the struct to two words either way, which
-/// `the_flyweight_stays_two_words` pins.
+/// Built from a [`FlatIdx`] and nothing else -- that already names a
+/// `(row, variant)` pair, and [`TargetColumns::split_flat`] owns the encoding.
+/// Split once here so the accessors stay field reads.
 #[derive(Debug, Clone, Copy)]
 pub struct Query<Lib, L> {
     lib: Lib,
diff --git a/rust/timsquery/src/models/source_id.rs b/rust/timsquery/src/models/source_id.rs
index f2043652..37c22a06 100644
--- a/rust/timsquery/src/models/source_id.rs
+++ b/rust/timsquery/src/models/source_id.rs
@@ -11,8 +11,8 @@
 //! The shape is preserved where a consumer distinguishes the two, which today
 //! is the JSON result path only: Carafe reads `id` with fastjson and keys
 //! results by it, so `"id": 7` must stay a bare number. The parquet writer does
-//! not distinguish — both id columns are `Utf8` and a numeric id is written as
-//! its digits — because a search result is read by column type, not by the
+//! not distinguish -- both id columns are `Utf8` and a numeric id is written as
+//! its digits -- because a search result is read by column type, not by the
 //! shape of one value.
 
 use serde::{
@@ -101,19 +101,21 @@ impl From<&str> for OwnedSourceId {
 }
 
 impl OwnedSourceId {
-    /// For a scratch buffer that is refilled before it is read (see
+    /// The id of a scratch buffer that has not been filled yet (see
     /// [`crate::Target::empty_like`]).
     ///
-    /// Deliberately not `Default`, and deliberately not `Numeric(0)`: every
-    /// `u64` is a valid id, so a numeric placeholder that leaked would look
-    /// exactly like a real result keyed on 0 — the same reason
-    /// `RowIdx::default()` is `u32::MAX` rather than 0. This one is visible in
-    /// any output that would wrongly carry it.
+    /// Allocates nothing: an empty `String` owns no buffer until something is
+    /// pushed into it, and [`Self::set_from`] then grows it once -- exactly what
+    /// a fresh `String` would cost. A named placeholder like `"<unset>"` would
+    /// allocate on every scratch buffer to store bytes nothing reads.
     ///
-    /// It is `Text` so the first [`Self::set_from`] with a text id reuses this
-    /// allocation instead of making one; a `Numeric` placeholder could not.
+    /// Deliberately not `Default`, and deliberately not `Numeric(0)`: every
+    /// `u64` is a valid id, so a numeric placeholder that leaked into a result
+    /// would look exactly like a row keyed on 0 -- the same reason
+    /// `RowIdx::default()` is `u32::MAX` rather than 0. An empty id is visibly
+    /// unset.
     pub fn placeholder() -> Self {
-        Self::Text("<unset>".to_string())
+        Self::Text(String::new())
     }
 }
 
diff --git a/rust/timsquery/src/models/target_columns.rs b/rust/timsquery/src/models/target_columns.rs
index b699f58e..21ade1b4 100644
--- a/rust/timsquery/src/models/target_columns.rs
+++ b/rust/timsquery/src/models/target_columns.rs
@@ -23,7 +23,7 @@ pub use index::{
 ///
 /// All three are opaque: no constructor from an integer, no accessor yielding
 /// one, no `Display`, no `Serialize`. So none of them can be invented by a
-/// caller, confused with an id, or written to an output file — a handle can
+/// caller, confused with an id, or written to an output file -- a handle can
 /// only be obtained from the arena and handed straight back to it.
 ///
 /// Construction is `pub(super)`, i.e. this file, so the arena is the only thing
@@ -35,7 +35,7 @@ mod index {
 
     /// A scored slot after decoy expansion: `0..expanded_len()`. Distinct from
     /// [`RowIdx`] because `variants_per_row` slots map onto one row, so using
-    /// one where the other is meant reads a real but wrong row — in range, no
+    /// one where the other is meant reads a real but wrong row -- in range, no
     /// panic, plausible data. The type is what stops that.
     #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
     pub struct FlatIdx(u32);
@@ -43,7 +43,7 @@ mod index {
     /// Which competition group a row belongs to, as a handle rather than a
     /// value. Rows that compete share one, and that is all a consumer needs:
     /// grouping sorts by it and compares it, and never reads it. Opaque for the
-    /// same reason as the indices above — a handle that could be printed would
+    /// same reason as the indices above -- a handle that could be printed would
     /// end up in an output file as though it meant something.
     ///
     /// `Ord` because grouping works by sorting competitors adjacent; any total
@@ -137,12 +137,9 @@ pub struct DecoyGroups {
 
 /// One row's worth of input to [`TargetColumns::push_row`].
 ///
-/// A struct rather than ten positional arguments, and it carries the row's `id`,
-/// which is the point: a row cannot be stored apart from the name its file gave
-/// it. Attaching ids afterwards, zipped on by position, is how the DIA-NN names
-/// got dropped -- `seal` minted `0..n` over them.
-///
-/// `Default` covers the optional half, so a caller names only what it has:
+/// Carries the row's `id`, so a row cannot be stored apart from the name its
+/// file gave it. `Default` covers the optional half, so a caller names only
+/// what it has:
 ///
 /// ```ignore
 /// geom.push_row(Row {
@@ -165,14 +162,11 @@ pub struct Row<'a, L: KeyLike> {
     pub seq_strip: &'a str,
     pub seq_mod: &'a str,
     pub mods: &'a [(u8, u16)],
-    /// A stored decoy, as opposed to one the arena derives. Default `false`:
-    /// timsquery never invents a decoy, so a row is a target unless its reader
-    /// says otherwise.
+    /// A decoy the library shipped, as opposed to one the arena derives.
     pub is_decoy: bool,
     /// What the source file called this row, in the shape it used. `None` for a
-    /// format that names nothing (Spectronaut, Skyline), and for a row whose
-    /// name cell was blank. [`TargetColumns::seal`] mints ids only when *every*
-    /// row arrived `None`.
+    /// format that names nothing; [`TargetColumns::seal`] mints ids only when
+    /// *every* row arrived `None`.
     pub id: Option<OwnedSourceId>,
 }
 
@@ -211,16 +205,11 @@ pub struct TargetColumns<L: KeyLike> {
     pub(crate) mobility: Vec<f32>,
     // per-row decoy flag (len = n_rows)
     pub(crate) is_decoy: Vec<bool>,
-    /// Each row's id as it was pushed, before [`Self::seal`] decides what the
-    /// column becomes. Parallel to the row columns, and merged by
-    /// [`Self::append_arena`] like any other, so a shard cannot separate a row
-    /// from its name.
-    ///
-    /// Emptied by `seal`, which is the only reader.
+    /// Each row's id as pushed. Parallel to the row columns, so a shard merge
+    /// cannot separate a row from its name. Drained by [`Self::seal`].
     pub(crate) pending_ids: Vec<Option<OwnedSourceId>>,
-    /// What the source file called each row, when it said. Parallel to the row
-    /// columns. Built at [`Self::seal`] from `pending_ids`, minted there for
-    /// formats that carry no ids, so a sealed arena always has one per row.
+    /// Built at [`Self::seal`], minted there for formats that carry no ids, so
+    /// a sealed arena always has one per row.
     pub(crate) source_ids: SourceIds,
     /// The competition groups the input declared, interned: a code per row,
     /// plus the labels those codes point at. Rows that compete share a code, so
@@ -606,7 +595,7 @@ impl<L: KeyLike + DecoyShift> TargetColumns<L> {
 
     /// The scored slots in batches of at most `n`. The arena owns the split,
     /// so a caller batches work by stating a size rather than by computing
-    /// positions — no integer names a slot outside this crate.
+    /// positions -- no integer names a slot outside this crate.
     pub fn chunks(&self, n: usize) -> impl Iterator<Item = Vec<FlatIdx>> + use<L> {
         assert!(n > 0, "chunk size must be non-zero");
         let len = self.expanded_len();
@@ -619,7 +608,7 @@ impl<L: KeyLike + DecoyShift> TargetColumns<L> {
 
     /// Decompose a scored slot into its stored row and decoy variant. The
     /// single authority for the decoy index-transform encoding, and the only
-    /// route from a [`FlatIdx`] to a [`RowIdx`] — which is what keeps the two
+    /// route from a [`FlatIdx`] to a [`RowIdx`] -- which is what keeps the two
     /// index spaces from being used interchangeably.
     pub fn split_flat(&self, flat: FlatIdx) -> (RowIdx, u8) {
         let vpr = self.variants_per_row();
@@ -631,7 +620,7 @@ impl<L: KeyLike + DecoyShift> TargetColumns<L> {
     /// The inverse of [`Self::split_flat`]: name one of a row's scored slots.
     ///
     /// Both directions live here so the encoding has one owner. This is also the
-    /// only way to pair a row with a variant, and it checks the pairing — a
+    /// only way to pair a row with a variant, and it checks the pairing -- a
     /// caller that could build the pair itself could name a variant the library
     /// does not expand into, which would read a real but wrong slot.
     pub fn flat_for(&self, row: RowIdx, variant: u8) -> FlatIdx {
diff --git a/rust/timsquery/src/serde/diann_io.rs b/rust/timsquery/src/serde/diann_io.rs
index 826519e8..0fc36f77 100644
--- a/rust/timsquery/src/serde/diann_io.rs
+++ b/rust/timsquery/src/serde/diann_io.rs
@@ -341,7 +341,7 @@ pub fn read_targets<T: AsRef<Path>>(
 ///
 /// The column is per *file*, not per row: absent means the whole library is
 /// unnamed and every row is keyed by a minted counter. Present means every row
-/// must have a name — a blank cell is an error, not a row to quietly downgrade,
+/// must have a name -- a blank cell is an error, not a row to quietly downgrade,
 /// because a half-named library cannot be stored (the arena holds one id shape)
 /// and silently renumbering the named rows loses information the file had.
 ///
@@ -837,11 +837,8 @@ mod tests {
     use crate::models::SourceId;
     use std::path::PathBuf;
 
-    /// A file with the `transition_group_id` column promises every row has one.
-    /// A blank cell breaks that promise, and the two ways to carry on are both
-    /// wrong: storing a half-named library is impossible (one id shape per
-    /// column), and renumbering every row throws away the names the file did
-    /// give. So it is an error.
+    /// The column being present promises every row has a name; a blank cell is
+    /// rejected rather than costing the named rows theirs.
     #[test]
     fn a_blank_name_in_a_naming_library_is_an_error() {
         let with_names = "\

From 5f87304371890cf47571db284ce4116844d16d05 Mon Sep 17 00:00:00 2001
From: "J. Sebastian Paez" <jspaezp@gmail.com>
Date: Fri, 28 Aug 2026 08:47:39 -0700
Subject: [PATCH 19/19] style: replace every em dash with `--`

Repo-wide sweep over `.rs`, `.toml`, `.md` and `.py`, including the two
`\u{2014}` escapes in `calib_dash`'s fit-tab titles that a literal search does
not find. The `calib_dash` UI snapshots are regenerated: the only changes are
the dash itself and the trailing padding that shifts because `--` is two columns
where the em dash was one.
---
 CONTEXT.md                                    |   8 +-
 Cargo.toml                                    |   2 +-
 docs/development.md                           |  16 +--
 example_speclib_config.toml                   |   8 +-
 python/timsquery_pyo3/README.md               |  42 +++---
 .../examples/streaming_example.py             |   8 +-
 python/timsquery_pyo3/src/elution_group.rs    |   2 +-
 python/timsquery_pyo3/src/iterator.rs         |   2 +-
 python/timsquery_pyo3/src/spectrum.rs         |   2 +-
 rust/alloc_track/src/lib.rs                   |   6 +-
 rust/apex_sim/src/bench.rs                    |   2 +-
 rust/apex_sim/src/plots.rs                    |   2 +-
 rust/apex_sim/src/scorer.rs                   |   4 +-
 rust/apex_sim/src/sim.rs                      |   6 +-
 rust/array2d/src/lib.rs                       |   2 +-
 rust/calib_dash/src/app.rs                    |  40 +++---
 rust/calib_dash/src/bin/calib_dash.rs         |  14 +-
 rust/calib_dash/src/metrics.rs                |   6 +-
 rust/calib_dash/src/recording.rs              |  14 +-
 ...alib_dash__ui__tests__fit_layer_Curve.snap |   4 +-
 ...calib_dash__ui__tests__fit_layer_None.snap |   4 +-
 ...calib_dash__ui__tests__fit_layer_Path.snap |   4 +-
 ...r_and_a_different_grid_when_scrubbing.snap |   6 +-
 ...every_binding_over_the_tab_beneath_it.snap |   4 +-
 rust/calib_dash/src/ui.rs                     | 136 +++++++++---------
 rust/calibrt/src/grid.rs                      |   2 +-
 rust/calibrt/src/lib.rs                       |  36 ++---
 rust/calibrt/src/pathfinding.rs               |   2 +-
 rust/calibrt/src/types.rs                     |   2 +-
 rust/calibrt/tests/tests.rs                   |   2 +-
 rust/rescore_dash/src/app.rs                  |  14 +-
 rust/rescore_dash/src/curves.rs               |   6 +-
 rust/rescore_dash/src/labels.rs               |   6 +-
 rust/rescore_dash/src/lib.rs                  |   4 +-
 rust/rescore_dash/src/precompute.rs           |  24 ++--
 rust/rescore_dash/src/stats.rs                |   4 +-
 rust/rescore_dash/src/transform.rs            |   4 +-
 rust/rescore_dash/src/ui.rs                   |   8 +-
 rust/speclib_build_cli/src/config.rs          |   2 +-
 rust/speclib_build_cli/src/dedup.rs           |   2 +-
 rust/speclib_build_cli/src/entry.rs           |   2 +-
 rust/speclib_build_cli/src/koina/mod.rs       |   4 +-
 rust/speclib_build_cli/src/mods.rs            |   2 +-
 rust/speclib_build_cli/src/pipeline.rs        |   6 +-
 rust/tims_stage/Cargo.toml                    |   2 +-
 rust/tims_stage/src/backend.rs                |   4 +-
 rust/tims_stage/src/download.rs               |   2 +-
 rust/tims_stage/src/error.rs                  |   2 +-
 rust/tims_stage/src/load.rs                   |   8 +-
 rust/tims_stage/src/open.rs                   |   4 +-
 rust/tims_stage/src/resolve.rs                |   6 +-
 rust/tims_stage/src/tar.rs                    |  14 +-
 rust/tims_stage/src/upload.rs                 |   2 +-
 rust/tims_stage/src/uri.rs                    |   6 +-
 rust/tims_stage/tests/minio_smoke.rs          |   2 +-
 rust/timscentroid/src/centroiding.rs          |   6 +-
 rust/timscentroid/src/dimension.rs            |   2 +-
 rust/timscentroid/src/geometry.rs             |   2 +-
 rust/timscentroid/src/indexing.rs             |  20 +--
 rust/timscentroid/src/reader/mod.rs           |  12 +-
 rust/timscentroid/src/reader/mzdata.rs        |  14 +-
 rust/timscentroid/src/reader/uri_util.rs      |   6 +-
 rust/timscentroid/src/serialization/mod.rs    |   6 +-
 rust/timscentroid/src/storage.rs              |   4 +-
 rust/timscentroid/src/utils.rs                |   6 +-
 .../models/aggregators/chromatogram_agg.rs    |  10 +-
 .../src/models/aggregators/spectrum_agg.rs    |   8 +-
 rust/timsquery/src/models/capabilities.rs     |   2 +-
 rust/timsquery/src/models/indexed_data.rs     |   6 +-
 rust/timsquery/src/models/target.rs           |   4 +-
 rust/timsquery/src/serde/diann_speclib_io.rs  |  58 ++++----
 rust/timsquery/src/serde/index_serde.rs       |  16 +--
 rust/timsquery/src/serde/library_file.rs      |   4 +-
 rust/timsquery/src/serde/skyline_io.rs        |   2 +-
 rust/timsquery/src/traits/fragment_label.rs   |   2 +-
 rust/timsquery/src/traits/queriable_data.rs   |   4 +-
 rust/timsquery/src/utils/constants.rs         |   2 +-
 .../timsquery/tests/carafe_contract/README.md |  18 +--
 rust/timsquery/tests/carafe_contract/main.rs  |   2 +-
 rust/timsquery_cli/src/commands.rs            |   2 +-
 rust/timsquery_viewer/src/app.rs              |   2 +-
 rust/timsquery_viewer/src/calibration.rs      |  22 +--
 rust/timsquery_viewer/src/computed_state.rs   |   8 +-
 rust/timsquery_viewer/src/file_loader.rs      |   8 +-
 .../src/ui/panels/mobility_panel.rs           |   6 +-
 rust/timsseek/DATA_FLOW.md                    |  14 +-
 rust/timsseek/examples/query_bench.rs         |  16 +--
 .../src/data_sources/reference_library.rs     |   4 +-
 rust/timsseek/src/data_sources/speclib.rs     |  12 +-
 .../fragment_mass/elution_group_converter.rs  |   4 +-
 rust/timsseek/src/ml/cv.rs                    |  30 ++--
 rust/timsseek/src/ml/lda.rs                   |  12 +-
 rust/timsseek/src/ml/mlp.rs                   |  20 +--
 rust/timsseek/src/ml/mlp_fold.rs              |  56 ++++----
 rust/timsseek/src/ml/qvalues.rs               |  70 ++++-----
 rust/timsseek/src/models/decoy_policy.rs      |   2 +-
 rust/timsseek/src/models/query_item.rs        |   8 +-
 rust/timsseek/src/models/sequence.rs          |  24 ++--
 rust/timsseek/src/rt_calibration.rs           |  14 +-
 rust/timsseek/src/scoring/apex_dsp.rs         |   2 +-
 rust/timsseek/src/scoring/apex_finding.rs     |  12 +-
 .../src/scoring/blocks/apex_evidence.rs       |   2 +-
 .../src/scoring/blocks/apex_features.rs       |   2 +-
 rust/timsseek/src/scoring/blocks/derived.rs   |   2 +-
 rust/timsseek/src/scoring/blocks/identity.rs  |  12 +-
 .../timsseek/src/scoring/blocks/ion_errors.rs |   4 +-
 rust/timsseek/src/scoring/blocks/lazy.rs      |   2 +-
 rust/timsseek/src/scoring/blocks/mod.rs       |  22 +--
 .../src/scoring/blocks/result_meta.rs         |   4 +-
 rust/timsseek/src/scoring/blocks/rt.rs        |   2 +-
 .../src/scoring/blocks/sequence_counts.rs     |   4 +-
 rust/timsseek/src/scoring/offsets.rs          |   2 +-
 rust/timsseek/src/scoring/parquet_writer.rs   |   8 +-
 rust/timsseek/src/scoring/pipeline.rs         |  34 ++---
 rust/timsseek/src/scoring/results.rs          |   6 +-
 rust/timsseek/src/scoring/skip.rs             |   4 +-
 rust/timsseek/src/scoring/timings.rs          |   4 +-
 rust/timsseek/src/utils/elution_group_ops.rs  |   2 +-
 rust/timsseek/src/utils/maybe_par.rs          |  10 +-
 rust/timsseek_cli/Cargo.toml                  |   2 +-
 rust/timsseek_cli/assets/default_config.toml  |  20 +--
 rust/timsseek_cli/examples/load_bench.rs      |   4 +-
 rust/timsseek_cli/src/config.rs               |   4 +-
 rust/timsseek_cli/src/main.rs                 |  16 +--
 rust/timsseek_cli/src/processing.rs           |  20 +--
 rust/timsseek_macros/src/lib.rs               |  56 ++++----
 scripts/plot_spans.py                         |   6 +-
 127 files changed, 673 insertions(+), 673 deletions(-)

diff --git a/CONTEXT.md b/CONTEXT.md
index c718a7c3..737907ce 100644
--- a/CONTEXT.md
+++ b/CONTEXT.md
@@ -19,7 +19,7 @@ data; a query is the act of looking.
 
 **Library**:
 A collection of targets that also carries expected or observed fragment
-intensities. Intensities are what make it a library — without them it is targets.
+intensities. Intensities are what make it a library -- without them it is targets.
 Note this is narrower than the field's usage, where "spectral library" covers
 anything mapping analytes to m/z values.
 _Avoid_: spectral library (ambiguous), speclib
@@ -37,7 +37,7 @@ determinism, so it is never caller-supplied.
 _Avoid_: id, library_id, row id
 
 **Source id**:
-What the source file called a precursor — the JSON target payload's `id`,
+What the source file called a precursor -- the JSON target payload's `id`,
 mzSpecLib's `<Spectrum=N>` key, DIA-NN's `transition_group_id`. Opaque: carried
 through and echoed back, never used to address anything. Absent in some formats.
 _Avoid_: id, library id
@@ -56,7 +56,7 @@ discovery rate. Either shipped by the library or generated as a mass shift.
 A target and its decoy variants, competing as a unit so exactly one survives.
 
 **Variant**:
-One member of a decoy group — the target itself, or one of its mass-shifted
+One member of a decoy group -- the target itself, or one of its mass-shifted
 decoys. A stored row expands into several scored variants, so "one row" is not
 "one result".
 
@@ -68,7 +68,7 @@ contents: whether sequences are available, whether fragment labels carry ion
 chemistry, how isotopes are derived, how decoys are obtained.
 
 **Graceful degradation**:
-Proceeding with a capability absent rather than failing — skipping FDR when there
+Proceeding with a capability absent rather than failing -- skipping FDR when there
 are no decoys, skipping sequence-dependent scores when sequences are unavailable.
 The gate is per-score, not per-run; only some scores need sequences.
 
diff --git a/Cargo.toml b/Cargo.toml
index 7cd1bee9..a865fd6d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -73,7 +73,7 @@ parquet = { version = "59.2" }
 arrow = { version = "59.2", default-features = false }
 
 # Set as the global allocator on windows and musl, whose own allocators are
-# slower here — musl's serialises on one lock. Every binary that wants it repeats
+# slower here -- musl's serialises on one lock. Every binary that wants it repeats
 # the same `cfg(any(target_os = "windows", target_env = "musl"))` gate. Only the
 # deployables carry it: the CLIs and the viewer. The rest are dev utilities and
 # may run slow on those targets.
diff --git a/docs/development.md b/docs/development.md
index 22cbfdbb..a04fe175 100644
--- a/docs/development.md
+++ b/docs/development.md
@@ -20,11 +20,11 @@ Run any with `--help` for the full flag list.
 | Feature | Crate | Effect | Use case | Enable |
 |---------|-------|--------|----------|--------|
 | `parallel` / `rayon` | `timsseek_cli` / `timsseek` | Rayon parallel scoring | Default; fastest wall-time | On by default |
-| `instrumentation` | `timsseek_cli` / `timsseek` | `tracing-profile` perfetto spans | Perf tracing. **Requires `--no-default-features`** — the perfetto backend captures only the main thread, so rayon worker spans are dropped entirely. Run serial or traces for the hot path are empty. | `--features instrumentation --no-default-features` |
+| `instrumentation` | `timsseek_cli` / `timsseek` | `tracing-profile` perfetto spans | Perf tracing. **Requires `--no-default-features`** -- the perfetto backend captures only the main thread, so rayon worker spans are dropped entirely. Run serial or traces for the hot path are empty. | `--features instrumentation --no-default-features` |
 | `track-alloc` | `timsseek_cli` | Global allocator tracking via `alloc_track` | Binary prints per-phase allocation deltas to stderr: `[alloc] <phase> d_bytes=... d_live=... churn=... peak=... hist=...`. Detect churn + memory regressions. Dev-only; do not ship. | `--features track-alloc` |
 | `dashboard` | `timsseek_cli` / `rescore_dash` | Ratatui TUI of a rescoring run: score separation, per-feature histograms, FDR and calibration curves | Interactive dev inspection. Dev-only; also needs `TIMSSEEK_RESCORE_DASHBOARD` at runtime (below). | `--features dashboard` |
-| `calib-dashboard` | `timsseek_cli` | Pulls in `calib_dash`, wiring an interactive terminal dashboard into Phase 1/2 of RT calibration | Step through Phase 1 prescore batches, watch the calibration curve/DP path converge, inspect the Phase 2 fit and derived tolerances. Does nothing on its own — also requires `TIMSSEEK_CALIB_DASHBOARD=1` at runtime (see Env vars). Dev-only; do not ship. | `--features calib-dashboard` |
-| `query-instr` | `timscentroid` | Per-peak atomic counters in `IndexedPeakGroup::for_each_peak` | Filter-funnel shape + pass rates. ~10× wall-time inflation — funnel counts only, not timing. | `-p timscentroid --features query-instr` |
+| `calib-dashboard` | `timsseek_cli` | Pulls in `calib_dash`, wiring an interactive terminal dashboard into Phase 1/2 of RT calibration | Step through Phase 1 prescore batches, watch the calibration curve/DP path converge, inspect the Phase 2 fit and derived tolerances. Does nothing on its own -- also requires `TIMSSEEK_CALIB_DASHBOARD=1` at runtime (see Env vars). Dev-only; do not ship. | `--features calib-dashboard` |
+| `query-instr` | `timscentroid` | Per-peak atomic counters in `IndexedPeakGroup::for_each_peak` | Filter-funnel shape + pass rates. ~10× wall-time inflation -- funnel counts only, not timing. | `-p timscentroid --features query-instr` |
 | `aws` / `gcp` / `azure` | `timscentroid` | `object_store` cloud backends | Read `.d` / speclib from cloud | `--features aws` (etc.) |
 
 ## Env vars
@@ -44,13 +44,13 @@ Not shown by `--help`. Read directly via `std::env::var` / `var_os`.
 
 `task --list-all` enumerates everything. Non-obvious ones:
 
-- `task test`, `task fmt`, `task clippy` — `task fmt` runs nightly rustfmt + ruff. Do not use `cargo fmt` (stable silently drops nightly-only opts).
-- `task speclib:build -- <args>` — wrapper around `speclib_build`.
-- `task speclib:local-koina` / `task speclib:stop-koina` — local Koina docker. First run downloads all models (~10-30 min).
-- `task docker` — cross-builds linux/amd64 images.
+- `task test`, `task fmt`, `task clippy` -- `task fmt` runs nightly rustfmt + ruff. Do not use `cargo fmt` (stable silently drops nightly-only opts).
+- `task speclib:build -- <args>` -- wrapper around `speclib_build`.
+- `task speclib:local-koina` / `task speclib:stop-koina` -- local Koina docker. First run downloads all models (~10-30 min).
+- `task docker` -- cross-builds linux/amd64 images.
 - `task license_check`, `task todos`, `task bumpver`, `task build_python`.
 
-Per-crate: `rust/timsseek/Taskfile.yml` adds a watch loop (`task timsseek`) — rebuild + test + fmt + clippy on source change.
+Per-crate: `rust/timsseek/Taskfile.yml` adds a watch loop (`task timsseek`) -- rebuild + test + fmt + clippy on source change.
 
 ## S3 staging
 
diff --git a/example_speclib_config.toml b/example_speclib_config.toml
index 717afdc6..4023b535 100644
--- a/example_speclib_config.toml
+++ b/example_speclib_config.toml
@@ -2,7 +2,7 @@
 #
 # Reference configuration for speclib_build.
 # CLI flags override any value set here.
-# All fields are optional — omit a section or key to use the compiled-in default.
+# All fields are optional -- omit a section or key to use the compiled-in default.
 
 # ── Output ────────────────────────────────────────────────────────────────────
 # Path for the output spectral library (msgpack + zstd).
@@ -41,9 +41,9 @@ max = 4
 # ── Decoys ────────────────────────────────────────────────────────────────────
 [decoys]
 # Decoy generation strategy.
-#   none         — no decoys (target-only library)
-#   reverse      — reverse the amino-acid sequence
-#   edge_mutate  — mutate N- and C-terminal residues
+#   none         -- no decoys (target-only library)
+#   reverse      -- reverse the amino-acid sequence
+#   edge_mutate  -- mutate N- and C-terminal residues
 strategy = "none"
 
 # ── Prediction ────────────────────────────────────────────────────────────────
diff --git a/python/timsquery_pyo3/README.md b/python/timsquery_pyo3/README.md
index 91e3be6d..4fa2f836 100644
--- a/python/timsquery_pyo3/README.md
+++ b/python/timsquery_pyo3/README.md
@@ -54,7 +54,7 @@ result = index.query_chromatogram(eg, tolerance)
 result.fragment_intensities   # shape (n_fragments, n_cycles), dtype float32
 result.precursor_intensities  # shape (n_precursors, n_cycles), dtype float32
 
-result.fragment_labels        # [(label, mz), ...] — row order matches the array
+result.fragment_labels        # [(label, mz), ...] -- row order matches the array
 result.precursor_labels       # [(isotope_offset, mz), ...]
 result.rt_range_ms            # (start_ms, end_ms)
 result.num_cycles             # number of RT points
@@ -79,7 +79,7 @@ Avoid repeated allocations by reusing a `ChromatogramResult` across queries.
 The internal `Vec<f32>` capacity grows to the largest elution group and stays there.
 
 ```python
-result = index.query_chromatogram(eg1, tolerance)   # first query — allocates
+result = index.query_chromatogram(eg1, tolerance)   # first query -- allocates
 
 index.query_chromatogram_into(result, eg2, tolerance)  # reuses allocation
 index.query_chromatogram_into(result, eg3, tolerance)  # same allocation
@@ -89,11 +89,11 @@ index.query_chromatogram_into(result, eg3, tolerance)  # same allocation
 
 For large-scale workloads, stream elution groups from any Python iterator.
 Internally uses chunked rayon parallelism and reuses collector allocations
-across chunks — after the first chunk, allocations settle and only `memcpy`
+across chunks -- after the first chunk, allocations settle and only `memcpy`
 into numpy remains.
 
 ```python
-# Any iterable works — generator, list, map, etc.
+# Any iterable works -- generator, list, map, etc.
 eg_iter = (make_eg(row) for row in dataframe.itertuples())
 
 # Shared tolerance
@@ -113,7 +113,7 @@ for arrays in index.query_chromatograms_iter(eg_iter, tol_iter, chunk_size=256):
 ```
 
 `ChromatogramArrays` is a lightweight frozen object that owns its numpy arrays.
-The iterator's internal collector pool is never exposed — it just keeps reusing
+The iterator's internal collector pool is never exposed -- it just keeps reusing
 the same Rust-side buffers across chunks.
 
 ## Spectral queries
@@ -122,8 +122,8 @@ the same Rust-side buffers across chunks.
 
 ```python
 result = index.query_spectrum(eg, tolerance)
-result.precursor_intensities   # list[float] — one total intensity per precursor
-result.fragment_intensities    # list[float] — one total intensity per fragment
+result.precursor_intensities   # list[float] -- one total intensity per precursor
+result.fragment_intensities    # list[float] -- one total intensity per fragment
 result.precursor_labels        # list[(isotope_offset, mz)]
 result.fragment_labels         # list[(label, mz)]
 result.id                      # int
@@ -141,9 +141,9 @@ result.id                # int
 ```
 
 Each stats tuple contains:
-- `weight` — total accumulated intensity
-- `mean_mz` — intensity-weighted mean m/z (NaN if no peaks found)
-- `mean_mobility` — intensity-weighted mean ion mobility in 1/K0 (NaN if no peaks found)
+- `weight` -- total accumulated intensity
+- `mean_mz` -- intensity-weighted mean m/z (NaN if no peaks found)
+- `mean_mobility` -- intensity-weighted mean ion mobility in 1/K0 (NaN if no peaks found)
 
 ## Tolerance reference
 
@@ -172,10 +172,10 @@ tol = tol.with_quad(tq.PyQuadTolerance.absolute(0.2, 0.2))
 ## Lazy vs eager loading
 
 ```python
-# Eager (default): loads entire index into memory — faster queries
+# Eager (default): loads entire index into memory -- faster queries
 index = tq.PyTimsIndex("experiment.d")
 
-# Lazy: loads from cached .idx on demand — faster startup, lower memory
+# Lazy: loads from cached .idx on demand -- faster startup, lower memory
 index = tq.PyTimsIndex("experiment.d.idx", prefer_lazy=True)
 
 index.is_lazy  # bool
@@ -186,7 +186,7 @@ index.is_lazy  # bool
 ```python
 index.num_cycles          # total MS1 cycles in the acquisition
 index.rt_range_ms         # (start_ms, end_ms)
-index.rt_values_ms        # list[int] — RT in ms for every cycle index
+index.rt_values_ms        # list[int] -- RT in ms for every cycle index
 
 # Convert between seconds and cycle indices
 idx = index.rt_seconds_to_cycle_index(300.0)   # nearest cycle index
@@ -211,18 +211,18 @@ rt_axis = np.array(index.rt_values_ms, dtype=np.float32) / 1000.0  # seconds
 
 ## Roadmap
 
-- [x] **Aggregator reuse** — `query_chromatogram_into` reuses a `ChromatogramCollector`
+- [x] **Aggregator reuse** -- `query_chromatogram_into` reuses a `ChromatogramCollector`
       allocation across queries, avoiding repeated allocation.
-- [x] **SpectralCollector** — `query_spectrum` (summed f32) and `query_mz_mobility`
+- [x] **SpectralCollector** -- `query_spectrum` (summed f32) and `query_mz_mobility`
       (intensity-weighted mean m/z + mobility) per ion.
-- [ ] **PointIntensityAggregator** — single scalar total intensity per elution group.
-- [ ] **IonAnnot key type** — support `IonAnnot` fragment labels alongside `usize`,
+- [ ] **PointIntensityAggregator** -- single scalar total intensity per elution group.
+- [ ] **IonAnnot key type** -- support `IonAnnot` fragment labels alongside `usize`,
       enabling richer annotation round-trips between Python and Rust.
-- [ ] **Zero-copy array access** — return numpy views backed by Rust-owned memory
+- [ ] **Zero-copy array access** -- return numpy views backed by Rust-owned memory
       instead of copying, for large-scale workloads.
-- [x] **CycleToRTMapping exposure** — `rt_seconds_to_cycle_index`, `cycle_index_to_rt_ms`,
+- [x] **CycleToRTMapping exposure** -- `rt_seconds_to_cycle_index`, `cycle_index_to_rt_ms`,
       `rt_values_ms`, `num_cycles`, `rt_range_ms` on `PyTimsIndex`.
-- [ ] **Library file I/O** — read DIA-NN / Spectronaut libraries directly into
+- [ ] **Library file I/O** -- read DIA-NN / Spectronaut libraries directly into
       lists of `PyElutionGroup`, removing boilerplate on the Python side.
-- [x] **Streaming queries** — `query_chromatograms_iter` streams from any Python
+- [x] **Streaming queries** -- `query_chromatograms_iter` streams from any Python
       iterator with chunked rayon parallelism and internal collector reuse.
diff --git a/python/timsquery_pyo3/examples/streaming_example.py b/python/timsquery_pyo3/examples/streaming_example.py
index 3dcf446d..9c8bc715 100644
--- a/python/timsquery_pyo3/examples/streaming_example.py
+++ b/python/timsquery_pyo3/examples/streaming_example.py
@@ -12,9 +12,9 @@
 
 This example demonstrates the three query modes in timsquery_pyo3:
 
-  1. Single query           — one elution group at a time
-  2. Aggregator reuse       — reuse allocations across sequential queries
-  3. Streaming iterator     — iterator-in, iterator-out with chunked parallelism
+  1. Single query           -- one elution group at a time
+  2. Aggregator reuse       -- reuse allocations across sequential queries
+  3. Streaming iterator     -- iterator-in, iterator-out with chunked parallelism
 
 Usage:
     uv run examples/streaming_example.py <path_to_experiment.d>
@@ -106,7 +106,7 @@ def main():
     print(f"  loaded in {time.perf_counter() - t0:.2f}s  ({index})")
 
     # ------------------------------------------------------------------
-    # Set up tolerances — narrow search window
+    # Set up tolerances -- narrow search window
     # ------------------------------------------------------------------
     tolerance = tq.PyTolerance(
         mz=tq.PyMzTolerance.ppm(10.0, 10.0),
diff --git a/python/timsquery_pyo3/src/elution_group.rs b/python/timsquery_pyo3/src/elution_group.rs
index 0724d342..c4424a43 100644
--- a/python/timsquery_pyo3/src/elution_group.rs
+++ b/python/timsquery_pyo3/src/elution_group.rs
@@ -5,7 +5,7 @@ use timsquery::tinyvec::tiny_vec;
 /// An elution group defines a query target: one precursor and its fragments.
 ///
 /// NOTE: Fragment labels are `usize` only in this binding. This is a deliberate
-/// simplification — the Rust side is generic over `T: KeyLike` but we monomorphize
+/// simplification -- the Rust side is generic over `T: KeyLike` but we monomorphize
 /// to `usize` here for a clean Python interface. Other key types (e.g. `IonAnnot`)
 /// may be added in future versions.
 #[pyclass(skip_from_py_object)]
diff --git a/python/timsquery_pyo3/src/iterator.rs b/python/timsquery_pyo3/src/iterator.rs
index 2e051b1e..59b362ed 100644
--- a/python/timsquery_pyo3/src/iterator.rs
+++ b/python/timsquery_pyo3/src/iterator.rs
@@ -23,7 +23,7 @@ pub enum ToleranceSource {
 /// Lightweight result yielded by the streaming iterator.
 ///
 /// Owns materialized numpy arrays and metadata. The iterator's internal
-/// collector pool is never exposed — it reuses Rust-side buffers across chunks.
+/// collector pool is never exposed -- it reuses Rust-side buffers across chunks.
 #[pyclass(frozen)]
 pub struct PyChromatogramArrays {
     id: timsquery::models::OwnedSourceId,
diff --git a/python/timsquery_pyo3/src/spectrum.rs b/python/timsquery_pyo3/src/spectrum.rs
index 305ded54..0927c66d 100644
--- a/python/timsquery_pyo3/src/spectrum.rs
+++ b/python/timsquery_pyo3/src/spectrum.rs
@@ -4,7 +4,7 @@ use timsquery::{
     SpectralCollector,
 };
 
-/// Result of a spectral query — total summed intensity per ion.
+/// Result of a spectral query -- total summed intensity per ion.
 ///
 /// Each precursor/fragment gets a single f32 intensity value (summed
 /// across all matching peaks within the tolerance window).
diff --git a/rust/alloc_track/src/lib.rs b/rust/alloc_track/src/lib.rs
index 495d5096..9ab6d194 100644
--- a/rust/alloc_track/src/lib.rs
+++ b/rust/alloc_track/src/lib.rs
@@ -91,7 +91,7 @@ mod imp {
     static COUNT: AtomicU64 = AtomicU64::new(0);
     static LIVE: AtomicU64 = AtomicU64::new(0);
     static PEAK: AtomicU64 = AtomicU64::new(0);
-    /// Number of `on_dealloc` calls whose size exceeded observed `LIVE` —
+    /// Number of `on_dealloc` calls whose size exceeded observed `LIVE` --
     /// i.e. accounting drift (layout mismatch, custom allocator bug, etc.).
     /// Reported by [`report_snapshot_diff`]; nonzero means numbers are suspect.
     static DEALLOC_UNDERFLOWS: AtomicU64 = AtomicU64::new(0);
@@ -124,7 +124,7 @@ mod imp {
     pub(crate) fn on_dealloc(size: usize) {
         let s = size as u64;
         // Atomic saturating sub. Drift (curr < s) means the inner allocator
-        // reported mismatched layouts — accounting is already wrong, so we
+        // reported mismatched layouts -- accounting is already wrong, so we
         // clamp LIVE to 0, bump DEALLOC_UNDERFLOWS, and let report_snapshot_diff
         // surface it. Cannot panic/log from the hook: both may allocate and
         // recurse into this function. The debug_assert catches drift in tests;
@@ -189,7 +189,7 @@ mod imp {
         let drift = DEALLOC_UNDERFLOWS.load(Ordering::Relaxed);
         if drift > 0 {
             eprintln!(
-                "[alloc] WARNING: {drift} dealloc underflow(s) observed — live/peak numbers above are suspect."
+                "[alloc] WARNING: {drift} dealloc underflow(s) observed -- live/peak numbers above are suspect."
             );
         }
     }
diff --git a/rust/apex_sim/src/bench.rs b/rust/apex_sim/src/bench.rs
index cf71ed55..71302af8 100644
--- a/rust/apex_sim/src/bench.rs
+++ b/rust/apex_sim/src/bench.rs
@@ -423,7 +423,7 @@ pub struct ScorePopulations {
 
 /// Score `n_seed_pairs` matched present/absent realizations (varying only the
 /// seed). Each pair shares a seed, so the "absent" twin has IDENTICAL noise +
-/// interferents — only the real peak differs.
+/// interferents -- only the real peak differs.
 pub fn score_populations(base: &SimParams, n_seed_pairs: usize) -> ScorePopulations {
     let map = base.rt_mapper();
     let mut scorer = TraceScorer::new(base.n_cycles, base.real_fragments.len().max(1));
diff --git a/rust/apex_sim/src/plots.rs b/rust/apex_sim/src/plots.rs
index 60f6359f..79015208 100644
--- a/rust/apex_sim/src/plots.rs
+++ b/rust/apex_sim/src/plots.rs
@@ -357,7 +357,7 @@ fn log10_positive(vals: &[f32]) -> Vec<f64> {
 /// Fraction-per-bin bars over `[lo, hi]`: heights sum to 1, so populations of
 /// different size stay comparable. Returns the bars and the tallest height.
 ///
-/// `hi` must exceed `lo` — an empty range would give zero-width bins, so
+/// `hi` must exceed `lo` -- an empty range would give zero-width bins, so
 /// callers widen degenerate (all-equal) populations first.
 fn hist_bars(logs: &[f64], lo: f64, hi: f64) -> (Vec<Bar>, f64) {
     debug_assert!(hi > lo, "empty bin range [{lo}, {hi}]");
diff --git a/rust/apex_sim/src/scorer.rs b/rust/apex_sim/src/scorer.rs
index 45b36979..4aa6e206 100644
--- a/rust/apex_sim/src/scorer.rs
+++ b/rust/apex_sim/src/scorer.rs
@@ -98,7 +98,7 @@ pub fn run(
         pass2,
     } = run_with(&mut scorer, extraction, rt_mapper)?;
     // Traces and the window-global apex evidence are already computed, so each
-    // extra `score_at` is just the cycle-local feature block — the sweep is
+    // extra `score_at` is just the cycle-local feature block -- the sweep is
     // O(cycles * window), not O(cycles^2). Cycles that fail to score give 0.
     let landscape = (0..n_cycles)
         .map(|c| {
@@ -157,7 +157,7 @@ mod tests {
         let res = run(&data.extraction, &p.rt_mapper()).unwrap();
 
         assert_eq!(res.landscape.len(), p.n_cycles);
-        // On a clean peak the reported main score IS the landscape maximum —
+        // On a clean peak the reported main score IS the landscape maximum --
         // i.e. the scored apex is the best cycle in the window, not just a
         // cycle the landscape happens to agree with.
         let best = res
diff --git a/rust/apex_sim/src/sim.rs b/rust/apex_sim/src/sim.rs
index 30734543..4f287bd7 100644
--- a/rust/apex_sim/src/sim.rs
+++ b/rust/apex_sim/src/sim.rs
@@ -70,7 +70,7 @@ pub struct RandomPeaks {
     pub hit_precursors: bool,
     /// Interferents per cycle; when > 0 this overrides `count` as
     /// `round(density_per_cycle * n_cycles * hardness)`, so interferent DENSITY
-    /// (not absolute count) stays fixed as the window widens — a fixed count in
+    /// (not absolute count) stays fixed as the window widens -- a fixed count in
     /// a wide window is an artificially easy task.
     pub density_per_cycle: f32,
     /// Multiplier (>=1) to deliberately over-load interferents above realistic
@@ -672,8 +672,8 @@ mod tests {
         let (half, full) = (peak(0), peak(1));
 
         // Both rows co-elute at the same realized (off-grid) apex with the same
-        // width, so every shape term — peak height scale, the gaussian, the
-        // sub-cycle sampling loss — is common to both and cancels in the ratio.
+        // width, so every shape term -- peak height scale, the gaussian, the
+        // sub-cycle sampling loss -- is common to both and cancels in the ratio.
         // What survives is exactly the obs_scale ratio, computed WITHOUT
         // reproducing any of the generator's own arithmetic.
         assert!(full > 0.0, "reference fragment must carry signal: {full}");
diff --git a/rust/array2d/src/lib.rs b/rust/array2d/src/lib.rs
index 029343ab..f1b5f8b3 100644
--- a/rust/array2d/src/lib.rs
+++ b/rust/array2d/src/lib.rs
@@ -74,7 +74,7 @@ impl<T: ArrayElement> Default for Array2D<T> {
 impl<T: ArrayElement> Array2D<T> {
     /// Construct a zero-dimensional `Array2D` whose backing `Vec` has enough
     /// capacity for `ncols * nrows` elements. Use this for scratch buffers
-    /// that will be populated via [`Array2D::reset_with_value`] — the first
+    /// that will be populated via [`Array2D::reset_with_value`] -- the first
     /// call won't reallocate as long as its size fits the reserved capacity.
     pub fn with_capacity(ncols: usize, nrows: usize) -> Self {
         Self {
diff --git a/rust/calib_dash/src/app.rs b/rust/calib_dash/src/app.rs
index 4af6073f..b32fea85 100644
--- a/rust/calib_dash/src/app.rs
+++ b/rust/calib_dash/src/app.rs
@@ -56,7 +56,7 @@ impl Tab {
 /// cycled by `m`/`M`. Exactly one is active at a time.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum Layer {
-    /// Bare heatmap — the raw density the fit works from.
+    /// Bare heatmap -- the raw density the fit works from.
     None,
     /// The DP chain and the greedily attached tails, glyph-distinguished within the
     /// layer (`O`/`X`): is a bad edge the DP's choice or a tail grafted on after?
@@ -106,7 +106,7 @@ fn cycle<T: PartialEq + Copy, const N: usize>(
 }
 
 /// Whether the batch loop driving Phase 1 scoring should keep going after a pause.
-/// Only `Ctrl-C` ever produces `Abort` — a dashboard failure anywhere else is
+/// Only `Ctrl-C` ever produces `Abort` -- a dashboard failure anywhere else is
 /// logged and treated as `Continue`, since a dev tool must never fail a search.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Flow {
@@ -117,12 +117,12 @@ pub enum Flow {
 /// What the user asked for on leaving a pause.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum PauseAction {
-    /// Stay in the pause — the key changed the view, not the flow.
+    /// Stay in the pause -- the key changed the view, not the flow.
     Stay,
     /// Advance this many batches before pausing again.
     Next(u32),
     /// Stop showing the dashboard and let the pipeline run on. Both `r` (run to
-    /// end) and `q` (detach) land here — they differ only in what the user meant,
+    /// end) and `q` (detach) land here -- they differ only in what the user meant,
     /// not in what happens.
     Detach,
     Abort,
@@ -156,7 +156,7 @@ impl Stepper {
         true
     }
 
-    /// Whether a prior pause resolved to `Detach` or `Abort` — the user has already
+    /// Whether a prior pause resolved to `Detach` or `Abort` -- the user has already
     /// asked to stop seeing the dashboard, and nothing should reopen it.
     fn is_stopped(&self) -> bool {
         self.stopped
@@ -199,11 +199,11 @@ pub(crate) struct App {
     /// Bounded by `frames.retained`; the recording lives in `scrub_recording`.
     scrub_frame: Option<usize>,
     /// The original batch/chunk number of `scrub_frame`, for the Fit tab's "not live"
-    /// banner — "frame 2 of 5" alone means little to a user who thinks in batches.
+    /// banner -- "frame 2 of 5" alone means little to a user who thinks in batches.
     scrub_chunk: Option<usize>,
     /// The scrubbed frame's refit recording. `None` whenever `scrub_frame` is, and
     /// also momentarily after `scrub_frame` moves and before the next `sync_scrub`
-    /// catches up — `active_recording` falls back to the live view for that gap.
+    /// catches up -- `active_recording` falls back to the live view for that gap.
     scrub_recording: Option<FitRecording>,
     /// Whether the `?` key-map overlay is open. Modal: while it shows, every keypress
     /// (digits and `Ctrl-C` included) only dismisses it.
@@ -286,7 +286,7 @@ impl App {
 
     /// What the Fit tab should actually draw: the scrubbed frame's recording while
     /// `scrub_frame` is set and `sync_scrub` has caught up to it, the live `recording`
-    /// otherwise — never a blank tab for the gap between the two.
+    /// otherwise -- never a blank tab for the gap between the two.
     pub(crate) fn active_recording(&self) -> &FitRecording {
         if self.scrub_frame.is_some()
             && let Some(rec) = self.scrub_recording.as_ref()
@@ -317,7 +317,7 @@ impl App {
         self.scrub_recording = Some(recording);
     }
 
-    /// Drops back to the live view — the user scrubbed past the last retained frame,
+    /// Drops back to the live view -- the user scrubbed past the last retained frame,
     /// or a frame could not be refit and live beats a stale or absent recording.
     pub(crate) fn clear_scrub(&mut self) {
         self.scrub_frame = None;
@@ -339,7 +339,7 @@ impl App {
     }
 
     /// Folds one more digit into the pending count. A leading `0` does not start a
-    /// count — matching vim, which keeps `0` free as a motion — but extends one.
+    /// count -- matching vim, which keeps `0` free as a motion -- but extends one.
     fn push_digit(&mut self, d: u32) {
         if d == 0 && self.count.is_none() {
             return;
@@ -359,7 +359,7 @@ impl App {
     }
 
     /// Moves the cursor forward by `n`. Past the last retained frame this returns to
-    /// the live view rather than clamping — "keep pressing `>` and you get to now".
+    /// the live view rather than clamping -- "keep pressing `>` and you get to now".
     fn scrub_forward(&mut self, n: u32) {
         let Some(i) = self.scrub_frame else {
             return;
@@ -503,7 +503,7 @@ fn as_calibrt_tuple(p: &CalibrantPoint) -> (LibraryRT<f64>, ObservedRTSeconds<f6
 /// and RT tolerances plus how many calibrants they came from.
 ///
 /// `mz_ppm` and `mobility_pct` are signed `(lo, hi)` windows around zero and are
-/// genuinely asymmetric — Step B can derive a different tolerance on either side of a
+/// genuinely asymmetric -- Step B can derive a different tolerance on either side of a
 /// calibrant. `rt_seconds` is symmetric by construction.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct ToleranceSummary {
@@ -537,7 +537,7 @@ pub struct CalibDash {
     /// replaying that frame would disagree with what was shown live.
     current_points: Vec<CalibrantPoint>,
     n_calibrants: usize,
-    /// The previous batch's points, for `churn`. Empty before the first batch —
+    /// The previous batch's points, for `churn`. Empty before the first batch --
     /// `churn`'s own "everything admitted, nothing evicted" case.
     prev_points: Vec<CalibrantPoint>,
     /// The previous batch's fitted curve, for `curve_delta`. `None` before the first
@@ -583,7 +583,7 @@ impl CalibDash {
     }
 
     /// In order: record the frame, re-fit the live curve from those same points, push
-    /// this batch's metrics (every batch, rendered or not — see `metrics.rs`), then
+    /// this batch's metrics (every batch, rendered or not -- see `metrics.rs`), then
     /// either continue or pause to render.
     ///
     /// `Flow::Abort` happens only because the user pressed Ctrl-C at a pause: a
@@ -628,7 +628,7 @@ impl CalibDash {
     }
 
     /// Promotes the reserved final frame and refreshes the Convergence header's
-    /// decimation numbers one last time — the promotion can change them.
+    /// decimation numbers one last time -- the promotion can change them.
     pub fn finish(&mut self) {
         self.frames.finish();
         self.sync_frame_summary();
@@ -641,7 +641,7 @@ impl CalibDash {
 
     /// Re-fits a recorded frame's points from scratch, into `refit_state`/
     /// `refit_recording` rather than the live pair, through the same `fit_points`
-    /// sequence `refit_live` runs — so this reproduces the batch that actually ran.
+    /// sequence `refit_live` runs -- so this reproduces the batch that actually ran.
     /// `None` if the frame index doesn't exist or the re-fit was skipped.
     fn refit_frame(&mut self, i: usize) -> Option<(usize, &FitRecording)> {
         let (chunk, pts) = self.frames.frame(i)?;
@@ -851,7 +851,7 @@ mod tests {
             .collect()
     }
 
-    /// `n` retained frames, nothing decimated — what the scrubber tests need.
+    /// `n` retained frames, nothing decimated -- what the scrubber tests need.
     fn retained(n: usize) -> FrameSummary {
         FrameSummary {
             retained: n,
@@ -865,7 +865,7 @@ mod tests {
         rec.curve().map_or_else(Vec::new, |c| c.points().to_vec())
     }
 
-    /// Pointwise curve equality — behind every "what you scrub is what ran" test.
+    /// Pointwise curve equality -- behind every "what you scrub is what ran" test.
     fn assert_same_curve(live: &[Point], refit: &[Point]) {
         assert_eq!(live.len(), refit.len(), "curve lengths differ");
         for (a, b) in live.iter().zip(refit) {
@@ -1158,7 +1158,7 @@ mod tests {
     ///
     /// The backward keys make the reduction load-bearing rather than merely fast:
     /// `cycle` walks back by `n - steps`, which underflows for any count past the stop
-    /// list's length — and a count past 5 is an ordinary keystroke.
+    /// list's length -- and a count past 5 is an ordinary keystroke.
     #[test]
     fn a_huge_count_before_a_cycling_key_does_not_spin_or_underflow() {
         let mut app = App::new(10);
@@ -1273,7 +1273,7 @@ mod tests {
     }
 
     /// An overlong batch (more points than `n_calibrants`) must not let the live re-fit
-    /// see points the frame slab never recorded — `FrameStore` truncates its own copy,
+    /// see points the frame slab never recorded -- `FrameStore` truncates its own copy,
     /// and `on_batch` must clamp identically.
     #[test]
     fn an_overlong_batch_is_clamped_the_same_way_the_frame_slab_clamps_it() {
diff --git a/rust/calib_dash/src/bin/calib_dash.rs b/rust/calib_dash/src/bin/calib_dash.rs
index 2e1f306b..0fedce0a 100644
--- a/rust/calib_dash/src/bin/calib_dash.rs
+++ b/rust/calib_dash/src/bin/calib_dash.rs
@@ -1,9 +1,9 @@
-//! Standalone replay of a saved `calibration.json` — the RT calibration
+//! Standalone replay of a saved `calibration.json` -- the RT calibration
 //! dashboard without a live Phase 1 search behind it.
 //!
 //! The loaded points become a single Phase-1-shaped batch (chunk 0, one frame),
 //! so the batch scrubber shows one frame and the Convergence tab's history is a
-//! single point — a Phase 2 snapshot is one fit, not a run's sequence of batches.
+//! single point -- a Phase 2 snapshot is one fit, not a run's sequence of batches.
 
 use calib_dash::{
     CalibDash,
@@ -66,8 +66,8 @@ fn main() {
     dash.finish();
 }
 
-/// Reads `path` and keeps only the snapshot. The residual block is left opaque —
-/// nothing here reads it — and the provenance warning is dropped: there is no raw
+/// Reads `path` and keeps only the snapshot. The residual block is left opaque --
+/// nothing here reads it -- and the provenance warning is dropped: there is no raw
 /// file to check the calibration against.
 fn load_snapshot(path: &Path) -> Result<CalibrationSnapshot, String> {
     let (saved, _) = calibrt::SavedCalibration::<serde_json::Value>::read(path, None)?;
@@ -80,11 +80,11 @@ fn load_snapshot(path: &Path) -> Result<CalibrationSnapshot, String> {
 /// needs at least 2 points to define a curve.
 fn validate_snapshot(snapshot: &CalibrationSnapshot) -> Result<(), String> {
     if snapshot.grid_size == 0 {
-        return Err("grid_size is 0 — a calibration grid needs at least 1 bin".to_string());
+        return Err("grid_size is 0 -- a calibration grid needs at least 1 bin".to_string());
     }
     if snapshot.points.len() < 2 {
         return Err(format!(
-            "only {} calibrant point(s) in \"calibration.points\" — at least 2 are needed to \
+            "only {} calibrant point(s) in \"calibration.points\" -- at least 2 are needed to \
              fit a curve",
             snapshot.points.len()
         ));
@@ -104,7 +104,7 @@ mod tests {
     #[test]
     fn a_file_of_a_foreign_version_is_refused() {
         // The handle is held (not just its path) because dropping it is what
-        // deletes the file — including when the test fails.
+        // deletes the file -- including when the test fails.
         let mut f = NamedTempFile::new().expect("a writable temp dir");
         f.write_all(
             br#"{
diff --git a/rust/calib_dash/src/metrics.rs b/rust/calib_dash/src/metrics.rs
index 9fcc4115..d7eb224a 100644
--- a/rust/calib_dash/src/metrics.rs
+++ b/rust/calib_dash/src/metrics.rs
@@ -27,7 +27,7 @@ pub struct BatchMetrics {
 /// spaced points in `x_range`.
 ///
 /// Samples where either curve is out of bounds are skipped rather than counted
-/// as zero — counting them would dilute the mean toward zero exactly when the
+/// as zero -- counting them would dilute the mean toward zero exactly when the
 /// curves disagree most about their domain, which is the opposite of the signal
 /// wanted here.
 pub fn curve_delta(
@@ -124,7 +124,7 @@ mod tests {
     }
 
     /// Both signs of the same offset. The delta is a *magnitude*, so a curve
-    /// that moved down by 2 must report the same 2 as one that moved up by 2 —
+    /// that moved down by 2 must report the same 2 as one that moved up by 2 --
     /// without the `.abs()`, the downward direction reports `max = 0` (the
     /// running max never rises above its 0.0 seed) and a negative mean.
     #[test]
@@ -159,7 +159,7 @@ mod tests {
     /// 0.0 (which would read as "the curves agree").
     #[test]
     fn samples_outside_both_curves_are_skipped() {
-        // (b's x range, x range sampled, expected delta — None for NaN)
+        // (b's x range, x range sampled, expected delta -- None for NaN)
         let cases = [
             ((0.0, 5.0), (0.0, 10.0), Some(3.0)),
             ((20.0, 25.0), (0.0, 5.0), None),
diff --git a/rust/calib_dash/src/recording.rs b/rust/calib_dash/src/recording.rs
index b6464a0b..ba0a3ce1 100644
--- a/rust/calib_dash/src/recording.rs
+++ b/rust/calib_dash/src/recording.rs
@@ -1,7 +1,7 @@
 //! An owned copy of everything a finished [`calibrt::CalibrationState`] holds
 //! that a panel draws: the grid it fit on, and the fit's products.
 //!
-//! `weights` are `f32` for storage and display only — every metric is computed
+//! `weights` are `f32` for storage and display only -- every metric is computed
 //! from the `f64` values on the state, never from this downcast copy.
 
 use calibrt::{
@@ -17,7 +17,7 @@ pub struct FitRecording {
     weights: Vec<f32>,
     suppressed: Vec<bool>,
     /// See [`calibrt::CalibrationState::path_indices`]. The `bins` capacity is a
-    /// hint, not a bound — weight ties can push the survivor count past it.
+    /// hint, not a bound -- weight ties can push the survivor count past it.
     path_indices: Vec<usize>,
     /// See [`calibrt::CalibrationState::dp_range`].
     dp_range: std::ops::Range<usize>,
@@ -37,7 +37,7 @@ impl FitRecording {
             },
             weights: vec![0.0; bins * bins],
             suppressed: vec![false; bins * bins],
-            // Capacity hint only — see the field doc comment.
+            // Capacity hint only -- see the field doc comment.
             path_indices: Vec::with_capacity(bins),
             dp_range: 0..0,
             curve: None,
@@ -131,7 +131,7 @@ mod tests {
         // `col_of`/`row_of` would pass unnoticed without this one. Weight 0.5
         // is too light to be a row/column max next to the diagonal's weight-8
         // entry at row 7 and weight-3 entry at col 2, so it is suppressed and
-        // does not disturb the path/curve length assertions below — it only
+        // does not disturb the path/curve length assertions below -- it only
         // needs to show up in the raw weight grid.
         s.update(std::iter::once((
             LibraryRT(2.5),
@@ -159,7 +159,7 @@ mod tests {
         assert_eq!(rec.curve().unwrap().points().len(), 10);
     }
 
-    /// Nothing has been fit, so nothing is outstanding — Phase 1 draws an empty
+    /// Nothing has been fit, so nothing is outstanding -- Phase 1 draws an empty
     /// Fit tab before the first fit runs.
     #[test]
     fn a_recording_with_no_fit_reads_as_empty() {
@@ -201,7 +201,7 @@ mod tests {
         s.fit();
         assert!(
             !FitRecording::from_state(&s).is_suppressed(1, 1),
-            "A survives alone in its row/col on the second fit — a stale bit \
+            "A survives alone in its row/col on the second fit -- a stale bit \
              from the first fit must not linger"
         );
     }
@@ -255,7 +255,7 @@ mod tests {
                 rec.ridge().len()
             ),
             (10, 10, 10),
-            "the refit's own entries only — 13 of each would mean the first \
+            "the refit's own entries only -- 13 of each would mean the first \
              fit's leaked through"
         );
     }
diff --git a/rust/calib_dash/src/snapshots/calib_dash__ui__tests__fit_layer_Curve.snap b/rust/calib_dash/src/snapshots/calib_dash__ui__tests__fit_layer_Curve.snap
index edae2186..3b96dd1e 100644
--- a/rust/calib_dash/src/snapshots/calib_dash__ui__tests__fit_layer_Curve.snap
+++ b/rust/calib_dash/src/snapshots/calib_dash__ui__tests__fit_layer_Curve.snap
@@ -2,8 +2,8 @@
 source: rust/calib_dash/src/ui.rs
 expression: out
 ---
-    ┌ Fit — observed RT (s) ↑ vs library RT (s) → ───────────────────────────────────────────── b0 ┐
-    │ Showing: curve — fitted calibration                                                          │
+    ┌ Fit -- observed RT (s) ↑ vs library RT (s) → ──────────────────────────────────────────── b0 ┐
+    │ Showing: curve -- fitted calibration                                                         │
     │                                                                                              │
     │                                                                                        ▄▄▄▄▄▄│
     │                                                                                        ░░░░░░│
diff --git a/rust/calib_dash/src/snapshots/calib_dash__ui__tests__fit_layer_None.snap b/rust/calib_dash/src/snapshots/calib_dash__ui__tests__fit_layer_None.snap
index e22b382c..38162e04 100644
--- a/rust/calib_dash/src/snapshots/calib_dash__ui__tests__fit_layer_None.snap
+++ b/rust/calib_dash/src/snapshots/calib_dash__ui__tests__fit_layer_None.snap
@@ -2,8 +2,8 @@
 source: rust/calib_dash/src/ui.rs
 expression: out
 ---
-    ┌ Fit — observed RT (s) ↑ vs library RT (s) → ───────────────────────────────────────────── b0 ┐
-    │ Showing: none — density only                                                                 │
+    ┌ Fit -- observed RT (s) ↑ vs library RT (s) → ──────────────────────────────────────────── b0 ┐
+    │ Showing: none -- density only                                                                │
     │                                                                                              │
     │                                                                                        ▄▄▄▄▄▄│
     │                                                                                        ░░░░░░│
diff --git a/rust/calib_dash/src/snapshots/calib_dash__ui__tests__fit_layer_Path.snap b/rust/calib_dash/src/snapshots/calib_dash__ui__tests__fit_layer_Path.snap
index 80ec39cc..045ae801 100644
--- a/rust/calib_dash/src/snapshots/calib_dash__ui__tests__fit_layer_Path.snap
+++ b/rust/calib_dash/src/snapshots/calib_dash__ui__tests__fit_layer_Path.snap
@@ -2,8 +2,8 @@
 source: rust/calib_dash/src/ui.rs
 expression: out
 ---
-    ┌ Fit — observed RT (s) ↑ vs library RT (s) → ───────────────────────────────────────────── b0 ┐
-    │ Showing: path — O chosen, X greedy tail                                                      │
+    ┌ Fit -- observed RT (s) ↑ vs library RT (s) → ──────────────────────────────────────────── b0 ┐
+    │ Showing: path -- O chosen, X greedy tail                                                     │
     │                                                                                              │
     │                                                                                        ▄▄▄▄▄▄│
     │                                                                                        X░░░░░│
diff --git a/rust/calib_dash/src/snapshots/calib_dash__ui__tests__fit_tab_shows_a_banner_and_a_different_grid_when_scrubbing.snap b/rust/calib_dash/src/snapshots/calib_dash__ui__tests__fit_tab_shows_a_banner_and_a_different_grid_when_scrubbing.snap
index 2b766476..205bf24e 100644
--- a/rust/calib_dash/src/snapshots/calib_dash__ui__tests__fit_tab_shows_a_banner_and_a_different_grid_when_scrubbing.snap
+++ b/rust/calib_dash/src/snapshots/calib_dash__ui__tests__fit_tab_shows_a_banner_and_a_different_grid_when_scrubbing.snap
@@ -2,9 +2,9 @@
 source: rust/calib_dash/src/ui.rs
 expression: "render_snapshot(&mut app, 100, 30)"
 ---
- SCRUBBED — retained frame 3/5, batch 17 (not live; `>` returns to now)                             
-    ┌ Fit — observed RT (s) ↑ vs library RT (s) → ───────────────────────────────────────────── b0 ┐
-    │ Showing: none — density only                                                                 │
+ SCRUBBED -- retained frame 3/5, batch 17 (not live; `>` returns to now)                            
+    ┌ Fit -- observed RT (s) ↑ vs library RT (s) → ──────────────────────────────────────────── b0 ┐
+    │ Showing: none -- density only                                                                │
     │                                                                                  ████████████│
   15┤                                                                                  ████████████│
     │                                                                      ▄▄▄▄▄▄▄▄▄▄▄▄████████████│
diff --git a/rust/calib_dash/src/snapshots/calib_dash__ui__tests__the_keys_overlay_lists_every_binding_over_the_tab_beneath_it.snap b/rust/calib_dash/src/snapshots/calib_dash__ui__tests__the_keys_overlay_lists_every_binding_over_the_tab_beneath_it.snap
index 8ef621e9..48742401 100644
--- a/rust/calib_dash/src/snapshots/calib_dash__ui__tests__the_keys_overlay_lists_every_binding_over_the_tab_beneath_it.snap
+++ b/rust/calib_dash/src/snapshots/calib_dash__ui__tests__the_keys_overlay_lists_every_binding_over_the_tab_beneath_it.snap
@@ -3,8 +3,8 @@ source: rust/calib_dash/src/ui.rs
 expression: "render(&mut app, 100, 30)"
 ---
  Fit │ Convergence │ Tolerances                                                                     
-    ┌ Fit — observed RT (s) ↑ vs library RT (s) → ───────────────────────────────────────────── b0 ┐
-    │ Showing: none — density only                                                                 │
+    ┌ Fit -- observed RT (s) ↑ vs library RT (s) → ──────────────────────────────────────────── b0 ┐
+    │ Showing: none -- density only                                                                │
     │                                                                                              │
     │                                                                                        ▄▄▄▄▄▄│
     │                                                                                        ░░░░░░│
diff --git a/rust/calib_dash/src/ui.rs b/rust/calib_dash/src/ui.rs
index eeff25e4..fc1abc14 100644
--- a/rust/calib_dash/src/ui.rs
+++ b/rust/calib_dash/src/ui.rs
@@ -11,8 +11,8 @@
 //! `Modifier::REVERSED` says *what mode the screen is in*: the selected tab, a
 //! scrubbed (not live) frame, an accumulating count, a marked heatmap cell.
 //! Color says *what a thing is*: the density ramp and the mark kinds. Apart,
-//! neither channel has to mean three things at once, and inversion — a swap of
-//! whatever colors are already there — survives a colorblind reader, a
+//! neither channel has to mean three things at once, and inversion -- a swap of
+//! whatever colors are already there -- survives a colorblind reader, a
 //! monochrome screenshot and any terminal theme. `Mark` is the only place that
 //! adds to this.
 //!
@@ -21,7 +21,7 @@
 //! `paint_heatmap` runs exactly one `mark_*` arm per draw (`crate::Layer`, cycled
 //! by `m`/`M`), and each layer is internally overlap-free: the DP chain and greedy
 //! tails partition the path by construction, and the other three layers only emit
-//! `Mark::Region`. So no cross-layer priority exists to resolve below — `Mark`'s
+//! `Mark::Region`. So no cross-layer priority exists to resolve below -- `Mark`'s
 //! `Ord` only arbitrates a DP node against a tail node rounded into one cell.
 //!
 //! Nothing to draw, or no room to draw it in, renders a `Paragraph` saying so
@@ -151,7 +151,7 @@ const GLOBAL_KEYS: &[Binding] = &[
 const TAB_KEYS_AT: usize = 2;
 
 /// `?` itself, listed apart from `GLOBAL_KEYS` because the status line pins it
-/// to its own right-hand column — see `fit_status_hints`.
+/// to its own right-hand column -- see `fit_status_hints`.
 const KEYS_OVERLAY_KEY: Binding = Binding::new("?", "keys", "this screen");
 
 const FIT_KEYS: &[Binding] = &[
@@ -164,7 +164,7 @@ fn tab_keys(tab: Tab) -> &'static [Binding] {
     if tab == Tab::Fit { FIT_KEYS } else { &[] }
 }
 
-/// One `key`/`action` hint per binding: the key `BOLD`, the action `DarkGray` —
+/// One `key`/`action` hint per binding: the key `BOLD`, the action `DarkGray` --
 /// weight is what makes the bound letter scannable. `actions` false renders the
 /// keys alone, which is how the degrade below sheds action words but not keys.
 fn binding_spans(bindings: &[Binding], actions: bool) -> Vec<Span<'static>> {
@@ -194,7 +194,7 @@ fn binding_spans(bindings: &[Binding], actions: bool) -> Vec<Span<'static>> {
 /// The most detailed hint line (tab-local plus global bindings, ordered as
 /// `TAB_KEYS_AT` describes) that still fits `width`, degrading in stages: full
 /// text, keys only, global keys only, nothing. `? keys` is never part of this
-/// line — it has its own pinned-right column, so it survives every stage.
+/// line -- it has its own pinned-right column, so it survives every stage.
 fn fit_status_hints(tab_local: &[Binding], width: usize) -> Line<'static> {
     let (head, tail) = GLOBAL_KEYS.split_at(TAB_KEYS_AT);
     let full: Vec<Binding> = head.iter().chain(tab_local).chain(tail).copied().collect();
@@ -212,7 +212,7 @@ fn fit_status_hints(tab_local: &[Binding], width: usize) -> Line<'static> {
 }
 
 /// The status line: batch/pending-count on the left, key hints in the middle
-/// (degrading as `fit_status_hints` describes), `? keys` pinned to the right —
+/// (degrading as `fit_status_hints` describes), `? keys` pinned to the right --
 /// one `Paragraph` per column, so the right one stays right-aligned.
 fn draw_status_line(frame: &mut Frame, area: Rect, app: &App) {
     let mut state_spans = vec![Span::raw(format!(" b{} ", app.batch()))];
@@ -315,7 +315,7 @@ fn draw_scrub_banner(frame: &mut Frame, area: Rect, app: &App, frame_index: usiz
         .map(|c| format!(", batch {c}"))
         .unwrap_or_default();
     let text = format!(
-        " SCRUBBED — retained frame {}/{}{batch_note} (not live; `>` returns to now)",
+        " SCRUBBED -- retained frame {}/{}{batch_note} (not live; `>` returns to now)",
         frame_index + 1,
         app.frames().retained.max(1),
     );
@@ -329,8 +329,8 @@ fn draw_scrub_banner(frame: &mut Frame, area: Rect, app: &App, frame_index: usiz
 /// What one half of a terminal cell is marked with, for whichever layer
 /// (`crate::Layer`) is active.
 ///
-/// **Invariant:** a `Region` mark keeps the density glyph — `░▒▓█▀▄`,
-/// half-occupancy intact — and is identified by inversion, so a mark and the
+/// **Invariant:** a `Region` mark keeps the density glyph -- `░▒▓█▀▄`,
+/// half-occupancy intact -- and is identified by inversion, so a mark and the
 /// distribution under it stay both visible; color (`region_accent`) is redundant
 /// reinforcement. `DpNode`/`Tail` are the exception: they *replace* the cell with
 /// `O`/`X`, a path node being a point estimate rather than a region.
@@ -341,17 +341,17 @@ fn draw_scrub_banner(frame: &mut Frame, area: Rect, app: &App, frame_index: usiz
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 enum Mark {
     None,
-    /// Curve, ridge or suppressed layer — the density glyph (or, in place of a
-    /// space, `\u{b7}` — see `compose_marked`), reversed.
+    /// Curve, ridge or suppressed layer -- the density glyph (or, in place of a
+    /// space, `\u{b7}` -- see `compose_marked`), reversed.
     Region,
-    /// Path layer, Pass 2's greedily attached tail — `X`, the standard
+    /// Path layer, Pass 2's greedily attached tail -- `X`, the standard
     /// excluded/suspect-point convention.
     Tail,
-    /// Path layer, the DP's own chosen chain — `O`.
+    /// Path layer, the DP's own chosen chain -- `O`.
     DpNode,
 }
 
-/// The active layer's accent color for a `Region` mark — reinforcement only (see
+/// The active layer's accent color for a `Region` mark -- reinforcement only (see
 /// `Mark`), so a named ANSI constant (see `heat_color`) and never one of indices
 /// 9-15 (`Light*`/`White`, invisible on a light background).
 fn region_accent(layer: Layer) -> Color {
@@ -412,7 +412,7 @@ impl Dims {
 }
 
 /// Which half of a terminal cell a grid row landed in. Tracked per half so two
-/// grid rows sharing a terminal line stay distinct — the doubled resolution
+/// grid rows sharing a terminal line stay distinct -- the doubled resolution
 /// `heatmap_cells` promises.
 #[derive(Clone, Copy)]
 enum Half {
@@ -421,14 +421,14 @@ enum Half {
 }
 
 impl Half {
-    /// Slot offset in a cell's pair of half-rows — the layout `heatmap_cells`'s
+    /// Slot offset in a cell's pair of half-rows -- the layout `heatmap_cells`'s
     /// `out` and the mark buffer share.
     fn slot(self) -> usize {
         usize::from(matches!(self, Half::Lower))
     }
 }
 
-/// Flips a display-row index so grid row 0 — the *lowest* observed RT — lands at
+/// Flips a display-row index so grid row 0 -- the *lowest* observed RT -- lands at
 /// the *bottom* of the canvas. Every y flip in this module goes through here.
 /// Without it grid row 0 would land at display row 0, the *top* one, and a
 /// monotonically increasing calibration would render as a *descending* line.
@@ -457,8 +457,8 @@ fn draw_heatmap(frame: &mut Frame, area: Rect, app: &App) {
         return;
     };
 
-    let title_left = " Fit \u{2014} observed RT (s) \u{2191} vs library RT (s) \u{2192} ";
-    // `batch` only — the active layer gets its own subtitle row below.
+    let title_left = " Fit -- observed RT (s) \u{2191} vs library RT (s) \u{2192} ";
+    // `batch` only -- the active layer gets its own subtitle row below.
     let title_right = format!(" b{} ", app.batch());
     frame.render_widget(
         Block::bordered()
@@ -499,7 +499,7 @@ fn draw_heatmap(frame: &mut Frame, area: Rect, app: &App) {
 }
 
 /// Where every piece of the framed heatmap goes: the block, the canvas painted
-/// inside it, and the three areas — y gutter, x label row, subtitle — that are
+/// inside it, and the three areas -- y gutter, x label row, subtitle -- that are
 /// `None` when the terminal has no room for them. `inner_width` is the canvas width
 /// the x ticks are spaced across, `y_target` the tick count the gutter holds.
 struct HeatmapLayout {
@@ -657,14 +657,14 @@ fn layer_gloss(layer: Layer) -> &'static str {
     }
 }
 
-/// The Fit heatmap's subtitle, spelled out as a label ("Showing: ridge —
+/// The Fit heatmap's subtitle, spelled out as a label ("Showing: ridge --
 /// tolerance band") rather than a key hint: a reader who does not know the active
-/// layer cannot interpret a single inverted cell. Degrades fits-or-drops — gloss
-/// first, then the label truncated — so it can never wrap or panic at `avail == 0`.
+/// layer cannot interpret a single inverted cell. Degrades fits-or-drops -- gloss
+/// first, then the label truncated -- so it can never wrap or panic at `avail == 0`.
 fn fit_subtitle(layer: Layer, avail: usize) -> String {
     let label = layer.label();
     let gloss = layer_gloss(layer);
-    let full = format!(" Showing: {label} \u{2014} {gloss} ");
+    let full = format!(" Showing: {label} -- {gloss} ");
     if full.chars().count() <= avail {
         return full;
     }
@@ -675,8 +675,8 @@ fn fit_subtitle(layer: Layer, avail: usize) -> String {
     label.chars().take(avail).collect()
 }
 
-/// Paints the half-block heatmap itself — density field plus the active mark
-/// layer — into `area`: the framed canvas's inner rect, or the whole Fit-tab body
+/// Paints the half-block heatmap itself -- density field plus the active mark
+/// layer -- into `area`: the framed canvas's inner rect, or the whole Fit-tab body
 /// on a terminal too small to frame.
 fn paint_heatmap(frame: &mut Frame, area: Rect, rec: &FitRecording, app: &App) {
     if area.is_empty() {
@@ -731,7 +731,7 @@ fn paint_heatmap(frame: &mut Frame, area: Rect, rec: &FitRecording, app: &App) {
     }
 }
 
-/// A "nice" axis step (1/2/5 x 10^k) close to `span / target` — 37s at a target of
+/// A "nice" axis step (1/2/5 x 10^k) close to `span / target` -- 37s at a target of
 /// 8 ticks rounds to a step of 5s, not an unreadable 4.625.
 fn nice_step(span: f64, target: usize) -> f64 {
     let raw = span / target.max(1) as f64;
@@ -780,7 +780,7 @@ fn axis_decimals(step: f64) -> usize {
     (-step.log10().floor()).clamp(0.0, 2.0) as usize
 }
 
-/// An axis's tick step and the precision to print its labels at — paired here
+/// An axis's tick step and the precision to print its labels at -- paired here
 /// because tick placement, labels and the gutter sized for them must agree.
 fn axis_scale(lo: f64, hi: f64, target: usize) -> (f64, usize) {
     let step = nice_step((hi - lo).abs().max(EPS), target);
@@ -822,7 +822,7 @@ fn y_gutter_width(lo: f64, hi: f64, target: usize) -> usize {
 /// Picks one terminal cell's glyph and color from its two independent half-rows.
 /// "Occupied" means a half has nonzero weight or a mark, and the occupancy *shape*
 /// (`▀` upper only, `▄` lower only, a density glyph for both, ` ` for neither) is
-/// the primary signal — the one that makes the doubled vertical resolution visible
+/// the primary signal -- the one that makes the doubled vertical resolution visible
 /// in a `.symbol()`-only snapshot. With both halves occupied one character cannot
 /// show two marks, so `Mark`'s `Ord` picks the winner.
 fn compose_cell(
@@ -849,7 +849,7 @@ fn compose_cell(
 
 /// Resolves one already-occupied half (or, from `compose_cell`'s both-occupied
 /// case, the winning mark for the whole cell) into a glyph/color/modifier.
-/// `none_glyph` is what to draw for `Mark::None` — the asymmetric `▀`/`▄` for a
+/// `none_glyph` is what to draw for `Mark::None` -- the asymmetric `▀`/`▄` for a
 /// single occupied half, or the combined density glyph when both are occupied and
 /// neither carries a mark.
 ///
@@ -858,7 +858,7 @@ fn compose_cell(
 ///
 /// A `Region` mark on a zero-weight cell must not keep `heat_glyph`'s plain space:
 /// a *reversed* space is a solid block, the highest-density glyph here, and would
-/// lie about the data — routine, since the curve is evaluated at every display
+/// lie about the data -- routine, since the curve is evaluated at every display
 /// column and the ridge band often extends past the last real observation.
 /// `\u{b7}` reversed reads instead as "mark here, nothing under it".
 fn compose_marked(
@@ -916,7 +916,7 @@ fn mark_suppressed(marks: &mut [Mark], dims: Dims, rec: &FitRecording) {
 
 /// Marks the two greedily attached tails (`path[..dp_range.start]` and
 /// `path[dp_range.end..]`, `Mark::Tail`) apart from the DP's own chain
-/// (`path[dp_range]`, `Mark::DpNode`) — DP's choice, or a tail grafted on after?
+/// (`path[dp_range]`, `Mark::DpNode`) -- DP's choice, or a tail grafted on after?
 /// The one layer that draws two mark kinds, so it relies on `Mark`'s `Ord` for the
 /// rare cell downsampling rounds one of each into.
 fn mark_path(marks: &mut [Mark], dims: Dims, rec: &FitRecording) {
@@ -966,7 +966,7 @@ fn mark_curve(marks: &mut [Mark], dims: Dims, rec: &FitRecording) {
 
 /// Brackets each measured column at `curve ± half_width`. Every measurement's
 /// `library` is a path cell center, so it is one of the curve's own points and
-/// never out of bounds — the `Err` arm is unreachable in practice.
+/// never out of bounds -- the `Err` arm is unreachable in practice.
 fn mark_ridge(marks: &mut [Mark], dims: Dims, rec: &FitRecording) {
     let geom = rec.geom();
     let bins = dims.bins;
@@ -1036,7 +1036,7 @@ fn heatmap_cells(rec: &FitRecording, area_w: u16, area_h: u16) -> Vec<f32> {
 }
 
 /// The half-open range of source indices (out of `src_n`) display index `disp_i`
-/// (out of `disp_n`) covers — a partition of `0..src_n` whether downsampling or
+/// (out of `disp_n`) covers -- a partition of `0..src_n` whether downsampling or
 /// upsampling (where consecutive `disp_i` share one single-element range).
 fn bin_range(disp_i: usize, disp_n: usize, src_n: usize) -> Range<usize> {
     if disp_n == 0 || src_n == 0 {
@@ -1069,7 +1069,7 @@ fn grid_to_screen(row: usize, col: usize, dims: Dims) -> (usize, usize, Half) {
 }
 
 /// Grid-bin index of `v` within `range`, for placing an overlay mark on a value
-/// that is not itself a grid cell — a curve prediction or a ridge bound.
+/// that is not itself a grid cell -- a curve prediction or a ridge bound.
 ///
 /// Zero bins, a non-finite `v` or a zero-width range map to bin 0 rather than
 /// panicking or producing NaN: overlay placement reads geometry straight off a
@@ -1093,9 +1093,9 @@ fn bin_of(v: f64, range: (f64, f64), bins: usize) -> usize {
 // ---------------------------------------------------------------------
 
 /// One metric the Convergence tab reports, named once for both places it is
-/// labelled — the sparkline title and the batch-table header, both on screen at
+/// labelled -- the sparkline title and the batch-table header, both on screen at
 /// once. The short form wins: the table column is `TABLE_COL_WIDTH` wide.
-/// `in_table`/`sparkline` select each view's subset — the table's bookkeeping
+/// `in_table`/`sparkline` select each view's subset -- the table's bookkeeping
 /// columns have nothing worth plotting, and `mean_d` is plotted with no column.
 struct MetricColumn {
     label: &'static str,
@@ -1170,7 +1170,7 @@ fn draw_convergence_tab(frame: &mut Frame, area: Rect, app: &App) {
             frame,
             area,
             "Convergence",
-            "No batches recorded yet — metrics appear after the first Phase 1 batch.",
+            "No batches recorded yet -- metrics appear after the first Phase 1 batch.",
         );
         return;
     }
@@ -1201,7 +1201,7 @@ fn table_columns() -> impl Iterator<Item = &'static MetricColumn> {
 
 fn draw_sparklines(frame: &mut Frame, area: Rect, metrics: &[BatchMetrics]) {
     // Every series is normalized to its own maximum and they share no unit, so no
-    // shape or relative height here carries a magnitude — `spark_title` puts the
+    // shape or relative height here carries a magnitude -- `spark_title` puts the
     // numbers back. `Fill(1)` spreads rounding leftovers across the panes.
     let columns: Vec<&MetricColumn> = METRIC_COLUMNS.iter().filter(|c| c.sparkline).collect();
     let spark_rows = Layout::vertical(vec![Constraint::Fill(1); columns.len()]).split(area);
@@ -1215,7 +1215,7 @@ fn draw_sparklines(frame: &mut Frame, area: Rect, metrics: &[BatchMetrics]) {
     }
 }
 
-/// `label  peak <p>  now <n>` — the y-scale and the latest sample, which is what
+/// `label  peak <p>  now <n>` -- the y-scale and the latest sample, which is what
 /// turns a self-normalized shape back into a measurement: a `wrmse` that fell
 /// 5.0 → 0.08 otherwise draws the same descent as one that fell 5.0 → 4.9. `now`
 /// is the last *finite* sample, matching what `scaled_u64`'s hold actually draws.
@@ -1234,13 +1234,13 @@ fn spark_title(label: &str, values: &[f64], nan_holds: bool) -> String {
     )
 }
 
-/// A metric as a short decimal: `—` when non-finite, no fractional part for a
+/// A metric as a short decimal: `--` when non-finite, no fractional part for a
 /// whole number (`path` is a count), scientific notation only outside `FIXED`.
 fn fmt_metric(v: f64) -> String {
     // Outside this range four decimals print `0.0000` or run past the width.
     const FIXED: Range<f64> = 0.001..100_000.0;
     if !v.is_finite() {
-        return "—".to_string();
+        return "--".to_string();
     }
     let mag = v.abs();
     if v == 0.0 || v.fract() == 0.0 && mag < FIXED.end {
@@ -1258,8 +1258,8 @@ const SPARK_SCALE: f64 = 1000.0;
 
 /// Scales a metric series into `0..=SPARK_SCALE` for `Sparkline`, which takes
 /// `u64` and so cannot mark a sample as "no data" distinctly from `0`.
-/// Non-finite samples are routine here — batch 0 has no prior curve to diff
-/// against, and a failed fit produces NaN throughout — and mapping them to `0` would
+/// Non-finite samples are routine here -- batch 0 has no prior curve to diff
+/// against, and a failed fit produces NaN throughout -- and mapping them to `0` would
 /// draw identically to "the curve stopped moving". So each holds the last finite
 /// value, and only a leading run with no finite value yet reports as `0`.
 fn scaled_u64(values: &[f64]) -> Vec<u64> {
@@ -1415,7 +1415,7 @@ mod tests {
 
     /// The height thresholds: two chrome rows come off before the body sees anything,
     /// then `area.height >= 4` (the x-tick row), `block_h < 3` and `inner.height >= 2`
-    /// (the subtitle row) — one row later again with the banner.
+    /// (the subtitle row) -- one row later again with the banner.
     const SWEEP_HEIGHTS: [u16; 7] = [0, 1, 2, 3, 4, 5, 6];
 
     /// Both dimensions inside their smallest thresholds, then where two thresholds
@@ -1435,7 +1435,7 @@ mod tests {
         app.handle_key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
     }
 
-    /// Cycles to `tab` with the real `l` binding — `App` has no jump-to-tab setter.
+    /// Cycles to `tab` with the real `l` binding -- `App` has no jump-to-tab setter.
     fn goto_tab(app: &mut App, tab: Tab) {
         while app.tab() != tab {
             press(app, 'l');
@@ -1460,8 +1460,8 @@ mod tests {
         glyph_grid(&body_buffer(app, w, h))
     }
 
-    /// The tab body alone — `draw`'s middle rows, without the tab bar or status line
-    /// — rebased so row 0 is the body's first row. A tab-content snapshot has no
+    /// The tab body alone -- `draw`'s middle rows, without the tab bar or status line
+    /// -- rebased so row 0 is the body's first row. A tab-content snapshot has no
     /// business regenerating because a key hint was reworded.
     fn body_buffer(app: &mut App, w: u16, h: u16) -> Buffer {
         let buf = draw_to_buffer(app, w, h);
@@ -1493,7 +1493,7 @@ mod tests {
     }
 
     /// The tab body's glyph grid plus a trailing section naming every `REVERSED`
-    /// cell — for the snapshots where inversion *is* the payload: a region mark keeps
+    /// cell -- for the snapshots where inversion *is* the payload: a region mark keeps
     /// the density glyph under it (`Mark`), so in a `.symbol()`-only grid a layer
     /// marking the wrong cells is byte-identical to one marking the right ones.
     /// Column spans keep it to one line per affected row.
@@ -1583,7 +1583,7 @@ mod tests {
     }
 
     /// A plain diagonal ridge sized to `bins`, asymmetric in range only (`x` spans
-    /// `(0, bins)`, `y` spans `(0, 2*bins)`) — only exercises `heatmap_cells`'s
+    /// `(0, bins)`, `y` spans `(0, 2*bins)`) -- only exercises `heatmap_cells`'s
     /// down/upsampling at arbitrary bin counts.
     fn fixture_recording(bins: usize) -> FitRecording {
         let bins = bins.max(1);
@@ -1651,7 +1651,7 @@ mod tests {
         }
     }
 
-    /// The active layer's name must survive on screen — without it a single inverted
+    /// The active layer's name must survive on screen -- without it a single inverted
     /// mark is uninterpretable. Checked on the two layers no snapshot pins, so a
     /// change to the degrade order cannot drop it for only some of them.
     #[test]
@@ -1668,8 +1668,8 @@ mod tests {
     }
 
     /// `App::set_scrub_recording` is what `CalibDash::sync_scrub` calls once `<`/`>`
-    /// have moved `scrub_frame`. Pins that the Fit tab switches to that recording —
-    /// a visibly different grid — and draws the "not live" banner.
+    /// have moved `scrub_frame`. Pins that the Fit tab switches to that recording --
+    /// a visibly different grid -- and draws the "not live" banner.
     #[test]
     fn fit_tab_shows_a_banner_and_a_different_grid_when_scrubbing() {
         let mut app = fixture_app_with_ridge();
@@ -1684,7 +1684,7 @@ mod tests {
     /// A Fit-tab body exactly one row tall must still show the banner rather than
     /// spend that row on a heatmap too short to read: without it the replayed grid is
     /// indistinguishable from live. And clearing the scrub must take the banner back
-    /// off — a banner that survives the clear is the same lie inverted.
+    /// off -- a banner that survives the clear is the same lie inverted.
     #[test]
     fn the_scrub_banner_wins_the_only_body_row_and_goes_away_when_the_scrub_clears() {
         let mut app = fixture_app_with_ridge();
@@ -1733,7 +1733,7 @@ mod tests {
 
     /// A `contains`, not a snapshot: the panel is literal prose with no computed
     /// content, so a picture of it pins four wrapped lines and rows of border padding
-    /// to catch one thing — whether the explanation reaches the screen.
+    /// to catch one thing -- whether the explanation reaches the screen.
     #[test]
     fn tolerances_tab_explains_itself_during_phase_one() {
         let mut app = fixture_app_with_ridge(); // real_fit is None
@@ -1772,8 +1772,8 @@ mod tests {
     }
 
     /// The half-block parity, end to end and independently derived.
-    /// `fixture_recording(4)`'s four points land one per grid cell on the diagonal —
-    /// `(row, col)` = `(0,0) (1,1) (2,2) (3,3)` with weights 1..4 — so a 4x2 canvas
+    /// `fixture_recording(4)`'s four points land one per grid cell on the diagonal --
+    /// `(row, col)` = `(0,0) (1,1) (2,2) (3,3)` with weights 1..4 -- so a 4x2 canvas
     /// is exactly two grid rows per terminal line.
     ///
     /// Row 0 (the *lowest* observed RT) must land in the bottom line's *lower* half
@@ -1851,7 +1851,7 @@ mod tests {
     }
 
     /// A `Mark::Region` on a weighted cell changes no glyph, so neither function's
-    /// output is visible in a `.symbol()`-only snapshot — this pins what they mark, at
+    /// output is visible in a `.symbol()`-only snapshot -- this pins what they mark, at
     /// the mark-buffer level. `Layer::Ridge`'s whole payload is the sparse
     /// `center ± half_width` pair per measured column, straddling the curve, rather
     /// than the filled band between them; asserted structurally because a snapshot
@@ -2018,7 +2018,7 @@ mod tests {
 
     #[test]
     fn scaled_u64_carries_the_last_finite_value_across_a_nan() {
-        // Batch 0's own delta and any failed batch's metrics are NaN — this must not
+        // Batch 0's own delta and any failed batch's metrics are NaN -- this must not
         // draw as the scale's `0`, which looks identical to "the curve stopped".
         let scaled = scaled_u64(&[10.0, f64::NAN, 10.0]);
         assert_eq!(
@@ -2027,7 +2027,7 @@ mod tests {
         );
         assert_eq!(scaled[2], scaled[0]);
 
-        // A *leading* NaN run has nothing to carry forward — the one case where `0`
+        // A *leading* NaN run has nothing to carry forward -- the one case where `0`
         // means "nothing to show yet" rather than "converged".
         let scaled = scaled_u64(&[f64::NAN, f64::NAN, 10.0]);
         assert_eq!(scaled[0], 0, "{scaled:?}");
@@ -2061,7 +2061,7 @@ mod tests {
         line.spans.iter().map(|s| s.content.as_ref()).collect()
     }
 
-    /// Inversion, not a color, is what makes a pending count unmistakable — and the
+    /// Inversion, not a color, is what makes a pending count unmistakable -- and the
     /// glyph-only `render` harness cannot see style, so this reads the buffer.
     #[test]
     fn status_line_pending_count_is_reversed() {
@@ -2173,15 +2173,15 @@ mod tests {
     }
 
     /// Reporting `-8.5 .. +9.5` as `±9.5` understates one side by two ppm and
-    /// `±8.5` overstates the other — the reason `mz_ppm` is a pair at all.
+    /// `±8.5` overstates the other -- the reason `mz_ppm` is a pair at all.
     #[test]
     fn fmt_interval_collapses_only_the_symmetric_case() {
         assert_eq!(fmt_interval((-3.0, 3.0)), "±3.0");
         assert_eq!(fmt_interval((-8.5, 9.5)), "-8.5 .. +9.5");
     }
 
-    /// `now` must report what the right edge draws — the last *finite* sample under
-    /// `scaled_u64`'s hold. Reporting `—` beside a held bar contradicts the plot.
+    /// `now` must report what the right edge draws -- the last *finite* sample under
+    /// `scaled_u64`'s hold. Reporting `--` beside a held bar contradicts the plot.
     #[test]
     fn spark_title_reports_the_value_the_right_edge_actually_draws() {
         let title = spark_title("wrmse", &[2.0, 0.5, f64::NAN], true);
@@ -2191,7 +2191,7 @@ mod tests {
         // Batch 0's `max_delta` is NaN, so the plot is flat at the floor, where
         // `peak 0  now 0` would read as "converged" rather than "not measured".
         let title = spark_title("max_delta", &[f64::NAN], true);
-        assert_eq!(title, "max_delta  peak —  now —  (NaN holds)");
+        assert_eq!(title, "max_delta  peak --  now --  (NaN holds)");
     }
 
     /// Every tab, every mark layer, a scrubbed frame, an empty app and the keys
@@ -2241,7 +2241,7 @@ mod tests {
 
         sweep_painted(&mut fixture_app_with_metrics());
 
-        // A scrubbed frame is `draw_fit_tab`'s `Length(1), Min(0)` split — the one
+        // A scrubbed frame is `draw_fit_tab`'s `Length(1), Min(0)` split -- the one
         // path that deliberately hands the heatmap zero rows.
         let mut scrubbed = fixture_app_with_ridge();
         scrubbed.set_frame_summary(RETAINED_5);
@@ -2249,7 +2249,7 @@ mod tests {
         sweep_painted(&mut scrubbed);
 
         // A mark layer changes the glyphs, never the layout, so it needs the size
-        // sweep once rather than once per layout combination above — and only on the
+        // sweep once rather than once per layout combination above -- and only on the
         // Fit tab, the only tab that reads `app.layer()`.
         for layer in Layer::ALL.into_iter().filter(|l| *l != Layer::None) {
             let mut app = fixture_app_with_metrics();
diff --git a/rust/calibrt/src/grid.rs b/rust/calibrt/src/grid.rs
index 993c1d7b..b9cbe242 100644
--- a/rust/calibrt/src/grid.rs
+++ b/rust/calibrt/src/grid.rs
@@ -246,7 +246,7 @@ impl Grid {
 pub struct Node {
     pub center: Point,
     pub suppressed: bool,
-    // Internal accumulators — not exposed beyond crate
+    // Internal accumulators -- not exposed beyond crate
     pub(crate) sum_wx: f64,
     pub(crate) sum_wy: f64,
     pub(crate) sum_w: f64,
diff --git a/rust/calibrt/src/lib.rs b/rust/calibrt/src/lib.rs
index ee48222f..0c1faf98 100644
--- a/rust/calibrt/src/lib.rs
+++ b/rust/calibrt/src/lib.rs
@@ -119,7 +119,7 @@ impl CalibrationCurve {
 
         // Find the partition point; first element >= x_val.
         let i = self.points.partition_point(|p| p.library < x_val);
-        // Clamp to [1, slopes.len()] — partition_point can return 0 when x_val == first_x
+        // Clamp to [1, slopes.len()] -- partition_point can return 0 when x_val == first_x
         let i = i.max(1).min(self.slopes.len());
         Ok(ObservedRTSeconds(self.predict_with_index(x_val, i)))
     }
@@ -173,7 +173,7 @@ pub struct RidgeMeasurement {
 }
 
 /// Everything a consumer reports about a fit's [`RidgeMeasurement`]s, folded in
-/// the one place the arithmetic is written — the dashboard, the search's derived
+/// the one place the arithmetic is written -- the dashboard, the search's derived
 /// tolerances and the CLI's log line all read this rather than each summing the
 /// slice their own way.
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -220,7 +220,7 @@ impl RidgeSummary {
     }
 }
 
-/// Serializable snapshot of calibration data — points + config.
+/// Serializable snapshot of calibration data -- points + config.
 /// Used for save/load. Does not include the fitted curve (reconstructed on load).
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct CalibrationSnapshot {
@@ -233,7 +233,7 @@ pub struct CalibrationSnapshot {
 /// writer and the reader's gate cannot disagree.
 pub const CALIBRATION_FORMAT_VERSION: &str = "v3";
 
-/// JSON v3 calibration file format — shared between CLI and viewer.
+/// JSON v3 calibration file format -- shared between CLI and viewer.
 ///
 /// `calibration` is the grid's own snapshot and the only record of the fit: the
 /// curve and the ridge widths are recomputed by refitting it, so the file cannot
@@ -246,11 +246,11 @@ pub struct SavedCalibration<R = serde_json::Value> {
     pub version: String,
     pub rt_range_seconds: [f64; 2],
     pub calibration: CalibrationSnapshot,
-    /// The uniform RT tolerance. Every writer has one — it is what a query falls
+    /// The uniform RT tolerance. Every writer has one -- it is what a query falls
     /// back to where the grid measured no ridge.
     pub rt_tolerance_minutes: f32,
     /// What a search measured beyond the curve. `None` for a writer that measures
-    /// no residuals — zeros there would read as "measured, and tight".
+    /// no residuals -- zeros there would read as "measured, and tight".
     ///
     /// The path is named because a bare `default` would demand `R: Default`.
     #[serde(default = "Option::default")]
@@ -288,8 +288,8 @@ impl<R> SavedCalibration<R> {
 
     /// Parse a calibration file and check its provenance. The `Option<String>`
     /// is a reason to distrust the file, not an error: a calibration is only
-    /// valid for the run it was fit on, and `raw_rt_range` — the RT span of the
-    /// run it is about to be used on — is the one cheap way to catch the wrong
+    /// valid for the run it was fit on, and `raw_rt_range` -- the RT span of the
+    /// run it is about to be used on -- is the one cheap way to catch the wrong
     /// file. `None` there means nothing verifies it, which also warns.
     pub fn read(
         path: &std::path::Path,
@@ -318,7 +318,7 @@ impl<R> SavedCalibration<R> {
     fn provenance_warning(&self, raw_rt_range: Option<[f64; 2]>) -> Option<String> {
         let Some(raw) = raw_rt_range else {
             return Some(
-                "No raw RT range to check the calibration against — nothing verifies it was \
+                "No raw RT range to check the calibration against -- nothing verifies it was \
                  fit on this run"
                     .to_string(),
             );
@@ -332,7 +332,7 @@ impl<R> SavedCalibration<R> {
         }
         Some(format!(
             "Calibration RT range [{:.1}, {:.1}]s overlaps the raw file's [{:.1}, {:.1}]s by \
-             {:.0}% — it may have been fit on a different run",
+             {:.0}% -- it may have been fit on a different run",
             self.rt_range_seconds[0],
             self.rt_range_seconds[1],
             raw[0],
@@ -357,7 +357,7 @@ pub struct GridGeom {
 pub struct CalibrationState {
     grid: grid::Grid,
     path_indices: Vec<usize>,
-    /// The DP-chosen segment within [`Self::path_indices`] — see
+    /// The DP-chosen segment within [`Self::path_indices`] -- see
     /// [`Self::dp_range`].
     dp_range: std::ops::Range<usize>,
     /// Survivors of suppression, refilled per fit. Sized at `bins`, which is a
@@ -409,7 +409,7 @@ impl CalibrationState {
     ///
     /// The geometry is derived *here*, by `point_ranges`, rather than passed in:
     /// a caller that supplies the acquisition RT range instead would clamp an
-    /// iRT-scaled library — whose RTs fall entirely outside it — into one edge
+    /// iRT-scaled library -- whose RTs fall entirely outside it -- into one edge
     /// column. Every calibrant weighs [`CALIBRANT_WEIGHT`].
     ///
     /// On `Err` the previous fit is left alone: a later, larger point set may well
@@ -497,7 +497,7 @@ impl CalibrationState {
         self.clear_fit();
     }
 
-    /// Re-point `self` at a new geometry and clear the previous fit — see
+    /// Re-point `self` at a new geometry and clear the previous fit -- see
     /// `grid::Grid::reconfigure` for what stays allocated.
     pub fn reconfigure(
         &mut self,
@@ -534,7 +534,7 @@ impl CalibrationState {
     }
 
     /// The assembled path as row-major grid indices, one per point, from the
-    /// grid's own arithmetic — so an overlay never has to re-derive them and risk
+    /// grid's own arithmetic -- so an overlay never has to re-derive them and risk
     /// landing in a different cell.
     pub fn path_indices(&self) -> &[usize] {
         &self.path_indices
@@ -561,7 +561,7 @@ impl CalibrationState {
     /// Everything needed to rebuild an equal state: the points, and the grid
     /// geometry they were binned under. Refitting a snapshot under its own
     /// `(grid_size, lookback)` reproduces the curve, so this is the state's
-    /// persistent form — see [`Self::from_snapshot`].
+    /// persistent form -- see [`Self::from_snapshot`].
     pub fn snapshot(&self) -> CalibrationSnapshot {
         CalibrationSnapshot {
             points: self
@@ -828,7 +828,7 @@ mod ridge_summary_tests {
     }
 
     /// A total ridge weight of 0.25 must report the half-width it measured, not
-    /// a fraction of it. And a weightless column keeps its count and bounds —
+    /// a fraction of it. And a weightless column keeps its count and bounds --
     /// only the mean goes NaN, where a 0.0 would read as a perfectly tight
     /// ridge.
     #[test]
@@ -846,7 +846,7 @@ mod ridge_summary_tests {
 
     /// The two axes are bounded independently, a non-finite point drops out of
     /// both, and the three refusals are distinguishable: nothing left to bound
-    /// is `NoPoints`, while a single collapsed axis is `ZeroRange` — which is
+    /// is `NoPoints`, while a single collapsed axis is `ZeroRange` -- which is
     /// what a grid built from these ranges would have said anyway.
     #[test]
     fn point_ranges_bounds_both_axes_and_names_each_refusal() {
@@ -924,7 +924,7 @@ mod calibration_state_tests {
         s.update(pts1.iter().copied()).unwrap();
         s.fit();
 
-        // Same bins, a completely different (shifted, wider) range — the case
+        // Same bins, a completely different (shifted, wider) range -- the case
         // `reconfigure` exists to keep allocation-free.
         s.reconfigure(10, (100.0, 200.0), (100.0, 200.0)).unwrap();
         let pts2: Vec<_> = (0..10)
diff --git a/rust/calibrt/src/pathfinding.rs b/rust/calibrt/src/pathfinding.rs
index 3a7c2960..5a3b0991 100644
--- a/rust/calibrt/src/pathfinding.rs
+++ b/rust/calibrt/src/pathfinding.rs
@@ -243,7 +243,7 @@ mod tests {
     /// declining one takes a node with no admissible in-window predecessor: with
     /// `lookback == 1` the dip at `(3.5, 0.1)` fails the monotonic edge back to
     /// the core chain, and the stray at `(4.5, 4.5)` can only look back one rank
-    /// — at the dip — so it accumulates the dip's 0.4 rather than the chain's,
+    /// -- at the dip -- so it accumulates the dip's 0.4 rather than the chain's,
     /// and the DP's best path ends at the chain. Pass 2's forward walk re-checks
     /// monotonicity against the DP's chosen *endpoint* instead, skips the dip
     /// (its observed RT is below the chain) and grafts the stray on as a suffix.
diff --git a/rust/calibrt/src/types.rs b/rust/calibrt/src/types.rs
index 3c76c816..2e108417 100644
--- a/rust/calibrt/src/types.rs
+++ b/rust/calibrt/src/types.rs
@@ -4,7 +4,7 @@ use serde::{
 };
 use std::fmt;
 
-/// Library reference retention time. Unit-agnostic — could be iRT, minutes,
+/// Library reference retention time. Unit-agnostic -- could be iRT, minutes,
 /// or arbitrary units depending on the spectral library.
 #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Serialize, Deserialize)]
 #[serde(transparent)]
diff --git a/rust/calibrt/tests/tests.rs b/rust/calibrt/tests/tests.rs
index 1df120a5..7dabd81a 100644
--- a/rust/calibrt/tests/tests.rs
+++ b/rust/calibrt/tests/tests.rs
@@ -5,7 +5,7 @@ use calibrt::{
 };
 
 /// A degenerate range on *either* axis is an error. Both, because the two are
-/// separate checks in `grid::spans` — dropping the y one leaves the x case
+/// separate checks in `grid::spans` -- dropping the y one leaves the x case
 /// green.
 #[test]
 fn a_zero_range_on_either_axis_is_rejected() {
diff --git a/rust/rescore_dash/src/app.rs b/rust/rescore_dash/src/app.rs
index e4a5aec8..85468857 100644
--- a/rust/rescore_dash/src/app.rs
+++ b/rust/rescore_dash/src/app.rs
@@ -1,8 +1,8 @@
 //! Dashboard state: which tab, which feature, which transforms, and the key
 //! bindings that move between them.
 //!
-//! [`App`] is a [`Dashboard`] — everything materialized, see
-//! [`crate::precompute`] — plus the handful of fields a keystroke can change.
+//! [`App`] is a [`Dashboard`] -- everything materialized, see
+//! [`crate::precompute`] -- plus the handful of fields a keystroke can change.
 //! Nothing here computes over the data; a key press moves an index.
 //! Rendering lives in [`crate::ui`].
 
@@ -156,8 +156,8 @@ impl App {
     }
 
     pub(crate) fn handle_key(&mut self, key: KeyEvent) -> Flow {
-        // Handled before anything else — including the filter-editing dispatch
-        // below — so Ctrl-C always quits rather than being typed into the filter
+        // Handled before anything else -- including the filter-editing dispatch
+        // below -- so Ctrl-C always quits rather than being typed into the filter
         // box or toggling clip.
         if is_ctrl_c(key) {
             return Flow::Quit;
@@ -260,7 +260,7 @@ impl App {
         } else {
             // `sort_desc` picks the finite-value order; NaN sorts last either
             // way. That rule has to live in the comparator itself, not in a
-            // value substitution followed by a blanket `idx.reverse()` — a
+            // value substitution followed by a blanket `idx.reverse()` -- a
             // later reverse of the whole vector would undo a NaN-last
             // placement exactly when `sort_desc` is false.
             let desc = self.sort_desc;
@@ -291,7 +291,7 @@ fn available() -> bool {
 /// Never fails the caller and never panics on setup: a non-terminal stdout or
 /// a failed `try_init` warns, restores the terminal and returns `Ok`. This is
 /// deliberately unlike `ratatui::init`, which is `try_init().expect(..)` and
-/// would unwind past the caller's warn-only `if let Err` — after the results
+/// would unwind past the caller's warn-only `if let Err` -- after the results
 /// have already been written to disk.
 ///
 /// The terminal is restored on every returning path. [`catch_panics`] covers
@@ -576,7 +576,7 @@ pub(crate) mod tests {
         assert_eq!(app.visible, &[1, 0]);
     }
 
-    /// A wholly NaN column gets a NaN AUC — a real, naturally occurring case,
+    /// A wholly NaN column gets a NaN AUC -- a real, naturally occurring case,
     /// not a synthetic key. It must sort last regardless of direction.
     #[test]
     fn nan_sort_keys_sort_last_in_both_directions() {
diff --git a/rust/rescore_dash/src/curves.rs b/rust/rescore_dash/src/curves.rs
index 4d669578..a9b6bc39 100644
--- a/rust/rescore_dash/src/curves.rs
+++ b/rust/rescore_dash/src/curves.rs
@@ -44,7 +44,7 @@ pub(crate) fn qvalue_curves(
 /// already covers both classes, so the curve is `(1,1)` at every point rather
 /// than starting at `(0,0)`.
 ///
-/// Empty when either class is absent — a PP plot of one class says nothing.
+/// Empty when either class is absent -- a PP plot of one class says nothing.
 pub(crate) fn pp_curve(score: &[f32], is_target: &[bool], n_points: usize) -> Vec<(f64, f64)> {
     let mut targets: Vec<f32> = Vec::new();
     let mut decoys: Vec<f32> = Vec::new();
@@ -92,7 +92,7 @@ mod tests {
     }
 
     /// A zoomed curve must spend all of its points inside its own range and
-    /// agree with the wide curve wherever they overlap — a zoom that merely
+    /// agree with the wide curve wherever they overlap -- a zoom that merely
     /// rescaled the axis without re-gridding would be the bug this guards.
     #[test]
     fn zoomed_curves_resolve_the_low_q_region() {
@@ -157,7 +157,7 @@ mod tests {
     /// Axes are `(decoy CDF, target CDF)`; the panel draws the `y = x`
     /// reference line, so a curve point where `d > tt` sits BELOW that
     /// diagonal. When targets score higher, the decoy CDF races ahead of the
-    /// target CDF in the shared middle range — the curve dips below y = x,
+    /// target CDF in the shared middle range -- the curve dips below y = x,
     /// which is what good target/decoy separation looks like on this plot.
     #[test]
     fn pp_curve_dips_below_the_diagonal_when_targets_score_higher() {
diff --git a/rust/rescore_dash/src/labels.rs b/rust/rescore_dash/src/labels.rs
index a6fd4395..bd68feb5 100644
--- a/rust/rescore_dash/src/labels.rs
+++ b/rust/rescore_dash/src/labels.rs
@@ -109,7 +109,7 @@ impl Labels {
     }
 }
 
-/// One title per `(column, transform)`, the discriminant score last — it is
+/// One title per `(column, transform)`, the discriminant score last -- it is
 /// titled like a feature because it is stored and queried like one.
 fn build_titles(view: &RescoreView<'_>) -> Vec<String> {
     view.feature_names
@@ -124,7 +124,7 @@ fn build_titles(view: &RescoreView<'_>) -> Vec<String> {
 ///
 /// Two exclusions at two steps, neither a subset of the other: `dropped` is what
 /// the transform refused, `outside range` what survived it and then fell outside
-/// the axis. Kept short — the panel is under half the terminal width and its
+/// the axis. Kept short -- the panel is under half the terminal width and its
 /// border truncates the rest; run-level facts go to [`Labels::basis`].
 fn build_subtitles(slots: &[Slot], n_sampled: usize) -> Vec<String> {
     let pct = |n: u32| {
@@ -270,7 +270,7 @@ mod tests {
     /// The subtitle has to fit the histogram panel, which is under half of a
     /// terminal's width; anything longer is silently cut off by the border it is
     /// drawn on. `log10` rejects the non-positive half, and the subtitle is the
-    /// only place that says so — a histogram that silently shrank would read as
+    /// only place that says so -- a histogram that silently shrank would read as
     /// "those rows do not exist".
     #[test]
     fn subtitles_fit_a_narrow_panel_and_report_what_a_transform_refused() {
diff --git a/rust/rescore_dash/src/lib.rs b/rust/rescore_dash/src/lib.rs
index 2e657479..e90fed8c 100644
--- a/rust/rescore_dash/src/lib.rs
+++ b/rust/rescore_dash/src/lib.rs
@@ -2,8 +2,8 @@
 //! target/decoy separation, FDR curve and decoy calibration.
 //!
 //! Two steps, deliberately separate. [`Dashboard::build`] materializes
-//! everything on screen from a [`RescoreView`] — see [`precompute`] for what is
-//! exact and what is sampled — and [`run`] opens the TUI over the result.
+//! everything on screen from a [`RescoreView`] -- see [`precompute`] for what is
+//! exact and what is sampled -- and [`run`] opens the TUI over the result.
 //! Splitting them lets the caller drop the feature matrix, gigabytes at a
 //! realistic library size, before the TUI blocks for as long as the user leaves
 //! it open.
diff --git a/rust/rescore_dash/src/precompute.rs b/rust/rescore_dash/src/precompute.rs
index ccb6588f..d5e2d324 100644
--- a/rust/rescore_dash/src/precompute.rs
+++ b/rust/rescore_dash/src/precompute.rs
@@ -41,7 +41,7 @@ use std::sync::Arc;
 ///
 /// Approximate, and not pinned by a test. A clipped axis bound is `log10` of a
 /// discrete order statistic, so on a spiky column the sample and the whole data
-/// can pick neighbouring values and slide every bin — a swing far wider than
+/// can pick neighbouring values and slide every bin -- a swing far wider than
 /// the sampling error itself, and one that moves with the draw. Any bound
 /// asserted here would be measuring the seed.
 pub const DEFAULT_SAMPLE: usize = 250_000;
@@ -96,9 +96,9 @@ const PP_CURVE_POINTS: usize = 200;
 
 /// Upper q-value bounds the FDR curve can be drawn over, widest first.
 ///
-/// Every one of these gets its own `Q_CURVE_POINTS` grid — see
+/// Every one of these gets its own `Q_CURVE_POINTS` grid -- see
 /// [`curves::qvalue_curves`] for why a zoom cannot just be a slice of the wide
-/// curve — which is affordable because they share one sort.
+/// curve -- which is affordable because they share one sort.
 const Q_ZOOMS: [f64; 4] = [1.0, 0.1, 0.05, 0.01];
 
 /// Which of [`Q_ZOOMS`] the FDR tab opens on.
@@ -140,7 +140,7 @@ impl Slot {
 
 /// One stored histogram, borrowed from the dashboard's count store.
 ///
-/// The panel never owns or builds one of these — [`precompute_column`] fills
+/// The panel never owns or builds one of these -- [`precompute_column`] fills
 /// the counts at init and [`Dashboard::hist`] slices into them.
 #[derive(Debug, Clone, Copy)]
 pub(crate) struct HistView<'a> {
@@ -234,7 +234,7 @@ pub struct Dashboard {
 impl Dashboard {
     /// Materialize everything the TUI shows.
     ///
-    /// `sample` is the pass-B row count — [`DEFAULT_SAMPLE`] unless the caller
+    /// `sample` is the pass-B row count -- [`DEFAULT_SAMPLE`] unless the caller
     /// has a reason. At or above `view.n_rows()` every row is taken in order,
     /// which makes the histograms, clip ranges and per-feature AUCs exact
     /// rather than sampled.
@@ -320,7 +320,7 @@ impl Dashboard {
         column * SLOTS_PER_COLUMN + local_slot(t.index(), usize::from(clip))
     }
 
-    /// The stored histogram for a column. Pure indexing — this is the whole of
+    /// The stored histogram for a column. Pure indexing -- this is the whole of
     /// what a redraw does.
     pub(crate) fn hist(&self, column: usize, t: Axis, clip: bool) -> HistView<'_> {
         let slot = self.slot_index(column, t, clip);
@@ -420,8 +420,8 @@ fn all_rows_tables(view: &RescoreView<'_>) -> AllRows {
 }
 
 /// Deterministic mixed LCG. Two runs over the same data must show the same
-/// histograms — a sample that moved between runs would be indistinguishable
-/// from a bug — and this crate carries no `rand` dependency.
+/// histograms -- a sample that moved between runs would be indistinguishable
+/// from a bug -- and this crate carries no `rand` dependency.
 struct Lcg(u64);
 
 impl Lcg {
@@ -685,7 +685,7 @@ pub(crate) mod tests {
     use super::*;
     use crate::view::ThresholdRow;
 
-    /// A synthetic run. THE definition of what test rows look like — the
+    /// A synthetic run. THE definition of what test rows look like -- the
     /// alternating labels, the perfectly-separating score and the
     /// target/decoy q-values are asserted against from two modules, so they
     /// get one home rather than a copy in each.
@@ -805,7 +805,7 @@ pub(crate) mod tests {
 
     /// Zooming has to re-grid, not re-slice. Every zoom keeps a full
     /// `Q_CURVE_POINTS` grid over its own range, and the y axis rescales with
-    /// it — a `q <= 0.01` panel still scaled to the q = 1 target count would
+    /// it -- a `q <= 0.01` panel still scaled to the q = 1 target count would
     /// draw the part being zoomed into flat against the axis.
     #[test]
     fn zooming_the_fdr_curve_regrids_and_rescales() {
@@ -898,7 +898,7 @@ pub(crate) mod tests {
     /// Both sampling regimes, on a column whose value *is* its row index.
     ///
     /// At or above the run size every row is taken in order, which is what makes
-    /// small runs — and most of these tests — exact rather than approximate.
+    /// small runs -- and most of these tests -- exact rather than approximate.
     #[test]
     fn gather_sample_takes_every_row_or_a_random_draw_across_the_whole_run() {
         let f = fixture(10_000, &[("a", &|i, _| i as f64)]);
@@ -1085,7 +1085,7 @@ pub(crate) mod tests {
 
     /// The unclipped axis comes from pass A's exact all-rows values, and the
     /// sample is a subset of those rows, so nothing sampled can fall outside
-    /// it — for any transform, including the two that are not monotone.
+    /// it -- for any transform, including the two that are not monotone.
     #[test]
     fn nothing_sampled_ever_falls_outside_the_unclipped_axis() {
         let f = fixture(
diff --git a/rust/rescore_dash/src/stats.rs b/rust/rescore_dash/src/stats.rs
index 4e8698eb..08584d02 100644
--- a/rust/rescore_dash/src/stats.rs
+++ b/rust/rescore_dash/src/stats.rs
@@ -123,7 +123,7 @@ impl ColumnStats {
         self.hi >= self.lo
     }
 
-    /// `|Cohen's d|` — pooled-SD standardized mean difference. NaN when either
+    /// `|Cohen's d|` -- pooled-SD standardized mean difference. NaN when either
     /// class contributed no finite value; `0.0` for a constant column, where
     /// there is no difference to standardize.
     pub(crate) fn cohens_d(&self) -> f64 {
@@ -405,7 +405,7 @@ mod tests {
     }
 
     /// Ties share the mid-rank of their run, so an all-tied column collapses to
-    /// 50 regardless of length — not to 0, and not spread across the axis.
+    /// 50 regardless of length -- not to 0, and not spread across the axis.
     #[test]
     fn mid_rank_percentiles_map_an_all_tied_column_entirely_to_fifty() {
         for len in [1, 2, 3, 4, 10, 11] {
diff --git a/rust/rescore_dash/src/transform.rs b/rust/rescore_dash/src/transform.rs
index 1c8f5f42..8a8eb509 100644
--- a/rust/rescore_dash/src/transform.rs
+++ b/rust/rescore_dash/src/transform.rs
@@ -2,7 +2,7 @@
 //!
 //! A transform never errors. Values it cannot map (non-positives under a log,
 //! negatives under a square root, anything non-finite) are dropped, and the
-//! caller reports the drop count in the panel subtitle — a silently shrinking
+//! caller reports the drop count in the panel subtitle -- a silently shrinking
 //! histogram would misread as "these rows do not exist".
 //!
 //! [`XTransform`] is applied once, at init, over a sorted sample. (`YTransform`
@@ -96,7 +96,7 @@ impl XTransform {
         }
     }
 
-    /// Whether a *finite* `v` is inside this transform's domain — exactly the
+    /// Whether a *finite* `v` is inside this transform's domain -- exactly the
     /// condition [`Self::apply`] tests.
     pub fn accepts(self, v: f64) -> bool {
         match self {
diff --git a/rust/rescore_dash/src/ui.rs b/rust/rescore_dash/src/ui.rs
index 63c055e1..3b03e8ab 100644
--- a/rust/rescore_dash/src/ui.rs
+++ b/rust/rescore_dash/src/ui.rs
@@ -3,7 +3,7 @@
 //! Every panel is a lookup into the precomputed [`crate::precompute::Dashboard`]:
 //! histogram bins, axis ranges, curves, threshold tables, panel titles and
 //! table cells were all computed before the TUI opened. A frame indexes arrays
-//! and draws — a keystroke costs a redraw and not a re-scan.
+//! and draws -- a keystroke costs a redraw and not a re-scan.
 
 use crate::app::{
     App,
@@ -77,7 +77,7 @@ pub fn draw(frame: &mut Frame, app: &mut App) {
     let selected = app.tab().index();
     // Full width, which is why the run-level basis goes here and not into a
     // histogram subtitle that the panel border would truncate.
-    let banner = format!("rescore — {}", app.dash.labels.basis);
+    let banner = format!("rescore -- {}", app.dash.labels.basis);
     frame.render_widget(
         Tabs::new(titles)
             .select(selected)
@@ -368,7 +368,7 @@ mod tests {
         ))
     }
 
-    /// A smoke test over the whole lookup surface — every axis and both clip
+    /// A smoke test over the whole lookup surface -- every axis and both clip
     /// settings on every tab. It asserts only that a frame draws, and that the
     /// tab that drew it says which one it is: a slot the precompute left
     /// unplottable or an axis range it could not derive panics on index here
@@ -406,7 +406,7 @@ mod tests {
     }
 
     /// The features tab is the only one with a sort, and `S` only flips the
-    /// direction — which has to appear on screen, or the key silently changes
+    /// direction -- which has to appear on screen, or the key silently changes
     /// what the table means.
     #[test]
     fn the_features_tab_names_its_sort_key_and_direction() {
diff --git a/rust/speclib_build_cli/src/config.rs b/rust/speclib_build_cli/src/config.rs
index 0c24bff1..b399c92c 100644
--- a/rust/speclib_build_cli/src/config.rs
+++ b/rust/speclib_build_cli/src/config.rs
@@ -196,7 +196,7 @@ impl Default for FiltersConfig {
 #[derive(Debug, Deserialize)]
 #[serde(default, deny_unknown_fields)]
 pub struct SpeclibBuildConfig {
-    // Inputs — not directly deserialised from TOML but set after merging CLI args.
+    // Inputs -- not directly deserialised from TOML but set after merging CLI args.
     // URIs: either local paths or remote (s3://...).
     #[serde(skip)]
     pub fasta: Option<String>,
diff --git a/rust/speclib_build_cli/src/dedup.rs b/rust/speclib_build_cli/src/dedup.rs
index ddc2e2b8..424a5f6b 100644
--- a/rust/speclib_build_cli/src/dedup.rs
+++ b/rust/speclib_build_cli/src/dedup.rs
@@ -21,7 +21,7 @@ impl PeptideDedup {
                 bloom.set(seq);
                 buckets.entry(key).or_default().push(slice);
             } else {
-                // Maybe seen — check bucket
+                // Maybe seen -- check bucket
                 let bucket = buckets.entry(key).or_default();
                 if !bucket
                     .iter()
diff --git a/rust/speclib_build_cli/src/entry.rs b/rust/speclib_build_cli/src/entry.rs
index e5686aa6..68a7668e 100644
--- a/rust/speclib_build_cli/src/entry.rs
+++ b/rust/speclib_build_cli/src/entry.rs
@@ -247,7 +247,7 @@ mod tests {
 
     #[test]
     fn test_build_entry_skipped_too_few_ions() {
-        // Only 1 ion — min_ions = 3 → should return None.
+        // Only 1 ion -- min_ions = 3 → should return None.
         let fragment = FragmentPrediction {
             annotations: vec!["y3^1".to_string()],
             mzs: vec![400.0],
diff --git a/rust/speclib_build_cli/src/koina/mod.rs b/rust/speclib_build_cli/src/koina/mod.rs
index 6e4ff811..8fc44fd6 100644
--- a/rust/speclib_build_cli/src/koina/mod.rs
+++ b/rust/speclib_build_cli/src/koina/mod.rs
@@ -91,7 +91,7 @@ impl KoinaClient {
 
             let status = resp.status();
 
-            // Client errors (4xx) — no point retrying.
+            // Client errors (4xx) -- no point retrying.
             if status.is_client_error() {
                 let body = resp.text().await.unwrap_or_default();
                 return Err(format!(
@@ -111,7 +111,7 @@ impl KoinaClient {
                 });
             }
 
-            // 5xx or other non-success — record and retry.
+            // 5xx or other non-success -- record and retry.
             last_err = format!("Koina request failed with status {status}");
         }
 
diff --git a/rust/speclib_build_cli/src/mods.rs b/rust/speclib_build_cli/src/mods.rs
index 0be51883..a1c7d7cb 100644
--- a/rust/speclib_build_cli/src/mods.rs
+++ b/rust/speclib_build_cli/src/mods.rs
@@ -315,7 +315,7 @@ mod tests {
 
     #[test]
     fn test_expand_variable_mods_respects_fixed_mods() {
-        // Sequence already has a fixed C[U:4] — variable M should still work.
+        // Sequence already has a fixed C[U:4] -- variable M should still work.
         let var_m = Modification::parse("M[U:35]").unwrap();
         let sequence = "PEPTMC[U:4]IDMEK";
         let results = expand_variable_mods(sequence, &[var_m], 1);
diff --git a/rust/speclib_build_cli/src/pipeline.rs b/rust/speclib_build_cli/src/pipeline.rs
index 01537c50..b82f5674 100644
--- a/rust/speclib_build_cli/src/pipeline.rs
+++ b/rust/speclib_build_cli/src/pipeline.rs
@@ -63,7 +63,7 @@ async fn flush_batch(
         return Ok(());
     }
 
-    // Koina/Prosit accepts UNIMOD notation — convert our short form [U:N] → [UNIMOD:N]
+    // Koina/Prosit accepts UNIMOD notation -- convert our short form [U:N] → [UNIMOD:N]
     let inputs: Vec<PredictionInput> = batch
         .iter()
         .map(|item| PredictionInput {
@@ -159,7 +159,7 @@ pub async fn run(config: &SpeclibBuildConfig) -> Result<(), Box<dyn std::error::
                 .any(|c| matches!(c, 'U' | 'B' | 'J' | 'Z' | 'X'))
             {
                 tracing::warn!(
-                    "Protein {} contains non-standard amino acids (U/B/J/Z/X) — affected peptides will be skipped",
+                    "Protein {} contains non-standard amino acids (U/B/J/Z/X) -- affected peptides will be skipped",
                     prot.description,
                 );
             }
@@ -211,7 +211,7 @@ pub async fn run(config: &SpeclibBuildConfig) -> Result<(), Box<dyn std::error::
     };
 
     if base_peptides.is_empty() {
-        return Err("No peptides after digestion/dedup — nothing to do".into());
+        return Err("No peptides after digestion/dedup -- nothing to do".into());
     }
 
     // ── Phase 2: Set up prediction ──────────────────────────────────────────
diff --git a/rust/tims_stage/Cargo.toml b/rust/tims_stage/Cargo.toml
index a4fb4500..d3fba273 100644
--- a/rust/tims_stage/Cargo.toml
+++ b/rust/tims_stage/Cargo.toml
@@ -13,7 +13,7 @@ tempfile = { workspace = true }
 indicatif = { workspace = true }
 bytes = "1"
 url = "2"
-# RFC-3986 URIs — matches the reader manifest's `http::Uri` members.
+# RFC-3986 URIs -- matches the reader manifest's `http::Uri` members.
 http = "1"
 
 [dev-dependencies]
diff --git a/rust/tims_stage/src/backend.rs b/rust/tims_stage/src/backend.rs
index 89400f35..11c302c3 100644
--- a/rust/tims_stage/src/backend.rs
+++ b/rust/tims_stage/src/backend.rs
@@ -39,7 +39,7 @@ impl Default for StagingConfig {
 
 /// RAII handle over a per-run tempdir + its inner `sample.d/` path.
 ///
-/// Callers MUST keep `StagedDotD` alive for as long as they use the path —
+/// Callers MUST keep `StagedDotD` alive for as long as they use the path --
 /// the tempdir is deleted on drop, and `AsRef<Path>` does not extend the
 /// borrow beyond the handle's lifetime. Do NOT store `&Path` derived from
 /// `as_ref()` past the end of the scope that holds the handle.
@@ -139,7 +139,7 @@ fn sweep_stale(root: &Path, age_hours: u64) -> Result<(), StageError> {
         let mtime = meta.modified().ok();
         if has_lock {
             // Live session. Only force-remove if it's very stale (2x threshold)
-            // AND still claims to be locked — best-effort for crashed runs.
+            // AND still claims to be locked -- best-effort for crashed runs.
             if let Some(mt) = mtime {
                 let hard_threshold = std::time::SystemTime::now()
                     .checked_sub(std::time::Duration::from_secs(age_hours * 2 * 3600))
diff --git a/rust/tims_stage/src/download.rs b/rust/tims_stage/src/download.rs
index a2beb784..07683541 100644
--- a/rust/tims_stage/src/download.rs
+++ b/rust/tims_stage/src/download.rs
@@ -1,7 +1,7 @@
 //! Stream a URI to a local file.
 //!
 //! For URIs that may exceed RAM (speclib parquet, large FASTAs), this is the
-//! right primitive — it streams via `StorageProvider::get_to_file` for remote
+//! right primitive -- it streams via `StorageProvider::get_to_file` for remote
 //! and is a plain file copy for local. Unlike [`crate::open_reader`] it does
 //! not buffer the whole payload in memory, so no size cap is imposed.
 
diff --git a/rust/tims_stage/src/error.rs b/rust/tims_stage/src/error.rs
index 8ff69b0f..895e70a5 100644
--- a/rust/tims_stage/src/error.rs
+++ b/rust/tims_stage/src/error.rs
@@ -44,7 +44,7 @@ pub enum StageError {
     PayloadTooLarge { uri: String, size: u64, cap: u64 },
 }
 
-/// Strip query strings from a URI before embedding in an error message —
+/// Strip query strings from a URI before embedding in an error message --
 /// presigned-style URLs carry credentials in the query.
 pub(crate) fn redact_uri(uri: &str) -> String {
     match uri.split_once('?') {
diff --git a/rust/tims_stage/src/load.rs b/rust/tims_stage/src/load.rs
index 4f32815a..07864436 100644
--- a/rust/tims_stage/src/load.rs
+++ b/rust/tims_stage/src/load.rs
@@ -2,8 +2,8 @@
 //!
 //! `load_raw` is the one place raw dispatch happens. It sniffs the URI via the
 //! reader registry, asks the chosen reader for its [`Manifest`] (the files it
-//! needs), materializes those — in place for local inputs, or by fetching
-//! exactly the declared files for remote ones — and calls `read`. Transport
+//! needs), materializes those -- in place for local inputs, or by fetching
+//! exactly the declared files for remote ones -- and calls `read`. Transport
 //! never guesses vendor shape: it fetches what the reader declared, by name.
 //!
 //! Lives in `tims_stage` (one crate above `timscentroid`, where the registry
@@ -84,7 +84,7 @@ pub fn load_raw(
         });
     }
 
-    // Local: canonicalize first so RELATIVE paths resolve — `local_uri`
+    // Local: canonicalize first so RELATIVE paths resolve -- `local_uri`
     // (sniff) and `local_in_place` (read) both require an absolute path. This
     // is the single place all entry points funnel through, so relative inputs
     // work uniformly (`read_index`, `load_index_auto`, the pyo3 binding, …).
@@ -257,7 +257,7 @@ mod tests {
         let dotd = src.path().join("sample.d");
         std::fs::create_dir(&dotd).unwrap();
         std::fs::write(dotd.join("analysis.tdf"), b"tdf").unwrap();
-        // analysis.tdf_bin intentionally absent — must error, not silently skip.
+        // analysis.tdf_bin intentionally absent -- must error, not silently skip.
 
         let backend = PerRunTempdir::new(StagingConfig::default()).unwrap();
         let err = stage_manifest(&backend, &dotd_manifest(&dotd)).unwrap_err();
diff --git a/rust/tims_stage/src/open.rs b/rust/tims_stage/src/open.rs
index 9f691039..03caa146 100644
--- a/rust/tims_stage/src/open.rs
+++ b/rust/tims_stage/src/open.rs
@@ -8,7 +8,7 @@
 //! single buffer.
 //!
 //! **This path is only appropriate for small inputs** (speclibs, FASTAs,
-//! peptide lists — typically MBs to low-GB). The default cap is
+//! peptide lists -- typically MBs to low-GB). The default cap is
 //! [`DEFAULT_IN_MEMORY_CAP`] (4 GiB); remote payloads that exceed this abort
 //! with [`StageError::PayloadTooLarge`] *before* the full GET. For streaming
 //! reads of larger objects (e.g. raw `.d` bundles), use the tar / prefix
@@ -44,7 +44,7 @@ pub fn open_reader(uri: &str) -> Result<Box<dyn Read + Send>, StageError> {
 
 /// Cheap existence probe for a URI. Remote URIs dispatch a HEAD through the
 /// provider; local paths call `Path::exists`. Network failures surface as
-/// [`StageError::Transport`] — only `NotFound` translates to `Ok(false)`.
+/// [`StageError::Transport`] -- only `NotFound` translates to `Ok(false)`.
 pub fn uri_exists(uri: &str) -> Result<bool, StageError> {
     if is_remote_uri(uri) {
         let (loc, key) = split_uri(uri)?;
diff --git a/rust/tims_stage/src/resolve.rs b/rust/tims_stage/src/resolve.rs
index 77f947f0..8b240c99 100644
--- a/rust/tims_stage/src/resolve.rs
+++ b/rust/tims_stage/src/resolve.rs
@@ -21,13 +21,13 @@ use timscentroid::{
 
 #[derive(Debug)]
 pub enum Resolved {
-    /// A prebuilt `.idx` (local or remote) — load directly, no reader dispatch.
+    /// A prebuilt `.idx` (local or remote) -- load directly, no reader dispatch.
     Idx { loc: StorageLocation },
     /// A raw vendor artifact (local path or `s3://…`). Handed to
     /// [`crate::load::load_raw`], which sniffs the reader and manifest-stages
     /// remote inputs. Carries the canonical URI verbatim.
     Raw { uri: String },
-    /// A tarred `.d` container — extracted to a tempdir first, then read as a
+    /// A tarred `.d` container -- extracted to a tempdir first, then read as a
     /// local `.d`. (Bruker-specific transport.)
     Tar { spec: SourceSpec },
 }
@@ -62,7 +62,7 @@ pub fn resolve(uri: &str) -> Result<Resolved, StageError> {
     }
 
     // No sidecar. `.tar` is a container (extract first); everything else is a
-    // raw artifact handed to the reader registry via `load_raw` — no vendor
+    // raw artifact handed to the reader registry via `load_raw` -- no vendor
     // shape decided here.
     match (shape.loc, shape.name) {
         (_, NameKind::Raw) => Ok(Resolved::Raw {
diff --git a/rust/tims_stage/src/tar.rs b/rust/tims_stage/src/tar.rs
index c4fdb40a..825acab7 100644
--- a/rust/tims_stage/src/tar.rs
+++ b/rust/tims_stage/src/tar.rs
@@ -28,7 +28,7 @@ const PREFETCH: usize = 64 * 1024;
 /// Abstraction over "something we can pull byte ranges out of".
 ///
 /// `read_range` is for small header reads (up to a few KiB). For large
-/// payload copies (often GBs), use `copy_range_to_file` which streams — the
+/// payload copies (often GBs), use `copy_range_to_file` which streams -- the
 /// S3 impl routes that through one range-GET whose response body writes
 /// directly to disk. Never loop `read_range` for big payloads: each call
 /// is a separate HTTP GET on S3.
@@ -234,10 +234,10 @@ fn basename_of(path: &str) -> &str {
 /// Returns a map `basename -> (payload_offset, payload_size)`.
 ///
 /// Typeflag handling:
-///   - `'0'` / `0`  : regular file — record if basename is required.
-///   - `'x'` / `'g'`: pax extended header — skip payload.
-///   - `'L'` / `'K'`: GNU long-name record — hard error.
-///   - anything else: unknown — skip payload, don't record.
+///   - `'0'` / `0`  : regular file -- record if basename is required.
+///   - `'x'` / `'g'`: pax extended header -- skip payload.
+///   - `'L'` / `'K'`: GNU long-name record -- hard error.
+///   - anything else: unknown -- skip payload, don't record.
 ///
 /// Permissive-by-default; the corpus-inventory step will tell us which
 /// branches can be pruned later.
@@ -267,9 +267,9 @@ fn walk_tar_index(reader: &mut dyn TarReader) -> Result<BTreeMap<String, (u64, u
                     out.insert(bn, (payload_offset, h.size));
                 }
             }
-            b'x' | b'g' => { /* pax extended header — skip payload */ }
+            b'x' | b'g' => { /* pax extended header -- skip payload */ }
             b'L' | b'K' => return Err(StageError::UnsupportedTarFeature),
-            _ => { /* unknown typeflag — skip payload */ }
+            _ => { /* unknown typeflag -- skip payload */ }
         }
         offset = payload_offset + padded;
         if REQUIRED.iter().all(|r| out.contains_key(*r)) {
diff --git a/rust/tims_stage/src/upload.rs b/rust/tims_stage/src/upload.rs
index 41033fe4..8a03195b 100644
--- a/rust/tims_stage/src/upload.rs
+++ b/rust/tims_stage/src/upload.rs
@@ -4,7 +4,7 @@
 //! small outputs** (result JSONs, parquet shards, run reports). For the
 //! default cap see [`DEFAULT_UPLOAD_CAP`]. To stream a large `.d` bundle
 //! instead, bundle it into a tar and use the staging pipeline in reverse
-//! (not yet implemented — avoid pointing `upload_file` at multi-GB payloads).
+//! (not yet implemented -- avoid pointing `upload_file` at multi-GB payloads).
 
 use crate::common::transport_err;
 use crate::error::StageError;
diff --git a/rust/tims_stage/src/uri.rs b/rust/tims_stage/src/uri.rs
index def6e5f3..14176b8a 100644
--- a/rust/tims_stage/src/uri.rs
+++ b/rust/tims_stage/src/uri.rs
@@ -4,7 +4,7 @@ use crate::error::StageError;
 use std::path::Path;
 use timscentroid::StorageLocation;
 
-/// Where an URI points — local filesystem or remote object store.
+/// Where an URI points -- local filesystem or remote object store.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum LocKind {
     Local,
@@ -14,9 +14,9 @@ pub(crate) enum LocKind {
 /// What kind of artifact the URI names, by suffix.
 ///
 /// Only two categories matter to staging/resolution: a prebuilt `.idx`, a
-/// `.tar` container, or `Raw` — any vendor artifact. Vendor SHAPE (`.d`,
+/// `.tar` container, or `Raw` -- any vendor artifact. Vendor SHAPE (`.d`,
 /// `.mzML`, `.wiff`) is NOT classified here; that lives in each reader's
-/// `sniff`. `Raw` never errors on an unfamiliar suffix — the reader registry
+/// `sniff`. `Raw` never errors on an unfamiliar suffix -- the reader registry
 /// rejects genuinely-unknown formats at dispatch time (loudly), not the parser.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum NameKind {
diff --git a/rust/tims_stage/tests/minio_smoke.rs b/rust/tims_stage/tests/minio_smoke.rs
index 5ffbe4a1..769d105b 100644
--- a/rust/tims_stage/tests/minio_smoke.rs
+++ b/rust/tims_stage/tests/minio_smoke.rs
@@ -13,7 +13,7 @@ use common::minio;
 ///
 /// Fixtures are seeded by the test itself (two tiny objects) so no external
 /// bucket state is assumed. A missing `MINIO_TEST_ENDPOINT` is a hard failure
-/// when the test runs — silent passes would mask CI misconfiguration.
+/// when the test runs -- silent passes would mask CI misconfiguration.
 #[test]
 #[ignore = "requires MinIO endpoint + aws feature; run explicitly with --ignored"]
 fn stage_manifest_against_minio() {
diff --git a/rust/timscentroid/src/centroiding.rs b/rust/timscentroid/src/centroiding.rs
index 1c1e4731..ffdc9954 100644
--- a/rust/timscentroid/src/centroiding.rs
+++ b/rust/timscentroid/src/centroiding.rs
@@ -44,7 +44,7 @@ pub struct CentroidingConfig {
     /// after which the centroiding will stop early (instead of going
     /// through all peaks, which will very likely be noise).
     /// A number ~200 seems to work well in practice. **`0` disables
-    /// early-stop** — the whole frame is clustered and only `max_peaks`
+    /// early-stop** -- the whole frame is clustered and only `max_peaks`
     /// can truncate it. Disabling is the right choice under a tight
     /// `mz_ppm_tol`, where most peaks are singletons and early-stop would
     /// otherwise clip real signal (see `IndexingCentroidingConfig`).
@@ -67,7 +67,7 @@ impl Default for CentroidingConfig {
 /// MS1 and MS2 are centroided independently: MS1 favors precursor m/z
 /// precision (peak counts are small, so a tight merge is cheap), while MS2
 /// keeps a tight m/z merge with early-stop disabled and a moderate
-/// `max_peaks` cap — the setting that preserves fragment signal without the
+/// `max_peaks` cap -- the setting that preserves fragment signal without the
 /// peak-count explosion of a full raw pass.
 ///
 /// Use [`IndexingCentroidingConfig::uniform`] to apply one config to both
@@ -100,7 +100,7 @@ impl Default for IndexingCentroidingConfig {
                 max_peaks: 50_000,
                 mz_ppm_tol: 1.0,
                 im_pct_tol: 3.0,
-                early_stop_iterations: 0, // disabled — see field doc
+                early_stop_iterations: 0, // disabled -- see field doc
             },
         }
     }
diff --git a/rust/timscentroid/src/dimension.rs b/rust/timscentroid/src/dimension.rs
index 9ae9fdf4..e9073b73 100644
--- a/rust/timscentroid/src/dimension.rs
+++ b/rust/timscentroid/src/dimension.rs
@@ -13,7 +13,7 @@
 /// and take the mobility-less fallback path.
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 pub enum MobilityKind {
-    /// TIMS 1/K0 — the only searchable kind (current behavior).
+    /// TIMS 1/K0 -- the only searchable kind (current behavior).
     Ook0,
     /// No IM axis (mzML, no-IM library); the stored scalar is a sentinel.
     Absent,
diff --git a/rust/timscentroid/src/geometry.rs b/rust/timscentroid/src/geometry.rs
index 779a6405..08f4c967 100644
--- a/rust/timscentroid/src/geometry.rs
+++ b/rust/timscentroid/src/geometry.rs
@@ -53,7 +53,7 @@ pub enum RingShape {
         mz_lo: (f64, f64),
         mz_hi: (f64, f64),
     },
-    /// Generic polygon fallback. Not expected on current instruments —
+    /// Generic polygon fallback. Not expected on current instruments --
     /// loading one fires a single-shot `tracing::warn!` asking the user
     /// to report the ring shape so we can extend the classifier.
     Polygon(Polygon<f64>),
diff --git a/rust/timscentroid/src/indexing.rs b/rust/timscentroid/src/indexing.rs
index 4c9644d0..b742789d 100644
--- a/rust/timscentroid/src/indexing.rs
+++ b/rust/timscentroid/src/indexing.rs
@@ -420,7 +420,7 @@ impl IndexedTimstofPeaks {
 ///
 /// Four length-aligned columns carried together as a single value. Fields
 /// are private so the "all columns same length" invariant can't be broken
-/// by a direct push to one column — callers go through `push`, which
+/// by a direct push to one column -- callers go through `push`, which
 /// advances all four in lockstep.
 #[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
 pub struct PeakColumns<T: RTIndex> {
@@ -456,7 +456,7 @@ impl<T: RTIndex> PeakColumns<T> {
         self.cycle_index.reserve(n);
     }
 
-    /// Atomic row append — all four columns advance together.
+    /// Atomic row append -- all four columns advance together.
     #[inline]
     pub fn push(&mut self, mz: f32, intensity: f32, mobility: MobInt, cycle_index: T) {
         self.mz.push(mz);
@@ -475,7 +475,7 @@ impl<T: RTIndex> PeakColumns<T> {
         }
     }
 
-    /// Consume into raw column Vecs. Private — drops the bundled invariant;
+    /// Consume into raw column Vecs. Private -- drops the bundled invariant;
     /// used only by the AoS sort round-trip inside this module.
     fn into_parts(self) -> (Vec<f32>, Vec<f32>, Vec<MobInt>, Vec<T>) {
         (self.mz, self.intensity, self.mobility, self.cycle_index)
@@ -892,7 +892,7 @@ pub fn dump_for_each_peak_funnel(label: &str) {
     }
 }
 
-/// Zero the funnel counters — call between phases so each phase's dump
+/// Zero the funnel counters -- call between phases so each phase's dump
 /// shows its own contribution, not cumulative. No-op when `query-instr`
 /// is disabled.
 pub fn reset_for_each_peak_funnel() {
@@ -971,7 +971,7 @@ fn check_bucket_sorted_heuristic_aos<T: RTIndex>(
 ) -> bool {
     // 1. max mz of each bucket <= min mz of the next bucket
     // 2. each bucket is sorted by cycle_index (fully checked on bucket 0,
-    //    first/last only on later buckets — cheap heuristic)
+    //    first/last only on later buckets -- cheap heuristic)
     let mut last_max = f32::MIN;
     let buckets_ordered = peaks.chunks(bucket_size).all(|bucket| {
         let curr_min = bucket
@@ -1046,7 +1046,7 @@ fn apply_mob_mask<const N: usize>(
 /// Per-bucket inner scan for `for_each_peak`. `mz_filter = Unrestricted` means
 /// "the whole bucket is known to be inside the query mz range, skip the per-peak
 /// mz compare". With `#[inline(always)]` + the `OptionallyRestricted` split at
-/// each call site, LLVM specializes two code paths — one that branches on mz per
+/// each call site, LLVM specializes two code paths -- one that branches on mz per
 /// peak, one that doesn't.
 ///
 /// Each filter reads only the column it needs (mz or mobility). The full
@@ -1122,7 +1122,7 @@ fn scan_bucket_slice<T, F>(
 impl<T: RTIndex> IndexedPeakGroup<T> {
     /// Query peaks based on m/z, rt, and im ranges.
     ///
-    /// Returns an iterator of owned `IndexedPeak<T>` — peaks are materialized
+    /// Returns an iterator of owned `IndexedPeak<T>` -- peaks are materialized
     /// from the SoA columns on demand.
     pub fn query_peaks(
         &self,
@@ -1134,7 +1134,7 @@ impl<T: RTIndex> IndexedPeakGroup<T> {
     }
 
     /// Callback-style peak scan. Mirrors `query_peaks` but fuses the
-    /// consumer body into the inner bucket loop — no
+    /// consumer body into the inner bucket loop -- no
     /// `Iterator::next` call boundary per peak. Per the flamegraph,
     /// `QueryPeaksIterator::next` takes ~63% of wall at
     /// `RAYON_NUM_THREADS=1`; inlining the consumer via `#[inline]`
@@ -1213,7 +1213,7 @@ impl<T: RTIndex> IndexedPeakGroup<T> {
                 bucket_size
             );
         }
-        // Cheap but worth it — <40ms even on Hela.
+        // Cheap but worth it -- <40ms even on Hela.
         assert!(peaks.iter().all(|x| x.intensity >= 0.0));
         let max_cycle = T::new(cycle_to_rt_ms.len() as u32 - 1);
         assert!(peaks.iter().all(|x| x.cycle_index <= max_cycle));
@@ -1769,7 +1769,7 @@ mod tests {
     }
 
     /// The matched-peak set returned by `for_each_peak` (the production query
-    /// path) must NOT depend on `bucket_size` — bucketing is an index-layout
+    /// path) must NOT depend on `bucket_size` -- bucketing is an index-layout
     /// detail, not a filter. Regression guard for a bucket-boundary bug where
     /// `query_bucket_range` used `end() <= mz_range.start()` and dropped peaks
     /// at exactly the query's (inclusive) lower m/z bound. Stresses duplicated
diff --git a/rust/timscentroid/src/reader/mod.rs b/rust/timscentroid/src/reader/mod.rs
index d75e339a..c09eac82 100644
--- a/rust/timscentroid/src/reader/mod.rs
+++ b/rust/timscentroid/src/reader/mod.rs
@@ -4,7 +4,7 @@
 //! claims ([`RawReader::sniff`]), which artifacts belong together
 //! ([`RawReader::manifest`]), and how to build the in-memory index
 //! ([`RawReader::read`]). The [`ReaderRegistry`] picks a backend for a URI by
-//! sniffing — vendor suffix/scheme knowledge lives ONLY in each reader, never
+//! sniffing -- vendor suffix/scheme knowledge lives ONLY in each reader, never
 //! in the staging/resolve layer. Adding a format is one `impl RawReader` + one
 //! registry push.
 
@@ -65,7 +65,7 @@ impl ResolvedSource {
         Self { dir, entry }
     }
 
-    /// Borrow a local artifact in place — no staging. `dir` is the artifact's
+    /// Borrow a local artifact in place -- no staging. `dir` is the artifact's
     /// parent, `entry` its own name (a `.d` dir or an `.mzML` file).
     pub fn local_in_place(path: &Path) -> Result<Self, ReadError> {
         let dir = path
@@ -132,7 +132,7 @@ pub trait RawReader: Send + Sync {
     }
 
     /// The exact artifact set (entry + required + optional). Vendor "which
-    /// files belong together" knowledge lives here, nowhere else — the staging
+    /// files belong together" knowledge lives here, nowhere else -- the staging
     /// layer fetches exactly these, by name, so transport never guesses shape.
     fn manifest(&self, uri: &Uri) -> Manifest;
 
@@ -144,7 +144,7 @@ pub trait RawReader: Send + Sync {
 
     /// Extensions this reader claims for single-FILE inputs, for building
     /// file-dialog / help filters (no leading dot, e.g. `["mzML", "mzml"]`).
-    /// Directory formats (`.d`) return `&[]` — they are picked as folders.
+    /// Directory formats (`.d`) return `&[]` -- they are picked as folders.
     fn file_extensions(&self) -> &'static [&'static str] {
         &[]
     }
@@ -172,7 +172,7 @@ impl ReaderRegistry {
         Self(v)
     }
 
-    /// The union of single-file extensions claimed by all registered readers —
+    /// The union of single-file extensions claimed by all registered readers --
     /// the single source of truth for "what raw files can we open" (dialog
     /// filters, help text). Directory formats (`.d`) are excluded.
     pub fn file_extensions(&self) -> Vec<&'static str> {
@@ -249,7 +249,7 @@ pub fn local_uri(path: &Path) -> Result<Uri, ReadError> {
         })
 }
 
-/// Bruker TDF `.d` reader — wraps [`IndexedTimstofPeaks::from_timstof_file`].
+/// Bruker TDF `.d` reader -- wraps [`IndexedTimstofPeaks::from_timstof_file`].
 ///
 /// MVP regression-safety: the manifest declares the minimal read set
 /// (`analysis.tdf` + `analysis.tdf_bin`) for documentation and future
diff --git a/rust/timscentroid/src/reader/mzdata.rs b/rust/timscentroid/src/reader/mzdata.rs
index cda5ba47..5f91a966 100644
--- a/rust/timscentroid/src/reader/mzdata.rs
+++ b/rust/timscentroid/src/reader/mzdata.rs
@@ -43,20 +43,20 @@ use crate::rt_mapping::{
 };
 
 /// CV accessions for the ion-mobility-type scan param.
-const ACC_INVERSE_REDUCED_IM: u32 = 1002815; // 1/K0 — searchable
+const ACC_INVERSE_REDUCED_IM: u32 = 1002815; // 1/K0 -- searchable
 const ACC_FAIMS_CV: u32 = 1001581; // FAIMS compensation voltage
 const ACC_DRIFT_TIME: u32 = 1002476; // drift time (not 1/K0)
 
 /// Bucket size for peak groups, matching the TDF path.
 const BUCKET_SIZE: usize = 4096;
 
-/// The `1.0` mobility placeholder stored on every peak of a non-`Ook0` run —
+/// The `1.0` mobility placeholder stored on every peak of a non-`Ook0` run --
 /// present only to satisfy `IndexedPeakGroup::new` (non-NaN, ≥0); never used
 /// once the mobility filter is unrestricted.
 const MOBILITY_SENTINEL: f32 = 1.0;
 
 /// Reader for open mzML. (Native Thermo `.raw` via mzdata's `thermo` feature is
-/// deferred — it needs `MZReader::open_path`, not the mzML-only `MzMLReader`
+/// deferred -- it needs `MZReader::open_path`, not the mzML-only `MzMLReader`
 /// used here, and would extend `sniff` to claim `.raw`.)
 pub struct MzdataReader;
 
@@ -103,7 +103,7 @@ impl RawReader for MzdataReader {
 /// Detect the mobility axis from a scan's `ion_mobility_type` param accession.
 /// Keys on the ACCESSION, not `has_ion_mobility()`: a real Astral file carries
 /// `FAIMS compensation voltage` (value 0), so `has_ion_mobility()` returns true
-/// and `ion_mobility()` returns 0.0 — both would mislead.
+/// and `ion_mobility()` returns 0.0 -- both would mislead.
 ///
 /// Returns `None` if the spectrum carries no scan yet (defer to a later
 /// spectrum); `Some(Absent)` when a scan exists but declares no IM-type param.
@@ -206,7 +206,7 @@ pub fn from_mzml_file(
                 }
                 continue;
             };
-            // Dedup windows by their bounds at millidalton (1e-3 m/z) precision —
+            // Dedup windows by their bounds at millidalton (1e-3 m/z) precision --
             // fine enough to keep genuinely distinct DIA windows apart, coarse
             // enough that float jitter maps a recurring window to one bin.
             let key = (
@@ -310,7 +310,7 @@ fn push_peaks<T: RTIndex>(spec: &impl SpectrumLike, cycle_index: T, out: &mut Ve
 }
 
 /// First strictly-overlapping window pair, if any. Half-open: adjacent DIA
-/// windows SHARE an edge (`upper == next.lower`), which is NOT an overlap — only
+/// windows SHARE an edge (`upper == next.lower`), which is NOT an overlap -- only
 /// a strict interior intersection (`a.lo < b.hi && b.lo < a.hi`) counts, so a
 /// normal contiguous DIA scheme does not trip it.
 fn first_overlapping_pair(windows: &[WindowAccum]) -> Option<(usize, usize)> {
@@ -329,7 +329,7 @@ fn warn_on_overlapping_windows(windows: &[WindowAccum]) {
         let (a, b) = (&windows[i], &windows[j]);
         warn!(
             "mzML: overlapping isolation windows ([{:.3},{:.3}] vs [{:.3},{:.3}]); \
-             staggered/demux acquisition is out of scope — results may be approximate",
+             staggered/demux acquisition is out of scope -- results may be approximate",
             a.mz_start, a.mz_end, b.mz_start, b.mz_end
         );
     }
diff --git a/rust/timscentroid/src/reader/uri_util.rs b/rust/timscentroid/src/reader/uri_util.rs
index 1c45f051..d39113a3 100644
--- a/rust/timscentroid/src/reader/uri_util.rs
+++ b/rust/timscentroid/src/reader/uri_util.rs
@@ -13,7 +13,7 @@ use http::uri::PathAndQuery;
 ///
 /// The `parse`/`from_parts` panics are effectively unreachable: `base` already
 /// parsed as a `Uri`, and callers only ever append literal path segments
-/// (`analysis.tdf`, `.scan`) to an already-valid, already-encoded path — so the
+/// (`analysis.tdf`, `.scan`) to an already-valid, already-encoded path -- so the
 /// result is always a valid URI path. A panic here means a caller passed an
 /// unencoded segment, which is a bug, not runtime input.
 fn with_path(base: &Uri, new_path: &str) -> Uri {
@@ -26,7 +26,7 @@ fn with_path(base: &Uri, new_path: &str) -> Uri {
     Uri::from_parts(parts).expect("reassembled URI is valid")
 }
 
-/// Append `/segment` to the URI path — a child within a directory URI.
+/// Append `/segment` to the URI path -- a child within a directory URI.
 /// `s3://bkt/sample.d` + `analysis.tdf` → `s3://bkt/sample.d/analysis.tdf`.
 pub fn child(base: &Uri, segment: &str) -> Uri {
     let path = base.path().trim_end_matches('/');
@@ -40,7 +40,7 @@ pub fn with_suffix(base: &Uri, suffix: &str) -> Uri {
     with_path(base, &format!("{path}{suffix}"))
 }
 
-/// Replace the last path segment with `name` — a co-located sibling artifact.
+/// Replace the last path segment with `name` -- a co-located sibling artifact.
 /// `.../a/foo.wiff` + `bar.data` → `.../a/bar.data`.
 pub fn sibling(base: &Uri, name: &str) -> Uri {
     let path = base.path().trim_end_matches('/');
diff --git a/rust/timscentroid/src/serialization/mod.rs b/rust/timscentroid/src/serialization/mod.rs
index f5a2351b..632343ab 100644
--- a/rust/timscentroid/src/serialization/mod.rs
+++ b/rust/timscentroid/src/serialization/mod.rs
@@ -536,7 +536,7 @@ impl IndexedTimstofPeaks {
         storage: StorageProvider,
         meta: TimscentroidMetadata,
     ) -> Result<Self, SerializationError> {
-        // Always parallel — measured 144s serial vs <expected ~20s parallel on
+        // Always parallel -- measured 144s serial vs <expected ~20s parallel on
         // a 1.1 GB / 9-shard index from S3. S3 supports thousands of concurrent
         // GETs per prefix, so the prior serial heuristic was pessimistic. Local
         // stays parallel (CPU-bound decode).
@@ -600,7 +600,7 @@ impl IndexedTimstofPeaks {
 
 // Helper function to write parquet to bytes (used by cloud storage).
 //
-// All four slices in `cols` share the same length — enforced by
+// All four slices in `cols` share the same length -- enforced by
 // `IndexedPeakGroup::columns`.
 fn write_peaks_to_parquet_bytes<T: RTIndex>(
     cols: PeakColumnsView<'_, T>,
@@ -658,7 +658,7 @@ fn write_peaks_to_parquet_bytes<T: RTIndex>(
 /// Extend SoA column buffers from a single Arrow RecordBatch.
 ///
 /// Validates schema + mobility invariants (non-negative, non-NaN) at the
-/// boundary — the inner scan loop assumes this.
+/// boundary -- the inner scan loop assumes this.
 pub(crate) fn extend_soa_from_batch<T: RTIndex>(
     dst: &mut PeakColumns<T>,
     batch: &RecordBatch,
diff --git a/rust/timscentroid/src/storage.rs b/rust/timscentroid/src/storage.rs
index 7bf34b2b..87d4de12 100644
--- a/rust/timscentroid/src/storage.rs
+++ b/rust/timscentroid/src/storage.rs
@@ -173,7 +173,7 @@ impl StorageProvider {
     }
 
     /// Non-creating constructor for read-only callers. Does NOT `create_dir_all`
-    /// on a local path — use `new` when you want writes (which may implicitly
+    /// on a local path -- use `new` when you want writes (which may implicitly
     /// create the parent directory).
     pub fn open(location: StorageLocation) -> Result<Self, SerializationError> {
         let (store, is_local, prefix): (Arc<dyn ObjectStore>, bool, String) = match location {
@@ -225,7 +225,7 @@ impl StorageProvider {
         })
     }
 
-    /// Fetch a specific byte range. Errors on short read — S3 returns 416 on
+    /// Fetch a specific byte range. Errors on short read -- S3 returns 416 on
     /// out-of-bounds, but `LocalFileSystem` silently truncates to EOF, so we
     /// post-check the returned length against the requested length. No
     /// pre-HEAD; the tar walker issues many small range GETs and doubling
diff --git a/rust/timscentroid/src/utils.rs b/rust/timscentroid/src/utils.rs
index 3986abb7..31a64611 100644
--- a/rust/timscentroid/src/utils.rs
+++ b/rust/timscentroid/src/utils.rs
@@ -5,7 +5,7 @@ use thiserror::Error;
 /// Non-negative non-NaN f16 mobility, stored as raw bits.
 ///
 /// Invariant: `bits` encodes a non-negative, non-NaN f16 value.
-/// Enforced at construction via `try_new` / `from_f16` — every `MobInt`
+/// Enforced at construction via `try_new` / `from_f16` -- every `MobInt`
 /// in flight has already passed the check.
 ///
 /// For values in the valid range, `u16` bit comparison matches `f16`
@@ -14,7 +14,7 @@ use thiserror::Error;
 /// hot path SIMD-trivial.
 ///
 /// `#[repr(transparent)]` ensures `Vec<MobInt>` is byte-identical to
-/// `Vec<u16>` — zero-cost reinterpretation in either direction when
+/// `Vec<u16>` -- zero-cost reinterpretation in either direction when
 /// needed (though construction must still go through `try_new`).
 #[derive(
     Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Serialize, serde::Deserialize,
@@ -55,7 +55,7 @@ impl MobInt {
         Self::try_new(m.to_bits())
     }
 
-    /// Free reinterpret — same bits, same register.
+    /// Free reinterpret -- same bits, same register.
     #[inline(always)]
     pub fn to_f16(self) -> f16 {
         f16::from_bits(self.0)
diff --git a/rust/timsquery/src/models/aggregators/chromatogram_agg.rs b/rust/timsquery/src/models/aggregators/chromatogram_agg.rs
index 2e627bab..7948e70c 100644
--- a/rust/timsquery/src/models/aggregators/chromatogram_agg.rs
+++ b/rust/timsquery/src/models/aggregators/chromatogram_agg.rs
@@ -19,7 +19,7 @@ use timscentroid::rt_mapping::{
 };
 use timscentroid::utils::TupleRange;
 
-// TODO: rename to `ChromatogramAccumulator` — struct carries query scalars
+// TODO: rename to `ChromatogramAccumulator` -- struct carries query scalars
 // (id, mobility_ook0, etc.) alongside the accumulated chromatograms, but the
 // "Collector" name dates from when it owned a full Target. The query
 // and accumulator roles are now structurally separated; a rename would match.
@@ -32,17 +32,17 @@ pub struct ChromatogramCollector<T: KeyLike, V: ArrayElement + ValueLike> {
     pub precursor_mono_mz: f64,
     pub precursor_charge: u8,
     /// Cached from `Target::precursor_mz_limits()` at reset
-    /// (skips negative-isotope labels — do not derive from mono_mz + charge alone).
+    /// (skips negative-isotope labels -- do not derive from mono_mz + charge alone).
     pub precursor_mz_limits: (f64, f64),
 
-    // mz_order inside each array IS the (key, mz) list we need for iteration —
+    // mz_order inside each array IS the (key, mz) list we need for iteration --
     // labels/mzs are NOT duplicated on the collector.
     pub precursors: MzMajorIntensityArray<i8, V>,
     pub fragments: MzMajorIntensityArray<T, V>,
     pub rt_range_ms: TupleRange<u32>,
 
     /// MS1 peaks written into any precursor chromatogram cell during the
-    /// most recent `add_query`. Informational only — downstream fast-path
+    /// most recent `add_query`. Informational only -- downstream fast-path
     /// decisions key off `n_fragment_peaks_added`.
     pub n_precursor_peaks_added: u64,
 
@@ -115,7 +115,7 @@ impl<T: KeyLike, V: ValueLike + ArrayElement> ChromatogramCollector<T, V> {
     }
 
     /// Like `try_reset_with` but lets callers override `rt_seconds` / `mobility_ook0`
-    /// without rebuilding the source eg — replaces the `eg.clone().with_rt_seconds(..)`
+    /// without rebuilding the source eg -- replaces the `eg.clone().with_rt_seconds(..)`
     /// and `eg.clone().with_mobility(..)` clone-then-mutate pattern.
     pub fn try_reset_with_overrides(
         &mut self,
diff --git a/rust/timsquery/src/models/aggregators/spectrum_agg.rs b/rust/timsquery/src/models/aggregators/spectrum_agg.rs
index c50af072..15f5df9f 100644
--- a/rust/timsquery/src/models/aggregators/spectrum_agg.rs
+++ b/rust/timsquery/src/models/aggregators/spectrum_agg.rs
@@ -23,11 +23,11 @@ use std::ops::{
 };
 
 /// Inline-capacity target matching `Target`'s precursor/fragment
-/// label TinyVecs — typical peptide ≤13 fragments / ≤3 precursors stays
+/// label TinyVecs -- typical peptide ≤13 fragments / ≤3 precursors stays
 /// stack-resident.
 const SPEC_INLINE_CAP: usize = 13;
 
-// TODO: rename to `SpectralAccumulator` — struct holds query scalars +
+// TODO: rename to `SpectralAccumulator` -- struct holds query scalars +
 // label/mz lists alongside the accumulated intensities. "Collector" name
 // predates the Query/Accumulator split.
 #[derive(Debug, Clone, Serialize)]
@@ -38,7 +38,7 @@ pub struct SpectralCollector<T: KeyLike, V: Default + ValueLike> {
     pub rt_seconds: f32,
     pub precursor_mono_mz: f64,
     pub precursor_charge: u8,
-    /// Cached from `Target::precursor_mz_limits()` — skips
+    /// Cached from `Target::precursor_mz_limits()` -- skips
     /// negative-isotope labels, do NOT recompute from mono_mz + charge.
     pub precursor_mz_limits: (f64, f64),
     // Labels + mzs: arrays carry only intensities, so we need separate storage.
@@ -74,7 +74,7 @@ impl<T: KeyLike, V: ValueLike + Default> SpectralCollector<T, V> {
         self.reset_with_overrides(eg, None, None);
     }
 
-    /// Reset with optional rt/mobility overrides — replaces
+    /// Reset with optional rt/mobility overrides -- replaces
     /// `item.query.clone().with_rt_seconds(r).with_mobility(m)` at callers.
     pub fn reset_with_overrides(
         &mut self,
diff --git a/rust/timsquery/src/models/capabilities.rs b/rust/timsquery/src/models/capabilities.rs
index b4af6307..8effb853 100644
--- a/rust/timsquery/src/models/capabilities.rs
+++ b/rust/timsquery/src/models/capabilities.rs
@@ -47,7 +47,7 @@ impl TargetCapabilities {
     /// decoys.
     ///
     /// Decoy generation is a scoring decision, so no constructor in this crate
-    /// produces it — `DecoyStrategy::LazyMassShift` has to be named outright,
+    /// produces it -- `DecoyStrategy::LazyMassShift` has to be named outright,
     /// and timsseek is the only thing that names it (`map_decoy_strategy`,
     /// resolved once in `finalize_reference_library` before `seal`). This is
     /// not a style preference: readers used to default to decoys here, and
diff --git a/rust/timsquery/src/models/indexed_data.rs b/rust/timsquery/src/models/indexed_data.rs
index abd3f54e..86db434e 100644
--- a/rust/timsquery/src/models/indexed_data.rs
+++ b/rust/timsquery/src/models/indexed_data.rs
@@ -111,7 +111,7 @@ struct QueryRanges {
 ///
 /// The combined gate: mobility is only searchable when BOTH the run index and
 /// the library carry a TIMS 1/K0 axis. If either side is `Absent`/`Unsupported`
-/// the axis is unrestricted — this is what prevents the H2 trap where a TIMS run
+/// the axis is unrestricted -- this is what prevents the H2 trap where a TIMS run
 /// against a no-IM library would filter the 1/K0 window around a library sentinel
 /// and silently return zero IDs.
 ///
@@ -170,7 +170,7 @@ impl QueryRanges {
 
     /// Compute query ranges with RT intersection (for ChromatogramCollector's
     /// pre-scoped rt_range_ms window). Returns None if the RT ranges don't
-    /// intersect — caller early-exits.
+    /// intersect -- caller early-exits.
     fn from_query_data_with_rt_intersection<FH: KeyLike>(
         query: &impl crate::traits::queriable_data::HasQueryData<FH>,
         tolerance: &Tolerance,
@@ -242,7 +242,7 @@ impl<FH: KeyLike> QueriableData<PointIntensityAggregator<FH>> for IndexedTimstof
                 self.rt_ms_to_cycle_index(rt)
             });
 
-        // Copy iterators to stack before the closures — can't borrow aggregator
+        // Copy iterators to stack before the closures -- can't borrow aggregator
         // immutably (for the iterator) and mutably (for `.intensity +=`) at once.
         let prec_mzs: tinyvec::TinyVec<[f64; 16]> =
             aggregator.iter_precursors().map(|(_, mz)| mz).collect();
diff --git a/rust/timsquery/src/models/target.rs b/rust/timsquery/src/models/target.rs
index 1dbf1259..76cde440 100644
--- a/rust/timsquery/src/models/target.rs
+++ b/rust/timsquery/src/models/target.rs
@@ -139,9 +139,9 @@ impl<T: KeyLike> Target<T> {
 
     /// In-place copy reusing Vec/TinyVec capacity. The `clear()` + `push`
     /// pattern preserves the destination's heap buffer capacity across
-    /// resets — after warm-up, zero alloc. Used by the isotope-offset
+    /// resets -- after warm-up, zero alloc. Used by the isotope-offset
     /// scratch in timsseek. `G` is any `QueryGeom` (e.g. the columnar
-    /// flyweight), not necessarily `Self` — the body reads `src` only
+    /// flyweight), not necessarily `Self` -- the body reads `src` only
     /// through trait methods.
     pub fn reset_from<G: crate::traits::QueryGeom<Label = T>>(&mut self, src: &G) {
         self.id.set_from(src.output_id());
diff --git a/rust/timsquery/src/serde/diann_speclib_io.rs b/rust/timsquery/src/serde/diann_speclib_io.rs
index 4df9cc23..6c36efa3 100644
--- a/rust/timsquery/src/serde/diann_speclib_io.rs
+++ b/rust/timsquery/src/serde/diann_speclib_io.rs
@@ -52,7 +52,7 @@ const PRODUCT_SIZE: usize = 12;
 
 /// Smallest plausible `Entry` on disk (peptide header + zero-fragment count +
 /// `dc` + entry_flags + proteotypic + pid_index + empty-name count). Used only
-/// to bound pre-allocation against a corrupt count prefix — never a parse gate.
+/// to bound pre-allocation against a corrupt count prefix -- never a parse gate.
 const MIN_ENTRY_BYTES: usize = 40;
 
 // --- Layer 1: decode ------------------------------------------------------
@@ -142,7 +142,7 @@ impl<'a> Cursor<'a> {
         self.take(n).map(|_| ())
     }
 
-    /// `vec<i32>`: `i32 count` + `count` contiguous i32 — skip.
+    /// `vec<i32>`: `i32 count` + `count` contiguous i32 -- skip.
     fn skip_vec_i32(&mut self) -> Result<(), TargetReadingError> {
         let n = self.read_count()?;
         self.skip_bytes(n * 4)
@@ -235,7 +235,7 @@ impl<'a> Peptide<'a> {
     }
 }
 
-/// `Peptide::read` — consume one peptide from `c` and return a view over its
+/// `Peptide::read` -- consume one peptide from `c` and return a view over its
 /// span. Works for both the target and (when `dc != 0`) the embedded decoy.
 fn read_peptide<'a>(c: &mut Cursor<'a>, version: i32) -> Result<Peptide<'a>, TargetReadingError> {
     let start = c.mark();
@@ -258,7 +258,7 @@ pub(crate) struct EntryView<'a> {
     had_file_decoy: bool,
 }
 
-/// `Entry::read` — a target `Peptide`, an optional embedded decoy, then the
+/// `Entry::read` -- a target `Peptide`, an optional embedded decoy, then the
 /// Entry-level fields.
 fn read_entry<'a>(
     c: &mut Cursor<'a>,
@@ -312,7 +312,7 @@ fn skip_entry(c: &mut Cursor, version: i32) -> Result<(), TargetReadingError> {
     let _proteotypic = c.read_i32()?;
     let _pid_index = c.read_i32()?;
     let name_len = c.read_count()?;
-    c.skip_bytes(name_len)?; // name bytes — skipped, decoded later in parallel
+    c.skip_bytes(name_len)?; // name bytes -- skipped, decoded later in parallel
     if version <= -3 {
         c.skip_bytes(12)?; // pg_qvalue, ptm_qvalue, site_conf
     }
@@ -362,7 +362,7 @@ impl SpecLib {
     }
 
     /// Memory-map a `.speclib` file, then parse the header. Avoids a ~file-sized
-    /// resident buffer — pages fault in on demand and are OS-reclaimable.
+    /// resident buffer -- pages fault in on demand and are OS-reclaimable.
     pub(crate) fn open_mmap(path: &Path) -> Result<Self, TargetReadingError> {
         let file = File::open(path).map_err(TargetReadingError::IoError)?;
         // SAFETY: read-only ingest. The library file is not written during load;
@@ -393,29 +393,29 @@ impl SpecLib {
         let _name = c.read_str()?;
         let _fasta_names = c.read_str()?;
 
-        // --- Section 1: proteins (Isoform[]) — walk & discard ---
+        // --- Section 1: proteins (Isoform[]) -- walk & discard ---
         let n_isoforms = c.read_count()?;
         for _ in 0..n_isoforms {
             skip_isoform(&mut c)?;
         }
 
-        // --- Section 2: protein_ids (PG[]) — keep only `ids` per group ---
+        // --- Section 2: protein_ids (PG[]) -- keep only `ids` per group ---
         let n_pg = c.read_count()?;
         let mut pg_ids = Vec::with_capacity(bounded_capacity(n_pg, c.remaining(), MIN_ENTRY_BYTES));
         for _ in 0..n_pg {
             pg_ids.push(read_pg_keep_ids(&mut c)?);
         }
 
-        // --- Sections 3-5: precursor / name / gene string dictionaries — discard ---
+        // --- Sections 3-5: precursor / name / gene string dictionaries -- discard ---
         for _ in 0..3 {
             skip_strings(&mut c)?;
         }
 
-        // --- Section 6: iRT range (2x f64) — discard (per-entry iRT present) ---
+        // --- Section 6: iRT range (2x f64) -- discard (per-entry iRT present) ---
         let _irt_min = c.read_f64()?;
         let _irt_max = c.read_f64()?;
 
-        // --- Section 7: entries — recorded, parsed lazily ---
+        // --- Section 7: entries -- recorded, parsed lazily ---
         let n_entries = c.read_count()?;
         let entries_start = c.mark();
 
@@ -441,7 +441,7 @@ impl SpecLib {
     ///
     /// Phase A (serial, allocation-free): walk the variable-length envelope
     /// recording each entry's start offset. Boundary finding is inherently
-    /// sequential — an entry's position depends on all prior entries' lengths.
+    /// sequential -- an entry's position depends on all prior entries' lengths.
     /// This is the ~1 core the format forces; it does no allocation or mapping.
     ///
     /// Phase B (parallel): each entry is re-parsed and mapped independently from
@@ -521,7 +521,7 @@ impl SpecLib {
     }
 }
 
-/// `Isoform::read` — read & discard.
+/// `Isoform::read` -- read & discard.
 fn skip_isoform(c: &mut Cursor) -> Result<(), TargetReadingError> {
     let _sp = c.read_i32()?;
     let size = c.read_count()?;
@@ -533,7 +533,7 @@ fn skip_isoform(c: &mut Cursor) -> Result<(), TargetReadingError> {
     c.skip_bytes(size * 4) // prec[size]
 }
 
-/// `PG::read` — keep only the `;`-joined `ids` string.
+/// `PG::read` -- keep only the `;`-joined `ids` string.
 fn read_pg_keep_ids(c: &mut Cursor) -> Result<String, TargetReadingError> {
     let size_p = c.read_count()?;
     let ids = c.read_str()?;
@@ -546,7 +546,7 @@ fn read_pg_keep_ids(c: &mut Cursor) -> Result<String, TargetReadingError> {
     Ok(ids)
 }
 
-/// `read_strings` — read & discard.
+/// `read_strings` -- read & discard.
 fn skip_strings(c: &mut Cursor) -> Result<(), TargetReadingError> {
     let n = c.read_count()?;
     for _ in 0..n {
@@ -564,14 +564,14 @@ fn bounded_capacity(count: usize, remaining_bytes: usize, min_record_bytes: usiz
 
 // --- Layer 3: map ---------------------------------------------------------
 
-/// Counts of fragments/records dropped during a decode — surfaced via `warn!`
+/// Counts of fragments/records dropped during a decode -- surfaced via `warn!`
 /// and returned for callers to assert on.
 #[derive(Debug, Default, Clone, Copy)]
 pub struct SpeclibDecodeStats {
     /// Fragments flagged `ExcludeFromAssay` (`type & 0x80`). Kept (see
     /// [`map_entry`]); counted for reporting only.
     pub exclude_flagged: usize,
-    /// Fragments with a neutral loss (`loss != 0`) — `IonAnnot` cannot hold loss.
+    /// Fragments with a neutral loss (`loss != 0`) -- `IonAnnot` cannot hold loss.
     pub loss_dropped: usize,
     /// Fragments whose ion-type code or recovered series was unusable.
     pub unknown_ion_dropped: usize,
@@ -599,7 +599,7 @@ impl SpeclibDecodeStats {
     }
 }
 
-/// Strip DIA-NN mod annotations — anything inside `(...)` or `[...]` — leaving
+/// Strip DIA-NN mod annotations -- anything inside `(...)` or `[...]` -- leaving
 /// the bare residue string.
 fn strip_mods(s: &str) -> String {
     let mut out = String::with_capacity(s.len());
@@ -655,7 +655,7 @@ fn append_arena(dst: &mut TargetColumns<IonAnnot>, mut src: TargetColumns<IonAnn
 
     // CSR offset arrays carry a leading 0; skip it and rebase the remainder onto
     // the running arena length. `try_from` mirrors the checked pushes in
-    // `TargetColumns` — an overflow fails loud rather than wrapping an offset.
+    // `TargetColumns` -- an overflow fails loud rather than wrapping an offset.
     dst.frag_off.extend(src.frag_off[1..].iter().map(|&o| {
         u32::try_from(o as usize + frag_base).expect("fragment arena exceeds u32 offset range")
     }));
@@ -721,7 +721,7 @@ fn map_entry(
     }
 
     // `name` (== transition_group_id) is `modified_peptide + charge`. Strip the
-    // exact known-charge decimal suffix — not "trailing digits" — so a
+    // exact known-charge decimal suffix -- not "trailing digits" -- so a
     // C-terminal mod ending in a digit is left intact.
     let charge = pep.charge();
     if charge < 1 || charge > u8::MAX as i32 {
@@ -758,7 +758,7 @@ fn map_entry(
 
     for f in pep.fragments() {
         // `type & 0x80` => ExcludeFromAssay: DIA-NN's non-quantifier transitions.
-        // They carry valid m/z + intensity and are kept — dropping them leaves
+        // They carry valid m/z + intensity and are kept -- dropping them leaves
         // ~3 fragments/precursor on real libraries, which starves cross-library
         // calibration matching (needs >=5 shared fragments). Counted only.
         if f.typ() & 0x80 != 0 {
@@ -788,7 +788,7 @@ fn map_entry(
         };
 
         // N-terminal (b/a/c): series = index; C-terminal (y/x/z): series =
-        // length - index (isotope arg is always 0 — a library fragment).
+        // length - index (isotope arg is always 0 -- a library fragment).
         let is_nterm = matches!(type_char, 'b' | 'a' | 'c');
         let series = if is_nterm {
             f.index() as i64
@@ -831,7 +831,7 @@ fn map_entry(
     }
 
     // (label, mz) pairs for the arena, with the parallel reference-intensity
-    // sidecar filled in the same order — dedup already collapsed duplicate
+    // sidecar filled in the same order -- dedup already collapsed duplicate
     // labels, so this order is what lands in `geom.frag_labels`.
     let mut frags: Vec<(IonAnnot, f64)> = Vec::with_capacity(kept.len());
     for &(ion, mz, height) in kept.iter() {
@@ -845,7 +845,7 @@ fn map_entry(
         precursor_mz: pep.mz() as f64,
         charge: charge as u8,
         // Library iRT is dimensionless here; keep it raw (no minute->second
-        // scaling) — Phase 1 RT tolerance is unrestricted.
+        // scaling) -- Phase 1 RT tolerance is unrestricted.
         rt_seconds: pep.i_rt(),
         mobility: pep.i_im(),
         frags: &frags,
@@ -879,7 +879,7 @@ pub fn parse_speclib_reader<R: Read>(reader: R) -> Result<ParsedSpeclib, TargetR
 
 /// Cheap sniff: extension is `.speclib` and the first 4 bytes are not the
 /// parquet magic `PAR1` (a `*.parquet.*.speclib` clash is handled by the parquet
-/// reader). No version check here — a too-new file must still sniff true so
+/// reader). No version check here -- a too-new file must still sniff true so
 /// `read` returns a real `UnsupportedSpeclibVersion` diagnostic.
 pub fn sniff_diann_speclib_library_file<T: AsRef<Path>>(path: T) -> bool {
     let path = path.as_ref();
@@ -912,16 +912,16 @@ pub fn read_diann_speclib_library_file<T: AsRef<Path>>(
     let path = path.as_ref();
     info!("Reading DIA-NN .speclib binary from {}", path.display());
 
-    // mmap the file (not an owned read) — pages fault in on demand, no
+    // mmap the file (not an owned read) -- pages fault in on demand, no
     // file-sized resident buffer.
     let (mut geom, frag_intens, stats, at_eof) = SpecLib::open_mmap(path)?.parse_parallel()?;
 
     if !at_eof {
         // A parse that doesn't land on EOF means the entries were misaligned
-        // (wrong field sizes / version gating) — the decoded library would be
+        // (wrong field sizes / version gating) -- the decoded library would be
         // silently corrupt. Fail loudly rather than return garbage.
         return Err(TargetReadingError::SpeclibParse(format!(
-            "parse did not land on EOF for {} — structural desync",
+            "parse did not land on EOF for {} -- structural desync",
             path.display()
         )));
     }
@@ -981,7 +981,7 @@ mod tests {
     }
 
     // All expected values below are sourced from `reference_parser.py` (an
-    // independent decoder), not from this reader — so the test is not circular.
+    // independent decoder), not from this reader -- so the test is not circular.
 
     #[test]
     fn test_sniff_diann_speclib() {
diff --git a/rust/timsquery/src/serde/index_serde.rs b/rust/timsquery/src/serde/index_serde.rs
index e47cff21..35950eab 100644
--- a/rust/timsquery/src/serde/index_serde.rs
+++ b/rust/timsquery/src/serde/index_serde.rs
@@ -620,7 +620,7 @@ fn sniff_cached_index(location: &str) -> Result<bool, crate::errors::DataReading
     let is_cloud = location.contains("://");
 
     if !is_cloud {
-        // Local: check filesystem directly — no StorageProvider, no logging noise
+        // Local: check filesystem directly -- no StorageProvider, no logging noise
         let metadata_path = std::path::Path::new(location).join("metadata.json");
         let is_cached = metadata_path.exists();
         debug!("Local index sniff: {} -> cached={}", location, is_cached);
@@ -806,7 +806,7 @@ pub fn load_index_auto(
                 reader = reader.with_centroiding_config(centroid_cfg);
             }
 
-            // Raw always returns eager (can't lazy-load raw — needs centroiding).
+            // Raw always returns eager (can't lazy-load raw -- needs centroiding).
             let (eager, source) = reader.read_index(input)?;
             Ok((IndexedPeaksHandle::Eager(eager), source))
         }
@@ -829,7 +829,7 @@ use tims_stage::{
     sidecar_of,
 };
 
-/// How an index was obtained — surfaced so callers (CLI, viewer) can tell the
+/// How an index was obtained -- surfaced so callers (CLI, viewer) can tell the
 /// user whether a prebuilt cache was reused or the raw data was rebuilt, and by
 /// which reader. Loading is otherwise transparent.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -852,14 +852,14 @@ use timscentroid::serialization::SerializationError;
 
 /// Load an eagerly-materialized index from a URI.
 ///
-/// - `uri` — local path or `s3://` URL. May point at a prebuilt `.idx`, a raw
+/// - `uri` -- local path or `s3://` URL. May point at a prebuilt `.idx`, a raw
 ///   artifact (`.d`, `.mzML`, …), or a `.tar` container.
-/// - `backend` — the staging backend used when a raw input must be fetched to
+/// - `backend` -- the staging backend used when a raw input must be fetched to
 ///   a local tempdir. Typically `&tims_stage::PerRunTempdir::new(cfg)?`.
-/// - `save_sidecar` — when true, and we built an index from a cache-capable raw
+/// - `save_sidecar` -- when true, and we built an index from a cache-capable raw
 ///   input, write a `.idx` sidecar to `sidecar_of(uri)` so the next run
 ///   short-circuits on the sidecar fast-path.
-/// - `centroid_cfg` — centroiding configuration threaded through the reader.
+/// - `centroid_cfg` -- centroiding configuration threaded through the reader.
 pub fn load_index(
     uri: &str,
     backend: &dyn StagingBackend,
@@ -911,7 +911,7 @@ pub fn load_index(
                     reader: reader_name,
                 },
             ))
-            // staged drops here (RAII) — tempdir removed.
+            // staged drops here (RAII) -- tempdir removed.
         }
     }
 }
diff --git a/rust/timsquery/src/serde/library_file.rs b/rust/timsquery/src/serde/library_file.rs
index 25065f37..0c41a70a 100644
--- a/rust/timsquery/src/serde/library_file.rs
+++ b/rust/timsquery/src/serde/library_file.rs
@@ -339,7 +339,7 @@ impl TargetTable {
     /// into the `frag_intens` sidecar so the timsseek bridge can score against
     /// them; sequences and the decoy flag are threaded into the arena too. When
     /// no extras were supplied (e.g. plain `IonAnnot` JSON, which only exercises
-    /// the extraction/geometry path), `frag_intens` stays `None` — matching the
+    /// the extraction/geometry path), `frag_intens` stays `None` -- matching the
     /// historical behavior where timsseek rejected that shape.
     fn from_elution_groups(egc: ElutionGroupCollection) -> Result<Self, TargetReadingError> {
         match egc {
@@ -561,7 +561,7 @@ pub fn read_targets<T: AsRef<Path>>(path: T) -> Result<TargetTable, TargetReadin
             }
         }
     }
-    // Dead default in practice (JsonReader always sniffs true) — a harmless
+    // Dead default in practice (JsonReader always sniffs true) -- a harmless
     // defensive fallback.
     Err(last_err.unwrap_or(TargetReadingError::UnableToParseElutionGroups))
 }
diff --git a/rust/timsquery/src/serde/skyline_io.rs b/rust/timsquery/src/serde/skyline_io.rs
index 9c79fbf6..d580ce41 100644
--- a/rust/timsquery/src/serde/skyline_io.rs
+++ b/rust/timsquery/src/serde/skyline_io.rs
@@ -281,7 +281,7 @@ fn parse_precursor_group(
     }
 
     // Fragments are every non-precursor row. Precursor (isotope) rows are
-    // ignored — downstream computes the isotope envelope from the peptide
+    // ignored -- downstream computes the isotope envelope from the peptide
     // sequence, matching the DIA-NN path.
     let fragment_rows: Vec<&SkylineLibraryRow> =
         rows.iter().filter(|r| !r.is_precursor_row()).collect();
diff --git a/rust/timsquery/src/traits/fragment_label.rs b/rust/timsquery/src/traits/fragment_label.rs
index 9abf2f0a..e415a698 100644
--- a/rust/timsquery/src/traits/fragment_label.rs
+++ b/rust/timsquery/src/traits/fragment_label.rs
@@ -18,7 +18,7 @@ pub trait DecoyShift {
 /// "b-ion count" feature). Implemented only by ion-annotated labels
 /// (`IonAnnot`); arbitrary string labels are `DecoyShift` but not
 /// `FragmentLabel`. NOTE: decoy m/z shifting is gated on `DecoyShift`, not this
-/// trait — a decoy variant computes its shift through `DecoyShift::decoy_shift_mz`,
+/// trait -- a decoy variant computes its shift through `DecoyShift::decoy_shift_mz`,
 /// which every label implements.
 // TODO(fragment-features): add series() accessor once a standalone series
 // enum exists (today series and ordinal are fused in `IonSeriesOrdinal`), and
diff --git a/rust/timsquery/src/traits/queriable_data.rs b/rust/timsquery/src/traits/queriable_data.rs
index e1f79a52..28563f8a 100644
--- a/rust/timsquery/src/traits/queriable_data.rs
+++ b/rust/timsquery/src/traits/queriable_data.rs
@@ -18,7 +18,7 @@ use timscentroid::rt_mapping::RTIndex;
 /// Data needed to build a query against the index.
 ///
 /// Exposes exactly what `QueryRanges::from_query_data` and per-aggregator
-/// `add_query` impls read — scalars for range building + iterators for
+/// `add_query` impls read -- scalars for range building + iterators for
 /// precursor and fragment m/z windows. A fully immutable view, implemented
 /// by `Target` as well as by aggregators that carry their own
 /// query scalars.
@@ -34,7 +34,7 @@ pub trait HasQueryData<FH: KeyLike> {
     fn rt_seconds(&self) -> f32;
     fn iter_precursors(&self) -> impl Iterator<Item = (i8, f64)> + '_;
     /// Borrowed label + copied mz. Named `iter_fragments` (not `_refs`)
-    /// since the mz is Copy — the `_refs` name would mislead readers.
+    /// since the mz is Copy -- the `_refs` name would mislead readers.
     fn iter_fragments<'a>(&'a self) -> impl Iterator<Item = (&'a FH, f64)> + 'a
     where
         FH: 'a;
diff --git a/rust/timsquery/src/utils/constants.rs b/rust/timsquery/src/utils/constants.rs
index 0b52f85a..4108364b 100644
--- a/rust/timsquery/src/utils/constants.rs
+++ b/rust/timsquery/src/utils/constants.rs
@@ -1,6 +1,6 @@
 /// Mass difference between the 13C and 12C carbon isotopes (Da), i.e. the
 /// spacing between adjacent peaks of a peptide isotope envelope. This is NOT
-/// the free-neutron mass (1.00866 Da) — using that overstates the spacing by
+/// the free-neutron mass (1.00866 Da) -- using that overstates the spacing by
 /// ~0.0053 Da/step, biasing measured M+1/M+2 m/z errors several ppm negative.
 /// Value: 13C = 13.0033548378 u (AME2020 / NIST), 12C ≡ 12; difference below.
 pub const C13_C12_MASS_DIFF: f64 = 1.0033548378;
diff --git a/rust/timsquery/tests/carafe_contract/README.md b/rust/timsquery/tests/carafe_contract/README.md
index 166cbb74..a416a020 100644
--- a/rust/timsquery/tests/carafe_contract/README.md
+++ b/rust/timsquery/tests/carafe_contract/README.md
@@ -15,8 +15,8 @@ Refs: `util/CallTimsQuery.java`, `ai/AIGear.java`, `dia/{PSMQuery,PSMQueryResult
 >
 > Two test modules pin the mechanically checkable parts against the literal
 > JSON in this document. If you edit a payload here, edit it there:
-> - `main.rs` (next to this file) — input (targets, tolerances)
-> - `timsquery_cli`'s `carafe_output_contract` module — output (result field
+> - `main.rs` (next to this file) -- input (targets, tolerances)
+> - `timsquery_cli`'s `carafe_output_contract` module -- output (result field
 >   names, `-a`/`-f` flag values, the `results.json` basename)
 
 ## CLI
@@ -38,9 +38,9 @@ Refs: `util/CallTimsQuery.java`, `ai/AIGear.java`, `dia/{PSMQuery,PSMQueryResult
 Binary path: `bin/timsquery/{windows,macos,linux}/timsquery_cli[.exe]`.
 
 **Fragile couplings** (most likely to break on a timsquery change):
-- Aggregator names are literals — rename breaks Carafe, no fallback.
-- `-o` is a dir; Carafe reads `<out_dir>/results.json` — basename must be exactly `results.json`.
-- Output parsed line-by-line — must be ndjson, one object per line.
+- Aggregator names are literals -- rename breaks Carafe, no fallback.
+- `-o` is a dir; Carafe reads `<out_dir>/results.json` -- basename must be exactly `results.json`.
+- Output parsed line-by-line -- must be ndjson, one object per line.
 - Exit 0 = success; nonzero logged, no retry.
 
 ## Tolerances (`-t`)
@@ -53,13 +53,13 @@ Binary path: `bin/timsquery/{windows,macos,linux}/timsquery_cli[.exe]`.
   "quad":     { "absolute": [quad, quad] }
 }
 ```
-`ms` unit key is dynamic on Carafe's side (`itolu`, currently `ppm`), but timsquery only accepts `ppm`/`da` (and the `Ppm`/`Absolute` spellings) — any other unit fails to deserialize. Each value is `[low, high]`. A negative `low` is valid and means the window sits entirely above the target mass. Defaults: itol 15, mobility 3.0, quad 0.1, rt_win 0.1 (spectra) / `CParameter.rt_win` (xic).
+`ms` unit key is dynamic on Carafe's side (`itolu`, currently `ppm`), but timsquery only accepts `ppm`/`da` (and the `Ppm`/`Absolute` spellings) -- any other unit fails to deserialize. Each value is `[low, high]`. A negative `low` is valid and means the window sits entirely above the target mass. Defaults: itol 15, mobility 3.0, quad 0.1, rt_win 0.1 (spectra) / `CParameter.rt_win` (xic).
 
 ### `ms` window derivation (`itol` / `itol_shift`)
 
 The `ms` window is `[itol - itol_shift, itol + itol_shift]`, built from two independent inputs:
 
-- **`itol`** = `CParameter.itol` — the configured fragment-ion tolerance (default 15). Static per run.
+- **`itol`** = `CParameter.itol` -- the configured fragment-ion tolerance (default 15). Static per run.
 - **`itol_shift`** = per-run **median observed m/z error**, a data-driven calibration offset measured before the query (`AIGear.java`, search `error_shift`):
   - Carafe collects MS1 and MS2 mass errors from already-matched ions, takes the median of each (`ms1_error_shift`, `ms2_error_shift`).
   - If precursor and fragment units match (`CParameter.tolu` == `CParameter.itolu`): `itol_shift = max(ms1_error_shift, ms2_error_shift)`.
@@ -71,7 +71,7 @@ timsquery interprets the pair as `[light_magnitude, heavy_magnitude]`: `[2, 7]`
 - signed error window = `[itol_shift - itol, itol_shift + itol]`
 - light magnitude = `itol - itol_shift`, heavy magnitude = `itol + itol_shift`
 
-Example: `itol` 15, `itol_shift` +2 → `[13, 17]` = "13 ppm light to 17 ppm heavy" = a ±15 ppm window centered on the +2 ppm systematic offset. This is the intended behavior — the offset shifts the window's center, `itol` sets its half-width.
+Example: `itol` 15, `itol_shift` +2 → `[13, 17]` = "13 ppm light to 17 ppm heavy" = a ±15 ppm window centered on the +2 ppm systematic offset. This is the intended behavior -- the offset shifts the window's center, `itol` sets its half-width.
 
 ## Targets (`-e`, `psm_query.json`)
 
@@ -85,7 +85,7 @@ JSON **array** of:
 
 ## Results (`-o`, `<out_dir>/results.json`)
 
-**ndjson** — one object per line, one line per `id`. Parsed `JSON.parseObject(line, …)`, keyed by `id`.
+**ndjson** -- one object per line, one line per `id`. Parsed `JSON.parseObject(line, …)`, keyed by `id`.
 (`.json` name is misleading; it is not a JSON array.)
 
 ### spectrum-aggregator → `PSMQueryResult`
diff --git a/rust/timsquery/tests/carafe_contract/main.rs b/rust/timsquery/tests/carafe_contract/main.rs
index 9ce2a6a4..26dd72a0 100644
--- a/rust/timsquery/tests/carafe_contract/main.rs
+++ b/rust/timsquery/tests/carafe_contract/main.rs
@@ -149,7 +149,7 @@ fn carafe_tolerance_spellings_deserialize() {
 }
 
 /// When Carafe's calibration offset exceeds the half-width the low edge goes
-/// negative — a window sitting entirely above the target mass. This already
+/// negative -- a window sitting entirely above the target mass. This already
 /// worked; the test pins it so a future "both edges must be positive" check
 /// cannot be added without failing. `mz_range`'s invariant is `low + high >= 0`.
 #[test]
diff --git a/rust/timsquery_cli/src/commands.rs b/rust/timsquery_cli/src/commands.rs
index e3c3453d..56261815 100644
--- a/rust/timsquery_cli/src/commands.rs
+++ b/rust/timsquery_cli/src/commands.rs
@@ -578,7 +578,7 @@ mod carafe_output_contract {
     /// Invariants 2 and 3, on the bytes rather than the type.
     ///
     /// The singular/plural split across the two modes (`precursor_mz` vs
-    /// `precursor_mzs`) is deliberate — two schemas, not a typo.
+    /// `precursor_mzs`) is deliberate -- two schemas, not a typo.
     #[test]
     fn spectrum_results_are_ndjson_with_the_contract_field_names() {
         // Two records with distinct ids: framing must not depend on there
diff --git a/rust/timsquery_viewer/src/app.rs b/rust/timsquery_viewer/src/app.rs
index b3e2dc7c..0d940f95 100644
--- a/rust/timsquery_viewer/src/app.rs
+++ b/rust/timsquery_viewer/src/app.rs
@@ -1270,7 +1270,7 @@ impl ViewerApp {
             ScreenshotState::Countdown { deadline } => {
                 let now = Instant::now();
                 if now >= *deadline {
-                    // Deadline reached — capture at native resolution
+                    // Deadline reached -- capture at native resolution
                     ctx.send_viewport_cmd(egui::ViewportCommand::Screenshot(
                         egui::UserData::default(),
                     ));
diff --git a/rust/timsquery_viewer/src/calibration.rs b/rust/timsquery_viewer/src/calibration.rs
index 179a6c62..392e9c2e 100644
--- a/rust/timsquery_viewer/src/calibration.rs
+++ b/rust/timsquery_viewer/src/calibration.rs
@@ -65,7 +65,7 @@ const CONTROL_STOP_REQUESTED: u8 = 2;
 // Configuration
 // ---------------------------------------------------------------------------
 
-/// How many scored elution groups between channel snapshots. The viewer's own —
+/// How many scored elution groups between channel snapshots. The viewer's own --
 /// it governs UI refresh, nothing the search does.
 const SNAPSHOT_INTERVAL: usize = 100;
 
@@ -313,7 +313,7 @@ impl ViewerCalibrationState {
     /// Stop and reset all state. Returns to Idle.
     pub fn reset(&mut self) {
         self.stop();
-        // Drop the receiver BEFORE joining — if the background thread is
+        // Drop the receiver BEFORE joining -- if the background thread is
         // blocked on tx.send(Done), dropping the receiver unblocks it.
         self.receiver = None;
         if let Some(handle) = self.thread_handle.take() {
@@ -395,7 +395,7 @@ impl ViewerCalibrationState {
     }
 
     /// Re-fit the curve to `self.snapshot_points`, on a grid the points themselves
-    /// span rather than the file's acquisition RT range — which would clamp an
+    /// span rather than the file's acquisition RT range -- which would clamp an
     /// iRT-scaled library, whose RTs fall entirely outside it, into one edge column.
     ///
     /// A geometry the points cannot support leaves the previous fit alone: a later
@@ -477,7 +477,7 @@ impl ViewerCalibrationState {
         let mut heap = CalibrantHeap::new(heap_capacity);
         let mut n_scored: usize = 0;
 
-        // Process in chunks — each chunk is parallelized via Rayon.
+        // Process in chunks -- each chunk is parallelized via Rayon.
         // Between chunks: merge heaps, send snapshot, check pause/stop.
         for chunk in indices.chunks(SNAPSHOT_INTERVAL) {
             // Check control flag between chunks.
@@ -498,13 +498,13 @@ impl ViewerCalibrationState {
                 }
             }
 
-            // Score chunk in parallel — per-thread TraceScorer + CalibrantHeap.
+            // Score chunk in parallel -- per-thread TraceScorer + CalibrantHeap.
             let chunk_heap: CalibrantHeap = chunk
                 .par_iter()
                 .fold(
                     || {
                         (
-                            // Viewer is interactive, not a hot path — a conservative
+                            // Viewer is interactive, not a hot path -- a conservative
                             // default capacity is fine; realloc on outliers is free.
                             TraceScorer::new(n_cycles, 16),
                             CalibrantHeap::new(heap_capacity),
@@ -593,7 +593,7 @@ impl ViewerCalibrationState {
     /// The points and their geometry come from the fitted grid, so a reader
     /// refits the same curve and the same ridge widths the viewer is showing.
     /// The residual statistics are the ones this file was loaded with, since the
-    /// viewer measures no residuals of its own — see [`Self::residuals`].
+    /// viewer measures no residuals of its own -- see [`Self::residuals`].
     pub fn save_to_file(
         &self,
         path: &std::path::Path,
@@ -876,7 +876,7 @@ impl ViewerCalibrationState {
                         let (grid_x_min, grid_x_max) = cs.grid_x_range();
                         let n_samples = 200;
 
-                        // Interpolated region (solid cyan) — within curve bounds
+                        // Interpolated region (solid cyan) -- within curve bounds
                         let interp_step = (curve_x_max - curve_x_min) / n_samples as f64;
                         let interp_pts: Vec<[f64; 2]> = (0..=n_samples)
                             .filter_map(|i| {
@@ -894,7 +894,7 @@ impl ViewerCalibrationState {
                             );
                         }
 
-                        // Extrapolated regions (dashed red) — beyond curve bounds
+                        // Extrapolated regions (dashed red) -- beyond curve bounds
                         // Clamp Y to grid range so extrapolation doesn't fly off
                         let (grid_y_min, grid_y_max) = cs.grid_y_range();
                         let extrap_color = egui::Color32::from_rgb(255, 100, 100);
@@ -1043,7 +1043,7 @@ impl ViewerCalibrationState {
     fn render_tolerance_suggestion(&mut self, ui: &mut egui::Ui, tolerance: &mut Tolerance) {
         let floor = self.search.min_rt_tolerance_minutes;
 
-        // The weight-averaged half-width gives the global tolerance — heavy
+        // The weight-averaged half-width gives the global tolerance -- heavy
         // columns count more.
         let ridge_stats = self.calibration_state.as_ref().and_then(|cs| {
             cs.curve()?; // ensure curve is fitted
@@ -1107,7 +1107,7 @@ impl ViewerCalibrationState {
 impl Drop for ViewerCalibrationState {
     fn drop(&mut self) {
         self.stop();
-        // Drop the receiver BEFORE joining — unblocks any tx.send(Done)
+        // Drop the receiver BEFORE joining -- unblocks any tx.send(Done)
         // in the background thread that would otherwise deadlock.
         self.receiver = None;
         if let Some(handle) = self.thread_handle.take() {
diff --git a/rust/timsquery_viewer/src/computed_state.rs b/rust/timsquery_viewer/src/computed_state.rs
index cca1f8a0..53633b1e 100644
--- a/rust/timsquery_viewer/src/computed_state.rs
+++ b/rust/timsquery_viewer/src/computed_state.rs
@@ -96,7 +96,7 @@ pub struct MobilityData {
     pub mobility_range: (f64, f64),
     /// 2x tolerance window (the actual query range)
     pub wide_mobility_range: (f64, f64),
-    /// Monotonically increasing counter — used to reset plot zoom on new data.
+    /// Monotonically increasing counter -- used to reset plot zoom on new data.
     pub generation: u64,
 }
 
@@ -126,7 +126,7 @@ enum ChromatogramState {
     Computed {
         cache_key: (u64, Tolerance, SmoothingMethod),
     },
-    /// Computation failed for this combination — prevents infinite retry
+    /// Computation failed for this combination -- prevents infinite retry
     Failed {
         cache_key: (u64, Tolerance, SmoothingMethod),
         error: String,
@@ -143,7 +143,7 @@ pub struct ComputedState {
     reference_lines: HashMap<String, (f64, Color32)>,
     ms2: Ms2State,
     mobility: MobilityState,
-    /// Reusable allocation — not reset between elution groups.
+    /// Reusable allocation -- not reset between elution groups.
     scratch: ScratchBuffers,
 }
 
@@ -424,7 +424,7 @@ impl ComputedState {
 
         let trace_scorer = scratch
             .trace_scorer
-            // Viewer is interactive, not a hot path — a conservative
+            // Viewer is interactive, not a hot path -- a conservative
             // default capacity is fine; realloc on outliers is free.
             .get_or_insert_with(|| TraceScorer::new(num_cycles, 16));
 
diff --git a/rust/timsquery_viewer/src/file_loader.rs b/rust/timsquery_viewer/src/file_loader.rs
index 935c5a08..3517345e 100644
--- a/rust/timsquery_viewer/src/file_loader.rs
+++ b/rust/timsquery_viewer/src/file_loader.rs
@@ -84,7 +84,7 @@ impl FileLoader {
 
     /// Open a file dialog for a single raw data FILE (mzML / Thermo raw).
     /// `.d`/`.idx` are directories and need `open_raw_data_dialog`. The accepted
-    /// extensions come from the reader registry — the single source of truth for
+    /// extensions come from the reader registry -- the single source of truth for
     /// which raw file formats are compiled in.
     pub fn open_raw_data_file_dialog(&mut self) {
         let extensions = timscentroid::reader::ReaderRegistry::with_builtins().file_extensions();
@@ -160,7 +160,7 @@ impl FileLoader {
 /// and the reference intensities + isotope envelope come from the flyweight's
 /// `ExpectedIntensity` impl, which routes the envelope through
 /// `isotope_dist_or_averagine` (averagine fallback). There is no private
-/// isotope model here — the viewer shows exactly what the CLI scores.
+/// isotope model here -- the viewer shows exactly what the CLI scores.
 #[derive(Debug)]
 pub struct ElutionGroupData {
     inner: ReferenceLibrary,
@@ -258,7 +258,7 @@ impl ElutionGroupData {
         // arena flyweight exactly the way the scoring pipeline does
         // (`fill_scratch_from`). The precursor envelope comes from
         // `expected_precursor_envelope()`, which routes through
-        // `isotope_dist_or_averagine` — no `[1.0, 0.0, 0.0]` fallback.
+        // `isotope_dist_or_averagine` -- no `[1.0, 0.0, 0.0]` fallback.
         let q = self.item_at(index);
         let mut eg = Target::empty_like();
         fill_scratch_from(&mut eg, &q);
@@ -440,7 +440,7 @@ mod tests {
 
     /// The envelope the viewer DISPLAYS (obtained via `get_elem`, i.e. the
     /// flyweight's `expected_precursor_envelope`) must equal what the scoring
-    /// path computes via `isotope_dist_or_averagine` — NOT the deleted
+    /// path computes via `isotope_dist_or_averagine` -- NOT the deleted
     /// `[1.0, 0.0, 0.0]` fallback.
     #[test]
     fn displayed_envelope_matches_isotope_dist_or_averagine() {
diff --git a/rust/timsquery_viewer/src/ui/panels/mobility_panel.rs b/rust/timsquery_viewer/src/ui/panels/mobility_panel.rs
index e5ae62cc..d4c08ea7 100644
--- a/rust/timsquery_viewer/src/ui/panels/mobility_panel.rs
+++ b/rust/timsquery_viewer/src/ui/panels/mobility_panel.rs
@@ -56,14 +56,14 @@ impl MobilityPanel {
             .allow_drag(true);
 
         plot.show(ui, |plot_ui| {
-            // 2x (wide query) range — solid lines
+            // 2x (wide query) range -- solid lines
             let (wide_lo, wide_hi) = data.wide_mobility_range;
             plot_ui
                 .hline(HLine::new("2x range lo", wide_lo).color(Color32::from_rgb(120, 120, 120)));
             plot_ui
                 .hline(HLine::new("2x range hi", wide_hi).color(Color32::from_rgb(120, 120, 120)));
 
-            // 1x (integration) range — dashed lines
+            // 1x (integration) range -- dashed lines
             let (tol_lo, tol_hi) = data.mobility_range;
             plot_ui.hline(
                 HLine::new("1x range lo", tol_lo)
@@ -76,7 +76,7 @@ impl MobilityPanel {
                     .style(egui_plot::LineStyle::dashed_dense()),
             );
 
-            // Reference mobility — thin dashed
+            // Reference mobility -- thin dashed
             plot_ui.hline(
                 HLine::new("ref mobility", data.ref_mobility)
                     .color(Color32::from_rgb(255, 60, 60))
diff --git a/rust/timsseek/DATA_FLOW.md b/rust/timsseek/DATA_FLOW.md
index 4abd6fc6..a2338b49 100644
--- a/rust/timsseek/DATA_FLOW.md
+++ b/rust/timsseek/DATA_FLOW.md
@@ -1,6 +1,6 @@
 # Scoring Pipeline Data Flow
 
-The flow, not the details — counts, defaults and hyperparameters live in the
+The flow, not the details -- counts, defaults and hyperparameters live in the
 code and are expected to drift. Paths are relative to `rust/`.
 
 ## Shape
@@ -10,12 +10,12 @@ hits, then re-extract everything with the calibrated windows.
 
 | Phase | Entry point | Does |
 |---|---|---|
-| 1. Prescore | `phase1_prescore` — `timsseek_cli/src/processing.rs` | Broad, uncalibrated extraction of the whole library; keeps the best-scoring peptides as calibrants. |
+| 1. Prescore | `phase1_prescore` -- `timsseek_cli/src/processing.rs` | Broad, uncalibrated extraction of the whole library; keeps the best-scoring peptides as calibrants. |
 | 2. Calibrate | `calibrate_from_phase1` | Fits the iRT→RT curve from the calibrants, measures m/z and mobility error, derives the narrow tolerances. |
 | 3. Score | `phase3_score` | Re-extracts every peptide at its calibrated RT with the derived tolerances and computes the full feature set. |
 | 4. Compete | `target_decoy_compete` | Dedups by sequence, competes within decoy groups, adds log-space group-difference features. |
-| 5. Rescore | `ml::rescore_with` — `timsseek/src/ml/mod.rs` | Fits a discriminant over feature projections and assigns q-values. LDA/MLP stream raw rows; GBM retains its input frame. |
-| 6. Write | `execute_pipeline` — `timsseek_cli/src/processing.rs` | Writes filtered results and optional feature-statistics sidecars, then completes the performance report. |
+| 5. Rescore | `ml::rescore_with` -- `timsseek/src/ml/mod.rs` | Fits a discriminant over feature projections and assigns q-values. LDA/MLP stream raw rows; GBM retains its input frame. |
+| 6. Write | `execute_pipeline` -- `timsseek_cli/src/processing.rs` | Writes filtered results and optional feature-statistics sidecars, then completes the performance report. |
 
 `main()` → `process_single_file()` loads the raw index, builds a `Scorer`, and
 calls `processing::run_pipeline()` → `execute_pipeline()`, which runs all six
@@ -36,10 +36,10 @@ Prescore and full scoring share `compute_traces()`
 composite apex profile; the apex is that profile's argmax.
 
 * **Phase 1** stops there. Its score is the apex profile peak itself, *not* an
-  evidence term — that value only has to rank calibrants.
+  evidence term -- that value only has to rank calibrants.
 * **Phase 3** additionally computes `ApexEvidence` (extraction-global, so
   computed once) and evaluates the apex-local features at the chosen cycle.
-  `main_score` combines them multiplicatively — evidence scaled by a product
+  `main_score` combines them multiplicatively -- evidence scaled by a product
   over the apex features.
 
 Phase 3 then refines in two passes (query at the apex for observed mobility,
@@ -70,7 +70,7 @@ order.
 
 Walk order per lane: scoring blocks (composition order) → `ResultMeta` →
 `Derived` → (nonlinear only) `sequence_counts`. `sequence_counts` is
-unconditional — an unparsed peptide contributes NaN rather than a shorter row,
+unconditional -- an unparsed peptide contributes NaN rather than a shorter row,
 so every row is the same width. Those AA counts have no linear lane, so LDA
 never sees them.
 
diff --git a/rust/timsseek/examples/query_bench.rs b/rust/timsseek/examples/query_bench.rs
index 892e4272..657c41ca 100644
--- a/rust/timsseek/examples/query_bench.rs
+++ b/rust/timsseek/examples/query_bench.rs
@@ -11,17 +11,17 @@
 //! All three go through the same `for_each_peak` / `for_each_ms1_peak`
 //! scan machinery, so time-delta between them attributes to sink cost.
 //! Total time per aggregator attributes the hot path (scan + filter +
-//! sink) at realistic peak density — library fragment m/zs cluster
+//! sink) at realistic peak density -- library fragment m/zs cluster
 //! around real peptide peaks, unlike a uniform-random mz bench.
 //!
 //! Run: cargo run -r -p timsseek --example query_bench
 //!
 //! Env overrides:
-//!   BENCH_DOTD    — .d path (default Hela)
-//!   BENCH_SPECLIB — speclib path (default asdad)
-//!   QB_N         — number of speclib entries to process (default 2000)
-//!   QB_ITERS     — outer repeat count (default 1)
-//!   QB_BUCKET    — rebucket to this size before benching (default 256,
+//!   BENCH_DOTD    -- .d path (default Hela)
+//!   BENCH_SPECLIB -- speclib path (default asdad)
+//!   QB_N         -- number of speclib entries to process (default 2000)
+//!   QB_ITERS     -- outer repeat count (default 1)
+//!   QB_BUCKET    -- rebucket to this size before benching (default 256,
 //!                  set 0 to skip rebucket and use on-disk size)
 
 use std::ops::AddAssign;
@@ -48,7 +48,7 @@ use timsseek::IonAnnot;
 use timsseek::data_sources::speclib::Speclib;
 use timsseek::models::DecoyPolicy;
 
-/// Counting peak sink — single u32 increment per peak. One dependent
+/// Counting peak sink -- single u32 increment per peak. One dependent
 /// scalar store (no fadd, no scatter, no memory fence) → cleanest
 /// "iteration + filter" cost ceiling. LLVM can't elide the counter
 /// because it's read from the aggregator after the call.
@@ -114,7 +114,7 @@ fn main() {
     let tolerance = Tolerance::default();
     eprintln!("Tolerance: {:?}", tolerance);
 
-    // Cycle-mapping range — use the index's full range so no RT filtering
+    // Cycle-mapping range -- use the index's full range so no RT filtering
     // prunes peaks away; isolates per-peak iteration cost.
     let cycle_mapping = index.ms1_cycle_mapping();
     let (min_rt, max_rt) = cycle_mapping.range_milis();
diff --git a/rust/timsseek/src/data_sources/reference_library.rs b/rust/timsseek/src/data_sources/reference_library.rs
index 7f9d153c..8cae2c70 100644
--- a/rust/timsseek/src/data_sources/reference_library.rs
+++ b/rust/timsseek/src/data_sources/reference_library.rs
@@ -191,7 +191,7 @@ impl<'a> QueryGeom for RefQuery<'a> {
 ///
 /// The two travel together because the scorer holds the run's raw-data index,
 /// not the library arena, so it cannot derive one from the other. Both are
-/// opaque, so neither can reach an output file or be confused with an id — the
+/// opaque, so neither can reach an output file or be confused with an id -- the
 /// writer resolves them against the arena at the end.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct RowHandles {
@@ -202,7 +202,7 @@ pub struct RowHandles {
 /// Arm-neutral identity accessors the scoring loop needs but that are NOT part
 /// of `QueryGeom` / `ExpectedIntensity`. Implemented by the `RefQuery`
 /// flyweight so the batch scoring loop stays generic (monomorphized,
-/// zero-heap) over the concrete type — see
+/// zero-heap) over the concrete type -- see
 /// `Scorer::{prescore,score_calibrated}_batch_impl`.
 pub trait ScoredIdentity {
     /// Whether this item is a target (vs a decoy variant).
diff --git a/rust/timsseek/src/data_sources/speclib.rs b/rust/timsseek/src/data_sources/speclib.rs
index 51a951bd..1905ea8d 100644
--- a/rust/timsseek/src/data_sources/speclib.rs
+++ b/rust/timsseek/src/data_sources/speclib.rs
@@ -158,7 +158,7 @@ impl ReferenceEG {
     }
 }
 
-/// Strip mod annotations — anything inside `(...)` or `[...]` — from a
+/// Strip mod annotations -- anything inside `(...)` or `[...]` -- from a
 /// sequence, leaving the bare residue string. The native format ships one
 /// (modified) sequence per precursor; the arena's composition-isotope path
 /// needs the stripped residues.
@@ -188,7 +188,7 @@ pub struct LoadReport {
 /// Finalize a freshly-narrowed lazy `ReferenceLibrary` arena: apply the decoy
 /// strategy, seal, run the whole-library parse gate + averagine tally, and set
 /// `caps.sequence_features`. This is the single shared tail of the DEFAULT
-/// `.speclib` load (see `speclib_data_flow.md`) — the memory-optimized path
+/// `.speclib` load (see `speclib_data_flow.md`) -- the memory-optimized path
 /// that avoids the 9 GB peak RSS of the fully-materialized target+2-decoy
 /// expansion.
 ///
@@ -315,7 +315,7 @@ impl SpeclibFormat {
     pub fn detect_from_extension(path: &Path) -> Option<Self> {
         let path_str = path.to_string_lossy().to_lowercase();
 
-        // Accept both `.zst` and `.zstd` — DIA-NN/user pipelines use either.
+        // Accept both `.zst` and `.zstd` -- DIA-NN/user pipelines use either.
         if path_str.ends_with(".msgpack.zst") || path_str.ends_with(".msgpack.zstd") {
             Some(SpeclibFormat::MessagePackZstd)
         } else if path_str.ends_with(".msgpack") {
@@ -926,7 +926,7 @@ mod tests {
         let lib = expect_lazy(&speclib);
 
         // Check that isotope intensities are normalized (M0 should be 1.0),
-        // for every flat entry (targets AND decoy variants — the envelope is
+        // for every flat entry (targets AND decoy variants -- the envelope is
         // computed per-target and shared across variants, see
         // `decoy_variant_reuses_target_intensities` in reference_library.rs).
         for q in lib.iter() {
@@ -976,7 +976,7 @@ mod tests {
         assert_eq!(n_decoys, 4, "Should have 4 decoy entries (2 per target)");
 
         // Each target index (== decoy_group in the old materialized scheme)
-        // should have exactly 3 flat variants (1 target + 2 decoys) — this is
+        // should have exactly 3 flat variants (1 target + 2 decoys) -- this is
         // guaranteed structurally by `ReferenceLibrary::item_at`'s `t,+,-`
         // packing, so assert it directly rather than re-deriving groups.
         let n_target_indices = lib.geom.n_rows();
@@ -1290,7 +1290,7 @@ mod tests {
     }
 
     /// The Mzpaf arena WITHOUT the intensity sidecar (`frag_intens: None`) is
-    /// the TSV/parquet/Skyline bridge shape — scoring is intensity-driven, so
+    /// the TSV/parquet/Skyline bridge shape -- scoring is intensity-driven, so
     /// narrowing it to a `ReferenceLibrary` must be an `Err` (the branch that
     /// causes the disclosed DIA-NN/Skyline regression).
     #[test]
diff --git a/rust/timsseek/src/fragment_mass/elution_group_converter.rs b/rust/timsseek/src/fragment_mass/elution_group_converter.rs
index 6ff9a0d9..bf0d5929 100644
--- a/rust/timsseek/src/fragment_mass/elution_group_converter.rs
+++ b/rust/timsseek/src/fragment_mass/elution_group_converter.rs
@@ -39,7 +39,7 @@ fn count_carbon_sulphur(form: &MolecularFormula) -> (u16, u16) {
 
     // `elements()` yields (element, isotope, count). The middle field is the
     // isotope (nucleon number, `None` for the natural/unspecified isotope), NOT
-    // the atom count — the count is the third field. `count` is i32 and can be
+    // the atom count -- the count is the third field. `count` is i32 and can be
     // negative for a loss; clamp before the u16 cast.
     for (elem, _isotope, count) in form.elements() {
         let n = (*count).max(0) as u16;
@@ -54,7 +54,7 @@ fn count_carbon_sulphur(form: &MolecularFormula) -> (u16, u16) {
 }
 
 /// In-chain (C, S) atom counts per standard residue, indexed by `byte - b'A'`.
-/// `None` = a non-standard code (B/J/O/U/X/Z) — defer to the rustyms path.
+/// `None` = a non-standard code (B/J/O/U/X/Z) -- defer to the rustyms path.
 ///
 /// A residue contributes the same carbon/sulfur as its free amino acid: forming
 /// a peptide bond removes one water per bond and the terminal water carries
diff --git a/rust/timsseek/src/ml/cv.rs b/rust/timsseek/src/ml/cv.rs
index 5b8f997a..8ea27621 100644
--- a/rust/timsseek/src/ml/cv.rs
+++ b/rust/timsseek/src/ml/cv.rs
@@ -246,7 +246,7 @@ impl GBMConfig {
     }
 }
 
-/// Label + score access for a scored record — everything
+/// Label + score access for a scored record -- everything
 /// [`CrossValidatedScorer`] needs from `T` once the feature matrix exists.
 pub(crate) trait FeatureLike {
     fn get_y(&self) -> f64;
@@ -407,7 +407,7 @@ pub(crate) trait FoldModel: Sized {
     ///
     /// # The NAN-vs-finite contract
     /// * `f32::NAN` means **"this model does not report a value for this
-    ///   column"** — the column is absent from the sidecar for this fold.
+    ///   column"** -- the column is absent from the sidecar for this fold.
     /// * Any FINITE value, **including `0.0`**, is a reported measurement and
     ///   reaches the sidecar as-is.
     ///
@@ -566,14 +566,14 @@ impl DataBuffer {
         }
     }
 
-    /// [`Self::fill_features_from`] plus the label channel — the TRAINING path.
+    /// [`Self::fill_features_from`] plus the label channel -- the TRAINING path.
     fn fill_from<D: FoldDataset>(&mut self, data: &D, rows: &[usize], ncols: usize) {
         self.fill_features_from(data, rows, ncols);
         self.response_buffer
             .extend(rows.iter().map(|&i| f64::from(!data.is_decoy(i))));
     }
 
-    /// Feature matrix only — valid after EITHER fill.
+    /// Feature matrix only -- valid after EITHER fill.
     fn features_as_matrix(&self) -> Matrix<'_, f64> {
         assert_eq!(self.fold_buffer.len(), self.nrows * self.ncols);
         let mat = Matrix::new(self.fold_buffer.as_slice(), self.nrows, self.ncols);
@@ -583,14 +583,14 @@ impl DataBuffer {
 
     /// Features + labels. Only valid after [`Self::fill_from`].
     ///
-    /// The assertion catches a features-only gather OF A NON-EMPTY ROW SET —
+    /// The assertion catches a features-only gather OF A NON-EMPTY ROW SET --
     /// [`Self::fill_features_from`] clears `response_buffer`, so the labels are
     /// missing while `nrows` is not, and this panics instead of handing out an
     /// empty response slice. It does NOT catch the zero-row case: with
     /// `nrows == 0` both sides are `0` and the two fills are indistinguishable
     /// here, so an empty gather returns an empty view either way. That is the
     /// shape `crossfit` produces (it passes `val = &[]`), and it is harmless
-    /// because that path uses [`Self::fill_from`] anyway — but the assertion is
+    /// because that path uses [`Self::fill_from`] anyway -- but the assertion is
     /// not what makes it safe.
     fn as_matrix(&self) -> FoldView<'_> {
         let mat = self.features_as_matrix();
@@ -656,7 +656,7 @@ impl FoldModel for GbmFoldModel {
         Ok(Self { booster, ncols })
     }
 
-    /// Features only — see [`DataBuffer::fill_features_from`] for why the label
+    /// Features only -- see [`DataBuffer::fill_features_from`] for why the label
     /// channel is not touched on the scoring path.
     fn predict<D: FoldDataset>(&self, data: &D, rows: &[usize]) -> Result<Vec<f64>, ForustError> {
         let mut buffer = DataBuffer::default();
@@ -665,7 +665,7 @@ impl FoldModel for GbmFoldModel {
     }
 
     /// forust reports only the columns it actually split on. Every other lane
-    /// is `NAN` — "not reported" — rather than `0.0`, because this model has no
+    /// is `NAN` -- "not reported" -- rather than `0.0`, because this model has no
     /// gain measurement for a column it never used. See the
     /// [`FoldModel::importance`] contract.
     fn importance(&self) -> Vec<f32> {
@@ -757,8 +757,8 @@ pub struct FeatureStat {
 /// `feature_stats` is in the dataset's own column order
 /// ([`FoldDataset::column_names`], i.e. the matrix's column order), one entry per
 /// column. `feature_importance` is sorted by importance DESCENDING (top features
-/// first), and carries only the columns the model reported a finite value for —
-/// see [`FoldModel::importance`] — so it is generally shorter than
+/// first), and carries only the columns the model reported a finite value for --
+/// see [`FoldModel::importance`] -- so it is generally shorter than
 /// `feature_stats` and in a different order.
 ///
 /// Descending because the two TSV sidecars `timsseek_cli` writes
@@ -778,10 +778,10 @@ pub type RescoreFeatureStats = Vec<FoldStats>;
 ///
 /// Partition-agnostic on purpose: `fold_rows[f]` is simply "the rows summarized
 /// under fold `f`" and `models[f]` is "the model whose importance is reported
-/// there". The two rescoring partitions in this crate disagree on both — the
+/// there". The two rescoring partitions in this crate disagree on both -- the
 /// [`CrossValidatedScorer`] fits on fold `f` and scores the others, while
 /// `qvalues::crossfit_lda` fits on everything BUT fold `f` and scores only fold
-/// `f` — and both are leak-free. Keeping this function ignorant of which one it
+/// `f` -- and both are leak-free. Keeping this function ignorant of which one it
 /// is handed is what lets the sidecar have one implementation without the two
 /// partitions being forced to converge.
 ///
@@ -1168,7 +1168,7 @@ impl<T: FeatureLike + Sync, M: FoldModel> CrossValidatedScorer<T, M> {
 
     /// Compute per-fold feature means + per-fold model importance.
     ///
-    /// The stats for fold `f` summarize `fold_rows[f]` — for THIS partition,
+    /// The stats for fold `f` summarize `fold_rows[f]` -- for THIS partition,
     /// the rows fold `f`'s model was TRAINED on. Folds with no fitted model
     /// (shouldn't happen post-fit) produce empty maps. See
     /// [`fold_feature_stats`], which the LDA cross-fit shares with a different
@@ -1184,7 +1184,7 @@ impl<T: FeatureLike + Sync, M: FoldModel> CrossValidatedScorer<T, M> {
     /// Test-only, and it exists for one assertion. The hybrid rescorers feed
     /// this scorer a column that was cross-fit under a DIFFERENT train/score
     /// split (`qvalues::crossfit`), and the two splits are only leak-free
-    /// together if they agree on the fold ASSIGNMENT — a disagreement is
+    /// together if they agree on the fold ASSIGNMENT -- a disagreement is
     /// invisible to this scorer's own cross-validation and shows up solely as an
     /// optimistic FDR. Exposing the partition lets
     /// `qvalues::crossfit_holds_out_exactly_the_rows_the_gbm_scorer_trains_on`
@@ -1481,7 +1481,7 @@ mod test {
     /// every other model: an LDA's `|coef|` of exactly 0.0 is a measurement of a
     /// dead or constant column, and silently deleting those rows removes
     /// exactly what an operator reads the sidecar to find. Both halves are
-    /// asserted — dropping the NAN alone would also pass if 0.0 were dropped
+    /// asserted -- dropping the NAN alone would also pass if 0.0 were dropped
     /// too, so the surviving zero is the load-bearing assertion.
     #[test]
     fn importance_nan_is_unreported_but_zero_is_a_value() {
diff --git a/rust/timsseek/src/ml/lda.rs b/rust/timsseek/src/ml/lda.rs
index 9eeb400c..d1807923 100644
--- a/rust/timsseek/src/ml/lda.rs
+++ b/rust/timsseek/src/ml/lda.rs
@@ -6,7 +6,7 @@
 //!
 //! Features are z-standardized before the fit (Fisher LDA is scale-invariant,
 //! but the `lambda * I` term is not), and non-finite values are imputed to the
-//! column mean, i.e. 0 post-standardization — LDA cannot take missing natively.
+//! column mean, i.e. 0 post-standardization -- LDA cannot take missing natively.
 
 use crate::ml::cv::{
     FoldDataset,
@@ -19,8 +19,8 @@ use crate::utils::maybe_par::chunked_fold_reduce;
 /// rescue a rank-deficient one.
 pub(crate) const DEFAULT_SHRINKAGE: f64 = 1e-2;
 
-/// Row-chunk size for the parallel reductions. Fixed so chunk boundaries — and
-/// therefore the summation order of the partial accumulators — are identical
+/// Row-chunk size for the parallel reductions. Fixed so chunk boundaries -- and
+/// therefore the summation order of the partial accumulators -- are identical
 /// across runs, keeping the fit bitwise-deterministic despite parallelism.
 const CHUNK_ROWS: usize = 65_536;
 
@@ -44,7 +44,7 @@ impl LdaModel {
     ///
     /// `fit_matrix`, not `fit`: the [`FoldModel`] impl below also has a
     /// 5-argument `fit` on this same type, and the two were distinguishable only
-    /// by argument TYPES — `(&[f64], usize, usize, &[bool], f64)` against
+    /// by argument TYPES -- `(&[f64], usize, usize, &[bool], f64)` against
     /// `(&LdaConfig, &D, usize, &[usize], &[usize])`. Calling the wrong one is a
     /// type error rather than a silent bug, but a reader at a call site could not
     /// tell which was meant, and the arities matched only by coincidence (the
@@ -344,7 +344,7 @@ impl FoldModel for LdaModel {
             .collect())
     }
 
-    /// `|coef|` — the discriminant weights live in standardized space, so their
+    /// `|coef|` -- the discriminant weights live in standardized space, so their
     /// magnitudes are directly comparable across columns.
     ///
     /// NEVER `NAN`, i.e. never "unreported" under the
@@ -355,7 +355,7 @@ impl FoldModel for LdaModel {
     ///
     /// A column that is constant, or has no finite value at all, standardizes
     /// to all-zeros and therefore solves to exactly `0.0`. That zero is a
-    /// RESULT, not a gap, and it reaches the sidecar — "this feature is dead in
+    /// RESULT, not a gap, and it reaches the sidecar -- "this feature is dead in
     /// this fold" is one of the more useful things the sidecar can say.
     fn importance(&self) -> Vec<f32> {
         let out: Vec<f32> = self.coef.iter().map(|c| c.abs() as f32).collect();
diff --git a/rust/timsseek/src/ml/mlp.rs b/rust/timsseek/src/ml/mlp.rs
index 0d04581c..20a77067 100644
--- a/rust/timsseek/src/ml/mlp.rs
+++ b/rust/timsseek/src/ml/mlp.rs
@@ -7,7 +7,7 @@
 // one index walks several parallel arrays at once (`w`/`gw`, `mean`/`var`/
 // `inv_std`) and where the inner AXPY loops are shaped for vectorization.
 // Rewriting them as iterator zips needs 3- and 4-way nests and sinks the
-// codegen — the same tradeoff `ml/lda.rs` documents at its own hot loops.
+// codegen -- the same tradeoff `ml/lda.rs` documents at its own hot loops.
 #![allow(clippy::needless_range_loop)]
 
 use matrixmultiply::sgemm;
@@ -153,7 +153,7 @@ impl Tensor {
 // ---------------------------------------------------------------- layer trait
 
 /// `(param, grad, apply_weight_decay)`. Biases and norm parameters return
-/// `false` — decaying them toward zero fights what those layers are for.
+/// `false` -- decaying them toward zero fights what those layers are for.
 type ParamSlots<'a> = Vec<(&'a mut [f32], &'a mut [f32], bool)>;
 
 pub trait Layer: Send {
@@ -196,7 +196,7 @@ impl Linear {
     /// origin, and standardized inputs are centered on the origin, so at init
     /// the whole first layer hinges on the exact center of the data. A unit
     /// that lands with all its inputs on the negative side outputs zero, and
-    /// a dead ReLU has EXACTLY zero gradient — an absorbing state that no
+    /// a dead ReLU has EXACTLY zero gradient -- an absorbing state that no
     /// learning rate, epoch count, or minibatch noise recovers from. A random
     /// bias moves those boundaries away from the shared input origin.
     pub fn new(n_in: usize, n_out: usize, rng: &mut StdRng) -> Self {
@@ -315,7 +315,7 @@ pub const LEAKY_SLOPE: f32 = 0.01;
 /// a pure ReLU's zero region is an ABSORBING state: its gradient is exactly
 /// zero, so a unit that dies contributes nothing and receives nothing, forever.
 /// That is not a slow-learning problem that a smaller learning rate or more
-/// epochs or minibatch noise can fix — there is no gradient to be noisy about.
+/// epochs or minibatch noise can fix -- there is no gradient to be noisy about.
 pub struct Relu {
     dim: usize,
     slope: f32,
@@ -560,7 +560,7 @@ impl Mlp {
     /// regardless.
     ///
     /// The sink is the persistent [`Self::eval_sink`] rather than a local, so an
-    /// every-epoch early-stopping evaluation allocates nothing in steady state —
+    /// every-epoch early-stopping evaluation allocates nothing in steady state --
     /// the claim the module header makes. Reusing it cannot change the returned
     /// number: `loss_and_grad` reshapes the sink and writes every row of it
     /// before returning, and the loss it returns never reads the gradient.
@@ -734,7 +734,7 @@ impl Mlp {
     }
 
     /// `sum_o |W1[j, o]|` over the first weight-bearing layer, per input
-    /// column. The closest analogue to LDA's `|coef|` that a net admits —
+    /// column. The closest analogue to LDA's `|coef|` that a net admits --
     /// there is no gain equivalent.
     ///
     /// Indexed by TRANSFORMED input, so callers map back through
@@ -773,7 +773,7 @@ impl MlpBatch {
 /// Result of one streaming fit.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct TrainOutcome {
-    /// Mean training loss of the epoch whose weights the model now holds — the
+    /// Mean training loss of the epoch whose weights the model now holds -- the
     /// last epoch run, or the RESTORED epoch when early stopping rolled back.
     /// Reporting the last epoch's loss after a rollback would describe weights
     /// that were thrown away.
@@ -914,7 +914,7 @@ impl ColumnTransform {
         self.cols.len() + self.n_isna
     }
 
-    /// Lane indices dropped by the cull. Callers report these — a culled
+    /// Lane indices dropped by the cull. Callers report these -- a culled
     /// column's `0.0` importance is otherwise indistinguishable from an
     /// uninformative one's.
     pub fn culled(&self) -> &[usize] {
@@ -973,9 +973,9 @@ impl ColumnTransform {
     /// COMPANION belongs to, or `None` when `k` is a standardized feature (or
     /// past the end).
     ///
-    /// Companions have no lane of their own — they are appended after the
+    /// Companions have no lane of their own -- they are appended after the
     /// standardized block, in the lane order of the missable columns they
-    /// flag — so a caller that wants a lane-indexed vector has no way to place
+    /// flag -- so a caller that wants a lane-indexed vector has no way to place
     /// them without this. It is a lookup rather than a public field so the
     /// companion LAYOUT stays an internal detail of [`Self::apply`]; the two
     /// must agree, and this is the only other place that encodes the order.
diff --git a/rust/timsseek/src/ml/mlp_fold.rs b/rust/timsseek/src/ml/mlp_fold.rs
index 265579cf..8b59fea8 100644
--- a/rust/timsseek/src/ml/mlp_fold.rs
+++ b/rust/timsseek/src/ml/mlp_fold.rs
@@ -81,7 +81,7 @@ impl std::fmt::Display for MlpFoldError {
             } => write!(
                 f,
                 "fold {fold}: the train slice is EMPTY, so all {ncols} lane columns are \
-                 vacuously dead — this is a zero-row fold, not a dead feature set"
+                 vacuously dead -- this is a zero-row fold, not a dead feature set"
             ),
             MlpFoldError::NoUsableColumns {
                 fold,
@@ -95,7 +95,7 @@ impl std::fmt::Display for MlpFoldError {
             MlpFoldError::NonFiniteScore { row, n_bad, scored } => write!(
                 f,
                 "the net produced a NON-FINITE logit for {n_bad} of {scored} scored rows (first \
-                 at dataset row {row}) — the weights or an activation diverged during training"
+                 at dataset row {row}) -- the weights or an activation diverged during training"
             ),
         }
     }
@@ -130,7 +130,7 @@ pub struct MlpFoldModel {
 
 #[cfg(test)]
 impl MlpFoldModel {
-    /// The transform fitted at `fit` time — the one `predict` uses.
+    /// The transform fitted at `fit` time -- the one `predict` uses.
     pub(crate) fn transform(&self) -> &ColumnTransform {
         &self.transform
     }
@@ -166,8 +166,8 @@ impl MlpFoldModel {
 ///
 /// **`_isna` companions have no lane of their own**, so each one's value is summed
 /// into the column it flags. For either metric the resulting number answers one
-/// question — how much this column matters, through its value AND through its
-/// missingness — which is the only reading that makes the two comparable.
+/// question -- how much this column matters, through its value AND through its
+/// missingness -- which is the only reading that makes the two comparable.
 fn fold_inputs_to_lanes(transform: &ColumnTransform, raw: &[f32]) -> Vec<f32> {
     // Every transformed input is either a standardized column or a companion, so
     // with the right length the loop below places all of them; a short/long
@@ -201,7 +201,7 @@ fn fold_inputs_to_lanes(transform: &ColumnTransform, raw: &[f32]) -> Vec<f32> {
 }
 
 /// One row in every `INNER_VAL_STRIDE` of `train` is carved off as the inner
-/// validation slice — 20%.
+/// validation slice -- 20%.
 ///
 /// Why a STRIDE and not a tail cut or a random sample:
 ///
@@ -211,7 +211,7 @@ fn fold_inputs_to_lanes(transform: &ColumnTransform, raw: &[f32]) -> Vec<f32> {
 ///    construction. A random sample would have to be seeded from somewhere, and
 ///    every seed source available here is already spoken for.
 ///  * **Class-proportional under any row ORDER.** The rescore path shuffles
-///    before building the matrix, so a tail cut would usually be fine there —
+///    before building the matrix, so a tail cut would usually be fine there --
 ///    but `FoldModel::fit` is handed whatever slice the caller has, and the
 ///    obvious unshuffled layout is targets-then-decoys, where a tail cut is a
 ///    single-class validation set and the stopping decision becomes nonsense. A
@@ -224,7 +224,7 @@ const INNER_VAL_STRIDE: usize = 5;
 /// `160` is `MIN_INNER_VAL_ROWS * INNER_VAL_STRIDE`: the floor is really on the
 /// SIZE OF THE VALIDATION SET, 32 rows. A held-out loss averaged over fewer
 /// rows than that is dominated by which rows landed in it, and a patience rule
-/// reading it stops on sampling noise rather than on the overfitting turn —
+/// reading it stops on sampling noise rather than on the overfitting turn --
 /// worse than not stopping at all. The 20% also costs training rows, which a
 /// small fold cannot spare.
 ///
@@ -235,7 +235,7 @@ const MIN_TRAIN_ROWS_FOR_INNER_VAL: usize = MIN_INNER_VAL_ROWS * INNER_VAL_STRID
 
 /// The floor on the number of rows the stopping decision is averaged over.
 ///
-/// It applies to EITHER source of those rows — the inner carve (via
+/// It applies to EITHER source of those rows -- the inner carve (via
 /// [`MIN_TRAIN_ROWS_FOR_INNER_VAL`], which is this times the stride) and the
 /// outer `val` slice a caller passes (via [`usable_val`]). The argument above is
 /// about the SIZE of the held-out set and says nothing about where it came from:
@@ -246,7 +246,7 @@ const MIN_TRAIN_ROWS_FOR_INNER_VAL: usize = MIN_INNER_VAL_ROWS * INNER_VAL_STRID
 const MIN_INNER_VAL_ROWS: usize = 32;
 
 /// The outer `val` slice if it is big enough to make a stopping decision on,
-/// otherwise nothing — see [`MIN_INNER_VAL_ROWS`].
+/// otherwise nothing -- see [`MIN_INNER_VAL_ROWS`].
 ///
 /// Returning an empty slice rather than a flag so the rest of `fit` has ONE
 /// notion of "is there a held-out set": an under-floor slice is indistinguishable
@@ -358,14 +358,14 @@ impl FoldModel for MlpFoldModel {
 
     /// `val` is the EARLY-STOPPING SLICE, and it is used as one whenever
     /// [`MlpConfig::early_stopping_patience`] is set. It reaches
-    /// [`ColumnTransform::apply`] and [`Mlp::eval_loss`] and nothing else — not
-    /// the transform FIT, not the optimizer, not the RNG — so the only thing it
+    /// [`ColumnTransform::apply`] and [`Mlp::eval_loss`] and nothing else -- not
+    /// the transform FIT, not the optimizer, not the RNG -- so the only thing it
     /// can move is which epoch's weights are kept, which is what early stopping
     /// means.
     ///
     /// # The `val = &[]` callers
     /// A caller that has no fold to spare may pass an empty slice. Rather than
-    /// silently training the full budget there, an inner slice is carved out of `train` — see
+    /// silently training the full budget there, an inner slice is carved out of `train` -- see
     /// [`inner_val_split`] for the rule and [`MIN_TRAIN_ROWS_FOR_INNER_VAL`] for
     /// when it declines to. Those rows are excluded from the optimizer and used
     /// only for the stopping decision.
@@ -377,26 +377,26 @@ impl FoldModel for MlpFoldModel {
     ///
     /// **The [`ColumnTransform`] is still fitted over ALL of `train`,
     /// inner-validation rows included.** Deliberate, and the choice worth
-    /// stating: those rows are train-fold rows — the outer partition does not
+    /// stating: those rows are train-fold rows -- the outer partition does not
     /// hold them out from this model, this function does, for a decision that
-    /// never leaves it — so including them breaks no leak property. What it buys
+    /// never leaves it -- so including them breaks no leak property. What it buys
     /// is that the cull set, the standardization moments and the imputation
     /// means do not move when the patience knob does: a config knob that changed
     /// WHICH LANE COLUMNS ARE ALIVE would change the importance sidecar and the
     /// [`MlpFoldError::NoUsableColumns`] failure mode along with it. The cost is
     /// that the inner-validation loss is very slightly optimistic, through
     /// label-free per-column moments that 80% of the same rows already
-    /// determine — second-order next to the epoch it is being used to choose.
+    /// determine -- second-order next to the epoch it is being used to choose.
     ///
     /// `fold` is NOT ignored: it is the only thing that distinguishes one
     /// fold's initialization from another's, via
     /// [`MlpConfig::rng_for_fold`]. Passing the same `fold` for every fold
-    /// would give every fold the same weight init and the same shuffle order —
+    /// would give every fold the same weight init and the same shuffle order --
     /// still leak-free, but the folds would be correlated in a way nothing
     /// downstream would notice.
     ///
-    /// Everything fitted here — the cull set, the standardization moments, the
-    /// imputation means, the weights — comes from `train` and only `train`.
+    /// Everything fitted here -- the cull set, the standardization moments, the
+    /// imputation means, the weights -- comes from `train` and only `train`.
     fn fit_with_progress<D: FoldDataset>(
         cfg: &MlpConfig,
         data: &D,
@@ -434,7 +434,7 @@ impl FoldModel for MlpFoldModel {
         }
 
         // Where the stopping decision gets measured. A big enough outer `val`
-        // slice is preferred whenever there is one — it costs no training rows —
+        // slice is preferred whenever there is one -- it costs no training rows --
         // and the inner carve is the fallback for the callers that pass `&[]`
         // (and for an outer slice under [`MIN_INNER_VAL_ROWS`], which is not a
         // set worth stopping on; see [`usable_val`]). With early stopping off
@@ -444,7 +444,7 @@ impl FoldModel for MlpFoldModel {
         if !val.is_empty() && val_rows.is_empty() {
             tracing::debug!(
                 "MLP fold {}: the outer validation slice has {} rows, under the {} a held-out \
-                 measurement needs — ignoring it, so this fit is exactly the `val = &[]` fit. \
+                 measurement needs -- ignoring it, so this fit is exactly the `val = &[]` fit. \
                  That falls back to the inner carve ONLY with early stopping on and enough \
                  train rows to carve from (too few rows logs just below); with early stopping \
                  off there is no carve and no stopping decision to make",
@@ -461,7 +461,7 @@ impl FoldModel for MlpFoldModel {
         if early_stopping && val_rows.is_empty() && inner_pos.is_empty() {
             tracing::debug!(
                 "MLP fold {}: {} train rows is under the {} needed to carve an inner \
-                 validation slice — training the full {} epoch budget with no early stopping",
+                 validation slice -- training the full {} epoch budget with no early stopping",
                 fold,
                 train.len(),
                 MIN_TRAIN_ROWS_FOR_INNER_VAL,
@@ -475,7 +475,7 @@ impl FoldModel for MlpFoldModel {
         let fit_rows: Vec<usize> = fit_pos.iter().map(|&p| train[p]).collect();
 
         // The held-out set, transformed through the TRAIN-fitted transform. It
-        // reaches `Mlp::eval_loss` and nothing else — no optimizer step, no
+        // reaches `Mlp::eval_loss` and nothing else -- no optimizer step, no
         // transform fit, no RNG draw.
         //
         // Streamed whenever early stopping is on: it is the stopping decision,
@@ -493,7 +493,7 @@ impl FoldModel for MlpFoldModel {
             None
         };
 
-        // Seeded from (config seed, fold index) alone — see the module docs.
+        // Seeded from (config seed, fold index) alone -- see the module docs.
         let mut rng = cfg.rng_for_fold(fold);
         let mut net = Mlp::feedforward(width, &cfg.hidden, &mut rng);
         let mut opt = Adam::new(cfg.lr).with_weight_decay(cfg.weight_decay);
@@ -573,7 +573,7 @@ impl FoldModel for MlpFoldModel {
 
     /// Score `rows` through the SAME transform that was fitted at `fit` time.
     ///
-    /// Nothing is refitted here — not the cull set, not the moments, not the
+    /// Nothing is refitted here -- not the cull set, not the moments, not the
     /// imputation means. A refit would make a row's score depend on the other
     /// rows it happened to be batched with, which is both a leak (the batch may
     /// contain rows the caller is holding out) and non-reproducible.
@@ -582,7 +582,7 @@ impl FoldModel for MlpFoldModel {
     /// needs a monotone ranking and the sigmoid is a monotone no-op on it.
     ///
     /// Every returned value is FINITE, or this is an
-    /// [`MlpFoldError::NonFiniteScore`] — see that variant for why the check lives
+    /// [`MlpFoldError::NonFiniteScore`] -- see that variant for why the check lives
     /// here and not downstream.
     fn predict<D: FoldDataset>(&self, data: &D, rows: &[usize]) -> Result<Vec<f64>, MlpFoldError> {
         let names = data.column_names();
@@ -808,7 +808,7 @@ mod test {
             assert!(
                 auc > best_raw + 0.05,
                 "seed {seed}: held-out AUC {auc} barely beats the best raw column \
-                 ({best_raw}) — the fit added nothing"
+                 ({best_raw}) -- the fit added nothing"
             );
         }
     }
@@ -1202,7 +1202,7 @@ mod test {
             assert_eq!(
                 model.transform().width(),
                 3,
-                "seed {seed}: three survivors and NO companion — a companion would mean the \
+                "seed {seed}: three survivors and NO companion -- a companion would mean the \
                  fit saw the column as missable, outside the clean-column diagnostic path"
             );
 
diff --git a/rust/timsseek/src/ml/qvalues.rs b/rust/timsseek/src/ml/qvalues.rs
index cb0f872c..0fefd4a9 100644
--- a/rust/timsseek/src/ml/qvalues.rs
+++ b/rust/timsseek/src/ml/qvalues.rs
@@ -170,8 +170,8 @@ const RESCORE_SHUFFLE_SEED: u64 = 42;
 
 /// Canonicalize candidate order, then apply the fixed seeded shuffle.
 ///
-/// Shared by all four rescorers so the row order — and therefore the positional
-/// fold partition `fold(i) = i % N_RESCORE_FOLDS` derived from it — has exactly
+/// Shared by all four rescorers so the row order -- and therefore the positional
+/// fold partition `fold(i) = i % N_RESCORE_FOLDS` derived from it -- has exactly
 /// one definition.
 ///
 /// Canonicalizing first matters because upstream stages can emit candidates in
@@ -190,7 +190,7 @@ const RESCORE_SHUFFLE_SEED: u64 = 42;
 ///
 /// The shuffle is NOT cosmetic: every fold partition below is positional, so an
 /// unshuffled (library-ordered) input would make folds correlate with library
-/// layout — e.g. protein-grouped or target/decoy-blocked speclibs would give
+/// layout -- e.g. protein-grouped or target/decoy-blocked speclibs would give
 /// systematically unbalanced folds.
 ///
 /// Feature rows must be projected after this call because fold assignment and
@@ -214,7 +214,7 @@ fn canonicalize_and_shuffle(data: &mut [CompetedCandidate]) {
 ///
 /// Tied scores change the q-values they produce, so the sort is stable: ties
 /// keep the seeded-shuffle input order and the result is reproducible on any
-/// thread count. Reproducible, not correct — breaking ties on a real key is a
+/// thread count. Reproducible, not correct -- breaking ties on a real key is a
 /// separate decision, not made here.
 fn finalize(
     mut scored: Vec<CompetedCandidate>,
@@ -235,7 +235,7 @@ struct CrossFit<M: FoldModel> {
     /// Held-out score per row, row-aligned with the input matrix.
     scores: Vec<f64>,
     /// The per-fold fitted models, indexed by fold. Always
-    /// `N_RESCORE_FOLDS` long — a `CrossFit` only exists if every fold fit.
+    /// `N_RESCORE_FOLDS` long -- a `CrossFit` only exists if every fold fit.
     models: Vec<M>,
     /// `fold_rows[f]` = the rows `models[f]` SCORED (ascending), i.e. exactly
     /// fold `f`. Kept so the sidecar stats summarize exactly those rows without
@@ -276,12 +276,12 @@ impl<M: FoldModel> CrossFit<M> {
 /// The hybrid needs this even more sharply: there the held-out score is not the
 /// final score but one `lda_score` column fed to a
 /// cross-validated GBM. An in-sample column would smuggle a row's own label
-/// into a feature the GBM reads while that row is held out of its GBM fold — so
+/// into a feature the GBM reads while that row is held out of its GBM fold -- so
 /// the GBM's own CV cannot notice, and the leak surfaces only as an optimistic
 /// FDR.
 ///
 /// # Partition
-/// Fold membership comes from [`FoldDataset::get_fold`] — for the
+/// Fold membership comes from [`FoldDataset::get_fold`] -- for the
 /// production datasets, that is `i % N_RESCORE_FOLDS`. For
 /// fold `f` the model is fitted on every row with `get_fold(i) != f` and then
 /// scores only the rows with `get_fold(i) == f`, so no row contributes to the
@@ -297,7 +297,7 @@ impl<M: FoldModel> CrossFit<M> {
 ///
 /// What the two DO have to agree on is the fold ASSIGNMENT `get_fold`, or a
 /// hybrid row's cross-fit column can come from a model trained on rows the GBM
-/// is holding out — leak restored, silently. Both sides read that assignment
+/// is holding out -- leak restored, silently. Both sides read that assignment
 /// from [`FoldDataset::get_fold`], so it has one definition; the
 /// `crossfit_holds_out_exactly_the_rows_the_gbm_scorer_trains_on` test pins the
 /// two partitions against each other rather than against a re-typed modulo.
@@ -335,7 +335,7 @@ where
         // for and there is no third slice to hand over. The LDA is closed-form
         // and ignores it. `MlpFoldModel` DOES early-stop, and handles the empty
         // slice by carving a deterministic inner validation set out of `train`
-        // — see its `fit` for the rule; nothing about it reaches fold `f`.
+        // -- see its `fit` for the rule; nothing about it reaches fold `f`.
         let model = M::fit(cfg, data, f, &train, &[]).map_err(|e| RescoreError::CrossFit {
             model: what,
             fold: f,
@@ -380,7 +380,7 @@ where
     })
 }
 
-/// Cross-fit an [`LdaModel`] on [`LdaConfig::default`] — see [`crossfit`] for
+/// Cross-fit an [`LdaModel`] on [`LdaConfig::default`] -- see [`crossfit`] for
 /// the partition and the failure policy.
 ///
 /// `N_RESCORE_FOLDS` fits instead of 1 is affordable precisely because the LDA
@@ -416,7 +416,7 @@ pub fn rescore(mut data: Vec<CompetedCandidate>) -> RescoreResult {
     canonicalize_and_shuffle(&mut data);
 
     // The ALL-lane matrix (linear ++ nonlinear), built over `data` in its
-    // post-shuffle order — see `canonicalize_and_shuffle` for why that order is
+    // post-shuffle order -- see `canonicalize_and_shuffle` for why that order is
     // load-bearing.
     let names = all_feature_name_set();
     debug_assert_eq!(names.len(), ALL_NCOLS);
@@ -447,11 +447,11 @@ pub fn rescore(mut data: Vec<CompetedCandidate>) -> RescoreResult {
 /// is generally much cheaper and less sensitive than GBM, with neither gap
 /// constant across candidate counts.
 ///
-/// The FDR machinery (`assign_qval`, target-decoy competition) is untouched —
+/// The FDR machinery (`assign_qval`, target-decoy competition) is untouched --
 /// only the discriminant score source changes.
 ///
 /// CROSS-FIT, not a single in-sample fit: every row's score comes from an LDA
-/// fitted without that row, via [`crossfit_lda`] — see [`crossfit`] for the
+/// fitted without that row, via [`crossfit_lda`] -- see [`crossfit`] for the
 /// partition and why it is mandatory.
 ///
 /// Returns PER-FOLD [`FoldStats`] (one per fold, like the GBM path): feature
@@ -462,14 +462,14 @@ pub fn rescore(mut data: Vec<CompetedCandidate>) -> RescoreResult {
 /// ([`crate::ml::RescoreModel::Lda`]).
 /// See `ml::lda` for the fit details.
 pub fn rescore_lda(mut data: Vec<CompetedCandidate>) -> RescoreResult {
-    // Canonical sort + seeded shuffle — the same helper, key and seed as every
+    // Canonical sort + seeded shuffle -- the same helper, key and seed as every
     // other rescorer.
     canonicalize_and_shuffle(&mut data);
 
     // LDA trains on the LINEAR lane only: fields that are approx-Gaussian after
     // their declared per-row transform (raw/log2/ln1p). Skew-taming is done at
     // emit time by the grammar, so there is no data-dependent normalization step
-    // here — the only remaining data-dependent op is LDA's own standardization.
+    // here -- the only remaining data-dependent op is LDA's own standardization.
     // Built after the shuffle, per `canonicalize_and_shuffle`.
     let names: Vec<Arc<str>> = linear_feature_name_set();
     let nrows = data.len();
@@ -559,7 +559,7 @@ fn hybrid_frame(
 /// `lda_score` as one extra column into the NONLINEAR lane, then train the GBM
 /// CV on `nonlinear + lda_score` instead of the full feature frame.
 ///
-/// LEAK-FREEDOM: `lda_score` is cross-fit via [`crossfit`] — see there for the
+/// LEAK-FREEDOM: `lda_score` is cross-fit via [`crossfit`] -- see there for the
 /// partition, why a label-aware feature fed to a CV'd GBM in particular must be
 /// leak-free, and why the fold ASSIGNMENT has to match the one
 /// `CrossValidatedScorer` derives its own partition from. ASSIGNMENT, not
@@ -575,7 +575,7 @@ fn hybrid_frame(
 pub fn rescore_hybrid(mut data: Vec<CompetedCandidate>) -> RescoreResult {
     let config = GBMConfig::default();
 
-    // Canonical sort + seeded shuffle — IDENTICAL to `rescore` (same helper,
+    // Canonical sort + seeded shuffle -- IDENTICAL to `rescore` (same helper,
     // same key, same seed) so fold assignment and downstream q-values are
     // reproducible.
     canonicalize_and_shuffle(&mut data);
@@ -641,7 +641,7 @@ fn rescore_mlp_with(mut data: Vec<CompetedCandidate>, config: MlpConfig) -> Resc
     Ok(finalize(scorer.score(), stats))
 }
 
-/// MLP rescorer over the ALL lane (linear ++ nonlinear) — the same feature set
+/// MLP rescorer over the ALL lane (linear ++ nonlinear) -- the same feature set
 /// [`rescore`] gives the GBM, so the two are directly comparable. The one
 /// [`crate::ml::RescoreModel::Mlp`] selects.
 ///
@@ -653,15 +653,15 @@ pub fn rescore_mlp(data: Vec<CompetedCandidate>) -> RescoreResult {
 }
 
 // ---------------------------------------------------------------------------
-// Lane feature projections — shared ordering for streaming and matrix consumers
+// Lane feature projections -- shared ordering for streaming and matrix consumers
 // ---------------------------------------------------------------------------
 //
 // GBM consumers retain a flat row-major `Vec<f64>`; LDA and MLP project the same
 // rows into one-row scratch and retain no raw frame. Every contributing block's
 // width is an inherent const, so the lane widths below are compile-time constants.
 //
-// The per-row walk order is fixed — scoring blocks (composition order) ->
-// `ResultMeta` -> `Derived` -> (nonlinear only) `sequence_counts` — and the
+// The per-row walk order is fixed -- scoring blocks (composition order) ->
+// `ResultMeta` -> `Derived` -> (nonlinear only) `sequence_counts` -- and the
 // name-set walks further down repeat it exactly, which is what keeps column
 // `j` and name `j` the same feature.
 
@@ -680,7 +680,7 @@ const NONLINEAR_NCOLS: usize = ScoringFields::NONLINEAR_LEN
 const ALL_NCOLS: usize = LINEAR_NCOLS + NONLINEAR_NCOLS;
 
 // Neither lane may collapse to nothing. Now that the widths are consts this is
-// a build failure rather than a test failure — a lane that lost every feature
+// a build failure rather than a test failure -- a lane that lost every feature
 // would otherwise train a model on a zero-column matrix.
 const _: () = assert!(LINEAR_NCOLS > 0, "linear lane collapsed");
 const _: () = assert!(NONLINEAR_NCOLS > 0, "nonlinear lane collapsed");
@@ -796,7 +796,7 @@ fn build_nonlinear_matrix(data: &[CompetedCandidate]) -> Vec<f64> {
     out
 }
 
-/// The ALL-lane matrix (linear then nonlinear, per row) — the GBM feature set,
+/// The ALL-lane matrix (linear then nonlinear, per row) -- the GBM feature set,
 /// `ALL_NCOLS` wide, matching [`all_feature_name_set`]'s order.
 ///
 /// ONE pass over `rows` with ONE `Derived::compute` per row: the two lanes are
@@ -843,7 +843,7 @@ pub fn linear_feature_name_set() -> Vec<Arc<str>> {
 }
 
 /// NONLINEAR-lane feature names, in [`project_nonlinear_row`]'s order. The
-/// `sequence_counts` names are unconditional — a peptide with no parsed
+/// `sequence_counts` names are unconditional -- a peptide with no parsed
 /// sequence contributes NaN values under them, not a shorter row.
 pub fn nonlinear_feature_name_set() -> Vec<Arc<str>> {
     let mut n = NameSink::new();
@@ -863,7 +863,7 @@ pub fn all_feature_name_set() -> Vec<Arc<str>> {
 }
 
 // ---------------------------------------------------------------------------
-// Label / score plumbing. `FeatureLike` is the label+score half only — the
+// Label / score plumbing. `FeatureLike` is the label+score half only -- the
 // GBM/LDA feature values reach the scorer as a prebuilt lane frame
 // (`PrecomputedFeatures::from_row_major`); the MLP supplies the same projection
 // through `write_competed_all_row` one row at a time. Neither route needs
@@ -1037,7 +1037,7 @@ mod feature_tests {
         v
     }
 
-    /// A target candidate over `PEPTIDEK` — 8 residues, no mods. With
+    /// A target candidate over `PEPTIDEK` -- 8 residues, no mods. With
     /// `sequence_features` set the sequence lanes carry those counts; without it
     /// they stay NaN, which is the only difference between the two cases.
     fn sample_competed_candidate(sequence_features: bool) -> CompetedCandidate {
@@ -1065,7 +1065,7 @@ mod feature_tests {
     ///
     /// Checked with an UNPARSED peptide as well as a parsed one: the sequence
     /// block is unconditional now, so a row must be exactly as wide either way
-    /// — the width being a compile-time const is what makes that structural.
+    /// -- the width being a compile-time const is what makes that structural.
     #[test]
     fn lane_matrix_widths_match_name_sets() {
         for data in [
@@ -1083,7 +1083,7 @@ mod feature_tests {
     }
 
     /// The all-lane matrix is exactly the linear row followed by the nonlinear
-    /// row, per row — the one-pass build must not reorder or drop anything
+    /// row, per row -- the one-pass build must not reorder or drop anything
     /// relative to the two single-lane builds.
     #[test]
     fn all_matrix_is_linear_then_nonlinear_per_row() {
@@ -1426,7 +1426,7 @@ mod feature_tests {
             let held_auc = pair_auc(&held, &fold0_is_target);
             assert!(
                 (held_auc - 0.5).abs() < 1e-12,
-                "seed {seed}: held-out fold-0 rows must not separate — the only \
+                "seed {seed}: held-out fold-0 rows must not separate -- the only \
                  column that could separate them was culled from the model that \
                  scores them. AUC={held_auc} scores={held:?}"
             );
@@ -1498,7 +1498,7 @@ mod feature_tests {
                 assert_eq!(
                     fs.feature_importance.len(),
                     ALL_NCOLS,
-                    "seed {seed}: fold {f} — the MLP measures every lane \
+                    "seed {seed}: fold {f} -- the MLP measures every lane \
                          column (0.0 for culled ones), so none may be dropped"
                 );
                 assert!(
@@ -1539,7 +1539,7 @@ mod feature_tests {
             assert!(
                 !fs.feature_importance.is_empty(),
                 "fold {}: the GBM reported no importance at all, so it built no trees and \
-                 the score is a per-fold constant — every other assertion in this test \
+                 the score is a per-fold constant -- every other assertion in this test \
                  then passes without measuring anything (this is what n = 90 did)",
                 fs.fold
             );
@@ -1786,7 +1786,7 @@ mod feature_tests {
         let auc = pair_auc(&scores, &is_target);
         assert!(
             auc > 0.8,
-            "AUC {auc} — the GBM sees a constant nonlinear lane here, so anything above \
+            "AUC {auc} -- the GBM sees a constant nonlinear lane here, so anything above \
              chance has to come through lda_score, and it did not"
         );
     }
@@ -1802,7 +1802,7 @@ mod feature_tests {
         //
         // Two things are pinned, and both matter:
         //   (a) every mobility feature is NaN (or, for the `_isna` companions,
-        //       flipped to 1.0 == "missing" — an isna column is BY CONSTRUCTION
+        //       flipped to 1.0 == "missing" -- an isna column is BY CONSTRUCTION
         //       never NaN, so demanding NaN there would be wrong);
         //   (b) every non-mobility feature is bit-for-bit unchanged. Without (b)
         //       an impl that NaN'd the whole record would pass (a).
@@ -1844,7 +1844,7 @@ mod feature_tests {
         // No exact counts: adding a mobility-derived feature must not break
         // this test, since the assertions above are already per-feature. The
         // only thing worth pinning is that the `mob` name filter still matches
-        // something — otherwise the loop above would pass vacuously.
+        // something -- otherwise the loop above would pass vacuously.
         assert!(
             !nan_mob.is_empty(),
             "no mobility features matched the name filter"
@@ -1861,7 +1861,7 @@ mod feature_tests {
 
     /// Row-major layout: value `j` of row `i` lives at `matrix[i * nf + j]`.
     ///
-    /// Every consumer indexes on that contract — `rescore_dash` sweeps the
+    /// Every consumer indexes on that contract -- `rescore_dash` sweeps the
     /// matrix a row at a time with every column's accumulator live, so an
     /// interleaved or transposed write would silently mix features together
     /// rather than fail. Rows carry distinct `delta_group_ln1p_diff` values so the
diff --git a/rust/timsseek/src/models/decoy_policy.rs b/rust/timsseek/src/models/decoy_policy.rs
index 5feb47c0..e70df572 100644
--- a/rust/timsseek/src/models/decoy_policy.rs
+++ b/rust/timsseek/src/models/decoy_policy.rs
@@ -62,7 +62,7 @@ impl std::str::FromStr for DecoyPolicy {
 /// - `Force`: always (re)generate lazy mass-shift decoys, ignoring any
 ///   decoys the file already carries.
 /// - `IfMissing` + no file decoys: generate lazy mass-shift decoys.
-/// - `IfMissing` + file already has decoys: `Passthrough` — use the file's
+/// - `IfMissing` + file already has decoys: `Passthrough` -- use the file's
 ///   own decoy rows as-is (no arena-side generation).
 /// - `Never`: no decoy generation; library rows are used as-is.
 pub fn map_decoy_strategy(policy: DecoyPolicy, has_file_decoys: bool) -> DecoyStrategy {
diff --git a/rust/timsseek/src/models/query_item.rs b/rust/timsseek/src/models/query_item.rs
index 47002278..a02d8767 100644
--- a/rust/timsseek/src/models/query_item.rs
+++ b/rust/timsseek/src/models/query_item.rs
@@ -25,7 +25,7 @@ pub fn linear_get<K: PartialEq, V: Copy>(entries: &[(K, V)], key: &K) -> Option<
 
 /// Rejection returned by [`ExpectedIntensities::try_from_pairs`] when the
 /// input contains a repeated fragment or precursor key. Keys are expected
-/// to be unique — `linear_get`/`remove_*` return only the first match and
+/// to be unique -- `linear_get`/`remove_*` return only the first match and
 /// silently masking a duplicate corrupts downstream scoring.
 #[derive(Debug, Clone)]
 pub struct DuplicateKeyError {
@@ -47,7 +47,7 @@ impl std::error::Error for DuplicateKeyError {}
 /// Stored as `TinyVec<[(K, f32); 13]>` per field: each entry keeps its key
 /// alongside the intensity for diagnostics and by-key lookup. For typical
 /// peptides (<=13 fragments / <=13 precursors) the backing storage is inline,
-/// so `clone()` is a stack memcpy and mutation is in-place swap-remove —
+/// so `clone()` is a stack memcpy and mutation is in-place swap-remove --
 /// zero heap allocations on the hot path.
 ///
 /// # Invariants
@@ -56,7 +56,7 @@ impl std::error::Error for DuplicateKeyError {}
 /// [`ExpectedIntensities::remove_fragment`]/`remove_precursor` return only
 /// the first match; a duplicate silently hides data. All construction paths
 /// go through [`ExpectedIntensities::try_from_pairs`] which enforces this.
-/// Direct struct-literal construction bypasses the check — avoid it outside
+/// Direct struct-literal construction bypasses the check -- avoid it outside
 /// tests where uniqueness is obvious.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ExpectedIntensities<T: KeyLike + Default> {
@@ -155,7 +155,7 @@ impl<T: KeyLike + Default> ExpectedIntensities<T> {
     /// In-place copy from `other` reusing each TinyVec's current backing.
     /// For ≤13 entries this stays fully inline. For spilled buffers the
     /// heap allocation is reused when `other.len() <= self.capacity()`.
-    /// Prefer this over `*self = other.clone()` on the scoring hot path —
+    /// Prefer this over `*self = other.clone()` on the scoring hot path --
     /// the default `Clone::clone_from` drops the destination buffer
     /// before reallocating.
     pub fn clone_from_ref(&mut self, other: &Self)
diff --git a/rust/timsseek/src/models/sequence.rs b/rust/timsseek/src/models/sequence.rs
index 2ac4bb0f..e8f74aac 100644
--- a/rust/timsseek/src/models/sequence.rs
+++ b/rust/timsseek/src/models/sequence.rs
@@ -20,7 +20,7 @@ pub const UNKNOWN_AA: AminoAcid = AminoAcid(u8::MAX);
 
 /// Canonical output order for the 20-dim count vector:
 /// A C D E F G H I K L M N P Q R S T V W Y.
-/// Do not reorder — `FEATURE_NAMES` follows this.
+/// Do not reorder -- `FEATURE_NAMES` follows this.
 pub const CANONICAL_AA_INDICES: [usize; 20] = [
     0, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 17, 18, 19, 21, 22, 24,
 ];
@@ -70,7 +70,7 @@ pub enum Mod {
 pub struct ModEntry {
     /// Residue position. Sentinel values: `POS_N_TERM` (0xFF) / `POS_C_TERM` (0xFE).
     /// Otherwise a 0-based residue index, valid range `0..=253`. Sequences
-    /// longer than 254 residues cannot be represented — the parser rejects them
+    /// longer than 254 residues cannot be represented -- the parser rejects them
     /// in `parse_sequence` rather than truncating here.
     pub pos: u8,
     pub kind: Mod,
@@ -156,8 +156,8 @@ impl Serialize for Peptide {
 ///
 /// A hand-rolled byte walk handles the grammar `normalize_to_proforma` actually
 /// emits (bare residues, `[UNIMOD:n]`, `[+/-mass]`, N-/C-terminal forms). It
-/// returns `Some` ONLY for inputs it fully recognizes; anything else — named
-/// mods, cross-links, unexpected bytes — yields `None` and defers to the rustyms
+/// returns `Some` ONLY for inputs it fully recognizes; anything else -- named
+/// mods, cross-links, unexpected bytes -- yields `None` and defers to the rustyms
 /// parser, which stays the authority for what is valid. So the fast path can
 /// never accept something rustyms would reject, with one deliberate exception:
 /// it does not check that a `UNIMOD:n` id exists in the ontology (a
@@ -171,7 +171,7 @@ pub fn parse_sequence(normalized: &str) -> Option<ParsedSequence> {
 }
 
 /// Classify one bracket body (`UNIMOD:n` or a signed mass like `+15.995`) into a
-/// [`Mod`]. `None` for anything else — a named mod, an unsigned number, empty —
+/// [`Mod`]. `None` for anything else -- a named mod, an unsigned number, empty --
 /// which forces the rustyms fallback in [`parse_sequence`].
 fn classify_mod(body: &str) -> Option<Mod> {
     let body = body.trim();
@@ -185,7 +185,7 @@ fn classify_mod(body: &str) -> Option<Mod> {
 }
 
 /// Byte-walk parser for the `normalize_to_proforma` output grammar. `None` means
-/// "not recognized — defer to rustyms", never "definitively invalid" (that
+/// "not recognized -- defer to rustyms", never "definitively invalid" (that
 /// verdict is the fallback's). See [`parse_sequence`] for the contract.
 fn parse_sequence_fast(s: &str) -> Option<ParsedSequence> {
     let b = s.as_bytes();
@@ -301,7 +301,7 @@ fn modification_to_mod(m: &rustyms::sequence::Modification) -> Option<Mod> {
     };
     let simple = match m {
         Modification::Simple(s) => s,
-        _ => return None, // Cross-link / ambiguous — out of v1 scope
+        _ => return None, // Cross-link / ambiguous -- out of v1 scope
     };
     match simple.as_ref() {
         SimpleModificationInner::Mass(mass) => Some(Mod::Mass(mass.value as f32)),
@@ -341,8 +341,8 @@ fn replace_ascii_ci(haystack: &str, needle: &str, replacement: &str) -> String {
 
 /// Convert DIA-NN parenthesised UNIMOD mods to ProForma brackets: each
 /// case-insensitive `(unimod:` / `(u:` opener becomes `[UNIMOD:` and the single
-/// `)` that closes it becomes `]`. Any other paren — notably `)` inside a bracket
-/// mod name like `[Carbamidomethyl (C)]` — is left untouched.
+/// `)` that closes it becomes `]`. Any other paren -- notably `)` inside a bracket
+/// mod name like `[Carbamidomethyl (C)]` -- is left untouched.
 fn convert_paren_unimod(s: &str) -> String {
     let lower = s.to_ascii_lowercase();
     let mut out = String::with_capacity(s.len());
@@ -367,7 +367,7 @@ fn convert_paren_unimod(s: &str) -> String {
                         out.push(']');
                         i += rel + 1; // consume ')'
                     }
-                    // Malformed (no closer) — copy the remainder verbatim.
+                    // Malformed (no closer) -- copy the remainder verbatim.
                     None => {
                         out.push_str(rest);
                         i = s.len();
@@ -391,7 +391,7 @@ fn convert_paren_unimod(s: &str) -> String {
 /// A leading (N-terminal) mod is rewritten to `[UNIMOD:n]-SEQ` as ProForma
 /// requires. Pass-through for plain sequences.
 ///
-/// Off the hot path — allocates on every replacement, which is fine at load.
+/// Off the hot path -- allocates on every replacement, which is fine at load.
 pub fn normalize_to_proforma(raw: &str) -> String {
     let trimmed = raw.trim_matches('_');
     // Fast path: plain-AA sequences (no mod tags) skip the rewrite chain.
@@ -401,7 +401,7 @@ pub fn normalize_to_proforma(raw: &str) -> String {
 
     // DIA-NN writes mods in parentheses, e.g. `C(UniMod:4)`; ProForma needs
     // brackets, e.g. `C[UNIMOD:4]`. Convert each opener and ONLY its matching
-    // `)` (see `convert_paren_unimod`) — never a blanket `)` replace, which would
+    // `)` (see `convert_paren_unimod`) -- never a blanket `)` replace, which would
     // corrupt parens inside a bracket mod name, e.g. `C[Carbamidomethyl (C)]`.
     let s = convert_paren_unimod(trimmed);
 
diff --git a/rust/timsseek/src/rt_calibration.rs b/rust/timsseek/src/rt_calibration.rs
index 2fac2b1a..1726d6c3 100644
--- a/rust/timsseek/src/rt_calibration.rs
+++ b/rust/timsseek/src/rt_calibration.rs
@@ -30,7 +30,7 @@ use timsquery::models::tolerance::{
 const DEFAULT_RT_FLOOR_MINUTES: f32 = 0.5;
 
 /// The RT tolerance a ridge half-width implies, in minutes, floored at
-/// `floor_minutes` — the same [`FloorsTriplet::rt_minutes`] that
+/// `floor_minutes` -- the same [`FloorsTriplet::rt_minutes`] that
 /// [`DimensionErrors::derive_windows`] applies to the uniform fallback. The
 /// per-query search path and a single-number UI must both come through here, or
 /// the window a user is shown is not the window the search would open.
@@ -116,7 +116,7 @@ pub struct DerivedWindows {
     pub mobility_pct: (f32, f32),
 }
 
-/// `median ± n_sigma * 1.4826 * MAD`, floored — the `"mad_symmetric"` method
+/// `median ± n_sigma * 1.4826 * MAD`, floored -- the `"mad_symmetric"` method
 /// [`DerivationParams`] names. Robust to tails: equal to `mean ± n_sigma * stdev`
 /// for a Gaussian population, and it resists the outlier inflation that would
 /// widen a window around a handful of bad matches.
@@ -216,7 +216,7 @@ impl CalibrationResult {
         self.fallback
     }
 
-    /// The grid this was fit on — the source for the curve, the ridge widths and
+    /// The grid this was fit on -- the source for the curve, the ridge widths and
     /// the calibrant points.
     pub fn state(&self) -> &CalibratedGrid {
         &self.state
@@ -242,7 +242,7 @@ impl CalibrationResult {
         ridge_half_width_interp(self.state.ridge_widths(), library_rt.0)
     }
 
-    /// The fitted curve. Present for the lifetime of `self` — [`Self::new`]
+    /// The fitted curve. Present for the lifetime of `self` -- [`Self::new`]
     /// rejects a grid without one.
     fn curve(&self) -> &RTCalibration {
         self.state
@@ -321,7 +321,7 @@ impl CalibrationResult {
 
     /// Write the calibration where a viewer or the dashboard can read it.
     ///
-    /// The grid's snapshot is the record of the fit — a reader refits it to get
+    /// The grid's snapshot is the record of the fit -- a reader refits it to get
     /// the curve and the ridge widths back. Everything a search measured that the
     /// grid does not know goes in [`ResidualBlock`].
     pub fn save_json(
@@ -547,7 +547,7 @@ mod tests {
         assert_eq!((symmetric.median, symmetric.mad), (0.0, 1.0));
 
         // Offset by 10: the median rides along, so the window is not centred on
-        // zero — that offset is the systematic error the window has to cover.
+        // zero -- that offset is the systematic error the window has to cover.
         let offset = ErrorStats::from_slice(&[8.0, 9.0, 10.0, 11.0, 12.0]);
         assert_eq!((offset.median, offset.mad), (10.0, 1.0));
 
@@ -564,7 +564,7 @@ mod tests {
         // Expectations are literals, not the implementation's own expression: at
         // MAD 1 and 2 sigma the half-spread is 2 * 1.4826 = 2.9652.
         //
-        // The offset dimension's left bound lands under its floor — its median is
+        // The offset dimension's left bound lands under its floor -- its median is
         // further from zero than the spread, so the window does not reach back.
         assert_eq!(w.mz_ppm.0, params.floors.mz_ppm as f64);
         assert!((w.mz_ppm.1 - 12.9652).abs() < 1e-4, "{:?}", w.mz_ppm);
diff --git a/rust/timsseek/src/scoring/apex_dsp.rs b/rust/timsseek/src/scoring/apex_dsp.rs
index 8e179de8..fdb08d3b 100644
--- a/rust/timsseek/src/scoring/apex_dsp.rs
+++ b/rust/timsseek/src/scoring/apex_dsp.rs
@@ -1,5 +1,5 @@
 //! Reusable numeric primitives for apex-local scoring. These carry no scoring
-//! semantics — they are the shared math toolkit that the apex-stage score
+//! semantics -- they are the shared math toolkit that the apex-stage score
 //! families ([`blocks::apex_features`], [`blocks::apex_evidence`]) build on.
 //! Score-specific building blocks (area-uniqueness, coelution-gradient, the
 //! weighted-score weights) live in their own family file, not here.
diff --git a/rust/timsseek/src/scoring/apex_finding.rs b/rust/timsseek/src/scoring/apex_finding.rs
index 6812b18a..2d60412e 100644
--- a/rust/timsseek/src/scoring/apex_finding.rs
+++ b/rust/timsseek/src/scoring/apex_finding.rs
@@ -142,7 +142,7 @@ pub struct ApexLocation {
 
 /// The result of the full scoring process (Phase 3): the apex-stage score
 /// blocks, plus the two bridge scalars (`joint_apex_cycle`, `retention_time_ms`
-/// — the latter drives the secondary-query RT). Assembled while the
+/// -- the latter drives the secondary-query RT). Assembled while the
 /// chromatogram buffers are live; moves into `ScoringFields` at finalize.
 #[derive(Debug, Clone, Copy)]
 pub struct ApexBlocks {
@@ -401,7 +401,7 @@ impl TraceScorer {
     }
 
     /// Stage B: Suggest best apex from precomputed traces.
-    /// Pure peak-pick on apex_profile — O(cycles). Truly cheap.
+    /// Pure peak-pick on apex_profile -- O(cycles). Truly cheap.
     /// Returns `apex_profile[max_loc]` as the ranking score.
     pub fn suggest_apex(
         &self,
@@ -436,7 +436,7 @@ impl TraceScorer {
     }
 
     /// Stage B': the window-global apex evidence. Cycle-invariant, so it is
-    /// computed ONCE per extraction and handed to [`Self::score_at`] — sweeping
+    /// computed ONCE per extraction and handed to [`Self::score_at`] -- sweeping
     /// `score_at` across cycles would otherwise redo four full-slice passes
     /// (2x argmax, 2x `area_uniqueness` total-sum) per cycle, making the sweep
     /// O(cycles^2). Needs `&mut self` only for `coel_scratch` reuse.
@@ -493,7 +493,7 @@ impl TraceScorer {
         let delta_second_next = cycle_val - second_next_val;
 
         // Unified apex source: Pass 2 scores at Pass 1's weighted-apex_profile
-        // location. `cycle` is `suggested.apex_cycle` (the weighted argmax) — the
+        // location. `cycle` is `suggested.apex_cycle` (the weighted argmax) -- the
         // single, best-validated apex finder. No re-location on a weaker profile.
         let effective_apex = cycle;
 
@@ -681,8 +681,8 @@ impl TraceScorer {
                 entry.1 /= pred_sqrt_sum;
             }
 
-            // One reciprocal per cycle, so the row loop below — which walks the
-            // cycle axis once per retained fragment — multiplies instead of
+            // One reciprocal per cycle, so the row loop below -- which walks the
+            // cycle axis once per retained fragment -- multiplies instead of
             // dividing. Zero stays zero, marking the cycles that finalize floors.
             let inv_sqrt_sum = &mut self.buffers.temp_inv_sqrt_sum;
             for (inv, &ss) in inv_sqrt_sum.iter_mut().zip(sqrt_sum.iter()) {
diff --git a/rust/timsseek/src/scoring/blocks/apex_evidence.rs b/rust/timsseek/src/scoring/blocks/apex_evidence.rs
index 083e762a..8d0fd389 100644
--- a/rust/timsseek/src/scoring/blocks/apex_evidence.rs
+++ b/rust/timsseek/src/scoring/blocks/apex_evidence.rs
@@ -120,7 +120,7 @@ pub fn compute_apex_evidence<T: KeyLike>(
     let cos_au = area_uniqueness(cosine_profile, cos_apex, 5);
     let scr_au = area_uniqueness(scribe_profile, scr_apex, 5);
 
-    // Coelution-gradient at each apex — shares the same scratch.
+    // Coelution-gradient at each apex -- shares the same scratch.
     let cos_cg = coelution_gradient(fragments, expected, cos_apex, 20, 10, scratch);
     let scr_cg = coelution_gradient(fragments, expected, scr_apex, 20, 10, scratch);
 
diff --git a/rust/timsseek/src/scoring/blocks/apex_features.rs b/rust/timsseek/src/scoring/blocks/apex_features.rs
index db16c895..f1a0560c 100644
--- a/rust/timsseek/src/scoring/blocks/apex_features.rs
+++ b/rust/timsseek/src/scoring/blocks/apex_features.rs
@@ -385,7 +385,7 @@ fn compute_fragment_apex_agreement<T: KeyLike>(
 /// envelope at the apex cycle.
 ///
 /// Uses existing predicted precursor_intensities (keys 0, 1, 2) rather than
-/// re-implementing averagine — the codebase already has sequence-specific predictions.
+/// re-implementing averagine -- the codebase already has sequence-specific predictions.
 fn compute_isotope_correlation(
     precursors: &MzMajorIntensityArray<i8, f32>,
     expected_precursor: &[(i8, f32)],
diff --git a/rust/timsseek/src/scoring/blocks/derived.rs b/rust/timsseek/src/scoring/blocks/derived.rs
index 0b79a068..60b8a6c6 100644
--- a/rust/timsseek/src/scoring/blocks/derived.rs
+++ b/rust/timsseek/src/scoring/blocks/derived.rs
@@ -1,5 +1,5 @@
 //! Cross-field / cross-block ML features. These reference more than one field,
-//! so they are NOT `#[feat]` attrs (which are strictly unary) — instead a
+//! so they are NOT `#[feat]` attrs (which are strictly unary) -- instead a
 //! hand-written [`Derived::compute`] reads a view of the finalized
 //! [`ScoringFields`] and fills a normal `#[derive(ScoreBlock)]` struct. The
 //! block emits ML features/names through the same lane walks as every other
diff --git a/rust/timsseek/src/scoring/blocks/identity.rs b/rust/timsseek/src/scoring/blocks/identity.rs
index 02a46f28..c019b020 100644
--- a/rust/timsseek/src/scoring/blocks/identity.rs
+++ b/rust/timsseek/src/scoring/blocks/identity.rs
@@ -1,4 +1,4 @@
-//! Identity family — peptide + precursor metadata. Hand-written because it is
+//! Identity family -- peptide + precursor metadata. Hand-written because it is
 //! irreducibly mixed-dtype (`Peptide`, `bool`, `f64`, `u32`, `u8`, `f32`); you
 //! never add a *score* here.
 
@@ -25,7 +25,7 @@ pub struct Identity {
     /// opaque and unserializable: the row orders the q-value tie-break without
     /// a caller-supplied id reaching the sort, and the group is only ever
     /// compared. The ids a reader wants are resolved from the arena at the
-    /// writer — see [`crate::scoring::parquet_writer`].
+    /// writer -- see [`crate::scoring::parquet_writer`].
     #[serde(skip)]
     pub row: RowIdx,
     #[serde(skip)]
@@ -40,7 +40,7 @@ impl Identity {
     /// Hand-written twin of what `#[derive(ScoreBlock)]` emits: no identity
     /// field is a linear-lane feature.
     pub const LINEAR_LEN: usize = 0;
-    /// `precursor_mz_round5`, `precursor_charge`, `precursor_mobility` — the
+    /// `precursor_mz_round5`, `precursor_charge`, `precursor_mobility` -- the
     /// context features. `is_target` is Parquet-only, as are the ids the writer
     /// resolves from `row`.
     pub const NONLINEAR_LEN: usize = 3;
@@ -60,7 +60,7 @@ impl Identity {
     /// Whether two results compete: same decoy group, same charge.
     ///
     /// Defined in terms of [`Self::competition_key`], so sorting by that key
-    /// always leaves competing results adjacent — the predicate and the sort
+    /// always leaves competing results adjacent -- the predicate and the sort
     /// order cannot drift apart.
     pub fn competes_with(&self, other: &Self) -> bool {
         self.competition_key() == other.competition_key()
@@ -134,8 +134,8 @@ impl ScoreBlock for Identity {
 mod tests {
     use super::*;
 
-    /// The two halves of the nonlinear lane — the per-record value array and
-    /// the set-level name walk — must agree on count, order, and which value
+    /// The two halves of the nonlinear lane -- the per-record value array and
+    /// the set-level name walk -- must agree on count, order, and which value
     /// sits under which name. Hand-written here (the derive can't check this
     /// block), so this is the only place the pairing is asserted.
     #[test]
diff --git a/rust/timsseek/src/scoring/blocks/ion_errors.rs b/rust/timsseek/src/scoring/blocks/ion_errors.rs
index 66e26372..bd288628 100644
--- a/rust/timsseek/src/scoring/blocks/ion_errors.rs
+++ b/rust/timsseek/src/scoring/blocks/ion_errors.rs
@@ -1,12 +1,12 @@
 //! Per-ion m/z and mobility error arrays. Array family: each `[f32; N]` field
 //! fans out to one feature per ion, and the `#[feat(..)]` list adds the
-//! linear-model companions — `abs` (magnitude, since these errors are
+//! linear-model companions -- `abs` (magnitude, since these errors are
 //! center-is-better) and `isna` (missing ion / mobility dim, not-missing-at-
 //! random). `columns` emits only the raw signed arrays.
 //!
 //! Changing an ion count means editing `NUM_MS*_IONS`; the array lengths and
 //! all `{field}_{i}` names flow from there. Column/feature names are `{field}_
-//! {i}` (+ transform suffix), generated by the macro — no name table.
+//! {i}` (+ transform suffix), generated by the macro -- no name table.
 
 use timsseek_macros::ScoreBlock;
 
diff --git a/rust/timsseek/src/scoring/blocks/lazy.rs b/rust/timsseek/src/scoring/blocks/lazy.rs
index ae3585b4..0e6dcfdb 100644
--- a/rust/timsseek/src/scoring/blocks/lazy.rs
+++ b/rust/timsseek/src/scoring/blocks/lazy.rs
@@ -6,7 +6,7 @@
 //! `timsseek_macros`): the derive generates every projection
 //! (`column_schema`/`columns` plus both feature lanes' value arrays and names)
 //! from the field list. Every field here is `#[feat(..)]`-annotated without
-//! `linear = false`, so they all land in the LINEAR lane — the live path the
+//! `linear = false`, so they all land in the LINEAR lane -- the live path the
 //! ML consumer reads.
 
 use serde::Serialize;
diff --git a/rust/timsseek/src/scoring/blocks/mod.rs b/rust/timsseek/src/scoring/blocks/mod.rs
index daef726c..bdea1a7c 100644
--- a/rust/timsseek/src/scoring/blocks/mod.rs
+++ b/rust/timsseek/src/scoring/blocks/mod.rs
@@ -1,7 +1,7 @@
 //! Score blocks: modular, derive-generated scoring fields.
 //!
 //! A *score* belongs to a *family*; a family is one file that owns its whole
-//! lifecycle — compute-from-inputs, parquet projection (`columns`), and the
+//! lifecycle -- compute-from-inputs, parquet projection (`columns`), and the
 //! two-lane ML projections (`linear_feature_array`/`nonlinear_feature_array` =
 //! values, `linear_feature_names`/`nonlinear_feature_names` = names). Adding a
 //! score to an existing family touches only that file, and forgetting a
@@ -30,11 +30,11 @@
 //! [`relative_intensities::RelativeIntensities`] are derive-generated too
 //! (names `{field}_{i}` from the field + count). Hand-written exceptions that
 //! still emit through the same sinks, with compute in-file:
-//! - [`identity::Identity`] — irreducibly mixed-dtype.
+//! - [`identity::Identity`] -- irreducibly mixed-dtype.
 //! - the features-only [`sequence_counts`] block (no Parquet column).
 //!
-//! The remaining blocks — including the output-only
-//! [`result_meta::ResultMeta`] — are generated by `#[derive(ScoreBlock)]`.
+//! The remaining blocks -- including the output-only
+//! [`result_meta::ResultMeta`] -- are generated by `#[derive(ScoreBlock)]`.
 
 use arrow::array::*;
 use arrow::datatypes::*;
@@ -71,7 +71,7 @@ pub mod sequence_counts;
 /// `linear_feature_array` / `nonlinear_feature_array` returning
 /// `[f64; Self::LINEAR_LEN]` / `[f64; Self::NONLINEAR_LEN]`, because a
 /// `-> [f64; Self::LEN]` signature in a trait requires unstable
-/// `generic_const_exprs`. Only the set-level NAME walks are dispatched here —
+/// `generic_const_exprs`. Only the set-level NAME walks are dispatched here --
 /// they must stay dynamic anyway, since an array field's `{field}_{i}` fan-out
 /// loops over a const path.
 ///
@@ -92,7 +92,7 @@ pub trait ScoreBlock {
 }
 
 // ---------------------------------------------------------------------------
-// ColSink — row-oriented Parquet column accumulator
+// ColSink -- row-oriented Parquet column accumulator
 // ---------------------------------------------------------------------------
 
 enum ColData {
@@ -117,7 +117,7 @@ struct Column {
 /// order per block. On the first row the columns are created (name + dtype +
 /// nullability recorded from the typed method); on later rows the cursor walks
 /// the existing columns and appends. Scalars are non-nullable; expanded array
-/// columns (`f32_array`) are nullable — this preserves the pre-block
+/// columns (`f32_array`) are nullable -- this preserves the pre-block
 /// column name→dtype→nullability set.
 #[derive(Default)]
 pub struct ColSink {
@@ -239,11 +239,11 @@ impl ColSink {
 }
 
 // ---------------------------------------------------------------------------
-// SchemaSink — Parquet schema-only accumulator (dtype/nullability, no data)
+// SchemaSink -- Parquet schema-only accumulator (dtype/nullability, no data)
 // ---------------------------------------------------------------------------
 
 /// Accumulates Parquet field schema (name, dtype, nullability) without any row
-/// data — the schema-only counterpart to [`ColSink`]. Dtype/nullability MUST
+/// data -- the schema-only counterpart to [`ColSink`]. Dtype/nullability MUST
 /// byte-match `ColSink`'s (scalars non-nullable, expanded array elements
 /// nullable); the golden schema test guards this.
 #[derive(Default)]
@@ -303,7 +303,7 @@ impl SchemaSink {
 }
 
 // ---------------------------------------------------------------------------
-// NameSink — set-level ML feature-name accumulator
+// NameSink -- set-level ML feature-name accumulator
 // ---------------------------------------------------------------------------
 
 /// Builds the ML feature-name list ONCE for a whole fit (a property of the
@@ -331,7 +331,7 @@ impl NameSink {
 }
 
 // ---------------------------------------------------------------------------
-// BlockFixture — fixed constants for the generated `sample_default()`
+// BlockFixture -- fixed constants for the generated `sample_default()`
 // ---------------------------------------------------------------------------
 
 /// Supplies a fixed constant per field type for a block's generated
diff --git a/rust/timsseek/src/scoring/blocks/result_meta.rs b/rust/timsseek/src/scoring/blocks/result_meta.rs
index d8322e22..43053582 100644
--- a/rust/timsseek/src/scoring/blocks/result_meta.rs
+++ b/rust/timsseek/src/scoring/blocks/result_meta.rs
@@ -1,7 +1,7 @@
-//! Result-meta family — post-model, output-only fields (filled in place after
+//! Result-meta family -- post-model, output-only fields (filled in place after
 //! rescoring, not computed via Inputs). `columns` emits all four; only the two
 //! delta-group fields carry `#[feat(raw)]`, so they are the only ones in a
-//! feature lane — the LINEAR one, since `linear = true` is the default
+//! feature lane -- the LINEAR one, since `linear = true` is the default
 //! (`discriminant_score`/`qvalue` are Parquet-only).
 
 use timsseek_macros::ScoreBlock;
diff --git a/rust/timsseek/src/scoring/blocks/rt.rs b/rust/timsseek/src/scoring/blocks/rt.rs
index 26d5ac62..6d0ada99 100644
--- a/rust/timsseek/src/scoring/blocks/rt.rs
+++ b/rust/timsseek/src/scoring/blocks/rt.rs
@@ -1,6 +1,6 @@
 //! Retention-time family. Finalize-stage: reads library/calibrated RT from
 //! metadata and the observed apex RT (`inp.apex.retention_time_ms`), so it is
-//! cheap arithmetic on an apex scalar — not a straddle.
+//! cheap arithmetic on an apex scalar -- not a straddle.
 
 use timsseek_macros::ScoreBlock;
 
diff --git a/rust/timsseek/src/scoring/blocks/sequence_counts.rs b/rust/timsseek/src/scoring/blocks/sequence_counts.rs
index 62b39108..801dea0f 100644
--- a/rust/timsseek/src/scoring/blocks/sequence_counts.rs
+++ b/rust/timsseek/src/scoring/blocks/sequence_counts.rs
@@ -1,8 +1,8 @@
-//! Sequence-derived features (nonlinear lane, features-only — no Parquet
+//! Sequence-derived features (nonlinear lane, features-only -- no Parquet
 //! column).
 //!
 //! UNCONDITIONAL: always [`LEN`] features wide. A peptide with no parsed
-//! sequence emits `f64::NAN` for all of them rather than emitting nothing —
+//! sequence emits `f64::NAN` for all of them rather than emitting nothing --
 //! NaN is exactly what forust reads as "missing", and a fixed width is what
 //! lets this block's contribution to the feature matrix be a compile-time
 //! constant like every other block's. Emitted LAST, so these names stay at the
diff --git a/rust/timsseek/src/scoring/offsets.rs b/rust/timsseek/src/scoring/offsets.rs
index 154eee14..288e4948 100644
--- a/rust/timsseek/src/scoring/offsets.rs
+++ b/rust/timsseek/src/scoring/offsets.rs
@@ -260,7 +260,7 @@ mod tests {
     #[test]
     fn weighted_ms1_calibrates_mz_when_mobility_absent() {
         // mzML vs no-IM library: finite m/z error, NaN mobility error. m/z MUST
-        // still calibrate — the calibrant must not be dropped just because
+        // still calibrate -- the calibrant must not be dropped just because
         // mobility is absent (regression guard for the `w_mz && w_mob` gate).
         let mut ms1 = TopNArray::new();
         ms1.push(ion(10.0, 5.0, f32::NAN));
diff --git a/rust/timsseek/src/scoring/parquet_writer.rs b/rust/timsseek/src/scoring/parquet_writer.rs
index 73628c23..cd9d0e59 100644
--- a/rust/timsseek/src/scoring/parquet_writer.rs
+++ b/rust/timsseek/src/scoring/parquet_writer.rs
@@ -106,7 +106,7 @@ fn emit_row(r: &FinalResult, geom: &TargetColumns<IonAnnot>, sink: &mut ColSink)
     sink.end_row();
 }
 
-/// Zero-row RecordBatch built directly from the block schema — no fake row.
+/// Zero-row RecordBatch built directly from the block schema -- no fake row.
 fn empty_batch() -> std::io::Result<RecordBatch> {
     let mut ss = super::blocks::SchemaSink::new();
     FinalResult::column_schema(&mut ss);
@@ -125,7 +125,7 @@ fn empty_batch() -> std::io::Result<RecordBatch> {
 /// **COMPILE-TIME SAFETY:** each block's `columns()` is generated by walking
 /// the same field list that defines the block struct (see
 /// `#[derive(ScoreBlock)]` in `timsseek_macros`), so a new field cannot
-/// silently skip the Parquet projection — there is no hand-written destructure
+/// silently skip the Parquet projection -- there is no hand-written destructure
 /// to fall out of sync.
 pub fn build_record_batch(
     results: &[FinalResult],
@@ -279,7 +279,7 @@ mod tests {
     /// The maintained contract: a SUBSET of columns downstream consumers rely on
     /// to join a row and threshold it. Each listed `column_name -> (dtype,
     /// nullable)` must be present and match. Everything else the writer emits
-    /// (all the feature/diagnostic columns) is free to change or disappear —
+    /// (all the feature/diagnostic columns) is free to change or disappear --
     /// this test does NOT reject extra columns, and column ORDER is not asserted
     /// (downstream reads by name). Add a column here only when you commit to
     /// keeping it stable.
@@ -311,7 +311,7 @@ mod tests {
     }
 
     /// The ids are not carried on a result any more, so this is what pins that
-    /// they still reach the file — and that the row a result points at is the
+    /// they still reach the file -- and that the row a result points at is the
     /// row whose id gets written.
     #[test]
     fn ids_resolve_from_the_arena_row() {
diff --git a/rust/timsseek/src/scoring/pipeline.rs b/rust/timsseek/src/scoring/pipeline.rs
index 1eb096de..d8123f24 100644
--- a/rust/timsseek/src/scoring/pipeline.rs
+++ b/rust/timsseek/src/scoring/pipeline.rs
@@ -20,7 +20,7 @@
 //!
 //! The scoring process has two phases:
 //!
-//! 1. **Prescore** (Phase 1): Broad extraction + `find_apex_location` — yields calibrant candidates.
+//! 1. **Prescore** (Phase 1): Broad extraction + `find_apex_location` -- yields calibrant candidates.
 //! 2. **Calibrated scoring** (Phase 3): Narrow calibrated extraction + `find_apex` + secondary query.
 
 use crate::data_sources::reference_library::{
@@ -89,7 +89,7 @@ use tracing::warn;
 /// - `Extraction` slot (ChromatogramCollector reset-and-reused, not reallocated)
 /// - `inner_collector` / `isotope_collector` reused across Phase 3 secondary queries
 /// - `isotope_scratch_eg` holds the neutron-offset-applied eg; `Option<>` because
-///   `Target` has no `Default` (bon builder with required fields) —
+///   `Target` has no `Default` (bon builder with required fields) --
 ///   init lazily on first peptide.
 pub struct ScoringWorker {
     pub scorer: TraceScorer,
@@ -111,7 +111,7 @@ impl ScoringWorker {
     }
 }
 
-/// Lightweight calibrant candidate — just enough to re-query in Phase 2.
+/// Lightweight calibrant candidate -- just enough to re-query in Phase 2.
 /// Implements Ord by score (ascending) for use in BinaryHeap<Reverse<_>>.
 #[derive(Debug, Clone)]
 pub struct CalibrantCandidate {
@@ -158,7 +158,7 @@ impl CalibrantHeap {
 
     /// Returns `Err(SkipReason::CalibrantNanScore)` when `candidate.score` is
     /// NaN so the caller can surface the count in reports. Non-positive or
-    /// +Inf scores are silently discarded — they are either sentinel
+    /// +Inf scores are silently discarded -- they are either sentinel
     /// (`score <= 0.0` means "no usable signal") or already dominated by any
     /// finite positive candidate in the heap.
     pub fn push(&mut self, candidate: CalibrantCandidate) -> Result<(), SkipReason> {
@@ -204,7 +204,7 @@ impl CalibrantHeap {
     }
 }
 
-/// Calibration configuration — all tunable parameters with defaults.
+/// Calibration configuration -- all tunable parameters with defaults.
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct CalibrationConfig {
@@ -229,7 +229,7 @@ impl Default for CalibrationConfig {
             n_calibrants: 2000,
             grid_size: 100,
             // Keep in sync with `timsseek_cli/assets/default_config.toml`
-            // ([calibration]) — that file carries the rationale for these
+            // ([calibration]) -- that file carries the rationale for these
             // sigmas, and `config::tests::default_template_parses`
             // fails if the two drift apart.
             mz_sigma: 3.0,
@@ -258,7 +258,7 @@ fn gate_expected_fragments(expected: &ExpectedIntensities<IonAnnot>) -> Result<(
 }
 
 /// Fill the per-worker scratch elution group in place from a `RefQuery`
-/// flyweight (Task 9). `reset_from` copies the per-variant geometry — for a
+/// flyweight (Task 9). `reset_from` copies the per-variant geometry -- for a
 /// decoy the fragment m/z values are ALREADY shifted by value, so no extra
 /// work is needed. It also sets the precursor labels to the isotope-envelope
 /// indices via the flyweight's `iter_precursors` (`0..n_isotopes`), which match
@@ -287,7 +287,7 @@ impl ScratchBufs {
 
     /// Refill both buffers from the flyweight: geometry into `eg`, and the
     /// expected fragment/precursor intensities into `expected` (deduped by
-    /// key via `try_from_pairs` — library keys are unique by construction).
+    /// key via `try_from_pairs` -- library keys are unique by construction).
     fn fill_from<Q: QueryGeom<Label = IonAnnot> + ExpectedIntensity>(&mut self, q: &Q) {
         fill_scratch_from(&mut self.eg, q);
         self.expected = ExpectedIntensities::try_from_pairs(
@@ -495,7 +495,7 @@ impl<I: ScorerQueriable> Scorer<I> {
         inner.reset_with_overrides(query, Some(new_rt_seconds), Some(mobility as f32));
 
         // Isotope scratch eg holds `query` with +1 neutron offset applied
-        // (buffer-override — reuses Vec capacity after warm-up).
+        // (buffer-override -- reuses Vec capacity after warm-up).
         let scratch_eg = worker
             .isotope_scratch_eg
             .get_or_insert_with(|| query.clone());
@@ -551,7 +551,7 @@ impl<I: ScorerQueriable> Scorer<I> {
 
 impl<I: ScorerQueriable> Scorer<I> {
     /// Build a chromatogram extraction using calibrated RT and per-query tolerance.
-    /// The speclib is NOT mutated — CalibrationResult provides the RT conversion.
+    /// The speclib is NOT mutated -- CalibrationResult provides the RT conversion.
     #[cfg_attr(
         feature = "instrumentation",
         tracing::instrument(skip_all, level = "trace")
@@ -574,7 +574,7 @@ impl<I: ScorerQueriable> Scorer<I> {
         let tolerance = calibration.get_tolerance(
             query.mono_precursor_mz(),
             query.mobility_ook0(),
-            original_irt, // library RT — ridge widths are indexed by library RT
+            original_irt, // library RT -- ridge widths are indexed by library RT
         );
 
         super::extraction::build_extraction_into(
@@ -701,7 +701,7 @@ impl<I: ScorerQueriable> Scorer<I> {
     ) -> (Vec<ScoredCandidate>, ScoreTimings, SkipCounts) {
         // Single columnar store (Task 9 deleted the materialized arm): the
         // flyweight is always a `RefQuery` from the arena, so the loop is
-        // monomorphized over one concrete type — statically dispatched, no
+        // monomorphized over one concrete type -- statically dispatched, no
         // per-item heap allocation on the scoring hot path.
         self.score_calibrated_batch_impl(|f| lib.item_at(f), flats, calibration)
     }
@@ -724,7 +724,7 @@ impl<I: ScorerQueriable> Scorer<I> {
             let lims = TupleRange::try_new(tmp.0, tmp.1).expect("Should already be ordered");
             self.fragmented_range.intersects(lims)
         };
-        // Pre-scan so scratch capacity holds every peptide — no realloc in hot path.
+        // Pre-scan so scratch capacity holds every peptide -- no realloc in hot path.
         let max_frags = flats
             .iter()
             .map(|&f| get_item(f).fragment_count())
@@ -781,9 +781,9 @@ impl<I: ScorerQueriable> Scorer<I> {
         (results.res, results.timings, results.skips)
     }
 
-    /// Phase 1: Lightweight prescore — broad extraction + find_apex_location only.
+    /// Phase 1: Lightweight prescore -- broad extraction + find_apex_location only.
     /// Returns an [`ApexLocation`], whose `score` is the apex-profile peak
-    /// value — NOT the apex evidence (see `TraceScorer::suggest_apex`).
+    /// value -- NOT the apex evidence (see `TraceScorer::suggest_apex`).
     #[cfg_attr(
         feature = "instrumentation",
         tracing::instrument(skip_all, level = "trace")
@@ -846,7 +846,7 @@ impl<I: ScorerQueriable> Scorer<I> {
         timings: &mut PrescoreTimings,
     ) -> CalibrantHeap {
         // Single columnar store (Task 9): iterate `RefQuery` flyweights from
-        // the arena directly — monomorphized, no per-item heap alloc on the
+        // the arena directly -- monomorphized, no per-item heap alloc on the
         // prescore hot path (see `score_calibrated_batch`).
         self.prescore_batch_impl(|f| lib.item_at(f), flats, config, timings)
     }
@@ -862,7 +862,7 @@ impl<I: ScorerQueriable> Scorer<I> {
         Q: QueryGeom<Label = IonAnnot> + ExpectedIntensity + ScoredIdentity,
     {
         // The flat index IS the global speclib index (see `Speclib::item_at`),
-        // so it doubles as `CalibrantCandidate::speclib_index` — no separate
+        // so it doubles as `CalibrantCandidate::speclib_index` -- no separate
         // chunk offset needed.
         let filter_fn = |q: &Q| {
             let tmp = q.precursor_mz_limits();
diff --git a/rust/timsseek/src/scoring/results.rs b/rust/timsseek/src/scoring/results.rs
index 83797080..59ed26b1 100644
--- a/rust/timsseek/src/scoring/results.rs
+++ b/rust/timsseek/src/scoring/results.rs
@@ -58,8 +58,8 @@ pub struct FinalizeInputs<'a> {
 /// same derive that projects a leaf block's `#[feat(...)]` scalars walks this
 /// list to emit the composed struct's Parquet columns/schema, its two lane
 /// value arrays and their name walks, and `sample_default`. Field order is
-/// load-bearing — parquet column order and the positional ML value vector both
-/// follow it — so folding every walk out of the one declaration order is what
+/// load-bearing -- parquet column order and the positional ML value vector both
+/// follow it -- so folding every walk out of the one declaration order is what
 /// makes them *impossible* to desync.
 ///
 /// The lane widths compose the same way the values do: `LINEAR_LEN` is the sum
@@ -207,7 +207,7 @@ impl FinalResult {
     }
 
     /// Value-free Parquet schema: scoring blocks (composition order), the
-    /// post-model meta block, then the ids — the same three blocks `emit_row`
+    /// post-model meta block, then the ids -- the same three blocks `emit_row`
     /// writes, in the same order.
     ///
     /// The ids are their own block because they are not on the result; the
diff --git a/rust/timsseek/src/scoring/skip.rs b/rust/timsseek/src/scoring/skip.rs
index e1d48833..7192df5a 100644
--- a/rust/timsseek/src/scoring/skip.rs
+++ b/rust/timsseek/src/scoring/skip.rs
@@ -19,7 +19,7 @@ pub enum SkipReason {
     PrecursorOutOfFragmentedRange,
     /// Query RT (± tolerance) does not intersect the run's cycle range.
     RetentionTimeOutOfBounds,
-    /// Speclib entry carries zero predicted fragments — nothing to score.
+    /// Speclib entry carries zero predicted fragments -- nothing to score.
     NoExpectedFragments,
     /// Extraction ran but zero quad isolation windows overlapped the query's
     /// precursor range. Signals a library / instrument scan-schedule mismatch
@@ -37,7 +37,7 @@ pub enum SkipReason {
     ApexInsufficientData,
     /// NaN / Inf surfaced in scoring math (indicates upstream data pathology).
     ApexNonFiniteScore,
-    /// Phase 1 `find_apex_location` returned NaN for a calibrant score —
+    /// Phase 1 `find_apex_location` returned NaN for a calibrant score --
     /// dropped before entering `CalibrantHeap` so downstream ordering stays
     /// well-defined. Non-zero count signals pathological fragment intensities
     /// or a divide-by-zero in the scoring math.
diff --git a/rust/timsseek/src/scoring/timings.rs b/rust/timsseek/src/scoring/timings.rs
index 4a222e20..55eb98da 100644
--- a/rust/timsseek/src/scoring/timings.rs
+++ b/rust/timsseek/src/scoring/timings.rs
@@ -6,8 +6,8 @@
 //!
 //! Two helpers reduce timing boilerplate:
 //!
-//! - `timed!` — times a block and accumulates elapsed into a `Duration` field.
-//! - [`TimedStep`] — progressive CLI output: prints a label immediately, then
+//! - `timed!` -- times a block and accumulates elapsed into a `Duration` field.
+//! - [`TimedStep`] -- progressive CLI output: prints a label immediately, then
 //!   appends elapsed time when the work finishes. Re-exported from
 //!   [`timscentroid::TimedStep`].
 
diff --git a/rust/timsseek/src/utils/elution_group_ops.rs b/rust/timsseek/src/utils/elution_group_ops.rs
index 76592f5c..dbd8f3e2 100644
--- a/rust/timsseek/src/utils/elution_group_ops.rs
+++ b/rust/timsseek/src/utils/elution_group_ops.rs
@@ -7,7 +7,7 @@ use crate::IonAnnot;
 /// (reusing Vec/TinyVec capacity), then apply an isotope-spacing m/z shift and label
 /// rewrite to every fragment in place. Zero alloc after warm-up.
 ///
-/// `dst` and `src` must refer to distinct Target values — typical use
+/// `dst` and `src` must refer to distinct Target values -- typical use
 /// is `apply_isotope_offset_fragments_into(&mut worker.isotope_scratch_eg, &item.query, 1)`.
 pub fn apply_isotope_offset_fragments_into(
     dst: &mut Target<IonAnnot>,
diff --git a/rust/timsseek/src/utils/maybe_par.rs b/rust/timsseek/src/utils/maybe_par.rs
index 89297272..4e714b4d 100644
--- a/rust/timsseek/src/utils/maybe_par.rs
+++ b/rust/timsseek/src/utils/maybe_par.rs
@@ -3,13 +3,13 @@
 //!
 //! The shapes, and what each one promises about ordering:
 //!
-//! * [`fold_reduce`] — per-item fold with per-worker accumulators. The
+//! * [`fold_reduce`] -- per-item fold with per-worker accumulators. The
 //!   accumulator count, and so the reduce order, follows the thread pool: NOT
 //!   reproducible for a non-associative `reduce` (e.g. float addition).
-//! * [`chunked_fold_reduce`] — per-chunk accumulate over a thread-count-
+//! * [`chunked_fold_reduce`] -- per-chunk accumulate over a thread-count-
 //!   independent partition, merged in ascending chunk order: bitwise
 //!   reproducible.
-//! * [`sort_by`] — in-place STABLE sort: ties keep input order, on any thread
+//! * [`sort_by`] -- in-place STABLE sort: ties keep input order, on any thread
 //!   count. Reproducible, which matters when a later pass walks the order
 //!   positionally (see `assign_qval`).
 
@@ -21,7 +21,7 @@ use rayon::prelude::*;
 /// `init()` must be an identity for `reduce`: rayon uses it to seed both the
 /// fold and the reduce, so a non-identity init miscounts on small inputs.
 ///
-/// The accumulator count — and therefore the order `reduce` combines them —
+/// The accumulator count -- and therefore the order `reduce` combines them --
 /// follows the thread pool. Use [`chunked_fold_reduce`] when that order must
 /// be reproducible.
 pub(crate) fn fold_reduce<Item, Acc, Init, Fold, Reduce>(
@@ -109,7 +109,7 @@ where
 
 /// Sort `items` in place by `cmp`, in parallel when rayon is on.
 ///
-/// Stable, so ties keep input order on any thread count — `assign_qval` walks
+/// Stable, so ties keep input order on any thread count -- `assign_qval` walks
 /// the sorted order positionally, so that reproducibility matters. Needs
 /// scratch proportional to `items.len() * size_of::<T>()`.
 pub(crate) fn sort_by<T, F>(items: &mut [T], cmp: F)
diff --git a/rust/timsseek_cli/Cargo.toml b/rust/timsseek_cli/Cargo.toml
index 3d9e78bd..a4a11488 100644
--- a/rust/timsseek_cli/Cargo.toml
+++ b/rust/timsseek_cli/Cargo.toml
@@ -49,7 +49,7 @@ track-alloc = ["alloc_track/enabled"]
 # Dev-only calibration fit dashboard (TIMSSEEK_CALIB_DASHBOARD=1). Opt-in;
 # build with `--features calib-dashboard`.
 calib-dashboard = ["dep:calib_dash"]
-# S3 is default (see above). GCS/Azure stay opt-in — add when actually needed.
+# S3 is default (see above). GCS/Azure stay opt-in -- add when actually needed.
 aws = ["tims_stage/aws", "timscentroid/aws"]
 gcp = ["tims_stage/gcp", "timscentroid/gcp"]
 azure = ["tims_stage/azure", "timscentroid/azure"]
diff --git a/rust/timsseek_cli/assets/default_config.toml b/rust/timsseek_cli/assets/default_config.toml
index 3a09acdf..776b4fc5 100644
--- a/rust/timsseek_cli/assets/default_config.toml
+++ b/rust/timsseek_cli/assets/default_config.toml
@@ -1,6 +1,6 @@
 # timsseek default configuration.
 #
-# Every section is optional unless explicitly noted — omitted sections fall back
+# Every section is optional unless explicitly noted -- omitted sections fall back
 # to the values shown here. Unknown fields are rejected to catch typos early.
 #
 # Dump this file at any time with:
@@ -10,7 +10,7 @@
 #
 # The CLI also accepts JSON configs; TOML is preferred for hand-authored ones.
 
-## Input spectral library (optional — `--speclib-uri` overrides this).
+## Input spectral library (optional -- `--speclib-uri` overrides this).
 # [input]
 # type = "speclib"
 # uri = "path/to/library.msgpack.zst"
@@ -21,16 +21,16 @@
 chunk_size = 20000
 
 ## Decoy generation strategy.
-## "if_missing"  — generate ±12 Da mass-shift decoys when the library has none
-## "always"      — always generate decoys (replace any existing ones)
-## "never"       — trust the library's decoy labels
+## "if_missing"  -- generate ±12 Da mass-shift decoys when the library has none
+## "always"      -- always generate decoys (replace any existing ones)
+## "never"       -- trust the library's decoy labels
 decoy_strategy = "if_missing"
 
 ## Rescore model applied in Phase 5 (`--rescore-model` overrides this).
-## "gbm"        — cross-validated gradient-boosted trees
-## "lda"        — Sage-style shrinkage LDA on the linear lane
-## "hybrid"     — cross-fit LDA score folded into the GBM feature frame
-## "mlp"        — small MLP on the full lane (default; same features as "gbm")
+## "gbm"        -- cross-validated gradient-boosted trees
+## "lda"        -- Sage-style shrinkage LDA on the linear lane
+## "hybrid"     -- cross-fit LDA score folded into the GBM feature frame
+## "mlp"        -- small MLP on the full lane (default; same features as "gbm")
 ##
 ## Runtime and sensitivity differences are scale- and dataset-dependent; benchmark
 ## representative inputs rather than relying on a fixed multiplier.
@@ -80,7 +80,7 @@ min_rt_tolerance_minutes = 0.5
 calibration_query_rt_window_minutes = 0.083333336   # 5 seconds (5 / 60)
 
 
-## Output directory (optional — `--output-uri` overrides this).
+## Output directory (optional -- `--output-uri` overrides this).
 # [output]
 # uri = "./results"
 
diff --git a/rust/timsseek_cli/examples/load_bench.rs b/rust/timsseek_cli/examples/load_bench.rs
index 0591f531..66fd5c98 100644
--- a/rust/timsseek_cli/examples/load_bench.rs
+++ b/rust/timsseek_cli/examples/load_bench.rs
@@ -16,8 +16,8 @@
 //!     ./target/release/examples/load_bench
 //!
 //! Env:
-//!   LOAD_BENCH_URI (required) — URI of the raw input to resolve+load.
-//!   RUST_LOG (optional)       — default "info,tims_stage=info,timscentroid=info".
+//!   LOAD_BENCH_URI (required) -- URI of the raw input to resolve+load.
+//!   RUST_LOG (optional)       -- default "info,tims_stage=info,timscentroid=info".
 
 use std::time::Instant;
 
diff --git a/rust/timsseek_cli/src/config.rs b/rust/timsseek_cli/src/config.rs
index 744c8293..782af5d7 100644
--- a/rust/timsseek_cli/src/config.rs
+++ b/rust/timsseek_cli/src/config.rs
@@ -188,10 +188,10 @@ rt = "Unrestricted"
 
     /// Template sanity guard. `default_config()` now *is* a parse of the
     /// embedded template, so a template-vs-literal comparison would be
-    /// tautological — but a malformed or silently-edited template would
+    /// tautological -- but a malformed or silently-edited template would
     /// otherwise only blow up at runtime.
     ///
-    /// No literal values are pinned here — those live in the template. The
+    /// No literal values are pinned here -- those live in the template. The
     /// `[calibration]` comparison is not a value check either: the template
     /// spells every calibration field out, so this is the only thing tying it
     /// to `CalibrationConfig::default()` (the `mz_sigma` 1.5→3.0 drift was
diff --git a/rust/timsseek_cli/src/main.rs b/rust/timsseek_cli/src/main.rs
index a0626050..d975567a 100644
--- a/rust/timsseek_cli/src/main.rs
+++ b/rust/timsseek_cli/src/main.rs
@@ -140,7 +140,7 @@ fn validate_inputs(
     }
     info!("✓ All {} raw input(s) validated", raw_inputs.len());
 
-    // Remote outputs skip the writability probe — the upload is the write test.
+    // Remote outputs skip the writability probe -- the upload is the write test.
     if !is_remote_uri(&output_uri) {
         let output_dir_path = std::path::Path::new(&output_uri);
 
@@ -174,7 +174,7 @@ fn validate_inputs(
     // Probe every artifact up-front so a collision fails before the heavy
     // analysis rather than after it.
     //
-    // IMPORTANT — the two artifact lists below must stay in sync with the
+    // IMPORTANT -- the two artifact lists below must stay in sync with the
     // writer sites (search for `ARTIFACT-LIST`):
     //   per-sample: processing.rs, main.rs overwrite-cleanup block
     //   run-level:  main.rs run report, OutputSink::finalize_run call site
@@ -284,14 +284,14 @@ fn sample_name_from_uri(uri: &str) -> Option<String> {
 fn get_frag_range_from_index(
     index: &IndexedTimstofPeaks,
 ) -> Result<TupleRange<f64>, errors::CliError> {
-    // `fragmented_range` panics only when there are no ms2 window groups —
+    // `fragmented_range` panics only when there are no ms2 window groups --
     // catch it and surface a readable "not a DIA run" error instead.
     let result =
         std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| index.fragmented_range()));
     match result {
         Ok(r) => Ok(r),
         Err(_) => Err(errors::CliError::DataReading {
-            source: "Index has no MS2 window groups — is this a DIA run?".to_string(),
+            source: "Index has no MS2 window groups -- is this a DIA run?".to_string(),
         }),
     }
 }
@@ -331,10 +331,10 @@ fn process_single_file(
     match index.mobility_kind() {
         timscentroid::MobilityKind::Ook0 => info!("Mobility axis: TIMS 1/K0 (searchable)"),
         timscentroid::MobilityKind::Absent => {
-            info!("Mobility axis: none — mobility filter + score features disabled")
+            info!("Mobility axis: none -- mobility filter + score features disabled")
         }
         timscentroid::MobilityKind::Unsupported(label) => info!(
-            "Mobility axis: unsupported [{label}] — mobility filter + score features disabled"
+            "Mobility axis: unsupported [{label}] -- mobility filter + score features disabled"
         ),
     }
     alloc_track::snap!("Loading index");
@@ -519,7 +519,7 @@ impl OutputSink {
 
 /// Load a Speclib from a local path or remote URI.
 ///
-/// Remote URIs are streamed (not buffered — speclibs can be multi-GB) to a
+/// Remote URIs are streamed (not buffered -- speclibs can be multi-GB) to a
 /// tempfile keeping the original basename, because `Speclib::from_file`
 /// sniffs the format by extension.
 fn speclib_from_uri(
@@ -977,7 +977,7 @@ fn run() -> std::result::Result<(), errors::CliError> {
                     file_start.elapsed(),
                     e
                 );
-                // I/O errors are likely systemic (disk full, permissions) —
+                // I/O errors are likely systemic (disk full, permissions) --
                 // abort the batch instead of failing every remaining file.
                 if matches!(e, errors::CliError::Io { .. }) {
                     run_report.status = timsseek::scoring::timings::RunStatus::Aborted;
diff --git a/rust/timsseek_cli/src/processing.rs b/rust/timsseek_cli/src/processing.rs
index 653ff54c..cdb4731a 100644
--- a/rust/timsseek_cli/src/processing.rs
+++ b/rust/timsseek_cli/src/processing.rs
@@ -100,12 +100,12 @@ mod calib_dash_hook {
         /// The dashboard compares calibrant identity across batches but never
         /// displays it, so it takes a hash of the arena handle rather than the
         /// id that handle resolves to. That keeps its point type `Copy` and,
-        /// more importantly, keeps `size_of` the true cost of a point — which is
+        /// more importantly, keeps `size_of` the true cost of a point -- which is
         /// what its replay memory budget is computed from. Only meaningful
         /// within one process.
         ///
         /// Concrete in `FlatIdx` rather than `impl Hash`, which would also
-        /// accept `score.to_bits()` — compiles, means nothing.
+        /// accept `score.to_bits()` -- compiles, means nothing.
         fn identity_hash(slot: FlatIdx) -> u64 {
             let mut hasher = DefaultHasher::new();
             slot.hash(&mut hasher);
@@ -114,7 +114,7 @@ mod calib_dash_hook {
 
         /// The dashboard for a whole run. Stays `None` inside unless
         /// `TIMSSEEK_CALIB_DASHBOARD` asks for it, so an ordinary run of a
-        /// dashboard-enabled binary allocates nothing — and neither does
+        /// dashboard-enabled binary allocates nothing -- and neither does
         /// anything else in this module that keys off it.
         pub struct Dash {
             inner: Option<calib_dash::CalibDash>,
@@ -275,7 +275,7 @@ fn check_rt_scale_compatibility(main_lib: &Speclib, calib_lib: &Speclib) {
     let (calib_min, calib_max) = rt_range(calib_lib);
 
     info!(
-        "RT ranges — main speclib: [{:.1}, {:.1}]s, calib lib: [{:.1}, {:.1}]s",
+        "RT ranges -- main speclib: [{:.1}, {:.1}]s, calib lib: [{:.1}, {:.1}]s",
         main_min, main_max, calib_min, calib_max
     );
 
@@ -308,7 +308,7 @@ fn check_rt_scale_compatibility(main_lib: &Speclib, calib_lib: &Speclib) {
         warn!("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
     } else if overlap_pct < 80.0 {
         warn!(
-            "RT overlap between main speclib and calib lib is {:.0}% — may affect calibration at the extremes",
+            "RT overlap between main speclib and calib lib is {:.0}% -- may affect calibration at the extremes",
             overlap_pct
         );
     }
@@ -567,7 +567,7 @@ pub fn execute_pipeline<I: ScorerQueriable>(
     let phase5_ms = step.finish().as_millis() as u64;
     alloc_track::snap!("Phase 5: Rescore");
 
-    // Collect q-value threshold counts — full report to log, key result to stdout
+    // Collect q-value threshold counts -- full report to log, key result to stdout
     let qval_report = report_qvalues_at_thresholds(&data, &[0.01, 0.05, 0.1, 0.5, 1.0]);
     let mut targets_at_1pct_qval = 0usize;
     let mut targets_at_5pct_qval = 0usize;
@@ -590,7 +590,7 @@ pub fn execute_pipeline<I: ScorerQueriable>(
     }
 
     // Built BEFORE Phase 6, because the writer below consumes `data`. So the
-    // precompute — including its ~1 GB feature matrix — runs while nothing is
+    // precompute -- including its ~1 GB feature matrix -- runs while nothing is
     // on disk yet; only the blocking TUI is after the write.
     #[cfg(feature = "dashboard")]
     let dashboard = crate::dashboard::build(&data, &feature_stats, &qval_report);
@@ -630,7 +630,7 @@ pub fn execute_pipeline<I: ScorerQueriable>(
         tracing::warn!("Failed to write feature_stats sidecar: {}", e);
     }
 
-    // After Phase 6, so a dashboard left open overnight — or killed — still has
+    // After Phase 6, so a dashboard left open overnight -- or killed -- still has
     // its results written.
     // No `snap!` around this: it blocks until the user quits, so any measurement
     // taken across it reports how long they looked at the screen.
@@ -642,7 +642,7 @@ pub fn execute_pipeline<I: ScorerQueriable>(
     }
 
     // Key result to stdout. The final output URI is printed by main.rs
-    // per-file footer — out_path_pq here is the local working path (which
+    // per-file footer -- out_path_pq here is the local working path (which
     // is a tempdir for remote destinations), not the eventual location.
     println!();
     println!("{} targets at 1% FDR", targets_at_1pct_qval);
@@ -802,7 +802,7 @@ fn calibrate_from_phase1<I: ScorerQueriable>(
         } else {
             0.0
         };
-        // Surface a collapsing cross-library match loudly — otherwise it silently
+        // Surface a collapsing cross-library match loudly -- otherwise it silently
         // becomes a ZeroRange grid -> identity fallback -> ~0 IDs, with no hint why.
         if matched < 2 || rate < 0.10 {
             warn!(
diff --git a/rust/timsseek_macros/src/lib.rs b/rust/timsseek_macros/src/lib.rs
index e0aa80b1..e4739919 100644
--- a/rust/timsseek_macros/src/lib.rs
+++ b/rust/timsseek_macros/src/lib.rs
@@ -1,4 +1,4 @@
-//! `#[derive(ScoreBlock)]` — projects a "score block" struct's fields into its
+//! `#[derive(ScoreBlock)]` -- projects a "score block" struct's fields into its
 //! Parquet surface (the `ScoreBlock` trait's `column_schema`/`columns`), the
 //! set-level ML feature-name walks (also on the trait), and the two ML feature
 //! *value* lanes, which are INHERENT `[f64; N]` methods sized by inherent
@@ -8,7 +8,7 @@
 //!
 //! The lane values are inherent, not trait methods, on purpose: `fn f(&self) ->
 //! [f64; Self::LEN]` in a trait needs unstable `generic_const_exprs`, while the
-//! same signature on a concrete type is stable — and inherent consts compose
+//! same signature on a concrete type is stable -- and inherent consts compose
 //! (`Fields::LINEAR_LEN = A::LINEAR_LEN + B::LINEAR_LEN`), which is what lets
 //! the whole feature matrix be a compile-time width.
 //!
@@ -162,7 +162,7 @@ impl Scalar {
         format_ident!("{name}")
     }
 
-    /// The scalar's own type, as tokens (e.g. `f32`) — used to reconstruct a
+    /// The scalar's own type, as tokens (e.g. `f32`) -- used to reconstruct a
     /// field's type for the generated `sample()`'s `BlockFixture` turbofish.
     fn type_tokens(self) -> TokenStream {
         match self {
@@ -193,7 +193,7 @@ enum FieldShape {
 }
 
 impl FieldShape {
-    /// The field's type, as tokens — `f32`/`f64`/... for a scalar,
+    /// The field's type, as tokens -- `f32`/`f64`/... for a scalar,
     /// `[f32; N]` for an array (reassembled from the parsed `len`).
     fn type_tokens(&self) -> TokenStream {
         match self {
@@ -297,7 +297,7 @@ enum FieldKind {
         feature: Option<(Vec<GeneratorSpec>, Lane)>,
     },
     /// `#[block]`: the field's own type is a `ScoreBlock`, so every walk
-    /// DELEGATES to it — widths sum its consts, lane arrays splice its arrays
+    /// DELEGATES to it -- widths sum its consts, lane arrays splice its arrays
     /// in, and the column/name walks call straight through.
     Block { ty: Type },
 }
@@ -390,8 +390,8 @@ fn collect_fields(input: &DeriveInput) -> Result<Vec<Field>> {
 }
 
 /// Emits the `SchemaSink`/`ColSink` calls shared by `column_schema` and
-/// `columns` (every field is a parquet column — or, for `#[block]`, a whole
-/// run of them — feature-routed or not).
+/// `columns` (every field is a parquet column -- or, for `#[block]`, a whole
+/// run of them -- feature-routed or not).
 fn schema_and_column_calls(fields: &[Field]) -> (Vec<TokenStream>, Vec<TokenStream>) {
     let mut schema_calls = Vec::with_capacity(fields.len());
     let mut column_calls = Vec::with_capacity(fields.len());
@@ -432,7 +432,7 @@ fn schema_and_column_calls(fields: &[Field]) -> (Vec<TokenStream>, Vec<TokenStre
 /// One feature lane's codegen: the width const's terms, the statements that
 /// fill the `[f64; LEN]` value array, and the set-level name pushes.
 struct LaneCode {
-    /// Summands of the lane's `LEN` const — `1usize` per scalar generator,
+    /// Summands of the lane's `LEN` const -- `1usize` per scalar generator,
     /// the array's own length expression (verbatim, so a const path like
     /// `NUM_MS2_IONS` stays a const path) per array generator, and the nested
     /// block's own `LEN` const per `#[block]` field.
@@ -494,7 +494,7 @@ fn lane_code(fields: &[Field], lane: Lane) -> Result<LaneCode> {
                     let value = generator.apply(scalar.to_f64_expr(ident));
                     // One name, computed once here, used by the name walk; the
                     // value walk is positional, so it cannot name anything
-                    // differently — there is nothing to name.
+                    // differently -- there is nothing to name.
                     let feat_name = format!("{name}{}", generator.name_suffix());
                     code.len_terms.push(quote! { 1usize });
                     code.fills.push(quote! {
@@ -561,7 +561,7 @@ fn lane_methods(code: &LaneCode, len_const: Ident, method: Ident) -> TokenStream
         }
     };
     quote! {
-        /// This lane's feature count — the sum of one per scalar generator and
+        /// This lane's feature count -- the sum of one per scalar generator and
         /// `N` per `[f32; N]` generator, so the lane's width is a compile-time
         /// constant that composes into the whole matrix's width.
         pub const #len_const: usize = 0usize #( + #len_terms )*;
@@ -603,7 +603,7 @@ fn sample_field_calls(fields: &[Field]) -> Vec<TokenStream> {
 /// (not `#[cfg(test)]`): it is reachable in a normal (non-test) build because
 /// `ScoringFields::sample` is used from another crate's test module
 /// (`timsseek_cli`), compiled against timsseek's normal build. Unit-testable
-/// without a proc-macro context — see `tests` below.
+/// without a proc-macro context -- see `tests` below.
 pub(crate) fn derive_score_block(input: DeriveInput) -> Result<TokenStream> {
     let fields = collect_fields(&input)?;
     let name = &input.ident;
@@ -677,7 +677,7 @@ pub(crate) fn derive_score_block(input: DeriveInput) -> Result<TokenStream> {
 /// `[f32; N]` (`N` may be any const expression; it is emitted verbatim). A
 /// field of any other type must be a `#[block]`.
 ///
-/// # `#[block]` — delegation
+/// # `#[block]` -- delegation
 ///
 /// A field marked `#[block]` is itself a `ScoreBlock`, and every walk
 /// DELEGATES to it rather than projecting the field: the width consts sum
@@ -689,8 +689,8 @@ pub(crate) fn derive_score_block(input: DeriveInput) -> Result<TokenStream> {
 /// with parquet column order and ML lane order both following the declaration
 /// order.
 ///
-/// A `#[block]` field is in BOTH lanes — which of its own features land in
-/// which lane is its own type's business — so `#[feat(...)]` on a `#[block]`
+/// A `#[block]` field is in BOTH lanes -- which of its own features land in
+/// which lane is its own type's business -- so `#[feat(...)]` on a `#[block]`
 /// field is rejected. Leaf, `#[block]`, and un-annotated fields may be freely
 /// mixed in one struct; each contributes its run of columns/features at its
 /// declaration position.
@@ -721,14 +721,14 @@ pub(crate) fn derive_score_block(input: DeriveInput) -> Result<TokenStream> {
 ///
 /// `linear = true` is the **default**: a plain `#[feat(raw)]` field goes to the
 /// LINEAR lane (the monotone-transform lane LDA reads). The LDA lane is
-/// therefore **opt-out**, not opt-in — write `linear = false` to route a field
+/// therefore **opt-out**, not opt-in -- write `linear = false` to route a field
 /// to the NONLINEAR lane instead (the tree/GBM lane, which needs no monotone
 /// transforms). A field is in exactly one lane; all of its generators go there
 /// together.
 ///
 /// ## Array fields
 ///
-/// `[f32; N]` fields accept only `raw` and `isna` — any other generator is a
+/// `[f32; N]` fields accept only `raw` and `isna` -- any other generator is a
 /// compile error pointing at the generator token. They fan out to one feature
 /// per element, `{field}_0 .. {field}_{N-1}` (and `{field}_{i}_isna` for
 /// `isna`), matching the `{field}_{i}` naming their Parquet columns already
@@ -738,8 +738,8 @@ pub(crate) fn derive_score_block(input: DeriveInput) -> Result<TokenStream> {
 ///
 /// Four `ScoreBlock` trait methods:
 ///
-/// - `column_schema(&mut SchemaSink)` — Parquet field dtypes/nullability
-/// - `columns(&self, &mut ColSink)` — Parquet values
+/// - `column_schema(&mut SchemaSink)` -- Parquet field dtypes/nullability
+/// - `columns(&self, &mut ColSink)` -- Parquet values
 /// - `linear_feature_names(&mut NameSink)` / `nonlinear_feature_names(&mut NameSink)`
 ///
 /// and, on an INHERENT impl, the lane value surface:
@@ -753,16 +753,16 @@ pub(crate) fn derive_score_block(input: DeriveInput) -> Result<TokenStream> {
 /// compile-time constant that composes: a set of blocks sums their consts to
 /// get the whole feature matrix's width, with no runtime length bookkeeping.
 ///
-/// The name walk stays dynamic (`NameSink`) — an array field's `{field}_{i}`
+/// The name walk stays dynamic (`NameSink`) -- an array field's `{field}_{i}`
 /// fan-out is a loop over a const *path*, which no macro can unroll.
 ///
 /// A lane's value array and its name walk are emitted from the same single
 /// pass over the field list, so entry `j` of the array is always the feature
-/// named `j` — they cannot desync.
+/// named `j` -- they cannot desync.
 ///
 /// Plus a public inherent `fn sample_default() -> Self` on the struct, filling
-/// every leaf field from `BlockFixture::fixture()` — a fixed, finite, non-zero
-/// constant per type — and every `#[block]` field from its own
+/// every leaf field from `BlockFixture::fixture()` -- a fixed, finite, non-zero
+/// constant per type -- and every `#[block]` field from its own
 /// `sample_default()`. It is deliberately not `#[cfg(test)]`; see
 /// `derive_score_block`.
 ///
@@ -780,7 +780,7 @@ pub(crate) fn derive_score_block(input: DeriveInput) -> Result<TokenStream> {
 ///     /// LINEAR lane, features `ion_err_0 .. ion_err_5`.
 ///     #[feat(raw)]
 ///     pub ion_err: [f32; 6],
-///     /// Parquet column only — no feature.
+///     /// Parquet column only -- no feature.
 ///     pub n_cycles: u32,
 /// }
 /// ```
@@ -937,7 +937,7 @@ mod tests {
     /// `#[block]` DELEGATION: a composed struct's widths are the sum of its
     /// blocks' own consts, its lane arrays splice the blocks' arrays in at a
     /// running cursor, and its column/name/fixture walks call straight
-    /// through — the six walks a composition of blocks needs, all off the one
+    /// through -- the six walks a composition of blocks needs, all off the one
     /// declaration order.
     #[test]
     fn block_fields_delegate_every_walk() {
@@ -950,7 +950,7 @@ mod tests {
         .unwrap();
         let ts = derive_score_block(di).unwrap().to_string();
         let f = flat(&ts);
-        // Widths SUM the blocks' own consts — no literal count.
+        // Widths SUM the blocks' own consts -- no literal count.
         assert!(
             f.contains("pubconstLINEAR_LEN:usize=0usize+<Identity>::LINEAR_LEN+<Rt>::LINEAR_LEN;"),
             "{ts}"
@@ -1027,7 +1027,7 @@ mod tests {
             )),
             "{ts}"
         );
-        // Name walk: same order — leaf name, delegated walk, leaf name.
+        // Name walk: same order -- leaf name, delegated walk, leaf name.
         assert!(
             f.contains(concat!(
                 r#"out.push("before");"#,
@@ -1079,8 +1079,8 @@ mod tests {
             ),
             "{ts}"
         );
-        // The `{field}_{i}` name fan-out stays a runtime loop — no macro can
-        // unroll a const path — but the format string itself is a literal.
+        // The `{field}_{i}` name fan-out stays a runtime loop -- no macro can
+        // unroll a const path -- but the format string itself is a literal.
         assert!(
             f.contains(r#"foriin0..NUM_MS2_IONS{out.push(&format!("arr_{i}"));}"#),
             "{ts}"
diff --git a/scripts/plot_spans.py b/scripts/plot_spans.py
index 49a7cb11..3d3083d4 100644
--- a/scripts/plot_spans.py
+++ b/scripts/plot_spans.py
@@ -105,7 +105,7 @@ def load_spans(path: Path) -> list[Span]:
             idle = parse_duration(str(fields.get("time.idle", "0ns")))
             label_fields = {k: v for k, v in span.items() if k != "name"}
             # `step{label=...}` and `file{name=...}` are the dominant spans
-            # — show only the field value, not the wrapper `step[label=x]`.
+            # -- show only the field value, not the wrapper `step[label=x]`.
             if name == "step" and "label" in label_fields:
                 label = str(label_fields["label"])
             elif name == "file" and "name" in label_fields:
@@ -142,7 +142,7 @@ def plot(spans: list[Span], out: Path, min_ms: float) -> None:
     if not kept:
         raise SystemExit(f"no spans >= {min_ms}ms; lower --min-ms")
 
-    # One lane per (thread, depth) — avoids vertical squish when depth is high.
+    # One lane per (thread, depth) -- avoids vertical squish when depth is high.
     lane_keys = sorted({(s.thread, s.depth) for s in kept})
     lane_idx = {k: i for i, k in enumerate(lane_keys)}
 
@@ -230,7 +230,7 @@ def main() -> None:
         "--min-ms",
         type=float,
         default=50.0,
-        help="hide spans shorter than this (default 50ms) — filters out bucket-sort noise",
+        help="hide spans shorter than this (default 50ms) -- filters out bucket-sort noise",
     )
     ap.add_argument("--wandb", metavar="RUN_NAME", default=None)
     ap.add_argument("--wandb-project", default="timsseek-spans")