thyra 3.7.4__tar.gz → 3.8.0__tar.gz

{thyra-3.7.4 → thyra-3.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: thyra
-Version: 3.7.4
+Version: 3.8.0
 Summary: A modern Python library for converting Mass Spectrometry Imaging (MSI) data into SpatialData/Zarr format - your portal to spatial omics
 Project-URL: Homepage, https://github.com/M4i-Imaging-Mass-Spectrometry/thyra
 Project-URL: Repository, https://github.com/M4i-Imaging-Mass-Spectrometry/thyra
@@ -47,7 +47,7 @@ Requires-Dist: spatialdata<0.9,>=0.8.0
 Requires-Dist: tifffile>=2022.8.12
 Requires-Dist: tqdm>=4.50.0
 Requires-Dist: xarray>=2024.10.0
-Requires-Dist: zarr<3.2,>=3.1.4
+Requires-Dist: zarr<3.2,>=3.1.6
 Description-Content-Type: text/markdown
 
 <p align="center">

{thyra-3.7.4 → thyra-3.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "thyra"
-version = "3.7.4"
+version = "3.8.0"
 description = "A modern Python library for converting Mass Spectrometry Imaging (MSI) data into SpatialData/Zarr format - your portal to spatial omics"
 authors = [{ name = "Theodoros Visvikis", email = "t.visvikis@maastrichtuniversity.nl" }]
 maintainers = [{ name = "Theodoros Visvikis", email = "t.visvikis@maastrichtuniversity.nl" }]
@@ -91,16 +91,28 @@ dependencies = [
     # bit ome_zarr 0.12.x with newer dask, and spatialdata 0.8 requires >= 0.16.
     "ome-zarr>=0.16.0, <0.19",        # tested 0.18.0
     "tqdm>=4.50.0",
-    # Floor is 3.1.4, and it is load-bearing. anndata >= 0.13 writes every zarr v3
-    # array with `shards="auto"`. zarr < 3.1.4 sized the auto chunk with
-    # `max_bytes=1024` where its own comment says "aim for a 1MiB chunk" (compare
-    # `_auto_partition` in 3.1.3 vs 3.1.4), so one shard -- one FILE -- came out at
-    # ~1 KB. Measured on test_data/pea.imzML: 393,310 files for a single table and
-    # 434 s of a 445 s conversion spent in the write, against 12 files and 2.7 s on
-    # 3.1.6. Nothing in Thyra changed; the anndata 0.13 bump alone did this.
-    # 3.1.4 is also where `array.target_shard_size_bytes` arrives, which is the
-    # knob _chunking.table_write_config sets to claim the budget from anndata.
-    "zarr>=3.1.4, <3.2",              # tested 3.1.6
+    # Floor is 3.1.6, and it is load-bearing. anndata >= 0.13 writes every zarr v3
+    # array with `shards="auto"`, and `_auto_partition` sized the auto INNER chunk
+    # with `max_bytes=1024` where the line right above it says "aim for a 1MiB
+    # chunk". zarr-python#3603 changed that 1024 to 1048576; it merged six days
+    # AFTER 3.1.5 shipped, so 3.1.4 and 3.1.5 both still carry the defect
+    # (`chunk_grids.py:267` in each) and 3.1.6 is the first release without it.
+    # Do not drop the floor to 3.1.4 on the grounds that 3.1.4 is where
+    # `array.target_shard_size_bytes` arrives -- the knob _chunking.table_write_config
+    # sets to claim the budget from anndata. That knob is necessary, not sufficient.
+    #
+    # Both halves of the damage, measured on X/data of test_data/pea.imzML (60.1M
+    # nnz, f8, 481 MB):
+    #   - Below 3.1.4 the knob does not exist, so a shard is 2 auto chunks -- ~1.8 KB,
+    #     and a shard is one FILE. 393,310 files for a single table, and 434 s of a
+    #     445 s conversion spent in the write, against 12 files and 2.7 s on 3.1.6.
+    #     Nothing in Thyra changed; the anndata 0.13 bump alone did this.
+    #   - On 3.1.4/3.1.5 the 128 MiB budget IS honoured, so the file count stays sane
+    #     (4), but the chunk inside those files is 920 B: ~145,900 separately
+    #     compressed chunks per shard against 142 on 3.1.6, plus the shard index that
+    #     implies. A 3.1.5 resolve buys that silently, and the shard-level assertion
+    #     cannot see it; _chunking.MIN_TABLE_CHUNK_BYTES is what catches it.
+    "zarr>=3.1.6, <3.2",              # tested 3.1.6
     "imagecodecs>=2024.1.1",  # For reading compressed TIFF optical images
     # Floor is 0.13.2, not 0.13.0. anndata 0.13.0 imports
     # `typing_extensions.sentinel` (needs typing-extensions >= 4.16) but declares

{thyra-3.7.4 → thyra-3.8.0}/thyra/__init__.py

@@ -36,7 +36,7 @@ warnings.filterwarnings(
     category=FutureWarning,
 )
 
-__version__ = "3.7.4"
+__version__ = "3.8.0"
 
 # Import key components - avoid wildcard imports
 try:

{thyra-3.7.4 → thyra-3.8.0}/thyra/converters/spatialdata/_chunking.py

@@ -53,13 +53,28 @@ INNER_TILE_EDGE = 512
 # began auto-sharding, so read amplification is unchanged.
 TABLE_SHARD_TARGET_BYTES = 128 * 1024 * 1024
 
-# zarr < 3.1.4 computed the auto chunk with ``max_bytes=1024`` where 1 MiB was
-# meant, so ``shards="auto"`` produced ~1 KB shards -- one file per KB of table.
-# It also predates ``array.target_shard_size_bytes``, making the budget above
-# unenforceable. pyproject pins the floor at 3.1.4 for exactly this reason;
-# this constant is what the regression test checks the floor still buys us.
+# zarr < 3.1.6 computed the auto chunk with ``max_bytes=1024`` where 1 MiB was
+# meant (zarr-python#3603, first released in 3.1.6 -- it landed after both 3.1.4
+# and 3.1.5). zarr < 3.1.4 additionally predates ``array.target_shard_size_bytes``,
+# making the budget above unenforceable, and there ``shards="auto"`` produced
+# ~1 KB SHARDS -- one file per KB of table. pyproject pins the floor at 3.1.6 for
+# both reasons.
+#
+# This constant guards the shard, i.e. the file, so it only ever catches that
+# second, pre-3.1.4 half: on 3.1.4/3.1.5 the budget above still lands large
+# shards and it is the chunk inside them that collapses. MIN_TABLE_CHUNK_BYTES
+# is the half that catches those two.
 MIN_TABLE_SHARD_BYTES = 64 * 1024
 
+# Minimum size for the INNER chunk of a table array -- the unit that sits inside
+# a shard and the unit a random read decompresses. This is the half of the defect
+# a large shard hides: on 3.1.4/3.1.5 the file count looks fine while each file
+# quietly holds ~146,000 separately compressed chunks instead of ~142, and pays
+# for all of them in the shard index. 64 KiB sits well above the ~800 B those
+# versions hand the regression-test fixture and well below the ~200 KB 3.1.6
+# hands it, so the two are never close to the threshold.
+MIN_TABLE_CHUNK_BYTES = 64 * 1024
+
 
 @contextmanager
 def table_write_config() -> Iterator[None]:

{thyra-3.7.4 → thyra-3.8.0}/thyra/metadata/extractors/imzml_extractor.py

@@ -16,6 +16,7 @@ from ...resampling.constants import (
     normalize_spectrum_type,
 )
 from ...utils.pyimzml_direct import read_spectrum_mzs_only
+from ..ontology.cache import ONTOLOGY
 from ..types import ComprehensiveMetadata, EssentialMetadata
 
 logger = logging.getLogger(__name__)
@@ -30,6 +31,119 @@ UM_PER_UNIT = {
     "UO:0000018": 0.001,  # nanometer
 }
 
+# Analyzer-component terms, in preference order. The first one found under a
+# <componentList><analyzer> is surfaced as ``instrument_info["analyzer"]``, so
+# on a hybrid that declares several analyzers the highest-resolution stage --
+# the one that defines the mass axis of the stored spectra -- wins.
+_ANALYZER_ACCESSIONS = (
+    "MS:1000079",  # fourier transform ion cyclotron resonance mass spectrometer
+    "MS:1000484",  # orbitrap
+    "MS:1000084",  # time-of-flight
+    "MS:1000264",  # ion trap
+)
+
+# The subset of analyzers whose axis-spacing law the resampling detector chain
+# distinguishes. Values are the exact ``instrument_type`` strings
+# ``FTICRDetector`` and ``OrbitrapDetector`` match on -- change both together.
+# TOF is deliberately absent: an imzML declaring a TOF analyzer says nothing
+# about which vendor grid the spectra arrived on, and stamping a TOF type here
+# could arm detectors whose source-grid claims only hold for their own reader.
+_ANALYZER_FAMILIES = {
+    "MS:1000079": "FT-ICR",
+    "MS:1000484": "Orbitrap",
+}
+
+# Instrument-model terms that imply an analyzer family when no analyzer
+# component is declared. The local ontology tables are flat -- no is-a links --
+# so family membership is enumerated rather than walked.
+_FTICR_MODEL_ACCESSIONS = frozenset(
+    {
+        "MS:1000141",  # apex IV
+        "MS:1000142",  # apex Q
+        "MS:1000448",  # LTQ FT
+        "MS:1000557",  # LTQ FT Ultra
+        "MS:1000695",  # apex ultra
+        "MS:1001548",  # Bruker Daltonics solarix series
+        "MS:1001549",  # solariX
+        "MS:1001556",  # Bruker Daltonics apex series
+    }
+)
+
+_ORBITRAP_MODEL_ACCESSIONS = frozenset(
+    {
+        "MS:1000449",  # LTQ Orbitrap
+        "MS:1000555",  # LTQ Orbitrap Discovery
+        "MS:1000556",  # LTQ Orbitrap XL
+        "MS:1000639",  # LTQ Orbitrap XL ETD
+        "MS:1000643",  # MALDI LTQ Orbitrap
+        "MS:1000649",  # Exactive
+        "MS:1001742",  # LTQ Orbitrap Velos
+        "MS:1001910",  # LTQ Orbitrap Elite
+        "MS:1001911",  # Q Exactive
+        "MS:1002416",  # Orbitrap Fusion
+        "MS:1002417",  # Orbitrap Fusion ETD
+        "MS:1002523",  # Q Exactive HF
+        "MS:1002526",  # Exactive Plus
+        "MS:1002634",  # Q Exactive Plus
+        "MS:1002732",  # Orbitrap Fusion Lumos
+        "MS:1002835",  # LTQ Orbitrap Classic
+        "MS:1002877",  # Q Exactive HF-X
+        "MS:1003028",  # Orbitrap Exploris 480
+        "MS:1003029",  # Orbitrap Eclipse
+        "MS:1003094",  # Orbitrap Exploris 240
+        "MS:1003095",  # Orbitrap Exploris 120
+        "MS:1003096",  # LTQ Orbitrap Velos Pro
+        "MS:1003112",  # Orbitrap ID-X
+    }
+)
+
+# timsTOF models carry no family here on purpose: the timsTOF decision is
+# ``DataCharacteristics.is_timstof``, a substring match on the surfaced model
+# name -- the same single path the native .d route goes through. Stamping an
+# ``instrument_type`` as well would create a second, divergable path.
+_TIMSTOF_MODEL_ACCESSIONS = frozenset(
+    {
+        "MS:1003005",  # timsTOF Pro
+        "MS:1003123",  # Bruker Daltonics timsTOF series
+        "MS:1003124",  # timsTOF fleX
+        "MS:1003229",  # timsTOF
+        "MS:1003230",  # timsTOF Pro 2
+        "MS:1003231",  # timsTOF SCP
+    }
+)
+
+_MODEL_FAMILIES: Dict[str, Optional[str]] = {
+    **{acc: "FT-ICR" for acc in _FTICR_MODEL_ACCESSIONS},
+    **{acc: "Orbitrap" for acc in _ORBITRAP_MODEL_ACCESSIONS},
+    **{acc: None for acc in _TIMSTOF_MODEL_ACCESSIONS},
+}
+
+# Last-resort family match, applied to model text the file provides itself:
+# the free-text value of MS:1000031 "instrument model", or the name of a model
+# term newer than the shipped ontology tables. Tokens are vendor product names
+# unambiguous enough that a substring hit identifies the family ("scimaX MRMS",
+# "Orbitrap Astral", "solariX XR" all resolve correctly); generic words like
+# "ft" or "tof" are deliberately not in the list.
+_FAMILY_NAME_TOKENS = (
+    ("solarix", "FT-ICR"),
+    ("scimax", "FT-ICR"),
+    ("mrms", "FT-ICR"),
+    ("ft-icr", "FT-ICR"),
+    ("fticr", "FT-ICR"),
+    ("orbitrap", "Orbitrap"),
+    ("exactive", "Orbitrap"),
+    ("exploris", "Orbitrap"),
+)
+
+
+def _family_from_model_text(text: str) -> Optional[str]:
+    """Resolve an analyzer family from free-form instrument-model text."""
+    lowered = text.lower()
+    for token, family in _FAMILY_NAME_TOKENS:
+        if token in lowered:
+            return family
+    return None
+
 
 class ImzMLMetadataExtractor(MetadataExtractor):
     """ImzML-specific metadata extractor with optimized two-phase extraction."""
@@ -658,21 +772,152 @@ class ImzMLMetadataExtractor(MetadataExtractor):
         return params
 
     def _extract_instrument_info(self) -> Dict[str, Any]:
-        """Extract instrument information."""
-        instrument = {}
+        """Extract instrument information from the instrumentConfiguration blocks.
+
+        This used to read ``imzmldict`` for "instrument model" and friends, but
+        pyimzml's ``__readimzmlmeta`` only ever collects pixel-geometry and
+        laser parameters -- none of those keys can exist, so every store Thyra
+        wrote carried an empty ``instrument_information`` for imzML sources,
+        and neither ``FTICRDetector`` nor ``OrbitrapDetector`` could ever fire
+        on an imzML. The declarations survive on ``parser.metadata``, so they
+        are read from there:
+
+        - ``instrument_model`` / ``instrument_serial_number`` -- from the
+          instrumentConfiguration's own cvParams, referenceableParamGroup
+          inheritance included (Bruker and SCiLS exports put the model term in
+          a ``CommonInstrumentParams`` group).
+        - ``analyzer`` -- the CV name of the first recognised
+          ``<componentList><analyzer>`` term, which is what
+          ``normalize_analyzer`` in the metadata schema accepts.
+        - ``instrument_type`` -- the exact string the resampling detector
+          chain matches on (``"FT-ICR"`` / ``"Orbitrap"``), when the analyzer
+          or the model resolves to a family the chain distinguishes.  Absent
+          otherwise: an unstated analyzer stays unstated.
+        """
+        info: Dict[str, Any] = {}
+        configs = self._instrument_configurations()
+        if not configs:
+            return info
 
-        if hasattr(self.parser, "imzmldict") and self.parser.imzmldict:
-            instrument_keys = [
-                "instrument model",
-                "instrument serial number",
-                "software",
-                "software version",
-            ]
-            for key in instrument_keys:
-                if key in self.parser.imzmldict:
-                    instrument[key.replace(" ", "_")] = self.parser.imzmldict[key]
+        model = self._instrument_model(configs)
+        if model:
+            info["instrument_model"] = model
 
-        return instrument
+        serial = self._config_param(configs, "MS:1000529")
+        if isinstance(serial, str) and serial.strip():
+            info["instrument_serial_number"] = serial.strip()
+
+        analyzer_accession = self._analyzer_accession(configs)
+        if analyzer_accession is not None:
+            info["analyzer"] = ONTOLOGY.terms[analyzer_accession][0]
+
+        family = self._analyzer_family(configs, analyzer_accession, model)
+        if family is not None:
+            info["instrument_type"] = family
+
+        return info
+
+    def _instrument_configurations(self) -> List[Any]:
+        """The parsed instrumentConfiguration ParamGroups, in document order."""
+        metadata = getattr(self.parser, "metadata", None)
+        configs = getattr(metadata, "instrument_configurations", None)
+        if not isinstance(configs, dict):
+            return []
+        return list(configs.values())
+
+    @staticmethod
+    def _config_param(configs: List[Any], accession: str) -> Any:
+        """The first value any configuration declares for ``accession``."""
+        for config in configs:
+            params = getattr(config, "param_by_accession", None)
+            if isinstance(params, dict) and accession in params:
+                return params[accession]
+        return None
+
+    def _instrument_model(self, configs: List[Any]) -> Optional[str]:
+        """The declared instrument model, from the shape the exporter chose.
+
+        Vendors write the model two ways: generic ``MS:1000031 instrument
+        model`` carrying the name as free text, or the model's own child term
+        as a valueless flag (``MS:1001549 solariX``, ``MS:1003124 timsTOF
+        fleX``).  The explicit value wins; a known model accession resolves
+        through the shipped ontology table; and a term newer than the table is
+        still usable when its *name* identifies a family.
+        """
+        value = self._config_param(configs, "MS:1000031")
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+
+        for config in configs:
+            params = getattr(config, "param_by_accession", None)
+            if not isinstance(params, dict):
+                continue
+            for accession in params:
+                if accession in _MODEL_FAMILIES:
+                    return ONTOLOGY.terms[accession][0]
+
+        for config in configs:
+            params = getattr(config, "param_by_name", None)
+            if not isinstance(params, dict):
+                continue
+            for name, value in params.items():
+                if (
+                    isinstance(name, str)
+                    and value is True
+                    and _family_from_model_text(name) is not None
+                ):
+                    return name
+
+        return None
+
+    @staticmethod
+    def _analyzer_accession(configs: List[Any]) -> Optional[str]:
+        """The highest-priority analyzer term declared on any componentList."""
+        declared: set = set()
+        for config in configs:
+            for component in getattr(config, "components", None) or []:
+                if getattr(component, "type", None) != "analyzer":
+                    continue
+                params = getattr(component, "param_by_accession", None)
+                if isinstance(params, dict):
+                    declared.update(params)
+
+        for accession in _ANALYZER_ACCESSIONS:
+            if accession in declared:
+                return accession
+        return None
+
+    def _analyzer_family(
+        self,
+        configs: List[Any],
+        analyzer_accession: Optional[str],
+        model: Optional[str],
+    ) -> Optional[str]:
+        """Resolve the axis family, preferring the analyzer declaration.
+
+        The analyzer cvParam states the physics outright, so it outranks the
+        model term, which outranks a substring match on free-form model text.
+        A file that declares none of the three resolves to ``None``.
+        """
+        if analyzer_accession in _ANALYZER_FAMILIES:
+            return _ANALYZER_FAMILIES[analyzer_accession]
+        if analyzer_accession is not None:
+            # A recognised analyzer outside the family table (TOF, ion trap)
+            # is a real declaration; do not second-guess it from the model.
+            return None
+
+        for config in configs:
+            params = getattr(config, "param_by_accession", None)
+            if not isinstance(params, dict):
+                continue
+            for accession in params:
+                family = _MODEL_FAMILIES.get(accession)
+                if family is not None:
+                    return family
+
+        if model is not None:
+            return _family_from_model_text(model)
+        return None
 
     def _extract_raw_metadata(self) -> Dict[str, Any]:
         """Extract raw metadata from imzmldict and spectrum cvParams."""

{thyra-3.7.4 → thyra-3.8.0}/thyra/metadata/extractors/waters_extractor.py

@@ -235,8 +235,16 @@ class WatersMetadataExtractor(MetadataExtractor):
         )
 
     def _extract_waters_specific(self) -> Dict[str, Any]:
-        """Extract Waters format-specific metadata."""
+        """Extract Waters format-specific metadata.
+
+        ``format`` is the key ``DataCharacteristics.from_metadata`` reads for
+        its format flags (``is_waters_raw`` prefix-matches on "Waters ").
+        ``data_format`` predates it and only ever fed the stored
+        format-specific block, so both are kept: renaming it would change
+        stored metadata for no downstream gain.
+        """
         return {
+            "format": "Waters MassLynx raw",
             "data_format": "waters_raw",
             "data_path": str(self._data_path),
             "is_imaging": True,
@@ -280,9 +288,15 @@ class WatersMetadataExtractor(MetadataExtractor):
         return params
 
     def _extract_instrument_info(self) -> Dict[str, Any]:
-        """Extract instrument information."""
+        """Extract instrument information.
+
+        The key is ``manufacturer`` because that is what
+        ``DataCharacteristics.from_metadata`` reads; this used to say
+        ``vendor``, which nothing downstream consumed, so the fact that a
+        file was Waters never reached the resampling detector chain.
+        """
         return {
-            "vendor": "Waters",
+            "manufacturer": "Waters",
             "format": "MassLynx .raw",
         }
 

{thyra-3.7.4 → thyra-3.8.0}/thyra/resampling/data_characteristics.py

@@ -34,6 +34,7 @@ class DataCharacteristics:
     is_rapiflex_format: bool = False
     is_timstof: bool = False
     is_phi_tofsims: bool = False
+    is_waters_raw: bool = False
 
     @property
     def needs_resampling(self) -> bool:
@@ -123,7 +124,17 @@ class DataCharacteristics:
             instrument_info.get("instrument_type") if instrument_info else None
         )
         manufacturer = instrument_info.get("manufacturer") if instrument_info else None
+        # Bruker .d surfaces the name in GlobalMetadata, which stays
+        # authoritative; an imzML surfaces the declared model term through
+        # instrument_info instead. Folding the two here keeps ``is_timstof``
+        # below the single deciding path for both routes -- a timsTOF fleX
+        # exported to imzML used to lose its identity entirely because only
+        # GlobalMetadata was consulted.
         instrument_name = global_meta.get("InstrumentName") if global_meta else None
+        if not instrument_name and instrument_info:
+            instrument_name = instrument_info.get(
+                "instrument_model"
+            ) or instrument_info.get("instrument_name")
 
         # Format detection
         is_rapiflex = (
@@ -144,6 +155,10 @@ class DataCharacteristics:
         source_format = format_specific.get("format") if format_specific else None
         is_phi_tofsims = bool(source_format and source_format.startswith("PHI "))
 
+        # WatersMetadataExtractor stamps "Waters MassLynx raw"; same prefix
+        # convention as the PHI flag above.
+        is_waters_raw = bool(source_format and source_format.startswith("Waters "))
+
         return cls(
             spectrum_type=spectrum_type,
             total_peaks=total_peaks,
@@ -154,4 +169,5 @@ class DataCharacteristics:
             is_rapiflex_format=is_rapiflex,
             is_timstof=is_timstof,
             is_phi_tofsims=is_phi_tofsims,
+            is_waters_raw=is_waters_raw,
         )

{thyra-3.7.4 → thyra-3.8.0}/thyra/resampling/instrument_detectors.py

@@ -298,6 +298,48 @@ class PhiToFSIMSDetector(InstrumentDetector):
         return AxisType.LINEAR_TOF
 
 
+class WatersDetector(InstrumentDetector):
+    """Detector for Waters MassLynx .raw imaging data (SELECT SERIES MRT et al.).
+
+    Without this detector a Waters acquisition's fate hinged on its declared
+    spectrum representation: centroid files happened to land on
+    :class:`CentroidImzMLDetector` -- the right answer, reached by accident on
+    a detector whose name says imzML -- while profile files fell through to
+    :class:`DefaultDetector`. That reported ``CONSTANT``, which downstream
+    pairs with the 0.1 Da default bin width: R = 5,000 at m/z 500, on an
+    instrument built for 100,000+.
+    """
+
+    @property
+    def name(self) -> str:
+        """Return detector name."""
+        return "Waters MassLynx"
+
+    def matches(self, characteristics: DataCharacteristics) -> bool:
+        """Check whether the Waters extractor stamped the MassLynx raw format."""
+        return characteristics.is_waters_raw
+
+    def get_resampling_method(self) -> ResamplingMethod:
+        """Return nearest-neighbour, which bins counts and cannot invent them."""
+        return ResamplingMethod.NEAREST_NEIGHBOR
+
+    def get_axis_type(self) -> AxisType:
+        """Return reflector TOF: bin width proportional to m/z.
+
+        SCiLS Lab 2026b calls the same law Orthogonal TOF (formerly Reflector
+        TOF): bin size proportional to m/z, i.e. constant relative resolution
+        (2026b User Guide, p.75). That is the law for an orthogonal-TOF
+        instrument like the SELECT SERIES MRT.
+        """
+        return AxisType.REFLECTOR_TOF
+
+    # ``source_grid_law`` stays at the inherited ``None`` on purpose: MassLynx
+    # lays out the stored m/z grid, not Thyra, and no law has been measured
+    # for it. Declaring one untested would open ``_gate_tic_preserving`` --
+    # the gate that keeps auto-selection off the interpolating path -- on
+    # data whose grid Thyra has not actually identified.
+
+
 class DefaultDetector(InstrumentDetector):
     """Fallback detector for unknown instruments.
 
@@ -351,6 +393,7 @@ class InstrumentDetectorChain:
             FTICRDetector(),
             OrbitrapDetector(),
             PhiToFSIMSDetector(),
+            WatersDetector(),
             # Generic spectrum type detector
             CentroidImzMLDetector(),
             # Fallback last