diff --git a/Cargo.lock b/Cargo.lock
index 9716d6b3..727a0ac8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1117,9 +1117,9 @@ dependencies = [
 
 [[package]]
 name = "aws-lc-rs"
-version = "1.16.2"
+version = "1.18.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a054912289d18629dc78375ba2c3726a3afe3ff71b4edba9dedfca0e3446d1fc"
+checksum = "b281d307588d634de920874890732659e2e7672f72b5e10e81badc1a8a83621e"
 dependencies = [
  "aws-lc-sys",
  "zeroize",
@@ -1127,14 +1127,15 @@ dependencies = [
 
 [[package]]
 name = "aws-lc-sys"
-version = "0.39.1"
+version = "0.45.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83a25cf98105baa966497416dbd42565ce3a8cf8dbfd59803ec9ad46f3126399"
+checksum = "9bff6c3b54fad79a2e60b8102caf565819711497c1f5f092f49508e2f5c31b27"
 dependencies = [
  "cc",
  "cmake",
  "dunce",
  "fs_extra",
+ "pkg-config",
 ]
 
 [[package]]
@@ -4925,11 +4926,12 @@ checksum = "2195bf6aa996a481483b29d62a7663eed3fe39600c460e323f8ff41e90bdd89b"
 [[package]]
 name = "mzannotate"
 version = "0.2.0"
-source = "git+https://github.com/jspaezp/rustyms?rev=142c96ed1d31c56936c003af5f599d0c8f740005#142c96ed1d31c56936c003af5f599d0c8f740005"
+source = "git+https://github.com/jspaezp/rustyms?rev=c033092561166e1b9960fa2a6678299af52a94e1#c033092561166e1b9960fa2a6678299af52a94e1"
 dependencies = [
  "context_error",
  "indexmap",
- "itertools 0.14.0",
+ "itertools 0.13.0",
+ "memchr",
  "mzcore",
  "mzcv",
  "mzdata",
@@ -4944,12 +4946,12 @@ dependencies = [
 [[package]]
 name = "mzcore"
 version = "0.2.0"
-source = "git+https://github.com/jspaezp/rustyms?rev=142c96ed1d31c56936c003af5f599d0c8f740005#142c96ed1d31c56936c003af5f599d0c8f740005"
+source = "git+https://github.com/jspaezp/rustyms?rev=c033092561166e1b9960fa2a6678299af52a94e1#c033092561166e1b9960fa2a6678299af52a94e1"
 dependencies = [
  "bincode",
  "context_error",
  "flate2",
- "itertools 0.14.0",
+ "itertools 0.13.0",
  "mzcv",
  "ordered-float 5.3.0",
  "roxmltree",
@@ -4963,7 +4965,7 @@ dependencies = [
 [[package]]
 name = "mzcv"
 version = "0.3.0"
-source = "git+https://github.com/jspaezp/rustyms?rev=142c96ed1d31c56936c003af5f599d0c8f740005#142c96ed1d31c56936c003af5f599d0c8f740005"
+source = "git+https://github.com/jspaezp/rustyms?rev=c033092561166e1b9960fa2a6678299af52a94e1#c033092561166e1b9960fa2a6678299af52a94e1"
 dependencies = [
  "bincode",
  "chrono",
@@ -7026,9 +7028,9 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.23.37"
+version = "0.23.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "758025cb5fccfd3bc2fd74708fd4682be41d99e5dff73c377c0646c6012c73a4"
+checksum = "0d41d731c7d2f962d1ccc364cec258de3c0e93b38c2fb3ba97ac74513048d634"
 dependencies = [
  "aws-lc-rs",
  "once_cell",
@@ -7072,9 +7074,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.13"
+version = "0.103.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e"
+checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2"
 dependencies = [
  "aws-lc-rs",
  "ring",
@@ -8187,6 +8189,7 @@ dependencies = [
  "array2d",
  "arrow 59.2.0",
  "bon",
+ "calibrt",
  "csv",
  "flate2",
  "half",
diff --git a/Cargo.toml b/Cargo.toml
index 6d622b81..fcde6247 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -77,18 +77,12 @@ insta = { version = "1.34.0" }
 bon = "3.8.1"
 tinyvec = { features = ["alloc", "serde"], version = "1.10.0" }
 smallvec = { version = "1.13", features = ["const_generics", "union"] }
-# `mzannotate` carries the mzSpecLib reader. Two fixes are not in a release yet:
-# named attribute sets were never applied, so every decoy in a target/decoy
-# library read back as a target, and retention time was dropped for any spectrum
-# whose writer grouped other attributes with it. `mzcore` and `mzcv` come from
-# the same source so the graph holds one copy of each and the ontology types
-# unify.
-#
-# Pinned by revision, not by branch: a branch can be force-pushed or deleted.
-# All three become version numbers once the fixes ship.
-mzannotate = { git = "https://github.com/jspaezp/rustyms", rev = "142c96ed1d31c56936c003af5f599d0c8f740005" }
-mzcore = { git = "https://github.com/jspaezp/rustyms", rev = "142c96ed1d31c56936c003af5f599d0c8f740005" }
-mzcv = { git = "https://github.com/jspaezp/rustyms", rev = "142c96ed1d31c56936c003af5f599d0c8f740005" }
+# mzSpecLib record API preserves RT terms, grouped units and attribute-set
+# provenance before projection (jspaezp/rustyms PR #6). Keep all ontology crates
+# on the same reviewed revision so their types unify.
+mzannotate = { git = "https://github.com/jspaezp/rustyms", rev = "c033092561166e1b9960fa2a6678299af52a94e1" }
+mzcore = { git = "https://github.com/jspaezp/rustyms", rev = "c033092561166e1b9960fa2a6678299af52a94e1" }
+mzcv = { git = "https://github.com/jspaezp/rustyms", rev = "c033092561166e1b9960fa2a6678299af52a94e1" }
 csv = "1.3"
 
 tempfile = "3.23.0"
diff --git a/docs/development.md b/docs/development.md
index f8441048..a8b9168f 100644
--- a/docs/development.md
+++ b/docs/development.md
@@ -31,6 +31,41 @@ q-value columns (`result_mode=raw` Parquet metadata). It bypasses calibration,
 rescoring and q-value filtering. Supplied decoys do not by themselves validate a
 decoy strategy for a new analyte class.
 
+Library RT is declared once per library: seconds, normalized index, unspecified
+coordinates, or absent. Measured minutes convert to seconds; normalized indices
+retain their values, including zero and negative values. Declared normalized-scale
+metadata is preserved from mzSpecLib headers and prediction provenance; records
+select the actual axis. Mixed RT availability or
+axes are rejected. An RT-free library searches unrestricted on RT, omits RT
+prediction/residual features, and retains decoy competition, rescoring and q-values
+when decoys are available. RT, m/z and mobility calibrate independently. Without
+an RT fit, score-selected apexes still supply m/z and mobility measurements,
+without ridge filtering. RT-free prescoring retains bounded candidates across
+observed RT bands. Mobility calibration requires a searchable run axis; FAIMS and
+absent mobility do not contribute sentinel measurements. An axis without measurements keeps its configured tolerance
+in primary and secondary extraction. A failed RT fit never reinterprets an index
+as seconds; initial extraction searches unrestricted RT. Secondary queries still
+center on detected apex RT and observed mobility.
+
+Results format 5 includes `library_rt_axis` Parquet metadata. Unavailable library
+RT, calibrated RT and RT residuals are NaN; observed apex RT remains seconds.
+Calibration format v4 records the input library axis and effective tolerance
+enums; an empty RT snapshot means no RT fit, while residuals can still contain
+m/z and mobility calibration. Older calibration files
+must be regenerated. Explicit `rt_seconds` JSON/Python inputs remain seconds. JSON `rt_axis` is
+preserved whether optional precursor/fragment labels are supplied or filled in.
+Rust source geometry exposes `LibraryRT<f32>` through `Target` and `OwnedTarget`.
+`ExtractionQuery` borrows that geometry with a separately resolved acquisition
+window. `RtSelection::Centered(ObservedRTSeconds(...))` or `FullRun` resolves
+against the acquisition extent once. Collectors copy that window and reuse their
+geometry/intensity buffers; they retain no source borrow. Index queries accept
+`PeakTolerance` for m/z, mobility and quadrupole only. Isotope extraction shifts
+collector buffers directly, without an owned target or library-axis clone.
+The viewer searches full-run without an RT fit, including libraries measured in
+seconds. Direct-query CLI restricted RT inputs explicitly mean acquisition
+seconds; normalized library indices require calibration first. Python target
+`rt_seconds` likewise specifies an acquisition coordinate.
+
 `run_report.json` records the resolved `scoring_plan` once for the search library,
 plus `calibration_scoring_plan` when a separate calibration library is supplied.
 These are the same plans serialized in Parquet metadata: sequence-operation
@@ -49,7 +84,7 @@ intensities, so those reader routes remain extraction-only.
 Standalone `calib_dash` reads saved `calibration.json`, not a spectral library.
 
 [Analyte module documentation](../rust/timsquery/src/chemistry/analyte.rs) documents chemistry storage, reader mappings,
-library-wide sequence eligibility, and results format version 4.
+library-wide sequence eligibility, and results format version 5.
 
 Precursor isotope envelopes retain the three-bin C/S approximation. Scoring
 finalization includes known modification C/S deltas or an explicitly based
diff --git a/python/timsquery_pyo3/src/index.rs b/python/timsquery_pyo3/src/index.rs
index c53c4a03..5485be6d 100644
--- a/python/timsquery_pyo3/src/index.rs
+++ b/python/timsquery_pyo3/src/index.rs
@@ -7,7 +7,6 @@ use timsquery::traits::queriable_data::QueriableData;
 use timsquery::{
     ChromatogramCollector,
     MzMobilityStatsCollector,
-    OptionallyRestricted,
     SpectralCollector,
     Tolerance,
 };
@@ -21,28 +20,20 @@ use crate::spectrum::{
 use crate::target::PyTarget;
 use crate::tolerance::PyTolerance;
 
-/// Compute the RT range in milliseconds for a chromatogram query.
-///
-/// If the tolerance is restricted, returns the tolerance-derived range.
-/// If unrestricted, falls back to the full acquisition RT range from the
-/// cycle mapping (giving a chromatogram spanning the entire run).
-pub(crate) fn rt_range_ms_for_chromatogram(
+/// Python target `rt_seconds` is an explicit acquisition coordinate.
+pub(crate) fn resolve_query_rt(
     tol: &Tolerance,
     rt_seconds: f32,
     handle: &IndexedPeaksHandle,
-) -> PyResult<timsquery::TupleRange<u32>> {
-    match tol.rt_range_as_milis(rt_seconds) {
-        OptionallyRestricted::Restricted(range) => Ok(range),
-        OptionallyRestricted::Unrestricted => {
-            let (start, end) = handle.ms1_cycle_mapping().range_milis();
-            timsquery::TupleRange::try_new(start, end).map_err(|e| {
-                PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
-                    "Empty RT range in index: {:?}",
-                    e
-                ))
-            })
-        }
-    }
+) -> PyResult<timsquery::ResolvedRt> {
+    timsquery::ResolvedRt::from_mapping(
+        timsquery::RtSelection::Centered(timsquery::ObservedRTSeconds(rt_seconds)),
+        &tol.rt,
+        handle.ms1_cycle_mapping(),
+    )
+    .map_err(|e| {
+        PyErr::new::<pyo3::exceptions::PyValueError, _>(format!("Invalid query RT: {e:?}"))
+    })
 }
 
 /// Resolved tolerances: either one shared or one per query.
@@ -133,15 +124,18 @@ impl PyTimsIndex {
         target: &PyTarget,
         tolerance: &PyTolerance,
     ) -> PyResult<PyChromatogramResult> {
-        let target = target.inner.clone();
+        let target = &target.inner;
         let tol = &tolerance.inner;
-        let rt_range_ms = rt_range_ms_for_chromatogram(tol, target.rt_seconds(), &self.handle)?;
+        let resolved_rt = resolve_query_rt(tol, target.rt_seconds(), &self.handle)?;
         let ref_rt = self.handle.ms1_cycle_mapping();
 
-        let mut collector = ChromatogramCollector::<usize, f32>::new(&target, rt_range_ms, ref_rt)
-            .map_err(|e| PyErr::new::<pyo3::exceptions::PyValueError, _>(format!("{:?}", e)))?;
+        let mut collector = ChromatogramCollector::<usize, f32>::new(
+            &timsquery::ExtractionQuery::new(target, resolved_rt),
+            ref_rt,
+        )
+        .map_err(|e| PyErr::new::<pyo3::exceptions::PyValueError, _>(format!("{:?}", e)))?;
 
-        self.handle.add_query(&mut collector, tol);
+        self.handle.add_query(&mut collector, &tol.peak_tolerance());
 
         Ok(PyChromatogramResult::new(collector, target.id()))
     }
@@ -161,18 +155,22 @@ impl PyTimsIndex {
         target: &PyTarget,
         tolerance: &PyTolerance,
     ) -> PyResult<()> {
-        let target = target.inner.clone();
+        let target = &target.inner;
         let tol = &tolerance.inner;
-        let rt_range_ms = rt_range_ms_for_chromatogram(tol, target.rt_seconds(), &self.handle)?;
+        let resolved_rt = resolve_query_rt(tol, target.rt_seconds(), &self.handle)?;
         let ref_rt = self.handle.ms1_cycle_mapping();
 
         result
             .collector
-            .try_reset_with(&target, rt_range_ms, ref_rt)
+            .try_reset_with(
+                &timsquery::ExtractionQuery::new(target, resolved_rt),
+                ref_rt,
+            )
             .map_err(|e| PyErr::new::<pyo3::exceptions::PyValueError, _>(format!("{:?}", e)))?;
 
         result.source_id.set_from(target.id());
-        self.handle.add_query(&mut result.collector, tol);
+        self.handle
+            .add_query(&mut result.collector, &tol.peak_tolerance());
 
         Ok(())
     }
@@ -189,10 +187,13 @@ impl PyTimsIndex {
         target: &PyTarget,
         tolerance: &PyTolerance,
     ) -> PyResult<PySpectralResult> {
-        let target = target.inner.clone();
+        let target = &target.inner;
         let tol = &tolerance.inner;
-        let mut collector = SpectralCollector::<usize, f32>::new(&target);
-        self.handle.add_query(&mut collector, tol);
+        let mut collector = SpectralCollector::<usize, f32>::new(&timsquery::ExtractionQuery::new(
+            target,
+            resolve_query_rt(tol, target.rt_seconds(), &self.handle)?,
+        ));
+        self.handle.add_query(&mut collector, &tol.peak_tolerance());
         Ok(PySpectralResult::new(collector, target.id()))
     }
 
@@ -209,10 +210,15 @@ impl PyTimsIndex {
         target: &PyTarget,
         tolerance: &PyTolerance,
     ) -> PyResult<PyMzMobilityResult> {
-        let target = target.inner.clone();
+        let target = &target.inner;
         let tol = &tolerance.inner;
-        let mut collector = SpectralCollector::<usize, MzMobilityStatsCollector>::new(&target);
-        self.handle.add_query(&mut collector, tol);
+        let mut collector = SpectralCollector::<usize, MzMobilityStatsCollector>::new(
+            &timsquery::ExtractionQuery::new(
+                target,
+                resolve_query_rt(tol, target.rt_seconds(), &self.handle)?,
+            ),
+        );
+        self.handle.add_query(&mut collector, &tol.peak_tolerance());
         Ok(PyMzMobilityResult::new(collector, target.id()))
     }
 
@@ -239,13 +245,14 @@ impl PyTimsIndex {
             .iter()
             .enumerate()
             .map(|(i, target)| {
-                let inner = target.inner.clone();
+                let inner = &target.inner;
                 let tol = tolerances.get(i);
-                let rt_range_ms =
-                    rt_range_ms_for_chromatogram(tol, inner.rt_seconds(), &self.handle)?;
-                ChromatogramCollector::<usize, f32>::new(&inner, rt_range_ms, ref_rt).map_err(|e| {
-                    PyErr::new::<pyo3::exceptions::PyValueError, _>(format!("{:?}", e))
-                })
+                let resolved_rt = resolve_query_rt(tol, inner.rt_seconds(), &self.handle)?;
+                ChromatogramCollector::<usize, f32>::new(
+                    &timsquery::ExtractionQuery::new(inner, resolved_rt),
+                    ref_rt,
+                )
+                .map_err(|e| PyErr::new::<pyo3::exceptions::PyValueError, _>(format!("{:?}", e)))
             })
             .collect::<PyResult<Vec<_>>>()?;
 
@@ -253,10 +260,19 @@ impl PyTimsIndex {
         let handle = &*self.handle;
         py.detach(|| match &tolerances {
             ResolvedTolerances::Single(tol) => {
-                handle.par_add_query_multi(&mut collectors[..], rayon::iter::repeat_n(tol, n));
+                handle.par_add_query_multi(
+                    &mut collectors[..],
+                    rayon::iter::repeat_n(&tol.peak_tolerance(), n),
+                );
             }
             ResolvedTolerances::PerQuery(tols) => {
-                handle.par_add_query_multi(&mut collectors[..], &tols[..]);
+                handle.par_add_query_multi(
+                    &mut collectors[..],
+                    &tols
+                        .iter()
+                        .map(Tolerance::peak_tolerance)
+                        .collect::<Vec<_>>()[..],
+                );
             }
         });
 
diff --git a/python/timsquery_pyo3/src/iterator.rs b/python/timsquery_pyo3/src/iterator.rs
index 2a305ed5..efb69007 100644
--- a/python/timsquery_pyo3/src/iterator.rs
+++ b/python/timsquery_pyo3/src/iterator.rs
@@ -9,7 +9,7 @@ use timsquery::{
     Tolerance,
 };
 
-use crate::index::rt_range_ms_for_chromatogram;
+use crate::index::resolve_query_rt;
 use crate::numpy_utils::array2d_to_numpy;
 use crate::target::PyTarget;
 use crate::tolerance::PyTolerance;
@@ -34,7 +34,7 @@ pub struct PyChromatogramArrays {
     #[pyo3(get)]
     fragment_labels: Vec<(usize, f64)>,
     #[pyo3(get)]
-    rt_range_ms: (u32, u32),
+    resolved_rt: (u32, u32),
     #[pyo3(get)]
     num_cycles: usize,
 }
@@ -92,7 +92,7 @@ fn extract_arrays(
             .iter()
             .map(|(k, mz)| (*k, *mz))
             .collect(),
-        rt_range_ms: (rt.start(), rt.end()),
+        resolved_rt: (rt.start(), rt.end()),
         num_cycles: collector.num_cycles(),
     })
 }
@@ -104,7 +104,7 @@ pub struct PyChromatogramIterator {
     tol_source: ToleranceSource,
     target_source: Py<PyAny>,
     pool: Vec<ChromatogramCollector<usize, f32>>,
-    chunk_tolerances: Vec<Tolerance>,
+    chunk_tolerances: Vec<timsquery::PeakTolerance>,
     buffer: VecDeque<PyChromatogramArrays>,
     chunk_size: usize,
     exhausted: bool,
@@ -140,7 +140,7 @@ impl PyChromatogramIterator {
             match next_result {
                 Ok(obj) => {
                     let target_ref: PyRef<'_, PyTarget> = obj.extract(py)?;
-                    let target = target_ref.inner.clone();
+                    let target = &target_ref.inner;
 
                     let tol = match &self.tol_source {
                         ToleranceSource::Single(t) => t.clone(),
@@ -159,27 +159,29 @@ impl PyChromatogramIterator {
                         }
                     };
 
-                    let rt_range_ms =
-                        rt_range_ms_for_chromatogram(&tol, target.rt_seconds(), &self.handle)?;
+                    let resolved_rt = resolve_query_rt(&tol, target.rt_seconds(), &self.handle)?;
 
                     if i < self.pool.len() {
                         self.pool[i]
-                            .try_reset_with(&target, rt_range_ms, ref_rt)
+                            .try_reset_with(
+                                &timsquery::ExtractionQuery::new(target, resolved_rt),
+                                ref_rt,
+                            )
                             .map_err(|e| {
                                 PyErr::new::<pyo3::exceptions::PyValueError, _>(format!("{e:?}"))
                             })?;
                     } else {
-                        let collector =
-                            ChromatogramCollector::<usize, f32>::new(&target, rt_range_ms, ref_rt)
-                                .map_err(|e| {
-                                    PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
-                                        "{e:?}"
-                                    ))
-                                })?;
+                        let collector = ChromatogramCollector::<usize, f32>::new(
+                            &timsquery::ExtractionQuery::new(target, resolved_rt),
+                            ref_rt,
+                        )
+                        .map_err(|e| {
+                            PyErr::new::<pyo3::exceptions::PyValueError, _>(format!("{e:?}"))
+                        })?;
                         self.pool.push(collector);
                     }
                     source_ids.push(target.id().to_owned_id());
-                    self.chunk_tolerances.push(tol);
+                    self.chunk_tolerances.push(tol.peak_tolerance());
                     n_this_chunk += 1;
                 }
                 Err(err) if err.is_instance_of::<pyo3::exceptions::PyStopIteration>(py) => {
diff --git a/python/timsquery_pyo3/src/target.rs b/python/timsquery_pyo3/src/target.rs
index f785d9b4..327c3cff 100644
--- a/python/timsquery_pyo3/src/target.rs
+++ b/python/timsquery_pyo3/src/target.rs
@@ -1,5 +1,5 @@
 use pyo3::prelude::*;
-use timsquery::Target;
+use timsquery::OwnedTarget;
 use timsquery::tinyvec::tiny_vec;
 
 /// A query target consists of one precursor and its fragments.
@@ -11,7 +11,7 @@ use timsquery::tinyvec::tiny_vec;
 #[pyclass(skip_from_py_object)]
 #[derive(Debug, Clone)]
 pub struct PyTarget {
-    pub(crate) inner: Target<usize>,
+    pub(crate) inner: OwnedTarget<usize>,
 }
 
 #[pymethods]
@@ -22,7 +22,7 @@ impl PyTarget {
     ///     id: Numeric source ID for this target.
     ///     precursor_mz: Monoisotopic precursor m/z.
     ///     precursor_charge: Charge state.
-    ///     rt_seconds: Expected retention time in seconds.
+    ///     rt_seconds: Expected retention time on the queried acquisition, in seconds.
     ///     mobility: Expected ion mobility (1/K0).
     ///     fragment_mzs: List of fragment m/z values.
     ///     fragment_labels: List of integer labels (one per fragment, same length as fragment_mzs).
@@ -45,11 +45,11 @@ impl PyTarget {
         };
         let fragment_labels_tv = fragment_labels.into_iter().collect();
 
-        let target = Target::builder()
+        let target = OwnedTarget::builder()
             .id(id)
             .precursor(precursor_mz, precursor_charge)
             .mobility_ook0(mobility)
-            .rt_seconds(rt_seconds)
+            .rt_value(rt_seconds)
             .fragment_mzs(fragment_mzs)
             .fragment_labels(fragment_labels_tv)
             .precursor_labels(precursor_labels_tv)
@@ -75,8 +75,26 @@ impl PyTarget {
     }
 
     #[getter]
-    fn rt_seconds(&self) -> f32 {
-        self.inner.rt_seconds()
+    fn rt_seconds(&self) -> Option<f32> {
+        self.inner
+            .rt()
+            .filter(|rt| *rt.axis == timsquery::RtAxis::Seconds)
+            .map(|rt| rt.value.0)
+    }
+
+    #[getter]
+    fn library_rt(&self) -> Option<f32> {
+        self.inner.rt().map(|rt| rt.value.0)
+    }
+
+    #[getter]
+    fn rt_axis(&self) -> &'static str {
+        match self.inner.rt().map(|rt| rt.axis) {
+            None => "absent",
+            Some(timsquery::RtAxis::Seconds) => "seconds",
+            Some(timsquery::RtAxis::NormalizedIndex { .. }) => "normalized_index",
+            _ => "unspecified",
+        }
     }
 
     #[getter]
@@ -96,11 +114,12 @@ impl PyTarget {
 
     fn __repr__(&self) -> String {
         format!(
-            "Target(id={}, mz={:.4}, charge={}, rt={:.1}s, mob={:.3}, frags={}, precs={})",
+            "Target(id={}, mz={:.4}, charge={}, rt={:?} ({}), mob={:.3}, frags={}, precs={})",
             self.inner.id(),
             self.inner.precursor_mz(),
             self.inner.precursor_charge(),
-            self.inner.rt_seconds(),
+            self.library_rt(),
+            self.rt_axis(),
             self.inner.mobility_ook0(),
             self.inner.fragment_count(),
             self.inner.precursor_count(),
diff --git a/rust/apex_sim/src/sim.rs b/rust/apex_sim/src/sim.rs
index c9c07fdd..24a96f3a 100644
--- a/rust/apex_sim/src/sim.rs
+++ b/rust/apex_sim/src/sim.rs
@@ -341,13 +341,21 @@ pub fn build(params: &SimParams) -> SimData {
 
     let chromatograms = ChromatogramCollector::<String, f32> {
         mobility_ook0: 1.0,
-        rt_seconds: (map((realized_apex as usize).min(n - 1)) as f32) / 1000.0,
+        rt: timsquery::ResolvedRt::resolve(
+            timsquery::RtSelection::Centered(timsquery::ObservedRTSeconds(
+                (map((realized_apex as usize).min(n - 1)) as f32) / 1000.0,
+            )),
+            &timsquery::models::tolerance::RtTolerance::Unrestricted,
+            rt_range_ms
+                .map_elems(|ms| timsquery::ObservedRTSeconds(ms as f32 / 1000.0))
+                .unwrap(),
+        )
+        .unwrap(),
         precursor_mono_mz: dummy_mz,
         precursor_charge: 2,
         precursor_mz_limits: (dummy_mz - 1.0, dummy_mz + 1.0),
         precursors,
         fragments,
-        rt_range_ms,
         n_precursor_peaks_added: n_prec_peaks,
         n_fragment_peaks_added: n_frag_peaks,
         n_quad_windows_matched: 1,
diff --git a/rust/calib_dash/src/bin/calib_dash.rs b/rust/calib_dash/src/bin/calib_dash.rs
index 0fedce0a..00e96860 100644
--- a/rust/calib_dash/src/bin/calib_dash.rs
+++ b/rust/calib_dash/src/bin/calib_dash.rs
@@ -28,6 +28,10 @@ fn main() {
             std::process::exit(1);
         }
     };
+    if snapshot.points.is_empty() {
+        eprintln!("No RT fit in {}; no RT curve to replay.", path.display());
+        return;
+    }
     if let Err(e) = validate_snapshot(&snapshot) {
         eprintln!("invalid calibration snapshot in {}: {e}", path.display());
         std::process::exit(1);
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 3b96dd1e..dbceb77b 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,7 +2,7 @@
 source: rust/calib_dash/src/ui.rs
 expression: out
 ---
-    ┌ Fit -- observed RT (s) ↑ vs library RT (s) → ──────────────────────────────────────────── b0 ┐
+    ┌ Fit -- observed RT (s) ↑ vs library RT coordinate → ───────────────────────────────────── 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 38162e04..d9deb187 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,7 +2,7 @@
 source: rust/calib_dash/src/ui.rs
 expression: out
 ---
-    ┌ Fit -- observed RT (s) ↑ vs library RT (s) → ──────────────────────────────────────────── b0 ┐
+    ┌ Fit -- observed RT (s) ↑ vs library RT coordinate → ───────────────────────────────────── 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 045ae801..432e31e9 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,7 +2,7 @@
 source: rust/calib_dash/src/ui.rs
 expression: out
 ---
-    ┌ Fit -- observed RT (s) ↑ vs library RT (s) → ──────────────────────────────────────────── b0 ┐
+    ┌ Fit -- observed RT (s) ↑ vs library RT coordinate → ───────────────────────────────────── b0 ┐
     │ Showing: path -- O chosen, X greedy tail                                                     │
     │                                                                                              │
     │                                                                                        ▄▄▄▄▄▄│
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 205bf24e..93aea185 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
@@ -3,7 +3,7 @@ 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 ┐
+    ┌ Fit -- observed RT (s) ↑ vs library RT coordinate → ───────────────────────────────────── 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 48742401..fb117b1b 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,7 +3,7 @@ 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 ┐
+    ┌ Fit -- observed RT (s) ↑ vs library RT coordinate → ───────────────────────────────────── b0 ┐
     │ Showing: none -- density only                                                                │
     │                                                                                              │
     │                                                                                        ▄▄▄▄▄▄│
diff --git a/rust/calib_dash/src/ui.rs b/rust/calib_dash/src/ui.rs
index fc1abc14..797277c8 100644
--- a/rust/calib_dash/src/ui.rs
+++ b/rust/calib_dash/src/ui.rs
@@ -457,7 +457,7 @@ fn draw_heatmap(frame: &mut Frame, area: Rect, app: &App) {
         return;
     };
 
-    let title_left = " Fit -- observed RT (s) \u{2191} vs library RT (s) \u{2192} ";
+    let title_left = " Fit -- observed RT (s) \u{2191} vs library RT coordinate \u{2192} ";
     // `batch` only -- the active layer gets its own subtitle row below.
     let title_right = format!(" b{} ", app.batch());
     frame.render_widget(
diff --git a/rust/calibrt/src/lib.rs b/rust/calibrt/src/lib.rs
index 0c1faf98..0a323f7f 100644
--- a/rust/calibrt/src/lib.rs
+++ b/rust/calibrt/src/lib.rs
@@ -4,10 +4,16 @@
 
 pub mod grid;
 mod pathfinding;
+mod saved_calibration;
 pub mod types;
+pub use saved_calibration::{
+    CALIBRATION_FORMAT_VERSION,
+    SavedCalibration,
+};
 pub use types::{
     LibraryRT,
     ObservedRTSeconds,
+    RtAxis,
 };
 
 /// Minimum denominator for slope calculations to avoid division by zero.
@@ -229,119 +235,6 @@ pub struct CalibrationSnapshot {
     pub lookback: usize,
 }
 
-/// The only version [`SavedCalibration`] reads or writes. Named once so the
-/// 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.
-///
-/// `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
-/// carry a curve that disagrees with the points that produced it.
-///
-/// `R` is the residual block a writer measures beyond the curve. This crate does
-/// not interpret it; a reader that has no use for it can leave it opaque.
-#[derive(Debug, serde::Serialize, serde::Deserialize)]
-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
-    /// 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".
-    ///
-    /// The path is named because a bare `default` would demand `R: Default`.
-    #[serde(default = "Option::default")]
-    pub residuals: Option<R>,
-    pub n_scored: usize,
-}
-
-impl<R> SavedCalibration<R> {
-    /// Assemble a file record. The version is stamped here, not by callers.
-    pub fn new(
-        rt_range_seconds: [f64; 2],
-        calibration: CalibrationSnapshot,
-        rt_tolerance_minutes: f32,
-        residuals: Option<R>,
-        n_scored: usize,
-    ) -> Self {
-        Self {
-            version: CALIBRATION_FORMAT_VERSION.to_string(),
-            rt_range_seconds,
-            calibration,
-            rt_tolerance_minutes,
-            residuals,
-            n_scored,
-        }
-    }
-
-    /// Serialize to `path` in the layout [`Self::read`] expects.
-    pub fn write(&self, path: &std::path::Path) -> Result<(), String>
-    where
-        R: serde::Serialize,
-    {
-        let json = serde_json::to_string_pretty(self).map_err(|e| e.to_string())?;
-        std::fs::write(path, json).map_err(|e| e.to_string())
-    }
-
-    /// 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
-    /// file. `None` there means nothing verifies it, which also warns.
-    pub fn read(
-        path: &std::path::Path,
-        raw_rt_range: Option<[f64; 2]>,
-    ) -> Result<(Self, Option<String>), String>
-    where
-        R: serde::de::DeserializeOwned,
-    {
-        let json = std::fs::read_to_string(path).map_err(|e| e.to_string())?;
-        let saved: Self = serde_json::from_str(&json).map_err(|e| e.to_string())?;
-        if saved.version != CALIBRATION_FORMAT_VERSION {
-            return Err(format!(
-                "Unsupported calibration version: {} (expected {CALIBRATION_FORMAT_VERSION})",
-                saved.version
-            ));
-        }
-        let warning = saved.provenance_warning(raw_rt_range);
-        Ok((saved, warning))
-    }
-
-    /// Number of calibrant points the curve was fit on.
-    pub fn n_calibrants(&self) -> usize {
-        self.calibration.points.len()
-    }
-
-    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 \
-                 fit on this run"
-                    .to_string(),
-            );
-        };
-        let overlap_lo = self.rt_range_seconds[0].max(raw[0]);
-        let overlap_hi = self.rt_range_seconds[1].min(raw[1]);
-        let overlap = (overlap_hi - overlap_lo).max(0.0);
-        let span = self.rt_range_seconds[1] - self.rt_range_seconds[0];
-        if span <= 0.0 || overlap / span >= 0.5 {
-            return None;
-        }
-        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",
-            self.rt_range_seconds[0],
-            self.rt_range_seconds[1],
-            raw[0],
-            raw[1],
-            (overlap / span) * 100.0,
-        ))
-    }
-}
-
 /// Grid geometry, so a consumer can lay out [`CalibrationState::grid_cells`]
 /// without inferring it from the node coordinates (which is impossible for an
 /// empty or single-occupied grid).
diff --git a/rust/calibrt/src/saved_calibration.rs b/rust/calibrt/src/saved_calibration.rs
new file mode 100644
index 00000000..45a46ad6
--- /dev/null
+++ b/rust/calibrt/src/saved_calibration.rs
@@ -0,0 +1,202 @@
+//! Saved calibration format, version validation, and file I/O.
+use crate::{
+    CalibrationSnapshot,
+    RtAxis,
+};
+
+/// The only version [`SavedCalibration`] reads or writes. Named once so the
+/// writer and the reader's gate cannot disagree.
+pub const CALIBRATION_FORMAT_VERSION: &str = "v4";
+
+/// JSON v4 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
+/// carry a curve that disagrees with the points that produced it.
+///
+/// `R` is the residual block a writer measures beyond the curve. This crate does
+/// not interpret it; a reader that has no use for it can leave it opaque.
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+pub struct SavedCalibration<R = serde_json::Value> {
+    #[serde(deserialize_with = "deserialize_version")]
+    pub version: String,
+    pub rt_range_seconds: [f64; 2],
+    /// Input-axis descriptor supplied by the library consumer. The fitter maps
+    /// numerical library coordinates to observed seconds without interpreting units.
+    pub library_rt_axis: RtAxis,
+    pub calibration: CalibrationSnapshot,
+    /// 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".
+    ///
+    /// The path is named because a bare `default` would demand `R: Default`.
+    #[serde(default = "Option::default")]
+    pub residuals: Option<R>,
+    pub n_scored: usize,
+}
+
+impl<R> SavedCalibration<R> {
+    /// Assemble a file record. The version is stamped here, not by callers.
+    pub fn new(
+        rt_range_seconds: [f64; 2],
+        calibration: CalibrationSnapshot,
+        rt_tolerance_minutes: f32,
+        residuals: Option<R>,
+        n_scored: usize,
+    ) -> Self {
+        Self {
+            version: CALIBRATION_FORMAT_VERSION.to_string(),
+            library_rt_axis: RtAxis::Unspecified,
+            rt_range_seconds,
+            calibration,
+            rt_tolerance_minutes,
+            residuals,
+            n_scored,
+        }
+    }
+
+    pub fn with_library_rt_axis(mut self, axis: RtAxis) -> Self {
+        self.library_rt_axis = axis;
+        self
+    }
+
+    /// Serialize to `path` in the layout [`Self::read`] expects.
+    pub fn write(&self, path: &std::path::Path) -> Result<(), String>
+    where
+        R: serde::Serialize,
+    {
+        let json = serde_json::to_string_pretty(self).map_err(|e| e.to_string())?;
+        std::fs::write(path, json).map_err(|e| e.to_string())
+    }
+
+    /// 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
+    /// file. `None` there means nothing verifies it, which also warns.
+    pub fn read(
+        path: &std::path::Path,
+        raw_rt_range: Option<[f64; 2]>,
+    ) -> Result<(Self, Option<String>), String>
+    where
+        R: serde::de::DeserializeOwned,
+    {
+        let json = std::fs::read_to_string(path).map_err(|e| e.to_string())?;
+        let saved: Self = serde_json::from_str(&json).map_err(|e| e.to_string())?;
+        let warning = saved.provenance_warning(raw_rt_range);
+        Ok((saved, warning))
+    }
+
+    /// Number of calibrant points the curve was fit on.
+    pub fn n_calibrants(&self) -> usize {
+        self.calibration.points.len()
+    }
+
+    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 \
+                 fit on this run"
+                    .to_string(),
+            );
+        };
+        let overlap_lo = self.rt_range_seconds[0].max(raw[0]);
+        let overlap_hi = self.rt_range_seconds[1].min(raw[1]);
+        let overlap = (overlap_hi - overlap_lo).max(0.0);
+        let span = self.rt_range_seconds[1] - self.rt_range_seconds[0];
+        if span <= 0.0 || overlap / span >= 0.5 {
+            return None;
+        }
+        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",
+            self.rt_range_seconds[0],
+            self.rt_range_seconds[1],
+            raw[0],
+            raw[1],
+            (overlap / span) * 100.0,
+        ))
+    }
+}
+
+fn deserialize_version<'de, D: serde::Deserializer<'de>>(
+    deserializer: D,
+) -> Result<String, D::Error> {
+    let version = <String as serde::Deserialize>::deserialize(deserializer)?;
+    if version != CALIBRATION_FORMAT_VERSION {
+        return Err(serde::de::Error::custom(format!(
+            "Unsupported calibration version: {version} (expected {CALIBRATION_FORMAT_VERSION})"
+        )));
+    }
+    Ok(version)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn fixture() -> serde_json::Value {
+        serde_json::json!({
+            "version": "v4",
+            "rt_range_seconds": [0.0, 1200.0],
+            "library_rt_axis": {"kind": "normalized_index", "scale": "anchors"},
+            "calibration": {"points": [], "grid_size": 16, "lookback": 4},
+            "rt_tolerance_minutes": 1.25,
+            "n_scored": 0
+        })
+    }
+
+    #[test]
+    fn typed_axis_preserves_the_v4_wire_format() {
+        let json = fixture();
+        let saved: SavedCalibration = serde_json::from_value(json.clone()).unwrap();
+        assert_eq!(
+            saved.library_rt_axis,
+            RtAxis::NormalizedIndex {
+                scale: Some("anchors".into())
+            }
+        );
+        assert_eq!(
+            serde_json::to_value(saved).unwrap()["library_rt_axis"],
+            json["library_rt_axis"]
+        );
+    }
+
+    #[test]
+    fn malformed_axis_is_rejected_at_deserialization() {
+        for axis in [
+            serde_json::json!({"kind": "unknown"}),
+            serde_json::json!({"kind": "normalized_index", "scale": 42}),
+        ] {
+            let mut json = fixture();
+            json["library_rt_axis"] = axis;
+            assert!(serde_json::from_value::<SavedCalibration>(json).is_err());
+        }
+    }
+
+    #[test]
+    fn direct_deserialization_checks_version_even_without_v4_fields() {
+        for json in [
+            r#"{"version":"v3","rt_range_seconds":[0,1200]}"#,
+            r#"{"rt_range_seconds":[0,1200],"version":"v3"}"#,
+        ] {
+            let error = serde_json::from_str::<SavedCalibration>(json)
+                .unwrap_err()
+                .to_string();
+            assert!(
+                error.contains("Unsupported calibration version: v3 (expected v4)"),
+                "{error}"
+            );
+        }
+        let mut json = fixture();
+        json["version"] = serde_json::json!("v2");
+        assert!(
+            serde_json::from_value::<SavedCalibration>(json)
+                .unwrap_err()
+                .to_string()
+                .contains("Unsupported calibration version")
+        );
+    }
+}
diff --git a/rust/calibrt/src/types.rs b/rust/calibrt/src/types.rs
index 2e108417..4e81886a 100644
--- a/rust/calibrt/src/types.rs
+++ b/rust/calibrt/src/types.rs
@@ -4,13 +4,39 @@ use serde::{
 };
 use std::fmt;
 
+/// Coordinate domain of the library used to fit a calibration.
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(tag = "kind", rename_all = "snake_case")]
+pub enum RtAxis {
+    #[default]
+    Absent,
+    Seconds,
+    NormalizedIndex {
+        scale: Option<String>,
+    },
+    Unspecified,
+}
+
+impl std::fmt::Display for RtAxis {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Absent => f.write_str("no RT"),
+            Self::Seconds => f.write_str("s"),
+            Self::NormalizedIndex { scale: Some(scale) } => write!(f, "index ({scale})"),
+            Self::NormalizedIndex { scale: None } => f.write_str("index"),
+            Self::Unspecified => f.write_str("unspecified units"),
+        }
+    }
+}
+
 /// 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)]
 pub struct LibraryRT<T>(pub T);
 
-/// Observed retention time from raw instrument data, always in seconds.
+/// Retention time on an acquisition axis, always in seconds.
+/// May be a calibrated prediction, an explicit query center, or a measured apex.
 #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Serialize, Deserialize)]
 #[serde(transparent)]
 pub struct ObservedRTSeconds<T>(pub T);
diff --git a/rust/timsquery/Cargo.toml b/rust/timsquery/Cargo.toml
index fb241177..0329808f 100644
--- a/rust/timsquery/Cargo.toml
+++ b/rust/timsquery/Cargo.toml
@@ -8,6 +8,7 @@ license.workspace = true
 
 # Workspace member deps
 array2d = { path = "../array2d" }
+calibrt = { path = "../calibrt" }
 timscentroid = { path = "../timscentroid" }
 micromzpaf = { path = "../micromzpaf" }
 tims_stage = { path = "../tims_stage" }
diff --git a/rust/timsquery/src/chemistry/analyte.rs b/rust/timsquery/src/chemistry/analyte.rs
index 9a28697b..f581a4b7 100644
--- a/rust/timsquery/src/chemistry/analyte.rs
+++ b/rust/timsquery/src/chemistry/analyte.rs
@@ -55,7 +55,7 @@
 //! modification spellings therefore collapse. Incomparable entries remain separate;
 //! formula equality and labels do not establish chemical identity or competition.
 //!
-//! Results format version 4 resolves metadata from the library. `sequence` is nullable
+//! Results format version 5 resolves metadata from the library. `sequence` is nullable
 //! and canonically formatted; `entry_name`, `molecular_formula`, and `formula_basis`
 //! are nullable columns. Unformattable properties produce null. The viewer's Analyte
 //! column displays sequence or formula. `Analyte` serialization preserves property
@@ -871,7 +871,7 @@ mod tests {
         TargetCapabilities,
         TargetColumnsBuilder,
     };
-    use crate::traits::QueryGeom;
+    use crate::traits::Target;
 
     #[test]
     fn geometry_and_formula_rows_need_no_peptide() {
diff --git a/rust/timsquery/src/errors.rs b/rust/timsquery/src/errors.rs
index a28a876f..65861e6d 100644
--- a/rust/timsquery/src/errors.rs
+++ b/rust/timsquery/src/errors.rs
@@ -86,6 +86,7 @@ impl Display for UnsupportedDataError {
 
 #[derive(Debug)]
 pub enum DataProcessingError {
+    InvalidRtQuery,
     ExpectedVectorLength { real: usize, expected: usize },
     ExpectedNonEmptyData,
     InsufficientData { real: usize, expected: usize },
diff --git a/rust/timsquery/src/lib.rs b/rust/timsquery/src/lib.rs
index 96023678..747ae7d5 100644
--- a/rust/timsquery/src/lib.rs
+++ b/rust/timsquery/src/lib.rs
@@ -17,7 +17,7 @@ pub use crate::models::base::{
     MzMajorIntensityArray,
     RTMajorIntensityArray,
 };
-pub use crate::models::target::Target;
+pub use crate::models::target::OwnedTarget;
 
 // Re-export traits
 pub use crate::models::PeakAddable;
@@ -71,3 +71,20 @@ pub use crate::serde::index_serde::{
     LoadIndexError,
     load_index,
 };
+
+pub use crate::models::retention_time::{
+    RtAxis,
+    RtCoordinate,
+};
+pub use crate::traits::Target;
+
+pub use calibrt::{
+    LibraryRT,
+    ObservedRTSeconds,
+};
+pub use models::extraction_query::{
+    ExtractionQuery,
+    ResolvedRt,
+    RtSelection,
+};
+pub use models::tolerance::PeakTolerance;
diff --git a/rust/timsquery/src/models/aggregators/chromatogram_agg.rs b/rust/timsquery/src/models/aggregators/chromatogram_agg.rs
index 948bbc68..97c12841 100644
--- a/rust/timsquery/src/models/aggregators/chromatogram_agg.rs
+++ b/rust/timsquery/src/models/aggregators/chromatogram_agg.rs
@@ -1,3 +1,7 @@
+use crate::{
+    ExtractionQuery,
+    ResolvedRt,
+};
 use serde::Serialize;
 
 use crate::errors::DataProcessingError;
@@ -6,7 +10,7 @@ use crate::models::base::{
     Chromatogram,
     MzMajorIntensityArray,
 };
-use crate::traits::QueryGeom;
+use crate::traits::Target;
 use crate::traits::queriable_data::HasQueryData;
 use crate::{
     KeyLike,
@@ -27,7 +31,7 @@ use timscentroid::utils::TupleRange;
 pub struct ChromatogramCollector<T: KeyLike, V: ArrayElement + ValueLike> {
     // Query scalars carried from the eg at reset time.
     pub mobility_ook0: f32,
-    pub rt_seconds: f32,
+    pub rt: ResolvedRt,
     pub precursor_mono_mz: f64,
     pub precursor_charge: u8,
     /// Cached from `Target::precursor_mz_limits()` at reset
@@ -38,7 +42,6 @@ pub struct ChromatogramCollector<T: KeyLike, V: ArrayElement + ValueLike> {
     // 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
@@ -63,10 +66,11 @@ pub struct ChromatogramCollector<T: KeyLike, V: ArrayElement + ValueLike> {
 
 impl<T: KeyLike, V: ValueLike + ArrayElement> ChromatogramCollector<T, V> {
     pub fn new(
-        eg: &impl QueryGeom<Label = T>,
-        rt_range_ms: TupleRange<u32>,
+        query: &ExtractionQuery<'_, impl Target<Label = T>>,
         ref_rt_ms: &CycleToRTMapping<MS1CycleIndex>,
     ) -> Result<Self, DataProcessingError> {
+        let eg = query.source();
+        let rt_range_ms = query.rt().range_millis();
         let start = ref_rt_ms.ms_to_closest_index(rt_range_ms.start());
         let end = ref_rt_ms.ms_to_closest_index(rt_range_ms.end());
         let num_cycles = end.index() - start.index() + 1;
@@ -89,14 +93,13 @@ impl<T: KeyLike, V: ValueLike + ArrayElement> ChromatogramCollector<T, V> {
         let fragments =
             MzMajorIntensityArray::try_new_empty(fragment_order, num_cycles, start.index())?;
         Ok(Self {
-            mobility_ook0: eg.mobility_ook0(),
-            rt_seconds: eg.rt_seconds(),
+            mobility_ook0: query.mobility_center(),
+            rt: query.rt(),
             precursor_mono_mz: eg.mono_precursor_mz(),
             precursor_charge: eg.precursor_charge(),
             precursor_mz_limits: eg.precursor_mz_limits(),
             precursors,
             fragments,
-            rt_range_ms,
             n_precursor_peaks_added: 0,
             n_fragment_peaks_added: 0,
             n_quad_windows_matched: 0,
@@ -105,24 +108,11 @@ impl<T: KeyLike, V: ValueLike + ArrayElement> ChromatogramCollector<T, V> {
 
     pub fn try_reset_with(
         &mut self,
-        eg: &impl QueryGeom<Label = T>,
-        rt_range_ms: TupleRange<u32>,
-        ref_rt_ms: &CycleToRTMapping<MS1CycleIndex>,
-    ) -> Result<(), DataProcessingError> {
-        self.try_reset_with_overrides(eg, None, None, rt_range_ms, ref_rt_ms)
-    }
-
-    /// Like `try_reset_with` but lets callers override `rt_seconds` / `mobility_ook0`
-    /// 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,
-        eg: &impl QueryGeom<Label = T>,
-        rt_override: Option<f32>,
-        mobility_override: Option<f32>,
-        rt_range_ms: TupleRange<u32>,
+        query: &ExtractionQuery<'_, impl Target<Label = T>>,
         ref_rt_ms: &CycleToRTMapping<MS1CycleIndex>,
     ) -> Result<(), DataProcessingError> {
+        let eg = query.source();
+        let rt_range_ms = query.rt().range_millis();
         let start = ref_rt_ms.ms_to_closest_index(rt_range_ms.start());
         let end = ref_rt_ms.ms_to_closest_index(rt_range_ms.end());
         let num_cycles = end.index() - start.index() + 1;
@@ -134,12 +124,11 @@ impl<T: KeyLike, V: ValueLike + ArrayElement> ChromatogramCollector<T, V> {
             return Err(DataProcessingError::ExpectedNonEmptyData);
         }
 
-        self.mobility_ook0 = mobility_override.unwrap_or_else(|| eg.mobility_ook0());
-        self.rt_seconds = rt_override.unwrap_or_else(|| eg.rt_seconds());
+        self.mobility_ook0 = query.mobility_center();
+        self.rt = query.rt();
         self.precursor_mono_mz = eg.mono_precursor_mz();
         self.precursor_charge = eg.precursor_charge();
         self.precursor_mz_limits = eg.precursor_mz_limits();
-        self.rt_range_ms = rt_range_ms;
         self.n_precursor_peaks_added = 0;
         self.n_fragment_peaks_added = 0;
         self.n_quad_windows_matched = 0;
@@ -164,7 +153,7 @@ impl<T: KeyLike, V: ValueLike + ArrayElement> ChromatogramCollector<T, V> {
     }
 
     pub fn rt_range_milis(&self) -> TupleRange<u32> {
-        self.rt_range_ms
+        self.rt.range_millis()
     }
 
     /// Filter ions using a predicate closure.
@@ -224,8 +213,8 @@ impl<T: KeyLike, V: ArrayElement + ValueLike> HasQueryData<T> for ChromatogramCo
         self.mobility_ook0
     }
 
-    fn rt_seconds(&self) -> f32 {
-        self.rt_seconds
+    fn rt(&self) -> ResolvedRt {
+        self.rt
     }
 
     fn iter_precursors(&self) -> impl Iterator<Item = (i8, f64)> + '_ {
@@ -243,15 +232,15 @@ impl<T: KeyLike, V: ArrayElement + ValueLike> HasQueryData<T> for ChromatogramCo
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::Target;
+    use crate::OwnedTarget;
     use tinyvec::tiny_vec;
 
     #[test]
     fn test_filter_ions_with_custom_predicate() {
-        let eg = Target::builder()
+        let eg = OwnedTarget::builder()
             .id(1)
             .mobility_ook0(0.8)
-            .rt_seconds(100.0)
+            .rt_value(100.0)
             .precursor(400.0, 1u8)
             .precursor_labels(tiny_vec!(0))
             .fragment_mzs(vec![600.0, 700.0, 800.0])
@@ -261,8 +250,19 @@ mod tests {
 
         let rt_ms = CycleToRTMapping::new(vec![10, 20]);
         let mut collector = ChromatogramCollector::<usize, f32>::new(
-            &eg,
-            TupleRange::try_new(9, 20).unwrap(),
+            &crate::ExtractionQuery::new(
+                &eg,
+                crate::ResolvedRt::resolve(
+                    crate::RtSelection::FullRun,
+                    &crate::models::tolerance::RtTolerance::Unrestricted,
+                    TupleRange::try_new(
+                        crate::ObservedRTSeconds(0.009),
+                        crate::ObservedRTSeconds(0.020),
+                    )
+                    .unwrap(),
+                )
+                .unwrap(),
+            ),
             &rt_ms,
         )
         .unwrap();
diff --git a/rust/timsquery/src/models/aggregators/point_agg.rs b/rust/timsquery/src/models/aggregators/point_agg.rs
index 17caac9f..9245d06b 100644
--- a/rust/timsquery/src/models/aggregators/point_agg.rs
+++ b/rust/timsquery/src/models/aggregators/point_agg.rs
@@ -1,18 +1,30 @@
-use crate::KeyLike;
-use crate::models::target::Target;
-use crate::traits::QueryGeom;
+use crate::models::target::OwnedTarget;
+use crate::traits::Target;
 use crate::traits::queriable_data::HasQueryData;
+use crate::{
+    ExtractionQuery,
+    KeyLike,
+    ResolvedRt,
+};
 use serde::Serialize;
 use std::sync::Arc;
 use tinyvec::TinyVec;
 
 const POINT_INLINE_CAP: usize = 13;
 
+fn serialize_rt_center<S: serde::Serializer>(
+    rt: &ResolvedRt,
+    serializer: S,
+) -> Result<S::Ok, S::Error> {
+    rt.center().map_or(f32::NAN, |r| r.0).serialize(serializer)
+}
+
 #[derive(Debug, Clone, Serialize)]
 pub struct PointIntensityAggregator<T: KeyLike> {
     pub id: crate::models::OwnedSourceId,
     pub mobility_ook0: f32,
-    pub rt_seconds: f32,
+    #[serde(rename = "rt_seconds", serialize_with = "serialize_rt_center")]
+    pub rt: ResolvedRt,
     pub precursor_mono_mz: f64,
     pub precursor_charge: u8,
     pub precursor_mz_limits: (f64, f64),
@@ -24,11 +36,8 @@ pub struct PointIntensityAggregator<T: KeyLike> {
 }
 
 impl<T: KeyLike> PointIntensityAggregator<T> {
-    pub fn new_with_elution_group(elution_group: Arc<Target<T>>) -> Self {
-        Self::new(elution_group.as_ref())
-    }
-
-    pub fn new(eg: &impl QueryGeom<Label = T>) -> Self {
+    pub fn new(query: &ExtractionQuery<'_, impl Target<Label = T>>) -> Self {
+        let eg = query.source();
         let mut precursor_labels = TinyVec::new();
         let mut precursor_mzs = TinyVec::new();
         for (lbl, mz) in eg.iter_precursors() {
@@ -43,8 +52,8 @@ impl<T: KeyLike> PointIntensityAggregator<T> {
         }
         Self {
             id: eg.output_id().to_owned_id(),
-            mobility_ook0: eg.mobility_ook0(),
-            rt_seconds: eg.rt_seconds(),
+            mobility_ook0: query.mobility_center(),
+            rt: query.rt(),
             precursor_mono_mz: eg.mono_precursor_mz(),
             precursor_charge: eg.precursor_charge(),
             precursor_mz_limits: eg.precursor_mz_limits(),
@@ -66,8 +75,8 @@ impl<T: KeyLike> HasQueryData<T> for PointIntensityAggregator<T> {
         self.mobility_ook0
     }
 
-    fn rt_seconds(&self) -> f32 {
-        self.rt_seconds
+    fn rt(&self) -> ResolvedRt {
+        self.rt
     }
 
     fn iter_precursors(&self) -> impl Iterator<Item = (i8, f64)> + '_ {
@@ -89,12 +98,12 @@ impl<T: KeyLike> HasQueryData<T> for PointIntensityAggregator<T> {
 
 #[derive(Debug, Clone)]
 pub struct RawPeakVectorAggregator<T: KeyLike> {
-    pub query: Arc<Target<T>>,
+    pub query: Arc<OwnedTarget<T>>,
     pub peaks: RawPeakVectorArrays,
 }
 
 impl<T: KeyLike> RawPeakVectorAggregator<T> {
-    pub fn new_with_elution_group(elution_group: Arc<Target<T>>) -> Self {
+    pub fn new_with_elution_group(elution_group: Arc<OwnedTarget<T>>) -> Self {
         Self {
             query: elution_group,
             peaks: RawPeakVectorArrays::new(),
diff --git a/rust/timsquery/src/models/aggregators/spectrum_agg.rs b/rust/timsquery/src/models/aggregators/spectrum_agg.rs
index 3e3a5e79..2547c7cb 100644
--- a/rust/timsquery/src/models/aggregators/spectrum_agg.rs
+++ b/rust/timsquery/src/models/aggregators/spectrum_agg.rs
@@ -1,10 +1,14 @@
+use crate::{
+    ExtractionQuery,
+    ResolvedRt,
+};
 use serde::Serialize;
 use serde::ser::SerializeStruct;
 use timscentroid::indexing::IndexedPeak;
 use timscentroid::rt_mapping::RTIndex;
 use tinyvec::TinyVec;
 
-use crate::traits::QueryGeom;
+use crate::traits::Target;
 use crate::traits::queriable_data::{
     HasQueryData,
     PeakAddable,
@@ -34,7 +38,7 @@ const SPEC_INLINE_CAP: usize = 13;
 pub struct SpectralCollector<T: KeyLike, V: Default + ValueLike> {
     // Query scalars carried from eg at construction / reset.
     pub mobility_ook0: f32,
-    pub rt_seconds: f32,
+    pub rt: ResolvedRt,
     pub precursor_mono_mz: f64,
     pub precursor_charge: u8,
     /// Cached from `Target::precursor_mz_limits()` -- skips
@@ -50,10 +54,10 @@ 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 {
+    pub fn new(query: &ExtractionQuery<'_, impl Target<Label = T>>) -> Self {
         let mut out = Self {
             mobility_ook0: 0.0,
-            rt_seconds: 0.0,
+            rt: query.rt(),
             precursor_mono_mz: 0.0,
             precursor_charge: 0,
             precursor_mz_limits: (0.0, 0.0),
@@ -64,24 +68,14 @@ impl<T: KeyLike, V: ValueLike + Default> SpectralCollector<T, V> {
             precursors: Vec::new(),
             fragments: Vec::new(),
         };
-        out.reset_with_overrides(eg, None, None);
+        out.reset_with(query);
         out
     }
 
-    pub fn reset_with(&mut self, eg: &impl QueryGeom<Label = T>) {
-        self.reset_with_overrides(eg, None, None);
-    }
-
-    /// 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,
-        eg: &impl QueryGeom<Label = T>,
-        rt_override: Option<f32>,
-        mobility_override: Option<f32>,
-    ) {
-        self.mobility_ook0 = mobility_override.unwrap_or_else(|| eg.mobility_ook0());
-        self.rt_seconds = rt_override.unwrap_or_else(|| eg.rt_seconds());
+    pub fn reset_with(&mut self, query: &ExtractionQuery<'_, impl Target<Label = T>>) {
+        let eg = query.source();
+        self.mobility_ook0 = query.mobility_center();
+        self.rt = query.rt();
         self.precursor_mono_mz = eg.mono_precursor_mz();
         self.precursor_charge = eg.precursor_charge();
         self.precursor_mz_limits = eg.precursor_mz_limits();
@@ -149,8 +143,8 @@ impl<T: KeyLike, V: Default + ValueLike> HasQueryData<T> for SpectralCollector<T
         self.mobility_ook0
     }
 
-    fn rt_seconds(&self) -> f32 {
-        self.rt_seconds
+    fn rt(&self) -> ResolvedRt {
+        self.rt
     }
 
     fn iter_precursors(&self) -> impl Iterator<Item = (i8, f64)> + '_ {
diff --git a/rust/timsquery/src/models/extraction_query.rs b/rust/timsquery/src/models/extraction_query.rs
new file mode 100644
index 00000000..6625b661
--- /dev/null
+++ b/rust/timsquery/src/models/extraction_query.rs
@@ -0,0 +1,259 @@
+//! Library coordinates never become acquisition coordinates implicitly.
+use crate::models::tolerance::RtTolerance;
+use crate::{
+    ObservedRTSeconds,
+    Target,
+    TupleRange,
+};
+use serde::Serialize;
+
+/// The caller must establish acquisition provenance before centering a query.
+///
+/// ```compile_fail
+/// use timsquery::{LibraryRT, RtSelection};
+/// let source_seconds = LibraryRT(120.0f32);
+/// let selection = RtSelection::Centered(source_seconds);
+/// ```
+#[derive(Debug, Clone, Copy)]
+pub enum RtSelection {
+    FullRun,
+    Centered(ObservedRTSeconds<f32>),
+}
+
+#[derive(Debug, Clone, Copy, Serialize)]
+pub struct ResolvedRt {
+    center: Option<ObservedRTSeconds<f32>>,
+    bounds: TupleRange<ObservedRTSeconds<f32>>,
+}
+
+impl ResolvedRt {
+    pub fn resolve(
+        selection: RtSelection,
+        tolerance: &RtTolerance,
+        acquisition: TupleRange<ObservedRTSeconds<f32>>,
+    ) -> Result<Self, crate::DataProcessingError> {
+        let invalid = || crate::DataProcessingError::InvalidRtQuery;
+        let (start, end) = (acquisition.start().0, acquisition.end().0);
+        if !start.is_finite() || !end.is_finite() || start < 0.0 || end < start {
+            return Err(invalid());
+        }
+        let RtSelection::Centered(center) = selection else {
+            return Ok(Self {
+                center: None,
+                bounds: acquisition,
+            });
+        };
+        if !center.0.is_finite() || center.0 < 0.0 {
+            return Err(invalid());
+        }
+        // Preserve the configured tolerance's minute-domain arithmetic before
+        // converting the resolved bounds to acquisition seconds.
+        let center_minutes = center.0 / 60.0;
+        let (left, right) = match tolerance {
+            RtTolerance::Unrestricted => {
+                return Ok(Self {
+                    center: Some(center),
+                    bounds: acquisition,
+                });
+            }
+            RtTolerance::Minutes((lo, hi)) => (*lo, *hi),
+            RtTolerance::Pct((lo, hi)) => {
+                (center_minutes * lo / 100.0, center_minutes * hi / 100.0)
+            }
+        };
+        if !left.is_finite() || !right.is_finite() || left < 0.0 || right < 0.0 {
+            return Err(invalid());
+        }
+        let lo = ((center_minutes - left) * 60.0).max(start);
+        let hi = ((center_minutes + right) * 60.0).min(end);
+        if lo > hi {
+            return Err(invalid());
+        }
+        Ok(Self {
+            center: Some(center),
+            bounds: TupleRange::try_new(ObservedRTSeconds(lo), ObservedRTSeconds(hi))
+                .map_err(|_| invalid())?,
+        })
+    }
+
+    pub fn from_mapping(
+        selection: RtSelection,
+        tolerance: &RtTolerance,
+        mapping: &timscentroid::rt_mapping::CycleToRTMapping<
+            timscentroid::rt_mapping::MS1CycleIndex,
+        >,
+    ) -> Result<Self, crate::DataProcessingError> {
+        let (lo, hi) = mapping.range_milis();
+        Self::resolve(
+            selection,
+            tolerance,
+            TupleRange::try_new(
+                ObservedRTSeconds(lo as f32 / 1000.0),
+                ObservedRTSeconds(hi as f32 / 1000.0),
+            )
+            .map_err(|_| crate::DataProcessingError::InvalidRtQuery)?,
+        )
+    }
+
+    /// Reporting/prediction metadata; filtering uses `bounds` only.
+    pub fn center(&self) -> Option<ObservedRTSeconds<f32>> {
+        self.center
+    }
+
+    pub fn bounds(&self) -> TupleRange<ObservedRTSeconds<f32>> {
+        self.bounds
+    }
+
+    pub fn range_millis(&self) -> TupleRange<u32> {
+        self.bounds
+            .map_elems(|s| (s.0 * 1000.0) as u32)
+            .expect("validated RT bounds")
+    }
+}
+
+/// Borrows source geometry only during collector construction or reset.
+/// Does not implement `Target`: source RT remains a library coordinate.
+pub struct ExtractionQuery<'q, T: Target + ?Sized> {
+    source: &'q T,
+    rt: ResolvedRt,
+    mobility_center: f32,
+}
+
+impl<'q, T: Target + ?Sized> ExtractionQuery<'q, T> {
+    pub fn new(source: &'q T, rt: ResolvedRt) -> Self {
+        Self {
+            source,
+            rt,
+            mobility_center: source.mobility_ook0(),
+        }
+    }
+
+    pub fn source(&self) -> &'q T {
+        self.source
+    }
+
+    pub fn rt(&self) -> ResolvedRt {
+        self.rt
+    }
+
+    pub fn mobility_center(&self) -> f32 {
+        self.mobility_center
+    }
+
+    pub fn with_mobility(mut self, mobility: f32) -> Self {
+        self.mobility_center = mobility;
+        self
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn acquisition() -> TupleRange<ObservedRTSeconds<f32>> {
+        TupleRange::try_new(ObservedRTSeconds(10.0), ObservedRTSeconds(200.0)).unwrap()
+    }
+
+    #[test]
+    fn resolves_and_clips_once_on_acquisition_axis() {
+        let rt = ResolvedRt::resolve(
+            RtSelection::Centered(ObservedRTSeconds(20.0)),
+            &RtTolerance::Minutes((0.5, 0.5)),
+            acquisition(),
+        )
+        .unwrap();
+        assert_eq!(rt.center(), Some(ObservedRTSeconds(20.0)));
+        assert_eq!(
+            rt.range_millis(),
+            TupleRange::try_new(10_000, 50_000).unwrap()
+        );
+        let full = ResolvedRt::resolve(
+            RtSelection::FullRun,
+            &RtTolerance::Minutes((0.01, 0.01)),
+            acquisition(),
+        )
+        .unwrap();
+        assert_eq!(full.center(), None);
+        assert_eq!(full.bounds(), acquisition());
+    }
+
+    #[test]
+    fn invalid_center_or_disjoint_window_never_becomes_full_run() {
+        for center in [f32::NAN, f32::INFINITY, -1.0] {
+            assert!(
+                ResolvedRt::resolve(
+                    RtSelection::Centered(ObservedRTSeconds(center)),
+                    &RtTolerance::Unrestricted,
+                    acquisition()
+                )
+                .is_err()
+            );
+        }
+        assert!(
+            ResolvedRt::resolve(
+                RtSelection::Centered(ObservedRTSeconds(300.0)),
+                &RtTolerance::Minutes((0.1, 0.1)),
+                acquisition()
+            )
+            .is_err()
+        );
+    }
+
+    #[test]
+    fn rejects_invalid_tolerances_and_handles_percentages() {
+        for tol in [
+            RtTolerance::Minutes((-1.0, 1.0)),
+            RtTolerance::Pct((f32::NAN, 1.0)),
+        ] {
+            assert!(
+                ResolvedRt::resolve(
+                    RtSelection::Centered(ObservedRTSeconds(100.0)),
+                    &tol,
+                    acquisition()
+                )
+                .is_err()
+            );
+        }
+        let rt = ResolvedRt::resolve(
+            RtSelection::Centered(ObservedRTSeconds(100.0)),
+            &RtTolerance::Pct((10.0, 20.0)),
+            acquisition(),
+        )
+        .unwrap();
+        assert_eq!(
+            rt.range_millis(),
+            TupleRange::try_new(90_000, 120_000).unwrap()
+        );
+    }
+
+    #[test]
+    fn collector_owns_no_source_borrow_and_reset_changes_both_center_and_bounds() {
+        use crate::{
+            OwnedTarget,
+            SpectralCollector,
+        };
+        let mut collector: SpectralCollector<usize, f32> = {
+            let source = OwnedTarget::empty_like();
+            let rt = ResolvedRt::resolve(
+                RtSelection::FullRun,
+                &RtTolerance::Unrestricted,
+                acquisition(),
+            )
+            .unwrap();
+            SpectralCollector::new(&ExtractionQuery::new(&source, rt))
+        };
+        let source = OwnedTarget::empty_like();
+        let rt = ResolvedRt::resolve(
+            RtSelection::Centered(ObservedRTSeconds(100.0)),
+            &RtTolerance::Minutes((0.5, 0.5)),
+            acquisition(),
+        )
+        .unwrap();
+        collector.reset_with(&ExtractionQuery::new(&source, rt));
+        assert_eq!(collector.rt.center(), Some(ObservedRTSeconds(100.0)));
+        assert_eq!(
+            collector.rt.range_millis(),
+            TupleRange::try_new(70_000, 129_999).unwrap()
+        );
+    }
+}
diff --git a/rust/timsquery/src/models/indexed_data.rs b/rust/timsquery/src/models/indexed_data.rs
index 86db434e..cdbe2f1a 100644
--- a/rust/timsquery/src/models/indexed_data.rs
+++ b/rust/timsquery/src/models/indexed_data.rs
@@ -7,10 +7,8 @@
 //!
 //! The query pattern follows these steps:
 //!
-//! 1. **Tolerance Application**: The [`Tolerance`] struct defines search windows
-//!    for m/z, retention time, ion mobility, and quadrupole isolation
-//! 2. **Range Calculation**: For each dimension, calculate the query range based
-//!    on the target value and tolerance (e.g., `mz ± ppm` or `rt ± minutes`)
+//! 1. [`PeakTolerance`] defines m/z, mobility, and quadrupole windows.
+//! 2. RT bounds come from the collector's resolved acquisition window.
 //! 3. **Peak Filtering**: Query the indexed data structure for peaks within all ranges
 //! 4. **Aggregation**: Accumulate filtered peaks into the aggregator (sum intensities,
 //!    build profiles, compute statistics, etc.)
@@ -78,7 +76,7 @@ use crate::traits::{
 use crate::{
     KeyLike,
     OptionallyRestricted,
-    Tolerance,
+    PeakTolerance,
 };
 use half::f16;
 use timscentroid::rt_mapping::{
@@ -139,7 +137,7 @@ impl QueryRanges {
     /// Compute query ranges from query data + tolerance.
     fn from_query_data<FH: KeyLike>(
         query: &impl crate::traits::queriable_data::HasQueryData<FH>,
-        tolerance: &Tolerance,
+        tolerance: &PeakTolerance,
         run_mobility: &MobilityKind,
         rt_ms_to_cycle: impl Fn(u32) -> MS1CycleIndex,
     ) -> Self {
@@ -151,13 +149,11 @@ impl QueryRanges {
         } else {
             Unrestricted
         };
-        let rt_range_milliseconds = tolerance.rt_range_as_milis(query.rt_seconds());
-        let ms1_cycle_range = match rt_range_milliseconds {
-            Restricted(x) => Restricted(
-                TupleRange::try_new(rt_ms_to_cycle(x.start()), rt_ms_to_cycle(x.end())).unwrap(),
-            ),
-            Unrestricted => Unrestricted,
-        };
+        let rt = query.rt().range_millis();
+        let ms1_cycle_range = Restricted(
+            TupleRange::try_new(rt_ms_to_cycle(rt.start()), rt_ms_to_cycle(rt.end()))
+                .expect("resolved RT bounds are ordered"),
+        );
         let ms2_cycle_range = ms1_to_ms2_cycle_range(&ms1_cycle_range);
 
         Self {
@@ -168,50 +164,6 @@ 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.
-    fn from_query_data_with_rt_intersection<FH: KeyLike>(
-        query: &impl crate::traits::queriable_data::HasQueryData<FH>,
-        tolerance: &Tolerance,
-        run_mobility: &MobilityKind,
-        rt_limits_milis: TupleRange<u32>,
-        rt_ms_to_cycle: impl Fn(u32) -> MS1CycleIndex,
-    ) -> Option<Self> {
-        let prec_mz_limits = query.precursor_mz_limits();
-        let quad_range =
-            tolerance.quad_range_f32((prec_mz_limits.0 as f32, prec_mz_limits.1 as f32));
-        let im_range = if im_axis_filterable(run_mobility, &query.mobility_kind()) {
-            tolerance.mobility_range_f16(query.mobility_ook0())
-        } else {
-            Unrestricted
-        };
-
-        let rt_range_milliseconds = match tolerance
-            .rt_range_as_milis(query.rt_seconds())
-            .map(|x| x.try_intercept(rt_limits_milis))
-        {
-            Restricted(Some(x)) => Restricted(x),
-            Restricted(None) => return None,
-            Unrestricted => Unrestricted,
-        };
-
-        let ms1_cycle_range = match rt_range_milliseconds {
-            Restricted(x) => Restricted(
-                TupleRange::try_new(rt_ms_to_cycle(x.start()), rt_ms_to_cycle(x.end())).unwrap(),
-            ),
-            Unrestricted => Unrestricted,
-        };
-        let ms2_cycle_range = ms1_to_ms2_cycle_range(&ms1_cycle_range);
-
-        Some(Self {
-            quad_range,
-            im_range,
-            ms1_cycle_range,
-            ms2_cycle_range,
-        })
-    }
-
     /// Constrain the IM range based on quadrupole isolation geometry.
     ///
     /// For MS2 queries, the ion mobility range must be further constrained to the
@@ -236,7 +188,7 @@ impl QueryRanges {
 }
 
 impl<FH: KeyLike> QueriableData<PointIntensityAggregator<FH>> for IndexedTimstofPeaks {
-    fn add_query(&self, aggregator: &mut PointIntensityAggregator<FH>, tolerance: &Tolerance) {
+    fn add_query(&self, aggregator: &mut PointIntensityAggregator<FH>, tolerance: &PeakTolerance) {
         let ranges =
             QueryRanges::from_query_data(aggregator, tolerance, self.mobility_kind(), |rt| {
                 self.rt_ms_to_cycle_index(rt)
@@ -269,16 +221,15 @@ impl<FH: KeyLike> QueriableData<PointIntensityAggregator<FH>> for IndexedTimstof
 }
 
 impl<FH: KeyLike> QueriableData<ChromatogramCollector<FH, f32>> for IndexedTimstofPeaks {
-    fn add_query(&self, aggregator: &mut ChromatogramCollector<FH, f32>, tolerance: &Tolerance) {
-        let Some(ranges) = QueryRanges::from_query_data_with_rt_intersection(
-            aggregator,
-            tolerance,
-            self.mobility_kind(),
-            aggregator.rt_range_milis(),
-            |rt| self.rt_ms_to_cycle_index(rt),
-        ) else {
-            return; // No RT intersection, early exit
-        };
+    fn add_query(
+        &self,
+        aggregator: &mut ChromatogramCollector<FH, f32>,
+        tolerance: &PeakTolerance,
+    ) {
+        let ranges =
+            QueryRanges::from_query_data(aggregator, tolerance, self.mobility_kind(), |rt| {
+                self.rt_ms_to_cycle_index(rt)
+            });
 
         // Locally-accumulated counters: incrementing aggregator fields inside
         // `iter_mut_*` would conflict with the mutable borrow; write back once
@@ -334,7 +285,7 @@ impl<FH: KeyLike> QueriableData<ChromatogramCollector<FH, f32>> for IndexedTimst
 }
 
 impl<FH: KeyLike> QueriableData<SpectralCollector<FH, f32>> for IndexedTimstofPeaks {
-    fn add_query(&self, aggregator: &mut SpectralCollector<FH, f32>, tolerance: &Tolerance) {
+    fn add_query(&self, aggregator: &mut SpectralCollector<FH, f32>, tolerance: &PeakTolerance) {
         let ranges =
             QueryRanges::from_query_data(aggregator, tolerance, self.mobility_kind(), |rt| {
                 self.rt_ms_to_cycle_index(rt)
@@ -375,7 +326,7 @@ impl<FH: KeyLike> QueriableData<SpectralCollector<FH, f32>> for IndexedTimstofPe
 impl<FH: KeyLike, V: PeakAddable<MS1CycleIndex> + PeakAddable<WindowCycleIndex>>
     QueriableData<SpectralCollector<FH, V>> for IndexedTimstofPeaks
 {
-    fn add_query(&self, aggregator: &mut SpectralCollector<FH, V>, tolerance: &Tolerance) {
+    fn add_query(&self, aggregator: &mut SpectralCollector<FH, V>, tolerance: &PeakTolerance) {
         let ranges =
             QueryRanges::from_query_data(aggregator, tolerance, self.mobility_kind(), |rt| {
                 self.rt_ms_to_cycle_index(rt)
@@ -432,7 +383,11 @@ fn ms1_to_ms2_cycle_range(
 }
 
 impl<FH: KeyLike> QueriableData<ChromatogramCollector<FH, f32>> for IndexedPeaksHandle {
-    fn add_query(&self, aggregator: &mut ChromatogramCollector<FH, f32>, tolerance: &Tolerance) {
+    fn add_query(
+        &self,
+        aggregator: &mut ChromatogramCollector<FH, f32>,
+        tolerance: &PeakTolerance,
+    ) {
         match self {
             IndexedPeaksHandle::Eager(eager) => {
                 // Delegate to existing implementation
@@ -440,15 +395,12 @@ impl<FH: KeyLike> QueriableData<ChromatogramCollector<FH, f32>> for IndexedPeaks
             }
             IndexedPeaksHandle::Lazy(lazy) => {
                 // Use QueryRanges to compute common tolerances, then convert to u32 for lazy API
-                let Some(ranges) = QueryRanges::from_query_data_with_rt_intersection(
+                let ranges = QueryRanges::from_query_data(
                     aggregator,
                     tolerance,
                     lazy.mobility_kind(),
-                    aggregator.rt_range_milis(),
                     |rt| lazy.rt_ms_to_cycle_index(rt),
-                ) else {
-                    return; // No RT intersection, early exit
-                };
+                );
 
                 // Convert MS1CycleIndex ranges to u32 for lazy API
                 let cycle_range_u32 = match ranges.ms1_cycle_range {
@@ -519,7 +471,7 @@ impl<FH: KeyLike> QueriableData<ChromatogramCollector<FH, f32>> for IndexedPeaks
 }
 
 impl<FH: KeyLike> QueriableData<SpectralCollector<FH, f32>> for IndexedPeaksHandle {
-    fn add_query(&self, aggregator: &mut SpectralCollector<FH, f32>, tolerance: &Tolerance) {
+    fn add_query(&self, aggregator: &mut SpectralCollector<FH, f32>, tolerance: &PeakTolerance) {
         match self {
             IndexedPeaksHandle::Eager(eager) => eager.add_query(aggregator, tolerance),
             IndexedPeaksHandle::Lazy(lazy) => {
@@ -574,7 +526,7 @@ impl<FH: KeyLike> QueriableData<SpectralCollector<FH, MzMobilityStatsCollector>>
     fn add_query(
         &self,
         aggregator: &mut SpectralCollector<FH, MzMobilityStatsCollector>,
-        tolerance: &Tolerance,
+        tolerance: &PeakTolerance,
     ) {
         match self {
             IndexedPeaksHandle::Eager(eager) => eager.add_query(aggregator, tolerance),
@@ -669,10 +621,10 @@ mod mobility_gate_tests {
 
     #[test]
     fn ctor_unrestricts_im_range_for_non_ook0_run() {
-        use crate::Tolerance;
+        use crate::PeakTolerance;
         use crate::models::aggregators::PointIntensityAggregator;
         use crate::models::indexed_data::QueryRanges;
-        use crate::models::target::Target;
+        use crate::models::target::OwnedTarget;
         use timscentroid::rt_mapping::{
             MS1CycleIndex,
             RTIndex,
@@ -680,18 +632,30 @@ mod mobility_gate_tests {
         use timscentroid::utils::OptionallyRestricted;
         use tinyvec::tiny_vec;
 
-        let eg = Target::<usize>::builder()
+        let eg = OwnedTarget::<usize>::builder()
             .id(1)
             .mobility_ook0(0.8)
-            .rt_seconds(100.0)
+            .rt_value(100.0)
             .precursor(400.0, 1u8)
             .precursor_labels(tiny_vec!(0))
             .fragment_mzs(vec![600.0])
             .fragment_labels(tiny_vec!(0usize))
             .try_build()
             .unwrap();
-        let agg = PointIntensityAggregator::new(&eg);
-        let tol = Tolerance::default(); // mobility = Pct((3,3)) => Restricted for a finite value
+        let agg = PointIntensityAggregator::new(&crate::ExtractionQuery::new(
+            &eg,
+            crate::ResolvedRt::resolve(
+                crate::RtSelection::FullRun,
+                &crate::models::tolerance::RtTolerance::Unrestricted,
+                crate::TupleRange::try_new(
+                    crate::ObservedRTSeconds(0.009),
+                    crate::ObservedRTSeconds(0.020),
+                )
+                .unwrap(),
+            )
+            .unwrap(),
+        ));
+        let tol = PeakTolerance::default(); // mobility = Pct((3,3)) => Restricted for a finite value
 
         // Ook0 run against the default Ook0 library => mobility filter is applied.
         let r = QueryRanges::from_query_data(&agg, &tol, &MobilityKind::Ook0, |_| {
@@ -705,4 +669,56 @@ mod mobility_gate_tests {
         });
         assert!(matches!(r.im_range, OptionallyRestricted::Unrestricted));
     }
+    #[test]
+    fn index_uses_resolved_bounds_even_when_source_seconds_differ() {
+        use super::QueryRanges;
+        use crate::models::aggregators::SpectralCollector;
+        use crate::models::tolerance::RtTolerance;
+        use crate::{
+            ExtractionQuery,
+            ObservedRTSeconds,
+            OwnedTarget,
+            PeakTolerance,
+            ResolvedRt,
+            RtSelection,
+            TupleRange,
+        };
+        use timscentroid::rt_mapping::{
+            MS1CycleIndex,
+            RTIndex,
+        };
+        let rt = ResolvedRt::resolve(
+            RtSelection::Centered(ObservedRTSeconds(100.0)),
+            &RtTolerance::Minutes((0.5, 0.5)),
+            TupleRange::try_new(ObservedRTSeconds(0.0), ObservedRTSeconds(200.0)).unwrap(),
+        )
+        .unwrap();
+        let source = OwnedTarget::<usize>::builder()
+            .id(1)
+            .mobility_ook0(1.0)
+            .rt_value(900.0)
+            .precursor(500.0, 2)
+            .precursor_labels(tinyvec::tiny_vec!(0))
+            .fragment_labels(tinyvec::tiny_vec!(0usize))
+            .fragment_mzs(vec![300.0])
+            .try_build()
+            .unwrap();
+        let collector: SpectralCollector<usize, f32> =
+            SpectralCollector::new(&ExtractionQuery::new(&source, rt));
+        let ranges = QueryRanges::from_query_data(
+            &collector,
+            &PeakTolerance::default(),
+            &MobilityKind::Absent,
+            MS1CycleIndex::new,
+        );
+        let timscentroid::utils::OptionallyRestricted::Restricted(bounds) = ranges.ms1_cycle_range
+        else {
+            panic!("resolved RT must constrain index traversal");
+        };
+        assert_eq!(
+            bounds,
+            TupleRange::try_new(MS1CycleIndex::new(70_000), MS1CycleIndex::new(129_999)).unwrap()
+        );
+        assert_eq!(source.rt_seconds(), 900.0);
+    }
 }
diff --git a/rust/timsquery/src/models/mod.rs b/rust/timsquery/src/models/mod.rs
index b63e63e0..83fd9712 100644
--- a/rust/timsquery/src/models/mod.rs
+++ b/rust/timsquery/src/models/mod.rs
@@ -1,9 +1,15 @@
 pub mod aggregators;
 pub mod base;
 pub mod capabilities;
+pub mod extraction_query;
 pub mod indexed_data;
 mod lazy;
 pub mod query_handle;
+pub mod retention_time;
+pub use retention_time::{
+    RtAxis,
+    RtCoordinate,
+};
 pub mod source_id;
 pub mod target;
 pub mod target_columns;
diff --git a/rust/timsquery/src/models/query_handle.rs b/rust/timsquery/src/models/query_handle.rs
index a33b7852..15244348 100644
--- a/rust/timsquery/src/models/query_handle.rs
+++ b/rust/timsquery/src/models/query_handle.rs
@@ -13,7 +13,7 @@ use crate::models::target_columns::{
 use crate::traits::{
     DecoyShift,
     KeyLike,
-    QueryGeom,
+    Target,
 };
 use crate::utils::constants::C13_C12_MASS_DIFF;
 
@@ -92,7 +92,7 @@ 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> {
+impl<Lib: Deref<Target = TargetColumns<L>>, L: KeyLike + DecoyShift> Target for Query<Lib, L> {
     type Label = L;
 
     fn source_id(&self) -> Option<crate::models::SourceId<'_>> {
@@ -113,8 +113,8 @@ impl<Lib: Deref<Target = TargetColumns<L>>, L: KeyLike + DecoyShift> QueryGeom f
         self.geom().charge(self.row())
     }
 
-    fn rt_seconds(&self) -> f32 {
-        self.geom().rt_seconds(self.row())
+    fn rt(&self) -> Option<crate::models::RtCoordinate<'_>> {
+        self.geom().rt(self.row())
     }
 
     fn mobility_ook0(&self) -> f32 {
@@ -172,7 +172,7 @@ mod tests {
         TargetColumns,
         TargetColumnsBuilder,
     };
-    use crate::traits::QueryGeom;
+    use crate::traits::Target;
 
     /// Rows come from the arena; there is no constructor from an integer.
     fn first_row<L: KeyLike>(lib: &TargetColumns<L>) -> RowIdx {
@@ -200,7 +200,7 @@ mod tests {
         c.push_row(Row {
             precursor_mz: 654.855,
             charge: 2,
-            rt_seconds: 1.0,
+            rt: Some(crate::models::RtCoordinate::seconds(1.0)),
             mobility: 1.0,
             frags: &[
                 (IonAnnot::try_from("y1").unwrap(), 200.0), // ordinal 1 -> NOT shifted
@@ -293,7 +293,7 @@ mod tests {
         c.push_row(Row {
             precursor_mz: 500.0,
             charge: 2,
-            rt_seconds: 1.0,
+            rt: Some(crate::models::RtCoordinate::seconds(1.0)),
             mobility: 1.0,
             frags: &[(Arc::<str>::from("f"), 300.0)],
 
diff --git a/rust/timsquery/src/models/retention_time.rs b/rust/timsquery/src/models/retention_time.rs
new file mode 100644
index 00000000..d0efad28
--- /dev/null
+++ b/rust/timsquery/src/models/retention_time.rs
@@ -0,0 +1,17 @@
+//! Library coordinates and observed extraction times are different domains.
+pub use calibrt::RtAxis;
+
+#[derive(Debug, Clone, Copy)]
+pub struct RtCoordinate<'a> {
+    pub value: calibrt::LibraryRT<f32>,
+    pub axis: &'a RtAxis,
+}
+
+impl RtCoordinate<'static> {
+    pub fn seconds(value: f32) -> Self {
+        Self {
+            value: calibrt::LibraryRT(value),
+            axis: &RtAxis::Seconds,
+        }
+    }
+}
diff --git a/rust/timsquery/src/models/source_id.rs b/rust/timsquery/src/models/source_id.rs
index 721da859..562fe82d 100644
--- a/rust/timsquery/src/models/source_id.rs
+++ b/rust/timsquery/src/models/source_id.rs
@@ -69,7 +69,7 @@ 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
+    /// sides are text. `OwnedTarget::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) {
@@ -102,7 +102,7 @@ impl From<&str> for OwnedSourceId {
 
 impl OwnedSourceId {
     /// The id of a scratch buffer that has not been filled yet (see
-    /// [`crate::Target::empty_like`]).
+    /// [`crate::OwnedTarget::empty_like`]).
     ///
     /// Allocates nothing: an empty `String` owns no buffer until something is
     /// pushed into it, and [`Self::set_from`] then grows it once -- exactly what
diff --git a/rust/timsquery/src/models/target.rs b/rust/timsquery/src/models/target.rs
index 76cde440..73c08d4e 100644
--- a/rust/timsquery/src/models/target.rs
+++ b/rust/timsquery/src/models/target.rs
@@ -1,4 +1,4 @@
-use crate::models::target::target_builder::{
+use crate::models::target::owned_target_builder::{
     SetPrecursorCharge,
     SetPrecursorMonoMz,
 };
@@ -15,12 +15,16 @@ use tinyvec::TinyVec;
 /// [`crate::models::TargetColumns`].
 #[derive(Debug, Serialize, Deserialize, Clone, bon::Builder)]
 #[builder(finish_fn(vis = "", name = try_build_internal))]
-pub struct Target<T: KeyLike> {
+pub struct OwnedTarget<T: KeyLike> {
     #[builder(into)]
     id: crate::models::OwnedSourceId,
     #[serde(alias = "mobility")]
     mobility_ook0: f32,
-    rt_seconds: f32,
+    #[serde(rename = "rt_seconds")]
+    rt_value: f32,
+    #[serde(default = "legacy_rt_axis")]
+    #[builder(default = crate::models::RtAxis::Seconds)]
+    rt_axis: crate::models::RtAxis,
     #[serde(alias = "precursor")]
     #[serde(alias = "precursor_mz")]
     precursor_mono_mz: f64,
@@ -44,7 +48,7 @@ pub struct Target<T: KeyLike> {
     // regardless of the types (bc those are just fat pointers)
     //
     // Changing the labels to TinyVec with capaciry of 13 makes the struct 144 bytes for
-    // the concrete type Target<IonAnnot> but 408 bytes for Target<String>
+    // the concrete type OwnedTarget<IonAnnot> but 408 bytes for OwnedTarget<String>
     //
     // In theory I can make this lighter if it was a genetic ...
     #[serde(alias = "fragments")]
@@ -54,8 +58,8 @@ pub struct Target<T: KeyLike> {
     precursor_labels: TinyVec<[i8; 13]>,
 }
 
-impl<T: KeyLike + Default, S: target_builder::IsComplete> TargetBuilder<T, S> {
-    pub fn try_build(self) -> Result<Target<T>, crate::errors::DataProcessingError> {
+impl<T: KeyLike + Default, S: owned_target_builder::IsComplete> OwnedTargetBuilder<T, S> {
+    pub fn try_build(self) -> Result<OwnedTarget<T>, crate::errors::DataProcessingError> {
         let candidate = self.try_build_internal();
         if candidate.fragment_labels.is_empty() | candidate.precursor_labels.is_empty() {
             return Err(crate::DataProcessingError::ExpectedNonEmptyData);
@@ -68,31 +72,32 @@ impl<T: KeyLike + Default, S: target_builder::IsComplete> TargetBuilder<T, S> {
     }
 }
 
-impl<T: KeyLike + Default, S: target_builder::State> TargetBuilder<T, S> {
+impl<T: KeyLike + Default, S: owned_target_builder::State> OwnedTargetBuilder<T, S> {
     pub fn precursor(
         self,
         mz_mono: f64,
         charge: u8,
-    ) -> TargetBuilder<T, SetPrecursorCharge<SetPrecursorMonoMz<S>>>
+    ) -> OwnedTargetBuilder<T, SetPrecursorCharge<SetPrecursorMonoMz<S>>>
     where
-        S::PrecursorCharge: target_builder::IsUnset,
-        S::PrecursorMonoMz: target_builder::IsUnset,
+        S::PrecursorCharge: owned_target_builder::IsUnset,
+        S::PrecursorMonoMz: owned_target_builder::IsUnset,
     {
         self.precursor_mono_mz(mz_mono).precursor_charge(charge)
     }
 }
 
-impl<T: KeyLike + Default> Target<T> {
+impl<T: KeyLike + Default> OwnedTarget<T> {
     /// Build an empty scratch group DIRECTLY (bypassing the `bon` builder,
     /// which rejects empty fragment/precursor label sets). All scalars are
     /// zeroed and all vecs empty; the intended use is a reuse-in-place scratch
-    /// buffer that gets refilled via [`Target::reset_from`] before
+    /// buffer that gets refilled via [`OwnedTarget::reset_from`] before
     /// every query, so the zeroed initial state is never observed.
     pub fn empty_like() -> Self {
         Self {
             id: crate::models::OwnedSourceId::placeholder(),
             mobility_ook0: 0.0,
-            rt_seconds: 0.0,
+            rt_value: 0.0,
+            rt_axis: crate::models::RtAxis::Absent,
             precursor_mono_mz: 0.0,
             precursor_charge: 0,
             fragment_mzs: Vec::new(),
@@ -102,7 +107,7 @@ impl<T: KeyLike + Default> Target<T> {
     }
 }
 
-impl<T: KeyLike> Target<T> {
+impl<T: KeyLike> OwnedTarget<T> {
     pub fn id(&self) -> crate::models::SourceId<'_> {
         self.id.as_ref()
     }
@@ -115,8 +120,21 @@ impl<T: KeyLike> Target<T> {
         self.fragment_mzs.len()
     }
 
+    pub fn rt(&self) -> Option<crate::models::RtCoordinate<'_>> {
+        (self.rt_axis != crate::models::RtAxis::Absent).then_some(crate::models::RtCoordinate {
+            value: calibrt::LibraryRT(self.rt_value),
+            axis: &self.rt_axis,
+        })
+    }
+
+    /// Source coordinate in seconds, when its declared unit is seconds.
+    /// This does not establish that it belongs to the current acquisition.
     pub fn rt_seconds(&self) -> f32 {
-        self.rt_seconds
+        if self.rt_axis == crate::models::RtAxis::Seconds {
+            self.rt_value
+        } else {
+            f32::NAN
+        }
     }
 
     pub fn precursor_charge(&self) -> u8 {
@@ -134,19 +152,18 @@ impl<T: KeyLike> Target<T> {
 
     // NOTE: I am thinking about removing this and leave the rest as a trait
     pub fn set_rt_seconds(&mut self, rt_seconds: f32) {
-        self.rt_seconds = rt_seconds;
+        self.rt_value = rt_seconds;
+        self.rt_axis = crate::models::RtAxis::Seconds;
     }
 
-    /// 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
-    /// scratch in timsseek. `G` is any `QueryGeom` (e.g. the columnar
-    /// 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) {
+    /// Materialize borrowed source geometry, reusing fragment buffers.
+    /// Owned metadata, including the library RT axis, is cloned here.
+    pub fn reset_from<G: crate::traits::Target<Label = T>>(&mut self, src: &G) {
         self.id.set_from(src.output_id());
         self.mobility_ook0 = src.mobility_ook0();
-        self.rt_seconds = src.rt_seconds();
+        let rt = src.rt();
+        self.rt_value = rt.map_or(0.0, |r| r.value.0);
+        self.rt_axis = rt.map_or(crate::models::RtAxis::Absent, |r| r.axis.clone());
         self.precursor_mono_mz = src.mono_precursor_mz();
         self.precursor_charge = src.precursor_charge();
         self.fragment_mzs.clear();
@@ -220,14 +237,15 @@ impl<T: KeyLike> Target<T> {
             .map(|(label, mz)| (label, *mz))
     }
 
-    pub fn cast<U: KeyLike>(&self, f: impl Fn(&T) -> U) -> Target<U> {
+    pub fn cast<U: KeyLike>(&self, f: impl Fn(&T) -> U) -> OwnedTarget<U> {
         let fragment_labels_converted: TinyVec<[U; 13]> =
             self.fragment_labels.iter().map(f).collect();
 
-        Target {
+        OwnedTarget {
             id: self.id.clone(),
             mobility_ook0: self.mobility_ook0,
-            rt_seconds: self.rt_seconds,
+            rt_value: self.rt_value,
+            rt_axis: self.rt_axis.clone(),
             precursor_mono_mz: self.precursor_mono_mz,
             precursor_charge: self.precursor_charge,
             fragment_mzs: self.fragment_mzs.clone(),
@@ -236,3 +254,7 @@ impl<T: KeyLike> Target<T> {
         }
     }
 }
+
+pub(crate) fn legacy_rt_axis() -> crate::models::RtAxis {
+    crate::models::RtAxis::Seconds
+}
diff --git a/rust/timsquery/src/models/target_columns.rs b/rust/timsquery/src/models/target_columns.rs
index d4dec02b..bb868d53 100644
--- a/rust/timsquery/src/models/target_columns.rs
+++ b/rust/timsquery/src/models/target_columns.rs
@@ -154,7 +154,7 @@ pub struct DecoyGroups {
 /// geom.push_row(Row {
 ///     precursor_mz: 900.4,
 ///     charge: 2,
-///     rt_seconds: 1.0,
+///     rt: Some(crate::models::RtCoordinate::seconds(1.0)),
 ///     mobility: 0.8,
 ///     frags: &frags,
 ///     analyte: Default::default(),
@@ -165,7 +165,7 @@ pub struct DecoyGroups {
 pub struct Row<'a, L: KeyLike> {
     pub precursor_mz: f64,
     pub charge: u8,
-    pub rt_seconds: f32,
+    pub rt: Option<crate::models::RtCoordinate<'a>>,
     pub mobility: f32,
     pub frags: &'a [(L, f64)],
     pub analyte: AnalyteInput<'a>,
@@ -201,7 +201,7 @@ impl<L: KeyLike> Default for Row<'_, L> {
         Self {
             precursor_mz: 0.0,
             charge: 0,
-            rt_seconds: 0.0,
+            rt: None,
             mobility: 0.0,
             frags: &[],
             analyte: AnalyteInput::default(),
@@ -219,6 +219,8 @@ pub enum TargetBuildError {
     Identity(#[from] SourceIdError),
     #[error("invalid analyte: {message}")]
     InvalidAnalyte { message: String },
+    #[error("invalid library RT: {message}")]
+    InvalidRt { message: String },
 }
 
 #[derive(Debug, Clone)]
@@ -229,7 +231,9 @@ pub struct TargetColumns<L: KeyLike> {
     // caller-supplied id (those live in `source_ids`)
     pub(crate) precursor_mz: Vec<f64>,
     pub(crate) charge: Vec<u8>,
-    pub(crate) rt_seconds: Vec<f32>,
+    pub(crate) rt_values: Vec<f32>,
+    pub(crate) rt_axis: crate::models::RtAxis,
+    pub(crate) rt_error: Option<String>,
     pub(crate) mobility: Vec<f32>,
     // per-row decoy flag (len = n_rows)
     pub(crate) is_decoy: Vec<bool>,
@@ -305,7 +309,9 @@ impl<L: KeyLike> TargetColumns<L> {
             decoy_resolution: None,
             precursor_mz: Vec::new(),
             charge: Vec::new(),
-            rt_seconds: Vec::new(),
+            rt_values: Vec::new(),
+            rt_axis: crate::models::RtAxis::Absent,
+            rt_error: None,
             mobility: Vec::new(),
             is_decoy: Vec::new(),
             pending_ids: Vec::new(),
@@ -326,7 +332,7 @@ impl<L: KeyLike> TargetColumns<L> {
         let Row {
             precursor_mz,
             charge,
-            rt_seconds,
+            rt,
             mobility,
             frags,
             analyte,
@@ -337,7 +343,16 @@ impl<L: KeyLike> TargetColumns<L> {
         } = row;
         self.precursor_mz.push(precursor_mz);
         self.charge.push(charge);
-        self.rt_seconds.push(rt_seconds);
+        let axis = rt.map_or(&crate::models::RtAxis::Absent, |r| r.axis);
+        if self.rt_values.is_empty() {
+            self.rt_axis = axis.clone();
+        } else if &self.rt_axis != axis {
+            self.rt_error = Some("mixed RT availability or incompatible axes; every retained entry must have RT on one axis, or none may have RT".into());
+        }
+        if rt.is_some_and(|r| !r.value.0.is_finite() || *r.axis == crate::models::RtAxis::Absent) {
+            self.rt_error = Some("present RT must be finite and have a non-absent axis".into());
+        }
+        self.rt_values.push(rt.map_or(0.0, |r| r.value.0));
         self.mobility.push(mobility);
         self.pending_ids.push(id);
         self.pending_groups.push(decoy_group);
@@ -509,8 +524,19 @@ impl<L: KeyLike> TargetColumns<L> {
         self.precursor_mz[tgt.get()]
     }
 
-    pub fn rt_seconds(&self, tgt: RowIdx) -> f32 {
-        self.rt_seconds[tgt.get()]
+    pub fn rt_axis(&self) -> &crate::models::RtAxis {
+        &self.rt_axis
+    }
+
+    pub fn rt(&self, tgt: RowIdx) -> Option<crate::models::RtCoordinate<'_>> {
+        (self.rt_axis != crate::models::RtAxis::Absent).then(|| crate::models::RtCoordinate {
+            value: calibrt::LibraryRT(self.rt_values[tgt.get()]),
+            axis: &self.rt_axis,
+        })
+    }
+
+    pub fn library_rt(&self, tgt: RowIdx) -> Option<calibrt::LibraryRT<f32>> {
+        self.rt(tgt).map(|r| r.value)
     }
 
     pub fn mobility(&self, tgt: RowIdx) -> f32 {
@@ -558,6 +584,9 @@ impl<L: KeyLike> TargetColumns<L> {
     where
         L: DecoyShift,
     {
+        if let Some(message) = self.rt_error.take() {
+            return Err(TargetBuildError::InvalidRt { message });
+        }
         assert_eq!(self.analytes.len(), self.n_rows());
         assert_eq!(self.entry_names.len(), self.n_rows());
         self.analytes
@@ -657,7 +686,7 @@ impl<L: KeyLike> TargetColumns<L> {
     fn shrink(&mut self) {
         self.precursor_mz.shrink_to_fit();
         self.charge.shrink_to_fit();
-        self.rt_seconds.shrink_to_fit();
+        self.rt_values.shrink_to_fit();
         self.mobility.shrink_to_fit();
         self.is_decoy.shrink_to_fit();
         self.frag_off.shrink_to_fit();
@@ -837,7 +866,7 @@ mod tests {
             c.push_row(Row {
                 precursor_mz: 500.0,
                 charge: spec.charge,
-                rt_seconds: 1.0,
+                rt: Some(crate::models::RtCoordinate::seconds(1.0)),
                 mobility: 0.8,
                 frags: &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
                 analyte: crate::chemistry::analyte::Analyte::from_sequence("PEP").as_input(),
@@ -934,7 +963,7 @@ mod tests {
             c.push_row(Row {
                 precursor_mz: 500.0,
                 charge: 2,
-                rt_seconds: 1.0,
+                rt: Some(crate::models::RtCoordinate::seconds(1.0)),
                 mobility: 0.8,
                 frags: &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
                 analyte: crate::chemistry::analyte::Analyte::from_sequence("PEP").as_input(),
@@ -986,7 +1015,7 @@ mod tests {
         c.push_row(Row {
             precursor_mz: 500.0,
             charge: 2,
-            rt_seconds: 1.0,
+            rt: Some(crate::models::RtCoordinate::seconds(1.0)),
             mobility: 0.8,
             frags: &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
             analyte: crate::chemistry::analyte::Analyte::from_sequence("PEP").as_input(),
@@ -1009,7 +1038,7 @@ mod tests {
         c.push_row(Row {
             precursor_mz: 500.0,
             charge: 2,
-            rt_seconds: 1.0,
+            rt: Some(crate::models::RtCoordinate::seconds(1.0)),
             mobility: 0.8,
             frags: &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
             analyte: crate::chemistry::analyte::Analyte::from_sequence("PEP").as_input(),
@@ -1018,7 +1047,7 @@ mod tests {
         c.push_row(Row {
             precursor_mz: 510.0,
             charge: 2,
-            rt_seconds: 1.0,
+            rt: Some(crate::models::RtCoordinate::seconds(1.0)),
             mobility: 0.8,
             frags: &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
             analyte: crate::chemistry::analyte::Analyte::from_sequence("PEP").as_input(),
@@ -1042,7 +1071,7 @@ mod tests {
         c.push_row(Row {
             precursor_mz: 500.0,
             charge: 2,
-            rt_seconds: 1.0,
+            rt: Some(crate::models::RtCoordinate::seconds(1.0)),
             mobility: 0.8,
             frags: &[
                 (IonAnnot::try_from("y3").unwrap(), 300.0),
@@ -1054,7 +1083,7 @@ mod tests {
         c.push_row(Row {
             precursor_mz: 600.0,
             charge: 3,
-            rt_seconds: 2.0,
+            rt: Some(crate::models::RtCoordinate::seconds(2.0)),
             mobility: 0.9,
             frags: &[
                 (IonAnnot::try_from("y2").unwrap(), 200.0),
@@ -1093,7 +1122,7 @@ mod tests {
         c.push_row(Row {
             precursor_mz: 500.0,
             charge: 2,
-            rt_seconds: 1.0,
+            rt: Some(crate::models::RtCoordinate::seconds(1.0)),
             mobility: 0.8,
             frags: &[(Arc::<str>::from("frag_a"), 300.0)],
             analyte: crate::chemistry::analyte::Analyte::from_sequence("PEP").as_input(),
@@ -1102,7 +1131,7 @@ mod tests {
         c.push_row(Row {
             precursor_mz: 600.0,
             charge: 2,
-            rt_seconds: 1.0,
+            rt: Some(crate::models::RtCoordinate::seconds(1.0)),
             mobility: 0.8,
             frags: &[(Arc::<str>::from("frag_b"), 400.0)],
             analyte: crate::chemistry::analyte::Analyte::from_sequence("TIDE").as_input(),
diff --git a/rust/timsquery/src/models/tolerance.rs b/rust/timsquery/src/models/tolerance.rs
index 0251d5f7..92541064 100644
--- a/rust/timsquery/src/models/tolerance.rs
+++ b/rust/timsquery/src/models/tolerance.rs
@@ -135,26 +135,14 @@ impl Tolerance {
     /// assert!(range.start() < range.end());
     /// ```
     pub fn mz_range(&self, mz: f64) -> TupleRange<f64> {
-        match self.ms {
-            MzTolerance::Absolute((low, high)) => (mz - low, mz + high)
-                .try_into()
-                .expect(Self::MZ_RANGE_INVARIANT),
-            MzTolerance::Ppm((low, high)) => {
-                let low = mz * low / 1e6;
-                let high = mz * high / 1e6;
-                (mz - low, mz + high)
-                    .try_into()
-                    .expect(Self::MZ_RANGE_INVARIANT)
-            }
-        }
+        self.peak_tolerance().mz_range(mz)
     }
 
     /// Calculate m/z tolerance range (convenience method, returns f32).
     ///
     /// Same as [`mz_range`](Self::mz_range) but accepts and returns `f32`.
     pub fn mz_range_f32(&self, mz: f32) -> TupleRange<f32> {
-        let tmp = self.mz_range(mz as f64);
-        (tmp.start() as f32, tmp.end() as f32).try_into().unwrap()
+        self.peak_tolerance().mz_range_f32(mz)
     }
 
     // ============================================================================
@@ -272,17 +260,7 @@ impl Tolerance {
     /// - `MobilityTolerance::Pct((low, high))`: Percentage of mobility value
     /// - `MobilityTolerance::Unrestricted`: No mobility bounds
     pub fn mobility_range(&self, mobility: f32) -> OptionallyRestricted<TupleRange<f32>> {
-        match self.mobility {
-            MobilityTolerance::Absolute((low, high)) => {
-                Restricted((mobility - low, mobility + high).try_into().unwrap())
-            }
-            MobilityTolerance::Pct((low, high)) => {
-                let low = mobility * (low / 100.0);
-                let high = mobility * (high / 100.0);
-                Restricted((mobility - low, mobility + high).try_into().unwrap())
-            }
-            MobilityTolerance::Unrestricted => Unrestricted,
-        }
+        self.peak_tolerance().mobility_range(mobility)
     }
 
     /// Calculate ion mobility tolerance range (convenience method, returns f16).
@@ -290,15 +268,7 @@ impl Tolerance {
     /// Same as [`mobility_range`](Self::mobility_range) but returns half-precision floats.
     /// Useful for memory-efficient storage of mobility ranges.
     pub fn mobility_range_f16(&self, mobility: f32) -> OptionallyRestricted<TupleRange<f16>> {
-        let tmp = self.mobility_range(mobility);
-        match tmp {
-            Restricted(x) => Restricted(
-                (f16::from_f32(x.start()), f16::from_f32(x.end()))
-                    .try_into()
-                    .unwrap(),
-            ),
-            Unrestricted => Unrestricted,
-        }
+        self.peak_tolerance().mobility_range_f16(mobility)
     }
 
     // ============================================================================
@@ -312,8 +282,7 @@ impl Tolerance {
     ///
     /// Accepts precursor m/z range as `(f32, f32)`, delegates to [`quad_range`](Self::quad_range).
     pub fn quad_range_f32(&self, precursor_mz_range: (f32, f32)) -> TupleRange<f32> {
-        let tmp = self.quad_range((precursor_mz_range.0 as f64, precursor_mz_range.1 as f64));
-        (tmp.start() as f32, tmp.end() as f32).try_into().unwrap()
+        self.peak_tolerance().quad_range_f32(precursor_mz_range)
     }
 
     /// Calculate quadrupole isolation range (primary method, returns f64).
@@ -338,20 +307,7 @@ impl Tolerance {
     /// This method expands that window by the tolerance to account for
     /// quad isolation inaccuracy.
     pub fn quad_range(&self, precursor_mz_range: (f64, f64)) -> TupleRange<f64> {
-        match self.quad {
-            QuadTolerance::Absolute((low, high)) => {
-                let mz_low = precursor_mz_range.0.min(precursor_mz_range.1) - (low as f64);
-                let mz_high = precursor_mz_range.1.max(precursor_mz_range.0) + (high as f64);
-                assert!(mz_low <= mz_high);
-                assert!(
-                    mz_low > 0.0,
-                    "Precursor mz is 0 or less, inputs: self: {:?}, precursor_mz_range: {:?}",
-                    self,
-                    precursor_mz_range,
-                );
-                (mz_low, mz_high).try_into().unwrap()
-            }
-        }
+        self.peak_tolerance().quad_range(precursor_mz_range)
     }
 
     // ============================================================================
@@ -431,3 +387,94 @@ impl Tolerance {
         }
     }
 }
+
+/// Peak-domain tolerances. RT is already resolved on the extraction query.
+#[derive(Debug, Clone, PartialEq)]
+pub struct PeakTolerance {
+    pub ms: MzTolerance,
+    pub mobility: MobilityTolerance,
+    pub quad: QuadTolerance,
+}
+impl Tolerance {
+    pub fn peak_tolerance(&self) -> PeakTolerance {
+        PeakTolerance {
+            ms: self.ms.clone(),
+            mobility: self.mobility.clone(),
+            quad: self.quad.clone(),
+        }
+    }
+}
+impl Default for PeakTolerance {
+    fn default() -> Self {
+        Tolerance::default().peak_tolerance()
+    }
+}
+impl PeakTolerance {
+    pub fn mz_range(&self, mz: f64) -> TupleRange<f64> {
+        match self.ms {
+            MzTolerance::Absolute((low, high)) => (mz - low, mz + high)
+                .try_into()
+                .expect(Tolerance::MZ_RANGE_INVARIANT),
+            MzTolerance::Ppm((low, high)) => {
+                let low = mz * low / 1e6;
+                let high = mz * high / 1e6;
+                (mz - low, mz + high)
+                    .try_into()
+                    .expect(Tolerance::MZ_RANGE_INVARIANT)
+            }
+        }
+    }
+
+    pub fn mz_range_f32(&self, mz: f32) -> TupleRange<f32> {
+        let tmp = self.mz_range(mz as f64);
+        (tmp.start() as f32, tmp.end() as f32).try_into().unwrap()
+    }
+
+    pub fn mobility_range(&self, mobility: f32) -> OptionallyRestricted<TupleRange<f32>> {
+        match self.mobility {
+            MobilityTolerance::Absolute((low, high)) => {
+                Restricted((mobility - low, mobility + high).try_into().unwrap())
+            }
+            MobilityTolerance::Pct((low, high)) => {
+                let low = mobility * (low / 100.0);
+                let high = mobility * (high / 100.0);
+                Restricted((mobility - low, mobility + high).try_into().unwrap())
+            }
+            MobilityTolerance::Unrestricted => Unrestricted,
+        }
+    }
+
+    pub fn mobility_range_f16(&self, mobility: f32) -> OptionallyRestricted<TupleRange<f16>> {
+        let tmp = self.mobility_range(mobility);
+        match tmp {
+            Restricted(x) => Restricted(
+                (f16::from_f32(x.start()), f16::from_f32(x.end()))
+                    .try_into()
+                    .unwrap(),
+            ),
+            Unrestricted => Unrestricted,
+        }
+    }
+
+    pub fn quad_range_f32(&self, precursor_mz_range: (f32, f32)) -> TupleRange<f32> {
+        let tmp = self.quad_range((precursor_mz_range.0 as f64, precursor_mz_range.1 as f64));
+        (tmp.start() as f32, tmp.end() as f32).try_into().unwrap()
+    }
+
+    pub fn quad_range(&self, precursor_mz_range: (f64, f64)) -> TupleRange<f64> {
+        match self.quad {
+            QuadTolerance::Absolute((low, high)) => {
+                let mz_low = precursor_mz_range.0.min(precursor_mz_range.1) - (low as f64);
+                let mz_high = precursor_mz_range.1.max(precursor_mz_range.0) + (high as f64);
+                assert!(mz_low <= mz_high);
+                assert!(
+                    mz_low > 0.0,
+                    "Precursor mz is 0 or less, inputs: self: {:?}, precursor_mz_range: {:?}",
+                    self,
+                    precursor_mz_range,
+                );
+                (mz_low, mz_high).try_into().unwrap()
+            }
+        }
+    }
+}
diff --git a/rust/timsquery/src/serde/chromatogram_output.rs b/rust/timsquery/src/serde/chromatogram_output.rs
index bc0b0225..72b9d2d8 100644
--- a/rust/timsquery/src/serde/chromatogram_output.rs
+++ b/rust/timsquery/src/serde/chromatogram_output.rs
@@ -129,7 +129,7 @@ impl ChromatogramOutput {
         Ok(ChromatogramOutput {
             id: source_id.to_owned_id(),
             mobility_ook0: collector.mobility_ook0,
-            rt_seconds: collector.rt_seconds,
+            rt_seconds: collector.rt.center().map_or(f32::NAN, |r| r.0),
             precursor_mzs,
             fragment_mzs,
             precursor_intensities,
diff --git a/rust/timsquery/src/serde/diann_io.rs b/rust/timsquery/src/serde/diann_io.rs
index 9c9ec994..f3e0c258 100644
--- a/rust/timsquery/src/serde/diann_io.rs
+++ b/rust/timsquery/src/serde/diann_io.rs
@@ -1,5 +1,5 @@
 use super::precursor_extras::PrecursorExtras;
-use crate::Target;
+use crate::OwnedTarget;
 use crate::ion::{
     IonAnnot,
     IonParsingError,
@@ -293,7 +293,7 @@ struct ParquetColumnData<'a> {
 
 pub fn read_targets<T: AsRef<Path>>(
     file: T,
-) -> Result<Vec<(Target<IonAnnot>, PrecursorExtras)>, DiannReadingError> {
+) -> Result<Vec<(OwnedTarget<IonAnnot>, PrecursorExtras)>, DiannReadingError> {
     let file_handle = std::fs::File::open(file.as_ref())?;
 
     let mut rdr = csv::ReaderBuilder::new()
@@ -401,7 +401,7 @@ fn parse_precursor_group(
     naming: Naming,
     rows: &[DiannLibraryRow],
     buffers: &mut ParsingBuffers,
-) -> Result<(Target<IonAnnot>, PrecursorExtras), DiannPrecursorParsingError> {
+) -> Result<(OwnedTarget<IonAnnot>, PrecursorExtras), DiannPrecursorParsingError> {
     if rows.is_empty() {
         error!("Empty precursor group encountered on {id}");
         return Err(DiannPrecursorParsingError::Other);
@@ -502,14 +502,14 @@ fn parse_precursor_group(
         relative_intensities,
     };
 
-    let eg = Target::builder()
+    let eg = OwnedTarget::builder()
         .id(naming.id_for(
             id,
             first_row.transition_group_id.as_deref(),
             &first_row.modified_peptide,
         )?)
         .mobility_ook0(mobility)
-        .rt_seconds(rt_seconds)
+        .rt_value(rt_seconds)
         .fragment_labels(buffers.fragment_labels.as_slice().into())
         .fragment_mzs(fragment_mzs)
         .precursor_labels(tiny_vec![0]) // Single monoisotopic precursor
@@ -523,7 +523,7 @@ fn parse_precursor_group(
 /// Read a DIA-NN spectral library from a parquet file (DiaNN 2.2+ format)
 pub fn read_parquet_library_file<T: AsRef<Path>>(
     file: T,
-) -> Result<Vec<(Target<IonAnnot>, PrecursorExtras)>, DiannReadingError> {
+) -> Result<Vec<(OwnedTarget<IonAnnot>, PrecursorExtras)>, DiannReadingError> {
     use arrow::record_batch::RecordBatch;
     use parquet::arrow::arrow_reader::ParquetRecordBatchReaderBuilder;
 
@@ -741,7 +741,7 @@ fn parse_precursor_group_from_parquet(
     indices: &[usize],
     columns: &ParquetColumnData,
     buffers: &mut ParsingBuffers,
-) -> Result<(Target<IonAnnot>, PrecursorExtras), DiannPrecursorParsingError> {
+) -> Result<(OwnedTarget<IonAnnot>, PrecursorExtras), DiannPrecursorParsingError> {
     if indices.is_empty() {
         error!("Empty precursor group encountered on {id}");
         return Err(DiannPrecursorParsingError::Other);
@@ -840,14 +840,14 @@ fn parse_precursor_group_from_parquet(
         relative_intensities: rel_intensities,
     };
 
-    let eg = Target::builder()
+    let eg = OwnedTarget::builder()
         .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)
+        .rt_value(rt_seconds)
         .fragment_labels(buffers.fragment_labels.as_slice().into())
         .fragment_mzs(fragment_mzs)
         .precursor_labels(tiny_vec![0])
@@ -998,7 +998,7 @@ AAAAAAALQAK\tAAAAAAALQAK\t478.7\t2\t11.0\t0.9\tP2\t0\t300.0\ty\t3\t1\tnoloss\t1.
         // Labels as a set: the reader's fragment order is not part of the
         // contract being tested here. Keyed on the mzPAF spelling because
         // `IonAnnot` is deliberately not `Ord`.
-        fn label_set(eg: &Target<IonAnnot>) -> Vec<String> {
+        fn label_set(eg: &OwnedTarget<IonAnnot>) -> Vec<String> {
             let mut out: Vec<String> = eg
                 .iter_fragments()
                 .map(|(label, _mz)| label.to_string())
diff --git a/rust/timsquery/src/serde/diann_speclib_io.rs b/rust/timsquery/src/serde/diann_speclib_io.rs
index f67b06ed..2e01de6c 100644
--- a/rust/timsquery/src/serde/diann_speclib_io.rs
+++ b/rust/timsquery/src/serde/diann_speclib_io.rs
@@ -650,7 +650,15 @@ fn append_arena(dst: &mut TargetColumnsBuilder<IonAnnot>, src: TargetColumnsBuil
 
     dst.precursor_mz.append(&mut src.precursor_mz);
     dst.charge.append(&mut src.charge);
-    dst.rt_seconds.append(&mut src.rt_seconds);
+    if dst.rt_values.is_empty() {
+        dst.rt_axis = src.rt_axis.clone();
+    } else if !src.rt_values.is_empty() && dst.rt_axis != src.rt_axis {
+        dst.rt_error = Some("incompatible RT axes in library shards".into());
+    }
+    if src.rt_error.is_some() {
+        dst.rt_error = src.rt_error.take();
+    }
+    dst.rt_values.append(&mut src.rt_values);
     dst.mobility.append(&mut src.mobility);
     dst.is_decoy.append(&mut src.is_decoy);
     dst.pending_ids.append(&mut src.pending_ids);
@@ -846,7 +854,10 @@ fn map_entry(
         charge: charge as u8,
         // Library iRT is dimensionless here; keep it raw (no minute->second
         // scaling) -- Phase 1 RT tolerance is unrestricted.
-        rt_seconds: pep.i_rt(),
+        rt: Some(crate::models::RtCoordinate {
+            value: calibrt::LibraryRT(pep.i_rt()),
+            axis: &crate::models::RtAxis::NormalizedIndex { scale: None },
+        }),
         mobility: pep.i_im(),
         frags: &frags,
         analyte: crate::chemistry::analyte::Analyte::from_sequence(&modified_peptide).as_input(),
@@ -1001,6 +1012,36 @@ 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.
 
+    #[test]
+    fn shard_merge_preserves_rt_axis_and_rejects_incompatible_presence() {
+        fn shard(rt: Option<crate::RtCoordinate<'_>>) -> TargetColumnsBuilder<IonAnnot> {
+            let mut builder =
+                TargetColumnsBuilder::with_capabilities(TargetCapabilities::default_diann());
+            builder.push_row(Row {
+                rt,
+                charge: 2,
+                precursor_mz: 500.0,
+                ..Default::default()
+            });
+            builder
+        }
+        let axis = crate::RtAxis::NormalizedIndex { scale: None };
+        let index = Some(crate::RtCoordinate {
+            value: crate::LibraryRT(-20.0),
+            axis: &axis,
+        });
+        let mut merged = shard(index);
+        append_arena(&mut merged, shard(index));
+        let geom = merged.seal(DecoyPolicy::Never).unwrap();
+        assert_eq!(geom.rt_axis(), &axis);
+        assert_eq!(geom.n_rows(), 2);
+        for rt in [None, Some(crate::RtCoordinate::seconds(120.0))] {
+            let mut merged = shard(index);
+            append_arena(&mut merged, shard(rt));
+            assert!(merged.seal(DecoyPolicy::Never).is_err());
+        }
+    }
+
     #[test]
     fn test_sniff_diann_speclib() {
         assert!(
@@ -1079,7 +1120,7 @@ mod tests {
         assert_eq!(geom.charge[0], 2);
         assert!((geom.precursor_mz[0] - 654.85541).abs() < 1e-3);
         // Library iRT kept raw (dimensionless), not scaled to seconds.
-        assert!((geom.rt_seconds[0] - (-3.8674114)).abs() < 1e-3);
+        assert!((geom.rt_values[0] - (-3.8674114)).abs() < 1e-3);
         assert!((geom.mobility[0] - 1.0254545).abs() < 1e-4);
 
         // The fixture has Peptide.length == 0, so y-series is recovered from the
@@ -1140,7 +1181,7 @@ mod tests {
         );
         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.rt_values[532] - (-31.935_83)).abs() < 1e-3);
         assert!((geom.mobility[532] - 0.9704546).abs() < 1e-4);
         assert_eq!(geom.frag_range(row(&geom, 532)).len(), 6);
     }
diff --git a/rust/timsquery/src/serde/elution_group_inputs.rs b/rust/timsquery/src/serde/elution_group_inputs.rs
index 53f5eee8..fe7e862b 100644
--- a/rust/timsquery/src/serde/elution_group_inputs.rs
+++ b/rust/timsquery/src/serde/elution_group_inputs.rs
@@ -2,13 +2,14 @@ use crate::ion::{
     IonAnnot,
     UnknownIonCounter,
 };
+use crate::models::target::legacy_rt_axis;
 use crate::tinyvec::{
     TinyVec,
     tiny_vec,
 };
 use crate::{
     KeyLike,
-    Target,
+    OwnedTarget,
 };
 
 #[derive(Debug)]
@@ -35,6 +36,8 @@ pub struct ElutionGroupInput<T: KeyLike> {
     pub id: u64,
     pub mobility: f32,
     pub rt_seconds: f32,
+    #[serde(default = "legacy_rt_axis")]
+    pub rt_axis: crate::RtAxis,
     #[serde(alias = "precursor_mz")]
     #[serde(alias = "precursor_mono_mz")]
     pub precursor: f64,
@@ -67,6 +70,7 @@ impl<T: KeyLike> ElutionGroupInput<T> {
             id: self.id,
             mobility: self.mobility,
             rt_seconds: self.rt_seconds,
+            rt_axis: self.rt_axis,
             precursor: self.precursor,
             precursor_charge: self.precursor_charge,
             precursor_isotopes: self.precursor_isotopes,
@@ -95,6 +99,7 @@ impl<T: KeyLike> ElutionGroupInput<T> {
             id: self.id,
             mobility: self.mobility,
             rt_seconds: self.rt_seconds,
+            rt_axis: self.rt_axis,
             precursor: self.precursor,
             precursor_charge: self.precursor_charge,
             precursor_isotopes: self.precursor_isotopes,
@@ -104,14 +109,15 @@ impl<T: KeyLike> ElutionGroupInput<T> {
     }
 }
 
-impl<T: KeyLike, U: TryInto<T> + KeyLike> TryFrom<ElutionGroupInput<U>> for Target<T> {
+impl<T: KeyLike, U: TryInto<T> + KeyLike> TryFrom<ElutionGroupInput<U>> for OwnedTarget<T> {
     type Error = ElutionGroupInputError;
 
     fn try_from(val: ElutionGroupInput<U>) -> Result<Self, Self::Error> {
-        let builder = Target::builder()
+        let builder = OwnedTarget::builder()
             .id(val.id)
             .mobility_ook0(val.mobility)
-            .rt_seconds(val.rt_seconds)
+            .rt_value(val.rt_seconds)
+            .rt_axis(val.rt_axis)
             .precursor(val.precursor, val.precursor_charge)
             .precursor_labels(if let Some(isotopes) = val.precursor_isotopes {
                 TinyVec::Heap(isotopes.into_iter().collect())
diff --git a/rust/timsquery/src/serde/library_file.rs b/rust/timsquery/src/serde/library_file.rs
index 1c456b35..7f02a77c 100644
--- a/rust/timsquery/src/serde/library_file.rs
+++ b/rust/timsquery/src/serde/library_file.rs
@@ -25,7 +25,7 @@ use super::spectronaut_io::{
     read_targets as read_spectronaut_tsv,
     sniff_spectronaut_library_file,
 };
-use crate::Target;
+use crate::OwnedTarget;
 use crate::ion::IonAnnot;
 use crate::models::capabilities::{
     DecoyPolicy,
@@ -87,8 +87,8 @@ impl From<ElutionGroupInputError> for TargetReadingError {
 
 #[derive(Debug)]
 pub enum ElutionGroupCollection {
-    StringLabels(Vec<Target<String>>, Option<Vec<PrecursorExtras>>),
-    MzpafLabels(Vec<Target<IonAnnot>>, Option<Vec<PrecursorExtras>>),
+    StringLabels(Vec<OwnedTarget<String>>, Option<Vec<PrecursorExtras>>),
+    MzpafLabels(Vec<OwnedTarget<IonAnnot>>, Option<Vec<PrecursorExtras>>),
 }
 
 impl ElutionGroupCollection {
@@ -134,17 +134,17 @@ impl ElutionGroupCollection {
                     .into_iter()
                     .map(|x| x.try_fill_labels_annot())
                     .collect();
-                let out: Result<Vec<Target<IonAnnot>>, ElutionGroupInputError> =
+                let out: Result<Vec<OwnedTarget<IonAnnot>>, ElutionGroupInputError> =
                     filled?.into_iter().map(|x| x.try_into()).collect();
                 return Ok(ElutionGroupCollection::MzpafLabels(out?, None));
             }
-            let out: Result<Vec<Target<IonAnnot>>, ElutionGroupInputError> =
+            let out: Result<Vec<OwnedTarget<IonAnnot>>, ElutionGroupInputError> =
                 eg_inputs.into_iter().map(|x| x.try_into()).collect();
             return Ok(ElutionGroupCollection::MzpafLabels(out?, None));
         }
         debug!("Attempting to deserialize elution group inputs with string labels");
         if let Ok(eg_inputs) = serde_json::from_str::<Vec<ElutionGroupInput<String>>>(content) {
-            let out: Result<Vec<Target<String>>, ElutionGroupInputError> =
+            let out: Result<Vec<OwnedTarget<String>>, ElutionGroupInputError> =
                 eg_inputs.into_iter().map(|x| x.try_into()).collect();
             return Ok(ElutionGroupCollection::StringLabels(out?, None));
         }
@@ -157,11 +157,11 @@ impl ElutionGroupCollection {
         // here only turned a loadable file into a rejection.
         debug!("Attempting direct deserialization of elution groups");
         debug!("Attempting to deserialize elution groups with mzpaf labels");
-        if let Ok(egs) = serde_json::from_str::<Vec<Target<IonAnnot>>>(content) {
+        if let Ok(egs) = serde_json::from_str::<Vec<OwnedTarget<IonAnnot>>>(content) {
             return Ok(ElutionGroupCollection::MzpafLabels(egs, None));
         }
         debug!("Attempting to deserialize elution groups with string labels");
-        if let Ok(egs) = serde_json::from_str::<Vec<Target<String>>>(content) {
+        if let Ok(egs) = serde_json::from_str::<Vec<OwnedTarget<String>>>(content) {
             return Ok(ElutionGroupCollection::StringLabels(egs, None));
         }
         Err(TargetReadingError::UnableToParseElutionGroups)
@@ -205,7 +205,7 @@ impl TargetTable {
     /// modified sequence.
     fn mzpaf_with_intensities(
         decoys: DecoyPolicy,
-        egs: Vec<Target<IonAnnot>>,
+        egs: Vec<OwnedTarget<IonAnnot>>,
         rows: Vec<PrecursorExtras>,
     ) -> Result<Self, TargetReadingError> {
         if egs.len() != rows.len() {
@@ -243,7 +243,7 @@ impl TargetTable {
             geom.push_row(Row {
                 precursor_mz: eg.precursor_mz(),
                 charge: eg.precursor_charge(),
-                rt_seconds: eg.rt_seconds(),
+                rt: eg.rt(),
                 mobility: eg.mobility_ook0(),
                 frags: &frags,
                 analyte: row.analyte.as_input(),
@@ -300,7 +300,7 @@ impl TargetTable {
                     geom.push_row(Row {
                         precursor_mz: eg.precursor_mz(),
                         charge: eg.precursor_charge(),
-                        rt_seconds: eg.rt_seconds(),
+                        rt: eg.rt(),
                         mobility: eg.mobility_ook0(),
                         frags: &frags,
                         id: Some(eg.id().to_owned_id()),
@@ -332,7 +332,7 @@ impl TargetTable {
                     geom.push_row(Row {
                         precursor_mz: eg.precursor_mz(),
                         charge: eg.precursor_charge(),
-                        rt_seconds: eg.rt_seconds(),
+                        rt: eg.rt(),
                         mobility: eg.mobility_ook0(),
                         frags: &frags,
                         id: Some(eg.id().to_owned_id()),
@@ -592,6 +592,59 @@ mod tests {
             .join(name)
     }
 
+    #[test]
+    fn optional_json_labels_do_not_change_rt_coordinates() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("targets.json");
+        for axis in [
+            None,
+            Some(crate::RtAxis::Absent),
+            Some(crate::RtAxis::Seconds),
+            Some(crate::RtAxis::Unspecified),
+            Some(crate::RtAxis::NormalizedIndex {
+                scale: Some("reference".into()),
+            }),
+        ] {
+            for label in ["y3", "opaque"] {
+                for omit_precursors in [false, true] {
+                    for omit_fragments in [false, true] {
+                        let mut entry = serde_json::json!({"id":1, "mobility":1.0, "rt_seconds":20.0,
+                            "precursor_mz":500.0, "precursor_charge":2, "fragments":[300.0],
+                            "fragment_labels":[label], "precursor_labels":[0]});
+                        let fields = entry.as_object_mut().unwrap();
+                        if let Some(axis) = &axis {
+                            fields.insert("rt_axis".into(), serde_json::to_value(axis).unwrap());
+                        }
+                        if omit_precursors {
+                            fields.remove("precursor_labels");
+                        }
+                        if omit_fragments {
+                            fields.remove("fragment_labels");
+                        }
+                        std::fs::write(&path, serde_json::to_vec(&vec![entry]).unwrap()).unwrap();
+                        let table = super::read_targets(&path).unwrap();
+                        let expected = axis.as_ref().unwrap_or(&crate::RtAxis::Seconds);
+                        fn check<L: crate::KeyLike>(
+                            geom: &crate::models::TargetColumns<L>,
+                            expected: &crate::RtAxis,
+                        ) {
+                            assert_eq!(geom.rt_axis(), expected);
+                            let row = geom.rows().next().unwrap();
+                            assert_eq!(
+                                geom.library_rt(row).map(|rt| rt.0),
+                                (expected != &crate::RtAxis::Absent).then_some(20.0)
+                            );
+                        }
+                        match table {
+                            super::TargetTable::Mzpaf { geom, .. } => check(&geom, expected),
+                            super::TargetTable::Str { geom, .. } => check(&geom, expected),
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     /// JSON naming no fragment labels loads, with labels minted.
     ///
     /// The arena has no integer-labelled variant, so minting `u8` labels for
diff --git a/rust/timsquery/src/serde/mzspeclib_io.rs b/rust/timsquery/src/serde/mzspeclib_io.rs
index 01295e06..5a9091fb 100644
--- a/rust/timsquery/src/serde/mzspeclib_io.rs
+++ b/rust/timsquery/src/serde/mzspeclib_io.rs
@@ -34,6 +34,10 @@ use std::collections::HashSet;
 use std::io::BufRead;
 use std::path::Path;
 
+use crate::models::{
+    RtAxis,
+    RtCoordinate,
+};
 use micromzpaf::{
     IonAnnot,
     IonSeriesOrdinal,
@@ -49,12 +53,16 @@ use mzannotate::mzdata::params::{
     ParamValue,
 };
 use mzannotate::mzdata::prelude::PeakCollection;
+use mzannotate::mzspeclib::record::{
+    HeaderView,
+    MzSpecLibLibrary,
+    SpectrumRecord,
+};
 use mzannotate::mzspeclib::{
     AnalyteTarget,
     Attribute,
     AttributeValue,
     EntryType,
-    LibraryHeader,
     MzSpecLibTextParser,
 };
 use mzannotate::spectrum::AnnotatedSpectrum;
@@ -220,7 +228,7 @@ fn read_counting_degradation(
         policy.unannotated
     };
     let reader = open_reader(path)?;
-    let parser = MzSpecLibTextParser::open(reader, Some(path.to_path_buf()), ontologies())
+    let mut parser = MzSpecLibLibrary::open(reader, Some(path.to_path_buf()), ontologies())
         .map_err(|e| TargetReadingError::SpeclibParse(format!("mzSpecLib header: {e}")))?;
 
     let mut geom = TargetColumnsBuilder::with_capabilities(TargetCapabilities::default_diann());
@@ -230,19 +238,23 @@ fn read_counting_degradation(
     // the only place it can be read: it is what an entry declaring nothing about
     // its mass provenance falls back to.
     let library_theoretical_mz = library_declares_theoretical_mz(parser.header());
+    let normalized_axis = normalized_rt_axis(parser.header());
     let spectrum_attribute_sets: HashSet<String> = parser
         .header()
-        .attribute_classes
-        .get(&EntryType::Spectrum)
-        .into_iter()
-        .flatten()
-        .map(|set| set.id.clone())
+        .attribute_sets()
+        .filter(|s| s.entry_type() == EntryType::Spectrum)
+        .map(|s| s.name().to_owned())
         .collect();
-
-    for (index, spectrum) in parser.enumerate() {
-        let spectrum = spectrum.map_err(|e| {
-            TargetReadingError::SpeclibParse(format!("mzSpecLib spectrum {}: {e}", index + 1))
-        })?;
+    let mut reader = parser.reader();
+    let mut record = reader.empty_record();
+    while reader
+        .read_into(&mut record)
+        .map_err(|e| TargetReadingError::SpeclibParse(e.to_string()))?
+    {
+        let rt = record_rt(&record, &normalized_axis)?;
+        let spectrum = record
+            .materialize()
+            .map_err(|e| TargetReadingError::SpeclibParse(e.to_string()))?;
         let row = SpectrumRow::extract(
             &spectrum,
             library_theoretical_mz,
@@ -280,7 +292,7 @@ fn read_counting_degradation(
         geom.push_row(Row {
             precursor_mz: row.precursor_mz,
             charge: row.charge,
-            rt_seconds: row.rt_seconds,
+            rt,
             mobility: row.mobility,
             frags: &row.frags,
             analyte: row.analyte.as_input(),
@@ -345,10 +357,8 @@ struct Degradation {
     peaks_over_the_label_ceiling: usize,
     rows_without_sequence: usize,
     rows_without_fragments: usize,
-    // No count of entries missing a retention time. Zero is an ordinary value
-    // on a normalized scale rather than an absence -- it is an anchor point, and
-    // it is what msspeculator's own libraries write -- so there is nothing to
-    // test for. See the CONTEXT.md entry on retention time.
+    // TargetColumnsBuilder checks RT consistency on insertion;
+    // seal rejects mixed availability or axes.
 }
 
 impl Degradation {
@@ -422,7 +432,6 @@ struct SpectrumRow {
     entry_name: Option<String>,
     precursor_mz: f64,
     charge: u8,
-    rt_seconds: f32,
     mobility: f32,
     is_decoy: bool,
     declared_group: Option<String>,
@@ -551,7 +560,6 @@ impl SpectrumRow {
                 .then(|| spectrum.description.id.clone()),
             precursor_mz: precursor_mz(spectrum, peptidoform),
             charge: charge(spectrum, peptidoform),
-            rt_seconds: rt_seconds(spectrum),
             mobility: mobility(spectrum),
             is_decoy: is_decoy(spectrum)?,
             declared_group: declared_group(spectrum),
@@ -646,23 +654,75 @@ fn charge(spectrum: &Spectrum, peptidoform: Option<&mzcore::sequence::Peptidofor
         .unwrap_or(0)
 }
 
-/// Whatever the file's retention time is, scaled from the minutes mzannotate
-/// normalises every declared unit into.
-///
-/// Not necessarily a duration. `MS:1000896|normalized retention time` is an
-/// index on a reference scale, which is what msspeculator writes and what the
-/// Spectronaut export carries, so this can hold a dimensionless value where
-/// zero and negative numbers are ordinary. Calibration fits a monotone path
-/// from it to observed time, so ordering is what has to survive here, not
-/// units. See the CONTEXT.md entry on retention time.
-fn rt_seconds(spectrum: &Spectrum) -> f32 {
-    const SECONDS_PER_MINUTE: f64 = 60.0;
-    spectrum
-        .description
-        .acquisition
-        .scans
-        .first()
-        .map_or(0.0, |scan| (scan.start_time * SECONDS_PER_MINUTE) as f32)
+/// Read the raw coordinate with its grouped unit before legacy materialization.
+/// Measured time takes precedence; normalized indices never undergo unit scaling.
+fn record_rt<'axis>(
+    record: &SpectrumRecord<'_>,
+    normalized_axis: &'axis RtAxis,
+) -> Result<Option<RtCoordinate<'axis>>, TargetReadingError> {
+    let error = |message: String| {
+        TargetReadingError::SpeclibParse(format!("spectrum {:?} RT: {message}", record.key()))
+    };
+    let attrs = record.attributes().map_err(|e| error(e.to_string()))?;
+    for (accession, normalized) in [
+        (mzcv::curie!(MS:1000894), false),
+        (mzcv::curie!(MS:1000896), true),
+    ] {
+        let mut selected = None;
+        for attr in attrs.by_accession(accession) {
+            let mut value = attr.to_f64().map_err(|e| error(e.to_string()))?;
+            let axis = if normalized {
+                normalized_axis
+            } else {
+                let units: Vec<_> = attr
+                    .group()
+                    .into_iter()
+                    .flat_map(|g| g.by_accession(mzcv::curie!(UO:0000000)).collect::<Vec<_>>())
+                    .map(|u| u.raw_value())
+                    .collect();
+                match units.as_slice() {
+                    [] => &RtAxis::Unspecified,
+                    [unit] if unit.starts_with("UO:0000010|") || *unit == "UO:0000010" => {
+                        &RtAxis::Seconds
+                    }
+                    [unit] if unit.starts_with("UO:0000031|") || *unit == "UO:0000031" => {
+                        value *= 60.0;
+                        &RtAxis::Seconds
+                    }
+                    _ => return Err(error("unknown or ambiguous measured RT unit".into())),
+                }
+            };
+            let value = value as f32;
+            if !value.is_finite() {
+                return Err(error("RT is not finite".into()));
+            }
+            let next = (value, axis);
+            if selected.as_ref().is_some_and(|old| old != &next) {
+                return Err(error("conflicting RT declarations".into()));
+            }
+            selected = Some(next);
+        }
+        if selected.is_some() {
+            return Ok(selected.map(|(value, axis)| RtCoordinate {
+                value: calibrt::LibraryRT(value),
+                axis,
+            }));
+        }
+    }
+    Ok(None)
+}
+
+/// Header provenance describes a possible normalized scale. Records still
+/// select the actual axis; a declaration alone does not make RT present.
+fn normalized_rt_axis(header: HeaderView<'_>) -> RtAxis {
+    let scale = header
+        .attributes()
+        .by_accession(mzcv::curie!(MS:1003275))
+        .find(|attr| attr.raw_value() == "msspeculator:retention.normalized.scale")
+        .and_then(|attr| attr.group())
+        .and_then(|group| group.by_accession(mzcv::curie!(MS:1003276)).next())
+        .map(|value| value.raw_value().to_owned());
+    RtAxis::NormalizedIndex { scale }
 }
 
 /// `MS:1002815|inverse reduced ion mobility` first, because that is the axis a
@@ -803,19 +863,12 @@ fn peak_mz_is_theoretical(spectrum: &Spectrum, library_declares_theoretical_mz:
 ///
 /// The header is parsed by `MzSpecLibTextParser::open`, so this is answerable
 /// before the first entry is yielded.
-fn library_declares_theoretical_mz(header: &LibraryHeader) -> bool {
-    header
-        .attribute_classes
-        .get(&EntryType::Spectrum)
-        .into_iter()
-        .flatten()
-        .filter(|set| set.id == "all")
-        .flat_map(|set| set.attributes.iter().flatten())
-        .filter(|attribute| {
-            attribute.name.accession == mzcv::curie!(MS:1003072)
-                || attribute.name.accession == mzcv::curie!(MS:1003065)
-        })
-        .filter_map(|attribute| ms_accession(&attribute.value.to_string()))
+fn library_declares_theoretical_mz(header: HeaderView<'_>) -> bool {
+    header.attribute_sets()
+        .filter(|s| s.entry_type() == EntryType::Spectrum && s.name() == "all")
+        .flat_map(|s| s.attributes().iter())
+        .filter(|a| matches!(a.accession(), Some(x) if x == mzcv::curie!(MS:1003072) || x == mzcv::curie!(MS:1003065)))
+        .filter_map(|a| ms_accession(a.raw_value()))
         .any(declares_theoretical_mz)
 }
 
@@ -1022,6 +1075,126 @@ mod tests {
     use crate::models::capabilities::DecoyPolicy;
     use std::path::PathBuf;
 
+    fn rt_library(
+        header: &str,
+        rows: &[&str],
+    ) -> Result<TargetColumns<IonAnnot>, TargetReadingError> {
+        let mut text = format!(
+            "<mzSpecLib>\nMS:1003186|library format version=1.0\nMS:1003188|library name=rt\n{header}"
+        );
+        for (i, rt) in rows.iter().enumerate() {
+            text.push_str(&format!("<Spectrum={}>\nMS:1003061|library spectrum name=entry{i}\nMS:1000744|selected ion m/z=500\n{rt}MS:1003059|number of peaks=1\n<Analyte=1>\nMS:1000041|charge state=2\n<Peaks>\n100.0\t10.0\n", i + 1));
+        }
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("rt.mzspeclib.txt");
+        std::fs::write(&path, text).unwrap();
+        match read_mzspeclib_library_file(&path, LoadPolicy::default())? {
+            TargetTable::Mzpaf { geom, .. } => Ok(geom),
+            _ => unreachable!(),
+        }
+    }
+
+    #[test]
+    fn measured_rt_converts_units_and_preserves_zero() {
+        let geom = rt_library(
+            "",
+            &[
+                "[1]MS:1000894|retention time=2\n[1]UO:0000000|unit=UO:0000031|minute\n",
+                "[1]MS:1000894|retention time=120\n[1]UO:0000000|unit=UO:0000010|second\n",
+                "[1]MS:1000894|retention time=0\n[1]UO:0000000|unit=UO:0000010|second\n",
+            ],
+        )
+        .unwrap();
+        assert_eq!(geom.rt_axis(), &RtAxis::Seconds);
+        assert_eq!(
+            geom.rows()
+                .map(|r| geom.library_rt(r).map(|rt| rt.0))
+                .collect::<Vec<_>>(),
+            vec![Some(120.0), Some(120.0), Some(0.0)]
+        );
+    }
+
+    #[test]
+    fn records_select_the_axis_even_when_the_header_declares_a_normalized_scale() {
+        let header = "[1]MS:1003275|other attribute name=unrelated\n[1]MS:1003276|other attribute value=wrong scale\n[2]MS:1003275|other attribute name=msspeculator:retention.normalized.scale\n[2]MS:1003276|other attribute value=reference anchors\n";
+        let normalized = "MS:1000896|normalized retention time=-20\n";
+        let geom = rt_library(header, &[normalized, normalized]).unwrap();
+        assert_eq!(
+            geom.rt_axis(),
+            &RtAxis::NormalizedIndex {
+                scale: Some("reference anchors".into())
+            }
+        );
+        assert!(
+            geom.rows()
+                .all(|r| geom.library_rt(r).map(|rt| rt.0) == Some(-20.0))
+        );
+        let measured = "[1]MS:1000894|retention time=2\n[1]UO:0000000|unit=UO:0000031|minute\nMS:1000896|normalized retention time=-20\n";
+        let geom = rt_library(header, &[measured]).unwrap();
+        assert_eq!(geom.rt_axis(), &RtAxis::Seconds);
+        assert_eq!(
+            geom.library_rt(geom.rows().next().unwrap()).map(|rt| rt.0),
+            Some(120.0)
+        );
+        assert_eq!(
+            rt_library(header, &["", ""]).unwrap().rt_axis(),
+            &RtAxis::Absent
+        );
+        assert!(rt_library(header, &["", normalized]).is_err());
+        assert!(rt_library(header, &[normalized, measured]).is_err());
+    }
+
+    #[test]
+    fn normalized_rt_is_not_a_duration() {
+        let geom = rt_library("", &[
+            "[1]MS:1000896|normalized retention time=-12\n[1]UO:0000000|unit=UO:0000031|minute\n",
+            "[1]MS:1000896|normalized retention time=0\n[1]UO:0000000|unit=UO:0000031|minute\n",
+        ]).unwrap();
+        assert_eq!(geom.rt_axis(), &RtAxis::NormalizedIndex { scale: None });
+        assert_eq!(
+            geom.rows()
+                .map(|r| geom.library_rt(r).map(|rt| rt.0))
+                .collect::<Vec<_>>(),
+            vec![Some(-12.0), Some(0.0)]
+        );
+    }
+
+    #[test]
+    fn absent_and_unspecified_rt_are_distinct_and_mixtures_are_rejected() {
+        let absent = rt_library("", &["", ""]).unwrap();
+        assert_eq!(absent.rt_axis(), &RtAxis::Absent);
+        assert!(
+            absent
+                .rows()
+                .all(|r| absent.library_rt(r).map(|rt| rt.0).is_none())
+        );
+        let present = "MS:1000894|retention time=0\n";
+        let geom = rt_library("", &[present]).unwrap();
+        assert_eq!(geom.rt_axis(), &RtAxis::Unspecified);
+        assert_eq!(
+            geom.library_rt(geom.rows().next().unwrap()).map(|rt| rt.0),
+            Some(0.0)
+        );
+        for rows in [
+            [present, ""],
+            ["", present],
+            [present, "MS:1000896|normalized retention time=0\n"],
+        ] {
+            let err = format!("{:?}", rt_library("", &rows).unwrap_err());
+            assert!(err.contains("mixed RT"), "{err}");
+        }
+    }
+
+    #[test]
+    fn inherited_grouped_rt_keeps_its_unit() {
+        let geom = rt_library("<AttributeSet Spectrum=all>\n[1]MS:1000894|retention time=2\n[1]UO:0000000|unit=UO:0000031|minute\n", &["", ""]).unwrap();
+        assert_eq!(geom.rt_axis(), &RtAxis::Seconds);
+        assert!(
+            geom.rows()
+                .all(|r| geom.library_rt(r).map(|rt| rt.0) == Some(120.0))
+        );
+    }
+
     fn fixture(name: &str) -> PathBuf {
         PathBuf::from(env!("CARGO_MANIFEST_DIR"))
             .join("tests/mzspeclib_files")
@@ -1377,7 +1550,11 @@ mod tests {
         let first = diann.rows().next().unwrap();
         assert!((diann.precursor_mz(first) - 778.412_96).abs() < 1e-4);
         assert_eq!(diann.charge(first), 2);
-        assert_eq!(diann.rt_seconds(first), 0.0, "DIA-NN declares no RT");
+        assert_eq!(
+            diann.library_rt(first).map(|rt| rt.0),
+            None,
+            "DIA-NN declares no RT"
+        );
         assert_eq!(diann.output_id(first).to_string(), "AAAAAAAAAAAAAAAASAGGK2");
 
         // Spectronaut writes `MS:1003208|experimental precursor monoisotopic
@@ -1392,7 +1569,7 @@ mod tests {
             "ion mobility drift time, the spelling both exports use"
         );
         assert!(
-            spectronaut.rt_seconds(first) > 0.0,
+            spectronaut.library_rt(first).map(|rt| rt.0).unwrap() > 0.0,
             "Spectronaut declares RT"
         );
     }
@@ -1436,7 +1613,10 @@ mod tests {
             );
             assert_eq!(plain.precursor_mz(a), gzipped.precursor_mz(b));
             assert_eq!(plain.charge(a), gzipped.charge(b));
-            assert_eq!(plain.rt_seconds(a), gzipped.rt_seconds(b));
+            assert_eq!(
+                plain.library_rt(a).map(|rt| rt.0),
+                gzipped.library_rt(b).map(|rt| rt.0)
+            );
             assert_eq!(plain.mobility(a), gzipped.mobility(b));
             assert_eq!(plain.frag_mzs(a), gzipped.frag_mzs(b));
             assert_eq!(plain.frag_labels(a), gzipped.frag_labels(b));
@@ -1669,17 +1849,12 @@ mod tests {
             "VLSAAKPEDR"
         );
         assert_eq!(geom.frag_labels(first).len(), 4);
-        // The only fixture declaring `MS:1000896` in `minute`, and so the only
-        // one that pins the minute path: the entry says 1.559414, and 60x that
-        // is what a reader has to come back with. Which mzannotate build is in
-        // the graph decides it -- the pinned one leaves a `minute`-declared
-        // value alone for the `* 60` here to scale, a release divides it by
-        // sixty first and hands back a sixtieth of the number.
-        assert!(
-            (geom.rt_seconds(first) - 93.564_84).abs() < 1e-3,
-            "declared 1.559414 minute, got {} s",
-            geom.rt_seconds(first),
+        // Normalized RT remains an index, even when the exporter labels it minute.
+        assert_eq!(
+            geom.rt_axis(),
+            &crate::RtAxis::NormalizedIndex { scale: Some("linear interpolation anchored at TFAHTESHISK = 0 and SILDYVSLVEK = 100 (PROCAL standards, PROSPECT convention)".into()) }
         );
+        assert!((geom.library_rt(first).map(|rt| rt.0).unwrap() - 1.559414).abs() < 1e-5);
     }
 
     /// A third-party library carries no `msspeculator:` attributes and no
@@ -1709,7 +1884,10 @@ mod tests {
     #[test]
     fn every_declared_retention_time_survives_the_load() {
         let geom = arena("target_decoy_attribute_set.mzspeclib.txt");
-        let rts: Vec<f32> = geom.rows().map(|r| geom.rt_seconds(r)).collect();
+        let rts: Vec<f32> = geom
+            .rows()
+            .map(|r| geom.library_rt(r).map(|rt| rt.0).unwrap())
+            .collect();
 
         // Read straight off the fixture, target and decoy of each pair sharing
         // one value.
diff --git a/rust/timsquery/src/serde/psims_origin_type.rs b/rust/timsquery/src/serde/psims_origin_type.rs
index 02d26ee8..d6610258 100644
--- a/rust/timsquery/src/serde/psims_origin_type.rs
+++ b/rust/timsquery/src/serde/psims_origin_type.rs
@@ -14,7 +14,7 @@
 /// `--check` compares this against the published ontology, so most
 /// releases will report a difference that leaves the table unchanged.
 /// Regenerating then edits only this line.
-pub const DATA_VERSION: &str = "4.1.261";
+pub const DATA_VERSION: &str = "4.2.2";
 
 /// One `spectrum origin type` term, and what it implies for a reader.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
diff --git a/rust/timsquery/src/serde/skyline_io.rs b/rust/timsquery/src/serde/skyline_io.rs
index 26c0b65a..38603924 100644
--- a/rust/timsquery/src/serde/skyline_io.rs
+++ b/rust/timsquery/src/serde/skyline_io.rs
@@ -1,5 +1,5 @@
 use super::precursor_extras::PrecursorExtras;
-use crate::Target;
+use crate::OwnedTarget;
 use crate::ion::{
     IonAnnot,
     IonParsingError,
@@ -229,7 +229,7 @@ struct ParsingBuffers {
 
 pub fn read_targets<T: AsRef<Path>>(
     file: T,
-) -> Result<Vec<(Target<IonAnnot>, PrecursorExtras)>, SkylineReadingError> {
+) -> Result<Vec<(OwnedTarget<IonAnnot>, PrecursorExtras)>, SkylineReadingError> {
     let file_handle = std::fs::File::open(file.as_ref())?;
 
     let mut rdr = csv::ReaderBuilder::new()
@@ -282,7 +282,7 @@ fn parse_precursor_group(
     id: u64,
     rows: &[SkylineLibraryRow],
     buffers: &mut ParsingBuffers,
-) -> Result<Option<(Target<IonAnnot>, PrecursorExtras)>, SkylinePrecursorParsingError> {
+) -> Result<Option<(OwnedTarget<IonAnnot>, PrecursorExtras)>, SkylinePrecursorParsingError> {
     if rows.is_empty() {
         error!("Empty precursor group encountered on {id}");
         return Err(SkylinePrecursorParsingError::Other);
@@ -383,10 +383,11 @@ fn parse_precursor_group(
         relative_intensities,
     };
 
-    let eg = Target::builder()
+    let eg = OwnedTarget::builder()
         .id(id)
         .mobility_ook0(0.0)
-        .rt_seconds(0.0)
+        .rt_value(0.0)
+        .rt_axis(crate::models::RtAxis::Absent)
         .fragment_labels(buffers.fragment_labels.as_slice().into())
         .fragment_mzs(fragment_mzs)
         .precursor_labels(tiny_vec![0])
diff --git a/rust/timsquery/src/serde/spectronaut_io.rs b/rust/timsquery/src/serde/spectronaut_io.rs
index 4834dbf6..0591dc6e 100644
--- a/rust/timsquery/src/serde/spectronaut_io.rs
+++ b/rust/timsquery/src/serde/spectronaut_io.rs
@@ -1,5 +1,5 @@
 use super::precursor_extras::PrecursorExtras;
-use crate::Target;
+use crate::OwnedTarget;
 use crate::ion::{
     IonAnnot,
     IonParsingError,
@@ -203,7 +203,7 @@ struct ParsingBuffers {
 
 pub fn read_targets<T: AsRef<Path>>(
     file: T,
-) -> Result<Vec<(Target<IonAnnot>, PrecursorExtras)>, SpectronautReadingError> {
+) -> Result<Vec<(OwnedTarget<IonAnnot>, PrecursorExtras)>, SpectronautReadingError> {
     let file_handle = std::fs::File::open(file.as_ref())?;
 
     let mut rdr = csv::ReaderBuilder::new()
@@ -253,7 +253,7 @@ fn parse_precursor_group(
     id: u64,
     rows: &[SpectronautLibraryRow],
     buffers: &mut ParsingBuffers,
-) -> Result<Option<(Target<IonAnnot>, PrecursorExtras)>, SpectronautPrecursorParsingError> {
+) -> Result<Option<(OwnedTarget<IonAnnot>, PrecursorExtras)>, SpectronautPrecursorParsingError> {
     if rows.is_empty() {
         error!("Empty precursor group encountered on {id}");
         return Err(SpectronautPrecursorParsingError::Other);
@@ -277,7 +277,7 @@ fn parse_precursor_group(
 
     // iRT values are in a similar scale to DIA-NN's Tr_recalibrated (loosely minutes)
     // Convert to seconds
-    let rt_seconds = first_row.irt as f32 * 60.0;
+    let rt_seconds = first_row.irt as f32;
     let precursor_mz = first_row.precursor_mz;
     let precursor_charge: u8 =
         first_row
@@ -359,10 +359,11 @@ fn parse_precursor_group(
         relative_intensities,
     };
 
-    let eg = Target::builder()
+    let eg = OwnedTarget::builder()
         .id(id)
         .mobility_ook0(mobility)
-        .rt_seconds(rt_seconds)
+        .rt_value(rt_seconds)
+        .rt_axis(crate::models::RtAxis::NormalizedIndex { scale: None })
         .fragment_labels(buffers.fragment_labels.as_slice().into())
         .fragment_mzs(fragment_mzs)
         .precursor_labels(tiny_vec![0]) // Single monoisotopic precursor
@@ -456,17 +457,23 @@ mod tests {
             .join("sample_lib.tsv");
 
         let mut elution_groups = read_targets(file_path).expect("Failed to read library");
-        elution_groups.sort_by(|a, b| a.0.rt_seconds().partial_cmp(&b.0.rt_seconds()).unwrap());
+        elution_groups.sort_by(|a, b| {
+            a.0.rt()
+                .unwrap()
+                .value
+                .0
+                .total_cmp(&b.0.rt().unwrap().value.0)
+        });
 
-        // First precursor (KTVTAMDVVYALKR) has iRT=44.467922 -> rt_seconds ~ 2668
-        // Second precursor (MRECISIHVGQAGVQIGNACWELYCLEHGIQPDGQMPSDK) has iRT=83.00864 -> rt_seconds ~ 4980
+        // First precursor (KTVTAMDVVYALKR) has iRT=44.467922
+        // Second precursor (MRECISIHVGQAGVQIGNACWELYCLEHGIQPDGQMPSDK) has iRT=83.00864
 
         let first_eg = &elution_groups[0].0;
         let second_eg = &elution_groups[1].0;
 
-        // Check that the first elution group has the expected RT (approximately 44.467922 * 60)
+        // Check that the first elution group has the expected normalized RT (44.467922)
         assert!(
-            (first_eg.rt_seconds() - 44.467922 * 60.0).abs() < 0.01,
+            (first_eg.rt().unwrap().value.0 - 44.467922).abs() < 0.01,
             "First elution group RT mismatch"
         );
 
@@ -480,7 +487,7 @@ mod tests {
 
         // Check second precursor RT
         assert!(
-            (second_eg.rt_seconds() - 83.00864 * 60.0).abs() < 0.01,
+            (second_eg.rt().unwrap().value.0 - 83.00864).abs() < 0.01,
             "Second elution group RT mismatch"
         );
     }
diff --git a/rust/timsquery/src/traits/mod.rs b/rust/timsquery/src/traits/mod.rs
index 9747f568..5265f286 100644
--- a/rust/timsquery/src/traits/mod.rs
+++ b/rust/timsquery/src/traits/mod.rs
@@ -16,4 +16,4 @@ pub use queriable_data::{
     PeakAddable,
     QueriableData,
 };
-pub use query_geom::QueryGeom;
+pub use query_geom::Target;
diff --git a/rust/timsquery/src/traits/queriable_data.rs b/rust/timsquery/src/traits/queriable_data.rs
index 28563f8a..d604faaf 100644
--- a/rust/timsquery/src/traits/queriable_data.rs
+++ b/rust/timsquery/src/traits/queriable_data.rs
@@ -5,10 +5,10 @@ use crate::models::aggregators::{
     PointIntensityAggregator,
     SpectralCollector,
 };
-use crate::models::target::Target;
+
 use crate::{
     KeyLike,
-    Tolerance,
+    PeakTolerance,
 };
 use rayon::prelude::*;
 use std::ops::AddAssign;
@@ -20,8 +20,7 @@ use timscentroid::rt_mapping::RTIndex;
 /// Exposes exactly what `QueryRanges::from_query_data` and per-aggregator
 /// `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.
+/// by collectors with an explicitly resolved acquisition RT window.
 pub trait HasQueryData<FH: KeyLike> {
     fn precursor_mz_limits(&self) -> (f64, f64);
     fn mobility_ook0(&self) -> f32;
@@ -31,7 +30,7 @@ pub trait HasQueryData<FH: KeyLike> {
     fn mobility_kind(&self) -> timscentroid::MobilityKind {
         timscentroid::MobilityKind::Ook0
     }
-    fn rt_seconds(&self) -> f32;
+    fn rt(&self) -> crate::ResolvedRt;
     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.
@@ -40,31 +39,6 @@ pub trait HasQueryData<FH: KeyLike> {
         FH: 'a;
 }
 
-impl<FH: KeyLike> HasQueryData<FH> for Target<FH> {
-    fn precursor_mz_limits(&self) -> (f64, f64) {
-        self.precursor_mz_limits()
-    }
-
-    fn mobility_ook0(&self) -> f32 {
-        Target::mobility_ook0(self)
-    }
-
-    fn rt_seconds(&self) -> f32 {
-        Target::rt_seconds(self)
-    }
-
-    fn iter_precursors(&self) -> impl Iterator<Item = (i8, f64)> + '_ {
-        Target::iter_precursors(self)
-    }
-
-    fn iter_fragments<'a>(&'a self) -> impl Iterator<Item = (&'a FH, f64)> + 'a
-    where
-        FH: 'a,
-    {
-        self.iter_fragments_refs().map(|(k, mz)| (k, *mz))
-    }
-}
-
 /// Trait indicating that indexed data can be queried with a specific aggregator type.
 ///
 /// This trait connects indexed peak data (typically `IndexedTimstofPeaks`) with
@@ -79,27 +53,29 @@ impl<FH: KeyLike> HasQueryData<FH> for Target<FH> {
 ///
 /// The typical usage flow:
 ///
-/// 1. Create an aggregator with an `ElutionGroup` defining target m/z values
-/// 2. Create a `Tolerance` defining search windows (m/z, RT, mobility, quad)
-/// 3. Call `add_query()` to extract and accumulate matching peaks
-/// 4. Repeat for multiple queries or use `par_add_query_multi()` for batch queries
+/// 1. Resolve acquisition RT and borrow source geometry in an `ExtractionQuery`.
+/// 2. Construct or reset the collector from that query.
+/// 3. Call `add_query` with peak-domain tolerances.
 ///
 /// # Example
 ///
-/// ```ignore
-/// use timsquery::{IndexedTimstofPeaks, ChromatogramCollector, ElutionGroup, Tolerance, QueriableData};
-/// use std::sync::Arc;
-///
-/// let peaks: IndexedTimstofPeaks = unimplemented!();
-/// let elution_group = Arc::new(ElutionGroup::default());
-/// let ref_rt = Arc::new(vec![0u32; 100]);
-/// let mut aggregator = ChromatogramCollector::new(elution_group, ref_rt)?;
-/// let tolerance = Tolerance::default();
-///
-/// // Query peaks and accumulate into chromatogram
-/// peaks.add_query(&mut aggregator, &tolerance);
-///
-/// // The aggregator is modified in place with results
+/// ```no_run
+/// use timsquery::{ChromatogramCollector, DataProcessingError, ExtractionQuery,
+///     OwnedTarget, QueriableData, ResolvedRt, RtSelection, Tolerance};
+/// use timscentroid::IndexedTimstofPeaks;
+///
+/// fn extract(index: &IndexedTimstofPeaks, source: &OwnedTarget<usize>)
+///     -> Result<(), DataProcessingError>
+/// {
+///     let settings = Tolerance::default();
+///     let mapping = index.ms1_cycle_mapping();
+///     let rt = ResolvedRt::from_mapping(RtSelection::FullRun, &settings.rt, mapping)?;
+///     let query = ExtractionQuery::new(source, rt);
+///     let mut collector: ChromatogramCollector<usize, f32> =
+///         ChromatogramCollector::new(&query, mapping)?;
+///     index.add_query(&mut collector, &settings.peak_tolerance());
+///     Ok(())
+/// }
 /// ```
 ///
 /// # Implementation Notes
@@ -125,8 +101,8 @@ where
     /// # Arguments
     ///
     /// - `queriable_aggregator`: Mutable aggregator to accumulate results into
-    /// - `tolerance`: Defines search windows for m/z, RT, mobility, and quadrupole
-    fn add_query(&self, queriable_aggregator: &mut QA, tolerance: &Tolerance);
+    /// - `tolerance`: Defines search windows for m/z, mobility, and quadrupole
+    fn add_query(&self, queriable_aggregator: &mut QA, tolerance: &PeakTolerance);
 
     /// Execute multiple queries in parallel, one per aggregator.
     ///
@@ -134,7 +110,7 @@ where
     /// Rayon. Both parameters accept any `IntoParallelIterator`, so you can pass:
     ///
     /// - `&mut [QA]` for aggregators (the common case)
-    /// - `&[Tolerance]` or `&Vec<Tolerance>` for per-query tolerances
+    /// - `&[PeakTolerance]` or `&Vec<PeakTolerance>` for per-query tolerances
     /// - `rayon::iter::repeatn(&tol, n)` for a single shared tolerance
     ///
     /// # Arguments
@@ -146,7 +122,7 @@ where
         QA: 'a,
         A: IntoParallelIterator<Item = &'a mut QA>,
         A::Iter: IndexedParallelIterator,
-        T: IntoParallelIterator<Item = &'a Tolerance>,
+        T: IntoParallelIterator<Item = &'a PeakTolerance>,
         T::Iter: IndexedParallelIterator,
     {
         queriable_aggregators
diff --git a/rust/timsquery/src/traits/query_geom.rs b/rust/timsquery/src/traits/query_geom.rs
index 049adfa2..50c4fe72 100644
--- a/rust/timsquery/src/traits/query_geom.rs
+++ b/rust/timsquery/src/traits/query_geom.rs
@@ -1,10 +1,9 @@
-use crate::models::target::Target;
+use crate::models::target::OwnedTarget;
 use crate::traits::KeyLike;
 
-/// Read-only geometry contract shared by the materialized `Target`
-/// and the columnar flyweight `Query<L>`. Method names mirror the aggregator
-/// collectors' existing calls so they relax to `&impl QueryGeom` unchanged.
-pub trait QueryGeom {
+/// Source-library geometry shared by owned targets and columnar queries.
+/// RT stays in the library domain, even when its unit is seconds.
+pub trait Target {
     type Label: KeyLike;
 
     /// What the source file called this row, when it said. `None` for formats
@@ -19,7 +18,10 @@ pub trait QueryGeom {
     fn output_id(&self) -> crate::models::SourceId<'_>;
     fn mono_precursor_mz(&self) -> f64;
     fn precursor_charge(&self) -> u8;
-    fn rt_seconds(&self) -> f32;
+    fn rt(&self) -> Option<crate::models::RtCoordinate<'_>>;
+    fn library_rt(&self) -> Option<calibrt::LibraryRT<f32>> {
+        self.rt().map(|r| r.value)
+    }
     fn mobility_ook0(&self) -> f32;
     fn precursor_mz_limits(&self) -> (f64, f64);
     fn precursor_count(&self) -> usize;
@@ -30,7 +32,7 @@ pub trait QueryGeom {
     fn iter_fragments_refs(&self) -> impl Iterator<Item = (&Self::Label, f64)>;
 }
 
-impl<T: KeyLike> QueryGeom for Target<T> {
+impl<T: KeyLike> Target for OwnedTarget<T> {
     type Label = T;
 
     fn source_id(&self) -> Option<crate::models::SourceId<'_>> {
@@ -49,8 +51,8 @@ impl<T: KeyLike> QueryGeom for Target<T> {
         self.precursor_charge()
     }
 
-    fn rt_seconds(&self) -> f32 {
-        self.rt_seconds()
+    fn rt(&self) -> Option<crate::models::RtCoordinate<'_>> {
+        self.rt()
     }
 
     fn mobility_ook0(&self) -> f32 {
@@ -76,25 +78,25 @@ impl<T: KeyLike> QueryGeom for Target<T> {
     fn iter_fragments_refs(&self) -> impl Iterator<Item = (&Self::Label, f64)> {
         // Inherent method resolves here (inherent-first), returns (&T, &f64);
         // map to owned m/z. No recursion.
-        Target::iter_fragments_refs(self).map(|(k, v)| (k, *v))
+        OwnedTarget::iter_fragments_refs(self).map(|(k, v)| (k, *v))
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::models::target::Target;
+    use crate::models::target::OwnedTarget;
 
-    fn via_trait<G: QueryGeom>(g: &G) -> crate::models::OwnedSourceId {
+    fn via_trait<G: Target>(g: &G) -> crate::models::OwnedSourceId {
         g.output_id().to_owned_id()
     }
 
     #[test]
     fn target_output_id_is_its_source_id() {
-        let eg: Target<crate::IonAnnot> = Target::builder()
+        let eg: OwnedTarget<crate::IonAnnot> = OwnedTarget::builder()
             .id(7)
             .mobility_ook0(0.75)
-            .rt_seconds(1.0)
+            .rt_value(1.0)
             .fragment_labels([crate::IonAnnot::try_from("y3").unwrap()].as_slice().into())
             .fragment_mzs(vec![100.0])
             .precursor_labels(tinyvec::tiny_vec!(0))
@@ -106,16 +108,16 @@ mod tests {
 
     #[test]
     fn reset_from_accepts_generic_geom() {
-        fn reset_via_trait<G: QueryGeom<Label = crate::IonAnnot>>(
-            dst: &mut Target<crate::IonAnnot>,
+        fn reset_via_trait<G: Target<Label = crate::IonAnnot>>(
+            dst: &mut OwnedTarget<crate::IonAnnot>,
             src: &G,
         ) {
             dst.reset_from(src);
         }
-        let src: Target<crate::IonAnnot> = Target::builder()
+        let src: OwnedTarget<crate::IonAnnot> = OwnedTarget::builder()
             .id(3)
             .mobility_ook0(0.5)
-            .rt_seconds(2.0)
+            .rt_value(2.0)
             .fragment_labels([crate::IonAnnot::try_from("y2").unwrap()].as_slice().into())
             .fragment_mzs(vec![250.0])
             .precursor_labels(tinyvec::tiny_vec!(0))
diff --git a/rust/timsquery/tests/carafe_contract/main.rs b/rust/timsquery/tests/carafe_contract/main.rs
index 26dd72a0..46911963 100644
--- a/rust/timsquery/tests/carafe_contract/main.rs
+++ b/rust/timsquery/tests/carafe_contract/main.rs
@@ -62,7 +62,7 @@ fn carafe_target_payload_loads_through_the_public_reader() {
     let row = geom.rows().next().unwrap();
     assert_eq!(geom.precursor_mz(row), 650.32);
     assert_eq!(geom.charge(row), 2);
-    assert_eq!(geom.rt_seconds(row), 1234.5);
+    assert_eq!(geom.library_rt(row).map(|rt| rt.0).unwrap(), 1234.5);
     assert_eq!(geom.mobility(row), 0.95);
 
     // Positionally paired with the m/z values; the `^N` suffix survives.
diff --git a/rust/timsquery_cli/src/cli.rs b/rust/timsquery_cli/src/cli.rs
index 78895cb2..770398c1 100644
--- a/rust/timsquery_cli/src/cli.rs
+++ b/rust/timsquery_cli/src/cli.rs
@@ -59,7 +59,8 @@ pub struct QueryIndexArgs {
     #[arg(short, long)]
     pub tolerance_settings_path: PathBuf,
 
-    /// The path to the json file with the elution groups.
+    /// Query geometry file. With restricted RT tolerance, supplied seconds must
+    /// be coordinates on the queried acquisition; this command does not calibrate RT.
     #[arg(short, long)]
     pub elution_groups_path: PathBuf,
 
diff --git a/rust/timsquery_cli/src/commands.rs b/rust/timsquery_cli/src/commands.rs
index 86c6bfe3..310dc5ea 100644
--- a/rust/timsquery_cli/src/commands.rs
+++ b/rust/timsquery_cli/src/commands.rs
@@ -80,7 +80,7 @@ pub fn main_query_index(args: QueryIndexArgs) -> Result<(), CliError> {
 
     // Every format funnels into one of the two label-typed arenas; extraction
     // is generic over the label, so both arms call the same driver over the
-    // columnar flyweights (`QueryGeom`). The readers hand back target geometry
+    // columnar flyweights (`Target`). The readers hand back target geometry
     // only (`caps.decoys == DecoyStrategy::Stored`, so `expanded_len() ==
     // n_rows()`): decoy generation is a scoring decision the cli never makes, so
     // a `QueryRef` (geometry only) is all the collectors need.
@@ -368,7 +368,7 @@ pub fn process_and_serialize<L: KeyLike + Display + DecoyShift>(
 mod tests {
     use super::*;
     use std::path::PathBuf;
-    use timsquery::models::target::Target;
+    use timsquery::models::target::OwnedTarget;
     use timsquery::models::tolerance::{
         MobilityTolerance,
         MzTolerance,
@@ -441,7 +441,7 @@ mod tests {
     fn test_elution_group_template_deserializable() {
         use timsquery::IonAnnot;
         let elution_groups =
-            serde_json::from_str::<Vec<Target<IonAnnot>>>(ELUTION_GROUP_TEMPLATE).unwrap();
+            serde_json::from_str::<Vec<OwnedTarget<IonAnnot>>>(ELUTION_GROUP_TEMPLATE).unwrap();
         assert!(elution_groups.len() == 2);
         // Write to a temp file ... while I implement direct reading api
         let tmp_file = tempfile::NamedTempFile::new().unwrap();
@@ -486,7 +486,7 @@ mod tests {
             PointIntensityAggregator,
             SpectralCollector,
         };
-        use timsquery::traits::QueryGeom;
+        use timsquery::traits::Target;
 
         let tmp_file = tempfile::NamedTempFile::new().unwrap();
         std::fs::write(tmp_file.path(), STRING_LABEL_TEMPLATE).unwrap();
@@ -506,9 +506,34 @@ mod tests {
         // The read -> item_at -> collector path builds without error for every row.
         for flat in geom.flats() {
             let q = geom.item_at(flat);
-            let point = PointIntensityAggregator::new(&q);
+            let point = PointIntensityAggregator::new(&timsquery::ExtractionQuery::new(
+                &q,
+                timsquery::ResolvedRt::resolve(
+                    timsquery::RtSelection::FullRun,
+                    &timsquery::models::tolerance::RtTolerance::Unrestricted,
+                    timsquery::TupleRange::try_new(
+                        timsquery::ObservedRTSeconds(0.009),
+                        timsquery::ObservedRTSeconds(0.020),
+                    )
+                    .unwrap(),
+                )
+                .unwrap(),
+            ));
             assert_eq!(point.fragment_mzs.len(), q.fragment_count());
-            let _spectrum: SpectralCollector<_, f32> = SpectralCollector::new(&q);
+            let _spectrum: SpectralCollector<_, f32> =
+                SpectralCollector::new(&timsquery::ExtractionQuery::new(
+                    &q,
+                    timsquery::ResolvedRt::resolve(
+                        timsquery::RtSelection::FullRun,
+                        &timsquery::models::tolerance::RtTolerance::Unrestricted,
+                        timsquery::TupleRange::try_new(
+                            timsquery::ObservedRTSeconds(0.009),
+                            timsquery::ObservedRTSeconds(0.020),
+                        )
+                        .unwrap(),
+                    )
+                    .unwrap(),
+                ));
         }
     }
 }
diff --git a/rust/timsquery_cli/src/processing.rs b/rust/timsquery_cli/src/processing.rs
index 86ad0798..6ba08338 100644
--- a/rust/timsquery_cli/src/processing.rs
+++ b/rust/timsquery_cli/src/processing.rs
@@ -28,7 +28,7 @@ use timsquery::models::tolerance::Tolerance;
 use timsquery::serde::ChromatogramOutput;
 use timsquery::traits::{
     DecoyShift,
-    QueryGeom,
+    Target,
 };
 use timsquery::{
     KeyLike,
@@ -71,7 +71,7 @@ impl SpectrumOutput {
         SpectrumOutput {
             id: source_id.to_owned_id(),
             mobility_ook0: agg.mobility_ook0,
-            rt_seconds: agg.rt_seconds,
+            rt_seconds: agg.rt.center().map_or(f32::NAN, |r| r.0),
             precursor_mz: agg.precursor_mono_mz,
             fragment_mzs,
             precursor_intensities,
@@ -98,6 +98,29 @@ impl<T: KeyLike + Display> AggregatorContainer<T> {
     where
         T: DecoyShift,
     {
+        // Direct-query CLI inputs express acquisition seconds. Library indices
+        // require calibration in timsseek before they can constrain this axis.
+        let queries = queries
+            .iter()
+            .map(|q| {
+                let selection = match (&tolerance.rt, q.rt()) {
+                    (_, Some(rt)) if *rt.axis == timsquery::RtAxis::Seconds => {
+                        timsquery::RtSelection::Centered(timsquery::ObservedRTSeconds(rt.value.0))
+                    }
+                    (timsquery::models::tolerance::RtTolerance::Unrestricted, _) | (_, None) => {
+                        timsquery::RtSelection::FullRun
+                    }
+                    _ => {
+                        return Err(CliError::DataProcessing(
+                            "Direct queries require acquisition seconds or unrestricted RT".into(),
+                        ));
+                    }
+                };
+                let rt = timsquery::ResolvedRt::from_mapping(selection, &tolerance.rt, ref_rts)
+                    .map_err(|e| CliError::DataProcessing(format!("{e:?}")))?;
+                Ok(timsquery::ExtractionQuery::new(q, rt))
+            })
+            .collect::<Result<Vec<_>, CliError>>()?;
         Ok(match aggregator {
             PossibleAggregator::PointIntensity => AggregatorContainer::Point(
                 queries.iter().map(PointIntensityAggregator::new).collect(),
@@ -106,15 +129,7 @@ impl<T: KeyLike + Display> AggregatorContainer<T> {
                 let collectors = queries
                     .iter()
                     .map(|q| {
-                        let rt_range = match tolerance.rt_range_as_milis(q.rt_seconds()) {
-                            timsquery::OptionallyRestricted::Unrestricted => {
-                                let range = ref_rts.range_milis();
-                                timsquery::TupleRange::try_new(range.0, range.1)
-                                    .expect("Reference RTs should be sorted and valid")
-                            }
-                            timsquery::OptionallyRestricted::Restricted(r) => r,
-                        };
-                        ChromatogramCollector::new(q, rt_range, ref_rts)
+                        ChromatogramCollector::new(q, ref_rts)
                             .map_err(|e| CliError::DataProcessing(format!("{:?}", e)))
                     })
                     .collect::<Result<Vec<_>, _>>()?;
@@ -127,6 +142,7 @@ impl<T: KeyLike + Display> AggregatorContainer<T> {
     }
 
     pub fn add_query(&mut self, index: &IndexedTimstofPeaks, tolerance: &Tolerance) {
+        let tolerance = &tolerance.peak_tolerance();
         match self {
             AggregatorContainer::Point(aggregators) => {
                 let n = aggregators.len();
@@ -220,7 +236,6 @@ impl<T: KeyLike + Display> AggregatorContainer<T> {
 mod tests {
     use super::*;
     use crate::cli::SerializationFormat;
-    use timsquery::TupleRange;
     use timsquery::serde::TargetTable;
 
     #[test]
@@ -256,8 +271,13 @@ mod tests {
             };
             let queries: Vec<_> = geom.flats().map(|f| geom.item_at(f)).collect();
             let cycles = CycleToRTMapping::new(vec![10, 20]);
-            let mut spectra =
-                AggregatorContainer::Spectrum(queries.iter().map(SpectralCollector::new).collect());
+            let mut spectra = AggregatorContainer::new(
+                &queries,
+                PossibleAggregator::Spectrum,
+                &cycles,
+                &Tolerance::default(),
+            )
+            .unwrap();
             let mut bytes = Vec::new();
             let mut ser = JsonStreamSerializer::new(&mut bytes, SerializationFormat::Json);
             assert!(
@@ -270,6 +290,11 @@ mod tests {
                 .unwrap();
             ser.finish().unwrap();
             let output: Vec<serde_json::Value> = serde_json::from_slice(&bytes).unwrap();
+            assert!(
+                output
+                    .iter()
+                    .all(|row| { (row["rt_seconds"].as_f64().unwrap() - 0.01).abs() < 1e-6 })
+            );
             assert_eq!(
                 output.iter().map(|r| r["id"].clone()).collect::<Vec<_>>(),
                 *ids.as_array().unwrap()
@@ -279,9 +304,23 @@ mod tests {
                 .iter()
                 .enumerate()
                 .map(|(i, q)| {
-                    let mut agg =
-                        ChromatogramCollector::new(q, TupleRange::try_new(9, 20).unwrap(), &cycles)
-                            .unwrap();
+                    let mut agg = ChromatogramCollector::new(
+                        &timsquery::ExtractionQuery::new(
+                            q,
+                            timsquery::ResolvedRt::resolve(
+                                timsquery::RtSelection::FullRun,
+                                &timsquery::models::tolerance::RtTolerance::Unrestricted,
+                                timsquery::TupleRange::try_new(
+                                    timsquery::ObservedRTSeconds(0.009),
+                                    timsquery::ObservedRTSeconds(0.020),
+                                )
+                                .unwrap(),
+                            )
+                            .unwrap(),
+                        ),
+                        &cycles,
+                    )
+                    .unwrap();
                     // The middle query produces no signal and must be skipped.
                     if i != 1 {
                         agg.precursors
diff --git a/rust/timsquery_viewer/src/app.rs b/rust/timsquery_viewer/src/app.rs
index 0d940f95..6f92bf23 100644
--- a/rust/timsquery_viewer/src/app.rs
+++ b/rust/timsquery_viewer/src/app.rs
@@ -50,7 +50,7 @@ type ChromatogramComputeResult = Result<
         crate::chromatogram_processor::ChromatogramCollector<IonAnnot, f32>,
         timsseek::ExpectedIntensities<IonAnnot>,
         u64, // selected_idx as cache key
-        timsquery::models::target::Target<IonAnnot>,
+        timsquery::models::target::OwnedTarget<IonAnnot>,
     ),
     String,
 >;
@@ -125,6 +125,8 @@ struct PersistentState {
     dock_state: DockState<Pane>,
     #[serde(default)]
     calibration_snapshot: Option<calibrt::CalibrationSnapshot>,
+    #[serde(default)]
+    calibration_rt_axis: Option<timsquery::RtAxis>,
 }
 
 fn default_true() -> bool {
@@ -348,6 +350,7 @@ impl ViewerApp {
                         screenshot_delay_secs: 3.0,
                         calibration: ViewerCalibrationState::from_snapshot(
                             state.calibration_snapshot,
+                            state.calibration_rt_axis,
                         ),
                     };
                 }
@@ -524,23 +527,25 @@ impl ViewerApp {
 
             let index_owned = index.clone();
             // If calibration is available, project the library RT to measured RT
-            let mut elution_group_owned = elution_group.clone();
-            if let Some(cs) = &self.calibration.calibration_state
-                && let Some(curve) = cs.curve()
-            {
-                let lib_rt = elution_group_owned.rt_seconds();
-                let calibrated_rt = match curve.predict(LibraryRT(lib_rt as f64)) {
-                    Ok(y) => y.0 as f32,
-                    Err(calibrt::CalibRtError::OutOfBounds(y)) => y as f32,
-                    Err(_) => lib_rt,
-                };
-                tracing::debug!(
-                    "RT calibration: {:.1}s (library) → {:.1}s (projected)",
-                    lib_rt,
-                    calibrated_rt,
-                );
-                elution_group_owned.set_rt_seconds(calibrated_rt);
-            }
+            let elution_group_owned = elution_group.clone();
+            let observed_rt = elution_group.rt().and_then(|rt| {
+                let curve = self
+                    .calibration
+                    .calibration_state
+                    .as_ref()
+                    .filter(|_| &self.calibration.library_rt_axis == rt.axis)
+                    .and_then(|cs| cs.curve());
+                match curve {
+                    Some(curve) => match curve.predict(LibraryRT(rt.value.0 as f64)) {
+                        Ok(rt) => Some(timsquery::ObservedRTSeconds(rt.0 as f32)),
+                        Err(calibrt::CalibRtError::OutOfBounds(seconds)) => {
+                            Some(timsquery::ObservedRTSeconds(seconds as f32))
+                        }
+                        Err(_) => None,
+                    },
+                    None => None,
+                }
+            });
             let expected_intensities_owned = expected_intensities.clone();
             let tolerance_owned = self.data.tolerance.clone();
             let smoothing_owned = self.data.smoothing;
@@ -554,6 +559,7 @@ impl ViewerApp {
                     );
                     let result = Self::compute_chromatogram_background(
                         elution_group_owned,
+                        observed_rt,
                         expected_intensities_owned,
                         selected_idx,
                         index_owned,
@@ -593,7 +599,8 @@ impl ViewerApp {
 
     /// Compute chromatogram in background thread
     fn compute_chromatogram_background(
-        elution_group: timsquery::models::target::Target<IonAnnot>,
+        elution_group: timsquery::models::target::OwnedTarget<IonAnnot>,
+        observed_rt: Option<timsquery::ObservedRTSeconds<f32>>,
         expected_intensities: timsseek::ExpectedIntensities<IonAnnot>,
         selected_idx: usize,
         index: Arc<IndexedPeaksHandle>,
@@ -607,9 +614,19 @@ impl ViewerApp {
             return Err("Computation cancelled".to_string());
         }
 
-        // Build collector
-        let mut collector = ComputedState::build_collector(&index, elution_group.clone())
-            .map_err(|e| format!("Failed to build collector: {:?}", e))?;
+        let selection = observed_rt.map_or(
+            timsquery::RtSelection::FullRun,
+            timsquery::RtSelection::Centered,
+        );
+        let rt = timsquery::ResolvedRt::from_mapping(
+            selection,
+            &tolerance.rt,
+            index.ms1_cycle_mapping(),
+        )
+        .map_err(|e| format!("Invalid extraction RT: {e:?}"))?;
+        let query = timsquery::ExtractionQuery::new(&elution_group, rt);
+        let mut collector = ComputedState::build_collector(&index, &query)
+            .map_err(|e| format!("Failed to build collector: {e:?}"))?;
 
         // Check if cancelled after building collector
         if cancel_token.is_cancelled() {
@@ -681,38 +698,32 @@ impl ViewerApp {
                     if let Some(elution_groups) = self.data.elution_groups.as_ref()
                         && let Ok((elution_group, _)) =
                             elution_groups.get_elem(selected_idx as usize)
+                        && let Some(rt) = elution_group.rt()
                     {
-                        let lib_rt = elution_group.rt_seconds() as f64;
-
-                        // Check if calibration projects to a different RT
                         let calibrated_rt = self
                             .calibration
                             .calibration_state
                             .as_ref()
+                            .filter(|_| &self.calibration.library_rt_axis == rt.axis)
                             .and_then(|cs| cs.curve())
-                            .and_then(|curve| match curve.predict(LibraryRT(lib_rt)) {
+                            .and_then(|curve| match curve.predict(LibraryRT(rt.value.0 as f64)) {
                                 Ok(y) => Some(y.0),
                                 Err(calibrt::CalibRtError::OutOfBounds(y)) => Some(y),
                                 Err(_) => None,
                             });
-
-                        if let Some(cal_rt) = calibrated_rt {
-                            // Show both: dashed library RT + solid calibrated RT
+                        // Only measured seconds belong on the acquisition-time plot.
+                        if matches!(rt.axis, timsquery::RtAxis::Seconds) {
                             self.computed.insert_reference_line(
                                 "Library RT".into(),
-                                lib_rt,
-                                Color32::from_rgba_unmultiplied(100, 100, 255, 120), // dim blue
+                                rt.value.0 as f64,
+                                Color32::BLUE,
                             );
+                        }
+                        if let Some(seconds) = calibrated_rt {
                             self.computed.insert_reference_line(
                                 "Calibrated RT".into(),
-                                cal_rt,
-                                Color32::from_rgb(255, 165, 0), // orange
-                            );
-                        } else {
-                            self.computed.insert_reference_line(
-                                "Library RT".into(),
-                                lib_rt,
-                                Color32::BLUE,
+                                seconds,
+                                Color32::from_rgb(255, 165, 0),
                             );
                         }
                     }
@@ -1404,6 +1415,7 @@ impl eframe::App for ViewerApp {
             smoothing: self.data.smoothing,
             dock_state: self.dock_state.clone(),
             calibration_snapshot: self.calibration.snapshot_for_persistence(),
+            calibration_rt_axis: Some(self.calibration.library_rt_axis.clone()),
         };
 
         if let Ok(value) = ron::to_string(&state) {
@@ -1724,7 +1736,7 @@ impl<'a> TabViewer for AppTabViewer<'a> {
                 let selected_library_rt = self.ui.selected_index.and_then(|idx| {
                     let eg_data = self.data.elution_groups.as_ref()?;
                     let (eg, _) = eg_data.get_elem(idx).ok()?;
-                    Some(eg.rt_seconds() as f64)
+                    eg.rt().map(|rt| rt.value.0 as f64)
                 });
                 self.calibration.render_panel(
                     ui,
diff --git a/rust/timsquery_viewer/src/calibration.rs b/rust/timsquery_viewer/src/calibration.rs
index 729500c6..7f005778 100644
--- a/rust/timsquery_viewer/src/calibration.rs
+++ b/rust/timsquery_viewer/src/calibration.rs
@@ -121,6 +121,7 @@ fn broad_calibration_tolerance() -> Tolerance {
 /// Owns the calibration background thread and collects results.
 pub struct ViewerCalibrationState {
     pub phase: CalibrationPhase,
+    pub library_rt_axis: timsquery::RtAxis,
     pub calibration_state: Option<CalibrationState>,
     pub generation: u64,
     pub n_scored: usize,
@@ -152,6 +153,7 @@ impl Default for ViewerCalibrationState {
             phase: CalibrationPhase::Idle,
             calibration_state: None,
             generation: 0,
+            library_rt_axis: timsquery::RtAxis::Unspecified,
             n_scored: 0,
             n_calibrants_found: 0,
             heap_capacity: search.n_calibrants,
@@ -169,8 +171,11 @@ impl Default for ViewerCalibrationState {
 
 impl ViewerCalibrationState {
     /// Reconstruct from a persisted snapshot (app state restore).
-    pub fn from_snapshot(snapshot: Option<calibrt::CalibrationSnapshot>) -> Self {
-        let Some(snapshot) = snapshot else {
+    pub fn from_snapshot(
+        snapshot: Option<calibrt::CalibrationSnapshot>,
+        axis: Option<timsquery::RtAxis>,
+    ) -> Self {
+        let (Some(snapshot), Some(axis)) = (snapshot, axis) else {
             return Self::default();
         };
         if snapshot.points.is_empty() {
@@ -195,6 +200,7 @@ impl ViewerCalibrationState {
             },
             calibration_state,
             generation: 0,
+            library_rt_axis: axis,
             n_scored: n_calibrants_found,
             n_calibrants_found,
             heap_capacity: search.n_calibrants,
@@ -247,6 +253,10 @@ impl ViewerCalibrationState {
             return;
         }
 
+        self.library_rt_axis = elution_groups.rt_axis().clone();
+        if self.library_rt_axis == timsquery::RtAxis::Absent {
+            return;
+        }
         // Increment generation to invalidate stale data.
         self.generation += 1;
         self.n_scored = 0;
@@ -517,11 +527,22 @@ impl ViewerCalibrationState {
                             return (scorer, local_heap);
                         };
 
+                        let Some(library_rt) = elution_group.rt().map(|rt| rt.value) else {
+                            return (scorer, local_heap);
+                        };
                         let extraction = match build_extraction(
-                            &elution_group,
+                            &timsquery::ExtractionQuery::new(
+                                &elution_group,
+                                timsquery::ResolvedRt::from_mapping(
+                                    timsquery::RtSelection::FullRun,
+                                    &tolerance.rt,
+                                    index.ms1_cycle_mapping(),
+                                )
+                                .expect("valid acquisition range"),
+                            ),
                             expected_intensities,
                             index.as_ref(),
-                            &tolerance,
+                            &tolerance.peak_tolerance(),
                             Some(TOP_N_FRAGMENTS),
                         ) {
                             Ok(ext) => ext,
@@ -548,7 +569,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_rt: LibraryRT(elution_group.rt_seconds()),
+                                library_rt,
                             });
                         }
                         (scorer, local_heap)
@@ -609,6 +630,7 @@ impl ViewerCalibrationState {
             self.residuals.clone(),
             self.n_scored,
         )
+        .with_library_rt_axis(self.library_rt_axis.clone())
         .write(path)
     }
 
@@ -623,6 +645,10 @@ impl ViewerCalibrationState {
 
         let (saved, warning) = SavedCalibration::read(path, raw_rt_range)?;
 
+        self.library_rt_axis = saved.library_rt_axis.clone();
+
+        self.snapshot_points.clear();
+        self.calibration_state = None;
         // Reconstruct CalibrationState from the snapshot
         if let Ok(cal) = calibrt::CalibrationState::from_snapshot(&saved.calibration) {
             self.snapshot_points = saved
@@ -786,7 +812,7 @@ impl ViewerCalibrationState {
         let plot_id = format!("calibration_plot_{}", self.generation);
         let plot = Plot::new(plot_id)
             .height(ui.available_height().max(100.0))
-            .x_axis_label("Library RT (s)")
+            .x_axis_label(format!("Library RT ({})", self.library_rt_axis))
             .y_axis_label("Measured RT (s)")
             .allow_zoom(true)
             .allow_drag(true);
@@ -1068,6 +1094,22 @@ impl ViewerCalibrationState {
         }
 
         ui.vertical(|ui| {
+            if let Some(residuals) = &self.residuals {
+                ui.horizontal(|ui| {
+                    ui.label(format!(
+                        "m/z: {:?}; mobility: {:?}",
+                        residuals.tolerance.ms, residuals.tolerance.mobility,
+                    ));
+                    if ui.button("Apply saved tolerances").clicked() {
+                        tolerance.ms = residuals.tolerance.ms.clone();
+                        tolerance.mobility = residuals.tolerance.mobility.clone();
+                        tolerance.quad = residuals.tolerance.quad.clone();
+                        if self.calibration_state.as_ref().and_then(|s| s.curve()).is_none() {
+                            tolerance.rt = RtTolerance::Unrestricted;
+                        }
+                    }
+                });
+            }
             if let Some((rt_min, stats)) = suggested {
                 ui.horizontal(|ui| {
                     ui.label(format!(
@@ -1159,3 +1201,49 @@ fn simple_shuffle(indices: &mut [usize]) {
         indices.swap(i, j);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn loading_mass_only_calibration_clears_previous_rt_fit() {
+        use timsseek::rt_calibration::{
+            CalibrationResult,
+            DerivationParams,
+            DimensionErrors,
+            ErrorStats,
+        };
+        let mut grid = CalibrationState::deferred(10, 3).unwrap();
+        grid.refit(10, [(0.0, 30.0), (100.0, 180.0)].into_iter())
+            .unwrap();
+        assert!(grid.curve().is_some());
+        let mut viewer = ViewerCalibrationState::default();
+        viewer.calibration_state = Some(grid);
+        viewer.snapshot_points = vec![(LibraryRT(0.0), ObservedRTSeconds(30.0))];
+        let calibration = CalibrationResult::from_measurements(
+            CalibrationState::deferred(10, 3).unwrap(),
+            &Tolerance::default(),
+            DimensionErrors {
+                mz_ppm: ErrorStats::from_slice(&[2.0, 3.0]),
+                ..Default::default()
+            },
+            DerivationParams::default(),
+        )
+        .with_rt_axis(&timsquery::RtAxis::Absent);
+        let path = std::env::temp_dir().join(format!(
+            "tbtk-viewer-mass-calibration-{}.json",
+            std::process::id()
+        ));
+        calibration.save_json([0.0, 600.0], 2, &path).unwrap();
+        let loaded = viewer.load_from_file(&path, None);
+        std::fs::remove_file(&path).unwrap();
+        loaded.unwrap();
+        assert!(viewer.calibration_state.is_none());
+        assert!(viewer.snapshot_points.is_empty());
+        assert_eq!(viewer.library_rt_axis, timsquery::RtAxis::Absent);
+        let residuals = viewer.residuals.as_ref().unwrap();
+        assert_eq!(residuals.errors.mz_ppm.n, 2);
+        assert_eq!(&residuals.tolerance.ms, calibration.mz_tolerance());
+    }
+}
diff --git a/rust/timsquery_viewer/src/computed_state.rs b/rust/timsquery_viewer/src/computed_state.rs
index c2248331..59d8982b 100644
--- a/rust/timsquery_viewer/src/computed_state.rs
+++ b/rust/timsquery_viewer/src/computed_state.rs
@@ -1,7 +1,7 @@
 use egui::Color32;
 use std::collections::HashMap;
 use timsquery::ion::IonAnnot;
-use timsquery::models::target::Target;
+use timsquery::models::target::OwnedTarget;
 use timsquery::models::tolerance::{
     RtTolerance,
     Tolerance,
@@ -47,7 +47,7 @@ pub(crate) struct ChromatogramComputationResult {
     pub output: ChromatogramOutput,
     pub collector: ChromatogramCollector<IonAnnot, f32>,
     pub expected_intensities: ExpectedIntensities<IonAnnot>,
-    pub elution_group: Target<IonAnnot>,
+    pub elution_group: OwnedTarget<IonAnnot>,
 }
 
 #[derive(Debug)]
@@ -65,7 +65,7 @@ struct ChromatogramResult {
     output: ChromatogramOutput,
     scoring: Option<ScoringResult>,
     expected_intensities: ExpectedIntensities<IonAnnot>,
-    elution_group: Target<IonAnnot>,
+    elution_group: OwnedTarget<IonAnnot>,
 }
 
 #[derive(Debug, Default)]
@@ -270,28 +270,22 @@ impl ComputedState {
 
     pub(crate) fn build_collector(
         index: &IndexedPeaksHandle,
-        elution_group: Target<IonAnnot>,
+        elution_group: &timsquery::ExtractionQuery<'_, impl timsquery::Target<Label = IonAnnot>>,
     ) -> Result<ChromatogramCollector<IonAnnot, f32>, ViewerError> {
-        let max_range = index.ms1_cycle_mapping().range_milis();
-        let collector = ChromatogramCollector::new(
-            &elution_group,
-            TupleRange::try_new(max_range.0, max_range.1)
-                .expect("Reference RTs should be sorted and valid"),
-            index.ms1_cycle_mapping(),
-        )
-        .map_err(|e| ViewerError::General(format!("Failed to create collector: {:?}", e)))?;
+        let collector = ChromatogramCollector::new(elution_group, index.ms1_cycle_mapping())
+            .map_err(|e| ViewerError::General(format!("Failed to create collector: {:?}", e)))?;
         Ok(collector)
     }
 
     #[instrument(skip_all, fields(eg_id = %elution_group.id()))]
     pub(crate) fn generate_chromatogram(
         collector: &mut ChromatogramCollector<IonAnnot, f32>,
-        elution_group: &Target<IonAnnot>,
+        elution_group: &OwnedTarget<IonAnnot>,
         index: &IndexedPeaksHandle,
         tolerance: &Tolerance,
         smoothing: &SmoothingMethod,
     ) -> Result<ChromatogramOutput, ViewerError> {
-        index.add_query(collector, tolerance);
+        index.add_query(collector, &tolerance.peak_tolerance());
 
         let mut output =
             ChromatogramOutput::try_new(collector, index.ms1_cycle_mapping(), elution_group.id())
@@ -338,7 +332,7 @@ impl ComputedState {
                     tracing::warn!(
                         "collector id={} rt={} mob={} prec_mz={}",
                         source_id,
-                        context.chromatograms.rt_seconds,
+                        context.chromatograms.rt.center().map_or(f32::NAN, |r| r.0),
                         context.chromatograms.mobility_ook0,
                         context.chromatograms.precursor_mono_mz,
                     );
@@ -568,10 +562,16 @@ impl ComputedState {
             .with_rt_tolerance(RtTolerance::Minutes((5.0 / 60.0, 5.0 / 60.0)))
             .with_wider_mobility(2.0);
 
+        let Ok(rt) = timsquery::ResolvedRt::from_mapping(
+            timsquery::RtSelection::Centered(timsquery::ObservedRTSeconds(rt_override)),
+            &wide_tolerance.rt,
+            index.ms1_cycle_mapping(),
+        ) else {
+            return false;
+        };
         let mut collector: SpectralCollector<IonAnnot, MzMobilityStatsCollector> =
-            SpectralCollector::new(&eg);
-        collector.reset_with_overrides(&eg, Some(rt_override), None);
-        index.add_query(&mut collector, &wide_tolerance);
+            SpectralCollector::new(&timsquery::ExtractionQuery::new(&eg, rt));
+        index.add_query(&mut collector, &wide_tolerance.peak_tolerance());
 
         // Compute 1x and 2x mobility ranges for overlays
         let mob_1x = tolerance.mobility_range(ook0);
diff --git a/rust/timsquery_viewer/src/file_loader.rs b/rust/timsquery_viewer/src/file_loader.rs
index 00e10d7d..1b87945e 100644
--- a/rust/timsquery_viewer/src/file_loader.rs
+++ b/rust/timsquery_viewer/src/file_loader.rs
@@ -9,12 +9,12 @@ use std::path::{
     PathBuf,
 };
 use std::sync::Arc;
-use timsquery::Target;
+use timsquery::OwnedTarget;
 use timsquery::ion::IonAnnot;
 use timsquery::models::FlatIdx;
 use timsquery::models::tolerance::Tolerance;
 use timsquery::serde::IndexedPeaksHandle;
-use timsquery::traits::QueryGeom;
+use timsquery::traits::Target;
 use timsseek::data_sources::reference_library::ScoredIdentity;
 use timsseek::{
     ExpectedIntensities,
@@ -212,6 +212,10 @@ impl ElutionGroupData {
             .expect("row ordinal past the end of the library")
     }
 
+    pub fn rt_axis(&self) -> &timsquery::RtAxis {
+        self.inner.geometry().rt_axis()
+    }
+
     fn item_at(&self, idx: usize) -> RefQuery<'_> {
         self.inner.item_at(self.flat(idx))
     }
@@ -271,7 +275,7 @@ impl ElutionGroupData {
     pub fn get_elem(
         &self,
         index: usize,
-    ) -> Result<(Target<IonAnnot>, ExpectedIntensities<IonAnnot>), ViewerError> {
+    ) -> Result<(OwnedTarget<IonAnnot>, ExpectedIntensities<IonAnnot>), ViewerError> {
         if index >= self.len() {
             return Err(ViewerError::General(format!(
                 "Elution group index {index} out of bounds"
@@ -281,7 +285,7 @@ impl ElutionGroupData {
         // The viewer owns the selected query and its expected intensities.
         // Precursor values use the library's composition/averagine envelope.
         let q = self.item_at(index);
-        let mut eg = Target::empty_like();
+        let mut eg = OwnedTarget::empty_like();
         eg.reset_from(&q);
         let expected = ExpectedIntensities::try_from_pairs(
             q.iter_expected_fragments(),
@@ -415,7 +419,11 @@ impl ElutionGroupData {
             add_col(ui, if q.is_target() { "No" } else { "Yes" });
         });
         table_row.col(|ui| {
-            add_col(ui, &format!("{:.2}", q.rt_seconds()));
+            add_col(
+                ui,
+                &q.rt()
+                    .map_or_else(|| "—".into(), |rt| format!("{:.2} {}", rt.value, rt.axis)),
+            );
         });
         table_row.col(|ui| {
             add_col(ui, &format!("{:.4}", q.mobility_ook0()));
@@ -455,7 +463,7 @@ mod tests {
         geom.push_row(Row {
             precursor_mz: 600.0,
             charge: 1,
-            rt_seconds: 10.0,
+            rt: Some(timsquery::models::RtCoordinate::seconds(10.0)),
             mobility: 1.0,
             frags: &[
                 (IonAnnot::try_from("y3").unwrap(), 300.0),
diff --git a/rust/timsseek/examples/query_bench.rs b/rust/timsseek/examples/query_bench.rs
index 834cd1d8..a63200f0 100644
--- a/rust/timsseek/examples/query_bench.rs
+++ b/rust/timsseek/examples/query_bench.rs
@@ -45,7 +45,6 @@ use timsquery::traits::queriable_data::{
     PeakAddable,
     QueriableData,
 };
-use timsquery::utils::TupleRange;
 use timsseek::IonAnnot;
 use timsseek::data_sources::reference_library::ReferenceLibrary;
 use timsseek::models::LoadPolicy;
@@ -121,8 +120,12 @@ fn main() {
     // 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();
-    let rt_range = TupleRange::try_new(min_rt, max_rt).expect("rt range valid");
+    let rt = timsquery::ResolvedRt::from_mapping(
+        timsquery::RtSelection::FullRun,
+        &tolerance.rt,
+        cycle_mapping,
+    )
+    .unwrap();
 
     let items: Vec<_> = speclib.iter().take(n).collect();
     eprintln!("Benching {} items × {} iters each", items.len(), iters);
@@ -133,8 +136,10 @@ fn main() {
         let mut total_peaks = 0u64;
         for _ in 0..iters {
             for item in &items {
-                let mut agg = SpectralCollector::<IonAnnot, NoOpSink>::new(item);
-                index.add_query(&mut agg, &tolerance);
+                let mut agg = SpectralCollector::<IonAnnot, NoOpSink>::new(
+                    &timsquery::ExtractionQuery::new(item, rt),
+                );
+                index.add_query(&mut agg, &tolerance.peak_tolerance());
                 for (_, s) in agg.iter_precursors() {
                     total_peaks += s.0 as u64;
                 }
@@ -160,8 +165,10 @@ fn main() {
         let mut total_intensity = 0.0f64;
         for _ in 0..iters {
             for item in &items {
-                let mut agg = PointIntensityAggregator::<IonAnnot>::new(item);
-                index.add_query(&mut agg, &tolerance);
+                let mut agg = PointIntensityAggregator::<IonAnnot>::new(
+                    &timsquery::ExtractionQuery::new(item, rt),
+                );
+                index.add_query(&mut agg, &tolerance.peak_tolerance());
                 total_intensity += agg.intensity;
             }
         }
@@ -181,12 +188,13 @@ fn main() {
         let mut total_frag_peaks = 0u64;
         for _ in 0..iters {
             for item in &items {
-                let Ok(mut agg) =
-                    ChromatogramCollector::<IonAnnot, f32>::new(item, rt_range, cycle_mapping)
-                else {
+                let Ok(mut agg) = ChromatogramCollector::<IonAnnot, f32>::new(
+                    &timsquery::ExtractionQuery::new(item, rt),
+                    cycle_mapping,
+                ) else {
                     continue;
                 };
-                index.add_query(&mut agg, &tolerance);
+                index.add_query(&mut agg, &tolerance.peak_tolerance());
                 total_frag_peaks += agg.n_fragment_peaks_added;
             }
         }
diff --git a/rust/timsseek/src/data_sources/reference_library.rs b/rust/timsseek/src/data_sources/reference_library.rs
index 4335201e..45da8286 100644
--- a/rust/timsseek/src/data_sources/reference_library.rs
+++ b/rust/timsseek/src/data_sources/reference_library.rs
@@ -18,7 +18,7 @@ use timsquery::models::{
     RowIdx,
     TargetColumns,
 };
-use timsquery::traits::QueryGeom;
+use timsquery::traits::Target;
 #[cfg(test)]
 use timsquery::utils::constants::PROTON_MASS;
 
@@ -42,7 +42,7 @@ pub trait ExpectedIntensity {
     fn expected_precursor_envelope(&self) -> SmallVec<[(i8, f32); 3]>;
 }
 
-/// Flyweight over a `ReferenceLibrary`: `QueryGeom` (geometry, delegated to the
+/// Flyweight over a `ReferenceLibrary`: `Target` (geometry, delegated to the
 /// arena flyweight) + `ExpectedIntensity` (reference intensities + envelope).
 #[derive(Clone, Copy)]
 pub struct RefQuery<'a> {
@@ -105,7 +105,7 @@ impl ReferenceLibrary {
     /// Finite library-RT extent across every scored variant.
     pub fn rt_range(&self) -> Option<(f32, f32)> {
         self.iter()
-            .map(|q| q.rt_seconds())
+            .filter_map(|q| q.library_rt().map(|r| r.0))
             .filter(|rt| rt.is_finite())
             .fold(None, |range, rt| {
                 Some(match range {
@@ -214,7 +214,7 @@ impl ReferenceLibrary {
                     builder.push_row(Row {
                         precursor_mz: geom.precursor_mz(row),
                         charge: geom.charge(row),
-                        rt_seconds: geom.rt_seconds(row),
+                        rt: geom.rt(row),
                         mobility: geom.mobility(row),
                         frags: &fragments,
                         analyte: analyte.as_input(),
@@ -305,7 +305,7 @@ impl<'a> ExpectedIntensity for RefQuery<'a> {
     }
 }
 
-impl<'a> QueryGeom for RefQuery<'a> {
+impl<'a> Target for RefQuery<'a> {
     type Label = IonAnnot;
 
     fn source_id(&self) -> Option<timsquery::models::SourceId<'_>> {
@@ -324,8 +324,8 @@ impl<'a> QueryGeom for RefQuery<'a> {
         self.geom.precursor_charge()
     }
 
-    fn rt_seconds(&self) -> f32 {
-        self.geom.rt_seconds()
+    fn rt(&self) -> Option<timsquery::models::RtCoordinate<'_>> {
+        self.geom.rt()
     }
 
     fn mobility_ook0(&self) -> f32 {
@@ -365,7 +365,7 @@ pub struct RowHandles {
     pub group: GroupCode,
 }
 
-/// Identity accessors used by generic scoring loops alongside `QueryGeom`
+/// Identity accessors used by generic scoring loops alongside `Target`
 /// and `ExpectedIntensity`. `RefQuery` resolves handles without copying row
 /// data. Candidates retain handles; chemistry consumers borrow the owning library.
 pub trait ScoredIdentity {
@@ -563,7 +563,7 @@ mod tests {
         geom.push_row(Row {
             precursor_mz: 900.4,
             charge: 2,
-            rt_seconds: 1.0,
+            rt: Some(timsquery::models::RtCoordinate::seconds(1.0)),
             mobility: 1.0,
             frags: &[
                 (IonAnnot::try_from("y3").unwrap(), 300.0),
@@ -676,7 +676,7 @@ mod tests {
         geom.push_row(Row {
             precursor_mz: 900.4,
             charge: 2,
-            rt_seconds: 1.0,
+            rt: Some(timsquery::models::RtCoordinate::seconds(1.0)),
             mobility: 1.0,
             frags: &[(timsquery::IonAnnot::try_from("y3").unwrap(), 300.0)],
             analyte: timsquery::chemistry::analyte::Analyte::from_sequence("PEP").as_input(),
@@ -890,7 +890,7 @@ mod tests {
         let lib = tiny_ref_lib();
         let expected = lib
             .iter()
-            .map(|q| q.rt_seconds())
+            .filter_map(|q| q.library_rt().map(|r| r.0))
             .fold((f32::INFINITY, f32::NEG_INFINITY), |(lo, hi), rt| {
                 (lo.min(rt), hi.max(rt))
             });
@@ -990,7 +990,7 @@ mod load_tests {
     /// policy and triples, and one that ships its own stays 1:1.
     #[test]
     fn every_format_loads_to_the_same_shape() {
-        use timsquery::traits::QueryGeom;
+        use timsquery::traits::Target;
 
         struct Case {
             fixture: &'static str,
@@ -1101,7 +1101,7 @@ mod load_tests {
 
     #[test]
     fn test_mass_shift_decoys() {
-        use timsquery::traits::QueryGeom;
+        use timsquery::traits::Target;
 
         let test_file = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
             .parent()
@@ -1141,8 +1141,8 @@ mod load_tests {
             // Verify other properties are preserved
             for decoy in [&plus, &minus] {
                 assert_eq!(
-                    decoy.rt_seconds(),
-                    target.rt_seconds(),
+                    decoy.library_rt().map(|rt| rt.0),
+                    target.library_rt().map(|rt| rt.0),
                     "RT should be preserved"
                 );
                 assert_eq!(
@@ -1248,7 +1248,7 @@ mod load_tests {
             geom.push_row(Row {
                 precursor_mz: 500.0 + 100.0 * i as f64,
                 charge: 2,
-                rt_seconds: 120.0,
+                rt: Some(timsquery::models::RtCoordinate::seconds(120.0)),
                 mobility: 0.75,
                 frags: &frags,
                 analyte: timsquery::chemistry::analyte::Analyte::from_sequence(spec.sequence)
@@ -1627,7 +1627,7 @@ mod load_tests {
         geom.push_row(Row {
             precursor_mz: 900.4,
             charge: 2,
-            rt_seconds: 1.0,
+            rt: Some(timsquery::models::RtCoordinate::seconds(1.0)),
             mobility: 1.0,
             frags: &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
             analyte: timsquery::chemistry::analyte::Analyte::from_sequence("PEP").as_input(),
diff --git a/rust/timsseek/src/ml/qvalues.rs b/rust/timsseek/src/ml/qvalues.rs
index a4facb67..7d1a2c34 100644
--- a/rust/timsseek/src/ml/qvalues.rs
+++ b/rust/timsseek/src/ml/qvalues.rs
@@ -638,7 +638,10 @@ const LINEAR_NCOLS: usize =
 const BASE_NONLINEAR_NCOLS: usize =
     ScoringFields::NONLINEAR_LEN + ResultMeta::NONLINEAR_LEN + Derived::NONLINEAR_LEN;
 fn nonlinear_ncols(library: &ReferenceLibrary) -> usize {
-    BASE_NONLINEAR_NCOLS + library.scoring_plan().width()
+    library.scoring_plan().nonlinear_indices().len()
+        + ResultMeta::NONLINEAR_LEN
+        + Derived::NONLINEAR_LEN
+        + library.scoring_plan().width()
 }
 fn linear_ncols(library: &ReferenceLibrary) -> usize {
     library.scoring_plan().linear_indices().len() + ResultMeta::LINEAR_LEN + Derived::LINEAR_LEN
@@ -721,7 +724,10 @@ fn project_nonlinear_row(
     derived: &Derived,
     out: &mut impl ValueSink,
 ) {
-    out.push(&scoring.nonlinear_feature_array());
+    let values = scoring.nonlinear_feature_array();
+    for &i in library.scoring_plan().nonlinear_indices() {
+        out.push(&values[i..i + 1]);
+    }
     out.push(&meta.nonlinear_feature_array());
     out.push(&derived.nonlinear_feature_array());
     library.scoring_plan().project(
@@ -858,9 +864,17 @@ pub fn linear_feature_name_set(library: &ReferenceLibrary) -> Vec<Arc<str>> {
 pub fn nonlinear_feature_name_set(library: &ReferenceLibrary) -> Vec<Arc<str>> {
     let mut n = NameSink::new();
     <ScoringFields as ScoreBlock>::nonlinear_feature_names(&mut n);
+    let all = n.into_names();
+    let mut n = NameSink::new();
     <ResultMeta as ScoreBlock>::nonlinear_feature_names(&mut n);
     <Derived as ScoreBlock>::nonlinear_feature_names(&mut n);
-    let mut names = n.into_names();
+    let mut names: Vec<_> = library
+        .scoring_plan()
+        .nonlinear_indices()
+        .iter()
+        .map(|&i| all[i].clone())
+        .chain(n.into_names())
+        .collect();
     names.extend(library.scoring_plan().names().cloned());
     names
 }
@@ -1046,6 +1060,7 @@ mod feature_tests {
                 analyte: analyte.as_input(),
                 charge: 2,
                 precursor_mz: 500.0,
+                rt: Some(timsquery::RtCoordinate::seconds(1.0)),
                 frags: &frags,
                 ..Default::default()
             });
@@ -1379,6 +1394,60 @@ mod feature_tests {
         );
     }
 
+    #[test]
+    fn rt_free_library_omits_rt_features_and_keeps_rescoring_and_qvalues() {
+        use timsquery::models::{
+            Row,
+            TargetCapabilities,
+            TargetColumnsBuilder,
+        };
+        let mut builder =
+            TargetColumnsBuilder::with_capabilities(TargetCapabilities::default_diann());
+        let frags = [(timsquery::ion::IonAnnot::try_from("y1").unwrap(), 300.0)];
+        let analyte = timsquery::chemistry::analyte::Analyte::from_sequence("PEPTIDEK");
+        for _ in 0..1024 {
+            builder.push_row(Row {
+                precursor_mz: 500.0,
+                charge: 2,
+                frags: &frags,
+                analyte: analyte.as_input(),
+                ..Default::default()
+            });
+        }
+        let library = ReferenceLibrary::try_from(timsquery::serde::TargetTable::Mzpaf {
+            geom: builder
+                .seal(timsquery::models::capabilities::DecoyPolicy::Force)
+                .unwrap(),
+            frag_intens: Some(vec![1.0; 1024]),
+        })
+        .unwrap();
+        assert_eq!(library.geometry().rt_axis(), &timsquery::RtAxis::Absent);
+        assert!(matches!(
+            library.geometry().capabilities().decoys,
+            timsquery::models::capabilities::DecoyStrategy::MassShift { .. }
+        ));
+        let names = all_feature_name_set(&library);
+        assert!(
+            names
+                .iter()
+                .all(|n| !n.contains("calibrated_rt") && !n.contains("calibrated_delta_rt"))
+        );
+        let data = synthetic_competed(90);
+        let mut streamed = vec![0.0; all_ncols(&library)];
+        write_competed_all_row(&library, &data[0], &mut streamed);
+        assert_eq!(
+            streamed,
+            build_all_matrix(&library, competed_rows(&data[..1]))
+        );
+        let (out, stats) = rescore_lda(data, &library).unwrap();
+        assert_eq!(out.len(), 90);
+        assert!(!stats.is_empty());
+        assert!(
+            out.iter()
+                .all(|r| r.discriminant_score.is_finite() && (0.0..=1.0).contains(&r.qvalue))
+        );
+    }
+
     #[test]
     fn rescore_lda_is_cross_fit_and_deterministic() {
         let n = 90;
diff --git a/rust/timsseek/src/rt_calibration.rs b/rust/timsseek/src/rt_calibration.rs
index 1726d6c3..abf8cd99 100644
--- a/rust/timsseek/src/rt_calibration.rs
+++ b/rust/timsseek/src/rt_calibration.rs
@@ -171,7 +171,7 @@ impl Default for DerivationParams {
     }
 }
 
-/// A fitted RT calibration plus the tolerance windows measured alongside it.
+/// Independently calibrated dimensions, with an optional RT fit.
 ///
 /// The grid is the source of truth for the curve, the ridge widths and the points
 /// they came from. Taken by `&` on every scoring thread; nothing here refits.
@@ -179,16 +179,14 @@ pub struct CalibrationResult {
     state: CalibratedGrid,
     /// Fallback uniform RT tolerance, used where the grid measured no ridge.
     rt_tolerance_minutes: f32,
-    mz_tolerance_ppm: (f64, f64),
-    mobility_tolerance_pct: (f32, f32),
+    tolerance: Tolerance,
     errors: DimensionErrors,
     derivation: Option<DerivationParams>,
-    fallback: bool,
+    library_rt_axis: timsquery::RtAxis,
 }
 
 impl CalibrationResult {
-    /// Wrap a fitted grid. `Err` when the grid has no curve, which keeps
-    /// [`Self::convert_irt`] infallible.
+    /// Wrap a fitted grid. `Err` when the grid has no curve.
     pub fn new(
         state: CalibratedGrid,
         rt_tolerance_minutes: f32,
@@ -201,19 +199,60 @@ impl CalibrationResult {
         Ok(Self {
             state,
             rt_tolerance_minutes,
-            mz_tolerance_ppm,
-            mobility_tolerance_pct,
+            tolerance: Tolerance {
+                ms: MzTolerance::Ppm(mz_tolerance_ppm),
+                rt: RtTolerance::Unrestricted,
+                mobility: MobilityTolerance::Pct(mobility_tolerance_pct),
+                quad: QuadTolerance::Absolute((0.1, 0.1)),
+            },
             errors: DimensionErrors::default(),
             derivation: None,
-            fallback: false,
+            library_rt_axis: timsquery::RtAxis::Unspecified,
         })
     }
 
-    /// A fallback is an identity RT mapping rather than a measurement of this run.
-    /// It must not be persisted as a calibration: its two identity endpoints are
-    /// non-empty like any real fit, so a reader could not tell the file apart.
-    pub fn is_fallback(&self) -> bool {
-        self.fallback
+    /// Record the coordinate domain used when fitting this calibration.
+    pub fn with_rt_axis(mut self, axis: &timsquery::RtAxis) -> Self {
+        self.library_rt_axis = axis.clone();
+        self
+    }
+
+    pub fn has_rt_calibration(&self) -> bool {
+        self.state.curve().is_some()
+    }
+
+    /// Each axis with no measurements retains its configured extraction window.
+    pub fn from_measurements(
+        mut state: CalibratedGrid,
+        configured: &Tolerance,
+        errors: DimensionErrors,
+        derivation: DerivationParams,
+    ) -> Self {
+        if state.curve().is_none() {
+            state.reset();
+        }
+        let windows = errors.derive_windows(&derivation);
+        let mut tolerance = configured
+            .clone()
+            .with_rt_tolerance(RtTolerance::Unrestricted);
+        if errors.mz_ppm.n > 0 {
+            let mut bounds = windows.mz_ppm;
+            if let MzTolerance::Ppm(broad) = configured.ms {
+                bounds = (bounds.0.min(broad.0), bounds.1.min(broad.1));
+            }
+            tolerance.ms = MzTolerance::Ppm(bounds);
+        }
+        if errors.mobility_pct.n > 0 {
+            tolerance.mobility = MobilityTolerance::Pct(windows.mobility_pct);
+        }
+        Self {
+            state,
+            tolerance,
+            rt_tolerance_minutes: windows.rt_minutes,
+            errors,
+            derivation: Some(derivation),
+            library_rt_axis: timsquery::RtAxis::Unspecified,
+        }
     }
 
     /// The grid this was fit on -- the source for the curve, the ridge widths and
@@ -242,21 +281,24 @@ impl CalibrationResult {
         ridge_half_width_interp(self.state.ridge_widths(), library_rt.0)
     }
 
-    /// The fitted curve. Present for the lifetime of `self` -- [`Self::new`]
-    /// rejects a grid without one.
-    fn curve(&self) -> &RTCalibration {
-        self.state
+    /// Convert indexed RT to calibrated absolute RT (seconds).
+    pub fn convert_irt(&self, irt: LibraryRT<f32>) -> Result<ObservedRTSeconds<f32>, CalibRtError> {
+        match self
+            .state
             .curve()
-            .expect("CalibrationResult::new rejects a grid with no curve")
+            .ok_or(CalibRtError::NoPoints)?
+            .predict(LibraryRT(irt.0 as f64))
+        {
+            Ok(rt) => Ok(ObservedRTSeconds(rt.0 as f32)),
+            // calibrt reports its extrapolated observed value in this variant.
+            Err(CalibRtError::OutOfBounds(seconds)) => Ok(ObservedRTSeconds(seconds as f32)),
+            Err(err) => Err(err),
+        }
     }
 
-    /// Convert indexed RT to calibrated absolute RT (seconds).
-    pub fn convert_irt(&self, irt: LibraryRT<f32>) -> ObservedRTSeconds<f32> {
-        match self.curve().predict(LibraryRT(irt.0 as f64)) {
-            Ok(rt) => ObservedRTSeconds(rt.0 as f32),
-            Err(CalibRtError::OutOfBounds(rt)) => ObservedRTSeconds(rt as f32),
-            Err(_) => ObservedRTSeconds(irt.0),
-        }
+    /// Keep calibrated m/z and mobility windows without imposing an RT constraint.
+    pub fn unrestricted_rt_tolerance(&self) -> Tolerance {
+        self.tolerance.clone()
     }
 
     /// Derived RT tolerance in minutes.
@@ -275,27 +317,27 @@ impl CalibrationResult {
 
     /// Get per-query tolerance. Uses position-dependent ridge width when available,
     /// falls back to uniform `rt_tolerance_minutes` otherwise.
-    /// `rt` is the library RT in seconds (pre-calibration).
+    /// `rt` is a coordinate on the original library axis.
     pub fn get_tolerance(&self, _mz: f64, _mobility: f32, rt: LibraryRT<f32>) -> Tolerance {
         let rt_tol_minutes = match self.ridge_half_width_at(LibraryRT(rt.0 as f64)) {
             Some(half_width) => rt_tolerance_from_ridge(half_width, self.rt_floor_minutes()),
             None => self.rt_tolerance_minutes,
         };
 
-        Tolerance {
-            ms: MzTolerance::Ppm(self.mz_tolerance_ppm),
-            rt: RtTolerance::Minutes((rt_tol_minutes, rt_tol_minutes)),
-            mobility: MobilityTolerance::Pct(self.mobility_tolerance_pct),
-            quad: QuadTolerance::Absolute((0.1, 0.1)),
+        if !self.has_rt_calibration() {
+            return self.unrestricted_rt_tolerance();
         }
+        self.tolerance
+            .clone()
+            .with_rt_tolerance(RtTolerance::Minutes((rt_tol_minutes, rt_tol_minutes)))
     }
 
-    pub fn mz_tolerance(&self) -> (f64, f64) {
-        self.mz_tolerance_ppm
+    pub fn mz_tolerance(&self) -> &MzTolerance {
+        &self.tolerance.ms
     }
 
-    pub fn mobility_tolerance(&self) -> (f32, f32) {
-        self.mobility_tolerance_pct
+    pub fn mobility_tolerance(&self) -> &MobilityTolerance {
+        &self.tolerance.mobility
     }
 
     /// Summary of ridge width measurements for reporting.
@@ -305,18 +347,19 @@ impl CalibrationResult {
 
     /// Tolerance for the secondary spectral query at a detected apex.
     pub fn get_spectral_tolerance(&self) -> Tolerance {
-        Tolerance {
-            ms: MzTolerance::Ppm(self.mz_tolerance_ppm),
-            rt: RtTolerance::Minutes((0.5 / 60.0, 0.5 / 60.0)), // ~0.5 seconds
-            mobility: MobilityTolerance::Pct(self.mobility_tolerance_pct),
-            quad: QuadTolerance::Absolute((0.1, 0.1)),
-        }
+        self.tolerance
+            .clone()
+            .with_rt_tolerance(RtTolerance::Minutes((0.5 / 60.0, 0.5 / 60.0)))
     }
 
-    /// Tight mobility tolerance for isotope pattern matching.
+    /// Tight mobility refinement only when mobility calibration succeeded.
     pub fn get_isotope_tolerance(&self) -> Tolerance {
-        self.get_spectral_tolerance()
-            .with_mobility_tolerance(MobilityTolerance::Pct((3.0, 3.0)))
+        let tolerance = self.get_spectral_tolerance();
+        if self.errors.mobility_pct.n > 0 {
+            tolerance.with_mobility_tolerance(MobilityTolerance::Pct((3.0, 3.0)))
+        } else {
+            tolerance
+        }
     }
 
     /// Write the calibration where a viewer or the dashboard can read it.
@@ -337,37 +380,22 @@ impl CalibrationResult {
             Some(ResidualBlock {
                 errors: self.errors.clone(),
                 derivation: self.derivation.clone().unwrap_or_default(),
-                mz_ppm: [self.mz_tolerance_ppm.0, self.mz_tolerance_ppm.1],
-                mobility_pct: [
-                    self.mobility_tolerance_pct.0 as f64,
-                    self.mobility_tolerance_pct.1 as f64,
-                ],
+                tolerance: self.unrestricted_rt_tolerance(),
             }),
             n_scored,
         )
+        .with_library_rt_axis(self.library_rt_axis.clone())
         .write(path)
     }
 
-    /// Fallback when calibration fails: identity RT mapping, secondary tolerance.
+    /// No measured dimensions: preserve configured windows and search all RT.
     pub fn fallback<I: ScorerQueriable>(pipeline: &Scorer<I>) -> Self {
-        let range = pipeline.index.ms1_cycle_mapping().range_milis();
-        let start = range.0 as f64 / 1000.0;
-        let end = range.1 as f64 / 1000.0;
-        let mut state = CalibratedGrid::new(10, (start, end), (start, end), 10)
-            .expect("the run's own RT range is a valid grid geometry");
-        state
-            .update(
-                [start, end]
-                    .into_iter()
-                    .map(|rt| (LibraryRT(rt), ObservedRTSeconds(rt), CALIBRANT_WEIGHT)),
-            )
-            .expect("the identity endpoints are finite");
-        state.fit();
-
-        let mut out = Self::new(state, 1.0, (10.0, 10.0), (5.0, 5.0))
-            .expect("two identity endpoints always fit a two-point curve");
-        out.fallback = true;
-        out
+        Self::from_measurements(
+            CalibratedGrid::deferred(10, 10).expect("valid default grid geometry"),
+            &pipeline.broad_tolerance,
+            DimensionErrors::default(),
+            DerivationParams::default(),
+        )
     }
 }
 
@@ -380,8 +408,7 @@ pub type SavedCalibration = calibrt::SavedCalibration<ResidualBlock>;
 pub struct ResidualBlock {
     pub errors: DimensionErrors,
     pub derivation: DerivationParams,
-    pub mz_ppm: [f64; 2],
-    pub mobility_pct: [f64; 2],
+    pub tolerance: Tolerance,
 }
 
 /// Linearly interpolate the ridge half-width at a given library RT (seconds).
@@ -411,6 +438,78 @@ mod tests {
     use super::*;
     use tempfile::TempDir;
 
+    #[test]
+    fn dimensions_calibrate_independently_and_missing_axes_keep_configuration() {
+        let configured = Tolerance {
+            ms: MzTolerance::Absolute((0.01, 0.02)),
+            mobility: MobilityTolerance::Unrestricted,
+            rt: RtTolerance::Minutes((1.0, 2.0)),
+            quad: QuadTolerance::Absolute((0.3, 0.4)),
+        };
+        for (mz, mob) in [(false, false), (true, false), (false, true), (true, true)] {
+            let errors = DimensionErrors {
+                mz_ppm: ErrorStats::from_slice(if mz { &[2.0, 3.0, 4.0] } else { &[] }),
+                mobility_pct: ErrorStats::from_slice(if mob { &[0.2, 0.3, 0.4] } else { &[] }),
+                ..Default::default()
+            };
+            let result = CalibrationResult::from_measurements(
+                CalibratedGrid::deferred(10, 3).unwrap(),
+                &configured,
+                errors,
+                DerivationParams::default(),
+            );
+            assert!(!result.has_rt_calibration());
+            assert!(result.convert_irt(LibraryRT(20.0)).is_err());
+            let primary = result.get_tolerance(500.0, 1.0, LibraryRT(20.0));
+            assert_eq!(primary.rt, RtTolerance::Unrestricted);
+            assert_eq!(primary.quad, configured.quad);
+            if mz {
+                assert!(matches!(primary.ms, MzTolerance::Ppm(_)));
+            } else {
+                assert_eq!(primary.ms, configured.ms);
+            }
+            if mob {
+                assert!(matches!(primary.mobility, MobilityTolerance::Pct(_)));
+            } else {
+                assert_eq!(primary.mobility, configured.mobility);
+            }
+            let secondary = result.get_spectral_tolerance();
+            assert_eq!(secondary.ms, primary.ms);
+            assert_eq!(secondary.mobility, primary.mobility);
+            assert_eq!(secondary.quad, primary.quad);
+            if !mob {
+                assert_eq!(result.get_isotope_tolerance().mobility, configured.mobility);
+            }
+            let dir = TempDir::new().unwrap();
+            let path = dir.path().join("calibration.json");
+            result.save_json([0.0, 600.0], 10, &path).unwrap();
+            let (saved, _) = SavedCalibration::read(&path, None).unwrap();
+            assert!(saved.calibration.points.is_empty());
+            let residuals = saved.residuals.unwrap();
+            assert_eq!(residuals.tolerance.ms, primary.ms);
+            assert_eq!(residuals.tolerance.mobility, primary.mobility);
+            assert_eq!(residuals.errors.mz_ppm.n, if mz { 3 } else { 0 });
+        }
+    }
+
+    #[test]
+    fn measured_mz_window_stays_inside_configured_ppm_window() {
+        let configured = Tolerance {
+            ms: MzTolerance::Ppm((8.0, 15.0)),
+            ..Tolerance::default()
+        };
+        let result = CalibrationResult::from_measurements(
+            CalibratedGrid::deferred(10, 3).unwrap(),
+            &configured,
+            DimensionErrors {
+                mz_ppm: ErrorStats::from_slice(&[-60.0, 0.0, 60.0]),
+                ..Default::default()
+            },
+            DerivationParams::default(),
+        );
+        assert_eq!(*result.mz_tolerance(), configured.ms);
+    }
+
     /// A curve with enough spread that the grid fit is non-degenerate, plus ridge
     /// widths and tolerances distinct from every default, so a field silently
     /// dropped by the round-trip shows up as a mismatch.
@@ -457,9 +556,26 @@ mod tests {
     /// The snapshot is the whole record of the fit, so refitting it must reproduce
     /// the curve and the ridge widths. Walks a reader's real path:
     /// `read` -> `from_snapshot` -> `new`.
+    #[test]
+    fn unavailable_calibration_never_reinterprets_the_input_as_seconds() {
+        let mut calibration = sample_calibration();
+        calibration.state = CalibratedGrid::deferred(10, 3).unwrap();
+        assert!(matches!(
+            calibration.convert_irt(LibraryRT(-20.0)),
+            Err(CalibRtError::NoPoints)
+        ));
+        assert!(matches!(
+            calibration.convert_irt(LibraryRT(0.0)),
+            Err(CalibRtError::NoPoints)
+        ));
+    }
+
     #[test]
     fn a_saved_snapshot_refits_to_the_same_calibration() {
-        let original = sample_calibration();
+        let axis = timsquery::RtAxis::NormalizedIndex {
+            scale: Some("test-reference".into()),
+        };
+        let original = sample_calibration().with_rt_axis(&axis);
         let dir = save_fixture(&original);
         let path = dir.path().join("calibration.json");
 
@@ -469,11 +585,16 @@ mod tests {
             "the fixture's RT range is the one it claims: {warning:?}"
         );
 
+        assert_eq!(saved.library_rt_axis, axis);
+
         let residuals = saved
             .residuals
             .expect("a search's calibration carries its residuals");
-        assert_eq!(residuals.mz_ppm, [7.5, 8.5]);
-        assert_eq!(residuals.mobility_pct, [2.5, 3.5]);
+        assert_eq!(residuals.tolerance.ms, MzTolerance::Ppm((7.5, 8.5)));
+        assert_eq!(
+            residuals.tolerance.mobility,
+            MobilityTolerance::Pct((2.5, 3.5))
+        );
         assert_eq!(
             residuals.errors.rt_seconds.n,
             original.errors().rt_seconds.n
@@ -482,16 +603,9 @@ mod tests {
         let refit = CalibratedGrid::from_snapshot(&saved.calibration).unwrap();
         assert_eq!(refit.fit_points(), original.state().fit_points());
 
-        let reloaded = CalibrationResult::new(
-            refit,
-            saved.rt_tolerance_minutes,
-            (residuals.mz_ppm[0], residuals.mz_ppm[1]),
-            (
-                residuals.mobility_pct[0] as f32,
-                residuals.mobility_pct[1] as f32,
-            ),
-        )
-        .unwrap();
+        let reloaded =
+            CalibrationResult::new(refit, saved.rt_tolerance_minutes, (7.5, 8.5), (2.5, 3.5))
+                .unwrap();
 
         // The ridge was refit, not read back, so matching it is the claim that the
         // persisted points and geometry reproduce the grid they came from.
@@ -517,8 +631,14 @@ mod tests {
                 rt.0
             );
             assert_eq!(
-                reloaded.convert_irt(rt).0,
-                original.convert_irt(rt).0,
+                reloaded
+                    .convert_irt(rt)
+                    .map(|v| v.0)
+                    .map_err(|e| format!("{e:?}")),
+                original
+                    .convert_irt(rt)
+                    .map(|v| v.0)
+                    .map_err(|e| format!("{e:?}")),
                 "RT conversion mismatch at library RT {}",
                 rt.0
             );
@@ -601,6 +721,7 @@ mod tests {
             r#"{{
               "version": "{version}",
               "rt_range_seconds": [0.0, 1200.0],
+              "library_rt_axis": {{"kind": "seconds"}},
               "calibration": {{
                 "points": [[0.0, 30.0, 1.0], [100.0, 200.0, 1.0],
                            [200.0, 370.0, 1.0], [300.0, 540.0, 1.0]],
@@ -639,6 +760,9 @@ mod tests {
         let dir = write_foreign("v2");
         let err = SavedCalibration::read(&dir.path().join("calibration.json"), Some([0.0, 1200.0]))
             .unwrap_err();
-        assert!(err.contains("v2") && err.contains("v3"), "{err}");
+        assert!(
+            err.contains("v2") && err.contains(CALIBRATION_FORMAT_VERSION),
+            "{err}"
+        );
     }
 }
diff --git a/rust/timsseek/src/scoring/apex_finding.rs b/rust/timsseek/src/scoring/apex_finding.rs
index 02ae5940..c079f473 100644
--- a/rust/timsseek/src/scoring/apex_finding.rs
+++ b/rust/timsseek/src/scoring/apex_finding.rs
@@ -94,7 +94,7 @@ pub struct CandidateMetadata {
     pub library_rt: f32,
 
     /// Calibrated retention time in seconds (predicted observed RT for this run).
-    /// Equals library_rt when no calibration has been applied.
+    /// NaN when no prediction is available.
     pub calibrated_rt_seconds: f32,
 
     /// Reference ion mobility (ook0) from library.
diff --git a/rust/timsseek/src/scoring/extraction.rs b/rust/timsseek/src/scoring/extraction.rs
index 49dbe365..6b3733d4 100644
--- a/rust/timsseek/src/scoring/extraction.rs
+++ b/rust/timsseek/src/scoring/extraction.rs
@@ -1,38 +1,32 @@
 //! Shared extraction builder -- used by both CLI (Scorer) and viewer.
 
-use crate::data_sources::reference_library::{
-    ExpectedIntensity,
-    RefQuery,
-};
+use crate::data_sources::reference_library::ExpectedIntensity;
 use crate::models::ExpectedIntensities;
 use crate::scoring::apex_finding::Extraction;
 use crate::traits::MappableRTCycles;
-use timsquery::traits::QueryGeom;
+#[cfg(test)]
 use timsquery::utils::TupleRange;
 use timsquery::{
     ChromatogramCollector,
+    ExtractionQuery,
     IonAnnot,
     KeyLike,
-    OptionallyRestricted,
+    PeakTolerance,
     QueriableData,
-    Tolerance,
 };
 
 use super::skip::SkipReason;
 
-/// Build an extraction from owned query inputs.
-///
-/// RT range derived internally from query.rt_seconds() + tolerance,
-/// clamped to the index's cycle_mapping range.
+/// Build an extraction from borrowed source geometry and resolved acquisition RT.
 ///
 /// top_n_fragments:
 ///   Some(n) -> filter_zero_intensity_ions + select_top_n_fragments(n)
 ///   None    -> no filtering, all ions kept
 pub fn build_extraction<T, I>(
-    query: &timsquery::Target<T>,
+    query: &ExtractionQuery<'_, impl timsquery::Target<Label = T>>,
     mut expected_intensities: ExpectedIntensities<T>,
     index: &I,
-    tolerance: &Tolerance,
+    tolerance: &PeakTolerance,
     top_n_fragments: Option<usize>,
 ) -> Result<Extraction<T>, SkipReason>
 where
@@ -40,20 +34,8 @@ where
     I: QueriableData<ChromatogramCollector<T, f32>> + MappableRTCycles,
 {
     let cycle_mapping = index.ms1_cycle_mapping();
-    let max_range = cycle_mapping.range_milis();
-    let max_range = TupleRange::try_new(max_range.0, max_range.1)
-        .expect("Reference RTs should be sorted and valid");
-
-    let rt_range = match tolerance.rt_range_as_milis(query.rt_seconds()) {
-        OptionallyRestricted::Unrestricted => max_range,
-        OptionallyRestricted::Restricted(r) => r,
-    };
 
-    if !max_range.intersects(rt_range) {
-        return Err(SkipReason::RetentionTimeOutOfBounds);
-    }
-
-    let mut agg = ChromatogramCollector::new(query, rt_range, cycle_mapping)
+    let mut agg = ChromatogramCollector::new(query, cycle_mapping)
         .map_err(|_| SkipReason::RetentionTimeOutOfBounds)?;
 
     index.add_query(&mut agg, tolerance);
@@ -96,44 +78,28 @@ fn classify_post_add_query<T: KeyLike>(
 ///
 /// On first call the `scratch` slot is `None` and a fresh `Extraction` is
 /// allocated. Subsequent calls reset the existing one in place.
-pub fn build_extraction_into<I>(
+pub fn build_extraction_into<I, Q>(
     scratch: &mut Option<Extraction<IonAnnot>>,
-    query: &RefQuery<'_>,
-    rt_override: Option<f32>,
+    query: &ExtractionQuery<'_, Q>,
     index: &I,
-    tolerance: &Tolerance,
+    tolerance: &PeakTolerance,
     top_n_fragments: Option<usize>,
 ) -> Result<(), SkipReason>
 where
+    Q: timsquery::Target<Label = IonAnnot> + ExpectedIntensity,
     I: QueriableData<ChromatogramCollector<IonAnnot, f32>> + MappableRTCycles,
 {
     let cycle_mapping = index.ms1_cycle_mapping();
-    let max_range = cycle_mapping.range_milis();
-    let max_range = TupleRange::try_new(max_range.0, max_range.1)
-        .expect("Reference RTs should be sorted and valid");
-
-    let query_rt = rt_override.unwrap_or_else(|| query.rt_seconds());
-    let rt_range = match tolerance.rt_range_as_milis(query_rt) {
-        OptionallyRestricted::Unrestricted => max_range,
-        OptionallyRestricted::Restricted(r) => r,
-    };
-
-    if !max_range.intersects(rt_range) {
-        return Err(SkipReason::RetentionTimeOutOfBounds);
-    }
 
     match scratch {
         Some(extr) => {
             extr.chromatograms
-                .try_reset_with_overrides(query, rt_override, None, rt_range, cycle_mapping)
+                .try_reset_with(query, cycle_mapping)
                 .map_err(|_| SkipReason::RetentionTimeOutOfBounds)?;
         }
         None => {
-            let mut agg = ChromatogramCollector::new(query, rt_range, cycle_mapping)
+            let agg = ChromatogramCollector::new(query, cycle_mapping)
                 .map_err(|_| SkipReason::RetentionTimeOutOfBounds)?;
-            if let Some(rt) = rt_override {
-                agg.rt_seconds = rt;
-            }
             *scratch = Some(Extraction {
                 expected_intensities: ExpectedIntensities::default(),
                 chromatograms: agg,
@@ -144,7 +110,7 @@ where
     let extr = scratch
         .as_mut()
         .expect("extraction set by build_extraction_into");
-    refill_expected(extr, query);
+    refill_expected(extr, query.source());
     index.add_query(&mut extr.chromatograms, tolerance);
 
     classify_post_add_query(&extr.chromatograms)?;
@@ -165,7 +131,7 @@ where
 }
 
 /// Copy validated reference values only into the buffers filtering will mutate.
-fn refill_expected(extraction: &mut Extraction<IonAnnot>, query: &RefQuery<'_>) {
+fn refill_expected(extraction: &mut Extraction<IonAnnot>, query: &impl ExpectedIntensity) {
     let expected = &mut extraction.expected_intensities;
     expected.fragment_intensities.clear();
     expected
@@ -195,12 +161,59 @@ mod tests {
         CycleToRTMapping,
         MS1CycleIndex,
     };
+    use timsquery::Tolerance;
     use timsquery::models::capabilities::TargetCapabilities;
     use timsquery::models::{
         Row,
         TargetColumnsBuilder,
     };
 
+    #[test]
+    fn extraction_preserves_source_coordinate() {
+        let axis = timsquery::RtAxis::NormalizedIndex {
+            scale: Some("anchors".into()),
+        };
+        let mut builder =
+            TargetColumnsBuilder::with_capabilities(TargetCapabilities::default_diann());
+        let fragments = [(IonAnnot::try_from("y1").unwrap(), 300.0)];
+        builder.push_row(Row {
+            precursor_mz: 500.0,
+            charge: 2,
+            frags: &fragments,
+            rt: Some(timsquery::RtCoordinate {
+                value: timsquery::LibraryRT(-20.0),
+                axis: &axis,
+            }),
+            ..Default::default()
+        });
+        let lib = ReferenceLibrary::try_from(timsquery::serde::TargetTable::Mzpaf {
+            geom: builder.seal(crate::models::DecoyPolicy::Never).unwrap(),
+            frag_intens: Some(vec![1.0]),
+        })
+        .unwrap();
+        let source = lib.iter().next().unwrap();
+        let rt = timsquery::ResolvedRt::resolve(
+            timsquery::RtSelection::Centered(timsquery::ObservedRTSeconds(120.0)),
+            &timsquery::models::tolerance::RtTolerance::Minutes((0.5, 0.5)),
+            TupleRange::try_new(
+                timsquery::ObservedRTSeconds(0.0),
+                timsquery::ObservedRTSeconds(300.0),
+            )
+            .unwrap(),
+        )
+        .unwrap();
+        let query = ExtractionQuery::new(&source, rt);
+        assert_eq!(
+            query.rt().range_millis(),
+            TupleRange::try_new(90_000, 150_000).unwrap()
+        );
+        assert_eq!(
+            timsquery::Target::library_rt(query.source()),
+            Some(timsquery::LibraryRT(-20.0))
+        );
+        assert!(std::ptr::eq(query.source(), &source));
+    }
+
     struct TestIndex(CycleToRTMapping<MS1CycleIndex>);
 
     impl MappableRTCycles for TestIndex {
@@ -214,7 +227,11 @@ mod tests {
     }
 
     impl QueriableData<ChromatogramCollector<IonAnnot, f32>> for TestIndex {
-        fn add_query(&self, agg: &mut ChromatogramCollector<IonAnnot, f32>, _: &Tolerance) {
+        fn add_query(
+            &self,
+            agg: &mut ChromatogramCollector<IonAnnot, f32>,
+            _: &timsquery::PeakTolerance,
+        ) {
             // First fragment and all precursors remain zero, exercising removal.
             for row in 1..agg.fragments.num_ions() {
                 agg.fragments
@@ -243,6 +260,7 @@ mod tests {
         for count in [20, 2] {
             builder.push_row(Row {
                 precursor_mz: 500.0,
+                rt: Some(timsquery::RtCoordinate::seconds(0.0)),
                 charge: 2,
                 frags: &fragments[..count],
                 analyte: timsquery::chemistry::analyte::Analyte::from_sequence("PEPTIDEK")
@@ -264,20 +282,20 @@ mod tests {
         for query in lib.iter() {
             // Compare both unfiltered extraction and zero-signal/top-N filtering.
             for top_n in [None, Some(8)] {
-                let mut materialized = timsquery::Target::empty_like();
+                let mut materialized = timsquery::OwnedTarget::empty_like();
                 materialized.reset_from(&query);
-                let mut shifted_direct = timsquery::Target::empty_like();
-                let mut shifted_owned = timsquery::Target::empty_like();
-                crate::utils::elution_group_ops::apply_isotope_offset_fragments_into(
-                    &mut shifted_direct,
-                    &query,
-                    1,
-                );
-                crate::utils::elution_group_ops::apply_isotope_offset_fragments_into(
-                    &mut shifted_owned,
-                    &materialized,
-                    1,
-                );
+                let rt = timsquery::ResolvedRt::from_mapping(
+                    timsquery::RtSelection::FullRun,
+                    &tolerance.rt,
+                    &index.0,
+                )
+                .unwrap();
+                let direct_query = ExtractionQuery::new(&query, rt);
+                let owned_query = ExtractionQuery::new(&materialized, rt);
+                let mut shifted_direct = timsquery::SpectralCollector::new(&direct_query);
+                let mut shifted_owned = timsquery::SpectralCollector::new(&owned_query);
+                crate::utils::elution_group_ops::shift_fragment_isotopes(&mut shifted_direct, 1);
+                crate::utils::elution_group_ops::shift_fragment_isotopes(&mut shifted_owned, 1);
                 assert_eq!(
                     serde_json::to_value(&shifted_direct).unwrap(),
                     serde_json::to_value(&shifted_owned).unwrap()
@@ -287,9 +305,22 @@ mod tests {
                     query.expected_precursor_envelope(),
                 )
                 .unwrap();
-                let baseline =
-                    build_extraction(&materialized, expected, &index, &tolerance, top_n).unwrap();
-                build_extraction_into(&mut slot, &query, None, &index, &tolerance, top_n).unwrap();
+                let baseline = build_extraction(
+                    &owned_query,
+                    expected,
+                    &index,
+                    &tolerance.peak_tolerance(),
+                    top_n,
+                )
+                .unwrap();
+                build_extraction_into(
+                    &mut slot,
+                    &direct_query,
+                    &index,
+                    &tolerance.peak_tolerance(),
+                    top_n,
+                )
+                .unwrap();
                 let actual = slot.as_ref().unwrap();
                 assert_eq!(
                     actual.expected_intensities.fragment_intensities,
@@ -309,10 +340,28 @@ mod tests {
                 }
                 allocation = Some(ptr);
             }
-            build_extraction_into(&mut slot, &query, Some(0.01), &index, &tolerance, None).unwrap();
-            assert_eq!(slot.as_ref().unwrap().chromatograms.rt_seconds, 0.01);
+            build_extraction_into(
+                &mut slot,
+                &ExtractionQuery::new(
+                    &query,
+                    timsquery::ResolvedRt::from_mapping(
+                        timsquery::RtSelection::Centered(timsquery::ObservedRTSeconds(0.01)),
+                        &tolerance.rt,
+                        &index.0,
+                    )
+                    .unwrap(),
+                ),
+                &index,
+                &tolerance.peak_tolerance(),
+                None,
+            )
+            .unwrap();
+            assert_eq!(
+                slot.as_ref().unwrap().chromatograms.rt.center().unwrap().0,
+                0.01
+            );
             assert_eq!(
-                query.rt_seconds(),
+                timsquery::Target::library_rt(&query).unwrap().0,
                 0.0,
                 "calibration must not change library RT"
             );
diff --git a/rust/timsseek/src/scoring/offsets.rs b/rust/timsseek/src/scoring/offsets.rs
index 288e4948..1893353d 100644
--- a/rust/timsseek/src/scoring/offsets.rs
+++ b/rust/timsseek/src/scoring/offsets.rs
@@ -156,8 +156,12 @@ impl MzMobilityOffsets {
         // (mzML against a no-IM library) has all-NaN mobility errors, but its m/z
         // errors are perfectly good and MUST still calibrate. Gate each on its
         // own weight; return NaN mobility rather than dropping the whole calibrant.
-        if w_mz > 0.0 {
-            let mz_avg = (mz / w_mz) as f32;
+        if w_mz > 0.0 || w_mob > 0.0 {
+            let mz_avg = if w_mz > 0.0 {
+                (mz / w_mz) as f32
+            } else {
+                f32::NAN
+            };
             let mob_avg = if w_mob > 0.0 {
                 (mob / w_mob) as f32
             } else {
@@ -280,6 +284,20 @@ mod tests {
         );
     }
 
+    #[test]
+    fn weighted_ms1_calibrates_mobility_when_mz_absent() {
+        let mut ms1 = TopNArray::new();
+        ms1.push(ion(10.0, f32::NAN, 2.0));
+        let offsets = MzMobilityOffsets {
+            ms1,
+            ms2: TopNArray::new(),
+            ref_mobility: 1.0,
+        };
+        let (mz, mob) = offsets.weighted_ms1().unwrap();
+        assert!(mz.is_nan());
+        assert_eq!(mob, 2.0);
+    }
+
     #[test]
     fn weighted_ms1_none_without_mz_signal() {
         let offsets = MzMobilityOffsets {
diff --git a/rust/timsseek/src/scoring/parquet_writer.rs b/rust/timsseek/src/scoring/parquet_writer.rs
index 7c8914db..e8f53196 100644
--- a/rust/timsseek/src/scoring/parquet_writer.rs
+++ b/rust/timsseek/src/scoring/parquet_writer.rs
@@ -46,7 +46,7 @@ use super::results::FinalResult;
 /// keys`), and then a target and its shipped decoy share one `decoy_group_id`
 /// across two `library_id`s. Other formats declare nothing, so for them the
 /// duplication is expected, not a bug.
-pub const RESULTS_FORMAT_VERSION: u32 = 4;
+pub const RESULTS_FORMAT_VERSION: u32 = 5;
 
 // ---------------------------------------------------------------------------
 // Build a RecordBatch from a slice of FinalResult
@@ -260,6 +260,10 @@ impl<'a> ResultParquetWriter<'a> {
         let schema = empty_batch.schema();
 
         let kv = vec![
+            KeyValue {
+                key: "library_rt_axis".into(),
+                value: Some(serde_json::to_string(geom.rt_axis()).map_err(std::io::Error::other)?),
+            },
             KeyValue {
                 key: "result_mode".into(),
                 value: Some(if raw { "raw" } else { "rescored" }.into()),
@@ -375,7 +379,7 @@ mod tests {
             geom.push_row(Row {
                 precursor_mz: 900.4,
                 charge: 2,
-                rt_seconds: 1.0,
+                rt: Some(timsquery::models::RtCoordinate::seconds(1.0)),
                 mobility: 1.0,
                 frags: &[(IonAnnot::try_from("y3").unwrap(), 300.0)],
                 analyte: timsquery::chemistry::analyte::Analyte::from_sequence(seq).as_input(),
@@ -593,6 +597,12 @@ mod tests {
         let reader = SerializedFileReader::new(file).expect("reader");
         let meta = reader.metadata().file_metadata();
         let kv_list = meta.key_value_metadata().expect("kv metadata present");
+        let axis = kv_list
+            .iter()
+            .find(|k| k.key == "library_rt_axis")
+            .expect("RT metadata");
+        let axis: serde_json::Value = serde_json::from_str(axis.value.as_deref().unwrap()).unwrap();
+        assert_eq!(axis["kind"], "seconds");
         let plan = kv_list
             .iter()
             .find(|k| k.key == "scoring_plan")
diff --git a/rust/timsseek/src/scoring/pipeline.rs b/rust/timsseek/src/scoring/pipeline.rs
index 46f6b85f..63bbaecb 100644
--- a/rust/timsseek/src/scoring/pipeline.rs
+++ b/rust/timsseek/src/scoring/pipeline.rs
@@ -44,14 +44,16 @@ use timscentroid::rt_mapping::{
     RTIndex,
 };
 use timsquery::models::FlatIdx;
-use timsquery::traits::QueryGeom;
+use timsquery::traits::Target;
 use timsquery::utils::TupleRange;
 use timsquery::{
     ChromatogramCollector,
+    ExtractionQuery,
     KeyLike,
     MzMobilityStatsCollector,
+    ResolvedRt,
+    RtSelection,
     SpectralCollector,
-    Target,
     Tolerance,
 };
 
@@ -96,13 +98,11 @@ use tracing::warn;
 /// Per-rayon-worker scoring state. Holds a `TraceScorer` plus reusable scratch:
 /// - `Extraction` slot (ChromatogramCollector reset-and-reused, not reallocated)
 /// - `inner_collector` / `isotope_collector` reused across Phase 3 secondary queries
-/// - `isotope_query` holds geometry with a neutron offset, initialized lazily.
 pub struct ScoringWorker {
     pub scorer: TraceScorer,
     pub extraction: Option<Extraction<IonAnnot>>,
     pub inner_collector: Option<SpectralCollector<IonAnnot, MzMobilityStatsCollector>>,
     pub isotope_collector: Option<SpectralCollector<IonAnnot, f32>>,
-    pub isotope_query: Option<timsquery::Target<IonAnnot>>,
 }
 
 impl ScoringWorker {
@@ -112,7 +112,6 @@ impl ScoringWorker {
             extraction: None,
             inner_collector: None,
             isotope_collector: None,
-            isotope_query: None,
         }
     }
 }
@@ -196,11 +195,13 @@ fn calibrant_heap_group(index: FlatIdx) -> usize {
 }
 
 /// Two independent calibration folds, each split into equal-width library-RT
-/// bands. This is a bounded, mergeable accumulator for the parallel prescore.
+/// bands (observed RT when library RT is absent). This is a bounded, mergeable
+/// accumulator for the parallel prescore.
 pub struct StratifiedCalibrantHeaps {
     heaps: [[CalibrantHeap; CALIBRANT_RT_BANDS]; CALIBRANT_HEAP_GROUPS],
     rt_min: f32,
     band_scale: f32,
+    observed_rt_bands: bool,
 }
 
 impl StratifiedCalibrantHeaps {
@@ -217,9 +218,23 @@ impl StratifiedCalibrantHeaps {
             }),
             rt_min,
             band_scale,
+            observed_rt_bands: false,
         }
     }
 
+    pub fn for_library(
+        capacity: usize,
+        library_range: Option<(f32, f32)>,
+        observed_range: (f64, f64),
+    ) -> Self {
+        let mut heaps = Self::new(
+            capacity,
+            library_range.unwrap_or((observed_range.0 as f32, observed_range.1 as f32)),
+        );
+        heaps.observed_rt_bands = library_range.is_none();
+        heaps
+    }
+
     fn band_of(&self, library_rt: f32) -> usize {
         if self.band_scale == 0.0 {
             return 0;
@@ -229,7 +244,11 @@ impl StratifiedCalibrantHeaps {
 
     pub fn push(&mut self, candidate: CalibrantCandidate) -> Result<(), SkipReason> {
         let group = calibrant_heap_group(candidate.speclib_index);
-        let band = self.band_of(candidate.library_rt.0);
+        let band = self.band_of(if self.observed_rt_bands {
+            candidate.apex_rt.0
+        } else {
+            candidate.library_rt.0
+        });
         self.heaps[group][band].push(candidate)
     }
 
@@ -577,46 +596,34 @@ impl<I: ScorerQueriable> Scorer<I> {
         isotope_tol: &Tolerance,
         worker: &mut ScoringWorker,
     ) {
-        let new_rt_seconds = apex.retention_time_ms as f32 / 1000.0;
-
-        // **Pass 1**: query at apex RT to determine observed mobility.
+        let apex_rt = RtSelection::Centered(calibrt::ObservedRTSeconds(
+            apex.retention_time_ms as f32 / 1000.0,
+        ));
+        let resolve = |tolerance: &Tolerance| {
+            ResolvedRt::from_mapping(apex_rt, &tolerance.rt, self.index.ms1_cycle_mapping())
+                .expect("detected apex lies inside acquisition")
+        };
+        let spectral_query = ExtractionQuery::new(query, resolve(spectral_tol));
         let inner = worker
             .inner_collector
-            .get_or_insert_with(|| SpectralCollector::new(query));
-        inner.reset_with_overrides(query, Some(new_rt_seconds), None);
-        self.index.add_query(inner, spectral_tol);
-
+            .get_or_insert_with(|| SpectralCollector::new(&spectral_query));
+        inner.reset_with(&spectral_query);
+        self.index.add_query(inner, &spectral_tol.peak_tolerance());
         let mobility = Self::get_mobility(inner);
-
-        // **Pass 2**: same collector, now with mobility override.
-        let inner = worker.inner_collector.as_mut().expect("init above");
-        inner.reset_with_overrides(query, Some(new_rt_seconds), Some(mobility as f32));
-
-        self.index.add_query(inner, isotope_tol);
+        let isotope_query =
+            ExtractionQuery::new(query, resolve(isotope_tol)).with_mobility(mobility as f32);
+        inner.reset_with(&isotope_query);
+        self.index.add_query(inner, &isotope_tol.peak_tolerance());
         if !query.scoring_plan().fragment_isotopes().enabled {
-            // Workers may be reused with another library. Never consume a stale
-            // isotope collector when this library disables the operation.
             worker.isotope_collector = None;
             return;
         }
-
-        // Isotope query holds `query` with +1 neutron offset applied
-        // (buffer-override -- reuses Vec capacity after warm-up).
-        let isotope_query = worker.isotope_query.get_or_insert_with(Target::empty_like);
-        crate::utils::elution_group_ops::apply_isotope_offset_fragments_into(
-            isotope_query,
-            query,
-            1i8,
-        );
-
         let isotope = worker
             .isotope_collector
-            .get_or_insert_with(|| SpectralCollector::new(isotope_query));
-        isotope.reset_with_overrides(isotope_query, Some(new_rt_seconds), Some(mobility as f32));
-
-        // Both queries share the same isotope_tol per existing logic.
-        let isotope = worker.isotope_collector.as_mut().expect("init above");
-        self.index.add_query(isotope, isotope_tol);
+            .get_or_insert_with(|| SpectralCollector::new(&isotope_query));
+        isotope.reset_with(&isotope_query);
+        crate::utils::elution_group_ops::shift_fragment_isotopes(isotope, 1);
+        self.index.add_query(isotope, &isotope_tol.peak_tolerance());
     }
 
     #[cfg_attr(
@@ -669,30 +676,66 @@ impl<I: ScorerQueriable> Scorer<I> {
         calibration: &CalibrationResult,
         worker: &mut ScoringWorker,
     ) -> Result<super::apex_finding::CandidateMetadata, SkipReason> {
-        let original_irt = LibraryRT(query.rt_seconds());
-        let calibrated_rt = calibration.convert_irt(original_irt);
-        let tolerance = calibration.get_tolerance(
-            query.mono_precursor_mz(),
-            query.mobility_ook0(),
-            original_irt, // library RT -- ridge widths are indexed by library RT
-        );
-
-        super::extraction::build_extraction_into(
-            &mut worker.extraction,
-            query,
-            Some(calibrated_rt.0),
-            &self.index,
-            &tolerance,
-            Some(TOP_N_FRAGMENTS),
-        )?;
+        let original_rt = query.library_rt();
+        let calibrated_rt = if !calibration.has_rt_calibration() {
+            None
+        } else {
+            original_rt
+                .map(|rt| {
+                    calibration
+                        .convert_irt(rt)
+                        .map_err(|_| SkipReason::RetentionTimeOutOfBounds)
+                })
+                .transpose()?
+        };
+        if let (Some(original_rt), Some(observed_rt)) = (original_rt, calibrated_rt) {
+            let tolerance = calibration.get_tolerance(
+                query.mono_precursor_mz(),
+                query.mobility_ook0(),
+                original_rt,
+            );
+            let observed_query = ExtractionQuery::new(
+                query,
+                ResolvedRt::from_mapping(
+                    RtSelection::Centered(observed_rt),
+                    &tolerance.rt,
+                    self.index.ms1_cycle_mapping(),
+                )
+                .map_err(|_| SkipReason::RetentionTimeOutOfBounds)?,
+            );
+            super::extraction::build_extraction_into(
+                &mut worker.extraction,
+                &observed_query,
+                &self.index,
+                &tolerance.peak_tolerance(),
+                Some(TOP_N_FRAGMENTS),
+            )?;
+        } else {
+            let tolerance = calibration.unrestricted_rt_tolerance();
+            super::extraction::build_extraction_into(
+                &mut worker.extraction,
+                &ExtractionQuery::new(
+                    query,
+                    ResolvedRt::from_mapping(
+                        RtSelection::FullRun,
+                        &self.broad_tolerance.rt,
+                        self.index.ms1_cycle_mapping(),
+                    )
+                    .map_err(|_| SkipReason::RetentionTimeOutOfBounds)?,
+                ),
+                &self.index,
+                &tolerance.peak_tolerance(),
+                Some(TOP_N_FRAGMENTS),
+            )?;
+        }
 
         Ok(super::apex_finding::CandidateMetadata {
             is_target: identity.is_target,
             charge: query.precursor_charge(),
             handles: identity.handles,
             source_id: identity.source_id,
-            library_rt: original_irt.0,
-            calibrated_rt_seconds: calibrated_rt.0,
+            library_rt: original_rt.map_or(f32::NAN, |r| r.0),
+            calibrated_rt_seconds: calibrated_rt.map_or(f32::NAN, |r| r.0),
             ref_mobility_ook0: query.mobility_ook0(),
             ref_precursor_mz: query.mono_precursor_mz(),
         })
@@ -727,10 +770,17 @@ impl<I: ScorerQueriable> Scorer<I> {
                         );
                         super::extraction::build_extraction_into(
                             &mut worker.extraction,
-                            query,
-                            None,
+                            &ExtractionQuery::new(
+                                query,
+                                ResolvedRt::from_mapping(
+                                    RtSelection::FullRun,
+                                    &self.broad_tolerance.rt,
+                                    self.index.ms1_cycle_mapping(),
+                                )
+                                .map_err(|_| SkipReason::RetentionTimeOutOfBounds)?,
+                            ),
                             &self.index,
-                            &tolerance,
+                            &tolerance.peak_tolerance(),
                             Some(TOP_N_FRAGMENTS),
                         )?;
                         Ok(super::apex_finding::CandidateMetadata {
@@ -738,7 +788,7 @@ impl<I: ScorerQueriable> Scorer<I> {
                             charge: query.precursor_charge(),
                             handles: identity.handles,
                             source_id: identity.source_id,
-                            library_rt: query.rt_seconds(),
+                            library_rt: query.library_rt().map_or(f32::NAN, |r| r.0),
                             calibrated_rt_seconds: f32::NAN,
                             ref_mobility_ook0: query.mobility_ook0(),
                             ref_precursor_mz: query.mono_precursor_mz(),
@@ -931,10 +981,17 @@ impl<I: ScorerQueriable> Scorer<I> {
             tracing::span!(tracing::Level::TRACE, "prescore::extraction").in_scope(|| {
                 super::extraction::build_extraction_into(
                     &mut worker.extraction,
-                    query,
-                    None,
+                    &ExtractionQuery::new(
+                        query,
+                        ResolvedRt::from_mapping(
+                            RtSelection::FullRun,
+                            &self.broad_tolerance.rt,
+                            self.index.ms1_cycle_mapping(),
+                        )
+                        .map_err(|_| SkipReason::RetentionTimeOutOfBounds)?,
+                    ),
                     &self.index,
-                    &self.broad_tolerance,
+                    &self.broad_tolerance.peak_tolerance(),
                     Some(TOP_N_FRAGMENTS),
                 )
             })
@@ -971,7 +1028,7 @@ impl<I: ScorerQueriable> Scorer<I> {
         lib: &ReferenceLibrary,
         flats: &[FlatIdx],
         capacity_per_band: usize,
-        library_rt_range: (f32, f32),
+        library_rt_range: Option<(f32, f32)>,
         timings: &mut PrescoreTimings,
     ) -> StratifiedCalibrantHeaps {
         let get_item = |f| lib.item_at(f);
@@ -1009,7 +1066,11 @@ impl<I: ScorerQueriable> Scorer<I> {
                 );
                 (
                     ScoringWorker::new(num_cycles, max_frags),
-                    StratifiedCalibrantHeaps::new(capacity_per_band, library_rt_range),
+                    StratifiedCalibrantHeaps::for_library(
+                        capacity_per_band,
+                        library_rt_range,
+                        self.acquisition_rt_range_seconds(),
+                    ),
                     PrescoreTimings::default(),
                 )
             },
@@ -1025,7 +1086,7 @@ impl<I: ScorerQueriable> Scorer<I> {
                             score: loc.score,
                             apex_rt: ObservedRTSeconds(loc.retention_time_ms as f32 / 1000.0),
                             speclib_index: flat,
-                            library_rt: LibraryRT(q.rt_seconds()),
+                            library_rt: q.library_rt().unwrap_or(LibraryRT(f32::NAN)),
                         };
                         if let Err(reason) = heap.push(cand) {
                             t.skips.bump(reason);
@@ -1071,7 +1132,7 @@ mod tests {
         geom.push_row(Row {
             precursor_mz: 900.4,
             charge: 2,
-            rt_seconds: 1.0,
+            rt: Some(timsquery::models::RtCoordinate::seconds(1.0)),
             mobility: 1.0,
             frags: &[
                 (IonAnnot::try_from("y3").unwrap(), 300.0),
@@ -1117,6 +1178,39 @@ mod tests {
         );
     }
 
+    #[test]
+    fn rt_free_candidates_are_bounded_by_observed_rt_bands() {
+        let lib = tiny_lazy_lib();
+        let flat = lib.geometry().flats().next().unwrap();
+        let make = || StratifiedCalibrantHeaps::for_library(1, None, (0.0, 300.0));
+        let mut direct = make();
+        let mut left = make();
+        let mut right = make();
+        for i in 0..30 {
+            let candidate = CalibrantCandidate {
+                score: i as f32 + 1.0,
+                apex_rt: ObservedRTSeconds(i as f32 * 10.0),
+                library_rt: LibraryRT(f32::NAN),
+                speclib_index: flat,
+            };
+            direct.push(candidate.clone()).unwrap();
+            if i % 2 == 0 {
+                left.push(candidate).unwrap();
+            } else {
+                right.push(candidate).unwrap();
+            }
+        }
+        left.merge_in_place(right);
+        let scores = |heap: StratifiedCalibrantHeaps| {
+            let mut scores: Vec<_> = heap.into_vec().into_iter().map(|c| c.score).collect();
+            scores.sort_by(f32::total_cmp);
+            scores
+        };
+        let retained = scores(direct);
+        assert_eq!(retained.len(), CALIBRANT_RT_BANDS);
+        assert_eq!(retained, scores(left));
+    }
+
     #[test]
     fn stratified_calibrant_merge_matches_direct_fold() {
         let lib = tiny_lazy_lib();
diff --git a/rust/timsseek/src/scoring/plan.rs b/rust/timsseek/src/scoring/plan.rs
index 230c8e18..cc108e17 100644
--- a/rust/timsseek/src/scoring/plan.rs
+++ b/rust/timsseek/src/scoring/plan.rs
@@ -143,6 +143,9 @@ pub struct ScoringPlan {
     fragment_isotopes: FragmentIsotopeDecision,
     #[serde(skip)]
     linear_indices: Vec<usize>,
+    #[serde(skip)]
+    nonlinear_indices: Vec<usize>,
+    library_rt_axis: timsquery::RtAxis,
     rows: usize,
     unmodified_rows: usize,
     operations: Vec<OperationDecision>,
@@ -164,13 +167,29 @@ impl ScoringPlan {
         let mut isotope_names = NameSink::new();
         FragmentIsotopeScores::linear_feature_names(&mut isotope_names);
         let isotope_names = isotope_names.into_names();
+        let has_rt = geom.rt_axis() != &timsquery::RtAxis::Absent;
+        let mut rt_names = NameSink::new();
+        crate::scoring::blocks::rt::Rt::linear_feature_names(&mut rt_names);
+        crate::scoring::blocks::rt::Rt::nonlinear_feature_names(&mut rt_names);
+        let rt_names = rt_names.into_names();
+        let mut nonlinear_names = NameSink::new();
+        ScoringFields::nonlinear_feature_names(&mut nonlinear_names);
+        let nonlinear_indices = nonlinear_names
+            .into_names()
+            .iter()
+            .enumerate()
+            .filter_map(|(i, name)| (has_rt || !rt_names.contains(name)).then_some(i))
+            .collect();
         let mut linear_names = NameSink::new();
         ScoringFields::linear_feature_names(&mut linear_names);
         let linear_indices = linear_names
             .into_names()
             .iter()
             .enumerate()
-            .filter_map(|(i, name)| (enabled || !isotope_names.contains(name)).then_some(i))
+            .filter_map(|(i, name)| {
+                ((enabled || !isotope_names.contains(name)) && (has_rt || !rt_names.contains(name)))
+                    .then_some(i)
+            })
             .collect();
         let fragment_isotopes = FragmentIsotopeDecision {
             enabled,
@@ -226,6 +245,8 @@ impl ScoringPlan {
             isotopes,
             fragment_isotopes,
             linear_indices,
+            nonlinear_indices,
+            library_rt_axis: geom.rt_axis().clone(),
             rows,
             unmodified_rows,
             operations,
@@ -259,6 +280,10 @@ impl ScoringPlan {
         &self.linear_indices
     }
 
+    pub(crate) fn nonlinear_indices(&self) -> &[usize] {
+        &self.nonlinear_indices
+    }
+
     pub fn isotopes(&self) -> &IsotopePlan {
         &self.isotopes
     }
diff --git a/rust/timsseek/src/scoring/skip.rs b/rust/timsseek/src/scoring/skip.rs
index 9203f560..ea6c337e 100644
--- a/rust/timsseek/src/scoring/skip.rs
+++ b/rust/timsseek/src/scoring/skip.rs
@@ -52,6 +52,7 @@ pub enum SkipReason {
 /// Map the timsquery-level error into a `SkipReason` sub-bucket.
 fn classify_tq_error(err: &TQDataProcessingError) -> SkipReason {
     match err {
+        TQDataProcessingError::InvalidRtQuery => SkipReason::RetentionTimeOutOfBounds,
         TQDataProcessingError::ExpectedNonEmptyData => SkipReason::ApexEmptyData,
         TQDataProcessingError::InsufficientData { .. } => SkipReason::ApexInsufficientData,
         TQDataProcessingError::UnexpectedInfiniteError(_)
diff --git a/rust/timsseek/src/utils/elution_group_ops.rs b/rust/timsseek/src/utils/elution_group_ops.rs
index 54d52f11..d9857ef7 100644
--- a/rust/timsseek/src/utils/elution_group_ops.rs
+++ b/rust/timsseek/src/utils/elution_group_ops.rs
@@ -1,18 +1,15 @@
-use timsquery::Target;
+use timsquery::SpectralCollector;
 use timsquery::utils::constants::C13_C12_MASS_DIFF;
 
 use crate::IonAnnot;
 
-/// Buffer-override variant of `isotope_offset_fragments`: reset `dst` from `src`
-/// (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.
-pub fn apply_isotope_offset_fragments_into(
-    dst: &mut Target<IonAnnot>,
-    src: &impl timsquery::traits::QueryGeom<Label = IonAnnot>,
-    offset: i8,
-) {
-    dst.reset_from(src);
-    for (k, v) in dst.iter_fragments_refs_mut() {
+/// Shift fragment labels and m/z in the collector's reusable buffers.
+pub fn shift_fragment_isotopes(dst: &mut SpectralCollector<IonAnnot, f32>, offset: i8) {
+    for (k, v) in dst
+        .fragment_labels
+        .iter_mut()
+        .zip(dst.fragment_mzs.iter_mut())
+    {
         // The error names the representable range, so a library carrying an
         // isotope offset too close to the ceiling says what the limit is rather
         // than asserting the situation is impossible.
diff --git a/rust/timsseek_cli/src/predicted_library.rs b/rust/timsseek_cli/src/predicted_library.rs
index de116b02..e026feb7 100644
--- a/rust/timsseek_cli/src/predicted_library.rs
+++ b/rust/timsseek_cli/src/predicted_library.rs
@@ -48,21 +48,7 @@ use timsseek::data_sources::reference_library::ReferenceLibrary;
 
 use crate::errors::CliError;
 
-/// The scale the file route puts retention on: sixty times what msspeculator
-/// reported, whatever that number means.
-///
-/// With no chromatography context it is a dimensionless PROCAL-anchored index,
-/// which the mzSpecLib writer has to declare in `minute` because the vocabulary
-/// has no unit for an index, and the mzSpecLib reader multiplies by sixty
-/// regardless -- which recovers the declared minutes only because the pinned
-/// mzannotate leaves a `minute`-declared value alone (a release divides it by
-/// sixty). Scoring only requires `rt_seconds` to be ordered, so scaling one
-/// route and not the other gives two libraries 60x apart that each work alone
-/// and disagree the moment a run holds one of each --
-/// `check_rt_scale_compatibility` then reports a pair with no overlapping RT
-/// range. That the unit is wrong for the context-free case is
-/// <https://github.com/TalusBio/timsbuktoolkit/issues/115>, which is a different
-/// question from the two routes agreeing.
+/// Convert predicted gradient minutes to acquisition seconds; indices remain unchanged.
 const SECONDS_PER_MINUTE: f32 = 60.0;
 
 /// A library that was predicted rather than read, plus what produced it.
@@ -163,9 +149,16 @@ impl PredictedLibraryHandle {
                     .to_string(),
             });
         };
-        let arena = build_arena(rows, decoys).map_err(|e| CliError::LibraryBuild {
-            source: format!("assembling the predicted library: {e:?}"),
-        })?;
+        let normalized_axis = timsquery::RtAxis::NormalizedIndex {
+            scale: provenance
+                .pointer("/retention/normalized/scale")
+                .and_then(serde_json::Value::as_str)
+                .map(str::to_owned),
+        };
+        let arena =
+            build_arena(rows, decoys, &normalized_axis).map_err(|e| CliError::LibraryBuild {
+                source: format!("assembling the predicted library: {e:?}"),
+            })?;
         let library = ReferenceLibrary::try_from(arena).map_err(|e| CliError::LibraryBuild {
             source: format!("finalizing the predicted library: {e:?}"),
         })?;
@@ -196,7 +189,7 @@ impl PredictedLibrarySink {
 impl LibrarySink for PredictedLibrarySink {
     fn header(&mut self, provenance: &LibraryProvenance) -> Result<()> {
         // Kept as the JSON `to_json` builds, unflattened: this is a record of
-        // what produced the library, and nothing here reads it.
+        // what produced the library, including its normalized RT scale.
         self.record_provenance(provenance.to_json());
         Ok(())
     }
@@ -227,7 +220,8 @@ struct PredictedRow {
     analyte: timsquery::chemistry::analyte::Analyte,
     precursor_mz: f64,
     charge: u8,
-    rt_seconds: f32,
+    rt_value: f32,
+    rt_axis: timsquery::RtAxis,
     mobility: f32,
     frags: Vec<(IonAnnot, f64)>,
     /// Parallel to `frags`, kept apart because the arena stores the two in
@@ -266,7 +260,16 @@ impl PredictedRow {
             // chromatography context, the normalized index without one. `irt`
             // carries the index alongside a gradient time, under a term the
             // reader keeps as a scan param and never scores on.
-            rt_seconds: row.rt * SECONDS_PER_MINUTE,
+            rt_value: if row.irt.is_some() {
+                row.rt * SECONDS_PER_MINUTE
+            } else {
+                row.rt
+            },
+            rt_axis: if row.irt.is_some() {
+                timsquery::RtAxis::Seconds
+            } else {
+                timsquery::RtAxis::NormalizedIndex { scale: None }
+            },
             mobility: row.mobility as f32,
             frags,
             intensities,
@@ -304,6 +307,7 @@ fn ion_annot(peak: &Peak<'_>) -> Result<IonAnnot> {
 fn build_arena(
     rows: Vec<PredictedRow>,
     decoys: DecoyPolicy,
+    normalized_axis: &timsquery::RtAxis,
 ) -> Result<TargetTable, TargetReadingError> {
     // A zero-row arena seals: ids and groups are both vacuously consistent, the
     // parse gate has nothing to reject, and the result searches to zero results
@@ -336,7 +340,14 @@ fn build_arena(
         geom.push_row(Row {
             precursor_mz: row.precursor_mz,
             charge: row.charge,
-            rt_seconds: row.rt_seconds,
+            rt: Some(timsquery::RtCoordinate {
+                value: timsquery::LibraryRT(row.rt_value),
+                axis: if matches!(row.rt_axis, timsquery::RtAxis::NormalizedIndex { .. }) {
+                    normalized_axis
+                } else {
+                    &row.rt_axis
+                },
+            }),
             mobility: row.mobility,
             frags: &row.frags,
 
@@ -481,8 +492,16 @@ mod tests {
     /// Borrows the rows rather than taking them so one set can be put through
     /// this route and the file route both.
     fn build(rows: &[SpectrumRow<'_>], decoys: DecoyPolicy) -> PredictedLibrary {
+        build_with_scale(rows, decoys, None)
+    }
+
+    fn build_with_scale(
+        rows: &[SpectrumRow<'_>],
+        decoys: DecoyPolicy,
+        scale: Option<&str>,
+    ) -> PredictedLibrary {
         let (handle, mut collector) = sink();
-        collector.record_test_provenance();
+        collector.record_provenance(serde_json::json!({"generator":{"tool":"test"}, "retention":{"normalized":{"scale":scale}}}));
         for row in rows {
             collector.spectrum(row).expect("row converts");
         }
@@ -507,7 +526,7 @@ mod tests {
                     geom.decoy_group(tgt),
                     geom.charge(tgt),
                     geom.precursor_mz(tgt),
-                    geom.rt_seconds(tgt),
+                    geom.library_rt(tgt).map(|rt| rt.0).unwrap(),
                     geom.analyte(tgt)
                         .peptide
                         .known()
@@ -692,13 +711,59 @@ mod tests {
         );
     }
 
+    #[test]
+    fn declared_scale_survives_prediction_and_file_loading_only_for_normalized_rows() {
+        let fixture = Fixture::new("PEPTIDEK", "PEPTIDEK");
+        for scale in [None, Some("reference anchors")] {
+            for irt in [None, Some(37.75)] {
+                let rows = [SpectrumRow {
+                    irt,
+                    rt: 2.0,
+                    ..fixture.row(2, false, None, peaks(2))
+                }];
+                let predicted = build_with_scale(&rows, DecoyPolicy::Never, scale);
+                let TargetTable::Mzpaf {
+                    geom: from_file, ..
+                } = via_file_table_with_scale(&rows, scale)
+                else {
+                    panic!("expected mzpaf")
+                };
+                let expected = if irt.is_some() {
+                    timsquery::RtAxis::Seconds
+                } else {
+                    timsquery::RtAxis::NormalizedIndex {
+                        scale: scale.map(str::to_owned),
+                    }
+                };
+                let sunk = predicted.library.geometry();
+                assert_eq!(sunk.rt_axis(), &expected);
+                assert_eq!(from_file.rt_axis(), &expected);
+                assert_eq!(
+                    sunk.library_rt(sunk.rows().next().unwrap()).map(|rt| rt.0),
+                    from_file
+                        .library_rt(from_file.rows().next().unwrap())
+                        .map(|rt| rt.0)
+                );
+            }
+        }
+    }
+
     #[test]
     fn retention_is_stored_on_the_scale_the_file_route_reads_the_same_library_back_on() {
         let fixture = Fixture::new("PEPTIDEK", "PEPTIDEK");
         let lib = build(&[fixture.row(2, false, None, peaks(2))], DecoyPolicy::Never);
 
         let tgt = lib.library.geometry().rows().next().unwrap();
-        assert!((lib.library.geometry().rt_seconds(tgt) - 93.56484).abs() < 1e-3);
+        assert!(
+            (lib.library
+                .geometry()
+                .library_rt(tgt)
+                .map(|rt| rt.0)
+                .unwrap()
+                - 1.559414)
+                .abs()
+                < 1e-3
+        );
     }
 
     #[test]
@@ -715,7 +780,16 @@ mod tests {
         let lib = build(&[contextual], DecoyPolicy::Never);
 
         let tgt = lib.library.geometry().rows().next().unwrap();
-        assert!((lib.library.geometry().rt_seconds(tgt) - 1890.0).abs() < 1e-3);
+        assert!(
+            (lib.library
+                .geometry()
+                .library_rt(tgt)
+                .map(|rt| rt.0)
+                .unwrap()
+                - 1890.0)
+                .abs()
+                < 1e-3
+        );
     }
 
     #[test]
@@ -744,9 +818,8 @@ mod tests {
     /// out of the real writer; what is reproduced here is only the framing the
     /// reader needs to parse one -- the format version, and the two attribute
     /// sets that carry `spectrum origin type`, which is where `is_decoy` reads
-    /// from. The provenance pairs are dropped because no per-row value comes from
-    /// them.
-    fn write_mzspeclib_header(out: &mut impl std::io::Write) {
+    /// from. Only the normalized-scale provenance is included when requested.
+    fn write_mzspeclib_header(out: &mut impl std::io::Write, scale: Option<&str>) {
         for line in [
             "<mzSpecLib>",
             "MS:1003186|library format version=1.0",
@@ -759,6 +832,16 @@ mod tests {
             "MS:1003072|spectrum origin type=MS:1003195|unnatural peptidoform decoy spectrum",
         ] {
             writeln!(out, "{line}").expect("header writes");
+            if line == "MS:1003188|library name=both_routes"
+                && let Some(scale) = scale
+            {
+                writeln!(
+                    out,
+                    "[1]MS:1003275|other attribute name=msspeculator:retention.normalized.scale"
+                )
+                .unwrap();
+                writeln!(out, "[1]MS:1003276|other attribute value={scale}").unwrap();
+            }
         }
     }
 
@@ -766,13 +849,17 @@ mod tests {
     /// project's reader back off it, which is what a `build-library` followed by
     /// a `search` does.
     fn via_file_table(rows: &[SpectrumRow<'_>]) -> TargetTable {
+        via_file_table_with_scale(rows, None)
+    }
+
+    fn via_file_table_with_scale(rows: &[SpectrumRow<'_>], scale: Option<&str>) -> TargetTable {
         let dir = tempfile::tempdir().expect("temp dir");
         // The name the sniffer dispatches on: it takes `.mzspeclib.` anywhere in
         // the file name, and reads plain text for anything not ending `.gz`.
         let path = dir.path().join("both_routes.mzspeclib.txt");
         {
             let mut file = std::fs::File::create(&path).expect("library file");
-            write_mzspeclib_header(&mut file);
+            write_mzspeclib_header(&mut file, scale);
             // The sink appends to the same handle at the cursor the header left,
             // and closes it when this scope drops it.
             let mut writer = msspeculator_inference::mzspeclib::MzSpecLibSink::new(file, &path);
@@ -905,16 +992,20 @@ mod tests {
                 "precursor m/z of {id}",
             );
             assert!(
-                (sunk.rt_seconds(row) - from_file.rt_seconds(mirror)).abs() < 1e-3,
+                (sunk.library_rt(row).map(|rt| rt.0).unwrap()
+                    - from_file.library_rt(mirror).map(|rt| rt.0).unwrap())
+                .abs()
+                    < 1e-3,
                 "retention of {id}: {} against {}",
-                sunk.rt_seconds(row),
-                from_file.rt_seconds(mirror),
+                sunk.library_rt(row).map(|rt| rt.0).unwrap(),
+                from_file.library_rt(mirror).map(|rt| rt.0).unwrap(),
             );
             assert!(
                 (sunk.mobility(row) - from_file.mobility(mirror)).abs() < 1e-6,
                 "mobility of {id}",
             );
 
+            assert_eq!(sunk.rt_axis(), from_file.rt_axis());
             let (sunk_frags, file_frags) = (fragments(sunk, row), fragments(&from_file, mirror));
             assert_eq!(
                 sunk_frags.keys().collect::<Vec<_>>(),
diff --git a/rust/timsseek_cli/src/processing.rs b/rust/timsseek_cli/src/processing.rs
index 762b2675..24d91093 100644
--- a/rust/timsseek_cli/src/processing.rs
+++ b/rust/timsseek_cli/src/processing.rs
@@ -230,22 +230,25 @@ pub fn execute_pipeline<I: ScorerQueriable>(
     // === PHASE 2: Calibration (fit RT + measure errors + derive tolerances) ===
     info!("Phase 2: Calibration...");
     let step = TimedStep::begin("Phase 2: Calibrate");
-    let calibration = match calibrate_from_phase1(
-        calibrants,
-        phase1_lib,
-        main_lookup.as_ref(),
-        pipeline,
-        calib_config,
-    ) {
-        Ok(calib) => {
-            info!("Calibration succeeded");
-            calib
-        }
-        Err(e) => {
-            tracing::error!("Calibration failed: {:?}. Using fallback.", e);
-            CalibrationResult::fallback(pipeline)
+    let calibration = {
+        match calibrate_from_phase1(
+            calibrants,
+            phase1_lib,
+            main_lookup.as_ref(),
+            pipeline,
+            calib_config,
+        ) {
+            Ok(calib) => {
+                info!("Calibration succeeded");
+                calib
+            }
+            Err(e) => {
+                tracing::error!("Calibration failed: {:?}. Using fallback.", e);
+                CalibrationResult::fallback(pipeline)
+            }
         }
     };
+    let calibration = calibration.with_rt_axis(speclib.geometry().rt_axis());
     let phase2_ms = step
         .finish_with(format_args!(
             "{} fit points → {} path nodes",
@@ -265,28 +268,19 @@ pub fn execute_pipeline<I: ScorerQueriable>(
             summary.in_ridge_ratio * 100.0,
         );
     }
-    // The mobility tolerance is only meaningful for a searchable TIMS 1/K0 run;
-    // for mzML/FAIMS it is fit from sentinel mobilities and never used (the
-    // query gate unrestricts mobility), so report it as disabled rather than
-    // print a misleading number.
-    if pipeline.index.mobility_kind().is_scoreable() {
-        println!(
-            "  m/z: ({:.1}, {:.1}) ppm   mobility: ({:.1}, {:.1}) %",
-            calibration.mz_tolerance().0,
-            calibration.mz_tolerance().1,
-            calibration.mobility_tolerance().0,
-            calibration.mobility_tolerance().1,
-        );
-    } else {
-        println!(
-            "  m/z: ({:.1}, {:.1}) ppm   mobility: disabled (no searchable axis)",
-            calibration.mz_tolerance().0,
-            calibration.mz_tolerance().1,
-        );
-    }
+    println!(
+        "  m/z: {:?}   mobility: {}   RT fit: {}",
+        calibration.mz_tolerance(),
+        if pipeline.index.mobility_kind().is_scoreable() {
+            format!("{:?}", calibration.mobility_tolerance())
+        } else {
+            "disabled (no searchable axis)".to_owned()
+        },
+        calibration.has_rt_calibration()
+    );
 
     // Save the calibration for the viewer to load.
-    if !calibration.is_fallback() {
+    {
         let (rt_lo_ms, rt_hi_ms) = pipeline.index.ms1_cycle_mapping().range_milis();
         let rt_lo = rt_lo_ms as f64 / 1000.0;
         let rt_hi = rt_hi_ms as f64 / 1000.0;
diff --git a/rust/timsseek_cli/src/processing/calibration.rs b/rust/timsseek_cli/src/processing/calibration.rs
index b64c15af..bea03d43 100644
--- a/rust/timsseek_cli/src/processing/calibration.rs
+++ b/rust/timsseek_cli/src/processing/calibration.rs
@@ -1,16 +1,10 @@
 use indicatif::ProgressIterator;
 use timsquery::models::FlatIdx;
-use timsquery::models::tolerance::{
-    MobilityTolerance,
-    MzTolerance,
-    QuadTolerance,
-    RtTolerance,
-};
-use timsquery::traits::QueryGeom;
+use timsquery::models::tolerance::RtTolerance;
+use timsquery::traits::Target;
 use timsquery::{
     MzMobilityStatsCollector,
     SpectralCollector,
-    Tolerance,
 };
 use timsseek::data_sources::reference_library::ReferenceLibrary;
 use timsseek::rt_calibration::{
@@ -57,7 +51,7 @@ pub(super) fn build_precursor_fragment_lookup(
     speclib: &ReferenceLibrary,
 ) -> PrecursorFragmentLookup {
     let mut map: PrecursorFragmentLookup = std::collections::HashMap::new();
-    for item in speclib.iter() {
+    for item in speclib.iter().filter(|q| q.library_rt().is_some()) {
         let mz_key = (item.mono_precursor_mz() * 100.0).round() as i64;
         let charge = item.precursor_charge();
         let mut frag_mzs: Vec<i64> = item
@@ -67,7 +61,7 @@ pub(super) fn build_precursor_fragment_lookup(
         frag_mzs.sort_unstable();
         map.entry((mz_key, charge))
             .or_default()
-            .push((item.rt_seconds(), frag_mzs));
+            .push((item.library_rt().map_or(f32::NAN, |r| r.0), frag_mzs));
     }
     info!(
         "Built precursor+fragment lookup with {} unique (mz, charge) buckets from main speclib",
@@ -82,7 +76,11 @@ fn library_rt_for_candidate(
     main_lookup: Option<&PrecursorFragmentLookup>,
 ) -> Option<f64> {
     let Some(lookup) = main_lookup else {
-        return Some(candidate.library_rt.0 as f64);
+        return candidate
+            .library_rt
+            .0
+            .is_finite()
+            .then_some(candidate.library_rt.0 as f64);
     };
     let calib_item = phase1_lib.item_at(candidate.speclib_index);
     let mz_key = (calib_item.mono_precursor_mz() * 100.0).round() as i64;
@@ -95,24 +93,14 @@ fn library_rt_for_candidate(
         .collect();
     calib_frags.sort_unstable();
 
-    let calib_rt = calib_item.rt_seconds();
     bucket
         .iter()
         .filter_map(|(main_rt, main_frags)| {
             let shared = count_shared_fragments(&calib_frags, main_frags);
-            (shared >= MIN_SHARED_FRAGMENTS).then_some((
-                shared,
-                (main_rt - calib_rt).abs(),
-                *main_rt,
-            ))
-        })
-        .min_by(|a, b| {
-            b.0.cmp(&a.0).then(
-                a.1.partial_cmp(&b.1)
-                    .expect("NaN RT residual in calibrant matching"),
-            )
+            (shared >= MIN_SHARED_FRAGMENTS).then_some((shared, *main_rt))
         })
-        .map(|(_, _, rt)| rt as f64)
+        .min_by(|a, b| b.0.cmp(&a.0).then(a.1.total_cmp(&b.1)))
+        .map(|(_, rt)| rt as f64)
 }
 
 /// Fixed so a run and its Phase-1 heap history can be reproduced exactly.
@@ -462,10 +450,12 @@ pub(super) mod calib_dash_hook {
             };
             let flow = d.on_batch(
                 chunk,
-                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.speclib_index),
+                calibrants.filter(|c| c.library_rt.0.is_finite()).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.speclib_index),
+                    }
                 }),
             );
             if matches!(flow, calib_dash::Flow::Abort) {
@@ -486,12 +476,21 @@ pub(super) mod calib_dash_hook {
             let Some(d) = dash.inner.as_mut() else {
                 return;
             };
-            let mobility = calibration.mobility_tolerance();
+            let (
+                timsquery::models::tolerance::MzTolerance::Ppm(mz),
+                timsquery::models::tolerance::MobilityTolerance::Pct(mobility),
+            ) = (calibration.mz_tolerance(), calibration.mobility_tolerance())
+            else {
+                return;
+            };
+            if !calibration.has_rt_calibration() {
+                return;
+            }
             let rt_tolerance_seconds = calibration.rt_tolerance_minutes() as f64 * 60.0;
             d.show_final(
                 calib_dash::FitRecording::from_state(calibration.state()),
                 calib_dash::ToleranceSummary {
-                    mz_ppm: calibration.mz_tolerance(),
+                    mz_ppm: *mz,
                     mobility_pct: (mobility.0 as f64, mobility.1 as f64),
                     rt_seconds: rt_tolerance_seconds,
                     n_calibrants: calibration.errors().rt_seconds.n,
@@ -534,15 +533,18 @@ pub(super) fn check_rt_scale_compatibility(
     main_lib: &ReferenceLibrary,
     calib_lib: &ReferenceLibrary,
 ) {
+    // Matching re-anchors the calibration library onto the main library axis.
+    // Numeric range overlap across unrelated coordinate systems proves nothing.
+    if main_lib.geometry().rt_axis() != calib_lib.geometry().rt_axis()
+        || !matches!(
+            main_lib.geometry().rt_axis(),
+            timsquery::RtAxis::NormalizedIndex { scale: Some(_) }
+        )
+    {
+        return;
+    }
     fn rt_range(lib: &ReferenceLibrary) -> (f32, f32) {
-        let mut min_rt = f32::INFINITY;
-        let mut max_rt = f32::NEG_INFINITY;
-        for q in lib.iter() {
-            let rt = q.rt_seconds();
-            min_rt = min_rt.min(rt);
-            max_rt = max_rt.max(rt);
-        }
-        (min_rt, max_rt)
+        lib.rt_range().unwrap_or((0.0, 0.0))
     }
 
     let (main_min, main_max) = rt_range(main_lib);
@@ -612,13 +614,18 @@ pub(super) fn phase1_prescore<I: ScorerQueriable>(
 
     let mut timings = timsseek::scoring::PrescoreTimings::default();
     let shuffled = speclib.shuffled_flats(PHASE1_SHUFFLE_SEED);
-    let rt_range = speclib.rt_range().unwrap_or((0.0, 0.0));
-    let convergence_rt_range = mapped_rt_range.unwrap_or(rt_range);
+    let rt_range = speclib.rt_range();
+    let convergence_rt_range = if main_lookup.is_some() {
+        mapped_rt_range
+    } else {
+        rt_range
+    };
     let capacity_per_band = capacity_per_rt_band(config);
     let acquisition_rt_range = pipeline.acquisition_rt_range_seconds();
-    let mut heaps = StratifiedCalibrantHeaps::new(capacity_per_band, rt_range);
-    let mut convergence =
-        match Phase1Convergence::new(config, convergence_rt_range, acquisition_rt_range) {
+    let mut heaps =
+        StratifiedCalibrantHeaps::for_library(capacity_per_band, rt_range, acquisition_rt_range);
+    let mut convergence = convergence_rt_range.and_then(|range| {
+        match Phase1Convergence::new(config, range, acquisition_rt_range) {
             Ok(convergence) => Some(convergence),
             Err(error) => {
                 warn!(
@@ -627,7 +634,8 @@ pub(super) fn phase1_prescore<I: ScorerQueriable>(
                 );
                 None
             }
-        };
+        }
+    });
     let mut visited = 0usize;
 
     // Shuffle individual flat indices, not source-order chunks: libraries are
@@ -684,63 +692,6 @@ fn count_shared_fragments(a: &[i64], b: &[i64]) -> usize {
 
 const MIN_SHARED_FRAGMENTS: usize = 5;
 
-/// Every calibrant was found inside the first-pass window, so a derived window
-/// wider than it measures contamination of the per-calibrant offset (a mean
-/// over a 50 ppm query box), not the instrument. On a 21-min HeLa run the
-/// unclamped derivation gave 60 ppm; at 10-15 ppm Phase 3 found 34% more
-/// peptides. Returns the bound when it clamped.
-fn clamp_mz_window_to_first_pass(
-    mz_ppm: &mut (f64, f64),
-    first_pass: &Tolerance,
-) -> Option<(f64, f64)> {
-    let MzTolerance::Ppm((lo, hi)) = first_pass.ms else {
-        return None;
-    };
-    if mz_ppm.0 <= lo && mz_ppm.1 <= hi {
-        return None;
-    }
-    *mz_ppm = (mz_ppm.0.min(lo), mz_ppm.1.min(hi));
-    Some((lo, hi))
-}
-
-#[cfg(test)]
-mod clamp_tests {
-    use super::*;
-
-    fn first_pass(lo: f64, hi: f64) -> Tolerance {
-        Tolerance {
-            ms: MzTolerance::Ppm((lo, hi)),
-            rt: RtTolerance::Unrestricted,
-            mobility: MobilityTolerance::Unrestricted,
-            quad: QuadTolerance::Absolute((0.1, 0.1)),
-        }
-    }
-
-    #[test]
-    fn clamps_each_side_to_the_first_pass_window() {
-        let mut w = (59.1, 61.3);
-        assert_eq!(
-            clamp_mz_window_to_first_pass(&mut w, &first_pass(15.0, 15.0)),
-            Some((15.0, 15.0))
-        );
-        assert_eq!(w, (15.0, 15.0));
-
-        let mut w = (8.0, 20.0);
-        assert!(clamp_mz_window_to_first_pass(&mut w, &first_pass(15.0, 15.0)).is_some());
-        assert_eq!(w, (8.0, 15.0));
-    }
-
-    #[test]
-    fn inside_the_first_pass_window_is_untouched() {
-        let mut w = (8.9, 11.1);
-        assert_eq!(
-            clamp_mz_window_to_first_pass(&mut w, &first_pass(15.0, 15.0)),
-            None
-        );
-        assert_eq!(w, (8.9, 11.1));
-    }
-}
-
 pub(super) fn calibrate_from_phase1<I: ScorerQueriable>(
     candidates: Vec<CalibrantCandidate>,
     phase1_lib: &ReferenceLibrary,
@@ -770,7 +721,7 @@ pub(super) fn calibrate_from_phase1<I: ScorerQueriable>(
         })
         .collect();
 
-    if main_lookup.is_some() {
+    if main_lookup.is_some_and(|lookup| !lookup.is_empty()) {
         let matched = points.len();
         let total = candidates.len();
         let rate = if total > 0 {
@@ -778,12 +729,11 @@ pub(super) fn calibrate_from_phase1<I: ScorerQueriable>(
         } else {
             0.0
         };
-        // Surface a collapsing cross-library match loudly -- otherwise it silently
-        // becomes a ZeroRange grid -> identity fallback -> ~0 IDs, with no hint why.
+        // Cross-library matching determines whether an RT fit can be attempted.
         if matched < 2 || rate < 0.10 {
             warn!(
                 "Calibration: only {}/{} calibrants ({:.1}%) matched the main speclib (>= {} shared fragments). \
-                 Calibration will fail or degrade (likely ZeroRange -> fallback). Common causes: main speclib \
+                 RT fitting may fail; m/z and mobility calibration still run. Common causes: main speclib \
                  entries carry < {} usable fragments (e.g. over-aggressive fragment filtering on load), or the \
                  calib lib and main speclib m/z scales don't align.",
                 matched,
@@ -802,11 +752,17 @@ pub(super) fn calibrate_from_phase1<I: ScorerQueriable>(
 
     // Use CalibrationState for fitting + ridge width measurement
     let mut cal_state = CalibratedGrid::deferred(config.grid_size, config.dp_lookback)?;
-    cal_state.refit(
+    if let Err(error) = cal_state.refit(
         config.grid_size,
         points.iter().map(|p| (p.library, p.observed)),
-    )?;
-    let cal_curve = cal_state.curve().ok_or(CalibRtError::NoPoints)?;
+    ) {
+        info!(
+            ?error,
+            "No RT fit; measuring m/z and mobility without a ridge filter"
+        );
+        cal_state = CalibratedGrid::deferred(config.grid_size, config.dp_lookback)?;
+    }
+    let cal_curve = cal_state.curve();
 
     // Position-dependent RT tolerance comes from the ridge the fit measured.
     let ridge_widths = cal_state.ridge_widths();
@@ -818,15 +774,13 @@ pub(super) fn calibrate_from_phase1<I: ScorerQueriable>(
     }
 
     // === Step B: Measure m/z and mobility errors at calibrant apexes ===
-    let query_tolerance = Tolerance {
-        ms: MzTolerance::Ppm((50.0, 50.0)),
-        rt: RtTolerance::Minutes((
+    let query_tolerance = pipeline
+        .broad_tolerance
+        .clone()
+        .with_rt_tolerance(RtTolerance::Minutes((
             config.calibration_query_rt_window_minutes,
             config.calibration_query_rt_window_minutes,
-        )),
-        mobility: MobilityTolerance::Pct((5.0, 5.0)),
-        quad: QuadTolerance::Absolute((0.1, 0.1)),
-    };
+        )));
 
     let mut mz_errors_ppm: Vec<f32> = Vec::with_capacity(candidates.len());
     let mut mobility_errors_pct: Vec<f32> = Vec::with_capacity(candidates.len());
@@ -836,31 +790,44 @@ pub(super) fn calibrate_from_phase1<I: ScorerQueriable>(
     for (candidate, library_rt_opt) in candidates.iter().zip(library_rt_for_candidate.iter()) {
         let item = phase1_lib.item_at(candidate.speclib_index);
 
-        // Skip calibrants that never matched in the main speclib.
-        let Some(library_rt_s) = *library_rt_opt else {
-            continue;
-        };
-
-        let predicted_rt = match cal_curve.predict(LibraryRT(library_rt_s)) {
-            Ok(o) => o.0,
-            Err(_) => continue,
-        };
-        let rt_residual_signed = candidate.apex_rt.0 as f64 - predicted_rt;
-        let half_width = ridge_half_width_interp(ridge_widths, library_rt_s);
-        let in_ridge = match half_width {
-            Some(hw) => rt_residual_signed.abs() <= hw,
-            None => true,
+        let rt_residual = match (cal_curve, *library_rt_opt) {
+            (Some(curve), Some(library_rt)) => {
+                let predicted = match curve.predict(LibraryRT(library_rt)) {
+                    Ok(rt) => rt.0,
+                    Err(CalibRtError::OutOfBounds(seconds)) => seconds,
+                    Err(_) => continue,
+                };
+                let residual = candidate.apex_rt.0 as f64 - predicted;
+                if ridge_half_width_interp(ridge_widths, library_rt)
+                    .is_some_and(|width| residual.abs() > width)
+                {
+                    n_off_ridge += 1;
+                    continue;
+                }
+                Some(residual as f32)
+            }
+            // A fitted ridge is only applicable to matched RT coordinates.
+            (Some(_), None) if !ridge_widths.is_empty() => continue,
+            _ => None,
         };
-        if !in_ridge {
-            n_off_ridge += 1;
-            continue;
+        if let Some(residual) = rt_residual {
+            rt_residuals_seconds.push(residual);
         }
 
-        // No clone: build collector from the flyweight (QueryGeom) + rt override.
+        // No clone: build collector from the flyweight (Target) + rt override.
         let mut agg: SpectralCollector<IonAnnot, MzMobilityStatsCollector> =
-            SpectralCollector::new(&item);
-        agg.reset_with_overrides(&item, Some(candidate.apex_rt.0), None);
-        pipeline.index.add_query(&mut agg, &query_tolerance);
+            SpectralCollector::new(&timsquery::ExtractionQuery::new(
+                &item,
+                timsquery::ResolvedRt::from_mapping(
+                    timsquery::RtSelection::Centered(candidate.apex_rt),
+                    &query_tolerance.rt,
+                    pipeline.index.ms1_cycle_mapping(),
+                )
+                .expect("calibrant apex inside acquisition"),
+            ));
+        pipeline
+            .index
+            .add_query(&mut agg, &query_tolerance.peak_tolerance());
 
         let expected_mob = item.mobility_ook0() as f64;
         let offsets = MzMobilityOffsets::new(&agg, expected_mob);
@@ -868,17 +835,18 @@ pub(super) fn calibrate_from_phase1<I: ScorerQueriable>(
             continue;
         };
 
-        mz_errors_ppm.push(mz_err_ppm);
+        if mz_err_ppm.is_finite() {
+            mz_errors_ppm.push(mz_err_ppm);
+        }
         // Mobility is NaN for a non-searchable-axis run (mzML/no-IM lib); don't
         // let it poison the MAD-based mobility tolerance (unused there anyway).
-        if mob_err_pct.is_finite() {
+        if pipeline.index.mobility_kind().is_scoreable() && mob_err_pct.is_finite() {
             mobility_errors_pct.push(mob_err_pct);
         }
-        rt_residuals_seconds.push(rt_residual_signed as f32);
     }
 
     info!(
-        "Ridge filter: kept {}/{} calibrants (dropped {} off-ridge)",
+        "m/z measurements: {}/{} candidates (dropped {} off-ridge)",
         mz_errors_ppm.len(),
         candidates.len(),
         n_off_ridge,
@@ -896,43 +864,226 @@ pub(super) fn calibrate_from_phase1<I: ScorerQueriable>(
     derivation.sigma.rt = config.rt_sigma_factor;
     derivation.floors.rt_minutes = config.min_rt_tolerance_minutes;
 
-    let mut windows = errors.derive_windows(&derivation);
-    if let Some((lo, hi)) =
-        clamp_mz_window_to_first_pass(&mut windows.mz_ppm, &pipeline.broad_tolerance)
-    {
-        warn!(
-            "derived m/z window exceeded the first-pass window ({lo:.1}, {hi:.1}) ppm; clamped. \
-             Residual MAD {:.1} ppm is contamination of the box-mean offset, not the instrument.",
-            errors.mz_ppm.mad
-        );
-    }
     info!(
-        "RT residuals: MAD={:.1}s, n={}",
-        errors.rt_seconds.mad, errors.rt_seconds.n
+        "Calibration measurements: m/z={}, mobility={}, RT={}; off-ridge={}",
+        errors.mz_ppm.n, errors.mobility_pct.n, errors.rt_seconds.n, n_off_ridge,
     );
-    info!(
-        "Calibration: RT tol={:.2} min, m/z tol=({:.1}, {:.1}) ppm, mob tol=({:.1}, {:.1}) %",
-        windows.rt_minutes,
-        windows.mz_ppm.0,
-        windows.mz_ppm.1,
-        windows.mobility_pct.0,
-        windows.mobility_pct.1,
-    );
-
-    Ok(CalibrationResult::new(
+    Ok(CalibrationResult::from_measurements(
         cal_state,
-        windows.rt_minutes,
-        windows.mz_ppm,
-        windows.mobility_pct,
-    )?
-    .with_error_stats(errors)
-    .with_derivation(derivation))
+        &pipeline.broad_tolerance,
+        errors,
+        derivation,
+    ))
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    struct TestIndex {
+        rt: timscentroid::rt_mapping::CycleToRTMapping<timscentroid::rt_mapping::MS1CycleIndex>,
+        queries: std::sync::Mutex<Vec<(f32, timsquery::PeakTolerance)>>,
+        mobility_kind: timscentroid::MobilityKind,
+    }
+
+    impl timsseek::traits::MappableRTCycles for TestIndex {
+        fn ms1_cycle_mapping(
+            &self,
+        ) -> &timscentroid::rt_mapping::CycleToRTMapping<timscentroid::rt_mapping::MS1CycleIndex>
+        {
+            &self.rt
+        }
+
+        fn mobility_kind(&self) -> &timscentroid::MobilityKind {
+            &self.mobility_kind
+        }
+    }
+    impl timsquery::QueriableData<timsquery::ChromatogramCollector<IonAnnot, f32>> for TestIndex {
+        fn add_query(
+            &self,
+            _: &mut timsquery::ChromatogramCollector<IonAnnot, f32>,
+            _: &timsquery::PeakTolerance,
+        ) {
+        }
+    }
+    impl timsquery::QueriableData<SpectralCollector<IonAnnot, f32>> for TestIndex {
+        fn add_query(
+            &self,
+            _: &mut SpectralCollector<IonAnnot, f32>,
+            _: &timsquery::PeakTolerance,
+        ) {
+        }
+    }
+    impl timsquery::QueriableData<SpectralCollector<IonAnnot, MzMobilityStatsCollector>> for TestIndex {
+        fn add_query(
+            &self,
+            agg: &mut SpectralCollector<IonAnnot, MzMobilityStatsCollector>,
+            tolerance: &timsquery::PeakTolerance,
+        ) {
+            self.queries
+                .lock()
+                .unwrap()
+                .push((agg.rt.center().unwrap().0, tolerance.clone()));
+            for ((_, mz), values) in agg.iter_mut_precursors() {
+                values.add(100.0, mz * (1.0 + 4e-6), 1.01);
+            }
+        }
+    }
+
+    #[test]
+    fn phase2_measures_at_observed_apex_without_library_rt_or_with_failed_rt_fit() {
+        use timsquery::models::tolerance::{
+            MobilityTolerance,
+            MzTolerance,
+        };
+        use timsquery::models::{
+            Row,
+            TargetCapabilities,
+            TargetColumnsBuilder,
+        };
+        for (library_rt, mobility_kind) in [
+            (None, timscentroid::MobilityKind::Ook0),
+            (Some(10.0), timscentroid::MobilityKind::Ook0),
+            (None, timscentroid::MobilityKind::Absent),
+            (
+                Some(10.0),
+                timscentroid::MobilityKind::Unsupported("FAIMS".into()),
+            ),
+        ] {
+            let expected_mobility_count = usize::from(mobility_kind.is_scoreable());
+            let mut builder =
+                TargetColumnsBuilder::with_capabilities(TargetCapabilities::default_diann());
+            let fragments = [(IonAnnot::try_from("y1").unwrap(), 300.0)];
+            builder.push_row(Row {
+                precursor_mz: 500.0,
+                charge: 2,
+                mobility: 1.0,
+                rt: library_rt.map(timsquery::RtCoordinate::seconds),
+                frags: &fragments,
+                ..Default::default()
+            });
+            let lib = ReferenceLibrary::try_from(timsquery::serde::TargetTable::Mzpaf {
+                geom: builder
+                    .seal(timsquery::models::capabilities::DecoyPolicy::Never)
+                    .unwrap(),
+                frag_intens: Some(vec![1.0]),
+            })
+            .unwrap();
+            let pipeline = Scorer {
+                index: TestIndex {
+                    rt: timscentroid::rt_mapping::CycleToRTMapping::new(vec![0, 30_000, 60_000]),
+                    queries: Default::default(),
+                    mobility_kind,
+                },
+                broad_tolerance: timsquery::Tolerance {
+                    ms: MzTolerance::Ppm((20.0, 25.0)),
+                    mobility: MobilityTolerance::Pct((6.0, 7.0)),
+                    ..Default::default()
+                },
+                fragmented_range: timsquery::utils::TupleRange::try_new(100.0, 1000.0).unwrap(),
+            };
+            let candidate = || CalibrantCandidate {
+                score: 20.0,
+                apex_rt: timsseek::rt_calibration::ObservedRTSeconds(30.0),
+                library_rt: LibraryRT(library_rt.unwrap_or(f32::NAN)),
+                speclib_index: lib.geometry().flats().next().unwrap(),
+            };
+            let config = CalibrationConfig::default();
+            let calibration =
+                calibrate_from_phase1(vec![candidate()], &lib, None, &pipeline, &config).unwrap();
+            assert!(!calibration.has_rt_calibration());
+            assert_eq!(calibration.errors().mz_ppm.n, 1);
+            assert_eq!(calibration.errors().mobility_pct.n, expected_mobility_count);
+            assert_eq!(calibration.errors().rt_seconds.n, 0);
+            assert!((calibration.errors().mz_ppm.mean - 4.0).abs() < 0.01);
+            if expected_mobility_count > 0 {
+                assert!((calibration.errors().mobility_pct.mean - 1.0).abs() < 0.01);
+            } else {
+                assert_eq!(
+                    calibration.mobility_tolerance(),
+                    &pipeline.broad_tolerance.mobility
+                );
+            }
+            assert_eq!(
+                calibration.unrestricted_rt_tolerance().rt,
+                RtTolerance::Unrestricted
+            );
+            let queries = pipeline.index.queries.lock().unwrap();
+            assert_eq!(queries.len(), 1);
+            assert_eq!(queries[0].0, 30.0);
+            assert_eq!(queries[0].1.ms, pipeline.broad_tolerance.ms);
+            drop(queries);
+            // Empty main-library lookup must not suppress auxiliary-library mass calibration.
+            let calibration = calibrate_from_phase1(
+                vec![candidate()],
+                &lib,
+                Some(&Default::default()),
+                &pipeline,
+                &config,
+            )
+            .unwrap();
+            assert_eq!(calibration.errors().mz_ppm.n, 1);
+            assert!(!calibration.has_rt_calibration());
+            // Prescore actually visits RT-free rows rather than returning early.
+            if library_rt.is_none() {
+                let (_, timings, _) = phase1_prescore(&lib, &pipeline, 10, &config, None, None);
+                assert_eq!(timings.n_passed_filter, 1);
+            }
+        }
+    }
+
+    #[test]
+    fn calibration_matches_fragments_without_subtracting_unrelated_rt_axes() {
+        use timsquery::models::{
+            Row,
+            TargetCapabilities,
+            TargetColumnsBuilder,
+        };
+        let mut builder =
+            TargetColumnsBuilder::with_capabilities(TargetCapabilities::default_diann());
+        let frags: Vec<_> = (1..=MIN_SHARED_FRAGMENTS)
+            .map(|i| {
+                (
+                    IonAnnot::try_from(format!("y{i}").as_str()).unwrap(),
+                    300.0 + i as f64,
+                )
+            })
+            .collect();
+        builder.push_row(Row {
+            precursor_mz: 500.0,
+            charge: 2,
+            frags: &frags,
+            rt: Some(timsquery::RtCoordinate::seconds(9000.0)),
+            ..Default::default()
+        });
+        let calibration = ReferenceLibrary::try_from(timsquery::serde::TargetTable::Mzpaf {
+            geom: builder
+                .seal(timsquery::models::capabilities::DecoyPolicy::Never)
+                .unwrap(),
+            frag_intens: Some(vec![1.0; frags.len()]),
+        })
+        .unwrap();
+        let fingerprint: Vec<_> = frags
+            .iter()
+            .map(|(_, mz)| (mz * 100.0).round() as i64)
+            .collect();
+        let mut lookup = PrecursorFragmentLookup::new();
+        lookup.insert(
+            (50000, 2),
+            vec![(0.0, fingerprint.clone()), (-20.0, fingerprint)],
+        );
+        let candidate = CalibrantCandidate {
+            score: 1.0,
+            apex_rt: timsseek::rt_calibration::ObservedRTSeconds(120.0),
+            library_rt: LibraryRT(9000.0),
+            speclib_index: calibration.geometry().flats().next().unwrap(),
+        };
+        assert_eq!(
+            library_rt_for_candidate(&candidate, &calibration, Some(&lookup)),
+            Some(-20.0)
+        );
+    }
+
     fn curve_summary(visited: usize, value: f32) -> CurveSummary {
         CurveSummary {
             visited,